+
−# copyright 2014 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+
−# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+
−#
+
−# This file is part of CubicWeb.
+
−#
+
−# CubicWeb is free software: you can redistribute it and/or modify it under the
+
−# terms of the GNU Lesser General Public License as published by the Free
+
−# Software Foundation, either version 2.1 of the License, or (at your option)
+
−# any later version.
+
−#
+
−# CubicWeb is distributed in the hope that it will be useful, but WITHOUT
+
−# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+
−# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+
−# details.
+
−#
+
−# You should have received a copy of the GNU Lesser General Public License along
+
−# with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.
+
−"""Hooks for synchronizing computed attributes"""
+
−
+
−__docformat__ = "restructuredtext en"
+
−from cubicweb import _
+
−
+
−from collections import defaultdict
+
−
+
−from rql import nodes
+
−
+
−from cubicweb.server import hook
+
−
+
−
+
−class RecomputeAttributeOperation(hook.DataOperationMixIn, hook.Operation):
+
−    """Operation to recompute caches of computed attribute at commit time,
+
−    depending on what's have been modified in the transaction and avoiding to
+
−    recompute twice the same attribute
+
−    """
+
−    containercls = dict
+
−    def add_data(self, computed_attribute, eid=None):
+
−        try:
+
−            self._container[computed_attribute].add(eid)
+
−        except KeyError:
+
−            self._container[computed_attribute] = set((eid,))
+
−
+
−    def precommit_event(self):
+
−        for computed_attribute_rdef, eids in self.get_data().items():
+
−            attr = computed_attribute_rdef.rtype
+
−            formula  = computed_attribute_rdef.formula
+
−            select = self.cnx.repo.vreg.rqlhelper.parse(formula).children[0]
+
−            xvar = select.get_variable('X')
+
−            select.add_selected(xvar, index=0)
+
−            select.add_group_var(xvar, index=0)
+
−            if None in eids:
+
−                select.add_type_restriction(xvar, computed_attribute_rdef.subject)
+
−            else:
+
−                select.add_eid_restriction(xvar, eids)
+
−            update_rql = 'SET X %s %%(value)s WHERE X eid %%(x)s' % attr
+
−            for eid, value in self.cnx.execute(select.as_string()):
+
−                self.cnx.execute(update_rql, {'value': value, 'x': eid})
+
−
+
−
+
−class EntityWithCACreatedHook(hook.Hook):
+
−    """When creating an entity that has some computed attribute, those
+
−    attributes have to be computed.
+
−
+
−    Concret class of this hook are generated at registration time by
+
−    introspecting the schema.
+
−    """
+
−    __abstract__ = True
+
−    events = ('after_add_entity',)
+
−    # list of computed attribute rdefs that have to be recomputed
+
−    computed_attributes = None
+
−
+
−    def __call__(self):
+
−        for rdef in self.computed_attributes:
+
−            RecomputeAttributeOperation.get_instance(self._cw).add_data(
+
−                rdef, self.entity.eid)
+
−
+
−
+
−class RelationInvolvedInCAModifiedHook(hook.Hook):
+
−    """When some relation used in a computed attribute is updated, those
+
−    attributes have to be recomputed.
+
−
+
−    Concret class of this hook are generated at registration time by
+
−    introspecting the schema.
+
−    """
+
−    __abstract__ = True
+
−    events = ('after_add_relation', 'before_delete_relation')
+
−    # list of (computed attribute rdef, optimize_on) that have to be recomputed
+
−    optimized_computed_attributes = None
+
−
+
−    def __call__(self):
+
−        for rdef, optimize_on in self.optimized_computed_attributes:
+
−            if optimize_on is None:
+
−                eid = None
+
−            else:
+
−                eid = getattr(self, optimize_on)
+
−            RecomputeAttributeOperation.get_instance(self._cw).add_data(rdef, eid)
+
−
+
−
+
−class AttributeInvolvedInCAModifiedHook(hook.Hook):
+
−    """When some attribute used in a computed attribute is updated, those
+
−    attributes have to be recomputed.
+
−
+
−    Concret class of this hook are generated at registration time by
+
−    introspecting the schema.
+
−    """
+
−    __abstract__ = True
+
−    events = ('after_update_entity',)
+
−    # list of (computed attribute rdef, attributes of this entity type involved)
+
−    # that may have to be recomputed
+
−    attributes_computed_attributes = None
+
−
+
−    def __call__(self):
+
−        edited_attributes = frozenset(self.entity.cw_edited)
+
−        for rdef, used_attributes in self.attributes_computed_attributes.items():
+
−            if edited_attributes.intersection(used_attributes):
+
−                # XXX optimize if the modified attributes belong to the same
+
−                # entity as the computed attribute
+
−                RecomputeAttributeOperation.get_instance(self._cw).add_data(rdef)
+
−
+
−
+
−# code generation at registration time #########################################
+
−
+
−def _optimize_on(formula_select, rtype):
+
−    """Given a formula and some rtype, tells whether on update of the given
+
−    relation, formula may be recomputed only for rhe relation's subject
+
−    ('eidfrom' returned), object ('eidto' returned) or None.
+
−
+
−    Optimizing is only possible when X is used as direct subject/object of this
+
−    relation, else we may miss some necessary update.
+
−    """
+
−    for rel in formula_select.get_nodes(nodes.Relation):
+
−        if rel.r_type == rtype:
+
−            sub = rel.get_variable_parts()[0]
+
−            obj = rel.get_variable_parts()[1]
+
−            if sub.name == 'X':
+
−                return 'eidfrom'
+
−            elif obj.name == 'X':
+
−                return 'eidto'
+
−            else:
+
−                return None
+
−
+
−
+
−class _FormulaDependenciesMatrix(object):
+
−    """This class computes and represents the dependencies of computed attributes
+
−    towards relations and attributes
+
−    """
+
−
+
−    def __init__(self, schema):
+
−        """Analyzes the schema to compute the dependencies"""
+
−        # entity types holding some computed attribute {etype: [computed rdefs]}
+
−        self.computed_attribute_by_etype = defaultdict(list)
+
−        # depending entity types {dep. etype: {computed rdef: dep. etype attributes}}
+
−        self.computed_attribute_by_etype_attrs = defaultdict(lambda: defaultdict(set))
+
−        # depending relations def {dep. rdef: [computed rdefs]
+
−        self.computed_attribute_by_relation = defaultdict(list) # by rdef
+
−        # Walk through all attributes definitions
+
−        for rdef in schema.iter_computed_attributes():
+
−            self.computed_attribute_by_etype[rdef.subject.type].append(rdef)
+
−            # extract the relations it depends upon - `rdef.formula_select` is
+
−            # expected to have been set by finalize_computed_attributes
+
−            select = rdef.formula_select
+
−            for rel_node in select.get_nodes(nodes.Relation):
+
−                if rel_node.is_types_restriction():
+
−                    continue
+
−                rschema = schema.rschema(rel_node.r_type)
+
−                lhs, rhs = rel_node.get_variable_parts()
+
−                for sol in select.solutions:
+
−                    subject_etype = sol[lhs.name]
+
−                    if isinstance(rhs, nodes.VariableRef):
+
−                        object_etypes = set(sol[rhs.name] for sol in select.solutions)
+
−                    else:
+
−                        object_etypes = rschema.objects(subject_etype)
+
−                    for object_etype in object_etypes:
+
−                        if rschema.final:
+
−                            attr_for_computations = self.computed_attribute_by_etype_attrs[subject_etype]
+
−                            attr_for_computations[rdef].add(rschema.type)
+
−                        else:
+
−                            depend_on_rdef = rschema.rdefs[subject_etype, object_etype]
+
−                            self.computed_attribute_by_relation[depend_on_rdef].append(rdef)
+
−
+
−    def generate_entity_creation_hooks(self):
+
−        for etype, computed_attributes in self.computed_attribute_by_etype.items():
+
−            regid = 'computed_attribute.%s_created' % etype
+
−            selector = hook.is_instance(etype)
+
−            yield type('%sCreatedHook' % etype,
+
−                       (EntityWithCACreatedHook,),
+
−                       {'__regid__': regid,
+
−                        '__select__':  hook.Hook.__select__ & selector,
+
−                        'computed_attributes': computed_attributes})
+
−
+
−    def generate_relation_change_hooks(self):
+
−        for rdef, computed_attributes in self.computed_attribute_by_relation.items():
+
−            regid = 'computed_attribute.%s_modified' % rdef.rtype
+
−            selector = hook.match_rtype(rdef.rtype.type,
+
−                                        frometypes=(rdef.subject.type,),
+
−                                        toetypes=(rdef.object.type,))
+
−            optimized_computed_attributes = []
+
−            for computed_rdef in computed_attributes:
+
−                optimized_computed_attributes.append(
+
−                    (computed_rdef,
+
−                     _optimize_on(computed_rdef.formula_select, rdef.rtype))
+
−                     )
+
−            yield type('%sModifiedHook' % rdef.rtype,
+
−                       (RelationInvolvedInCAModifiedHook,),
+
−                       {'__regid__': regid,
+
−                        '__select__':  hook.Hook.__select__ & selector,
+
−                        'optimized_computed_attributes': optimized_computed_attributes})
+
−
+
−    def generate_entity_update_hooks(self):
+
−        for etype, attributes_computed_attributes in self.computed_attribute_by_etype_attrs.items():
+
−            regid = 'computed_attribute.%s_updated' % etype
+
−            selector = hook.is_instance(etype)
+
−            yield type('%sModifiedHook' % etype,
+
−                       (AttributeInvolvedInCAModifiedHook,),
+
−                       {'__regid__': regid,
+
−                        '__select__':  hook.Hook.__select__ & selector,
+
−                        'attributes_computed_attributes': attributes_computed_attributes})
+
−
+
−
+
−def registration_callback(vreg):
+
−    vreg.register_all(globals().values(), __name__)
+
−    dependencies = _FormulaDependenciesMatrix(vreg.schema)
+
−    for hook_class in dependencies.generate_entity_creation_hooks():
+
−        vreg.register(hook_class)
+
−    for hook_class in dependencies.generate_relation_change_hooks():
+
−        vreg.register(hook_class)
+
−    for hook_class in dependencies.generate_entity_update_hooks():
+
−        vreg.register(hook_class)