mirror of
https://github.com/python/cpython.git
synced 2025-10-24 23:46:23 +00:00
6ba3329c27
Python 2.6 one, since the intention is to keep an unified 2.x/3.x codebase. The Python code is automatically translated using "2to3". Please, do not update this code in Python 3.0 by hand. Update the 2.6 one and then do "2to3".
370 lines
11 KiB
Python
370 lines
11 KiB
Python
#!/bin/env python
|
|
#------------------------------------------------------------------------
|
|
# Copyright (c) 1997-2001 by Total Control Software
|
|
# All Rights Reserved
|
|
#------------------------------------------------------------------------
|
|
#
|
|
# Module Name: dbShelve.py
|
|
#
|
|
# Description: A reimplementation of the standard shelve.py that
|
|
# forces the use of cPickle, and DB.
|
|
#
|
|
# Creation Date: 11/3/97 3:39:04PM
|
|
#
|
|
# License: This is free software. You may use this software for any
|
|
# purpose including modification/redistribution, so long as
|
|
# this header remains intact and that you do not claim any
|
|
# rights of ownership or authorship of this software. This
|
|
# software has been tested, but no warranty is expressed or
|
|
# implied.
|
|
#
|
|
# 13-Dec-2000: Updated to be used with the new bsddb3 package.
|
|
# Added DBShelfCursor class.
|
|
#
|
|
#------------------------------------------------------------------------
|
|
|
|
"""Manage shelves of pickled objects using bsddb database files for the
|
|
storage.
|
|
"""
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
import pickle
|
|
import sys
|
|
|
|
import sys
|
|
absolute_import = (sys.version_info[0] >= 3)
|
|
if absolute_import :
|
|
# Because this syntaxis is not valid before Python 2.5
|
|
exec("from . import db")
|
|
else :
|
|
from . import db
|
|
|
|
#At version 2.3 cPickle switched to using protocol instead of bin
|
|
if sys.version_info[:3] >= (2, 3, 0):
|
|
HIGHEST_PROTOCOL = pickle.HIGHEST_PROTOCOL
|
|
# In python 2.3.*, "cPickle.dumps" accepts no
|
|
# named parameters. "pickle.dumps" accepts them,
|
|
# so this seems a bug.
|
|
if sys.version_info[:3] < (2, 4, 0):
|
|
def _dumps(object, protocol):
|
|
return pickle.dumps(object, protocol)
|
|
else :
|
|
def _dumps(object, protocol):
|
|
return pickle.dumps(object, protocol=protocol)
|
|
|
|
else:
|
|
HIGHEST_PROTOCOL = None
|
|
def _dumps(object, protocol):
|
|
return pickle.dumps(object, bin=protocol)
|
|
|
|
|
|
if sys.version_info[0:2] <= (2, 5) :
|
|
try:
|
|
from UserDict import DictMixin
|
|
except ImportError:
|
|
# DictMixin is new in Python 2.3
|
|
class DictMixin: pass
|
|
MutableMapping = DictMixin
|
|
else :
|
|
import collections
|
|
MutableMapping = collections.MutableMapping
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
|
|
def open(filename, flags=db.DB_CREATE, mode=0o660, filetype=db.DB_HASH,
|
|
dbenv=None, dbname=None):
|
|
"""
|
|
A simple factory function for compatibility with the standard
|
|
shleve.py module. It can be used like this, where key is a string
|
|
and data is a pickleable object:
|
|
|
|
from bsddb import dbshelve
|
|
db = dbshelve.open(filename)
|
|
|
|
db[key] = data
|
|
|
|
db.close()
|
|
"""
|
|
if type(flags) == type(''):
|
|
sflag = flags
|
|
if sflag == 'r':
|
|
flags = db.DB_RDONLY
|
|
elif sflag == 'rw':
|
|
flags = 0
|
|
elif sflag == 'w':
|
|
flags = db.DB_CREATE
|
|
elif sflag == 'c':
|
|
flags = db.DB_CREATE
|
|
elif sflag == 'n':
|
|
flags = db.DB_TRUNCATE | db.DB_CREATE
|
|
else:
|
|
raise db.DBError("flags should be one of 'r', 'w', 'c' or 'n' or use the bsddb.db.DB_* flags")
|
|
|
|
d = DBShelf(dbenv)
|
|
d.open(filename, dbname, filetype, flags, mode)
|
|
return d
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class DBShelveError(db.DBError): pass
|
|
|
|
|
|
class DBShelf(MutableMapping):
|
|
"""A shelf to hold pickled objects, built upon a bsddb DB object. It
|
|
automatically pickles/unpickles data objects going to/from the DB.
|
|
"""
|
|
def __init__(self, dbenv=None):
|
|
self.db = db.DB(dbenv)
|
|
self._closed = True
|
|
if HIGHEST_PROTOCOL:
|
|
self.protocol = HIGHEST_PROTOCOL
|
|
else:
|
|
self.protocol = 1
|
|
|
|
|
|
def __del__(self):
|
|
self.close()
|
|
|
|
|
|
def __getattr__(self, name):
|
|
"""Many methods we can just pass through to the DB object.
|
|
(See below)
|
|
"""
|
|
return getattr(self.db, name)
|
|
|
|
|
|
#-----------------------------------
|
|
# Dictionary access methods
|
|
|
|
def __len__(self):
|
|
return len(self.db)
|
|
|
|
|
|
def __getitem__(self, key):
|
|
data = self.db[key]
|
|
return pickle.loads(data)
|
|
|
|
|
|
def __setitem__(self, key, value):
|
|
data = _dumps(value, self.protocol)
|
|
self.db[key] = data
|
|
|
|
|
|
def __delitem__(self, key):
|
|
del self.db[key]
|
|
|
|
|
|
def keys(self, txn=None):
|
|
if txn != None:
|
|
return self.db.keys(txn)
|
|
else:
|
|
return list(self.db.keys())
|
|
|
|
if sys.version_info[0:2] >= (2, 6) :
|
|
def __iter__(self) :
|
|
return self.db.__iter__()
|
|
|
|
|
|
def open(self, *args, **kwargs):
|
|
self.db.open(*args, **kwargs)
|
|
self._closed = False
|
|
|
|
|
|
def close(self, *args, **kwargs):
|
|
self.db.close(*args, **kwargs)
|
|
self._closed = True
|
|
|
|
|
|
def __repr__(self):
|
|
if self._closed:
|
|
return '<DBShelf @ 0x%x - closed>' % (id(self))
|
|
else:
|
|
return repr(dict(iter(self.items())))
|
|
|
|
|
|
def items(self, txn=None):
|
|
if txn != None:
|
|
items = self.db.items(txn)
|
|
else:
|
|
items = list(self.db.items())
|
|
newitems = []
|
|
|
|
for k, v in items:
|
|
newitems.append( (k, pickle.loads(v)) )
|
|
return newitems
|
|
|
|
def values(self, txn=None):
|
|
if txn != None:
|
|
values = self.db.values(txn)
|
|
else:
|
|
values = list(self.db.values())
|
|
|
|
return list(map(pickle.loads, values))
|
|
|
|
#-----------------------------------
|
|
# Other methods
|
|
|
|
def __append(self, value, txn=None):
|
|
data = _dumps(value, self.protocol)
|
|
return self.db.append(data, txn)
|
|
|
|
def append(self, value, txn=None):
|
|
if self.get_type() == db.DB_RECNO:
|
|
return self.__append(value, txn=txn)
|
|
raise DBShelveError("append() only supported when dbshelve opened with filetype=dbshelve.db.DB_RECNO")
|
|
|
|
|
|
def associate(self, secondaryDB, callback, flags=0):
|
|
def _shelf_callback(priKey, priData, realCallback=callback):
|
|
# Safe in Python 2.x because expresion short circuit
|
|
if sys.version_info[0] < 3 or isinstance(priData, bytes) :
|
|
data = pickle.loads(priData)
|
|
else :
|
|
data = pickle.loads(bytes(priData, "iso8859-1")) # 8 bits
|
|
return realCallback(priKey, data)
|
|
|
|
return self.db.associate(secondaryDB, _shelf_callback, flags)
|
|
|
|
|
|
#def get(self, key, default=None, txn=None, flags=0):
|
|
def get(self, *args, **kw):
|
|
# We do it with *args and **kw so if the default value wasn't
|
|
# given nothing is passed to the extension module. That way
|
|
# an exception can be raised if set_get_returns_none is turned
|
|
# off.
|
|
data = self.db.get(*args, **kw)
|
|
try:
|
|
return pickle.loads(data)
|
|
except (EOFError, TypeError, pickle.UnpicklingError):
|
|
return data # we may be getting the default value, or None,
|
|
# so it doesn't need unpickled.
|
|
|
|
def get_both(self, key, value, txn=None, flags=0):
|
|
data = _dumps(value, self.protocol)
|
|
data = self.db.get(key, data, txn, flags)
|
|
return pickle.loads(data)
|
|
|
|
|
|
def cursor(self, txn=None, flags=0):
|
|
c = DBShelfCursor(self.db.cursor(txn, flags))
|
|
c.protocol = self.protocol
|
|
return c
|
|
|
|
|
|
def put(self, key, value, txn=None, flags=0):
|
|
data = _dumps(value, self.protocol)
|
|
return self.db.put(key, data, txn, flags)
|
|
|
|
|
|
def join(self, cursorList, flags=0):
|
|
raise NotImplementedError
|
|
|
|
|
|
#----------------------------------------------
|
|
# Methods allowed to pass-through to self.db
|
|
#
|
|
# close, delete, fd, get_byteswapped, get_type, has_key,
|
|
# key_range, open, remove, rename, stat, sync,
|
|
# upgrade, verify, and all set_* methods.
|
|
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class DBShelfCursor:
|
|
"""
|
|
"""
|
|
def __init__(self, cursor):
|
|
self.dbc = cursor
|
|
|
|
def __del__(self):
|
|
self.close()
|
|
|
|
|
|
def __getattr__(self, name):
|
|
"""Some methods we can just pass through to the cursor object. (See below)"""
|
|
return getattr(self.dbc, name)
|
|
|
|
|
|
#----------------------------------------------
|
|
|
|
def dup(self, flags=0):
|
|
c = DBShelfCursor(self.dbc.dup(flags))
|
|
c.protocol = self.protocol
|
|
return c
|
|
|
|
|
|
def put(self, key, value, flags=0):
|
|
data = _dumps(value, self.protocol)
|
|
return self.dbc.put(key, data, flags)
|
|
|
|
|
|
def get(self, *args):
|
|
count = len(args) # a method overloading hack
|
|
method = getattr(self, 'get_%d' % count)
|
|
method(*args)
|
|
|
|
def get_1(self, flags):
|
|
rec = self.dbc.get(flags)
|
|
return self._extract(rec)
|
|
|
|
def get_2(self, key, flags):
|
|
rec = self.dbc.get(key, flags)
|
|
return self._extract(rec)
|
|
|
|
def get_3(self, key, value, flags):
|
|
data = _dumps(value, self.protocol)
|
|
rec = self.dbc.get(key, flags)
|
|
return self._extract(rec)
|
|
|
|
|
|
def current(self, flags=0): return self.get_1(flags|db.DB_CURRENT)
|
|
def first(self, flags=0): return self.get_1(flags|db.DB_FIRST)
|
|
def last(self, flags=0): return self.get_1(flags|db.DB_LAST)
|
|
def next(self, flags=0): return self.get_1(flags|db.DB_NEXT)
|
|
def prev(self, flags=0): return self.get_1(flags|db.DB_PREV)
|
|
def consume(self, flags=0): return self.get_1(flags|db.DB_CONSUME)
|
|
def next_dup(self, flags=0): return self.get_1(flags|db.DB_NEXT_DUP)
|
|
def next_nodup(self, flags=0): return self.get_1(flags|db.DB_NEXT_NODUP)
|
|
def prev_nodup(self, flags=0): return self.get_1(flags|db.DB_PREV_NODUP)
|
|
|
|
|
|
def get_both(self, key, value, flags=0):
|
|
data = _dumps(value, self.protocol)
|
|
rec = self.dbc.get_both(key, flags)
|
|
return self._extract(rec)
|
|
|
|
|
|
def set(self, key, flags=0):
|
|
rec = self.dbc.set(key, flags)
|
|
return self._extract(rec)
|
|
|
|
def set_range(self, key, flags=0):
|
|
rec = self.dbc.set_range(key, flags)
|
|
return self._extract(rec)
|
|
|
|
def set_recno(self, recno, flags=0):
|
|
rec = self.dbc.set_recno(recno, flags)
|
|
return self._extract(rec)
|
|
|
|
set_both = get_both
|
|
|
|
def _extract(self, rec):
|
|
if rec is None:
|
|
return None
|
|
else:
|
|
key, data = rec
|
|
# Safe in Python 2.x because expresion short circuit
|
|
if sys.version_info[0] < 3 or isinstance(data, bytes) :
|
|
return key, pickle.loads(data)
|
|
else :
|
|
return key, pickle.loads(bytes(data, "iso8859-1")) # 8 bits
|
|
|
|
#----------------------------------------------
|
|
# Methods allowed to pass-through to self.dbc
|
|
#
|
|
# close, count, delete, get_recno, join_item
|
|
|
|
|
|
#---------------------------------------------------------------------------
|