%PDF-
%PDF-
Mini Shell
Mini Shell
#include "bdb1.h"
VALUE bdb1_eFatal;
VALUE bdb1_mDb, bdb1_mMarshal, bdb1_cCommon, bdb1_cRecnum;
static ID id_dump, id_load;
ID bdb1_id_current_db;
static VALUE bdb1_cBtree, bdb1_cHash, bdb1_cUnknown;
static ID id_bt_compare, id_bt_prefix, id_h_hash, bdb1_id_call;
static VALUE bdb1_errstr;
static int bdb1_errcall = 0;
static const char *
db_strerror(int err)
{
if (err == 0)
return "" ;
if (err > 0)
return strerror(err) ;
return "Unknown Error" ;
}
int
bdb1_test_error(int comm)
{
VALUE error;
switch (comm) {
case 0:
case 1:
break;
default:
error = bdb1_eFatal;
if (bdb1_errcall) {
bdb1_errcall = 0;
rb_raise(error, "%s -- %s", StringValueCStr(bdb1_errstr), db_strerror(comm));
}
else
rb_raise(error, "%s", db_strerror(errno));
}
return comm;
}
static VALUE
test_dump(VALUE obj, DBT *key, VALUE a, int type_kv)
{
bdb1_DB *dbst;
VALUE tmp = a;
Data_Get_Struct(obj, bdb1_DB, dbst);
if (dbst->filter[type_kv]) {
if (FIXNUM_P(dbst->filter[type_kv])) {
tmp = rb_funcall(obj, NUM2INT(dbst->filter[type_kv]), 1, a);
}
else {
tmp = rb_funcall(dbst->filter[type_kv], bdb1_id_call, 1, a);
}
}
if (dbst->marshal != Qundef) {
if (rb_obj_is_kind_of(a, bdb1_cDelegate)) {
tmp = bdb1_deleg_to_orig(tmp);
}
tmp = rb_funcall(dbst->marshal, id_dump, 1, tmp);
if (TYPE(tmp) != T_STRING) {
rb_raise(rb_eTypeError, "dump() must return String");
}
}
else {
tmp = rb_obj_as_string(tmp);
if (NIL_P(a)) {
key->data = StringValueCStr(tmp);
key->size = RSTRING_LEN(tmp) + 1;
return tmp;
}
}
key->data = StringValuePtr(tmp);
key->size = RSTRING_LEN(tmp);
return tmp;
}
static VALUE
test_ret(VALUE obj, VALUE tmp, VALUE a, int type_kv)
{
bdb1_DB *dbst;
Data_Get_Struct(obj, bdb1_DB, dbst);
if (dbst->marshal != Qundef || NIL_P(a)) {
return a;
}
if (dbst->filter[type_kv]) {
return rb_obj_as_string(a);
}
return tmp;
}
static VALUE
test_recno(VALUE obj, DBT *key, db_recno_t *recno, VALUE a)
{
bdb1_DB *dbst;
Data_Get_Struct(obj, bdb1_DB, dbst);
if (dbst->type == DB_RECNO) {
*recno = NUM2INT(a) + dbst->array_base;
key->data = recno;
key->size = sizeof(db_recno_t);
return a;
}
return test_dump(obj, key, a, FILTER_KEY);
}
VALUE
bdb1_test_load(VALUE obj, const DBT *a, int type_kv)
{
VALUE res;
int i;
bdb1_DB *dbst;
Data_Get_Struct(obj, bdb1_DB, dbst);
if (dbst->marshal != Qundef) {
res = rb_str_new(a->data, a->size);
if (dbst->filter[2 + type_kv]) {
if (FIXNUM_P(dbst->filter[2 + type_kv])) {
res = rb_funcall(obj,
NUM2INT(dbst->filter[2 + type_kv]), 1, res);
}
else {
res = rb_funcall(dbst->filter[2 + type_kv],
bdb1_id_call, 1, res);
}
}
res = rb_funcall(dbst->marshal, id_load, 1, res);
}
else {
if (a->size == 1 && ((char *)a->data)[0] == '\000') {
res = Qnil;
}
else {
res = rb_tainted_str_new(a->data, a->size);
if (dbst->filter[2 + type_kv]) {
if (FIXNUM_P(dbst->filter[2 + type_kv])) {
res = rb_funcall(obj,
NUM2INT(dbst->filter[2 + type_kv]),
1, res);
}
else {
res = rb_funcall(dbst->filter[2 + type_kv],
bdb1_id_call, 1, res);
}
}
}
}
return res;
}
static VALUE
test_load_dyna(VALUE obj, DBT *key, DBT *val)
{
bdb1_DB *dbst;
VALUE del, res, tmp;
struct deleg_class *delegst;
Data_Get_Struct(obj, bdb1_DB, dbst);
res = bdb1_test_load(obj, val, FILTER_VALUE);
if (dbst->marshal != Qundef && !SPECIAL_CONST_P(res)) {
del = Data_Make_Struct(bdb1_cDelegate, struct deleg_class,
bdb1_deleg_mark, bdb1_deleg_free, delegst);
delegst->db = obj;
if (dbst->type == DB_RECNO) {
tmp = INT2NUM((*(db_recno_t *)key->data) - dbst->array_base);
}
else {
tmp = rb_str_new(key->data, key->size);
}
delegst->key = rb_funcall(dbst->marshal, id_load, 1, tmp);
delegst->obj = res;
res = del;
}
return res;
}
static int
bdb1_bt_compare(const DBT *a, const DBT *b)
{
VALUE obj, av, bv, res;
bdb1_DB *dbst;
if (NIL_P(obj = rb_thread_local_aref(rb_thread_current(), bdb1_id_current_db))) {
rb_raise(bdb1_eFatal, "BUG : current_db not set");
}
Data_Get_Struct(obj, bdb1_DB, dbst);
av = bdb1_test_load(obj, a, FILTER_VALUE);
bv = bdb1_test_load(obj, b, FILTER_VALUE);
if (dbst->bt_compare == 0)
res = rb_funcall(obj, id_bt_compare, 2, av, bv);
else
res = rb_funcall(dbst->bt_compare, bdb1_id_call, 2, av, bv);
return NUM2INT(res);
}
static size_t
bdb1_bt_prefix(const DBT *a, const DBT *b)
{
VALUE obj, av, bv, res;
bdb1_DB *dbst;
if (NIL_P(obj = rb_thread_local_aref(rb_thread_current(), bdb1_id_current_db))) {
rb_raise(bdb1_eFatal, "BUG : current_db not set");
}
Data_Get_Struct(obj, bdb1_DB, dbst);
av = bdb1_test_load(obj, a, FILTER_VALUE);
bv = bdb1_test_load(obj, b, FILTER_VALUE);
if (dbst->bt_prefix == 0)
res = rb_funcall(obj, id_bt_prefix, 2, av, bv);
else
res = rb_funcall(dbst->bt_prefix, bdb1_id_call, 2, av, bv);
return NUM2INT(res);
}
static u_int32_t
bdb1_h_hash(const void *bytes, size_t length)
{
VALUE obj, st, res;
bdb1_DB *dbst;
if (NIL_P(obj = rb_thread_local_aref(rb_thread_current(), bdb1_id_current_db))) {
rb_raise(bdb1_eFatal, "BUG : current_db not set");
}
Data_Get_Struct(obj, bdb1_DB, dbst);
st = rb_tainted_str_new((char *)bytes, length);
if (dbst->h_hash == 0)
res = rb_funcall(obj, id_h_hash, 1, st);
else
res = rb_funcall(dbst->h_hash, bdb1_id_call, 1, st);
return (u_int32_t)NUM2LONG(res);
}
static void
bdb1_i_close(bdb1_DB *dbst)
{
if (dbst->dbp != NULL && !(dbst->options & BDB1_NOT_OPEN)) {
dbst->options |= BDB1_NOT_OPEN;
bdb1_test_error(dbst->dbp->close(dbst->dbp));
}
dbst->dbp = NULL;
}
static void
bdb1_free(bdb1_DB *dbst)
{
bdb1_i_close(dbst);
free(dbst);
}
static void
bdb1_mark(bdb1_DB *dbst)
{
int i;
rb_gc_mark(dbst->marshal);
rb_gc_mark(dbst->bt_compare);
rb_gc_mark(dbst->bt_prefix);
rb_gc_mark(dbst->h_hash);
for (i = 0; i < 4; i++) {
rb_gc_mark(dbst->filter[i]);
}
}
static VALUE
bdb1_i185_btree(VALUE obj, VALUE dbstobj)
{
VALUE key, value;
bdb1_DB *dbst;
char *options;
Data_Get_Struct(dbstobj, bdb1_DB, dbst);
key = rb_ary_entry(obj, 0);
value = rb_ary_entry(obj, 1);
key = rb_obj_as_string(key);
options = StringValueCStr(key);
if (strcmp(options, "set_flags") == 0) {
dbst->has_info = Qtrue;
dbst->info.bi.flags = NUM2INT(value);
}
else if (strcmp(options, "set_cachesize") == 0) {
dbst->has_info = Qtrue;
dbst->info.bi.cachesize = NUM2INT(value);
}
else if (strcmp(options, "set_bt_minkey") == 0) {
dbst->has_info = Qtrue;
dbst->info.bi.minkeypage = NUM2INT(value);
}
else if (strcmp(options, "set_pagesize") == 0) {
dbst->has_info = Qtrue;
dbst->info.bi.psize = NUM2INT(value);
}
else if (strcmp(options, "set_bt_compare") == 0) {
if (!rb_respond_to(value, bdb1_id_call)) {
rb_raise(bdb1_eFatal, "arg must respond to #call");
}
dbst->has_info = Qtrue;
dbst->options |= BDB1_BT_COMPARE;
dbst->bt_compare = value;
dbst->info.bi.compare = bdb1_bt_compare;
}
else if (strcmp(options, "set_bt_prefix") == 0) {
if (!rb_respond_to(value, bdb1_id_call)) {
rb_raise(bdb1_eFatal, "arg must respond to #call");
}
dbst->has_info = Qtrue;
dbst->options |= BDB1_BT_PREFIX;
dbst->bt_prefix = value;
dbst->info.bi.prefix = bdb1_bt_prefix;
}
else if (strcmp(options, "set_lorder") == 0) {
dbst->has_info = Qtrue;
dbst->info.bi.lorder = NUM2INT(value);
}
return Qnil;
}
static VALUE
bdb1_i185_hash(VALUE obj, VALUE dbstobj)
{
VALUE key, value;
bdb1_DB *dbst;
char *options;
Data_Get_Struct(dbstobj, bdb1_DB, dbst);
key = rb_ary_entry(obj, 0);
value = rb_ary_entry(obj, 1);
key = rb_obj_as_string(key);
options = StringValueCStr(key);
if (strcmp(options, "set_h_ffactor") == 0) {
dbst->has_info = Qtrue;
dbst->info.hi.ffactor = NUM2INT(value);
}
else if (strcmp(options, "set_h_nelem") == 0) {
dbst->has_info = Qtrue;
dbst->info.hi.nelem = NUM2INT(value);
}
else if (strcmp(options, "set_cachesize") == 0) {
dbst->has_info = Qtrue;
dbst->info.hi.cachesize = NUM2INT(value);
}
else if (strcmp(options, "set_h_hash") == 0) {
if (!rb_respond_to(value, bdb1_id_call)) {
rb_raise(bdb1_eFatal, "arg must respond to #call");
}
dbst->has_info = Qtrue;
dbst->options |= BDB1_H_HASH;
dbst->h_hash = value;
dbst->info.hi.hash = bdb1_h_hash;
}
else if (strcmp(options, "set_lorder") == 0) {
dbst->has_info = Qtrue;
dbst->info.hi.lorder = NUM2INT(value);
}
return Qnil;
}
static VALUE
bdb1_i185_recno(VALUE obj, VALUE dbstobj)
{
VALUE key, value;
bdb1_DB *dbst;
char *options, *str;
Data_Get_Struct(dbstobj, bdb1_DB, dbst);
key = rb_ary_entry(obj, 0);
value = rb_ary_entry(obj, 1);
key = rb_obj_as_string(key);
options = StringValueCStr(key);
if (strcmp(options, "set_flags") == 0) {
dbst->has_info = Qtrue;
dbst->info.ri.flags = NUM2INT(value);
}
else if (strcmp(options, "set_re_delim") == 0) {
int ch;
if (TYPE(value) == T_STRING) {
str = StringValueCStr(value);
dbst->info.ri.bval = str[0];
}
else {
dbst->info.ri.bval = NUM2INT(value);
}
dbst->has_info = Qtrue;
dbst->info.ri.flags |= R_FIXEDLEN;
}
else if (strcmp(options, "set_re_len") == 0) {
dbst->has_info = Qtrue;
dbst->info.ri.reclen = NUM2INT(value);
dbst->info.ri.flags |= R_FIXEDLEN;
}
else if (strcmp(options, "set_re_pad") == 0) {
int ch;
if (TYPE(value) == T_STRING) {
str = StringValueCStr(value);
dbst->info.ri.bval = str[0];
}
else {
dbst->info.ri.bval = NUM2INT(value);
}
dbst->has_info = Qtrue;
dbst->info.ri.flags |= R_FIXEDLEN;
}
else if (strcmp(options, "set_cachesize") == 0) {
dbst->has_info = Qtrue;
dbst->info.ri.cachesize = NUM2INT(value);
}
else if (strcmp(options, "set_pagesize") == 0) {
dbst->has_info = Qtrue;
dbst->info.ri.psize = NUM2INT(value);
}
else if (strcmp(options, "set_lorder") == 0) {
dbst->has_info = Qtrue;
dbst->info.ri.lorder = NUM2INT(value);
}
else if (strcmp(options, "set_array_base") == 0 ||
strcmp(options, "array_base") == 0) {
int ary_base = NUM2INT(value);
switch (ary_base) {
case 0: dbst->array_base = 1; break;
case 1: dbst->array_base = 0; break;
default: rb_raise(bdb1_eFatal, "array base must be 0 or 1");
}
}
return Qnil;
}
static VALUE
bdb1_load_dump(VALUE obj)
{
VALUE res;
res = rb_funcall(obj, rb_intern("respond_to?"), 2, ID2SYM(id_load), Qtrue);
if (RTEST(res)) {
res = rb_funcall(obj, rb_intern("respond_to?"), 2, ID2SYM(id_dump), Qtrue);
}
return res;
}
static VALUE
bdb1_i185_common(VALUE obj, VALUE dbstobj)
{
VALUE key, value;
bdb1_DB *dbst;
char *options;
Data_Get_Struct(dbstobj, bdb1_DB, dbst);
key = rb_ary_entry(obj, 0);
value = rb_ary_entry(obj, 1);
key = rb_obj_as_string(key);
options = StringValueCStr(key);
if (strcmp(options, "marshal") == 0) {
switch (value) {
case Qtrue:
dbst->marshal = bdb1_mMarshal;
dbst->options |= BDB1_MARSHAL;
break;
case Qfalse:
dbst->marshal = Qundef;
dbst->options &= ~BDB1_MARSHAL;
break;
default:
if (!RTEST(bdb1_load_dump(value))) {
rb_raise(bdb1_eFatal, "marshal value must be true or false");
}
dbst->marshal = value;
dbst->options |= BDB1_MARSHAL;
break;
}
}
else if (strcmp(options, "set_store_key") == 0) {
if (!rb_respond_to(value, bdb1_id_call)) {
rb_raise(bdb1_eFatal, "arg must respond to #call");
}
dbst->filter[FILTER_KEY] = value;
}
else if (strcmp(options, "set_fetch_key") == 0) {
if (!rb_respond_to(value, bdb1_id_call)) {
rb_raise(bdb1_eFatal, "arg must respond to #call");
}
dbst->filter[2 + FILTER_KEY] = value;
}
else if (strcmp(options, "set_store_value") == 0) {
if (!rb_respond_to(value, bdb1_id_call)) {
rb_raise(bdb1_eFatal, "arg must respond to #call");
}
dbst->filter[FILTER_VALUE] = value;
}
else if (strcmp(options, "set_fetch_value") == 0) {
if (!rb_respond_to(value, bdb1_id_call)) {
rb_raise(bdb1_eFatal, "arg must respond to #call");
}
dbst->filter[2 + FILTER_VALUE] = value;
}
return Qnil;
}
static int
bdb1_hard_count(DB *dbp)
{
DBT key, data;
db_recno_t recno;
int count = 0;
DATA_ZERO(key);
key.data = &recno;
key.size = sizeof(db_recno_t);
DATA_ZERO(data);
if (bdb1_test_error(dbp->seq(dbp, &key, &data, DB_LAST)) == 0) {
count = *(db_recno_t *)key.data;
}
return count;
}
/*
* call-seq:
*
* BDB1::Btree.new(name = nil, flags = "r", mode = 0, options = {})
* BDB1::Hash.new(name = nil, flags = "r", mode = 0, options = {})
* BDB1::Recnum.new(name = nil, flags = "r", mode = 0, options = {})
*
* Open the database.
*
* * +name+
* The argument name is used as the name of a single physical
* file on disk that will be used to back the database.
*
* If +nil+ is given, an on-memory database is created.
*
* * +flags+
* The flags must be the string "r", "r+", "w", "w+", "a", "a+" or
* and integer value.
*
* The flags value must be set to 0 or by bitwise inclusively
* OR'ing together one or more of the following values
*
* * +BDB1::CREATE+
* Create any underlying files, as necessary. If the files
* do not already exist and the DB_CREATE flag is not
* specified, the call will fail.
*
* * +BDB1::RDONLY+
* Open the database for reading only. Any attempt to
* modify items in the database will fail regardless of the
* actual permissions of any underlying files.
*
* * +BDB1::TRUNCATE+
* Physically truncate the underlying database file,
* discarding all previous subdatabases or databases.
* Underlying filesystem primitives are used to implement
* this flag. For this reason it is only applicable to the
* physical database file and cannot be used to discard
* subdatabases.
*
* The DB_TRUNCATE flag cannot be transaction protected,
* and it is an error to specify it in a transaction
* protected environment.
*
* * +BDB1::WRITE+
* Open the database for writing. Without this flag, any
* attempt to modify items in the database will fail.
*
* * +mode+
* mode to create the file
*
* * +options+
* Hash, Possible options are (see the documentation of Berkeley DB
* for more informations)
*
* * +set_flags+: general database configuration
* * +set_cachesize+: set the database cache size
* * +set_pagesize+: set the underlying database page size
* * +set_lorder+: set the database byte order
* * +set_store_key+: specify a Proc called before a key is stored
* * +set_fetch_key+: specify a Proc called after a key is read
* * +set_store_value+: specify a Proc called before a value is stored
* * +set_fetch_value+: specify a Proc called after a value is read
*
* * +options specific to BDB1::Btree+
*
* * +set_bt_compare+: specify a Btree comparison function
* * +set_bt_minkey+: set the minimum number of keys per Btree page
* * +set_bt_prefix+: specify a Btree prefix comparison function
*
* * +options specific to BDB1::Hash+
*
* * +set_h_ffactor+: set the Hash table density
* * +set_h_hash+: specify a hashing function
* * +set_h_nelem+: set the Hash table size
*
* * +options specific to BDB1::Recnum+
*
* * +set_re_delim+: set the variable-length record delimiter
* * +set_re_len+: set the fixed-length record length
* * +set_re_pad+: set the fixed-length record pad byte
*
* Proc given to +set_bt_compare+, +set_bt_prefix+,
* +set_h_hash+, +set_store_key+, +set_fetch_key+,
* +set_store_value+ and +set_fetch_value+ can be also
* specified as a method (replace the prefix +set_+ with
* +bdb1_+)
*
* For example:
*
* module BDB1
* class Btreesort < Btree
* def bdb1_bt_compare(a, b)
* b.downcase <=> a.downcase
* end
* end
* end
*/
VALUE
bdb1_init(int argc, VALUE *argv, VALUE obj)
{
VALUE b, c, d, f;
int mode, oflags;
char *name;
bdb1_DB *dbst;
void *openinfo = NULL;
f = Qnil; name = NULL;
mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
oflags = DB_RDONLY;
if (argc && TYPE(argv[argc - 1]) == T_HASH) {
f = argv[argc - 1];
argc--;
}
switch(rb_scan_args(argc, argv, "03", &b, &c, &d)) {
case 3:
mode = NUM2INT(d);
/* ... */
case 2:
if (TYPE(c) == T_STRING) {
char *m = StringValueCStr(c);
if (strcmp(m, "r") == 0) {
oflags = DB_RDONLY;
}
else if (strcmp(m, "r+") == 0) {
oflags = DB_WRITE;
}
else if (strcmp(m, "w") == 0 || strcmp(m, "w+") == 0) {
oflags = DB_CREATE | DB_TRUNCATE | DB_WRITE;
}
else if (strcmp(m, "a") == 0 || strcmp(m, "a+") == 0) {
oflags = DB_CREATE | DB_WRITE;
}
else {
rb_raise(bdb1_eFatal, "flags must be r, r+, w, w+, a or a+");
}
}
else if (NIL_P(c)) {
oflags = DB_RDONLY;
}
else {
oflags = NUM2INT(c);
}
/* ... */
case 1:
if (!NIL_P(b)) {
SafeStringValue(b);
name = StringValueCStr(b);
}
else {
name = NULL;
}
/* ... */
}
Data_Get_Struct(obj, bdb1_DB, dbst);
if (dbst->type < DB_BTREE || dbst->type > DB_RECNO) {
rb_raise(bdb1_eFatal, "Unknown db185 type %d", dbst->type);
}
if (!NIL_P(f)) {
if (TYPE(f) != T_HASH) {
rb_raise(bdb1_eFatal, "options must be an hash");
}
switch(dbst->type) {
case 0:
rb_iterate(rb_each, f, bdb1_i185_btree, obj);
if (dbst->bt_compare == 0 && rb_respond_to(obj, id_bt_compare)) {
dbst->has_info = Qtrue;
dbst->options |= BDB1_BT_COMPARE;
dbst->info.bi.compare = bdb1_bt_compare;
}
if (dbst->bt_prefix == 0 && rb_respond_to(obj, id_bt_prefix)) {
dbst->has_info = Qtrue;
dbst->options |= BDB1_BT_PREFIX;
dbst->info.bi.prefix = bdb1_bt_prefix;
}
break;
case 1:
rb_iterate(rb_each, f, bdb1_i185_hash, obj);
if (dbst->h_hash == 0 && rb_respond_to(obj, id_h_hash)) {
dbst->has_info = Qtrue;
dbst->options |= BDB1_H_HASH;
dbst->info.hi.hash = bdb1_h_hash;
}
break;
case 2:
rb_iterate(rb_each, f, bdb1_i185_recno, obj);
break;
}
rb_iterate(rb_each, f, bdb1_i185_common, obj);
}
if (name == NULL) oflags = O_CREAT | O_RDWR;
if (dbst->has_info) openinfo = &dbst->info;
dbst->dbp = dbopen(name, oflags, mode, dbst->type, openinfo);
if (dbst->dbp == NULL) {
rb_raise(bdb1_eFatal, "Failed `%s'", db_strerror(errno));
}
dbst->options &= ~BDB1_NOT_OPEN;
if (dbst->type == 2) {
dbst->len = bdb1_hard_count(dbst->dbp);
}
return obj;
}
/*
* call-seq:
* db.close(flags = 0)
*
* Closes the file.
*/
static VALUE
bdb1_close(VALUE obj)
{
VALUE opt;
bdb1_DB *dbst;
if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4) {
rb_raise(rb_eSecurityError, "Insecure: can't close the database");
}
Data_Get_Struct(obj, bdb1_DB, dbst);
bdb1_i_close(dbst);
return Qnil;
}
VALUE
bdb1_s_alloc(VALUE obj)
{
bdb1_DB *dbst;
VALUE res, cl;
res = Data_Make_Struct(obj, bdb1_DB, bdb1_mark, bdb1_free, dbst);
dbst->marshal = Qundef;
dbst->options |= BDB1_NOT_OPEN;
cl = obj;
while (cl) {
if (cl == bdb1_cBtree || RCLASS(cl)->m_tbl == RCLASS(bdb1_cBtree)->m_tbl) {
dbst->type = DB_BTREE;
break;
}
else if (cl == bdb1_cHash || RCLASS(cl)->m_tbl == RCLASS(bdb1_cHash)->m_tbl) {
dbst->type = DB_HASH;
break;
}
else if (cl == bdb1_cRecnum || RCLASS(cl)->m_tbl == RCLASS(bdb1_cRecnum)->m_tbl) {
dbst->type = DB_RECNO;
break;
}
cl = RCLASS_SUPER(cl);
}
if (!cl) {
rb_raise(bdb1_eFatal, "unknown database type");
}
if (RTEST(bdb1_load_dump(obj))) {
dbst->marshal = obj;
dbst->options |= BDB1_MARSHAL;
}
if (rb_method_boundp(obj, rb_intern("bdb1_store_key"), 0)) {
dbst->filter[FILTER_KEY] = INT2FIX(rb_intern("bdb1_store_key"));
}
if (rb_method_boundp(obj, rb_intern("bdb1_fetch_key"), 0)) {
dbst->filter[2 + FILTER_KEY] = INT2FIX(rb_intern("bdb1_fetch_key"));
}
if (rb_method_boundp(obj, rb_intern("bdb1_store_value"), 0)) {
dbst->filter[FILTER_VALUE] = INT2FIX(rb_intern("bdb1_store_value"));
}
if (rb_method_boundp(obj, rb_intern("bdb1_fetch_value"), 0)) {
dbst->filter[2 + FILTER_VALUE] = INT2FIX(rb_intern("bdb1_fetch_value"));
}
return res;
}
/*
* Same as +new+.
*/
static VALUE
bdb1_s_create(int argc, VALUE *argv, VALUE obj)
{
VALUE st, res;
res = rb_funcall2(obj, rb_intern("allocate"), 0, 0);
rb_obj_call_init(res, argc, argv);
return res;
}
static VALUE
bdb1_i_create(VALUE obj, VALUE db)
{
VALUE tmp[2];
tmp[0] = rb_ary_entry(obj, 0);
tmp[1] = rb_ary_entry(obj, 1);
bdb1_put(2, tmp, db);
return Qnil;
}
/*
* call-seq:
* BDB1::Btree[hash]
* BDB1::Btree[key1, value1, key2, value2, ...]
* BDB1::Hash[hash]
* BDB1::Hash[key1, value1, key2, value2, ...]
* BDB1::Recnum[hash]
* BDB1::Recnum[key1, value1, key2, value2, ...]
*
* Creates a new temporary on-memory database, populated with the
* given hash or pairs of objects.
*/
static VALUE
bdb1_s_aref(int argc, VALUE *argv, VALUE obj)
{
VALUE res, tmp[2];
int i;
res = rb_funcall2(obj, rb_intern("new"), 0, 0);
if (argc == 1 && TYPE(argv[0]) == T_HASH) {
rb_iterate(rb_each, argv[0], bdb1_i_create, res);
return res;
}
if (argc % 2 != 0) {
rb_raise(rb_eArgError, "odd number args for %s", rb_class2name(obj));
}
for (i = 0; i < argc; i += 2) {
bdb1_put(2, argv + i, res);
}
return res;
}
/*
* Same as +new+ except that if a block is given it is called with an
* initialized object which is automatically closed when done.
*/
static VALUE
bdb1_s_open(int argc, VALUE *argv, VALUE obj)
{
VALUE res = rb_funcall2(obj, rb_intern("new"), argc, argv);
if (rb_block_given_p()) {
return rb_ensure(rb_yield, res, bdb1_close, res);
}
return res;
}
/*
* call-seq:
* db.put(key, value, flags = 0)
*
* Stores the +value+ associating with +key+ and returns the value
* stored.
*
* +flags+ can have the value +DBD::NOOVERWRITE+, in this case it will
* return +nil+ if the specified key exist, otherwise +true+.
*/
VALUE
bdb1_put(int argc, VALUE *argv, VALUE obj)
{
volatile VALUE a0 = Qnil;
volatile VALUE b0 = Qnil;
VALUE a, b, c;
bdb1_DB *dbst;
DBT key, data;
int ret, flags;
db_recno_t recno;
rb_secure(4);
GetDB(obj, dbst);
if (rb_scan_args(argc, argv, "21", &a, &b, &c) == 3)
flags = NUM2INT(c);
else
flags = 0;
DATA_ZERO(key);
DATA_ZERO(data);
a0 = test_recno(obj, &key, &recno, a);
b0 = test_dump(obj, &data, b, FILTER_VALUE);
ret = bdb1_test_error(dbst->dbp->put(dbst->dbp, &key, &data, flags));
if (ret == DB_KEYEXIST)
return Qfalse;
return test_ret(obj, b0, b, FILTER_VALUE);
}
static VALUE
bdb1_assign(VALUE obj, VALUE a, VALUE b)
{
VALUE tmp[2];
tmp[0] = a;
tmp[1] = b;
bdb1_put(2, tmp, obj);
return b;
}
static VALUE
test_load_key(VALUE obj, DBT *key)
{
bdb1_DB *dbst;
Data_Get_Struct(obj, bdb1_DB, dbst);
if (dbst->type == DB_RECNO)
return INT2NUM((*(db_recno_t *)key->data) - dbst->array_base);
return bdb1_test_load(obj, key, FILTER_KEY);
}
static VALUE
bdb1_assoc(VALUE obj, DBT *key, DBT *data)
{
return rb_assoc_new(test_load_key(obj, key),
bdb1_test_load(obj, data, FILTER_VALUE));
}
static VALUE
bdb1_assoc_dyna(VALUE obj, DBT *key, DBT *data)
{
return rb_assoc_new(test_load_key(obj, key),
test_load_dyna(obj, key, data));
}
static VALUE
bdb1_get_internal(int argc, VALUE *argv, VALUE obj, VALUE notfound, int dyna)
{
volatile VALUE a = Qnil;
VALUE b, c;
bdb1_DB *dbst;
DBT key, data;
DBT datas;
int flagss;
int ret, flags;
db_recno_t recno;
flagss = flags = 0;
GetDB(obj, dbst);
DATA_ZERO(key);
DATA_ZERO(data);
switch(rb_scan_args(argc, argv, "12", &a, &b, &c)) {
case 3:
flags = NUM2INT(c);
break;
case 2:
flagss = flags = NUM2INT(b);
break;
}
a = test_recno(obj, &key, &recno, a);
ret = bdb1_test_error(dbst->dbp->get(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND)
return notfound;
if (dyna) {
return test_load_dyna(obj, &key, &data);
}
else {
return bdb1_test_load(obj, &data, FILTER_VALUE);
}
}
VALUE
bdb1_get(int argc, VALUE *argv, VALUE obj)
{
return bdb1_get_internal(argc, argv, obj, Qnil, 0);
}
/*
* call-seq:
* db[key]
* db[key, flags = 0]
*
* Returns the value corresponding to +key+.
*/
static VALUE
bdb1_get_dyna(int argc, VALUE *argv, VALUE obj)
{
return bdb1_get_internal(argc, argv, obj, Qnil, 1);
}
static VALUE
bdb1_fetch(int argc, VALUE *argv, VALUE obj)
{
VALUE key, if_none;
VALUE val;
rb_scan_args(argc, argv, "11", &key, &if_none);
val = bdb1_get_internal(1, argv, obj, Qundef, 1);
if (val == Qundef) {
if (rb_block_given_p()) {
if (argc > 1) {
rb_raise(rb_eArgError, "wrong # of arguments", argc);
}
return rb_yield(key);
}
if (argc == 1) {
rb_raise(rb_eIndexError, "key not found");
}
return if_none;
}
return val;
}
static VALUE
bdb1_has_key(VALUE obj, VALUE key)
{
return bdb1_get_internal(1, &key, obj, Qfalse, 0);
}
/*
* call-seq:
* db.has_both?(key, value)
*
* Returns +true+ if the association from +key+ is +value+.
*/
static VALUE
bdb1_has_both(VALUE obj, VALUE a, VALUE b)
{
bdb1_DB *dbst;
DBT key, data;
DBT keys, datas;
int ret, flags;
db_recno_t recno;
volatile VALUE c = Qnil;
volatile VALUE d = Qnil;
GetDB(obj, dbst);
DATA_ZERO(key);
DATA_ZERO(data);
c = test_recno(obj, &key, &recno, a);
d = test_dump(obj, &data, b, FILTER_VALUE);
MEMCPY(&keys, &key, DBT, 1);
MEMCPY(&datas, &data, DBT, 1);
flags = (dbst->type == DB_HASH)?DB_FIRST:R_CURSOR;
while (1) {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND) {
return Qfalse;
}
if (key.size == keys.size &&
memcmp(keys.data, key.data, key.size) == 0 &&
data.size == datas.size &&
memcmp(datas.data, data.data, data.size) == 0) {
return Qtrue;
}
flags = DB_NEXT;
}
return Qnil;
}
/*
* call-seq:
* db.delete(key)
*
* Removes the association from the +key+.
*
* It returns the object deleted or +nil+ if the specified key doesn't
* exist.
*/
VALUE
bdb1_del(VALUE obj, VALUE a)
{
bdb1_DB *dbst;
DBT key;
int ret;
db_recno_t recno;
volatile VALUE c = Qnil;
rb_secure(4);
GetDB(obj, dbst);
if (dbst->type == DB_HASH) {
rb_warning("delete can give strange result with DB_HASH");
}
DATA_ZERO(key);
c = test_recno(obj, &key, &recno, a);
ret = bdb1_test_error(dbst->dbp->del(dbst->dbp, &key, 0));
if (ret == DB_NOTFOUND)
return Qnil;
else
return obj;
}
static VALUE
bdb1_empty(VALUE obj)
{
bdb1_DB *dbst;
DBT key, data;
int ret, flags;
db_recno_t recno;
GetDB(obj, dbst);
INIT_RECNO(dbst, key, recno);
DATA_ZERO(data);
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, DB_FIRST));
if (ret == DB_NOTFOUND) {
return Qtrue;
}
FREE_KEY(dbst, key);
return Qfalse;
}
static VALUE
bdb1_delete_if(VALUE obj)
{
bdb1_DB *dbst;
DBT key, data, save;
int ret, ret1, flags;
db_recno_t recno;
rb_secure(4);
GetDB(obj, dbst);
INIT_RECNO(dbst, key, recno);
DATA_ZERO(data);
flags = DB_FIRST;
do {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND) {
return Qnil;
}
flags = DB_NEXT;
if (RTEST(rb_yield(bdb1_assoc(obj, &key, &data)))) {
bdb1_test_error(dbst->dbp->del(dbst->dbp, 0, R_CURSOR));
}
} while (1);
return obj;
}
VALUE
bdb1_clear(VALUE obj)
{
bdb1_DB *dbst;
DBT key, data, save;
int ret, value, flags;
db_recno_t recno;
rb_secure(4);
GetDB(obj, dbst);
INIT_RECNO(dbst, key, recno);
DATA_ZERO(data);
flags = DB_FIRST;
value = 0;
do {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND) {
return INT2NUM(value);
}
value++;
bdb1_test_error(dbst->dbp->del(dbst->dbp, 0, R_CURSOR));
} while (1);
return INT2NUM(-1);
}
static VALUE
bdb1_length(VALUE obj)
{
bdb1_DB *dbst;
DBT key, data;
int ret, value, flags;
db_recno_t recno;
GetDB(obj, dbst);
if (dbst->type == DB_RECNO) {
return INT2NUM(bdb1_hard_count(dbst->dbp));
}
INIT_RECNO(dbst, key, recno);
DATA_ZERO(data);
value = 0;
flags = DB_FIRST;
do {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND) {
return INT2NUM(value);
}
flags = DB_NEXT;
FREE_KEY(dbst, key);
value++;
} while (1);
return INT2NUM(value);
}
static VALUE
bdb1_each_valuec(VALUE obj, VALUE sens, VALUE result)
{
bdb1_DB *dbst;
DBT key, data;
int ret, flags;
db_recno_t recno;
VALUE interm, rest;
GetDB(obj, dbst);
INIT_RECNO(dbst, key, recno);
DATA_ZERO(data);
flags = (sens == DB_NEXT)?DB_FIRST:DB_LAST;
do {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND) {
return result;
}
flags = sens;
FREE_KEY(dbst, key);
interm = bdb1_test_load(obj, &data, FILTER_VALUE);
rest = rb_yield(interm);
if (!NIL_P(result) && RTEST(rest)) {
rb_ary_push(result, interm);
}
} while (1);
}
VALUE
bdb1_each_value(VALUE obj)
{
return bdb1_each_valuec(obj, DB_NEXT, Qnil);
}
VALUE
bdb1_each_eulav(VALUE obj)
{
return bdb1_each_valuec(obj, DB_PREV, Qnil);
}
static VALUE
bdb1_each_keyc(VALUE obj, int sens)
{
bdb1_DB *dbst;
DBT key, data;
int ret, flags;
db_recno_t recno;
GetDB(obj, dbst);
INIT_RECNO(dbst, key, recno);
DATA_ZERO(data);
flags = (sens == DB_NEXT)?DB_FIRST:DB_LAST;
do {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND) {
return Qnil;
}
rb_yield(test_load_key(obj, &key));
flags = sens;
} while (1);
return obj;
}
VALUE
bdb1_each_key(VALUE obj)
{
return bdb1_each_keyc(obj, DB_NEXT);
}
static VALUE
bdb1_each_yek(VALUE obj)
{
return bdb1_each_keyc(obj, DB_PREV);
}
static VALUE
bdb1_each_common(VALUE obj, int sens)
{
bdb1_DB *dbst;
DBT key, data;
int ret, flags;
db_recno_t recno;
GetDB(obj, dbst);
INIT_RECNO(dbst, key, recno);
DATA_ZERO(data);
flags = (sens == DB_NEXT)?DB_FIRST:DB_LAST;
do {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND) {
return Qnil;
}
rb_yield(bdb1_assoc(obj, &key, &data));
flags = sens;
} while (1);
return obj;
}
static VALUE
bdb1_each_pair(VALUE obj)
{
return bdb1_each_common(obj, DB_NEXT);
}
static VALUE
bdb1_each_riap(VALUE obj)
{
return bdb1_each_common(obj, DB_PREV);
}
VALUE
bdb1_to_type(VALUE obj, VALUE result, VALUE flag)
{
bdb1_DB *dbst;
DBT key, data;
int ret, flags;
db_recno_t recno;
GetDB(obj, dbst);
INIT_RECNO(dbst, key, recno);
DATA_ZERO(data);
flags = NIL_P(flag) ? DB_LAST : DB_FIRST;
do {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND) {
return result;
}
switch (TYPE(result)) {
case T_ARRAY:
if (RTEST(flag)) {
rb_ary_push(result, bdb1_assoc(obj, &key, &data));
}
else {
rb_ary_push(result, bdb1_test_load(obj, &data, FILTER_VALUE));
}
break;
case T_HASH:
if (RTEST(flag)) {
rb_hash_aset(result, test_load_key(obj, &key),
bdb1_test_load(obj, &data, FILTER_VALUE));
}
else {
rb_hash_aset(result, bdb1_test_load(obj, &data, FILTER_VALUE),
test_load_key(obj, &key));
}
}
flags = NIL_P(flag) ? DB_PREV : DB_NEXT;
} while (1);
return result;
}
static VALUE
bdb1_to_a(VALUE obj)
{
return bdb1_to_type(obj, rb_ary_new(), Qtrue);
}
static VALUE
bdb1_invert(VALUE obj)
{
return bdb1_to_type(obj, rb_hash_new(), Qfalse);
}
static VALUE
bdb1_to_hash(VALUE obj)
{
return bdb1_to_type(obj, rb_hash_new(), Qtrue);
}
static VALUE
bdb1_each_kv(VALUE obj, VALUE a, VALUE result, VALUE flag)
{
bdb1_DB *dbst;
DBT keys, key, data;
int ret, flags;
db_recno_t recno;
VALUE k;
volatile VALUE b = Qnil;
GetDB(obj, dbst);
b = test_recno(obj, &key, &recno, a);
MEMCPY(&keys, &key, DBT, 1);
DATA_ZERO(data);
flags = R_CURSOR;
while (1) {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND || keys.size != key.size ||
memcmp(keys.data, key.data, key.size) != 0) {
return NIL_P(result)?obj:result;
}
k = bdb1_test_load(obj, &data, FILTER_VALUE);
if (RTEST(flag)) {
k = rb_assoc_new(test_load_key(obj, &key), k);
}
if (NIL_P(result)) {
rb_yield(k);
}
else {
rb_ary_push(result, k);
}
flags = DB_NEXT;
}
return Qnil;
}
/*
* call-seq:
* db.duplicates(key, assoc = true)
*
* Returns an array of all duplicate associations for the +key+.
*
* If +assoc+ is +false+ return only the values.
*/
static VALUE
bdb1_bt_duplicates(int argc, VALUE *argv, VALUE obj)
{
VALUE a, b;
if (rb_scan_args(argc, argv, "11", &a, &b) == 1) {
b = Qtrue;
}
return bdb1_each_kv(obj, a, rb_ary_new(), b);
}
/*
* call-seq:
* db.each_dup(key)
*
* Iterates over duplicate associations for the +key+.
*/
static VALUE
bdb1_bt_dup(VALUE obj, VALUE a)
{
return bdb1_each_kv(obj, a, Qnil, Qtrue);
}
/*
* call-seq:
* db.each_dup_value(key)
*
* Iterates over duplicate values for the +key+.
*/
static VALUE
bdb1_bt_dupval(VALUE obj, VALUE a)
{
return bdb1_each_kv(obj, a, Qnil, Qfalse);
}
static VALUE
bdb1_reject(VALUE obj)
{
return rb_hash_delete_if(bdb1_to_hash(obj));
}
static VALUE
bdb1_values(VALUE obj)
{
bdb1_DB *dbst;
DBT key, data;
int ret, flags;
db_recno_t recno;
VALUE ary;
GetDB(obj, dbst);
ary = rb_ary_new();
INIT_RECNO(dbst, key, recno);
DATA_ZERO(data);
flags = DB_FIRST;
do {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND) {
return ary;
}
flags = DB_NEXT;
FREE_KEY(dbst, key);
rb_ary_push(ary, bdb1_test_load(obj, &data, FILTER_VALUE));
} while (1);
return ary;
}
VALUE
bdb1_internal_value(VALUE obj, VALUE a, VALUE b, int sens)
{
bdb1_DB *dbst;
DBT key, data;
int ret, flags;
db_recno_t recno;
GetDB(obj, dbst);
INIT_RECNO(dbst, key, recno);
DATA_ZERO(data);
flags = (sens == DB_NEXT)?DB_FIRST:DB_LAST;
for (;;) {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND) {
return RTEST(b) ? Qnil : Qfalse;
}
flags = sens;
if (RTEST(rb_equal(a, bdb1_test_load(obj, &data, FILTER_VALUE)))) {
VALUE d;
d = RTEST(b) ? test_load_key(obj, &key) : Qtrue;
FREE_KEY(dbst, key);
return d;
}
FREE_KEY(dbst, key);
}
return RTEST(b) ? Qnil : Qfalse;
}
VALUE
bdb1_key(VALUE obj, VALUE a)
{
return bdb1_internal_value(obj, a, Qtrue, DB_NEXT);
}
VALUE
bdb1_has_value(VALUE obj, VALUE a)
{
return bdb1_internal_value(obj, a, Qfalse, DB_NEXT);
}
static VALUE
bdb1_keys(VALUE obj)
{
bdb1_DB *dbst;
DBT key, data;
int ret, flags;
db_recno_t recno;
VALUE ary;
GetDB(obj, dbst);
ary = rb_ary_new();
INIT_RECNO(dbst, key, recno);
DATA_ZERO(data);
flags = DB_FIRST;
do {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND) {
return ary;
}
rb_ary_push(ary, test_load_key(obj, &key));
FREE_KEY(dbst, key);
flags = DB_NEXT;
} while (1);
return ary;
}
static VALUE
bdb1_sync(VALUE obj)
{
bdb1_DB *dbst;
if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4)
rb_raise(rb_eSecurityError, "Insecure: can't sync the database");
GetDB(obj, dbst);
bdb1_test_error(dbst->dbp->sync(dbst->dbp, 0));
return Qtrue;
}
static VALUE
bdb1_values_at(int argc, VALUE *argv, VALUE obj)
{
VALUE result = rb_ary_new2(argc);
long i;
for (i = 0; i < argc; i++) {
rb_ary_push(result, bdb1_get(1, argv + i, obj));
}
return result;
}
static VALUE
bdb1_select(VALUE obj)
{
VALUE result = rb_ary_new();
if (rb_block_given_p()) {
return bdb1_each_valuec(obj, DB_NEXT, result);
}
rb_raise(rb_eArgError, "block is not given");
}
VALUE
bdb1_each_vc(VALUE obj, int replace, int rtest)
{
bdb1_DB *dbst;
DBT key, data;
int ret, flags;
db_recno_t recno;
VALUE res, result, val;
GetDB(obj, dbst);
INIT_RECNO(dbst, key, recno);
DATA_ZERO(data);
flags = DB_FIRST;
result = rb_ary_new();
do {
ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, flags));
if (ret == DB_NOTFOUND) {
return result;
}
flags = DB_NEXT;
FREE_KEY(dbst, key);
val = bdb1_test_load(obj, &data, FILTER_VALUE);
res = rb_yield(val);
if (rtest) {
if (RTEST(res)) {
rb_ary_push(result, val);
}
}
else {
rb_ary_push(result, res);
}
if (RTEST(replace)) {
DATA_ZERO(data);
res = test_dump(obj, &data, res, FILTER_VALUE);
bdb1_test_error(dbst->dbp->put(dbst->dbp, &key, &data, 0));
}
} while (1);
return Qnil;
}
/*
* This interface if for the version 1.85 and 1.86 of Berkeley DB (for
* Berkeley version >= 2 see bdb)
*
* Developers may choose to store data in any of several different
* storage structures to satisfy the requirements of a particular
* application. In database terminology, these storage structures and
* the code that operates on them are called access methods.
*
* The library includes support for the following access methods:
*
* * BDB1::Btree
*
* B+tree: Stores keys in sorted order, using a default function
* that does lexicographical ordering of keys.
*
* * BDB1::Hash
*
* Hashing: Stores records in a hash table for fast searches based
* on strict equality, using a default that hashes on the key as a
* bit string. Extended Linear Hashing modifies the hash function
* used by the table as new records are inserted, in order to keep
* buckets underfull in the steady state.
*
* * BDB1::Recnum
*
* Fixed and Variable-Length Records. Stores fixed- or
* variable-length records in sequential order.
*
*/
void
Init_bdb1(void)
{
bdb1_mMarshal = rb_const_get(rb_cObject, rb_intern("Marshal"));
id_dump = rb_intern("dump");
id_load = rb_intern("load");
bdb1_id_current_db = rb_intern("bdb1_current_db");
id_bt_compare = rb_intern("bdb1_bt_compare");
id_bt_prefix = rb_intern("bdb1_bt_prefix");
id_h_hash = rb_intern("bdb1_h_hash");
bdb1_id_call = rb_intern("call");
if (rb_const_defined_at(rb_cObject, rb_intern("BDB1"))) {
rb_raise(rb_eNameError, "class already defined");
}
bdb1_mDb = rb_define_module("BDB1");
bdb1_eFatal = rb_define_class_under(bdb1_mDb, "Fatal", rb_eStandardError);
/* CONSTANT */
rb_define_const(bdb1_mDb, "VERSION_MAJOR", INT2FIX(DB_VERSION_MAJOR));
rb_define_const(bdb1_mDb, "VERSION_MINOR", INT2FIX(DB_VERSION_MINOR));
rb_define_const(bdb1_mDb, "RELEASE_PATCH", INT2FIX(DB_RELEASE_PATCH));
rb_define_const(bdb1_mDb, "VERSION", rb_str_new2("1.x.x"));
rb_define_const(bdb1_mDb, "BTREE", INT2FIX(DB_BTREE));
rb_define_const(bdb1_mDb, "HASH", INT2FIX(DB_HASH));
rb_define_const(bdb1_mDb, "RECNO", INT2FIX(DB_RECNO));
rb_define_const(bdb1_mDb, "AFTER", INT2FIX(DB_AFTER));
rb_define_const(bdb1_mDb, "BEFORE", INT2FIX(DB_BEFORE));
rb_define_const(bdb1_mDb, "CREATE", INT2FIX(DB_CREATE));
rb_define_const(bdb1_mDb, "DUP", INT2FIX(DB_DUP));
rb_define_const(bdb1_mDb, "FIRST", INT2FIX(DB_FIRST));
rb_define_const(bdb1_mDb, "LAST", INT2FIX(DB_LAST));
rb_define_const(bdb1_mDb, "NEXT", INT2FIX(DB_NEXT));
rb_define_const(bdb1_mDb, "PREV", INT2FIX(DB_PREV));
rb_define_const(bdb1_mDb, "RDONLY", INT2FIX(DB_RDONLY));
rb_define_const(bdb1_mDb, "SET_RANGE", INT2FIX(DB_SET_RANGE));
rb_define_const(bdb1_mDb, "TRUNCATE", INT2FIX(DB_TRUNCATE));
rb_define_const(bdb1_mDb, "WRITE", INT2FIX(DB_WRITE));
rb_define_const(bdb1_mDb, "NOOVERWRITE", INT2FIX(DB_NOOVERWRITE));
/* DATABASE */
bdb1_cCommon = rb_define_class_under(bdb1_mDb, "Common", rb_cObject);
rb_define_method(bdb1_cCommon, "initialize", bdb1_init, -1);
rb_include_module(bdb1_cCommon, rb_mEnumerable);
rb_define_alloc_func(bdb1_cCommon, bdb1_s_alloc);
rb_define_singleton_method(bdb1_cCommon, "create", bdb1_s_create, -1);
rb_define_singleton_method(bdb1_cCommon, "open", bdb1_s_open, -1);
rb_define_singleton_method(bdb1_cCommon, "[]", bdb1_s_aref, -1);
rb_define_method(bdb1_cCommon, "close", bdb1_close, 0);
rb_define_method(bdb1_cCommon, "db_close", bdb1_close, 0);
rb_define_method(bdb1_cCommon, "put", bdb1_put, -1);
rb_define_method(bdb1_cCommon, "db_put", bdb1_put, -1);
rb_define_method(bdb1_cCommon, "[]=", bdb1_assign, 2);
rb_define_method(bdb1_cCommon, "store", bdb1_put, -1);
rb_define_method(bdb1_cCommon, "get", bdb1_get_dyna, -1);
rb_define_method(bdb1_cCommon, "db_get", bdb1_get_dyna, -1);
rb_define_method(bdb1_cCommon, "[]", bdb1_get_dyna, -1);
rb_define_method(bdb1_cCommon, "fetch", bdb1_fetch, -1);
rb_define_method(bdb1_cCommon, "delete", bdb1_del, 1);
rb_define_method(bdb1_cCommon, "del", bdb1_del, 1);
rb_define_method(bdb1_cCommon, "db_del", bdb1_del, 1);
rb_define_method(bdb1_cCommon, "sync", bdb1_sync, 0);
rb_define_method(bdb1_cCommon, "db_sync", bdb1_sync, 0);
rb_define_method(bdb1_cCommon, "flush", bdb1_sync, 0);
rb_define_method(bdb1_cCommon, "each", bdb1_each_pair, 0);
rb_define_method(bdb1_cCommon, "each_value", bdb1_each_value, 0);
rb_define_method(bdb1_cCommon, "reverse_each_value", bdb1_each_eulav, 0);
rb_define_method(bdb1_cCommon, "each_key", bdb1_each_key, 0);
rb_define_method(bdb1_cCommon, "reverse_each_key", bdb1_each_yek, 0);
rb_define_method(bdb1_cCommon, "each_pair", bdb1_each_pair, 0);
rb_define_method(bdb1_cCommon, "reverse_each", bdb1_each_riap, 0);
rb_define_method(bdb1_cCommon, "reverse_each_pair", bdb1_each_riap, 0);
rb_define_method(bdb1_cCommon, "keys", bdb1_keys, 0);
rb_define_method(bdb1_cCommon, "values", bdb1_values, 0);
rb_define_method(bdb1_cCommon, "delete_if", bdb1_delete_if, 0);
rb_define_method(bdb1_cCommon, "reject!", bdb1_delete_if, 0);
rb_define_method(bdb1_cCommon, "reject", bdb1_reject, 0);
rb_define_method(bdb1_cCommon, "clear", bdb1_clear, 0);
rb_define_method(bdb1_cCommon, "include?", bdb1_has_key, 1);
rb_define_method(bdb1_cCommon, "has_key?", bdb1_has_key, 1);
rb_define_method(bdb1_cCommon, "key?", bdb1_has_key, 1);
rb_define_method(bdb1_cCommon, "member?", bdb1_has_key, 1);
rb_define_method(bdb1_cCommon, "has_value?", bdb1_has_value, 1);
rb_define_method(bdb1_cCommon, "value?", bdb1_has_value, 1);
rb_define_method(bdb1_cCommon, "has_both?", bdb1_has_both, 2);
rb_define_method(bdb1_cCommon, "both?", bdb1_has_both, 2);
rb_define_method(bdb1_cCommon, "to_a", bdb1_to_a, 0);
rb_define_method(bdb1_cCommon, "to_hash", bdb1_to_hash, 0);
rb_define_method(bdb1_cCommon, "invert", bdb1_invert, 0);
rb_define_method(bdb1_cCommon, "empty?", bdb1_empty, 0);
rb_define_method(bdb1_cCommon, "length", bdb1_length, 0);
rb_define_alias(bdb1_cCommon, "size", "length");
rb_define_method(bdb1_cCommon, "key", bdb1_key, 1);
rb_define_method(bdb1_cCommon, "index", bdb1_key, 1);
rb_define_method(bdb1_cCommon, "select", bdb1_select, 0);
rb_define_method(bdb1_cCommon, "values_at", bdb1_values_at, -1);
bdb1_cBtree = rb_define_class_under(bdb1_mDb, "Btree", bdb1_cCommon);
rb_define_method(bdb1_cBtree, "duplicates", bdb1_bt_duplicates, -1);
rb_define_method(bdb1_cBtree, "each_dup", bdb1_bt_dup, 1);
rb_define_method(bdb1_cBtree, "each_dup_value", bdb1_bt_dupval, 1);
bdb1_cHash = rb_define_class_under(bdb1_mDb, "Hash", bdb1_cCommon);
rb_undef_method(bdb1_cHash, "delete_if");
rb_undef_method(bdb1_cHash, "reverse_each_value");
rb_undef_method(bdb1_cHash, "reverse_each_key");
rb_undef_method(bdb1_cHash, "reverse_each_pair");
rb_undef_method(bdb1_cHash, "reverse_each");
bdb1_cUnknown = rb_define_class_under(bdb1_mDb, "Unknown", bdb1_cCommon);
bdb1_errstr = rb_tainted_str_new(0, 0);
rb_global_variable(&bdb1_errstr);
bdb1_init_delegator();
bdb1_init_recnum();
}
Zerion Mini Shell 1.0