cubicweb: comparison hooks/syncschema.py

equal deleted inserted replaced

-:7b7d5a5d6365
+:202c4797e365
 # core entity and relation types which can't be removed
 CORE_TYPES = BASE_TYPES | SCHEMA_TYPES | META_RTYPES | set(
 ('CWUser', 'CWGroup','login', 'upassword', 'name', 'in_group'))
-def get_constraints(session, entity):
+def get_constraints(cnx, entity):
 constraints = []
-for cstreid in session.transaction_data.get(entity.eid, ()):
+for cstreid in cnx.transaction_data.get(entity.eid, ()):
-cstrent = session.entity_from_eid(cstreid)
+cstrent = cnx.entity_from_eid(cstreid)
 cstr = CONSTRAINTS[cstrent.type].deserialize(cstrent.value)
 cstr.eid = cstreid
 constraints.append(cstr)
 return constraints
 return cw.transaction_data['groupmap']
 except KeyError:
 cw.transaction_data['groupmap'] = gmap = ss.group_mapping(cw)
 return gmap
-def add_inline_relation_column(session, etype, rtype):
+def add_inline_relation_column(cnx, etype, rtype):
 """add necessary column and index for an inlined relation"""
 attrkey = '%s.%s' % (etype, rtype)
-createdattrs = session.transaction_data.setdefault('createdattrs', set())
+createdattrs = cnx.transaction_data.setdefault('createdattrs', set())
 if attrkey in createdattrs:
 return
 createdattrs.add(attrkey)
 table = SQL_PREFIX + etype
 column = SQL_PREFIX + rtype
 try:
