Re: [Python-es]RE: Representación de asociaciones en bases de datos

[Ernesto Revilla]

Hola,

----- Original Message -----
From: "Hernan Martinez Foffani" <hernan en orgmf.com.ar>
To: <python-es en aditel.org>
Sent: Friday, August 23, 2002 11:42 AM
Subject: [Python-es]RE: Representación de asociaciones en bases de datos


> > > en cuanto a mantenimiento... lo que sí te puedo asegurar es que si
> > > cada atributo del modelo de objetos es una tabla, el administrador
> > > no lo va a tener facil ;-)
> > Cada clase va a ser una tabla, no cada atributo.
>
> ah... ok.  esto cambia las cosas, no habia entendido bien la idea.
> por lo que veo vas a seguir el esquema tradicional de Objetct/Relational.
> quizás este paper te puede ser util:
>
http://www.objectarchitects.de/ObjectArchitects/papers/Published/ZippedPaper
> s/mappings04.pdf
> tiene varias referencias a otro papers que tambien te pueden servir.
Gracias, le echaré un vistazo. Trabajo sobre las ideas expresadas en
http://www.ambysoft.com/persistenceLayer.html
y algunas cunatas implementaciones en Java (básicamente
http://www.castor.org y
http://player.sf.net )

> me refería a que una vez congelado no permitir luego la modificacion
> *dinamica* de la estructura de clases. algo como:
>
> >>> C.__bases__ = (D,)
> Traceback (most recent call last):
>   File "<pyshell#10>", line 1, in ?
>     C.__bases__ = (D,)
> TypeError: __bases__ is frozen.

Esto ¿cómo se hace? ¿Cómo se puede congelar un tipo?

Temas slots:
He leído sobre los nuevos inventos en Python 2.2 .
De momento sólo uso las properties, es decir, a partir de un archivo de
definición de modelo (donde se indican sólo las clases con sus atributos y
tipos) se genera un archivo python que crea cada uno de los atributos. Las
propiedades me permiten comprobar quién accede cuando y al establecer un
valor, si tiene el tipo correcto. (Hay más cosas.)

Las clases generadas siempre se machacan al cambiar el modelo y
regenerarlos, pero el usuario escribe su propia clase heredando de la
generada. Ejemplo:

modelo.txt:
(Persona, class,
    {attributes: [
        (nombre,            string                                      ),
        (apellidos,         string          ),
        (fechaCreacion,   timestamp,    {defaultvalue: 'timestamp()'} ),
   }
)

(Cliente, class,
    {extends: [Persona],
     attributes: [
         (vendedor, Persona[1])
     ]
    }
)

Para cada clase se genera una clase Gen<clase>, es decir, GenPersona y
GenCliente.
un ejemplo del código generado:
GenPersona.py:
class GenPersona(PersistentObject):
    _class=classmap['Persona']
    # para cada propiedad....
    def get_apellidos(self):    return
PersistentObject.getProperty(self,'apellidos')
    def set_apellidos(self,value):
PersistentObject.setProperty(self,'apellidos',value)
    apellidos=property(get_apellidos,set_apellidos)

pero el código generado le puede dar igual al programador que tiene que
hacer lo siguiente (aunque se crea una plantilla por defecto, si no existe):

Persona.py:
from GenPersona import GenPersona
class Persona(GenPersona):
    # aquí van todos los métodos del programador
   def saludar(self):
        print "Hola. Me llamamo", self.nombre, self.apellidos

    # Para cambiar la manera de leer o asignar valores, es simple:
    def set_apellidos(self,nuevosApellidos):
        print "me cambio de apellidos, los nuevos son:", nuevosApellidos
        GenPersona.set_apellidos(self,nuevosApellidos)

estas ideas salen de webware/MiddleKit:
http://webware.sourceforge.net/Webware-0.7/MiddleKit/Docs/index.html

Es posible que la generación del archivo GenPersona desaparezca del todo,
quitar así una etapa más, la generación se haría mediante metaclases durante
la carga del modelo.

Cuando tenga algo más sólido ya os avisaré porque me gustaría que lo
probarais, pero todavía falta uno o dos meses.

Erny