lmdb 0.4.8 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 00ac2d717d44921d8a11dabbe516ba59203b37e2
-  data.tar.gz: 4cc13fff824970690d1f2e81c14d3be5c91e1df8
+SHA256:
+  metadata.gz: c02c1c99b143e331bf5fdbae711a57c4845b32ca07c4c041c9c639b96cbb8388
+  data.tar.gz: ce305105acf85f4161e654dc80ad045baeded4e8a8e39f45fed9f8da68f5c2ce
 SHA512:
-  metadata.gz: c96d8fad469d56c9f9b010952ce2b1e4b94eb0bb247a6abbdd25c9d10b6b016a74a9abaa30763784e5669666e71626c318a1b011fea3ebcca4f75b0100aa5ffd
-  data.tar.gz: eda8808e0a2844b8d80b9c27203108017e92bfe3dfe75872a336882cf8a7a6a3866b21c2e0ba330375b80d9a31928abf840abffa20a4229ac49fc6cd85c5815b
+  metadata.gz: 1303411d1515bf39a6406540f3a10d9e12c2bd3fea597d17a9e2b949bcf7707244381467a624edd15fada41ac65ae87721c2e42a9ec4dadb5b37e9f8db2a55b0
+  data.tar.gz: aeaa5861dcbde41e9fec9634f6cae749dce6a1348ab9541f90247c2cff60dcb10180701348757a00ba7fc11e93431ef97cfb3064e5face3cc50c704498ca183d

data/.gitignore

@@ -1,5 +1,6 @@
 *.o
 *.so
+*.bundle
 .#*
 *.log
 *.mdb
@@ -7,4 +8,6 @@ Makefile
 tmp/
 Gemfile.lock
 doc/
-.yardoc/
+.yardoc/
+*.gem
+dtrace/

data/.travis.yml

@@ -1,13 +1,14 @@
 language: ruby
 rvm:
-  - 1.8.7
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
+  - 2.3.8
+  - 2.4.9
+  - 2.5.7
+  - 2.6.3
+  - 2.7.0
   - ruby-head
   - rbx
 matrix:
   allow_failures:
     - rvm: ruby-head
-    - rvm: 1.8.7
+    - rvm: 2.3.8
     - rvm: rbx

data/CHANGES

@@ -1,3 +1,45 @@
+0.5.1
+
+  * Move read-only operations to read-only transactions (djt)
+
+0.5.0
+
+  * Add jumping to key-value pairs via MDB_GET_BOTH (djt)
+  * Add a number of handy predicates and shortcuts (see docs; djt)
+
+0.4.8
+
+  * Fix a bug in Database#delete (#38) and add tests.
+
+0.4.7
+
+  * Fix bug in nested transations (#34).
+
+0.4.6
+
+  * Import lmdb 0.9.14 source.
+  * Handle MDB_MAP_RESIZED during transaction.
+  * Expose mdb_env_set_mapsize() as Environment#mapsize=.
+  * Cleanup and bug detection in environment_free.
+  * Add accessors:
+     * Transaction#env
+     * Database#env
+     * Cursor#database
+  * Add Cursor#next_range for iterating up to a specified key.
+
+0.4.5
+
+  * Expand file paths in #copy and #new.
+  * Fix bug: mark cursor list in transaction_mark.
+
+0.4.4
+
+  * Fix gemspec: permit ruby version >= 2.
+
+0.4.3
+
+  * Restore 1.9.3 compatibility.
+
 0.4.2
 
   * Fix #11, #12, #14.

data/ext/lmdb_ext/env_flags.h

@@ -6,3 +6,6 @@ FLAG(NOMETASYNC, nometasync)
 FLAG(WRITEMAP, writemap)
 FLAG(MAPASYNC, mapasync)
 FLAG(NOTLS, notls)
+FLAG(NOLOCK, nolock)
+FLAG(NORDAHEAD, nordahead)
+FLAG(NOMEMINIT, nomeminit)

data/ext/lmdb_ext/errors.h

@@ -13,3 +13,9 @@ ERROR(TLS_FULL)
 ERROR(TXN_FULL)
 ERROR(CURSOR_FULL)
 ERROR(PAGE_FULL)
+ERROR(MAP_RESIZED)
+ERROR(INCOMPATIBLE)
+ERROR(BAD_RSLOT)
+ERROR(BAD_TXN)
+ERROR(BAD_VALSIZE)
+ERROR(BAD_DBI)

data/ext/lmdb_ext/lmdb_ext.c

@@ -38,8 +38,11 @@ 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);
+          //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);
 }
@@ -108,7 +111,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,6 +124,18 @@ static VALUE transaction_env(VALUE self) {
         return transaction->env;
 }
 
