def gen_for_table(self,tbl):
"""Generates sql files for creating history tables and stored procedures.
Calls functions for generating stored functions which differ for some cases. (embed tables, refuid columns)
Stored functions means function for add object, set attribute, get attribute, get object data, get list of instances and functions for diffing of versions.
For templated tables are generated stored functions to get resolved data or resolved data with its origin.
"""
# select col info
columns = self.plpy.execute(self.column_str % tbl)
att_types = self.plpy.execute(self.att_type_str % tbl)
self.atts[tbl] = dict(att_types)
self.refs[tbl] = list()
# create table obj
table = Table(tbl)
# add columns
for col in columns[:]:
table.add_column(col[0],col[1])
# add pk constraints
constraints = self.plpy.execute(self.pk_str % tbl)
for col in constraints[:]:
table.add_pk(col[0],col[1])
record = self.plpy.execute(self.refers_to_set_info_str % {'tbl': tbl})
table.refers_to_set = list()
if len(record) > 0:
for row in record:
table.refers_to_set.append(row[0])
self.refers_to_set[tbl] = table.refers_to_set
# add fk constraints
fkconstraints = self.plpy.execute(self.fk_str % tbl)
for col in fkconstraints[:]:
table.add_fk(col[0],col[1],col[2],col[3])
relName = col[0]
while relName in self.relFromTbl:
#check if relation if this name exists
#and add suffix to it
relName = relName + "_XXX"
self.relFromTbl[relName] = tbl
self.relFromCol[relName] = col[1]
self.relToTbl[relName] = col[2]
# if there is a reference, change int for identifier'
if col[1] not in table.refers_to_set:
self.atts[tbl][col[1]] = 'identifier'
prefix = col[0][0:7]
prefixForSet = col[0][0:5]
if prefix == "rembed_":
self.embed[tbl] = col[1]
self.embedNames[relName] = tbl
elif prefix == "rconta_":
self.composition[tbl] = col[1]
self.containsNames[relName] = tbl
elif prefix == "rcoble_":
self.containableNames[relName] = tbl
elif prefix == "rtempl_":
self.template[tbl] = col[2]
self.templateNames[relName] = tbl
elif prefix == "rrefer_" or prefixForSet == "rset_":
self.refs[tbl].append(col[1])
self.refNames[relName] = tbl
embed_into_rec = self.plpy.execute(self.embed_into_str % tbl)
table.embed_column = ""
for row in embed_into_rec:
table.embed_column = row[0]
refuid_rec = self.plpy.execute(self.refuid_columns_str % tbl)
table.refuid_columns = dict()
for row in refuid_rec:
table.refuid_columns[row[0]] = row[1]
record = self.plpy.execute(self.composition_str % tbl)
table.contains = list()
for row in record:
table.contains.append(row[0])
if tbl in self.templates:
templated_table = self.templates[tbl]
refuid_rec = self.plpy.execute(self.refuid_columns_str % templated_table)
for row in refuid_rec:
if row[0] not in table.refuid_columns:
table.refuid_columns[row[0]] = row[1]
table.validate();
# generate sql
self.table_sql.write(table.gen_hist())
self.fks = self.fks + (table.gen_fks())
#get dictionary of colname and reftable, which uid colname references
#cols_ref_uid = table.get_cols_reference_uid()
for col in columns[:]:
if (col[0] in table.refuid_columns):
reftable = table.refuid_columns[col[0]]
if col[0] in table.refers_to_set:
self.fn_sql.write(table.gen_set_refuid_set(col[0], reftable))
self.fn_sql.write(table.gen_refuid_set_insert(col[0], reftable))
self.fn_sql.write(table.gen_refuid_set_remove(col[0], reftable))
else:
#column that references uid has another set function(with finding corresponding uid)
self.fn_sql.write(table.gen_set_ref_uid(col[0], reftable))
elif (col[0] != 'name' and col[0] != 'uid'):
self.fn_sql.write(table.gen_set(col[0]))
#get uid of that references uid should not return uid but name of according instance
if table.embed_column <> "":
#adding full quolified name with _ delimiter
embed_column = table.embed_column
reftable = table.refuid_columns[embed_column]
self.fn_sql.write(table.gen_add_embed(embed_column,reftable))
#get uid from embed object, again name have to be full
self.fn_sql.write(table.gen_get_uid_embed(embed_column,reftable))
self.fn_sql.write(table.gen_get_name_embed(embed_column,reftable))
self.fn_sql.write(table.gen_names_embed(embed_column,reftable))
self.fn_sql.write(table.gen_set_name_embed(embed_column, reftable))
self.fn_sql.write(table.gen_get_name_changeset_embed(embed_column, reftable))
else:
self.fn_sql.write(table.gen_add())
self.fn_sql.write(table.gen_get_uid())
self.fn_sql.write(table.gen_get_name())
self.fn_sql.write(table.gen_names())
self.fn_sql.write(table.gen_set_name())
self.fn_sql.write(table.gen_get_name_changeset())
self.fn_sql.write(table.gen_del())
self.fn_sql.write(table.gen_undel())
self.fn_sql.write(table.gen_get_object_data())
self.fn_sql.write(table.gen_diff_data_type())
self.fn_sql.write(table.gen_diff_deleted())
self.fn_sql.write(table.gen_diff_created())
self.fn_sql.write(table.gen_diff_set_attribute())
self.fn_sql.write(table.gen_diff_init_function())
self.fn_sql.write(table.gen_diff_terminate_function())
self.fn_sql.write(table.gen_data_version())
self.fn_sql.write(table.gen_data_changes())
#different generated functions for templated and not templated tables
if tbl in self.templated_tables:
table.template_column = self.table_template_column[tbl]
if tbl in self.templates:
#tbl is template
table.templates = self.templates[tbl]
self.table_sql.write(table.gen_check_template_cycle())
else:
table.templates = ""
self.fn_sql.write(table.gen_resolved_data())
self.fn_sql.write(table.gen_resolved_data_diff())
self.fn_sql.write(table.gen_commit_templated())
#for templated tables that has columns that refers to set of identifiers, works like coalesce
if tbl in self.refers_to_set:
self.fn_sql.write(table.gen_refs_set_coal())
else:
self.fn_sql.write(table.gen_commit())
return
