def open_db2(filename, db_dir='', filetype=db.DB_BTREE): # backup
global home_dir
if not db_dir:
db_dir = home_dir
dir = setDBPath(db_dir)
path = os.path.join(dir, filename)
try:
d = dbshelve.open(path, filetype=filetype)
except Exception, msg:
print >> sys.stderr, "bsdcachedb: cannot open dbshelve on", path, msg
d = dbshelve.open(filename, filetype=filetype)
def open_db2(filename, db_dir='', filetype=db.DB_BTREE): # backup
global home_dir
if not db_dir:
db_dir = home_dir
dir = setDBPath(db_dir)
path = os.path.join(dir, filename)
try:
d = dbshelve.open(path, filetype=filetype)
except Exception, msg:
print >> sys.stderr, "bsdcachedb: cannot open dbshelve on", path, msg
d = dbshelve.open(filename, filetype=filetype)
def _openDB(self, db_path, open_type):
print >> sys.stderr, "..Try to open by", self.open_type_list[open_type]
d = None
if open_type == 1: # 'bsddb.dbshelve'
db_types = [db.DB_BTREE, db.DB_HASH]
for dbtype in db_types:
try:
d = dbshelve.open(db_path, filetype=dbtype)
break
except:
d = None
# except:
# print_exc()
if d is not None:
return d.cursor()
# data = dict(d.items())
# d.close()
# return data
else:
return d
elif open_type == 0: # 'bsddb.db'
try:
d = db.DB()
d.open(db_path, db.DB_UNKNOWN)
except:
d = None
# print_exc()
if d is not None:
return d.cursor()
# data = dict(d.items())
# d.close()
# return data
else:
return d
elif open_type == 2: # 'pickle'
try:
f = open(db_path)
d = load(f)
f.close()
return d
except:
return None
else:
try:
f = open(db_path)
d = f.readlines()
f.close()
return d
except:
return None
def _openDB(self, db_path, open_type):
print >> sys.stderr, time.asctime(),'-', "..Try to open by", self.open_type_list[open_type]
d = None
if open_type == 1: # 'bsddb.dbshelve'
db_types = [db.DB_BTREE, db.DB_HASH]
for dbtype in db_types:
try:
d = dbshelve.open(db_path, filetype=dbtype)
break
except:
d = None
# except:
# print_exc()
if d is not None:
return d.cursor()
# data = dict(d.items())
# d.close()
# return data
else:
return d
elif open_type == 0: # 'bsddb.db'
try:
d = db.DB()
d.open(db_path, db.DB_UNKNOWN)
except:
d = None
# print_exc()
if d is not None:
return d.cursor()
# data = dict(d.items())
# d.close()
# return data
else:
return d
elif open_type == 2: # 'pickle'
try:
f = open(db_path)
d = load(f)
f.close()
return d
except:
return None
else:
try:
f = open(db_path)
d = f.readlines()
f.close()
return d
except:
return None
def open(self):
if self.__shelf is not None:
return
log.debug("Opening state database...")
self.__flags = db.DB_PRIVATE | db.DB_CREATE | db.DB_THREAD \
| db.DB_INIT_LOCK | db.DB_INIT_MPOOL
self.__env = env = db.DBEnv()
env.open(self.__config.appdata_dir, self.__flags)
self.__shelf = dbshelve.open(self.__config.state_db_file,
'c',
dbenv=env)
log.debug("State database opened with %d entries.", len(self.keys()))
def open_db(filename, db_dir='', filetype=db.DB_BTREE, writeback=False):
global home_dir
if not db_dir:
db_dir = home_dir
dir = setDBPath(db_dir)
path = os.path.join(dir, filename)
env = db.DBEnv()
# Concurrent Data Store
env.open(dir, db.DB_THREAD|db.DB_INIT_CDB|db.DB_INIT_MPOOL|db.DB_CREATE|db.DB_PRIVATE)
#d = db.DB(env)
#d.open(path, filetype, db.DB_THREAD|db.DB_CREATE)
#_db = BsdDbShelf(d, writeback=writeback)
_db = dbshelve.open(filename, flags=db.DB_THREAD|db.DB_CREATE,
filetype=filetype, dbenv=env)
return _db, dir
def open(self):
if self.__shelf is not None:
return
history_dir = os.path.join(self.__config.appdata_dir, "history")
if not os.path.exists(history_dir):
self.info("Creating history dir %s", history_dir)
os.mkdir(history_dir)
self.debug("Opening history database...")
self.__flags = db.DB_PRIVATE | db.DB_CREATE | db.DB_THREAD \
| db.DB_INIT_LOCK | db.DB_INIT_MPOOL
self.__env = env = db.DBEnv()
env.open(history_dir, self.__flags)
self.__shelf = dbshelve.open("history.db", 'c', dbenv=env)
self.debug("History database opened with %d entries.",
len(self.keys()))
def __init__(self, dbfile, len):
observer.Subject.__init__(self)
self.dbfile = dbfile
env = bsddb.db.DBEnv()
env.open(dbfile, bsddb.db.DB_PRIVATE | bsddb.db.DB_CREATE |
bsddb.db.DB_THREAD | bsddb.db.DB_INIT_LOCK |
bsddb.db.DB_INIT_MPOOL)
self.db = dbshelve.open(dbfile, dbenv = env)
self.lock = threading.RLock()
self.len = len
try:
self.history = self.db["history"]
except:
self.history = []
def open_db(filename, db_dir='', filetype=db.DB_BTREE, writeback=False):
global home_dir
if not db_dir:
db_dir = home_dir
dir = setDBPath(db_dir)
path = os.path.join(dir, filename)
env = db.DBEnv()
# Concurrent Data Store
env.open(
dir, db.DB_THREAD | db.DB_INIT_CDB | db.DB_INIT_MPOOL | db.DB_CREATE
| db.DB_PRIVATE)
#d = db.DB(env)
#d.open(path, filetype, db.DB_THREAD|db.DB_CREATE)
#_db = BsdDbShelf(d, writeback=writeback)
_db = dbshelve.open(filename,
flags=db.DB_THREAD | db.DB_CREATE,
filetype=filetype,
dbenv=env)
return _db, dir
def __init__(self, dbfile, len):
observer.Subject.__init__(self)
self.dbfile = dbfile
env = bsddb.db.DBEnv()
env.open(
dbfile,
bsddb.db.DB_PRIVATE | bsddb.db.DB_CREATE | bsddb.db.DB_THREAD
| bsddb.db.DB_INIT_LOCK | bsddb.db.DB_INIT_MPOOL)
self.db = dbshelve.open(dbfile, dbenv=env)
self.lock = threading.RLock()
self.len = len
try:
self.history = self.db["history"]
except:
self.history = []
def test(filename, mode='direct'):
from random import randint
from time import clock
abc = 'abcdefghijklmnopqrstuvwxyz'
val1 = abc * 23
val2 = abc * 20
t0 = clock()
if mode == 'remote':
db = PersistentDict(filename)
else:
db = dbshelve.open(filename, flags='c')
for i in range(10000):
key = abc+'%4.4d' % i
# print key
db[key] = val1
print(('inserts', clock() - t0))
t0 = clock()
for i in range(10000):
key = abc+'%4.4d' % i
# print key
tmp = db[key]
db[key] = val2
tmp = db[key]
print(('newvalues', clock() - t0))
t0 = clock()
for i in range(10000):
j = randint(0, 10000)
key = abc+'%4.4d' % j
try:
tmp = db[key]
# print key
del db[key]
# db.sync()
except:
pass
print(('deletes', clock() - t0))
db.close()
def test(filename):
from random import randint
from time import clock
abc = 'abcdefghijklmnopqrstuvwxyz'
val1 = abc * 23
val2 = abc * 20
t0 = clock()
db = dbshelve.open(filename, flags='c')
for i in range(10000):
key = abc + '%4.4d' % i
# print key
db[key] = val1
print((clock() - t0))
t0 = clock()
for i in range(10000):
key = abc + '%4.4d' % i
# print key
tmp = db[key]
db[key] = val2
tmp = db[key]
print((clock() - t0))
t0 = clock()
for i in range(10000):
j = randint(0, 10000)
key = abc + '%4.4d' % j
try:
tmp = db[key]
print(key)
del db[key]
# db.sync()
except:
pass
print((clock() - t0))
#!/usr/bin/python
#
# Copyright (C) 2005, TUBITAK/UEKAE
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free
# Software Foundation; either version 2 of the License, or (at your option)
# any later version.
#
# Please read the COPYING file.
#
# Author: Eray Ozkural <*****@*****.**>
import sys
import bsddb.dbshelve as shelve
sys.path.append('.')
import pisi
d = shelve.open( sys.argv[1], flags='r' )
for (k, data) in d.iteritems():
print k, data
d.close()
def createDB(self):
self.primary = dbshelve.open(self.filename,
dbname="primary",
dbenv=self.env,
filetype=self.dbtype)
def do_open(self):
self.d = dbshelve.open(self.filename)
fd = file(fname)
buf = fd.read()
elements = {}
i = 0
bname = os.path.basename(fname).lower()
bname = bname.replace('.dat', '.db')
dbdir = 'db'
if not os.path.exists(dbdir):
os.mkdir(dbdir)
bname = os.path.join(dbdir, bname)
print fname, '->', bname
try:
os.unlink(bname)
except:
pass
db = dbshelve.open(bname)
dbcharset = 'utf-8'
bufsp = buf.split('\0')
bpos = 0
for recData in bufsp:
bpos += len(recData) + 1
i += 1
r = Record(recData)
print i * 100 / len(bufsp), r.word.encode(termcharset)
if r.word == 'NOWORD': continue
word = r.word.encode(dbcharset)
db[word] = bpos
db.close()
def createDB(self):
self.primary = dbshelve.open(self.filename, dbname="primary", dbenv=self.env, filetype=self.dbtype)
#!/usr/bin/python
#
# Copyright (C) 2005, TUBITAK/UEKAE
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free
# Software Foundation; either version 2 of the License, or (at your option)
# any later version.
#
# Please read the COPYING file.
#
# perform analysis on problem instances and store results in a database
# avoiding multiple invocations of the same instance
import sys
import bsddb.dbshelve as shelve
sys.path.append('.')
import pisi
d = shelve.open( sys.argv[1] )
for (k, data) in d.iteritems():
print k, data
d.close()
def test01_badpointer(self):
dbs = dbshelve.open(self.filename)
dbs.close()
self.assertRaises(db.DBError, dbs.get, "foo")
def __init__(self):
util.check_dir(ctx.config.db_dir())
self.filename = os.path.join(ctx.config.db_dir(), 'source.bdb')
self.d = shelve.open(self.filename)
self.fdummy = file(self.filename + '.lock', 'w')
fcntl.flock(self.fdummy, fcntl.LOCK_EX)
def do_open(self):
self.d = dbshelve.open(self.filename)
def test01_badpointer(self):
dbs = dbshelve.open(self.filename)
dbs.close()
self.assertRaises(db.DBError, dbs.get, "foo")
