cubicweb: comparison server/sources/native.py

equal deleted inserted replaced

-:29450466273a
+:ca853478aaa8
 "is already linked using this relation.")
 % {'role': neg_role(role),
 'rtype': rdef.rtype,
 'eid': tentity.eid})
-def _undo_rel_info(session, subj, rtype, obj):
+def _undo_rel_info(cnx, subj, rtype, obj):
 entities = []
 for role, eid in (('subject', subj), ('object', obj)):
 try:
-entities.append(session.entity_from_eid(eid))
+entities.append(cnx.entity_from_eid(eid))
 except UnknownEid:
-raise _UndoException(session._(
+raise _UndoException(cnx._(
 "Can't restore relation %(rtype)s, %(role)s entity %(eid)s"
 " doesn't exist anymore.")
-% {'role': session._(role),
+% {'role': cnx._(role),
-'rtype': session._(rtype),
+'rtype': cnx._(rtype),
 'eid': eid})
 sentity, oentity = entities
 try:
-rschema = session.vreg.schema.rschema(rtype)
+rschema = cnx.vreg.schema.rschema(rtype)
 rdef = rschema.rdefs[(sentity.cw_etype, oentity.cw_etype)]
 except KeyError:
-raise _UndoException(session._(
+raise _UndoException(cnx._(
 "Can't restore relation %(rtype)s between %(subj)s and "
 "%(obj)s, that relation does not exists anymore in the "
 "schema.")
-% {'rtype': session._(rtype),
+% {'rtype': cnx._(rtype),
 'subj': subj,
 'obj': obj})
 return sentity, oentity, rdef
-def _undo_has_later_transaction(session, eid):
+def _undo_has_later_transaction(cnx, eid):
-return session.system_sql('''\
+return cnx.system_sql('''\
 SELECT T.tx_uuid FROM transactions AS TREF, transactions AS T
 WHERE TREF.tx_uuid='%(txuuid)s' AND T.tx_uuid!='%(txuuid)s'
 AND T.tx_time>=TREF.tx_time
 AND (EXISTS(SELECT 1 FROM tx_entity_actions AS TEA
 WHERE TEA.tx_uuid=T.tx_uuid AND TEA.eid=%(eid)s)
 OR EXISTS(SELECT 1 FROM tx_relation_actions as TRA
 WHERE TRA.tx_uuid=T.tx_uuid AND (
 TRA.eid_from=%(eid)s OR TRA.eid_to=%(eid)s))
-)''' % {'txuuid': session.transaction_data['undoing_uuid'],
+)''' % {'txuuid': cnx.transaction_data['undoing_uuid'],
 'eid': eid}).fetchone()
 class DefaultEidGenerator(object):
 __slots__ = ('source', 'cnx', 'lock')
 def close(self):
 if self.cnx:
 self.cnx.close()
 self.cnx = None
-def create_eid(self, _session, count=1):
+def create_eid(self, _cnx, count=1):
 # lock needed to prevent 'Connection is busy with results for another
 # command (0)' errors with SQLServer
 assert count > 0
 with self.lock:
 return self._create_eid(count)
 self.lock = Lock()
 def close(self):
 pass
-def create_eid(self, session, count=1):
+def create_eid(self, cnx, count=1):
 assert count > 0
 source = self.source
 with self.lock:
 for sql in source.dbhelper.sqls_increment_numrange('entities_id_seq', count):
-cursor = source.doexec(session, sql)
+cursor = source.doexec(cnx, sql)
 return cursor.fetchone()[0]
 class NativeSQLSource(SQLAdapterMixIn, AbstractSource):
 """adapter for source using the native cubicweb schema (see below)
 """clear potential caches for the given eid"""
 self._cache.pop('Any X WHERE X eid %s, X is %s' % (eid, etype), None)
 self._cache.pop('Any X WHERE X eid %s' % eid, None)
 self._cache.pop('Any %s' % eid, None)
-def sqlexec(self, session, sql, args=None):
+def sqlexec(self, cnx, sql, args=None):
 """execute the query and return its result"""
-return self.process_result(self.doexec(session, sql, args))
+return self.process_result(self.doexec(cnx, sql, args))
 def init_creating(self, cnxset=None):
 # check full text index availibility
 if self.do_fti:
 if cnxset is None:
 return authentifier.authenticate(cnx, login, **kwargs)
 except AuthenticationError:
 continue
 raise AuthenticationError()
-def syntax_tree_search(self, session, union, args=None, cachekey=None,
+def syntax_tree_search(self, cnx, union, args=None, cachekey=None,
 varmap=None):
 """return result from this source for a rql query (actually from
 a rql syntax tree and a solution dictionary mapping each used
 variable to a possible type). If cachekey is given, the query
 necessary to fetch the results (but not the results themselves)
 sql, qargs, cbs = self._rql_sqlgen.generate(union, args, varmap)
 self._cache[cachekey] = sql, qargs, cbs
 args = self.merge_args(args, qargs)
 assert isinstance(sql, basestring), repr(sql)
 try:
-cursor = self.doexec(session, sql, args)
+cursor = self.doexec(cnx, sql, args)
 except (self.OperationalError, self.InterfaceError):
-if session.mode == 'write':
+if cnx.mode == 'write':
 # do not attempt to reconnect if there has been some write
 # during the transaction
 raise
 # FIXME: better detection of deconnection pb
 self.warning("trying to reconnect")
-session.cnxset.reconnect()
+cnx.cnxset.reconnect()
-cursor = self.doexec(session, sql, args)
+cursor = self.doexec(cnx, sql, args)
 except self.DbapiError as exc:
 # We get this one with pyodbc and SQL Server when connection was reset
-if exc.args[0] == '08S01' and session.mode != 'write':
+if exc.args[0] == '08S01' and cnx.mode != 'write':
 self.warning("trying to reconnect")
-session.cnxset.reconnect()
+cnx.cnxset.reconnect()
-cursor = self.doexec(session, sql, args)
+cursor = self.doexec(cnx, sql, args)
 else:
 raise
-results = self.process_result(cursor, cbs, session=session)
+results = self.process_result(cursor, cbs, session=cnx)
 assert dbg_results(results)
 return results
 @contextmanager
 def _storage_handler(self, entity, event):
 finally:
 # 3/ restore original values
 for entity, attr, value in restore_values:
 entity.cw_edited.edited_attribute(attr, value)
-def add_entity(self, session, entity):
+def add_entity(self, cnx, entity):
 """add a new entity to the source"""
 with self._storage_handler(entity, 'added'):
 attrs = self.preprocess_entity(entity)
 sql = self.sqlgen.insert(SQL_PREFIX + entity.cw_etype, attrs)
-self.doexec(session, sql, attrs)
+self.doexec(cnx, sql, attrs)
-if session.ertype_supports_undo(entity.cw_etype):
+if cnx.ertype_supports_undo(entity.cw_etype):
-self._record_tx_action(session, 'tx_entity_actions', 'C',
+self._record_tx_action(cnx, 'tx_entity_actions', 'C',
 etype=entity.cw_etype, eid=entity.eid)
-def update_entity(self, session, entity):
+def update_entity(self, cnx, entity):
 """replace an entity in the source"""
 with self._storage_handler(entity, 'updated'):
 attrs = self.preprocess_entity(entity)
-if session.ertype_supports_undo(entity.cw_etype):
+if cnx.ertype_supports_undo(entity.cw_etype):
-changes = self._save_attrs(session, entity, attrs)
+changes = self._save_attrs(cnx, entity, attrs)
-self._record_tx_action(session, 'tx_entity_actions', 'U',
+self._record_tx_action(cnx, 'tx_entity_actions', 'U',
 etype=entity.cw_etype, eid=entity.eid,
 changes=self._binary(dumps(changes)))
 sql = self.sqlgen.update(SQL_PREFIX + entity.cw_etype, attrs,
 ['cw_eid'])
-self.doexec(session, sql, attrs)
+self.doexec(cnx, sql, attrs)
-def delete_entity(self, session, entity):
+def delete_entity(self, cnx, entity):
 """delete an entity from the source"""
 with self._storage_handler(entity, 'deleted'):
-if session.ertype_supports_undo(entity.cw_etype):
+if cnx.ertype_supports_undo(entity.cw_etype):
 attrs = [SQL_PREFIX + r.type
 for r in entity.e_schema.subject_relations()
 if (r.final or r.inlined) and not r in VIRTUAL_RTYPES]
-changes = self._save_attrs(session, entity, attrs)
+changes = self._save_attrs(cnx, entity, attrs)
-self._record_tx_action(session, 'tx_entity_actions', 'D',
+self._record_tx_action(cnx, 'tx_entity_actions', 'D',
 etype=entity.cw_etype, eid=entity.eid,
 changes=self._binary(dumps(changes)))
 attrs = {'cw_eid': entity.eid}
 sql = self.sqlgen.delete(SQL_PREFIX + entity.cw_etype, attrs)
-self.doexec(session, sql, attrs)
+self.doexec(cnx, sql, attrs)
-def add_relation(self, session, subject, rtype, object, inlined=False):
+def add_relation(self, cnx, subject, rtype, object, inlined=False):
 """add a relation to the source"""
-self._add_relations(session,  rtype, [(subject, object)], inlined)
+self._add_relations(cnx,  rtype, [(subject, object)], inlined)
-if session.ertype_supports_undo(rtype):
+if cnx.ertype_supports_undo(rtype):
-self._record_tx_action(session, 'tx_relation_actions', 'A',
+self._record_tx_action(cnx, 'tx_relation_actions', 'A',
 eid_from=subject, rtype=rtype, eid_to=object)
-def add_relations(self, session,  rtype, subj_obj_list, inlined=False):
+def add_relations(self, cnx,  rtype, subj_obj_list, inlined=False):
 """add a relations to the source"""
-self._add_relations(session, rtype, subj_obj_list, inlined)
+self._add_relations(cnx, rtype, subj_obj_list, inlined)
-if session.ertype_supports_undo(rtype):
+if cnx.ertype_supports_undo(rtype):
 for subject, object in subj_obj_list:
-self._record_tx_action(session, 'tx_relation_actions', 'A',
+self._record_tx_action(cnx, 'tx_relation_actions', 'A',
 eid_from=subject, rtype=rtype, eid_to=object)
-def _add_relations(self, session, rtype, subj_obj_list, inlined=False):
+def _add_relations(self, cnx, rtype, subj_obj_list, inlined=False):
 """add a relation to the source"""
 sql = []
 if inlined is False:
 attrs = [{'eid_from': subject, 'eid_to': object}
 for subject, object in subj_obj_list]
 sql.append((self.sqlgen.insert('%s_relation' % rtype, attrs[0]), attrs))
 else: # used by data import
 etypes = {}
 for subject, object in subj_obj_list:
-etype = session.entity_metas(subject)['type']
+etype = cnx.entity_metas(subject)['type']
 if etype in etypes:
 etypes[etype].append((subject, object))
 else:
 etypes[etype] = [(subject, object)]
 for subj_etype, subj_obj_list in etypes.iteritems():
 for subject, object in subj_obj_list]
 sql.append((self.sqlgen.update(SQL_PREFIX + etype, attrs[0],
 ['cw_eid']),
 attrs))
 for statement, attrs in sql:
-self.doexecmany(session, statement, attrs)
+self.doexecmany(cnx, statement, attrs)
-def delete_relation(self, session, subject, rtype, object):
+def delete_relation(self, cnx, subject, rtype, object):
 """delete a relation from the source"""
 rschema = self.schema.rschema(rtype)
-self._delete_relation(session, subject, rtype, object, rschema.inlined)
+self._delete_relation(cnx, subject, rtype, object, rschema.inlined)
-if session.ertype_supports_undo(rtype):
+if cnx.ertype_supports_undo(rtype):
-self._record_tx_action(session, 'tx_relation_actions', 'R',
+self._record_tx_action(cnx, 'tx_relation_actions', 'R',
 eid_from=subject, rtype=rtype, eid_to=object)
-def _delete_relation(self, session, subject, rtype, object, inlined=False):
+def _delete_relation(self, cnx, subject, rtype, object, inlined=False):
 """delete a relation from the source"""
 if inlined:
-table = SQL_PREFIX + session.entity_metas(subject)['type']
+table = SQL_PREFIX + cnx.entity_metas(subject)['type']
 column = SQL_PREFIX + rtype
 sql = 'UPDATE %s SET %s=NULL WHERE %seid=%%(eid)s' % (table, column,
 SQL_PREFIX)
 attrs = {'eid' : subject}
 else:
 attrs = {'eid_from': subject, 'eid_to': object}
 sql = self.sqlgen.delete('%s_relation' % rtype, attrs)
-self.doexec(session, sql, attrs)
+self.doexec(cnx, sql, attrs)
-def doexec(self, session, query, args=None, rollback=True):
+def doexec(self, cnx, query, args=None, rollback=True):
 """Execute a query.
 it's a function just so that it shows up in profiling
 """
-cursor = session.cnxset.cu
+cursor = cnx.cnxset.cu
 if server.DEBUG & server.DBG_SQL:
-cnx = session.cnxset.cnx
+cnx = cnx.cnxset.cnx
 # getattr to get the actual connection if cnx is a CnxLoggingWrapper
 # instance
 print 'exec', query, args, getattr(cnx, '_cnx', cnx)
 try:
 # str(query) to avoid error if it's an unicode string
 # db schema
 self.critical("sql: %r\n args: %s\ndbms message: %r",
 query, args, ex.args[0])
 if rollback:
 try:
-session.cnxset.rollback()
+cnx.cnxset.rollback()
 if self.repo.config.mode != 'test':
 self.critical('transaction has been rolled back')
 except Exception as ex:
 pass
 if ex.__class__.__name__ == 'IntegrityError':
 # need string comparison because of various backends
 for arg in ex.args:
 # postgres, sqlserver
 mo = re.search("unique_[a-z0-9]{32}", arg)
 if mo is not None:
-raise UniqueTogetherError(session, cstrname=mo.group(0))
+raise UniqueTogetherError(cnx, cstrname=mo.group(0))
 # old sqlite
 mo = re.search('columns (.*) are not unique', arg)
 if mo is not None: # sqlite in use
 # we left chop the 'cw_' prefix of attribute names
 rtypes = [c.strip()[3:]
 for c in mo.group(1).split(',')]
-raise UniqueTogetherError(session, rtypes=rtypes)
+raise UniqueTogetherError(cnx, rtypes=rtypes)
 # sqlite after http://www.sqlite.org/cgi/src/info/c80e229dd9c1230a
 if arg.startswith('UNIQUE constraint failed:'):
 # message looks like: "UNIQUE constraint failed: foo.cw_bar, foo.cw_baz"
 # so drop the prefix, split on comma, drop the tablenames, and drop "cw_"
 columns = arg.split(':', 1)[1].split(',')
 rtypes = [c.split('.', 1)[1].strip()[3:] for c in columns]
-raise UniqueTogetherError(session, rtypes=rtypes)
+raise UniqueTogetherError(cnx, rtypes=rtypes)
 raise
 return cursor
-def doexecmany(self, session, query, args):
+def doexecmany(self, cnx, query, args):
 """Execute a query.
 it's a function just so that it shows up in profiling
 """
 if server.DEBUG & server.DBG_SQL:
 print 'execmany', query, 'with', len(args), 'arguments'
-cursor = session.cnxset.cu
+cursor = cnx.cnxset.cu
 try:
 # str(query) to avoid error if it's an unicode string
 cursor.executemany(str(query), args)
 except Exception as ex:
 if self.repo.config.mode != 'test':
 # during test we get those message when trying to alter sqlite
 # db schema
 self.critical("sql many: %r\n args: %s\ndbms message: %r",
 query, args, ex.args[0])
 try:
-session.cnxset.rollback()
+cnx.cnxset.rollback()
 if self.repo.config.mode != 'test':
 self.critical('transaction has been rolled back')
 except Exception:
 pass
 raise
 # short cut to method requiring advanced db helper usage ##################
-def update_rdef_column(self, session, rdef):
+def update_rdef_column(self, cnx, rdef):
 """update physical column for a relation definition (final or inlined)
 """
 table, column = rdef_table_column(rdef)
 coltype, allownull = rdef_physical_info(self.dbhelper, rdef)
 if not self.dbhelper.alter_column_support:
 self.error("backend can't alter %s.%s to %s%s", table, column, coltype,
 not allownull and 'NOT NULL' or '')
 return
-self.dbhelper.change_col_type(LogCursor(session.cnxset.cu),
+self.dbhelper.change_col_type(LogCursor(cnx.cnxset.cu),
 table, column, coltype, allownull)
 self.info('altered %s.%s: now %s%s', table, column, coltype,
 not allownull and 'NOT NULL' or '')
-def update_rdef_null_allowed(self, session, rdef):
+def update_rdef_null_allowed(self, cnx, rdef):
 """update NULL / NOT NULL of physical column for a relation definition
 (final or inlined)
 """
 if not self.dbhelper.alter_column_support:
 # not supported (and NOT NULL not set by yams in that case, so no
 # worry)
 return
 table, column = rdef_table_column(rdef)
 coltype, allownull = rdef_physical_info(self.dbhelper, rdef)
-self.dbhelper.set_null_allowed(LogCursor(session.cnxset.cu),
+self.dbhelper.set_null_allowed(LogCursor(cnx.cnxset.cu),
 table, column, coltype, allownull)
-def update_rdef_indexed(self, session, rdef):
+def update_rdef_indexed(self, cnx, rdef):
 table, column = rdef_table_column(rdef)
 if rdef.indexed:
-self.create_index(session, table, column)
+self.create_index(cnx, table, column)
 else:
-self.drop_index(session, table, column)
+self.drop_index(cnx, table, column)
-def update_rdef_unique(self, session, rdef):
+def update_rdef_unique(self, cnx, rdef):
 table, column = rdef_table_column(rdef)
 if rdef.constraint_by_type('UniqueConstraint'):
-self.create_index(session, table, column, unique=True)
+self.create_index(cnx, table, column, unique=True)
 else:
-self.drop_index(session, table, column, unique=True)
+self.drop_index(cnx, table, column, unique=True)
-def create_index(self, session, table, column, unique=False):
+def create_index(self, cnx, table, column, unique=False):
-cursor = LogCursor(session.cnxset.cu)
+cursor = LogCursor(cnx.cnxset.cu)
 self.dbhelper.create_index(cursor, table, column, unique)
-def drop_index(self, session, table, column, unique=False):
+def drop_index(self, cnx, table, column, unique=False):
-cursor = LogCursor(session.cnxset.cu)
+cursor = LogCursor(cnx.cnxset.cu)
 self.dbhelper.drop_index(cursor, table, column, unique)
 # system source interface #################################################
-def _eid_type_source(self, session, eid, sql, _retry=True):
+def _eid_type_source(self, cnx, eid, sql, _retry=True):
 try:
-res = self.doexec(session, sql).fetchone()
+res = self.doexec(cnx, sql).fetchone()
 if res is not None:
 return res
 except (self.OperationalError, self.InterfaceError):
-if session.mode == 'read' and _retry:
+if cnx.mode == 'read' and _retry:
 self.warning("trying to reconnect (eid_type_source())")
-session.cnxset.reconnect()
+cnx.cnxset.reconnect()
-return self._eid_type_source(session, eid, sql, _retry=False)
+return self._eid_type_source(cnx, eid, sql, _retry=False)
 except Exception:
-assert session.cnxset, 'session has no connections set'
+assert cnx.cnxset, 'connection has no connections set'
 self.exception('failed to query entities table for eid %s', eid)
 raise UnknownEid(eid)
-def eid_type_source(self, session, eid): # pylint: disable=E0202
+def eid_type_source(self, cnx, eid): # pylint: disable=E0202
 """return a tuple (type, source, extid) for the entity with id <eid>"""
 sql = 'SELECT type, extid, asource FROM entities WHERE eid=%s' % eid
-res = self._eid_type_source(session, eid, sql)
+res = self._eid_type_source(cnx, eid, sql)
 if res[-2] is not None:
 if not isinstance(res, list):
 res = list(res)
 res[-2] = b64decode(res[-2])
 return res
-def eid_type_source_pre_131(self, session, eid):
+def eid_type_source_pre_131(self, cnx, eid):
 """return a tuple (type, source, extid) for the entity with id <eid>"""
 sql = 'SELECT type, extid FROM entities WHERE eid=%s' % eid
-res = self._eid_type_source(session, eid, sql)
+res = self._eid_type_source(cnx, eid, sql)
 if not isinstance(res, list):
 res = list(res)
 if res[-1] is not None:
 res[-1] = b64decode(res[-1])
 res.append(res[1])
 return res
-def extid2eid(self, session, extid):
+def extid2eid(self, cnx, extid):
 """get eid from an external id. Return None if no record found."""
 assert isinstance(extid, str)
-cursor = self.doexec(session,
+cursor = self.doexec(cnx,
 'SELECT eid FROM entities WHERE extid=%(x)s',
 {'x': b64encode(extid)})
 # XXX testing rowcount cause strange bug with sqlite, results are there
 #     but rowcount is 0
 #if cursor.rowcount > 0:
 return result[0]
 except Exception:
 pass
 return None
-def _handle_is_relation_sql(self, session, sql, attrs):
+def _handle_is_relation_sql(self, cnx, sql, attrs):
 """ Handler for specific is_relation sql that may be
 overwritten in some stores"""
-self.doexec(session, sql % attrs)
+self.doexec(cnx, sql % attrs)
 _handle_insert_entity_sql = doexec
 _handle_is_instance_of_sql = _handle_source_relation_sql = _handle_is_relation_sql
-def add_info(self, session, entity, source, extid, complete):
+def add_info(self, cnx, entity, source, extid, complete):
 """add type and source info for an eid into the system table"""
-with session.ensure_cnx_set:
+with cnx.ensure_cnx_set:
 # begin by inserting eid/type/source/extid into the entities table
 if extid is not None:
 assert isinstance(extid, str)
 extid = b64encode(extid)
 attrs = {'type': entity.cw_etype, 'eid': entity.eid, 'extid': extid,
 'asource': source.uri}
-self._handle_insert_entity_sql(session, self.sqlgen.insert('entities', attrs), attrs)
+self._handle_insert_entity_sql(cnx, self.sqlgen.insert('entities', attrs), attrs)
 # insert core relations: is, is_instance_of and cw_source
 try:
-self._handle_is_relation_sql(session, 'INSERT INTO is_relation(eid_from,eid_to) VALUES (%s,%s)',
+self._handle_is_relation_sql(cnx, 'INSERT INTO is_relation(eid_from,eid_to) VALUES (%s,%s)',
-(entity.eid, eschema_eid(session, entity.e_schema)))
+(entity.eid, eschema_eid(cnx, entity.e_schema)))
 except IndexError:
 # during schema serialization, skip
 pass
 else:
 for eschema in entity.e_schema.ancestors() + [entity.e_schema]:
-self._handle_is_relation_sql(session,
+self._handle_is_relation_sql(cnx,
 'INSERT INTO is_instance_of_relation(eid_from,eid_to) VALUES (%s,%s)',
-(entity.eid, eschema_eid(session, eschema)))
+(entity.eid, eschema_eid(cnx, eschema)))
 if 'CWSource' in self.schema and source.eid is not None: # else, cw < 3.10
-self._handle_is_relation_sql(session, 'INSERT INTO cw_source_relation(eid_from,eid_to) VALUES (%s,%s)',
+self._handle_is_relation_sql(cnx, 'INSERT INTO cw_source_relation(eid_from,eid_to) VALUES (%s,%s)',
 (entity.eid, source.eid))
 # now we can update the full text index
 if self.do_fti and self.need_fti_indexation(entity.cw_etype):
 if complete:
 entity.complete(entity.e_schema.indexable_attributes())
-self.index_entity(session, entity=entity)
+self.index_entity(cnx, entity=entity)
-def update_info(self, session, entity, need_fti_update):
+def update_info(self, cnx, entity, need_fti_update):
 """mark entity as being modified, fulltext reindex if needed"""
 if self.do_fti and need_fti_update:
 # reindex the entity only if this query is updating at least
 # one indexable attribute
-self.index_entity(session, entity=entity)
+self.index_entity(cnx, entity=entity)
-def delete_info_multi(self, session, entities):
+def delete_info_multi(self, cnx, entities):
 """delete system information on deletion of a list of entities with the
 same etype and belinging to the same source
 * update the fti
 * remove record from the `entities` table
 """
-self.fti_unindex_entities(session, entities)
+self.fti_unindex_entities(cnx, entities)
 attrs = {'eid': '(%s)' % ','.join([str(_e.eid) for _e in entities])}
-self.doexec(session, self.sqlgen.delete_many('entities', attrs), attrs)
+self.doexec(cnx, self.sqlgen.delete_many('entities', attrs), attrs)
 # undo support #############################################################
-def undoable_transactions(self, session, ueid=None, **actionfilters):
+def undoable_transactions(self, cnx, ueid=None, **actionfilters):
 """See :class:`cubicweb.repoapi.ClientConnection.undoable_transactions`"""
-# force filtering to session's user if not a manager
+# force filtering to connection's user if not a manager
-if not session.user.is_in_group('managers'):
+if not cnx.user.is_in_group('managers'):
-ueid = session.user.eid
+ueid = cnx.user.eid
 restr = {}
 if ueid is not None:
 restr['tx_user'] = ueid
 sql = self.sqlgen.select('transactions', restr, ('tx_uuid', 'tx_time', 'tx_user'))
 if actionfilters:
 sql += ' WHERE %s' % ' OR '.join(subqsqls)
 restr.update(trarestr)
 restr.update(tearestr)
 # we want results ordered by transaction's time descendant
 sql += ' ORDER BY tx_time DESC'
-with session.ensure_cnx_set:
+with cnx.ensure_cnx_set:
-cu = self.doexec(session, sql, restr)
+cu = self.doexec(cnx, sql, restr)
 # turn results into transaction objects
 return [tx.Transaction(*args) for args in cu.fetchall()]
-def tx_info(self, session, txuuid):
+def tx_info(self, cnx, txuuid):
 """See :class:`cubicweb.repoapi.ClientConnection.transaction_info`"""
-return tx.Transaction(txuuid, *self._tx_info(session, txuuid))
+return tx.Transaction(txuuid, *self._tx_info(cnx, txuuid))
-def tx_actions(self, session, txuuid, public):
+def tx_actions(self, cnx, txuuid, public):
 """See :class:`cubicweb.repoapi.ClientConnection.transaction_actions`"""
-self._tx_info(session, txuuid)
+self._tx_info(cnx, txuuid)
 restr = {'tx_uuid': txuuid}
 if public:
 restr['txa_public'] = True
 # XXX use generator to avoid loading everything in memory?
 sql = self.sqlgen.select('tx_entity_actions', restr,
 ('txa_action', 'txa_public', 'txa_order',
 'etype', 'eid', 'changes'))
-cu = self.doexec(session, sql, restr)
+cu = self.doexec(cnx, sql, restr)
 actions = [tx.EntityAction(a,p,o,et,e,c and loads(self.binary_to_str(c)))
 for a,p,o,et,e,c in cu.fetchall()]
 sql = self.sqlgen.select('tx_relation_actions', restr,
 ('txa_action', 'txa_public', 'txa_order',
 'rtype', 'eid_from', 'eid_to'))
-cu = self.doexec(session, sql, restr)
+cu = self.doexec(cnx, sql, restr)
 actions += [tx.RelationAction(*args) for args in cu.fetchall()]
 return sorted(actions, key=lambda x: x.order)
-def undo_transaction(self, session, txuuid):
+def undo_transaction(self, cnx, txuuid):
 """See :class:`cubicweb.repoapi.ClientConnection.undo_transaction`
 important note: while undoing of a transaction, only hooks in the
 'integrity', 'activeintegrity' and 'undo' categories are called.
 """
 # set mode so connections set isn't released subsquently until commit/rollback
-session.mode = 'write'
+cnx.mode = 'write'
 errors = []
-session.transaction_data['undoing_uuid'] = txuuid
+cnx.transaction_data['undoing_uuid'] = txuuid
-with session.deny_all_hooks_but('integrity', 'activeintegrity', 'undo'):
+with cnx.deny_all_hooks_but('integrity', 'activeintegrity', 'undo'):
-with session.security_enabled(read=False):
+with cnx.security_enabled(read=False):
-for action in reversed(self.tx_actions(session, txuuid, False)):
+for action in reversed(self.tx_actions(cnx, txuuid, False)):
 undomethod = getattr(self, '_undo_%s' % action.action.lower())
-errors += undomethod(session, action)
+errors += undomethod(cnx, action)
 # remove the transactions record
-self.doexec(session,
+self.doexec(cnx,
 "DELETE FROM transactions WHERE tx_uuid='%s'" % txuuid)
 if errors:
 raise UndoTransactionException(txuuid, errors)
 else:
 return
-def start_undoable_transaction(self, session, uuid):
+def start_undoable_transaction(self, cnx, uuid):
-"""session callback to insert a transaction record in the transactions
+"""connection callback to insert a transaction record in the transactions
 table when some undoable transaction is started
 """
-ueid = session.user.eid
+ueid = cnx.user.eid
 attrs = {'tx_uuid': uuid, 'tx_user': ueid, 'tx_time': datetime.utcnow()}
-self.doexec(session, self.sqlgen.insert('transactions', attrs), attrs)
+self.doexec(cnx, self.sqlgen.insert('transactions', attrs), attrs)
-def _save_attrs(self, session, entity, attrs):
+def _save_attrs(self, cnx, entity, attrs):
 """return a pickleable dictionary containing current values for given
 attributes of the entity
 """
 restr = {'cw_eid': entity.eid}
 sql = self.sqlgen.select(SQL_PREFIX + entity.cw_etype, restr, attrs)
-cu = self.doexec(session, sql, restr)
+cu = self.doexec(cnx, sql, restr)
 values = dict(zip(attrs, cu.fetchone()))
 # ensure backend specific binary are converted back to string
 eschema = entity.e_schema
 for column in attrs:
 # [3:] remove 'cw_' prefix
 value = values[column]
 if value is not None:
 values[column] = self.binary_to_str(value)
 return values
-def _record_tx_action(self, session, table, action, **kwargs):
+def _record_tx_action(self, cnx, table, action, **kwargs):
 """record a transaction action in the given table (either
 'tx_entity_actions' or 'tx_relation_action')
 """
-kwargs['tx_uuid'] = session.transaction_uuid()
+kwargs['tx_uuid'] = cnx.transaction_uuid()
 kwargs['txa_action'] = action
-kwargs['txa_order'] = session.transaction_inc_action_counter()
+kwargs['txa_order'] = cnx.transaction_inc_action_counter()
-kwargs['txa_public'] = session.running_dbapi_query
+kwargs['txa_public'] = cnx.running_dbapi_query
-self.doexec(session, self.sqlgen.insert(table, kwargs), kwargs)
+self.doexec(cnx, self.sqlgen.insert(table, kwargs), kwargs)
-def _tx_info(self, session, txuuid):
+def _tx_info(self, cnx, txuuid):
 """return transaction's time and user of the transaction with the given uuid.
 raise `NoSuchTransaction` if there is no such transaction of if the
-session's user isn't allowed to see it.
+connection's user isn't allowed to see it.
 """
-with session.ensure_cnx_set:
+with cnx.ensure_cnx_set:
 restr = {'tx_uuid': txuuid}
 sql = self.sqlgen.select('transactions', restr,
 ('tx_time', 'tx_user'))
-cu = self.doexec(session, sql, restr)
+cu = self.doexec(cnx, sql, restr)
 try:
 time, ueid = cu.fetchone()
 except TypeError:
 raise tx.NoSuchTransaction(txuuid)
-if not (session.user.is_in_group('managers')
+if not (cnx.user.is_in_group('managers')
-or session.user.eid == ueid):
+or cnx.user.eid == ueid):
 raise tx.NoSuchTransaction(txuuid)
 return time, ueid
 def _reedit_entity(self, entity, changes, err):
-session = entity._cw
+cnx = entity._cw
 eid = entity.eid
 entity.cw_edited = edited = EditedEntity(entity)
 # check for schema changes, entities linked through inlined relation
 # still exists, rewrap binary values
 eschema = entity.e_schema
 if rtype == "eid":
 continue # XXX should even `eid` be stored in action changes?
 try:
 rschema = getrschema[rtype]
 except KeyError:
-err(session._("can't restore relation %(rtype)s of entity %(eid)s, "
+err(cnx._("can't restore relation %(rtype)s of entity %(eid)s, "
 "this relation does not exist in the schema anymore.")
 % {'rtype': rtype, 'eid': eid})
 if not rschema.final:
 if not rschema.inlined:
 assert value is None
 # not a deletion: we must put something in edited
 try:
 entity._cw.entity_from_eid(value) # check target exists
 edited[rtype] = value
 except UnknownEid:
-err(session._("can't restore entity %(eid)s of type %(eschema)s, "
+err(cnx._("can't restore entity %(eid)s of type %(eschema)s, "
 "target of %(rtype)s (eid %(value)s) does not exist any longer")
 % locals())
 elif eschema.destination(rtype) in ('Bytes', 'Password'):
 changes[column] = self._binary(value)
 edited[rtype] = Binary(value)
 elif isinstance(value, str):
-edited[rtype] = unicode(value, session.encoding, 'replace')
+edited[rtype] = unicode(value, cnx.encoding, 'replace')
 else:
 edited[rtype] = value
 # This must only be done after init_entitiy_caches : defered in calling functions
 # edited.check()
-def _undo_d(self, session, action):
+def _undo_d(self, cnx, action):
 """undo an entity deletion"""
 errors = []
 err = errors.append
 eid = action.eid
 etype = action.etype
-_ = session._
+_ = cnx._
 # get an entity instance
 try:
-entity = self.repo.vreg['etypes'].etype_class(etype)(session)
+entity = self.repo.vreg['etypes'].etype_class(etype)(cnx)
 except Exception:
 err("can't restore entity %s of type %s, type no more supported"
 % (eid, etype))
 return errors
 self._reedit_entity(entity, action.changes, err)
 entity.eid = eid
-session.repo.init_entity_caches(session, entity, self)
+cnx.repo.init_entity_caches(cnx, entity, self)
 entity.cw_edited.check()
-self.repo.hm.call_hooks('before_add_entity', session, entity=entity)
+self.repo.hm.call_hooks('before_add_entity', cnx, entity=entity)
 # restore the entity
 action.changes['cw_eid'] = eid
 sql = self.sqlgen.insert(SQL_PREFIX + etype, action.changes)
-self.doexec(session, sql, action.changes)
+self.doexec(cnx, sql, action.changes)
 # restore record in entities (will update fti if needed)
-self.add_info(session, entity, self, None, True)
+self.add_info(cnx, entity, self, None, True)
-self.repo.hm.call_hooks('after_add_entity', session, entity=entity)
+self.repo.hm.call_hooks('after_add_entity', cnx, entity=entity)
 return errors
-def _undo_r(self, session, action):
+def _undo_r(self, cnx, action):
 """undo a relation removal"""
 errors = []
 subj, rtype, obj = action.eid_from, action.rtype, action.eid_to
 try:
-sentity, oentity, rdef = _undo_rel_info(session, subj, rtype, obj)
+sentity, oentity, rdef = _undo_rel_info(cnx, subj, rtype, obj)
 except _UndoException as ex:
 errors.append(unicode(ex))
 else:
 for role, entity in (('subject', sentity),
 ('object', oentity)):
 _undo_check_relation_target(entity, rdef, role)
 except _UndoException as ex:
 errors.append(unicode(ex))
 continue
 if not errors:
-self.repo.hm.call_hooks('before_add_relation', session,
+self.repo.hm.call_hooks('before_add_relation', cnx,
 eidfrom=subj, rtype=rtype, eidto=obj)
 # add relation in the database
-self._add_relations(session, rtype, [(subj, obj)], rdef.rtype.inlined)
+self._add_relations(cnx, rtype, [(subj, obj)], rdef.rtype.inlined)
 # set related cache
-session.update_rel_cache_add(subj, rtype, obj, rdef.rtype.symmetric)
+cnx.update_rel_cache_add(subj, rtype, obj, rdef.rtype.symmetric)
-self.repo.hm.call_hooks('after_add_relation', session,
+self.repo.hm.call_hooks('after_add_relation', cnx,
 eidfrom=subj, rtype=rtype, eidto=obj)
 return errors
-def _undo_c(self, session, action):
+def _undo_c(self, cnx, action):
 """undo an entity creation"""
 eid = action.eid
 # XXX done to avoid fetching all remaining relation for the entity
 # we should find an efficient way to do this (keeping current veolidf
 # massive deletion performance)
-if _undo_has_later_transaction(session, eid):
+if _undo_has_later_transaction(cnx, eid):
-msg = session._('some later transaction(s) touch entity, undo them '
+msg = cnx._('some later transaction(s) touch entity, undo them '
 'first')
 raise ValidationError(eid, {None: msg})
 etype = action.etype
 # get an entity instance
 try:
-entity = self.repo.vreg['etypes'].etype_class(etype)(session)
+entity = self.repo.vreg['etypes'].etype_class(etype)(cnx)
 except Exception:
-return [session._(
+return [cnx._(
 "Can't undo creation of entity %(eid)s of type %(etype)s, type "
 "no more supported" % {'eid': eid, 'etype': etype})]
 entity.eid = eid
 # for proper eid/type cache update
-CleanupDeletedEidsCacheOp.get_instance(session).add_data(eid)
+CleanupDeletedEidsCacheOp.get_instance(cnx).add_data(eid)
-self.repo.hm.call_hooks('before_delete_entity', session, entity=entity)
+self.repo.hm.call_hooks('before_delete_entity', cnx, entity=entity)
 # remove is / is_instance_of which are added using sql by hooks, hence
 # unvisible as transaction action
-self.doexec(session, 'DELETE FROM is_relation WHERE eid_from=%s' % eid)
+self.doexec(cnx, 'DELETE FROM is_relation WHERE eid_from=%s' % eid)
-self.doexec(session, 'DELETE FROM is_instance_of_relation WHERE eid_from=%s' % eid)
+self.doexec(cnx, 'DELETE FROM is_instance_of_relation WHERE eid_from=%s' % eid)
-self.doexec(session, 'DELETE FROM cw_source_relation WHERE eid_from=%s' % self.eid)
+self.doexec(cnx, 'DELETE FROM cw_source_relation WHERE eid_from=%s' % self.eid)
 # XXX check removal of inlined relation?
 # delete the entity
 attrs = {'cw_eid': eid}
 sql = self.sqlgen.delete(SQL_PREFIX + entity.cw_etype, attrs)
-self.doexec(session, sql, attrs)
+self.doexec(cnx, sql, attrs)
 # remove record from entities (will update fti if needed)
-self.delete_info_multi(session, [entity])
+self.delete_info_multi(cnx, [entity])
-self.repo.hm.call_hooks('after_delete_entity', session, entity=entity)
+self.repo.hm.call_hooks('after_delete_entity', cnx, entity=entity)
 return ()
-def _undo_u(self, session, action):
+def _undo_u(self, cnx, action):
 """undo an entity update"""
 errors = []
 err = errors.append
 try:
-entity = session.entity_from_eid(action.eid)
+entity = cnx.entity_from_eid(action.eid)
 except UnknownEid:
-err(session._("can't restore state of entity %s, it has been "
+err(cnx._("can't restore state of entity %s, it has been "
 "deleted inbetween") % action.eid)
 return errors
 self._reedit_entity(entity, action.changes, err)
 entity.cw_edited.check()
-self.repo.hm.call_hooks('before_update_entity', session, entity=entity)
+self.repo.hm.call_hooks('before_update_entity', cnx, entity=entity)
 sql = self.sqlgen.update(SQL_PREFIX + entity.cw_etype, action.changes,
 ['cw_eid'])
-self.doexec(session, sql, action.changes)
+self.doexec(cnx, sql, action.changes)
-self.repo.hm.call_hooks('after_update_entity', session, entity=entity)
+self.repo.hm.call_hooks('after_update_entity', cnx, entity=entity)
 return errors
-def _undo_a(self, session, action):
+def _undo_a(self, cnx, action):
 """undo a relation addition"""
 errors = []
 subj, rtype, obj = action.eid_from, action.rtype, action.eid_to
 try:
-sentity, oentity, rdef = _undo_rel_info(session, subj, rtype, obj)
+sentity, oentity, rdef = _undo_rel_info(cnx, subj, rtype, obj)
 except _UndoException as ex:
 errors.append(unicode(ex))
 else:
 rschema = rdef.rtype
 if rschema.inlined:
 sql = 'SELECT 1 FROM cw_%s WHERE cw_eid=%s and cw_%s=%s'\
 % (sentity.cw_etype, subj, rtype, obj)
 else:
 sql = 'SELECT 1 FROM %s_relation WHERE eid_from=%s and eid_to=%s'\
 % (rtype, subj, obj)
-cu = self.doexec(session, sql)
+cu = self.doexec(cnx, sql)
 if cu.fetchone() is None:
-errors.append(session._(
+errors.append(cnx._(
 "Can't undo addition of relation %(rtype)s from %(subj)s to"
 " %(obj)s, doesn't exist anymore" % locals()))
 if not errors:
-self.repo.hm.call_hooks('before_delete_relation', session,
+self.repo.hm.call_hooks('before_delete_relation', cnx,
 eidfrom=subj, rtype=rtype, eidto=obj)
 # delete relation from the database
-self._delete_relation(session, subj, rtype, obj, rschema.inlined)
+self._delete_relation(cnx, subj, rtype, obj, rschema.inlined)
 # set related cache
-session.update_rel_cache_del(subj, rtype, obj, rschema.symmetric)
+cnx.update_rel_cache_del(subj, rtype, obj, rschema.symmetric)
-self.repo.hm.call_hooks('after_delete_relation', session,
+self.repo.hm.call_hooks('after_delete_relation', cnx,
 eidfrom=subj, rtype=rtype, eidto=obj)
 return errors
 # full text index handling #################################################
 return True
 if any(eschema.fulltext_containers()):
 return True
 return False
-def index_entity(self, session, entity):
+def index_entity(self, cnx, entity):
 """create an operation to [re]index textual content of the given entity
 on commit
 """
-FTIndexEntityOp.get_instance(session).add_data(entity.eid)
+FTIndexEntityOp.get_instance(cnx).add_data(entity.eid)
 def fti_unindex_entities(self, cnx, entities):
 """remove text content for entities from the full text index
 """
 cursor = cnx.cnxset.cu
 triggered on precommit, not commit, and this should be done after other
 precommit operation which may add relations to the entity
 """
 def precommit_event(self):
-session = self.session
+cnx = self.cnx
-source = session.repo.system_source
+source = cnx.repo.system_source
-pendingeids = session.transaction_data.get('pendingeids', ())
+pendingeids = cnx.transaction_data.get('pendingeids', ())
-done = session.transaction_data.setdefault('indexedeids', set())
+done = cnx.transaction_data.setdefault('indexedeids', set())
 to_reindex = set()
 for eid in self.get_data():
 if eid in pendingeids or eid in done:
 # entity added and deleted in the same transaction or already
 # processed
 continue
 done.add(eid)
-iftindexable = session.entity_from_eid(eid).cw_adapt_to('IFTIndexable')
+iftindexable = cnx.entity_from_eid(eid).cw_adapt_to('IFTIndexable')
 to_reindex |= set(iftindexable.fti_containers())
-source.fti_unindex_entities(session, to_reindex)
+source.fti_unindex_entities(cnx, to_reindex)
-source.fti_index_entities(session, to_reindex)
+source.fti_index_entities(cnx, to_reindex)
 def sql_schema(driver):
 helper = get_db_helper(driver)
 typemap = helper.TYPE_MAPPING
 schema = """

changeset 9611	ca853478aaa8
parent 9605	e6b8931abe17
child 9664	5ef5494b6b0b