+/**
+ * @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;
+}
+
+
 static void transaction_finish(VALUE self, int commit) {
         TRANSACTION(self, transaction);
 
@@ -231,9 +246,9 @@ static VALUE with_transaction(VALUE venv, VALUE(*fn)(VALUE), VALUE arg, int flag
                 if (txn_args.stop || !txn) {
                         // !txn is when rb_thread_call_without_gvl2
                         // returns before calling txn_begin
-                        if (txn) {
-                                mdb_txn_abort(txn);
-                        }
+                        if (txn) mdb_txn_abort(txn);
+
+                        //rb_warn("got here lol");
                         rb_thread_check_ints();
                         goto retry; // in what cases do we get here?
                 }
@@ -246,6 +261,7 @@ static VALUE with_transaction(VALUE venv, VALUE(*fn)(VALUE), VALUE arg, int flag
         transaction->parent = environment_active_txn(venv);
         transaction->env = venv;
         transaction->txn = txn;
+        transaction->flags = flags;
         transaction->thread = rb_thread_current();
         transaction->cursors = rb_ary_new();
         environment_set_active_txn(venv, transaction->thread, vtxn);
@@ -254,6 +270,7 @@ static VALUE with_transaction(VALUE venv, VALUE(*fn)(VALUE), VALUE arg, int flag
         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_abort(vtxn);
                 rb_jump_tag(exception);
@@ -319,6 +336,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 +383,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 +497,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,
@@ -745,7 +778,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 +815,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 +964,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))
@@ -1025,7 +1119,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 +1176,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 +1207,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 +1223,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 +1234,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 +1279,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 +1353,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 +1395,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 +1530,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 +1603,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 +1637,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);

data/ext/lmdb_ext/lmdb_ext.h

@@ -53,6 +53,7 @@ typedef struct {
         VALUE    thread;
         VALUE    cursors;
         MDB_txn* txn;
+        unsigned int flags;
 } Transaction;
 
 typedef struct {
@@ -116,10 +117,10 @@ static void cursor_free(Cursor* cursor);
 static VALUE cursor_get(VALUE self);
 static VALUE cursor_last(VALUE self);
 static void cursor_mark(Cursor* cursor);
-static VALUE cursor_next(VALUE self);
+static VALUE cursor_next(int argc, VALUE* argv, VALUE self);
 static VALUE cursor_prev(VALUE self);
 static VALUE cursor_put(int argc, VALUE* argv, VALUE self);
-static VALUE cursor_set(VALUE self, VALUE vkey);
+static VALUE cursor_set(int argc, VALUE* argv, VALUE self);
 static VALUE cursor_set_range(VALUE self, VALUE vkey);
 static VALUE database_clear(VALUE self);
 static VALUE database_cursor(VALUE self);
@@ -129,6 +130,9 @@ 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 database_get_flags(VALUE self);
+static VALUE database_is_dupsort(VALUE self);
+static VALUE database_is_dupfixed(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);

data/lib/lmdb/database.rb

@@ -11,9 +11,12 @@ module LMDB
     #      puts "at #{key}: #{value}"
     #    end
     def each
-      cursor do |c|
-        while i = c.next
-          yield(i)
+      # maybe_txn true do
+      env.transaction do
+        cursor do |c|
+          while i = c.next
+            yield(i)
+          end
         end
       end
     end
@@ -37,13 +40,123 @@ module LMDB
     #      db['b'] = 1234    #=> 1234
     #      db['a']           #=> 'b'
     def []=(key, value)
-      put(key, value)
+      put key, value
       value
     end
 
+    # Get the keys as an array.
+    # @return [Array] of keys.
+    def keys
+      each_key.to_a
+    end
+
+    # Iterate over each key in the database, skipping over duplicate records.
+    #
+    # @yield key [String] the next key in the database.
+    # @return [Enumerator] in lieu of a block.
+    def each_key(&block)
+      return enum_for :each_key unless block_given?
+      # maybe_txn true do
+      env.transaction do
+        cursor do |c|
+          while (rec = c.next true)
+            yield rec.first
+          end
+        end
+      end
+    end
+
+    # Iterate over the duplicate values of a given key, using an
+    # implicit cursor. Works whether +:dupsort+ is set or not.
+    #
+    # @param key [#to_s] The key in question.
+    # @yield value [String] the next value associated with the key.
+    # @return [Enumerator] in lieu of a block.
+    def each_value(key, &block)
+      return enum_for :each_value, key unless block_given?
+
+      value = get(key) or return
+      unless dupsort?
+        yield value
+        return
+      end
+
+      #maybe_txn true do
+      env.transaction do
+        cursor do |c|
+          method = :set
+          while rec = c.send(method, key)
+            method = :next_range
+            yield rec[1]
+          end
+        end
+      end
+    end
+
+    # Return the cardinality (number of duplicates) of a given
+    # key. Works whether +:dupsort+ is set or not.
+    # @param key [#to_s] The key in question.
+    # @return [Integer] The number of entries under the key.
+    def cardinality(key)
+      ret = 0
+      maybe_txn true do
+      # env.transaction do
+        if get key
+          if dupsort?
+            cursor do |c|
+              c.set key
+              ret = c.count
+            end
+          else
+            ret = 1
+          end
+        end
+      end
+      ret
+    end
+
+    # Test if the database has a given key (or, if opened in
+    # +:dupsort+, value)
+    def has?(key, value = nil)
+      v = get(key) or return false
+      return true if value.nil? or value.to_s == v
+      return false unless dupsort?
+
+      ret = false
+      # read-only txn was having trouble being nested inside a read-write
+      #maybe_txn true do
+      env.transaction do
+        cursor { |c| ret = !!c.set(key, value) }
+      end
+      ret
+    end
+
+    # Delete the key (and optional value pair) if it exists; do not
+    # complain about missing keys.
+    # @param key [#to_s] The key.
+    # @param value [#to_s] The optional value.
+    def delete?(key, value = nil)
+      delete key, value if has? key, value
+    end
+
     # @return the number of records in this database
     def size
       stat[:entries]
     end
+
+    private
+
+    # having trouble with read-only transactions embedded in
+    # read-write for some reason; can't pin it down to test it yet so
+    # going to do this (djt; 2020-02-10)
+    def maybe_txn(readonly, &block)
+      if t = env.active_txn
+        yield t
+      else
+        env.transaction !!readonly do |t|
+          yield t
+        end
+      end
+    end
   end
 end

data/lib/lmdb/version.rb

@@ -1,3 +1,3 @@
 module LMDB
-  VERSION = '0.4.8'
+  VERSION = '0.5.3'.freeze
 end

data/lmdb.gemspec

@@ -19,8 +19,8 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- spec/*`.split("\n")
   s.require_paths = ['lib']
 
-  s.required_ruby_version = ">= 1.9.3"
-  s.add_development_dependency 'rake', "~> 10.0"
-  s.add_development_dependency 'rake-compiler', '<=0.8.2'
+  s.required_ruby_version = ">= 2.4"
+  s.add_development_dependency 'rake', "~> 13.0"
+  s.add_development_dependency 'rake-compiler', '~> 1.1'
   s.add_development_dependency 'rspec', "~> 3.0"
 end

data/spec/lmdb_spec.rb

@@ -2,15 +2,15 @@
 require 'helper'
 
 describe LMDB do
-  let(:env) { LMDB.new(path) }
+  let(:env) { LMDB.new(path, mapsize: 2**20) }
   after     { env.close rescue nil }
 
   let(:db)  { env.database }
 
   it 'has version constants' do
-    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_MAJOR.should be_instance_of(Integer)
+    LMDB::LIB_VERSION_MINOR.should be_instance_of(Integer)
+    LMDB::LIB_VERSION_PATCH.should be_instance_of(Integer)
     LMDB::LIB_VERSION.should be_instance_of(String)
     LMDB::VERSION.should be_instance_of(String)
   end
@@ -37,7 +37,8 @@ describe LMDB do
       end
 
       it 'accepts options' do
-        env = LMDB::Environment.new(path, :nosync => true, :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)
         env.info[:maxreaders].should == 777
         env.info[:mapsize].should == 111111
@@ -52,22 +53,22 @@ describe LMDB do
 
     it 'should return stat' do
       stat = env.stat
-      stat[:psize].should be_instance_of(Fixnum)
-      stat[:depth].should be_instance_of(Fixnum)
-      stat[:branch_pages].should be_instance_of(Fixnum)
-      stat[:leaf_pages].should be_instance_of(Fixnum)
-      stat[:overflow_pages].should be_instance_of(Fixnum)
-      stat[:entries].should be_instance_of(Fixnum)
+      stat[:psize].should be_instance_of(Integer)
+      stat[:depth].should be_instance_of(Integer)
+      stat[:branch_pages].should be_instance_of(Integer)
+      stat[:leaf_pages].should be_instance_of(Integer)
+      stat[:overflow_pages].should be_instance_of(Integer)
+      stat[:entries].should be_instance_of(Integer)
     end
 
     it 'should return info' do
       info = env.info
-      info[:mapaddr].should be_instance_of(Fixnum)
-      info[:mapsize].should be_instance_of(Fixnum)
-      info[:last_pgno].should be_instance_of(Fixnum)
-      info[:last_txnid].should be_instance_of(Fixnum)
-      info[:maxreaders].should be_instance_of(Fixnum)
-      info[:numreaders].should be_instance_of(Fixnum)
+      info[:mapaddr].should be_instance_of(Integer)
+      info[:mapsize].should be_instance_of(Integer)
+      info[:last_pgno].should be_instance_of(Integer)
+      info[:last_txnid].should be_instance_of(Integer)
+      info[:maxreaders].should be_instance_of(Integer)
+      info[:numreaders].should be_instance_of(Integer)
     end
 
     it 'should set mapsize' do
@@ -183,10 +184,18 @@ describe LMDB do
   describe LMDB::Database do
     subject { db }
 
+    it 'should return flags' do
+      subject.flags.should be_instance_of(Hash)
+      subject.dupsort?.should == false
+      subject.dupfixed?.should == false
+    end
+
     it 'should support named databases' do
       main = env.database
-      db1 = env.database('db1', :create => true)
-      db2 = env.database('db2', :create => true)
+      # funnily it complains in 2.7 unless i do this
+      dbopts = { create: true }
+      db1 = env.database 'db1', create: true # actually no it doesn't wtf
+      db2 = env.database 'db2', **dbopts
 
       main['key'] = '1'
       db1['key'] = '2'
@@ -201,6 +210,10 @@ describe LMDB do
       subject.get('cat').should be_nil
       subject.put('cat', 'garfield').should be_nil
       subject.get('cat').should == 'garfield'
+
+      # check for key-value pairs on non-dupsort database
+      subject.has?('cat', 'garfield').should == true
+      subject.has?('cat', 'heathcliff').should == false
     end
 
     it 'should delete by key' do
@@ -214,6 +227,9 @@ describe LMDB do
       subject.put('cat', 'garfield')
       subject.delete('cat', 'garfield').should be_nil
       proc { subject.delete('cat', 'garfield') }.should raise_error(LMDB::Error::NOTFOUND)
+
+      # soft delete
+      subject.delete?('cat', 'heathcliff').should be_nil
     end
 
     it 'stores key/values in same transaction' do
@@ -273,10 +289,16 @@ describe LMDB do
 
     it 'should get environment' do
       main = env.database
-      db1 = env.database('db1', :create => true)
+      db1 = env.database('db1', create: true)
       main.env.should == env
       db1.env.should == env
     end
+
+    it 'should iterate over/list keys' do
+      db['k1'] = 'v1'
+      db['k2'] = 'v2'
+      db.keys.sort.should == %w[k1 k2]
+    end
   end
 
   describe LMDB::Cursor do
@@ -331,6 +353,49 @@ describe LMDB do
       end
     end
 
+    it 'should set to a key-value pair when db is dupsort' do
+      dupdb = env.database 'dupsort', create: true, dupsort: true
+
+      # check flag while we're at it
+      dupdb.flags[:dupsort].should == true
+      dupdb.dupsort?.should == true
+      dupdb.dupfixed?.should == false
+
+      # add the no-op keyword to trigger a complaint from ruby 2.7
+      dupdb.put 'key1', 'value1', nodupdata: false
+      dupdb.put 'key1', 'value2'
+      dupdb.put 'key2', 'value3'
+      dupdb.cursor do |c|
+        c.set('key1', 'value2').should == ['key1', 'value2']
+        c.set('key1', 'value1').should == ['key1', 'value1']
+        c.set('key1', 'value3').should == nil
+      end
+
+      # this is basically an extended test of `cursor.set key, val`
+      dupdb.has?('key1', 'value1').should == true
+      dupdb.has?('key1', 'value2').should == true
+      dupdb.has?('key1', 'value0').should == false
+
+      # match the contents of key1
+      dupdb.each_value('key1').to_a.sort.should == ['value1', 'value2']
+
+      # we should have two entries for key1
+      dupdb.cardinality('key1').should == 2
+
+      dupdb.each_key.to_a.sort.should == ['key1', 'key2']
+
+      # XXX move this or whatever
+      env.transaction do |t|
+        dupdb.put 'key1', 'value1' unless dupdb.has? 'key1', 'value1'
+      end
+    end
+
+    it 'should complain setting a key-value pair without dupsort' do
+      db.cursor do |c|
+        proc { c.set('key1', 'value1') }.should raise_error(LMDB::Error)
+      end
+    end
+
     it 'should raise without block or txn' do
       proc { db.cursor.next }.should raise_error(LMDB::Error)
     end
@@ -346,5 +411,12 @@ describe LMDB do
       env.transaction { c = db.cursor; db2 = c.database }
       db2.should == db
     end
+
+    it 'should nest a read-only txn in a read-write' do
+      env.transaction do |t|
+        # has? opens a read-only transaction
+        db.put 'hurr', 'durr' unless db.has? 'hurr', 'durr'
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lmdb
 version: !ruby/object:Gem::Version
-  version: 0.4.8
+  version: 0.5.3
 platform: ruby
 authors:
 - Daniel Mendler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-02 00:00:00.000000000 Z
+date: 2020-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -103,15 +103,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Ruby bindings to Lightning MDB