cubicweb: comparison server/sources/native.py

equal deleted inserted replaced

-:6b0832bbd1da
+:d9e8af8a7a42
 from pickle import loads, dumps
 from threading import Lock
 from datetime import datetime
 from base64 import b64decode, b64encode
+from contextlib import contextmanager
 from logilab.common.compat import any
 from logilab.common.cache import Cache
 from logilab.common.decorators import cached, clear_cache
 from logilab.common.configuration import Method
 self.do_fti = not repo.config['delay-full-text-indexation']
 # sql queries cache
 self._cache = Cache(repo.config['rql-cache-size'])
 self._temp_table_data = {}
 self._eid_creation_lock = Lock()
+# (etype, attr) / storage mapping
+self._storages = {}
 # XXX no_sqlite_wrap trick since we've a sqlite locking pb when
 # running unittest_multisources with the wrapping below
 if self.dbdriver == 'sqlite' and \
 not getattr(repo.config, 'no_sqlite_wrap', False):
 from cubicweb.server.sources.extlite import ConnectionWrapper
 def map_attribute(self, etype, attr, cb):
 self._rql_sqlgen.attr_map['%s.%s' % (etype, attr)] = cb
 def unmap_attribute(self, etype, attr):
 self._rql_sqlgen.attr_map.pop('%s.%s' % (etype, attr), None)
+def set_storage(self, etype, attr, storage):
+storage_dict = self._storages.setdefault(etype, {})
+storage_dict[attr] = storage
+self.map_attribute(etype, attr, storage.sqlgen_callback)
+def unset_storage(self, etype, attr):
+self._storages[etype].pop(attr)
+# if etype has no storage left, remove the entry
+if not self._storages[etype]:
+del self._storages[etype]
+self.unmap_attribute(etype, attr)
 # ISource interface #######################################################
 def compile_rql(self, rql, sols):
 rqlst = self.repo.vreg.rqlhelper.parse(rql)
 try:
 del self._temp_table_data[table]
 except KeyError:
 continue
+@contextmanager
+def _storage_handler(self, entity, event):
+# 1/ memorize values as they are before the storage is called.
+#    For instance, the BFSStorage will replace the `data`
+#    binary value with a Binary containing the destination path
+#    on the filesystem. To make the entity.data usage absolutely
+#    transparent, we'll have to reset entity.data to its binary
+#    value once the SQL query will be executed
+orig_values = {}
+etype = entity.__regid__
+for attr, storage in self._storages.get(etype, {}).items():
+if attr in entity.edited_attributes:
+orig_values[attr] = entity[attr]
+handler = getattr(storage, 'entity_%s' % event)
+handler(entity, attr)
+yield # 2/ execute the source's instructions
+# 3/ restore original values
+for attr, value in orig_values.items():
+entity[attr] = value
 def add_entity(self, session, entity):
 """add a new entity to the source"""
-attrs = self.preprocess_entity(entity)
+with self._storage_handler(entity, 'added'):
-sql = self.sqlgen.insert(SQL_PREFIX + entity.__regid__, attrs)
+attrs = self.preprocess_entity(entity)
-self.doexec(session, sql, attrs)
+sql = self.sqlgen.insert(SQL_PREFIX + entity.__regid__, attrs)
-if session.undoable_action('C', entity.__regid__):
+self.doexec(session, sql, attrs)
-self._record_tx_action(session, 'tx_entity_actions', 'C',
+if session.undoable_action('C', entity.__regid__):
-etype=entity.__regid__, eid=entity.eid)
+self._record_tx_action(session, 'tx_entity_actions', 'C',
+etype=entity.__regid__, eid=entity.eid)
 def update_entity(self, session, entity):
 """replace an entity in the source"""
-attrs = self.preprocess_entity(entity)
+with self._storage_handler(entity, 'updated'):
-if session.undoable_action('U', entity.__regid__):
+attrs = self.preprocess_entity(entity)
-changes = self._save_attrs(session, entity, attrs)
+if session.undoable_action('U', entity.__regid__):
-self._record_tx_action(session, 'tx_entity_actions', 'U',
+changes = self._save_attrs(session, entity, attrs)
-etype=entity.__regid__, eid=entity.eid,
+self._record_tx_action(session, 'tx_entity_actions', 'U',
-changes=self._binary(dumps(changes)))
+etype=entity.__regid__, eid=entity.eid,
-sql = self.sqlgen.update(SQL_PREFIX + entity.__regid__, attrs,
+changes=self._binary(dumps(changes)))
-['cw_eid'])
+sql = self.sqlgen.update(SQL_PREFIX + entity.__regid__, attrs,
-self.doexec(session, sql, attrs)
+['cw_eid'])
+self.doexec(session, sql, attrs)
 def delete_entity(self, session, entity):
 """delete an entity from the source"""
-if session.undoable_action('D', entity.__regid__):
+with self._storage_handler(entity, 'deleted'):
-attrs = [SQL_PREFIX + r.type
+if session.undoable_action('D', entity.__regid__):
-for r in entity.e_schema.subject_relations()
+attrs = [SQL_PREFIX + r.type
-if (r.final or r.inlined) and not r in VIRTUAL_RTYPES]
+for r in entity.e_schema.subject_relations()
-changes = self._save_attrs(session, entity, attrs)
+if (r.final or r.inlined) and not r in VIRTUAL_RTYPES]
-self._record_tx_action(session, 'tx_entity_actions', 'D',
+changes = self._save_attrs(session, entity, attrs)
-etype=entity.__regid__, eid=entity.eid,
+self._record_tx_action(session, 'tx_entity_actions', 'D',
-changes=self._binary(dumps(changes)))
+etype=entity.__regid__, eid=entity.eid,
-attrs = {'cw_eid': entity.eid}
+changes=self._binary(dumps(changes)))
-sql = self.sqlgen.delete(SQL_PREFIX + entity.__regid__, attrs)
+attrs = {'cw_eid': entity.eid}
-self.doexec(session, sql, attrs)
+sql = self.sqlgen.delete(SQL_PREFIX + entity.__regid__, attrs)
+self.doexec(session, sql, attrs)
 def _add_relation(self, session, subject, rtype, object, inlined=False):
 """add a relation to the source"""
 if inlined is False:
 attrs = {'eid_from': subject, 'eid_to': object}

changeset 4964	d9e8af8a7a42
parent 4943	7f5b83578fec
child 5011	57c4c6399b44