#include <stddef.h> /* for offsetof() */

#include <Python.h>

#define COMPILING_BSDDB_C

#include "bsddb.h"

#undef COMPILING_BSDDB_C

static char *rcs_id = "$Id$";

#if (PY_VERSION_HEX < 0x02050000)

typedef int Py_ssize_t;

#if (PY_VERSION_HEX < 0x02060000) /* really: before python trunk r63675 */

#define PyBytes_FromStringAndSize PyString_FromStringAndSize

#define PyBytes_FromString PyString_FromString

#define PyBytes_AsStringAndSize PyString_AsStringAndSize

#define PyBytes_Check PyString_Check

#define PyBytes_GET_SIZE PyString_GET_SIZE

#define PyBytes_AS_STRING PyString_AS_STRING

#if (PY_VERSION_HEX >= 0x03000000)

#define NUMBER_Check PyLong_Check

#define NUMBER_AsLong PyLong_AsLong

#define NUMBER_FromLong PyLong_FromLong

#define NUMBER_Check PyInt_Check

#define NUMBER_AsLong PyInt_AsLong

#define NUMBER_FromLong PyInt_FromLong

#ifdef WITH_THREAD

#define MYDB_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS;

#define MYDB_END_ALLOW_THREADS Py_END_ALLOW_THREADS;

#if (PY_VERSION_HEX >= 0x02030000)

#define MYDB_USE_GILSTATE

#if defined(MYDB_USE_GILSTATE)

#define MYDB_BEGIN_BLOCK_THREADS \

PyGILState_STATE __savestate = PyGILState_Ensure();

#define MYDB_END_BLOCK_THREADS \

PyGILState_Release(__savestate);

#else /* MYDB_USE_GILSTATE */

static PyInterpreterState* _db_interpreterState = NULL;

#define MYDB_BEGIN_BLOCK_THREADS { \

#define MYDB_END_BLOCK_THREADS \

#endif /* MYDB_USE_GILSTATE */

#define MYDB_BEGIN_ALLOW_THREADS

#define MYDB_END_ALLOW_THREADS

#define MYDB_BEGIN_BLOCK_THREADS

#define MYDB_END_BLOCK_THREADS

#define INCOMPLETE_IS_WARNING 1

static PyObject* DBError; /* Base class, all others derive from this */

static PyObject* DBCursorClosedError; /* raised when trying to use a closed cursor object */

static PyObject* DBKeyEmptyError; /* DB_KEYEMPTY: also derives from KeyError */

static PyObject* DBKeyExistError; /* DB_KEYEXIST */

static PyObject* DBLockDeadlockError; /* DB_LOCK_DEADLOCK */

static PyObject* DBLockNotGrantedError; /* DB_LOCK_NOTGRANTED */

static PyObject* DBNotFoundError; /* DB_NOTFOUND: also derives from KeyError */

static PyObject* DBOldVersionError; /* DB_OLD_VERSION */

static PyObject* DBRunRecoveryError; /* DB_RUNRECOVERY */

static PyObject* DBVerifyBadError; /* DB_VERIFY_BAD */

static PyObject* DBNoServerError; /* DB_NOSERVER */

static PyObject* DBNoServerHomeError; /* DB_NOSERVER_HOME */

static PyObject* DBNoServerIDError; /* DB_NOSERVER_ID */

static PyObject* DBPageNotFoundError; /* DB_PAGE_NOTFOUND */

static PyObject* DBSecondaryBadError; /* DB_SECONDARY_BAD */

#if !INCOMPLETE_IS_WARNING

static PyObject* DBIncompleteError; /* DB_INCOMPLETE */

static PyObject* DBInvalidArgError; /* EINVAL */

static PyObject* DBAccessError; /* EACCES */

static PyObject* DBNoSpaceError; /* ENOSPC */

static PyObject* DBNoMemoryError; /* DB_BUFFER_SMALL (ENOMEM when < 4.3) */

