cubicweb: comparison hooks/syncschema.py

equal deleted inserted replaced

-:141b935a38fc
+:99024ad59223
 cw.transaction_data['groupmap'] = gmap = ss.group_mapping(cw)
 return gmap
 def add_inline_relation_column(session, etype, rtype):
 """add necessary column and index for an inlined relation"""
+attrkey = '%s.%s' % (etype, rtype)
+createdattrs = session.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'
 % (table, column)), rollback_on_failure=False)
 # 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.pool.source('system').create_index(session, table, column)
 session.info('added index on %s(%s)', table, column)
-session.transaction_data.setdefault('createdattrs', []).append(
-'%s.%s' % (etype, rtype))
 def check_valid_changes(session, entity, ro_attrs=('name', 'final')):
 errors = {}
 # don't use getattr(entity, attr), we would get the modified value if any
 entity[attr] = newval
 if errors:
 raise ValidationError(entity.eid, errors)
+class SyncSchemaHook(hook.Hook):
+"""abstract class for schema synchronization hooks (in the `syncschema`
+category)
+"""
+__abstract__ = True
+category = 'syncschema'
 # operations for low-level database alteration  ################################
 class DropTable(hook.Operation):
 """actually remove a database from the instance's schema"""
 table = None # make pylint happy
 if self.table in dropped:
 return # already processed
 dropped.add(self.table)
 self.session.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):
 super(DropRelationTable, self).__init__(
 else:
 # not supported by sqlite for instance
 self.error('dropping column not supported by the backend, handle '
 'it yourself (%s.%s)', table, column)
+# XXX revertprecommit_event
 # base operations for in-memory schema synchronization  ########################
 class MemSchemaNotifyChanges(hook.SingleLastOperation):
 """the update schema operation:
 def precommit_event(self):
 for eschema in self.session.repo.schema.entities():
 if not eschema.final:
 clear_cache(eschema, 'ordered_relations')
-def commit_event(self):
+def postcommit_event(self):
 rebuildinfered = self.session.data.get('rebuild-infered', True)
 repo = self.session.repo
 # commit event should not raise error, while set_schema has chances to
 # do so because it triggers full vreg reloading
 try:
 self.precommit_event()
 class MemSchemaOperation(hook.Operation):
 """base class for schema operations"""
-def __init__(self, session, kobj=None, **kwargs):
+def __init__(self, session, **kwargs):
-self.kobj = kobj
-# once Operation.__init__ has been called, event may be triggered, so
-# do this last !
 hook.Operation.__init__(self, session, **kwargs)
 # every schema operation is triggering a schema update
 MemSchemaNotifyChanges(session)
-def prepare_constraints(self, rdef):
-# if constraints is already a list, reuse it (we're updating multiple
-# constraints of the same rdef in the same transactions)
-if not isinstance(rdef.constraints, list):
-rdef.constraints = list(rdef.constraints)
-self.constraints = rdef.constraints
-class MemSchemaEarlyOperation(MemSchemaOperation):
-def insert_index(self):
-"""schema operation which are inserted at the begining of the queue
-(typically to add/remove entity or relation types)
-"""
-i = -1
-for i, op in enumerate(self.session.pending_operations):
-if not isinstance(op, MemSchemaEarlyOperation):
-return i
-return i + 1
 # operations for high-level source database alteration  ########################
-class SourceDbCWETypeRename(hook.Operation):
+class CWETypeAddOp(MemSchemaOperation):
+"""after adding a CWEType entity:
+* add it to the instance's schema
+* create the necessary table
+* set creation_date and modification_date by creating the necessary
+CWAttribute entities
+* add owned_by relation by creating the necessary CWRelation entity
+"""
+def precommit_event(self):
+session = self.session
+entity = self.entity
+schema = session.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.pool.source('system').dbhelper,
+eschema, prefix=SQL_PREFIX)
+for sql in tablesql.split(';'):
+if sql.strip():
+session.system_sql(sql)
+# add meta relations
+gmap = group_mapping(session)
+cmap = ss.cstrtype_mapping(session)
+for rtype in (META_RTYPES - VIRTUAL_RTYPES):
+rschema = schema[rtype]
+sampletype = rschema.subjects()[0]
+desttype = rschema.objects()[0]
+rdef = copy(rschema.rdef(sampletype, desttype))
+rdef.subject = mock_object(eid=entity.eid)
+mock = mock_object(eid=None)
+ss.execschemarql(session.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)
+# revert changes on database
+self.session.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 precommit_event(self):
+def rename(self, oldname, newname):
+self.session.vreg.schema.rename_entity_type(oldname, newname)
 # we need sql to operate physical changes on the system database
 sqlexec = self.session.system_sql
-sqlexec('ALTER TABLE %s%s RENAME TO %s%s' % (SQL_PREFIX, self.oldname,
+sqlexec('ALTER TABLE %s%s RENAME TO %s%s' % (SQL_PREFIX, oldname,
-SQL_PREFIX, self.newname))
+SQL_PREFIX, newname))
-self.info('renamed table %s to %s', self.oldname, self.newname)
+self.info('renamed table %s to %s', oldname, newname)
 sqlexec('UPDATE entities SET type=%s WHERE type=%s',
-(self.newname, self.oldname))
+(newname, oldname))
 sqlexec('UPDATE deleted_entities SET type=%s WHERE type=%s',
-(self.newname, self.oldname))
+(newname, oldname))
+# XXX transaction records
-class SourceDbCWRTypeUpdate(hook.Operation):
+def precommit_event(self):
+self.rename(self.oldname, self.newname)
+def revertprecommit_event(self):
+self.rename(self.newname, self.oldname)
+class CWRTypeUpdateOp(MemSchemaOperation):
 """actually update some properties of a relation definition"""
 rschema = entity = values = None # make pylint happy
+oldvalus = None
 def precommit_event(self):
 rschema = self.rschema
 if rschema.final:
-return
+return # watched changes to final relation type are unexpected
 session = self.session
 if 'fulltext_container' in self.values:
 for subjtype, objtype in rschema.rdefs:
 hook.set_operation(session, 'fti_update_etypes', subjtype,
 UpdateFTIndexOp)
 hook.set_operation(session, 'fti_update_etypes', objtype,
 UpdateFTIndexOp)
+# update the in-memory schema first
+self.oldvalues = dict( (attr, getattr(rschema, attr)) for attr in self.values)
+self.rschema.__dict__.update(self.values)
+# then make necessary changes to the system source database
 if not 'inlined' in self.values:
 return # nothing to do
 inlined = self.values['inlined']
-# check in-lining is necessary / possible
+# 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
 rtype = rschema.type
 try:
 add_inline_relation_column(session, str(etype), rtype)
 except Exception, 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
+# been previously dropped (eg sqlite)
 self.error('error while altering table %s: %s', etype, ex)
 # copy existant data.
 # XXX don't use, it's not supported by sqlite (at least at when i tried it)
 #sqlexec('UPDATE %(etype)s SET %(rtype)s=eid_to '
 #        'FROM %(rtype)s_relation '
 cursor.executemany('UPDATE %s SET %s=%%(val)s WHERE %s=%%(x)s'
 % (table, column, eidcolumn), args)
 # drop existant table
 DropRelationTable(session, rtype)
+def revertprecommit_event(self):
-class SourceDbCWAttributeAdd(hook.Operation):
+# revert changes on in memory schema
+self.rschema.__dict__.update(self.oldvalues)
+# XXX revert changes on database
+class CWAttributeAddOp(MemSchemaOperation):
 """an attribute relation (CWAttribute) has been added:
 * add the necessary column
 * set default on this column if any and possible
 * register an operation to add the relation definition to the
 instance's schema on commit
 entity = None # make pylint happy
 def init_rdef(self, **kwargs):
 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),
