cubicweb: comparison server/schemahooks.py

equal deleted inserted replaced

-:672acc730ce5
+:d628defebc17
 from cubicweb.server import schemaserial as ss
 from cubicweb.server.sqlutils import SQL_PREFIX
 from cubicweb.server.pool import Operation, SingleLastOperation, PreCommitOperation
 from cubicweb.server.hookhelper import (entity_attr, entity_name,
 check_internal_entity)
 # core entity and relation types which can't be removed
 CORE_ETYPES = list(BASE_TYPES) + ['CWEType', 'CWRType', 'CWUser', 'CWGroup',
 'CWConstraint', 'CWAttribute', 'CWRelation']
 CORE_RTYPES = ['eid', 'creation_date', 'modification_date',
 'login', 'upassword', 'name',
 try:
 session.system_sql(str('ALTER TABLE %s ADD COLUMN %s integer'
 % (table, column)))
 session.info('added column %s to table %s', column, table)
 except:
 # 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',
 table, column)
 # create index before alter table which may expectingly fail during test
 # (sqlite) while index creation should never fail (test for index existence
 # once Operation.__init__ has been called, event may be triggered, so
 # do this last !
 Operation.__init__(self, session, **kwargs)
 # every schema operation is triggering a schema update
 UpdateSchemaOp(session)
 class EarlySchemaOperation(SchemaOperation):
 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, EarlySchemaOperation):
 return i
 return i + 1
 class UpdateSchemaOp(SingleLastOperation):
 """the update schema operation:
 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):
 self.repo = session.repo
 SingleLastOperation.__init__(self, session)
 def commit_event(self):
 self.repo.set_schema(self.repo.schema)
 class DropTableOp(PreCommitOperation):
 """actually remove a database from the application's schema"""
 table = None # make pylint happy
 def precommit_event(self):
 dropped = self.session.query_data('droppedtables',
 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)
 class DropColumnOp(PreCommitOperation):
 """actually remove the attribut's column from entity table in the system
 database
 """
 table = column = None # make pylint happy
 % (table, column))
 self.info('dropped column %s from table %s', column, table)
 except Exception, ex:
 # not supported by sqlite for instance
 self.error('error while altering table %s: %s', table, ex)
 # deletion ####################################################################
 class DeleteCWETypeOp(SchemaOperation):
 """actually remove the entity type from the application's schema"""
 def commit_event(self):
 try:
 # del_entity_type also removes entity's relations
 self.schema.del_entity_type(self.kobj)
 except KeyError:
 def after_del_eetype(session, eid):
 # workflow cleanup
 session.execute('DELETE State X WHERE NOT X state_of Y')
 session.execute('DELETE Transition X WHERE NOT X transition_of Y')
 class DeleteCWRTypeOp(SchemaOperation):
 """actually remove the relation type from the application's schema"""
 def commit_event(self):
 try:
 self.schema.del_relation_type(self.kobj)
 except KeyError:
 # s/o entity type have already been deleted
 {'x': eid})
 session.execute('DELETE CWRelation X WHERE X relation_type Y, Y eid %(x)s',
 {'x': eid})
 DeleteCWRTypeOp(session, name)
 class DelErdefOp(SchemaOperation):
 """actually remove the relation definition from the application's schema"""
 def commit_event(self):
 subjtype, rtype, objtype = self.kobj
 try:
 self.schema.del_relation_def(subjtype, rtype, objtype)
 except KeyError:
 # relation type may have been already deleted
 pass
 def after_del_relation_type(session, rdefeid, rtype, rteid):
 """before deleting a CWAttribute or CWRelation entity:
 * if this is a final or inlined relation definition, instantiate an
 operation to drop necessary column, else if this is the last instance
 of a non final relation, instantiate an operation to drop necessary
 'R eid %%(x)s' % rdeftype, {'x': rteid})
 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.is_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': rteid, 'name': str(subjschema)})
 if rset[0][0] == 0 and not subjschema.eid in pendings:
 # if this is the last instance, drop associated relation type
 if lastrel and not rteid in pendings:
 execute('DELETE CWRType X WHERE X eid %(x)s', {'x': rteid}, 'x')
 DelErdefOp(session, (subjschema, rschema, objschema))
 # addition ####################################################################
 class AddCWETypeOp(EarlySchemaOperation):
 """actually add the entity type to the application's schema"""
 eid = None # make pylint happy
 def commit_event(self):
 eschema = self.schema.add_entity_type(self.kobj)
 eschema.eid = self.eid
 def before_add_eetype(session, entity):
 """before adding a CWEType entity:
 * check that we are not using an existing entity type,
 """
 name = entity['name']
 for rql, kwargs in relrqls:
 session.execute(rql, kwargs)
 class AddCWRTypeOp(EarlySchemaOperation):
 """actually add the relation type to the application's schema"""
 eid = None # make pylint happy
 def commit_event(self):
 rschema = self.schema.add_relation_type(self.kobj)
 rschema.set_default_groups()
 rschema.eid = self.eid
 def before_add_ertype(session, entity):
 """before adding a CWRType entity:
 * check that we are not using an existing relation type,
 * register an operation to add the relation type to the application's
 schema on commit
 We don't know yeat this point if a table is necessary
 """
 name = entity['name']
 if name in session.repo.schema.relations():
 raise RepositoryError('a relation type %s already exists' % name)
 def after_add_ertype(session, entity):
 """after a CWRType entity has been added:
 * register an operation to add the relation type to the application's
 schema on commit
 We don't know yeat this point if a table is necessary
 class AddErdefOp(EarlySchemaOperation):
 """actually add the attribute relation definition to the application's
 schema
 """
 def commit_event(self):
 self.schema.add_relation_def(self.kobj)
 TYPE_CONVERTER = {
 'Boolean': bool,
 'Int': int,
 'Float': float,
 'Password': str,
 'String': unicode,
 'Date' : unicode,
 'Datetime' : unicode,
 'Time' : unicode,
 }
 """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
 application's schema on commit
 constraints are handled by specific hooks
 """
 entity = None # make pylint happy
 def precommit_event(self):
 session = self.session
 entity = None # make pylint happy
 def precommit_event(self):
 session = self.session
 entity = self.entity
 fromentity = entity.from_entity[0]
 relationtype = entity.relation_type[0]
 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, rtype = str(fromentity.name), str(relationtype.name)
 obj = str(entity.to_entity[0].name)
 card = entity.get('cardinality')
 # create the necessary table
 for sql in tablesql.split(';'):
 if sql.strip():
 self.session.system_sql(sql)
 session.add_query_data('createdtables', rtype)
 def after_add_enfrdef(session, entity):
 AddCWRelationPreCommitOp(session, entity=entity)
 # update ######################################################################
 self.info('renamed table %s to %s', self.oldname, self.newname)
 sqlexec('UPDATE entities SET type=%s WHERE type=%s',
 (self.newname, self.oldname))
 sqlexec('UPDATE deleted_entities SET type=%s WHERE type=%s',
 (self.newname, self.oldname))
 def commit_event(self):
 self.session.repo.schema.rename_entity_type(self.oldname, self.newname)
 class UpdateRdefOp(SchemaOperation):
 column = SQL_PREFIX + rtype
 if self.values['indexed']:
 sysource.create_index(self.session, table, column)
 else:
 sysource.drop_index(self.session, table, column)
 def commit_event(self):
 # structure should be clean, not need to remove entity's relations
 # at this point
 self.rschema._rproperties[self.kobj].update(self.values)
 def after_update_erdef(session, entity):
 desttype = entity.to_entity[0].name
 rschema = session.repo.schema[entity.relation_type[0].name]
 newvalues = {}
 for prop in rschema.rproperty_defs(desttype):
 UpdateRdefOp(session, (subjtype, desttype), rschema=rschema,
 values=newvalues)
 class UpdateRtypeOp(SchemaOperation):
 """actually update some properties of a relation definition"""
 rschema = values = entity = None # make pylint happy
 def precommit_event(self):
 session = self.session
 rschema = self.rschema
 DropColumnOp(session, table=SQL_PREFIX + str(etype),
 column=SQL_PREFIX + rtype)
 else:
 for etype in rschema.subjects():
 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
 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 '
 #        'WHERE %(etype)s.eid=%(rtype)s_relation.eid_from'
 #        % locals())
 def commit_event(self):
 # structure should be clean, not need to remove entity's relations
 # at this point
 self.rschema.__dict__.update(self.values)
 def after_update_ertype(session, entity):
 rschema = session.repo.schema.rschema(entity.name)
 newvalues = {}
 for prop in ('meta', 'symetric', 'inlined'):
 if prop in entity:
 from cubicweb.schema import CONSTRAINTS
 class ConstraintOp(SchemaOperation):
 """actually update constraint of a relation definition"""
 entity = None # make pylint happy
 def prepare_constraints(self, rtype, subjtype, objtype):
 constraints = rtype.rproperty(subjtype, objtype, 'constraints')
 self.constraints = list(constraints)
 rtype.set_rproperty(subjtype, objtype, 'constraints', self.constraints)
 return self.constraints
 def precommit_event(self):
 rdef = self.entity.reverse_constrained_by[0]
 session = self.session
 # when the relation is added in the same transaction, the constraint object
 # is created by AddEN?FRDefPreCommitOp, there is nothing to do here
 if rdef.eid in session.query_data('neweids', ()):
 self.cancelled = True
 return
 self.cancelled = False
 schema = session.repo.schema
 subjtype, rtype, objtype = schema.schema_by_eid(rdef.eid)
 self.prepare_constraints(rtype, subjtype, objtype)
 cstrtype = self.entity.type
 # not supported by sqlite for instance
 self.error('error while altering table %s: %s', table, ex)
 elif cstrtype == 'UniqueConstraint':
 session.pool.source('system').create_index(
 self.session, table, column, unique=True)
 def commit_event(self):
 if self.cancelled:
 return
 # in-place removing
 if not self.cstr is None:
 class DelConstraintOp(ConstraintOp):
 """actually remove a constraint of a relation definition"""
 rtype = subjtype = objtype = None # make pylint happy
 def precommit_event(self):
 self.prepare_constraints(self.rtype, self.subjtype, self.objtype)
 cstrtype = self.cstr.type()
 table = SQL_PREFIX + str(self.subjtype)
 column = SQL_PREFIX + str(self.rtype)
 # alter the physical schema on size/unique constraint changes
 if cstrtype == 'SizeConstraint':
 try:
 self.session.system_sql('ALTER TABLE %s ALTER COLUMN %s TYPE TEXT'
 % (table, column))
 self.info('altered column %s of table %s: now TEXT',
 column, table)
 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)
 def commit_event(self):
 self.constraints.remove(self.cstr)
 def before_delete_constrained_by(session, fromeid, rtype, toeid):
 def after_add_constrained_by(session, fromeid, rtype, toeid):
 if fromeid in session.query_data('neweids', ()):
 session.add_query_data(fromeid, toeid)
 # schema permissions synchronization ##########################################
 class PermissionOp(Operation):
 """base class to synchronize schema permission definitions"""
 def __init__(self, session, perm, etype_eid):
 """synchronize schema when a *_permission relation has been added on a group
 """
 def __init__(self, session, perm, etype_eid, group_eid):
 self.group = entity_name(session, group_eid)
 PermissionOp.__init__(self, session, perm, etype_eid)
 def commit_event(self):
 """the observed connections pool has been commited"""
 try:
 erschema = self.schema[self.name]
 except KeyError:
 # duh, schema not found, log error and skip operation
 self.error('no schema for %s', self.name)
 return
 groups = list(erschema.get_groups(self.perm))
 try:
 groups.index(self.group)
 self.warning('group %s already have permission %s on %s',
 self.group, self.perm, erschema.type)
 except ValueError:
 groups.append(self.group)
 expression
 """
 def __init__(self, session, perm, etype_eid, expression):
 self.expr = expression
 PermissionOp.__init__(self, session, perm, etype_eid)
 def commit_event(self):
 """the observed connections pool has been commited"""
 try:
 erschema = self.schema[self.name]
 except KeyError:
 AddGroupPermissionOp(session, perm, subject, object)
 else: # RQLExpression
 expr = session.execute('Any EXPR WHERE X eid %(x)s, X expression EXPR',
 {'x': object}, 'x')[0][0]
 AddRQLExpressionPermissionOp(session, perm, subject, expr)
 class DelGroupPermissionOp(AddGroupPermissionOp):
 """synchronize schema when a *_permission relation has been deleted from a group"""
 def commit_event(self):
 """the observed connections pool has been commited"""
 try:
 erschema = self.schema[self.name]
 except KeyError:
 # duh, schema not found, log error and skip operation
 self.error('no schema for %s', self.name)
 return
 groups = list(erschema.get_groups(self.perm))
 try:
 groups.remove(self.group)
 erschema.set_groups(self.perm, groups)
 except ValueError:
 self.error('can\'t remove permission %s on %s to group %s',
 self.perm, erschema.type, self.group)
 class DelRQLExpressionPermissionOp(AddRQLExpressionPermissionOp):
 """synchronize schema when a *_permission relation has been deleted from an rql expression"""
 def commit_event(self):
 """the observed connections pool has been commited"""
 try:
 erschema = self.schema[self.name]
 except KeyError:
 self.error('can\'t remove permission %s on %s for expression %s',
 self.perm, erschema.type, self.expr)
 return
 erschema.set_rqlexprs(self.perm, rqlexprs)
 def before_del_permission(session, subject, rtype, object):
 """delete entity/relation *_permission, need to update schema
 skip the operation if the related type is being deleted
 """
 hm.register_hook(before_del_eetype, 'before_delete_entity', 'CWEType')
 hm.register_hook(after_del_eetype, 'after_delete_entity', 'CWEType')
 hm.register_hook(before_del_ertype, 'before_delete_entity', 'CWRType')
 hm.register_hook(after_del_relation_type, 'after_delete_relation', 'relation_type')
 hm.register_hook(rebuild_infered_relations, 'after_add_relation', 'specializes')
 hm.register_hook(rebuild_infered_relations, 'after_delete_relation', 'specializes')
 # constraints synchronization hooks
 hm.register_hook(after_add_econstraint, 'after_add_entity', 'CWConstraint')
 hm.register_hook(after_update_econstraint, 'after_update_entity', 'CWConstraint')
 hm.register_hook(before_delete_constrained_by, 'before_delete_relation', 'constrained_by')
 hm.register_hook(after_add_constrained_by, 'after_add_relation', 'constrained_by')

branch	tls-sprint
changeset 1802	d628defebc17
parent 1398	5fe84a5f7035
child 1977	606923dff11b
child 1981	e6eed4324357