lmdb 0.6.6 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcfc5ce25df41f83029918b757006f4f34b674f41c2c2691cc40128a7e63a46e
-  data.tar.gz: 9cf681ab6dc945eac9b8225717248f42cf27940a704e951aed3dbd59f151df23
+  metadata.gz: c098384d91381d0f7c66a4794f88ea55c1c8a1e54d60480a75a379704407252d
+  data.tar.gz: 11c4e5b74f9b552ad9f89d5a189bf812340ab409b43b54361cb84f7d47dfd906
 SHA512:
-  metadata.gz: 888eb18fa7e8be017e950f1b8893fc9c4f3c4cc1fa616312438b23be86344cfdeb37d2cc7edc477a528292776ae45e95c0f65c8cd49cd417a4be387f1dd3a28f
-  data.tar.gz: 07740710e001f491d22b902d27c1e446d2bab1b93e42d41951e47fdd084b5d5f982dadc551f13764146e8725b8dda4b7a7084c2781454bac2d9f332e16fd666e
+  metadata.gz: da3b52d345951ad527b67ce32998c749b17267b7b0d075f695e841d1b2a0891df4e0064e021e7db9ac21f41c0b81a4fb590ff88a98250675e15ad14baf185680
+  data.tar.gz: 12ae851f60db43dec61730f8497a06bf952e56242bff2e8fe64153a852c34582441556320cb1627fa65b7c29dfe417ba312c929d242511c0ab9c3888b12075b4

data/CHANGES

@@ -1,3 +1,12 @@
+0.7.0
+
+  * Nesting read-only transactions finally works, by making it a noop
+    and using the parent transaction (djt)
+
+0.6.6
+
+  * added `put?` and `delete?` (djt)
+
 0.5.1
 
   * Move read-only operations to read-only transactions (djt)

data/ext/lmdb_ext/lmdb_ext.c

@@ -285,69 +285,87 @@ static void stop_txn_begin(void *arg)
  */
 
 static VALUE with_transaction(VALUE venv, VALUE(*fn)(VALUE), VALUE arg, int flags) {
-    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);
-
+  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);
+
+  /*
+   * If the requested transaction is read-only and there is a parent
+   * transaction (whether read-only or not), we need to use the
+   * parent transaction.
+   *
+   * XXX except conceivably you could do a transaction (RO or RW)
+   * that spawns a thread that opens another transaction.
+   *
+   * note we do *NOT* re-begin the parent transaction, nor do we
+   * want to commit it
+   *
+   */
+
+  if (tparent && flags & MDB_RDONLY) {
+    int exception;
+    VALUE ret = rb_protect(fn, NIL_P(arg) ? vparent : arg, &exception);
+    if (exception) {
+      if (vparent == environment_active_txn(venv))
+        transaction_abort(vparent);
+      rb_jump_tag(exception);
+    }
+    return ret;
+  }
+  else {
     // XXX note this is a cursed goto loop that could almost certainly
     // be rewritten as a do-while
- retry:
+  retry:
     txn = NULL;
 
     txn_args.env    = environment->env;
-    txn_args.parent = active_txn(venv);
+    txn_args.parent = active_txn(venv); // this returns an MDB_txn
     txn_args.flags  = flags;
     txn_args.htxn   = &txn;
     txn_args.result = 0;
     txn_args.stop   = 0;
 
-    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);
-    }
+    if (flags & MDB_RDONLY)
+      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");
+      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");
+      }
+
+      // try to acquire the new transaction
+      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;
         }
 
-        CALL_WITHOUT_GVL(call_txn_begin, &txn_args, stop_txn_begin, &txn_args);
+        //rb_warn("got here lol");
+        rb_thread_check_ints();
+        goto retry; // in what cases do we get here?
+      }
 
-        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?
-        }
-
-        // set the thread
-        environment->rw_txn_thread = thread;
+      // set the thread
+      environment->rw_txn_thread = thread;
     }
 
     // this will raise unless result is zero
@@ -373,14 +391,15 @@ 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);
+      // rb_warn("lol got exception");
+      if (vtxn == environment_active_txn(venv))
+        transaction_abort(vtxn);
+      rb_jump_tag(exception);
     }
     if (vtxn == environment_active_txn(venv))
-        transaction_commit(vtxn);
+      transaction_commit(vtxn);
     return ret;
+  }
 }
 
 static void environment_check(Environment* environment) {
@@ -773,23 +792,24 @@ static void environment_set_active_txn(VALUE self, VALUE thread, VALUE txn) {
         }
 }
 
