BerkeleyDB
view release on metacpan or search on metacpan
BerkeleyDB.xs view on Meta::CPAN
}
}
#endif
SetValue_iv(mode, "Mode") ;
env->set_errcall(env, db_errcall_cb) ;
RETVAL->active = TRUE ;
RETVAL->cds_enabled = ((flags & DB_INIT_CDB) != 0 ? TRUE : FALSE) ;
#ifdef IS_DB_3_0_x
status = (env->open)(env, home, config, flags, mode) ;
#else /* > 3.0 */
status = (env->open)(env, home, flags, mode) ;
#endif
Trace(("ENV->open(env=%p,home=%s,flags=%d,mode=%d)\n",env,home,flags,mode)) ;
Trace(("ENV->open returned %s\n", my_db_strerror(status))) ;
}
if (status == 0)
hash_store_iv("BerkeleyDB::Term::Env", (char *)RETVAL, 1) ;
else {
(env->close)(env, 0) ;
#ifdef AT_LEAST_DB_4_3
if (RETVAL->MsgHandle)
SvREFCNT_dec(RETVAL->MsgHandle) ;
#endif
if (RETVAL->ErrHandle)
SvREFCNT_dec(RETVAL->ErrHandle) ;
if (RETVAL->ErrPrefix)
SvREFCNT_dec(RETVAL->ErrPrefix) ;
Safefree(RETVAL) ;
RETVAL = NULL ;
}
#endif /* DB_VERSION_MAJOR > 2 */
{
SV * sv_err = perl_get_sv(ERR_BUFF, FALSE);
sv_setpv(sv_err, db_strerror(status));
}
}
OUTPUT:
RETVAL
DB_ENV*
DB_ENV(env)
BerkeleyDB::Env env
PREINIT:
dMY_CXT;
CODE:
if (env->active)
RETVAL = env->Env ;
else
RETVAL = NULL;
OUTPUT:
RETVAL
void
log_archive(env, flags=0)
u_int32_t flags
BerkeleyDB::Env env
PREINIT:
dMY_CXT;
PPCODE:
{
char ** list;
char ** file;
AV * av;
#ifndef AT_LEAST_DB_3
softCrash("log_archive needs at least Berkeley DB 3.x.x");
#else
# ifdef AT_LEAST_DB_4
env->Status = env->Env->log_archive(env->Env, &list, flags) ;
# else
# ifdef AT_LEAST_DB_3_3
env->Status = log_archive(env->Env, &list, flags) ;
# else
env->Status = log_archive(env->Env, &list, flags, safemalloc) ;
# endif
# endif
#ifdef DB_ARCH_REMOVE
if (env->Status == 0 && list != NULL && flags != DB_ARCH_REMOVE)
#else
if (env->Status == 0 && list != NULL )
#endif
{
for (file = list; *file != NULL; ++file)
{
XPUSHs(sv_2mortal(newSVpv(*file, 0))) ;
}
safefree(list);
}
#endif
}
DualType
log_set_config(env, flags=0, onoff=0)
BerkeleyDB::Env env
u_int32_t flags
int onoff
PREINIT:
dMY_CXT;
CODE:
{
#ifndef AT_LEAST_DB_4_7
softCrash("log_set_config needs at least Berkeley DB 4.7.x");
#else
RETVAL = env->Status = env->Env->log_set_config(env->Env, flags, onoff) ;
#endif
}
OUTPUT:
RETVAL
DualType
log_get_config(env, flags, onoff)
BerkeleyDB::Env env
u_int32_t flags
int onoff=NO_INIT
PREINIT:
dMY_CXT;
CODE:
{
#ifndef AT_LEAST_DB_4_7
softCrash("log_get_config needs at least Berkeley DB 4.7.x");
BerkeleyDB.xs view on Meta::CPAN
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_
void
_db_open_unknown(ref)
SV * ref
PREINIT:
dMY_CXT;
PPCODE:
{
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 RETVAL ;
BerkeleyDB__Txn txn = NULL ;
#ifdef AT_LEAST_DB_5_2
static char * Names[] = {"", "Btree", "Hash", "Recno", "Queue", "Unknown", "Heap"} ;
#else
static char * Names[] = {"", "Btree", "Hash", "Recno", "Queue", "Unknown", "Heap"} ;
#endif
char * enc_passwd = NULL ;
int enc_flags = 0 ;
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") ;
ZMALLOC(db, BerkeleyDB_type) ;
RETVAL = my_db_open(db, ref, ref_dbenv, dbenv, txn, file, subname,
DB_UNKNOWN, flags, mode, &info, enc_passwd, enc_flags, hash) ;
XPUSHs(sv_2mortal(newSViv(PTR2IV(RETVAL))));
if (RETVAL)
XPUSHs(sv_2mortal(newSVpv(Names[RETVAL->type], 0))) ;
else
XPUSHs(sv_2mortal(newSViv((IV)NULL)));
}
MODULE = BerkeleyDB::Btree PACKAGE = BerkeleyDB::Btree PREFIX = btree_
BerkeleyDB::Btree::Raw
_db_open_btree(self, ref)
char * self
SV * ref
PREINIT:
dMY_CXT;
BerkeleyDB.xs view on Meta::CPAN
{ \
if (db->ftype) \
RETVAL = sv_mortalcopy(db->ftype) ; \
ST(0) = RETVAL ; \
if (db->ftype && (code == &PL_sv_undef)) { \
SvREFCNT_dec(db->ftype) ; \
db->ftype = NULL ; \
} \
else if (code) { \
if (db->ftype) \
sv_setsv(db->ftype, code) ; \
else \
db->ftype = newSVsv(code) ; \
} \
}
SV *
filter_fetch_key(db, code)
BerkeleyDB::Common db
SV * code
SV * RETVAL = &PL_sv_undef ;
CODE:
DBM_setFilter(db->filter_fetch_key, code) ;
SV *
filter_store_key(db, code)
BerkeleyDB::Common db
SV * code
SV * RETVAL = &PL_sv_undef ;
CODE:
DBM_setFilter(db->filter_store_key, code) ;
SV *
filter_fetch_value(db, code)
BerkeleyDB::Common db
SV * code
SV * RETVAL = &PL_sv_undef ;
CODE:
DBM_setFilter(db->filter_fetch_value, code) ;
SV *
filter_store_value(db, code)
BerkeleyDB::Common db
SV * code
SV * RETVAL = &PL_sv_undef ;
CODE:
DBM_setFilter(db->filter_store_value, code) ;
#endif /* DBM_FILTERING */
void
partial_set(db, offset, length)
BerkeleyDB::Common db
u_int32_t offset
u_int32_t length
PREINIT:
dMY_CXT;
INIT:
ckActive_Database(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::Common db
PREINIT:
dMY_CXT;
INIT:
ckActive_Database(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 ;
#define db_del(db, key, flags) \
(db->Status = ((db->dbp)->del)(db->dbp, db->txn, &key, flags))
DualType
db_del(db, key, flags=0)
u_int flags
BerkeleyDB::Common db
DBTKEY key
PREINIT:
dMY_CXT;
INIT:
Trace(("db_del db[%p] in [%p] txn[%p] key[%.*s] flags[%d]\n", db->dbp, db, db->txn, key.size, (char*)key.data, flags)) ;
ckActive_Database(db->active) ;
saveCurrentDB(db) ;
#ifdef AT_LEAST_DB_3
# ifdef AT_LEAST_DB_3_2
# define writeToKey() (flagSet(DB_CONSUME)||flagSet(DB_CONSUME_WAIT)||flagSet(DB_GET_BOTH)||flagSet(DB_SET_RECNO))
# else
# define writeToKey() (flagSet(DB_CONSUME)||flagSet(DB_GET_BOTH)||flagSet(DB_SET_RECNO))
# endif
#else
#define writeToKey() (flagSet(DB_GET_BOTH)||flagSet(DB_SET_RECNO))
#endif
#define db_get(db, key, data, flags) \
(db->Status = ((db->dbp)->get)(db->dbp, db->txn, &key, &data, flags))
DualType
db_get(db, key, data, flags=0)
u_int flags
BerkeleyDB::Common db
DBTKEY_B key
DBT_OPT data
PREINIT:
dMY_CXT;
CODE:
ckActive_Database(db->active) ;
saveCurrentDB(db) ;
SetPartial(data,db) ;
Trace(("db_get db[%p] in [%p] txn[%p] key [%.*s] flags[%d]\n", db->dbp, db, db->txn, key.size, (char*)key.data, flags)) ;
RETVAL = db_get(db, key, data, flags);
Trace((" RETVAL %d\n", RETVAL));
OUTPUT:
RETVAL
key if (writeToKey()) OutputKey(ST(1), key) ;
data
#define db_exists(db, key, flags) \
(db->Status = ((db->dbp)->exists)(db->dbp, db->txn, &key, flags))
DualType
db_exists(db, key, flags=0)
BerkeleyDB.xs view on Meta::CPAN
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 ;
( run in 0.487 second using v1.01-cache-2.11-cpan-71847e10f99 )