cubicweb: comparison entity.py

equal deleted inserted replaced

-:163d25c9fdd2
+:aed065b97f12
 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.rset import ResultSet
 from cubicweb.selectors import yes
 from cubicweb.appobject import AppObject
 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_restrictions(cls, mainvar, select, fetchattrs,
-selection, orderby, restrictions, user,
+user, ordermethod='fetch_order', visited=None):
-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
 etypecls = user._cw.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)
 remove_ambiguous_rels(fetchattrs, targettypes, user._cw.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)
+orderterm = getattr(cls, ordermethod)(attr, var.name)
 if orderterm:
-orderby.append(orderterm)
+var, order = orderterm.split()
-return selection, orderby, restrictions
+select.add_sort_var(select.get_variable(var), order=='ASC')
 @classmethod
 @cached
 def _rest_attr_info(cls):
 mainattr, needcheck = 'eid', True
 :param role: is the role played by 'self' in the relation ('subject' or 'object')
 :param limit: resultset's maximum size
 :param entities: if True, the entites are returned; if False, a result set is returned
 """
+rtype = str(rtype)
 try:
 return self._cw_relation_cache(rtype, role, entities, limit)
 except KeyError:
 pass
 if not self.has_eid():
 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]
+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')
-else:
+gcard = greater_card(rschema, (self.e_schema,), targettypes, 0)
-restriction = 'E eid %%(x)s, X %s E' % rtype
+else:
+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)
+'String')
+gcard = greater_card(rschema, targettypes, (self.e_schema,), 1)
 etypecls = self._cw.vreg['etypes'].etype_class(targettypes[0])
 if len(targettypes) > 1:
 fetchattrs = self._cw.vreg['etypes'].fetch_attrs(targettypes)
 # XXX we should fetch ambiguous relation objects too but not
 # recurse on them in _fetch_restrictions; it is easier to remove
-# them completely for now, as it would require an deeper api rewrite
+# them completely for now, as it would require a 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 retreived, 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):
 ordermethod = ordermethod or 'fetch_unrelated_order'
 if isinstance(rtype, basestring):
 rtype = self._cw.vreg.schema.rschema(rtype)
 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')
+select.add_selected(searchedvar)
 # initialize some variables according to `self` existance
 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':
+var = select.get_variable('ZZ') # XXX unname when tests pass
-restriction = ['NOT S %s ZZ' % rtype]
+if role == 'subject':
-else:
+rel = make_relation(var, rtype.type, (searchedvar,), VariableRef)
-restriction = ['NOT ZZ %s O' % rtype]
+else:
+rel = make_relation(searchedvar, rtype.type, (var,), 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.type, (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
 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() and 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,

changeset 7794	aed065b97f12
parent 7702	73cadb5d0097
child 7798	8930f7a284dd