+static MDB_txn* extract_txn(VALUE vtxn) {
+  if (NIL_P(vtxn)) return NULL;
+  TRANSACTION(vtxn, transaction);
+  if (!transaction->txn) rb_raise(cError, "Transaction is already terminated");
+  if (transaction->thread != rb_thread_current())
+    rb_raise(cError, "Transaction is from another thread");
+  return transaction->txn;
+}
 
 static MDB_txn* active_txn(VALUE self) {
         VALUE vtxn = environment_active_txn(self);
-        if (NIL_P(vtxn))
-                return 0;
-        TRANSACTION(vtxn, transaction);
-        if (!transaction->txn)
-                rb_raise(cError, "Transaction is already terminated");
-        if (transaction->thread != rb_thread_current())
-                rb_raise(cError, "Wrong thread");
-        return transaction->txn;
+        return extract_txn(vtxn);
 }
 
 static MDB_txn* need_txn(VALUE self) {
         MDB_txn* txn = active_txn(self);
-        if (!txn)
-                rb_raise(cError, "No active transaction");
+
+        if (!txn) rb_raise(cError, "No active transaction");
         return txn;
 }
 

data/ext/lmdb_ext/lmdb_ext.h

@@ -104,12 +104,12 @@ typedef struct {
 } EnvironmentOptions;
 
 typedef struct {
-        MDB_env *env;
-        MDB_txn *parent;
-        unsigned int flags;
-        MDB_txn **htxn;
-        int result;
-        int stop;
+  MDB_env *env;
+  MDB_txn *parent;
+  unsigned int flags;
+  MDB_txn **htxn; // not sure why this is a pointer to a pointer
+  int result;
+  int stop;
 } TxnArgs;
 
 static VALUE cEnvironment, cDatabase, cTransaction, cCursor, cError;

data/lib/lmdb/database.rb

@@ -136,16 +136,18 @@ module LMDB
 
     # Conditionally put a value into the database.
     #
-    # @param key [String] The key of the record
-    # @param value [String] the (optional) value
+    # @param key [#to_s] The key of the record
+    # @param value [#to_s, nil] the (optional) value
     # @param options [Hash] options
     #
     # @see #put
     #
     # @return [void]
+    #
     def put?(key, value = nil, **options)
+      flags = { (dupsort? ? :nodupdata : :nooverwrite) => true }
       begin
-        put key, value, **options
+        put key, value, **options.merge(flags)
       rescue LMDB::Error::KEYEXIST
         nil
       end
@@ -154,15 +156,15 @@ module LMDB
     # Delete the key (and optional value pair) if it exists; do not
     # complain about missing keys.
     # @param key [#to_s] The key of the record
-    # @param value [#to_s] The optional value
+    # @param value [#to_s, nil] The optional value
     #
     # @see #delete
     #
     # @return [void]
     #
-    def delete?(key, value = nil, **options)
+    def delete?(key, value = nil)
       begin
-        delete key, value, **options
+        delete key, value
       rescue LMDB::Error::NOTFOUND
         nil
       end
@@ -186,6 +188,10 @@ module LMDB
     # 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)
+    #
+    # 2025-11-14: this miiiigght no longer be necessary?? like as of
+    # whenever i implemented that short-circuiting code
+    #
     def maybe_txn(readonly, &block)
       if t = env.active_txn
         # warn "reusing #{t.readonly? ? 'read-only ' : ''}txn #{t.inspect}"

data/lib/lmdb/version.rb

@@ -1,3 +1,3 @@
 module LMDB
-  VERSION = '0.6.6'.freeze
+  VERSION = '0.7.0'.freeze
 end

data/spec/lmdb_spec.rb

@@ -40,8 +40,8 @@ describe LMDB do
         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
+        env.info[:maxreaders].should eq(777)
+        env.info[:mapsize].should eq(111111)
         env.flags.should include(:nosync)
         env.close
 
@@ -74,7 +74,7 @@ describe LMDB do
     it 'should set mapsize' do
       size_before = env.info[:mapsize]
       env.mapsize = size_before * 2
-      env.info[:mapsize].should == size_before * 2
+      env.info[:mapsize].should eq(size_before * 2)
     end
 
     it 'should copy' do
@@ -108,7 +108,7 @@ describe LMDB do
       it 'returns list of named databases' do
         db1 = subject.database 'db1', create: true
         db2 = subject.database 'db2', create: true
-        subject.databases.should == ['db1', 'db2']
+        subject.databases.should eq(['db1', 'db2'])
       end
 
       it 'returns list of named databases when there are non-database kes in the main db' do
@@ -117,7 +117,7 @@ describe LMDB do
         subject.database 'db1', create: true
         subject.database 'db2', create: true
 
-        subject.databases.should == ['db1', 'db2']
+        subject.databases.should eq(['db1', 'db2'])
       end
     end
 
@@ -125,71 +125,71 @@ describe LMDB do
       subject { env }
 
       it 'should create transactions' do
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
         subject.transaction do |txn|
