diff --git a/BerkeleyDB.cabal b/BerkeleyDB.cabal --- a/BerkeleyDB.cabal +++ b/BerkeleyDB.cabal @@ -1,11 +1,11 @@ name: BerkeleyDB -version: 0.7.2 +version: 0.8 license: BSD3 license-file: LICENSE cabal-version: >= 1.4 -copyright: (c) 2009 Stephen Blackheath -author: Stephen Blackheath -maintainer: http://blacksapphire.com/antispam/ +copyright: (c) 2009 Stephen Blackheath, (c) 2010 typLAB +author: Stephen Blackheath, Erik Hesselink +maintainer: http://blacksapphire.com/antispam/, typLAB stability: beta synopsis: Berkeley DB binding description: @@ -14,13 +14,7 @@ (It is NOT an SQL-based database.) This package provides a thin Haskell binding for Berkeley DB. . This is a work in progress: The coverage of the Berkeley DB API is not yet complete. Tested with - Berkeley DB version 4.6. - . - /CXX flag/ (enabled by default): - On some platforms, BerkeleyDB won't load into ghci if the CXX flag is enabled. - The CXX flag is required if you want to use the BerkeleyDBXML package. - You are recommended to disable this flag if you are not using BerkeleyDBXML. - To disable it, configure with --flags=-CXX. + Berkeley DB versions 4.7 and 4.8, but should work with earlier versions. . Berkeley DB home page: @@ -31,7 +25,8 @@ DARCS repository: . - Changes: 0.7.2: Fix on db4.7 + Changes: 0.8: Support db4.7 and db4.8, removed C++ binding. + 0.7.2: Fix on db4.7 category: Database build-type: Simple @@ -41,25 +36,11 @@ examples/tests.hs, examples/capitals.hs -Flag CXX - Default: True - Description: - Enable the use of the C++ library db_cxx. - On some platforms, BerkeleyDB won't load into ghci if this flag is enabled. - This flag is required for if you want to use the BerkeleyDBXML package. - It is recommended to disable this flag if you are not using BerkeleyDBXML. - Library exposed-modules: Database.Berkeley.Db build-depends: base >= 3 && < 5, extensible-exceptions, bytestring >= 0.9 include-dirs: Database/Berkeley/ - if flag(CXX) - extra-libraries: db db_cxx - ghc-options: -pgml c++ - cc-options: -DUSE_DB_CXX - c-sources: Database/Berkeley/db_helper.cpp - else - extra-libraries: db - c-sources: Database/Berkeley/db_helper.c + extra-libraries: db + c-sources: Database/Berkeley/db_helper.c diff --git a/Database/Berkeley/Db.hsc b/Database/Berkeley/Db.hsc --- a/Database/Berkeley/Db.hsc +++ b/Database/Berkeley/Db.hsc @@ -188,10 +188,7 @@ data DbEnv_struct type DbEnv = ForeignPtr DbEnv_struct -foreign import ccall "db_helper.h &_dbenv_delete" _dbenv_delete - :: FunPtr (Ptr DbEnv_struct -> IO ()) - foreign import ccall safe "db_helper.h _dbenv_create" _dbenv_create :: Ptr (Ptr DbEnv_struct) -> CUInt -> IO CInt @@ -206,7 +203,7 @@ then throwDB "_dbenv_create" ret else do p <- peek ptr - newForeignPtr _dbenv_delete p + newForeignPtr finalizerFree p where orFlags = foldr (.|.) 0 $ map toNum flags toNum DB_RPCCLIENT = 0x0000002 @@ -404,7 +401,6 @@ DB_DIRTY_READ | DB_TXN_SNAPSHOT | DB_CXX_NO_EXCEPTIONS | - DB_XA_CREATE | DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT | DB_INIT_CDB | @@ -484,7 +480,6 @@ dbToNum DB_DIRTY_READ = #const DB_DIRTY_READ dbToNum DB_TXN_SNAPSHOT = #const DB_TXN_SNAPSHOT dbToNum DB_CXX_NO_EXCEPTIONS = #const DB_CXX_NO_EXCEPTIONS -dbToNum DB_XA_CREATE = #const DB_XA_CREATE dbToNum DB_USE_ENVIRON = #const DB_USE_ENVIRON dbToNum DB_USE_ENVIRON_ROOT = #const DB_USE_ENVIRON_ROOT dbToNum DB_INIT_CDB = #const DB_INIT_CDB diff --git a/Database/Berkeley/db_helper.c b/Database/Berkeley/db_helper.c --- a/Database/Berkeley/db_helper.c +++ b/Database/Berkeley/db_helper.c @@ -4,20 +4,7 @@ #include #include -#if defined(USE_DB_CXX) #define UNWRAP_DBENV() \ - DB_ENV* dbenv = dbenvp->get_DB_ENV(); \ - if (dbenv == NULL) return -20881; /* Haskell binding-specific error code */ - -#define UNWRAP_DBTXN_() \ - if (dbtxnp == NULL) \ - dbtxn = NULL; \ - else { \ - if (*dbtxnp == NULL) return -20883; /* Haskell binding-specific error code */ \ - dbtxn = (*dbtxnp)->get_DB_TXN(); \ - } -#else -#define UNWRAP_DBENV() \ DB_ENV* dbenv; \ if (*dbenvp == NULL) return -20881; /* Haskell binding-specific error code */ \ dbenv = *dbenvp; @@ -29,7 +16,6 @@ if (*dbtxnp == NULL) return -20883; /* Haskell binding-specific error code */ \ dbtxn = *dbtxnp; \ } -#endif #define UNWRAP_DB() \ DB* db = *dbp; \ @@ -45,28 +31,14 @@ int _dbenv_create(MY_DBENV** dbenvpp, u_int32_t flags) { -#if defined(USE_DB_CXX) - *dbenvpp = new DbEnv(flags); - return 0; -#else int ret; *dbenvpp = (MY_DBENV*)malloc(sizeof(MY_DBENV*)); ret = db_env_create(*dbenvpp, flags); if (ret != 0) free(*dbenvpp); return ret; -#endif } -void _dbenv_delete(MY_DBENV* dbenvp) -{ -#if defined(USE_DB_CXX) -#else - _dbenv_close(dbenvp, 0); - free(dbenvp); -#endif -} - int _dbenv_get_lk_max_lockers(MY_DBENV* dbenvp, u_int32_t *lk_maxp) { UNWRAP_DBENV(); return dbenv->get_lk_max_lockers(dbenv, lk_maxp); @@ -141,16 +113,12 @@ int _dbenv_close(MY_DBENV* dbenvp, u_int32_t flags) { int ret; -#if defined(USE_DB_CXX) - ret = dbenvp->close(flags); -#else if (*dbenvp != NULL) { ret = (*dbenvp)->close(*dbenvp,flags); *dbenvp = NULL; } else ret = 0; -#endif return ret; } @@ -187,11 +155,7 @@ txn = NULL; else { if (*txnp == NULL) return -20883; /* Haskell binding-specific error code */ -#if defined(USE_DB_CXX) - txn = (*txnp)->get_DB_TXN(); -#else txn = *txnp; -#endif } return db->open(db, txn, file, database, (DBTYPE) type, flags, mode); } @@ -207,17 +171,7 @@ if (parent == NULL) return -20883; /* Haskell binding-specific error code */ } *txnpp = (MY_DBTXN**)malloc(sizeof(MY_DBTXN*)); -#if defined(USE_DB_CXX) - try { - return dbenvp->txn_begin(parent, *txnpp, flags); - } - catch (DbException& exc) { - free(*txnpp); - return exc.get_errno(); - } -#else return dbenv->txn_begin(dbenv, parent, *txnpp, flags); -#endif } int _dbenv_txn_checkpoint(MY_DBENV* dbenvp, u_int32_t kbyte, u_int32_t min, u_int32_t flags) @@ -243,11 +197,7 @@ void _dbtxn_delete(MY_DBTXN** dbtxnp) { if (*dbtxnp != NULL) -#if defined(USE_DB_CXX) - (*dbtxnp)->abort(); -#else (*dbtxnp)->abort(*dbtxnp); -#endif free(dbtxnp); } diff --git a/Database/Berkeley/db_helper.cpp b/Database/Berkeley/db_helper.cpp deleted file mode 100644 --- a/Database/Berkeley/db_helper.cpp +++ /dev/null @@ -1,499 +0,0 @@ -#include "db_helper.h" - -#include -#include -#include - -#if defined(USE_DB_CXX) -#define UNWRAP_DBENV() \ - DB_ENV* dbenv = dbenvp->get_DB_ENV(); \ - if (dbenv == NULL) return -20881; /* Haskell binding-specific error code */ - -#define UNWRAP_DBTXN_() \ - if (dbtxnp == NULL) \ - dbtxn = NULL; \ - else { \ - if (*dbtxnp == NULL) return -20883; /* Haskell binding-specific error code */ \ - dbtxn = (*dbtxnp)->get_DB_TXN(); \ - } -#else -#define UNWRAP_DBENV() \ - DB_ENV* dbenv; \ - if (*dbenvp == NULL) return -20881; /* Haskell binding-specific error code */ \ - dbenv = *dbenvp; - -#define UNWRAP_DBTXN_() \ - if (dbtxnp == NULL) \ - dbtxn = NULL; \ - else { \ - if (*dbtxnp == NULL) return -20883; /* Haskell binding-specific error code */ \ - dbtxn = *dbtxnp; \ - } -#endif - -#define UNWRAP_DB() \ - DB* db = *dbp; \ - if (db == NULL) return -20882; /* Haskell binding-specific error code */ - -#define UNWRAP_DBCURSOR() \ - DBC* dbc = *dbcp; \ - if (dbc == NULL) return -20884; /* Haskell binding-specific error code */ - -#define UNWRAP_DBTXN() \ - DB_TXN* dbtxn; \ - UNWRAP_DBTXN_() - -int _dbenv_create(MY_DBENV** dbenvpp, u_int32_t flags) -{ -#if defined(USE_DB_CXX) - *dbenvpp = new DbEnv(flags); - return 0; -#else - int ret; - *dbenvpp = (MY_DBENV*)malloc(sizeof(MY_DBENV*)); - ret = db_env_create(*dbenvpp, flags); - if (ret != 0) - free(*dbenvpp); - return ret; -#endif -} - -void _dbenv_delete(MY_DBENV* dbenvp) -{ -#if defined(USE_DB_CXX) -#else - _dbenv_close(dbenvp, 0); - free(dbenvp); -#endif -} - -int _dbenv_get_lk_max_lockers(MY_DBENV* dbenvp, u_int32_t *lk_maxp) { - UNWRAP_DBENV(); - return dbenv->get_lk_max_lockers(dbenv, lk_maxp); -} - -int _dbenv_set_lk_max_lockers(MY_DBENV* dbenvp, u_int32_t max) { - UNWRAP_DBENV(); - return dbenv->set_lk_max_lockers(dbenv, max); -} - -int _dbenv_get_lk_max_locks(MY_DBENV* dbenvp, u_int32_t *lk_maxp) { - UNWRAP_DBENV(); - return dbenv->get_lk_max_locks(dbenv, lk_maxp); -} - -int _dbenv_set_lk_max_locks(MY_DBENV* dbenvp, u_int32_t max) { - UNWRAP_DBENV(); - return dbenv->set_lk_max_locks(dbenv, max); -} - -int _dbenv_get_lk_max_objects(MY_DBENV* dbenvp, u_int32_t *lk_maxp) { - UNWRAP_DBENV(); - return dbenv->get_lk_max_objects(dbenv, lk_maxp); -} - -int _dbenv_set_lk_max_objects(MY_DBENV* dbenvp, u_int32_t max) { - UNWRAP_DBENV(); - return dbenv->set_lk_max_objects(dbenv, max); -} - -int _dbenv_get_tx_max(MY_DBENV* dbenvp, u_int32_t *lk_maxp) { - UNWRAP_DBENV(); - return dbenv->get_tx_max(dbenv, lk_maxp); -} - -int _dbenv_set_tx_max(MY_DBENV* dbenvp, u_int32_t max) { - UNWRAP_DBENV(); - return dbenv->set_tx_max(dbenv, max); -} - -int _dbenv_get_cachesize(MY_DBENV* dbenvp, u_int32_t *gbytesp, u_int32_t *bytesp, int *ncachep) { - UNWRAP_DBENV(); - return dbenv->get_cachesize(dbenv, gbytesp, bytesp, ncachep); -} - -int _dbenv_set_cachesize(MY_DBENV* dbenvp, u_int32_t gbytes, u_int32_t bytes, int ncache) { - UNWRAP_DBENV(); - return dbenv->set_cachesize(dbenv, gbytes, bytes, ncache); -} - -int _dbenv_get_lg_regionmax(MY_DBENV* dbenvp, u_int32_t *lk_maxp) { - UNWRAP_DBENV(); - return dbenv->get_lg_regionmax(dbenv, lk_maxp); -} - -int _dbenv_set_lg_regionmax(MY_DBENV* dbenvp, u_int32_t max) { - UNWRAP_DBENV(); - return dbenv->set_lg_regionmax(dbenv, max); -} - -int _dbenv_set_lk_detect(MY_DBENV* dbenvp, u_int32_t flag) -{ - UNWRAP_DBENV(); - return dbenv->set_lk_detect(dbenv, flag); -} - -int _dbenv_open(MY_DBENV* dbenvp, char *db_home, u_int32_t flags, int mode) { - UNWRAP_DBENV(); - return dbenv->open(dbenv, db_home, flags, mode); -} - -int _dbenv_close(MY_DBENV* dbenvp, u_int32_t flags) -{ - int ret; -#if defined(USE_DB_CXX) - ret = dbenvp->close(flags); -#else - if (*dbenvp != NULL) { - ret = (*dbenvp)->close(*dbenvp,flags); - *dbenvp = NULL; - } - else - ret = 0; -#endif - return ret; -} - -int _db_create(DB*** dbpp, MY_DBENV* dbenvp, u_int32_t flags) -{ - int ret; - UNWRAP_DBENV(); - *dbpp = (DB**)malloc(sizeof(DB**)); - ret = db_create(*dbpp, dbenv, flags); - if (ret != 0) - free(*dbpp); - return ret; -} - -void _db_delete(DB** dbp) -{ - if (*dbp != NULL) - (*dbp)->close(*dbp, 0); - free(dbp); -} - -int _db_set_pagesize(DB** dbp, u_int32_t pagesize) -{ - UNWRAP_DB(); - return db->set_pagesize(db, pagesize); -} - -int _db_open(DB** dbp, MY_DBTXN** txnp, const char* file, const char* database, - int type, u_int32_t flags, int mode) -{ - DB_TXN* txn; - UNWRAP_DB(); - if (txnp == NULL) - txn = NULL; - else { - if (*txnp == NULL) return -20883; /* Haskell binding-specific error code */ -#if defined(USE_DB_CXX) - txn = (*txnp)->get_DB_TXN(); -#else - txn = *txnp; -#endif - } - return db->open(db, txn, file, database, (DBTYPE) type, flags, mode); -} - -int _dbenv_txn_begin(MY_DBENV* dbenvp, MY_DBTXN** parentp, MY_DBTXN*** txnpp, u_int32_t flags) -{ - MY_DBTXN* parent; - UNWRAP_DBENV(); - if (parentp == NULL) - parent = NULL; - else { - parent = *parentp; - if (parent == NULL) return -20883; /* Haskell binding-specific error code */ - } -#if defined(USE_DB_CXX) - try { - *txnpp = (MY_DBTXN**)malloc(sizeof(MY_DBTXN*)*2); - int ret = dbenvp->txn_begin(parent, *txnpp, flags); - // We store two copies of the pointer. The second one becomes NULL if - // the transaction gets adopted by BerkeleyDBXML. If it's adopted, we - // don't force an abort in our finalizer. - (*txnpp)[1] = (*txnpp)[0]; - return ret; - } - catch (DbException& exc) { - free(*txnpp); - return exc.get_errno(); - } -#else - *txnpp = (MY_DBTXN**)malloc(sizeof(MY_DBTXN*)); - return dbenv->txn_begin(dbenv, parent, *txnpp, flags); -#endif -} - -void detach_DbTxn(MY_DBTXN** dbtxnp) -{ - dbtxnp[1] = NULL; // Nullify the second slot to mark it as adopted, so - // as to prevent BerkeleyDB from aborting the transaction - // in its finalizer. -} - -int _dbenv_txn_checkpoint(MY_DBENV* dbenvp, u_int32_t kbyte, u_int32_t min, u_int32_t flags) -{ - UNWRAP_DBENV(); - return dbenv->txn_checkpoint(dbenv, kbyte, min, flags); -} - -int _dbtxn_abort(MY_DBTXN** dbtxnp) -{ - UNWRAP_DBTXN(); - *dbtxnp = NULL; - dbtxn->abort(dbtxn); -} - -int _dbtxn_commit(MY_DBTXN** dbtxnp, u_int32_t flags) -{ - UNWRAP_DBTXN(); - *dbtxnp = NULL; - dbtxn->commit(dbtxn, flags); -} - -void _dbtxn_delete(MY_DBTXN** dbtxnp) -{ -#if defined(USE_DB_CXX) - // If either slot has been nulled, don't abort it in the finalizer. - // Slot 0 nulled = explicitly commited or aborted by dbTxn_abort or dbTxn_commit. - // Slot 1 nulled = adopted by BerkeleyDBXML. - if (*dbtxnp != NULL && dbtxnp[1] != NULL) - (*dbtxnp)->abort(); -#else - if (*dbtxnp != NULL) - (*dbtxnp)->abort(*dbtxnp); -#endif - free(dbtxnp); -} - -u_int32_t _dbtxn_id(MY_DBTXN** dbtxnp) -{ - UNWRAP_DBTXN(); - return dbtxn->id(dbtxn); -} - -int _dbenv_lock_get(MY_DBENV* dbenvp, u_int32_t lockerID, u_int32_t flags, - const char* object, u_int32_t object_len, u_int32_t lockmode, _DB_LOCK** dblock) -{ - DBT dbt; - UNWRAP_DBENV(); - - memset(&dbt, 0, sizeof(dbt)); - dbt.flags = DB_DBT_USERMEM; - dbt.data = (void*)object; - dbt.size = object_len; - *dblock = (_DB_LOCK*)malloc(sizeof(_DB_LOCK)); - (*dblock)->dbenv = dbenvp; - int ret = dbenv->lock_get(dbenv, lockerID, flags, &dbt, (db_lockmode_t)lockmode, &(*dblock)->lock); - if (ret != 0) - free(*dblock); - return ret; -} - -int _dbenv_lock_put(_DB_LOCK* dblock) -{ - MY_DBENV* dbenvp = dblock->dbenv; - UNWRAP_DBENV(); - return dbenv->lock_put(dbenv, &dblock->lock); -} - -void _dblock_delete(_DB_LOCK* dblock) -{ - free(dblock); -} - -void _freeString(char* str) -{ - free(str); -} - -int _db_get(DB** dbp, MY_DBTXN** dbtxnp, const char* key, u_int32_t key_len, char** value, u_int32_t* value_len, u_int32_t flags) -{ - DBT keyDbt; - DBT valueDbt; - int ret; - DB_TXN* dbtxn; - UNWRAP_DB(); - UNWRAP_DBTXN_(); - - memset(&keyDbt, 0, sizeof(keyDbt)); - keyDbt.flags = DB_DBT_USERMEM; - keyDbt.data = (void*)key; - keyDbt.size = key_len; - memset(&valueDbt, 0, sizeof(valueDbt)); - valueDbt.flags = DB_DBT_MALLOC; - - *value = NULL; - *value_len = 0; - ret = db->get(db, dbtxn, &keyDbt, &valueDbt, flags); - if (ret == 0) { - *value = (char*)valueDbt.data; - *value_len = valueDbt.size; - } - return ret; -} - -int _db_put(DB** dbp, MY_DBTXN** dbtxnp, const char* key, u_int32_t key_len, const char* value, u_int32_t value_len, u_int32_t flags) -{ - DBT keyDbt; - DBT valueDbt; - DB_TXN* dbtxn; - UNWRAP_DB(); - UNWRAP_DBTXN_(); - - memset(&keyDbt, 0, sizeof(keyDbt)); - keyDbt.flags = DB_DBT_USERMEM; - keyDbt.data = (void*)key; - keyDbt.size = key_len; - memset(&valueDbt, 0, sizeof(valueDbt)); - valueDbt.flags = DB_DBT_USERMEM; - valueDbt.data = (void*)value; - valueDbt.size = value_len; - return db->put(db, dbtxn, &keyDbt, &valueDbt, flags); -} - -int _db_del(DB** dbp, MY_DBTXN** dbtxnp, const char* key, u_int32_t key_len, u_int32_t flags) -{ - DBT keyDbt; - DB_TXN* dbtxn; - UNWRAP_DB(); - UNWRAP_DBTXN_(); - - memset(&keyDbt, 0, sizeof(keyDbt)); - keyDbt.flags = DB_DBT_USERMEM; - keyDbt.data = (void*)key; - keyDbt.size = key_len; - return db->del(db, dbtxn, &keyDbt, flags); -} - -int _db_close(DB** dbp, u_int32_t flags) -{ - UNWRAP_DB(); - *dbp = NULL; - return db->close(db, flags); -} - -int _db_cursor(DB** dbp, MY_DBTXN** dbtxnp, DBC*** dbcursorpp, u_int32_t flags) -{ - DB_TXN* dbtxn; - UNWRAP_DB(); - UNWRAP_DBTXN_(); - *dbcursorpp = (DBC**)malloc(sizeof(DBC**)); - int ret = db->cursor(db, dbtxn, *dbcursorpp, flags); - if (ret != 0) - free(*dbcursorpp); - return ret; -} - -void _dbcursor_delete(DBC** dbc) -{ - if (*dbc != NULL) - (*dbc)->close(*dbc); - free(dbc); -} - -int _dbCursor_close(DBC** dbc) -{ - if (*dbc != NULL) { - int ret = (*dbc)->close(*dbc); - *dbc = NULL; - return ret; - } - else - return 0; -} - -int _dbCursor_count(DBC** dbcp, u_int32_t* countp, u_int32_t flags) -{ - UNWRAP_DBCURSOR(); - db_recno_t countp_; - int ret = dbc->count(dbc, &countp_, flags); - *countp = (u_int32_t) countp_; - return ret; -} - -int _dbCursor_del(DBC** dbcp, u_int32_t flags) -{ - UNWRAP_DBCURSOR(); - return dbc->del(dbc, flags); -} - -int _dbCursor_dup(DBC** dbcp, DBC*** dbcursorpp, u_int32_t flags) -{ - UNWRAP_DBCURSOR(); - *dbcursorpp = (DBC**)malloc(sizeof(DBC**)); - int ret = dbc->dup(dbc, *dbcursorpp, flags); - if (ret != 0) - free(*dbcursorpp); - return ret; -} - -int _dbCursor_get(DBC** dbcp, char** key, u_int32_t* key_len, char** value, u_int32_t* value_len, u_int32_t flags) -{ - UNWRAP_DBCURSOR(); - int ret; - - DBT keyDbt; - memset(&keyDbt, 0, sizeof(keyDbt)); - keyDbt.flags = DB_DBT_MALLOC; - *key = NULL; - *key_len = 0; - - DBT valueDbt; - memset(&valueDbt, 0, sizeof(valueDbt)); - valueDbt.flags = DB_DBT_MALLOC; - *value = NULL; - *value_len = 0; - - ret = dbc->get(dbc, &keyDbt, &valueDbt, flags); - if (ret == 0) { - *key = (char*)keyDbt.data; - *key_len = keyDbt.size; - *value = (char*)valueDbt.data; - *value_len = valueDbt.size; - } - return ret; -} - -int _dbCursor_set(DBC** dbcp, const char* key, u_int32_t key_len, char** value, u_int32_t* value_len, u_int32_t flags) -{ - UNWRAP_DBCURSOR(); - int ret; - - DBT keyDbt; - memset(&keyDbt, 0, sizeof(keyDbt)); - keyDbt.flags = DB_DBT_USERMEM; - keyDbt.data = (void*)key; - keyDbt.size = key_len; - - DBT valueDbt; - memset(&valueDbt, 0, sizeof(valueDbt)); - valueDbt.flags = DB_DBT_MALLOC; - *value = NULL; - *value_len = 0; - - ret = dbc->get(dbc, &keyDbt, &valueDbt, flags); - if (ret == 0) { - *value = (char*)valueDbt.data; - *value_len = valueDbt.size; - } - return ret; -} - -int _dbCursor_put(DBC** dbcp, const char* key, u_int32_t key_len, const char* value, u_int32_t value_len, u_int32_t flags) -{ - UNWRAP_DBCURSOR(); - DBT keyDbt; - memset(&keyDbt, 0, sizeof(keyDbt)); - keyDbt.flags = DB_DBT_USERMEM; - keyDbt.data = (void*)key; - keyDbt.size = key_len; - DBT valueDbt; - memset(&valueDbt, 0, sizeof(valueDbt)); - valueDbt.flags = DB_DBT_USERMEM; - valueDbt.data = (void*)value; - valueDbt.size = value_len; - return dbc->put(dbc, &keyDbt, &valueDbt, flags); -} diff --git a/Database/Berkeley/db_helper.h b/Database/Berkeley/db_helper.h --- a/Database/Berkeley/db_helper.h +++ b/Database/Berkeley/db_helper.h @@ -1,15 +1,9 @@ #ifndef _DB_HELPER_H_ #define _DB_HELPER_H_ -#if defined(USE_DB_CXX) -#include -#define MY_DBENV DbEnv -#define MY_DBTXN DbTxn -#else #include #define MY_DBENV DB_ENV* #define MY_DBTXN DB_TXN -#endif typedef struct _DB_LOCK { MY_DBENV* dbenv; @@ -17,12 +11,7 @@ } _DB_LOCK; - -#if defined(USE_DB_CXX) -extern "C" { -#endif int _dbenv_create(MY_DBENV** dbenvpp, u_int32_t flags); -void _dbenv_delete(MY_DBENV* dbenvp); int _dbenv_get_lk_max_lockers(MY_DBENV* dbenvp, u_int32_t *lk_maxp); int _dbenv_set_lk_max_lockers(MY_DBENV* dbenvp, u_int32_t max); int _dbenv_get_lk_max_locks(MY_DBENV* dbenvp, u_int32_t *lk_maxp); @@ -68,8 +57,5 @@ int _dbCursor_get(DBC** dbcp, char** key, u_int32_t* key_len, char** value, u_int32_t* value_len, u_int32_t flags); int _dbCursor_set(DBC** dbcp, const char* key, u_int32_t key_len, char** value, u_int32_t* value_len, u_int32_t flags); int _dbCursor_put(DBC** dbcp, const char* key, u_int32_t key_len, const char* value, u_int32_t value_len, u_int32_t flags); -#if defined(USE_DB_CXX) -} -#endif #endif