static PyObject* DBAgainError; /* EAGAIN */

static PyObject* DBBusyError; /* EBUSY */

static PyObject* DBFileExistsError; /* EEXIST */

static PyObject* DBNoSuchFileError; /* ENOENT */

static PyObject* DBPermissionsError; /* EPERM */

#if (DBVER >= 42)

static PyObject* DBRepHandleDeadError; /* DB_REP_HANDLE_DEAD */

static PyObject* DBRepUnavailError; /* DB_REP_UNAVAIL */

#if (DBVER < 43)

#define DB_BUFFER_SMALL ENOMEM

#if PYTHON_API_VERSION < 1010

#error "Python 2.1 or later required"

#define DEFAULT_GET_RETURNS_NONE 1

#define DEFAULT_CURSOR_SET_RETURNS_NONE 1 /* 0 in pybsddb < 4.2, python < 2.4 */

#ifndef staticforward

#define staticforward static

#ifndef statichere

#define statichere static

staticforward PyTypeObject DB_Type, DBCursor_Type, DBEnv_Type, DBTxn_Type,

DBLock_Type;

#if (DBVER >= 43)

staticforward PyTypeObject DBSequence_Type;

#ifndef Py_TYPE

#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)

#define DBObject_Check(v) (Py_TYPE(v) == &DB_Type)

#define DBCursorObject_Check(v) (Py_TYPE(v) == &DBCursor_Type)

#define DBEnvObject_Check(v) (Py_TYPE(v) == &DBEnv_Type)

#define DBTxnObject_Check(v) (Py_TYPE(v) == &DBTxn_Type)

#define DBLockObject_Check(v) (Py_TYPE(v) == &DBLock_Type)

#if (DBVER >= 43)

#define DBSequenceObject_Check(v) (Py_TYPE(v) == &DBSequence_Type)

#if (DBVER < 46)

#define _DBC_close(dbc) dbc->c_close(dbc)

#define _DBC_count(dbc,a,b) dbc->c_count(dbc,a,b)

#define _DBC_del(dbc,a) dbc->c_del(dbc,a)

#define _DBC_dup(dbc,a,b) dbc->c_dup(dbc,a,b)

#define _DBC_get(dbc,a,b,c) dbc->c_get(dbc,a,b,c)

#define _DBC_pget(dbc,a,b,c,d) dbc->c_pget(dbc,a,b,c,d)

#define _DBC_put(dbc,a,b,c) dbc->c_put(dbc,a,b,c)

#define _DBC_close(dbc) dbc->close(dbc)

#define _DBC_count(dbc,a,b) dbc->count(dbc,a,b)

#define _DBC_del(dbc,a) dbc->del(dbc,a)

#define _DBC_dup(dbc,a,b) dbc->dup(dbc,a,b)

#define _DBC_get(dbc,a,b,c) dbc->get(dbc,a,b,c)

#define _DBC_pget(dbc,a,b,c,d) dbc->pget(dbc,a,b,c,d)

#define _DBC_put(dbc,a,b,c) dbc->put(dbc,a,b,c)

#define INSERT_IN_DOUBLE_LINKED_LIST(backlink,object) \

{ \

object->sibling_next=backlink; \

object->sibling_prev_p=&(backlink); \

backlink=object; \

if (object->sibling_next) { \

object->sibling_next->sibling_prev_p=&(object->sibling_next); \

} \

}

#define EXTRACT_FROM_DOUBLE_LINKED_LIST(object) \

{ \

if (object->sibling_next) { \

object->sibling_next->sibling_prev_p=object->sibling_prev_p; \

} \

*(object->sibling_prev_p)=object->sibling_next; \

}

#define EXTRACT_FROM_DOUBLE_LINKED_LIST_MAYBE_NULL(object) \

{ \

if (object->sibling_next) { \

object->sibling_next->sibling_prev_p=object->sibling_prev_p; \

} \

if (object->sibling_prev_p) { \

*(object->sibling_prev_p)=object->sibling_next; \

} \

}