-          subject.active_txn.should == txn
+          subject.active_txn.should eq(txn)
           txn.should be_instance_of(described_class)
           txn.abort
-          subject.active_txn.should == nil
+          subject.active_txn.should be_nil
         end
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
       end
 
       it 'should create read-only transactions' do
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
         subject.transaction(true) do |txn|
-          subject.active_txn.should == txn
+          subject.active_txn.should eq(txn)
           txn.should be_instance_of(described_class)
           txn.abort
-          subject.active_txn.should == nil
+          subject.active_txn.should be_nil
         end
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
       end
 
       it 'can create child transactions' do
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
         env.transaction do |txn|
-          subject.active_txn.should == txn
+          subject.active_txn.should eq(txn)
           env.transaction do |ctxn|
-            subject.active_txn.should == ctxn
+            subject.active_txn.should eq(ctxn)
             ctxn.abort
-            subject.active_txn.should == txn
+            subject.active_txn.should eq(txn)
           end
-          subject.active_txn.should == txn
+          subject.active_txn.should eq(txn)
         end
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
       end
 
       it 'should support aborting parent transaction' do
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
         env.transaction do |txn|
-          subject.active_txn.should == txn
+          subject.active_txn.should eq(txn)
           env.transaction do |ctxn|
-            subject.active_txn.should == ctxn
+            subject.active_txn.should eq(ctxn)
             db['key'] = 'value'
             txn.abort
-            subject.active_txn.should == nil
+            subject.active_txn.should be_nil
           end
-          subject.active_txn.should == nil
+          subject.active_txn.should be_nil
         end
-        db['key'].should be(nil)
-        subject.active_txn.should == nil
+        db['key'].should be_nil
+        subject.active_txn.should be_nil
       end
 
       it 'should support comitting parent transaction' do
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
         env.transaction do |txn|
-          subject.active_txn.should == txn
+          subject.active_txn.should eq(txn)
           env.transaction do |ctxn|
-            subject.active_txn.should == ctxn
+            subject.active_txn.should eq(ctxn)
             db['key'] = 'value'
             txn.commit
-            subject.active_txn.should == nil
+            subject.active_txn.should be_nil
           end
-          subject.active_txn.should == nil
+          subject.active_txn.should be_nil
         end
-        db['key'].should == 'value'
-        subject.active_txn.should == nil
+        db['key'].should eq('value')
+        subject.active_txn.should be_nil
       end
 
       it 'should get environment' do
@@ -197,7 +197,7 @@ describe LMDB do
         env.transaction do |txn|
           env2 = txn.env
         end
-        env2.should == env
+        env2.should eq(env)
       end
     end
   end
@@ -207,8 +207,8 @@ describe LMDB do
 
     it 'should return flags' do
       subject.flags.should be_instance_of(Hash)
-      subject.dupsort?.should == false
-      subject.dupfixed?.should == false
+      subject.dupsort?.should be_falsy
+      subject.dupfixed?.should be_falsy
     end
 
     it 'should support named databases' do
@@ -222,19 +222,22 @@ describe LMDB do
       db1['key'] = '2'
       db2['key'] = '3'
 
-      main['key'].should == '1'
-      db1['key'].should == '2'
-      db2['key'].should == '3'
+      main['key'].should eq(?1)
+      db1['key'].should  eq(?2)
+      db2['key'].should  eq(?3)
     end
 
     it 'should get/put data' do
       subject.get('cat').should be_nil
       subject.put('cat', 'garfield').should be_nil
-      subject.get('cat').should == 'garfield'
+      subject.get('cat').should eq('garfield')
 
       # check for key-value pairs on non-dupsort database
-      subject.has?('cat', 'garfield').should == true
-      subject.has?('cat', 'heathcliff').should == false
+      subject.has?('cat', 'garfield').should be_truthy
+      subject.has?('cat', 'heathcliff').should be_falsy
+
+      subject.put?('dog', 'odie')
+      subject.has?('dog', 'odie').should be_truthy
     end
 
     it 'should delete by key' do
@@ -255,7 +258,7 @@ describe LMDB do
 
     it 'stores key/values in same transaction' do
       db.put('key', 'value').should be_nil
-      db.get('key').should == 'value'
+      db.get('key').should eq('value')
     end
 
     it 'stores key/values in different transactions' do
@@ -268,10 +271,10 @@ describe LMDB do
       end
 
       env.transaction do
-        db.get('key').should == 'value'
-        db.get('key2').should == 'value2'
+        db.get('key').should eq('value')
+        db.get('key2').should eq('value2')
         env.transaction do
-          db.get('key3').should == 'value3'
+          db.get('key3').should eq('value3')
         end
       end
     end
@@ -281,22 +284,22 @@ describe LMDB do
     end
 
     it 'should return size' do
-      db.size.should == 0
+      db.size.should eq(0)
       db.put('key', 'value')
