lmdb 0.4.7 → 0.6

data/ext/lmdb_ext/lmdb_ext.h

@@ -47,18 +47,35 @@
         Data_Get_Struct(var, Cursor, var_cur);  \
         cursor_check(var_cur)
 
+/*
+  hey yo if you can convince hyc to add a function like
+  mdb_txn_get_flags or even mdb_txn_is_rdonly, you could probably get
+  rid of these wrapper structs and a lot of complexity, cause that is
+  literally the only reason why they're needed
+
+  actually no we would also need to know when a txn has a child and
+  there is also no mdb_txn_get_child or whatever
+*/
+
 typedef struct {
         VALUE    env;
-        VALUE    parent;
+        VALUE    parent; // ignored for ro threads
+        VALUE    child;  // ditto
         VALUE    thread;
         VALUE    cursors;
         MDB_txn* txn;
+        unsigned int flags;
 } Transaction;
 
+// we have an extra field `rw_txn_thread` here that acts as the
+// registry for the single read-write transaction. if it's populated,
+// that's the one
+
 typedef struct {
         MDB_env* env;
-        VALUE    thread_txn_hash;
-        VALUE    txn_thread_hash;
+        VALUE    thread_txn_hash; /* transaction -> thread  */
+        VALUE    txn_thread_hash; /* thread      -> transaction */
+        VALUE    rw_txn_thread;   /* the thread with the rw transaction */
 } Environment;
 
 typedef struct {
@@ -116,10 +133,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 +146,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,124 @@ 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 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.7'
+  VERSION = '0.6'.freeze
 end

data/lmdb.gemspec

@@ -19,8 +19,9 @@ 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"
+  s.add_development_dependency 'ruby_memcheck', "~> 1.0"
 end

data/spec/helper.rb

@@ -2,6 +2,9 @@ require 'lmdb'
 require 'rspec'
 require 'fileutils'
 
+# for valgrind
+at_exit { GC.start }
+
 SPEC_ROOT = File.dirname(__FILE__)
 TEMP_ROOT = File.join(SPEC_ROOT, 'tmp')
 

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
@@ -100,7 +101,7 @@ describe LMDB do
     end
 
     describe LMDB::Transaction do
-      subject { env}
+      subject { env }
 
       it 'should create transactions' do
         subject.active_txn.should == nil
@@ -170,7 +171,7 @@ describe LMDB do
         subject.active_txn.should == nil
       end
 
-      it 'should access from transaction to environment' do
+      it 'should get environment' do
         env2 = nil
         env.transaction do |txn|
           env2 = txn.env
@@ -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,26 @@ 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
+      proc { subject.delete('cat') }.should raise_error(LMDB::Error::NOTFOUND)
+      proc { subject.delete('cat', 'garfield') }.should raise_error(LMDB::Error::NOTFOUND)
+
+      subject.put('cat', 'garfield')
+      subject.delete('cat').should be_nil
+      proc { subject.delete('cat') }.should raise_error(LMDB::Error::NOTFOUND)
+
+      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
@@ -258,12 +287,18 @@ describe LMDB do
       db['key'].should == bin2
     end
 
-    it 'should access environment' 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
@@ -318,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
@@ -328,10 +406,17 @@ describe LMDB do
       proc { c.next }.should raise_error(LMDB::Error)
     end
 
-    it 'should access database' do
+    it 'should get database' do
       db2 = nil
       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.7
+  version: '0.6'
 platform: ruby
 authors:
 - Daniel Mendler
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-09-28 00:00:00.000000000 Z
+date: 2022-05-27 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
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: ruby_memcheck
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: lmdb is a Ruby binding to OpenLDAP Lightning MDB.
 email: mail@daniel-mendler.de
 executables: []
@@ -66,6 +80,7 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- behaviour.org
 - ext/lmdb_ext/cursor_delete_flags.h
 - ext/lmdb_ext/cursor_put_flags.h
 - ext/lmdb_ext/dbi_flags.h
@@ -95,7 +110,7 @@ homepage: https://github.com/minad/lmdb
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -103,16 +118,15 @@ 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.1
-signing_key: 
+rubygems_version: 3.3.11
+signing_key:
 specification_version: 4
 summary: Ruby bindings to Lightning MDB
 test_files: