diff options
Diffstat (limited to 'db-4.8.30/cxx')
| -rw-r--r-- | db-4.8.30/cxx/cxx_db.cpp | 810 | ||||
| -rw-r--r-- | db-4.8.30/cxx/cxx_dbc.cpp | 123 | ||||
| -rw-r--r-- | db-4.8.30/cxx/cxx_dbt.cpp | 56 | ||||
| -rw-r--r-- | db-4.8.30/cxx/cxx_env.cpp | 1217 | ||||
| -rw-r--r-- | db-4.8.30/cxx/cxx_except.cpp | 356 | ||||
| -rw-r--r-- | db-4.8.30/cxx/cxx_lock.cpp | 41 | ||||
| -rw-r--r-- | db-4.8.30/cxx/cxx_logc.cpp | 78 | ||||
| -rw-r--r-- | db-4.8.30/cxx/cxx_mpool.cpp | 128 | ||||
| -rw-r--r-- | db-4.8.30/cxx/cxx_multi.cpp | 123 | ||||
| -rw-r--r-- | db-4.8.30/cxx/cxx_seq.cpp | 109 | ||||
| -rw-r--r-- | db-4.8.30/cxx/cxx_txn.cpp | 115 |
11 files changed, 3156 insertions, 0 deletions
diff --git a/db-4.8.30/cxx/cxx_db.cpp b/db-4.8.30/cxx/cxx_db.cpp new file mode 100644 index 0000000..a6e6ac5 --- /dev/null +++ b/db-4.8.30/cxx/cxx_db.cpp @@ -0,0 +1,810 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2009 Oracle. All rights reserved. + * + * $Id$ + */ + +#include "db_config.h" + +#include "db_int.h" + +#include "db_cxx.h" +#include "dbinc/cxx_int.h" + +#include "dbinc/db_page.h" +#include "dbinc_auto/db_auto.h" +#include "dbinc_auto/crdel_auto.h" +#include "dbinc/db_dispatch.h" +#include "dbinc_auto/db_ext.h" +#include "dbinc_auto/common_ext.h" + +// Helper macros for simple methods that pass through to the +// underlying C method. It may return an error or raise an exception. +// Note this macro expects that input _argspec is an argument +// list element (e.g., "char *arg") and that _arglist is the arguments +// that should be passed through to the C method (e.g., "(db, arg)") +// +#define DB_METHOD(_name, _argspec, _arglist, _retok) \ +int Db::_name _argspec \ +{ \ + int ret; \ + DB *db = unwrap(this); \ + \ + ret = db->_name _arglist; \ + if (!_retok(ret)) \ + DB_ERROR(dbenv_, "Db::" # _name, ret, error_policy()); \ + return (ret); \ +} + +#define DB_DESTRUCTOR(_name, _argspec, _arglist, _retok) \ +int Db::_name _argspec \ +{ \ + int ret; \ + DB *db = unwrap(this); \ + \ + if (!db) { \ + DB_ERROR(dbenv_, "Db::" # _name, EINVAL, error_policy()); \ + return (EINVAL); \ + } \ + ret = db->_name _arglist; \ + cleanup(); \ + if (!_retok(ret)) \ + DB_ERROR(dbenv_, "Db::" # _name, ret, error_policy()); \ + return (ret); \ +} + +#define DB_METHOD_QUIET(_name, _argspec, _arglist) \ +int Db::_name _argspec \ +{ \ + DB *db = unwrap(this); \ + \ + return (db->_name _arglist); \ +} + +#define DB_METHOD_VOID(_name, _argspec, _arglist) \ +void Db::_name _argspec \ +{ \ + DB *db = unwrap(this); \ + \ + db->_name _arglist; \ +} + +// A truism for the Db object is that there is a valid +// DB handle from the constructor until close(). +// After the close, the DB handle is invalid and +// no operations are permitted on the Db (other than +// destructor). Leaving the Db handle open and not +// doing a close is generally considered an error. +// +// We used to allow Db objects to be closed and reopened. +// This implied always keeping a valid DB object, and +// coordinating the open objects between Db/DbEnv turned +// out to be overly complicated. Now we do not allow this. + +Db::Db(DbEnv *dbenv, u_int32_t flags) +: imp_(0) +, dbenv_(dbenv) +, mpf_(0) +, construct_error_(0) +, flags_(0) +, construct_flags_(flags) +, append_recno_callback_(0) +, associate_callback_(0) +, associate_foreign_callback_(0) +, bt_compare_callback_(0) +, bt_compress_callback_(0) +, bt_decompress_callback_(0) +, bt_prefix_callback_(0) +, db_partition_callback_(0) +, dup_compare_callback_(0) +, feedback_callback_(0) +, h_compare_callback_(0) +, h_hash_callback_(0) +{ + if (dbenv_ == 0) + flags_ |= DB_CXX_PRIVATE_ENV; + + if ((construct_error_ = initialize()) != 0) + DB_ERROR(dbenv_, "Db::Db", construct_error_, error_policy()); +} + +// If the DB handle is still open, we close it. This is to make stack +// allocation of Db objects easier so that they are cleaned up in the error +// path. If the environment was closed prior to this, it may cause a trap, but +// an error message is generated during the environment close. Applications +// should call close explicitly in normal (non-exceptional) cases to check the +// return value. +// +Db::~Db() +{ + DB *db; + + db = unwrap(this); + if (db != NULL) { + (void)db->close(db, 0); + cleanup(); + } +} + +// private method to initialize during constructor. +// initialize must create a backing DB object, +// and if that creates a new DB_ENV, it must be tied to a new DbEnv. +// +int Db::initialize() +{ + DB *db; + DB_ENV *cenv = unwrap(dbenv_); + int ret; + u_int32_t cxx_flags; + + cxx_flags = construct_flags_ & DB_CXX_NO_EXCEPTIONS; + + // Create a new underlying DB object. + // We rely on the fact that if a NULL DB_ENV* is given, + // one is allocated by DB. + // + if ((ret = db_create(&db, cenv, + construct_flags_ & ~cxx_flags)) != 0) + return (ret); + + // Associate the DB with this object + imp_ = db; + db->api_internal = this; + + // Create a new DbEnv from a DB_ENV* if it was created locally. + // It is deleted in Db::close(). + // + if ((flags_ & DB_CXX_PRIVATE_ENV) != 0) + dbenv_ = new DbEnv(db->dbenv, cxx_flags); + + // Create a DbMpoolFile from the DB_MPOOLFILE* in the DB handle. + mpf_ = new DbMpoolFile(); + mpf_->imp_ = db->mpf; + + return (0); +} + +// private method to cleanup after destructor or during close. +// If the environment was created by this Db object, we need to delete it. +// +void Db::cleanup() +{ + if (imp_ != 0) { + imp_ = 0; + + // we must dispose of the DbEnv object if + // we created it. This will be the case + // if a NULL DbEnv was passed into the constructor. + // The underlying DB_ENV object will be inaccessible + // after the close, so we must clean it up now. + // + if ((flags_ & DB_CXX_PRIVATE_ENV) != 0) { + dbenv_->cleanup(); + delete dbenv_; + dbenv_ = 0; + } + + delete mpf_; + } +} + +// Return a tristate value corresponding to whether we should +// throw exceptions on errors: +// ON_ERROR_RETURN +// ON_ERROR_THROW +// ON_ERROR_UNKNOWN +// +int Db::error_policy() +{ + if (dbenv_ != NULL) + return (dbenv_->error_policy()); + else { + // If the dbenv_ is null, that means that the user + // did not attach an environment, so the correct error + // policy can be deduced from constructor flags + // for this Db. + // + if ((construct_flags_ & DB_CXX_NO_EXCEPTIONS) != 0) { + return (ON_ERROR_RETURN); + } + else { + return (ON_ERROR_THROW); + } + } +} + +DB_DESTRUCTOR(close, (u_int32_t flags), (db, flags), DB_RETOK_STD) +DB_METHOD(compact, (DbTxn *txnid, Dbt *start, Dbt *stop, + DB_COMPACT *c_data, u_int32_t flags, Dbt *end), + (db, unwrap(txnid), start, stop, c_data, flags, end), DB_RETOK_STD) + +// The following cast implies that Dbc can be no larger than DBC +DB_METHOD(cursor, (DbTxn *txnid, Dbc **cursorp, u_int32_t flags), + (db, unwrap(txnid), (DBC **)cursorp, flags), + DB_RETOK_STD) + +DB_METHOD(del, (DbTxn *txnid, Dbt *key, u_int32_t flags), + (db, unwrap(txnid), key, flags), + DB_RETOK_DBDEL) + +void Db::err(int error, const char *format, ...) +{ + DB *db = unwrap(this); + + DB_REAL_ERR(db->dbenv, error, DB_ERROR_SET, 1, format); +} + +void Db::errx(const char *format, ...) +{ + DB *db = unwrap(this); + + DB_REAL_ERR(db->dbenv, 0, DB_ERROR_NOT_SET, 1, format); +} + +DB_METHOD(exists, (DbTxn *txnid, Dbt *key, u_int32_t flags), + (db, unwrap(txnid), key, flags), DB_RETOK_EXISTS) + +DB_METHOD(fd, (int *fdp), (db, fdp), DB_RETOK_STD) + +int Db::get(DbTxn *txnid, Dbt *key, Dbt *value, u_int32_t flags) +{ + DB *db = unwrap(this); + int ret; + + ret = db->get(db, unwrap(txnid), key, value, flags); + + if (!DB_RETOK_DBGET(ret)) { + if (ret == DB_BUFFER_SMALL) + DB_ERROR_DBT(dbenv_, "Db::get", value, error_policy()); + else + DB_ERROR(dbenv_, "Db::get", ret, error_policy()); + } + + return (ret); +} + +int Db::get_byteswapped(int *isswapped) +{ + DB *db = (DB *)unwrapConst(this); + return (db->get_byteswapped(db, isswapped)); +} + +DbEnv *Db::get_env() +{ + DB *db = (DB *)unwrapConst(this); + DB_ENV *dbenv = db->get_env(db); + return (dbenv != NULL ? DbEnv::get_DbEnv(dbenv) : NULL); +} + +DbMpoolFile *Db::get_mpf() +{ + return (mpf_); +} + +DB_METHOD(get_dbname, (const char **filenamep, const char **dbnamep), + (db, filenamep, dbnamep), DB_RETOK_STD) + +DB_METHOD(get_open_flags, (u_int32_t *flagsp), (db, flagsp), DB_RETOK_STD) + +int Db::get_type(DBTYPE *dbtype) +{ + DB *db = (DB *)unwrapConst(this); + return (db->get_type(db, dbtype)); +} + +// Dbc is a "compatible" subclass of DBC - that is, no virtual functions +// or even extra data members, so these casts, although technically +// non-portable, "should" always be okay. +DB_METHOD(join, (Dbc **curslist, Dbc **cursorp, u_int32_t flags), + (db, (DBC **)curslist, (DBC **)cursorp, flags), DB_RETOK_STD) + +DB_METHOD(key_range, + (DbTxn *txnid, Dbt *key, DB_KEY_RANGE *results, u_int32_t flags), + (db, unwrap(txnid), key, results, flags), DB_RETOK_STD) + +// If an error occurred during the constructor, report it now. +// Otherwise, call the underlying DB->open method. +// +int Db::open(DbTxn *txnid, const char *file, const char *database, + DBTYPE type, u_int32_t flags, int mode) +{ + int ret; + DB *db = unwrap(this); + + if (construct_error_ != 0) + ret = construct_error_; + else + ret = db->open(db, unwrap(txnid), file, database, type, flags, + mode); + + if (!DB_RETOK_STD(ret)) + DB_ERROR(dbenv_, "Db::open", ret, error_policy()); + + return (ret); +} + +int Db::pget(DbTxn *txnid, Dbt *key, Dbt *pkey, Dbt *value, u_int32_t flags) +{ + DB *db = unwrap(this); + int ret; + + ret = db->pget(db, unwrap(txnid), key, pkey, value, flags); + + /* The logic here is identical to Db::get - reuse the macro. */ + if (!DB_RETOK_DBGET(ret)) { + if (ret == DB_BUFFER_SMALL && DB_OVERFLOWED_DBT(value)) + DB_ERROR_DBT(dbenv_, "Db::pget", value, error_policy()); + else + DB_ERROR(dbenv_, "Db::pget", ret, error_policy()); + } + + return (ret); +} + +DB_METHOD(put, (DbTxn *txnid, Dbt *key, Dbt *value, u_int32_t flags), + (db, unwrap(txnid), key, value, flags), DB_RETOK_DBPUT) + +DB_DESTRUCTOR(rename, + (const char *file, const char *database, const char *newname, + u_int32_t flags), + (db, file, database, newname, flags), DB_RETOK_STD) + +DB_DESTRUCTOR(remove, (const char *file, const char *database, u_int32_t flags), + (db, file, database, flags), DB_RETOK_STD) + +DB_METHOD(truncate, (DbTxn *txnid, u_int32_t *countp, u_int32_t flags), + (db, unwrap(txnid), countp, flags), DB_RETOK_STD) + +DB_METHOD(stat, (DbTxn *txnid, void *sp, u_int32_t flags), + (db, unwrap(txnid), sp, flags), DB_RETOK_STD) + +DB_METHOD(stat_print, (u_int32_t flags), (db, flags), DB_RETOK_STD) + +DB_METHOD(sync, (u_int32_t flags), (db, flags), DB_RETOK_STD) + +DB_METHOD(upgrade, + (const char *name, u_int32_t flags), (db, name, flags), DB_RETOK_STD) + +//////////////////////////////////////////////////////////////////////// +// +// callbacks +// +// *_intercept_c are 'glue' functions that must be declared +// as extern "C" so to be typesafe. Using a C++ method, even +// a static class method with 'correct' arguments, will not pass +// the test; some picky compilers do not allow mixing of function +// pointers to 'C' functions with function pointers to C++ functions. +// +// One wart with this scheme is that the *_callback_ method pointer +// must be declared public to be accessible by the C intercept. +// It's possible to accomplish the goal without this, and with +// another public transfer method, but it's just too much overhead. +// These callbacks are supposed to be *fast*. +// +// The DBTs we receive in these callbacks from the C layer may be +// manufactured there, but we want to treat them as a Dbts. +// Technically speaking, these DBTs were not constructed as a Dbts, +// but it should be safe to cast them as such given that Dbt is a +// *very* thin extension of the DBT. That is, Dbt has no additional +// data elements, does not use virtual functions, virtual inheritance, +// multiple inheritance, RTI, or any other language feature that +// causes the structure to grow or be displaced. Although this may +// sound risky, a design goal of C++ is complete structure +// compatibility with C, and has the philosophy 'if you don't use it, +// you shouldn't incur the overhead'. If the C/C++ compilers you're +// using on a given machine do not have matching struct layouts, then +// a lot more things will be broken than just this. +// +// The alternative, creating a Dbt here in the callback, and populating +// it from the DBT, is just too slow and cumbersome to be very useful. + +// These macros avoid a lot of boilerplate code for callbacks + +#define DB_CALLBACK_C_INTERCEPT(_name, _rettype, _cargspec, \ + _return, _cxxargs) \ +extern "C" _rettype _db_##_name##_intercept_c _cargspec \ +{ \ + Db *cxxthis; \ + \ + /* We don't have a dbenv handle at this point. */ \ + DB_ASSERT(NULL, cthis != NULL); \ + cxxthis = Db::get_Db(cthis); \ + DB_ASSERT(cthis->dbenv->env, cxxthis != NULL); \ + DB_ASSERT(cthis->dbenv->env, cxxthis->_name##_callback_ != 0); \ + \ + _return (*cxxthis->_name##_callback_) _cxxargs; \ +} + +#define DB_SET_CALLBACK(_cxxname, _name, _cxxargspec, _cb) \ +int Db::_cxxname _cxxargspec \ +{ \ + DB *cthis = unwrap(this); \ + \ + _name##_callback_ = _cb; \ + return ((*(cthis->_cxxname))(cthis, \ + (_cb) ? _db_##_name##_intercept_c : NULL)); \ +} + +#define DB_GET_CALLBACK(_cxxname, _name, _cxxargspec, _cbp) \ +int Db::_cxxname _cxxargspec \ +{ \ + if (_cbp != NULL) \ + *(_cbp) = _name##_callback_; \ + return 0; \ +} + +/* associate callback - doesn't quite fit the pattern because of the flags */ +DB_CALLBACK_C_INTERCEPT(associate, + int, (DB *cthis, const DBT *key, const DBT *data, DBT *retval), + return, (cxxthis, Dbt::get_const_Dbt(key), Dbt::get_const_Dbt(data), + Dbt::get_Dbt(retval))) + +int Db::associate(DbTxn *txn, Db *secondary, int (*callback)(Db *, const Dbt *, + const Dbt *, Dbt *), u_int32_t flags) +{ + DB *cthis = unwrap(this); + + /* Since the secondary Db is used as the first argument + * to the callback, we store the C++ callback on it + * rather than on 'this'. + */ + secondary->associate_callback_ = callback; + return ((*(cthis->associate))(cthis, unwrap(txn), unwrap(secondary), + (callback) ? _db_associate_intercept_c : NULL, flags)); +} + +/* associate callback - doesn't quite fit the pattern because of the flags */ +DB_CALLBACK_C_INTERCEPT(associate_foreign, int, + (DB *cthis, const DBT *key, DBT *data, const DBT *fkey, int *changed), + return, (cxxthis, Dbt::get_const_Dbt(key), + Dbt::get_Dbt(data), Dbt::get_const_Dbt(fkey), changed)) + +int Db::associate_foreign(Db *secondary, int (*callback)(Db *, + const Dbt *, Dbt *, const Dbt *, int *), u_int32_t flags) +{ + DB *cthis = unwrap(this); + + secondary->associate_foreign_callback_ = callback; + return ((*(cthis->associate_foreign))(cthis, unwrap(secondary), + (callback) ? _db_associate_foreign_intercept_c : NULL, flags)); +} + +DB_CALLBACK_C_INTERCEPT(feedback, + void, (DB *cthis, int opcode, int pct), + /* no return */ (void), (cxxthis, opcode, pct)) + +DB_GET_CALLBACK(get_feedback, feedback, + (void (**argp)(Db *cxxthis, int opcode, int pct)), argp) + +DB_SET_CALLBACK(set_feedback, feedback, + (void (*arg)(Db *cxxthis, int opcode, int pct)), arg) + +DB_CALLBACK_C_INTERCEPT(append_recno, + int, (DB *cthis, DBT *data, db_recno_t recno), + return, (cxxthis, Dbt::get_Dbt(data), recno)) + +DB_GET_CALLBACK(get_append_recno, append_recno, + (int (**argp)(Db *cxxthis, Dbt *data, db_recno_t recno)), argp) + +DB_SET_CALLBACK(set_append_recno, append_recno, + (int (*arg)(Db *cxxthis, Dbt *data, db_recno_t recno)), arg) + +DB_CALLBACK_C_INTERCEPT(bt_compare, + int, (DB *cthis, const DBT *data1, const DBT *data2), + return, + (cxxthis, Dbt::get_const_Dbt(data1), Dbt::get_const_Dbt(data2))) + +DB_GET_CALLBACK(get_bt_compare, bt_compare, + (int (**argp)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), argp) + +DB_SET_CALLBACK(set_bt_compare, bt_compare, + (int (*arg)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), arg) + +DB_CALLBACK_C_INTERCEPT(bt_compress, + int, (DB *cthis, const DBT *data1, const DBT *data2, const DBT *data3, + const DBT *data4, DBT *data5), return, + (cxxthis, Dbt::get_const_Dbt(data1), Dbt::get_const_Dbt(data2), + Dbt::get_const_Dbt(data3), Dbt::get_const_Dbt(data4), Dbt::get_Dbt(data5))) + +DB_CALLBACK_C_INTERCEPT(bt_decompress, + int, (DB *cthis, const DBT *data1, const DBT *data2, DBT *data3, + DBT *data4, DBT *data5), return, + (cxxthis, Dbt::get_const_Dbt(data1), Dbt::get_const_Dbt(data2), + Dbt::get_Dbt(data3), Dbt::get_Dbt(data4), Dbt::get_Dbt(data5))) + +// The {g|s}et_bt_compress methods don't fit into the standard macro templates +// since they take two callback functions. +int Db::get_bt_compress( + int (**bt_compress) + (Db *, const Dbt *, const Dbt *, const Dbt *, const Dbt *, Dbt *), + int (**bt_decompress) + (Db *, const Dbt *, const Dbt *, Dbt *, Dbt *, Dbt *)) +{ + if (bt_compress != NULL) + *(bt_compress) = bt_compress_callback_; + if (bt_decompress != NULL) + *(bt_decompress) = bt_decompress_callback_; + return 0; +} + +int Db::set_bt_compress( + int (*bt_compress) + (Db *, const Dbt *, const Dbt *, const Dbt *, const Dbt *, Dbt *), + int (*bt_decompress)(Db *, const Dbt *, const Dbt *, Dbt *, Dbt *, Dbt *)) +{ + DB *cthis = unwrap(this); + + bt_compress_callback_ = bt_compress; + bt_decompress_callback_ = bt_decompress; + return ((*(cthis->set_bt_compress))(cthis, + (bt_compress ? _db_bt_compress_intercept_c : NULL), + (bt_decompress ? _db_bt_decompress_intercept_c : NULL))); + +} + +DB_CALLBACK_C_INTERCEPT(bt_prefix, + size_t, (DB *cthis, const DBT *data1, const DBT *data2), + return, + (cxxthis, Dbt::get_const_Dbt(data1), Dbt::get_const_Dbt(data2))) + +DB_GET_CALLBACK(get_bt_prefix, bt_prefix, + (size_t (**argp)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), argp) + +DB_SET_CALLBACK(set_bt_prefix, bt_prefix, + (size_t (*arg)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), arg) + +DB_CALLBACK_C_INTERCEPT(dup_compare, + int, (DB *cthis, const DBT *data1, const DBT *data2), + return, + (cxxthis, Dbt::get_const_Dbt(data1), Dbt::get_const_Dbt(data2))) + +DB_GET_CALLBACK(get_dup_compare, dup_compare, + (int (**argp)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), argp) + +DB_SET_CALLBACK(set_dup_compare, dup_compare, + (int (*arg)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), arg) + +DB_CALLBACK_C_INTERCEPT(h_compare, + int, (DB *cthis, const DBT *data1, const DBT *data2), + return, + (cxxthis, Dbt::get_const_Dbt(data1), Dbt::get_const_Dbt(data2))) + +DB_GET_CALLBACK(get_h_compare, h_compare, + (int (**argp)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), argp) + +DB_SET_CALLBACK(set_h_compare, h_compare, + (int (*arg)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), arg) + +DB_CALLBACK_C_INTERCEPT(h_hash, + u_int32_t, (DB *cthis, const void *data, u_int32_t len), + return, (cxxthis, data, len)) + +DB_GET_CALLBACK(get_h_hash, h_hash, + (u_int32_t (**argp)(Db *cxxthis, const void *data, u_int32_t len)), argp) + +DB_SET_CALLBACK(set_h_hash, h_hash, + (u_int32_t (*arg)(Db *cxxthis, const void *data, u_int32_t len)), arg) + +// This is a 'glue' function declared as extern "C" so it will +// be compatible with picky compilers that do not allow mixing +// of function pointers to 'C' functions with function pointers +// to C++ functions. +// +extern "C" +int _verify_callback_c(void *handle, const void *str_arg) +{ + char *str; + __DB_STD(ostream) *out; + + str = (char *)str_arg; + out = (__DB_STD(ostream) *)handle; + + (*out) << str; + if (out->fail()) + return (EIO); + + return (0); +} + +int Db::verify(const char *name, const char *subdb, + __DB_STD(ostream) *ostr, u_int32_t flags) +{ + DB *db = unwrap(this); + int ret; + + if (!db) + ret = EINVAL; + else { + ret = __db_verify_internal(db, name, subdb, ostr, + _verify_callback_c, flags); + + // After a DB->verify (no matter if success or failure), + // the underlying DB object must not be accessed. + // + cleanup(); + } + + if (!DB_RETOK_STD(ret)) + DB_ERROR(dbenv_, "Db::verify", ret, error_policy()); + + return (ret); +} + +DB_METHOD(set_bt_compare, (bt_compare_fcn_type func), + (db, func), DB_RETOK_STD) +DB_METHOD(get_bt_minkey, (u_int32_t *bt_minkeyp), + (db, bt_minkeyp), DB_RETOK_STD) +DB_METHOD(set_bt_minkey, (u_int32_t bt_minkey), + (db, bt_minkey), DB_RETOK_STD) +DB_METHOD(set_bt_prefix, (bt_prefix_fcn_type func), + (db, func), DB_RETOK_STD) +DB_METHOD(set_dup_compare, (dup_compare_fcn_type func), + (db, func), DB_RETOK_STD) +DB_METHOD(get_encrypt_flags, (u_int32_t *flagsp), + (db, flagsp), DB_RETOK_STD) +DB_METHOD(set_encrypt, (const char *passwd, u_int32_t flags), + (db, passwd, flags), DB_RETOK_STD) +DB_METHOD_VOID(get_errfile, (FILE **errfilep), (db, errfilep)) +DB_METHOD_VOID(set_errfile, (FILE *errfile), (db, errfile)) +DB_METHOD_VOID(get_errpfx, (const char **errpfx), (db, errpfx)) +DB_METHOD_VOID(set_errpfx, (const char *errpfx), (db, errpfx)) +DB_METHOD(get_flags, (u_int32_t *flagsp), (db, flagsp), + DB_RETOK_STD) +DB_METHOD(set_flags, (u_int32_t flags), (db, flags), + DB_RETOK_STD) +DB_METHOD(set_h_compare, (h_compare_fcn_type func), + (db, func), DB_RETOK_STD) +DB_METHOD(get_h_ffactor, (u_int32_t *h_ffactorp), + (db, h_ffactorp), DB_RETOK_STD) +DB_METHOD(set_h_ffactor, (u_int32_t h_ffactor), + (db, h_ffactor), DB_RETOK_STD) +DB_METHOD(set_h_hash, (h_hash_fcn_type func), + (db, func), DB_RETOK_STD) +DB_METHOD(get_h_nelem, (u_int32_t *h_nelemp), + (db, h_nelemp), DB_RETOK_STD) +DB_METHOD(set_h_nelem, (u_int32_t h_nelem), + (db, h_nelem), DB_RETOK_STD) +DB_METHOD(get_lorder, (int *db_lorderp), (db, db_lorderp), + DB_RETOK_STD) +DB_METHOD(set_lorder, (int db_lorder), (db, db_lorder), + DB_RETOK_STD) +DB_METHOD_VOID(get_msgfile, (FILE **msgfilep), (db, msgfilep)) +DB_METHOD_VOID(set_msgfile, (FILE *msgfile), (db, msgfile)) +DB_METHOD_QUIET(get_multiple, (), (db)) +DB_METHOD(get_pagesize, (u_int32_t *db_pagesizep), + (db, db_pagesizep), DB_RETOK_STD) +DB_METHOD(set_pagesize, (u_int32_t db_pagesize), + (db, db_pagesize), DB_RETOK_STD) + +DB_CALLBACK_C_INTERCEPT(db_partition, + u_int32_t, (DB *cthis, DBT *key), + return, (cxxthis, Dbt::get_Dbt(key))) + +// set_partition and get_partition_callback do not fit into the macro +// templates, since there is an additional argument in the API calls. +int Db::set_partition(u_int32_t parts, Dbt *keys, + u_int32_t (*arg)(Db *cxxthis, Dbt *key)) +{ + DB *cthis = unwrap(this); + + db_partition_callback_ = arg; + return ((*(cthis->set_partition))(cthis, parts, keys, + arg ? _db_db_partition_intercept_c : NULL)); +} + +int Db::get_partition_callback(u_int32_t *parts, + u_int32_t (**argp)(Db *cxxthis, Dbt *key)) +{ + DB *cthis = unwrap(this); + if (argp != NULL) + *(argp) = db_partition_callback_; + if (parts != NULL) + (cthis->get_partition_callback)(cthis, parts, NULL); + return 0; +} + +DB_METHOD(set_partition_dirs, (const char **dirp), (db, dirp), DB_RETOK_STD) +DB_METHOD(get_partition_dirs, (const char ***dirpp), (db, dirpp), DB_RETOK_STD) +DB_METHOD(get_partition_keys, (u_int32_t *parts, Dbt **keys), + (db, parts, (DBT **)keys), DB_RETOK_STD) +DB_METHOD(get_priority, (DB_CACHE_PRIORITY *priorityp), + (db, priorityp), DB_RETOK_STD) +DB_METHOD(set_priority, (DB_CACHE_PRIORITY priority), + (db, priority), DB_RETOK_STD) +DB_METHOD(get_re_delim, (int *re_delimp), + (db, re_delimp), DB_RETOK_STD) +DB_METHOD(set_re_delim, (int re_delim), + (db, re_delim), DB_RETOK_STD) +DB_METHOD(get_re_len, (u_int32_t *re_lenp), + (db, re_lenp), DB_RETOK_STD) +DB_METHOD(set_re_len, (u_int32_t re_len), + (db, re_len), DB_RETOK_STD) +DB_METHOD(get_re_pad, (int *re_padp), + (db, re_padp), DB_RETOK_STD) +DB_METHOD(set_re_pad, (int re_pad), + (db, re_pad), DB_RETOK_STD) +DB_METHOD(get_re_source, (const char **re_source), + (db, re_source), DB_RETOK_STD) +DB_METHOD(set_re_source, (const char *re_source), + (db, re_source), DB_RETOK_STD) +DB_METHOD(sort_multiple, (Dbt *key, Dbt *data, u_int32_t flags), + (db, key, data, flags), DB_RETOK_STD) +DB_METHOD(get_q_extentsize, (u_int32_t *extentsizep), + (db, extentsizep), DB_RETOK_STD) +DB_METHOD(set_q_extentsize, (u_int32_t extentsize), + (db, extentsize), DB_RETOK_STD) + +DB_METHOD_QUIET(get_alloc, (db_malloc_fcn_type *malloc_fcnp, + db_realloc_fcn_type *realloc_fcnp, db_free_fcn_type *free_fcnp), + (db, malloc_fcnp, realloc_fcnp, free_fcnp)) + +DB_METHOD_QUIET(set_alloc, (db_malloc_fcn_type malloc_fcn, + db_realloc_fcn_type realloc_fcn, db_free_fcn_type free_fcn), + (db, malloc_fcn, realloc_fcn, free_fcn)) + +void Db::get_errcall(void (**argp)(const DbEnv *, const char *, const char *)) +{ + dbenv_->get_errcall(argp); +} + +void Db::set_errcall(void (*arg)(const DbEnv *, const char *, const char *)) +{ + dbenv_->set_errcall(arg); +} + +void Db::get_msgcall(void (**argp)(const DbEnv *, const char *)) +{ + dbenv_->get_msgcall(argp); +} + +void Db::set_msgcall(void (*arg)(const DbEnv *, const char *)) +{ + dbenv_->set_msgcall(arg); +} + +void *Db::get_app_private() const +{ + return unwrapConst(this)->app_private; +} + +void Db::set_app_private(void *value) +{ + unwrap(this)->app_private = value; +} + +DB_METHOD(get_cachesize, (u_int32_t *gbytesp, u_int32_t *bytesp, int *ncachep), + (db, gbytesp, bytesp, ncachep), DB_RETOK_STD) +DB_METHOD(set_cachesize, (u_int32_t gbytes, u_int32_t bytes, int ncache), + (db, gbytes, bytes, ncache), DB_RETOK_STD) + +DB_METHOD(get_create_dir, (const char **dirp), (db, dirp), DB_RETOK_STD) +DB_METHOD(set_create_dir, (const char *dir), (db, dir), DB_RETOK_STD) + +int Db::set_paniccall(void (*callback)(DbEnv *, int)) +{ + return (dbenv_->set_paniccall(callback)); +} + +__DB_STD(ostream) *Db::get_error_stream() +{ + return dbenv_->get_error_stream(); +} + +void Db::set_error_stream(__DB_STD(ostream) *error_stream) +{ + dbenv_->set_error_stream(error_stream); +} + +__DB_STD(ostream) *Db::get_message_stream() +{ + return dbenv_->get_message_stream(); +} + +void Db::set_message_stream(__DB_STD(ostream) *message_stream) +{ + dbenv_->set_message_stream(message_stream); +} + +DB_METHOD_QUIET(get_transactional, (), (db)) diff --git a/db-4.8.30/cxx/cxx_dbc.cpp b/db-4.8.30/cxx/cxx_dbc.cpp new file mode 100644 index 0000000..d4d461d --- /dev/null +++ b/db-4.8.30/cxx/cxx_dbc.cpp @@ -0,0 +1,123 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2009 Oracle. All rights reserved. + * + * $Id$ + */ + +#include "db_config.h" + +#include "db_int.h" + +#include "db_cxx.h" +#include "dbinc/cxx_int.h" + +#include "dbinc/db_page.h" +#include "dbinc_auto/db_auto.h" +#include "dbinc_auto/crdel_auto.h" +#include "dbinc/db_dispatch.h" +#include "dbinc_auto/db_ext.h" +#include "dbinc_auto/common_ext.h" + +// Helper macro for simple methods that pass through to the +// underlying C method. It may return an error or raise an exception. +// Note this macro expects that input _argspec is an argument +// list element (e.g., "char *arg") and that _arglist is the arguments +// that should be passed through to the C method (e.g., "(db, arg)") +// +#define DBC_METHOD(_name, _argspec, _arglist, _retok) \ +int Dbc::_name _argspec \ +{ \ + int ret; \ + DBC *dbc = this; \ + \ + ret = dbc->_name _arglist; \ + if (!_retok(ret)) \ + DB_ERROR(DbEnv::get_DbEnv(dbc->dbenv), \ + "Dbc::" # _name, ret, ON_ERROR_UNKNOWN); \ + return (ret); \ +} + +// It's private, and should never be called, but VC4.0 needs it resolved +// +Dbc::~Dbc() +{ +} + +DBC_METHOD(close, (void), (dbc), DB_RETOK_STD) +DBC_METHOD(cmp, (Dbc *other_cursor, int *result, u_int32_t _flags), + (dbc, other_cursor, result, _flags), DB_RETOK_STD) +DBC_METHOD(count, (db_recno_t *countp, u_int32_t _flags), + (dbc, countp, _flags), DB_RETOK_STD) +DBC_METHOD(del, (u_int32_t _flags), + (dbc, _flags), DB_RETOK_DBCDEL) + +int Dbc::dup(Dbc** cursorp, u_int32_t _flags) +{ + int ret; + DBC *dbc = this; + DBC *new_cursor = 0; + + ret = dbc->dup(dbc, &new_cursor, _flags); + + if (DB_RETOK_STD(ret)) + // The following cast implies that Dbc can be no larger than DBC + *cursorp = (Dbc*)new_cursor; + else + DB_ERROR(DbEnv::get_DbEnv(dbc->dbenv), + "Dbc::dup", ret, ON_ERROR_UNKNOWN); + + return (ret); +} + +int Dbc::get(Dbt* key, Dbt *data, u_int32_t _flags) +{ + int ret; + DBC *dbc = this; + + ret = dbc->get(dbc, key, data, _flags); + + if (!DB_RETOK_DBCGET(ret)) { + if (ret == DB_BUFFER_SMALL && DB_OVERFLOWED_DBT(key)) + DB_ERROR_DBT(DbEnv::get_DbEnv(dbc->dbenv), + "Dbc::get", key, ON_ERROR_UNKNOWN); + else if (ret == DB_BUFFER_SMALL && DB_OVERFLOWED_DBT(data)) + DB_ERROR_DBT(DbEnv::get_DbEnv(dbc->dbenv), + "Dbc::get", data, ON_ERROR_UNKNOWN); + else + DB_ERROR(DbEnv::get_DbEnv(dbc->dbenv), + "Dbc::get", ret, ON_ERROR_UNKNOWN); + } + + return (ret); +} + +int Dbc::pget(Dbt* key, Dbt *pkey, Dbt *data, u_int32_t _flags) +{ + int ret; + DBC *dbc = this; + + ret = dbc->pget(dbc, key, pkey, data, _flags); + + /* Logic is the same as for Dbc::get - reusing macro. */ + if (!DB_RETOK_DBCGET(ret)) { + if (ret == DB_BUFFER_SMALL && DB_OVERFLOWED_DBT(key)) + DB_ERROR_DBT(DbEnv::get_DbEnv(dbc->dbenv), + "Dbc::pget", key, ON_ERROR_UNKNOWN); + else if (ret == DB_BUFFER_SMALL && DB_OVERFLOWED_DBT(data)) + DB_ERROR_DBT(DbEnv::get_DbEnv(dbc->dbenv), + "Dbc::pget", data, ON_ERROR_UNKNOWN); + else + DB_ERROR(DbEnv::get_DbEnv(dbc->dbenv), + "Dbc::pget", ret, ON_ERROR_UNKNOWN); + } + + return (ret); +} + +DBC_METHOD(put, (Dbt* key, Dbt *data, u_int32_t _flags), + (dbc, key, data, _flags), DB_RETOK_DBCPUT) +DBC_METHOD(get_priority, (DB_CACHE_PRIORITY *priorityp), + (dbc, priorityp), DB_RETOK_STD) +DBC_METHOD(set_priority, (DB_CACHE_PRIORITY pri), (dbc, pri), DB_RETOK_STD) diff --git a/db-4.8.30/cxx/cxx_dbt.cpp b/db-4.8.30/cxx/cxx_dbt.cpp new file mode 100644 index 0000000..a3dbf9d --- /dev/null +++ b/db-4.8.30/cxx/cxx_dbt.cpp @@ -0,0 +1,56 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2009 Oracle. All rights reserved. + * + * $Id$ + */ + +#include "db_config.h" + +#include "db_int.h" + +#include "db_cxx.h" +#include "dbinc/cxx_int.h" + +#include "dbinc/db_page.h" +#include "dbinc_auto/db_auto.h" +#include "dbinc_auto/crdel_auto.h" +#include "dbinc/db_dispatch.h" +#include "dbinc_auto/db_ext.h" +#include "dbinc_auto/common_ext.h" + +Dbt::Dbt() +{ + DBT *dbt = this; + memset(dbt, 0, sizeof(DBT)); +} + +Dbt::Dbt(void *data_arg, u_int32_t size_arg) +{ + DBT *dbt = this; + memset(dbt, 0, sizeof(DBT)); + set_data(data_arg); + set_size(size_arg); +} + +Dbt::~Dbt() +{ +} + +Dbt::Dbt(const Dbt &that) +{ + const DBT *from = &that; + DBT *to = this; + memcpy(to, from, sizeof(DBT)); +} + +Dbt &Dbt::operator = (const Dbt &that) +{ + if (this != &that) { + const DBT *from = &that; + DBT *to = this; + memcpy(to, from, sizeof(DBT)); + } + return (*this); +} diff --git a/db-4.8.30/cxx/cxx_env.cpp b/db-4.8.30/cxx/cxx_env.cpp new file mode 100644 index 0000000..4276c0a --- /dev/null +++ b/db-4.8.30/cxx/cxx_env.cpp @@ -0,0 +1,1217 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2009 Oracle. All rights reserved. + * + * $Id$ + */ + +#include "db_config.h" + +#include "db_int.h" + +#include "db_cxx.h" +#include "dbinc/cxx_int.h" + +#include "dbinc/db_page.h" +#include "dbinc/db_am.h" +#include "dbinc/log.h" +#include "dbinc_auto/common_ext.h" +#include "dbinc_auto/log_ext.h" + +#ifdef HAVE_CXX_STDHEADERS +using std::cerr; +#endif + +// Helper macros for simple methods that pass through to the +// underlying C method. They may return an error or raise an exception. +// These macros expect that input _argspec is an argument +// list element (e.g., "char *arg") and that _arglist is the arguments +// that should be passed through to the C method (e.g., "(dbenv, arg)") +// +#define DBENV_METHOD_ERR(_name, _argspec, _arglist, _on_err) \ +int DbEnv::_name _argspec \ +{ \ + DB_ENV *dbenv = unwrap(this); \ + int ret; \ + \ + if ((ret = dbenv->_name _arglist) != 0) { \ + _on_err; \ + } \ + return (ret); \ +} + +#define DBENV_METHOD(_name, _argspec, _arglist) \ + DBENV_METHOD_ERR(_name, _argspec, _arglist, \ + DB_ERROR(this, "DbEnv::" # _name, ret, error_policy())) + +#define DBENV_METHOD_QUIET(_name, _argspec, _arglist) \ +int DbEnv::_name _argspec \ +{ \ + DB_ENV *dbenv = unwrap(this); \ + \ + return (dbenv->_name _arglist); \ +} + +#define DBENV_METHOD_VOID(_name, _argspec, _arglist) \ +void DbEnv::_name _argspec \ +{ \ + DB_ENV *dbenv = unwrap(this); \ + \ + dbenv->_name _arglist; \ +} + +// The reason for a static variable is that some structures +// (like Dbts) have no connection to any Db or DbEnv, so when +// errors occur in their methods, we must have some reasonable +// way to determine whether to throw or return errors. +// +// This variable is taken from flags whenever a DbEnv is constructed. +// Normally there is only one DbEnv per program, and even if not, +// there is typically a single policy of throwing or returning. +// +static int last_known_error_policy = ON_ERROR_UNKNOWN; + +// These 'glue' function are declared as extern "C" so they will +// be compatible with picky compilers that do not allow mixing +// of function pointers to 'C' functions with function pointers +// to C++ functions. +// +extern "C" +void _feedback_intercept_c(DB_ENV *dbenv, int opcode, int pct) +{ + DbEnv::_feedback_intercept(dbenv, opcode, pct); +} + +extern "C" +void _paniccall_intercept_c(DB_ENV *dbenv, int errval) +{ + DbEnv::_paniccall_intercept(dbenv, errval); +} + +extern "C" +void _event_func_intercept_c(DB_ENV *dbenv, u_int32_t event, void *event_info) +{ + DbEnv::_event_func_intercept(dbenv, event, event_info); +} + +extern "C" +void _stream_error_function_c(const DB_ENV *dbenv, + const char *prefix, const char *message) +{ + DbEnv::_stream_error_function(dbenv, prefix, message); +} + +extern "C" +void _stream_message_function_c(const DB_ENV *dbenv, const char *message) +{ + DbEnv::_stream_message_function(dbenv, message); +} + +extern "C" +int _app_dispatch_intercept_c(DB_ENV *dbenv, DBT *dbt, DB_LSN *lsn, db_recops op) +{ + return (DbEnv::_app_dispatch_intercept(dbenv, dbt, lsn, op)); +} + +extern "C" +int _rep_send_intercept_c(DB_ENV *dbenv, const DBT *cntrl, const DBT *data, + const DB_LSN *lsn, int id, u_int32_t flags) +{ + return (DbEnv::_rep_send_intercept(dbenv, + cntrl, data, lsn, id, flags)); +} + +extern "C" +int _isalive_intercept_c( + DB_ENV *dbenv, pid_t pid, db_threadid_t thrid, u_int32_t flags) +{ + return (DbEnv::_isalive_intercept(dbenv, pid, thrid, flags)); +} + +extern "C" +void _thread_id_intercept_c(DB_ENV *dbenv, pid_t *pidp, db_threadid_t *thridp) +{ + DbEnv::_thread_id_intercept(dbenv, pidp, thridp); +} + +extern "C" +char *_thread_id_string_intercept_c(DB_ENV *dbenv, pid_t pid, + db_threadid_t thrid, char *buf) +{ + return (DbEnv::_thread_id_string_intercept(dbenv, pid, thrid, buf)); +} + +void DbEnv::_feedback_intercept(DB_ENV *dbenv, int opcode, int pct) +{ + DbEnv *cxxenv = DbEnv::get_DbEnv(dbenv); + if (cxxenv == 0) { + DB_ERROR(0, + "DbEnv::feedback_callback", EINVAL, ON_ERROR_UNKNOWN); + return; + } + if (cxxenv->feedback_callback_ == 0) { + DB_ERROR(DbEnv::get_DbEnv(dbenv), + "DbEnv::feedback_callback", EINVAL, cxxenv->error_policy()); + return; + } + (*cxxenv->feedback_callback_)(cxxenv, opcode, pct); +} + +void DbEnv::_paniccall_intercept(DB_ENV *dbenv, int errval) +{ + DbEnv *cxxenv = DbEnv::get_DbEnv(dbenv); + if (cxxenv == 0) { + DB_ERROR(0, + "DbEnv::paniccall_callback", EINVAL, ON_ERROR_UNKNOWN); + return; + } + if (cxxenv->paniccall_callback_ == 0) { + DB_ERROR(cxxenv, "DbEnv::paniccall_callback", EINVAL, + cxxenv->error_policy()); + return; + } + (*cxxenv->paniccall_callback_)(cxxenv, errval); +} + +void DbEnv::_event_func_intercept( + DB_ENV *dbenv, u_int32_t event, void *event_info) +{ + DbEnv *cxxenv = DbEnv::get_DbEnv(dbenv); + if (cxxenv == 0) { + DB_ERROR(0, + "DbEnv::event_func_callback", EINVAL, ON_ERROR_UNKNOWN); + return; + } + if (cxxenv->event_func_callback_ == 0) { + DB_ERROR(cxxenv, "DbEnv::event_func_callback", EINVAL, + cxxenv->error_policy()); + return; + } + (*cxxenv->event_func_callback_)(cxxenv, event, event_info); +} + +int DbEnv::_app_dispatch_intercept(DB_ENV *dbenv, DBT *dbt, DB_LSN *lsn, + db_recops op) +{ + DbEnv *cxxenv = DbEnv::get_DbEnv(dbenv); + if (cxxenv == 0) { + DB_ERROR(DbEnv::get_DbEnv(dbenv), + "DbEnv::app_dispatch_callback", EINVAL, ON_ERROR_UNKNOWN); + return (EINVAL); + } + if (cxxenv->app_dispatch_callback_ == 0) { + DB_ERROR(DbEnv::get_DbEnv(dbenv), + "DbEnv::app_dispatch_callback", EINVAL, + cxxenv->error_policy()); + return (EINVAL); + } + Dbt *cxxdbt = (Dbt *)dbt; + DbLsn *cxxlsn = (DbLsn *)lsn; + return ((*cxxenv->app_dispatch_callback_)(cxxenv, cxxdbt, cxxlsn, op)); +} + +int DbEnv::_isalive_intercept( + DB_ENV *dbenv, pid_t pid, db_threadid_t thrid, u_int32_t flags) +{ + DbEnv *cxxenv = DbEnv::get_DbEnv(dbenv); + if (cxxenv == 0) { + DB_ERROR(DbEnv::get_DbEnv(dbenv), + "DbEnv::isalive_callback", EINVAL, ON_ERROR_UNKNOWN); + return (0); + } + return ((*cxxenv->isalive_callback_)(cxxenv, pid, thrid, flags)); +} + +int DbEnv::_rep_send_intercept(DB_ENV *dbenv, const DBT *cntrl, const DBT *data, + const DB_LSN *lsn, int id, u_int32_t flags) +{ + DbEnv *cxxenv = DbEnv::get_DbEnv(dbenv); + if (cxxenv == 0) { + DB_ERROR(DbEnv::get_DbEnv(dbenv), + "DbEnv::rep_send_callback", EINVAL, ON_ERROR_UNKNOWN); + return (EINVAL); + } + const Dbt *cxxcntrl = (const Dbt *)cntrl; + const DbLsn *cxxlsn = (const DbLsn *)lsn; + Dbt *cxxdata = (Dbt *)data; + return ((*cxxenv->rep_send_callback_)(cxxenv, + cxxcntrl, cxxdata, cxxlsn, id, flags)); +} + +void DbEnv::_thread_id_intercept(DB_ENV *dbenv, + pid_t *pidp, db_threadid_t *thridp) +{ + DbEnv *cxxenv = DbEnv::get_DbEnv(dbenv); + if (cxxenv == 0) { + DB_ERROR(DbEnv::get_DbEnv(dbenv), + "DbEnv::thread_id_callback", EINVAL, ON_ERROR_UNKNOWN); + } else + cxxenv->thread_id_callback_(cxxenv, pidp, thridp); +} + +char *DbEnv::_thread_id_string_intercept(DB_ENV *dbenv, + pid_t pid, db_threadid_t thrid, char *buf) +{ + DbEnv *cxxenv = DbEnv::get_DbEnv(dbenv); + if (cxxenv == 0) { + DB_ERROR(DbEnv::get_DbEnv(dbenv), + "DbEnv::thread_id_string_callback", EINVAL, + ON_ERROR_UNKNOWN); + return (NULL); + } + return (cxxenv->thread_id_string_callback_(cxxenv, pid, thrid, buf)); +} + +// A truism for the DbEnv object is that there is a valid +// DB_ENV handle from the constructor until close(). +// After the close, the DB_ENV handle is invalid and +// no operations are permitted on the DbEnv (other than +// destructor). Leaving the DbEnv handle open and not +// doing a close is generally considered an error. +// +// We used to allow DbEnv objects to be closed and reopened. +// This implied always keeping a valid DB_ENV object, and +// coordinating the open objects between Db/DbEnv turned +// out to be overly complicated. Now we do not allow this. + +DbEnv::DbEnv(u_int32_t flags) +: imp_(0) +, construct_error_(0) +, construct_flags_(flags) +, error_stream_(0) +, message_stream_(0) +, app_dispatch_callback_(0) +, feedback_callback_(0) +, paniccall_callback_(0) +, event_func_callback_(0) +, rep_send_callback_(0) +{ + if ((construct_error_ = initialize(0)) != 0) + DB_ERROR(this, "DbEnv::DbEnv", construct_error_, + error_policy()); +} + +DbEnv::DbEnv(DB_ENV *dbenv, u_int32_t flags) +: imp_(0) +, construct_error_(0) +, construct_flags_(flags) +, error_stream_(0) +, message_stream_(0) +, app_dispatch_callback_(0) +, feedback_callback_(0) +, paniccall_callback_(0) +, event_func_callback_(0) +, rep_send_callback_(0) +{ + if ((construct_error_ = initialize(dbenv)) != 0) + DB_ERROR(this, "DbEnv::DbEnv", construct_error_, + error_policy()); +} + +// If the DB_ENV handle is still open, we close it. This is to make stack +// allocation of DbEnv objects easier so that they are cleaned up in the error +// path. Note that the C layer catches cases where handles are open in the +// environment at close time and reports an error. Applications should call +// close explicitly in normal (non-exceptional) cases to check the return +// value. +// +DbEnv::~DbEnv() +{ + DB_ENV *dbenv = unwrap(this); + + if (dbenv != NULL) { + (void)dbenv->close(dbenv, 0); + cleanup(); + } +} + +// called by destructors before the DB_ENV is destroyed. +void DbEnv::cleanup() +{ + imp_ = 0; +} + +int DbEnv::close(u_int32_t flags) +{ + int ret; + DB_ENV *dbenv = unwrap(this); + + ret = dbenv->close(dbenv, flags); + + // after a close (no matter if success or failure), + // the underlying DB_ENV object must not be accessed. + cleanup(); + + // It's safe to throw an error after the close, + // since our error mechanism does not peer into + // the DB* structures. + // + if (ret != 0) + DB_ERROR(this, "DbEnv::close", ret, error_policy()); + + return (ret); +} + +DBENV_METHOD(dbremove, + (DbTxn *txn, const char *name, const char *subdb, u_int32_t flags), + (dbenv, unwrap(txn), name, subdb, flags)) +DBENV_METHOD(dbrename, (DbTxn *txn, const char *name, const char *subdb, + const char *newname, u_int32_t flags), + (dbenv, unwrap(txn), name, subdb, newname, flags)) + +void DbEnv::err(int error, const char *format, ...) +{ + DB_ENV *dbenv = unwrap(this); + + DB_REAL_ERR(dbenv, error, DB_ERROR_SET, 1, format); +} + +// Return a tristate value corresponding to whether we should +// throw exceptions on errors: +// ON_ERROR_RETURN +// ON_ERROR_THROW +// ON_ERROR_UNKNOWN +// +int DbEnv::error_policy() +{ + if ((construct_flags_ & DB_CXX_NO_EXCEPTIONS) != 0) { + return (ON_ERROR_RETURN); + } + else { + return (ON_ERROR_THROW); + } +} + +void DbEnv::errx(const char *format, ...) +{ + DB_ENV *dbenv = unwrap(this); + + DB_REAL_ERR(dbenv, 0, DB_ERROR_NOT_SET, 1, format); +} + +void *DbEnv::get_app_private() const +{ + return unwrapConst(this)->app_private; +} + +DBENV_METHOD(failchk, (u_int32_t flags), (dbenv, flags)) +DBENV_METHOD(fileid_reset, (const char *file, u_int32_t flags), + (dbenv, file, flags)) +DBENV_METHOD(get_home, (const char **homep), (dbenv, homep)) +DBENV_METHOD(get_open_flags, (u_int32_t *flagsp), (dbenv, flagsp)) +DBENV_METHOD(get_data_dirs, (const char ***dirspp), (dbenv, dirspp)) + +bool DbEnv::is_bigendian() +{ + return unwrap(this)->is_bigendian() ? true : false; +} + +DBENV_METHOD(get_thread_count, (u_int32_t *count), (dbenv, count)) +DBENV_METHOD(set_thread_count, (u_int32_t count), (dbenv, count)) + +// used internally during constructor +// to associate an existing DB_ENV with this DbEnv, +// or create a new one. +// +int DbEnv::initialize(DB_ENV *dbenv) +{ + int ret; + + last_known_error_policy = error_policy(); + + if (dbenv == 0) { + // Create a new DB_ENV environment. + if ((ret = ::db_env_create(&dbenv, + construct_flags_ & ~DB_CXX_NO_EXCEPTIONS)) != 0) + return (ret); + } + imp_ = dbenv; + dbenv->api1_internal = this; // for DB_ENV* to DbEnv* conversion + return (0); +} + +// lock methods +DBENV_METHOD(lock_detect, (u_int32_t flags, u_int32_t atype, int *aborted), + (dbenv, flags, atype, aborted)) +DBENV_METHOD_ERR(lock_get, + (u_int32_t locker, u_int32_t flags, Dbt *obj, + db_lockmode_t lock_mode, DbLock *lock), + (dbenv, locker, flags, obj, lock_mode, &lock->lock_), + DbEnv::runtime_error_lock_get(this, "DbEnv::lock_get", ret, + DB_LOCK_GET, lock_mode, obj, *lock, + -1, error_policy())) +DBENV_METHOD(lock_id, (u_int32_t *idp), (dbenv, idp)) +DBENV_METHOD(lock_id_free, (u_int32_t id), (dbenv, id)) +DBENV_METHOD(lock_put, (DbLock *lock), (dbenv, &lock->lock_)) +DBENV_METHOD(lock_stat, (DB_LOCK_STAT **statp, u_int32_t flags), + (dbenv, statp, flags)) +DBENV_METHOD(lock_stat_print, (u_int32_t flags), (dbenv, flags)) +DBENV_METHOD_ERR(lock_vec, + (u_int32_t locker, u_int32_t flags, DB_LOCKREQ list[], + int nlist, DB_LOCKREQ **elist_returned), + (dbenv, locker, flags, list, nlist, elist_returned), + DbEnv::runtime_error_lock_get(this, "DbEnv::lock_vec", ret, + (*elist_returned)->op, (*elist_returned)->mode, + Dbt::get_Dbt((*elist_returned)->obj), DbLock((*elist_returned)->lock), + (int)((*elist_returned) - list), error_policy())) +// log methods +DBENV_METHOD(log_archive, (char **list[], u_int32_t flags), + (dbenv, list, flags)) + +int DbEnv::log_compare(const DbLsn *lsn0, const DbLsn *lsn1) +{ + return (::log_compare(lsn0, lsn1)); +} + +// The following cast implies that DbLogc can be no larger than DB_LOGC +DBENV_METHOD(log_cursor, (DbLogc **cursorp, u_int32_t flags), + (dbenv, (DB_LOGC **)cursorp, flags)) +DBENV_METHOD(log_file, (DbLsn *lsn, char *namep, size_t len), + (dbenv, lsn, namep, len)) +DBENV_METHOD(log_flush, (const DbLsn *lsn), (dbenv, lsn)) +DBENV_METHOD(log_get_config, (u_int32_t which, int *onoffp), + (dbenv, which, onoffp)) +DBENV_METHOD(log_put, (DbLsn *lsn, const Dbt *data, u_int32_t flags), + (dbenv, lsn, data, flags)) + +int DbEnv::log_printf(DbTxn *txn, const char *fmt, ...) +{ + DB_ENV *dbenv = unwrap(this); + va_list ap; + int ret; + + va_start(ap, fmt); + ret = __log_printf_pp(dbenv, unwrap(txn), fmt, ap); + va_end(ap); + + return (ret); +} + +DBENV_METHOD(log_set_config, (u_int32_t which, int onoff), + (dbenv, which, onoff)) +DBENV_METHOD(log_stat, (DB_LOG_STAT **spp, u_int32_t flags), + (dbenv, spp, flags)) +DBENV_METHOD(log_stat_print, (u_int32_t flags), (dbenv, flags)) + +DBENV_METHOD(lsn_reset, (const char *file, u_int32_t flags), + (dbenv, file, flags)) + +int DbEnv::memp_fcreate(DbMpoolFile **dbmfp, u_int32_t flags) +{ + DB_ENV *dbenv = unwrap(this); + int ret; + DB_MPOOLFILE *mpf; + + if (dbenv == NULL) + ret = EINVAL; + else + ret = dbenv->memp_fcreate(dbenv, &mpf, flags); + + if (DB_RETOK_STD(ret)) { + *dbmfp = new DbMpoolFile(); + (*dbmfp)->imp_ = mpf; + } else + DB_ERROR(this, "DbMpoolFile::f_create", ret, ON_ERROR_UNKNOWN); + + return (ret); +} + +DBENV_METHOD(memp_register, + (int ftype, pgin_fcn_type pgin_fcn, pgout_fcn_type pgout_fcn), + (dbenv, ftype, pgin_fcn, pgout_fcn)) + +// memory pool methods +DBENV_METHOD(memp_stat, + (DB_MPOOL_STAT **gsp, DB_MPOOL_FSTAT ***fsp, u_int32_t flags), + (dbenv, gsp, fsp, flags)) +DBENV_METHOD(memp_stat_print, (u_int32_t flags), (dbenv, flags)) +DBENV_METHOD(memp_sync, (DbLsn *sn), (dbenv, sn)) +DBENV_METHOD(memp_trickle, (int pct, int *nwrotep), (dbenv, pct, nwrotep)) + +// If an error occurred during the constructor, report it now. +// Otherwise, call the underlying DB->open method. +// +int DbEnv::open(const char *db_home, u_int32_t flags, int mode) +{ + int ret; + DB_ENV *dbenv = unwrap(this); + + if (construct_error_ != 0) + ret = construct_error_; + else + ret = dbenv->open(dbenv, db_home, flags, mode); + + if (!DB_RETOK_STD(ret)) + DB_ERROR(this, "DbEnv::open", ret, error_policy()); + + return (ret); +} + +int DbEnv::remove(const char *db_home, u_int32_t flags) +{ + int ret; + DB_ENV *dbenv = unwrap(this); + + ret = dbenv->remove(dbenv, db_home, flags); + + // after a remove (no matter if success or failure), + // the underlying DB_ENV object must not be accessed, + // so we clean up in advance. + // + cleanup(); + + if (ret != 0) + DB_ERROR(this, "DbEnv::remove", ret, error_policy()); + + return (ret); +} + +// Report an error associated with the DbEnv. +// error_policy is one of: +// ON_ERROR_THROW throw an error +// ON_ERROR_RETURN do nothing here, the caller will return an error +// ON_ERROR_UNKNOWN defer the policy to policy saved in DbEnv::DbEnv +// +void DbEnv::runtime_error(DbEnv *dbenv, + const char *caller, int error, int error_policy) +{ + if (error_policy == ON_ERROR_UNKNOWN) + error_policy = last_known_error_policy; + if (error_policy == ON_ERROR_THROW) { + // Creating and throwing the object in two separate + // statements seems to be necessary for HP compilers. + switch (error) { + case DB_LOCK_DEADLOCK: + { + DbDeadlockException dl_except(caller); + dl_except.set_env(dbenv); + throw dl_except; + } + case DB_LOCK_NOTGRANTED: + { + DbLockNotGrantedException lng_except(caller); + lng_except.set_env(dbenv); + throw lng_except; + } + case DB_REP_HANDLE_DEAD: + { + DbRepHandleDeadException hd_except(caller); + hd_except.set_env(dbenv); + throw hd_except; + } + case DB_RUNRECOVERY: + { + DbRunRecoveryException rr_except(caller); + rr_except.set_env(dbenv); + throw rr_except; + } + default: + { + DbException except(caller, error); + except.set_env(dbenv); + throw except; + } + } + } +} + +// Like DbEnv::runtime_error, but issue a DbMemoryException +// based on the fact that this Dbt is not large enough. +void DbEnv::runtime_error_dbt(DbEnv *dbenv, + const char *caller, Dbt *dbt, int error_policy) +{ + if (error_policy == ON_ERROR_UNKNOWN) + error_policy = last_known_error_policy; + if (error_policy == ON_ERROR_THROW) { + // Creating and throwing the object in two separate + // statements seems to be necessary for HP compilers. + DbMemoryException except(caller, dbt); + except.set_env(dbenv); + throw except; + } +} + +// Like DbEnv::runtime_error, but issue a DbLockNotGrantedException, +// or a regular runtime error. +// call regular runtime_error if it +void DbEnv::runtime_error_lock_get(DbEnv *dbenv, + const char *caller, int error, + db_lockop_t op, db_lockmode_t mode, Dbt *obj, + DbLock lock, int index, int error_policy) +{ + if (error != DB_LOCK_NOTGRANTED) { + runtime_error(dbenv, caller, error, error_policy); + return; + } + + if (error_policy == ON_ERROR_UNKNOWN) + error_policy = last_known_error_policy; + if (error_policy == ON_ERROR_THROW) { + // Creating and throwing the object in two separate + // statements seems to be necessary for HP compilers. + DbLockNotGrantedException except(caller, op, mode, + obj, lock, index); + except.set_env(dbenv); + throw except; + } +} + +void DbEnv::_stream_error_function( + const DB_ENV *dbenv, const char *prefix, const char *message) +{ + const DbEnv *cxxenv = DbEnv::get_const_DbEnv(dbenv); + if (cxxenv == 0) { + DB_ERROR(0, + "DbEnv::stream_error", EINVAL, ON_ERROR_UNKNOWN); + return; + } + + if (cxxenv->error_callback_) + cxxenv->error_callback_(cxxenv, prefix, message); + else if (cxxenv->error_stream_) { + // HP compilers need the extra casts, we don't know why. + if (prefix) { + (*cxxenv->error_stream_) << prefix; + (*cxxenv->error_stream_) << (const char *)": "; + } + if (message) + (*cxxenv->error_stream_) << (const char *)message; + (*cxxenv->error_stream_) << (const char *)"\n"; + } +} + +void DbEnv::_stream_message_function(const DB_ENV *dbenv, const char *message) +{ + const DbEnv *cxxenv = DbEnv::get_const_DbEnv(dbenv); + if (cxxenv == 0) { + DB_ERROR(0, + "DbEnv::stream_message", EINVAL, ON_ERROR_UNKNOWN); + return; + } + + if (cxxenv->message_callback_) + cxxenv->message_callback_(cxxenv, message); + else if (cxxenv->message_stream_) { + // HP compilers need the extra casts, we don't know why. + (*cxxenv->message_stream_) << (const char *)message; + (*cxxenv->message_stream_) << (const char *)"\n"; + } +} + +// static method +char *DbEnv::strerror(int error) +{ + return (db_strerror(error)); +} + +// We keep these alphabetical by field name, +// for comparison with Java's list. +// +DBENV_METHOD(set_data_dir, (const char *dir), (dbenv, dir)) +DBENV_METHOD(get_encrypt_flags, (u_int32_t *flagsp), + (dbenv, flagsp)) +DBENV_METHOD(set_encrypt, (const char *passwd, u_int32_t flags), + (dbenv, passwd, flags)) +DBENV_METHOD_VOID(get_errfile, (FILE **errfilep), (dbenv, errfilep)) +DBENV_METHOD_VOID(set_errfile, (FILE *errfile), (dbenv, errfile)) +DBENV_METHOD_VOID(get_errpfx, (const char **errpfxp), (dbenv, errpfxp)) +DBENV_METHOD_VOID(set_errpfx, (const char *errpfx), (dbenv, errpfx)) +DBENV_METHOD(get_intermediate_dir_mode, (const char **modep), (dbenv, modep)) +DBENV_METHOD(set_intermediate_dir_mode, (const char *mode), (dbenv, mode)) +DBENV_METHOD(get_lg_bsize, (u_int32_t *bsizep), (dbenv, bsizep)) +DBENV_METHOD(set_lg_bsize, (u_int32_t bsize), (dbenv, bsize)) +DBENV_METHOD(get_lg_dir, (const char **dirp), (dbenv, dirp)) +DBENV_METHOD(set_lg_dir, (const char *dir), (dbenv, dir)) +DBENV_METHOD(get_lg_filemode, (int *modep), (dbenv, modep)) +DBENV_METHOD(set_lg_filemode, (int mode), (dbenv, mode)) +DBENV_METHOD(get_lg_max, (u_int32_t *maxp), (dbenv, maxp)) +DBENV_METHOD(set_lg_max, (u_int32_t max), (dbenv, max)) +DBENV_METHOD(get_lg_regionmax, (u_int32_t *regionmaxp), (dbenv, regionmaxp)) +DBENV_METHOD(set_lg_regionmax, (u_int32_t regionmax), (dbenv, regionmax)) +DBENV_METHOD(get_lk_conflicts, (const u_int8_t **lk_conflictsp, int *lk_maxp), + (dbenv, lk_conflictsp, lk_maxp)) +DBENV_METHOD(set_lk_conflicts, (u_int8_t *lk_conflicts, int lk_max), + (dbenv, lk_conflicts, lk_max)) +DBENV_METHOD(get_lk_detect, (u_int32_t *detectp), (dbenv, detectp)) +DBENV_METHOD(set_lk_detect, (u_int32_t detect), (dbenv, detect)) +DBENV_METHOD(get_lk_max_lockers, (u_int32_t *max_lockersp), + (dbenv, max_lockersp)) +DBENV_METHOD(set_lk_max_lockers, (u_int32_t max_lockers), (dbenv, max_lockers)) +DBENV_METHOD(get_lk_max_locks, (u_int32_t *max_locksp), (dbenv, max_locksp)) +DBENV_METHOD(set_lk_max_locks, (u_int32_t max_locks), (dbenv, max_locks)) +DBENV_METHOD(get_lk_max_objects, (u_int32_t *max_objectsp), + (dbenv, max_objectsp)) +DBENV_METHOD(set_lk_max_objects, (u_int32_t max_objects), (dbenv, max_objects)) +DBENV_METHOD(get_lk_partitions, (u_int32_t *partitionsp), (dbenv, partitionsp)) +DBENV_METHOD(set_lk_partitions, (u_int32_t partitions), (dbenv, partitions)) +DBENV_METHOD(get_mp_max_openfd, (int *maxopenfdp), (dbenv, maxopenfdp)) +DBENV_METHOD(set_mp_max_openfd, (int maxopenfd), (dbenv, maxopenfd)) +DBENV_METHOD(get_mp_max_write, (int *maxwritep, db_timeout_t *maxwrite_sleepp), + (dbenv, maxwritep, maxwrite_sleepp)) +DBENV_METHOD(set_mp_max_write, (int maxwrite, db_timeout_t maxwrite_sleep), + (dbenv, maxwrite, maxwrite_sleep)) +DBENV_METHOD(get_mp_mmapsize, (size_t *mmapsizep), (dbenv, mmapsizep)) +DBENV_METHOD(set_mp_mmapsize, (size_t mmapsize), (dbenv, mmapsize)) +DBENV_METHOD(get_mp_pagesize, (u_int32_t *pagesizep), (dbenv, pagesizep)) +DBENV_METHOD(set_mp_pagesize, (u_int32_t pagesize), (dbenv, pagesize)) +DBENV_METHOD(get_mp_tablesize, (u_int32_t *tablesizep), (dbenv, tablesizep)) +DBENV_METHOD(set_mp_tablesize, (u_int32_t tablesize), (dbenv, tablesize)) +DBENV_METHOD_VOID(get_msgfile, (FILE **msgfilep), (dbenv, msgfilep)) +DBENV_METHOD_VOID(set_msgfile, (FILE *msgfile), (dbenv, msgfile)) +DBENV_METHOD(get_tmp_dir, (const char **tmp_dirp), (dbenv, tmp_dirp)) +DBENV_METHOD(set_tmp_dir, (const char *tmp_dir), (dbenv, tmp_dir)) +DBENV_METHOD(get_tx_max, (u_int32_t *tx_maxp), (dbenv, tx_maxp)) +DBENV_METHOD(set_tx_max, (u_int32_t tx_max), (dbenv, tx_max)) + +DBENV_METHOD(stat_print, (u_int32_t flags), (dbenv, flags)) + +DBENV_METHOD_QUIET(get_alloc, + (db_malloc_fcn_type *malloc_fcnp, db_realloc_fcn_type *realloc_fcnp, + db_free_fcn_type *free_fcnp), + (dbenv, malloc_fcnp, realloc_fcnp, free_fcnp)) + +DBENV_METHOD_QUIET(set_alloc, + (db_malloc_fcn_type malloc_fcn, db_realloc_fcn_type realloc_fcn, + db_free_fcn_type free_fcn), + (dbenv, malloc_fcn, realloc_fcn, free_fcn)) + +void DbEnv::set_app_private(void *value) +{ + unwrap(this)->app_private = value; +} + +DBENV_METHOD(get_cachesize, + (u_int32_t *gbytesp, u_int32_t *bytesp, int *ncachep), + (dbenv, gbytesp, bytesp, ncachep)) +DBENV_METHOD(set_cachesize, + (u_int32_t gbytes, u_int32_t bytes, int ncache), + (dbenv, gbytes, bytes, ncache)) +DBENV_METHOD(get_cache_max, (u_int32_t *gbytesp, u_int32_t *bytesp), + (dbenv, gbytesp, bytesp)) +DBENV_METHOD(set_cache_max, (u_int32_t gbytes, u_int32_t bytes), + (dbenv, gbytes, bytes)) +DBENV_METHOD(get_create_dir, (const char **dirp), (dbenv, dirp)) +DBENV_METHOD(set_create_dir, (const char *dir), (dbenv, dir)) + +void DbEnv::get_errcall(void (**argp)(const DbEnv *, const char *, const char *)) +{ + if (argp != NULL) + *argp = error_callback_; + return; +} + +void DbEnv::set_errcall(void (*arg)(const DbEnv *, const char *, const char *)) +{ + DB_ENV *dbenv = unwrap(this); + + error_callback_ = arg; + error_stream_ = 0; + + dbenv->set_errcall(dbenv, (arg == 0) ? 0 : + _stream_error_function_c); +} + +__DB_STD(ostream) *DbEnv::get_error_stream() +{ + return (error_stream_); +} + +void DbEnv::set_error_stream(__DB_STD(ostream) *stream) +{ + DB_ENV *dbenv = unwrap(this); + + error_stream_ = stream; + error_callback_ = 0; + + dbenv->set_errcall(dbenv, (stream == 0) ? 0 : + _stream_error_function_c); +} + +int DbEnv::get_feedback(void (**argp)(DbEnv *, int, int)) +{ + if (argp != NULL) + *argp = feedback_callback_; + return 0; +} + +int DbEnv::set_feedback(void (*arg)(DbEnv *, int, int)) +{ + DB_ENV *dbenv = unwrap(this); + + feedback_callback_ = arg; + + return (dbenv->set_feedback(dbenv, + arg == 0 ? 0 : _feedback_intercept_c)); +} + +DBENV_METHOD(get_flags, (u_int32_t *flagsp), (dbenv, flagsp)) +DBENV_METHOD(set_flags, (u_int32_t flags, int onoff), (dbenv, flags, onoff)) + +void DbEnv::get_msgcall(void (**argp)(const DbEnv *, const char *)) +{ + if (argp != NULL) + *argp = message_callback_; +} + +void DbEnv::set_msgcall(void (*arg)(const DbEnv *, const char *)) +{ + DB_ENV *dbenv = unwrap(this); + + message_callback_ = arg; + message_stream_ = 0; + + dbenv->set_msgcall(dbenv, (arg == 0) ? 0 : + _stream_message_function_c); +} + +__DB_STD(ostream) *DbEnv::get_message_stream() +{ + return (message_stream_); +} + +void DbEnv::set_message_stream(__DB_STD(ostream) *stream) +{ + DB_ENV *dbenv = unwrap(this); + + message_stream_ = stream; + message_callback_ = 0; + + dbenv->set_msgcall(dbenv, (stream == 0) ? 0 : + _stream_message_function_c); +} + +int DbEnv::set_paniccall(void (*arg)(DbEnv *, int)) +{ + DB_ENV *dbenv = unwrap(this); + + paniccall_callback_ = arg; + + return (dbenv->set_paniccall(dbenv, + arg == 0 ? 0 : _paniccall_intercept_c)); +} + +int DbEnv::set_event_notify(void (*arg)(DbEnv *, u_int32_t, void *)) +{ + DB_ENV *dbenv = unwrap(this); + + event_func_callback_ = arg; + + return (dbenv->set_event_notify(dbenv, + arg == 0 ? 0 : _event_func_intercept_c)); +} + +DBENV_METHOD(set_rpc_server, + (void *cl, char *host, long tsec, long ssec, u_int32_t flags), + (dbenv, cl, host, tsec, ssec, flags)) +DBENV_METHOD(get_shm_key, (long *shm_keyp), (dbenv, shm_keyp)) +DBENV_METHOD(set_shm_key, (long shm_key), (dbenv, shm_key)) + +int DbEnv::get_app_dispatch + (int (**argp)(DbEnv *, Dbt *, DbLsn *, db_recops)) +{ + if (argp != NULL) + *argp = app_dispatch_callback_; + return 0; +} + +int DbEnv::set_app_dispatch + (int (*arg)(DbEnv *, Dbt *, DbLsn *, db_recops)) +{ + DB_ENV *dbenv = unwrap(this); + int ret; + + app_dispatch_callback_ = arg; + if ((ret = dbenv->set_app_dispatch(dbenv, + arg == 0 ? 0 : _app_dispatch_intercept_c)) != 0) + DB_ERROR(this, "DbEnv::set_app_dispatch", ret, error_policy()); + + return (ret); +} + +int DbEnv::get_isalive + (int (**argp)(DbEnv *, pid_t, db_threadid_t, u_int32_t)) +{ + if (argp != NULL) + *argp = isalive_callback_; + return 0; +} + +int DbEnv::set_isalive + (int (*arg)(DbEnv *, pid_t, db_threadid_t, u_int32_t)) +{ + DB_ENV *dbenv = unwrap(this); + int ret; + + isalive_callback_ = arg; + if ((ret = dbenv->set_isalive(dbenv, + arg == 0 ? 0 : _isalive_intercept_c)) != 0) + DB_ERROR(this, "DbEnv::set_isalive", ret, error_policy()); + + return (ret); +} + +DBENV_METHOD(get_tx_timestamp, (time_t *timestamp), (dbenv, timestamp)) +DBENV_METHOD(set_tx_timestamp, (time_t *timestamp), (dbenv, timestamp)) +DBENV_METHOD(get_verbose, (u_int32_t which, int *onoffp), + (dbenv, which, onoffp)) +DBENV_METHOD(set_verbose, (u_int32_t which, int onoff), (dbenv, which, onoff)) + +DBENV_METHOD(mutex_alloc, + (u_int32_t flags, db_mutex_t *mutexp), (dbenv, flags, mutexp)) +DBENV_METHOD(mutex_free, (db_mutex_t mutex), (dbenv, mutex)) +DBENV_METHOD(mutex_get_align, (u_int32_t *argp), (dbenv, argp)) +DBENV_METHOD(mutex_get_increment, (u_int32_t *argp), (dbenv, argp)) +DBENV_METHOD(mutex_get_max, (u_int32_t *argp), (dbenv, argp)) +DBENV_METHOD(mutex_get_tas_spins, (u_int32_t *argp), (dbenv, argp)) +DBENV_METHOD(mutex_lock, (db_mutex_t mutex), (dbenv, mutex)) +DBENV_METHOD(mutex_set_align, (u_int32_t arg), (dbenv, arg)) +DBENV_METHOD(mutex_set_increment, (u_int32_t arg), (dbenv, arg)) +DBENV_METHOD(mutex_set_max, (u_int32_t arg), (dbenv, arg)) +DBENV_METHOD(mutex_set_tas_spins, (u_int32_t arg), (dbenv, arg)) +DBENV_METHOD(mutex_stat, + (DB_MUTEX_STAT **statp, u_int32_t flags), (dbenv, statp, flags)) +DBENV_METHOD(mutex_stat_print, (u_int32_t flags), (dbenv, flags)) +DBENV_METHOD(mutex_unlock, (db_mutex_t mutex), (dbenv, mutex)) + +int DbEnv::get_thread_id_fn(void (**argp)(DbEnv *, pid_t *, db_threadid_t *)) +{ + if (argp != NULL) + *argp = thread_id_callback_; + return 0; +} + +int DbEnv::set_thread_id(void (*arg)(DbEnv *, pid_t *, db_threadid_t *)) +{ + DB_ENV *dbenv = unwrap(this); + int ret; + + thread_id_callback_ = arg; + if ((ret = dbenv->set_thread_id(dbenv, + arg == 0 ? 0 : _thread_id_intercept_c)) != 0) + DB_ERROR(this, "DbEnv::set_thread_id", ret, error_policy()); + + return (ret); +} + +int DbEnv::get_thread_id_string_fn( + char *(**argp)(DbEnv *, pid_t, db_threadid_t, char *)) +{ + if (argp != NULL) + *argp = thread_id_string_callback_; + return 0; +} + +int DbEnv::set_thread_id_string( + char *(*arg)(DbEnv *, pid_t, db_threadid_t, char *)) +{ + DB_ENV *dbenv = unwrap(this); + int ret; + + thread_id_string_callback_ = arg; + if ((ret = dbenv->set_thread_id_string(dbenv, + arg == 0 ? 0 : _thread_id_string_intercept_c)) != 0) + DB_ERROR(this, "DbEnv::set_thread_id_string", ret, + error_policy()); + + return (ret); +} + +DBENV_METHOD(add_data_dir, (const char *dir), (dbenv, dir)) + +int DbEnv::cdsgroup_begin(DbTxn **tid) +{ + DB_ENV *dbenv = unwrap(this); + DB_TXN *txn; + int ret; + + ret = dbenv->cdsgroup_begin(dbenv, &txn); + if (DB_RETOK_STD(ret)) + *tid = new DbTxn(txn, NULL); + else + DB_ERROR(this, "DbEnv::cdsgroup_begin", ret, error_policy()); + + return (ret); +} + +int DbEnv::txn_begin(DbTxn *pid, DbTxn **tid, u_int32_t flags) +{ + DB_ENV *dbenv = unwrap(this); + DB_TXN *txn; + int ret; + + ret = dbenv->txn_begin(dbenv, unwrap(pid), &txn, flags); + if (DB_RETOK_STD(ret)) + *tid = new DbTxn(txn, pid); + else + DB_ERROR(this, "DbEnv::txn_begin", ret, error_policy()); + + return (ret); +} + +DBENV_METHOD(txn_checkpoint, (u_int32_t kbyte, u_int32_t min, u_int32_t flags), + (dbenv, kbyte, min, flags)) + +int DbEnv::txn_recover(DbPreplist *preplist, u_int32_t count, + u_int32_t *retp, u_int32_t flags) +{ + DB_ENV *dbenv = unwrap(this); + DB_PREPLIST *c_preplist; + u_int32_t i; + int ret; + + /* + * We need to allocate some local storage for the + * returned preplist, and that requires us to do + * our own argument validation. + */ + if (count <= 0) + ret = EINVAL; + else + ret = __os_malloc(dbenv->env, sizeof(DB_PREPLIST) * count, + &c_preplist); + + if (ret != 0) { + DB_ERROR(this, "DbEnv::txn_recover", ret, error_policy()); + return (ret); + } + + if ((ret = + dbenv->txn_recover(dbenv, c_preplist, count, retp, flags)) != 0) { + __os_free(dbenv->env, c_preplist); + DB_ERROR(this, "DbEnv::txn_recover", ret, error_policy()); + return (ret); + } + + for (i = 0; i < *retp; i++) { + preplist[i].txn = new DbTxn(NULL); + preplist[i].txn->imp_ = c_preplist[i].txn; + memcpy(preplist[i].gid, c_preplist[i].gid, + sizeof(preplist[i].gid)); + } + + __os_free(dbenv->env, c_preplist); + + return (0); +} + +DBENV_METHOD(txn_stat, (DB_TXN_STAT **statp, u_int32_t flags), + (dbenv, statp, flags)) +DBENV_METHOD(txn_stat_print, (u_int32_t flags), (dbenv, flags)) + +int DbEnv::rep_set_transport(int myid, int (*arg)(DbEnv *, + const Dbt *, const Dbt *, const DbLsn *, int, u_int32_t)) +{ + DB_ENV *dbenv = unwrap(this); + int ret; + + rep_send_callback_ = arg; + if ((ret = dbenv->rep_set_transport(dbenv, myid, + arg == 0 ? 0 : _rep_send_intercept_c)) != 0) + DB_ERROR(this, "DbEnv::rep_set_transport", ret, error_policy()); + + return (ret); +} + +DBENV_METHOD(rep_elect, (u_int32_t nsites, u_int32_t nvotes, u_int32_t flags), + (dbenv, nsites, nvotes, flags)) +DBENV_METHOD(rep_flush, (), (dbenv)) +DBENV_METHOD(rep_get_config, (u_int32_t which, int *onoffp), + (dbenv, which, onoffp)) +DBENV_METHOD(rep_get_request, (u_int32_t *min, u_int32_t *max), + (dbenv, min, max)) +DBENV_METHOD(rep_set_request, (u_int32_t min, u_int32_t max), (dbenv, min, max)) + +int DbEnv::rep_process_message(Dbt *control, + Dbt *rec, int id, DbLsn *ret_lsnp) +{ + DB_ENV *dbenv = unwrap(this); + int ret; + + ret = dbenv->rep_process_message(dbenv, control, rec, id, ret_lsnp); + if (!DB_RETOK_REPPMSG(ret)) + DB_ERROR(this, "DbEnv::rep_process_message", ret, + error_policy()); + + return (ret); +} + +DBENV_METHOD(rep_set_config, + (u_int32_t which, int onoff), (dbenv, which, onoff)) +DBENV_METHOD(rep_start, + (Dbt *cookie, u_int32_t flags), + (dbenv, (DBT *)cookie, flags)) + +DBENV_METHOD(rep_stat, (DB_REP_STAT **statp, u_int32_t flags), + (dbenv, statp, flags)) +DBENV_METHOD(rep_stat_print, (u_int32_t flags), (dbenv, flags)) +DBENV_METHOD(rep_sync, (u_int32_t flags), (dbenv, flags)) + +DBENV_METHOD(rep_get_clockskew, (u_int32_t *fast_clockp, u_int32_t *slow_clockp), + (dbenv, fast_clockp, slow_clockp)) +DBENV_METHOD(rep_set_clockskew, (u_int32_t fast_clock, u_int32_t slow_clock), + (dbenv, fast_clock, slow_clock)) +DBENV_METHOD(rep_get_limit, (u_int32_t *gbytesp, u_int32_t *bytesp), + (dbenv, gbytesp, bytesp)) +DBENV_METHOD(rep_set_limit, (u_int32_t gbytes, u_int32_t bytes), + (dbenv, gbytes, bytes)) + +// +// Begin advanced replication API method implementations +DBENV_METHOD(rep_get_nsites, (u_int32_t *n), (dbenv, n)) +DBENV_METHOD(rep_set_nsites, (u_int32_t n), (dbenv, n)) +DBENV_METHOD(rep_get_priority, (u_int32_t *priority), + (dbenv, priority)) +DBENV_METHOD(rep_set_priority, (u_int32_t priority), + (dbenv, priority)) +DBENV_METHOD(rep_get_timeout, (int which, db_timeout_t * timeout), + (dbenv, which, timeout)) +DBENV_METHOD(rep_set_timeout, (int which, db_timeout_t timeout), + (dbenv, which, timeout)) +DBENV_METHOD(repmgr_add_remote_site, (const char* host, u_int16_t port, + int * eidp, u_int32_t flags), (dbenv, host, port, eidp, flags)) +DBENV_METHOD(repmgr_get_ack_policy, (int *policy), (dbenv, policy)) +DBENV_METHOD(repmgr_set_ack_policy, (int policy), (dbenv, policy)) +DBENV_METHOD(repmgr_set_local_site, (const char* host, u_int16_t port, + u_int32_t flags), (dbenv, host, port, flags)) +DBENV_METHOD(repmgr_site_list, (u_int *countp, DB_REPMGR_SITE **listp), + (dbenv, countp, listp)) + +int DbEnv::repmgr_start(int nthreads, u_int32_t flags) +{ + DB_ENV *dbenv = unwrap(this); + int ret; + + ret = dbenv->repmgr_start(dbenv, nthreads, flags); + if (!DB_RETOK_REPMGR_START(ret)) + DB_ERROR(this, "DbEnv::repmgr_start", ret, + error_policy()); + + return (ret); +} + +DBENV_METHOD(repmgr_stat, (DB_REPMGR_STAT **statp, u_int32_t flags), + (dbenv, statp, flags)) +DBENV_METHOD(repmgr_stat_print, (u_int32_t flags), (dbenv, flags)) + +// End advanced replication API method implementations. + +DBENV_METHOD(get_timeout, + (db_timeout_t *timeoutp, u_int32_t flags), + (dbenv, timeoutp, flags)) +DBENV_METHOD(set_timeout, + (db_timeout_t timeout, u_int32_t flags), + (dbenv, timeout, flags)) + +// static method +char *DbEnv::version(int *major, int *minor, int *patch) +{ + return (db_version(major, minor, patch)); +} + +// static method +DbEnv *DbEnv::wrap_DB_ENV(DB_ENV *dbenv) +{ + DbEnv *wrapped_env = get_DbEnv(dbenv); + return (wrapped_env != NULL) ? wrapped_env : new DbEnv(dbenv, 0); +} diff --git a/db-4.8.30/cxx/cxx_except.cpp b/db-4.8.30/cxx/cxx_except.cpp new file mode 100644 index 0000000..a2e73d5 --- /dev/null +++ b/db-4.8.30/cxx/cxx_except.cpp @@ -0,0 +1,356 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2009 Oracle. All rights reserved. + * + * $Id$ + */ + +#include "db_config.h" + +#include "db_int.h" + +#include "db_cxx.h" +#include "dbinc/cxx_int.h" + +static const int MAX_DESCRIPTION_LENGTH = 1024; + +// Note: would not be needed if we can inherit from exception +// It does not appear to be possible to inherit from exception +// with the current Microsoft library (VC5.0). +// +static char *dupString(const char *s) +{ + char *r = new char[strlen(s)+1]; + strcpy(r, s); + return (r); +} + +//////////////////////////////////////////////////////////////////////// +// // +// DbException // +// // +//////////////////////////////////////////////////////////////////////// + +DbException::~DbException() throw() +{ + delete [] what_; +} + +DbException::DbException(int err) +: err_(err) +, dbenv_(0) +{ + describe(0, 0); +} + +DbException::DbException(const char *description) +: err_(0) +, dbenv_(0) +{ + describe(0, description); +} + +DbException::DbException(const char *description, int err) +: err_(err) +, dbenv_(0) +{ + describe(0, description); +} + +DbException::DbException(const char *prefix, const char *description, int err) +: err_(err) +, dbenv_(0) +{ + describe(prefix, description); +} + +DbException::DbException(const DbException &that) +: __DB_STD(exception)() +, what_(dupString(that.what_)) +, err_(that.err_) +, dbenv_(0) +{ +} + +DbException &DbException::operator = (const DbException &that) +{ + if (this != &that) { + err_ = that.err_; + delete [] what_; + what_ = dupString(that.what_); + } + return (*this); +} + +void DbException::describe(const char *prefix, const char *description) +{ + char *msgbuf, *p, *end; + + msgbuf = new char[MAX_DESCRIPTION_LENGTH]; + p = msgbuf; + end = msgbuf + MAX_DESCRIPTION_LENGTH - 1; + + if (prefix != NULL) { + strncpy(p, prefix, (p < end) ? end - p: 0); + p += strlen(prefix); + strncpy(p, ": ", (p < end) ? end - p: 0); + p += 2; + } + if (description != NULL) { + strncpy(p, description, (p < end) ? end - p: 0); + p += strlen(description); + if (err_ != 0) { + strncpy(p, ": ", (p < end) ? end - p: 0); + p += 2; + } + } + if (err_ != 0) { + strncpy(p, db_strerror(err_), (p < end) ? end - p: 0); + p += strlen(db_strerror(err_)); + } + + /* + * If the result was too long, the buffer will not be null-terminated, + * so we need to fix that here before duplicating it. + */ + if (p >= end) + *end = '\0'; + + what_ = dupString(msgbuf); + delete [] msgbuf; +} + +int DbException::get_errno() const +{ + return (err_); +} + +const char *DbException::what() const throw() +{ + return (what_); +} + +DbEnv *DbException::get_env() const +{ + return dbenv_; +} + +void DbException::set_env(DbEnv *dbenv) +{ + dbenv_= dbenv; +} + +//////////////////////////////////////////////////////////////////////// +// // +// DbMemoryException // +// // +//////////////////////////////////////////////////////////////////////// + +static const char *memory_err_desc = "Dbt not large enough for available data"; +DbMemoryException::~DbMemoryException() throw() +{ +} + +DbMemoryException::DbMemoryException(Dbt *dbt) +: DbException(memory_err_desc, DB_BUFFER_SMALL) +, dbt_(dbt) +{ +} + +DbMemoryException::DbMemoryException(const char *prefix, Dbt *dbt) +: DbException(prefix, memory_err_desc, DB_BUFFER_SMALL) +, dbt_(dbt) +{ +} + +DbMemoryException::DbMemoryException(const DbMemoryException &that) +: DbException(that) +, dbt_(that.dbt_) +{ +} + +DbMemoryException +&DbMemoryException::operator =(const DbMemoryException &that) +{ + if (this != &that) { + DbException::operator=(that); + dbt_ = that.dbt_; + } + return (*this); +} + +Dbt *DbMemoryException::get_dbt() const +{ + return (dbt_); +} + +//////////////////////////////////////////////////////////////////////// +// // +// DbDeadlockException // +// // +//////////////////////////////////////////////////////////////////////// + +DbDeadlockException::~DbDeadlockException() throw() +{ +} + +DbDeadlockException::DbDeadlockException(const char *description) +: DbException(description, DB_LOCK_DEADLOCK) +{ +} + +DbDeadlockException::DbDeadlockException(const DbDeadlockException &that) +: DbException(that) +{ +} + +DbDeadlockException +&DbDeadlockException::operator =(const DbDeadlockException &that) +{ + if (this != &that) + DbException::operator=(that); + return (*this); +} + +//////////////////////////////////////////////////////////////////////// +// // +// DbLockNotGrantedException // +// // +//////////////////////////////////////////////////////////////////////// + +DbLockNotGrantedException::~DbLockNotGrantedException() throw() +{ + delete lock_; +} + +DbLockNotGrantedException::DbLockNotGrantedException(const char *prefix, + db_lockop_t op, db_lockmode_t mode, const Dbt *obj, const DbLock lock, + int index) +: DbException(prefix, DbEnv::strerror(DB_LOCK_NOTGRANTED), + DB_LOCK_NOTGRANTED) +, op_(op) +, mode_(mode) +, obj_(obj) +, lock_(new DbLock(lock)) +, index_(index) +{ +} + +DbLockNotGrantedException::DbLockNotGrantedException(const char *description) +: DbException(description, DB_LOCK_NOTGRANTED) +, op_(DB_LOCK_GET) +, mode_(DB_LOCK_NG) +, obj_(NULL) +, lock_(NULL) +, index_(0) +{ +} + +DbLockNotGrantedException::DbLockNotGrantedException + (const DbLockNotGrantedException &that) +: DbException(that) +{ + op_ = that.op_; + mode_ = that.mode_; + obj_ = that.obj_; + lock_ = (that.lock_ != NULL) ? new DbLock(*that.lock_) : NULL; + index_ = that.index_; +} + +DbLockNotGrantedException +&DbLockNotGrantedException::operator =(const DbLockNotGrantedException &that) +{ + if (this != &that) { + DbException::operator=(that); + op_ = that.op_; + mode_ = that.mode_; + obj_ = that.obj_; + lock_ = (that.lock_ != NULL) ? new DbLock(*that.lock_) : NULL; + index_ = that.index_; + } + return (*this); +} + +db_lockop_t DbLockNotGrantedException::get_op() const +{ + return op_; +} + +db_lockmode_t DbLockNotGrantedException::get_mode() const +{ + return mode_; +} + +const Dbt* DbLockNotGrantedException::get_obj() const +{ + return obj_; +} + +DbLock* DbLockNotGrantedException::get_lock() const +{ + return lock_; +} + +int DbLockNotGrantedException::get_index() const +{ + return index_; +} + +//////////////////////////////////////////////////////////////////////// +// // +// DbRepHandleDeadException // +// // +//////////////////////////////////////////////////////////////////////// + +DbRepHandleDeadException::~DbRepHandleDeadException() throw() +{ +} + +DbRepHandleDeadException::DbRepHandleDeadException(const char *description) +: DbException(description, DB_REP_HANDLE_DEAD) +{ +} + +DbRepHandleDeadException::DbRepHandleDeadException + (const DbRepHandleDeadException &that) +: DbException(that) +{ +} + +DbRepHandleDeadException +&DbRepHandleDeadException::operator =(const DbRepHandleDeadException &that) +{ + if (this != &that) + DbException::operator=(that); + return (*this); +} + +//////////////////////////////////////////////////////////////////////// +// // +// DbRunRecoveryException // +// // +//////////////////////////////////////////////////////////////////////// + +DbRunRecoveryException::~DbRunRecoveryException() throw() +{ +} + +DbRunRecoveryException::DbRunRecoveryException(const char *description) +: DbException(description, DB_RUNRECOVERY) +{ +} + +DbRunRecoveryException::DbRunRecoveryException + (const DbRunRecoveryException &that) +: DbException(that) +{ +} + +DbRunRecoveryException +&DbRunRecoveryException::operator =(const DbRunRecoveryException &that) +{ + if (this != &that) + DbException::operator=(that); + return (*this); +} diff --git a/db-4.8.30/cxx/cxx_lock.cpp b/db-4.8.30/cxx/cxx_lock.cpp new file mode 100644 index 0000000..b48aa60 --- /dev/null +++ b/db-4.8.30/cxx/cxx_lock.cpp @@ -0,0 +1,41 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2009 Oracle. All rights reserved. + * + * $Id$ + */ + +#include "db_config.h" + +#include "db_int.h" + +#include "db_cxx.h" +#include "dbinc/cxx_int.h" + +//////////////////////////////////////////////////////////////////////// +// // +// DbLock // +// // +//////////////////////////////////////////////////////////////////////// + +DbLock::DbLock(DB_LOCK value) +: lock_(value) +{ +} + +DbLock::DbLock() +{ + memset(&lock_, 0, sizeof(DB_LOCK)); +} + +DbLock::DbLock(const DbLock &that) +: lock_(that.lock_) +{ +} + +DbLock &DbLock::operator = (const DbLock &that) +{ + lock_ = that.lock_; + return (*this); +} diff --git a/db-4.8.30/cxx/cxx_logc.cpp b/db-4.8.30/cxx/cxx_logc.cpp new file mode 100644 index 0000000..cdc6eb1 --- /dev/null +++ b/db-4.8.30/cxx/cxx_logc.cpp @@ -0,0 +1,78 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2009 Oracle. All rights reserved. + * + * $Id$ + */ + +#include "db_config.h" + +#include "db_int.h" + +#include "db_cxx.h" +#include "dbinc/cxx_int.h" + +#include "dbinc/db_page.h" +#include "dbinc_auto/db_auto.h" +#include "dbinc_auto/crdel_auto.h" +#include "dbinc/db_dispatch.h" +#include "dbinc_auto/db_ext.h" +#include "dbinc_auto/common_ext.h" + +// It's private, and should never be called, +// but some compilers need it resolved +// +DbLogc::~DbLogc() +{ +} + +// The name _flags prevents a name clash with __db_log_cursor::flags +int DbLogc::close(u_int32_t _flags) +{ + DB_LOGC *logc = this; + int ret; + DbEnv *dbenv2 = DbEnv::get_DbEnv(logc->env->dbenv); + + ret = logc->close(logc, _flags); + + if (!DB_RETOK_STD(ret)) + DB_ERROR(dbenv2, "DbLogc::close", ret, ON_ERROR_UNKNOWN); + + return (ret); +} + +// The name _flags prevents a name clash with __db_log_cursor::flags +int DbLogc::get(DbLsn *get_lsn, Dbt *data, u_int32_t _flags) +{ + DB_LOGC *logc = this; + int ret; + + ret = logc->get(logc, get_lsn, data, _flags); + + if (!DB_RETOK_LGGET(ret)) { + if (ret == DB_BUFFER_SMALL) + DB_ERROR_DBT(DbEnv::get_DbEnv(logc->env->dbenv), + "DbLogc::get", data, ON_ERROR_UNKNOWN); + else + DB_ERROR(DbEnv::get_DbEnv(logc->env->dbenv), + "DbLogc::get", ret, ON_ERROR_UNKNOWN); + } + + return (ret); +} + +// The name _flags prevents a name clash with __db_log_cursor::flags +int DbLogc::version(u_int32_t *versionp, u_int32_t _flags) +{ + DB_LOGC *logc = this; + int ret; + + ret = logc->version(logc, versionp, _flags); + + if (!DB_RETOK_LGGET(ret)) + DB_ERROR(DbEnv::get_DbEnv(logc->env->dbenv), + "DbLogc::version", ret, ON_ERROR_UNKNOWN); + + return (ret); +} diff --git a/db-4.8.30/cxx/cxx_mpool.cpp b/db-4.8.30/cxx/cxx_mpool.cpp new file mode 100644 index 0000000..2112452 --- /dev/null +++ b/db-4.8.30/cxx/cxx_mpool.cpp @@ -0,0 +1,128 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2009 Oracle. All rights reserved. + * + * $Id$ + */ + +#include "db_config.h" + +#include "db_int.h" + +#include "db_cxx.h" +#include "dbinc/cxx_int.h" + +// Helper macros for simple methods that pass through to the +// underlying C method. It may return an error or raise an exception. +// Note this macro expects that input _argspec is an argument +// list element (e.g., "char *arg") and that _arglist is the arguments +// that should be passed through to the C method (e.g., "(mpf, arg)") +// +#define DB_MPOOLFILE_METHOD(_name, _argspec, _arglist, _retok) \ +int DbMpoolFile::_name _argspec \ +{ \ + int ret; \ + DB_MPOOLFILE *mpf = unwrap(this); \ + \ + if (mpf == NULL) \ + ret = EINVAL; \ + else \ + ret = mpf->_name _arglist; \ + if (!_retok(ret)) \ + DB_ERROR(DbEnv::get_DbEnv(mpf->env->dbenv), \ + "DbMpoolFile::"#_name, ret, ON_ERROR_UNKNOWN); \ + return (ret); \ +} + +#define DB_MPOOLFILE_METHOD_VOID(_name, _argspec, _arglist) \ +void DbMpoolFile::_name _argspec \ +{ \ + DB_MPOOLFILE *mpf = unwrap(this); \ + \ + mpf->_name _arglist; \ +} + +//////////////////////////////////////////////////////////////////////// +// // +// DbMpoolFile // +// // +//////////////////////////////////////////////////////////////////////// + +DbMpoolFile::DbMpoolFile() +: imp_(0) +{ +} + +DbMpoolFile::~DbMpoolFile() +{ +} + +int DbMpoolFile::close(u_int32_t flags) +{ + DB_MPOOLFILE *mpf = unwrap(this); + int ret; + DbEnv *dbenv = DbEnv::get_DbEnv(mpf->env->dbenv); + + if (mpf == NULL) + ret = EINVAL; + else + ret = mpf->close(mpf, flags); + + imp_ = 0; // extra safety + + // This may seem weird, but is legal as long as we don't access + // any data before returning. + delete this; + + if (!DB_RETOK_STD(ret)) + DB_ERROR(dbenv, "DbMpoolFile::close", ret, ON_ERROR_UNKNOWN); + + return (ret); +} + +DB_MPOOLFILE_METHOD(get, + (db_pgno_t *pgnoaddr, DbTxn *txn, u_int32_t flags, void *pagep), + (mpf, pgnoaddr, unwrap(txn), flags, pagep), DB_RETOK_MPGET) +DB_MPOOLFILE_METHOD(open, + (const char *file, u_int32_t flags, int mode, size_t pagesize), + (mpf, file, flags, mode, pagesize), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(put, + (void *pgaddr, DB_CACHE_PRIORITY priority, u_int32_t flags), + (mpf, pgaddr, priority, flags), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(get_clear_len, (u_int32_t *lenp), + (mpf, lenp), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(set_clear_len, (u_int32_t len), + (mpf, len), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(get_fileid, (u_int8_t *fileid), + (mpf, fileid), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(set_fileid, (u_int8_t *fileid), + (mpf, fileid), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(get_flags, (u_int32_t *flagsp), + (mpf, flagsp), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(set_flags, (u_int32_t flags, int onoff), + (mpf, flags, onoff), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(get_ftype, (int *ftypep), + (mpf, ftypep), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(set_ftype, (int ftype), + (mpf, ftype), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(get_last_pgno, (db_pgno_t *pgnop), + (mpf, pgnop), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(get_lsn_offset, (int32_t *offsetp), + (mpf, offsetp), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(set_lsn_offset, (int32_t offset), + (mpf, offset), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(get_maxsize, (u_int32_t *gbytesp, u_int32_t *bytesp), + (mpf, gbytesp, bytesp), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(set_maxsize, (u_int32_t gbytes, u_int32_t bytes), + (mpf, gbytes, bytes), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(get_pgcookie, (DBT *dbt), + (mpf, dbt), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(set_pgcookie, (DBT *dbt), + (mpf, dbt), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(get_priority, (DB_CACHE_PRIORITY *priorityp), + (mpf, priorityp), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(set_priority, (DB_CACHE_PRIORITY priority), + (mpf, priority), DB_RETOK_STD) +DB_MPOOLFILE_METHOD(sync, (), + (mpf), DB_RETOK_STD) diff --git a/db-4.8.30/cxx/cxx_multi.cpp b/db-4.8.30/cxx/cxx_multi.cpp new file mode 100644 index 0000000..6e1a361 --- /dev/null +++ b/db-4.8.30/cxx/cxx_multi.cpp @@ -0,0 +1,123 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2009 Oracle. All rights reserved. + * + * $Id$ + */ + +#include "db_config.h" + +#include "db_int.h" + +#include "db_cxx.h" + +DbMultipleIterator::DbMultipleIterator(const Dbt &dbt) + : data_((u_int8_t*)dbt.get_data()), + p_((u_int32_t*)(data_ + dbt.get_ulen() - sizeof(u_int32_t))) +{ +} + +bool DbMultipleDataIterator::next(Dbt &data) +{ + if (*p_ == (u_int32_t)-1) { + data.set_data(0); + data.set_size(0); + p_ = 0; + } else { + data.set_data(data_ + *p_--); + data.set_size(*p_--); + if (data.get_size() == 0 && data.get_data() == data_) + data.set_data(0); + } + return (p_ != 0); +} + +bool DbMultipleKeyDataIterator::next(Dbt &key, Dbt &data) +{ + if (*p_ == (u_int32_t)-1) { + key.set_data(0); + key.set_size(0); + data.set_data(0); + data.set_size(0); + p_ = 0; + } else { + key.set_data(data_ + *p_--); + key.set_size(*p_--); + data.set_data(data_ + *p_--); + data.set_size(*p_--); + } + return (p_ != 0); +} + +bool DbMultipleRecnoDataIterator::next(db_recno_t &recno, Dbt &data) +{ + if (*p_ == (u_int32_t)0) { + recno = 0; + data.set_data(0); + data.set_size(0); + p_ = 0; + } else { + recno = *p_--; + data.set_data(data_ + *p_--); + data.set_size(*p_--); + } + return (p_ != 0); +} + + +DbMultipleBuilder::DbMultipleBuilder(Dbt &dbt) : dbt_(dbt) +{ + DB_MULTIPLE_WRITE_INIT(p_, dbt_.get_DBT()); +} + + +bool DbMultipleDataBuilder::append(void *dbuf, size_t dlen) +{ + DB_MULTIPLE_WRITE_NEXT(p_, dbt_.get_DBT(), dbuf, dlen); + return (p_ != 0); +} + +bool DbMultipleDataBuilder::reserve(void *&ddest, size_t dlen) +{ + DB_MULTIPLE_RESERVE_NEXT(p_, dbt_.get_DBT(), ddest, dlen); + return (ddest != 0); +} + +bool DbMultipleKeyDataBuilder::append( + void *kbuf, size_t klen, void *dbuf, size_t dlen) +{ + DB_MULTIPLE_KEY_WRITE_NEXT(p_, dbt_.get_DBT(), + kbuf, klen, dbuf, dlen); + return (p_ != 0); +} + +bool DbMultipleKeyDataBuilder::reserve( + void *&kdest, size_t klen, void *&ddest, size_t dlen) +{ + DB_MULTIPLE_KEY_RESERVE_NEXT(p_, dbt_.get_DBT(), + kdest, klen, ddest, dlen); + return (kdest != 0 && ddest != 0); +} + + +DbMultipleRecnoDataBuilder::DbMultipleRecnoDataBuilder(Dbt &dbt) : dbt_(dbt) +{ + DB_MULTIPLE_RECNO_WRITE_INIT(p_, dbt_.get_DBT()); +} + +bool DbMultipleRecnoDataBuilder::append( + db_recno_t recno, void *dbuf, size_t dlen) +{ + DB_MULTIPLE_RECNO_WRITE_NEXT(p_, dbt_.get_DBT(), + recno, dbuf, dlen); + return (p_ != 0); +} + +bool DbMultipleRecnoDataBuilder::reserve( + db_recno_t recno, void *&ddest, size_t dlen) +{ + DB_MULTIPLE_RECNO_RESERVE_NEXT(p_, dbt_.get_DBT(), + recno, ddest, dlen); + return (ddest != 0); +} diff --git a/db-4.8.30/cxx/cxx_seq.cpp b/db-4.8.30/cxx/cxx_seq.cpp new file mode 100644 index 0000000..1a7a5df --- /dev/null +++ b/db-4.8.30/cxx/cxx_seq.cpp @@ -0,0 +1,109 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2009 Oracle. All rights reserved. + * + * $Id$ + */ + +#include "db_config.h" + +#include "db_int.h" + +#include "db_cxx.h" +#include "dbinc/cxx_int.h" + +// Helper macro for simple methods that pass through to the +// underlying C method. It may return an error or raise an exception. +// Note this macro expects that input _argspec is an argument +// list element (e.g., "char *arg") and that _arglist is the arguments +// that should be passed through to the C method (e.g., "(db, arg)") +// +#define DBSEQ_METHOD(_name, _argspec, _arglist, _destructor) \ +int DbSequence::_name _argspec \ +{ \ + int ret; \ + DB_SEQUENCE *seq = unwrap(this); \ + DbEnv *dbenv = DbEnv::get_DbEnv(seq->seq_dbp->dbenv); \ + \ + ret = seq->_name _arglist; \ + if (_destructor) \ + imp_ = 0; \ + if (!DB_RETOK_STD(ret)) \ + DB_ERROR(dbenv, \ + "DbSequence::" # _name, ret, ON_ERROR_UNKNOWN); \ + return (ret); \ +} + +DbSequence::DbSequence(Db *db, u_int32_t flags) +: imp_(0) +{ + DB_SEQUENCE *seq; + int ret; + + if ((ret = db_sequence_create(&seq, unwrap(db), flags)) != 0) + DB_ERROR(db->get_env(), "DbSequence::DbSequence", ret, + ON_ERROR_UNKNOWN); + else { + imp_ = seq; + seq->api_internal = this; + } +} + +DbSequence::DbSequence(DB_SEQUENCE *seq) +: imp_(seq) +{ + seq->api_internal = this; +} + +DbSequence::~DbSequence() +{ + DB_SEQUENCE *seq; + + seq = unwrap(this); + if (seq != NULL) + (void)seq->close(seq, 0); +} + +DBSEQ_METHOD(open, (DbTxn *txnid, Dbt *key, u_int32_t flags), + (seq, unwrap(txnid), key, flags), 0) +DBSEQ_METHOD(initial_value, (db_seq_t value), (seq, value), 0) +DBSEQ_METHOD(close, (u_int32_t flags), (seq, flags), 1) +DBSEQ_METHOD(remove, (DbTxn *txnid, u_int32_t flags), + (seq, unwrap(txnid), flags), 1) +DBSEQ_METHOD(stat, (DB_SEQUENCE_STAT **sp, u_int32_t flags), + (seq, sp, flags), 0) +DBSEQ_METHOD(stat_print, (u_int32_t flags), (seq, flags), 0) + +DBSEQ_METHOD(get, + (DbTxn *txnid, int32_t delta, db_seq_t *retp, u_int32_t flags), + (seq, unwrap(txnid), delta, retp, flags), 0) +DBSEQ_METHOD(get_cachesize, (int32_t *sizep), (seq, sizep), 0) +DBSEQ_METHOD(set_cachesize, (int32_t size), (seq, size), 0) +DBSEQ_METHOD(get_flags, (u_int32_t *flagsp), (seq, flagsp), 0) +DBSEQ_METHOD(set_flags, (u_int32_t flags), (seq, flags), 0) +DBSEQ_METHOD(get_range, (db_seq_t *minp, db_seq_t *maxp), (seq, minp, maxp), 0) +DBSEQ_METHOD(set_range, (db_seq_t min, db_seq_t max), (seq, min, max), 0) + +Db *DbSequence::get_db() +{ + DB_SEQUENCE *seq = unwrap(this); + DB *db; + (void)seq->get_db(seq, &db); + return Db::get_Db(db); +} + +Dbt *DbSequence::get_key() +{ + DB_SEQUENCE *seq = unwrap(this); + memset(&key_, 0, sizeof(DBT)); + (void)seq->get_key(seq, &key_); + return Dbt::get_Dbt(&key_); +} + +// static method +DbSequence *DbSequence::wrap_DB_SEQUENCE(DB_SEQUENCE *seq) +{ + DbSequence *wrapped_seq = get_DbSequence(seq); + return (wrapped_seq != NULL) ? wrapped_seq : new DbSequence(seq); +} diff --git a/db-4.8.30/cxx/cxx_txn.cpp b/db-4.8.30/cxx/cxx_txn.cpp new file mode 100644 index 0000000..28b9344 --- /dev/null +++ b/db-4.8.30/cxx/cxx_txn.cpp @@ -0,0 +1,115 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2009 Oracle. All rights reserved. + * + * $Id$ + */ + +#include "db_config.h" + +#include "db_int.h" + +#include "db_cxx.h" +#include "dbinc/cxx_int.h" + +#include "dbinc/txn.h" + +// Helper macro for simple methods that pass through to the +// underlying C method. It may return an error or raise an exception. +// Note this macro expects that input _argspec is an argument +// list element (e.g., "char *arg") and that _arglist is the arguments +// that should be passed through to the C method (e.g., "(db, arg)") +// +#define DBTXN_METHOD(_name, _delete, _argspec, _arglist) \ +int DbTxn::_name _argspec \ +{ \ + int ret; \ + DB_TXN *txn = unwrap(this); \ + DbEnv *dbenv = DbEnv::get_DbEnv(txn->mgrp->env->dbenv); \ + \ + ret = txn->_name _arglist; \ + /* Weird, but safe if we don't access this again. */ \ + if (_delete) { \ + /* Can't do this in the destructor. */ \ + if (parent_txn_ != NULL) \ + parent_txn_->remove_child_txn(this); \ + delete this; \ + } \ + if (!DB_RETOK_STD(ret)) \ + DB_ERROR(dbenv, "DbTxn::" # _name, ret, ON_ERROR_UNKNOWN); \ + return (ret); \ +} + +// private constructor, never called but needed by some C++ linkers +DbTxn::DbTxn(DbTxn *ptxn) +: imp_(0) +{ + TAILQ_INIT(&children); + memset(&child_entry, 0, sizeof(child_entry)); + parent_txn_ = ptxn; + if (parent_txn_ != NULL) + parent_txn_->add_child_txn(this); +} + +DbTxn::DbTxn(DB_TXN *txn, DbTxn *ptxn) +: imp_(txn) +{ + txn->api_internal = this; + TAILQ_INIT(&children); + memset(&child_entry, 0, sizeof(child_entry)); + parent_txn_ = ptxn; + if (parent_txn_ != NULL) + parent_txn_->add_child_txn(this); +} + +DbTxn::~DbTxn() +{ + DbTxn *txn, *pnext; + + for(txn = TAILQ_FIRST(&children); txn != NULL;) { + pnext = TAILQ_NEXT(txn, child_entry); + delete txn; + txn = pnext; + } +} + +DBTXN_METHOD(abort, 1, (), (txn)) +DBTXN_METHOD(commit, 1, (u_int32_t flags), (txn, flags)) +DBTXN_METHOD(discard, 1, (u_int32_t flags), (txn, flags)) + +void DbTxn::remove_child_txn(DbTxn *kid) +{ + TAILQ_REMOVE(&children, kid, child_entry); + kid->set_parent(NULL); +} + +void DbTxn::add_child_txn(DbTxn *kid) +{ + TAILQ_INSERT_HEAD(&children, kid, child_entry); + kid->set_parent(this); +} + +u_int32_t DbTxn::id() +{ + DB_TXN *txn; + + txn = unwrap(this); + return (txn->id(txn)); // no error +} + +DBTXN_METHOD(get_name, 0, (const char **namep), (txn, namep)) +DBTXN_METHOD(prepare, 0, (u_int8_t *gid), (txn, gid)) +DBTXN_METHOD(set_name, 0, (const char *name), (txn, name)) +DBTXN_METHOD(set_timeout, 0, (db_timeout_t timeout, u_int32_t flags), + (txn, timeout, flags)) + +// static method +DbTxn *DbTxn::wrap_DB_TXN(DB_TXN *txn) +{ + DbTxn *wrapped_txn = get_DbTxn(txn); + // txn may have a valid parent transaction, but here we don't care. + // We maintain parent-kid relationship in DbTxn only to make sure + // unresolved kids of DbTxn objects are deleted. + return (wrapped_txn != NULL) ? wrapped_txn : new DbTxn(txn, NULL); +} |