cubicweb: comparison rset.py

equal deleted inserted replaced

-:672acc730ce5
+:d628defebc17
 from logilab.common.decorators import cached, clear_cache, copy_cache
 from rql import nodes
 from cubicweb import NotAnEntity
 class ResultSet(object):
 """a result set wrap a RQL query result. This object implements a partial
 list protocol to allow direct use as a list of result rows.
 # set by the cursor which returned this resultset
 self.vreg = None
 self.req = None
 # actions cache
 self._rsetactions = None
 def __str__(self):
 if not self.rows:
 return '<empty resultset %s>' % self.rql
 return '<resultset %s (%s rows)>' % (self.rql, len(self.rows))
 def __repr__(self):
 if not self.rows:
 return '<empty resultset for %r>' % self.rql
 rows = self.rows
 if len(rows) > 10:
 return self._rsetactions[key]
 except KeyError:
 actions = self.vreg.possible_vobjects('actions', self.req, self, **kwargs)
 self._rsetactions[key] = actions
 return actions
 def __len__(self):
 """returns the result set's size"""
 return self.rowcount
 def __nonzero__(self):
 return self.rowcount
 def __getitem__(self, i):
 """returns the ith element of the result set"""
 return self.rows[i] #ResultSetRow(self.rows[i])
 def __getslice__(self, i, j):
 """returns slice [i:j] of the result set"""
 return self.rows[i:j]
 def __iter__(self):
 """Returns an iterator over rows"""
 return iter(self.rows)
 def __add__(self, rset):
 :type transormcb: callable(row, desc)
 :param transformcb:
 a callable which should take a row and its type description as
 parameters, and return the transformed row and type description.
 :type col: int
 :param col: the column index
 :rtype: `ResultSet`
 rset.rowcount = len(rows)
 return rset
 def split_rset(self, keyfunc=None, col=0, return_dict=False):
 """Splits the result set in multiple result set according to a given key
 :type keyfunc: callable(entity or FinalType)
 :param keyfunc:
 a callable which should take a value of the rset in argument and
 return the value used to group the value. If not define, raw value
 of the specified columns is used.
 :type limit: int
 :param limit: the maximum number of results
 :type offset: int
 :param offset: the offset index
 :type inplace: bool
 :param inplace:
 if true, the result set is modified in place, else a new result set
 is returned and the original is left unmodified
 if not offset:
 # can copy built entity caches
 copy_cache(rset, 'get_entity', self)
 rset.limited = (limit, offset)
 return rset
 def printable_rql(self, encoded=False):
 """return the result set's origin rql as a string, with arguments
 substitued
 """
 encoding = self.req.encoding
 # sounds like we get encoded or unicode string due to a bug in as_string
 if not encoded:
 if isinstance(rqlstr, unicode):
 return rqlstr
 return unicode(rqlstr, encoding)
 else:
 if isinstance(rqlstr, unicode):
 return rqlstr.encode(encoding)
 return rqlstr
 # client helper methods ###################################################
 def entities(self, col=0):
 """iter on entities with eid in the `col` column of the result set"""
 for i in xrange(len(self)):
 @cached
 def get_entity(self, row, col=None):
 """special method for query retreiving a single entity, returns a
 partially initialized Entity instance.
 WARNING: due to the cache wrapping this function, you should NEVER
 give row as a named parameter (i.e. rset.get_entity(req, 0)
 is OK but rset.get_entity(row=0, req=req) isn't
 :type row,col: int, int
 """internal method to get a single entity, returns a
 partially initialized Entity instance.
 partially means that only attributes selected in the RQL
 query will be directly assigned to the entity.
 :type row,col: int, int
 :param row,col:
 row and col numbers localizing the entity among the result's table
 :return: the partially initialized `Entity` instance
 entity.set_related_cache(attr, x, rrset)
 return entity
 @cached
 def syntax_tree(self):
 """get the syntax tree for the source query.
 :rtype: rql.stmts.Statement
 :return: the RQL syntax tree of the originating query
 """
 if self._rqlst:
 rqlst.schema = self.vreg.schema
 self.vreg.rqlhelper.annotate(rqlst)
 else:
 rqlst = self.vreg.parse(self.req, self.rql, self.args)
 return rqlst
 @cached
 def column_types(self, col):
 """return the list of different types in the column with the given col
 index default to 0 (ie the first column)
 :type col: int
 :param col: the index of the desired column
 :rtype: list
 :return: the different entities type found in the column
 locate_query_col = col
 rqlst = self.syntax_tree()
 etype = self.description[row][col]
 if self.vreg.schema.eschema(etype).is_final():
 # final type, find a better one to locate the correct subquery
 # (ambiguous if possible)
 for i in xrange(len(rqlst.children[0].selection)):
 if i == col:
 continue
 coletype = self.description[row][i]
 if coletype is None:
 for rel in rqlst.iget_nodes(nodes.Relation):
 if rel.r_type == 'has_text':
 __, rhs = rel.get_variable_parts()
 return rhs.eval(self.args)
 return None
 def attr_desc_iterator(rqlst, index=0):
 """return an iterator on a list of 2-uple (index, attr_relation)
 localizing attribute relations of the main variable in a result's row

branch	tls-sprint
changeset 1802	d628defebc17
parent 1477	b056a49c16dc
child 1922	1a0ddb675951