#define INSERT_IN_DOUBLE_LINKED_LIST_TXN(backlink,object) \

{ \

object->sibling_next_txn=backlink; \

object->sibling_prev_p_txn=&(backlink); \

backlink=object; \

if (object->sibling_next_txn) { \

object->sibling_next_txn->sibling_prev_p_txn= \

&(object->sibling_next_txn); \

} \

}

#define EXTRACT_FROM_DOUBLE_LINKED_LIST_TXN(object) \

{ \

if (object->sibling_next_txn) { \

object->sibling_next_txn->sibling_prev_p_txn= \

object->sibling_prev_p_txn; \

} \

*(object->sibling_prev_p_txn)=object->sibling_next_txn; \

}

#define RETURN_IF_ERR() \

if (makeDBError(err)) { \

return NULL; \

}

#define RETURN_NONE() Py_INCREF(Py_None); return Py_None;

#define _CHECK_OBJECT_NOT_CLOSED(nonNull, pyErrObj, name) \

if ((nonNull) == NULL) { \

PyObject *errTuple = NULL; \

errTuple = Py_BuildValue("(is)", 0, #name " object has been closed"); \

if (errTuple) { \

PyErr_SetObject((pyErrObj), errTuple); \

Py_DECREF(errTuple); \

} \

return NULL; \

}

#define CHECK_DB_NOT_CLOSED(dbobj) \

_CHECK_OBJECT_NOT_CLOSED(dbobj->db, DBError, DB)

#define CHECK_ENV_NOT_CLOSED(env) \

_CHECK_OBJECT_NOT_CLOSED(env->db_env, DBError, DBEnv)

#define CHECK_CURSOR_NOT_CLOSED(curs) \

_CHECK_OBJECT_NOT_CLOSED(curs->dbc, DBCursorClosedError, DBCursor)

#if (DBVER >= 43)

#define CHECK_SEQUENCE_NOT_CLOSED(curs) \

_CHECK_OBJECT_NOT_CLOSED(curs->sequence, DBError, DBSequence)

#define CHECK_DBFLAG(mydb, flag) (((mydb)->flags & (flag)) || \

(((mydb)->myenvobj != NULL) && ((mydb)->myenvobj->flags & (flag))))

#define CLEAR_DBT(dbt) (memset(&(dbt), 0, sizeof(dbt)))

#define FREE_DBT(dbt) if ((dbt.flags & (DB_DBT_MALLOC|DB_DBT_REALLOC)) && \

dbt.data != NULL) { free(dbt.data); dbt.data = NULL; }

static int makeDBError(int err);

static int _DB_get_type(DBObject* self)

{

DBTYPE type;

int err;

err = self->db->get_type(self->db, &type);

if (makeDBError(err)) {

return -1;

}

return type;

}

static int make_dbt(PyObject* obj, DBT* dbt)

{

CLEAR_DBT(*dbt);

if (obj == Py_None) {

/* no need to do anything, the structure has already been zeroed */

}

else if (!PyArg_Parse(obj, "s#", &dbt->data, &dbt->size)) {

PyErr_SetString(PyExc_TypeError,

#if (PY_VERSION_HEX < 0x03000000)

"Data values must be of type string or None.");

"Data values must be of type bytes or None.");

return 0;

}

return 1;

}

static int

make_key_dbt(DBObject* self, PyObject* keyobj, DBT* key, int* pflags)

