BerkeleyDB
view release on metacpan or search on metacpan
BerkeleyDB.xs view on Meta::CPAN
CODE:
{
DB_TXN *txn ;
DB_TXN *p_id = NULL ;
Trace(("txn_begin pid %p, flags %d\n", pid, flags)) ;
#if DB_VERSION_MAJOR == 2
if (env->Env->tx_info == NULL)
softCrash("Transaction Manager not enabled") ;
#endif
if (!env->txn_enabled)
softCrash("Transaction Manager not enabled") ;
if (pid)
p_id = pid->txn ;
env->TxnMgrStatus =
#if DB_VERSION_MAJOR == 2
txn_begin(env->Env->tx_info, p_id, &txn) ;
#else
# ifdef AT_LEAST_DB_4
env->Env->txn_begin(env->Env, p_id, &txn, flags) ;
# else
txn_begin(env->Env, p_id, &txn, flags) ;
# endif
#endif
if (env->TxnMgrStatus == 0) {
ZMALLOC(RETVAL, BerkeleyDB_Txn_type) ;
RETVAL->txn = txn ;
RETVAL->active = TRUE ;
Trace(("_txn_begin created txn [%p] in [%p]\n", txn, RETVAL));
hash_store_iv("BerkeleyDB::Term::Txn", (char *)RETVAL, 1) ;
}
else
RETVAL = NULL ;
}
OUTPUT:
RETVAL
#if DB_VERSION_MAJOR == 2
# define env_txn_checkpoint(e,k,m,f) txn_checkpoint(e->Env->tx_info, k, m)
#else /* DB 3.0 or better */
# ifdef AT_LEAST_DB_4
# define env_txn_checkpoint(e,k,m,f) e->Env->txn_checkpoint(e->Env, k, m, f)
# else
# ifdef AT_LEAST_DB_3_1
# define env_txn_checkpoint(e,k,m,f) txn_checkpoint(e->Env, k, m, 0)
# else
# define env_txn_checkpoint(e,k,m,f) txn_checkpoint(e->Env, k, m)
# endif
# endif
#endif
DualType
env_txn_checkpoint(env, kbyte, min, flags=0)
BerkeleyDB::Env env
long kbyte
long min
u_int32_t flags
PREINIT:
dMY_CXT;
HV *
txn_stat(env)
BerkeleyDB::Env env
HV * RETVAL = NULL ;
PREINIT:
dMY_CXT;
CODE:
{
DB_TXN_STAT * stat ;
#ifdef AT_LEAST_DB_4
if(env->Env->txn_stat(env->Env, &stat, 0) == 0) {
#else
# ifdef AT_LEAST_DB_3_3
if(txn_stat(env->Env, &stat) == 0) {
# else
# if DB_VERSION_MAJOR == 2
if(txn_stat(env->Env->tx_info, &stat, safemalloc) == 0) {
# else
if(txn_stat(env->Env, &stat, safemalloc) == 0) {
# endif
# endif
#endif
RETVAL = (HV*)sv_2mortal((SV*)newHV()) ;
hv_store_iv(RETVAL, "st_time_ckp", stat->st_time_ckp) ;
hv_store_iv(RETVAL, "st_last_txnid", stat->st_last_txnid) ;
hv_store_iv(RETVAL, "st_maxtxns", stat->st_maxtxns) ;
hv_store_iv(RETVAL, "st_naborts", stat->st_naborts) ;
hv_store_iv(RETVAL, "st_nbegins", stat->st_nbegins) ;
hv_store_iv(RETVAL, "st_ncommits", stat->st_ncommits) ;
hv_store_iv(RETVAL, "st_nactive", stat->st_nactive) ;
#if DB_VERSION_MAJOR > 2
hv_store_iv(RETVAL, "st_maxnactive", stat->st_maxnactive) ;
hv_store_iv(RETVAL, "st_regsize", stat->st_regsize) ;
hv_store_iv(RETVAL, "st_region_wait", stat->st_region_wait) ;
hv_store_iv(RETVAL, "st_region_nowait", stat->st_region_nowait) ;
#endif
safefree(stat) ;
}
}
OUTPUT:
RETVAL
#define EnDis(x) ((x) ? "Enabled" : "Disabled")
void
printEnv(env)
BerkeleyDB::Env env
PREINIT:
dMY_CXT;
INIT:
ckActive_Environment(env->active) ;
CODE:
#if 0
printf("env [0x%X]\n", env) ;
printf(" ErrPrefix [%s]\n", env->ErrPrefix
? SvPVX(env->ErrPrefix) : 0) ;
printf(" DB_ENV\n") ;
printf(" db_lorder [%d]\n", env->Env.db_lorder) ;
printf(" db_home [%s]\n", env->Env.db_home) ;
printf(" db_data_dir [%s]\n", env->Env.db_data_dir) ;
printf(" db_log_dir [%s]\n", env->Env.db_log_dir) ;
printf(" db_tmp_dir [%s]\n", env->Env.db_tmp_dir) ;
printf(" lk_info [%s]\n", EnDis(env->Env.lk_info)) ;
printf(" lk_max [%d]\n", env->Env.lk_max) ;
printf(" lg_info [%s]\n", EnDis(env->Env.lg_info)) ;
printf(" lg_max [%d]\n", env->Env.lg_max) ;
printf(" mp_info [%s]\n", EnDis(env->Env.mp_info)) ;
printf(" mp_size [%d]\n", env->Env.mp_size) ;
printf(" tx_info [%s]\n", EnDis(env->Env.tx_info)) ;
printf(" tx_max [%d]\n", env->Env.tx_max) ;
printf(" flags [%d]\n", env->Env.flags) ;
printf("\n") ;
#endif
SV *
errPrefix(env, prefix)
BerkeleyDB::Env env
SV * prefix
PREINIT:
dMY_CXT;
BerkeleyDB.xs view on Meta::CPAN
SV * sv ;
DB_INFO info ;
BerkeleyDB__Env dbenv = NULL;
SV * ref_dbenv = NULL;
const char * file = NULL ;
const char * subname = NULL ;
int flags = 0 ;
int mode = 0 ;
BerkeleyDB db ;
BerkeleyDB__Txn txn = NULL ;
char * enc_passwd = NULL ;
int enc_flags = 0 ;
Trace(("_db_open_hash start\n")) ;
hash = (HV*) SvRV(ref) ;
SetValue_pv(file, "Filename", char *) ;
SetValue_pv(subname, "Subname", char *) ;
SetValue_ov(txn, "Txn", BerkeleyDB__Txn) ;
SetValue_ov(dbenv, "Env", BerkeleyDB__Env) ;
ref_dbenv = sv ;
SetValue_iv(flags, "Flags") ;
SetValue_iv(mode, "Mode") ;
SetValue_pv(enc_passwd,"Enc_Passwd", char *) ;
SetValue_iv(enc_flags, "Enc_Flags") ;
Zero(&info, 1, DB_INFO) ;
SetValue_iv(info.db_cachesize, "Cachesize") ;
SetValue_iv(info.db_lorder, "Lorder") ;
SetValue_iv(info.db_pagesize, "Pagesize") ;
SetValue_iv(info.h_ffactor, "Ffactor") ;
SetValue_iv(info.h_nelem, "Nelem") ;
SetValue_iv(info.flags, "Property") ;
#ifdef AT_LEAST_DB_6_0
SetValue_iv(info.blob_threshold, "BlobThreshold") ;
SetValue_pv(info.blob_dir, "BlobDir", char*) ;
#endif
ZMALLOC(db, BerkeleyDB_type) ;
if ((sv = readHash(hash, "Hash")) && sv != &PL_sv_undef) {
info.h_hash = hash_cb ;
db->hash = newSVsv(sv) ;
}
/* DB_DUPSORT was introduced in DB 2.5.9 */
if ((sv = readHash(hash, "DupCompare")) && sv != &PL_sv_undef) {
#ifdef DB_DUPSORT
info.dup_compare = dup_compare ;
db->dup_compare = newSVsv(sv) ;
info.flags |= DB_DUP|DB_DUPSORT ;
#else
croak("DupCompare needs Berkeley DB 2.5.9 or later") ;
#endif
}
RETVAL = my_db_open(db, ref, ref_dbenv, dbenv, txn, file, subname,
DB_HASH, flags, mode, &info, enc_passwd, enc_flags, hash) ;
Trace(("_db_open_hash end\n")) ;
}
OUTPUT:
RETVAL
HV *
db_stat(db, flags=0)
int flags
BerkeleyDB::Common db
HV * RETVAL = NULL ;
PREINIT:
dMY_CXT;
INIT:
ckActive_Database(db->active) ;
CODE:
{
#if DB_VERSION_MAJOR == 2
softCrash("$db->db_stat for a Hash needs Berkeley DB 3.x or better") ;
#else
DB_HASH_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, "hash_magic", stat->hash_magic) ;
hv_store_iv(RETVAL, "hash_version", stat->hash_version);
hv_store_iv(RETVAL, "hash_pagesize", stat->hash_pagesize);
#ifdef AT_LEAST_DB_3_1
hv_store_iv(RETVAL, "hash_nkeys", stat->hash_nkeys);
hv_store_iv(RETVAL, "hash_ndata", stat->hash_ndata);
#else
hv_store_iv(RETVAL, "hash_nrecs", stat->hash_nrecs);
#endif
#ifndef AT_LEAST_DB_3_1
hv_store_iv(RETVAL, "hash_nelem", stat->hash_nelem);
#endif
hv_store_iv(RETVAL, "hash_ffactor", stat->hash_ffactor);
hv_store_iv(RETVAL, "hash_buckets", stat->hash_buckets);
hv_store_iv(RETVAL, "hash_free", stat->hash_free);
hv_store_iv(RETVAL, "hash_bfree", stat->hash_bfree);
hv_store_iv(RETVAL, "hash_bigpages", stat->hash_bigpages);
hv_store_iv(RETVAL, "hash_big_bfree", stat->hash_big_bfree);
hv_store_iv(RETVAL, "hash_overflows", stat->hash_overflows);
hv_store_iv(RETVAL, "hash_ovfl_free", stat->hash_ovfl_free);
hv_store_iv(RETVAL, "hash_dup", stat->hash_dup);
hv_store_iv(RETVAL, "hash_dup_free", stat->hash_dup_free);
#if DB_VERSION_MAJOR >= 3
hv_store_iv(RETVAL, "hash_metaflags", stat->hash_metaflags);
#endif
safefree(stat) ;
}
#endif
}
OUTPUT:
RETVAL
MODULE = BerkeleyDB::Unknown PACKAGE = BerkeleyDB::Unknown PREFIX = hash_
BerkeleyDB.xs view on Meta::CPAN
int flags = 0 ;
int mode = 0 ;
BerkeleyDB db ;
BerkeleyDB__Txn txn = NULL ;
char * enc_passwd = NULL ;
int enc_flags = 0 ;
Trace(("In _db_open_btree\n"));
hash = (HV*) SvRV(ref) ;
SetValue_pv(file, "Filename", char*) ;
SetValue_pv(subname, "Subname", char *) ;
SetValue_ov(txn, "Txn", BerkeleyDB__Txn) ;
SetValue_ov(dbenv, "Env", BerkeleyDB__Env) ;
ref_dbenv = sv ;
SetValue_iv(flags, "Flags") ;
SetValue_iv(mode, "Mode") ;
SetValue_pv(enc_passwd,"Enc_Passwd", char *) ;
SetValue_iv(enc_flags, "Enc_Flags") ;
Zero(&info, 1, DB_INFO) ;
SetValue_iv(info.db_cachesize, "Cachesize") ;
SetValue_iv(info.db_lorder, "Lorder") ;
SetValue_iv(info.db_pagesize, "Pagesize") ;
SetValue_iv(info.bt_minkey, "Minkey") ;
SetValue_iv(info.flags, "Property") ;
#ifdef AT_LEAST_DB_6_0
SetValue_iv(info.blob_threshold, "BlobThreshold") ;
SetValue_pv(info.blob_dir, "BlobDir", char*) ;
#endif
ZMALLOC(db, BerkeleyDB_type) ;
if ((sv = readHash(hash, "Compare")) && sv != &PL_sv_undef) {
Trace((" Parsed Compare callback\n"));
info.bt_compare = btree_compare ;
db->compare = newSVsv(sv) ;
}
/* DB_DUPSORT was introduced in DB 2.5.9 */
if ((sv = readHash(hash, "DupCompare")) && sv != &PL_sv_undef) {
#ifdef DB_DUPSORT
Trace((" Parsed DupCompare callback\n"));
info.dup_compare = dup_compare ;
db->dup_compare = newSVsv(sv) ;
info.flags |= DB_DUP|DB_DUPSORT ;
#else
softCrash("DupCompare needs Berkeley DB 2.5.9 or later") ;
#endif
}
if ((sv = readHash(hash, "Prefix")) && sv != &PL_sv_undef) {
Trace((" Parsed Prefix callback\n"));
info.bt_prefix = btree_prefix ;
db->prefix = newSVsv(sv) ;
}
RETVAL = my_db_open(db, ref, ref_dbenv, dbenv, txn, file, subname,
DB_BTREE, flags, mode, &info, enc_passwd, enc_flags, hash) ;
}
OUTPUT:
RETVAL
HV *
db_stat(db, flags=0)
int flags
BerkeleyDB::Common db
HV * RETVAL = NULL ;
PREINIT:
dMY_CXT;
INIT:
ckActive_Database(db->active) ;
CODE:
{
DB_BTREE_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, "bt_magic", stat->bt_magic);
hv_store_iv(RETVAL, "bt_version", stat->bt_version);
#if DB_VERSION_MAJOR > 2
hv_store_iv(RETVAL, "bt_metaflags", stat->bt_metaflags) ;
hv_store_iv(RETVAL, "bt_flags", stat->bt_metaflags) ;
#else
hv_store_iv(RETVAL, "bt_flags", stat->bt_flags) ;
#endif
#ifndef AT_LEAST_DB_4_4
hv_store_iv(RETVAL, "bt_maxkey", stat->bt_maxkey) ;
#endif
hv_store_iv(RETVAL, "bt_minkey", stat->bt_minkey);
hv_store_iv(RETVAL, "bt_re_len", stat->bt_re_len);
hv_store_iv(RETVAL, "bt_re_pad", stat->bt_re_pad);
hv_store_iv(RETVAL, "bt_pagesize", stat->bt_pagesize);
hv_store_iv(RETVAL, "bt_levels", stat->bt_levels);
#ifdef AT_LEAST_DB_3_1
hv_store_iv(RETVAL, "bt_nkeys", stat->bt_nkeys);
hv_store_iv(RETVAL, "bt_ndata", stat->bt_ndata);
#else
hv_store_iv(RETVAL, "bt_nrecs", stat->bt_nrecs);
#endif
hv_store_iv(RETVAL, "bt_int_pg", stat->bt_int_pg);
hv_store_iv(RETVAL, "bt_leaf_pg", stat->bt_leaf_pg);
hv_store_iv(RETVAL, "bt_dup_pg", stat->bt_dup_pg);
hv_store_iv(RETVAL, "bt_over_pg", stat->bt_over_pg);
hv_store_iv(RETVAL, "bt_free", stat->bt_free);
#if DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 5
hv_store_iv(RETVAL, "bt_freed", stat->bt_freed);
hv_store_iv(RETVAL, "bt_pfxsaved", stat->bt_pfxsaved);
hv_store_iv(RETVAL, "bt_split", stat->bt_split);
hv_store_iv(RETVAL, "bt_rootsplit", stat->bt_rootsplit);
hv_store_iv(RETVAL, "bt_fastsplit", stat->bt_fastsplit);
hv_store_iv(RETVAL, "bt_added", stat->bt_added);
hv_store_iv(RETVAL, "bt_deleted", stat->bt_deleted);
hv_store_iv(RETVAL, "bt_get", stat->bt_get);
hv_store_iv(RETVAL, "bt_cache_hit", stat->bt_cache_hit);
BerkeleyDB.xs view on Meta::CPAN
{
#ifndef AT_LEAST_DB_3
softCrash("BerkeleyDB::Queue needs Berkeley DB 3.0.x or better");
#else
HV * hash ;
SV * sv ;
DB_INFO info ;
BerkeleyDB__Env dbenv = NULL;
SV * ref_dbenv = NULL;
const char * file = NULL ;
const char * subname = NULL ;
int flags = 0 ;
int mode = 0 ;
BerkeleyDB db ;
BerkeleyDB__Txn txn = NULL ;
char * enc_passwd = NULL ;
int enc_flags = 0 ;
hash = (HV*) SvRV(ref) ;
SetValue_pv(file, "Fname", char*) ;
SetValue_pv(subname, "Subname", char *) ;
SetValue_ov(dbenv, "Env", BerkeleyDB__Env) ;
ref_dbenv = sv ;
SetValue_ov(txn, "Txn", BerkeleyDB__Txn) ;
SetValue_iv(flags, "Flags") ;
SetValue_iv(mode, "Mode") ;
SetValue_pv(enc_passwd,"Enc_Passwd", char *) ;
SetValue_iv(enc_flags, "Enc_Flags") ;
Zero(&info, 1, DB_INFO) ;
SetValue_iv(info.db_cachesize, "Cachesize") ;
SetValue_iv(info.db_lorder, "Lorder") ;
SetValue_iv(info.db_pagesize, "Pagesize") ;
SetValue_iv(info.bt_minkey, "Minkey") ;
SetValue_iv(info.q_extentsize, "ExtentSize") ;
SetValue_iv(info.flags, "Property") ;
if ((sv = readHash(hash, "Len")) && sv != &PL_sv_undef) {
info.re_len = SvIV(sv) ; ;
flagSet_DB2(info.flags, DB_FIXEDLEN) ;
}
if ((sv = readHash(hash, "Pad")) && sv != &PL_sv_undef) {
info.re_pad = (u_int32_t)SvPOK(sv) ? *SvPV(sv,PL_na) : SvIV(sv) ; ;
flagSet_DB2(info.flags, DB_PAD) ;
}
ZMALLOC(db, BerkeleyDB_type) ;
#ifdef ALLOW_RECNO_OFFSET
SetValue_iv(db->array_base, "ArrayBase") ;
db->array_base = (db->array_base == 0 ? 1 : 0) ;
#endif /* ALLOW_RECNO_OFFSET */
RETVAL = my_db_open(db, ref, ref_dbenv, dbenv, txn, file, subname,
DB_QUEUE, flags, mode, &info, enc_passwd, enc_flags, hash) ;
#endif
}
OUTPUT:
RETVAL
HV *
db_stat(db, flags=0)
int flags
BerkeleyDB::Common db
HV * RETVAL = NULL ;
PREINIT:
dMY_CXT;
INIT:
ckActive_Database(db->active) ;
CODE:
{
#if DB_VERSION_MAJOR == 2
softCrash("$db->db_stat for a Queue needs Berkeley DB 3.x or better") ;
#else /* Berkeley DB 3, or better */
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)
BerkeleyDB.xs view on Meta::CPAN
Trace(("_txn_begin created txn [%p] in [%p]\n", txn, RETVAL));
hash_store_iv("BerkeleyDB::Term::Txn", (char *)RETVAL, 1) ;
}
else
RETVAL = NULL ;
}
OUTPUT:
RETVAL
DualType
status(mgr)
BerkeleyDB::TxnMgr mgr
PREINIT:
dMY_CXT;
CODE:
RETVAL = mgr->env->TxnMgrStatus ;
OUTPUT:
RETVAL
void
_DESTROY(mgr)
BerkeleyDB::TxnMgr mgr
PREINIT:
dMY_CXT;
CODE:
Trace(("In BerkeleyDB::TxnMgr::DESTROY dirty=%d\n", PL_dirty)) ;
Safefree(mgr) ;
Trace(("End of BerkeleyDB::TxnMgr::DESTROY\n")) ;
DualType
txn_close(txnp)
BerkeleyDB::TxnMgr txnp
NOT_IMPLEMENTED_YET
#if DB_VERSION_MAJOR == 2
# define xx_txn_checkpoint(t,k,m,f) txn_checkpoint(t->env->Env->tx_info, k, m)
#else
# ifdef AT_LEAST_DB_4
# define xx_txn_checkpoint(e,k,m,f) e->env->Env->txn_checkpoint(e->env->Env, k, m, f)
# else
# ifdef AT_LEAST_DB_3_1
# define xx_txn_checkpoint(t,k,m,f) txn_checkpoint(t->env->Env, k, m, 0)
# else
# define xx_txn_checkpoint(t,k,m,f) txn_checkpoint(t->env->Env, k, m)
# endif
# endif
#endif
DualType
xx_txn_checkpoint(txnp, kbyte, min, flags=0)
BerkeleyDB::TxnMgr txnp
long kbyte
long min
u_int32_t flags
PREINIT:
dMY_CXT;
HV *
txn_stat(txnp)
BerkeleyDB::TxnMgr txnp
HV * RETVAL = NULL ;
PREINIT:
dMY_CXT;
CODE:
{
DB_TXN_STAT * stat ;
#ifdef AT_LEAST_DB_4
if(txnp->env->Env->txn_stat(txnp->env->Env, &stat, 0) == 0) {
#else
# ifdef AT_LEAST_DB_3_3
if(txn_stat(txnp->env->Env, &stat) == 0) {
# else
# if DB_VERSION_MAJOR == 2
if(txn_stat(txnp->env->Env->tx_info, &stat, safemalloc) == 0) {
# else
if(txn_stat(txnp->env->Env, &stat, safemalloc) == 0) {
# endif
# endif
#endif
RETVAL = (HV*)sv_2mortal((SV*)newHV()) ;
hv_store_iv(RETVAL, "st_time_ckp", stat->st_time_ckp) ;
hv_store_iv(RETVAL, "st_last_txnid", stat->st_last_txnid) ;
hv_store_iv(RETVAL, "st_maxtxns", stat->st_maxtxns) ;
hv_store_iv(RETVAL, "st_naborts", stat->st_naborts) ;
hv_store_iv(RETVAL, "st_nbegins", stat->st_nbegins) ;
hv_store_iv(RETVAL, "st_ncommits", stat->st_ncommits) ;
hv_store_iv(RETVAL, "st_nactive", stat->st_nactive) ;
#if DB_VERSION_MAJOR > 2
hv_store_iv(RETVAL, "st_maxnactive", stat->st_maxnactive) ;
hv_store_iv(RETVAL, "st_regsize", stat->st_regsize) ;
hv_store_iv(RETVAL, "st_region_wait", stat->st_region_wait) ;
hv_store_iv(RETVAL, "st_region_nowait", stat->st_region_nowait) ;
#endif
safefree(stat) ;
}
}
OUTPUT:
RETVAL
BerkeleyDB::TxnMgr
txn_open(dir, flags, mode, dbenv)
int flags
const char * dir
int mode
BerkeleyDB::Env dbenv
NOT_IMPLEMENTED_YET
MODULE = BerkeleyDB::Txn PACKAGE = BerkeleyDB::Txn PREFIX = xx_
DualType
status(tid)
BerkeleyDB::Txn tid
PREINIT:
dMY_CXT;
CODE:
RETVAL = tid->Status ;
OUTPUT:
RETVAL
int
set_timeout(txn, timeout, flags=0)
BerkeleyDB::Txn txn
db_timeout_t timeout
u_int32_t flags
PREINIT:
dMY_CXT;
INIT:
ckActive_Transaction(txn->active) ;
CODE:
#ifndef AT_LEAST_DB_4
softCrash("$env->set_timeout needs Berkeley DB 4.x or better") ;
#else
RETVAL = txn->Status = txn->txn->set_timeout(txn->txn, timeout, flags);
#endif
BerkeleyDB.xs view on Meta::CPAN
DualType
get_cachesize(seq, size)
BerkeleyDB::Sequence seq;
int32_t size = NO_INIT
PREINIT:
dMY_CXT;
INIT:
ckActive_Sequence(seq->active) ;
CODE:
#ifndef AT_LEAST_DB_4_3
softCrash("$seq->get_cachesize needs Berkeley DB 4.3.x or better") ;
#else
RETVAL = seq->seq->get_cachesize(seq->seq, &size);
#endif
OUTPUT:
RETVAL
size
DualType
set_flags(seq, flags)
BerkeleyDB::Sequence seq;
u_int32_t flags
PREINIT:
dMY_CXT;
INIT:
ckActive_Sequence(seq->active) ;
CODE:
#ifndef AT_LEAST_DB_4_3
softCrash("$seq->set_flags needs Berkeley DB 4.3.x or better") ;
#else
RETVAL = seq->seq->set_flags(seq->seq, flags);
#endif
OUTPUT:
RETVAL
DualType
get_flags(seq, flags)
BerkeleyDB::Sequence seq;
u_int32_t flags = NO_INIT
PREINIT:
dMY_CXT;
INIT:
ckActive_Sequence(seq->active) ;
CODE:
#ifndef AT_LEAST_DB_4_3
softCrash("$seq->get_flags needs Berkeley DB 4.3.x or better") ;
#else
RETVAL = seq->seq->get_flags(seq->seq, &flags);
#endif
OUTPUT:
RETVAL
flags
DualType
set_range(seq)
BerkeleyDB::Sequence seq;
NOT_IMPLEMENTED_YET
DualType
stat(seq)
BerkeleyDB::Sequence seq;
NOT_IMPLEMENTED_YET
MODULE = BerkeleyDB PACKAGE = BerkeleyDB
BOOT:
{
#ifdef dTHX
dTHX;
#endif
SV * sv_err = perl_get_sv(ERR_BUFF, GV_ADD|GV_ADDMULTI) ;
SV * version_sv = perl_get_sv("BerkeleyDB::db_version", GV_ADD|GV_ADDMULTI) ;
SV * ver_sv = perl_get_sv("BerkeleyDB::db_ver", GV_ADD|GV_ADDMULTI) ;
int Major, Minor, Patch ;
MY_CXT_INIT;
(void)db_version(&Major, &Minor, &Patch) ;
/* Check that the versions of db.h and libdb.a are the same */
if (Major != DB_VERSION_MAJOR || Minor != DB_VERSION_MINOR
|| Patch != DB_VERSION_PATCH)
croak("\nBerkeleyDB needs compatible versions of libdb & db.h\n\tyou have db.h version %d.%d.%d and libdb version %d.%d.%d\n",
DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH,
Major, Minor, Patch) ;
if (Major < 2 || (Major == 2 && Minor < 6))
{
croak("BerkeleyDB needs Berkeley DB 2.6 or greater. This is %d.%d.%d\n",
Major, Minor, Patch) ;
}
sv_setpvf(version_sv, "%d.%d", Major, Minor) ;
sv_setpvf(ver_sv, "%d.%03d%03d", Major, Minor, Patch) ;
sv_setpv(sv_err, "");
DBT_clear(empty) ;
empty.data = &zero ;
empty.size = sizeof(db_recno_t) ;
empty.flags = 0 ;
}
( run in 2.246 seconds using v1.01-cache-2.11-cpan-39bf76dae61 )