BDB
view release on metacpan or search on metacpan
}
if (nreqs <= max_outstanding)
break;
poll_wait ();
++maxreqs;
}
return count;
}
/*****************************************************************************/
static void
bdb_request (bdb_req req)
{
switch (req->type)
{
case REQ_ENV_OPEN:
req->result = req->env->open (req->env, req->buf1, req->uint1, req->int1);
break;
case REQ_ENV_CLOSE:
req->result = req->env->close (req->env, req->uint1);
break;
case REQ_ENV_TXN_CHECKPOINT:
req->result = req->env->txn_checkpoint (req->env, req->uint1, req->int1, req->uint2);
break;
case REQ_ENV_LOCK_DETECT:
req->result = req->env->lock_detect (req->env, req->uint1, req->uint2, &req->int1);
break;
case REQ_ENV_MEMP_SYNC:
req->result = req->env->memp_sync (req->env, 0);
break;
case REQ_ENV_MEMP_TRICKLE:
req->result = req->env->memp_trickle (req->env, req->int1, &req->int2);
break;
case REQ_ENV_DBREMOVE:
req->result = req->env->dbremove (req->env, req->txn, req->buf1, req->buf2, req->uint1);
break;
case REQ_ENV_DBRENAME:
req->result = req->env->dbrename (req->env, req->txn, req->buf1, req->buf2, req->buf3, req->uint1);
break;
case REQ_DB_OPEN:
req->result = req->db->open (req->db, req->txn, req->buf1, req->buf2, req->int1, req->uint1, req->int2);
break;
case REQ_DB_CLOSE:
req->result = req->db->close (req->db, req->uint1);
break;
#if DBVER >= 404
case REQ_DB_COMPACT:
req->result = req->db->compact (req->db, req->txn, req->dbt1.data ? &req->dbt1 : 0, req->dbt2.data ? &req->dbt2 : 0, 0, req->uint1, 0);
break;
#endif
case REQ_DB_SYNC:
req->result = req->db->sync (req->db, req->uint1);
break;
case REQ_DB_VERIFY:
req->result = req->db->verify (req->db, req->buf1, req->buf2, 0, req->uint1);
break;
case REQ_DB_UPGRADE:
req->result = req->db->upgrade (req->db, req->buf1, req->uint1);
break;
case REQ_DB_PUT:
req->result = req->db->put (req->db, req->txn, &req->dbt1, &req->dbt2, req->uint1);
break;
#if DBVER >= 406
case REQ_DB_EXISTS:
req->result = req->db->exists (req->db, req->txn, &req->dbt1, req->uint1);
break;
#endif
case REQ_DB_GET:
req->result = req->db->get (req->db, req->txn, &req->dbt1, &req->dbt3, req->uint1);
break;
case REQ_DB_PGET:
req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
break;
case REQ_DB_DEL:
req->result = req->db->del (req->db, req->txn, &req->dbt1, req->uint1);
break;
case REQ_DB_KEY_RANGE:
req->result = req->db->key_range (req->db, req->txn, &req->dbt1, &req->key_range, req->uint1);
break;
case REQ_TXN_COMMIT:
req->result = req->txn->commit (req->txn, req->uint1);
break;
case REQ_TXN_ABORT:
req->result = req->txn->abort (req->txn);
break;
case REQ_TXN_FINISH:
if (req->txn->flags & TXN_DEADLOCK)
{
req->result = req->txn->abort (req->txn);
if (!req->result)
req->result = DB_LOCK_DEADLOCK;
}
else
req->result = req->txn->commit (req->txn, req->uint1);
break;
const_iv (LOCK_MINWRITE)
const_iv (LOCK_OLDEST)
const_iv (LOCK_RANDOM)
const_iv (LOCK_YOUNGEST)
const_iv (DONOTINDEX)
const_iv (KEYEMPTY)
const_iv (KEYEXIST)
const_iv (LOCK_DEADLOCK)
const_iv (LOCK_NOTGRANTED)
const_iv (NOSERVER)
#if DBVER < 502
const_iv (NOSERVER_HOME)
const_iv (NOSERVER_ID)
#endif
const_iv (NOTFOUND)
const_iv (PAGE_NOTFOUND)
const_iv (REP_DUPMASTER)
const_iv (REP_HANDLE_DEAD)
const_iv (REP_HOLDELECTION)
const_iv (REP_ISPERM)
const_iv (REP_NEWMASTER)
const_iv (REP_NEWSITE)
const_iv (REP_NOTPERM)
const_iv (REP_UNAVAIL)
const_iv (RUNRECOVERY)
const_iv (SECONDARY_BAD)
const_iv (VERIFY_BAD)
const_iv (SALVAGE)
const_iv (AGGRESSIVE)
const_iv (PRINTABLE)
const_iv (NOORDERCHK)
const_iv (ORDERCHKONLY)
const_iv (ARCH_ABS)
const_iv (ARCH_DATA)
const_iv (ARCH_LOG)
const_iv (ARCH_REMOVE)
const_iv (VERB_DEADLOCK)
const_iv (VERB_RECOVERY)
const_iv (VERB_REPLICATION)
const_iv (VERB_WAITSFOR)
const_iv (VERSION_MAJOR)
const_iv (VERSION_MINOR)
const_iv (VERSION_PATCH)
const_iv (LOGVERSION)
const_iv (LOGOLDVER)
#if DBVER >= 403
const_iv (INORDER)
const_iv (LOCK_MAXWRITE)
const_iv (SEQ_DEC)
const_iv (SEQ_INC)
const_iv (SEQ_WRAP)
const_iv (BUFFER_SMALL)
const_iv (LOG_BUFFER_FULL)
const_iv (VERSION_MISMATCH)
#endif
#if DBVER >= 404
const_iv (REGISTER)
const_iv (DSYNC_DB)
const_iv (READ_COMMITTED)
const_iv (READ_UNCOMMITTED)
const_iv (REP_IGNORE)
const_iv (REP_LOCKOUT)
const_iv (REP_JOIN_FAILURE)
const_iv (FREE_SPACE)
const_iv (FREELIST_ONLY)
const_iv (VERB_REGISTER)
#endif
#if DBVER >= 405
const_iv (MULTIVERSION)
const_iv (TXN_SNAPSHOT)
#endif
#if DBVER >= 406
const_iv (PREV_DUP)
const_iv (PRIORITY_UNCHANGED)
const_iv (PRIORITY_VERY_LOW)
const_iv (PRIORITY_LOW)
const_iv (PRIORITY_DEFAULT)
const_iv (PRIORITY_HIGH)
const_iv (PRIORITY_VERY_HIGH)
const_iv (IGNORE_LEASE)
#endif
#if DBVER >= 407
//const_iv (MULTIPLE_KEY)
const_iv (LOG_DIRECT)
const_iv (LOG_DSYNC)
const_iv (LOG_AUTO_REMOVE)
const_iv (LOG_IN_MEMORY)
const_iv (LOG_ZERO)
#else
const_iv (DIRECT_LOG)
const_iv (LOG_AUTOREMOVE)
# if DBVER >= 403
const_iv (DSYNC_LOG)
const_iv (LOG_INMEMORY)
# endif
#if DBVER >= 408
const_iv (LOGVERSION_LATCHING)
#endif
#endif
};
bdb_stash = gv_stashpv ("BDB" , 1);
bdb_env_stash = gv_stashpv ("BDB::Env" , 1);
bdb_txn_stash = gv_stashpv ("BDB::Txn" , 1);
bdb_cursor_stash = gv_stashpv ("BDB::Cursor" , 1);
bdb_db_stash = gv_stashpv ("BDB::Db" , 1);
bdb_sequence_stash = gv_stashpv ("BDB::Sequence", 1);
for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
newCONSTSUB (bdb_stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
prepare_cb = &PL_sv_undef;
{
/* we currently only allow version, minor-version and patchlevel to go up to 255 */
char vstring[3] = { DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH };
}
void
db_env_log_archive (DB_ENV *env, SV_mutable *listp, U32 flags = 0, SV *callback = 0)
PREINIT:
CALLBACK
CODE:
{
dREQ (REQ_ENV_LOG_ARCHIVE, 1);
req->sv1 = SvREFCNT_inc (listp);
req->env = env;
req->uint1 = flags;
REQ_SEND;
}
DB *
db_create (DB_ENV *env = 0, U32 flags = 0)
CODE:
{
errno = db_create (&RETVAL, env, flags);
if (errno)
croak ("db_create: %s", db_strerror (errno));
if (RETVAL)
RETVAL->app_private = (void *)newSVsv (ST (0));
}
OUTPUT:
RETVAL
void
db_open (DB *db, DB_TXN_ornull *txnid, bdb_filename file, bdb_filename database, int type, U32 flags, int mode, SV *callback = 0)
PREINIT:
CALLBACK
CODE:
{
dREQ (REQ_DB_OPEN, 2);
req->db = db;
req->txn = txnid;
req->buf1 = strdup_ornull (file);
req->buf2 = strdup_ornull (database);
req->int1 = type;
req->uint1 = flags | DB_THREAD;
req->int2 = mode;
REQ_SEND;
}
void
db_close (DB *db, U32 flags = 0, SV *callback = 0)
PREINIT:
CALLBACK
CODE:
{
dREQ (REQ_DB_CLOSE, 0);
ptr_nuke (ST (0));
req->db = db;
req->uint1 = flags;
req->sv1 = (SV *)db->app_private;
REQ_SEND;
}
#if DBVER >= 404
void
db_compact (DB *db, DB_TXN_ornull *txn = 0, SV *start = 0, SV *stop = 0, SV *unused1 = 0, U32 flags = DB_FREE_SPACE, SV *unused2 = 0, SV *callback = 0)
PREINIT:
CALLBACK
CODE:
{
dREQ (REQ_DB_COMPACT, 2);
req->db = db;
req->txn = txn;
if (start) sv_to_dbt (&req->dbt1, start);
if (stop ) sv_to_dbt (&req->dbt2, stop );
req->uint1 = flags;
REQ_SEND;
}
#endif
void
db_sync (DB *db, U32 flags = 0, SV *callback = 0)
PREINIT:
CALLBACK
CODE:
{
dREQ (REQ_DB_SYNC, 1);
req->db = db;
req->uint1 = flags;
REQ_SEND;
}
void
db_verify (DB *db, bdb_filename file, bdb_filename database = 0, SV *dummy = 0, U32 flags = 0, SV *callback = 0)
PREINIT:
CALLBACK
CODE:
{
dREQ (REQ_DB_VERIFY, 1);
ptr_nuke (ST (0)); /* verify destroys the database handle, hopefully it is freed as well */
req->db = db;
req->buf1 = strdup (file);
req->buf2 = strdup_ornull (database);
req->uint1 = flags;
REQ_SEND;
}
void
db_upgrade (DB *db, bdb_filename file, U32 flags = 0, SV *callback = 0)
PREINIT:
CALLBACK
CODE:
{
dREQ (REQ_DB_UPGRADE, 1);
req->db = db;
req->buf1 = strdup (file);
req->uint1 = flags;
REQ_SEND;
}
void
db_key_range (DB *db, DB_TXN_ornull *txn, SV *key, SV_mutable *key_range, U32 flags = 0, SV *callback = 0)
int set_timeout (DB_ENV *env, NV timeout, U32 flags = DB_SET_TXN_TIMEOUT)
CODE:
RETVAL = env->set_timeout (env, timeout * 1000000, flags);
OUTPUT:
RETVAL
int set_mp_max_openfd (DB_ENV *env, int maxopenfd);
CODE:
RETVAL = env->set_mp_max_openfd (env, maxopenfd);
OUTPUT:
RETVAL
int set_mp_max_write (DB_ENV *env, int maxwrite, int maxwrite_sleep);
CODE:
RETVAL = env->set_mp_max_write (env, maxwrite, maxwrite_sleep);
OUTPUT:
RETVAL
int set_mp_mmapsize (DB_ENV *env, int mmapsize_mb)
CODE:
RETVAL = env->set_mp_mmapsize (env, ((size_t)mmapsize_mb) << 20);
OUTPUT:
RETVAL
int set_lk_detect (DB_ENV *env, U32 detect = DB_LOCK_DEFAULT)
CODE:
RETVAL = env->set_lk_detect (env, detect);
OUTPUT:
RETVAL
int set_lk_max_lockers (DB_ENV *env, U32 max)
CODE:
RETVAL = env->set_lk_max_lockers (env, max);
OUTPUT:
RETVAL
int set_lk_max_locks (DB_ENV *env, U32 max)
CODE:
RETVAL = env->set_lk_max_locks (env, max);
OUTPUT:
RETVAL
int set_lk_max_objects (DB_ENV *env, U32 max)
CODE:
RETVAL = env->set_lk_max_objects (env, max);
OUTPUT:
RETVAL
int set_lg_bsize (DB_ENV *env, U32 max)
CODE:
RETVAL = env->set_lg_bsize (env, max);
OUTPUT:
RETVAL
int set_lg_max (DB_ENV *env, U32 max)
CODE:
RETVAL = env->set_lg_max (env, max);
OUTPUT:
RETVAL
#if DBVER >= 404
int mutex_set_max (DB_ENV *env, U32 max)
CODE:
RETVAL = env->mutex_set_max (env, max);
OUTPUT:
RETVAL
int mutex_set_increment (DB_ENV *env, U32 increment)
CODE:
RETVAL = env->mutex_set_increment (env, increment);
OUTPUT:
RETVAL
int mutex_set_tas_spins (DB_ENV *env, U32 tas_spins)
CODE:
RETVAL = env->mutex_set_tas_spins (env, tas_spins);
OUTPUT:
RETVAL
int mutex_set_align (DB_ENV *env, U32 align)
CODE:
RETVAL = env->mutex_set_align (env, align);
OUTPUT:
RETVAL
#endif
DB_TXN *
txn_begin (DB_ENV *env, DB_TXN_ornull *parent = 0, U32 flags = 0)
CODE:
errno = env->txn_begin (env, parent, &RETVAL, flags);
if (errno)
croak ("DB_ENV->txn_begin: %s", db_strerror (errno));
OUTPUT:
RETVAL
#if DBVER >= 405
DB_TXN *
cdsgroup_begin (DB_ENV *env)
CODE:
errno = env->cdsgroup_begin (env, &RETVAL);
if (errno)
croak ("DB_ENV->cdsgroup_begin: %s", db_strerror (errno));
OUTPUT:
RETVAL
#endif
MODULE = BDB PACKAGE = BDB::Db
void
DESTROY (DB_ornuked *db)
CODE:
if (db)
{
SV *env = (SV *)db->app_private;
db->close (db, 0);
SvREFCNT_dec (env);
}
( run in 2.119 seconds using v1.01-cache-2.11-cpan-0bb4e1dffa6 )