author | Sylvain Thénault <sylvain.thenault@logilab.fr> |
Mon, 18 Jan 2010 11:50:34 +0100 | |
branch | stable |
changeset 4246 | c95b8c7e5fb2 |
parent 4212 | ab6573088b4a |
child 4252 | 6c4f109c2b03 |
permissions | -rw-r--r-- |
0 | 1 |
"""The `ResultSet` class which is returned as result of a rql query |
2 |
||
3 |
:organization: Logilab |
|
4212
ab6573088b4a
update copyright: welcome 2010
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
3949
diff
changeset
|
4 |
:copyright: 2001-2010 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2. |
0 | 5 |
:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr |
1977
606923dff11b
big bunch of copyright / docstring update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1922
diff
changeset
|
6 |
:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses |
0 | 7 |
""" |
8 |
__docformat__ = "restructuredtext en" |
|
9 |
||
10 |
from logilab.common.decorators import cached, clear_cache, copy_cache |
|
11 |
||
12 |
from rql import nodes |
|
13 |
||
14 |
from cubicweb import NotAnEntity |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
15 |
|
0 | 16 |
|
17 |
class ResultSet(object): |
|
18 |
"""a result set wrap a RQL query result. This object implements a partial |
|
19 |
list protocol to allow direct use as a list of result rows. |
|
20 |
||
21 |
:type rowcount: int |
|
22 |
:ivar rowcount: number of rows in the result |
|
23 |
||
24 |
:type rows: list |
|
25 |
:ivar rows: list of rows of result |
|
26 |
||
27 |
:type description: list |
|
28 |
:ivar description: |
|
29 |
result's description, using the same structure as the result itself |
|
30 |
||
31 |
:type rql: str or unicode |
|
32 |
:ivar rql: the original RQL query string |
|
33 |
""" |
|
34 |
def __init__(self, results, rql, args=None, description=(), cachekey=None, |
|
35 |
rqlst=None): |
|
36 |
self.rows = results |
|
37 |
self.rowcount = results and len(results) or 0 |
|
38 |
# original query and arguments |
|
39 |
self.rql = rql |
|
40 |
self.args = args |
|
41 |
self.cachekey = cachekey |
|
42 |
# entity types for each cell (same shape as rows) |
|
43 |
# maybe discarded if specified when the query has been executed |
|
44 |
self.description = description |
|
45 |
# parsed syntax tree |
|
46 |
if rqlst is not None: |
|
47 |
rqlst.schema = None # reset schema in case of pyro transfert |
|
48 |
self._rqlst = rqlst |
|
49 |
# set to (limit, offset) when a result set is limited using the |
|
50 |
# .limit method |
|
51 |
self.limited = None |
|
52 |
# set by the cursor which returned this resultset |
|
53 |
self.vreg = None |
|
54 |
self.req = None |
|
1381
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
55 |
# actions cache |
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
56 |
self._rsetactions = None |
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
57 |
|
0 | 58 |
def __str__(self): |
59 |
if not self.rows: |
|
60 |
return '<empty resultset %s>' % self.rql |
|
61 |
return '<resultset %s (%s rows)>' % (self.rql, len(self.rows)) |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
62 |
|
0 | 63 |
def __repr__(self): |
64 |
if not self.rows: |
|
170
455ff18ef28e
use repr (instead of str) to print rql in __repr__ method of a result set
Stephanie Marcu <stephanie.marcu@logilab.fr>
parents:
0
diff
changeset
|
65 |
return '<empty resultset for %r>' % self.rql |
616
545a7e18c47f
don't display too much rset rows
sylvain.thenault@logilab.fr
parents:
572
diff
changeset
|
66 |
rows = self.rows |
545a7e18c47f
don't display too much rset rows
sylvain.thenault@logilab.fr
parents:
572
diff
changeset
|
67 |
if len(rows) > 10: |
545a7e18c47f
don't display too much rset rows
sylvain.thenault@logilab.fr
parents:
572
diff
changeset
|
68 |
rows = rows[:10] + ['...'] |
0 | 69 |
if not self.description: |
616
545a7e18c47f
don't display too much rset rows
sylvain.thenault@logilab.fr
parents:
572
diff
changeset
|
70 |
return '<resultset %r (%s rows): %s>' % (self.rql, len(self.rows), |
545a7e18c47f
don't display too much rset rows
sylvain.thenault@logilab.fr
parents:
572
diff
changeset
|
71 |
'\n'.join(str(r) for r in rows)) |
545a7e18c47f
don't display too much rset rows
sylvain.thenault@logilab.fr
parents:
572
diff
changeset
|
72 |
return '<resultset %r (%s rows): %s>' % (self.rql, len(self.rows), |
545a7e18c47f
don't display too much rset rows
sylvain.thenault@logilab.fr
parents:
572
diff
changeset
|
73 |
'\n'.join('%s (%s)' % (r, d) |
545a7e18c47f
don't display too much rset rows
sylvain.thenault@logilab.fr
parents:
572
diff
changeset
|
74 |
for r, d in zip(rows, self.description))) |
0 | 75 |
|
1381
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
76 |
def possible_actions(self, **kwargs): |
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
77 |
if self._rsetactions is None: |
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
78 |
self._rsetactions = {} |
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
79 |
if kwargs: |
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
80 |
key = tuple(sorted(kwargs.iteritems())) |
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
81 |
else: |
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
82 |
key = None |
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
83 |
try: |
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
84 |
return self._rsetactions[key] |
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
85 |
except KeyError: |
2650
18aec79ec3a3
R [vreg] important refactoring of the vregistry, moving behaviour to end dictionnary (and so leaving room for more flexibility ; keep bw compat ; update api usage in cw
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2648
diff
changeset
|
86 |
actions = self.vreg['actions'].possible_vobjects( |
18aec79ec3a3
R [vreg] important refactoring of the vregistry, moving behaviour to end dictionnary (and so leaving room for more flexibility ; keep bw compat ; update api usage in cw
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2648
diff
changeset
|
87 |
self.req, rset=self, **kwargs) |
1381
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
88 |
self._rsetactions[key] = actions |
6042f1b342bb
consider kwargs in possible_actions
sylvain.thenault@logilab.fr
parents:
616
diff
changeset
|
89 |
return actions |
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
90 |
|
0 | 91 |
def __len__(self): |
92 |
"""returns the result set's size""" |
|
93 |
return self.rowcount |
|
94 |
||
95 |
def __nonzero__(self): |
|
96 |
return self.rowcount |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
97 |
|
0 | 98 |
def __getitem__(self, i): |
99 |
"""returns the ith element of the result set""" |
|
100 |
return self.rows[i] #ResultSetRow(self.rows[i]) |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
101 |
|
0 | 102 |
def __getslice__(self, i, j): |
103 |
"""returns slice [i:j] of the result set""" |
|
104 |
return self.rows[i:j] |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
105 |
|
0 | 106 |
def __iter__(self): |
107 |
"""Returns an iterator over rows""" |
|
108 |
return iter(self.rows) |
|
109 |
||
110 |
def __add__(self, rset): |
|
111 |
# XXX buggy implementation (.rql and .args attributes at least much |
|
112 |
# probably differ) |
|
113 |
# at least rql could be fixed now that we have union and sub-queries |
|
114 |
# but I tend to think that since we have that, we should not need this |
|
115 |
# method anymore (syt) |
|
116 |
rset = ResultSet(self.rows+rset.rows, self.rql, self.args, |
|
117 |
self.description +rset.description) |
|
118 |
return self.req.decorate_rset(rset) |
|
119 |
||
3764
034aa14b740a
drop _prepare_copy method from rset in favor of a more generic copy method
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
120 |
def copy(self, rows=None, descr=None): |
034aa14b740a
drop _prepare_copy method from rset in favor of a more generic copy method
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
121 |
if rows is None: |
034aa14b740a
drop _prepare_copy method from rset in favor of a more generic copy method
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
122 |
rows = self.rows[:] |
034aa14b740a
drop _prepare_copy method from rset in favor of a more generic copy method
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
123 |
descr = self.description[:] |
0 | 124 |
rset = ResultSet(rows, self.rql, self.args, descr) |
125 |
return self.req.decorate_rset(rset) |
|
126 |
||
127 |
def transformed_rset(self, transformcb): |
|
128 |
""" the result set according to a given column types |
|
129 |
||
130 |
:type transormcb: callable(row, desc) |
|
131 |
:param transformcb: |
|
132 |
a callable which should take a row and its type description as |
|
133 |
parameters, and return the transformed row and type description. |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
134 |
|
0 | 135 |
|
136 |
:type col: int |
|
137 |
:param col: the column index |
|
138 |
||
139 |
:rtype: `ResultSet` |
|
140 |
""" |
|
141 |
rows, descr = [], [] |
|
3764
034aa14b740a
drop _prepare_copy method from rset in favor of a more generic copy method
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
142 |
rset = self.copy(rows, descr) |
0 | 143 |
for row, desc in zip(self.rows, self.description): |
144 |
nrow, ndesc = transformcb(row, desc) |
|
145 |
if ndesc: # transformcb returns None for ndesc to skip that row |
|
146 |
rows.append(nrow) |
|
147 |
descr.append(ndesc) |
|
148 |
rset.rowcount = len(rows) |
|
149 |
return rset |
|
150 |
||
151 |
def filtered_rset(self, filtercb, col=0): |
|
152 |
"""filter the result set according to a given filtercb |
|
153 |
||
154 |
:type filtercb: callable(entity) |
|
155 |
:param filtercb: |
|
156 |
a callable which should take an entity as argument and return |
|
157 |
False if it should be skipped, else True |
|
158 |
||
159 |
:type col: int |
|
160 |
:param col: the column index |
|
161 |
||
162 |
:rtype: `ResultSet` |
|
163 |
""" |
|
164 |
rows, descr = [], [] |
|
3764
034aa14b740a
drop _prepare_copy method from rset in favor of a more generic copy method
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
165 |
rset = self.copy(rows, descr) |
0 | 166 |
for i in xrange(len(self)): |
167 |
if not filtercb(self.get_entity(i, col)): |
|
168 |
continue |
|
169 |
rows.append(self.rows[i]) |
|
170 |
descr.append(self.description[i]) |
|
171 |
rset.rowcount = len(rows) |
|
172 |
return rset |
|
173 |
||
174 |
||
175 |
def sorted_rset(self, keyfunc, reverse=False, col=0): |
|
176 |
"""sorts the result set according to a given keyfunc |
|
177 |
||
178 |
:type keyfunc: callable(entity) |
|
179 |
:param keyfunc: |
|
180 |
a callable which should take an entity as argument and return |
|
181 |
the value used to compare and sort |
|
182 |
||
183 |
:type reverse: bool |
|
184 |
:param reverse: if the result should be reversed |
|
185 |
||
186 |
:type col: int |
|
187 |
:param col: the column index. if col = -1, the whole row are used |
|
188 |
||
189 |
:rtype: `ResultSet` |
|
190 |
""" |
|
191 |
rows, descr = [], [] |
|
3764
034aa14b740a
drop _prepare_copy method from rset in favor of a more generic copy method
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
192 |
rset = self.copy(rows, descr) |
0 | 193 |
if col >= 0: |
194 |
entities = sorted(enumerate(self.entities(col)), |
|
195 |
key=lambda (i, e): keyfunc(e), reverse=reverse) |
|
196 |
else: |
|
197 |
entities = sorted(enumerate(self), |
|
198 |
key=lambda (i, e): keyfunc(e), reverse=reverse) |
|
1132 | 199 |
for index, _ in entities: |
0 | 200 |
rows.append(self.rows[index]) |
201 |
descr.append(self.description[index]) |
|
202 |
rset.rowcount = len(rows) |
|
203 |
return rset |
|
204 |
||
205 |
def split_rset(self, keyfunc=None, col=0, return_dict=False): |
|
206 |
"""Splits the result set in multiple result set according to a given key |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
207 |
|
0 | 208 |
:type keyfunc: callable(entity or FinalType) |
209 |
:param keyfunc: |
|
210 |
a callable which should take a value of the rset in argument and |
|
211 |
return the value used to group the value. If not define, raw value |
|
212 |
of the specified columns is used. |
|
213 |
||
214 |
:type col: int |
|
215 |
:param col: the column index. if col = -1, the whole row are used |
|
216 |
||
217 |
:type return_dict: Boolean |
|
218 |
:param return_dict: If true, the function return a mapping |
|
219 |
(key -> rset) instead of a list of rset |
|
220 |
||
221 |
:rtype: List of `ResultSet` or mapping of `ResultSet` |
|
222 |
||
223 |
""" |
|
224 |
result = [] |
|
225 |
mapping = {} |
|
226 |
for idx, line in enumerate(self): |
|
227 |
if col >= 0: |
|
228 |
try: |
|
1132 | 229 |
key = self.get_entity(idx, col) |
0 | 230 |
except NotAnEntity: |
231 |
key = line[col] |
|
232 |
else: |
|
233 |
key = line |
|
234 |
if keyfunc is not None: |
|
235 |
key = keyfunc(key) |
|
236 |
||
237 |
if key not in mapping: |
|
238 |
rows, descr = [], [] |
|
3764
034aa14b740a
drop _prepare_copy method from rset in favor of a more generic copy method
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
239 |
rset = self.copy(rows, descr) |
0 | 240 |
mapping[key] = rset |
241 |
result.append(rset) |
|
242 |
else: |
|
243 |
rset = mapping[key] |
|
244 |
rset.rows.append(self.rows[idx]) |
|
245 |
rset.description.append(self.description[idx]) |
|
246 |
||
247 |
||
248 |
for rset in result: |
|
249 |
rset.rowcount = len(rset.rows) |
|
250 |
if return_dict: |
|
251 |
return mapping |
|
252 |
else: |
|
253 |
return result |
|
254 |
||
255 |
def limit(self, limit, offset=0, inplace=False): |
|
256 |
"""limit the result set to the given number of rows optionaly starting |
|
257 |
from an index different than 0 |
|
258 |
||
259 |
:type limit: int |
|
260 |
:param limit: the maximum number of results |
|
261 |
||
262 |
:type offset: int |
|
263 |
:param offset: the offset index |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
264 |
|
0 | 265 |
:type inplace: bool |
266 |
:param inplace: |
|
267 |
if true, the result set is modified in place, else a new result set |
|
268 |
is returned and the original is left unmodified |
|
269 |
||
270 |
:rtype: `ResultSet` |
|
271 |
""" |
|
272 |
stop = limit+offset |
|
273 |
rows = self.rows[offset:stop] |
|
274 |
descr = self.description[offset:stop] |
|
275 |
if inplace: |
|
276 |
rset = self |
|
277 |
rset.rows, rset.description = rows, descr |
|
278 |
rset.rowcount = len(rows) |
|
279 |
clear_cache(rset, 'description_struct') |
|
280 |
if offset: |
|
281 |
clear_cache(rset, 'get_entity') |
|
282 |
# we also have to fix/remove from the request entity cache entities |
|
283 |
# which get a wrong rset reference by this limit call |
|
284 |
for entity in self.req.cached_entities(): |
|
285 |
if entity.rset is self: |
|
286 |
if offset <= entity.row < stop: |
|
287 |
entity.row = entity.row - offset |
|
288 |
else: |
|
289 |
self.req.drop_entity_cache(entity.eid) |
|
290 |
else: |
|
3764
034aa14b740a
drop _prepare_copy method from rset in favor of a more generic copy method
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
291 |
rset = self.copy(rows, descr) |
0 | 292 |
if not offset: |
293 |
# can copy built entity caches |
|
294 |
copy_cache(rset, 'get_entity', self) |
|
295 |
rset.limited = (limit, offset) |
|
296 |
return rset |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
297 |
|
0 | 298 |
def printable_rql(self, encoded=False): |
299 |
"""return the result set's origin rql as a string, with arguments |
|
300 |
substitued |
|
301 |
""" |
|
302 |
encoding = self.req.encoding |
|
303 |
rqlstr = self.syntax_tree().as_string(encoding, self.args) |
|
304 |
# sounds like we get encoded or unicode string due to a bug in as_string |
|
305 |
if not encoded: |
|
306 |
if isinstance(rqlstr, unicode): |
|
307 |
return rqlstr |
|
308 |
return unicode(rqlstr, encoding) |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
309 |
else: |
0 | 310 |
if isinstance(rqlstr, unicode): |
311 |
return rqlstr.encode(encoding) |
|
312 |
return rqlstr |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
313 |
|
0 | 314 |
# client helper methods ################################################### |
315 |
||
316 |
def entities(self, col=0): |
|
317 |
"""iter on entities with eid in the `col` column of the result set""" |
|
318 |
for i in xrange(len(self)): |
|
319 |
# may have None values in case of outer join (or aggregat on eid |
|
320 |
# hacks) |
|
321 |
if self.rows[i][col] is not None: |
|
322 |
yield self.get_entity(i, col) |
|
323 |
||
324 |
@cached |
|
325 |
def get_entity(self, row, col=None): |
|
326 |
"""special method for query retreiving a single entity, returns a |
|
327 |
partially initialized Entity instance. |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
328 |
|
0 | 329 |
WARNING: due to the cache wrapping this function, you should NEVER |
330 |
give row as a named parameter (i.e. rset.get_entity(req, 0) |
|
331 |
is OK but rset.get_entity(row=0, req=req) isn't |
|
332 |
||
333 |
:type row,col: int, int |
|
334 |
:param row,col: |
|
335 |
row and col numbers localizing the entity among the result's table |
|
336 |
||
337 |
:return: the partially initialized `Entity` instance |
|
338 |
""" |
|
339 |
if col is None: |
|
340 |
from warnings import warn |
|
341 |
msg = 'col parameter will become mandatory in future version' |
|
342 |
warn(msg, DeprecationWarning, stacklevel=3) |
|
343 |
col = 0 |
|
344 |
etype = self.description[row][col] |
|
345 |
try: |
|
346 |
eschema = self.vreg.schema.eschema(etype) |
|
3689
deb13e88e037
follow yams 0.25 api changes to improve performance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3625
diff
changeset
|
347 |
if eschema.final: |
0 | 348 |
raise NotAnEntity(etype) |
349 |
except KeyError: |
|
350 |
raise NotAnEntity(etype) |
|
351 |
return self._build_entity(row, col) |
|
352 |
||
2647
b0a2e779845c
enable server side entity caching, 25% speedup on codenaf insertion. ALL CW TESTS OK
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2381
diff
changeset
|
353 |
def _build_entity(self, row, col): |
0 | 354 |
"""internal method to get a single entity, returns a |
355 |
partially initialized Entity instance. |
|
356 |
||
357 |
partially means that only attributes selected in the RQL |
|
358 |
query will be directly assigned to the entity. |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
359 |
|
0 | 360 |
:type row,col: int, int |
361 |
:param row,col: |
|
362 |
row and col numbers localizing the entity among the result's table |
|
363 |
||
364 |
:return: the partially initialized `Entity` instance |
|
365 |
""" |
|
366 |
req = self.req |
|
367 |
if req is None: |
|
368 |
raise AssertionError('dont call get_entity with no req on the result set') |
|
369 |
rowvalues = self.rows[row] |
|
370 |
eid = rowvalues[col] |
|
371 |
assert eid is not None |
|
372 |
# return cached entity if exists. This also avoids potential recursion |
|
373 |
# XXX should we consider updating a cached entity with possible |
|
374 |
# new attributes found in this resultset ? |
|
375 |
try: |
|
2648
4ae7d02ce063
F [rset repo cache] set entity.rset when no set on entities retreived from the cache
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2647
diff
changeset
|
376 |
entity = req.entity_cache(eid) |
4ae7d02ce063
F [rset repo cache] set entity.rset when no set on entities retreived from the cache
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2647
diff
changeset
|
377 |
if entity.rset is None: |
4ae7d02ce063
F [rset repo cache] set entity.rset when no set on entities retreived from the cache
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2647
diff
changeset
|
378 |
# entity has no rset set, this means entity has been cached by |
4ae7d02ce063
F [rset repo cache] set entity.rset when no set on entities retreived from the cache
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2647
diff
changeset
|
379 |
# the repository (req is a repository session) which had no rset |
4ae7d02ce063
F [rset repo cache] set entity.rset when no set on entities retreived from the cache
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2647
diff
changeset
|
380 |
# info. Add id. |
4ae7d02ce063
F [rset repo cache] set entity.rset when no set on entities retreived from the cache
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2647
diff
changeset
|
381 |
entity.rset = self |
4ae7d02ce063
F [rset repo cache] set entity.rset when no set on entities retreived from the cache
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2647
diff
changeset
|
382 |
entity.row = row |
4ae7d02ce063
F [rset repo cache] set entity.rset when no set on entities retreived from the cache
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2647
diff
changeset
|
383 |
entity.col = col |
4ae7d02ce063
F [rset repo cache] set entity.rset when no set on entities retreived from the cache
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2647
diff
changeset
|
384 |
return entity |
0 | 385 |
except KeyError: |
386 |
pass |
|
387 |
# build entity instance |
|
388 |
etype = self.description[row][col] |
|
2650
18aec79ec3a3
R [vreg] important refactoring of the vregistry, moving behaviour to end dictionnary (and so leaving room for more flexibility ; keep bw compat ; update api usage in cw
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2648
diff
changeset
|
389 |
entity = self.vreg['etypes'].etype_class(etype)(req, rset=self, |
18aec79ec3a3
R [vreg] important refactoring of the vregistry, moving behaviour to end dictionnary (and so leaving room for more flexibility ; keep bw compat ; update api usage in cw
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2648
diff
changeset
|
390 |
row=row, col=col) |
0 | 391 |
entity.set_eid(eid) |
392 |
# cache entity |
|
393 |
req.set_entity_cache(entity) |
|
394 |
eschema = entity.e_schema |
|
395 |
# try to complete the entity if there are some additional columns |
|
396 |
if len(rowvalues) > 1: |
|
397 |
rqlst = self.syntax_tree() |
|
398 |
if rqlst.TYPE == 'select': |
|
399 |
# UNION query, find the subquery from which this entity has been |
|
400 |
# found |
|
3625
f03b55a18c43
fix bug w/ get_entity and subqueries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3551
diff
changeset
|
401 |
select, col = rqlst.locate_subquery(col, etype, self.args) |
f03b55a18c43
fix bug w/ get_entity and subqueries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3551
diff
changeset
|
402 |
else: |
f03b55a18c43
fix bug w/ get_entity and subqueries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3551
diff
changeset
|
403 |
select = rqlst |
0 | 404 |
# take care, due to outer join support, we may find None |
405 |
# values for non final relation |
|
3625
f03b55a18c43
fix bug w/ get_entity and subqueries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3551
diff
changeset
|
406 |
for i, attr, x in attr_desc_iterator(select, col): |
f03b55a18c43
fix bug w/ get_entity and subqueries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3551
diff
changeset
|
407 |
outerselidx = rqlst.subquery_selection_index(select, i) |
f03b55a18c43
fix bug w/ get_entity and subqueries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3551
diff
changeset
|
408 |
if outerselidx is None: |
f03b55a18c43
fix bug w/ get_entity and subqueries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3551
diff
changeset
|
409 |
continue |
0 | 410 |
if x == 'subject': |
3689
deb13e88e037
follow yams 0.25 api changes to improve performance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3625
diff
changeset
|
411 |
rschema = eschema.subjrels[attr] |
deb13e88e037
follow yams 0.25 api changes to improve performance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3625
diff
changeset
|
412 |
if rschema.final: |
3625
f03b55a18c43
fix bug w/ get_entity and subqueries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3551
diff
changeset
|
413 |
entity[attr] = rowvalues[outerselidx] |
0 | 414 |
continue |
415 |
tetype = rschema.objects(etype)[0] |
|
416 |
card = rschema.rproperty(etype, tetype, 'cardinality')[0] |
|
417 |
else: |
|
3689
deb13e88e037
follow yams 0.25 api changes to improve performance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3625
diff
changeset
|
418 |
rschema = eschema.objrels[attr] |
0 | 419 |
tetype = rschema.subjects(etype)[0] |
420 |
card = rschema.rproperty(tetype, etype, 'cardinality')[1] |
|
421 |
# only keep value if it can't be multivalued |
|
422 |
if card in '1?': |
|
3625
f03b55a18c43
fix bug w/ get_entity and subqueries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3551
diff
changeset
|
423 |
if rowvalues[outerselidx] is None: |
0 | 424 |
if x == 'subject': |
425 |
rql = 'Any Y WHERE X %s Y, X eid %s' |
|
426 |
else: |
|
427 |
rql = 'Any Y WHERE Y %s X, X eid %s' |
|
428 |
rrset = ResultSet([], rql % (attr, entity.eid)) |
|
429 |
req.decorate_rset(rrset) |
|
430 |
else: |
|
3625
f03b55a18c43
fix bug w/ get_entity and subqueries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3551
diff
changeset
|
431 |
rrset = self._build_entity(row, outerselidx).as_rset() |
0 | 432 |
entity.set_related_cache(attr, x, rrset) |
433 |
return entity |
|
434 |
||
435 |
@cached |
|
436 |
def syntax_tree(self): |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
437 |
"""get the syntax tree for the source query. |
0 | 438 |
|
439 |
:rtype: rql.stmts.Statement |
|
440 |
:return: the RQL syntax tree of the originating query |
|
441 |
""" |
|
442 |
if self._rqlst: |
|
443 |
rqlst = self._rqlst.copy() |
|
444 |
# to avoid transport overhead when pyro is used, the schema has been |
|
445 |
# unset from the syntax tree |
|
446 |
rqlst.schema = self.vreg.schema |
|
447 |
self.vreg.rqlhelper.annotate(rqlst) |
|
448 |
else: |
|
449 |
rqlst = self.vreg.parse(self.req, self.rql, self.args) |
|
450 |
return rqlst |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
451 |
|
0 | 452 |
@cached |
453 |
def column_types(self, col): |
|
454 |
"""return the list of different types in the column with the given col |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
455 |
|
0 | 456 |
:type col: int |
457 |
:param col: the index of the desired column |
|
458 |
||
459 |
:rtype: list |
|
460 |
:return: the different entities type found in the column |
|
461 |
""" |
|
462 |
return frozenset(struc[-1][col] for struc in self.description_struct()) |
|
463 |
||
464 |
@cached |
|
465 |
def description_struct(self): |
|
466 |
"""return a list describing sequence of results with the same |
|
467 |
description, e.g. : |
|
468 |
[[0, 4, ('Bug',)] |
|
469 |
[[0, 4, ('Bug',), [5, 8, ('Story',)] |
|
470 |
[[0, 3, ('Project', 'Version',)]] |
|
471 |
""" |
|
472 |
result = [] |
|
473 |
last = None |
|
474 |
for i, row in enumerate(self.description): |
|
475 |
if row != last: |
|
476 |
if last is not None: |
|
477 |
result[-1][1] = i - 1 |
|
478 |
result.append( [i, None, row] ) |
|
479 |
last = row |
|
480 |
if last is not None: |
|
481 |
result[-1][1] = i |
|
482 |
return result |
|
483 |
||
484 |
@cached |
|
485 |
def related_entity(self, row, col): |
|
486 |
"""try to get the related entity to extract format information if any""" |
|
487 |
locate_query_col = col |
|
488 |
rqlst = self.syntax_tree() |
|
489 |
etype = self.description[row][col] |
|
3689
deb13e88e037
follow yams 0.25 api changes to improve performance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3625
diff
changeset
|
490 |
if self.vreg.schema.eschema(etype).final: |
572
9849fed789c9
test and fix potential error with None optional relation
sylvain.thenault@logilab.fr
parents:
170
diff
changeset
|
491 |
# final type, find a better one to locate the correct subquery |
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
492 |
# (ambiguous if possible) |
0 | 493 |
for i in xrange(len(rqlst.children[0].selection)): |
494 |
if i == col: |
|
495 |
continue |
|
496 |
coletype = self.description[row][i] |
|
497 |
if coletype is None: |
|
498 |
continue |
|
3689
deb13e88e037
follow yams 0.25 api changes to improve performance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3625
diff
changeset
|
499 |
if not self.vreg.schema.eschema(coletype).final: |
0 | 500 |
etype = coletype |
501 |
locate_query_col = i |
|
502 |
if len(self.column_types(i)) > 1: |
|
503 |
break |
|
572
9849fed789c9
test and fix potential error with None optional relation
sylvain.thenault@logilab.fr
parents:
170
diff
changeset
|
504 |
# UNION query, find the subquery from which this entity has been found |
3016
5787d1cc8106
[rset] fix #231354 w/ rql 0.22.3 api
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2650
diff
changeset
|
505 |
select = rqlst.locate_subquery(locate_query_col, etype, self.args)[0] |
5787d1cc8106
[rset] fix #231354 w/ rql 0.22.3 api
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2650
diff
changeset
|
506 |
col = rqlst.subquery_selection_index(select, col) |
3766
9e5dc4b1ada4
work around a pb. with subquery_selection_index
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
3764
diff
changeset
|
507 |
if col is None: |
9e5dc4b1ada4
work around a pb. with subquery_selection_index
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
3764
diff
changeset
|
508 |
# XXX unexpected, should fix subquery_selection_index ? |
9e5dc4b1ada4
work around a pb. with subquery_selection_index
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
3764
diff
changeset
|
509 |
return None, None |
0 | 510 |
try: |
511 |
myvar = select.selection[col].variable |
|
512 |
except AttributeError: |
|
572
9849fed789c9
test and fix potential error with None optional relation
sylvain.thenault@logilab.fr
parents:
170
diff
changeset
|
513 |
# not a variable |
0 | 514 |
return None, None |
515 |
rel = myvar.main_relation() |
|
516 |
if rel is not None: |
|
3016
5787d1cc8106
[rset] fix #231354 w/ rql 0.22.3 api
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2650
diff
changeset
|
517 |
index = rel.children[0].root_selection_index() |
572
9849fed789c9
test and fix potential error with None optional relation
sylvain.thenault@logilab.fr
parents:
170
diff
changeset
|
518 |
if index is not None and self.rows[row][index]: |
0 | 519 |
return self.get_entity(row, index), rel.r_type |
520 |
return None, None |
|
521 |
||
522 |
@cached |
|
523 |
def searched_text(self): |
|
524 |
"""returns the searched text in case of full-text search |
|
525 |
||
526 |
:return: searched text or `None` if the query is not |
|
527 |
a full-text query |
|
528 |
""" |
|
529 |
rqlst = self.syntax_tree() |
|
530 |
for rel in rqlst.iget_nodes(nodes.Relation): |
|
531 |
if rel.r_type == 'has_text': |
|
532 |
__, rhs = rel.get_variable_parts() |
|
533 |
return rhs.eval(self.args) |
|
534 |
return None |
|
1802
d628defebc17
delete-trailing-whitespace + some copyright update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1477
diff
changeset
|
535 |
|
0 | 536 |
|
537 |
def attr_desc_iterator(rqlst, index=0): |
|
538 |
"""return an iterator on a list of 2-uple (index, attr_relation) |
|
539 |
localizing attribute relations of the main variable in a result's row |
|
540 |
||
541 |
:type rqlst: rql.stmts.Select |
|
542 |
:param rqlst: the RQL syntax tree to describe |
|
543 |
||
544 |
:return: |
|
545 |
a generator on (index, relation, target) describing column being |
|
546 |
attribute of the main variable |
|
547 |
""" |
|
548 |
main = rqlst.selection[index] |
|
549 |
for i, term in enumerate(rqlst.selection): |
|
550 |
if i == index: |
|
551 |
continue |
|
2352
734eb79680e9
handle attribute selection on variable selected using MAX()
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
552 |
# XXX rewritten const |
734eb79680e9
handle attribute selection on variable selected using MAX()
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
553 |
# use iget_nodes for (hack) case where we have things like MAX(V) |
734eb79680e9
handle attribute selection on variable selected using MAX()
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
554 |
for vref in term.iget_nodes(nodes.VariableRef): |
734eb79680e9
handle attribute selection on variable selected using MAX()
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
555 |
var = vref.variable |
734eb79680e9
handle attribute selection on variable selected using MAX()
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
556 |
break |
734eb79680e9
handle attribute selection on variable selected using MAX()
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
557 |
else: |
0 | 558 |
continue |
559 |
for ref in var.references(): |
|
560 |
rel = ref.relation() |
|
561 |
if rel is None or rel.is_types_restriction(): |
|
562 |
continue |
|
563 |
lhs, rhs = rel.get_variable_parts() |
|
564 |
if main.is_equivalent(lhs): |
|
565 |
if rhs.is_equivalent(term): |
|
566 |
yield (i, rel.r_type, 'subject') |
|
567 |
elif main.is_equivalent(rhs): |
|
568 |
if lhs.is_equivalent(term): |
|
569 |
yield (i, rel.r_type, 'object') |