[gnue] r8457 - trunk/gnue-appserver/src

[reinhard]

Author: reinhard
Date: 2006-05-12 16:34:42 -0500 (Fri, 12 May 2006)
New Revision: 8457

Modified:
   trunk/gnue-appserver/src/data.py
Log:
Further optimization, introduced iterator support in data.recordset.


Modified: trunk/gnue-appserver/src/data.py
===================================================================
--- trunk/gnue-appserver/src/data.py    2006-05-12 17:17:21 UTC (rev 8456)
+++ trunk/gnue-appserver/src/data.py    2006-05-12 21:34:42 UTC (rev 8457)
@@ -118,7 +118,7 @@
         it will change the clean cache.
     """
 
-    key = "%s-%s" % (table, row)
+    key = table + u'-' + row
 
     # If we add 'clean' data there is no need to maintain an undo sequence
     if not dirty:
@@ -128,7 +128,7 @@
       # transaction support.
       if not crow.has_key (field):
         crow [field] = value
-        state = self.__state.setdefault (key, 'clean')
+        self.__state.setdefault (key, 'clean')
 
     else:
       # If there is no backup of the record right now, we have to create one
@@ -1221,13 +1221,14 @@
     self.__add     = []
     self.__added   = 0
     self.__remove  = {}
-    self.__mergeWithCache (conditions, order)
+    self.__mergeWithCache (conditions)
 
     self.__current   = None
     self.__resultSet = _createResultSet (self.__connections, self.__database,
                                          self.__content, conditions, order)
     self.__rawdata = self.__resultSet.raw()
 
+
   # ---------------------------------------------------------------------------
   # Return the number of records
   # ---------------------------------------------------------------------------
@@ -1242,6 +1243,45 @@
 
 
   # ---------------------------------------------------------------------------
+  # Iterator
+  # ---------------------------------------------------------------------------
+
+  def __iter__ (self):
+
+      # next uncommmitted new record to be inserted between the records read
+      # from the backend
+      if self.__add:
+          next_add = SortRecord(self.__add[0],
+                  self.__getSortSequence(self.__add[0]))
+      else:
+          next_add = None
+
+      for backend_record in [self.__buildRecords(r) for r in self.__rawdata]:
+
+          # if there are any uncommitted new records, insert them at the
+          # correct position
+          if next_add is not None:
+              gnue_id = backend_record._row
+              while next_add < SortRecord(gnue_id,
+                      self.__getSortSequence(gnue_id)):
+                  self.__add.pop(0)
+                  self.__added += 1
+                  yield record(self.__cache, self.__connections,
+                          self.__database, self.__getMasterTable(), next_add)
+                  if self.__add:
+                      next_add = SortRecord(self.__add[0],
+                              self.__getSortSequence(self.__add[0]))
+                  else:
+                      next_add = None
+
+          # don't yield records that have been deleted in uncommitted deletes
+          if self.__remove.has_key(backend_record._row):
+              continue
+
+          yield backend_record
+
+
+  # ---------------------------------------------------------------------------
   # Return the next record
   # ---------------------------------------------------------------------------
 
@@ -1272,8 +1312,8 @@
 
         if rec is not None:
           rid   = rec.getField (u'gnue_id')
-          left  = SortRecord (row, self.__getSortSequence (row, self.__order))
-          right = SortRecord (rid, self.__getSortSequence (rid, self.__order))
+          left  = SortRecord (row, self.__getSortSequence (row))
+          right = SortRecord (rid, self.__getSortSequence (rid))
 
           useAdd = cmp (left, right) <= 0
         else:
@@ -1371,7 +1411,7 @@
         return None
 
     # Now, have a look if the instance has to be removed
-    if self.__remove.has_key (self.__current.getRow ()):
+    if self.__remove.has_key (self.__current._row):
       self.__current = None
       res = self.__nextBackendRecord ()
 
@@ -1402,7 +1442,7 @@
   # Merge cache 
   # ---------------------------------------------------------------------------
 
-  def __mergeWithCache (self, conditions, order):
+  def __mergeWithCache (self, conditions):
     """
     """
 
@@ -1432,7 +1472,7 @@
           self.__removeFilter (row, conditions)
         else:
           # otherwise we have to analyze the sort order
-          if self.__sortOrderChanged (row, order):
+          if self.__sortOrderChanged (row):
             # if the sortorder has changed we remove it from the old position
             # and insert it at the new one
             self.__remove [row] = True
@@ -1445,8 +1485,8 @@
 
     # If we have a sort order defined, we need to sort all records listed for
     # addition
-    if order and len (self.__add):
-      self.__sortAddition (order)
+    if self.__order and len (self.__add):
+      self.__sortAddition ()
 
 
   # ---------------------------------------------------------------------------
@@ -1568,7 +1608,7 @@
   # Check wether a field in the sort order has changed or not
   # ---------------------------------------------------------------------------
 
-  def __sortOrderChanged (self, row, order):
+  def __sortOrderChanged (self, row):
     """
     This function checks if a field in the sort order has been changed.
 
