cubicweb: comparison rset.py

equal deleted inserted replaced

-:48f468f33704
+:e4580e5f0703
 # may have None values in case of outer join (or aggregat on eid
 # hacks)
 if self.rows[i][col] is not None:
 yield self.get_entity(i, col)
+def iter_rows_with_entities(self):
+""" iterates over rows, and for each row
+eids are converted to plain entities
+"""
+for i, row in enumerate(self):
+_row = []
+for j, col in enumerate(row):
+try:
+_row.append(self.get_entity(i, j) if col is not None else col)
+except NotAnEntity:
+_row.append(col)
+yield _row
 def complete_entity(self, row, col=0, skip_bytes=True):
 """short cut to get an completed entity instance for a particular
 row (all instance's attributes have been fetched)
 """
 entity = self.get_entity(row, col)
 """convenience method for query retrieving a single entity, returns a
 partially initialized Entity instance.
 .. warning::
-Due to the cache wrapping this function, you should NEVER
+Due to the cache wrapping this function, you should NEVER give row as
-give row as a named parameter (i.e. rset.get_entity(req, 0)
+a named parameter (i.e. `rset.get_entity(0, 1)` is OK but
-is OK but rset.get_entity(row=0, req=req) isn't)
+`rset.get_entity(row=0, col=1)` isn't)
 :type row,col: int, int
 :param row,col:
 row and col numbers localizing the entity among the result's table
 except KeyError:
 raise NotAnEntity(etype)
 return self._build_entity(row, col)
 def _build_entity(self, row, col):
-"""internal method to get a single entity, returns a
+"""internal method to get a single entity, returns a partially
-partially initialized Entity instance.
+initialized Entity instance.
-partially means that only attributes selected in the RQL
+partially means that only attributes selected in the RQL query will be
-query will be directly assigned to the entity.
+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
 select, col = rqlst.locate_subquery(col, etype, self.args)
 else:
 select = rqlst
 # take care, due to outer join support, we may find None
 # values for non final relation
-for i, attr, role in attr_desc_iterator(select, col):
+for i, attr, role in attr_desc_iterator(select, col, entity.cw_col):
-outerselidx = rqlst.subquery_selection_index(select, i)
-if outerselidx is None:
-continue
 if role == 'subject':
 rschema = eschema.subjrels[attr]
 if rschema.final:
 if attr == 'eid':
-entity.eid = rowvalues[outerselidx]
+entity.eid = rowvalues[i]
 else:
-entity[attr] = rowvalues[outerselidx]
+entity.cw_attr_cache[attr] = rowvalues[i]
 continue
 else:
 rschema = eschema.objrels[attr]
 rdef = eschema.rdef(attr, role)
 # only keep value if it can't be multivalued
 if rdef.role_cardinality(role) in '1?':
-if rowvalues[outerselidx] is None:
+if rowvalues[i] is None:
 if role == 'subject':
 rql = 'Any Y WHERE X %s Y, X eid %s'
 else:
 rql = 'Any Y WHERE Y %s X, X eid %s'
 rrset = ResultSet([], rql % (attr, entity.eid))
 rrset.req = req
 else:
-rrset = self._build_entity(row, outerselidx).as_rset()
+rrset = self._build_entity(row, i).as_rset()
 entity.cw_set_relation_cache(attr, role, rrset)
 return entity
 @cached
 def syntax_tree(self):
 if rel.r_type == 'has_text':
 __, rhs = rel.get_variable_parts()
 return rhs.eval(self.args)
 return None
+def _get_variable(term):
-def attr_desc_iterator(rqlst, index=0):
+# XXX rewritten const
+# use iget_nodes for (hack) case where we have things like MAX(V)
+for vref in term.iget_nodes(nodes.VariableRef):
+return vref.variable
+def attr_desc_iterator(select, selectidx, rootidx):
 """return an iterator on a list of 2-uple (index, attr_relation)
 localizing attribute relations of the main variable in a result's row
 :type rqlst: rql.stmts.Select
 :param rqlst: the RQL syntax tree to describe
 :return:
 a generator on (index, relation, target) describing column being
 attribute of the main variable
 """
-main = rqlst.selection[index]
+rootselect = select
-for i, term in enumerate(rqlst.selection):
+while rootselect.parent.parent is not None:
-if i == index:
+rootselect = rootselect.parent.parent.parent
+rootmain = rootselect.selection[selectidx]
+rootmainvar = _get_variable(rootmain)
+assert rootmainvar
+root = rootselect.parent
+selectmain = select.selection[selectidx]
+for i, term in enumerate(rootselect.selection):
+rootvar = _get_variable(term)
+if rootvar is None:
 continue
-# XXX rewritten const
+if rootvar.name == rootmainvar.name:
-# use iget_nodes for (hack) case where we have things like MAX(V)
+continue
-for vref in term.iget_nodes(nodes.VariableRef):
+if select is not rootselect:
-var = vref.variable
+term = select.selection[root.subquery_selection_index(select, i)]
-break
+var = _get_variable(term)
-else:
+if var is None:
 continue
 for ref in var.references():
 rel = ref.relation()
 if rel is None or rel.is_types_restriction():
 continue
 lhs, rhs = rel.get_variable_parts()
-if main.is_equivalent(lhs):
+if selectmain.is_equivalent(lhs):
 if rhs.is_equivalent(term):
 yield (i, rel.r_type, 'subject')
-elif main.is_equivalent(rhs):
+elif selectmain.is_equivalent(rhs):
 if lhs.is_equivalent(term):
 yield (i, rel.r_type, 'object')

branch	oldstable
changeset 7074	e4580e5f0703
parent 6915	99eb71b311e4
child 7285	39437617f3f0
child 7395	09ffcc04bd21