rset.py
changeset 3777 3ef8cdb5fb1c
parent 3720 5376aaadd16b
parent 3766 9e5dc4b1ada4
child 3890 d7a270f50f54
equal deleted inserted replaced
3739:817e96eeac5c 3777:3ef8cdb5fb1c
   115         # method anymore (syt)
   115         # method anymore (syt)
   116         rset = ResultSet(self.rows+rset.rows, self.rql, self.args,
   116         rset = ResultSet(self.rows+rset.rows, self.rql, self.args,
   117                          self.description +rset.description)
   117                          self.description +rset.description)
   118         return self.req.decorate_rset(rset)
   118         return self.req.decorate_rset(rset)
   119 
   119 
   120     def copy(self):
   120     def copy(self, rows=None, descr=None):
   121         rset = ResultSet(self.rows[:], self.rql, self.args, self.description[:])
   121         if rows is None:
   122         return self.req.decorate_rset(rset)
   122             rows = self.rows[:]
   123 
   123             descr = self.description[:]
   124     def _prepare_copy(self, rows, descr):
       
   125         rset = ResultSet(rows, self.rql, self.args, descr)
   124         rset = ResultSet(rows, self.rql, self.args, descr)
   126         return self.req.decorate_rset(rset)
   125         return self.req.decorate_rset(rset)
   127 
   126 
   128     def transformed_rset(self, transformcb):
   127     def transformed_rset(self, transformcb):
   129         """ the result set according to a given column types
   128         """ the result set according to a given column types
   138         :param col: the column index
   137         :param col: the column index
   139 
   138 
   140         :rtype: `ResultSet`
   139         :rtype: `ResultSet`
   141         """
   140         """
   142         rows, descr = [], []
   141         rows, descr = [], []
   143         rset = self._prepare_copy(rows, descr)
   142         rset = self.copy(rows, descr)
   144         for row, desc in zip(self.rows, self.description):
   143         for row, desc in zip(self.rows, self.description):
   145             nrow, ndesc = transformcb(row, desc)
   144             nrow, ndesc = transformcb(row, desc)
   146             if ndesc: # transformcb returns None for ndesc to skip that row
   145             if ndesc: # transformcb returns None for ndesc to skip that row
   147                 rows.append(nrow)
   146                 rows.append(nrow)
   148                 descr.append(ndesc)
   147                 descr.append(ndesc)
   161         :param col: the column index
   160         :param col: the column index
   162 
   161 
   163         :rtype: `ResultSet`
   162         :rtype: `ResultSet`
   164         """
   163         """
   165         rows, descr = [], []
   164         rows, descr = [], []
   166         rset = self._prepare_copy(rows, descr)
   165         rset = self.copy(rows, descr)
   167         for i in xrange(len(self)):
   166         for i in xrange(len(self)):
   168             if not filtercb(self.get_entity(i, col)):
   167             if not filtercb(self.get_entity(i, col)):
   169                 continue
   168                 continue
   170             rows.append(self.rows[i])
   169             rows.append(self.rows[i])
   171             descr.append(self.description[i])
   170             descr.append(self.description[i])
   188         :param col: the column index. if col = -1, the whole row are used
   187         :param col: the column index. if col = -1, the whole row are used
   189 
   188 
   190         :rtype: `ResultSet`
   189         :rtype: `ResultSet`
   191         """
   190         """
   192         rows, descr = [], []
   191         rows, descr = [], []
   193         rset = self._prepare_copy(rows, descr)
   192         rset = self.copy(rows, descr)
   194         if col >= 0:
   193         if col >= 0:
   195             entities = sorted(enumerate(self.entities(col)),
   194             entities = sorted(enumerate(self.entities(col)),
   196                               key=lambda (i, e): keyfunc(e), reverse=reverse)
   195                               key=lambda (i, e): keyfunc(e), reverse=reverse)
   197         else:
   196         else:
   198             entities = sorted(enumerate(self),
   197             entities = sorted(enumerate(self),
   235             if keyfunc is not None:
   234             if keyfunc is not None:
   236                 key = keyfunc(key)
   235                 key = keyfunc(key)
   237 
   236 
   238             if key not in mapping:
   237             if key not in mapping:
   239                 rows, descr = [], []
   238                 rows, descr = [], []
   240                 rset = self._prepare_copy(rows, descr)
   239                 rset = self.copy(rows, descr)
   241                 mapping[key] = rset
   240                 mapping[key] = rset
   242                 result.append(rset)
   241                 result.append(rset)
   243             else:
   242             else:
   244                 rset = mapping[key]
   243                 rset = mapping[key]
   245             rset.rows.append(self.rows[idx])
   244             rset.rows.append(self.rows[idx])
   330                     if offset <= entity.row < stop:
   329                     if offset <= entity.row < stop:
   331                         entity.row = entity.row - offset
   330                         entity.row = entity.row - offset
   332                     else:
   331                     else:
   333                         self.req.drop_entity_cache(entity.eid)
   332                         self.req.drop_entity_cache(entity.eid)
   334         else:
   333         else:
   335             rset = self._prepare_copy(rows, descr)
   334             rset = self.copy(rows, descr)
   336             if not offset:
   335             if not offset:
   337                 # can copy built entity caches
   336                 # can copy built entity caches
   338                 copy_cache(rset, 'get_entity', self)
   337                 copy_cache(rset, 'get_entity', self)
   339         rset.limited = (limit, offset)
   338         rset.limited = (limit, offset)
   340         return rset
   339         return rset
   556                     if len(self.column_types(i)) > 1:
   555                     if len(self.column_types(i)) > 1:
   557                         break
   556                         break
   558         # UNION query, find the subquery from which this entity has been found
   557         # UNION query, find the subquery from which this entity has been found
   559         select = rqlst.locate_subquery(locate_query_col, etype, self.args)[0]
   558         select = rqlst.locate_subquery(locate_query_col, etype, self.args)[0]
   560         col = rqlst.subquery_selection_index(select, col)
   559         col = rqlst.subquery_selection_index(select, col)
       
   560         if col is None:
       
   561             # XXX unexpected, should fix subquery_selection_index ?
       
   562             return None, None
   561         try:
   563         try:
   562             myvar = select.selection[col].variable
   564             myvar = select.selection[col].variable
   563         except AttributeError:
   565         except AttributeError:
   564             # not a variable
   566             # not a variable
   565             return None, None
   567             return None, None