rdf-lmdb 0.3.6 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bd37a5a5b62c89a2096f857dea6461798dc5bfc48d155b902979d97cf949214
-  data.tar.gz: f332981a1cfb15aa127d3a73b1356a5664221f057944ec21febf1c8c863de261
+  metadata.gz: '02085577cc4df2383a38f97e53f9f29cc75e94f5e2d8655be73d457737eabfa7'
+  data.tar.gz: a6eb270cb9297f16cb7e079f6f46710ef1b54ced75ae83db7cbe6cbaaba4ce84
 SHA512:
-  metadata.gz: cbda446d51f8d780de5bee1aa772a05ded8263eb820aa758c320f96cdd892b8fedb3925e409225d315bf17570604c4a63097e62bb8d9e776025042eb98b54776
-  data.tar.gz: 50f8483a107b10593bcc527ec7f25ef5e3505ebe1d21b6ee2cde2286142bf308036130365e2e810e0a498a6e283f6cb2c17d3c2b1c4fc3f302de86fb2daa4966
+  metadata.gz: 4c4daa84e4a59411d8ec197527a4571f48e56b5d54b911e572d5aae09c17d391be318f6cb519233bab468b641dcb9d2e2f07e6a767678235eab1afcbaa06db31
+  data.tar.gz: 5a132e61243460abf1819c5bd445a3a87b783aefe445b46b37af4abe0cd5327c03ba59095427459c02646eb802c2a139b38041e94dd8a07daa8da30502949e46

data/TODO.org

@@ -31,6 +31,7 @@
     - "consensus graphs" which extend the idea of union graphs to a shared reality for multiple users
     - "proxy graphs" that map to other systems (e.g. SQL)
       - or even other RDF stores
+      - (include caching)
     - statement-generating layers that do things we actually /do/ want statements in the graph for, but /generated/ rather than stored (or perhaps merely /cached/, and thus not subject to versioning)
       - e.g. "soft" inferences, stuff written in vocab specs that had no way to formally express at the time
         - I'm thinking specifically how ~?c a skos:OrderedCollection; skos:memberList (?m1 ?m2 ?mn)~ implies ~?c skos:member ?m1~ and so on.
@@ -38,7 +39,7 @@
       - e.g. stateful or aggregate statements computed from other statements
         - again this is totally doable with SHACL.
 * TODO RDF-star
-- at root there are terms
+- the basic element is the term
   - terms can be normalized and hashed
   - each term is assigned a numeric identifier that is local to the database and not otherwise exposed
     - assume this is a native-endian ~size_t~ integer; we are not gonna screw around with portability across cpu architectures
@@ -54,7 +55,7 @@
     - so subjects and objects can now be /statements/ in addition to URIs and bnodes (and literals for objects)
   - so it shouldn't be the end of the world to make that a thing
   - albeit backward-compatibility to existing stores might be a problem
-    - well if anybody wants to hire me te do that for them, they can
+    - well if anybody wants to hire me to do that for them, they can
 * TODO change history
 - anyway, that aside, what we're actually after is being able to access the state of the database at the instant of a particular transaction
   - random access is ideal
@@ -97,7 +98,8 @@
       - why not just stick a bit on the end of that as to whether it's added or removed
       - so we have ~added~ and ~removed~ tables of the form ~change id => statement id~
       - we also have i dunno, ~state~ or something of the form ~statement id => change id, bit for added/removed~
-** TODO global mtime
+** TODO global modification time
+- [X] temporary global mtime in stats databsae
 - which resources have been affected since this time/transaction id
 * TODO principals (multi-user)
 - each individual user gets their own quad store from their point of view
@@ -108,7 +110,7 @@
   - you can't add or delete statements in other people's slices and they can't change yours
   - though they should be able to transfer ownership of a set of statements to you somehow
     - (but the person receiving should be able to decline the transfer)
-** TODO lensing
+** TODO lenses/perspectives
 - my concern here is a way to have a single repository that can support multiple users without "leaking" content from other users
   - like we /could/ just partition these on the disk but there are reasons not to do this:
     1. it's gonna be a pain in the ass for downstream applications in the best case

data/lib/rdf/lmdb/version.rb

@@ -1,5 +1,5 @@
 module RDF
   module LMDB
-    VERSION = "0.3.6"
+    VERSION = "0.4.0".freeze
   end
 end

data/lib/rdf/lmdb.rb

@@ -88,15 +88,17 @@ module RDF
           'Cannot execute a rolled back transaction. Open a new one instead.' if
           @rolledback
 
-        ret = if @txn
-                @changes.apply(@repository)
-              else
-                wrap_txn { @changes.apply(@repository) }
-              end
+        if @mutable && !@changes.empty?
+          ret = if @txn
+                  @changes.apply(@repository)
+                else
+                  wrap_txn { @changes.apply(@repository) }
+                end
 
