def _checkOpen(self):
if self.db is None:
- raise error, "BSDDB object has already been closed"
+ raise error("BSDDB object has already been closed")
def isOpen(self):
return self.db is not None
if cachesize >= 20480:
e.set_cachesize(0, cachesize)
else:
- raise error, "cachesize must be >= 20480"
+ raise error("cachesize must be >= 20480")
e.set_lk_detect(db.DB_LOCK_DEFAULT)
e.open('.', db.DB_PRIVATE | db.DB_CREATE | db.DB_THREAD | db.DB_INIT_LOCK | db.DB_INIT_MPOOL)
return e
if file is not None and os.path.isfile(file):
os.unlink(file)
else:
- raise error, "flags should be one of 'r', 'w', 'c' or 'n', not "+repr(flag)
+ raise error("flags should be one of 'r', 'w', 'c' or 'n', not "+repr(flag))
return flags | db.DB_THREAD
#----------------------------------------------------------------------
from _bsddb import __version__
if version() < (3, 2, 0):
- raise ImportError, "correct BerkeleyDB symbols not found. Perhaps python was statically linked with an older version?"
+ raise ImportError("correct BerkeleyDB symbols not found. Perhaps python was statically linked with an older version?")
def isatty(self):
if self.closed:
- raise ValueError, "I/O operation on closed file"
+ raise ValueError("I/O operation on closed file")
return 0
def seek(self, pos, mode = 0):
if self.closed:
- raise ValueError, "I/O operation on closed file"
+ raise ValueError("I/O operation on closed file")
if mode == 1:
pos = pos + self.pos
elif mode == 2:
def tell(self):
if self.closed:
- raise ValueError, "I/O operation on closed file"
+ raise ValueError("I/O operation on closed file")
return self.pos
def read(self, n = -1):
if self.closed:
- raise ValueError, "I/O operation on closed file"
+ raise ValueError("I/O operation on closed file")
if n < 0:
newpos = self.len
else:
def truncate(self, size=None):
if self.closed:
- raise ValueError, "I/O operation on closed file"
+ raise ValueError("I/O operation on closed file")
if size is None:
size = self.pos
elif size < 0:
def write(self, s):
if self.closed:
- raise ValueError, "I/O operation on closed file"
+ raise ValueError("I/O operation on closed file")
if not s: return
if self.pos > self.len:
self.buflist.append('\0'*(self.pos - self.len))
def flush(self):
if self.closed:
- raise ValueError, "I/O operation on closed file"
+ raise ValueError("I/O operation on closed file")
"""
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"
+ 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)
if self.get_type() != db.DB_RECNO:
self.append = self.__append
return self.append(value, txn=txn)
- raise db.DBError, "append() only supported when dbshelve opened with filetype=dbshelve.db.DB_RECNO"
+ raise db.DBError("append() only supported when dbshelve opened with filetype=dbshelve.db.DB_RECNO")
def associate(self, secondaryDB, callback, flags=0):
columnlist_key = _columns_key(table)
if self.db.has_key(columnlist_key):
- raise TableAlreadyExists, "table already exists"
+ raise TableAlreadyExists("table already exists")
txn = self.env.txn_begin()
# store the table's column info
txn.commit()
txn = None
except DBError as dberror:
- raise TableDBError, dberror.args[1]
+ raise TableDBError(dberror.args[1])
finally:
if txn:
txn.abort()
"""
assert isinstance(table, str)
if contains_metastrings(table):
- raise ValueError, "bad table name: contains reserved metastrings"
+ raise ValueError("bad table name: contains reserved metastrings")
columnlist_key = _columns_key(table)
if not self.db.has_key(columnlist_key):
self.__load_column_info(table)
except DBError as dberror:
- raise TableDBError, dberror.args[1]
+ raise TableDBError(dberror.args[1])
finally:
if txn:
txn.abort()
try:
tcolpickles = self.db.get(_columns_key(table))
except DBNotFoundError:
- raise TableDBError, "unknown table: %r" % (table,)
+ raise TableDBError("unknown table: %r" % (table,))
if not tcolpickles:
- raise TableDBError, "unknown table: %r" % (table,)
+ raise TableDBError("unknown table: %r" % (table,))
self.__tablecolumns[table] = pickle.loads(tcolpickles)
def __new_rowid(self, table, txn) :
txn = None
try:
if not self.db.has_key(_columns_key(table)):
- raise TableDBError, "unknown table"
+ raise TableDBError("unknown table")
# check the validity of each column name
if table not in self.__tablecolumns:
self.__load_column_info(table)
for column in rowdict.keys() :
if not self.__tablecolumns[table].count(column):
- raise TableDBError, "unknown column: %r" % (column,)
+ raise TableDBError("unknown column: %r" % (column,))
# get a unique row identifier for this row
txn = self.env.txn_begin()
txn.abort()
self.db.delete(_rowid_key(table, rowid))
txn = None
- raise TableDBError, dberror.args[1], info[2]
+ raise TableDBError(dberror.args[1]).with_traceback(info[2])
finally:
if txn:
txn.abort()
txn.abort()
except DBError as dberror:
- raise TableDBError, dberror.args[1]
+ raise TableDBError(dberror.args[1])
def Delete(self, table, conditions={}):
"""Delete(table, conditions) - Delete items matching the given
if txn:
txn.abort()
except DBError as dberror:
- raise TableDBError, dberror.args[1]
+ raise TableDBError(dberror.args[1])
def Select(self, table, columns, conditions={}):
columns = self.__tablecolumns[table]
matching_rowids = self.__Select(table, columns, conditions)
except DBError as dberror:
- raise TableDBError, dberror.args[1]
+ raise TableDBError(dberror.args[1])
# return the matches as a list of dictionaries
return matching_rowids.values()
columns = self.tablecolumns[table]
for column in (columns + list(conditions.keys())):
if not self.__tablecolumns[table].count(column):
- raise TableDBError, "unknown column: %r" % (column,)
+ raise TableDBError("unknown column: %r" % (column,))
# keyed on rows that match so far, containings dicts keyed on
# column names containing the data for that row and column.
del self.__tablecolumns[table]
except DBError as dberror:
- raise TableDBError, dberror.args[1]
+ raise TableDBError(dberror.args[1])
finally:
if txn:
txn.abort()
except db.DBError as e:
pass
else:
- raise RuntimeError, "DBTxn.abort() called after DB_TXN no longer valid w/o an exception"
+ raise RuntimeError("DBTxn.abort() called after DB_TXN no longer valid w/o an exception")
txn = self.env.txn_begin()
txn.commit()
except db.DBError as e:
pass
else:
- raise RuntimeError, "DBTxn.commit() called after DB_TXN no longer valid w/o an exception"
+ raise RuntimeError("DBTxn.commit() called after DB_TXN no longer valid w/o an exception")
class BTreeTransactionTestCase(BasicTransactionTestCase):
if l == r:
# pass the set_bt_compare test
return 0
- raise RuntimeError, "i'm a naughty comparison function"
+ raise RuntimeError("i'm a naughty comparison function")
self.createDB (bad_comparator)
#print "\n*** test should print 2 uncatchable tracebacks ***"
self.addDataToDB (['a', 'b', 'c']) # this should raise, but...
# success, the string value in mappings isn't callable
pass
else:
- raise RuntimeError, "why was TypeError not raised for bad callable?"
+ raise RuntimeError("why was TypeError not raised for bad callable?")
# Delete key in select conditions
values = self.tdb.Select(
#print repr(pickledEgg)
rottenEgg = pickle.loads(pickledEgg)
if rottenEgg.args != egg.args or type(rottenEgg) != type(egg):
- raise Exception, (rottenEgg, '!=', egg)
+ raise Exception(rottenEgg, '!=', egg)
else:
- raise Exception, "where's my DBError exception?!?"
+ raise Exception("where's my DBError exception?!?")
self.db.close()
self.env.close()
projects / python / commitdiff