--- BDB/BDB.xs 2007/02/08 22:14:01 1.7 +++ BDB/BDB.xs 2007/02/11 22:07:23 1.8 @@ -42,10 +42,11 @@ # endif #endif -typedef DB_ENV DB_ENV_ornull; -typedef DB_TXN DB_TXN_ornull; -typedef DBC DBC_ornull; -typedef DB DB_ornull; +typedef DB_ENV DB_ENV_ornull; +typedef DB_TXN DB_TXN_ornull; +typedef DBC DBC_ornull; +typedef DB DB_ornull; +typedef DB_SEQUENCE DB_SEQUENCE_ornull; typedef SV SV8; /* byte-sv, used for argument-checking */ typedef char *octetstring; @@ -85,10 +86,13 @@ enum { REQ_QUIT, - REQ_ENV_OPEN, REQ_ENV_CLOSE, - REQ_DB_OPEN, REQ_DB_CLOSE, REQ_DB_COMPACT, REQ_DB_SYNC, REQ_DB_PUT, REQ_DB_GET, REQ_DB_PGET, REQ_DB_DEL, + REQ_ENV_OPEN, REQ_ENV_CLOSE, REQ_ENV_TXN_CHECKPOINT, REQ_ENV_LOCK_DETECT, + REQ_ENV_MEMP_SYNC, REQ_ENV_MEMP_TRICKLE, + REQ_DB_OPEN, REQ_DB_CLOSE, REQ_DB_COMPACT, REQ_DB_SYNC, + REQ_DB_PUT, REQ_DB_GET, REQ_DB_PGET, REQ_DB_DEL, REQ_DB_KEY_RANGE, REQ_TXN_COMMIT, REQ_TXN_ABORT, REQ_C_CLOSE, REQ_C_COUNT, REQ_C_PUT, REQ_C_GET, REQ_C_PGET, REQ_C_DEL, + REQ_SEQ_OPEN, REQ_SEQ_CLOSE, REQ_SEQ_GET, REQ_SEQ_REMOVE, }; typedef struct aio_cb @@ -109,6 +113,9 @@ SV *sv1, *sv2, *sv3; DBT dbt1, dbt2, dbt3; + DB_KEY_RANGE key_range; + DB_SEQUENCE *seq; + db_seq_t seq_t; } aio_cb; typedef aio_cb *aio_req; @@ -295,7 +302,6 @@ ENTER; SAVETMPS; PUSHMARK (SP); - EXTEND (SP, 1); switch (req->type) { @@ -314,6 +320,31 @@ dbt_to_sv (req->sv2, &req->dbt2); dbt_to_sv (req->sv3, &req->dbt3); break; + + case REQ_DB_KEY_RANGE: + { + AV *av = newAV (); + + av_push (av, newSVnv (req->key_range.less)); + av_push (av, newSVnv (req->key_range.equal)); + av_push (av, newSVnv (req->key_range.greater)); + + SvREADONLY_off (req->sv1); + sv_setsv_mg (req->sv1, newRV_noinc ((SV *)av)); + SvREFCNT_dec (req->sv1); + } + break; + + case REQ_SEQ_GET: + SvREADONLY_off (req->sv1); + + if (sizeof (IV) > 4) + sv_setiv_mg (req->sv1, req->seq_t); + else + sv_setnv_mg (req->sv1, req->seq_t); + + SvREFCNT_dec (req->sv1); + break; } errno = req->result; @@ -642,6 +673,22 @@ 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_DB_OPEN: req->result = req->db->open (req->db, req->txn, req->buf1, req->buf2, req->int1, req->uint1, req->int2); break; @@ -674,6 +721,10 @@ 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; @@ -710,6 +761,22 @@ req->result = req->dbc->c_del (req->dbc, req->uint1); break; + case REQ_SEQ_OPEN: + req->result = req->seq->open (req->seq, req->txn, &req->dbt1, req->uint1); + break; + + case REQ_SEQ_CLOSE: + req->result = req->seq->close (req->seq, req->uint1); + break; + + case REQ_SEQ_GET: + req->result = req->seq->get (req->seq, req->txn, req->int1, &req->seq_t, req->uint1); + break; + + case REQ_SEQ_REMOVE: + req->result = req->seq->remove (req->seq, req->txn, req->uint1); + break; + default: req->result = ENOSYS; break; @@ -954,6 +1021,22 @@ const_iv (KEYFIRST) const_iv (KEYLAST) const_iv (NODUPDATA) + + const_iv (FORCE) + + const_iv (LOCK_DEFAULT) + const_iv (LOCK_EXPIRE) + const_iv (LOCK_MAXLOCKS) + const_iv (LOCK_MAXWRITE) + const_iv (LOCK_MINLOCKS) + const_iv (LOCK_MINWRITE) + const_iv (LOCK_OLDEST) + const_iv (LOCK_RANDOM) + const_iv (LOCK_YOUNGEST) + + const_iv (SEQ_DEC) + const_iv (SEQ_INC) + const_iv (SEQ_WRAP) }; for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) @@ -1102,6 +1185,7 @@ SvREFCNT_dec (prepare_cb); prepare_cb = newSVsv (cb); + DB_ENV * db_env_create (U32 env_flags = 0) CODE: @@ -1117,6 +1201,8 @@ db_env_open (DB_ENV *env, octetstring db_home, U32 open_flags, int mode, SV *callback = &PL_sv_undef) CODE: { + env->set_thread_count (env, get_nthreads ()); + dREQ (REQ_ENV_OPEN); req->env = env; req->uint1 = open_flags | DB_THREAD; @@ -1136,6 +1222,49 @@ ptr_nuke (ST (0)); } +void +db_env_txn_checkpoint (DB_ENV *env, U32 kbyte = 0, U32 min = 0, U32 flags = 0, SV *callback = &PL_sv_undef) + CODE: +{ + dREQ (REQ_ENV_TXN_CHECKPOINT); + req->env = env; + req->uint1 = kbyte; + req->int1 = min; + req->uint2 = flags; + REQ_SEND; +} + +void +db_env_lock_detect (DB_ENV *env, U32 flags = 0, U32 atype = DB_LOCK_DEFAULT, SV *dummy = 0, SV *callback = &PL_sv_undef) + CODE: +{ + dREQ (REQ_ENV_LOCK_DETECT); + req->env = env; + req->uint1 = flags; + req->uint2 = atype; + REQ_SEND; +} + +void +db_env_memp_sync (DB_ENV *env, SV *dummy = 0, SV *callback = &PL_sv_undef) + CODE: +{ + dREQ (REQ_ENV_MEMP_SYNC); + req->env = env; + REQ_SEND; +} + +void +db_env_memp_trickle (DB_ENV *env, int percent, SV *dummy = 0, SV *callback = &PL_sv_undef) + CODE: +{ + dREQ (REQ_ENV_MEMP_TRICKLE); + req->env = env; + req->int1 = percent; + REQ_SEND; +} + + DB * db_create (DB_ENV *env = 0, U32 flags = 0) CODE: @@ -1201,6 +1330,19 @@ } void +db_key_range (DB *db, DB_TXN_ornull *txn, SV *key, SV *key_range, U32 flags = 0, SV *callback = &PL_sv_undef) + CODE: +{ + dREQ (REQ_DB_KEY_RANGE); + req->db = db; + req->txn = txn; + sv_to_dbt (&req->dbt1, key); + req->uint1 = flags; + req->sv1 = SvREFCNT_inc (key_range); SvREADONLY_on (key_range); + REQ_SEND; +} + +void db_put (DB *db, DB_TXN_ornull *txn, SV *key, SV *data, U32 flags = 0, SV *callback = &PL_sv_undef) CODE: { @@ -1371,6 +1513,54 @@ } +void +db_sequence_open (DB_SEQUENCE *seq, DB_TXN_ornull *txnid, SV *key, U32 flags = 0, SV *callback = &PL_sv_undef) + CODE: +{ + dREQ (REQ_SEQ_OPEN); + req->seq = seq; + req->txn = txnid; + req->uint1 = flags | DB_THREAD; + sv_to_dbt (&req->dbt1, key); + REQ_SEND; +} + +void +db_sequence_close (DB_SEQUENCE *seq, U32 flags = 0, SV *callback = &PL_sv_undef) + CODE: +{ + dREQ (REQ_SEQ_CLOSE); + req->seq = seq; + req->uint1 = flags; + REQ_SEND; + ptr_nuke (ST (0)); +} + +void +db_sequence_get (DB_SEQUENCE *seq, DB_TXN_ornull *txnid, int delta, SV *seq_value, U32 flags = DB_TXN_NOSYNC, SV *callback = &PL_sv_undef) + CODE: +{ + dREQ (REQ_SEQ_GET); + req->seq = seq; + req->txn = txnid; + req->int1 = delta; + req->uint1 = flags; + req->sv1 = SvREFCNT_inc (seq_value); SvREADONLY_on (seq_value); + REQ_SEND; +} + +void +db_sequence_remove (DB_SEQUENCE *seq, DB_TXN_ornull *txnid = 0, U32 flags = 0, SV *callback = &PL_sv_undef) + CODE: +{ + dREQ (REQ_SEQ_REMOVE); + req->seq = seq; + req->txn = txnid; + req->uint1 = flags; + REQ_SEND; +} + + MODULE = BDB PACKAGE = BDB::Env void @@ -1379,6 +1569,30 @@ if (env) env->close (env, 0); +int set_data_dir (DB_ENV *env, const char *dir) + CODE: + RETVAL = env->set_data_dir (env, dir); + OUTPUT: + RETVAL + +int set_tmp_dir (DB_ENV *env, const char *dir) + CODE: + RETVAL = env->set_tmp_dir (env, dir); + OUTPUT: + RETVAL + +int set_lg_dir (DB_ENV *env, const char *dir) + CODE: + RETVAL = env->set_lg_dir (env, dir); + OUTPUT: + RETVAL + +int set_shm_key (DB_ENV *env, long shm_key) + CODE: + RETVAL = env->set_shm_key (env, shm_key); + OUTPUT: + RETVAL + int set_cachesize (DB_ENV *env, U32 gbytes, U32 bytes, int ncache = 0) CODE: RETVAL = env->set_cachesize (env, gbytes, bytes, ncache); @@ -1403,6 +1617,60 @@ 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) + 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 + DB_TXN * txn_begin (DB_ENV *env, DB_TXN_ornull *parent = 0, U32 flags = 0) CODE: @@ -1448,7 +1716,6 @@ OUTPUT: RETVAL - int set_bt_minkey (DB *db, U32 minkey) CODE: RETVAL = db->set_bt_minkey (db, minkey); @@ -1506,6 +1773,17 @@ OUTPUT: RETVAL +DB_SEQUENCE * +sequence (DB *db, U32 flags = 0) + CODE: +{ + errno = db_sequence_create (&RETVAL, db, flags); + if (errno) + croak ("db_sequence_create: %s", db_strerror (errno)); +} + OUTPUT: + RETVAL + MODULE = BDB PACKAGE = BDB::Txn @@ -1530,3 +1808,35 @@ if (dbc) dbc->c_close (dbc); +MODULE = BDB PACKAGE = BDB::Sequence + +void +DESTROY (DB_SEQUENCE_ornull *seq) + CODE: + if (seq) + seq->close (seq, 0); + +int initial_value (DB_SEQUENCE *seq, db_seq_t value) + CODE: + RETVAL = seq->initial_value (seq, value); + OUTPUT: + RETVAL + +int set_cachesize (DB_SEQUENCE *seq, U32 size) + CODE: + RETVAL = seq->set_cachesize (seq, size); + OUTPUT: + RETVAL + +int set_flags (DB_SEQUENCE *seq, U32 flags) + CODE: + RETVAL = seq->set_flags (seq, flags); + OUTPUT: + RETVAL + +int set_range (DB_SEQUENCE *seq, db_seq_t min, db_seq_t max) + CODE: + RETVAL = seq->set_range (seq, min, max); + OUTPUT: + RETVAL +