-        @changes = RDF::Changeset.new
+          @changes = RDF::Changeset.new
 
-        ret
+          ret
+        end
       end
 
       def rollback
@@ -116,6 +118,9 @@ module RDF
     class Repository < ::RDF::Repository
       private
 
+      LMDB_OPTS =
+        %i[fixedmap nosubdir nosync rdonly nometasync writemap mapasync notls]
+
       # for the mapsize parameter
       UNITS = { nil => 1 }
       'kmgtpe'.split('').each_with_index do |x, i|
@@ -144,17 +149,19 @@ module RDF
         factor.to_i * UNITS[unit]
       end
 
-      def init_lmdb dir, **options
-        dir = Pathname(dir).expand_path
-        dir.mkdir unless dir.exist?
+      def init_lmdb dir = nil, **options
+        dir ||= options[:dir]
+        raise ArgumentError, 'must pass in either dir or dir: keyword' unless dir
+
+        @dir = Pathname(dir).expand_path
+        @dir.mkdir unless @dir.exist?
 
         options[:mapsize] = int_bytes options[:mapsize] if options[:mapsize]
 
-        # fire up the environment
-        @lmdb = ::LMDB.new dir, **options
+        @lmdb_opts = options.slice(*LMDB_OPTS)
 
         # XXX trip over the old database layout for now
-        dbs = @lmdb.database.keys.map(&:to_sym)
+        dbs = env.database.keys.map(&:to_sym)
         unless dbs.empty? or dbs.include? :int2term
           err = <<-ERR.tr_s("\n ", ' ')
 This version uses an updated (and incompatible) database layout.
@@ -163,9 +170,8 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
           raise ArgumentError, err
         end
 
