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()
