cubicweb: comparison cubicweb/server/rqlannotation.py

equal deleted inserted replaced

-:be23c3813bbf
+:670aa9bf0b6c
-# copyright 2003-2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2016 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
 # You should have received a copy of the GNU Lesser General Public License along
 # with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.
 """Functions to add additional annotations on a rql syntax tree to ease later
 code generation.
 """
 from __future__ import print_function
-__docformat__ = "restructuredtext en"
 from rql import BadRQLQuery
-from rql.nodes import Relation, VariableRef, Constant, Variable, Or, Exists
+from rql.nodes import Relation, VariableRef, Constant, Variable, Or
 from rql.utils import common_parent
 def _annotate_select(annotator, rqlst):
 has_text_query = False
 for subquery in rqlst.with_:
 if annotator._annotate_union(subquery.query):
 has_text_query = True
-#if server.DEBUG:
-#    print '-------- sql annotate', repr(rqlst)
 getrschema = annotator.schema.rschema
 for var in rqlst.defined_vars.values():
 stinfo = var.stinfo
 if stinfo.get('ftirels'):
 has_text_query = True
 # those particular queries should be executed using the system
 # entities table unless there is some type restriction
 stinfo['invariant'] = True
 stinfo['principal'] = None
 continue
-if any(rel for rel in stinfo['relations'] if rel.r_type == 'eid' and rel.operator() != '=') and \
+if (any(rel for rel in stinfo['relations'] if rel.r_type == 'eid' and rel.operator() != '=')
-not any(r for r in var.stinfo['relations'] - var.stinfo['rhsrelations']
+and not any(r for r in var.stinfo['relations'] - var.stinfo['rhsrelations']
-if r.r_type != 'eid' and (getrschema(r.r_type).inlined or getrschema(r.r_type).final)):
+if r.r_type != 'eid'
+and (getrschema(r.r_type).inlined or getrschema(r.r_type).final))):
 # Any X WHERE X eid > 2
 # those particular queries should be executed using the system entities table
 stinfo['invariant'] = True
 stinfo['principal'] = None
 continue
-if stinfo['selected'] and var.valuable_references() == 1+bool(stinfo['constnode']):
+if stinfo['selected'] and var.valuable_references() == 1 + bool(stinfo['constnode']):
 # "Any X", "Any X, Y WHERE X attr Y"
 stinfo['invariant'] = False
 continue
 joins = set()
 invariant = False
 role = 'subject' if onlhs else 'object'
 if rel.r_type == 'eid':
 if not (onlhs and len(stinfo['relations']) > 1):
 break
 if not stinfo['constnode']:
-joins.add( (rel, role) )
+joins.add((rel, role))
 continue
 elif rel.r_type == 'identity':
 # identity can't be used as principal, so check other relation are used
 # XXX explain rhs.operator == '='
-if rhs.operator != '=' or len(stinfo['relations']) <= 1: #(stinfo['constnode'] and rhs.operator == '='):
+if rhs.operator != '=' or len(stinfo['relations']) <= 1:
 break
-joins.add( (rel, role) )
+joins.add((rel, role))
 continue
 rschema = getrschema(rel.r_type)
 if rel.optional:
 if rel in stinfo.get('optrelations', ()):
 # optional variable can't be invariant if this is the lhs
 # variable of an inlined relation
-if not rel in stinfo['rhsrelations'] and rschema.inlined:
+if rel not in stinfo['rhsrelations'] and rschema.inlined:
 break
 # variable used as main variable of an optional relation can't
 # be invariant, unless we can use some other relation as
 # reference for the outer join
 elif not stinfo['constnode']:
 if rschema.final or (onlhs and rschema.inlined):
 if rschema.type != 'has_text':
 # need join anyway if the variable appears in a final or
 # inlined relation
 break
-joins.add( (rel, role) )
+joins.add((rel, role))
 continue
 if not stinfo['constnode']:
 if rschema.inlined and rel.neged(strict=True):
 # if relation is inlined, can't be invariant if that
 # variable is used anywhere else.
 # see 'Any P WHERE NOT N ecrit_par P, N eid 512':
 # sql for 'NOT N ecrit_par P' is 'N.ecrit_par is NULL' so P
 # can use N.ecrit_par as principal
 if (stinfo['selected'] or len(stinfo['relations']) > 1):
 break