-        # databases are opened in a transaction, who knew
-        @lmdb.transaction do # |t|
-          @dbs = {
+        env.transaction? do
+          dbs = {
             # this is the control database, it gets no flags
             control:   [],
             # actual instance data
@@ -187,7 +193,7 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
             # gp2stmt:   [:dupsort, :dupfixed],
             # go2stmt:   [:dupsort, :dupfixed],
           }.map do |name, flags|
-            [name, @lmdb.database(name.to_s,
+            [name, env.database(name.to_s,
               **(flags + [:create]).map { |f| [f, true] }.to_h)]
           end.to_h
 
@@ -196,7 +202,7 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
 
           # t.commit
         end
-        @lmdb.sync
+        env.sync
       end
 
       SPO = %i[subject predicate object].freeze
@@ -216,35 +222,42 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
       }.freeze
 
       def last_key db
-        db = @dbs[db] if db.is_a? Symbol
-        return nil if db.size == 0
-        # the last entry in the database should be the highest number
-        db.cursor { |c| c.last }.first.unpack1 ?J
+        env.transaction? do
+          db = env[db] if db.is_a? Symbol
+          if db.size != 0
+            # the last entry in the database should be the highest number
+            db.cursor { |c| c.last }.first.unpack1 ?J
+          else
+            nil
+          end
+        end
       end
 
       def int_for term
-        case term
-        when nil, RDF::Query::Variable then 0
-        when RDF::Statement
-          terms = term.to_a.map { |t| int_for t }
-          return if terms.include? nil # the statement implicitly not here
-
-          if raw = @dbs[:ints2stmt].get(terms.pack 'J3')
-            raw.unpack1 ?J
-          end
-        when Hash # of integers
-          if raw = @dbs[:ints2stmt].get(term.values_at(*SPO).pack 'J3')
-            raw.unpack1 ?J
-          end
-        when RDF::Term
-          thash = hash_term term
-          if raw = @dbs[:hash2term].get(thash)
-            raw.unpack1 ?J
-          end
-        when String
-          # assume this is the hash string
-          if raw = @dbs[:hash2term].get(term)
-            raw.unpack1 ?J
+        env.transaction? true do
+          case term
+          when nil, RDF::Query::Variable then 0
+          when RDF::Statement
+            terms = term.to_a.map { |t| int_for t }
+            unless terms.include? nil # the statement implicitly not here
+              if raw = env[:ints2stmt].get(terms.pack 'J3')
+                raw.unpack1 ?J
+              end
+            end
+          when Hash # of integers
+            if raw = env[:ints2stmt].get(term.values_at(*SPO).pack 'J3')
+              raw.unpack1 ?J
+            end
+          when RDF::Term
+            thash = hash_term term
+            if raw = env[:hash2term].get(thash)
+              raw.unpack1 ?J
+            end
+          when String
+            # assume this is the hash string
+            if raw = env[:hash2term].get(term)
+              raw.unpack1 ?J
+            end
           end
         end
       end
@@ -252,38 +265,44 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
       def store_term term
         return 0 if term.nil?
         raise ArgumentError, 'must be a term' unless term.is_a? RDF::Term
-        # get the hash first
-        thash = hash_term term
-        if ix = int_for(thash)
-          return ix
-        end
+        env.transaction? do
+          # get the hash first
+          thash = hash_term term
 
-        # this should start with 1, not zero
-        ix = (last_key(@dbs[:int2term]) || 0) + 1
-        ib = [ix].pack ?J
-        @dbs[:int2term].put ib, term.to_ntriples.to_nfc
+          if ix = int_for(thash)
+            ix
+          else
+            # this should start with 1, not zero
+            ix = (last_key(env[:int2term]) || 0) + 1
+            ib = [ix].pack ?J
+            env[:int2term].put ib, term.to_ntriples.to_nfc
 
-        # we need the hash too to resolve the term the other way
-        @dbs[:hash2term].put thash, ib
+            # we need the hash too to resolve the term the other way
+            env[:hash2term].put thash, ib
 
-        ix # return the current index
+            ix # return the current index
+          end
+        end
       end
 
       def store_stmt statement, ints = nil
-        ints ||= statement.to_h.transform_values { |v| store_term v }
-        ik = ints.values_at(*SPO).pack 'J3'
-        if ib = @dbs[:ints2stmt].get(ik)
-          return ib.unpack1 ?J
-        end
+        env.transaction? do
+          ints ||= statement.to_h.transform_values { |v| store_term v }
+          ik = ints.values_at(*SPO).pack 'J3'
 
-        # this should start with 1, not zero
-        ix = (last_key(:statement) || 0) + 1
-        ib = [ix].pack ?J
+          if ib = env[:ints2stmt].get(ik)
+            ib.unpack1 ?J
+          else
+            # this should start with 1, not zero
+            ix = (last_key(:statement) || 0) + 1
+            ib = [ix].pack ?J
 
-        @dbs[:statement].put ib, ik # number to triple-number
-        @dbs[:ints2stmt].put ik, ib # triple-number to number
+            env[:statement].put ib, ik # number to triple-number
+            env[:ints2stmt].put ik, ib # triple-number to number
 
-        ix # the index integer
+            ix # the index integer
+          end
+        end
       end
 
       # everything gets normalized to NFC on the way in (i
@@ -300,95 +319,104 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
       def add_one statement
         # get the integer keys for the terms and statement
         terms = statement.to_h
-        ints  = terms.transform_values { |v| store_term v }
-        ipack = ints.transform_values  { |v| [v].pack ?J  }
-        sint  = store_stmt statement, ints
-        spack = [sint].pack ?J
 
-        # now we map the SPO indices
-        SPO_MAP.each do |k, d|
-          db = @dbs[d]
-          ik = ipack[k]
-          # note we test before inserting or lmdb will dutifully
-          # create unlimited duplicate values and results will be wrong
-          db.put ik, spack unless db.has? ik, spack
-        end
+        env.transaction? do
+          ints  = terms.transform_values { |v| store_term v }
+          ipack = ints.transform_values  { |v| [v].pack ?J  }
+          sint  = store_stmt statement, ints
+          spack = [sint].pack ?J
+
+          # now we map the SPO indices
+          SPO_MAP.each do |k, d|
+            db = env[d]
+            ik = ipack[k]
+            # note we test before inserting or lmdb will dutifully
+            # create unlimited duplicate values and results will be wrong
+            db.put ik, spack unless db.has? ik, spack
+          end
 
-        # now we do the pair indices
-        PAIR_MAP.each do |pair, d|
-          db = @dbs[d]
-          ik = ipack.values_at(*pair).join
-          db.put ik, spack unless db.has? ik, spack
-        end
+          # now we do the pair indices
+          PAIR_MAP.each do |pair, d|
+            db = env[d]
+            ik = ipack.values_at(*pair).join
+            db.put ik, spack unless db.has? ik, spack
+          end
+
+          # associate the statement with its graph; note zero is the null graph
+          gint  = ints[:graph_name] || 0
+          gpack = [gint].pack ?J
 
-        # associate the statement with its graph; note zero is the null graph
-        gint  = ints[:graph_name] || 0
-        gpack = [gint].pack ?J
-        @dbs[:g2stmt].put gpack, spack unless @dbs[:g2stmt].has? gpack, spack
-        @dbs[:stmt2g].put spack, gpack unless @dbs[:stmt2g].has? spack, gpack
+          env[:g2stmt].put gpack, spack unless env[:g2stmt].has? gpack, spack
+          env[:stmt2g].put spack, gpack unless env[:stmt2g].has? spack, gpack
+        end
       end
 
       def rm_one statement, scan: true
         terms = statement.to_h
-        ints  = terms.transform_values { |v| int_for v }
-        # if none of the terms resolve, we don't have it
-        return [] if ints.values_at(*SPO).include? nil
-        # same goes for the statement
-        sint   = int_for(ints) or return []
-        spack  = [sint].pack ?J
-
-
-        gint   = ints[:graph_name] or return []
-        gpack  = [gint].pack ?J
-        graphs = @dbs[:stmt2g].each_value(spack).to_a.uniq
-
-        out  = []
-        unless graphs.empty?
-          # this will dissociate the statement from the graph
-          @dbs[:g2stmt].delete? gpack, spack
-          @dbs[:stmt2g].delete? spack, gpack
-
-          if graphs.size == 1 and graphs.first == gpack
-            # nuke the statement if this is the only instance of it
-            @dbs[:statement].delete? spack
-            @dbs[:ints2stmt].delete? ints.values_at(*SPO).pack('J3')
-
-            # now we nuke the indexes
-
-            # first the original spo
-            SPO_MAP.map do |k, d|
-              ib = [ints[k]].pack ?J
-              @dbs[d].delete? ib, spack
-              out << ints[k]
-            end
 
-            # add the graph if it is not null
-            out << terms[:graph_name] if terms[:graph_name] and gint != 0
+        op = -> _ = nil do
+          ints  = terms.transform_values { |v| int_for v }
+          # if none of the terms resolve, we don't have it
+          return [] if ints.values_at(*SPO).include? nil
+          # same goes for the statement
+          sint   = int_for(ints) or return []
+          spack  = [sint].pack ?J
+
+
+          gint   = ints[:graph_name] or return []
+          gpack  = [gint].pack ?J
+          graphs = env[:stmt2g].each_value(spack).to_a.uniq
+
+          out  = []
+          unless graphs.empty?
+            # this will dissociate the statement from the graph
+            env[:g2stmt].delete? gpack, spack
+            env[:stmt2g].delete? spack, gpack
+
+            if graphs.size == 1 and graphs.first == gpack
+              # nuke the statement if this is the only instance of it
+              env[:statement].delete? spack
+              env[:ints2stmt].delete? ints.values_at(*SPO).pack('J3')
+
+              # now we nuke the indexes
+
+              # first the original spo
+              SPO_MAP.map do |k, d|
+                ib = [ints[k]].pack ?J
+                env[d].delete? ib, spack
+                out << ints[k]
+              end
+
+              # add the graph if it is not null
+              out << terms[:graph_name] if terms[:graph_name] and gint != 0
 
-            # and now the pair map
-            ipack = ints.slice(*SPO).transform_values { |v| [v].pack ?J }
-            PAIR_MAP.map do |pair, d|
-              ib = ipack.values_at(*pair).join
-              @dbs[d].delete? ib, spack
+              # and now the pair map
+              ipack = ints.slice(*SPO).transform_values { |v| [v].pack ?J }
+              PAIR_MAP.map do |pair, d|
+                ib = ipack.values_at(*pair).join
+                env[d].delete? ib, spack
+              end
             end
           end
-        end
 
-        # nuke any unused terms
-        clean_terms out if scan
+          # nuke any unused terms
+          clean_terms out if scan
 
-        out
+          out
+        end
+
+        env.transaction? &op
       end
 
       def clean_terms terms
         terms.map! { |t| t.is_a?(RDF::Term) ? hash_term(t) : t.to_s }.uniq
-        @lmdb.transaction do
+        env.transaction? do
           terms.each do |hash|
             next if hash == NULL_SHA256
-            next unless ib = @dbs[:hash2term].get(hash)
-            unless SPOG_MAP.values.any? {|d| @dbs[d].get ib }
-              @dbs[:int2term].delete? ib
-              @dbs[:hash2term].delete? hash
+            next unless ib = env[:hash2term].get(hash)
+            unless SPOG_MAP.values.any? {|d| env[d].get ib }
+              env[:int2term].delete? ib
+              env[:hash2term].delete? hash
             end
           end
         end
@@ -399,32 +427,36 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
           statement.incomplete?
       end
 
-      def resolve_term candidate, cache: {}, write: false
+      def resolve_term candidate, cache: nil, write: true
+        cache ||= @icache
         int  = nil
-        term = case candidate
-               when nil then return
-               when Integer
-                 int = candidate
-                 return if int == 0
-                 return cache[int] if cache[int]
-                 str = [int].pack ?J
-                 @dbs[:int2term][str] or return
-               when String
-                 int = candidate.unpack1 ?J
-                 str = [int].pack ?J
-                 if candidate == str
-                   return if int == 0
-                   return cache[int] if cache[int]
-                   @dbs[:int2term][str] or return
-                 else
-                   return if candidate == NULL_SHA256
-                   str = @dbs[:hash2term][candidate] or return
-                   @dbs[:int2term][str] or return
-                   int = str.unpack1 ?J
-                 end
-               else
-                 raise ArgumentError, 'not an integer or a string'
-               end
+
+        term = env.transaction? do
+          case candidate
+          when nil then return
+          when Integer
+            int = candidate
+            return if int == 0
+            return cache[int] if cache[int]
+            str = [int].pack ?J
+            env[:int2term][str] or return
+          when String
+            int = candidate.unpack1 ?J
+            str = [int].pack ?J
+            if candidate == str
+              return if int == 0
+              return cache[int] if cache[int]
+              env[:int2term][str] or return
+            else
+              return if candidate == NULL_SHA256
+              str = env[:hash2term][candidate] or return
+              [:int2term][str] or return
+              int = str.unpack1 ?J
+            end
+          else
+            raise ArgumentError, 'not an integer or a string'
+          end
+        end
 
         term.force_encoding 'utf-8'
 
@@ -433,22 +465,17 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
         term
       end
 
-      def split_fixed string, length
-        string = string.dup
+      def resolve_terms string, cache: nil, write: true, hash: false
+        cache ||= @icache
+        # we create a sequence because they may be duplicate
         seq = []
-        until string.empty?
-          seq << string.slice!(0, length)
-        end
-        seq
-      end
 
-      def resolve_terms string, cache: {}, write: false, hash: false
-        seq = []
-        out = string.unpack('J*').map do |i|
-          seq << i
-          j = resolve_term(i, cache: cache, write: write)
-          [i, j]
-        end.to_h
+        out = env.transaction? do
+          string.unpack('J*').each_with_object({}) do |i, h|
+            seq << i
+            h[i] ||= resolve_term(i, cache: cache, write: write)
+          end
+        end
 
         # if we aren't returning a hash, make sure the result is
         # returned in order
@@ -456,12 +483,12 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
       end
 
       def each_maybe_with_graph has_graph = false, &block
-        body = -> do
-          cache = {}
-          @dbs[:statement].each do |spack, spo|
+        op = -> _ = nil do
+          cache = @icache
+          env[:statement].each do |spack, spo|
             spo = resolve_terms spo, cache: cache, write: true
 
-            @dbs[:stmt2g].each_value spack do |gpack|
+            env[:stmt2g].each_value spack do |gpack|
               gint = gpack.unpack1 ?J
               # setting the default graph to zero seems like something
               # i would do
@@ -472,11 +499,7 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
           end
         end
 
-        @lmdb.transaction do
-          body.call
-        end
-
-        #@lmdb.active_txn ? body.call : @lmdb.transaction(true, &body)
+        env.transaction? true, &op
       end
 
       def check_triple_quad arg, name: :triple, quad: false
@@ -531,7 +554,7 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
         ihash = thash.transform_values { |v| int_for v }
         cache = thash.keys.map { |k| [ihash[k], thash[k]] }.to_h
 
-        body = -> _ = nil do
+        op = -> _ = nil do
           # if the graph is nonexistent there is nothing to show
           return if thash[:graph_name] and !ihash[:graph_name]
 
@@ -542,17 +565,17 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
             stmt  = RDF::Statement.new(**thash)
             sint  = int_for(stmt) or return
             spack = [sint].pack ?J
-            first = @dbs[:statement].get(spack) or return
+            first = env[:statement].get(spack) or return
 
             # warn thash.inspect, ihash.inspect
 
             # note
             if gint = ihash[:graph_name]
               gpack = [gint].pack ?J
-              return unless @dbs[:stmt2g].has? spack, gpack
+              return unless env[:stmt2g].has? spack, gpack
               yield stmt
             else
-              @dbs[:stmt2g].each_value spack do |gpack|
+              env[:stmt2g].each_value spack do |gpack|
                 # return if gpack.unpack1(?J) == 0
                 graph = resolve_term gpack, cache: cache, write: true
                 yield RDF::Statement.from(stmt, graph_name: graph)
@@ -562,18 +585,18 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
             # if only a single component (e.g. :subject) is present then
             # we only need to check (e.g.) :s2stmt.
             pos = thash.keys.first
-            db  = @dbs[SPOG_MAP[pos]]
+            db  = env[SPOG_MAP[pos]]
             ix  = ihash[pos] or return # note ihash[pos] may be nil
             anchor = [ix].pack ?J
             return unless db.has? anchor
 
             db.each_value anchor do |spack|
-              spo = resolve_terms @dbs[:statement][spack],
+              spo = resolve_terms env[:statement][spack],
                 cache: cache, write: true
               if pos == :graph_name
                 yield RDF::Statement(*spo, graph_name: thash[:graph_name])
               else
-                @dbs[:stmt2g].each_value spack do |gpack|
+                env[:stmt2g].each_value spack do |gpack|
                   gint  = gpack.unpack1 ?J
                   graph = resolve_term gint, cache: cache, write: true
                   yield RDF::Statement(*spo, graph_name: graph)
@@ -582,7 +605,7 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
             end
           elsif thash.keys.count == 2 and thash[:graph_name]
             pos = (thash.keys - [:graph_name]).first
-            db  = @dbs[SPO_MAP[pos]]
+            db  = env[SPO_MAP[pos]]
             ix  = ihash[pos] or return
             anchor = [ix].pack ?J
             return unless db.has? anchor
@@ -590,10 +613,10 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
             # warn "ix: #{ix} #{ihash.inspect} orr bug here?"
 
             db.each_value anchor do |spack|
-              spo   = @dbs[:statement][spack]
+              spo   = env[:statement][spack]
               # warn "node: #{spack.unpack1 ?J} spo: #{spo.unpack 'J*'}"
               gpack = [ihash[:graph_name]].pack ?J
-              next unless @dbs[:stmt2g].has? spack, gpack
+              next unless env[:stmt2g].has? spack, gpack
               spo = resolve_terms spo
               yield RDF::Statement(*spo, graph_name: thash[:graph_name])
             end
@@ -608,7 +631,7 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
               (pr - thash.keys).empty? and ihash.values_at(*pr).none?(&:nil?)
             end.map do |pr, _|
               v = ihash.values_at(*pr).pack 'J2'
-              c = @dbs[PAIR_MAP[pr]].cardinality(v)
+              c = env[PAIR_MAP[pr]].cardinality(v)
               [c, pr]
             end.sort do |a, b|
               a.first <=> b.first
@@ -619,17 +642,17 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
               cache: cache, write: true) if ihash[:graph_name]
 
             ib = ihash.values_at(*pair).pack 'J2'
-            @dbs[PAIR_MAP[pair]].each_value ib do |spack|
-              spo = resolve_terms @dbs[:statement][spack],
+            env[PAIR_MAP[pair]].each_value ib do |spack|
+              spo = resolve_terms env[:statement][spack],
                 cache: cache, write: true
 
               if ihash[:graph_name]
                 # warn g, ihash.inspect
                 gpack = [ihash[:graph_name]].pack ?J
-                next unless @dbs[:stmt2g].has? spack, gpack
+                next unless env[:stmt2g].has? spack, gpack
                 yield RDF::Statement(*spo, graph_name: g)
               else
-                @dbs[:stmt2g].each_value spack do |gpack|
+                env[:stmt2g].each_value spack do |gpack|
                   gint = gpack.unpack1 ?J
                   g = resolve_term gint, cache: cache, write: true
                   yield RDF::Statement(*spo, graph_name: g)
@@ -639,21 +662,14 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
           end
         end
 
-        @lmdb.active_txn ? body.call : @lmdb.transaction(true, &body)
-
-        # ret = nil
-        # @lmdb.transaction do
-        #   ret = body.call
-        # end
-
-        # ret
+        env.transaction? true, &op
       end
 
       def log_mtime time = nil
         time ||= Time.now in: ?Z
         nsecs = time.utc.to_r
         nsecs = (nsecs * 10**9).numerator
-        @lmdb.transaction { @dbs[:control]['mtime'] = [nsecs].pack ?q }
+        env.transaction? { env[:control]['mtime'] = [nsecs].pack ?q }
         time
       end
 
@@ -667,6 +683,8 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
         raise ArgumentError, "Invalid transaction class #{@tx_class}" unless
           @tx_class.is_a? Class and @tx_class <= DEFAULT_TX_CLASS
 
+        @icache = {}
+
         init_lmdb dir, **options
         super uri: uri, title: title, **options, &block
       end
@@ -681,14 +699,13 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
         :serializable
       end
 
-      def path
-        Pathname(@lmdb.path)
-      end
+      attr_reader :dir
+
+      alias_method :path, :dir
 
       def clear
-        @lmdb.transaction do
-          @dbs.each_value { |db| db.clear }
-        end
+        env.transaction? { env.databases.each { |db| env[db].clear } }
+
         # we do not clear the main database; that nukes the sub-databases
         # @lmdb.database.clear
       end
@@ -698,7 +715,7 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
       end
 
       def close
-        @lmdb.close
+        env.close
       end
 
       # Return a {::Time} object representing when the store was last written.
@@ -706,7 +723,7 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
       # @return [Time] said modification time
       #
       def mtime
-        if packed = @dbs[:control]['mtime']
+        if packed = env[:control]['mtime']
           nsecs = Rational(packed.unpack1(?q), 10 ** 9)
           Time.at nsecs, in: ?Z
         else
@@ -718,10 +735,9 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
 
       def insert_statement statement
         complete! statement
-        @lmdb.transaction do |t|
+        env.transaction? do |t|
           add_one statement
           log_mtime
-          t.commit # cargo cult?
         end
         nil
       end
@@ -731,7 +747,7 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
         # because we want the transaction on the outside.
         complete! statement
         # warn "WTF LOL #{statement.inspect}"
-        @lmdb.transaction do |t|
+        env.transaction? do |t|
           if statement.variable?
             query(statement).each { |stmt| rm_one stmt }
           else
@@ -739,14 +755,12 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
           end
 
           log_mtime
-
-          t.commit
         end
         nil
       end
 
       def insert_statements statements
-        @lmdb.transaction do
+        env.transaction? do
           statements.each do |statement|
             complete! statement
             add_one statement
@@ -758,7 +772,7 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
       end
 
       def delete_statements statements
-        @lmdb.transaction do |t|
+        env.transaction? do
           hashes = []
 
           # we don't know what's in here but it may contain statements
@@ -781,8 +795,6 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
           clean_terms hashes.uniq
 
           log_mtime
-
-          t.commit
         end
 
         nil
@@ -791,82 +803,92 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
       # data retrieval
 
       def each &block
-        return enum_for :each unless block_given?
+        return enum_for :each unless block
 
         each_maybe_with_graph(&block)
       end
 
       def each_subject &block
-        return enum_for :each_subject unless block_given?
-        @dbs[:s2stmt].cursor do |c|
-          while (k, _ = c.next true)
-            yield resolve_term k
+        return enum_for :each_subject unless block
+        env.transaction? true do
+          env[:s2stmt].cursor do |c|
+            while (k, _ = c.next true)
+              block.call(resolve_term k)
+            end
           end
         end
       end
 
       def each_predicate &block
-        return enum_for :each_predicate unless block_given?
-        @dbs[:p2stmt].cursor do |c|
-          while (k, _ = c.next true)
-            yield resolve_term k
+        return enum_for :each_predicate unless block
+        env.transaction? true do
+          env[:p2stmt].cursor do |c|
+            while (k, _ = c.next true)
+              block.call(resolve_term k)
+            end
           end
         end
       end
 
       def each_object &block
-        return enum_for :each_object unless block_given?
-        @dbs[:o2stmt].cursor do |c|
-          while (k, _ = c.next true)
-            yield resolve_term k
+        return enum_for :each_object unless block
+
+        env.transaction? true do
+          env[:o2stmt].cursor do |c|
+            while (k, _ = c.next true)
+              block.call(resolve_term k)
+            end
           end
         end
       end
 
       def each_graph &block
-        return enum_for :each_graph unless block_given?
-        @dbs[:g2stmt].cursor do |c|
-          while (k, _ = c.next true)
-            yield RDF::Graph.new(graph_name: resolve_term(k), data: self)
+        return enum_for :each_graph unless block
+
+        env.transaction? true do
+          env[:g2stmt].cursor do |c|
+            while (k, _ = c.next true)
+              block.call RDF::Graph.new(graph_name: resolve_term(k), data: self)
+            end
           end
         end
       end
 
       def each_term &block
-        return enum_for :each_term unless block_given?
-        @dbs[:int2term].cursor do |c|
-          while (_, v = c.next)
-            # yield RDF::NTriples::Reader.unserialize v
-            v.force_encoding 'utf-8'
-            yield RDF::NTriples::Reader.parse_object(v, intern: true)
+        return enum_for :each_term unless block
+
+        env.transaction? true do
+          env[:int2term].cursor do |c|
+            while (_, v = c.next)
+              # yield RDF::NTriples::Reader.unserialize v
+              v.force_encoding 'utf-8'
+              block.call RDF::NTriples::Reader.parse_object(v, intern: true)
+            end
           end
         end
       end
 
       def project_graph graph_name, &block
-        return enum_for :project_graph, graph_name unless block_given?
-        body = -> do
+        return enum_for :project_graph, graph_name unless block
+
+        op = -> _ = nil do
           gint  = graph_name ? int_for(graph_name) : 0
           return unless gint
           gpack = [gint].pack ?J
           cache = {}
-          @dbs[:statement].each do |spack, spo|
-            next unless @dbs[:stmt2g].has? spack, gpack
+          env[:statement].each do |spack, spo|
+            next unless env[:stmt2g].has? spack, gpack
             spo = resolve_terms spo, cache: cache, write: true
 
             block.call RDF::Statement(*spo, graph_name: graph_name)
           end
         end
 
-        @lmdb.transaction do
-          body.call
-        end
-
-        #@lmdb.active_txn ? body.call : @lmdb.transaction(true, &body)
+        env.transaction? true, &op
       end
 
       def count
-        @dbs[:stmt2g].size
+        env[:stmt2g].size
       end
 
       def empty?
@@ -881,17 +903,17 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
 
       def delete_insert deletes, inserts
         ret = nil
-        @lmdb.transaction { ret = super(deletes, inserts) }
+        ret = env.transaction? { super(deletes, inserts) }
         commit_transaction # this is to satiate the test suite
         ret
       end
 
       def env
-        @lmdb
+        (@lmdb ||= {})[Process.pid] ||= ::LMDB.new dir, @lmdb_opts
       end
 
       def transaction mutable: false, &block
-        return begin_transaction mutable: mutable unless block_given?
+        return begin_transaction mutable: mutable unless block
 
         begin
           begin_transaction mutable: mutable, &block
@@ -912,39 +934,61 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
       def has_graph? graph_name
         raise ArgumentError, 'graph_name must be an RDF::Term' unless
           graph_name.is_a? RDF::Term
-        int  = int_for(graph_name) or return
-        pack = [int].pack ?J
-        @dbs[:g2stmt].has? pack
+
+        env.transaction? true do
+          if int = int_for(graph_name)
+            pack = [int].pack ?J
+            env[:g2stmt].has? pack
+          end
+        end
       end
 
       def has_subject? subject
         raise ArgumentError, 'subject must be an RDF::Term' unless
           subject.is_a? RDF::Term
-        int  = int_for(subject) or return
-        pack = [int].pack ?J
-        @dbs[:s2stmt].has? pack
+
+        env.transaction? true do
+          if int = int_for(subject)
+            pack = [int].pack ?J
+            # XXX fix this upstream
+            !!env[:s2stmt].has?(pack)
+          else
+            false
+          end
+        end
       end
 
       def has_predicate? predicate
         raise ArgumentError, 'predicate must be an RDF::Term' unless
           predicate.is_a? RDF::Term
-        int  = int_for(predicate) or return
-        pack = [int].pack ?J
-        @dbs[:p2stmt].has? pack
+
+        env.transaction? true do
+          if int = int_for(predicate)
+            pack = [int].pack ?J
+            env[:p2stmt].has? pack
+          end
+        end
       end
 
       def has_object? object
         raise ArgumentError, 'object must be an RDF::Term' unless
           object.is_a? RDF::Term
-        int  = int_for(object) or return
-        pack = [int].pack ?J
-        @dbs[:o2stmt].has? pack
+
+        env.transaction? true do
+          if int = int_for(object)
+            pack = [int].pack ?J
+            env[:o2stmt].has? pack
+          end
+        end
       end
 
       def has_term? term
         raise ArgumentError, 'term must be an RDF::Term' unless
           term.is_a? RDF::Term
-        @dbs[:hash2term].has? hash_term(term)
+
+        env.transaction? true do
+          env[:hash2term].has? hash_term(term)
+        end
       end
 
       def has_triple? triple
@@ -955,7 +999,6 @@ Currently you have to dump from the old layout and reload the new one. Sorry!
         has_statement? check_triple_quad quad, quad: true
       end
 
-
       # lol, ruby
     end
   end

data/rdf-lmdb.gemspec

@@ -25,7 +25,7 @@ robust key-value store.
   spec.require_paths = ["lib"]
 
   # ruby
-  spec.required_ruby_version = '>= 2.0'
+  spec.required_ruby_version = '>= 3.2'
 
   # dev/test dependencies
   spec.add_development_dependency 'bundler',  '~> 2'
@@ -36,5 +36,5 @@ robust key-value store.
   # stuff we use
   spec.add_runtime_dependency 'unf',  '~> 0.1'
   spec.add_runtime_dependency 'rdf',  '~> 3'
-  spec.add_runtime_dependency 'lmdb', '~> 0.6', '>= 0.6.2'
+  spec.add_runtime_dependency 'lmdb', '~> 0', '>= 0.8.1'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rdf-lmdb
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.4.0
 platform: ruby
 authors:
 - Dorian Taylor
 bindir: exe
 cert_chain: []
-date: 2025-06-16 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,20 +99,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.2
+        version: 0.8.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.2
+        version: 0.8.1
 description: |
   This module implements RDF::Repository on top of LMDB, a fast and
   robust key-value store.
@@ -147,14 +147,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Symas LMDB back-end for RDF::Repository
 test_files: []