def generateDefaults( self ):
self._identity = "object_identity"
object_identity = rdb.Table( self._identity,
self.engine,
rdb.Column( "uid", rdb.String(50), primary_key=True ),
rdb.Column( "id", rdb.String(60) ),
rdb.Column( "table_name", rdb.String(50) )
)
class ObjectIdentity( object ): pass
rdb.assign_mapper( ObjectIdentity, object_identity )
self._tables[ self._identity ] = object_identity
self._peer_factories[ self._identity ] = ObjectIdentity
def process_relationships(klass, was_deferred=False):
defer = False
for propname, reldesc in klass.relations.items():
if not reldesc.classname in ActiveMapperMeta.classes:
if not was_deferred: __deferred_classes__.append(klass)
defer = True
if not defer:
relations = {}
for propname, reldesc in klass.relations.items():
relclass = ActiveMapperMeta.classes[reldesc.classname]
relations[propname] = relation(relclass,
backref=reldesc.backref,
private=reldesc.private,
lazy=reldesc.lazy,
uselist=reldesc.uselist)
assign_mapper(klass, klass.table, properties=relations)
if was_deferred: __deferred_classes__.remove(klass)
if not was_deferred:
for deferred_class in __deferred_classes__:
process_relationships(deferred_class, was_deferred=True)
def __init__(cls, clsname, bases, dict):
table_name = clsname.lower()
columns = []
relations = {}
if 'mapping' in dict:
members = inspect.getmembers(dict.get('mapping'))
for name, value in members:
if name == '__table__':
table_name = value
continue
if name.startswith('__'): continue
if isinstance(value, column):
if value.foreign_key:
col = Column(value.colname or name,
value.coltype,
value.foreign_key,
primary_key=value.primary_key)
else:
col = Column(value.colname or name,
value.coltype,
primary_key=value.primary_key)
columns.append(col)
continue
if isinstance(value, relationship):
relations[name] = value
cls.table = Table(table_name, engine, *columns)
assign_mapper(cls, cls.table)
cls.relations = relations
ActiveMapperMeta.classes[clsname] = cls
process_relationships(cls)
super(ActiveMapperMeta, cls).__init__(clsname, bases, dict)
def _loadInstance( self, instance ):
relation_tables = []
primary_columns = [ rdb.Column( "uid", rdb.String(50), primary_key=True ) ]
portal_type = instance.portal_type
table_name = self.ident_translate( portal_type )
field_translator = self.translator_factory( self, table_name )
print "Processing Type", portal_type
d = {}
for field in instance.Schema().fields():
# filter badness from fields with same speling but different captilization.
field_name = self.ident_translate( field.getName() )
if field_name in d:
continue
result = field_translator.visit( field )
if result is None:
continue
elif isinstance( result, rdb.Column):
primary_columns.append( result )
elif isinstance( result, rdb.Table ):
relation_tables.append( result )
else:
print "Unexpected", result
raise RuntimeError
d[field_name] = None
# define type primary table
type_table = rdb.Table( table_name,
self.engine,
*primary_columns )
# setup a peer factory
klass_name = "%s_serializer"%portal_type.lower().replace(' ', '_')
type_klass = type( klass_name, (object,), {} )
self._peer_factories[ portal_type ] = type_klass
self._tables[ portal_type ] = type_table
# setup the reference relations
identity = self._peer_factories[ self._identity ]
properties = {}
for relation_table in relation_tables:
print "reference name", relation_table.reference_name
for relation_table in relation_tables:
properties[ relation_table.reference_name ] = rdb.relation( identity.mapper, relation_table, lazy = False)
self._tables[ relation_table.name ] = relation_table
kwargs = {'properties':properties}
# associate peer to mapper
rdb.assign_mapper( type_klass, type_table, **kwargs )