-joins.add( (rel, role) )
+joins.add((rel, role))
 else:
 # if there is at least one ambigous relation and no other to
 # restrict types, can't be invariant since we need to filter out
 # other types
 if not annotator.is_ambiguous(var):
 if col_alias.stinfo.get('ftirels'):
 has_text_query = True
 return has_text_query
 class CantSelectPrincipal(Exception):
 """raised when no 'principal' variable can be found"""
-def _select_principal(scope, 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
 return next(iter(_sort(diffscope_rels)))
 # XXX could use a relation from a different scope if it can't generate
 # duplicates, so we should have to check cardinality
 raise CantSelectPrincipal()
 def _select_main_var(relations):
 """given a list of rqlst relations, select one which will be used as main
 relation for the rhs variable
 """
 principal = None
 others = []
 # sort for test predictability
 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') \
+if (rel.operator() not in ('=', 'IS')
-or not isinstance(rel.children[1].children[0], VariableRef) or rel.neged(strict=True):
+or not isinstance(rel.children[1].children[0], VariableRef)
+or rel.neged(strict=True)):
 continue
 if rel.optional:
 others.append(rel)
 continue
 if rel.scope is rel.stmt:
 * it's not used as lhs in any final or inlined relation
 * there is no type restriction on this variable (either explicit in the
 syntax tree or because a solution for this variable has been removed
 due to security filtering)
 """
-#assert rqlst.TYPE == 'select', rqlst
+# assert rqlst.TYPE == 'select', rqlst
 rqlst.has_text_query = self._annotate_union(rqlst)
 def _annotate_union(self, union):
 has_text_query = False
 for select in union.children:
 # This is expected by the rql2sql generator which will use the `entities`
 # table to filter out by type if necessary, This optimisation is very
 # interesting in multi-sources cases, as it may avoid a costly query
 # on sources to get all entities of a given type to achieve this, while
 # we have all the necessary information.
-root = var.stmt.root # Union node
+root = var.stmt.root  # Union node
 # rel.scope -> Select or Exists node, so add .parent to get Union from
 # Select node
 rels = [rel for rel in var.stinfo['relations'] if rel.scope.parent is root]
 if len(rels) == 1 and rels[0].r_type == 'has_text':
 return False
 self.ambiguousvars.remove(var)
 def compute(self, rqlst):
 # set domains for each variable
 for varname, var in rqlst.defined_vars.items():
-if var.stinfo['uidrel'] is not None or \
+if (var.stinfo['uidrel'] is not None
-self.eschema(rqlst.solutions[0][varname]).final:
+or self.eschema(rqlst.solutions[0][varname]).final):
 ptypes = var.stinfo['possibletypes']
 else:
 ptypes = set(self.nfdomain)
 self.ambiguousvars.add(var)
 self.varsols[var] = ptypes
 # no relation to deambiguify
 continue
 def _debug_print(self):
 print('varsols', dict((x, sorted(str(v) for v in values))
 for x, values in self.varsols.items()))
 print('ambiguous vars', sorted(self.ambiguousvars))
 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 \
+if (len(var.stinfo['relations']) == 1
-or rel.scope is var.scope 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,))
 other = onlhs and rhs or lhs
 otheretypes = None
 # XXX isinstance(other.variable, Variable) to skip column alias
 if isinstance(other, VariableRef) and isinstance(other.variable, Variable):
 deambiguifier = other.variable
-if not var is self.deambification_map.get(deambiguifier):
+if var is not self.deambification_map.get(deambiguifier):
 if var.stinfo['typerel'] is None:
 otheretypes = deambiguifier.stinfo['possibletypes']
 elif not self.is_ambiguous(deambiguifier):
 otheretypes = self.varsols[deambiguifier]
 elif deambiguifier in self.not_invariants:

changeset 11703	670aa9bf0b6c
parent 11057	0b59724cb3f2
child 11770	22b854d3e8b2