-      db.size.should == 1
+      db.size.should eq(1)
       db.put('key2', 'value2')
-      db.size.should == 2
+      db.size.should eq(2)
     end
 
     it 'should be enumerable' do
       db['k1'] = 'v1'
       db['k2'] = 'v2'
-      db.to_a.should == [['k1', 'v1'], ['k2', 'v2']]
+      db.to_a.should eq([['k1', 'v1'], ['k2', 'v2']])
     end
 
     it 'should have shortcuts' do
       db['key'] = 'value'
-      db['key'].should == 'value'
+      db['key'].should eq('value')
     end
 
     it 'should store binary' do
@@ -304,15 +307,15 @@ describe LMDB do
       bin2 = "\xAAx\BB\xCC2"
       db[bin1] = bin2
       db['key'] = bin2
-      db[bin1].should == bin2
-      db['key'].should == bin2
+      db[bin1].should eq(bin2)
+      db['key'].should eq(bin2)
     end
 
     it 'should get environment' do
       main = env.database
       db1 = env.database('db1', create: true)
-      main.env.should == env
-      db1.env.should == env
+      main.env.should eq(env)
+      db1.env.should eq(env)
     end
 
     it 'should iterate over/list keys' do
@@ -330,38 +333,38 @@ describe LMDB do
 
     it 'should get first key/value' do
       db.cursor do |c|
-        c.first.should == ['key1', 'value1']
+        c.first.should eq(['key1', 'value1'])
       end
     end
 
     it 'should get last key/value' do
       db.cursor do |c|
-        c.last.should == ['key2', 'value2']
+        c.last.should eq(['key2', 'value2'])
       end
     end
 
     it 'should get next key/value' do
       db.cursor do |c|
         c.first
-        c.next.should == ['key2', 'value2']
+        c.next.should eq(['key2', 'value2'])
       end
     end
 
     it 'should seek to key' do
       db.cursor do |c|
-        c.set('key1').should == ['key1', 'value1']
+        c.set('key1').should eq(['key1', 'value1'])
       end
     end
 
     it 'should seek to closest key' do
       db.cursor do |c|
-        c.set_range('key0').should == ['key1', 'value1']
+        c.set_range('key0').should eq(['key1', 'value1'])
       end
     end
 
     it 'should seek to key with nuls' do
       db.cursor do |c|
-        c.set_range('\x00').should == ['key1', 'value1']
+        c.set_range('\x00').should eq(['key1', 'value1'])
       end
     end
 
@@ -369,8 +372,8 @@ describe LMDB do
       db.cursor do |c|
         db.put('key0', 'value0')
         c.first
-        c.next_range('key1').should == ['key1', 'value1']
-        c.next_range('key1').should == nil
+        c.next_range('key1').should eq(['key1', 'value1'])
+        c.next_range('key1').should be_nil
       end
     end
 
@@ -378,34 +381,35 @@ describe LMDB 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
+      dupdb.flags[:dupsort].should be_truthy
+      dupdb.dupsort?.should be_truthy
+      dupdb.dupfixed?.should be_falsy
 
       # 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
+        c.set('key1', 'value2').should eq(['key1', 'value2'])
+        c.set('key1', 'value1').should eq(['key1', 'value1'])
+        c.set('key1', 'value3').should be_nil
       end
 
+      # this should do nothing
       dupdb.put?('key1', 'value1', nodupdata: true).should be_nil
 
       # 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
+      dupdb.has?('key1', 'value1').should be_truthy
+      dupdb.has?('key1', 'value2').should be_truthy
+      dupdb.has?('key1', 'value0').should be_falsy
 
       # match the contents of key1
-      dupdb.each_value('key1').to_a.sort.should == ['value1', 'value2']
+      dupdb.each_value('key1').to_a.sort.should eq(['value1', 'value2'])
 
       # we should have two entries for key1
-      dupdb.cardinality('key1').should == 2
+      dupdb.cardinality('key1').should eq(2)
 
-      dupdb.each_key.to_a.sort.should == ['key1', 'key2']
+      dupdb.each_key.to_a.sort.should eq(['key1', 'key2'])
 
       # XXX move this or whatever
       env.transaction do |t|
@@ -432,7 +436,7 @@ describe LMDB do
     it 'should get database' do
       db2 = nil
       env.transaction { c = db.cursor; db2 = c.database }
-      db2.should == db
+      db2.should eq(db)
     end
 
     it 'should nest a read-only txn in a read-write' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lmdb
 version: !ruby/object:Gem::Version
-  version: 0.6.6
+  version: 0.7.0
 platform: ruby
 authors:
 - Daniel Mendler
 - Dorian Taylor
 bindir: bin
 cert_chain: []
-date: 2025-11-13 00:00:00.000000000 Z
+date: 2025-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake