#include "db_config.h"
#ifndef lint
static const char revid[] = "$Id: cxx_db.cpp,v 1.2 2004/03/30 01:21:24 jtownsen Exp $";
#endif
#include <errno.h>
#include <string.h>
#include "db_cxx.h"
#include "dbinc/cxx_int.h"
#include "db_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"
#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(env_, "Db::" # _name, ret, error_policy()); \
return (ret); \
}
#define DB_METHOD_CHECKED(_name, _cleanup, _argspec, _arglist, _retok) \
int Db::_name _argspec \
{ \
int ret; \
DB *db = unwrap(this); \
\
if (!db) { \
DB_ERROR(env_, "Db::" # _name, EINVAL, error_policy()); \
return (EINVAL); \
} \
if (_cleanup) \
cleanup(); \
ret = db->_name _arglist; \
if (!_retok(ret)) \
DB_ERROR(env_, "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; \
}
Db::Db(DbEnv *env, u_int32_t flags)
: imp_(0)
, env_(env)
, mpf_(0)
, construct_error_(0)
, flags_(0)
, construct_flags_(flags)
, append_recno_callback_(0)
, associate_callback_(0)
, bt_compare_callback_(0)
, bt_prefix_callback_(0)
, dup_compare_callback_(0)
, feedback_callback_(0)
, h_hash_callback_(0)
{
if (env_ == 0)
flags_ |= DB_CXX_PRIVATE_ENV;
if ((construct_error_ = initialize()) != 0)
DB_ERROR(env_, "Db::Db", construct_error_, error_policy());
}
Db::~Db()
{
DB *db;
db = unwrap(this);
if (db != NULL) {
cleanup();
(void)db->close(db, 0);
}
}
int Db::initialize()
{
DB *db;
DB_ENV *cenv = unwrap(env_);
int ret;
u_int32_t cxx_flags;
cxx_flags = construct_flags_ & DB_CXX_NO_EXCEPTIONS;
if ((ret = db_create(&db, cenv,
construct_flags_ & ~cxx_flags)) != 0)
return (ret);
imp_ = wrap(db);
db->api_internal = this;
if ((flags_ & DB_CXX_PRIVATE_ENV) != 0)
env_ = new DbEnv(db->dbenv, cxx_flags);
mpf_ = new DbMpoolFile();
mpf_->imp_ = wrap(db->mpf);
return (0);
}
void Db::cleanup()
{
DB *db = unwrap(this);
if (db != NULL) {
imp_ = 0;
if ((flags_ & DB_CXX_PRIVATE_ENV) != 0) {
env_->cleanup();
delete env_;
env_ = 0;
}
delete mpf_;
}
}
int Db::error_policy()
{
if (env_ != NULL)
return (env_->error_policy());
else {
if ((construct_flags_ & DB_CXX_NO_EXCEPTIONS) != 0) {
return (ON_ERROR_RETURN);
}
else {
return (ON_ERROR_THROW);
}
}
}
int Db::close(u_int32_t flags)
{
DB *db = unwrap(this);
int ret;
cleanup();
if ((ret = db->close(db, flags)) != 0)
DB_ERROR(env_, "Db::close", ret, error_policy());
return (ret);
}
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, 1, 1, format);
}
void Db::errx(const char *format, ...)
{
DB *db = unwrap(this);
DB_REAL_ERR(db->dbenv, 0, 0, 1, format);
}
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 == ENOMEM && DB_OVERFLOWED_DBT(value))
DB_ERROR_DBT(env_, "Db::get", value, error_policy());
else
DB_ERROR(env_, "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;
(void)db->get_env(db, &dbenv);
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));
}
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)
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(env_, "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);
if (!DB_RETOK_DBGET(ret)) {
if (ret == ENOMEM && DB_OVERFLOWED_DBT(value))
DB_ERROR_DBT(env_, "Db::pget", value, error_policy());
else
DB_ERROR(env_, "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_METHOD_CHECKED(rename, 1,
(const char *file, const char *database, const char *newname,
u_int32_t flags),
(db, file, database, newname, flags), DB_RETOK_STD)
DB_METHOD_CHECKED(remove, 1,
(const char *file, const char *database, u_int32_t flags),
(db, file, database, flags), DB_RETOK_STD)
DB_METHOD_CHECKED(truncate, 0,
(DbTxn *txnid, u_int32_t *countp, u_int32_t flags),
(db, unwrap(txnid), countp, flags), DB_RETOK_STD)
DB_METHOD_CHECKED(stat, 0,
(void *sp, u_int32_t flags), (db, sp, flags), DB_RETOK_STD)
DB_METHOD_CHECKED(sync, 0,
(u_int32_t flags), (db, flags), DB_RETOK_STD)
DB_METHOD_CHECKED(upgrade, 0,
(const char *name, u_int32_t flags), (db, name, flags), DB_RETOK_STD)
#define DB_CALLBACK_C_INTERCEPT(_name, _rettype, _cargspec, \
_return, _cxxargs) \
extern "C" _rettype _db_##_name##_intercept_c _cargspec \
{ \
Db *cxxthis; \
\
DB_ASSERT(cthis != NULL); \
cxxthis = Db::get_Db(cthis); \
DB_ASSERT(cxxthis != NULL); \
DB_ASSERT(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)); \
}
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);
secondary->associate_callback_ = callback;
return ((*(cthis->associate))(cthis, unwrap(txn), unwrap(secondary),
(callback) ? _db_associate_intercept_c : NULL, flags));
}
DB_CALLBACK_C_INTERCEPT(feedback,
void, (DB *cthis, int opcode, int pct),
(void), (cxxthis, opcode, pct))
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_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_SET_CALLBACK(set_bt_compare, bt_compare,
(int (*arg)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), arg)
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_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_SET_CALLBACK(set_dup_compare, dup_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_SET_CALLBACK(set_h_hash, h_hash,
(u_int32_t (*arg)(Db *cxxthis, const void *data, u_int32_t len)), arg)
extern "C"
int _verify_callback_c(void *handle, const void *str_arg)
{
char *str;
__DB_OSTREAMCLASS *out;
str = (char *)str_arg;
out = (__DB_OSTREAMCLASS *)handle;
(*out) << str;
if (out->fail())
return (EIO);
return (0);
}
int Db::verify(const char *name, const char *subdb,
__DB_OSTREAMCLASS *ostr, u_int32_t flags)
{
DB *db = unwrap(this);
int ret;
if (!db)
ret = EINVAL;
else {
cleanup();
ret = __db_verify_internal(db, name, subdb, ostr,
_verify_callback_c, flags);
}
if (!DB_RETOK_STD(ret))
DB_ERROR(env_, "Db::verify", ret, error_policy());
return (ret);
}
DB_METHOD(set_bt_compare, (bt_compare_fcn_type func),
(db, func), DB_RETOK_STD)
DB_METHOD(set_bt_maxkey, (u_int32_t bt_maxkey),
(db, bt_maxkey), 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(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(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_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(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(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::set_errcall(void (*arg)(const char *, char *))
{
env_->set_errcall(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)
int Db::set_paniccall(void (*callback)(DbEnv *, int))
{
return (env_->set_paniccall(callback));
}
void Db::set_error_stream(__DB_OSTREAMCLASS *error_stream)
{
env_->set_error_stream(error_stream);
}