+order=entity.ordernum, eid=entity.eid, **kwargs)
+self.session.vreg.schema.add_relation_def(rdefdef)
 self.session.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})
-subj = str(fromentity.name)
+return rdefdef
-rtype = entity.rtype.name
-obj = str(entity.otype.name)
-constraints = get_constraints(self.session, entity)
-rdef = ybo.RelationDefinition(subj, rtype, obj,
-description=entity.description,
-cardinality=entity.cardinality,
-constraints=constraints,
-order=entity.ordernum,
-eid=entity.eid,
-**kwargs)
-MemSchemaRDefAdd(self.session, rdef)
-return rdef
 def precommit_event(self):
 session = self.session
 entity = self.entity
 # entity.defaultval is a string or None, but we need a correctly typed
 default = TYPE_CONVERTER[entity.otype.name](default)
 props = {'default': default,
 'indexed': entity.indexed,
 'fulltextindexed': entity.fulltextindexed,
 'internationalizable': entity.internationalizable}
-rdef = self.init_rdef(**props)
+# update the in-memory schema first
-sysource = session.pool.source('system')
+rdefdef = self.init_rdef(**props)
+# then make necessary changes to the system source database
+syssource = session.pool.source('system')
 attrtype = y2sql.type_from_constraints(
-sysource.dbhelper, rdef.object, rdef.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
-if sysource.dbdriver == 'sqlite' and 'UNIQUE' in attrtype:
+if syssource.dbdriver == 'sqlite' and 'UNIQUE' in attrtype:
 extra_unique_index = True
 attrtype = attrtype.replace(' UNIQUE', '')
 else:
 extra_unique_index = False
 # added some str() wrapping query since some backend (eg psycopg) don't
 # allow unicode queries
-table = SQL_PREFIX + rdef.subject
+table = SQL_PREFIX + rdefdef.subject
-column = SQL_PREFIX + rdef.name
+column = SQL_PREFIX + rdefdef.name
 try:
 session.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)
 # 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:
