BerkeleyDB
view release on metacpan or search on metacpan
BerkeleyDB.xs view on Meta::CPAN
char *re_source;
#define DB_DELIMITER 0x0001
#define DB_FIXEDLEN 0x0008
#define DB_PAD 0x0010
u_int32_t flags;
u_int32_t q_extentsize;
u_int32_t heapsize_gbytes;
u_int32_t heapsize_bytes;
u_int32_t blob_threshold;
char *blob_dir;
} DB_INFO ;
#endif /* DB_VERSION_MAJOR > 2 */
typedef struct {
int Status ;
/* char ErrBuff[1000] ; */
SV * ErrPrefix ;
SV * ErrHandle ;
#ifdef AT_LEAST_DB_4_3
SV * MsgHandle ;
#endif
DB_ENV * Env ;
int open_dbs ;
int TxnMgrStatus ;
int active ;
bool txn_enabled ;
bool opened ;
bool cds_enabled;
} BerkeleyDB_ENV_type ;
typedef struct {
DBTYPE type ;
bool recno_or_queue ;
char * filename ;
BerkeleyDB_ENV_type * parent_env ;
DB * dbp ;
SV * compare ;
bool in_compare ;
SV * dup_compare ;
bool in_dup_compare ;
SV * prefix ;
bool in_prefix ;
SV * hash ;
bool in_hash ;
#ifdef AT_LEAST_DB_3_3
SV * associated ;
bool secondary_db ;
#endif
#ifdef AT_LEAST_DB_4_8
SV * associated_foreign ;
SV * bt_compress ;
SV * bt_uncompress ;
#endif
bool primary_recno_or_queue ;
int Status ;
DB_INFO * info ;
DBC * cursor ;
DB_TXN * txn ;
int open_cursors ;
#ifdef AT_LEAST_DB_4_3
int open_sequences ;
#endif
u_int32_t partial ;
u_int32_t dlen ;
u_int32_t doff ;
int active ;
bool cds_enabled;
#ifdef ALLOW_RECNO_OFFSET
int array_base ;
#endif
#ifdef DBM_FILTERING
SV * filter_fetch_key ;
SV * filter_store_key ;
SV * filter_fetch_value ;
SV * filter_store_value ;
int filtering ;
#endif
} BerkeleyDB_type;
typedef struct {
DBTYPE type ;
bool recno_or_queue ;
char * filename ;
DB * dbp ;
SV * compare ;
SV * dup_compare ;
SV * prefix ;
SV * hash ;
#ifdef AT_LEAST_DB_3_3
SV * associated ;
bool secondary_db ;
#endif
#ifdef AT_LEAST_DB_4_8
SV * associated_foreign ;
#endif
bool primary_recno_or_queue ;
int Status ;
DB_INFO * info ;
DBC * cursor ;
DB_TXN * txn ;
BerkeleyDB_type * parent_db ;
u_int32_t partial ;
u_int32_t dlen ;
u_int32_t doff ;
int active ;
bool cds_enabled;
#ifdef ALLOW_RECNO_OFFSET
int array_base ;
#endif
#ifdef DBM_FILTERING
SV * filter_fetch_key ;
SV * filter_store_key ;
SV * filter_fetch_value ;
SV * filter_store_value ;
int filtering ;
#endif
} BerkeleyDB_Cursor_type;
typedef struct {
int Status ;
#ifdef AT_LEAST_DB_6_0
DB_STREAM * stream ;
#endif
int active ;
u_int32_t partial ;
u_int32_t dlen ;
u_int32_t doff ;
#ifdef DBM_FILTERING
SV * filter_fetch_key ;
SV * filter_store_key ;
SV * filter_fetch_value ;
SV * filter_store_value ;
int filtering ;
#endif
} BerkeleyDB_DbStream_type ;
typedef struct {
BerkeleyDB_ENV_type * env ;
} BerkeleyDB_TxnMgr_type ;
#if 1
typedef struct {
int Status ;
DB_TXN * txn ;
int active ;
} BerkeleyDB_Txn_type ;
#else
typedef DB_TXN BerkeleyDB_Txn_type ;
#endif
#ifdef AT_LEAST_DB_4_3
typedef struct {
int active;
BerkeleyDB_type *db;
DB_SEQUENCE *seq;
} BerkeleyDB_Sequence_type;
#else
typedef int BerkeleyDB_Sequence_type;
typedef SV* db_seq_t;
BerkeleyDB.xs view on Meta::CPAN
{
BerkeleyDB__Txn__Raw tid ;
HE * he ;
I32 len ;
HV * hv = perl_get_hv("BerkeleyDB::Term::Txn", TRUE);
int all = 0 ;
int closed = 0 ;
(void)hv_iterinit(hv) ;
Trace(("BerkeleyDB::Term::close_all_txns dirty=%d\n", PL_dirty)) ;
while ( (he = hv_iternext(hv)) ) {
tid = * (BerkeleyDB__Txn__Raw *) hv_iterkey(he, &len) ;
Trace((" Aborting Transaction [%p] in [%p] Active [%d]\n", tid->txn, tid, tid->active));
if (tid->active) {
#ifdef AT_LEAST_DB_4
tid->txn->abort(tid->txn) ;
#else
txn_abort(tid->txn);
#endif
++ closed ;
}
tid->active = FALSE ;
++ all ;
}
Trace(("End of BerkeleyDB::Term::close_all_txns aborted %d of %d transactios\n",closed, all)) ;
}
#ifdef AT_LEAST_DB_6_0
/* Close All DB_STREAM */
{
BerkeleyDB__DbStream db ;
HE * he ;
I32 len ;
HV * hv = perl_get_hv("BerkeleyDB::Term::DbStream", TRUE);
int all = 0 ;
int closed = 0 ;
(void) hv_iterinit(hv) ;
Trace(("BerkeleyDB::DbStream::close_all_dbstream \n")) ;
while ( (he = hv_iternext(hv)) ) {
db = * (BerkeleyDB__DbStream*) hv_iterkey(he, &len) ;
Trace((" Closing DbStream [%p] in [%p] Active [%d]\n", db->stream, db, db->active));
if (db->active) {
(db->stream->close)(db->stream, 0);
++ closed ;
}
db->active = FALSE ;
++ all ;
}
Trace(("End of BerkeleyDB::Term::close_all_dbstream closed %d of %d streams\n",closed, all)) ;
}
#endif
/* Close All Cursors */
{
BerkeleyDB__Cursor db ;
HE * he ;
I32 len ;
HV * hv = perl_get_hv("BerkeleyDB::Term::Cursor", TRUE);
int all = 0 ;
int closed = 0 ;
(void) hv_iterinit(hv) ;
Trace(("BerkeleyDB::Term::close_all_cursors \n")) ;
while ( (he = hv_iternext(hv)) ) {
db = * (BerkeleyDB__Cursor*) hv_iterkey(he, &len) ;
Trace((" Closing Cursor [%p] in [%p] Active [%d]\n", db->cursor, db, db->active));
if (db->active) {
((db->cursor)->c_close)(db->cursor) ;
++ closed ;
}
db->active = FALSE ;
++ all ;
}
Trace(("End of BerkeleyDB::Term::close_all_cursors closed %d of %d cursors\n",closed, all)) ;
}
/* Close All Databases */
{
BerkeleyDB db ;
HE * he ;
I32 len ;
HV * hv = perl_get_hv("BerkeleyDB::Term::Db", TRUE);
int all = 0 ;
int closed = 0 ;
(void)hv_iterinit(hv) ;
Trace(("BerkeleyDB::Term::close_all_dbs\n" )) ;
while ( (he = hv_iternext(hv)) ) {
db = * (BerkeleyDB*) hv_iterkey(he, &len) ;
Trace((" Closing Database [%p] in [%p] Active [%d]\n", db->dbp, db, db->active));
if (db->active) {
(db->dbp->close)(db->dbp, 0) ;
++ closed ;
}
db->active = FALSE ;
++ all ;
}
Trace(("End of BerkeleyDB::Term::close_all_dbs closed %d of %d dbs\n",closed, all)) ;
}
/* Close All Environments */
{
BerkeleyDB__Env env ;
HE * he ;
I32 len ;
HV * hv = perl_get_hv("BerkeleyDB::Term::Env", TRUE);
int all = 0 ;
int closed = 0 ;
(void)hv_iterinit(hv) ;
Trace(("BerkeleyDB::Term::close_all_envs\n")) ;
while ( (he = hv_iternext(hv)) ) {
env = * (BerkeleyDB__Env*) hv_iterkey(he, &len) ;
Trace((" Closing Environment [%p] in [%p] Active [%d]\n", env->Env, env, env->active));
if (env->active) {
#if DB_VERSION_MAJOR == 2
db_appexit(env->Env) ;
#else
(env->Env->close)(env->Env, 0) ;
#endif
++ closed ;
}
env->active = FALSE ;
++ all ;
}
Trace(("End of BerkeleyDB::Term::close_all_envs closed %d of %d dbs\n",closed, all)) ;
}
Trace(("end close_everything\n")) ;
}
static void
destroyDB(BerkeleyDB db)
{
#ifdef dTHX
dTHX;
#endif
if (! PL_dirty && db->active) {
if (db->parent_env && db->parent_env->open_dbs)
-- db->parent_env->open_dbs ;
-- db->open_cursors ;
((db->dbp)->close)(db->dbp, 0) ;
}
if (db->hash)
SvREFCNT_dec(db->hash) ;
if (db->compare)
SvREFCNT_dec(db->compare) ;
if (db->dup_compare)
SvREFCNT_dec(db->dup_compare) ;
#ifdef AT_LEAST_DB_3_3
if (db->associated && !db->secondary_db)
SvREFCNT_dec(db->associated) ;
#endif
#ifdef AT_LEAST_DB_4_8
if (db->associated_foreign)
SvREFCNT_dec(db->associated_foreign) ;
#endif
if (db->prefix)
SvREFCNT_dec(db->prefix) ;
#ifdef DBM_FILTERING
if (db->filter_fetch_key)
SvREFCNT_dec(db->filter_fetch_key) ;
if (db->filter_store_key)
SvREFCNT_dec(db->filter_store_key) ;
if (db->filter_fetch_value)
SvREFCNT_dec(db->filter_fetch_value) ;
if (db->filter_store_value)
SvREFCNT_dec(db->filter_store_value) ;
#endif
hash_delete("BerkeleyDB::Term::Db", (char *)db) ;
if (db->filename)
Safefree(db->filename) ;
Safefree(db) ;
}
static int
softCrash(const char *pat, ...)
{
char buffer1 [500] ;
char buffer2 [500] ;
va_list args;
va_start(args, pat);
Trace(("softCrash: %s\n", pat)) ;
#define ABORT_PREFIX "BerkeleyDB Aborting: "
/* buffer = (char*) safemalloc(strlen(pat) + strlen(ABORT_PREFIX) + 1) ; */
strcpy(buffer1, ABORT_PREFIX) ;
strcat(buffer1, pat) ;
vsprintf(buffer2, buffer1, args) ;
/* Silence warning if -Werror=format-security enabled */
croak("%s", buffer2);
/* NOTREACHED */
va_end(args);
return 1 ;
}
static I32
GetArrayLength(BerkeleyDB db)
{
I32 RETVAL = 0 ;
#ifndef AT_LEAST_DB_3_1
DBT key ;
DBT value ;
DBC * cursor ;
DBT_clear(key) ;
DBT_clear(value) ;
#if DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 6
if ( ((db->dbp)->cursor)(db->dbp, db->txn, &cursor) == 0 )
#else
if ( ((db->dbp)->cursor)(db->dbp, db->txn, &cursor, 0) == 0 )
#endif
{
RETVAL = cursor->c_get(cursor, &key, &value, DB_LAST) ;
if (RETVAL == 0)
RETVAL = *(I32 *)key.data ;
else /* No key means empty file */
RETVAL = 0 ;
cursor->c_close(cursor) ;
}
Trace(("GetArrayLength got %d\n", RETVAL)) ;
return ((I32)RETVAL) ;
#else
DB_BTREE_STAT * stat ;
#ifdef AT_LEAST_DB_4_3
db->Status = ((db->dbp)->stat)(db->dbp, db->txn, &stat, 0) ;
#else
#ifdef AT_LEAST_DB_3_3
db->Status = ((db->dbp)->stat)(db->dbp, &stat, 0) ;
#else
db->Status = ((db->dbp)->stat)(db->dbp, &stat, safemalloc, 0) ;
#endif
#endif
if (db->Status == 0)
{
RETVAL = (I32)stat->bt_nkeys ;
}
Trace(("GetArrayLength got %d\n", stat->bt_nkeys)) ;
return (RETVAL);
#endif
}
static I32
GetQueueLength(BerkeleyDB db)
{
#ifndef AT_LEAST_DB_3_3
return 0;
#else
I32 RETVAL = 0 ;
DB_QUEUE_STAT * stat ;
#ifdef AT_LEAST_DB_4_3
db->Status = ((db->dbp)->stat)(db->dbp, db->txn, &stat, 0) ;
#else
#ifdef AT_LEAST_DB_3_3
db->Status = ((db->dbp)->stat)(db->dbp, &stat, 0) ;
#else
db->Status = ((db->dbp)->stat)(db->dbp, &stat, safemalloc, 0) ;
#endif
#endif
if (db->Status == 0)
{
RETVAL = (I32)stat->qs_nkeys ;
}
Trace(("GetQueueLength got %d\n", stat->qs_nkeys)) ;
return (RETVAL);
#endif
}
#if 0
#define GetRecnoKey(db, value) _GetRecnoKey(db, value)
static db_recno_t
_GetRecnoKey(BerkeleyDB db, I32 value)
{
BerkeleyDB.xs view on Meta::CPAN
DB_QUEUE_STAT * stat ;
#ifdef AT_LEAST_DB_4_3
db->Status = ((db->dbp)->stat)(db->dbp, db->txn, &stat, flags) ;
#else
#ifdef AT_LEAST_DB_3_3
db->Status = ((db->dbp)->stat)(db->dbp, &stat, flags) ;
#else
db->Status = ((db->dbp)->stat)(db->dbp, &stat, safemalloc, flags) ;
#endif
#endif
if (db->Status) {
XSRETURN_UNDEF;
} else {
RETVAL = (HV*)sv_2mortal((SV*)newHV()) ;
hv_store_iv(RETVAL, "qs_magic", stat->qs_magic) ;
hv_store_iv(RETVAL, "qs_version", stat->qs_version);
#ifdef AT_LEAST_DB_3_1
hv_store_iv(RETVAL, "qs_nkeys", stat->qs_nkeys);
hv_store_iv(RETVAL, "qs_ndata", stat->qs_ndata);
#else
hv_store_iv(RETVAL, "qs_nrecs", stat->qs_nrecs);
#endif
hv_store_iv(RETVAL, "qs_pages", stat->qs_pages);
hv_store_iv(RETVAL, "qs_pagesize", stat->qs_pagesize);
hv_store_iv(RETVAL, "qs_pgfree", stat->qs_pgfree);
hv_store_iv(RETVAL, "qs_re_len", stat->qs_re_len);
hv_store_iv(RETVAL, "qs_re_pad", stat->qs_re_pad);
#ifdef AT_LEAST_DB_3_2
#else
hv_store_iv(RETVAL, "qs_start", stat->qs_start);
#endif
hv_store_iv(RETVAL, "qs_first_recno", stat->qs_first_recno);
hv_store_iv(RETVAL, "qs_cur_recno", stat->qs_cur_recno);
#if DB_VERSION_MAJOR >= 3
hv_store_iv(RETVAL, "qs_metaflags", stat->qs_metaflags);
#endif
safefree(stat) ;
}
#endif
}
OUTPUT:
RETVAL
MODULE = BerkeleyDB::Common PACKAGE = BerkeleyDB::Common PREFIX = dab_
DualType
db_close(db,flags=0)
int flags
BerkeleyDB::Common db
PREINIT:
dMY_CXT;
INIT:
ckActive_Database(db->active) ;
saveCurrentDB(db) ;
CODE:
Trace(("BerkeleyDB::Common::db_close %p\n", db));
#ifdef STRICT_CLOSE
if (db->txn)
softCrash("attempted to close a database while a transaction was still open") ;
if (db->open_cursors)
softCrash("attempted to close a database with %d open cursor(s)",
db->open_cursors) ;
#ifdef AT_LEAST_DB_4_3
if (db->open_sequences)
softCrash("attempted to close a database with %d open sequence(s)",
db->open_sequences) ;
#endif /* AT_LEAST_DB_4_3 */
#endif /* STRICT_CLOSE */
RETVAL = db->Status = ((db->dbp)->close)(db->dbp, flags) ;
if (db->parent_env && db->parent_env->open_dbs)
-- db->parent_env->open_dbs ;
db->active = FALSE ;
hash_delete("BerkeleyDB::Term::Db", (char *)db) ;
-- db->open_cursors ;
Trace(("end of BerkeleyDB::Common::db_close\n"));
OUTPUT:
RETVAL
void
dab__DESTROY(db)
BerkeleyDB::Common db
PREINIT:
dMY_CXT;
CODE:
saveCurrentDB(db) ;
Trace(("In BerkeleyDB::Common::_DESTROY db %p dirty=%d\n", db, PL_dirty)) ;
destroyDB(db) ;
Trace(("End of BerkeleyDB::Common::DESTROY \n")) ;
#if DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 6
#define db_cursor(db, txn, cur,flags) ((db->dbp)->cursor)(db->dbp, txn, cur)
#else
#define db_cursor(db, txn, cur,flags) ((db->dbp)->cursor)(db->dbp, txn, cur,flags)
#endif
BerkeleyDB::Cursor::Raw
_db_cursor(db, flags=0)
u_int32_t flags
BerkeleyDB::Common db
BerkeleyDB::Cursor RETVAL = NULL ;
PREINIT:
dMY_CXT;
ALIAS: __db_write_cursor = 1
INIT:
ckActive_Database(db->active) ;
CODE:
{
DBC * cursor ;
saveCurrentDB(db) ;
if (ix == 1 && db->cds_enabled) {
#ifdef AT_LEAST_DB_3
flags |= DB_WRITECURSOR;
#else
flags |= DB_RMW;
#endif
}
if ((db->Status = db_cursor(db, db->txn, &cursor, flags)) == 0){
ZMALLOC(RETVAL, BerkeleyDB__Cursor_type) ;
db->open_cursors ++ ;
RETVAL->parent_db = db ;
RETVAL->cursor = cursor ;
RETVAL->dbp = db->dbp ;
RETVAL->txn = db->txn ;
RETVAL->type = db->type ;
RETVAL->recno_or_queue = db->recno_or_queue ;
RETVAL->cds_enabled = db->cds_enabled ;
RETVAL->filename = my_strdup(db->filename) ;
RETVAL->compare = db->compare ;
RETVAL->dup_compare = db->dup_compare ;
#ifdef AT_LEAST_DB_3_3
RETVAL->associated = db->associated ;
RETVAL->secondary_db = db->secondary_db;
RETVAL->primary_recno_or_queue = db->primary_recno_or_queue ;
#endif
#ifdef AT_LEAST_DB_4_8
RETVAL->associated_foreign = db->associated_foreign ;
#endif
RETVAL->prefix = db->prefix ;
RETVAL->hash = db->hash ;
RETVAL->partial = db->partial ;
RETVAL->doff = db->doff ;
RETVAL->dlen = db->dlen ;
RETVAL->active = TRUE ;
#ifdef ALLOW_RECNO_OFFSET
RETVAL->array_base = db->array_base ;
#endif /* ALLOW_RECNO_OFFSET */
#ifdef DBM_FILTERING
RETVAL->filtering = FALSE ;
RETVAL->filter_fetch_key = db->filter_fetch_key ;
RETVAL->filter_store_key = db->filter_store_key ;
RETVAL->filter_fetch_value = db->filter_fetch_value ;
RETVAL->filter_store_value = db->filter_store_value ;
#endif
/* RETVAL->info ; */
hash_store_iv("BerkeleyDB::Term::Cursor", (char *)RETVAL, 1) ;
}
}
OUTPUT:
RETVAL
BerkeleyDB::Cursor::Raw
_db_join(db, cursors, flags=0)
u_int32_t flags
BerkeleyDB::Common db
AV * cursors
BerkeleyDB::Cursor RETVAL = NULL ;
PREINIT:
dMY_CXT;
INIT:
ckActive_Database(db->active) ;
CODE:
{
#if DB_VERSION_MAJOR == 2 && (DB_VERSION_MINOR < 5 || (DB_VERSION_MINOR == 5 && DB_VERSION_PATCH < 2))
softCrash("join needs Berkeley DB 2.5.2 or later") ;
#else /* Berkeley DB >= 2.5.2 */
DBC * join_cursor ;
DBC ** cursor_list ;
I32 count = av_len(cursors) + 1 ;
int i ;
saveCurrentDB(db) ;
if (count < 1 )
softCrash("db_join: No cursors in parameter list") ;
cursor_list = (DBC **)safemalloc(sizeof(DBC*) * (count + 1));
for (i = 0 ; i < count ; ++i) {
SV * obj = (SV*) * av_fetch(cursors, i, FALSE) ;
IV tmp = SvIV(getInnerObject(obj)) ;
BerkeleyDB__Cursor cur = INT2PTR(BerkeleyDB__Cursor, tmp);
if (cur->dbp == db->dbp)
softCrash("attempted to do a self-join");
cursor_list[i] = cur->cursor ;
}
cursor_list[i] = NULL ;
#if DB_VERSION_MAJOR == 2
if ((db->Status = ((db->dbp)->join)(db->dbp, cursor_list, flags, &join_cursor)) == 0){
#else
if ((db->Status = ((db->dbp)->join)(db->dbp, cursor_list, &join_cursor, flags)) == 0){
#endif
ZMALLOC(RETVAL, BerkeleyDB__Cursor_type) ;
db->open_cursors ++ ;
RETVAL->parent_db = db ;
RETVAL->cursor = join_cursor ;
RETVAL->dbp = db->dbp ;
RETVAL->type = db->type ;
RETVAL->filename = my_strdup(db->filename) ;
RETVAL->compare = db->compare ;
RETVAL->dup_compare = db->dup_compare ;
#ifdef AT_LEAST_DB_3_3
RETVAL->associated = db->associated ;
RETVAL->secondary_db = db->secondary_db;
RETVAL->primary_recno_or_queue = db->primary_recno_or_queue ;
#endif
#ifdef AT_LEAST_DB_4_8
RETVAL->associated_foreign = db->associated_foreign ;
#endif
RETVAL->prefix = db->prefix ;
RETVAL->hash = db->hash ;
RETVAL->partial = db->partial ;
RETVAL->doff = db->doff ;
RETVAL->dlen = db->dlen ;
RETVAL->active = TRUE ;
#ifdef ALLOW_RECNO_OFFSET
RETVAL->array_base = db->array_base ;
#endif /* ALLOW_RECNO_OFFSET */
#ifdef DBM_FILTERING
RETVAL->filtering = FALSE ;
RETVAL->filter_fetch_key = db->filter_fetch_key ;
RETVAL->filter_store_key = db->filter_store_key ;
RETVAL->filter_fetch_value = db->filter_fetch_value ;
RETVAL->filter_store_value = db->filter_store_value ;
#endif
/* RETVAL->info ; */
hash_store_iv("BerkeleyDB::Term::Cursor", (char *)RETVAL, 1) ;
}
safefree(cursor_list) ;
#endif /* Berkeley DB >= 2.5.2 */
}
OUTPUT:
RETVAL
int
ArrayOffset(db)
BerkeleyDB::Common db
PREINIT:
dMY_CXT;
INIT:
ckActive_Database(db->active) ;
CODE:
#ifdef ALLOW_RECNO_OFFSET
RETVAL = db->array_base ? 0 : 1 ;
#else
RETVAL = 0 ;
#endif /* ALLOW_RECNO_OFFSET */
OUTPUT:
RETVAL
bool
cds_enabled(db)
BerkeleyDB::Common db
PREINIT:
dMY_CXT;
INIT:
ckActive_Database(db->active) ;
CODE:
RETVAL = db->cds_enabled ;
OUTPUT:
RETVAL
int
stat_print(db, flags=0)
BerkeleyDB::Common db
u_int32_t flags
INIT:
ckActive_Database(db->active) ;
CODE:
#ifndef AT_LEAST_DB_4_3
softCrash("$db->stat_print needs Berkeley DB 4.3 or better") ;
#else
RETVAL = db->dbp->stat_print(db->dbp, flags);
#endif
OUTPUT:
RETVAL
int
type(db)
BerkeleyDB::Common db
PREINIT:
dMY_CXT;
INIT:
ckActive_Database(db->active) ;
CODE:
RETVAL = db->type ;
BerkeleyDB.xs view on Meta::CPAN
hv_store_iv(hash, "compact_pages_examine", cmpt.compact_pages_examine) ;
hv_store_iv(hash, "compact_pages_truncated", cmpt.compact_pages_truncated) ;
}
#endif
}
OUTPUT:
RETVAL
end if (RETVAL == 0 && end) OutputValue_B(ST(5), end_key) ;
DualType
get_blob_threshold(db, bytes)
BerkeleyDB::Common db
u_int32_t bytes = NO_INIT
PREINIT:
dMY_CXT;
CODE:
#ifndef AT_LEAST_DB_6_0
softCrash("$db->get_blob_threshold needs Berkeley DB 6.0 or better") ;
#else
RETVAL = db->dbp->get_blob_threshold(db->dbp, &bytes);
#endif
OUTPUT:
RETVAL
bytes
DualType
get_blob_dir(db, dir)
BerkeleyDB::Common db
char* dir = NO_INIT
PREINIT:
dMY_CXT;
CODE:
#ifndef AT_LEAST_DB_6_0
softCrash("$db->get_blob_dir needs Berkeley DB 6.0 or better") ;
#else
RETVAL = db->dbp->get_blob_dir(db->dbp, (const char**)&dir);
#endif
OUTPUT:
RETVAL
dir
MODULE = BerkeleyDB::Cursor PACKAGE = BerkeleyDB::Cursor PREFIX = cu_
BerkeleyDB::Cursor::Raw
_c_dup(db, flags=0)
u_int32_t flags
BerkeleyDB::Cursor db
BerkeleyDB::Cursor RETVAL = NULL ;
PREINIT:
dMY_CXT;
INIT:
saveCurrentDB(db->parent_db);
ckActive_Database(db->active) ;
CODE:
{
#ifndef AT_LEAST_DB_3
softCrash("c_dup needs at least Berkeley DB 3.0.x");
#else
DBC * newcursor ;
db->Status = ((db->cursor)->c_dup)(db->cursor, &newcursor, flags) ;
if (db->Status == 0){
ZMALLOC(RETVAL, BerkeleyDB__Cursor_type) ;
db->parent_db->open_cursors ++ ;
RETVAL->parent_db = db->parent_db ;
RETVAL->cursor = newcursor ;
RETVAL->dbp = db->dbp ;
RETVAL->type = db->type ;
RETVAL->recno_or_queue = db->recno_or_queue ;
RETVAL->primary_recno_or_queue = db->primary_recno_or_queue ;
RETVAL->cds_enabled = db->cds_enabled ;
RETVAL->filename = my_strdup(db->filename) ;
RETVAL->compare = db->compare ;
RETVAL->dup_compare = db->dup_compare ;
#ifdef AT_LEAST_DB_3_3
RETVAL->associated = db->associated ;
#endif
#ifdef AT_LEAST_DB_4_8
RETVAL->associated_foreign = db->associated_foreign ;
#endif
RETVAL->prefix = db->prefix ;
RETVAL->hash = db->hash ;
RETVAL->partial = db->partial ;
RETVAL->doff = db->doff ;
RETVAL->dlen = db->dlen ;
RETVAL->active = TRUE ;
#ifdef ALLOW_RECNO_OFFSET
RETVAL->array_base = db->array_base ;
#endif /* ALLOW_RECNO_OFFSET */
#ifdef DBM_FILTERING
RETVAL->filtering = FALSE ;
RETVAL->filter_fetch_key = db->filter_fetch_key ;
RETVAL->filter_store_key = db->filter_store_key ;
RETVAL->filter_fetch_value = db->filter_fetch_value ;
RETVAL->filter_store_value = db->filter_store_value ;
#endif /* DBM_FILTERING */
/* RETVAL->info ; */
hash_store_iv("BerkeleyDB::Term::Cursor", (char *)RETVAL, 1) ;
}
#endif
}
OUTPUT:
RETVAL
DualType
_c_close(db)
BerkeleyDB::Cursor db
PREINIT:
dMY_CXT;
INIT:
saveCurrentDB(db->parent_db);
ckActive_Cursor(db->active) ;
hash_delete("BerkeleyDB::Term::Cursor", (char *)db) ;
CODE:
RETVAL = db->Status =
((db->cursor)->c_close)(db->cursor) ;
db->active = FALSE ;
if (db->parent_db->open_cursors)
-- db->parent_db->open_cursors ;
OUTPUT:
RETVAL
void
_DESTROY(db)
BerkeleyDB::Cursor db
PREINIT:
dMY_CXT;
CODE:
saveCurrentDB(db->parent_db);
Trace(("In BerkeleyDB::Cursor::_DESTROY db %p dirty=%d active=%d\n", db, PL_dirty, db->active));
hash_delete("BerkeleyDB::Term::Cursor", (char *)db) ;
if (db->active)
((db->cursor)->c_close)(db->cursor) ;
if (db->parent_db->open_cursors)
-- db->parent_db->open_cursors ;
Safefree(db->filename) ;
Safefree(db) ;
Trace(("End of BerkeleyDB::Cursor::_DESTROY\n")) ;
DualType
status(db)
BerkeleyDB::Cursor db
PREINIT:
dMY_CXT;
CODE:
RETVAL = db->Status ;
OUTPUT:
RETVAL
#define cu_c_del(c,f) (c->Status = ((c->cursor)->c_del)(c->cursor,f))
DualType
cu_c_del(db, flags=0)
int flags
BerkeleyDB::Cursor db
PREINIT:
dMY_CXT;
INIT:
saveCurrentDB(db->parent_db);
ckActive_Cursor(db->active) ;
OUTPUT:
RETVAL
#define cu_c_get(c,k,d,f) (c->Status = (c->cursor->c_get)(c->cursor,&k,&d,f))
DualType
cu_c_get(db, key, data, flags=0)
int flags
BerkeleyDB::Cursor db
DBTKEY_B key
DBT_B data
PREINIT:
dMY_CXT;
INIT:
Trace(("c_get db [%p] in [%p] flags [%d]\n", db->dbp, db, flags)) ;
saveCurrentDB(db->parent_db);
ckActive_Cursor(db->active) ;
/* DBT_clear(key); */
/* DBT_clear(data); */
SetPartial(data,db) ;
Trace(("c_get end\n")) ;
OUTPUT:
RETVAL
key
data if (! flagSet(DB_JOIN_ITEM)) OutputValue_B(ST(2), data) ;
#define cu_c_pget(c,k,p,d,f) (c->Status = (c->secondary_db ? (c->cursor->c_pget)(c->cursor,&k,&p,&d,f) : EINVAL))
DualType
cu_c_pget(db, key, pkey, data, flags=0)
int flags
BerkeleyDB::Cursor db
DBTKEY_B key
DBTKEY_Bpr pkey
DBT_B data
PREINIT:
dMY_CXT;
CODE:
#ifndef AT_LEAST_DB_3_3
softCrash("db_c_pget needs at least Berkeley DB 3.3");
#else
Trace(("c_pget db [%p] flags [%d]\n", db, flags)) ;
saveCurrentDB(db->parent_db);
ckActive_Cursor(db->active) ;
SetPartial(data,db) ;
RETVAL = cu_c_pget(db, key, pkey, data, flags);
Trace(("c_pget end\n")) ;
#endif
OUTPUT:
RETVAL
key if (writeToKey()) OutputKey(ST(1), key) ;
pkey
data
#define cu_c_put(c,k,d,f) (c->Status = (c->cursor->c_put)(c->cursor,&k,&d,f))
DualType
cu_c_put(db, key, data, flags=0)
int flags
BerkeleyDB::Cursor db
DBTKEY key
DBT data
PREINIT:
dMY_CXT;
INIT:
saveCurrentDB(db->parent_db);
ckActive_Cursor(db->active) ;
/* SetPartial(data,db) ; */
OUTPUT:
RETVAL
#define cu_c_count(c,p,f) (c->Status = (c->cursor->c_count)(c->cursor,&p,f))
DualType
cu_c_count(db, count, flags=0)
int flags
BerkeleyDB::Cursor db
u_int32_t count = NO_INIT
PREINIT:
dMY_CXT;
CODE:
#ifndef AT_LEAST_DB_3_1
softCrash("c_count needs at least Berkeley DB 3.1.x");
#else
Trace(("c_get count [%p] flags [%d]\n", db, flags)) ;
saveCurrentDB(db->parent_db);
ckActive_Cursor(db->active) ;
RETVAL = cu_c_count(db, count, flags) ;
Trace((" c_count got %d duplicates\n", count)) ;
#endif
OUTPUT:
RETVAL
count
void
partial_set(db, offset, length)
BerkeleyDB::Cursor db
u_int32_t offset
u_int32_t length
PREINIT:
dMY_CXT;
INIT:
ckActive_Cursor(db->active) ;
PPCODE:
if (GIMME_V == G_ARRAY) {
XPUSHs(sv_2mortal(newSViv(db->partial == DB_DBT_PARTIAL))) ;
XPUSHs(sv_2mortal(newSViv(db->doff))) ;
XPUSHs(sv_2mortal(newSViv(db->dlen))) ;
}
db->partial = DB_DBT_PARTIAL ;
db->doff = offset ;
db->dlen = length ;
void
partial_clear(db)
BerkeleyDB::Cursor db
PREINIT:
dMY_CXT;
INIT:
ckActive_Cursor(db->active) ;
PPCODE:
if (GIMME_V == G_ARRAY) {
XPUSHs(sv_2mortal(newSViv(db->partial == DB_DBT_PARTIAL))) ;
XPUSHs(sv_2mortal(newSViv(db->doff))) ;
XPUSHs(sv_2mortal(newSViv(db->dlen))) ;
}
db->partial =
db->doff =
db->dlen = 0 ;
BerkeleyDB::DbStream::Raw
_db_stream(db, flags)
BerkeleyDB::Cursor db
u_int32_t flags
BerkeleyDB::DbStream RETVAL = NULL ;
PREINIT:
dMY_CXT;
INIT:
saveCurrentDB(db->parent_db);
ckActive_Cursor(db->active) ;
CODE:
{
#ifndef AT_LEAST_DB_6_0
softCrash("db_stream needs at least Berkeley DB 6.0.x");
#else
DB_STREAM * stream = NULL ;
db->Status = ((db->cursor)->db_stream)(db->cursor, &stream, flags) ;
if (db->Status == 0){
ZMALLOC(RETVAL, BerkeleyDB__DbStream_type) ;
RETVAL->stream = stream ;
RETVAL->active = TRUE ;
hash_store_iv("BerkeleyDB::Term::DbStream", (char *)RETVAL, 1) ;
}
else
{
Trace(("db_stream [%s]\n", my_db_strerror(db->Status)));
}
#endif
}
OUTPUT:
RETVAL
BerkeleyDB::DbStream::Raw
_c_get_db_stream(db, key, cflags, sflags)
BerkeleyDB::Cursor db
DBTKEY_B4Blob key
u_int32_t cflags
u_int32_t sflags
BerkeleyDB::DbStream RETVAL = NULL ;
PREINIT:
dMY_CXT;
INIT:
saveCurrentDB(db->parent_db);
ckActive_Cursor(db->active) ;
CODE:
{
#ifndef AT_LEAST_DB_6_0
softCrash("db_stream needs at least Berkeley DB 6.0.x");
#else
DBT data;
DB_STREAM * stream = NULL ;
DBT_clear(data);
data.flags = DB_DBT_PARTIAL;
db->Status = (db->cursor->c_get)(db->cursor, &key, &data, cflags);
if (db->Status == 0)
db->Status = ((db->cursor)->db_stream)(db->cursor, &stream, sflags) ;
/* if (db->Status == EINVAL){
db->Status = (db->cursor->c_get)(db->cursor,&key,&data,DB_CURRENT) ;
} */
if (db->Status == 0){
ZMALLOC(RETVAL, BerkeleyDB__DbStream_type) ;
RETVAL->stream = stream ;
RETVAL->active = TRUE ;
hash_store_iv("BerkeleyDB::Term::DbStream", (char *)RETVAL, 1) ;
}
else
{
Trace(("db_stream [%s]\n", my_db_strerror(db->Status)));
}
#endif
}
OUTPUT:
RETVAL
key
MODULE = BerkeleyDB::DbStream PACKAGE = BerkeleyDB::DbStream PREFIX = xx_
void
DESTROY(dbstream)
BerkeleyDB::DbStream dbstream
PREINIT:
dMY_CXT;
CODE:
Trace(("In BerkeleyDB::DbStream::_DESTROY db %p active=%d\n", dbstream, dbstream->active));
hash_delete("BerkeleyDB::Term::DbStream", (char *)dbstream) ;
#ifdef AT_LEAST_DB_6_0
if (dbstream->active)
((dbstream->stream)->close)(dbstream->stream, 0) ;
Safefree(dbstream) ;
#endif
Trace(("End of BerkeleyDB::DbStream::_DESTROY\n")) ;
DualType
close(dbstream, flags=0)
BerkeleyDB::DbStream dbstream
u_int32_t flags
PREINIT:
dMY_CXT;
INIT:
ckActive_DbStream(dbstream->active) ;
CODE:
#ifndef AT_LEAST_DB_6_0
softCrash("$dbstream->close needs Berkeley DB 6.0 or better") ;
#else
RETVAL = (dbstream->stream->close)(dbstream->stream, flags);
dbstream->active = FALSE;
hash_delete("BerkeleyDB::Term::DbStream", (char *)dbstream) ;
#endif
OUTPUT:
RETVAL
DualType
read(db, data, offset, size, flags=0)
BerkeleyDB::DbStream db
DBT_Blob data
db_off_t offset
u_int32_t size
BerkeleyDB.xs view on Meta::CPAN
hash_delete("BerkeleyDB::Term::Txn", (char *)tid) ;
tid->active = FALSE ;
#ifdef AT_LEAST_DB_4
# define _txn_abort(t) (t->Status = t->txn->abort(t->txn))
#else
# define _txn_abort(t) (t->Status = txn_abort(t->txn))
#endif
DualType
_txn_abort(tid)
BerkeleyDB::Txn tid
PREINIT:
dMY_CXT;
INIT:
ckActive_Transaction(tid->active) ;
hash_delete("BerkeleyDB::Term::Txn", (char *)tid) ;
tid->active = FALSE ;
#ifdef AT_LEAST_DB_4
# define _txn_discard(t,f) (t->Status = t->txn->discard(t->txn, f))
#else
# ifdef AT_LEAST_DB_3_3_4
# define _txn_discard(t,f) (t->Status = txn_discard(t->txn, f))
# else
# define _txn_discard(t,f) (int)softCrash("txn_discard needs Berkeley DB 3.3.4 or better") ;
# endif
#endif
DualType
_txn_discard(tid, flags=0)
BerkeleyDB::Txn tid
u_int32_t flags
PREINIT:
dMY_CXT;
INIT:
ckActive_Transaction(tid->active) ;
hash_delete("BerkeleyDB::Term::Txn", (char *)tid) ;
tid->active = FALSE ;
#ifdef AT_LEAST_DB_4
# define xx_txn_id(t) t->txn->id(t->txn)
#else
# define xx_txn_id(t) txn_id(t->txn)
#endif
u_int32_t
xx_txn_id(tid)
BerkeleyDB::Txn tid
PREINIT:
dMY_CXT;
MODULE = BerkeleyDB::_tiedHash PACKAGE = BerkeleyDB::_tiedHash
int
FIRSTKEY(db)
BerkeleyDB::Common db
PREINIT:
dMY_CXT;
CODE:
{
DBTKEY key ;
DBT value ;
DBC * cursor ;
/*
TODO!
set partial value to 0 - to eliminate the retrieval of
the value need to store any existing partial settings &
restore at the end.
*/
saveCurrentDB(db) ;
DBT_clear(key) ;
DBT_clear(value) ;
/* If necessary create a cursor for FIRSTKEY/NEXTKEY use */
if (!db->cursor &&
(db->Status = db_cursor(db, db->txn, &cursor, 0)) == 0 )
db->cursor = cursor ;
if (db->cursor)
RETVAL = (db->Status) =
((db->cursor)->c_get)(db->cursor, &key, &value, DB_FIRST);
else
RETVAL = db->Status ;
/* check for end of cursor */
if (RETVAL == DB_NOTFOUND) {
((db->cursor)->c_close)(db->cursor) ;
db->cursor = NULL ;
}
ST(0) = sv_newmortal();
OutputKey(ST(0), key)
}
int
NEXTKEY(db, key)
BerkeleyDB::Common db
DBTKEY key = NO_INIT
PREINIT:
dMY_CXT;
CODE:
{
DBT value ;
saveCurrentDB(db) ;
DBT_clear(key) ;
DBT_clear(value) ;
key.flags = 0 ;
RETVAL = (db->Status) =
((db->cursor)->c_get)(db->cursor, &key, &value, DB_NEXT);
/* check for end of cursor */
if (db->Status == DB_NOTFOUND) {
((db->cursor)->c_close)(db->cursor) ;
db->cursor = NULL ;
}
ST(0) = sv_newmortal();
OutputKey(ST(0), key)
}
MODULE = BerkeleyDB::Recno PACKAGE = BerkeleyDB::Recno
I32
FETCHSIZE(db)
BerkeleyDB::Common db
PREINIT:
dMY_CXT;
CODE:
saveCurrentDB(db) ;
RETVAL = GetArrayLength(db) ;
OUTPUT:
RETVAL
MODULE = BerkeleyDB::Queue PACKAGE = BerkeleyDB::Queue
I32
FETCHSIZE(db)
BerkeleyDB::Common db
PREINIT:
dMY_CXT;
CODE:
saveCurrentDB(db) ;
RETVAL = GetQueueLength(db) ;
OUTPUT:
RETVAL
MODULE = BerkeleyDB::Common PACKAGE = BerkeleyDB::Common
BerkeleyDB::Sequence
db_create_sequence(db, flags=0)
BerkeleyDB::Common db
u_int32_t flags
PREINIT:
dMY_CXT;
CODE:
{
#ifndef AT_LEAST_DB_4_3
softCrash("$seq->create_sequence needs Berkeley DB 4.3.x or better") ;
#else
DB_SEQUENCE * seq ;
saveCurrentDB(db);
RETVAL = NULL;
if (db_sequence_create(&seq, db->dbp, flags) == 0)
{
ZMALLOC(RETVAL, BerkeleyDB_Sequence_type);
RETVAL->db = db;
RETVAL->seq = seq;
RETVAL->active = TRUE;
++ db->open_sequences ;
}
#endif
}
OUTPUT:
RETVAL
( run in 0.776 second using v1.01-cache-2.11-cpan-39bf76dae61 )