[Zope3-checkins] CVS: Zope3/src/zodb/storage - mapping.py:1.3.2.3

Jeremy Hylton jeremy@zope.com
Fri, 14 Feb 2003 15:33:16 -0500


Update of /cvs-repository/Zope3/src/zodb/storage
In directory cvs.zope.org:/tmp/cvs-serv30733/storage

Modified Files:
      Tag: ZODB3-2-integration-branch
	mapping.py 
Log Message:
Bring mapping storage up-to-date with ZODB 3.2.


=== Zope3/src/zodb/storage/mapping.py 1.3.2.2 => 1.3.2.3 ===
--- Zope3/src/zodb/storage/mapping.py:1.3.2.2	Thu Feb 13 19:27:19 2003
+++ Zope3/src/zodb/storage/mapping.py	Fri Feb 14 15:33:14 2003
@@ -1,6 +1,6 @@
 ##############################################################################
 #
-# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# Copyright (c) 2001 Zope Corporation and Contributors.
 # All Rights Reserved.
 #
 # This software is subject to the provisions of the Zope Public License,
@@ -18,99 +18,28 @@
 
 It is meant to illustrate the simplest possible storage.
 
-The Mapping storage uses a single data structure to map
-object ids to data.
-
-The Demo storage serves two purposes:
-
-  - Provide an example implementation of a full storage without
-    distracting storage details,
-
-  - Provide a volatile storage that is useful for giving demonstrations.
-
-The demo strorage can have a "base" storage that is used in a
-read-only fashion. The base storage must not not to contain version
+The Mapping storage uses a single data structure to map object ids to
 data.
-
-There are three main data structures:
-
-  _data -- Transaction logging information necessary for undo
-
-      This is a mapping from transaction id to transaction, where
-      a transaction is simply a 4-tuple:
-
-        packed, user, description, extension_data, records
-
-      where extension_data is a dictionary or None and records are the
-      actual records in chronological order. Packed is a flag
-      indicating whethe the transaction has been packed or not
-
-  _index -- A mapping from oid to record
-
-  _vindex -- A mapping from version name to version data
-
-      where version data is a mapping from oid to record
-
-A record is a tuple:
-
-  oid, serial, pre, vdata, p,
-
-where:
-
-     oid -- object id
-
-     serial -- object serial number
-
-     pre -- The previous record for this object (or None)
-
-     vdata -- version data
-
-        None if not a version, ortherwise:
-           version, non-version-record
-
-     p -- the pickle data or None
-
-The pickle data will be None for a record for an object created in
-an aborted version.
-
-It is instructive to watch what happens to the internal data structures
-as changes are made.  Foe example, in Zope, you can create an external
-method::
-
-  import Zope
-
-  def info(RESPONSE):
-      RESPONSE['Content-type']= 'text/plain'
-
-      return Zope.DB._storage._splat()
-
-and call it to minotor the storage.
-
 $Id$
 """
 
 import zodb.db
 from zodb import interfaces, utils
-from zodb.storage import base
+from zodb.storage.base import BaseStorage
 from zodb.storage.interfaces import *
 from zodb.serialize import findrefs
 from zodb.timestamp import TimeStamp
 from zodb.utils import z64
 
-def DB(name="Mapping Storage",
-       pool_size=7, cache_size=400):
-    ms = MappingStorage(name)
-    db = zodb.db.DB(ms, pool_size, cache_size)
-    return db
-
-class MappingStorage(base.BaseStorage):
+class MappingStorage(BaseStorage):
 
     __implements__ = IStorage
 
-    def __init__(self, name='Mapping Storage'):
-        base.BaseStorage.__init__(self, name)
+    def __init__(self, name="Mapping Storage"):
+        BaseStorage.__init__(self, name)
         self._index = {}
         self._tindex = []
+        self._ltid = None
 
     def close(self):
         pass
@@ -121,9 +50,10 @@
     def load(self, oid, version):
         self._lock_acquire()
         try:
-            p=self._index[oid]
+            p = self._index[oid]
             return p[8:], p[:8] # pickle, serial
-        finally: self._lock_release()
+        finally:
+            self._lock_release()
 
     def store(self, oid, serial, data, version, transaction):
         if transaction is not self._transaction:
@@ -135,16 +65,15 @@
         self._lock_acquire()
         try:
             if self._index.has_key(oid):
-                old=self._index[oid]
-                oserial=old[:8]
+                old = self._index[oid]
+                oserial = old[:8]
                 if serial != oserial:
                     raise interfaces.ConflictError(serials=(oserial, serial))
 
-            serial=self._serial
-            self._tindex.append((oid,serial+data))
+            self._tindex.append((oid, self._serial + data))
         finally: self._lock_release()
 
-        return serial
+        return self._serial
 
     def _clear_temp(self):
         self._tindex = []
@@ -160,39 +89,37 @@
     def pack(self, t):
         self._lock_acquire()
         try:
-            # Build an index of *only* those objects reachable
-            # from the root.
-            index=self._index
-            rootl = [z64]
-            pop=rootl.pop
-            pindex={}
-            referenced=pindex.has_key
+            # Build an index of *only* those objects reachable from the root.
+            rootl = ["\0\0\0\0\0\0\0\0"]
+            pindex = {}
             while rootl:
-                oid=pop()
-                if referenced(oid): continue
-
+                oid = rootl.pop()
+                if pindex.has_key(oid):
+                    continue
                 # Scan non-version pickle for references
-                r=index[oid]
-                pindex[oid]=r
-                p=r[8:]
+                r = self._index[oid]
+                pindex[oid] = r
+                p = r[8:]
                 rootl.extend(findrefs(p))
 
             # Now delete any unreferenced entries:
-            for oid in index.keys():
-                if not referenced(oid): del index[oid]
+            for oid in self._index.keys():
+                if not pindex.has_key(oid):
+                    del self._index[oid]
 
-        finally: self._lock_release()
+        finally:
+            self._lock_release()
 
     def _splat(self):
         """Spit out a string showing state."""
         o=[]
-        o.append('Index:')
+        o.append("Index:")
         index=self._index
         keys=index.keys()
         keys.sort()
         for oid in keys:
             r=index[oid]
-            o.append('  %s: %s, %s' %
+            o.append("  %s: %s, %s" %
                      (utils.u64(oid),TimeStamp(r[:8]),`r[8:]`))
 
         return "\n".join(o)