cubicweb: comparison entity.py

equal deleted inserted replaced

-:7b2c7f3d3703
+:acc23c284432
 from logilab.common.decorators import cached
 from logilab.common.deprecation import deprecated
 from logilab.mtconverter import TransformData, TransformError, xml_escape
 from rql.utils import rqlvar_maker
+from rql.stmts import Select
+from rql.nodes import (Not, VariableRef, Constant, make_relation,
+Relation as RqlRelation)
 from cubicweb import Unauthorized, typed_eid, neg_role
+from cubicweb.utils import support_args
 from cubicweb.rset import ResultSet
 from cubicweb.selectors import yes
 from cubicweb.appobject import AppObject
 from cubicweb.req import _check_cw_unsafe
-from cubicweb.schema import RQLVocabularyConstraint, RQLConstraint
+from cubicweb.schema import (RQLVocabularyConstraint, RQLConstraint,
+GeneratedConstraint)
 from cubicweb.rqlrewrite import RQLRewriter
-from cubicweb.uilib import printable_value, soup2xhtml
+from cubicweb.uilib import soup2xhtml
 from cubicweb.mixins import MI_REL_TRIGGERS
 from cubicweb.mttransforms import ENGINE
 _marker = object()
 # behind Apache mod_proxy
 if value == u'' or u'?' in value or u'/' in value or u'&' in value:
 return False
 return True
