[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)