lmdb 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e261f77741383fa6cfe1b174ed0856a76d18d92e
-  data.tar.gz: b44bb1ca05ec5dfec80b13ee9bdac03a3b745e83
+  metadata.gz: e65d2930d0d2e7812f17f527cec9e28227ff86d3
+  data.tar.gz: 9b1be0c534d29babf1ecfb665bc0a93f1cadc158
 SHA512:
-  metadata.gz: 2980d425391ff3ddb32210c7c05970927836648355ed9e31c18fad1e48f32b234ec4c8b9a6509c2b19afaf7e54f4391835fc136c0c61b716733760c103f1d22d
-  data.tar.gz: 3abc9db5742fac65951e9bc62f0f8c0ed8ebcc7b6625ca336f5fdeda925c3f7b72bc8bff51a3558101de8bee833862725d14a4e34dd5f70316301888e522753e
+  metadata.gz: 79f1fa24f25e0c3dc0971df47ed6eea2d5f2e388a244f6354586c1a15c0cd9934ff302391a7a51b46f50534ddeb5c1b126e842ffb6e59773967e5e5ef49e35dd
+  data.tar.gz: 29a36534234f8da14bce75b157add7d4f259e94addf60e32a2faaf2edf4f84d168580e85090803d4eb16bf095a05c5546c6ea172835ba0d2098305d78d02c4cd

data/CHANGES

@@ -1,3 +1,11 @@
+0.3.0
+
+  * Higher level API improved and stabilized
+
+0.2.0
+
+  * First working version
+
 0.1.0
 
   * Initial release

data/ext/lmdb_ext/cursor_delete_flags.h

@@ -0,0 +1 @@
+FLAG(NODUPDATA, nodupdata)

data/ext/lmdb_ext/cursor_put_flags.h

@@ -0,0 +1,2 @@
+#include "put_flags.h"
+FLAG(MULTIPLE, multiple)

data/ext/lmdb_ext/dbi_flags.h

@@ -0,0 +1,7 @@
+FLAG(REVERSEKEY, reversekey)
+FLAG(DUPSORT, dupsort)
+FLAG(INTEGERKEY, integerkey)
+FLAG(DUPFIXED, dupfixed)
+FLAG(INTEGERDUP, integerdup)
+FLAG(REVERSEDUP, reversedup)
+FLAG(CREATE, create)

data/ext/lmdb_ext/env_flags.h

@@ -0,0 +1,8 @@
+FLAG(FIXEDMAP, fixedmap)
+FLAG(NOSUBDIR, nosubdir)
+FLAG(NOSYNC, nosync)
+FLAG(RDONLY, rdonly)
+FLAG(NOMETASYNC, nometasync)
+FLAG(WRITEMAP, writemap)
+FLAG(MAPASYNC, mapasync)
+FLAG(NOTLS, notls)

data/ext/lmdb_ext/flag_parser.h

@@ -0,0 +1,14 @@
+static int METHOD(VALUE key, VALUE value, int* flags) {
+        ID id = rb_to_id(key);
+
+        if (0) {}
+#define FLAG(const, name) else if (id == rb_intern(#name)) { if (RTEST(value)) { *flags |= MDB_##const; } }
+#include FILE
+#undef FLAG
+        else {
+                VALUE s = rb_inspect(key);
+                rb_raise(cError, "Invalid option %s", StringValueCStr(s));
+        }
+
+        return 0;
+}

data/ext/lmdb_ext/lmdb_ext.c

@@ -24,8 +24,10 @@ static void transaction_deref(Transaction* transaction) {
                         Transaction* parent = (Transaction*)DATA_PTR(transaction->parent);
                         transaction_deref(parent);
                 }
-                if (transaction->txn)
+                if (transaction->txn) {
+                        rb_warn("Garbage collecting active transaction!");
                         mdb_txn_abort(transaction->txn);
+                }
                 free(transaction);
         }
 }
