ag/cpython-source-deps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import BSDDB 4.7.25 (as of svn r89086)

Browse Source
This commit is contained in:
Zachary Ware
2017-09-04 13:40:25 -05:00
parent 4b29e0458f
commit 8f590873d0
4781 changed files with 2241032 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

668
cxx/cxx_db.cpp Normal file
View File

@@ -0,0 +1,668 @@
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1997,2008 Oracle. All rights reserved.
*
* $Id: cxx_db.cpp 63573 2008-05-23 21:43:21Z trent.nelson $
*/
#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)
, bt_compare_callback_(0)
, bt_prefix_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)); \
}
/* 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));
}
DB_CALLBACK_C_INTERCEPT(feedback,
void, (DB *cthis, int opcode, int pct),
/* no return */ (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_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_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_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_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(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 DbEnv *, const char *, const char *))
{
dbenv_->set_errcall(arg);
}
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)
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))

121
cxx/cxx_dbc.cpp Normal file
View File

@@ -0,0 +1,121 @@
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1997,2008 Oracle. All rights reserved.
*
* $Id: cxx_dbc.cpp 63573 2008-05-23 21:43:21Z trent.nelson $
*/
#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(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)

56
cxx/cxx_dbt.cpp Normal file
View File

@@ -0,0 +1,56 @@
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1997,2008 Oracle. All rights reserved.
*
* $Id: cxx_dbt.cpp 63573 2008-05-23 21:43:21Z trent.nelson $
*/
#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);
}

1139
cxx/cxx_env.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

356
cxx/cxx_except.cpp Normal file
View File

@@ -0,0 +1,356 @@
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1997,2008 Oracle. All rights reserved.
*
* $Id: cxx_except.cpp 63573 2008-05-23 21:43:21Z trent.nelson $
*/
#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);
}

41
cxx/cxx_lock.cpp Normal file
View File

@@ -0,0 +1,41 @@
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1997,2008 Oracle. All rights reserved.
*
* $Id: cxx_lock.cpp 63573 2008-05-23 21:43:21Z trent.nelson $
*/
#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);
}

78
cxx/cxx_logc.cpp Normal file
View File

@@ -0,0 +1,78 @@
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1997,2008 Oracle. All rights reserved.
*
* $Id: cxx_logc.cpp 63573 2008-05-23 21:43:21Z trent.nelson $
*/
#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);
}

128
cxx/cxx_mpool.cpp Normal file
View File

@@ -0,0 +1,128 @@
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1997,2008 Oracle. All rights reserved.
*
* $Id: cxx_mpool.cpp 63573 2008-05-23 21:43:21Z trent.nelson $
*/
#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)

66
cxx/cxx_multi.cpp Normal file
View File

@@ -0,0 +1,66 @@
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1997,2008 Oracle. All rights reserved.
*
* $Id: cxx_multi.cpp 63573 2008-05-23 21:43:21Z trent.nelson $
*/
#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);
}

109
cxx/cxx_seq.cpp Normal file
View File

@@ -0,0 +1,109 @@
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1997,2008 Oracle. All rights reserved.
*
* $Id: cxx_seq.cpp 63573 2008-05-23 21:43:21Z trent.nelson $
*/
#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);
}

79
cxx/cxx_txn.cpp Normal file
View File

@@ -0,0 +1,79 @@
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1997,2008 Oracle. All rights reserved.
*
* $Id: cxx_txn.cpp 63573 2008-05-23 21:43:21Z trent.nelson $
*/
#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) \
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()
: imp_(0)
{
}
DbTxn::DbTxn(DB_TXN *txn)
: imp_(txn)
{
txn->api_internal = this;
}
DbTxn::~DbTxn()
{
}
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))
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);
return (wrapped_txn != NULL) ? wrapped_txn : new DbTxn(txn);
}