author | Aurelien Campeas <aurelien.campeas@logilab.fr> |
Wed, 11 Jun 2014 14:47:50 +0200 | |
changeset 10361 | 46d72f33c428 |
parent 10246 | ef106564b523 |
child 10366 | 38c7598b5c61 |
permissions | -rw-r--r-- |
10087
ed0b076c119b
[rset] kill the rset._rqlst cache
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9990
diff
changeset
|
1 |
# copyright 2003-2014 LOGILAB S.A. (Paris, FRANCE), all rights reserved. |
5421
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
2 |
# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
3 |
# |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
4 |
# This file is part of CubicWeb. |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
5 |
# |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
6 |
# CubicWeb is free software: you can redistribute it and/or modify it under the |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
7 |
# terms of the GNU Lesser General Public License as published by the Free |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
8 |
# Software Foundation, either version 2.1 of the License, or (at your option) |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
9 |
# any later version. |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
10 |
# |
5424
8ecbcbff9777
replace logilab-common by CubicWeb in disclaimer
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5421
diff
changeset
|
11 |
# CubicWeb is distributed in the hope that it will be useful, but WITHOUT |
5421
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
12 |
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
13 |
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
14 |
# details. |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
15 |
# |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
16 |
# You should have received a copy of the GNU Lesser General Public License along |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5419
diff
changeset
|
17 |
# with CubicWeb. If not, see <http://www.gnu.org/licenses/>. |
0 | 18 |
"""Helper classes to execute RQL queries on a set of sources, performing |
19 |
security checking and data aggregation. |
|
5726
c3b99606644d
[json] fix json serialization for recent simplejson implementation, and test encoding of entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5657
diff
changeset
|
20 |
""" |
0 | 21 |
__docformat__ = "restructuredtext en" |
22 |
||
23 |
from itertools import repeat |
|
24 |
||
8542
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
25 |
from rql import RQLSyntaxError, CoercionError |
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
26 |
from rql.stmts import Union |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
27 |
from rql.nodes import ETYPE_PYOBJ_MAP, etype_from_pyobj, Relation, Exists, Not |
8542
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
28 |
from yams import BASE_TYPES |
0 | 29 |
|
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
30 |
from cubicweb import ValidationError, Unauthorized, UnknownEid |
9954
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
31 |
from cubicweb.rqlrewrite import RQLRelationRewriter |
8748
f5027f8d2478
drop typed_eid() in favour of int() (closes #2742462)
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
8697
diff
changeset
|
32 |
from cubicweb import Binary, server |
0 | 33 |
from cubicweb.rset import ResultSet |
34 |
||
8542
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
35 |
from cubicweb.utils import QueryCache, RepeatList |
0 | 36 |
from cubicweb.server.rqlannotation import SQLGenAnnotator, set_qdata |
7118
e094b3d4eb95
[server] move EditedEntity class to its own module, to avoid cyclic dependency when needed from e.g. session.py
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7083
diff
changeset
|
37 |
from cubicweb.server.ssplanner import READ_ONLY_RTYPES, add_types_restriction |
e094b3d4eb95
[server] move EditedEntity class to its own module, to avoid cyclic dependency when needed from e.g. session.py
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7083
diff
changeset
|
38 |
from cubicweb.server.edition import EditedEntity |
9448
3e7cad3967c5
[multi-sources-removal] Drop the "true" multi-sources planner
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9286
diff
changeset
|
39 |
from cubicweb.server.ssplanner import SSPlanner |
8542
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
40 |
|
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
41 |
ETYPE_PYOBJ_MAP[Binary] = 'Bytes' |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
42 |
|
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
43 |
|
4722
9c13d5db03d9
pylint suggested refactorings
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4719
diff
changeset
|
44 |
def empty_rset(rql, args, rqlst=None): |
0 | 45 |
"""build an empty result set object""" |
46 |
return ResultSet([], rql, args, rqlst=rqlst) |
|
47 |
||
48 |
def update_varmap(varmap, selected, table): |
|
49 |
"""return a sql schema to store RQL query result""" |
|
50 |
for i, term in enumerate(selected): |
|
51 |
key = term.as_string() |
|
52 |
value = '%s.C%s' % (table, i) |
|
53 |
if varmap.get(key, value) != value: |
|
5768
1e73a466aa69
[fti] support for fti ranking: has_text query results sorted by relevance, and provides a way to control weight per entity / entity's attribute
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5726
diff
changeset
|
54 |
raise Exception('variable name conflict on %s: got %s / %s' |
1e73a466aa69
[fti] support for fti ranking: has_text query results sorted by relevance, and provides a way to control weight per entity / entity's attribute
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5726
diff
changeset
|
55 |
% (key, value, varmap)) |
0 | 56 |
varmap[key] = value |
57 |
||
58 |
# permission utilities ######################################################## |
|
59 |
||
60 |
def check_no_password_selected(rqlst): |
|
61 |
"""check that Password entities are not selected""" |
|
62 |
for solution in rqlst.solutions: |
|
8863
98c107bd6cd0
[querier] improve 'Password selection not allowed' error message
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8697
diff
changeset
|
63 |
for var, etype in solution.iteritems(): |
98c107bd6cd0
[querier] improve 'Password selection not allowed' error message
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8697
diff
changeset
|
64 |
if etype == 'Password': |
98c107bd6cd0
[querier] improve 'Password selection not allowed' error message
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8697
diff
changeset
|
65 |
raise Unauthorized('Password selection is not allowed (%s)' % var) |
0 | 66 |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
67 |
def term_etype(cnx, term, solution, args): |
5419
0b7805928a27
[repo security]Â deal with rewriten constant nodes in check_read_access, necessary when repo is used as an external source
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5168
diff
changeset
|
68 |
"""return the entity type for the given term (a VariableRef or a Constant |
0b7805928a27
[repo security]Â deal with rewriten constant nodes in check_read_access, necessary when repo is used as an external source
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5168
diff
changeset
|
69 |
node) |
0b7805928a27
[repo security]Â deal with rewriten constant nodes in check_read_access, necessary when repo is used as an external source
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5168
diff
changeset
|
70 |
""" |
0b7805928a27
[repo security]Â deal with rewriten constant nodes in check_read_access, necessary when repo is used as an external source
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5168
diff
changeset
|
71 |
try: |
0b7805928a27
[repo security]Â deal with rewriten constant nodes in check_read_access, necessary when repo is used as an external source
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5168
diff
changeset
|
72 |
return solution[term.name] |
0b7805928a27
[repo security]Â deal with rewriten constant nodes in check_read_access, necessary when repo is used as an external source
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5168
diff
changeset
|
73 |
except AttributeError: |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
74 |
return cnx.entity_metas(term.eval(args))['type'] |
5419
0b7805928a27
[repo security]Â deal with rewriten constant nodes in check_read_access, necessary when repo is used as an external source
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5168
diff
changeset
|
75 |
|
9954
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
76 |
def check_relations_read_access(cnx, select, args): |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
77 |
"""Raise :exc:`Unauthorized` if the given user doesn't have credentials to |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
78 |
read relations used in the givel syntaxt tree |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
79 |
""" |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
80 |
# use `term_etype` since we've to deal with rewritten constants here, |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
81 |
# when used as an external source by another repository. |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
82 |
# XXX what about local read security w/ those rewritten constants... |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
83 |
# XXX constants can also happen in some queries generated by req.find() |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
84 |
DBG = (server.DEBUG & server.DBG_SEC) and 'read' in server._SECURITY_CAPS |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
85 |
schema = cnx.repo.schema |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
86 |
user = cnx.user |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
87 |
if select.where is not None: |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
88 |
for rel in select.where.iget_nodes(Relation): |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
89 |
for solution in select.solutions: |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
90 |
# XXX has_text may have specific perm ? |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
91 |
if rel.r_type in READ_ONLY_RTYPES: |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
92 |
continue |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
93 |
rschema = schema.rschema(rel.r_type) |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
94 |
if rschema.final: |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
95 |
eschema = schema.eschema(term_etype(cnx, rel.children[0], |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
96 |
solution, args)) |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
97 |
rdef = eschema.rdef(rschema) |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
98 |
else: |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
99 |
rdef = rschema.rdef(term_etype(cnx, rel.children[0], |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
100 |
solution, args), |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
101 |
term_etype(cnx, rel.children[1].children[0], |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
102 |
solution, args)) |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
103 |
if not user.matching_groups(rdef.get_groups('read')): |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
104 |
if DBG: |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
105 |
print ('check_read_access: %s %s does not match %s' % |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
106 |
(rdef, user.groups, rdef.get_groups('read'))) |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
107 |
# XXX rqlexpr not allowed |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
108 |
raise Unauthorized('read', rel.r_type) |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
109 |
if DBG: |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
110 |
print ('check_read_access: %s %s matches %s' % |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
111 |
(rdef, user.groups, rdef.get_groups('read'))) |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
112 |
|
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
113 |
def get_local_checks(cnx, rqlst, solution): |
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
114 |
"""Check that the given user has credentials to access data read by the |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
115 |
query and return a dict defining necessary "local checks" (i.e. rql |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
116 |
expression in read permission defined in the schema) where no group grants |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
117 |
him the permission. |
0 | 118 |
|
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
119 |
Returned dictionary's keys are variable names and values the rql expressions |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
120 |
for this variable (with the given solution). |
9954
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
121 |
|
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
122 |
Raise :exc:`Unauthorized` if access is known to be defined, i.e. if there is |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
123 |
no matching group and no local permissions. |
0 | 124 |
""" |
9286
02a491f6fa92
[querier/security] instrument a bit the querier read security checks
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9267
diff
changeset
|
125 |
DBG = (server.DEBUG & server.DBG_SEC) and 'read' in server._SECURITY_CAPS |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
126 |
schema = cnx.repo.schema |
9954
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
127 |
user = cnx.user |
0 | 128 |
localchecks = {} |
129 |
# iterate on defined_vars and not on solutions to ignore column aliases |
|
130 |
for varname in rqlst.defined_vars: |
|
4953
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
131 |
eschema = schema.eschema(solution[varname]) |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
132 |
if eschema.final: |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
133 |
continue |
9954
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
134 |
if not user.matching_groups(eschema.get_groups('read')): |
0 | 135 |
erqlexprs = eschema.get_rqlexprs('read') |
136 |
if not erqlexprs: |
|
4953
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
137 |
ex = Unauthorized('read', solution[varname]) |
0 | 138 |
ex.var = varname |
9286
02a491f6fa92
[querier/security] instrument a bit the querier read security checks
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9267
diff
changeset
|
139 |
if DBG: |
02a491f6fa92
[querier/security] instrument a bit the querier read security checks
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9267
diff
changeset
|
140 |
print ('check_read_access: %s %s %s %s' % |
9954
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
141 |
(varname, eschema, user.groups, eschema.get_groups('read'))) |
0 | 142 |
raise ex |
5888
3ee80d487f11
[security] fix read rql expression insertion: we should not insert rql expr on variables only referenced in neged relation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5726
diff
changeset
|
143 |
# don't insert security on variable only referenced by 'NOT X relation Y' or |
3ee80d487f11
[security] fix read rql expression insertion: we should not insert rql expr on variables only referenced in neged relation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5726
diff
changeset
|
144 |
# 'NOT EXISTS(X relation Y)' |
3ee80d487f11
[security] fix read rql expression insertion: we should not insert rql expr on variables only referenced in neged relation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5726
diff
changeset
|
145 |
varinfo = rqlst.defined_vars[varname].stinfo |
3ee80d487f11
[security] fix read rql expression insertion: we should not insert rql expr on variables only referenced in neged relation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5726
diff
changeset
|
146 |
if varinfo['selected'] or ( |
3ee80d487f11
[security] fix read rql expression insertion: we should not insert rql expr on variables only referenced in neged relation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5726
diff
changeset
|
147 |
len([r for r in varinfo['relations'] |
3ee80d487f11
[security] fix read rql expression insertion: we should not insert rql expr on variables only referenced in neged relation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5726
diff
changeset
|
148 |
if (not schema.rschema(r.r_type).final |
3ee80d487f11
[security] fix read rql expression insertion: we should not insert rql expr on variables only referenced in neged relation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5726
diff
changeset
|
149 |
and ((isinstance(r.parent, Exists) and r.parent.neged(strict=True)) |
3ee80d487f11
[security] fix read rql expression insertion: we should not insert rql expr on variables only referenced in neged relation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5726
diff
changeset
|
150 |
or isinstance(r.parent, Not)))]) |
9954
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
151 |
!= |
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
152 |
len(varinfo['relations'])): |
5888
3ee80d487f11
[security] fix read rql expression insertion: we should not insert rql expr on variables only referenced in neged relation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5726
diff
changeset
|
153 |
localchecks[varname] = erqlexprs |
0 | 154 |
return localchecks |
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
155 |
|
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
156 |
|
0 | 157 |
# Plans ####################################################################### |
158 |
||
159 |
class ExecutionPlan(object): |
|
160 |
"""the execution model of a rql query, composed of querier steps""" |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
161 |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
162 |
def __init__(self, querier, rqlst, args, cnx): |
0 | 163 |
# original rql syntax tree |
164 |
self.rqlst = rqlst |
|
165 |
self.args = args or {} |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
166 |
# cnx executing the query |
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
167 |
self.cnx = cnx |
0 | 168 |
# quick reference to the system source |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
169 |
self.syssource = cnx.repo.system_source |
0 | 170 |
# execution steps |
171 |
self.steps = [] |
|
172 |
# various resource accesors |
|
173 |
self.querier = querier |
|
174 |
self.schema = querier.schema |
|
175 |
self.sqlannotate = querier.sqlgen_annotate |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
176 |
self.rqlhelper = cnx.vreg.rqlhelper |
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
177 |
|
0 | 178 |
def annotate_rqlst(self): |
179 |
if not self.rqlst.annotated: |
|
180 |
self.rqlhelper.annotate(self.rqlst) |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
181 |
|
0 | 182 |
def add_step(self, step): |
183 |
"""add a step to the plan""" |
|
184 |
self.steps.append(step) |
|
185 |
||
186 |
def sqlexec(self, sql, args=None): |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
187 |
return self.syssource.sqlexec(self.cnx, sql, args) |
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
188 |
|
0 | 189 |
def execute(self): |
190 |
"""execute a plan and return resulting rows""" |
|
9467
ad66d7b3fd48
[multi-sources-removal] Drop no more used federated ('true') multi-sources related code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9463
diff
changeset
|
191 |
for step in self.steps: |
ad66d7b3fd48
[multi-sources-removal] Drop no more used federated ('true') multi-sources related code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9463
diff
changeset
|
192 |
result = step.execute() |
ad66d7b3fd48
[multi-sources-removal] Drop no more used federated ('true') multi-sources related code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9463
diff
changeset
|
193 |
# the latest executed step contains the full query result |
ad66d7b3fd48
[multi-sources-removal] Drop no more used federated ('true') multi-sources related code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9463
diff
changeset
|
194 |
return result |
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
195 |
|
0 | 196 |
def preprocess(self, union, security=True): |
197 |
"""insert security when necessary then annotate rql st for sql generation |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
198 |
|
0 | 199 |
return rqlst to actually execute |
200 |
""" |
|
4954
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
201 |
cached = None |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
202 |
if security and self.cnx.read_security: |
4835
13b0b96d7982
[repo] enhanced security handling: deprecates unsafe_execute, in favor of explicit read/write security control using the `enabled_security` context manager. Also code executed on the repository side is now unsafe by default.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4764
diff
changeset
|
203 |
# ensure security is turned of when security is inserted, |
13b0b96d7982
[repo] enhanced security handling: deprecates unsafe_execute, in favor of explicit read/write security control using the `enabled_security` context manager. Also code executed on the repository side is now unsafe by default.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4764
diff
changeset
|
204 |
# else we may loop for ever... |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
205 |
if self.cnx.transaction_data.get('security-rqlst-cache'): |
4954
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
206 |
key = self.cache_key |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
207 |
else: |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
208 |
key = None |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
209 |
if key is not None and key in self.cnx.transaction_data: |
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
210 |
cachedunion, args = self.cnx.transaction_data[key] |
4954
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
211 |
union.children[:] = [] |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
212 |
for select in cachedunion.children: |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
213 |
union.append(select) |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
214 |
union.has_text_query = cachedunion.has_text_query |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
215 |
args.update(self.args) |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
216 |
self.args = args |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
217 |
cached = True |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
218 |
else: |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
219 |
with self.cnx.security_enabled(read=False): |
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
220 |
noinvariant = self._insert_security(union) |
4954
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
221 |
if key is not None: |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
222 |
self.cnx.transaction_data[key] = (union, self.args) |
4954
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
223 |
else: |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
224 |
noinvariant = () |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
225 |
if cached is None: |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
226 |
self.rqlhelper.simplify(union) |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
227 |
self.sqlannotate(union) |
96f67c5be0e6
[security] experimental rqlst cache for read security: to activate using a 'security-rqlst-cache' flag in transaction data when you'll issue a lot of identic queries with only kwargs varying
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4953
diff
changeset
|
228 |
set_qdata(self.schema.rschema, union, noinvariant) |
0 | 229 |
if union.has_text_query: |
230 |
self.cache_key = None |
|
231 |
||
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
232 |
def _insert_security(self, union): |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
233 |
noinvariant = set() |
0 | 234 |
for select in union.children[:]: |
235 |
for subquery in select.with_: |
|
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
236 |
self._insert_security(subquery.query) |
0 | 237 |
localchecks, restricted = self._check_permissions(select) |
238 |
if any(localchecks): |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
239 |
self.cnx.rql_rewriter.insert_local_checks( |
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
240 |
select, self.args, localchecks, restricted, noinvariant) |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
241 |
return noinvariant |
0 | 242 |
|
243 |
def _check_permissions(self, rqlst): |
|
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
244 |
"""Return a dict defining "local checks", i.e. RQLExpression defined in |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
245 |
the schema that should be inserted in the original query, together with |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
246 |
a set of variable names which requires some security to be inserted. |
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
247 |
|
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
248 |
Solutions where a variable has a type which the user can't definitly |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
249 |
read are removed, else if the user *may* read it (i.e. if an rql |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
250 |
expression is defined for the "read" permission of the related type), |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
251 |
the local checks dict is updated. |
0 | 252 |
|
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
253 |
The local checks dict has entries for each different local check |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
254 |
necessary, with associated solutions as value, a local check being |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
255 |
defined by a list of 2-uple (variable name, rql expressions) for each |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
256 |
variable which has to be checked. Solutions which don't require local |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
257 |
checks will be associated to the empty tuple key. |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
258 |
|
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
259 |
Note rqlst should not have been simplified at this point. |
0 | 260 |
""" |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
261 |
cnx = self.cnx |
0 | 262 |
msgs = [] |
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
263 |
# dict(varname: eid), allowing to check rql expression for variables |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
264 |
# which have a known eid |
4953
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
265 |
varkwargs = {} |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
266 |
if not cnx.transaction_data.get('security-rqlst-cache'): |
4953
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
267 |
for var in rqlst.defined_vars.itervalues(): |
5004
4cc020ee70e2
le patch rql26 a été importé
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4957
diff
changeset
|
268 |
if var.stinfo['constnode'] is not None: |
4cc020ee70e2
le patch rql26 a été importé
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4957
diff
changeset
|
269 |
eid = var.stinfo['constnode'].eval(self.args) |
8748
f5027f8d2478
drop typed_eid() in favour of int() (closes #2742462)
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
8697
diff
changeset
|
270 |
varkwargs[var.name] = int(eid) |
8238
087bb529035c
[spelling] fix dictionnary -> dictionary typo
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8127
diff
changeset
|
271 |
# dictionary of variables restricted for security reason |
0 | 272 |
localchecks = {} |
273 |
restricted_vars = set() |
|
274 |
newsolutions = [] |
|
275 |
for solution in rqlst.solutions: |
|
276 |
try: |
|
9954
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
277 |
localcheck = get_local_checks(cnx, rqlst, solution) |
8695
358d8bed9626
[toward-py3k] rewrite to "except AnException as exc:" (part of #2711624)
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
8694
diff
changeset
|
278 |
except Unauthorized as ex: |
0 | 279 |
msg = 'remove %s from solutions since %s has no %s access to %s' |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
280 |
msg %= (solution, cnx.user.login, ex.args[0], ex.args[1]) |
0 | 281 |
msgs.append(msg) |
282 |
LOGGER.info(msg) |
|
283 |
else: |
|
284 |
newsolutions.append(solution) |
|
4953
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
285 |
# try to benefit of rqlexpr.check cache for entities which |
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
286 |
# are specified by eid in query'args |
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
287 |
for varname, eid in varkwargs.iteritems(): |
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
288 |
try: |
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
289 |
rqlexprs = localcheck.pop(varname) |
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
290 |
except KeyError: |
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
291 |
continue |
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
292 |
# if entity has been added in the current transaction, the |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
293 |
# user can read it whatever rql expressions are associated |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
294 |
# to its type |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
295 |
if cnx.added_in_transaction(eid): |
4953
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
296 |
continue |
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
297 |
for rqlexpr in rqlexprs: |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
298 |
if rqlexpr.check(cnx, eid): |
4953
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
299 |
break |
c8c0e10dbd97
[read security] minor optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4843
diff
changeset
|
300 |
else: |
8333
baa3ea5eac2b
querier: Improve error message when ERQLExpression fails on some entity (closes #2267081)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
8238
diff
changeset
|
301 |
raise Unauthorized('No read acces on %r with eid %i.' % (var, eid)) |
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
302 |
# mark variables protected by an rql expression |
0 | 303 |
restricted_vars.update(localcheck) |
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
304 |
# turn local check into a dict key |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
305 |
localcheck = tuple(sorted(localcheck.iteritems())) |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
306 |
localchecks.setdefault(localcheck, []).append(solution) |
0 | 307 |
# raise Unautorized exception if the user can't access to any solution |
308 |
if not newsolutions: |
|
309 |
raise Unauthorized('\n'.join(msgs)) |
|
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
310 |
# if there is some message, solutions have been modified and must be |
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
311 |
# reconsidered by the syntax treee |
6128 | 312 |
if msgs: |
313 |
rqlst.set_possible_types(newsolutions) |
|
0 | 314 |
return localchecks, restricted_vars |
315 |
||
316 |
def finalize(self, select, solutions, insertedvars): |
|
317 |
rqlst = Union() |
|
318 |
rqlst.append(select) |
|
319 |
for mainvarname, rschema, newvarname in insertedvars: |
|
320 |
nvartype = str(rschema.objects(solutions[0][mainvarname])[0]) |
|
321 |
for sol in solutions: |
|
322 |
sol[newvarname] = nvartype |
|
323 |
select.clean_solutions(solutions) |
|
6129
fea746b60093
[ms] fix two planner bugs: one occuring query such as X created_by U where X in a external source and U may come from an ldap source. The other being that when we've to merge input maps, we were modifying the same tree/solutions while a copy were needed. Also, ensure we add type restrictions, necessary for pyro source
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6128
diff
changeset
|
324 |
add_types_restriction(self.schema, select) |
0 | 325 |
self.rqlhelper.annotate(rqlst) |
326 |
self.preprocess(rqlst, security=False) |
|
327 |
return rqlst |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
328 |
|
4759 | 329 |
|
0 | 330 |
class InsertPlan(ExecutionPlan): |
331 |
"""an execution model specific to the INSERT rql query |
|
332 |
""" |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
333 |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
334 |
def __init__(self, querier, rqlst, args, cnx): |
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
335 |
ExecutionPlan.__init__(self, querier, rqlst, args, cnx) |
0 | 336 |
# save originaly selected variable, we may modify this |
337 |
# dictionary for substitution (query parameters) |
|
338 |
self.selected = rqlst.selection |
|
6142
8bc6eac1fac1
[session] cleanup hook / operation / entity edition api
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6129
diff
changeset
|
339 |
# list of rows of entities definition (ssplanner.EditedEntity) |
0 | 340 |
self.e_defs = [[]] |
341 |
# list of new relation definition (3-uple (from_eid, r_type, to_eid) |
|
5657
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5596
diff
changeset
|
342 |
self.r_defs = set() |
0 | 343 |
# indexes to track entity definitions bound to relation definitions |
344 |
self._r_subj_index = {} |
|
345 |
self._r_obj_index = {} |
|
346 |
self._expanded_r_defs = {} |
|
347 |
||
348 |
def add_entity_def(self, edef): |
|
349 |
"""add an entity definition to build""" |
|
350 |
self.e_defs[-1].append(edef) |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
351 |
|
0 | 352 |
def add_relation_def(self, rdef): |
353 |
"""add an relation definition to build""" |
|
5657
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5596
diff
changeset
|
354 |
self.r_defs.add(rdef) |
0 | 355 |
if not isinstance(rdef[0], int): |
356 |
self._r_subj_index.setdefault(rdef[0], []).append(rdef) |
|
357 |
if not isinstance(rdef[2], int): |
|
358 |
self._r_obj_index.setdefault(rdef[2], []).append(rdef) |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
359 |
|
0 | 360 |
def substitute_entity_def(self, edef, edefs): |
361 |
"""substitute an incomplete entity definition by a list of complete |
|
362 |
equivalents |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
363 |
|
0 | 364 |
e.g. on queries such as :: |
365 |
INSERT Personne X, Societe Y: X nom N, Y nom 'toto', X travaille Y |
|
366 |
WHERE U login 'admin', U login N |
|
367 |
||
368 |
X will be inserted as many times as U exists, and so the X travaille Y |
|
369 |
relations as to be added as many time as X is inserted |
|
370 |
""" |
|
371 |
if not edefs or not self.e_defs: |
|
372 |
# no result, no entity will be created |
|
373 |
self.e_defs = () |
|
374 |
return |
|
375 |
# first remove the incomplete entity definition |
|
376 |
colidx = self.e_defs[0].index(edef) |
|
377 |
for i, row in enumerate(self.e_defs[:]): |
|
378 |
self.e_defs[i][colidx] = edefs[0] |
|
379 |
samplerow = self.e_defs[i] |
|
5657
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5596
diff
changeset
|
380 |
for edef_ in edefs[1:]: |
6142
8bc6eac1fac1
[session] cleanup hook / operation / entity edition api
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6129
diff
changeset
|
381 |
row = [ed.clone() for i, ed in enumerate(samplerow) |
8bc6eac1fac1
[session] cleanup hook / operation / entity edition api
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6129
diff
changeset
|
382 |
if i != colidx] |
8bc6eac1fac1
[session] cleanup hook / operation / entity edition api
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6129
diff
changeset
|
383 |
row.insert(colidx, edef_) |
0 | 384 |
self.e_defs.append(row) |
385 |
# now, see if this entity def is referenced as subject in some relation |
|
386 |
# definition |
|
8697
574bb05e40a4
[toward py3k] rewrite has_key() (part of #2711624)
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
8696
diff
changeset
|
387 |
if edef in self._r_subj_index: |
0 | 388 |
for rdef in self._r_subj_index[edef]: |
389 |
expanded = self._expanded(rdef) |
|
390 |
result = [] |
|
391 |
for exp_rdef in expanded: |
|
5657
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5596
diff
changeset
|
392 |
for edef_ in edefs: |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5596
diff
changeset
|
393 |
result.append( (edef_, exp_rdef[1], exp_rdef[2]) ) |
0 | 394 |
self._expanded_r_defs[rdef] = result |
395 |
# and finally, see if this entity def is referenced as object in some |
|
396 |
# relation definition |
|
8697
574bb05e40a4
[toward py3k] rewrite has_key() (part of #2711624)
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
8696
diff
changeset
|
397 |
if edef in self._r_obj_index: |
0 | 398 |
for rdef in self._r_obj_index[edef]: |
399 |
expanded = self._expanded(rdef) |
|
400 |
result = [] |
|
401 |
for exp_rdef in expanded: |
|
5657
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5596
diff
changeset
|
402 |
for edef_ in edefs: |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5596
diff
changeset
|
403 |
result.append( (exp_rdef[0], exp_rdef[1], edef_) ) |
0 | 404 |
self._expanded_r_defs[rdef] = result |
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
405 |
|
0 | 406 |
def _expanded(self, rdef): |
407 |
"""return expanded value for the given relation definition""" |
|
408 |
try: |
|
409 |
return self._expanded_r_defs[rdef] |
|
410 |
except KeyError: |
|
411 |
self.r_defs.remove(rdef) |
|
412 |
return [rdef] |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
413 |
|
0 | 414 |
def relation_defs(self): |
415 |
"""return the list for relation definitions to insert""" |
|
8696
0bb18407c053
[toward py3k] rewrite dict.keys() and dict.values() (part of #2711624)
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
8695
diff
changeset
|
416 |
for rdefs in self._expanded_r_defs.itervalues(): |
0 | 417 |
for rdef in rdefs: |
418 |
yield rdef |
|
419 |
for rdef in self.r_defs: |
|
420 |
yield rdef |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
421 |
|
0 | 422 |
def insert_entity_defs(self): |
423 |
"""return eids of inserted entities in a suitable form for the resulting |
|
424 |
result set, e.g.: |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
425 |
|
0 | 426 |
e.g. on queries such as :: |
427 |
INSERT Personne X, Societe Y: X nom N, Y nom 'toto', X travaille Y |
|
428 |
WHERE U login 'admin', U login N |
|
429 |
||
430 |
if there is two entities matching U, the result set will look like |
|
431 |
[(eidX1, eidY1), (eidX2, eidY2)] |
|
432 |
""" |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
433 |
cnx = self.cnx |
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
434 |
repo = cnx.repo |
0 | 435 |
results = [] |
436 |
for row in self.e_defs: |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
437 |
results.append([repo.glob_add_entity(cnx, edef) |
0 | 438 |
for edef in row]) |
439 |
return results |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
440 |
|
0 | 441 |
def insert_relation_defs(self): |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
442 |
cnx = self.cnx |
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
443 |
repo = cnx.repo |
7237
9f619715665b
[server] improve the speed of setting relations between entities (closes #1625257)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7139
diff
changeset
|
444 |
edited_entities = {} |
9f619715665b
[server] improve the speed of setting relations between entities (closes #1625257)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7139
diff
changeset
|
445 |
relations = {} |
0 | 446 |
for subj, rtype, obj in self.relation_defs(): |
447 |
# if a string is given into args instead of an int, we get it here |
|
448 |
if isinstance(subj, basestring): |
|
8748
f5027f8d2478
drop typed_eid() in favour of int() (closes #2742462)
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
8697
diff
changeset
|
449 |
subj = int(subj) |
0 | 450 |
elif not isinstance(subj, (int, long)): |
6142
8bc6eac1fac1
[session] cleanup hook / operation / entity edition api
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6129
diff
changeset
|
451 |
subj = subj.entity.eid |
0 | 452 |
if isinstance(obj, basestring): |
8748
f5027f8d2478
drop typed_eid() in favour of int() (closes #2742462)
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
8697
diff
changeset
|
453 |
obj = int(obj) |
0 | 454 |
elif not isinstance(obj, (int, long)): |
6142
8bc6eac1fac1
[session] cleanup hook / operation / entity edition api
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6129
diff
changeset
|
455 |
obj = obj.entity.eid |
0 | 456 |
if repo.schema.rschema(rtype).inlined: |
7237
9f619715665b
[server] improve the speed of setting relations between entities (closes #1625257)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7139
diff
changeset
|
457 |
if subj not in edited_entities: |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
458 |
entity = cnx.entity_from_eid(subj) |
7237
9f619715665b
[server] improve the speed of setting relations between entities (closes #1625257)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7139
diff
changeset
|
459 |
edited = EditedEntity(entity) |
9f619715665b
[server] improve the speed of setting relations between entities (closes #1625257)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7139
diff
changeset
|
460 |
edited_entities[subj] = edited |
9f619715665b
[server] improve the speed of setting relations between entities (closes #1625257)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7139
diff
changeset
|
461 |
else: |
9f619715665b
[server] improve the speed of setting relations between entities (closes #1625257)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7139
diff
changeset
|
462 |
edited = edited_entities[subj] |
6142
8bc6eac1fac1
[session] cleanup hook / operation / entity edition api
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6129
diff
changeset
|
463 |
edited.edited_attribute(rtype, obj) |
0 | 464 |
else: |
7237
9f619715665b
[server] improve the speed of setting relations between entities (closes #1625257)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7139
diff
changeset
|
465 |
if rtype in relations: |
9f619715665b
[server] improve the speed of setting relations between entities (closes #1625257)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7139
diff
changeset
|
466 |
relations[rtype].append((subj, obj)) |
9f619715665b
[server] improve the speed of setting relations between entities (closes #1625257)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7139
diff
changeset
|
467 |
else: |
9f619715665b
[server] improve the speed of setting relations between entities (closes #1625257)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7139
diff
changeset
|
468 |
relations[rtype] = [(subj, obj)] |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
469 |
repo.glob_add_relations(cnx, relations) |
7237
9f619715665b
[server] improve the speed of setting relations between entities (closes #1625257)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7139
diff
changeset
|
470 |
for edited in edited_entities.itervalues(): |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
471 |
repo.glob_update_entity(cnx, edited) |
0 | 472 |
|
473 |
||
474 |
class QuerierHelper(object): |
|
475 |
"""helper class to execute rql queries, putting all things together""" |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
476 |
|
0 | 477 |
def __init__(self, repo, schema): |
478 |
# system info helper |
|
479 |
self._repo = repo |
|
2476
1294a6bdf3bf
application -> instance where it makes sense
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2101
diff
changeset
|
480 |
# instance schema |
0 | 481 |
self.set_schema(schema) |
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
482 |
|
0 | 483 |
def set_schema(self, schema): |
484 |
self.schema = schema |
|
3240
8604a15995d1
refactor so that rql rewriter may be used outside the server. Enhance it to be usable for RRQLExpression as well
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3171
diff
changeset
|
485 |
repo = self._repo |
7027
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
486 |
# rql st and solution cache. |
7954
a3d3220669d6
[cache] replace lgc.cache with something more appropriate (closes #1921713)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
7779
diff
changeset
|
487 |
self._rql_cache = QueryCache(repo.config['rql-cache-size']) |
7027
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
488 |
# rql cache key cache. Don't bother using a Cache instance: we should |
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
489 |
# have a limited number of queries in there, since there are no entries |
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
490 |
# in this cache for user queries (which have no args) |
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
491 |
self._rql_ck_cache = {} |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
492 |
# some cache usage stats |
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
493 |
self.cache_hit, self.cache_miss = 0, 0 |
0 | 494 |
# rql parsing / analysing helper |
3240
8604a15995d1
refactor so that rql rewriter may be used outside the server. Enhance it to be usable for RRQLExpression as well
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3171
diff
changeset
|
495 |
self.solutions = repo.vreg.solutions |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
496 |
rqlhelper = repo.vreg.rqlhelper |
5768
1e73a466aa69
[fti] support for fti ranking: has_text query results sorted by relevance, and provides a way to control weight per entity / entity's attribute
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5726
diff
changeset
|
497 |
# set backend on the rql helper, will be used for function checking |
9460
a2a0bc984863
[config] cleanup/refactor server sources file values handling
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9448
diff
changeset
|
498 |
rqlhelper.backend = repo.config.system_source_config['db-driver'] |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
499 |
self._parse = rqlhelper.parse |
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
500 |
self._annotate = rqlhelper.annotate |
0 | 501 |
# rql planner |
9448
3e7cad3967c5
[multi-sources-removal] Drop the "true" multi-sources planner
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9286
diff
changeset
|
502 |
self._planner = SSPlanner(schema, rqlhelper) |
0 | 503 |
# sql generation annotator |
504 |
self.sqlgen_annotate = SQLGenAnnotator(schema).annotate |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
505 |
|
0 | 506 |
def parse(self, rql, annotate=False): |
507 |
"""return a rql syntax tree for the given rql""" |
|
508 |
try: |
|
3240
8604a15995d1
refactor so that rql rewriter may be used outside the server. Enhance it to be usable for RRQLExpression as well
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3171
diff
changeset
|
509 |
return self._parse(unicode(rql), annotate=annotate) |
0 | 510 |
except UnicodeError: |
511 |
raise RQLSyntaxError(rql) |
|
512 |
||
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
513 |
def plan_factory(self, rqlst, args, cnx): |
0 | 514 |
"""create an execution plan for an INSERT RQL query""" |
515 |
if rqlst.TYPE == 'insert': |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
516 |
return InsertPlan(self, rqlst, args, cnx) |
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
517 |
return ExecutionPlan(self, rqlst, args, cnx) |
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
518 |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
519 |
def execute(self, cnx, rql, args=None, build_descr=True): |
0 | 520 |
"""execute a rql query, return resulting rows and their description in |
521 |
a `ResultSet` object |
|
522 |
||
9701
46c8d8701240
an unicode string -> a unicode string
Rémi Cardona <remi.cardona@logilab.fr>
parents:
9286
diff
changeset
|
523 |
* `rql` should be a Unicode string or a plain ASCII string |
0 | 524 |
* `args` the optional parameters dictionary associated to the query |
525 |
* `build_descr` is a boolean flag indicating if the description should |
|
526 |
be built on select queries (if false, the description will be en empty |
|
527 |
list) |
|
528 |
||
4654
717310b3d576
docstring improvement
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
4533
diff
changeset
|
529 |
on INSERT queries, there will be one row with the eid of each inserted |
0 | 530 |
entity |
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1133
diff
changeset
|
531 |
|
0 | 532 |
result for DELETE and SET queries is undefined yet |
533 |
||
534 |
to maximize the rql parsing/analyzing cache performance, you should |
|
4654
717310b3d576
docstring improvement
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
4533
diff
changeset
|
535 |
always use substitute arguments in queries (i.e. avoid query such as |
0 | 536 |
'Any X WHERE X eid 123'!) |
537 |
""" |
|
2621
1b9d08840a0e
R [querier] debugging tweaks
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2601
diff
changeset
|
538 |
if server.DEBUG & (server.DBG_RQL | server.DBG_SQL): |
2629
0d445c2171e4
R [querier] debugging tweaks
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2621
diff
changeset
|
539 |
if server.DEBUG & (server.DBG_MORE | server.DBG_SQL): |
2621
1b9d08840a0e
R [querier] debugging tweaks
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2601
diff
changeset
|
540 |
print '*'*80 |
7779
3826d8480a68
[debug] use repr() in some place where you'll have a chance to get an unicode error if output encoding isn't properly detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7398
diff
changeset
|
541 |
print 'querier input', repr(rql), repr(args) |
0 | 542 |
# parse the query and binds variables |
8127
96d343a5e01b
[rql2sql] None for attributes in kwargs generate IS NULL, so should be considered in sql cache key. Closes #2116693
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7954
diff
changeset
|
543 |
cachekey = (rql,) |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
544 |
try: |
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
545 |
if args: |
7027
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
546 |
# search for named args in query which are eids (hence |
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
547 |
# influencing query's solutions) |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
548 |
eidkeys = self._rql_ck_cache[rql] |
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
549 |
if eidkeys: |
7027
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
550 |
# if there are some, we need a better cache key, eg (rql + |
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
551 |
# entity type of each eid) |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
552 |
try: |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
553 |
cachekey = self._repo.querier_cache_key(cnx, rql, |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
554 |
args, eidkeys) |
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
555 |
except UnknownEid: |
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
556 |
# we want queries such as "Any X WHERE X eid 9999" |
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
557 |
# return an empty result instead of raising UnknownEid |
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5082
diff
changeset
|
558 |
return empty_rset(rql, args) |
0 | 559 |
rqlst = self._rql_cache[cachekey] |
560 |
self.cache_hit += 1 |
|
561 |
except KeyError: |
|
562 |
self.cache_miss += 1 |
|
563 |
rqlst = self.parse(rql) |
|
564 |
try: |
|
7027
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
565 |
# compute solutions for rqlst and return named args in query |
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
566 |
# which are eids. Notice that if you may not need `eidkeys`, we |
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
567 |
# have to compute solutions anyway (kept as annotation on the |
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
568 |
# tree) |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
569 |
eidkeys = self.solutions(cnx, rqlst, args) |
0 | 570 |
except UnknownEid: |
4843
5f7363416765
fix hooks control method name + other litle cleanups
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
571 |
# we want queries such as "Any X WHERE X eid 9999" return an |
5f7363416765
fix hooks control method name + other litle cleanups
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
572 |
# empty result instead of raising UnknownEid |
10246
ef106564b523
[server/querier] stop passing a rqlst to empty_rset
Julien Cristau <julien.cristau@logilab.fr>
parents:
10087
diff
changeset
|
573 |
return empty_rset(rql, args) |
8127
96d343a5e01b
[rql2sql] None for attributes in kwargs generate IS NULL, so should be considered in sql cache key. Closes #2116693
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7954
diff
changeset
|
574 |
if args and rql not in self._rql_ck_cache: |
7027
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
575 |
self._rql_ck_cache[rql] = eidkeys |
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
576 |
if eidkeys: |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
577 |
cachekey = self._repo.querier_cache_key(cnx, rql, args, |
7027
d3d7ff6ab54c
[repo querier] fix rqlst cache no limit issue, comment the code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6427
diff
changeset
|
578 |
eidkeys) |
0 | 579 |
self._rql_cache[cachekey] = rqlst |
5072
072ae171aeb0
[cleanup] style fixes, add nodes, 0.2 cents refactorings
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4957
diff
changeset
|
580 |
if rqlst.TYPE != 'select': |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
581 |
if cnx.read_security: |
0 | 582 |
check_no_password_selected(rqlst) |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
583 |
# write query, ensure connection's mode is 'write' so connections |
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
584 |
# won't be released until commit/rollback |
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
585 |
cnx.mode = 'write' |
0 | 586 |
cachekey = None |
587 |
else: |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
588 |
if cnx.read_security: |
0 | 589 |
for select in rqlst.children: |
590 |
check_no_password_selected(select) |
|
9954
79d34ba48612
[CWEP002] refactor rql read security checking
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9892
diff
changeset
|
591 |
check_relations_read_access(cnx, select, args) |
0 | 592 |
# on select query, always copy the cached rqlst so we don't have to |
593 |
# bother modifying it. This is not necessary on write queries since |
|
594 |
# a new syntax tree is built from them. |
|
595 |
rqlst = rqlst.copy() |
|
9955
60a9cd1b3a4b
[CWEP002] Plug the computed relation rewriter in the querier
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
9954
diff
changeset
|
596 |
# Rewrite computed relations |
60a9cd1b3a4b
[CWEP002] Plug the computed relation rewriter in the querier
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
9954
diff
changeset
|
597 |
rewriter = RQLRelationRewriter(cnx) |
60a9cd1b3a4b
[CWEP002] Plug the computed relation rewriter in the querier
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
9954
diff
changeset
|
598 |
rewriter.rewrite(rqlst, args) |
3240
8604a15995d1
refactor so that rql rewriter may be used outside the server. Enhance it to be usable for RRQLExpression as well
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3171
diff
changeset
|
599 |
self._annotate(rqlst) |
8127
96d343a5e01b
[rql2sql] None for attributes in kwargs generate IS NULL, so should be considered in sql cache key. Closes #2116693
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7954
diff
changeset
|
600 |
if args: |
8342
7a5271182ef0
[rql annotation] fix has_text_query detection (if coming from sub-query and if has_text on a column aliases. Closes #2275322
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8333
diff
changeset
|
601 |
# different SQL generated when some argument is None or not (IS |
8127
96d343a5e01b
[rql2sql] None for attributes in kwargs generate IS NULL, so should be considered in sql cache key. Closes #2116693
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7954
diff
changeset
|
602 |
# NULL). This should be considered when computing sql cache key |
9167
c05652b108ce
[rql rewrite] move some code from querier to rqlrewrite where it makes more sense.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8867
diff
changeset
|
603 |
cachekey += tuple(sorted([k for k, v in args.iteritems() |
8127
96d343a5e01b
[rql2sql] None for attributes in kwargs generate IS NULL, so should be considered in sql cache key. Closes #2116693
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7954
diff
changeset
|
604 |
if v is None])) |
0 | 605 |
# make an execution plan |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
606 |
plan = self.plan_factory(rqlst, args, cnx) |
0 | 607 |
plan.cache_key = cachekey |
608 |
self._planner.build_plan(plan) |
|
609 |
# execute the plan |
|
610 |
try: |
|
611 |
results = plan.execute() |
|
6361
843684a50e48
[transaction] to avoid potential db corruption, we should rollback systematically in case of ValidationError
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6129
diff
changeset
|
612 |
except (Unauthorized, ValidationError): |
843684a50e48
[transaction] to avoid potential db corruption, we should rollback systematically in case of ValidationError
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6129
diff
changeset
|
613 |
# getting an Unauthorized/ValidationError exception means the |
9267
24d9b86dfa54
spelling: rollbacked -> rolled back
Rémi Cardona <remi.cardona@logilab.fr>
parents:
9167
diff
changeset
|
614 |
# transaction must be rolled back |
4532
85116e75f561
fix auto-rollback on unauthorized error:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
615 |
# |
85116e75f561
fix auto-rollback on unauthorized error:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
616 |
# notes: |
7398
26695dd703d8
[repository api] definitly kill usage of word 'pool' to refer to connections set used by a session
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7237
diff
changeset
|
617 |
# * we should not reset the connections set here, since we don't want the |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
618 |
# connection to loose it during processing |
4532
85116e75f561
fix auto-rollback on unauthorized error:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
619 |
# * don't rollback if we're in the commit process, will be handled |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
620 |
# by the connection |
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
621 |
if cnx.commit_state is None: |
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
622 |
cnx.commit_state = 'uncommitable' |
0 | 623 |
raise |
624 |
# build a description for the results if necessary |
|
625 |
descr = () |
|
626 |
if build_descr: |
|
627 |
if rqlst.TYPE == 'select': |
|
628 |
# sample selection |
|
8542
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
629 |
if len(rqlst.children) == 1 and len(rqlst.children[0].solutions) == 1: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
630 |
# easy, all lines are identical |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
631 |
selected = rqlst.children[0].selection |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
632 |
solution = rqlst.children[0].solutions[0] |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
633 |
description = _make_description(selected, args, solution) |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
634 |
descr = RepeatList(len(results), tuple(description)) |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
635 |
else: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
636 |
# hard, delegate the work :o) |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
637 |
descr = manual_build_descr(cnx, rqlst, args, results) |
0 | 638 |
elif rqlst.TYPE == 'insert': |
639 |
# on insert plan, some entities may have been auto-casted, |
|
640 |
# so compute description manually even if there is only |
|
641 |
# one solution |
|
642 |
basedescr = [None] * len(plan.selected) |
|
643 |
todetermine = zip(xrange(len(plan.selected)), repeat(False)) |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
644 |
descr = _build_descr(cnx, results, basedescr, todetermine) |
0 | 645 |
# FIXME: get number of affected entities / relations on non |
646 |
# selection queries ? |
|
647 |
# return a result set object |
|
10087
ed0b076c119b
[rset] kill the rset._rqlst cache
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9990
diff
changeset
|
648 |
return ResultSet(results, rql, args, descr) |
0 | 649 |
|
7083
b8e35cde46e9
help pylint by explicitely defining some attributes
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7027
diff
changeset
|
650 |
# these are overridden by set_log_methods below |
b8e35cde46e9
help pylint by explicitely defining some attributes
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7027
diff
changeset
|
651 |
# only defining here to prevent pylint from complaining |
b8e35cde46e9
help pylint by explicitely defining some attributes
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7027
diff
changeset
|
652 |
info = warning = error = critical = exception = debug = lambda msg,*a,**kw: None |
b8e35cde46e9
help pylint by explicitely defining some attributes
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
7027
diff
changeset
|
653 |
|
0 | 654 |
from logging import getLogger |
655 |
from cubicweb import set_log_methods |
|
656 |
LOGGER = getLogger('cubicweb.querier') |
|
657 |
set_log_methods(QuerierHelper, LOGGER) |
|
8542
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
658 |
|
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
659 |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
660 |
def manual_build_descr(cnx, rqlst, args, result): |
8542
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
661 |
"""build a description for a given result by analysing each row |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
662 |
|
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
663 |
XXX could probably be done more efficiently during execution of query |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
664 |
""" |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
665 |
# not so easy, looks for variable which changes from one solution |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
666 |
# to another |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
667 |
unstables = rqlst.get_variable_indices() |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
668 |
basedescr = [] |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
669 |
todetermine = [] |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
670 |
for i in xrange(len(rqlst.children[0].selection)): |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
671 |
ttype = _selection_idx_type(i, rqlst, args) |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
672 |
if ttype is None or ttype == 'Any': |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
673 |
ttype = None |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
674 |
isfinal = True |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
675 |
else: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
676 |
isfinal = ttype in BASE_TYPES |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
677 |
if ttype is None or i in unstables: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
678 |
basedescr.append(None) |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
679 |
todetermine.append( (i, isfinal) ) |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
680 |
else: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
681 |
basedescr.append(ttype) |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
682 |
if not todetermine: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
683 |
return RepeatList(len(result), tuple(basedescr)) |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
684 |
return _build_descr(cnx, result, basedescr, todetermine) |
8542
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
685 |
|
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
686 |
def _build_descr(cnx, result, basedescription, todetermine): |
8542
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
687 |
description = [] |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
688 |
entity_metas = cnx.entity_metas |
8542
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
689 |
todel = [] |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
690 |
for i, row in enumerate(result): |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
691 |
row_descr = basedescription[:] |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
692 |
for index, isfinal in todetermine: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
693 |
value = row[index] |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
694 |
if value is None: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
695 |
# None value inserted by an outer join, no type |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
696 |
row_descr[index] = None |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
697 |
continue |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
698 |
if isfinal: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
699 |
row_descr[index] = etype_from_pyobj(value) |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
700 |
else: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
701 |
try: |
9469
032825bbacab
[multi-sources-removal] Drop entities.source column
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9467
diff
changeset
|
702 |
row_descr[index] = entity_metas(value)['type'] |
8542
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
703 |
except UnknownEid: |
9508
1263f1258796
[server] rename session to cnx in querier and plan
Julien Cristau <julien.cristau@logilab.fr>
parents:
9469
diff
changeset
|
704 |
cnx.error('wrong eid %s in repository, you should ' |
8542
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
705 |
'db-check the database' % value) |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
706 |
todel.append(i) |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
707 |
break |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
708 |
else: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
709 |
description.append(tuple(row_descr)) |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
710 |
for i in reversed(todel): |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
711 |
del result[i] |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
712 |
return description |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
713 |
|
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
714 |
def _make_description(selected, args, solution): |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
715 |
"""return a description for a result set""" |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
716 |
description = [] |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
717 |
for term in selected: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
718 |
description.append(term.get_type(solution, args)) |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
719 |
return description |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
720 |
|
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
721 |
def _selection_idx_type(i, rqlst, args): |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
722 |
"""try to return type of term at index `i` of the rqlst's selection""" |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
723 |
for select in rqlst.children: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
724 |
term = select.selection[i] |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
725 |
for solution in select.solutions: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
726 |
try: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
727 |
ttype = term.get_type(solution, args) |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
728 |
if ttype is not None: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
729 |
return ttype |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
730 |
except CoercionError: |
7e264ce34cd4
[session / querier] reorganize code to building result set descriptions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
8342
diff
changeset
|
731 |
return None |