lmdb 0.4.7 → 0.6

data/ext/lmdb_ext/lmdb_ext.c

@@ -26,6 +26,7 @@ static void check(int code) {
 
         const char* err = mdb_strerror(code);
         const char* sep = strchr(err, ':');
+        // increment the offset by two in case there is a colon (plus space)
         if (sep)
                 err = sep + 2;
 
@@ -37,15 +38,19 @@ static void check(int code) {
 }
 
 static void transaction_free(Transaction* transaction) {
-        if (transaction->txn) {
-                rb_warn("Memory leak - Garbage collecting active transaction");
-                // mdb_txn_abort(transaction->txn);
+        if (transaction->txn && !NIL_P(transaction->txn)) {
+          //int id = (int)mdb_txn_id(transaction->txn);
+          //rb_warn(sprintf("Memory leak: Garbage collecting active transaction %d", id));
+          rb_warn("Memory leak: Garbage collecting active transaction");
+          // transaction_abort(transaction);
+          // mdb_txn_abort(transaction->txn);
         }
         free(transaction);
 }
 
 static void transaction_mark(Transaction* transaction) {
         rb_gc_mark(transaction->parent);
+        rb_gc_mark(transaction->child);
         rb_gc_mark(transaction->env);
         rb_gc_mark(transaction->cursors);
 }
@@ -108,7 +113,7 @@ static VALUE transaction_abort(VALUE self) {
 }
 
 /**
- * @overload transaction_env
+ * @overload env
  *   @return [Environment] the environment in which this transaction is running.
  *   @example
  *      env.transaction do |t|
@@ -121,49 +126,85 @@ static VALUE transaction_env(VALUE self) {
         return transaction->env;
 }
 
-static void transaction_finish(VALUE self, int commit) {
-        TRANSACTION(self, transaction);
-
-        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_active_txn(transaction->env);
-        while (!NIL_P(p) && p != self) {
-                TRANSACTION(p, txn);
-                p = txn->parent;
-        }
-        if (p != self)
-                rb_raise(cError, "Transaction is not active");
-
-        int ret = 0;
-        if (commit)
-                ret = mdb_txn_commit(transaction->txn);
-        else
-                mdb_txn_abort(transaction->txn);
+/**
+ * @overload readonly?
+ *   @note This predicate is considered *unstable*; do not get used to it.
+ *   @return [false,true] whether the transaction is read-only.
+ */
+static VALUE transaction_is_readonly(VALUE self) {
+    TRANSACTION(self, transaction);
+    //MDB_txn* txn = transaction->txn;
+    return (transaction->flags & MDB_RDONLY) ? Qtrue : Qfalse;
+}
 
-        long i;
-        for (i=0; i<RARRAY_LEN(transaction->cursors); i++) {
-                VALUE cursor = RARRAY_AREF(transaction->cursors, i);
-                cursor_close(cursor);
-        }
-        rb_ary_clear(transaction->cursors);
 
-        // Mark child transactions as closed
-        p = environment_active_txn(transaction->env);
+static void transaction_finish(VALUE self, int commit) {
+    TRANSACTION(self, transaction);
+
+    if (!transaction->txn)
+        rb_raise(cError, "Transaction is already terminated");
+
+    if (transaction->thread != rb_thread_current())
+        rb_raise(cError, "The thread closing the transaction "
+                 "is not the one that opened it");
+
+    // ensure the transaction being closed is the active one
+    VALUE p = environment_active_txn(transaction->env);
+    while (!NIL_P(p) && p != self) {
+        TRANSACTION(p, txn);
+        p = txn->parent;
+    }
+    // bail out if the transaction `self` is not the active one
+    if (p != self)
+        rb_raise(cError, "Transaction is not active");
+
+    // now eliminate the cursors
+    long i;
+    for (i=0; i<RARRAY_LEN(transaction->cursors); i++) {
+        VALUE cursor = RARRAY_AREF(transaction->cursors, i);
+        cursor_close(cursor);
+    }
+    rb_ary_clear(transaction->cursors);
+
+    // now actually finish the internal transaction
+    int ret = 0;
+    if (commit)
+        ret = mdb_txn_commit(transaction->txn);
+    else
+        mdb_txn_abort(transaction->txn);
+
+    // eliminate child transactions
+    if (transaction->child) {
+        p = self; // again this is a VALUE
+        Transaction* txn = transaction; // and this is the struct
+
+        // descend into deepest child transaction
+        do {
+            p = txn->child;
+            // this is TRANSACTION minus the declaration
+            Data_Get_Struct(txn->child, Transaction, txn);
+        } while (txn->child);
+
+        // now we ascend back up
         while (p != self) {
-                TRANSACTION(p, txn);
-                txn->txn = 0;
-                p = txn->parent;
+            TRANSACTION(p, txn);
+            txn->txn = 0;
+            p = txn->parent;
         }
-        transaction->txn = 0;
+    }
+    transaction->txn = 0;
 
-        environment_set_active_txn(transaction->env, transaction->thread, transaction->parent);
+    // no more active read-write transaction; unset the registry
+    if (!(transaction->flags & MDB_RDONLY) && !transaction->parent) {
+        ENVIRONMENT(transaction->env, env);
+        env->rw_txn_thread = NULL;
+    }
 
-        check(ret);
+    // now set the active transaction to the parent, if there is one
+    environment_set_active_txn(transaction->env, transaction->thread,
+                               transaction->parent);
+
+    check(ret);
 }
 
 // Ruby 1.8.7 compatibility
@@ -204,63 +245,143 @@ static void stop_txn_begin(void *arg)
         txn_args->stop = 1;
 }
 
+/**
+ * This is the code that opens transactions. Read-write transactions
+ * have to be called outside the GVL because they will block without
+ *
+ *
+ * Here is the basic problem with LMDB transactions:
+ *
+ * - There can only be one read-write transaction per LMDB
+ *   ENVIRONMENT, not process, not thread.
+ *
+ * - Read-write transactions can nest.
+ *
+ * - There can only be one active transaction per thread.
+ *
+ * - Every thread can have an active read-ONLY transaction, but only one.
+ *
+ * - This is because read-only transactions canNOT nest (it is
+ *   meaningless to have a nested read-only transaction)
+ *
+ * - Furthermore it is an error to open a read-only transaction under
+ *   a read-write transaction.
+ *
+ * - Same goes for opening a read-write transaction in the same thread
+ *   as an active read-only transaction.
+ *
+ * Nevertheless, the downstream Ruby user may not be able to
+ * completely control calls to env.transaction (e.g. if they are
+ * wrapping a transaction around a proc or lambda that happens to
+ * contain its own transaction), plus every call in LMDB needs to be
+ * implicitly wrapped in a transaction anyway.
+ *
+ * What this means is that we will, first, have to keep explicit track
+ * of the read-write transaction, if one exists. Second, we will have
+ * to simulate nesting for read-only transactions, so the behaviour in
+ * Ruby is the same as a read-write transaction.
+ *
+ */
+
 static VALUE with_transaction(VALUE venv, VALUE(*fn)(VALUE), VALUE arg, int flags) {
-        ENVIRONMENT(venv, environment);
+    ENVIRONMENT(venv, environment);
+
+    MDB_txn* txn;
+    TxnArgs txn_args;
+
+    VALUE thread  = rb_thread_current();
+    VALUE vparent = environment_active_txn(venv);
+
+    Transaction* tparent = NULL;
+    if (vparent && !NIL_P(vparent))
+        Data_Get_Struct(vparent, Transaction, tparent);
 
-        MDB_txn* txn;
-        TxnArgs txn_args;
+    // rb_warn("fart lol");
 
-    retry:
-        txn = NULL;
+    // XXX note this is a cursed goto loop that could almost certainly
+    // be rewritten as a do-while
+ retry:
+    txn = NULL;
 
-        txn_args.env = environment->env;
-        txn_args.parent = active_txn(venv);
-        txn_args.flags = flags;
-        txn_args.htxn = &txn;
-        txn_args.result = 0;
-        txn_args.stop = 0;
+    txn_args.env    = environment->env;
+    txn_args.parent = active_txn(venv);
+    txn_args.flags  = flags;
+    txn_args.htxn   = &txn;
+    txn_args.result = 0;
+    txn_args.stop   = 0;
 
-        if (flags & MDB_RDONLY) {
-                call_txn_begin(&txn_args);
+    if (flags & MDB_RDONLY) {
+        if (tparent && tparent->flags & MDB_RDONLY)
+            // this is a no-op: put the same actual transaction in a
+            // different wrapper struct
+            txn = txn_args.parent;
+        else
+            // this will return an error if the parent transaction is
+            // read-write, so we don't need to handle the case explicitly
+            call_txn_begin(&txn_args);
+    }
+    else {
+        if (tparent) {
+            // first we have to determine if we're on the same thread
+            // as the parent, which in turn must be the same as the
+            // environment's registry for which thread has the
+            // read-write transaction
+            if (thread != tparent->thread ||
+                thread != environment->rw_txn_thread)
+                rb_raise(cError,
+                         "Attempt to nest transaction on a different thread");
         }
-        else {
-                CALL_WITHOUT_GVL(
-                    call_txn_begin, &txn_args,
-                    stop_txn_begin, &txn_args);
-
-                if (txn_args.stop || !txn) {
-                        // !txn is when rb_thread_call_without_gvl2
-                        // returns before calling txn_begin
-                        if (txn) {
-                                mdb_txn_abort(txn);
-                        }
-                        rb_thread_check_ints();
-                        goto retry; // in what cases do we get here?
-                }
+
+        CALL_WITHOUT_GVL(call_txn_begin, &txn_args, stop_txn_begin, &txn_args);
+
+        if (txn_args.stop || !txn) {
+            // !txn is when rb_thread_call_without_gvl2
+            // returns before calling txn_begin
+            if (txn) {
+                mdb_txn_abort(txn);
+                txn_args.result = 0;
+            }
+
+            //rb_warn("got here lol");
+            rb_thread_check_ints();
+            goto retry; // in what cases do we get here?
         }
 
-        check(txn_args.result);
+        // set the thread
+        environment->rw_txn_thread = thread;
+    }
 
-        Transaction* transaction;
-        VALUE vtxn = Data_Make_Struct(cTransaction, Transaction, transaction_mark, transaction_free, transaction);
-        transaction->parent = environment_active_txn(venv);
-        transaction->env = venv;
-        transaction->txn = txn;
-        transaction->thread = rb_thread_current();
-        transaction->cursors = rb_ary_new();
-        environment_set_active_txn(venv, transaction->thread, vtxn);
+    // this will raise unless result is zero
+    check(txn_args.result);
 
-        int exception;
-        VALUE ret = rb_protect(fn, NIL_P(arg) ? vtxn : arg, &exception);
+    Transaction* transaction;
+    VALUE vtxn = Data_Make_Struct(cTransaction, Transaction, transaction_mark,
+                                  transaction_free, transaction);
+    transaction->parent  = vparent;
+    transaction->env     = venv;
+    transaction->txn     = txn;
+    transaction->flags   = flags;
+    transaction->thread  = rb_thread_current();
+    transaction->cursors = rb_ary_new();
 
-        if (exception) {
-                if (vtxn == environment_active_txn(venv))
-                        transaction_abort(vtxn);
-                rb_jump_tag(exception);
-        }
+    // set the parent's child to self
+    if (tparent) tparent->child = vtxn;
+
+    environment_set_active_txn(venv, transaction->thread, vtxn);
+
+    // now we run the function in the transaction
+    int exception;
+    VALUE ret = rb_protect(fn, NIL_P(arg) ? vtxn : arg, &exception);
+
+    if (exception) {
+        // rb_warn("lol got exception");
         if (vtxn == environment_active_txn(venv))
-                transaction_commit(vtxn);
-        return ret;
+            transaction_abort(vtxn);
+        rb_jump_tag(exception);
+    }
+    if (vtxn == environment_active_txn(venv))
+        transaction_commit(vtxn);
+    return ret;
 }
 
 static void environment_check(Environment* environment) {
@@ -319,6 +440,16 @@ static VALUE stat2hash(const MDB_stat* stat) {
         return ret;
 }
 
+static VALUE flags2hash(int flags) {
+        VALUE ret = rb_hash_new();
+
+#define FLAG(const, name) rb_hash_aset(ret, ID2SYM(rb_intern(#name)), (flags & MDB_##const) == 0 ? Qfalse : Qtrue);
+#include "dbi_flags.h"
+#undef FLAG
+
+        return ret;
+}
+
 /**
  * @overload stat
  *   Return useful statistics about an environment.
@@ -356,7 +487,7 @@ static VALUE environment_info(VALUE self) {
 
         VALUE ret = rb_hash_new();
 
-#define INFO_SET(name) rb_hash_aset(ret, ID2SYM(rb_intern(#name)), INT2NUM((size_t)info.me_##name));
+#define INFO_SET(name) rb_hash_aset(ret, ID2SYM(rb_intern(#name)), SIZET2NUM((size_t)info.me_##name));
         INFO_SET(mapaddr);
         INFO_SET(mapsize);
         INFO_SET(last_pgno);
@@ -470,7 +601,13 @@ static int environment_options(VALUE key, VALUE value, EnvironmentOptions* optio
  */
 static VALUE environment_new(int argc, VALUE *argv, VALUE klass) {
         VALUE path, option_hash;
+
+#ifdef RB_SCAN_ARGS_KEYWORDS
+        rb_scan_args_kw(RB_SCAN_ARGS_LAST_HASH_KEYWORDS,
+                        argc, argv, "1:", &path, &option_hash);
+#else
         rb_scan_args(argc, argv, "1:", &path, &option_hash);
+#endif
 
         EnvironmentOptions options = {
                 .flags = MDB_NOTLS,
@@ -641,7 +778,7 @@ static MDB_txn* active_txn(VALUE self) {
                 return 0;
         TRANSACTION(vtxn, transaction);
         if (!transaction->txn)
-                rb_raise(cError, "Transaction is terminated");
+                rb_raise(cError, "Transaction is already terminated");
         if (transaction->thread != rb_thread_current())
                 rb_raise(cError, "Wrong thread");
         return transaction->txn;
@@ -745,7 +882,13 @@ static VALUE environment_database(int argc, VALUE *argv, VALUE self) {
                 return call_with_transaction(self, self, "database", argc, argv, 0);
 
         VALUE name, option_hash;
+#ifdef RB_SCAN_ARGS_KEYWORDS
+        rb_scan_args_kw(RB_SCAN_ARGS_KEYWORDS,
+                        argc, argv, "01:", &name, &option_hash);
+#else
         rb_scan_args(argc, argv, "01:", &name, &option_hash);
+#endif
+
 
         int flags = 0;
         if (!NIL_P(option_hash))
@@ -776,13 +919,63 @@ static VALUE environment_database(int argc, VALUE *argv, VALUE self) {
 static VALUE database_stat(VALUE self) {
         DATABASE(self, database);
         if (!active_txn(database->env))
-                return call_with_transaction(database->env, self, "stat", 0, 0, MDB_RDONLY);
+                return call_with_transaction(database->env,
+                                             self, "stat", 0, 0, MDB_RDONLY);
 
         MDB_stat stat;
         check(mdb_stat(need_txn(database->env), database->dbi, &stat));
         return stat2hash(&stat);
 }
 
+/**
+ * @overload flags
+ *   Return the flags used to open the database.
+ *   @return [Hash] The flags.
+ */
+static VALUE database_get_flags(VALUE self) {
+        DATABASE(self, database);
+        if (!active_txn(database->env))
+                return call_with_transaction(database->env,
+                                             self, "flags", 0, 0, MDB_RDONLY);
+        unsigned int flags;
+        check(mdb_dbi_flags(need_txn(database->env), database->dbi, &flags));
+        return flags2hash(flags);
+}
+
+/* XXX these two could probably also be macro'd, or maybe not i dunno */
+
+/**
+ * @overload dupsort?
+ *   Returns whether the database is in +:dupsort+ mode.
+ *   @return [true, false]
+ */
+static VALUE database_is_dupsort(VALUE self) {
+        DATABASE(self, database);
+        if (!active_txn(database->env))
+                return call_with_transaction(database->env, self,
+                                             "dupsort?", 0, 0, MDB_RDONLY);
+        unsigned int flags;
+        check(mdb_dbi_flags(need_txn(database->env), database->dbi, &flags));
+
+        return (flags & MDB_DUPSORT) == 0 ? Qfalse : Qtrue;
+}
+
+/**
+ * @overload dupfixed?
+ *   Returns whether the database is in +:dupfixed+ mode.
+ *   @return [true, false]
+ */
+static VALUE database_is_dupfixed(VALUE self) {
+        DATABASE(self, database);
+        if (!active_txn(database->env))
+                return call_with_transaction(database->env, self,
+                                             "dupfixed?", 0, 0, MDB_RDONLY);
+        unsigned int flags;
+        check(mdb_dbi_flags(need_txn(database->env), database->dbi, &flags));
+
+        return (flags & MDB_DUPFIXED) == 0 ? Qfalse : Qtrue;
+}
+
 /**
  * @overload drop
  *   Remove a database from the environment.
@@ -875,8 +1068,13 @@ static VALUE database_put(int argc, VALUE *argv, VALUE self) {
         if (!active_txn(database->env))
                 return call_with_transaction(database->env, self, "put", argc, argv, 0);
 
-        VALUE vkey, vval, option_hash;
-        rb_scan_args(argc, argv, "2:", &vkey, &vval, &option_hash);
+        VALUE vkey, vval, option_hash = Qnil;
+#ifdef RB_SCAN_ARGS_KEYWORDS
+        rb_scan_args_kw(RB_SCAN_ARGS_LAST_HASH_KEYWORDS,
+                        argc, argv, "20:", &vkey, &vval, &option_hash);
+#else
+        rb_scan_args(argc, argv, "20:", &vkey, &vval, &option_hash);
+#endif
 
         int flags = 0;
         if (!NIL_P(option_hash))
@@ -927,7 +1125,7 @@ static VALUE database_delete(int argc, VALUE *argv, VALUE self) {
         if (NIL_P(vval)) {
                 check(mdb_del(need_txn(database->env), database->dbi, &key, 0));
         } else {
-                VALUE vval = StringValue(vval);
+                vval = StringValue(vval);
                 MDB_val value;
                 value.mv_size = RSTRING_LEN(vval);
                 value.mv_data = RSTRING_PTR(vval);
@@ -1025,7 +1223,7 @@ static VALUE database_cursor(VALUE self) {
 }
 
 /**
- * @overload database_env
+ * @overload env
  *   @return [Environment] the environment to which this database belongs.
  */
 static VALUE database_env(VALUE self) {
@@ -1082,21 +1280,30 @@ static VALUE cursor_prev(VALUE self) {
 }
 
 /**
- * @overload next
+ * @overload next nodup = nil
  *    Position the cursor to the next record in the database, and
  *    return its value.
+ *    @param nodup [true, false] If true, skip over duplicate records.
  *    @return [Array,nil] The [key, value] pair for the next record, or
  *        nil if no next record.
  */
-static VALUE cursor_next(VALUE self) {
+static VALUE cursor_next(int argc, VALUE* argv, VALUE self) {
         CURSOR(self, cursor);
+        VALUE nodup;
         MDB_val key, value;
+        MDB_cursor_op op = MDB_NEXT;
 
-        int ret = mdb_cursor_get(cursor->cur, &key, &value, MDB_NEXT);
+        rb_scan_args(argc, argv, "01", &nodup);
+
+        if (RTEST(nodup))
+          op = MDB_NEXT_NODUP;
+
+        int ret = mdb_cursor_get(cursor->cur, &key, &value, op);
         if (ret == MDB_NOTFOUND)
                 return Qnil;
         check(ret);
-        return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size), rb_str_new(value.mv_data, value.mv_size));
+        return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size),
+                            rb_str_new(value.mv_data, value.mv_size));
 }
 
 /**
@@ -1104,6 +1311,7 @@ static VALUE cursor_next(VALUE self) {
  *    Position the cursor to the next record in the database, and
  *    return its value if the record's key is less than or equal to
  *    the specified key, or nil otherwise.
+ *    @param key [#to_s] The key to serve as the upper bound
  *    @return [Array,nil] The [key, value] pair for the next record, or
  *        nil if no next record or the next record is out of the range.
  */
@@ -1119,7 +1327,7 @@ static VALUE cursor_next_range(VALUE self, VALUE upper_bound_key) {
         ub_key.mv_size = RSTRING_LEN(upper_bound_key);
         ub_key.mv_data = StringValuePtr(upper_bound_key);
 
-        MDB_txn *txn = mdb_cursor_txn(cursor->cur);
+        MDB_txn* txn = mdb_cursor_txn(cursor->cur);
         MDB_dbi dbi = mdb_cursor_dbi(cursor->cur);
 
         if (mdb_cmp(txn, dbi, &key, &ub_key) <= 0) {
@@ -1130,20 +1338,40 @@ static VALUE cursor_next_range(VALUE self, VALUE upper_bound_key) {
 }
 
 /**
- * @overload set(key)
- *   Set the cursor to a specified key
- *   @param key The key to which the cursor should be positioned
- *   @return [Array] The [key, value] pair to which the cursor now points.
+ * @overload set(key, value = nil)
+ *   Set the cursor to a specified key, optionally at the specified
+ *   value if the database was opened with +:dupsort+.
+ *   @param key [#to_s] The key to which the cursor should be positioned
+ *   @param value [nil, #to_s] The optional value (+:dupsort+ only)
+ *   @return [Array] The +[key, value]+ pair to which the cursor now points.
  */
-static VALUE cursor_set(VALUE self, VALUE vkey) {
-        CURSOR(self, cursor);
-        MDB_val key, value;
+ static VALUE cursor_set(int argc, VALUE* argv, VALUE self) {
+         CURSOR(self, cursor);
+         VALUE vkey, vval;
+         MDB_val key, value;
+         MDB_cursor_op op = MDB_SET_KEY;
+         int ret;
 
-        key.mv_size = RSTRING_LEN(vkey);
-        key.mv_data = StringValuePtr(vkey);
+         rb_scan_args(argc, argv, "11", &vkey, &vval);
 
-        check(mdb_cursor_get(cursor->cur, &key, &value, MDB_SET_KEY));
-        return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size), rb_str_new(value.mv_data, value.mv_size));
+         key.mv_size = RSTRING_LEN(vkey);
+         key.mv_data = StringValuePtr(vkey);
+
+         if (!NIL_P(vval)) {
+                 op = MDB_GET_BOTH;
+                 value.mv_size = RSTRING_LEN(vval);
+                 value.mv_data = StringValuePtr(vval);
+         }
+
+         ret = mdb_cursor_get(cursor->cur, &key, &value, op);
+
+         if (!NIL_P(vval) && ret == MDB_NOTFOUND)
+                 return Qnil;
+
+         check(ret);
+
+         return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size),
+                             rb_str_new(value.mv_data, value.mv_size));
 }
 
 /**
@@ -1155,12 +1383,20 @@ static VALUE cursor_set(VALUE self, VALUE vkey) {
 static VALUE cursor_set_range(VALUE self, VALUE vkey) {
         CURSOR(self, cursor);
         MDB_val key, value;
+        int ret;
 
         key.mv_size = RSTRING_LEN(vkey);
         key.mv_data = StringValuePtr(vkey);
 
-        check(mdb_cursor_get(cursor->cur, &key, &value, MDB_SET_RANGE));
-        return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size), rb_str_new(value.mv_data, value.mv_size));
+        ret = mdb_cursor_get(cursor->cur, &key, &value, MDB_SET_RANGE);
+
+        /* not sure why we were letting this throw an exception */
+        if (ret == MDB_NOTFOUND) return Qnil;
+
+        check(ret);
+
+        return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size),
+                            rb_str_new(value.mv_data, value.mv_size));
 }
 
 /**
@@ -1221,7 +1457,12 @@ static VALUE cursor_put(int argc, VALUE* argv, VALUE self) {
         CURSOR(self, cursor);
 
         VALUE vkey, vval, option_hash;
+#ifdef RB_SCAN_ARGS_KEYWORDS
+        rb_scan_args_kw(RB_SCAN_ARGS_LAST_HASH_KEYWORDS,
+                        argc, argv, "2:", &vkey, &vval, &option_hash);
+#else
         rb_scan_args(argc, argv, "2:", &vkey, &vval, &option_hash);
+#endif
 
         int flags = 0;
         if (!NIL_P(option_hash))
@@ -1258,7 +1499,12 @@ static VALUE cursor_delete(int argc, VALUE *argv, VALUE self) {
         CURSOR(self, cursor);
 
         VALUE option_hash;
+#ifdef RB_SCAN_ARGS_KEYWORDS
+        rb_scan_args_kw(RB_SCAN_ARGS_LAST_HASH_KEYWORDS,
+                        argc, argv, ":", &option_hash);
+#else
         rb_scan_args(argc, argv, ":", &option_hash);
+#endif
 
         int flags = 0;
         if (!NIL_P(option_hash))
@@ -1388,6 +1634,9 @@ void Init_lmdb_ext() {
         cDatabase = rb_define_class_under(mLMDB, "Database", rb_cObject);
         rb_undef_method(rb_singleton_class(cDatabase), "new");
         rb_define_method(cDatabase, "stat", database_stat, 0);
+        rb_define_method(cDatabase, "flags", database_get_flags, 0);
+        rb_define_method(cDatabase, "dupsort?", database_is_dupsort, 0);
+        rb_define_method(cDatabase, "dupfixed?", database_is_dupfixed, 0);
         rb_define_method(cDatabase, "drop", database_drop, 0);
         rb_define_method(cDatabase, "clear", database_clear, 0);
         rb_define_method(cDatabase, "get", database_get, 1);
@@ -1458,6 +1707,7 @@ void Init_lmdb_ext() {
         rb_define_method(cTransaction, "commit", transaction_commit, 0);
         rb_define_method(cTransaction, "abort", transaction_abort, 0);
         rb_define_method(cTransaction, "env", transaction_env, 0);
+        rb_define_method(cTransaction, "readonly?", transaction_is_readonly, 0);
 
         /**
          * Document-class: LMDB::Cursor
@@ -1491,10 +1741,10 @@ void Init_lmdb_ext() {
         rb_define_method(cCursor, "get", cursor_get, 0);
         rb_define_method(cCursor, "first", cursor_first, 0);
         rb_define_method(cCursor, "last", cursor_last, 0);
-        rb_define_method(cCursor, "next", cursor_next, 0);
+        rb_define_method(cCursor, "next", cursor_next, -1);
         rb_define_method(cCursor, "next_range", cursor_next_range, 1);
         rb_define_method(cCursor, "prev", cursor_prev, 0);
-        rb_define_method(cCursor, "set", cursor_set, 1);
+        rb_define_method(cCursor, "set", cursor_set, -1);
         rb_define_method(cCursor, "set_range", cursor_set_range, 1);
         rb_define_method(cCursor, "put", cursor_put, -1);
         rb_define_method(cCursor, "count", cursor_count, 0);