-session.system_sql(str('ALTER TABLE %s ADD %s integer'
+cnx.system_sql(str('ALTER TABLE %s ADD %s integer'
 % (table, column)), rollback_on_failure=False)
-session.info('added column %s to table %s', column, table)
+cnx.info('added column %s to table %s', column, table)
 except Exception:
 # silent exception here, if this error has not been raised because the
 # column already exists, index creation will fail anyway
-session.exception('error while adding column %s to table %s',
+cnx.exception('error while adding column %s to table %s',
 table, column)
 # create index before alter table which may expectingly fail during test
 # (sqlite) while index creation should never fail (test for index existence
 # is done by the dbhelper)
-session.repo.system_source.create_index(session, table, column)
+cnx.repo.system_source.create_index(cnx, table, column)
-session.info('added index on %s(%s)', table, column)
+cnx.info('added index on %s(%s)', table, column)
-def insert_rdef_on_subclasses(session, eschema, rschema, rdefdef, props):
+def insert_rdef_on_subclasses(cnx, eschema, rschema, rdefdef, props):
 # XXX 'infered': True/False, not clear actually
 props.update({'constraints': rdefdef.constraints,
 'description': rdefdef.description,
 'cardinality': rdefdef.cardinality,
 'permissions': rdefdef.get_permissions(),
 'order': rdefdef.order,
 'infered': False, 'eid': None
 })
-cstrtypemap = ss.cstrtype_mapping(session)
+cstrtypemap = ss.cstrtype_mapping(cnx)
-groupmap = group_mapping(session)
+groupmap = group_mapping(cnx)
 object = rschema.schema.eschema(rdefdef.object)
 for specialization in eschema.specialized_by(False):
 if (specialization, rdefdef.object) in rschema.rdefs:
 continue
 sperdef = RelationDefinitionSchema(specialization, rschema,
 object, None, values=props)
-ss.execschemarql(session.execute, sperdef,
+ss.execschemarql(cnx.execute, sperdef,
 ss.rdef2rql(sperdef, cstrtypemap, groupmap))
-def check_valid_changes(session, entity, ro_attrs=('name', 'final')):
+def check_valid_changes(cnx, entity, ro_attrs=('name', 'final')):
 errors = {}
 # don't use getattr(entity, attr), we would get the modified value if any
 for attr in entity.cw_edited:
 if attr in ro_attrs:
 origval, newval = entity.cw_edited.oldnewvalue(attr)
 class DropTable(hook.Operation):
 """actually remove a database from the instance's schema"""
 table = None # make pylint happy
 def precommit_event(self):
-dropped = self.session.transaction_data.setdefault('droppedtables',
+dropped = self.cnx.transaction_data.setdefault('droppedtables',
 set())
 if self.table in dropped:
 return # already processed
 dropped.add(self.table)
-self.session.system_sql('DROP TABLE %s' % self.table)
+self.cnx.system_sql('DROP TABLE %s' % self.table)
 self.info('dropped table %s', self.table)
 # XXX revertprecommit_event
 class DropRelationTable(DropTable):
-def __init__(self, session, rtype):
+def __init__(self, cnx, rtype):
 super(DropRelationTable, self).__init__(
-session, table='%s_relation' % rtype)
+cnx, table='%s_relation' % rtype)
-session.transaction_data.setdefault('pendingrtypes', set()).add(rtype)
+cnx.transaction_data.setdefault('pendingrtypes', set()).add(rtype)
 class DropColumn(hook.Operation):
 """actually remove the attribut's column from entity table in the system
 database
 """
 table = column = None # make pylint happy
 def precommit_event(self):
-session, table, column = self.session, self.table, self.column
+cnx, table, column = self.cnx, self.table, self.column
-source = session.repo.system_source
+source = cnx.repo.system_source
 # drop index if any
-source.drop_index(session, table, column)
+source.drop_index(cnx, table, column)
 if source.dbhelper.alter_column_support:
-session.system_sql('ALTER TABLE %s DROP COLUMN %s'
+cnx.system_sql('ALTER TABLE %s DROP COLUMN %s'
 % (table, column), rollback_on_failure=False)
 self.info('dropped column %s from table %s', column, table)
 else:
 # not supported by sqlite for instance
 self.error('dropping column not supported by the backend, handle '
 special operation which should be called once and after all other schema
 operations. It will trigger internal structures rebuilding to consider
 schema changes.
 """
-def __init__(self, session):
+def __init__(self, cnx):
-hook.SingleLastOperation.__init__(self, session)
+hook.SingleLastOperation.__init__(self, cnx)
 def precommit_event(self):
-for eschema in self.session.repo.schema.entities():
+for eschema in self.cnx.repo.schema.entities():
 if not eschema.final:
 clear_cache(eschema, 'ordered_relations')
 def postcommit_event(self):
-rebuildinfered = self.session.get_shared_data('rebuild-infered', True)
+rebuildinfered = self.cnx.get_shared_data('rebuild-infered', True)
-repo = self.session.repo
+repo = self.cnx.repo
 # commit event should not raise error, while set_schema has chances to
 # do so because it triggers full vreg reloading
 try:
 if rebuildinfered:
 repo.schema.rebuild_infered_relations()
 # trigger vreg reload
 repo.set_schema(repo.schema)
 # CWUser class might have changed, update current session users
-cwuser_cls = self.session.vreg['etypes'].etype_class('CWUser')
+cwuser_cls = self.cnx.vreg['etypes'].etype_class('CWUser')
 for session in repo._sessions.itervalues():
 session.user.__class__ = cwuser_cls
 except Exception:
 self.critical('error while setting schema', exc_info=True)
 self.precommit_event()
 class MemSchemaOperation(hook.Operation):
 """base class for schema operations"""
-def __init__(self, session, **kwargs):
+def __init__(self, cnx, **kwargs):
-hook.Operation.__init__(self, session, **kwargs)
+hook.Operation.__init__(self, cnx, **kwargs)
 # every schema operation is triggering a schema update
-MemSchemaNotifyChanges(session)
+MemSchemaNotifyChanges(cnx)
 # operations for high-level source database alteration  ########################
 class CWETypeAddOp(MemSchemaOperation):
 * add <meta rtype> relation by creating the necessary CWRelation entity
 """
 entity = None # make pylint happy
 def precommit_event(self):
-session = self.session
+cnx = self.cnx
 entity = self.entity
-schema = session.vreg.schema
+schema = cnx.vreg.schema
 etype = ybo.EntityType(eid=entity.eid, name=entity.name,
 description=entity.description)
 eschema = schema.add_entity_type(etype)
 # create the necessary table
-tablesql = y2sql.eschema2sql(session.repo.system_source.dbhelper,
+tablesql = y2sql.eschema2sql(cnx.repo.system_source.dbhelper,
 eschema, prefix=SQL_PREFIX)
 for sql in tablesql.split(';'):
 if sql.strip():
-session.system_sql(sql)
+cnx.system_sql(sql)
 # add meta relations
-gmap = group_mapping(session)
+gmap = group_mapping(cnx)
-cmap = ss.cstrtype_mapping(session)
+cmap = ss.cstrtype_mapping(cnx)
 for rtype in (META_RTYPES - VIRTUAL_RTYPES):
 try:
 rschema = schema[rtype]
 except KeyError:
 self.critical('rtype %s was not handled at cwetype creation time', rtype)
 except KeyError:
 # this combo does not exist because this is not a universal META_RTYPE
 continue
 rdef.subject = _MockEntity(eid=entity.eid)
 mock = _MockEntity(eid=None)
-ss.execschemarql(session.execute, mock, ss.rdef2rql(rdef, cmap, gmap))
+ss.execschemarql(cnx.execute, mock, ss.rdef2rql(rdef, cmap, gmap))
 def revertprecommit_event(self):
 # revert changes on in memory schema
-self.session.vreg.schema.del_entity_type(self.entity.name)
+self.cnx.vreg.schema.del_entity_type(self.entity.name)
 # revert changes on database
-self.session.system_sql('DROP TABLE %s%s' % (SQL_PREFIX, self.entity.name))
+self.cnx.system_sql('DROP TABLE %s%s' % (SQL_PREFIX, self.entity.name))
 class CWETypeRenameOp(MemSchemaOperation):
 """this operation updates physical storage accordingly"""
 oldname = newname = None # make pylint happy
 def rename(self, oldname, newname):
-self.session.vreg.schema.rename_entity_type(oldname, newname)
+self.cnx.vreg.schema.rename_entity_type(oldname, newname)
 # we need sql to operate physical changes on the system database
-sqlexec = self.session.system_sql
+sqlexec = self.cnx.system_sql
-dbhelper = self.session.repo.system_source.dbhelper
+dbhelper = self.cnx.repo.system_source.dbhelper
 sql = dbhelper.sql_rename_table(SQL_PREFIX+oldname,
 SQL_PREFIX+newname)
 sqlexec(sql)
 self.info('renamed table %s to %s', oldname, newname)
 sqlexec('UPDATE entities SET type=%(newname)s WHERE type=%(oldname)s',
 {'newname': newname, 'oldname': oldname})
-for eid, (etype, extid, auri) in self.session.repo._type_source_cache.items():
+for eid, (etype, extid, auri) in self.cnx.repo._type_source_cache.items():
 if etype == oldname:
-self.session.repo._type_source_cache[eid] = (newname, extid, auri)
+self.cnx.repo._type_source_cache[eid] = (newname, extid, auri)
 # XXX transaction records
 def precommit_event(self):
 self.rename(self.oldname, self.newname)
 def precommit_event(self):
 rschema = self.rschema
 if rschema.final:
 return # watched changes to final relation type are unexpected
-session = self.session
+cnx = self.cnx
 if 'fulltext_container' in self.values:
-op = UpdateFTIndexOp.get_instance(session)
+op = UpdateFTIndexOp.get_instance(cnx)
 for subjtype, objtype in rschema.rdefs:
 op.add_data(subjtype)
 op.add_data(objtype)
 # update the in-memory schema first
 self.oldvalues = dict( (attr, getattr(rschema, attr)) for attr in self.values)
 inlined = self.values['inlined']
 # check in-lining is possible when inlined
 if inlined:
 self.entity.check_inlined_allowed()
 # inlined changed, make necessary physical changes!
-sqlexec = self.session.system_sql
+sqlexec = self.cnx.system_sql
 rtype = rschema.type
 eidcolumn = SQL_PREFIX + 'eid'
 if not inlined:
 # need to create the relation if it has not been already done by
 # another event of the same transaction
-if not rschema.type in session.transaction_data.get('createdtables', ()):
+if not rschema.type in cnx.transaction_data.get('createdtables', ()):
 tablesql = y2sql.rschema2sql(rschema)
 # create the necessary table
 for sql in tablesql.split(';'):
 if sql.strip():
 sqlexec(sql)
-session.transaction_data.setdefault('createdtables', []).append(
+cnx.transaction_data.setdefault('createdtables', []).append(
 rschema.type)
 # copy existant data
 column = SQL_PREFIX + rtype
 for etype in rschema.subjects():
 table = SQL_PREFIX + str(etype)
 sqlexec('INSERT INTO %s_relation SELECT %s, %s FROM %s WHERE NOT %s IS NULL'
 % (rtype, eidcolumn, column, table, column))
 # drop existant columns
-#if session.repo.system_source.dbhelper.alter_column_support:
+#if cnx.repo.system_source.dbhelper.alter_column_support:
 for etype in rschema.subjects():
-DropColumn(session, table=SQL_PREFIX + str(etype),
+DropColumn(cnx, table=SQL_PREFIX + str(etype),
 column=SQL_PREFIX + rtype)
 else:
 for etype in rschema.subjects():
 try:
-add_inline_relation_column(session, str(etype), rtype)
+add_inline_relation_column(cnx, str(etype), rtype)
 except Exception as ex:
 # the column probably already exists. this occurs when the
 # entity's type has just been added or if the column has not
 # been previously dropped (eg sqlite)
 self.error('error while altering table %s: %s', etype, ex)
 if args:
 column = SQL_PREFIX + rtype
 cursor.executemany('UPDATE %s SET %s=%%(val)s WHERE %s=%%(x)s'
 % (table, column, eidcolumn), args)
 # drop existant table
-DropRelationTable(session, rtype)
+DropRelationTable(cnx, rtype)
 def revertprecommit_event(self):
 # revert changes on in memory schema
 self.rschema.__dict__.update(self.oldvalues)
 # XXX revert changes on database
 entity = self.entity
 fromentity = entity.stype
 rdefdef = self.rdefdef = ybo.RelationDefinition(
 str(fromentity.name), entity.rtype.name, str(entity.otype.name),
 description=entity.description, cardinality=entity.cardinality,
-constraints=get_constraints(self.session, entity),
+constraints=get_constraints(self.cnx, entity),
 order=entity.ordernum, eid=entity.eid, **kwargs)
-self.session.vreg.schema.add_relation_def(rdefdef)
+self.cnx.vreg.schema.add_relation_def(rdefdef)
-self.session.execute('SET X ordernum Y+1 '
+self.cnx.execute('SET X ordernum Y+1 '
 'WHERE X from_entity SE, SE eid %(se)s, X ordernum Y, '
 'X ordernum >= %(order)s, NOT X eid %(x)s',
 {'x': entity.eid, 'se': fromentity.eid,
 'order': entity.ordernum or 0})
 return rdefdef
 def precommit_event(self):
-session = self.session
+cnx = self.cnx
 entity = self.entity
 # entity.defaultval is a Binary or None, but we need a correctly typed
 # value
 default = entity.defaultval
 if default is not None:
 'fulltextindexed': entity.fulltextindexed,
 'internationalizable': entity.internationalizable}
 # update the in-memory schema first
 rdefdef = self.init_rdef(**props)
 # then make necessary changes to the system source database
-syssource = session.repo.system_source
+syssource = cnx.repo.system_source
 attrtype = y2sql.type_from_constraints(
 syssource.dbhelper, rdefdef.object, rdefdef.constraints)
 # XXX should be moved somehow into lgdb: sqlite doesn't support to
 # add a new column with UNIQUE, it should be added after the ALTER TABLE
 # using ADD INDEX
 # added some str() wrapping query since some backend (eg psycopg) don't
 # allow unicode queries
 table = SQL_PREFIX + rdefdef.subject
 column = SQL_PREFIX + rdefdef.name
 try:
-session.system_sql(str('ALTER TABLE %s ADD %s %s'
+cnx.system_sql(str('ALTER TABLE %s ADD %s %s'
 % (table, column, attrtype)),
 rollback_on_failure=False)
 self.info('added column %s to table %s', table, column)
 except Exception as ex:
 # the column probably already exists. this occurs when
 # the entity's type has just been added or if the column
 # has not been previously dropped
 self.error('error while altering table %s: %s', table, ex)
 if extra_unique_index or entity.indexed:
 try:
-syssource.create_index(session, table, column,
+syssource.create_index(cnx, table, column,
 unique=extra_unique_index)
 except Exception as ex:
 self.error('error while creating index for %s.%s: %s',
 table, column, ex)
 # final relations are not infered, propagate
-schema = session.vreg.schema
+schema = cnx.vreg.schema
 try:
 eschema = schema.eschema(rdefdef.subject)
 except KeyError:
 return # entity type currently being added
 # propagate attribute to children classes
 rschema = schema.rschema(rdefdef.name)
 # if relation type has been inserted in the same transaction, its final
 # attribute is still set to False, so we've to ensure it's False
 rschema.final = True
-insert_rdef_on_subclasses(session, eschema, rschema, rdefdef, props)
+insert_rdef_on_subclasses(cnx, eschema, rschema, rdefdef, props)
 # update existing entities with the default value of newly added attribute
 if default is not None:
 default = convert_default_value(self.rdefdef, default)
-session.system_sql('UPDATE %s SET %s=%%(default)s' % (table, column),
+cnx.system_sql('UPDATE %s SET %s=%%(default)s' % (table, column),
 {'default': default})
 def revertprecommit_event(self):
 # revert changes on in memory schema
 if getattr(self, 'rdefdef', None) is None:
 return
-self.session.vreg.schema.del_relation_def(
+self.cnx.vreg.schema.del_relation_def(
 self.rdefdef.subject, self.rdefdef.name, self.rdefdef.object)
 # XXX revert changes on database
 class CWRelationAddOp(CWAttributeAddOp):
 constraints are handled by specific hooks
 """
 entity = None # make pylint happy
 def precommit_event(self):
-session = self.session
+cnx = self.cnx
 entity = self.entity
 # update the in-memory schema first
 rdefdef = self.init_rdef(composite=entity.composite)
 # then make necessary changes to the system source database
-schema = session.vreg.schema
+schema = cnx.vreg.schema
 rtype = rdefdef.name
 rschema = schema.rschema(rtype)
 # this have to be done before permissions setting
 if rschema.inlined:
 # need to add a column if the relation is inlined and if this is the
 # first occurence of "Subject relation Something" whatever Something
 if len(rschema.objects(rdefdef.subject)) == 1:
-add_inline_relation_column(session, rdefdef.subject, rtype)
+add_inline_relation_column(cnx, rdefdef.subject, rtype)
 eschema = schema[rdefdef.subject]
-insert_rdef_on_subclasses(session, eschema, rschema, rdefdef,
+insert_rdef_on_subclasses(cnx, eschema, rschema, rdefdef,
 {'composite': entity.composite})
 else:
 if rschema.symmetric:
 # for symmetric relations, rdefs will store relation definitions
 # in both ways (i.e. (subj -> obj) and (obj -> subj))
 relation_already_defined = len(rschema.rdefs) > 1
 # need to create the relation if no relation definition in the
 # schema and if it has not been added during other event of the same
 # transaction
 if not (relation_already_defined or
-rtype in session.transaction_data.get('createdtables', ())):
+rtype in cnx.transaction_data.get('createdtables', ())):
 rschema = schema.rschema(rtype)
 # create the necessary table
 for sql in y2sql.rschema2sql(rschema).split(';'):
 if sql.strip():
-session.system_sql(sql)
+cnx.system_sql(sql)
-session.transaction_data.setdefault('createdtables', []).append(
+cnx.transaction_data.setdefault('createdtables', []).append(
 rtype)
 # XXX revertprecommit_event
 class RDefDelOp(MemSchemaOperation):
 """an actual relation has been removed"""
 rdef = None # make pylint happy
 def precommit_event(self):
-session = self.session
+cnx = self.cnx
 rdef = self.rdef
 rschema = rdef.rtype
 # make necessary changes to the system source database first
 rdeftype = rschema.final and 'CWAttribute' or 'CWRelation'
-execute = session.execute
+execute = cnx.execute
 rset = execute('Any COUNT(X) WHERE X is %s, X relation_type R,'
 'R eid %%(x)s' % rdeftype, {'x': rschema.eid})
 lastrel = rset[0][0] == 0
 # we have to update physical schema systematically for final and inlined
 # relations, but only if it's the last instance for this relation type
 if (rschema.final or rschema.inlined):
 rset = execute('Any COUNT(X) WHERE X is %s, X relation_type R, '
 'R eid %%(r)s, X from_entity E, E eid %%(e)s'
 % rdeftype,
 {'r': rschema.eid, 'e': rdef.subject.eid})
-if rset[0][0] == 0 and not session.deleted_in_transaction(rdef.subject.eid):
+if rset[0][0] == 0 and not cnx.deleted_in_transaction(rdef.subject.eid):
-ptypes = session.transaction_data.setdefault('pendingrtypes', set())
+ptypes = cnx.transaction_data.setdefault('pendingrtypes', set())
 ptypes.add(rschema.type)
-DropColumn(session, table=SQL_PREFIX + str(rdef.subject),
+DropColumn(cnx, table=SQL_PREFIX + str(rdef.subject),
 column=SQL_PREFIX + str(rschema))
 elif lastrel:
-DropRelationTable(session, str(rschema))
+DropRelationTable(cnx, str(rschema))
 # then update the in-memory schema
 if rdef.subject not in ETYPE_NAME_MAP and rdef.object not in ETYPE_NAME_MAP:
 rschema.del_relation_def(rdef.subject, rdef.object)
 # if this is the last relation definition of this type, drop associated
 # relation type
-if lastrel and not session.deleted_in_transaction(rschema.eid):
+if lastrel and not cnx.deleted_in_transaction(rschema.eid):
 execute('DELETE CWRType X WHERE X eid %(x)s', {'x': rschema.eid})
 def revertprecommit_event(self):
 # revert changes on in memory schema
 #
 # Note: add_relation_def takes a RelationDefinition, not a
 # RelationDefinitionSchema, needs to fake it
 rdef = self.rdef
 rdef.name = str(rdef.rtype)
 if rdef.subject not in ETYPE_NAME_MAP and rdef.object not in ETYPE_NAME_MAP:
-self.session.vreg.schema.add_relation_def(rdef)
+self.cnx.vreg.schema.add_relation_def(rdef)
 class RDefUpdateOp(MemSchemaOperation):
 """actually update some properties of a relation definition"""
 rschema = rdefkey = values = None # make pylint happy
 rdef = oldvalues = None
 indexed_changed = null_allowed_changed = False
 def precommit_event(self):
-session = self.session
+cnx = self.cnx
 rdef = self.rdef = self.rschema.rdefs[self.rdefkey]
 # update the in-memory schema first
 self.oldvalues = dict( (attr, getattr(rdef, attr)) for attr in self.values)
 rdef.update(self.values)
 # then make necessary changes to the system source database
-syssource = session.repo.system_source
+syssource = cnx.repo.system_source
 if 'indexed' in self.values:
-syssource.update_rdef_indexed(session, rdef)
+syssource.update_rdef_indexed(cnx, rdef)
 self.indexed_changed = True
 if 'cardinality' in self.values and (rdef.rtype.final or
 rdef.rtype.inlined) \
 and self.values['cardinality'][0] != self.oldvalues['cardinality'][0]:
-syssource.update_rdef_null_allowed(self.session, rdef)
+syssource.update_rdef_null_allowed(self.cnx, rdef)
 self.null_allowed_changed = True
 if 'fulltextindexed' in self.values:
-UpdateFTIndexOp.get_instance(session).add_data(rdef.subject)
+UpdateFTIndexOp.get_instance(cnx).add_data(rdef.subject)
 def revertprecommit_event(self):
 if self.rdef is None:
 return
 # revert changes on in memory schema
 self.rdef.update(self.oldvalues)
 # revert changes on database
-syssource = self.session.repo.system_source
+syssource = self.cnx.repo.system_source
 if self.indexed_changed:
-syssource.update_rdef_indexed(self.session, self.rdef)
+syssource.update_rdef_indexed(self.cnx, self.rdef)
 if self.null_allowed_changed:
-syssource.update_rdef_null_allowed(self.session, self.rdef)
+syssource.update_rdef_null_allowed(self.cnx, self.rdef)
 def _set_modifiable_constraints(rdef):
 # for proper in-place modification of in-memory schema: if rdef.constraints
 # is already a list, reuse it (we're updating multiple constraints of the
 """actually remove a constraint of a relation definition"""
 rdef = oldcstr = newcstr = None # make pylint happy
 size_cstr_changed = unique_changed = False
 def precommit_event(self):
-session = self.session
+cnx = self.cnx
 rdef = self.rdef
 # in-place modification of in-memory schema first
 _set_modifiable_constraints(rdef)
 rdef.constraints.remove(self.oldcstr)
 # then update database: alter the physical schema on size/unique
 # constraint changes
-syssource = session.repo.system_source
+syssource = cnx.repo.system_source
 cstrtype = self.oldcstr.type()
 if cstrtype == 'SizeConstraint':
-syssource.update_rdef_column(session, rdef)
+syssource.update_rdef_column(cnx, rdef)
 self.size_cstr_changed = True
 elif cstrtype == 'UniqueConstraint':
-syssource.update_rdef_unique(session, rdef)
+syssource.update_rdef_unique(cnx, rdef)
 self.unique_changed = True
 def revertprecommit_event(self):
 # revert changes on in memory schema
 if self.newcstr is not None:
 self.rdef.constraints.remove(self.newcstr)
 if self.oldcstr is not None:
 self.rdef.constraints.append(self.oldcstr)
 # revert changes on database
-syssource = self.session.repo.system_source
+syssource = self.cnx.repo.system_source
 if self.size_cstr_changed:
-syssource.update_rdef_column(self.session, self.rdef)
+syssource.update_rdef_column(self.cnx, self.rdef)
 if self.unique_changed:
-syssource.update_rdef_unique(self.session, self.rdef)
+syssource.update_rdef_unique(self.cnx, self.rdef)
 class CWConstraintAddOp(CWConstraintDelOp):
 """actually update constraint of a relation definition"""
 entity = None # make pylint happy
 def precommit_event(self):
-session = self.session
+cnx = self.cnx
 rdefentity = self.entity.reverse_constrained_by[0]
 # when the relation is added in the same transaction, the constraint
 # object is created by the operation adding the attribute or relation,
 # so there is nothing to do here
-if session.added_in_transaction(rdefentity.eid):
+if cnx.added_in_transaction(rdefentity.eid):
 return
-rdef = self.rdef = session.vreg.schema.schema_by_eid(rdefentity.eid)
+rdef = self.rdef = cnx.vreg.schema.schema_by_eid(rdefentity.eid)
 cstrtype = self.entity.type
 oldcstr = self.oldcstr = rdef.constraint_by_type(cstrtype)
 newcstr = self.newcstr = CONSTRAINTS[cstrtype].deserialize(self.entity.value)
 # in-place modification of in-memory schema first
 _set_modifiable_constraints(rdef)
 if oldcstr is not None:
 rdef.constraints.remove(oldcstr)
 rdef.constraints.append(newcstr)
 # then update database: alter the physical schema on size/unique
 # constraint changes
-syssource = session.repo.system_source
+syssource = cnx.repo.system_source
 if cstrtype == 'SizeConstraint' and (oldcstr is None or
 oldcstr.max != newcstr.max):
-syssource.update_rdef_column(session, rdef)
+syssource.update_rdef_column(cnx, rdef)
 self.size_cstr_changed = True
 elif cstrtype == 'UniqueConstraint' and oldcstr is None:
-syssource.update_rdef_unique(session, rdef)
+syssource.update_rdef_unique(cnx, rdef)
 self.unique_changed = True
 class CWUniqueTogetherConstraintAddOp(MemSchemaOperation):
 entity = None # make pylint happy
 def precommit_event(self):
-session = self.session
+cnx = self.cnx
 prefix = SQL_PREFIX
 entity = self.entity
 table = '%s%s' % (prefix, entity.constraint_of[0].name)
 cols = ['%s%s' % (prefix, r.name) for r in entity.relations]
-dbhelper = session.repo.system_source.dbhelper
+dbhelper = cnx.repo.system_source.dbhelper
 sqls = dbhelper.sqls_create_multicol_unique_index(table, cols, entity.name)
 for sql in sqls:
-session.system_sql(sql)
+cnx.system_sql(sql)
 def postcommit_event(self):
 entity = self.entity
-eschema = self.session.vreg.schema.schema_by_eid(entity.constraint_of[0].eid)
+eschema = self.cnx.vreg.schema.schema_by_eid(entity.constraint_of[0].eid)
 attrs = [r.name for r in entity.relations]
 eschema._unique_together.append(attrs)
 class CWUniqueTogetherConstraintDelOp(MemSchemaOperation):
 entity = cstrname = None # for pylint
 cols = () # for pylint
 def precommit_event(self):
-session = self.session
+cnx = self.cnx
 prefix = SQL_PREFIX
 table = '%s%s' % (prefix, self.entity.type)
-dbhelper = session.repo.system_source.dbhelper
+dbhelper = cnx.repo.system_source.dbhelper
 cols = ['%s%s' % (prefix, c) for c in self.cols]
 sqls = dbhelper.sqls_drop_multicol_unique_index(table, cols, self.cstrname)
 for sql in sqls:
-session.system_sql(sql)
+cnx.system_sql(sql)
 def postcommit_event(self):
-eschema = self.session.vreg.schema.schema_by_eid(self.entity.eid)
+eschema = self.cnx.vreg.schema.schema_by_eid(self.entity.eid)
 cols = set(self.cols)
 unique_together = [ut for ut in eschema._unique_together
 if set(ut) != cols]
 eschema._unique_together = unique_together
 """actually remove the entity type from the instance's schema"""
 etype = None # make pylint happy
 def postcommit_event(self):
 # del_entity_type also removes entity's relations
-self.session.vreg.schema.del_entity_type(self.etype)
+self.cnx.vreg.schema.del_entity_type(self.etype)
 class MemSchemaCWRTypeAdd(MemSchemaOperation):
 """actually add the relation type to the instance's schema"""
 rtypedef = None # make pylint happy
 def precommit_event(self):
-self.session.vreg.schema.add_relation_type(self.rtypedef)
+self.cnx.vreg.schema.add_relation_type(self.rtypedef)
 def revertprecommit_event(self):
-self.session.vreg.schema.del_relation_type(self.rtypedef.name)
+self.cnx.vreg.schema.del_relation_type(self.rtypedef.name)
 class MemSchemaCWRTypeDel(MemSchemaOperation):
 """actually remove the relation type from the instance's schema"""
 rtype = None # make pylint happy
 def postcommit_event(self):
 try:
-self.session.vreg.schema.del_relation_type(self.rtype)
+self.cnx.vreg.schema.del_relation_type(self.rtype)
 except KeyError:
 # s/o entity type have already been deleted
 pass
 eid = action = group_eid = expr = None # make pylint happy
 def precommit_event(self):
 """the observed connections.cnxset has been commited"""
 try:
-erschema = self.session.vreg.schema.schema_by_eid(self.eid)
+erschema = self.cnx.vreg.schema.schema_by_eid(self.eid)
 except KeyError:
 # duh, schema not found, log error and skip operation
 self.warning('no schema for %s', self.eid)
 return
 perms = list(erschema.action_permissions(self.action))
 if self.group_eid is not None:
-perm = self.session.entity_from_eid(self.group_eid).name
+perm = self.cnx.entity_from_eid(self.group_eid).name
 else:
 perm = erschema.rql_expression(self.expr)
 try:
 perms.index(perm)
 self.warning('%s already in permissions for %s on %s',
 """
 def precommit_event(self):
 """the observed connections set has been commited"""
 try:
-erschema = self.session.vreg.schema.schema_by_eid(self.eid)
+erschema = self.cnx.vreg.schema.schema_by_eid(self.eid)
 except KeyError:
 # duh, schema not found, log error and skip operation
 self.warning('no schema for %s', self.eid)
 return
 if isinstance(erschema, RelationSchema): # XXX 3.6 migration
 if isinstance(erschema, RelationDefinitionSchema) and \
 self.action in ('delete', 'add'): # XXX 3.6.1 migration
 return
 perms = list(erschema.action_permissions(self.action))
 if self.group_eid is not None:
-perm = self.session.entity_from_eid(self.group_eid).name
+perm = self.cnx.entity_from_eid(self.group_eid).name
 else:
 perm = erschema.rql_expression(self.expr)
 try:
 perms.remove(perm)
 erschema.set_action_permissions(self.action, perms)
 class MemSchemaSpecializesAdd(MemSchemaOperation):
 etypeeid = parentetypeeid = None # make pylint happy
 def precommit_event(self):
-eschema = self.session.vreg.schema.schema_by_eid(self.etypeeid)
+eschema = self.cnx.vreg.schema.schema_by_eid(self.etypeeid)
-parenteschema = self.session.vreg.schema.schema_by_eid(self.parentetypeeid)
+parenteschema = self.cnx.vreg.schema.schema_by_eid(self.parentetypeeid)
 eschema._specialized_type = parenteschema.type
 parenteschema._specialized_by.append(eschema.type)
 # XXX revertprecommit_event
 class MemSchemaSpecializesDel(MemSchemaOperation):
 etypeeid = parentetypeeid = None # make pylint happy
 def precommit_event(self):
 try:
-eschema = self.session.vreg.schema.schema_by_eid(self.etypeeid)
+eschema = self.cnx.vreg.schema.schema_by_eid(self.etypeeid)
-parenteschema = self.session.vreg.schema.schema_by_eid(self.parentetypeeid)
+parenteschema = self.cnx.vreg.schema.schema_by_eid(self.parentetypeeid)
 except KeyError:
 # etype removed, nothing to do
 return
 eschema._specialized_type = None
 parenteschema._specialized_by.remove(eschema.type)
 __regid__ = 'syncdelrelationtype'
 __select__ = SyncSchemaHook.__select__ & hook.match_rtype('relation_type')
 events = ('after_delete_relation',)
 def __call__(self):
-session = self._cw
+cnx = self._cw
 try:
-rdef = session.vreg.schema.schema_by_eid(self.eidfrom)
+rdef = cnx.vreg.schema.schema_by_eid(self.eidfrom)
 except KeyError:
 self.critical('cant get schema rdef associated to %s', self.eidfrom)
 return
 subjschema, rschema, objschema = rdef.as_triple()
-pendingrdefs = session.transaction_data.setdefault('pendingrdefs', set())
+pendingrdefs = cnx.transaction_data.setdefault('pendingrdefs', set())
 # first delete existing relation if necessary
 if rschema.final:
 rdeftype = 'CWAttribute'
 pendingrdefs.add((subjschema, rschema))
 else:
 rdeftype = 'CWRelation'
 pendingrdefs.add((subjschema, rschema, objschema))
-if not (session.deleted_in_transaction(subjschema.eid) or
+if not (cnx.deleted_in_transaction(subjschema.eid) or
-session.deleted_in_transaction(objschema.eid)):
+cnx.deleted_in_transaction(objschema.eid)):
-session.execute('DELETE X %s Y WHERE X is %s, Y is %s'
+cnx.execute('DELETE X %s Y WHERE X is %s, Y is %s'
 % (rschema, subjschema, objschema))
-RDefDelOp(session, rdef=rdef)
+RDefDelOp(cnx, rdef=rdef)
 # CWAttribute / CWRelation hooks ###############################################
 class AfterAddCWAttributeHook(SyncSchemaHook):
 We wait after the commit to as the schema in memory is only updated after
 the commit.
 """
 def postcommit_event(self):
-session = self.session
+cnx = self.cnx
-source = session.repo.system_source
+source = cnx.repo.system_source
-schema = session.repo.vreg.schema
+schema = cnx.repo.vreg.schema
 to_reindex = self.get_data()
 self.info('%i etypes need full text indexed reindexation',
 len(to_reindex))
 for etype in to_reindex:
-rset = session.execute('Any X WHERE X is %s' % etype)
+rset = cnx.execute('Any X WHERE X is %s' % etype)
 self.info('Reindexing full text index for %i entity of type %s',
 len(rset), etype)
 still_fti = list(schema[etype].indexable_attributes())
 for entity in rset.entities():
-source.fti_unindex_entities(session, [entity])
+source.fti_unindex_entities(cnx, [entity])
 for container in entity.cw_adapt_to('IFTIndexable').fti_containers():
 if still_fti or container is not entity:
-source.fti_unindex_entities(session, [container])
+source.fti_unindex_entities(cnx, [container])
-source.fti_index_entities(session, [container])
+source.fti_index_entities(cnx, [container])
 if to_reindex:
 # Transaction has already been committed
-session.cnxset.commit()
+cnx.cnxset.commit()
 # specializes synchronization hooks ############################################

changeset 9621	202c4797e365
parent 9548	be001628edad
child 9635	aaf099172bb9