+def rel_vars(rel):
-def remove_ambiguous_rels(attr_set, subjtypes, schema):
+return ((isinstance(rel.children[0], VariableRef)
-'''remove from `attr_set` the relations of entity types `subjtypes` that have
+and rel.children[0].variable or None),
-different entity type sets as target'''
+(isinstance(rel.children[1].children[0], VariableRef)
-for attr in attr_set.copy():
+and rel.children[1].children[0].variable or None)
-rschema = schema.rschema(attr)
+)
-if rschema.final:
+def rel_matches(rel, rtype, role, varname, operator='='):
+if rel.r_type == rtype and rel.children[1].operator == operator:
+same_role_var_idx = 0 if role == 'subject' else 1
+variables = rel_vars(rel)
+if variables[same_role_var_idx].name == varname:
+return variables[1 - same_role_var_idx]
+def build_cstr_with_linkto_infos(cstr, args, searchedvar, evar,
+lt_infos, eidvars):
+"""restrict vocabulary as much as possible in entity creation,
+based on infos provided by __linkto form param.
+Example based on following schema:
+class works_in(RelationDefinition):
+subject = 'CWUser'
+object = 'Lab'
+cardinality = '1*'
+constraints = [RQLConstraint('S in_group G, O welcomes G')]
+class welcomes(RelationDefinition):
+subject = 'Lab'
+object = 'CWGroup'
+If you create a CWUser in the "scientists" CWGroup you can show
+only the labs that welcome them using :
+lt_infos = {('in_group', 'subject'): 321}
+You get following restriction : 'O welcomes G, G eid 321'
+"""
+st = cstr.snippet_rqlst.copy()
+# replace relations in ST by eid infos from linkto where possible
+for (info_rtype, info_role), eids in lt_infos.iteritems():
+eid = eids[0] # NOTE: we currently assume a pruned lt_info with only 1 eid
+for rel in st.iget_nodes(RqlRelation):
+targetvar = rel_matches(rel, info_rtype, info_role, evar.name)
+if targetvar is not None:
+if targetvar.name in eidvars:
+rel.parent.remove(rel)
+else:
+eidrel = make_relation(
+targetvar, 'eid', (targetvar.name, 'Substitute'),
+Constant)
+rel.parent.replace(rel, eidrel)
+args[targetvar.name] = eid
+eidvars.add(targetvar.name)
+# if modified ST still contains evar references we must discard the
+# constraint, otherwise evar is unknown in the final rql query which can
+# lead to a SQL table cartesian product and multiple occurences of solutions
+evarname = evar.name
+for rel in st.iget_nodes(RqlRelation):
+for variable in rel_vars(rel):
+if variable and evarname == variable.name:
+return
+# else insert snippets into the global tree
+return GeneratedConstraint(st, cstr.mainvars - set(evarname))
+def pruned_lt_info(eschema, lt_infos):
+pruned = {}
+for (lt_rtype, lt_role), eids in lt_infos.iteritems():
+# we can only use lt_infos describing relation with a cardinality
+# of value 1 towards the linked entity
+if not len(eids) == 1:
 continue
-ttypes = None
+lt_card = eschema.rdef(lt_rtype, lt_role).cardinality[
-for subjtype in subjtypes:
+0 if lt_role == 'subject' else 1]
-cur_ttypes = rschema.objects(subjtype)
+if lt_card not in '?1':
-if ttypes is None:
+continue
-ttypes = cur_ttypes
+pruned[(lt_rtype, lt_role)] = eids
-elif cur_ttypes != ttypes:
+return pruned
-attr_set.remove(attr)
-break
 class Entity(AppObject):
 """an entity instance has e_schema automagically set on
 the class and instances has access to their issuing cursor.
 fetched)
 :type e_schema: `cubicweb.schema.EntitySchema`
 :ivar e_schema: the entity's schema
-:type rest_var: str
+:type rest_attr: str
-:cvar rest_var: indicates which attribute should be used to build REST urls
+:cvar rest_attr: indicates which attribute should be used to build REST urls
-If None is specified, the first non-meta attribute will
+If `None` is specified (the default), the first unique attribute will
-be used
+be used ('eid' if none found)
-:type skip_copy_for: list
+:type cw_skip_copy_for: list
-:cvar skip_copy_for: a list of relations that should be skipped when copying
+:cvar cw_skip_copy_for: a list of couples (rtype, role) for each relation
-this kind of entity. Note that some relations such
+that should be skipped when copying this kind of entity. Note that some
-as composite relations or relations that have '?1' as object
+relations such as composite relations or relations that have '?1' as
-cardinality are always skipped.
+object cardinality are always skipped.
 """
 __registry__ = 'etypes'
 __select__ = yes()
 # class attributes that must be set in class definition
 rest_attr = None
 fetch_attrs = None
-skip_copy_for = ('in_state',) # XXX turn into a set
+skip_copy_for = () # bw compat (< 3.14), use cw_skip_copy_for instead
+cw_skip_copy_for = [('in_state', 'subject')]
 # class attributes set automatically at registration time
 e_schema = None
 @classmethod
 def __initialize__(cls, schema):
 mixins += cls.__bases__[1:]
 cls.__bases__ = tuple(mixins)
 cls.info('plugged %s mixins on %s', mixins, cls)
 fetch_attrs = ('modification_date',)
 @classmethod
-def fetch_order(cls, attr, var):
+def cw_fetch_order(cls, select, attr, var):
-"""class method used to control sort order when multiple entities of
+"""This class method may be used to control sort order when multiple
-this type are fetched
+entities of this type are fetched through ORM methods. Its arguments
-"""
+are:
-return cls.fetch_unrelated_order(attr, var)
+* `select`, the RQL syntax tree
+* `attr`, the attribute being watched
+* `var`, the variable through which this attribute's value may be
+accessed in the query
+When you want to do some sorting on the given attribute, you should
+modify the syntax tree accordingly. For instance:
+.. sourcecode:: python
+from rql import nodes
+class Version(AnyEntity):
+__regid__ = 'Version'
+fetch_attrs = ('num', 'description', 'in_state')
+@classmethod
+def cw_fetch_order(cls, select, attr, var):
+if attr == 'num':
+func = nodes.Function('version_sort_value')
+func.append(nodes.variable_ref(var))
+sterm = nodes.SortTerm(func, asc=False)
+select.add_sort_term(sterm)
+The default implementation call
+:meth:`~cubicweb.entity.Entity.cw_fetch_unrelated_order`
+"""
+cls.cw_fetch_unrelated_order(select, attr, var)
 @classmethod
-def fetch_unrelated_order(cls, attr, var):
+def cw_fetch_unrelated_order(cls, select, attr, var):
-"""class method used to control sort order when multiple entities of
+"""This class method may be used to control sort order when multiple entities of
-this type are fetched to use in edition (eg propose them to create a
+this type are fetched to use in edition (e.g. propose them to create a
 new relation on an edited entity).
+See :meth:`~cubicweb.entity.Entity.cw_fetch_unrelated_order` for a
+description of its arguments and usage.
+By default entities will be listed on their modification date descending,
+i.e. you'll get entities recently modified first.
 """
 if attr == 'modification_date':
-return '%s DESC' % var
+select.add_sort_var(var, asc=False)
-return None
 @classmethod
 def fetch_rql(cls, user, restriction=None, fetchattrs=None, mainvar='X',
 settype=True, ordermethod='fetch_order'):
-"""return a rql to fetch all entities of the class type"""
+st = cls.fetch_rqlst(user, mainvar=mainvar, fetchattrs=fetchattrs,
-# XXX update api and implementation to AST manipulation (see unrelated rql)
+settype=settype, ordermethod=ordermethod)
-restrictions = restriction or []
+rql = st.as_string()
+if restriction:
+# cannot use RQLRewriter API to insert 'X rtype %(x)s' restriction
+warn('[3.14] fetch_rql: use of `restriction` parameter is '
+'deprecated, please use fetch_rqlst and supply a syntax'
+'tree with your restriction instead', DeprecationWarning)
+insert = ' WHERE ' + ','.join(restriction)
+if ' WHERE ' in rql:
+select, where = rql.split(' WHERE ', 1)
+rql = select + insert + ',' + where
+else:
+rql += insert
+return rql
+@classmethod
+def fetch_rqlst(cls, user, select=None, mainvar='X', fetchattrs=None,
+settype=True, ordermethod='fetch_order'):
+if select is None:
+select = Select()
+mainvar = select.get_variable(mainvar)
+select.add_selected(mainvar)
+elif isinstance(mainvar, basestring):
+assert mainvar in select.defined_vars
+mainvar = select.get_variable(mainvar)
+# eases string -> syntax tree test transition: please remove once stable
+select._varmaker = rqlvar_maker(defined=select.defined_vars,
+aliases=select.aliases, index=26)
 if settype:
-restrictions.append('%s is %s' % (mainvar, cls.__regid__))
+select.add_type_restriction(mainvar, cls.__regid__)
 if fetchattrs is None:
 fetchattrs = cls.fetch_attrs
-selection = [mainvar]
+cls._fetch_restrictions(mainvar, select, fetchattrs, user, ordermethod)
-orderby = []
+return select
-# start from 26 to avoid possible conflicts with X
-# XXX not enough to be sure it'll be no conflicts
-varmaker = rqlvar_maker(index=26)
-cls._fetch_restrictions(mainvar, varmaker, fetchattrs, selection,
-orderby, restrictions, user, ordermethod)
-rql = 'Any %s' % ','.join(selection)
-if orderby:
-rql +=  ' ORDERBY %s' % ','.join(orderby)
-rql += ' WHERE %s' % ', '.join(restrictions)
-return rql
 @classmethod
-def _fetch_restrictions(cls, mainvar, varmaker, fetchattrs,
+def _fetch_ambiguous_rtypes(cls, select, var, fetchattrs, subjtypes, schema):
-selection, orderby, restrictions, user,
+"""find rtypes in `fetchattrs` that relate different subject etypes
-ordermethod='fetch_order', visited=None):
+taken from (`subjtypes`) to different target etypes; these so called
+"ambiguous" relations, are added directly to the `select` syntax tree
+selection but removed from `fetchattrs` to avoid the fetch recursion
+because we have to choose only one targettype for the recursion and
+adding its own fetch attrs to the selection -when we recurse- would
+filter out the other possible target types from the result set
+"""
+for attr in fetchattrs.copy():
+rschema = schema.rschema(attr)
+if rschema.final:
+continue
+ttypes = None
+for subjtype in subjtypes:
+cur_ttypes = set(rschema.objects(subjtype))
+if ttypes is None:
+ttypes = cur_ttypes
+elif cur_ttypes != ttypes:
+# we found an ambiguous relation: remove it from fetchattrs
+fetchattrs.remove(attr)
+# ... and add it to the selection
+targetvar = select.make_variable()
+select.add_selected(targetvar)
+rel = make_relation(var, attr, (targetvar,), VariableRef)
+select.add_restriction(rel)
+break
+@classmethod
+def _fetch_restrictions(cls, mainvar, select, fetchattrs,
+user, ordermethod='fetch_order', visited=None):
 eschema = cls.e_schema
 if visited is None:
 visited = set((eschema.type,))
 elif eschema.type in visited:
 # avoid infinite recursion
 attr, cls.__regid__)
 continue
 rdef = eschema.rdef(attr)
 if not user.matching_groups(rdef.get_groups('read')):
 continue
-var = varmaker.next()
+if rschema.final or rdef.cardinality[0] in '?1':
-selection.append(var)
+var = select.make_variable()
-restriction = '%s %s %s' % (mainvar, attr, var)
+select.add_selected(var)
-restrictions.append(restriction)
+rel = make_relation(mainvar, attr, (var,), VariableRef)
+select.add_restriction(rel)
+else:
+cls.warning('bad relation %s specified in fetch attrs for %s',
+attr, cls)
+continue
 if not rschema.final:
-card = rdef.cardinality[0]
-if card not in '?1':
-cls.warning('bad relation %s specified in fetch attrs for %s',
-attr, cls)
-selection.pop()
-restrictions.pop()
-continue
 # XXX we need outer join in case the relation is not mandatory
 # (card == '?')  *or if the entity is being added*, since in
 # that case the relation may still be missing. As we miss this
 # later information here, systematically add it.
-restrictions[-1] += '?'
+rel.change_optional('right')
 targettypes = rschema.objects(eschema.type)
-# XXX user._cw.vreg iiiirk
+vreg = user._cw.vreg # XXX user._cw.vreg iiiirk
-etypecls = user._cw.vreg['etypes'].etype_class(targettypes[0])
+etypecls = vreg['etypes'].etype_class(targettypes[0])
 if len(targettypes) > 1:
 # find fetch_attrs common to all destination types
-fetchattrs = user._cw.vreg['etypes'].fetch_attrs(targettypes)
+fetchattrs = vreg['etypes'].fetch_attrs(targettypes)
-remove_ambiguous_rels(fetchattrs, targettypes, user._cw.vreg.schema)
+# ... and handle ambiguous relations
+cls._fetch_ambiguous_rtypes(select, var, fetchattrs,
+targettypes, vreg.schema)
 else:
 fetchattrs = etypecls.fetch_attrs
-etypecls._fetch_restrictions(var, varmaker, fetchattrs,
+etypecls._fetch_restrictions(var, select, fetchattrs,
-selection, orderby, restrictions,
 user, ordermethod, visited=visited)
 if ordermethod is not None:
-orderterm = getattr(cls, ordermethod)(attr, var)
+try:
-if orderterm:
+cmeth = getattr(cls, ordermethod)
-orderby.append(orderterm)
+warn('[3.14] %s %s class method should be renamed to cw_%s'
-return selection, orderby, restrictions
+% (cls.__regid__, ordermethod, ordermethod),
+DeprecationWarning)
+except AttributeError:
+cmeth = getattr(cls, 'cw_' + ordermethod)
+if support_args(cmeth, 'select'):
+cmeth(select, attr, var)
+else:
+warn('[3.14] %s should now take (select, attr, var) and '
+'modify the syntax tree when desired instead of '
+'returning something' % cmeth, DeprecationWarning)
+orderterm = cmeth(attr, var.name)
+if orderterm is not None:
+try:
+var, order = orderterm.split()
+except ValueError:
+if '(' in orderterm:
+cls.error('ignore %s until %s is upgraded',
+orderterm, cmeth)
+orderterm = None
+elif not ' ' in orderterm.strip():
+var = orderterm
+order = 'ASC'
+if orderterm is not None:
+select.add_sort_var(select.get_variable(var),
+order=='ASC')
 @classmethod
 @cached
-def _rest_attr_info(cls):
+def cw_rest_attr_info(cls):
+"""this class method return an attribute name to be used in URL for
+entities of this type and a boolean flag telling if its value should be
+checked for uniqness.
+The attribute returned is, in order of priority:
+* class's `rest_attr` class attribute
+* an attribute defined as unique in the class'schema
+* 'eid'
+"""
 mainattr, needcheck = 'eid', True
 if cls.rest_attr:
 mainattr = cls.rest_attr
 needcheck = not cls.e_schema.has_unique_values(mainattr)
 else:
 for rschema in cls.e_schema.subject_relations():
-if rschema.final and rschema != 'eid' and cls.e_schema.has_unique_values(rschema):
+if rschema.final and rschema != 'eid' \
+and cls.e_schema.has_unique_values(rschema):
 mainattr = str(rschema)
 needcheck = False
 break
 if mainattr == 'eid':
 needcheck = False
 def __json_encode__(self):
 """custom json dumps hook to dump the entity's eid
 which is not part of dict structure itself
 """
-dumpable = dict(self)
+dumpable = self.cw_attr_cache.copy()
 dumpable['eid'] = self.eid
 return dumpable
 def cw_adapt_to(self, interface):
 """return an adapter the entity to the given interface name.
 return self.cwuri # XXX consider kwargs?
 if sourcemeta.get('base-url'):
 kwargs['base_url'] = sourcemeta['base-url']
 use_ext_id = True
 if method in (None, 'view'):
-try:
+kwargs['_restpath'] = self.rest_path(use_ext_id)
-kwargs['_restpath'] = self.rest_path(use_ext_id)
-except TypeError:
-warn('[3.4] %s: rest_path() now take use_ext_eid argument, '
-'please update' % self.__regid__, DeprecationWarning)
-kwargs['_restpath'] = self.rest_path()
 else:
 kwargs['rql'] = 'Any X WHERE X eid %s' % self.eid
 return self._cw.build_url(method, **kwargs)
 def rest_path(self, use_ext_eid=False): # XXX cw_rest_path
 """returns a REST-like (relative) path for this entity"""
-mainattr, needcheck = self._rest_attr_info()
+mainattr, needcheck = self.cw_rest_attr_info()
 etype = str(self.e_schema)
 path = etype.lower()
 if mainattr != 'eid':
 value = getattr(self, mainattr)
 if not can_use_rest_path(value):
 if attrformat:
 encoding = self.cw_attr_metadata(attr, 'encoding')
 return self._cw_mtc_transform(value.getvalue(), attrformat, format,
 encoding)
 return u''
-value = printable_value(self._cw, attrtype, value, props,
+value = self._cw.printable_value(attrtype, value, props,
 displaytime=displaytime)
 if format == 'text/html':
 value = xml_escape(value)
 return value
 def _cw_mtc_transform(self, data, format, target_format, encoding,
 By default meta and composite relations are skipped.
 Overrides this if you want another behaviour
 """
 assert self.has_eid()
 execute = self._cw.execute
+skip_copy_for = {'subject': set(), 'object': set()}
+for rtype in self.skip_copy_for:
+skip_copy_for['subject'].add(rtype)
+warn('[3.14] skip_copy_for on entity classes (%s) is deprecated, '
+'use cw_skip_for instead with list of couples (rtype, role)' % self.__regid__,
+DeprecationWarning)
+for rtype, role in self.cw_skip_copy_for:
+assert role in ('subject', 'object'), role
+skip_copy_for[role].add(rtype)
 for rschema in self.e_schema.subject_relations():
 if rschema.final or rschema.meta:
 continue
 # skip already defined relations
 if getattr(self, rschema.type):
 continue
-if rschema.type in self.skip_copy_for:
+if rschema.type in skip_copy_for['subject']:
 continue
 # skip composite relation
 rdef = self.e_schema.rdef(rschema)
 if rdef.composite:
 continue
 for rschema in self.e_schema.object_relations():
 if rschema.meta:
 continue
 # skip already defined relations
 if self.related(rschema.type, 'object'):
+continue
+if rschema.type in skip_copy_for['object']:
 continue
 rdef = self.e_schema.rdef(rschema, 'object')
 # skip composite relation
 if rdef.composite:
 continue
 continue
 # case where attribute must be completed, but is not yet in entity
 var = varmaker.next()
 rql.append('%s %s %s' % (V, attr, var))
 selected.append((attr, var))
-# +1 since this doen't include the main variable
+# +1 since this doesn't include the main variable
 lastattr = len(selected) + 1
 # don't fetch extra relation if attributes specified or of the entity is
 # coming from an external source (may lead to error)
 if attributes is None and self.cw_metainformation()['source']['uri'] == 'system':
 # fetch additional relations (restricted to 0..1 relations)
 if True, the entites are returned; if False, a result set is returned
 :param safe:
 if True, an empty rset/list of entities will be returned in case of
 :exc:`Unauthorized`, else (the default), the exception is propagated
 """
+rtype = str(rtype)
 try:
 return self._cw_relation_cache(rtype, role, entities, limit)
 except KeyError:
 pass
 if not self.has_eid():
 rset = self._cw.empty_rset()
 self.cw_set_relation_cache(rtype, role, rset)
 return self.related(rtype, role, limit, entities)
 def cw_related_rql(self, rtype, role='subject', targettypes=None):
-rschema = self._cw.vreg.schema[rtype]
+vreg = self._cw.vreg
+rschema = vreg.schema[rtype]
+select = Select()
+mainvar, evar = select.get_variable('X'), select.get_variable('E')
+select.add_selected(mainvar)
+select.add_eid_restriction(evar, 'x', 'Substitute')
 if role == 'subject':
-restriction = 'E eid %%(x)s, E %s X' % rtype
+rel = make_relation(evar, rtype, (mainvar,), VariableRef)
+select.add_restriction(rel)
 if targettypes is None:
 targettypes = rschema.objects(self.e_schema)
 else:
-restriction += ', X is IN (%s)' % ','.join(targettypes)
+select.add_constant_restriction(mainvar, 'is',
-card = greater_card(rschema, (self.e_schema,), targettypes, 0)
+targettypes, 'etype')
+gcard = greater_card(rschema, (self.e_schema,), targettypes, 0)
 else:
-restriction = 'E eid %%(x)s, X %s E' % rtype
+rel = make_relation(mainvar, rtype, (evar,), VariableRef)
+select.add_restriction(rel)
 if targettypes is None:
 targettypes = rschema.subjects(self.e_schema)
 else:
-restriction += ', X is IN (%s)' % ','.join(targettypes)
+select.add_constant_restriction(mainvar, 'is', targettypes,
-card = greater_card(rschema, targettypes, (self.e_schema,), 1)
+'etype')
-etypecls = self._cw.vreg['etypes'].etype_class(targettypes[0])
+gcard = greater_card(rschema, targettypes, (self.e_schema,), 1)
+etypecls = vreg['etypes'].etype_class(targettypes[0])
 if len(targettypes) > 1:
-fetchattrs = self._cw.vreg['etypes'].fetch_attrs(targettypes)
+fetchattrs = vreg['etypes'].fetch_attrs(targettypes)
-# XXX we should fetch ambiguous relation objects too but not
+self._fetch_ambiguous_rtypes(select, mainvar, fetchattrs,
-# recurse on them in _fetch_restrictions; it is easier to remove
+targettypes, vreg.schema)
-# them completely for now, as it would require an deeper api rewrite
-remove_ambiguous_rels(fetchattrs, targettypes, self._cw.vreg.schema)
 else:
 fetchattrs = etypecls.fetch_attrs
-rql = etypecls.fetch_rql(self._cw.user, [restriction], fetchattrs,
+etypecls.fetch_rqlst(self._cw.user, select, mainvar, fetchattrs,
 settype=False)
 # optimisation: remove ORDERBY if cardinality is 1 or ? (though
 # greater_card return 1 for those both cases)
-if card == '1':
+if gcard == '1':
-if ' ORDERBY ' in rql:
+select.remove_sort_terms()
-rql = '%s WHERE %s' % (rql.split(' ORDERBY ', 1)[0],
+elif not select.orderby:
-rql.split(' WHERE ', 1)[1])
+# if modification_date is already retrieved, we use it instead
-elif not ' ORDERBY ' in rql:
+# of adding another variable for sorting. This should not be
-args = rql.split(' WHERE ', 1)
+# problematic, but it is with sqlserver, see ticket #694445
-# if modification_date already retrieved, we should use it instead
+for rel in select.where.get_nodes(RqlRelation):
-# of adding another variable for sort. This should be be problematic
+if (rel.r_type == 'modification_date'
-# but it's actually with sqlserver, see ticket #694445
+and rel.children[0].variable == mainvar
-if 'X modification_date ' in args[1]:
+and rel.children[1].operator == '='):
-var = args[1].split('X modification_date ', 1)[1].split(',', 1)[0]
+var = rel.children[1].children[0].variable
-args.insert(1, var.strip())
+select.add_sort_var(var, asc=False)
-rql = '%s ORDERBY %s DESC WHERE %s' % tuple(args)
+break
 else:
-rql = '%s ORDERBY Z DESC WHERE X modification_date Z, %s' % \
+mdvar = select.make_variable()
-tuple(args)
+rel = make_relation(mainvar, 'modification_date',
-return rql
+(mdvar,), VariableRef)
+select.add_restriction(rel)
+select.add_sort_var(mdvar, asc=False)
+return select.as_string()
 # generic vocabulary methods ##############################################
 def cw_unrelated_rql(self, rtype, targettype, role, ordermethod=None,
-vocabconstraints=True):
+vocabconstraints=True, lt_infos={}):
 """build a rql to fetch `targettype` entities unrelated to this entity
 using (rtype, role) relation.
 Consider relation permissions so that returned entities may be actually
 linked by `rtype`.
+`lt_infos` are supplementary informations, usually coming from __linkto
+parameter, that can help further restricting the results in case current
+entity is not yet created. It is a dict describing entities the current
+entity will be linked to, which keys are (rtype, role) tuples and values
+are a list of eids.
 """
 ordermethod = ordermethod or 'fetch_unrelated_order'
-if isinstance(rtype, basestring):
+rschema = self._cw.vreg.schema.rschema(rtype)
-rtype = self._cw.vreg.schema.rschema(rtype)
+rdef = rschema.role_rdef(self.e_schema, targettype, role)
-rdef = rtype.role_rdef(self.e_schema, targettype, role)
 rewriter = RQLRewriter(self._cw)
+select = Select()
 # initialize some variables according to the `role` of `self` in the
-# relation:
+# relation (variable names must respect constraints conventions):
-# * variable for myself (`evar`) and searched entities (`searchvedvar`)
+# * variable for myself (`evar`)
-# * entity type of the subject (`subjtype`) and of the object
+# * variable for searched entities (`searchvedvar`)
-#   (`objtype`) of the relation
 if role == 'subject':
-evar, searchedvar = 'S', 'O'
+evar = subjvar = select.get_variable('S')
-subjtype, objtype = self.e_schema, targettype
+searchedvar = objvar = select.get_variable('O')
 else:
-searchedvar, evar = 'S', 'O'
+searchedvar = subjvar = select.get_variable('S')
-objtype, subjtype = self.e_schema, targettype
+evar = objvar = select.get_variable('O')
-# initialize some variables according to `self` existance
+select.add_selected(searchedvar)
+# initialize some variables according to `self` existence
 if rdef.role_cardinality(neg_role(role)) in '?1':
 # if cardinality in '1?', we want a target entity which isn't
 # already linked using this relation
-if searchedvar == 'S':
+variable = select.make_variable()
-restriction = ['NOT S %s ZZ' % rtype]
+if role == 'subject':
-else:
+rel = make_relation(variable, rtype, (searchedvar,), VariableRef)
-restriction = ['NOT ZZ %s O' % rtype]
+else:
+rel = make_relation(searchedvar, rtype, (variable,), VariableRef)
+select.add_restriction(Not(rel))
 elif self.has_eid():
 # elif we have an eid, we don't want a target entity which is
 # already linked to ourself through this relation
-restriction = ['NOT S %s O' % rtype]
+rel = make_relation(subjvar, rtype, (objvar,), VariableRef)
-else:
+select.add_restriction(Not(rel))
-restriction = []
 if self.has_eid():
-restriction += ['%s eid %%(x)s' % evar]
+rel = make_relation(evar, 'eid', ('x', 'Substitute'), Constant)
+select.add_restriction(rel)
 args = {'x': self.eid}
 if role == 'subject':
 sec_check_args = {'fromeid': self.eid}
 else:
 sec_check_args = {'toeid': self.eid}
 existant = None # instead of 'SO', improve perfs
 else:
 args = {}
 sec_check_args = {}
-existant = searchedvar
+existant = searchedvar.name
-# retreive entity class for targettype to compute base rql
+# undefine unused evar, or the type resolver will consider it
+select.undefine_variable(evar)
+# retrieve entity class for targettype to compute base rql
 etypecls = self._cw.vreg['etypes'].etype_class(targettype)
-rql = etypecls.fetch_rql(self._cw.user, restriction,
+etypecls.fetch_rqlst(self._cw.user, select, searchedvar,
-mainvar=searchedvar, ordermethod=ordermethod)
+ordermethod=ordermethod)
-select = self._cw.vreg.parse(self._cw, rql, args).children[0]
+# from now on, we need variable type resolving
+self._cw.vreg.solutions(self._cw, select, args)
 # insert RQL expressions for schema constraints into the rql syntax tree
 if vocabconstraints:
 # RQLConstraint is a subclass for RQLVocabularyConstraint, so they
 # will be included as well
 cstrcls = RQLVocabularyConstraint
 else:
 cstrcls = RQLConstraint
+lt_infos = pruned_lt_info(self.e_schema, lt_infos or {})
+# if there are still lt_infos, use set to keep track of added eid
+# relations (adding twice the same eid relation is incorrect RQL)
+eidvars = set()
 for cstr in rdef.constraints:
 # consider constraint.mainvars to check if constraint apply
-if isinstance(cstr, cstrcls) and searchedvar in cstr.mainvars:
+if isinstance(cstr, cstrcls) and searchedvar.name in cstr.mainvars:
-if not self.has_eid() and evar in cstr.mainvars:
+if not self.has_eid():
-continue
+if lt_infos:
+# we can perhaps further restrict with linkto infos using
+# a custom constraint built from cstr and lt_infos
+cstr = build_cstr_with_linkto_infos(
+cstr, args, searchedvar, evar, lt_infos, eidvars)
+if cstr is None:
+continue # could not build constraint -> discard
+elif evar.name in cstr.mainvars:
+continue
 # compute a varmap suitable to RQLRewriter.rewrite argument
-varmap = dict((v, v) for v in 'SO' if v in select.defined_vars
+varmap = dict((v, v) for v in (searchedvar.name, evar.name)
-and v in cstr.mainvars)
+if v in select.defined_vars and v in cstr.mainvars)
 # rewrite constraint by constraint since we want a AND between
 # expressions.
 rewriter.rewrite(select, [(varmap, (cstr,))], select.solutions,
 args, existant)
 # insert security RQL expressions granting the permission to 'add' the
 # relation into the rql syntax tree, if necessary
 rqlexprs = rdef.get_rqlexprs('add')
 if rqlexprs and not rdef.has_perm(self._cw, 'add', **sec_check_args):
 # compute a varmap suitable to RQLRewriter.rewrite argument
-varmap = dict((v, v) for v in 'SO' if v in select.defined_vars)
+varmap = dict((v, v) for v in (searchedvar.name, evar.name)
+if v in select.defined_vars)
 # rewrite all expressions at once since we want a OR between them.
 rewriter.rewrite(select, [(varmap, rqlexprs)], select.solutions,
 args, existant)
 # ensure we have an order defined
 if not select.orderby:
-select.add_sort_var(select.defined_vars[searchedvar])
+select.add_sort_var(select.defined_vars[searchedvar.name])
 # we're done, turn the rql syntax tree as a string
 rql = select.as_string()
 return rql, args
 def unrelated(self, rtype, targettype, role='subject', limit=None,
-ordermethod=None): # XXX .cw_unrelated
+ordermethod=None, lt_infos={}): # XXX .cw_unrelated
 """return a result set of target type objects that may be related
 by a given relation, with self as subject or object
 """
 try:
-rql, args = self.cw_unrelated_rql(rtype, targettype, role, ordermethod)
+rql, args = self.cw_unrelated_rql(rtype, targettype, role,
+ordermethod, lt_infos=lt_infos)
 except Unauthorized:
 return self._cw.empty_rset()
 # XXX should be set in unrelated rql when manipulating the AST
 if limit is not None:
 before, after = rql.split(' WHERE ', 1)

branch	stable
changeset 8124	acc23c284432
parent 7995	9a9f35ef418c
child 8190	2a3c1b787688
child 8199	fb5c0e60a615