cubicweb: comparison server/rqlannotation.py

equal deleted inserted replaced

-:0aae5216f99e
+:3e133b29a1a4
 __docformat__ = "restructuredtext en"
 from logilab.common.compat import any
 from rql import BadRQLQuery
-from rql.nodes import Relation, VariableRef, Constant, Variable, Or
+from rql.nodes import Relation, VariableRef, Constant, Variable, Or, Exists
 from rql.utils import common_parent
 def _annotate_select(annotator, rqlst):
 for subquery in rqlst.with_:
 annotator._annotate_union(subquery.query)
 #    print '-------- sql annotate', repr(rqlst)
 getrschema = annotator.schema.rschema
 has_text_query = False
 need_distinct = rqlst.distinct
 for rel in rqlst.iget_nodes(Relation):
-if getrschema(rel.r_type).symmetric and not rel.neged(strict=True):
+if getrschema(rel.r_type).symmetric and not isinstance(rel.parent, Exists):
 for vref in rel.iget_nodes(VariableRef):
 stinfo = vref.variable.stinfo
 if not stinfo['constnode'] and stinfo['selected']:
 need_distinct = True
 # XXX could mark as not invariant
 # we have to select a kindof "main" relation which will "extrajoins"
 # the other
 # priority should be given to relation which are not in inner queries
 # (eg exists)
 try:
-stinfo['principal'] = _select_principal(var.sqlscope, joins)
+stinfo['principal'] = _select_principal(var.scope, joins)
 except CantSelectPrincipal:
 stinfo['invariant'] = False
 rqlst.need_distinct = need_distinct
 return has_text_query
 class CantSelectPrincipal(Exception):
 """raised when no 'principal' variable can be found"""
-def _select_principal(sqlscope, relations, _sort=lambda x:x):
+def _select_principal(scope, relations, _sort=lambda x:x):
 """given a list of rqlst relations, select one which will be used to
 represent an invariant variable (e.g. using on extremity of the relation
 instead of the variable's type table
 """
 # _sort argument is there for test
 # note: only eid and has_text among all final relations may be there
 if rel.r_type in ('eid', 'identity'):
 continue
 if rel.ored(traverse_scope=True):
 ored_rels.add(rel)
-elif rel.sqlscope is sqlscope:
+elif rel.scope is scope:
 return rel
 elif not rel.neged(traverse_scope=True):
 diffscope_rels.add(rel)
 if len(ored_rels) > 1:
 ored_rels_copy = tuple(ored_rels)
 continue
 if isinstance(common_parent(rel1, rel2), Or):
 ored_rels.discard(rel1)
 ored_rels.discard(rel2)
 for rel in _sort(ored_rels):
-if rel.sqlscope is sqlscope:
+if rel.scope is scope:
 return rel
 diffscope_rels.add(rel)
 # if DISTINCT query, can use variable from a different scope as principal
 # since introduced duplicates will be removed
-if sqlscope.stmt.distinct and diffscope_rels:
+if scope.stmt.distinct and diffscope_rels:
 return iter(_sort(diffscope_rels)).next()
 # XXX  could use a relation for a different scope if it can't generate
 # duplicates, so we would have to check cardinality
 raise CantSelectPrincipal()
 for rel in sorted(relations, key=lambda x: (x.children[0].name, x.r_type)):
 # only equality relation with a variable as rhs may be principal
 if rel.operator() not in ('=', 'IS') \
 or not isinstance(rel.children[1].children[0], VariableRef):
 continue
-if rel.sqlscope is rel.stmt:
+if rel.scope is rel.stmt:
 return rel
 principal = rel
 if principal is None:
 raise BadRQLQuery('unable to find principal in %s' % ', '.join(
 r.as_string() for r in relations))
 var._q_invariant = False
 else:
 var._q_invariant = True
 else:
 var._q_invariant = False
-for rel in select.iget_nodes(Relation):
-if rel.neged(strict=True) and not rel.is_types_restriction():
-rschema = getrschema(rel.r_type)
-if not rschema.final:
-# if one of the relation's variable is ambiguous but not
-# invariant, an intersection will be necessary
-for vref in rel.get_nodes(VariableRef):
-var = vref.variable
-if (not var._q_invariant and var.valuable_references() == 1
-and len(var.stinfo['possibletypes']) > 1):
-select.need_intersect = True
-break
-else:
-continue
-break
-else:
-select.need_intersect = False
 class SQLGenAnnotator(object):
 def __init__(self, schema):
 self.schema = schema
 return has_text_query
 def is_ambiguous(self, var):
 # ignore has_text relation
 if len([rel for rel in var.stinfo['relations']
-if rel.sqlscope is var.sqlscope and rel.r_type == 'has_text']) == 1:
+if rel.scope is var.scope and rel.r_type == 'has_text']) == 1:
 return False
 try:
 data = var.stmt._deamb_data
 except AttributeError:
 data = var.stmt._deamb_data = IsAmbData(self.schema, self.nfdomain)
 def set_rel_constraint(self, term, rel, etypes_func):
 if isinstance(term, VariableRef) and self.is_ambiguous(term.variable):
 var = term.variable
 if len(var.stinfo['relations']) == 1 \
-or rel.sqlscope is var.sqlscope or rel.r_type == 'identity':
+or rel.scope is var.scope or rel.r_type == 'identity':
 self.restrict(var, frozenset(etypes_func()))
 try:
 self.maydeambrels[var].add(rel)
 except KeyError:
 self.maydeambrels[var] = set((rel,))

branch	stable
changeset 5582	3e133b29a1a4
parent 5426	0d4853a6e5ee
child 6297	23c1e50ff97b