@@ -36,40 +38,26 @@ static void transaction_mark(Transaction* transaction) {
 }
 
 static VALUE transaction_commit(VALUE self) {
-        TRANSACTION(self, transaction);
-        ENVIRONMENT(transaction->env, environment);
-        if (!transaction->txn)
-                rb_raise(cError, "Transaction is terminated");
-
-        // Check nesting
-        VALUE p = environment->txn;
-        while (!NIL_P(p) && p != self) {
-                TRANSACTION(p, txn);
-                p = txn->parent;
-        }
-        if (p != self)
-                rb_raise(cError, "Transaction is not active");
-
-        mdb_txn_commit(transaction->txn);
-
-        p = environment->txn;
-        while (p != self) {
-                TRANSACTION(p, txn);
-                txn->txn = 0;
-                p = txn->parent;
-        }
-        transaction->txn = 0;
-
-        environment->txn = transaction->parent;
+        transaction_finish(self, 1);
         return Qnil;
 }
 
 static VALUE transaction_abort(VALUE self) {
+        transaction_finish(self, 0);
+        return Qnil;
+}
+
+static void transaction_finish(VALUE self, int commit) {
         TRANSACTION(self, transaction);
-        ENVIRONMENT(transaction->env, environment);
+
+        if (!transaction->txn)
+                rb_raise(cError, "Transaction is terminated");
+
+        if (transaction->thread != rb_thread_current())
+                rb_raise(cError, "Wrong thread");
 
         // Check nesting
-        VALUE p = environment->txn;
+        VALUE p = environment_active_txn(transaction->env);
         while (!NIL_P(p) && p != self) {
                 TRANSACTION(p, txn);
                 p = txn->parent;
@@ -77,20 +65,23 @@ static VALUE transaction_abort(VALUE self) {
         if (p != self)
                 rb_raise(cError, "Transaction is not active");
 
-        if (!transaction->txn)
-                rb_raise(cError, "Transaction is terminated");
-        mdb_txn_abort(transaction->txn);
+        int ret = 0;
+        if (commit)
+                ret = mdb_txn_commit(transaction->txn);
+        else
+                mdb_txn_abort(transaction->txn);
 
-        p = environment->txn;
+        p = environment_active_txn(transaction->env);
         while (p != self) {
                 TRANSACTION(p, txn);
                 txn->txn = 0;
                 p = txn->parent;
-        } while (p != self);
+        }
         transaction->txn = 0;
 
-        environment->txn = transaction->parent;
-        return Qnil;
+        environment_set_active_txn(transaction->env, transaction->thread, transaction->parent);
+
+        check(ret);
 }
 
 static VALUE call_with_transaction_helper(VALUE arg) {
@@ -107,27 +98,35 @@ static VALUE with_transaction(VALUE venv, VALUE(*fn)(VALUE), VALUE arg, int flag
         ENVIRONMENT(venv, environment);
 
         MDB_txn* txn;
-        check(mdb_txn_begin(environment->env, environment_txn(venv), flags, &txn));
+        check(mdb_txn_begin(environment->env, active_txn(venv), flags, &txn));
 
         Transaction* transaction;
         VALUE vtxn = Data_Make_Struct(cTransaction, Transaction, transaction_mark, transaction_deref, transaction);
         transaction->refcount = 1;
-        transaction->parent = environment->txn;
+        transaction->parent = environment_active_txn(venv);
         transaction->env = venv;
         transaction->txn = txn;
-        environment->txn = vtxn;
+        transaction->thread = rb_thread_current();
+        environment_set_active_txn(venv, transaction->thread, vtxn);
+
+        if (!NIL_P(transaction->parent)) {
+                TRANSACTION(transaction->parent, parent);
+                ++parent->refcount;
+        }
+
+        ++environment->refcount;
 
         int exception;
-        VALUE result = rb_protect(fn, NIL_P(arg) ? vtxn : arg, &exception);
+        VALUE ret = rb_protect(fn, NIL_P(arg) ? vtxn : arg, &exception);
 
         if (exception) {
-                if (vtxn == environment->txn)
+                if (vtxn == environment_active_txn(venv))
                         transaction_abort(vtxn);
                 rb_jump_tag(exception);
         }
-        if (vtxn == environment->txn)
+        if (vtxn == environment_active_txn(venv))
                 transaction_commit(vtxn);
-        return result;
+        return ret;
 }
 
 static void environment_check(Environment* environment) {
@@ -143,6 +142,12 @@ static void environment_deref(Environment *environment) {
         }
 }
 
+
+static void environment_mark(Environment* environment) {
+        rb_gc_mark(environment->thread_txn_hash);
+        rb_gc_mark(environment->txn_thread_hash);
+}
+
 static VALUE environment_close(VALUE self) {
         ENVIRONMENT(self, environment);
         mdb_env_close(environment->env);
@@ -151,9 +156,9 @@ static VALUE environment_close(VALUE self) {
 }
 
 static VALUE stat2hash(const MDB_stat* stat) {
-        VALUE result = rb_hash_new();
+        VALUE ret = rb_hash_new();
 
-#define STAT_SET(name) rb_hash_aset(result, ID2SYM(rb_intern(#name)), INT2NUM(stat->ms_##name))
+#define STAT_SET(name) rb_hash_aset(ret, ID2SYM(rb_intern(#name)), INT2NUM(stat->ms_##name))
         STAT_SET(psize);
         STAT_SET(depth);
         STAT_SET(branch_pages);
@@ -162,7 +167,7 @@ static VALUE stat2hash(const MDB_stat* stat) {
         STAT_SET(entries);
 #undef STAT_SET
 
-        return result;
+        return ret;
 }
 
 static VALUE environment_stat(VALUE self) {
@@ -178,9 +183,9 @@ static VALUE environment_info(VALUE self) {
         ENVIRONMENT(self, environment);
         check(mdb_env_info(environment->env, &info));
 
-        VALUE result = rb_hash_new();
+        VALUE ret = rb_hash_new();
 
-#define INFO_SET(name) rb_hash_aset(result, ID2SYM(rb_intern(#name)), INT2NUM((size_t)info.me_##name));
+#define INFO_SET(name) rb_hash_aset(ret, ID2SYM(rb_intern(#name)), INT2NUM((size_t)info.me_##name));
         INFO_SET(mapaddr);
         INFO_SET(mapsize);
         INFO_SET(last_pgno);
@@ -189,7 +194,7 @@ static VALUE environment_info(VALUE self) {
         INFO_SET(numreaders);
 #undef INFO_SET
 
-        return result;
+        return ret;
 }
 
 static VALUE environment_copy(VALUE self, VALUE path) {
@@ -208,51 +213,62 @@ static VALUE environment_sync(int argc, VALUE *argv, VALUE self) {
         return Qnil;
 }
 
-static VALUE environment_open(int argc, VALUE *argv, VALUE klass) {
-        VALUE path, options;
-        rb_scan_args(argc, argv, "11", &path, &options);
+static int environment_options(VALUE key, VALUE value, EnvironmentOptions* options) {
+        ID id = rb_to_id(key);
 
-        int flags = 0, maxreaders = -1, maxdbs = 10;
-        size_t mapsize = 0;
-        mode_t mode = 0755;
-        if (!NIL_P(options)) {
-                VALUE value = rb_hash_aref(options, ID2SYM(rb_intern("flags")));
-                if (!NIL_P(value))
-                        flags = NUM2INT(value);
+        if (id == rb_intern("mode"))
+                options->mode = NUM2INT(value);
+        else if (id == rb_intern("maxreaders"))
+                options->maxreaders = NUM2INT(value);
+        else if (id == rb_intern("maxdbs"))
+                options->maxdbs = NUM2INT(value);
+        else if (id == rb_intern("mapsize"))
+                options->mapsize = NUM2SSIZET(value);
 
-                value = rb_hash_aref(options, ID2SYM(rb_intern("mode")));
-                if (!NIL_P(value))
-                        mode = NUM2INT(value);
+#define FLAG(const, name) else if (id == rb_intern(#name)) { if (RTEST(value)) { options->flags |= MDB_##const; } }
+#include "env_flags.h"
+#undef FLAG
 
-                value = rb_hash_aref(options, ID2SYM(rb_intern("maxreaders")));
-                if (!NIL_P(value))
-                        maxreaders = NUM2INT(value);
+        else {
+                VALUE s = rb_inspect(key);
+                rb_raise(cError, "Invalid option %s", StringValueCStr(s));
+        }
 
-                value = rb_hash_aref(options, ID2SYM(rb_intern("maxdbs")));
-                if (!NIL_P(value))
-                        maxdbs = NUM2INT(value);
+        return 0;
+}
 
-                value = rb_hash_aref(options, ID2SYM(rb_intern("mapsize")));
-                if (!NIL_P(value))
-                        mapsize = NUM2SIZET(value);
-        }
+static VALUE environment_new(int argc, VALUE *argv, VALUE klass) {
+        VALUE path, option_hash;
+        rb_scan_args(argc, argv, "1:", &path, &option_hash);
+
+        EnvironmentOptions options = {
+                .flags = MDB_NOTLS,
+                .maxreaders = -1,
+                .maxdbs = 128,
+                .mapsize = 0,
+                .mode = 0755,
+        };
+        if (!NIL_P(option_hash))
+                rb_hash_foreach(option_hash, environment_options, (VALUE)&options);
 
         MDB_env* env;
         check(mdb_env_create(&env));
 
         Environment* environment;
-        VALUE venv = Data_Make_Struct(cEnvironment, Environment, 0, environment_deref, environment);
+        VALUE venv = Data_Make_Struct(cEnvironment, Environment, environment_mark, environment_deref, environment);
         environment->env = env;
         environment->refcount = 1;
-        environment->txn = Qnil;
+        environment->thread_txn_hash = rb_hash_new();
+        environment->txn_thread_hash = rb_hash_new();
 
-        if (maxreaders > 0)
-                check(mdb_env_set_maxreaders(environment->env, maxreaders));
-        if (mapsize > 0)
-                check(mdb_env_set_mapsize(environment->env, mapsize));
+        if (options.maxreaders > 0)
+                check(mdb_env_set_maxreaders(env, options.maxreaders));
+        if (options.mapsize > 0)
+                check(mdb_env_set_mapsize(env, options.mapsize));
+
+        check(mdb_env_set_maxdbs(env, options.maxdbs <= 0 ? 1 : options.maxdbs));
+        check(mdb_env_open(env, StringValueCStr(path), options.flags, options.mode));
 
-        check(mdb_env_set_maxdbs(environment->env, maxdbs <= 0 ? 1 : maxdbs));
-        check(mdb_env_open(environment->env, StringValueCStr(path), flags, mode));
         if (rb_block_given_p())
                 return rb_ensure(rb_yield, venv, environment_close, venv);
 
@@ -263,7 +279,13 @@ static VALUE environment_flags(VALUE self) {
         unsigned int flags;
         ENVIRONMENT(self, environment);
         check(mdb_env_get_flags(environment->env, &flags));
-        return INT2NUM(flags & ENV_FLAGS);
+
+        VALUE ret = rb_ary_new();
+#define FLAG(const, name) if (flags & MDB_##const) rb_ary_push(ret, ID2SYM(rb_intern(#name)));
+#include "env_flags.h"
+#undef FLAG
+
+        return ret;
 }
 
 static VALUE environment_path(VALUE self) {
@@ -273,27 +295,68 @@ static VALUE environment_path(VALUE self) {
         return rb_str_new2(path);
 }
 
-static VALUE environment_set_flags(VALUE self, VALUE vflags) {
-        unsigned int flags = NUM2INT(vflags), oldflags;
+static VALUE environment_change_flags(int argc, VALUE* argv, VALUE self, int set) {
         ENVIRONMENT(self, environment);
-        check(mdb_env_get_flags(environment->env, &oldflags));
-        check(mdb_env_set_flags(environment->env, oldflags & ENV_FLAGS, 0));
-        check(mdb_env_set_flags(environment->env, flags, 1));
-        return environment_flags(self);
+
+        int i;
+        for (i = 0; i < argc; ++i) {
+                ID id = rb_to_id(argv[i]);
+
+                if (0) {}
+#define FLAG(const, name) else if (id == rb_intern(#name)) check(mdb_env_set_flags(environment->env, MDB_##const, set));
+#include "env_flags.h"
+#undef FLAG
+                else
+                        rb_raise(cError, "Invalid option %s", StringValueCStr(argv[i]));
+        }
+        return Qnil;
+}
+
+static VALUE environment_set_flags(int argc, VALUE* argv, VALUE self) {
+        environment_change_flags(argc, argv, self, 1);
+        return Qnil;
 }
 
-static MDB_txn* environment_txn(VALUE self) {
+static VALUE environment_clear_flags(int argc, VALUE* argv, VALUE self) {
+        environment_change_flags(argc, argv, self, 0);
+        return Qnil;
+}
+
+static VALUE environment_active_txn(VALUE self) {
         ENVIRONMENT(self, environment);
-        if (NIL_P(environment->txn))
+        return rb_hash_aref(environment->thread_txn_hash, rb_thread_current());
+}
+
+static void environment_set_active_txn(VALUE self, VALUE thread, VALUE txn) {
+        ENVIRONMENT(self, environment);
+
+        if (NIL_P(txn)) {
+                VALUE oldtxn = rb_hash_aref(environment->thread_txn_hash, thread);
+                if (!NIL_P(oldtxn)) {
+                        rb_hash_delete(environment->thread_txn_hash, thread);
+                        rb_hash_delete(environment->txn_thread_hash, oldtxn);
+                }
+        } else {
+                rb_hash_aset(environment->txn_thread_hash, txn, thread);
+                rb_hash_aset(environment->thread_txn_hash, thread, txn);
+        }
+}
+
+
+static MDB_txn* active_txn(VALUE self) {
+        VALUE vtxn = environment_active_txn(self);
+        if (NIL_P(vtxn))
                 return 0;
-        TRANSACTION(environment->txn, transaction);
+        TRANSACTION(vtxn, transaction);
         if (!transaction->txn)
                 rb_raise(cError, "Transaction is terminated");
+        if (transaction->thread != rb_thread_current())
+                rb_raise(cError, "Wrong thread");
         return transaction->txn;
 }
 
-static MDB_txn* environment_need_txn(VALUE self) {
-        MDB_txn* txn = environment_txn(self);
+static MDB_txn* need_txn(VALUE self) {
+        MDB_txn* txn = active_txn(self);
         if (!txn)
                 rb_raise(cError, "No active transaction");
         return txn;
@@ -321,16 +384,26 @@ static void database_mark(Database* database) {
         rb_gc_mark(database->env);
 }
 
+#define METHOD database_flags
+#define FILE "dbi_flags.h"
+#include "flag_parser.h"
+#undef METHOD
+#undef FILE
+
 static VALUE environment_database(int argc, VALUE *argv, VALUE self) {
         ENVIRONMENT(self, environment);
-        if (NIL_P(environment->txn))
+        if (!active_txn(self))
                 return call_with_transaction(self, self, "database", argc, argv, 0);
 
-        VALUE vname, vflags;
-        rb_scan_args(argc, argv, "02", &vname, &vflags);
+        VALUE name, option_hash;
+        rb_scan_args(argc, argv, "01:", &name, &option_hash);
+
+        int flags = 0;
+        if (!NIL_P(option_hash))
+                rb_hash_foreach(option_hash, database_flags, (VALUE)&flags);
 
         MDB_dbi dbi;
-        check(mdb_dbi_open(environment_need_txn(self), NIL_P(vname) ? 0 : StringValueCStr(vname), NIL_P(vflags) ? 0 : NUM2INT(vflags), &dbi));
+        check(mdb_dbi_open(need_txn(self), NIL_P(name) ? 0 : StringValueCStr(name), flags, &dbi));
 
         Database* database;
         VALUE vdb = Data_Make_Struct(cDatabase, Database, database_mark, database_deref, database);
@@ -344,33 +417,33 @@ static VALUE environment_database(int argc, VALUE *argv, VALUE self) {
 
 static VALUE database_stat(VALUE self) {
         DATABASE(self, database);
-        if (!environment_txn(database->env))
+        if (!active_txn(database->env))
                 return call_with_transaction(database->env, self, "stat", 0, 0, MDB_RDONLY);
 
         MDB_stat stat;
-        check(mdb_stat(environment_need_txn(database->env), database->dbi, &stat));
+        check(mdb_stat(need_txn(database->env), database->dbi, &stat));
         return stat2hash(&stat);
 }
 
 static VALUE database_drop(VALUE self) {
         DATABASE(self, database);
-        if (!environment_txn(database->env))
+        if (!active_txn(database->env))
                 return call_with_transaction(database->env, self, "drop", 0, 0, 0);
-        check(mdb_drop(environment_need_txn(database->env), database->dbi, 1));
+        check(mdb_drop(need_txn(database->env), database->dbi, 1));
         return Qnil;
 }
 
 static VALUE database_clear(VALUE self) {
         DATABASE(self, database);
-        if (!environment_txn(database->env))
+        if (!active_txn(database->env))
                 return call_with_transaction(database->env, self, "clear", 0, 0, 0);
-        check(mdb_drop(environment_need_txn(database->env), database->dbi, 0));
+        check(mdb_drop(need_txn(database->env), database->dbi, 0));
         return Qnil;
 }
 
 static VALUE database_get(VALUE self, VALUE vkey) {
         DATABASE(self, database);
-        if (!environment_txn(database->env))
+        if (!active_txn(database->env))
                 return call_with_transaction(database->env, self, "get", 1, &vkey, MDB_RDONLY);
 
         vkey = StringValue(vkey);
@@ -378,20 +451,30 @@ static VALUE database_get(VALUE self, VALUE vkey) {
         key.mv_size = RSTRING_LEN(vkey);
         key.mv_data = RSTRING_PTR(vkey);
 
-        int ret = mdb_get(environment_need_txn(database->env), database->dbi, &key, &value);
+        int ret = mdb_get(need_txn(database->env), database->dbi, &key, &value);
         if (ret == MDB_NOTFOUND)
                 return Qnil;
         check(ret);
         return rb_str_new(value.mv_data, value.mv_size);
 }
 
+#define METHOD database_put_flags
+#define FILE "put_flags.h"
+#include "flag_parser.h"
+#undef METHOD
+#undef FILE
+
 static VALUE database_put(int argc, VALUE *argv, VALUE self) {
         DATABASE(self, database);
-        if (!environment_txn(database->env))
+        if (!active_txn(database->env))
                 return call_with_transaction(database->env, self, "put", argc, argv, 0);
 
-        VALUE vkey, vflags, vval;
-        rb_scan_args(argc, argv, "21", &vkey, &vval, &vflags);
+        VALUE vkey, vval, option_hash;
+        rb_scan_args(argc, argv, "2:", &vkey, &vval, &option_hash);
+
+        int flags = 0;
+        if (!NIL_P(option_hash))
+                rb_hash_foreach(option_hash, database_put_flags, (VALUE)&flags);
 
         vkey = StringValue(vkey);
         vval = StringValue(vval);
@@ -402,13 +485,13 @@ static VALUE database_put(int argc, VALUE *argv, VALUE self) {
         value.mv_size = RSTRING_LEN(vval);
         value.mv_data = RSTRING_PTR(vval);
 
-        check(mdb_put(environment_need_txn(database->env), database->dbi, &key, &value, NIL_P(vflags) ? 0 : NUM2INT(vflags)));
+        check(mdb_put(need_txn(database->env), database->dbi, &key, &value, flags));
         return Qnil;
 }
 
 static VALUE database_delete(int argc, VALUE *argv, VALUE self) {
         DATABASE(self, database);
-        if (!environment_txn(database->env))
+        if (!active_txn(database->env))
                 return call_with_transaction(database->env, self, "delete", argc, argv, 0);
 
         VALUE vkey, vval;
@@ -421,13 +504,13 @@ static VALUE database_delete(int argc, VALUE *argv, VALUE self) {
         key.mv_data = RSTRING_PTR(vkey);
 
         if (NIL_P(vval)) {
-                check(mdb_del(environment_need_txn(database->env), database->dbi, &key, 0));
+                check(mdb_del(need_txn(database->env), database->dbi, &key, 0));
         } else {
                 VALUE vval = StringValue(vval);
                 MDB_val value;
                 value.mv_size = RSTRING_LEN(vval);
                 value.mv_data = RSTRING_PTR(vval);
-                check(mdb_del(environment_need_txn(database->env), database->dbi, &key, &value));
+                check(mdb_del(need_txn(database->env), database->dbi, &key, &value));
         }
 
         return Qnil;
@@ -459,11 +542,11 @@ static VALUE cursor_close(VALUE self) {
 
 static VALUE database_cursor(VALUE self) {
         DATABASE(self, database);
-        if (!environment_txn(database->env))
+        if (!active_txn(database->env))
                 return call_with_transaction(database->env, self, "cursor", 0, 0, 0);
 
         MDB_cursor* cur;
-        check(mdb_cursor_open(environment_need_txn(database->env), database->dbi, &cur));
+        check(mdb_cursor_open(need_txn(database->env), database->dbi, &cur));
 
         Cursor* cursor;
         VALUE vcur = Data_Make_Struct(cCursor, Cursor, cursor_mark, cursor_free, cursor);
@@ -473,13 +556,13 @@ static VALUE database_cursor(VALUE self) {
 
         if (rb_block_given_p()) {
                 int exception;
-                VALUE result = rb_protect(rb_yield, vcur, &exception);
+                VALUE ret = rb_protect(rb_yield, vcur, &exception);
                 if (exception) {
                         cursor_close(vcur);
                         rb_jump_tag(exception);
                 }
                 cursor_close(vcur);
-                return result;
+                return ret;
         }
 
         return vcur;
@@ -548,11 +631,21 @@ static VALUE cursor_get(VALUE self) {
         return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size), rb_str_new(value.mv_data, value.mv_size));
 }
 
+#define METHOD cursor_put_flags
+#define FILE "cursor_put_flags.h"
+#include "flag_parser.h"
+#undef METHOD
+#undef FILE
+
 static VALUE cursor_put(int argc, VALUE* argv, VALUE self) {
         CURSOR(self, cursor);
 
-        VALUE vkey, vflags, vval;
-        rb_scan_args(argc, argv, "21", &vkey, &vval, &vflags);
+        VALUE vkey, vval, option_hash;
+        rb_scan_args(argc, argv, "2:", &vkey, &vval, &option_hash);
+
+        int flags = 0;
+        if (!NIL_P(option_hash))
+                rb_hash_foreach(option_hash, cursor_put_flags, (VALUE)&flags);
 
         vkey = StringValue(vkey);
         vval = StringValue(vval);
@@ -563,15 +656,27 @@ static VALUE cursor_put(int argc, VALUE* argv, VALUE self) {
         value.mv_size = RSTRING_LEN(vval);
         value.mv_data = RSTRING_PTR(vval);
 
-        check(mdb_cursor_put(cursor->cur, &key, &value, NIL_P(vflags) ? 0 : NUM2INT(vflags)));
+        check(mdb_cursor_put(cursor->cur, &key, &value, flags));
         return Qnil;
 }
 
+#define METHOD cursor_delete_flags
+#define FILE "cursor_delete_flags.h"
+#include "flag_parser.h"
+#undef METHOD
+#undef FILE
+
 static VALUE cursor_delete(int argc, VALUE *argv, VALUE self) {
         CURSOR(self, cursor);
-        VALUE vflags;
-        rb_scan_args(argc, argv, "01", &vflags);
-        check(mdb_cursor_del(cursor->cur, NIL_P(vflags) ? 0 : NUM2INT(vflags)));
+
+        VALUE option_hash;
+        rb_scan_args(argc, argv, ":", &option_hash);
+
+        int flags = 0;
+        if (!NIL_P(option_hash))
+                rb_hash_foreach(option_hash, cursor_delete_flags, (VALUE)&flags);
+
+        check(mdb_cursor_del(cursor->cur, flags));
         return Qnil;
 }
 
@@ -586,43 +691,14 @@ void Init_lmdb_ext() {
         VALUE mLMDB;
 
         mLMDB = rb_define_module("LMDB");
-        rb_define_const(mLMDB, "VERSION", rb_str_new2(MDB_VERSION_STRING));
-        rb_define_singleton_method(mLMDB, "open", environment_open, -1);
-
-#define NUM_CONST(name) rb_define_const(mLMDB, #name, INT2NUM(MDB_##name))
-
-        // Versions
-        NUM_CONST(VERSION_MAJOR);
-        NUM_CONST(VERSION_MINOR);
-        NUM_CONST(VERSION_PATCH);
-
-        // Environment flags
-        NUM_CONST(FIXEDMAP);
-        NUM_CONST(NOSUBDIR);
-        NUM_CONST(NOSYNC);
-        NUM_CONST(RDONLY);
-        NUM_CONST(NOMETASYNC);
-        NUM_CONST(WRITEMAP);
-        NUM_CONST(MAPASYNC);
-        NUM_CONST(NOTLS);
-
-        // Database flags
-        NUM_CONST(REVERSEKEY);
-        NUM_CONST(DUPSORT);
-        NUM_CONST(INTEGERKEY);
-        NUM_CONST(DUPFIXED);
-        NUM_CONST(INTEGERDUP);
-        NUM_CONST(REVERSEDUP);
-        NUM_CONST(CREATE);
-
-        // Write flags
-        NUM_CONST(NOOVERWRITE);
-        NUM_CONST(NODUPDATA);
-        NUM_CONST(CURRENT);
-        NUM_CONST(RESERVE);
-        NUM_CONST(APPEND);
-        NUM_CONST(APPENDDUP);
-        NUM_CONST(MULTIPLE);
+        rb_define_const(mLMDB, "LIB_VERSION", rb_str_new2(MDB_VERSION_STRING));
+        rb_define_singleton_method(mLMDB, "new", environment_new, -1);
+
+#define VERSION_CONST(name) rb_define_const(mLMDB, "LIB_VERSION_"#name, INT2NUM(MDB_VERSION_##name));
+        VERSION_CONST(MAJOR)
+        VERSION_CONST(MINOR)
+        VERSION_CONST(PATCH)
+#undef VERSION_CONST
 
         cError = rb_define_class_under(mLMDB, "Error", rb_eRuntimeError);
 #define ERROR(name) cError_##name = rb_define_class_under(cError, #name, cError);
@@ -630,15 +706,16 @@ void Init_lmdb_ext() {
 #undef ERROR
 
         cEnvironment = rb_define_class_under(mLMDB, "Environment", rb_cObject);
-        rb_undef_method(rb_singleton_class(cEnvironment), "new");
-        rb_define_singleton_method(cEnvironment, "open", environment_open, -1);
+        rb_define_singleton_method(cEnvironment, "new", environment_new, -1);
         rb_define_method(cEnvironment, "database", environment_database, -1);
+        rb_define_method(cEnvironment, "active_txn", environment_active_txn, 0);
         rb_define_method(cEnvironment, "close", environment_close, 0);
         rb_define_method(cEnvironment, "stat", environment_stat, 0);
         rb_define_method(cEnvironment, "info", environment_info, 0);
         rb_define_method(cEnvironment, "copy", environment_copy, 1);
         rb_define_method(cEnvironment, "sync", environment_sync, -1);
-        rb_define_method(cEnvironment, "flags=", environment_set_flags, 1);
+        rb_define_method(cEnvironment, "set_flags", environment_set_flags, -1);
+        rb_define_method(cEnvironment, "clear_flags", environment_clear_flags, -1);
         rb_define_method(cEnvironment, "flags", environment_flags, 0);
         rb_define_method(cEnvironment, "path", environment_path, 0);
         rb_define_method(cEnvironment, "transaction", environment_transaction, -1);

data/ext/lmdb_ext/lmdb_ext.h

@@ -4,16 +4,6 @@
 #include "ruby.h"
 #include "lmdb.h"
 
-#define ENV_FLAGS (                             \
-                MDB_FIXEDMAP    |               \
-                MDB_NOSUBDIR    |               \
-                MDB_NOSYNC      |               \
-                MDB_RDONLY      |               \
-                MDB_NOMETASYNC  |               \
-                MDB_WRITEMAP    |               \
-                MDB_MAPASYNC    |               \
-                MDB_NOTLS)
-
 #define ENVIRONMENT(var, var_env)                       \
         Environment* var_env;                           \
         Data_Get_Struct(var, Environment, var_env);     \
@@ -37,13 +27,15 @@ typedef struct Transaction Transaction;
 typedef struct Transaction {
         VALUE    env;
         VALUE    parent;
+        VALUE    thread;
         MDB_txn* txn;
         int      refcount;
 } Transaction;
 
 typedef struct {
         MDB_env* env;
-        VALUE    txn;
+        VALUE    thread_txn_hash;
+        VALUE    txn_thread_hash;
         int      refcount;
 } Environment;
 
@@ -65,6 +57,14 @@ typedef struct {
         const VALUE* argv;
 } HelperArgs;
 
+typedef struct {
+        mode_t mode;
+        int    flags;
+        int    maxreaders;
+        int    maxdbs;
+        size_t mapsize;
+} EnvironmentOptions;
+
 static VALUE cEnvironment, cDatabase, cTransaction, cCursor, cError;
 
 #define ERROR(name) static VALUE cError_##name;
@@ -73,6 +73,7 @@ static VALUE cEnvironment, cDatabase, cTransaction, cCursor, cError;
 
 // BEGIN PROTOTYPES
 void Init_lmdb_ext();
+static MDB_txn* active_txn(VALUE self);
 static VALUE call_with_transaction(VALUE venv, VALUE self, const char* name, int argc, const VALUE* argv, int flags);
 static VALUE call_with_transaction_helper(VALUE arg);
 static void check(int code);
@@ -98,25 +99,31 @@ static VALUE database_get(VALUE self, VALUE vkey);
 static void database_mark(Database* database);
 static VALUE database_put(int argc, VALUE *argv, VALUE self);
 static VALUE database_stat(VALUE self);
+static VALUE environment_active_txn(VALUE self);
+static VALUE environment_change_flags(int argc, VALUE* argv, VALUE self, int set);
 static void environment_check(Environment* environment);
+static VALUE environment_clear_flags(int argc, VALUE* argv, VALUE self);
 static VALUE environment_close(VALUE self);
 static VALUE environment_copy(VALUE self, VALUE path);
 static VALUE environment_database(int argc, VALUE *argv, VALUE self);
 static void environment_deref(Environment *environment);
 static VALUE environment_flags(VALUE self);
 static VALUE environment_info(VALUE self);
-static MDB_txn* environment_need_txn(VALUE self);
-static VALUE environment_open(int argc, VALUE *argv, VALUE klass);
+static void environment_mark(Environment* environment);
+static VALUE environment_new(int argc, VALUE *argv, VALUE klass);
+static int environment_options(VALUE key, VALUE value, EnvironmentOptions* options);
 static VALUE environment_path(VALUE self);
-static VALUE environment_set_flags(VALUE self, VALUE vflags);
+static void environment_set_active_txn(VALUE self, VALUE thread, VALUE txn);
+static VALUE environment_set_flags(int argc, VALUE* argv, VALUE self);
 static VALUE environment_stat(VALUE self);
 static VALUE environment_sync(int argc, VALUE *argv, VALUE self);
 static VALUE environment_transaction(int argc, VALUE *argv, VALUE self);
-static MDB_txn* environment_txn(VALUE self);
+static MDB_txn* need_txn(VALUE self);
 static VALUE stat2hash(const MDB_stat* stat);
 static VALUE transaction_abort(VALUE self);
 static VALUE transaction_commit(VALUE self);
 static void transaction_deref(Transaction* transaction);
+static void transaction_finish(VALUE self, int commit);
 static void transaction_mark(Transaction* transaction);
 static VALUE with_transaction(VALUE venv, VALUE(*fn)(VALUE), VALUE arg, int flags);
 // END PROTOTYPES

data/ext/lmdb_ext/put_flags.h

@@ -0,0 +1,5 @@
+FLAG(NOOVERWRITE, nooverwrite)
+FLAG(NODUPDATA, nodupdata)
+FLAG(CURRENT, current)
+FLAG(APPEND, append)
+FLAG(APPENDDUP, appenddup)

data/lib/lmdb/database.rb

@@ -0,0 +1,26 @@
+module LMDB
+  class Database
+    include Enumerable
+
+    def each
+      cursor do |c|
+        while i = c.next
+          yield(i)
+        end
+      end
+    end
+
+    def [](key)
+      get(key)
+    end
+
+    def []=(key, value)
+      put(key, value)
+      value
+    end
+
+    def size
+      stat[:entries]
+    end
+  end
+end

data/lib/lmdb/version.rb

@@ -0,0 +1,3 @@
+module LMDB
+  VERSION = '0.3.0'
+end

data/lib/lmdb.rb

@@ -1,29 +1,3 @@
 require 'lmdb_ext'
-
-module LMDB
-  class Database
-    include Enumerable
-
-    def each
-      cursor do |c|
-        while i = c.next
-          yield(i)
-        end
-      end
-    end
-
-    def [](key)
-      get(key)
-    end
-
-    def []=(key, value)
-      put(key, value)
-      value
-    end
-
-    def size
-      stat[:entries]
-    end
-  end
-end
-
+require 'lmdb/version'
+require 'lmdb/database'

data/lmdb.gemspec

@@ -1,9 +1,12 @@
 # -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/lib/lmdb/version'
+require 'date'
 
 Gem::Specification.new do |s|
   s.name        = File.basename(__FILE__, '.gemspec')
-  s.version     = '0.2.0'
+  s.version     = LMDB::VERSION
   s.platform    = Gem::Platform::RUBY
+  s.date        = Date.today.to_s
   s.licenses    = ['MIT']
   s.summary     = 'Ruby bindings to Lightning MDB'
   s.email       = 'mail@daniel-mendler.de'

data/spec/lmdb_spec.rb

@@ -2,71 +2,50 @@
 require 'helper'
 
 describe LMDB do
-  let(:env) { LMDB.open(path) }
+  let(:env) { LMDB.new(path) }
   after     { env.close rescue nil }
 
   let(:db)  { env.database }
 
   it 'has version constants' do
-    LMDB::VERSION_MAJOR.should be_instance_of(Fixnum)
-    LMDB::VERSION_MINOR.should be_instance_of(Fixnum)
-    LMDB::VERSION_PATCH.should be_instance_of(Fixnum)
+    LMDB::LIB_VERSION_MAJOR.should be_instance_of(Fixnum)
+    LMDB::LIB_VERSION_MINOR.should be_instance_of(Fixnum)
+    LMDB::LIB_VERSION_PATCH.should be_instance_of(Fixnum)
+    LMDB::LIB_VERSION.should be_instance_of(String)
     LMDB::VERSION.should be_instance_of(String)
   end
 
-  it 'has environment flags' do
-    LMDB::FIXEDMAP.should be_instance_of(Fixnum)
-    LMDB::NOSUBDIR.should be_instance_of(Fixnum)
-    LMDB::NOSYNC.should be_instance_of(Fixnum)
-    LMDB::RDONLY.should be_instance_of(Fixnum)
-    LMDB::NOMETASYNC.should be_instance_of(Fixnum)
-    LMDB::WRITEMAP.should be_instance_of(Fixnum)
-    LMDB::MAPASYNC.should be_instance_of(Fixnum)
-    LMDB::NOTLS.should be_instance_of(Fixnum)
-  end
-
-  it 'has database flags' do
-    LMDB::REVERSEKEY.should be_instance_of(Fixnum)
-    LMDB::DUPSORT.should be_instance_of(Fixnum)
-    LMDB::INTEGERKEY.should be_instance_of(Fixnum)
-    LMDB::DUPFIXED.should be_instance_of(Fixnum)
-    LMDB::INTEGERDUP.should be_instance_of(Fixnum)
-    LMDB::REVERSEDUP.should be_instance_of(Fixnum)
-    LMDB::CREATE.should be_instance_of(Fixnum)
-    LMDB::NOOVERWRITE.should be_instance_of(Fixnum)
-    LMDB::NODUPDATA.should be_instance_of(Fixnum)
-    LMDB::CURRENT.should be_instance_of(Fixnum)
-    LMDB::RESERVE.should be_instance_of(Fixnum)
-    LMDB::APPEND.should be_instance_of(Fixnum)
-    LMDB::APPENDDUP.should be_instance_of(Fixnum)
-    LMDB::MULTIPLE.should be_instance_of(Fixnum)
-  end
-
   describe LMDB::Environment do
     subject { env }
 
-    its(:path)  { should == path }
-    its(:flags) { should == 0 }
+    it 'should return flags' do
+      subject.flags.should be_instance_of(Array)
+    end
 
-    describe 'open' do
+    describe 'new' do
       it 'returns environment' do
-        env = LMDB::Environment.open(path)
+        env = LMDB::Environment.new(path)
         env.should be_instance_of(described_class::Environment)
         env.close
       end
 
       it 'accepts block' do
-        LMDB::Environment.open(path) do |env|
+        LMDB::Environment.new(path) do |env|
           env.should be_instance_of(described_class::Environment)
           42
         end.should == 42
       end
 
       it 'accepts options' do
-        env = LMDB::Environment.open(path, :flags => LMDB::NOSYNC, :mode => 0777, :maxreaders => 777, :mapsize => 111111, :maxdbs => 666)
+        env = LMDB::Environment.new(path, :nosync => true, :mode => 0777, :maxreaders => 777, :mapsize => 111111, :maxdbs => 666)
         env.should be_instance_of(described_class::Environment)
         env.info[:maxreaders].should == 777
         env.info[:mapsize].should == 111111
+        env.flags.should include(:nosync)
+        env.close
+
+        env = LMDB::Environment.new(path, :nosync => false)
+        env.flags.should_not include(:nosync)
         env.close
       end
     end
@@ -105,58 +84,84 @@ describe LMDB do
     end
 
     it 'should accept custom flags' do
-      (subject.flags = LMDB::NOSYNC).should == LMDB::NOSYNC
-      subject.flags.should == LMDB::NOSYNC
+      subject.flags.should_not include(:nosync)
 
-      (subject.flags = 0).should == 0
-      subject.flags.should == 0
+      subject.set_flags :nosync
+      subject.flags.should include(:nosync)
+
+      subject.clear_flags :nosync
+      subject.flags.should_not include(:nosync)
     end
 
     describe 'transaction' do
       subject { env}
 
       it 'should create transactions' do
+        subject.active_txn.should == nil
         subject.transaction do |txn|
+          subject.active_txn.should == txn
           txn.should be_instance_of(described_class::Transaction)
           txn.abort
+          subject.active_txn.should == nil
         end
+        subject.active_txn.should == nil
       end
 
       it 'should create read-only transactions' do
+        subject.active_txn.should == nil
         subject.transaction(true) do |txn|
+          subject.active_txn.should == txn
           txn.should be_instance_of(described_class::Transaction)
           txn.abort
+          subject.active_txn.should == nil
         end
+        subject.active_txn.should == nil
       end
 
       it 'can create child transactions' do
+        subject.active_txn.should == nil
         env.transaction do |txn|
-          txn.should be_instance_of(described_class::Transaction)
+          subject.active_txn.should == txn
           env.transaction do |ctxn|
-            ctxn.should be_instance_of(described_class::Transaction)
+            subject.active_txn.should == ctxn
             ctxn.abort
+            subject.active_txn.should == txn
           end
+          subject.active_txn.should == txn
         end
+        subject.active_txn.should == nil
       end
 
       it 'should support aborting parent transaction' do
+        subject.active_txn.should == nil
         env.transaction do |txn|
+          subject.active_txn.should == txn
           env.transaction do |ctxn|
+            subject.active_txn.should == ctxn
             db['key'] = 'value'
             txn.abort
+            subject.active_txn.should == nil
           end
+          subject.active_txn.should == nil
         end
         db['key'].should be(nil)
+        subject.active_txn.should == nil
       end
 
       it 'should support comitting parent transaction' do
+        subject.active_txn.should == nil
         env.transaction do |txn|
+          subject.active_txn.should == txn
           env.transaction do |ctxn|
+            subject.active_txn.should == ctxn
             db['key'] = 'value'
             txn.commit
+            subject.active_txn.should == nil
           end
+          subject.active_txn.should == nil
         end
         db['key'].should == 'value'
+        subject.active_txn.should == nil
       end
     end
   end
@@ -164,6 +169,20 @@ describe LMDB do
   describe LMDB::Database do
     subject { db }
 
+    it 'should support named databases' do
+      main = env.database
+      db1 = env.database('db1', :create => true)
+      db2 = env.database('db2', :create => true)
+
+      main['key'] = '1'
+      db1['key'] = '2'
+      db2['key'] = '3'
+
+      main['key'].should == '1'
+      db1['key'].should == '2'
+      db2['key'].should == '3'
+    end
+
     it 'should get/put data' do
       subject.get('cat').should be_nil
       subject.put('cat', 'garfield').should be_nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lmdb
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel Mendler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-07 00:00:00.000000000 Z
+date: 2013-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -66,8 +66,13 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- ext/lmdb_ext/cursor_delete_flags.h
+- ext/lmdb_ext/cursor_put_flags.h
+- ext/lmdb_ext/dbi_flags.h
+- ext/lmdb_ext/env_flags.h
 - ext/lmdb_ext/errors.h
 - ext/lmdb_ext/extconf.rb
+- ext/lmdb_ext/flag_parser.h
 - ext/lmdb_ext/liblmdb/.gitignore
 - ext/lmdb_ext/liblmdb/CHANGES
 - ext/lmdb_ext/liblmdb/COPYRIGHT
@@ -79,7 +84,10 @@ files:
 - ext/lmdb_ext/lmdb_ext.c
 - ext/lmdb_ext/lmdb_ext.h
 - ext/lmdb_ext/prototypes.sh
+- ext/lmdb_ext/put_flags.h
 - lib/lmdb.rb
+- lib/lmdb/database.rb
+- lib/lmdb/version.rb
 - lmdb.gemspec
 - spec/helper.rb
 - spec/lmdb_spec.rb
@@ -103,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Ruby bindings to Lightning MDB