cubicweb: comparison cubicweb/server/sources/rql2sql.py

equal deleted inserted replaced

-:25ec9be5f305
+:f32134dd0067
 asol[vname] = origsol[vname]
 if not asol in newsolutions:
 newsolutions.append(asol)
 return newsolutions
-def remove_unused_solutions(rqlst, solutions, varmap, schema):
+def remove_unused_solutions(rqlst, solutions, schema):
 """cleanup solutions: remove solutions where invariant variables are taking
 different types
 """
 newsols = _new_solutions(rqlst, solutions)
 existssols = {}
 unstable = set()
 invariants = {}
 for vname, var in rqlst.defined_vars.items():
 vtype = newsols[0][vname]
-if var._q_invariant or vname in varmap:
+if var._q_invariant:
 # remove invariant variable from solutions to remove duplicates
 # later, then reinserting a type for the variable even later
 for sol in newsols:
 invariants.setdefault(id(sol), {})[vname] = sol.pop(vname)
 elif var.scope is not rqlst:
 self.outer_pending = {}
 self.duplicate_switches = []
 self.aliases = {}
 self.restrictions = []
 self._restr_stack = []
-self.ignore_varmap = False
 self._needs_source_cb = {}
 def merge_source_cbs(self, needs_source_cb):
 if self.needs_source_cb is None:
 self.needs_source_cb = needs_source_cb
 self._lock = threading.Lock()
 if attrmap is None:
 attrmap = {}
 self.attr_map = attrmap
-def generate(self, union, args=None, varmap=None):
+def generate(self, union, args=None):
 """return SQL queries and a variable dictionary from a RQL syntax tree
 :partrqls: a list of couple (rqlst, solutions)
 :args: optional dictionary with values of substitutions used in the query
-:varmap: optional dictionary mapping variable name to a special table
-name, in case the query as to fetch data from temporary tables
 return an sql string and a dictionary with substitutions values
 """
 if args is None:
 args = {}
-if varmap is None:
-varmap =  {}
 self._lock.acquire()
 self._args = args
-self._varmap = varmap
 self._query_attrs = {}
 self._state = None
 # self._not_scope_offset = 0
 try:
 # union query for each rqlst / solution
 sols = select.solutions
 selectsortterms = distinct
 if len(sols) > 1:
 # remove invariant from solutions
 sols, existssols, unstable = remove_unused_solutions(
-select, sols, self._varmap, self.schema)
+select, sols, self.schema)
 if len(sols) > 1:
 # if there is still more than one solution, a UNION will be
 # generated and so sort terms have to be selected
 selectsortterms = True
 # and if select is using group by or aggregat, a wrapping
 else:
 # no variables in the RHS
 sql = self._visit_attribute_relation(relation)
 elif (rtype == 'is' and isinstance(rhs.children[0], Constant)
 and rhs.children[0].eval(self._args) is None):
-# special case "C is NULL"
+lhssql = lhs.accept(self)
-if lhs.name in self._varmap:
-lhssql = self._varmap[lhs.name]
-else:
-lhssql = lhs.accept(self)
 return '%s%s' % (lhssql, rhs.accept(self))
-elif '%s.%s' % (lhs, relation.r_type) in self._varmap:
-# relation has already been processed by a previous step
-return ''
 elif relation.optional:
 # OPTIONAL relation, generate a left|right outer join
 if rtype == 'identity' or rschema.inlined:
 sql = self._visit_outer_join_inlined_relation(relation, rschema)
 else:
 # column != 1234 may not get back rows where column is NULL...
 sql = '(%s IS NULL OR %s!=%s)' % (
 lhssql, lhssql, (rhsvar or rhsconst).accept(self))
 elif rhsconst is not None:
 sql = '%s=%s' % (lhssql, rhsconst.accept(self))
-elif isinstance(rhsvar, Variable) and rhsvar._q_invariant and \
+elif isinstance(rhsvar, Variable) and rhsvar._q_invariant:
-not rhsvar.name in self._varmap:
 # if the rhs variable is only linked to this relation, this mean we
 # only want the relation to exists, eg NOT NULL in case of inlined
 # relation
 if moresql is not None:
 return moresql
 def _process_relation_term(self, relation, rid, termvar, termconst, relfield):
 if termconst or not termvar._q_invariant:
 termsql = termconst and termconst.accept(self) or termvar.accept(self)
 yield '%s.%s=%s' % (rid, relfield, termsql)
 elif termvar._q_invariant:
-# if the variable is mapped, generate restriction anyway
-if termvar.name in self._varmap:
-termsql = termvar.accept(self)
-yield '%s.%s=%s' % (rid, relfield, termsql)
 extrajoin = self._extra_join_sql(relation, '%s.%s' % (rid, relfield), termvar)
 if extrajoin is not None:
 yield extrajoin
 def _visit_relation(self, relation, rschema):
 lhsvar, lhsconst, rhsvar, rhsconst = relation_info(relation)
 assert not (lhsconst and rhsconst), "doesn't make sense"
 attr = 'eid' if relation.r_type == 'identity' else relation.r_type
 lhsalias = self._var_table(lhsvar)
 rhsalias = rhsvar and self._var_table(rhsvar)
-try:
+if lhsalias is None:
-lhssql = self._varmap['%s.%s' % (lhsvar.name, attr)]
+lhssql = lhsconst.accept(self)
-except KeyError:
+elif attr == 'eid':
-if lhsalias is None:
+lhssql = lhsvar.accept(self)
-lhssql = lhsconst.accept(self)
+else:
-elif attr == 'eid':
+lhssql = '%s.%s%s' % (lhsalias, SQL_PREFIX, attr)
-lhssql = lhsvar.accept(self)
-else:
-lhssql = '%s.%s%s' % (lhsalias, SQL_PREFIX, attr)
 condition = '%s=%s' % (lhssql, (rhsconst or rhsvar).accept(self))
 # this is not a typo, rhs optional variable means lhs outer join and vice-versa
 if relation.optional == 'left':
 lhsvar, rhsvar = rhsvar, lhsvar
 lhsconst, rhsconst = rhsconst, lhsconst
 (eg X attr1 A, Y attr2 A). In case of selection, nothing to do here.
 """
 ored = relation.ored()
 for vref in rhs_vars:
 var = vref.variable
-if var.name in self._varmap:
-# ensure table is added
-self._var_info(var)
 if isinstance(var, ColumnAlias):
 # force sql generation whatever the computed principal
 principal = 1
 else:
 principal = var.stinfo.get('principal')
 if not rel is principal][0]
 else:
 _rel = relation
 lhssql = self._inlined_var_sql(_rel.children[0].variable,
 _rel.r_type)
-try:
+sql = lhssql + relation.children[1].accept(self)
-self._state.ignore_varmap = True
-sql = lhssql + relation.children[1].accept(self)
-finally:
-self._state.ignore_varmap = False
 if relation.optional == 'right':
 leftalias = self._var_table(principal.children[0].variable)
 rightalias = self._var_table(relation.children[0].variable)
 self._state.replace_tables_by_outer_join(
 leftalias, rightalias, 'LEFT', sql)
 table = self._var_table(lhs.variable)
 if table is None:
 assert rel.r_type == 'eid'
 lhssql = lhs.accept(self)
 else:
-try:
+mapkey = '%s.%s' % (self._state.solution[lhs.name], rel.r_type)
-lhssql = self._varmap['%s.%s' % (lhs.name, rel.r_type)]
+if mapkey in self.attr_map:
-except KeyError:
+cb, sourcecb = self.attr_map[mapkey]
-mapkey = '%s.%s' % (self._state.solution[lhs.name], rel.r_type)
+if sourcecb:
-if mapkey in self.attr_map:
+# callback is a source callback, we can't use this
-cb, sourcecb = self.attr_map[mapkey]
+# attribute in restriction
-if sourcecb:
+raise QueryError("can't use %s (%s) in restriction"
-# callback is a source callback, we can't use this
+% (mapkey, rel.as_string()))
-# attribute in restriction
+lhssql = cb(self, lhs.variable, rel)
-raise QueryError("can't use %s (%s) in restriction"
+elif rel.r_type == 'eid':
-% (mapkey, rel.as_string()))
+lhssql = lhs.variable._q_sql
-lhssql = cb(self, lhs.variable, rel)
+else:
-elif rel.r_type == 'eid':
+lhssql = '%s.%s%s' % (table, SQL_PREFIX, rel.r_type)
-lhssql = lhs.variable._q_sql
-else:
-lhssql = '%s.%s%s' % (table, SQL_PREFIX, rel.r_type)
 try:
 if rel._q_needcast == 'TODAY':
 sql = 'DATE(%s)%s' % (lhssql, rhssql)
 # XXX which cast function should be used
 #elif rel._q_needcast == 'NOW':
 me_is_principal = lhsvar.stinfo.get('principal') is rel
 if me_is_principal:
 if lhsvar.stinfo['typerel'] is None:
 # the variable is using the fti table, no join needed
 jointo = None
-elif not lhsvar.name in self._varmap:
+else:
 # join on entities instead of etype's table to get result for
 # external entities on multisources configurations
 ealias = lhsvar._q_sqltable = '_' + lhsvar.name
 jointo = lhsvar._q_sql = '%s.eid' % ealias
 self._state.add_table('entities AS %s' % ealias, ealias)
 rel = constant.relation()
 if rel is not None:
 rel._q_needcast = value
 return self.keyword_map[value]()
 if constant.type == 'Substitute':
-try:
+_id = value
-# we may found constant from simplified var in varmap
+if PY2 and isinstance(_id, unicode):
-return self._mapped_term(constant, '%%(%s)s' % value)[0]
+_id = _id.encode()
-except KeyError:
-_id = value
-if PY2 and isinstance(_id, unicode):
-_id = _id.encode()
 else:
 _id = str(id(constant)).replace('-', '', 1)
 self._query_attrs[_id] = value
 return '%%(%s)s' % _id
 # use accept, .variable may be a variable or a columnalias
 return variableref.variable.accept(self)
 def visit_columnalias(self, colalias):
 """get the sql name for a subquery column alias"""
-if colalias.name in self._varmap:
-sql = self._varmap[colalias.name]
-table = sql.split('.', 1)[0]
-colalias._q_sqltable = table
-colalias._q_sql = sql
-self._state.add_table(table)
-return sql
 return colalias._q_sql
 def visit_variable(self, variable):
 """get the table name and sql string for a variable"""
 #if contextrels is None and variable.name in self._state.done:
 if self._in_wrapping_query:
 return 'T1.%s' % self._state.aliases[variable.name]
 return variable._q_sql
 self._state.done.add(variable.name)
 vtablename = None
-if not self._state.ignore_varmap and variable.name in self._varmap:
+if variable.stinfo['attrvar']:
-sql, vtablename = self._var_info(variable)
-elif variable.stinfo['attrvar']:
 # attribute variable (systematically used in rhs of final
 # relation(s)), get table name and sql from any rhs relation
 sql = self._linked_var_sql(variable)
 elif variable._q_invariant:
 # since variable is invariant, we know we won't found final relation
 # no principal defined, relation is necessarily the principal and
 # so nothing to return here
 pass
 return None
-def _temp_table_scope(self, select, table):
+def _var_info(self, var):
-scope = 9999
+scope = self._state.scopes[var.scope]
-for var, sql in self._varmap.items():
+etype = self._state.solution[var.name]
-# skip "attribute variable" in varmap (such 'T.login')
+# XXX this check should be moved in rql.stcheck
-if not '.' in var and table == sql.split('.', 1)[0]:
+if self.schema.eschema(etype).final:
-try:
+raise BadRQLQuery(var.stmt.root)
-scope = min(scope, self._state.scopes[select.defined_vars[var].scope])
+tablealias = '_' + var.name
-except KeyError:
+sql = '%s.%seid' % (tablealias, SQL_PREFIX)
-scope = 0 # XXX
+self._state.add_table('%s%s AS %s' % (SQL_PREFIX, etype, tablealias),
-if scope == 0:
+tablealias, scope=scope)
-break
-return scope
-def _mapped_term(self, term, key):
-"""return sql and table alias to the `term`, mapped as `key` or raise
-KeyError when the key is not found in the varmap
-"""
-sql = self._varmap[key]
-tablealias = sql.split('.', 1)[0]
-scope = self._temp_table_scope(term.stmt, tablealias)
-self._state.add_table(tablealias, scope=scope)
 return sql, tablealias
-def _var_info(self, var):
-try:
-return self._mapped_term(var, var.name)
-except KeyError:
-scope = self._state.scopes[var.scope]
-etype = self._state.solution[var.name]
-# XXX this check should be moved in rql.stcheck
-if self.schema.eschema(etype).final:
-raise BadRQLQuery(var.stmt.root)
-tablealias = '_' + var.name
-sql = '%s.%seid' % (tablealias, SQL_PREFIX)
-self._state.add_table('%s%s AS %s' % (SQL_PREFIX, etype, tablealias),
-tablealias, scope=scope)
-return sql, tablealias
 def _inlined_var_sql(self, var, rtype):
-try:
+# rtype may be an attribute relation when called from
-sql = self._varmap['%s.%s' % (var.name, rtype)]
+# _visit_var_attr_relation.  take care about 'eid' rtype, since in
-scope = self._state.scopes[var.scope]
+# some case we may use the `entities` table, so in that case we've
-self._state.add_table(sql.split('.', 1)[0], scope=scope)
+# to properly use variable'sql
-except KeyError:
+if rtype == 'eid':
-# rtype may be an attribute relation when called from
+sql = var.accept(self)
-# _visit_var_attr_relation.  take care about 'eid' rtype, since in
+else:
-# some case we may use the `entities` table, so in that case we've
+sql = '%s.%s%s' % (self._var_table(var), SQL_PREFIX, rtype)
-# to properly use variable'sql
-if rtype == 'eid':
-sql = var.accept(self)
-else:
-sql = '%s.%s%s' % (self._var_table(var), SQL_PREFIX, rtype)
 return sql
 def _linked_var_sql(self, variable):
-if not self._state.ignore_varmap:
-try:
-return self._varmap[variable.name]
-except KeyError:
-pass
 rel = (variable.stinfo.get('principal') or
 next(iter(variable.stinfo['rhsrelations'])))
 linkedvar = rel.children[0].variable
 if rel.r_type == 'eid':
 return linkedvar.accept(self)
 if isinstance(linkedvar, ColumnAlias):
 raise BadRQLQuery('variable %s should be selected by the subquery'
 % variable.name)
-try:
+mapkey = '%s.%s' % (self._state.solution[linkedvar.name], rel.r_type)
-sql = self._varmap['%s.%s' % (linkedvar.name, rel.r_type)]
+if mapkey in self.attr_map:
-except KeyError:
+cb, sourcecb = self.attr_map[mapkey]
-mapkey = '%s.%s' % (self._state.solution[linkedvar.name], rel.r_type)
+if not sourcecb:
-if mapkey in self.attr_map:
+return cb(self, linkedvar, rel)
-cb, sourcecb = self.attr_map[mapkey]
+# attribute mapped at the source level (bfss for instance)
-if not sourcecb:
+stmt = rel.stmt
-return cb(self, linkedvar, rel)
+for selectidx, vref in iter_mapped_var_sels(stmt, variable):
-# attribute mapped at the source level (bfss for instance)
+stack = [cb]
-stmt = rel.stmt
+update_source_cb_stack(self._state, stmt, vref, stack)
-for selectidx, vref in iter_mapped_var_sels(stmt, variable):
+self._state._needs_source_cb[selectidx] = stack
-stack = [cb]
+linkedvar.accept(self)
-update_source_cb_stack(self._state, stmt, vref, stack)
+return '%s.%s%s' % (linkedvar._q_sqltable, SQL_PREFIX, rel.r_type)
-self._state._needs_source_cb[selectidx] = stack
-linkedvar.accept(self)
-sql = '%s.%s%s' % (linkedvar._q_sqltable, SQL_PREFIX, rel.r_type)
-return sql
 # tables handling #########################################################
 def _var_table(self, var):
 var.accept(self)#.visit_variable(var)

changeset 11237	f32134dd0067
parent 11057	0b59724cb3f2
child 11301	a76feec0a861