@@ -1577,7 +1617,7 @@
     @return: True if a field has been changed, False otherwise
     """
     
-    for field in [f ['name'] for f in order]:
+    for field in [f ['name'] for f in self.__order]:
       path = self.__getPropertyPath (field)
       if self.__fieldIsChanged (row, path):
         return True
@@ -1651,7 +1691,7 @@
   # Sort all records which we have to merge in
   # ---------------------------------------------------------------------------
 
-  def __sortAddition (self, order):
+  def __sortAddition (self):
     """
     This function sorts all records from the cache to fit the current sort
     order.
@@ -1661,7 +1701,7 @@
     if len (self.__add) > 1:
       seq = []
       for row in self.__add:
-        seq.append (SortRecord (row, self.__getSortSequence (row, order)))
+        seq.append (SortRecord (row, self.__getSortSequence (row)))
 
       seq.sort ()
       self.__add = [item.row for item in seq]
@@ -1671,7 +1711,7 @@
   # Create a sort sequence for a sort order and a given record
   # ---------------------------------------------------------------------------
 
-  def __getSortSequence (self, row, order):
+  def __getSortSequence (self, row):
     """
     This function creates a sequence of tuples (fieldvalue, direction) for the
     record specified by 'row' using the given sortorder.
@@ -1684,7 +1724,7 @@
     result = []
     append = result.append
 
-    for element in order:
+    for element in self.__order:
       field      = element ['name']
       direction  = element.get ('descending') or False
       ignorecase = element.get ('ignorecase') or False
@@ -1729,23 +1769,15 @@
     self.__connections = connections
     self.__database    = database
     self.__table       = table
-    self.__row         = row
-    self.__backend     = None
 
+    # performance note:
+    # we make this directly accessible because that's faster than get_row()
+    self._row          = row
 
-  # ---------------------------------------------------------------------------
-  # Get the gnue_id of the record
-  # ---------------------------------------------------------------------------
+    # backend database connection
+    self.__backend     = None
 
-  def getRow (self):
-    """
-    Return the current row-id of this record
-    @return: row id of this record instance
-    """
 
-    return self.__row
-
-
   # ---------------------------------------------------------------------------
   # Cache a single value for this record
   # ---------------------------------------------------------------------------
@@ -1758,7 +1790,7 @@
     @param value: value of the field
     """
 
-    self.__cache.write (self.__table, self.__row, field, value, False)
+    self.__cache.write (self.__table, self._row, field, value, False)
 
 
   # ---------------------------------------------------------------------------
@@ -1778,7 +1810,7 @@
     for field in fields:
       f = alias and (alias + '.' + field) or field
 
-      self.__cache.write (self.__table, self.__row, field, RecordSet [f], 
False)
+      self.__cache.write (self.__table, self._row, field, RecordSet [f], False)
 
 
   # ---------------------------------------------------------------------------
@@ -1807,7 +1839,7 @@
     # First try to return the value from the cache. Just trying it and ignoring
     # a KeyError exception is much faster than first checking if it exists.
     try:
-      return self.__cache.read (self.__table, self.__row, field, not original)
+      return self.__cache.read (self.__table, self._row, field, not original)
     except KeyError:
       pass
 
@@ -1821,11 +1853,11 @@
     if self.__backend is None:
       self.__backend = self.__connections.getConnection (self.__database, True)
 
-    new = self.__backend.requery (self.__table, {u'gnue_id': self.__row},
+    new = self.__backend.requery (self.__table, {u'gnue_id': self._row},
                                      [field])
     if new:
       value = new.get (field)
-      self.__cache.write (self.__table, self.__row, field, value, False)
+      self.__cache.write (self.__table, self._row, field, value, False)
     else:
       value = None
 
@@ -1849,7 +1881,7 @@
 
     checktype (field, unicode)
 
-    self.__cache.write (self.__table, self.__row, field, value, True)
+    self.__cache.write (self.__table, self._row, field, value, True)
 
 
   # ---------------------------------------------------------------------------
@@ -1865,7 +1897,7 @@
         another state than 'initializing'.
     """
 
-    self.__cache.initialized (self.__table, self.__row)
+    self.__cache.initialized (self.__table, self._row)
 
 
   # ---------------------------------------------------------------------------
@@ -1888,7 +1920,7 @@
     @return: current state of the record
     """
 
-    return self.__cache.state (self.__table, self.__row)
+    return self.__cache.state (self.__table, self._row)
 
 
   # ---------------------------------------------------------------------------
@@ -1901,7 +1933,7 @@
     instance.
     """
 
-    return "<record of table '%s', row '%s'>" % (self.__table, self.__row)
+    return "<record of table '%s', row '%s'>" % (self.__table, self._row)
       
 
 # =============================================================================