cubicweb: comparison cubicweb/hooks/syncschema.py

equal deleted inserted replaced

-:9c2fbb872e91
+:5e5e224239c3
 from cubicweb.server.sqlutils import SQL_PREFIX
 from cubicweb.hooks.synccomputed import RecomputeAttributeOperation
 # 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'))
+('CWUser', 'CWGroup', 'login', 'upassword', 'name', 'in_group'))
 def get_constraints(cnx, entity):
 constraints = []
 for cstreid in cnx.transaction_data.get(entity.eid, ()):
 return
 createdattrs.add(attrkey)
 table = SQL_PREFIX + etype
 column = SQL_PREFIX + rtype
 try:
-cnx.system_sql(str('ALTER TABLE %s ADD %s integer REFERENCES entities (eid)' % (table, column)),
+cnx.system_sql(str('ALTER TABLE %s ADD %s integer REFERENCES entities (eid)'
+% (table, column)),
 rollback_on_failure=False)
 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
 * create the necessary table
 * set creation_date and modification_date by creating the necessary
 CWAttribute entities
 * add <meta rtype> relation by creating the necessary CWRelation entity
 """
-entity = None # make pylint happy
+entity = None  # make pylint happy
 def precommit_event(self):
 cnx = self.cnx
 entity = self.entity
 schema = cnx.vreg.schema
 op.add_data(objtype)
 else:
 op.add_data(objtype)
 op.add_data(subjtype)
 # update the in-memory schema first
-self.oldvalues = dict( (attr, getattr(rschema, attr)) for attr in self.values)
+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 'inlined' not in self.values:
-return # nothing to do
+return  # nothing to do
 inlined = self.values['inlined']
 # check in-lining is possible when inlined
 if inlined:
 self.entity.check_inlined_allowed()
 # inlined changed, make necessary physical changes!
 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 cnx.transaction_data.get('createdtables', ()):
+if rschema.type not in cnx.transaction_data.get('createdtables', ()):
 # create the necessary table
 for sql in y2sql.rschema2sql(rschema):
 sqlexec(sql)
 cnx.transaction_data.setdefault('createdtables', []).append(
 rschema.type)
 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 cnx.repo.system_source.dbhelper.alter_column_support:
 for etype in rschema.subjects():
 DropColumn.get_instance(cnx).add_data((str(etype), rtype))
 else:
 for etype in rschema.subjects():
 try:
 # XXX revert changes on database
 class CWComputedRTypeUpdateOp(MemSchemaOperation):
 """actually update some properties of a computed relation definition"""
-rschema = entity = rule = None # make pylint happy
+rschema = entity = rule = None  # make pylint happy
 old_rule = None
 def precommit_event(self):
 # update the in-memory schema first
 self.old_rule = self.rschema.rule
 * register an operation to add the relation definition to the
 instance's schema on commit
 constraints are handled by specific hooks
 """
-entity = None # make pylint happy
+entity = None  # make pylint happy
 def init_rdef(self, **kwargs):
 entity = self.entity
 fromentity = entity.stype
 rdefdef = self.rdefdef = ybo.RelationDefinition(
 # final relations are not infered, propagate
 schema = cnx.vreg.schema
 try:
 eschema = schema.eschema(rdefdef.subject)
 except KeyError:
-return # entity type currently being added
+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(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)
 cnx.system_sql('UPDATE %s SET %s=%%(default)s' % (table, column),
 {'default': default})
 # if attribute is computed, compute it
 if getattr(entity, 'formula', None):
 # add rtype attribute for RelationDefinitionSchema api compat, this
 # is what RecomputeAttributeOperation expect
 rdefdef.rtype = rdefdef.name
 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
+entity = None  # make pylint happy
 def precommit_event(self):
 cnx = self.cnx
 entity = self.entity
 # update the in-memory schema first
 # XXX revertprecommit_event
 class RDefDelOp(MemSchemaOperation):
 """an actual relation has been removed"""
-rdef = None # make pylint happy
+rdef = None  # make pylint happy
 def precommit_event(self):
 cnx = self.cnx
 rdef = self.rdef
 rschema = rdef.rtype
 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
+rschema = rdefkey = values = None  # make pylint happy
 rdef = oldvalues = None
 indexed_changed = null_allowed_changed = False
 def precommit_event(self):
 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)
+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 = cnx.repo.system_source
 if 'indexed' in self.values:
 syssource.update_rdef_indexed(cnx, rdef)
 self.indexed_changed = True
-if 'cardinality' in self.values and rdef.rtype.final \
+if ('cardinality' in self.values and rdef.rtype.final
-and self.values['cardinality'][0] != self.oldvalues['cardinality'][0]:
+and self.values['cardinality'][0] != self.oldvalues['cardinality'][0]):
 syssource.update_rdef_null_allowed(self.cnx, rdef)
 self.null_allowed_changed = True
 if 'fulltextindexed' in self.values:
 UpdateFTIndexOp.get_instance(cnx).add_data(rdef.subject)
 if 'formula' in self.values:
 rdef.constraints = list(rdef.constraints)
 class CWConstraintDelOp(MemSchemaOperation):
 """actually remove a constraint of a relation definition"""
-rdef = oldcstr = newcstr = None # make pylint happy
+rdef = oldcstr = newcstr = None  # make pylint happy
 size_cstr_changed = unique_changed = False
 def precommit_event(self):
 cnx = self.cnx
 rdef = 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
+entity = None  # make pylint happy
 def precommit_event(self):
 cnx = self.cnx
 rdefentity = self.entity.reverse_constrained_by[0]
 rdef = self.rdef = cnx.vreg.schema.schema_by_eid(rdefentity.eid)
 cnx.system_sql('ALTER TABLE %s%s ADD CONSTRAINT %s CHECK(%s)' %
 (SQL_PREFIX, rdef.subject, cstrname, check))
 class CWUniqueTogetherConstraintAddOp(MemSchemaOperation):
-entity = None # make pylint happy
+entity = None  # make pylint happy
 def precommit_event(self):
 cnx = self.cnx
 prefix = SQL_PREFIX
 entity = self.entity
 attrs = [r.name for r in entity.relations]
 eschema._unique_together.append(attrs)
 class CWUniqueTogetherConstraintDelOp(MemSchemaOperation):
-entity = cstrname = None # for pylint
+entity = cstrname = None  # make pylint happy
-cols = () # for pylint
+cols = ()  # make pylint happy
 def insert_index(self):
 # We need to run before CWConstraintDelOp: if a size constraint is
 # removed and the column is part of a unique_together constraint, we
 # remove the unique_together index before changing the column's type.
 # operations for in-memory schema synchronization  #############################
 class MemSchemaCWETypeDel(MemSchemaOperation):
 """actually remove the entity type from the instance's schema"""
-etype = None # make pylint happy
+etype = None  # make pylint happy
 def postcommit_event(self):
 # del_entity_type also removes entity's relations
 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
+rtypedef = None  # make pylint happy
 def precommit_event(self):
 self.cnx.vreg.schema.add_relation_type(self.rtypedef)
 def revertprecommit_event(self):
 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
+rtype = None  # make pylint happy
 def postcommit_event(self):
 try:
 self.cnx.vreg.schema.del_relation_type(self.rtype)
 except KeyError:
 class MemSchemaPermissionAdd(MemSchemaOperation):
 """synchronize schema when a *_permission relation has been added on a group
 """
-eid = action = group_eid = expr = None # make pylint happy
+eid = action = group_eid = expr = None  # make pylint happy
 def precommit_event(self):
 """the observed connections.cnxset has been commited"""
 try:
 erschema = self.cnx.vreg.schema.schema_by_eid(self.eid)
 # XXX revertprecommit_event
 class MemSchemaSpecializesAdd(MemSchemaOperation):
-etypeeid = parentetypeeid = None # make pylint happy
+etypeeid = parentetypeeid = None  # make pylint happy
 def precommit_event(self):
 eschema = self.cnx.vreg.schema.schema_by_eid(self.etypeeid)
 parenteschema = self.cnx.vreg.schema.schema_by_eid(self.parentetypeeid)
 eschema._specialized_type = parenteschema.type
 # XXX revertprecommit_event
 class MemSchemaSpecializesDel(MemSchemaOperation):
-etypeeid = parentetypeeid = None # make pylint happy
+etypeeid = parentetypeeid = None  # make pylint happy
 def precommit_event(self):
 try:
 eschema = self.cnx.vreg.schema.schema_by_eid(self.etypeeid)
 parenteschema = self.cnx.vreg.schema.schema_by_eid(self.parentetypeeid)
 name = self.entity.name
 if name in CORE_TYPES:
 raise validation_error(self.entity, {None: _("can't be deleted")})
 # 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, rtype=name)
 class AfterAddCWComputedRTypeHook(SyncSchemaHook):
 """after a CWComputedRType entity has been added:
 return
 subjschema, rschema, objschema = rdef.as_triple()
 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))
 RDefDelOp(cnx, rdef=rdef)
 # CWComputedRType hooks #######################################################
 except (KeyError, IndexError):
 self._cw.critical('constraint type no more accessible')
 else:
 CWConstraintDelOp(self._cw, rdef=rdef, oldcstr=cstr)
 # unique_together constraints
 # XXX: use setoperations and before_add_relation here (on constraint_of and relations)
 class AfterAddCWUniqueTogetherConstraintHook(SyncSchemaHook):
 __regid__ = 'syncadd_cwuniquetogether_constraint'
 __select__ = SyncSchemaHook.__select__ & is_instance('CWUniqueTogetherConstraint')
 def __call__(self):
 action = self.rtype.split('_', 1)[0]
 if self._cw.entity_metas(self.eidto)['type'] == 'CWGroup':
 MemSchemaPermissionAdd(self._cw, action=action, eid=self.eidfrom,
 group_eid=self.eidto)
-else: # RQLExpression
+else:  # RQLExpression
 expr = self._cw.entity_from_eid(self.eidto).expression
 MemSchemaPermissionAdd(self._cw, action=action, eid=self.eidfrom,
 expr=expr)
 return
 action = self.rtype.split('_', 1)[0]
 if self._cw.entity_metas(self.eidto)['type'] == 'CWGroup':
 MemSchemaPermissionDel(self._cw, action=action, eid=self.eidfrom,
 group_eid=self.eidto)
-else: # RQLExpression
+else:  # RQLExpression
 expr = self._cw.entity_from_eid(self.eidto).expression
 MemSchemaPermissionDel(self._cw, action=action, eid=self.eidfrom,
 expr=expr)
 class UpdateFTIndexOp(hook.DataOperationMixIn, hook.SingleLastOperation):
 """operation to update full text indexation of entity whose schema change
 if to_reindex:
 # Transaction has already been committed
 cnx.cnxset.commit()
 # specializes synchronization hooks ############################################
 class AfterAddSpecializesHook(SyncSchemaHook):
 __regid__ = 'syncaddspecializes'
 __select__ = SyncSchemaHook.__select__ & hook.match_rtype('specializes')
 events = ('after_add_relation',)

changeset 11417	5e5e224239c3
parent 11416	9c2fbb872e91
child 11763	39df042f4ab4