-sysource.create_index(session, table, column,
+syssource.create_index(session, table, column,
 unique=extra_unique_index)
 except Exception, ex:
 self.error('error while creating index for %s.%s: %s',
 table, column, ex)
 # final relations are not infered, propagate
 schema = session.vreg.schema
 try:
-eschema = schema.eschema(rdef.subject)
+eschema = schema.eschema(rdefdef.subject)
 except KeyError:
 return # entity type currently being added
 # propagate attribute to children classes
-rschema = schema.rschema(rdef.name)
+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
 # XXX 'infered': True/False, not clear actually
-props.update({'constraints': rdef.constraints,
+props.update({'constraints': rdefdef.constraints,
-'description': rdef.description,
+'description': rdefdef.description,
-'cardinality': rdef.cardinality,
+'cardinality': rdefdef.cardinality,
-'constraints': rdef.constraints,
+'constraints': rdefdef.constraints,
-'permissions': rdef.get_permissions(),
+'permissions': rdefdef.get_permissions(),
-'order': rdef.order,
+'order': rdefdef.order,
 'infered': False, 'eid': None
 })
 cstrtypemap = ss.cstrtype_mapping(session)
 groupmap = group_mapping(session)
-object = schema.eschema(rdef.object)
+object = schema.eschema(rdefdef.object)
 for specialization in eschema.specialized_by(False):
-if (specialization, rdef.object) in rschema.rdefs:
+if (specialization, rdefdef.object) in rschema.rdefs:
 continue
 sperdef = RelationDefinitionSchema(specialization, rschema,
 object, props)
 ss.execschemarql(session.execute, sperdef,
 ss.rdef2rql(sperdef, cstrtypemap, groupmap))
 # modification_date update
 if default:
 session.system_sql('UPDATE %s SET %s=%%(default)s' % (table, column),
 {'default': default})
+def revertprecommit_event(self):
-class SourceDbCWRelationAdd(SourceDbCWAttributeAdd):
+# revert changes on in memory schema
+self.session.vreg.schema.del_relation_def(
+self.rdefdef.subject, self.rdefdef.name, self.rdefdef.object)
+# XXX revert changes on database
+class CWRelationAddOp(CWAttributeAddOp):
 """an actual relation has been added:
-* if this is an inlined relation, add the necessary column
-else if it's the first instance of this relation type, add the
+* add the relation definition to the instance's schema
-necessary table and set default permissions
-* register an operation to add the relation definition to the
+* if this is an inlined relation, add the necessary column else if it's the
-instance's schema on commit
+first instance of this relation type, add the necessary table and set
+default permissions
 constraints are handled by specific hooks
 """
 entity = None # make pylint happy
 def precommit_event(self):
 session = self.session
 entity = self.entity
-rdef = self.init_rdef(composite=entity.composite)
+# 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
-rtype = rdef.name
+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
-# and if it has not been added during other event of the same
+if len(rschema.objects(rdefdef.subject)) == 1:
-# transaction
+add_inline_relation_column(session, rdefdef.subject, rtype)
-key = '%s.%s' % (rdef.subject, rtype)
-try:
-alreadythere = bool(rschema.objects(rdef.subject))
-except KeyError:
-alreadythere = False
-if not (alreadythere or
-key in session.transaction_data.get('createdattrs', ())):
-add_inline_relation_column(session, rdef.subject, rtype)
 else:
 # 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 (rschema.subjects() or
+if not (len(rschema.rdefs) > 1 or
 rtype in session.transaction_data.get('createdtables', ())):
-try:
+rschema = schema.rschema(rtype)
-rschema = schema.rschema(rtype)
-tablesql = y2sql.rschema2sql(rschema)
-except KeyError:
-# fake we add it to the schema now to get a correctly
-# initialized schema but remove it before doing anything
-# more dangerous...
-rschema = schema.add_relation_type(rdef)
-tablesql = y2sql.rschema2sql(rschema)
-schema.del_relation_type(rtype)
 # create the necessary table
-for sql in tablesql.split(';'):
+for sql in y2sql.rschema2sql(rschema).split(';'):
 if sql.strip():
 session.system_sql(sql)
 session.transaction_data.setdefault('createdtables', []).append(
 rtype)
+# XXX revertprecommit_event
-class SourceDbRDefUpdate(hook.Operation):
+class RDefDelOp(MemSchemaOperation):
+"""an actual relation has been removed"""
+rdef = None # make pylint happy
+def precommit_event(self):
+session = self.session
+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
+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
+# for other relations
+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):
+ptypes = session.transaction_data.setdefault('pendingrtypes', set())
+ptypes.add(rschema.type)
+DropColumn(session, table=SQL_PREFIX + str(rdef.subject),
+column=SQL_PREFIX + str(rschema))
+elif lastrel:
+DropRelationTable(session, str(rschema))
+# then update the in-memory schema
+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):
+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
+self.rdef.name = str(self.rdef.rtype)
+self.session.vreg.schema.add_relation_def(self.rdef)
+class RDefUpdateOp(MemSchemaOperation):
 """actually update some properties of a relation definition"""
-rschema = values = None # make pylint happy
+rschema = rdefkey = values = None # make pylint happy
+oldvalues = None
+indexed_changed = null_allowed_changed = False
 def precommit_event(self):
 session = self.session
-etype = self.kobj[0]
+rdef = self.rdef = self.rschema.rdefs[self.rdefkey]
-table = SQL_PREFIX + etype
+# update the in-memory schema first
-column = SQL_PREFIX + self.rschema.type
+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.pool.source('system')
 if 'indexed' in self.values:
-sysource = session.pool.source('system')
+syssource.update_rdef_indexed(session, rdef)
-if self.values['indexed']:
+self.indexed_changed = True
-sysource.create_index(session, table, column)
+if 'cardinality' in self.values and (rdef.rtype.final or
-else:
+rdef.rtype.inlined) \
-sysource.drop_index(session, table, column)
+and self.values['cardinality'][0] != self.oldvalues['cardinality'][0]:
-if 'cardinality' in self.values and self.rschema.final:
+syssource.update_rdef_null_allowed(self.session, rdef)
-syssource = session.pool.source('system')
+self.null_allowed_changed = True
-if not syssource.dbhelper.alter_column_support:
-# not supported (and NOT NULL not set by yams in that case, so
-# no worry) XXX (syt) then should we set NOT NULL below ??
-return
-atype = self.rschema.objects(etype)[0]
-constraints = self.rschema.rdef(etype, atype).constraints
-coltype = y2sql.type_from_constraints(syssource.dbhelper, atype, constraints,
-creating=False)
-# XXX check self.values['cardinality'][0] actually changed?
-syssource.set_null_allowed(self.session, table, column, coltype,
-self.values['cardinality'][0] != '1')
 if 'fulltextindexed' in self.values:
-hook.set_operation(session, 'fti_update_etypes', etype,
+hook.set_operation(session, 'fti_update_etypes', rdef.subject,
 UpdateFTIndexOp)
+def revertprecommit_event(self):
-class SourceDbCWConstraintAdd(hook.Operation):
+# revert changes on in memory schema
+self.rdef.update(self.oldvalues)
+# revert changes on database
+syssource = self.session.pool.source('system')
+if self.indexed_changed:
+syssource.update_rdef_indexed(self.session, self.rdef)
+if self.null_allowed_changed:
+syssource.update_rdef_null_allowed(self.session, 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
+# same rdef in the same transactions)
+if not isinstance(rdef.constraints, list):
+rdef.constraints = list(rdef.constraints)
+class CWConstraintDelOp(MemSchemaOperation):
+"""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
+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.pool.source('system')
+cstrtype = self.oldcstr.type()
+if cstrtype == 'SizeConstraint':
+syssource.update_rdef_column(session, rdef)
+self.size_cstr_changed = True
+elif cstrtype == 'UniqueConstraint':
+syssource.update_rdef_unique(session, 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.pool.source('system')
+if self.size_cstr_changed:
+syssource.update_rdef_column(self.session, self.rdef)
+if self.unique_changed:
+syssource.update_rdef_unique(self.session, self.rdef)
+class CWConstraintAddOp(CWConstraintDelOp):
 """actually update constraint of a relation definition"""
 entity = None # make pylint happy
-cancelled = False
+def precommit_event(self):
-def precommit_event(self):
-rdef = self.entity.reverse_constrained_by[0]
 session = self.session
+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(rdef.eid):
+if session.added_in_transaction(rdefentity.eid):
 return
-rdefschema = session.vreg.schema.schema_by_eid(rdef.eid)
+rdef = self.rdef = session.vreg.schema.schema_by_eid(rdefentity.eid)
-subjtype, rtype, objtype = rdefschema.as_triple()
 cstrtype = self.entity.type
-oldcstr = rtype.rdef(subjtype, objtype).constraint_by_type(cstrtype)
+oldcstr = self.oldcstr = rdef.constraint_by_type(cstrtype)
-newcstr = CONSTRAINTS[cstrtype].deserialize(self.entity.value)
+newcstr = self.newcstr = CONSTRAINTS[cstrtype].deserialize(self.entity.value)
-table = SQL_PREFIX + str(subjtype)
+# in-place modification of in-memory schema first
-column = SQL_PREFIX + str(rtype)
+_set_modifiable_constraints(rdef)
-# alter the physical schema on size constraint changes
+newcstr.eid = self.entity.eid
-if newcstr.type() == 'SizeConstraint' and (
+if oldcstr is not None:
-oldcstr is None or oldcstr.max != newcstr.max):
+rdef.constraints.remove(oldcstr)
-syssource = self.session.pool.source('system')
+rdef.constraints.append(newcstr)
-card = rtype.rdef(subjtype, objtype).cardinality
+# then update database: alter the physical schema on size/unique
-coltype = y2sql.type_from_constraints(syssource.dbhelper, objtype,
+# constraint changes
-[newcstr], creating=False)
+syssource = session.pool.source('system')
-try:
+if cstrtype == 'SizeConstraint' and (oldcstr is None or
-syssource.change_col_type(session, table, column, coltype, card[0] != '1')
+oldcstr.max != newcstr.max):
-self.info('altered column %s of table %s: now %s',
+syssource.update_rdef_column(session, rdef)
-column, table, coltype)
+self.size_cstr_changed = True
-except Exception, ex:
-# not supported by sqlite for instance
-self.error('error while altering table %s: %s', table, ex)
 elif cstrtype == 'UniqueConstraint' and oldcstr is None:
-session.pool.source('system').create_index(
+syssource.update_rdef_unique(session, rdef)
-self.session, table, column, unique=True)
+self.unique_changed = True
-class SourceDbCWConstraintDel(hook.Operation):
-"""actually remove a constraint of a relation definition"""
-rtype = subjtype = None # make pylint happy
-def precommit_event(self):
-cstrtype = self.cstr.type()
-table = SQL_PREFIX + str(self.rdef.subject)
-column = SQL_PREFIX + str(self.rdef.rtype)
-# alter the physical schema on size/unique constraint changes
-if cstrtype == 'SizeConstraint':
-syssource = self.session.pool.source('system')
-coltype = y2sql.type_from_constraints(syssource.dbhelper,
-self.rdef.object, [],
-creating=False)
-try:
-syssource.change_col_type(session, table, column, coltype,
-self.rdef.cardinality[0] != '1')
-self.info('altered column %s of table %s: now %s',
-column, table, coltype)
-except Exception, ex:
-# not supported by sqlite for instance
-self.error('error while altering table %s: %s', table, ex)
-elif cstrtype == 'UniqueConstraint':
-self.session.pool.source('system').drop_index(
-self.session, table, column, unique=True)
 # operations for in-memory schema synchronization  #############################
-class MemSchemaCWETypeAdd(MemSchemaEarlyOperation):
-"""actually add the entity type to the instance's schema"""
-eid = None # make pylint happy
-def commit_event(self):
-self.session.vreg.schema.add_entity_type(self.kobj)
-class MemSchemaCWETypeRename(MemSchemaOperation):
-"""this operation updates physical storage accordingly"""
-oldname = newname = None # make pylint happy
-def commit_event(self):
-self.session.vreg.schema.rename_entity_type(self.oldname, self.newname)
 class MemSchemaCWETypeDel(MemSchemaOperation):
 """actually remove the entity type from the instance's schema"""
-def commit_event(self):
+def postcommit_event(self):
+# del_entity_type also removes entity's relations
+self.session.vreg.schema.del_entity_type(self.etype)
+class MemSchemaCWRTypeAdd(MemSchemaOperation):
+"""actually add the relation type to the instance's schema"""
+def precommit_event(self):
+self.session.vreg.schema.add_relation_type(self.rtypedef)
+def revertprecommit_event(self):
+self.session.vreg.schema.del_relation_type(self.rtypedef.name)
+class MemSchemaCWRTypeDel(MemSchemaOperation):
+"""actually remove the relation type from the instance's schema"""
+def postcommit_event(self):
 try:
-# del_entity_type also removes entity's relations
+self.session.vreg.schema.del_relation_type(self.rtype)
-self.session.vreg.schema.del_entity_type(self.kobj)
 except KeyError:
 # s/o entity type have already been deleted
 pass
-class MemSchemaCWRTypeAdd(MemSchemaEarlyOperation):
-"""actually add the relation type to the instance's schema"""
-eid = None # make pylint happy
-def commit_event(self):
-self.session.vreg.schema.add_relation_type(self.kobj)
-class MemSchemaCWRTypeUpdate(MemSchemaOperation):
-"""actually update some properties of a relation definition"""
-rschema = values = None # make pylint happy
-def commit_event(self):
-# structure should be clean, not need to remove entity's relations
-# at this point
-self.rschema.__dict__.update(self.values)
-class MemSchemaCWRTypeDel(MemSchemaOperation):
-"""actually remove the relation type from the instance's schema"""
-def commit_event(self):
-try:
-self.session.vreg.schema.del_relation_type(self.kobj)
-except KeyError:
-# s/o entity type have already been deleted
-pass
-class MemSchemaRDefAdd(MemSchemaEarlyOperation):
-"""actually add the attribute relation definition to the instance's
-schema
-"""
-def commit_event(self):
-self.session.vreg.schema.add_relation_def(self.kobj)
-class MemSchemaRDefUpdate(MemSchemaOperation):
-"""actually update some properties of a relation definition"""
-rschema = values = None # make pylint happy
-def commit_event(self):
-# structure should be clean, not need to remove entity's relations
-# at this point
-self.rschema.rdefs[self.kobj].update(self.values)
-class MemSchemaRDefDel(MemSchemaOperation):
-"""actually remove the relation definition from the instance's schema"""
-def commit_event(self):
-subjtype, rtype, objtype = self.kobj
-try:
-self.session.vreg.schema.del_relation_def(subjtype, rtype, objtype)
-except KeyError:
-# relation type may have been already deleted
-pass
-class MemSchemaCWConstraintAdd(MemSchemaOperation):
-"""actually update constraint of a relation definition
-has to be called before SourceDbCWConstraintAdd
-"""
-cancelled = False
-def precommit_event(self):
-rdef = 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 self.session.added_in_transaction(rdef.eid):
-self.cancelled = True
-return
-rdef = self.session.vreg.schema.schema_by_eid(rdef.eid)
-self.prepare_constraints(rdef)
-cstrtype = self.entity.type
-self.cstr = rdef.constraint_by_type(cstrtype)
-self.newcstr = CONSTRAINTS[cstrtype].deserialize(self.entity.value)
-self.newcstr.eid = self.entity.eid
-def commit_event(self):
-if self.cancelled:
-return
-# in-place modification
-if not self.cstr is None:
-self.constraints.remove(self.cstr)
-self.constraints.append(self.newcstr)
-class MemSchemaCWConstraintDel(MemSchemaOperation):
-"""actually remove a constraint of a relation definition
-has to be called before SourceDbCWConstraintDel
-"""
-rtype = subjtype = objtype = None # make pylint happy
-def precommit_event(self):
-self.prepare_constraints(self.rdef)
-def commit_event(self):
-self.constraints.remove(self.cstr)
 class MemSchemaPermissionAdd(MemSchemaOperation):
 """synchronize schema when a *_permission relation has been added on a group
 """
-def commit_event(self):
+def precommit_event(self):
 """the observed connections pool has been commited"""
 try:
 erschema = self.session.vreg.schema.schema_by_eid(self.eid)
 except KeyError:
 # duh, schema not found, log error and skip operation
 perm, self.action, erschema)
 except ValueError:
 perms.append(perm)
 erschema.set_action_permissions(self.action, perms)
+# XXX revertprecommit_event
 class MemSchemaPermissionDel(MemSchemaPermissionAdd):
 """synchronize schema when a *_permission relation has been deleted from a
 group
 """
-def commit_event(self):
+def precommit_event(self):
 """the observed connections pool has been commited"""
 try:
 erschema = self.session.vreg.schema.schema_by_eid(self.eid)
 except KeyError:
 # duh, schema not found, log error and skip operation
 erschema.set_action_permissions(self.action, perms)
 except ValueError:
 self.error('can\'t remove permission %s for %s on %s',
 perm, self.action, erschema)
+# XXX revertprecommit_event
 class MemSchemaSpecializesAdd(MemSchemaOperation):
-def commit_event(self):
+def precommit_event(self):
 eschema = self.session.vreg.schema.schema_by_eid(self.etypeeid)
 parenteschema = self.session.vreg.schema.schema_by_eid(self.parentetypeeid)
 eschema._specialized_type = parenteschema.type
 parenteschema._specialized_by.append(eschema.type)
+# XXX revertprecommit_event
 class MemSchemaSpecializesDel(MemSchemaOperation):
-def commit_event(self):
+def precommit_event(self):
 try:
 eschema = self.session.vreg.schema.schema_by_eid(self.etypeeid)
 parenteschema = self.session.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)
+# XXX revertprecommit_event
-class SyncSchemaHook(hook.Hook):
-__abstract__ = True
-category = 'syncschema'
 # CWEType hooks ################################################################
 class DelCWETypeHook(SyncSchemaHook):
 if name in CORE_ETYPES:
 raise ValidationError(self.entity.eid, {None: self._cw._('can\'t be deleted')})
 # delete every entities of this type
 if not name in ETYPE_NAME_MAP:
 self._cw.execute('DELETE %s X' % name)
-MemSchemaCWETypeDel(self._cw, name)
+MemSchemaCWETypeDel(self._cw, etype=name)
 DropTable(self._cw, table=SQL_PREFIX + name)
 class AfterDelCWETypeHook(DelCWETypeHook):
 __regid__ = 'wfcleanup'
 def __call__(self):
 entity = self.entity
 if entity.get('final'):
 return
-schema = self._cw.vreg.schema
+CWETypeAddOp(self._cw, entity=entity)
-name = entity['name']
-etype = ybo.EntityType(name=name, description=entity.get('description'),
-meta=entity.get('meta')) # don't care about final
-# fake we add it to the schema now to get a correctly initialized schema
-# but remove it before doing anything more dangerous...
-schema = self._cw.vreg.schema
-eschema = schema.add_entity_type(etype)
-# generate table sql and rql to add metadata
-tablesql = y2sql.eschema2sql(self._cw.pool.source('system').dbhelper,
-eschema, prefix=SQL_PREFIX)
-rdefrqls = []
-gmap = group_mapping(self._cw)
-cmap = ss.cstrtype_mapping(self._cw)
-for rtype in (META_RTYPES - VIRTUAL_RTYPES):
-rschema = schema[rtype]
-sampletype = rschema.subjects()[0]
-desttype = rschema.objects()[0]
-rdef = copy(rschema.rdef(sampletype, desttype))
-rdef.subject = mock_object(eid=entity.eid)
-mock = mock_object(eid=None)
-rdefrqls.append( (mock, tuple(ss.rdef2rql(rdef, cmap, gmap))) )
-# now remove it !
-schema.del_entity_type(name)
-# create the necessary table
-for sql in tablesql.split(';'):
-if sql.strip():
-self._cw.system_sql(sql)
-# register operation to modify the schema on commit
-# this have to be done before adding other relations definitions
-# or permission settings
-etype.eid = entity.eid
-MemSchemaCWETypeAdd(self._cw, etype)
-# add meta relations
-for rdef, relrqls in rdefrqls:
-ss.execschemarql(self._cw.execute, rdef, relrqls)
 class BeforeUpdateCWETypeHook(DelCWETypeHook):
 """check name change, handle final"""
 __regid__ = 'syncupdatecwetype'
 def __call__(self):
 entity = self.entity
 check_valid_changes(self._cw, entity, ro_attrs=('final',))
 # don't use getattr(entity, attr), we would get the modified value if any
 if 'name' in entity.edited_attributes:
-newname = entity.pop('name')
+oldname, newname = hook.entity_oldnewvalue(entity, 'name')
-oldname = entity.name
 if newname.lower() != oldname.lower():
-SourceDbCWETypeRename(self._cw, oldname=oldname, newname=newname)
+CWETypeRenameOp(self._cw, oldname=oldname, newname=newname)
-MemSchemaCWETypeRename(self._cw, oldname=oldname, newname=newname)
-entity['name'] = newname
 # CWRType hooks ################################################################
 class DelCWRTypeHook(SyncSchemaHook):
 # delete relation definitions using this relation type
 self._cw.execute('DELETE CWAttribute X WHERE X relation_type Y, Y eid %(x)s',
 {'x': self.entity.eid})
 self._cw.execute('DELETE CWRelation X WHERE X relation_type Y, Y eid %(x)s',
 {'x': self.entity.eid})
-MemSchemaCWRTypeDel(self._cw, name)
+MemSchemaCWRTypeDel(self._cw, rtype=name)
 class AfterAddCWRTypeHook(DelCWRTypeHook):
 """after a CWRType entity has been added:
 * register an operation to add the relation type to the instance's
 __regid__ = 'syncaddcwrtype'
 events = ('after_add_entity',)
 def __call__(self):
 entity = self.entity
-rtype = ybo.RelationType(name=entity.name,
+rtypedef = ybo.RelationType(name=entity.name,
-description=entity.get('description'),
+description=entity.description,
-meta=entity.get('meta', False),
+inlined=entity.get('inlined', False),
-inlined=entity.get('inlined', False),
+symmetric=entity.get('symmetric', False),
-symmetric=entity.get('symmetric', False),
+eid=entity.eid)
-eid=entity.eid)
+MemSchemaCWRTypeAdd(self._cw, rtypedef=rtypedef)
-MemSchemaCWRTypeAdd(self._cw, rtype)
 class BeforeUpdateCWRTypeHook(DelCWRTypeHook):
 """check name change, handle final"""
 __regid__ = 'syncupdatecwrtype'
 old, new = hook.entity_oldnewvalue(entity, prop)
 if old != new:
 newvalues[prop] = entity[prop]
 if newvalues:
 rschema = self._cw.vreg.schema.rschema(entity.name)
-SourceDbCWRTypeUpdate(self._cw, rschema=rschema, entity=entity,
+CWRTypeUpdateOp(self._cw, rschema=rschema, entity=entity,
 values=newvalues)
-MemSchemaCWRTypeUpdate(self._cw, rschema=rschema, values=newvalues)
 class AfterDelRelationTypeHook(SyncSchemaHook):
 """before deleting a CWAttribute or CWRelation entity:
 * if this is a final or inlined relation definition, instantiate an
 rdef = session.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()
-pendings = session.transaction_data.get('pendingeids', ())
 pendingrdefs = session.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 (subjschema.eid in pendings or objschema.eid in pendings):
+if not (session.deleted_in_transaction(subjschema.eid) or
+session.deleted_in_transaction(objschema.eid)):
 session.execute('DELETE X %s Y WHERE X is %s, Y is %s'
 % (rschema, subjschema, objschema))
-execute = session.execute
+RDefDelOp(session, rdef=rdef)
-rset = execute('Any COUNT(X) WHERE X is %s, X relation_type R,'
-'R eid %%(x)s' % rdeftype, {'x': self.eidto})
-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
-# for other relations
-if (rschema.final or rschema.inlined):
-rset = execute('Any COUNT(X) WHERE X is %s, X relation_type R, '
-'R eid %%(x)s, X from_entity E, E name %%(name)s'
-% rdeftype, {'x': self.eidto, 'name': str(subjschema)})
-if rset[0][0] == 0 and not subjschema.eid in pendings:
-ptypes = session.transaction_data.setdefault('pendingrtypes', set())
-ptypes.add(rschema.type)
-DropColumn(session, table=SQL_PREFIX + subjschema.type,
-column=SQL_PREFIX + rschema.type)
-elif lastrel:
-DropRelationTable(session, rschema.type)
-# if this is the last instance, drop associated relation type
-if lastrel and not self.eidto in pendings:
-execute('DELETE CWRType X WHERE X eid %(x)s', {'x': self.eidto})
-MemSchemaRDefDel(session, (subjschema, rschema, objschema))
 # CWAttribute / CWRelation hooks ###############################################
 class AfterAddCWAttributeHook(SyncSchemaHook):
 __regid__ = 'syncaddcwattribute'
 __select__ = SyncSchemaHook.__select__ & is_instance('CWAttribute')
 events = ('after_add_entity',)
 def __call__(self):
-SourceDbCWAttributeAdd(self._cw, entity=self.entity)
+CWAttributeAddOp(self._cw, entity=self.entity)
 class AfterAddCWRelationHook(AfterAddCWAttributeHook):
 __regid__ = 'syncaddcwrelation'
 __select__ = SyncSchemaHook.__select__ & is_instance('CWRelation')
 def __call__(self):
-SourceDbCWRelationAdd(self._cw, entity=self.entity)
+CWRelationAddOp(self._cw, entity=self.entity)
 class AfterUpdateCWRDefHook(SyncSchemaHook):
 __regid__ = 'syncaddcwattribute'
 __select__ = SyncSchemaHook.__select__ & is_instance('CWAttribute',
 def __call__(self):
 entity = self.entity
 if self._cw.deleted_in_transaction(entity.eid):
 return
-desttype = entity.otype.name
+subjtype = entity.stype.name
+objtype = entity.otype.name
 rschema = self._cw.vreg.schema[entity.rtype.name]
+# note: do not access schema rdef here, it may be added later by an
+# operation
 newvalues = {}
-for prop in RelationDefinitionSchema.rproperty_defs(desttype):
+for prop in RelationDefinitionSchema.rproperty_defs(objtype):
 if prop == 'constraints':
 continue
 if prop == 'order':
-prop = 'ordernum'
+attr = 'ordernum'
-if prop in entity.edited_attributes:
+else:
-old, new = hook.entity_oldnewvalue(entity, prop)
+attr = prop
+if attr in entity.edited_attributes:
+old, new = hook.entity_oldnewvalue(entity, attr)
 if old != new:
-newvalues[prop] = entity[prop]
+newvalues[prop] = new
 if newvalues:
-subjtype = entity.stype.name
+RDefUpdateOp(self._cw, rschema=rschema, rdefkey=(subjtype, objtype),
-MemSchemaRDefUpdate(self._cw, kobj=(subjtype, desttype),
+values=newvalues)
-rschema=rschema, values=newvalues)
-SourceDbRDefUpdate(self._cw, kobj=(subjtype, desttype),
-rschema=rschema, values=newvalues)
 # constraints synchronization hooks ############################################
 class AfterAddCWConstraintHook(SyncSchemaHook):
 __regid__ = 'syncaddcwconstraint'
 __select__ = SyncSchemaHook.__select__ & is_instance('CWConstraint')
 events = ('after_add_entity', 'after_update_entity')
 def __call__(self):
-MemSchemaCWConstraintAdd(self._cw, entity=self.entity)
+CWConstraintAddOp(self._cw, entity=self.entity)
-SourceDbCWConstraintAdd(self._cw, entity=self.entity)
 class AfterAddConstrainedByHook(SyncSchemaHook):
 __regid__ = 'syncdelconstrainedby'
 __select__ = SyncSchemaHook.__select__ & hook.match_rtype('constrained_by')
 try:
 cstr = rdef.constraint_by_type(entity.type)
 except IndexError:
 self._cw.critical('constraint type no more accessible')
 else:
-SourceDbCWConstraintDel(self._cw, rdef=rdef, cstr=cstr)
+CWConstraintDelOp(self._cw, rdef=rdef, oldcstr=cstr)
-MemSchemaCWConstraintDel(self._cw, rdef=rdef, cstr=cstr)
 # permissions synchronization hooks ############################################
 class AfterAddPermissionHook(SyncSchemaHook):

changeset 5891	99024ad59223
parent 5881	57387070f612
child 6002	0ce7052ce30b