|
1 """provide a minimal RQL support for google appengine dbmodel |
|
2 |
|
3 :organization: Logilab |
|
4 :copyright: 2008 LOGILAB S.A. (Paris, FRANCE), all rights reserved. |
|
5 :contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr |
|
6 """ |
|
7 __docformat__ = "restructuredtext en" |
|
8 |
|
9 from mx.DateTime import DateTimeType, DateTimeDeltaType |
|
10 from datetime import datetime |
|
11 |
|
12 from rql import RQLHelper, nodes |
|
13 from logilab.common.compat import any |
|
14 |
|
15 from cubicweb import Binary |
|
16 from cubicweb.rset import ResultSet |
|
17 from cubicweb.goa import mx2datetime, datetime2mx |
|
18 from cubicweb.server import SQL_CONNECT_HOOKS |
|
19 |
|
20 from google.appengine.api.datastore import Key, Get, Query, Entity |
|
21 from google.appengine.api.datastore_types import Text, Blob |
|
22 from google.appengine.api.datastore_errors import EntityNotFoundError, BadKeyError |
|
23 |
|
24 |
|
25 def etype_from_key(key): |
|
26 return Key(key).kind() |
|
27 |
|
28 def poss_var_types(myvar, ovar, kind, solutions): |
|
29 return frozenset(etypes[myvar] for etypes in solutions |
|
30 if etypes[ovar] == kind) |
|
31 |
|
32 def expand_result(results, result, myvar, values, dsget=None): |
|
33 values = map(dsget, values) |
|
34 if values: |
|
35 result[myvar] = values.pop(0) |
|
36 for value in values: |
|
37 newresult = result.copy() |
|
38 newresult[myvar] = value |
|
39 results.append(newresult) |
|
40 else: |
|
41 results.remove(result) |
|
42 |
|
43 def _resolve(restrictions, solutions, fixed): |
|
44 varname = restrictions[0].searched_var |
|
45 objs = [] |
|
46 for etype in frozenset(etypes[varname] for etypes in solutions): |
|
47 gqlargs = {} |
|
48 query = Query(etype) |
|
49 for restriction in restrictions: |
|
50 restriction.fill_query(fixed, query) |
|
51 pobjs = query.Run() |
|
52 if varname in fixed: |
|
53 value = fixed[varname] |
|
54 objs += (x for x in pobjs if x == value) |
|
55 else: |
|
56 objs += pobjs |
|
57 if varname in fixed and not objs: |
|
58 raise EidMismatch(varname, value) |
|
59 return objs |
|
60 |
|
61 def _resolve_not(restrictions, solutions, fixed): |
|
62 restr = restrictions[0] |
|
63 constrvarname = restr.constraint_var |
|
64 if len(restrictions) > 1 or not constrvarname in fixed: |
|
65 raise NotImplementedError() |
|
66 varname = restr.searched_var |
|
67 objs = [] |
|
68 for etype in frozenset(etypes[varname] for etypes in solutions): |
|
69 gqlargs = {} |
|
70 for operator in ('<', '>'): |
|
71 query = Query(etype) |
|
72 restr.fill_query(fixed, query, operator) |
|
73 objs += query.Run() |
|
74 return objs |
|
75 |
|
76 def _print_results(rlist): |
|
77 return '[%s]' % ', '.join(_print_result(r) for r in rlist) |
|
78 |
|
79 def _print_result(rdict): |
|
80 string = [] |
|
81 for k, v in rdict.iteritems(): |
|
82 if isinstance(v, Entity): |
|
83 string.append('%s: %s' % (k, v.key()))#_print_result(v))) |
|
84 elif isinstance(v, list): |
|
85 string.append('%s: [%s]' % (k, ', '.join(str(i) for i in v))) |
|
86 else: |
|
87 string.append('%s: %s' % (k, v)) |
|
88 return '{%s}' % ', '.join(string) |
|
89 |
|
90 |
|
91 class EidMismatch(Exception): |
|
92 def __init__(self, varname, value): |
|
93 self.varname = varname |
|
94 self.value = value |
|
95 |
|
96 |
|
97 class Restriction(object): |
|
98 supported_operators = ('=',) |
|
99 def __init__(self, rel): |
|
100 operator = rel.children[1].operator |
|
101 if not operator in self.supported_operators: |
|
102 raise NotImplementedError('unsupported operator') |
|
103 self.rel = rel |
|
104 self.operator = operator |
|
105 self.rtype = rel.r_type |
|
106 self.var = rel.children[0] |
|
107 |
|
108 def __repr__(self): |
|
109 return '<%s for %s>' % (self.__class__.__name__, self.rel) |
|
110 |
|
111 @property |
|
112 def rhs(self): |
|
113 return self.rel.children[1].children[0] |
|
114 |
|
115 |
|
116 class MultipleRestriction(object): |
|
117 def __init__(self, restrictions): |
|
118 self.restrictions = restrictions |
|
119 |
|
120 def resolve(self, solutions, fixed): |
|
121 return _resolve(self.restrictions, solutions, fixed) |
|
122 |
|
123 |
|
124 class VariableSelection(Restriction): |
|
125 def __init__(self, rel, dsget, prefix='s'): |
|
126 Restriction.__init__(self, rel) |
|
127 self._dsget = dsget |
|
128 self._not = self.rel.neged(strict=True) |
|
129 self._prefix = prefix + '_' |
|
130 |
|
131 def __repr__(self): |
|
132 return '<%s%s for %s>' % (self._prefix[0], self.__class__.__name__, self.rel) |
|
133 |
|
134 @property |
|
135 def searched_var(self): |
|
136 if self._prefix == 's_': |
|
137 return self.var.name |
|
138 return self.rhs.name |
|
139 |
|
140 @property |
|
141 def constraint_var(self): |
|
142 if self._prefix == 's_': |
|
143 return self.rhs.name |
|
144 return self.var.name |
|
145 |
|
146 def _possible_values(self, myvar, ovar, entity, solutions, dsprefix): |
|
147 if self.rtype == 'identity': |
|
148 return (entity.key(),) |
|
149 value = entity.get(dsprefix + self.rtype) |
|
150 if value is None: |
|
151 return [] |
|
152 if not isinstance(value, list): |
|
153 value = [value] |
|
154 vartypes = poss_var_types(myvar, ovar, entity.kind(), solutions) |
|
155 return (v for v in value if v.kind() in vartypes) |
|
156 |
|
157 def complete_and_filter(self, solutions, results): |
|
158 myvar = self.rhs.name |
|
159 ovar = self.var.name |
|
160 rtype = self.rtype |
|
161 if self.schema.rschema(rtype).is_final(): |
|
162 # should be detected by rql.stcheck: "Any C WHERE NOT X attr C" doesn't make sense |
|
163 #if self._not: |
|
164 # raise NotImplementedError() |
|
165 for result in results: |
|
166 result[myvar] = result[ovar].get('s_'+rtype) |
|
167 elif self.var.name in results[0]: |
|
168 if self.rhs.name in results[0]: |
|
169 self.filter(solutions, results) |
|
170 else: |
|
171 if self._not: |
|
172 raise NotImplementedError() |
|
173 for result in results[:]: |
|
174 values = self._possible_values(myvar, ovar, result[ovar], |
|
175 solutions, 's_') |
|
176 expand_result(results, result, myvar, values, self._dsget) |
|
177 else: |
|
178 assert self.rhs.name in results[0] |
|
179 self.object_complete_and_filter(solutions, results) |
|
180 |
|
181 def filter(self, solutions, results): |
|
182 myvar = self.rhs.name |
|
183 ovar = self.var.name |
|
184 newsols = {} |
|
185 for result in results[:]: |
|
186 entity = result[ovar] |
|
187 key = entity.key() |
|
188 if not key in newsols: |
|
189 values = self._possible_values(myvar, ovar, entity, solutions, 's_') |
|
190 newsols[key] = frozenset(v for v in values) |
|
191 if self._not: |
|
192 if result[myvar].key() in newsols[key]: |
|
193 results.remove(result) |
|
194 elif not result[myvar].key() in newsols[key]: |
|
195 results.remove(result) |
|
196 |
|
197 def object_complete_and_filter(self, solutions, results): |
|
198 if self._not: |
|
199 raise NotImplementedError() |
|
200 myvar = self.var.name |
|
201 ovar = self.rhs.name |
|
202 for result in results[:]: |
|
203 values = self._possible_values(myvar, ovar, result[ovar], |
|
204 solutions, 'o_') |
|
205 expand_result(results, result, myvar, values, self._dsget) |
|
206 |
|
207 |
|
208 class EidRestriction(Restriction): |
|
209 def __init__(self, rel, dsget): |
|
210 Restriction.__init__(self, rel) |
|
211 self._dsget = dsget |
|
212 |
|
213 def resolve(self, kwargs): |
|
214 value = self.rel.children[1].children[0].eval(kwargs) |
|
215 return self._dsget(value) |
|
216 |
|
217 |
|
218 class RelationRestriction(VariableSelection): |
|
219 |
|
220 def _get_value(self, fixed): |
|
221 return fixed[self.constraint_var].key() |
|
222 |
|
223 def fill_query(self, fixed, query, operator=None): |
|
224 restr = '%s%s %s' % (self._prefix, self.rtype, operator or self.operator) |
|
225 query[restr] = self._get_value(fixed) |
|
226 |
|
227 def resolve(self, solutions, fixed): |
|
228 if self.rtype == 'identity': |
|
229 if self._not: |
|
230 raise NotImplementedError() |
|
231 return [fixed[self.constraint_var]] |
|
232 if self._not: |
|
233 return _resolve_not([self], solutions, fixed) |
|
234 return _resolve([self], solutions, fixed) |
|
235 |
|
236 |
|
237 class NotRelationRestriction(RelationRestriction): |
|
238 |
|
239 def _get_value(self, fixed): |
|
240 return None |
|
241 |
|
242 def resolve(self, solutions, fixed): |
|
243 if self.rtype == 'identity': |
|
244 raise NotImplementedError() |
|
245 return _resolve([self], solutions, fixed) |
|
246 |
|
247 |
|
248 class AttributeRestriction(RelationRestriction): |
|
249 supported_operators = ('=', '>', '>=', '<', '<=', 'ILIKE') |
|
250 def __init__(self, rel, kwargs): |
|
251 RelationRestriction.__init__(self, rel, None) |
|
252 value = self.rhs.eval(kwargs) |
|
253 if isinstance(value, (DateTimeType, DateTimeDeltaType)): |
|
254 #yamstype = self.schema.rschema(self.rtype).objects()[0] |
|
255 value = mx2datetime(value, 'Datetime') |
|
256 self.value = value |
|
257 if self.operator == 'ILIKE': |
|
258 if value.startswith('%'): |
|
259 raise NotImplementedError('LIKE is only supported for prefix search') |
|
260 if not value.endswith('%'): |
|
261 raise NotImplementedError('LIKE is only supported for prefix search') |
|
262 self.operator = '>' |
|
263 self.value = value[:-1] |
|
264 |
|
265 def complete_and_filter(self, solutions, results): |
|
266 # check lhs var first in case this is a restriction |
|
267 assert self._not |
|
268 myvar, rtype, value = self.var.name, self.rtype, self.value |
|
269 for result in results[:]: |
|
270 if result[myvar].get('s_'+rtype) == value: |
|
271 results.remove(result) |
|
272 |
|
273 def _get_value(self, fixed): |
|
274 return self.value |
|
275 |
|
276 |
|
277 class DateAttributeRestriction(AttributeRestriction): |
|
278 """just a thin layer on top af `AttributeRestriction` that |
|
279 tries to convert date strings such as in : |
|
280 Any X WHERE X creation_date >= '2008-03-04' |
|
281 """ |
|
282 def __init__(self, rel, kwargs): |
|
283 super(DateAttributeRestriction, self).__init__(rel, kwargs) |
|
284 if isinstance(self.value, basestring): |
|
285 # try: |
|
286 self.value = datetime.strptime(self.value, '%Y-%m-%d') |
|
287 # except Exception, exc: |
|
288 # from logging import error |
|
289 # error('unable to parse date %s with format %%Y-%%m-%%d (exc=%s)', value, exc) |
|
290 |
|
291 |
|
292 class AttributeInRestriction(AttributeRestriction): |
|
293 def __init__(self, rel, kwargs): |
|
294 RelationRestriction.__init__(self, rel, None) |
|
295 values = [] |
|
296 for c in self.rel.children[1].iget_nodes(nodes.Constant): |
|
297 value = c.eval(kwargs) |
|
298 if isinstance(value, (DateTimeType, DateTimeDeltaType)): |
|
299 #yamstype = self.schema.rschema(self.rtype).objects()[0] |
|
300 value = mx2datetime(value, 'Datetime') |
|
301 values.append(value) |
|
302 self.value = values |
|
303 |
|
304 @property |
|
305 def operator(self): |
|
306 return 'in' |
|
307 |
|
308 |
|
309 class TypeRestriction(AttributeRestriction): |
|
310 def __init__(self, var): |
|
311 self.var = var |
|
312 |
|
313 def __repr__(self): |
|
314 return '<%s for %s>' % (self.__class__.__name__, self.var) |
|
315 |
|
316 def resolve(self, solutions, fixed): |
|
317 objs = [] |
|
318 for etype in frozenset(etypes[self.var.name] for etypes in solutions): |
|
319 objs += Query(etype).Run() |
|
320 return objs |
|
321 |
|
322 |
|
323 def append_result(res, descr, i, j, value, etype): |
|
324 if value is not None: |
|
325 if etype in ('Date', 'Datetime', 'Time'): |
|
326 value = datetime2mx(value, etype) |
|
327 elif isinstance(value, Text): |
|
328 value = unicode(value) |
|
329 elif isinstance(value, Blob): |
|
330 value = Binary(str(value)) |
|
331 if j == 0: |
|
332 res.append([value]) |
|
333 descr.append([etype]) |
|
334 else: |
|
335 res[i].append(value) |
|
336 descr[i].append(etype) |
|
337 |
|
338 |
|
339 class ValueResolver(object): |
|
340 def __init__(self, functions, args, term): |
|
341 self.functions = functions |
|
342 self.args = args |
|
343 self.term = term |
|
344 self._solution = self.term.stmt.solutions[0] |
|
345 |
|
346 def compute(self, result): |
|
347 """return (entity type, value) to which self.term is evaluated according |
|
348 to the given result dictionnary and to query arguments (self.args) |
|
349 """ |
|
350 return self.term.accept(self, result) |
|
351 |
|
352 def visit_function(self, node, result): |
|
353 args = tuple(n.accept(self, result)[1] for n in node.children) |
|
354 value = self.functions[node.name](*args) |
|
355 return node.get_type(self._solution, self.args), value |
|
356 |
|
357 def visit_variableref(self, node, result): |
|
358 value = result[node.name] |
|
359 try: |
|
360 etype = value.kind() |
|
361 value = str(value.key()) |
|
362 except AttributeError: |
|
363 etype = self._solution[node.name] |
|
364 return etype, value |
|
365 |
|
366 def visit_constant(self, node, result): |
|
367 return node.get_type(kwargs=self.args), node.eval(self.args) |
|
368 |
|
369 |
|
370 class RQLInterpreter(object): |
|
371 """algorithm: |
|
372 1. visit the restriction clauses and collect restriction for each subject |
|
373 of a relation. Different restriction types are: |
|
374 * EidRestriction |
|
375 * AttributeRestriction |
|
376 * RelationRestriction |
|
377 * VariableSelection (not really a restriction) |
|
378 -> dictionary {<variable>: [restriction...], ...} |
|
379 2. resolve eid restrictions |
|
380 3. for each select in union: |
|
381 for each solution in select'solutions: |
|
382 1. resolve variables which have attribute restriction |
|
383 2. resolve relation restriction |
|
384 3. resolve selection and add to global results |
|
385 """ |
|
386 def __init__(self, schema): |
|
387 self.schema = schema |
|
388 Restriction.schema = schema # yalta! |
|
389 self.rqlhelper = RQLHelper(schema, {'eid': etype_from_key}) |
|
390 self._stored_proc = {'LOWER': lambda x: x.lower(), |
|
391 'UPPER': lambda x: x.upper()} |
|
392 for cb in SQL_CONNECT_HOOKS.get('sqlite', []): |
|
393 cb(self) |
|
394 |
|
395 # emulate sqlite connection interface so we can reuse stored procedures |
|
396 def create_function(self, name, nbargs, func): |
|
397 self._stored_proc[name] = func |
|
398 |
|
399 def create_aggregate(self, name, nbargs, func): |
|
400 self._stored_proc[name] = func |
|
401 |
|
402 |
|
403 def execute(self, operation, parameters=None, eid_key=None, build_descr=True): |
|
404 rqlst = self.rqlhelper.parse(operation, annotate=True) |
|
405 try: |
|
406 self.rqlhelper.compute_solutions(rqlst, kwargs=parameters) |
|
407 except BadKeyError: |
|
408 results, description = [], [] |
|
409 else: |
|
410 results, description = self.interpret(rqlst, parameters) |
|
411 return ResultSet(results, operation, parameters, description, rqlst=rqlst) |
|
412 |
|
413 def interpret(self, node, kwargs, dsget=None): |
|
414 if dsget is None: |
|
415 self._dsget = Get |
|
416 else: |
|
417 self._dsget = dsget |
|
418 try: |
|
419 return node.accept(self, kwargs) |
|
420 except NotImplementedError: |
|
421 self.critical('support for query not implemented: %s', node) |
|
422 raise |
|
423 |
|
424 def visit_union(self, node, kwargs): |
|
425 results, description = [], [] |
|
426 extra = {'kwargs': kwargs} |
|
427 for child in node.children: |
|
428 pres, pdescr = self.visit_select(child, extra) |
|
429 results += pres |
|
430 description += pdescr |
|
431 return results, description |
|
432 |
|
433 def visit_select(self, node, extra): |
|
434 constraints = {} |
|
435 if node.where is not None: |
|
436 node.where.accept(self, constraints, extra) |
|
437 fixed, toresolve, postresolve, postfilters = {}, {}, {}, [] |
|
438 # extract NOT filters |
|
439 for vname, restrictions in constraints.items(): |
|
440 for restr in restrictions[:]: |
|
441 if isinstance(restr, AttributeRestriction) and restr._not: |
|
442 postfilters.append(restr) |
|
443 restrictions.remove(restr) |
|
444 if not restrictions: |
|
445 del constraints[vname] |
|
446 # add TypeRestriction for variable which have no restrictions at all |
|
447 for varname, var in node.defined_vars.iteritems(): |
|
448 if not varname in constraints: |
|
449 constraints[varname] = [TypeRestriction(var)] |
|
450 #print node, constraints |
|
451 # compute eid restrictions |
|
452 kwargs = extra['kwargs'] |
|
453 for varname, restrictions in constraints.iteritems(): |
|
454 for restr in restrictions[:]: |
|
455 if isinstance(restr, EidRestriction): |
|
456 assert not varname in fixed |
|
457 try: |
|
458 value = restr.resolve(kwargs) |
|
459 fixed[varname] = value |
|
460 except EntityNotFoundError: |
|
461 return [], [] |
|
462 restrictions.remove(restr) |
|
463 #print 'fixed', fixed.keys() |
|
464 # combine remaining restrictions |
|
465 for varname, restrictions in constraints.iteritems(): |
|
466 for restr in restrictions: |
|
467 if isinstance(restr, AttributeRestriction): |
|
468 toresolve.setdefault(varname, []).append(restr) |
|
469 elif isinstance(restr, NotRelationRestriction) or ( |
|
470 isinstance(restr, RelationRestriction) and |
|
471 not restr.searched_var in fixed and restr.constraint_var in fixed): |
|
472 toresolve.setdefault(varname, []).append(restr) |
|
473 else: |
|
474 postresolve.setdefault(varname, []).append(restr) |
|
475 try: |
|
476 if len(toresolve[varname]) > 1: |
|
477 toresolve[varname] = MultipleRestriction(toresolve[varname]) |
|
478 else: |
|
479 toresolve[varname] = toresolve[varname][0] |
|
480 except KeyError: |
|
481 pass |
|
482 #print 'toresolve %s' % toresolve |
|
483 #print 'postresolve %s' % postresolve |
|
484 # resolve additional restrictions |
|
485 if fixed: |
|
486 partres = [fixed.copy()] |
|
487 else: |
|
488 partres = [] |
|
489 for varname, restr in toresolve.iteritems(): |
|
490 varpartres = partres[:] |
|
491 try: |
|
492 values = tuple(restr.resolve(node.solutions, fixed)) |
|
493 except EidMismatch, ex: |
|
494 varname = ex.varname |
|
495 value = ex.value |
|
496 partres = [res for res in partres if res[varname] != value] |
|
497 if partres: |
|
498 continue |
|
499 # some join failed, no possible results |
|
500 return [], [] |
|
501 if not values: |
|
502 # some join failed, no possible results |
|
503 return [], [] |
|
504 if not varpartres: |
|
505 # init results |
|
506 for value in values: |
|
507 partres.append({varname: value}) |
|
508 elif not varname in partres[0]: |
|
509 # cartesian product |
|
510 for res in partres: |
|
511 res[varname] = values[0] |
|
512 for res in partres[:]: |
|
513 for value in values[1:]: |
|
514 res = res.copy() |
|
515 res[varname] = value |
|
516 partres.append(res) |
|
517 else: |
|
518 # union |
|
519 for res in varpartres: |
|
520 for value in values: |
|
521 res = res.copy() |
|
522 res[varname] = value |
|
523 partres.append(res) |
|
524 #print 'partres', len(partres) |
|
525 #print partres |
|
526 # Note: don't check for empty partres since constant selection may still |
|
527 # produce result at this point |
|
528 # sort to get RelationRestriction before AttributeSelection |
|
529 restrictions = sorted((restr for restrictions in postresolve.itervalues() |
|
530 for restr in restrictions), |
|
531 key=lambda x: not isinstance(x, RelationRestriction)) |
|
532 # compute stuff not doable in the previous step using datastore queries |
|
533 for restr in restrictions + postfilters: |
|
534 restr.complete_and_filter(node.solutions, partres) |
|
535 if not partres: |
|
536 # some join failed, no possible results |
|
537 return [], [] |
|
538 if extra.pop('has_exists', False): |
|
539 # remove potential duplicates introduced by exists |
|
540 toremovevars = [v.name for v in node.defined_vars.itervalues() |
|
541 if not v.scope is node] |
|
542 if toremovevars: |
|
543 newpartres = [] |
|
544 for result in partres: |
|
545 for var in toremovevars: |
|
546 del result[var] |
|
547 if not result in newpartres: |
|
548 newpartres.append(result) |
|
549 if not newpartres: |
|
550 # some join failed, no possible results |
|
551 return [], [] |
|
552 partres = newpartres |
|
553 if node.orderby: |
|
554 for sortterm in reversed(node.orderby): |
|
555 resolver = ValueResolver(self._stored_proc, kwargs, sortterm.term) |
|
556 partres.sort(reverse=not sortterm.asc, |
|
557 key=lambda x: resolver.compute(x)[1]) |
|
558 if partres: |
|
559 if node.offset: |
|
560 partres = partres[node.offset:] |
|
561 if node.limit: |
|
562 partres = partres[:node.limit] |
|
563 if not partres: |
|
564 return [], [] |
|
565 #print 'completed partres', _print_results(partres) |
|
566 # compute results |
|
567 res, descr = [], [] |
|
568 for j, term in enumerate(node.selection): |
|
569 resolver = ValueResolver(self._stored_proc, kwargs, term) |
|
570 if not partres: |
|
571 etype, value = resolver.compute({}) |
|
572 # only constant selected |
|
573 if not res: |
|
574 res.append([]) |
|
575 descr.append([]) |
|
576 res[0].append(value) |
|
577 descr[0].append(etype) |
|
578 else: |
|
579 for i, sol in enumerate(partres): |
|
580 etype, value = resolver.compute(sol) |
|
581 append_result(res, descr, i, j, value, etype) |
|
582 #print '--------->', res |
|
583 return res, descr |
|
584 |
|
585 def visit_and(self, node, constraints, extra): |
|
586 for child in node.children: |
|
587 child.accept(self, constraints, extra) |
|
588 def visit_exists(self, node, constraints, extra): |
|
589 extra['has_exists'] = True |
|
590 self.visit_and(node, constraints, extra) |
|
591 |
|
592 def visit_not(self, node, constraints, extra): |
|
593 for child in node.children: |
|
594 child.accept(self, constraints, extra) |
|
595 try: |
|
596 extra.pop(node) |
|
597 except KeyError: |
|
598 raise NotImplementedError() |
|
599 |
|
600 def visit_relation(self, node, constraints, extra): |
|
601 if node.is_types_restriction(): |
|
602 return |
|
603 rschema = self.schema.rschema(node.r_type) |
|
604 neged = node.neged(strict=True) |
|
605 if neged: |
|
606 # ok, we *may* process this Not node (not implemented error will be |
|
607 # raised later if we can't) |
|
608 extra[node.parent] = True |
|
609 if rschema.is_final(): |
|
610 self._visit_final_relation(rschema, node, constraints, extra) |
|
611 elif neged: |
|
612 self._visit_non_final_neged_relation(rschema, node, constraints) |
|
613 else: |
|
614 self._visit_non_final_relation(rschema, node, constraints) |
|
615 |
|
616 def _visit_non_final_relation(self, rschema, node, constraints, not_=False): |
|
617 lhs, rhs = node.get_variable_parts() |
|
618 for v1, v2, prefix in ((lhs, rhs, 's'), (rhs, lhs, 'o')): |
|
619 #if not_: |
|
620 nbrels = len(v2.variable.stinfo['relations']) |
|
621 #else: |
|
622 # nbrels = len(v2.variable.stinfo['relations']) - len(v2.variable.stinfo['uidrels']) |
|
623 if nbrels > 1: |
|
624 constraints.setdefault(v1.name, []).append( |
|
625 RelationRestriction(node, self._dsget, prefix)) |
|
626 # just init an empty list for v2 variable to avoid a |
|
627 # TypeRestriction being added for it |
|
628 constraints.setdefault(v2.name, []) |
|
629 break |
|
630 else: |
|
631 constraints.setdefault(rhs.name, []).append( |
|
632 VariableSelection(node, self._dsget, 's')) |
|
633 |
|
634 def _visit_non_final_neged_relation(self, rschema, node, constraints): |
|
635 lhs, rhs = node.get_variable_parts() |
|
636 for v1, v2, prefix in ((lhs, rhs, 's'), (rhs, lhs, 'o')): |
|
637 stinfo = v2.variable.stinfo |
|
638 if not stinfo['selected'] and len(stinfo['relations']) == 1: |
|
639 constraints.setdefault(v1.name, []).append( |
|
640 NotRelationRestriction(node, self._dsget, prefix)) |
|
641 constraints.setdefault(v2.name, []) |
|
642 break |
|
643 else: |
|
644 self._visit_non_final_relation(rschema, node, constraints, True) |
|
645 |
|
646 def _visit_final_relation(self, rschema, node, constraints, extra): |
|
647 varname = node.children[0].name |
|
648 if rschema.type == 'eid': |
|
649 constraints.setdefault(varname, []).append( |
|
650 EidRestriction(node, self._dsget)) |
|
651 else: |
|
652 rhs = node.children[1].children[0] |
|
653 if isinstance(rhs, nodes.VariableRef): |
|
654 constraints.setdefault(rhs.name, []).append( |
|
655 VariableSelection(node, self._dsget)) |
|
656 elif isinstance(rhs, nodes.Constant): |
|
657 if rschema.objects()[0] in ('Datetime', 'Date'): # XXX |
|
658 constraints.setdefault(varname, []).append( |
|
659 DateAttributeRestriction(node, extra['kwargs'])) |
|
660 else: |
|
661 constraints.setdefault(varname, []).append( |
|
662 AttributeRestriction(node, extra['kwargs'])) |
|
663 elif isinstance(rhs, nodes.Function) and rhs.name == 'IN': |
|
664 constraints.setdefault(varname, []).append( |
|
665 AttributeInRestriction(node, extra['kwargs'])) |
|
666 else: |
|
667 raise NotImplementedError() |
|
668 |
|
669 def _not_implemented(self, *args, **kwargs): |
|
670 raise NotImplementedError() |
|
671 |
|
672 visit_or = _not_implemented |
|
673 # shouldn't occurs |
|
674 visit_set = _not_implemented |
|
675 visit_insert = _not_implemented |
|
676 visit_delete = _not_implemented |
|
677 |
|
678 |
|
679 from logging import getLogger |
|
680 from cubicweb import set_log_methods |
|
681 set_log_methods(RQLInterpreter, getLogger('cubicweb.goa.rqlinterpreter')) |
|
682 set_log_methods(Restriction, getLogger('cubicweb.goa.rqlinterpreter')) |