cubicweb: comparison goa/rqlinterpreter.py

equal deleted inserted replaced

-:672acc730ce5
+:d628defebc17
 def etype_from_key(key):
 return Key(key).kind()
 def poss_var_types(myvar, ovar, kind, solutions):
 return frozenset(etypes[myvar] for etypes in solutions
 if etypes[ovar] == kind)
 def expand_result(results, result, myvar, values, dsget=None):
 values = map(dsget, values)
 if values:
 string.append('%s: [%s]' % (k, ', '.join(str(i) for i in v)))
 else:
 string.append('%s: %s' % (k, v))
 return '{%s}' % ', '.join(string)
 class EidMismatch(Exception):
 def __init__(self, varname, value):
 self.varname = varname
 self.value = value
 raise NotImplementedError('unsupported operator')
 self.rel = rel
 self.operator = operator
 self.rtype = rel.r_type
 self.var = rel.children[0]
 def __repr__(self):
 return '<%s for %s>' % (self.__class__.__name__, self.rel)
 @property
 def rhs(self):
 return self.rel.children[1].children[0]
 class MultipleRestriction(object):
 def __init__(self, restrictions):
 self.restrictions = restrictions
 def resolve(self, solutions, fixed):
 return _resolve(self.restrictions, solutions, fixed)
 class VariableSelection(Restriction):
 def __init__(self, rel, dsget, prefix='s'):
 Restriction.__init__(self, rel)
 self._dsget = dsget
 self._not = self.rel.neged(strict=True)
 self._prefix = prefix + '_'
 def __repr__(self):
 return '<%s%s for %s>' % (self._prefix[0], self.__class__.__name__, self.rel)
 @property
 def searched_var(self):
 if self._prefix == 's_':
 return self.var.name
 return self.rhs.name
 @property
 def constraint_var(self):
 if self._prefix == 's_':
 return self.rhs.name
 return self.var.name
 def _possible_values(self, myvar, ovar, entity, solutions, dsprefix):
 if self.rtype == 'identity':
 return (entity.key(),)
 value = entity.get(dsprefix + self.rtype)
 if value is None:
 return []
 if not isinstance(value, list):
 value = [value]
 vartypes = poss_var_types(myvar, ovar, entity.kind(), solutions)
 return (v for v in value if v.kind() in vartypes)
 def complete_and_filter(self, solutions, results):
 myvar = self.rhs.name
 ovar = self.var.name
 rtype = self.rtype
 if self.schema.rschema(rtype).is_final():
 values = self._possible_values(myvar, ovar, result[ovar],
 solutions, 's_')
 expand_result(results, result, myvar, values, self._dsget)
 else:
 assert self.rhs.name in results[0]
 self.object_complete_and_filter(solutions, results)
 def filter(self, solutions, results):
 myvar = self.rhs.name
 ovar = self.var.name
 newsols = {}
 for result in results[:]:
 if not key in newsols:
 values = self._possible_values(myvar, ovar, entity, solutions, 's_')
 newsols[key] = frozenset(v for v in values)
 if self._not:
 if result[myvar].key() in newsols[key]:
 results.remove(result)
 elif not result[myvar].key() in newsols[key]:
 results.remove(result)
 def object_complete_and_filter(self, solutions, results):
 if self._not:
 raise NotImplementedError()
 myvar = self.var.name
 ovar = self.rhs.name
 for result in results[:]:
 values = self._possible_values(myvar, ovar, result[ovar],
 solutions, 'o_')
 expand_result(results, result, myvar, values, self._dsget)
 class EidRestriction(Restriction):
 def __init__(self, rel, dsget):
 Restriction.__init__(self, rel)
 self._dsget = dsget
 class RelationRestriction(VariableSelection):
 def _get_value(self, fixed):
 return fixed[self.constraint_var].key()
 def fill_query(self, fixed, query, operator=None):
 restr = '%s%s %s' % (self._prefix, self.rtype, operator or self.operator)
 query[restr] = self._get_value(fixed)
 def resolve(self, solutions, fixed):
 class NotRelationRestriction(RelationRestriction):
 def _get_value(self, fixed):
 return None
 def resolve(self, solutions, fixed):
 if self.rtype == 'identity':
 raise NotImplementedError()
 return _resolve([self], solutions, fixed)
 raise NotImplementedError('LIKE is only supported for prefix search')
 if not value.endswith('%'):
 raise NotImplementedError('LIKE is only supported for prefix search')
 self.operator = '>'
 self.value = value[:-1]
 def complete_and_filter(self, solutions, results):
 # check lhs var first in case this is a restriction
 assert self._not
 myvar, rtype, value = self.var.name, self.rtype, self.value
 for result in results[:]:
 if result[myvar].get('s_'+rtype) == value:
 results.remove(result)
 def _get_value(self, fixed):
 return self.value
 class DateAttributeRestriction(AttributeRestriction):
 self.value = values
 @property
 def operator(self):
 return 'in'
 class TypeRestriction(AttributeRestriction):
 def __init__(self, var):
 self.var = var
 def __repr__(self):
 return '<%s for %s>' % (self.__class__.__name__, self.var)
 def resolve(self, solutions, fixed):
 objs = []
 for etype in frozenset(etypes[self.var.name] for etypes in solutions):
 objs += Query(etype).Run()
 return objs
 def __init__(self, functions, args, term):
 self.functions = functions
 self.args = args
 self.term = term
 self._solution = self.term.stmt.solutions[0]
 def compute(self, result):
 """return (entity type, value) to which self.term is evaluated according
 to the given result dictionnary and to query arguments (self.args)
 """
 return self.term.accept(self, result)
 def visit_function(self, node, result):
 args = tuple(n.accept(self, result)[1] for n in node.children)
 value = self.functions[node.name](*args)
 return node.get_type(self._solution, self.args), value
 def visit_variableref(self, node, result):
 value = result[node.name]
 try:
 etype = value.kind()
 value = str(value.key())
 except AttributeError:
 etype = self._solution[node.name]
 return etype, value
 def visit_constant(self, node, result):
 return node.get_type(kwargs=self.args), node.eval(self.args)
 class RQLInterpreter(object):
 """algorithm:
 1. visit the restriction clauses and collect restriction for each subject
 of a relation. Different restriction types are:
 * EidRestriction
 2. resolve eid restrictions
 3. for each select in union:
 for each solution in select'solutions:
 1. resolve variables which have attribute restriction
 2. resolve relation restriction
 3. resolve selection and add to global results
 """
 def __init__(self, schema):
 self.schema = schema
 Restriction.schema = schema # yalta!
 self.rqlhelper = RQLHelper(schema, {'eid': etype_from_key})
 self._stored_proc = {'LOWER': lambda x: x.lower(),
 'UPPER': lambda x: x.upper()}
 for cb in SQL_CONNECT_HOOKS.get('sqlite', []):
 cb(self)
 # emulate sqlite connection interface so we can reuse stored procedures
 def create_function(self, name, nbargs, func):
 self._stored_proc[name] = func
 def create_aggregate(self, name, nbargs, func):
 self._stored_proc[name] = func
 def execute(self, operation, parameters=None, eid_key=None, build_descr=True):
 rqlst = self.rqlhelper.parse(operation, annotate=True)
 try:
 self.rqlhelper.compute_solutions(rqlst, kwargs=parameters)
 except BadKeyError:
 results, description = [], []
 else:
 results, description = self.interpret(rqlst, parameters)
 return ResultSet(results, operation, parameters, description, rqlst=rqlst)
 def interpret(self, node, kwargs, dsget=None):
 if dsget is None:
 self._dsget = Get
 else:
 self._dsget = dsget
 for child in node.children:
 pres, pdescr = self.visit_select(child, extra)
 results += pres
 description += pdescr
 return results, description
 def visit_select(self, node, extra):
 constraints = {}
 if node.where is not None:
 node.where.accept(self, constraints, extra)
 fixed, toresolve, postresolve, postfilters = {}, {}, {}, []
 # compute eid restrictions
 kwargs = extra['kwargs']
 for varname, restrictions in constraints.iteritems():
 for restr in restrictions[:]:
 if isinstance(restr, EidRestriction):
 assert not varname in fixed
 try:
 value = restr.resolve(kwargs)
 fixed[varname] = value
 except EntityNotFoundError:
 return [], []
 for varname, restrictions in constraints.iteritems():
 for restr in restrictions:
 if isinstance(restr, AttributeRestriction):
 toresolve.setdefault(varname, []).append(restr)
 elif isinstance(restr, NotRelationRestriction) or (
 isinstance(restr, RelationRestriction) and
 not restr.searched_var in fixed and restr.constraint_var in fixed):
 toresolve.setdefault(varname, []).append(restr)
 else:
 postresolve.setdefault(varname, []).append(restr)
 try:
 # init results
 for value in values:
 partres.append({varname: value})
 elif not varname in partres[0]:
 # cartesian product
 for res in partres:
 res[varname] = values[0]
 for res in partres[:]:
 for value in values[1:]:
 res = res.copy()
 res[varname] = value
 partres.append(res)
 else:
 # union
 for res in varpartres:
 for value in values:
 res = res.copy()
 res[varname] = value
 partres.append(res)
 #print 'partres', len(partres)
 #print partres
 # Note: don't check for empty partres since constant selection may still
 # produce result at this point
 # sort to get RelationRestriction before AttributeSelection
 restrictions = sorted((restr for restrictions in postresolve.itervalues()
 for restr in restrictions),
 for i, sol in enumerate(partres):
 etype, value = resolver.compute(sol)
 append_result(res, descr, i, j, value, etype)
 #print '--------->', res
 return res, descr
 def visit_and(self, node, constraints, extra):
 for child in node.children:
 child.accept(self, constraints, extra)
 def visit_exists(self, node, constraints, extra):
 extra['has_exists'] = True
 self.visit_and(node, constraints, extra)
 def visit_not(self, node, constraints, extra):
 for child in node.children:
 child.accept(self, constraints, extra)
 try:
 extra.pop(node)
 except KeyError:
 raise NotImplementedError()
 def visit_relation(self, node, constraints, extra):
 if node.is_types_restriction():
 return
 rschema = self.schema.rschema(node.r_type)
 neged = node.neged(strict=True)
 self._visit_final_relation(rschema, node, constraints, extra)
 elif neged:
 self._visit_non_final_neged_relation(rschema, node, constraints)
 else:
 self._visit_non_final_relation(rschema, node, constraints)
 def _visit_non_final_relation(self, rschema, node, constraints, not_=False):
 lhs, rhs = node.get_variable_parts()
 for v1, v2, prefix in ((lhs, rhs, 's'), (rhs, lhs, 'o')):
 #if not_:
 nbrels = len(v2.variable.stinfo['relations'])
 #else:
 #    nbrels = len(v2.variable.stinfo['relations']) - len(v2.variable.stinfo['uidrels'])
 if nbrels > 1:
 constraints.setdefault(v1.name, []).append(
 RelationRestriction(node, self._dsget, prefix))
 # just init an empty list for v2 variable to avoid a
 # TypeRestriction being added for it
 constraints.setdefault(v2.name, [])
 break
 else:
 constraints.setdefault(rhs.name, []).append(
 VariableSelection(node, self._dsget, 's'))
 def _visit_non_final_neged_relation(self, rschema, node, constraints):
 lhs, rhs = node.get_variable_parts()
 for v1, v2, prefix in ((lhs, rhs, 's'), (rhs, lhs, 'o')):
 stinfo = v2.variable.stinfo
 if not stinfo['selected'] and len(stinfo['relations']) == 1:
 elif isinstance(rhs, nodes.Function) and rhs.name == 'IN':
 constraints.setdefault(varname, []).append(
 AttributeInRestriction(node, extra['kwargs']))
 else:
 raise NotImplementedError()
 def _not_implemented(self, *args, **kwargs):
 raise NotImplementedError()
 visit_or = _not_implemented
 # shouldn't occurs
 visit_set = _not_implemented
 visit_insert = _not_implemented
 visit_delete = _not_implemented
 from logging import getLogger
 from cubicweb import set_log_methods
 set_log_methods(RQLInterpreter, getLogger('cubicweb.goa.rqlinterpreter'))
 set_log_methods(Restriction, getLogger('cubicweb.goa.rqlinterpreter'))

branch	tls-sprint
changeset 1802	d628defebc17
parent 1133	8a409ea0c9ec
child 1977	606923dff11b