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 )