{

db_recno_t recno;

int type;

CLEAR_DBT(*key);

if (keyobj == Py_None) {

type = _DB_get_type(self);

if (type == -1)

return 0;

if (type == DB_RECNO || type == DB_QUEUE) {

PyErr_SetString(

PyExc_TypeError,

"None keys not allowed for Recno and Queue DB's");

return 0;

}

/* no need to do anything, the structure has already been zeroed */

}

else if (PyBytes_Check(keyobj)) {

/* verify access method type */

type = _DB_get_type(self);

if (type == -1)

return 0;

if (type == DB_RECNO || type == DB_QUEUE) {

PyErr_SetString(

PyExc_TypeError,

#if (PY_VERSION_HEX < 0x03000000)

"String keys not allowed for Recno and Queue DB's");

"Bytes keys not allowed for Recno and Queue DB's");

return 0;

}

/*

key->data = malloc(PyBytes_GET_SIZE(keyobj));

if (key->data == NULL) {

PyErr_SetString(PyExc_MemoryError, "Key memory allocation failed");

return 0;

}

memcpy(key->data, PyBytes_AS_STRING(keyobj),

PyBytes_GET_SIZE(keyobj));

key->flags = DB_DBT_REALLOC;

key->size = PyBytes_GET_SIZE(keyobj);

}

else if (NUMBER_Check(keyobj)) {

/* verify access method type */

type = _DB_get_type(self);

if (type == -1)

return 0;

if (type == DB_BTREE && pflags != NULL) {

/* if BTREE then an Integer key is allowed with the

*pflags |= DB_SET_RECNO;

}

else if (type != DB_RECNO && type != DB_QUEUE) {

PyErr_SetString(

PyExc_TypeError,

"Integer keys only allowed for Recno and Queue DB's");

return 0;

}

/* Make a key out of the requested recno, use allocated space so DB

recno = NUMBER_AsLong(keyobj);

key->data = malloc(sizeof(db_recno_t));

if (key->data == NULL) {

PyErr_SetString(PyExc_MemoryError, "Key memory allocation failed");

return 0;

}

key->ulen = key->size = sizeof(db_recno_t);

memcpy(key->data, &recno, sizeof(db_recno_t));

key->flags = DB_DBT_REALLOC;

}

else {

PyErr_Format(PyExc_TypeError,

#if (PY_VERSION_HEX < 0x03000000)

"String or Integer object expected for key, %s found",

"Bytes or Integer object expected for key, %s found",

Py_TYPE(keyobj)->tp_name);

return 0;

}

return 1;

}

static int add_partial_dbt(DBT* d, int dlen, int doff) {

/* if neither were set we do nothing (-1 is the default value) */

if ((dlen == -1) && (doff == -1)) {

return 1;

}

if ((dlen < 0) || (doff < 0)) {

PyErr_SetString(PyExc_TypeError, "dlen and doff must both be >= 0");

return 0;

}

d->flags = d->flags | DB_DBT_PARTIAL;

d->dlen = (unsigned int) dlen;

d->doff = (unsigned int) doff;

return 1;

}

unsigned int our_strlcpy(char* dest, const char* src, unsigned int n)

{

unsigned int srclen, copylen;

srclen = strlen(src);

if (n <= 0)

return srclen;

copylen = (srclen > n-1) ? n-1 : srclen;

/* populate dest[0] thru dest[copylen-1] */

memcpy(dest, src, copylen);

/* guarantee null termination */

dest[copylen] = 0;

return srclen;

}

static char _db_errmsg[1024];

#if (DBVER <= 42)

static void _db_errorCallback(const char* prefix, char* msg)

static void _db_errorCallback(const DB_ENV *db_env,

const char* prefix, const char* msg)

{

our_strlcpy(_db_errmsg, msg, sizeof(_db_errmsg));

}

static const char *DummyString = "This string is a simple placeholder";

static PyObject *Build_PyString(const char *p,int s)

{

if (!p) {

p=DummyString;

assert(s==0);

}

return PyBytes_FromStringAndSize(p,s);

}

static PyObject *BuildValue_S(const void *p,int s)

{

if (!p) {

p=DummyString;

assert(s==0);

}

return PyBytes_FromStringAndSize(p, s);

}

static PyObject *BuildValue_SS(const void *p1,int s1,const void *p2,int s2)

{

PyObject *a, *b, *r;

if (!p1) {

p1=DummyString;

assert(s1==0);

}

if (!p2) {

p2=DummyString;

assert(s2==0);

}

if (!(a = PyBytes_FromStringAndSize(p1, s1))) {

return NULL;

}

if (!(b = PyBytes_FromStringAndSize(p2, s2))) {

Py_DECREF(a);

return NULL;

}

#if (PY_VERSION_HEX >= 0x02040000)

r = PyTuple_Pack(2, a, b) ;

r = Py_BuildValue("OO", a, b);

Py_DECREF(a);

Py_DECREF(b);

return r;

}

static PyObject *BuildValue_IS(int i,const void *p,int s)

{

PyObject *a, *r;

if (!p) {

p=DummyString;

assert(s==0);

}

if (!(a = PyBytes_FromStringAndSize(p, s))) {

return NULL;

}

r = Py_BuildValue("iO", i, a);

Py_DECREF(a);

return r;

}

static PyObject *BuildValue_LS(long l,const void *p,int s)

{

PyObject *a, *r;

if (!p) {

p=DummyString;

assert(s==0);

}

if (!(a = PyBytes_FromStringAndSize(p, s))) {

return NULL;

}

r = Py_BuildValue("lO", l, a);

Py_DECREF(a);

return r;

}

static int makeDBError(int err)

{

char errTxt[2048]; /* really big, just in case... */

PyObject *errObj = NULL;

PyObject *errTuple = NULL;

int exceptionRaised = 0;

unsigned int bytes_left;

switch (err) {

case 0: /* successful, no error */ break;

#if (DBVER < 41)

case DB_INCOMPLETE:

#if INCOMPLETE_IS_WARNING

bytes_left = our_strlcpy(errTxt, db_strerror(err), sizeof(errTxt));

/* Ensure that bytes_left never goes negative */

if (_db_errmsg[0] && bytes_left < (sizeof(errTxt) - 4)) {

bytes_left = sizeof(errTxt) - bytes_left - 4 - 1;

assert(bytes_left >= 0);

strcat(errTxt, " -- ");

strncat(errTxt, _db_errmsg, bytes_left);

}

_db_errmsg[0] = 0;

exceptionRaised = PyErr_Warn(PyExc_RuntimeWarning, errTxt);

#else /* do an exception instead */

errObj = DBIncompleteError;

break;

#endif /* DBVER < 41 */

case DB_KEYEMPTY: errObj = DBKeyEmptyError; break;

case DB_KEYEXIST: errObj = DBKeyExistError; break;

case DB_LOCK_DEADLOCK: errObj = DBLockDeadlockError; break;

case DB_LOCK_NOTGRANTED: errObj = DBLockNotGrantedError; break;

case DB_NOTFOUND: errObj = DBNotFoundError; break;

case DB_OLD_VERSION: errObj = DBOldVersionError; break;

case DB_RUNRECOVERY: errObj = DBRunRecoveryError; break;

case DB_VERIFY_BAD: errObj = DBVerifyBadError; break;

case DB_NOSERVER: errObj = DBNoServerError; break;

case DB_NOSERVER_HOME: errObj = DBNoServerHomeError; break;

case DB_NOSERVER_ID: errObj = DBNoServerIDError; break;

case DB_PAGE_NOTFOUND: errObj = DBPageNotFoundError; break;

case DB_SECONDARY_BAD: errObj = DBSecondaryBadError; break;

case DB_BUFFER_SMALL: errObj = DBNoMemoryError; break;

#if (DBVER >= 43)

/* ENOMEM and DB_BUFFER_SMALL were one and the same until 4.3 */

case ENOMEM: errObj = PyExc_MemoryError; break;

case EINVAL: errObj = DBInvalidArgError; break;

case EACCES: errObj = DBAccessError; break;

case ENOSPC: errObj = DBNoSpaceError; break;

case EAGAIN: errObj = DBAgainError; break;

case EBUSY : errObj = DBBusyError; break;

case EEXIST: errObj = DBFileExistsError; break;

case ENOENT: errObj = DBNoSuchFileError; break;

case EPERM : errObj = DBPermissionsError; break;

#if (DBVER >= 42)

case DB_REP_HANDLE_DEAD : errObj = DBRepHandleDeadError; break;

case DB_REP_UNAVAIL : errObj = DBRepUnavailError; break;

default: errObj = DBError; break;

}

if (errObj != NULL) {

bytes_left = our_strlcpy(errTxt, db_strerror(err), sizeof(errTxt));

/* Ensure that bytes_left never goes negative */

if (_db_errmsg[0] && bytes_left < (sizeof(errTxt) - 4)) {

bytes_left = sizeof(errTxt) - bytes_left - 4 - 1;

assert(bytes_left >= 0);

strcat(errTxt, " -- ");

strncat(errTxt, _db_errmsg, bytes_left);

}

_db_errmsg[0] = 0;

errTuple = Py_BuildValue("(is)", err, errTxt);

if (errTuple == NULL) {

Py_DECREF(errObj);

return !0;

}

PyErr_SetObject(errObj, errTuple);

Py_DECREF(errTuple);

}

return ((errObj != NULL) || exceptionRaised);

}

static void makeTypeError(char* expected, PyObject* found)

{

PyErr_Format(PyExc_TypeError, "Expected %s argument, %s found.",

expected, Py_TYPE(found)->tp_name);

}

static int checkTxnObj(PyObject* txnobj, DB_TXN** txn)

{

if (txnobj == Py_None || txnobj == NULL) {

*txn = NULL;

return 1;

}

if (DBTxnObject_Check(txnobj)) {

*txn = ((DBTxnObject*)txnobj)->txn;

return 1;

}

else

makeTypeError("DBTxn", txnobj);

return 0;

}

static int _DB_delete(DBObject* self, DB_TXN *txn, DBT *key, int flags)

{

int err;

MYDB_BEGIN_ALLOW_THREADS;

err = self->db->del(self->db, txn, key, 0);

MYDB_END_ALLOW_THREADS;

if (makeDBError(err)) {

return -1;

}

self->haveStat = 0;

return 0;

}

static int _DB_put(DBObject* self, DB_TXN *txn, DBT *key, DBT *data, int flags)

{

int err;

MYDB_BEGIN_ALLOW_THREADS;

err = self->db->put(self->db, txn, key, data, flags);

MYDB_END_ALLOW_THREADS;

if (makeDBError(err)) {

return -1;

}

self->haveStat = 0;

return 0;

}

static PyObject* _DBCursor_get(DBCursorObject* self, int extra_flags,

PyObject *args, PyObject *kwargs, char *format)

{

int err;

PyObject* retval = NULL;

DBT key, data;

int dlen = -1;

int doff = -1;

int flags = 0;

static char* kwnames[] = { "flags", "dlen", "doff", NULL };

if (!PyArg_ParseTupleAndKeywords(args, kwargs, format, kwnames,

&flags, &dlen, &doff))

return NULL;

CHECK_CURSOR_NOT_CLOSED(self);

flags |= extra_flags;

CLEAR_DBT(key);

CLEAR_DBT(data);

if (!add_partial_dbt(&data, dlen, doff))

return NULL;

MYDB_BEGIN_ALLOW_THREADS;

err = _DBC_get(self->dbc, &key, &data, flags);

MYDB_END_ALLOW_THREADS;

if ((err == DB_NOTFOUND || err == DB_KEYEMPTY)

&& self->mydb->moduleFlags.getReturnsNone) {

Py_INCREF(Py_None);

retval = Py_None;

}

else if (makeDBError(err)) {

retval = NULL;

}

else { /* otherwise, success! */

/* if Recno or Queue, return the key as an Int */

switch (_DB_get_type(self->mydb)) {

case -1:

retval = NULL;

break;

case DB_RECNO:

case DB_QUEUE:

retval = BuildValue_IS(*((db_recno_t*)key.data), data.data, data.size);

break;

case DB_HASH:

case DB_BTREE:

default:

retval = BuildValue_SS(key.data, key.size, data.data, data.size);

break;

}

}

return retval;

}

static void _addIntToDict(PyObject* dict, char *name, int value)

{

PyObject* v = NUMBER_FromLong((long) value);

if (!v || PyDict_SetItemString(dict, name, v))

PyErr_Clear();

Py_XDECREF(v);

}

static void _addTimeTToDict(PyObject* dict, char *name, time_t value)

{

PyObject* v;

/* if the value fits in regular int, use that. */

#ifdef PY_LONG_LONG

if (sizeof(time_t) > sizeof(long))

v = PyLong_FromLongLong((PY_LONG_LONG) value);

else

v = NUMBER_FromLong((long) value);

if (!v || PyDict_SetItemString(dict, name, v))

PyErr_Clear();

Py_XDECREF(v);

}

#if (DBVER >= 43)

static void _addDb_seq_tToDict(PyObject* dict, char *name, db_seq_t value)

{

PyObject* v = PyLong_FromLongLong(value);

if (!v || PyDict_SetItemString(dict, name, v))

PyErr_Clear();

Py_XDECREF(v);

}

static void _addDB_lsnToDict(PyObject* dict, char *name, DB_LSN value)

{

PyObject *v = Py_BuildValue("(ll)",value.file,value.offset);

if (!v || PyDict_SetItemString(dict, name, v))

PyErr_Clear();

Py_XDECREF(v);

}

static DBObject*

newDBObject(DBEnvObject* arg, int flags)

{

DBObject* self;

DB_ENV* db_env = NULL;

int err;

self = PyObject_New(DBObject, &DB_Type);

if (self == NULL)

return NULL;

self->haveStat = 0;

self->flags = 0;

self->setflags = 0;

self->myenvobj = NULL;

self->db = NULL;

self->children_cursors = NULL;

#if (DBVER >=43)

self->children_sequences = NULL;

self->associateCallback = NULL;

self->btCompareCallback = NULL;

self->primaryDBType = 0;

Py_INCREF(Py_None);

self->private_obj = Py_None;

self->in_weakreflist = NULL;

/* keep a reference to our python DBEnv object */

if (arg) {

Py_INCREF(arg);

self->myenvobj = arg;

db_env = arg->db_env;

INSERT_IN_DOUBLE_LINKED_LIST(self->myenvobj->children_dbs,self);

} else {

self->sibling_prev_p=NULL;

self->sibling_next=NULL;

}

self->txn=NULL;

self->sibling_prev_p_txn=NULL;

self->sibling_next_txn=NULL;

if (self->myenvobj)

self->moduleFlags = self->myenvobj->moduleFlags;

else

self->moduleFlags.getReturnsNone = DEFAULT_GET_RETURNS_NONE;

self->moduleFlags.cursorSetReturnsNone = DEFAULT_CURSOR_SET_RETURNS_NONE;

MYDB_BEGIN_ALLOW_THREADS;

err = db_create(&self->db, db_env, flags);

if (self->db != NULL) {

self->db->set_errcall(self->db, _db_errorCallback);

self->db->app_private = (void*)self;

}

MYDB_END_ALLOW_THREADS;

/* TODO add a weakref(self) to the self->myenvobj->open_child_weakrefs

if (makeDBError(err)) {

if (self->myenvobj) {

Py_DECREF(self->myenvobj);

self->myenvobj = NULL;

}

Py_DECREF(self);

self = NULL;

}

return self;

}

static PyObject *DB_close_internal(DBObject* self, int flags, int do_not_close);

static void

DB_dealloc(DBObject* self)

{

PyObject *dummy;

if (self->db != NULL) {

dummy=DB_close_internal(self, 0, 0);