def genericset_added(genericset, event): """A new GenericSet was added. Create the setobject type for it. """ plan_identifier = genericset.plan_identifier table_identifier = genericset.table_identifier # update the genericset index catalog = getUtility(ICatalog) catalog.updateIndex(catalog['plan_identifier']) if not table_exists(table_identifier): # Create SA table type table_type = Table( table_identifier, metadata, Column(genericset.table_key_field, String(10), primary_key=True, autoincrement=False), mysql_engine='InnoDB' ) # Register table type setobject_table_registry.register_type(genericset.klass, table_identifier, table_type) # Even if the user gives a specialized class and module we create a # generic klass first, because the specialized class definition will not exist until the # user defines it in the source code and restarts the server. setobject_type = create_basemodel_type(genericset.klass, table_identifier) # DDL table_type.create()
def init_xref_relation(self): # Get some vars beforehand: type1 = setobject_type_registry.lookup(self.source_module, self.source_classname) type2 = setobject_type_registry.lookup(self.target_module, self.target_classname) table1class = type1.get_table_class() table2class = type2.get_table_class() table1primarykey = type1.get_primary_key_attr_name() table2primarykey = type2.get_primary_key_attr_name() table1name = type1.get_table_name() table2name = type2.get_table_name() if self.relation.foreignkeycol.lower() == self.relation.foreignkeycol2.lower(): raise UserException("Please choose different column names for both of the two foreign key columns") # Create/obtain xref table fkcol1 = Column( self.relation.foreignkeycol, getattr(table1class.c, table1primarykey).type, ForeignKey(table1name + "." + table1primarykey) ) fkcol2 = Column( self.relation.foreignkeycol2, getattr(table2class.c, table2primarykey).type, ForeignKey(table2name + "." + table2primarykey) ) mytable = Table(self.relation.xref_table, metadata, useexisting=True) if not mytable.exists(): # Create table with new columns mytable = Table(self.relation.xref_table, metadata, fkcol1, fkcol2, Column('id', Integer(8), primary_key=True, autoincrement=True, default=0, nullable=False), useexisting=True, mysql_engine='InnoDB') # Register table type setobject_table_registry.register_type('p2.datashackle.core.models.model', self.relation.xref_table, self.relation.xref_table, mytable) # Create table mytable.create() # Create setobject type create_basemodel_type(self.relation.xref_table, self.relation.xref_table) else: # Alter table to have the new columns if they aren't there yet mytable = Table(self.relation.xref_table, metadata, autoload=True, useexisting=True) if hasattr(mytable.c, self.relation.foreignkeycol) != True: # add fkcol1 fkcol1.create(mytable) if hasattr(mytable.c, self.relation.foreignkeycol2) != True: # add fkcol2 fkcol2.create(mytable) # Remap xref table setobject setobject_type_registry.lookup_by_table(self.relation.xref_table).sa_map()
def register_remaining_tables(registered): res = select_tables() for rec in res: table_identifier = str(rec.table) class_name = str(rec.klass) if not class_name in registered: # There's no sa table type for this table yet. Create one and map to a generic ModelBase. registered.append(table_identifier) # Create SA table type table_type = Table(table_identifier, metadata, autoload=True) # Register table type setobject_table_registry.register_type(class_name, table_identifier, table_type) # Create a new setobject orm type setobject_type = create_basemodel_type(class_name, table_identifier, do_mapping=False) res.close()
def orm_mapping(event=None): # Register table type for grokked ModelBase classes registered = [] for setobject_type in setobject_type_registry.values(): class_name = setobject_type.__name__ table_name = setobject_type.get_table_name() # Create SA table type if setobject_table_registry.get_by_table(table_name) == None: table_type = Table(table_name, metadata, autoload=True) else: table_type = setobject_table_registry.lookup_by_table(table_name) # And register it. setobject_table_registry.register_type(class_name, table_name, table_type) registered.append(class_name) # register all the non-grokked, remaining tables (e.g. user tables) register_remaining_tables(registered) map_tables()