1 post tagged “python django web”

Caso de Uso

Estava eu criando um sistema comercial  sobre Django. O Django possui uma ferramenta de mapeamento objeto-relacional (ORM)  onde vc define classes em Python (modelos no Djargão)  que serão mapeadas para tabelas no banco de dados. Os modelos (classes e instâncias) são usadas para manipular os dados em um banco relacional sem que seja necessário entrar no mérito do SQL. O fluxo de trabalho consiste em definir uma classe em Python (que herda de Model) e rodar um script de sincronização com o Banco de Dados (python manage.py syncdb), esta ação cria as respectivas tabelas no Banco.

Este sistema comercial tem o de sempre: produtos, categorias de produtos, clientes, fornecedores, etc.  O interessante são as "tabelas  de preço".

O Problema

Me deparei com duas  opções na hora de criar as tabelas de preço:

1. criar uma tabelona de preços que possua uma coluna para designar agrupamentos lógicos de preços.
2. criar  diversas tabelinhas de preço cada uma representando um agrupamento lógico.

A opção 1) não teria mistério quanto a implementação usando o ORM, mas é ineficiente pois a tabelona de preços seria potencialmente muito comprida. A opção 2) é mais interessante do ponto de vista do desempenho, mas exige que as tabelas sejam criadas sob demanda e dinamicamente. Aí surge o problema, pois estas tabelas de preços pequenas são criadas por uma stored procedure dentro do banco e não tem uma classe correspondente nos modelos do ORM. Ainda é possível manipular estas tabelas via SQL, porém o desejável seria usar o ferramental do ORM.

A Solução

Resolvi realizar o seguinte experimento: criar classes dinamicamente correspondendo as tabelas criadas dinamicamente, e assim restaurar o mapeamento objeto-relacional em tempo de execução. E rolou!

O trecho interessante do código é:

def create_tp_model(table_names, namespace):
    template = """
class %s(models.Model):
    preco = models.DecimalField("Preço", max_digits=10, decimal_places=3)
    produto = models.ForeignKey('Produto')
    class Meta:
        db_table = '%s'
"""
    for i in table_names:
        exec template%(i,i) in namespace       

# Create classes for pre-existing TP's
from django.db import connection, get_introspection_module
introspection_module = get_introspection_module()
cursor = connection.cursor()
table_names = [i for i in  introspection_module.get_table_list(cursor) \
                     if i.startswith('tp_')]    
create_tp_model(table_names, globals())

Deste ponto em diante eu posso obter uma referência para uma destas tabelas e usar o ORM normalmente.

tp_obj = getattr(sys.modules[module_holding_tp_objs], tp_name)
count = tp_obj.objects.count()

Algumas semanas depois de escrever o texto acima, eu encontrei uma documentação no site do DJango sobre esta abordagem: http://code.djangoproject.com/wiki/DynamicModels