factbase 0.19.6 → 0.19.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99e8fdb60e5fb1e8083b76db845cfad8a7b6be35700c543819ce631f8ac3ca19
-  data.tar.gz: 1fd106429c8a3aa39e56683060b5e61395e705abe336290da63fb1a35e748ec5
+  metadata.gz: 03d4be418b18984640fa333733a6b688aa2879b2e7def6d0ad901bce47490cd2
+  data.tar.gz: c6f24e2c444eb03eb739489d4cd09f927ece90a8c44f480c3b04fef1876b574d
 SHA512:
-  metadata.gz: e03d29fb285a301e48723690f3bdad751a0bc229bd559d901e22fdb196a4e263d5b75bbc6fef2da5480f07f1a4d22d510e630f7f7a7af8988d2b981d6a4b0b10
-  data.tar.gz: c41be62abd514f4ea0fde5e47fba206f27a8bd89a82a17e03c55a3908e5d9c98e909eca6bb571e183f8c2f11421617f0a20b31db132c1107a91eea0fb12cb0c1
+  metadata.gz: f73778d27a87c5a436769565032c5b064b24354ce62fad61822fd29941664e96c6d70f8481bf146bc72ef32669fc4969bae050eb70ef2f5c1fa0e19ee9395000
+  data.tar.gz: 299d0afc68fa48166fd4e01366e82ce1d22f8aa8c2f1dc2cfc9bd397763080f8db1762b20caa7738bafd0a5d606e9fa1725c13f400e13b40193ff13528b05b59

data/Gemfile.lock

@@ -25,6 +25,7 @@ GEM
     date (3.5.1)
     decoor (0.1.0)
     docile (1.4.1)
+    drb (2.2.3)
     elapsed (0.3.1)
       loog (~> 0.6)
       tago (~> 0.1)
@@ -34,10 +35,11 @@ GEM
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
     logger (1.7.0)
-    loog (0.7.2)
+    loog (0.8.0)
       ellipsized
       logger (~> 1.0)
-    minitest (6.0.1)
+    minitest (6.0.2)
+      drb (~> 2.0)
       prism (~> 1.5)
     minitest-reporters (1.7.1)
       ansi
@@ -55,14 +57,14 @@ GEM
     os (1.1.4)
     others (0.1.1)
     parallel (1.27.0)
-    parser (3.3.10.1)
+    parser (3.3.10.2)
       ast (~> 2.4.1)
       racc
     prism (1.9.0)
     psych (5.3.1)
       date
       stringio
-    qbash (0.7.2)
+    qbash (0.8.0)
       backtrace (> 0)
       elapsed (> 0)
       loog (> 0)
@@ -76,7 +78,7 @@ GEM
       tsort
     regexp_parser (2.11.3)
     rexml (3.4.4)
-    rubocop (1.84.1)
+    rubocop (1.84.2)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
@@ -90,7 +92,7 @@ GEM
     rubocop-ast (1.49.0)
       parser (>= 3.3.7.2)
       prism (~> 1.7)
-    rubocop-minitest (0.38.2)
+    rubocop-minitest (0.39.1)
       lint_roller (~> 1.1)
       rubocop (>= 1.75.0, < 2.0)
       rubocop-ast (>= 1.38.0, < 2.0)

data/README.md

@@ -227,52 +227,89 @@ This is the result of the benchmark:
 ```text
                                                                        
 query all facts from an empty factbase                             0.00
-insert 20000 facts                                                 0.67
+insert 20000 facts                                                 0.63
 export 20000 facts                                                 0.02
-import 410821 bytes (20000 facts)                                  0.01
-insert 10 facts                                                    0.04
-query 10 times w/txn                                               2.36
-query 10 times w/o txn                                             0.07
-modify 10 attrs w/txn                                              1.71
-delete 10 facts w/txn                                              3.38
-build index on 5000 facts                                          0.05
-export 5000 facts with index                                       0.05
+import 411003 bytes (20000 facts)                                  0.01
+insert 10 facts                                                    0.03
+query 10 times w/txn                                               2.03
+query 10 times w/o txn                                             0.13
+modify 10 attrs w/txn                                              1.51
+delete 10 facts w/txn                                              2.97
+build index on 5000 facts                                          0.03
+export 5000 facts with index                                       0.04
 import 5000 facts with persisted index                             0.03
-query 5000 facts using persisted index                             0.10
-export 5000 facts without index                                    0.00
+query 5000 facts using persisted index                             0.07
+export 5000 facts without index                                    0.01
 import 5000 facts without index                                    0.01
-query 5000 facts building index on-the-fly                         0.09
-(and (eq what 'issue-was-closed') (exists... -> 200                1.11
+query 5000 facts building index on-the-fly                         0.07
+query 15k facts  sel: 20%  card: 10  absent plain                  0.61
+query 15k facts  sel: 20%  card: 10  absent indexed(cold)          0.16
+query 15k facts  sel: 20%  card: 10  absent indexed(warm)          0.13
+query 15k facts  sel: 20%  card: 10  exists plain                  0.56
+query 15k facts  sel: 20%  card: 10  exists indexed(cold)          0.14
+query 15k facts  sel: 20%  card: 10  exists indexed(warm)          0.13
+query 15k facts  sel: 20%  card: 10  eq plain                      0.83
+query 15k facts  sel: 20%  card: 10  eq indexed(cold)              0.22
+query 15k facts  sel: 20%  card: 10  eq indexed(warm)              0.24
+query 15k facts  sel: 20%  card: 10  not plain                     1.11
+query 15k facts  sel: 20%  card: 10  not indexed(cold)             0.50
+query 15k facts  sel: 20%  card: 10  not indexed(warm)             0.43
+query 15k facts  sel: 20%  card: 10  gt plain                      0.84
+query 15k facts  sel: 20%  card: 10  gt indexed(cold)              0.26
+query 15k facts  sel: 20%  card: 10  gt indexed(warm)              0.19
+query 15k facts  sel: 20%  card: 10  lt plain                      0.84
+query 15k facts  sel: 20%  card: 10  lt indexed(cold)              0.27
+query 15k facts  sel: 20%  card: 10  lt indexed(warm)              0.20
+query 15k facts  sel: 20%  card: 10  and eq plain                  1.39
+query 15k facts  sel: 20%  card: 10  and eq indexed(cold)          0.85
+query 15k facts  sel: 20%  card: 10  and eq indexed(warm)          0.46
+query 15k facts  sel: 20%  card: 10  and complex plain             1.32
+query 15k facts  sel: 20%  card: 10  and complex indexed(cold)     0.48
+query 15k facts  sel: 20%  card: 10  and complex indexed(warm)     0.43
+query 15k facts  sel: 20%  card: 10  one plain                     0.72
+query 15k facts  sel: 20%  card: 10  one indexed(cold)             0.19
+query 15k facts  sel: 20%  card: 10  one indexed(warm)             0.15
+query 15k facts  sel: 20%  card: 10  or plain                      2.02
+query 15k facts  sel: 20%  card: 10  or indexed(cold)              0.42
+query 15k facts  sel: 20%  card: 10  or indexed(warm)              0.36
+query 15k facts  sel: 20%  card: 10  unique plain                  1.86
+query 15k facts  sel: 20%  card: 10  unique indexed(cold)          0.61
+query 15k facts  sel: 20%  card: 10  unique indexed(warm)          0.37
+(and (eq what 'issue-was-closed') (exists... -> 200                1.04
 (and (eq what 'issue-was-closed') (exists... -> 200/txn            1.23
-(and (eq what 'issue-was-closed') (exists... -> zero               1.18
-(and (eq what 'issue-was-closed') (exists... -> zero/txn           1.30
-transaction rollback on factbase with 100000 facts                 0.28
-(gt time '2024-03-23T03:21:43Z')                                   0.37
-(gt cost 50)                                                       0.18
+(and (eq what 'issue-was-closed') (exists... -> zero               1.06
+(and (eq what 'issue-was-closed') (exists... -> zero/txn           1.23
+transaction rollback on factbase with 100000 facts                 0.26
+(gt time '2024-03-23T03:21:43Z')                                   0.22
+(gt cost 50)                                                       0.10
 (eq title 'Object Thinking 5000')                                  0.03
-(and (eq foo 42.998) (or (gt bar 200) (absent z...                 0.03
-(and (exists foo) (not (exists blue)))                             1.73
-(eq id (agg (always) (max id)))                                    2.77
-(join "c<=cost,b<=bar" (eq id (agg (always) (ma...                 4.70
-(and (eq what "foo") (join "w<=what" (and (eq i...                 7.58
-delete!                                                            0.51
-(and (eq issue *) (eq repository *) (eq what '*') (eq where '*'))  0.43
+(and (eq foo 42.998) (or (gt bar 200) (absent z...                 0.02
+(and (exists foo) (not (exists blue)))                             1.12
+(eq id (agg (always) (max id)))                                    2.76
+(join "c<=cost,b<=bar" (eq id (agg (always) (ma...                 4.58
+(and (eq what "foo") (join "w<=what" (and (eq i...                 7.26
+delete!                                                            0.42
+(and (eq issue *) (eq repository *) (eq what '*') (eq where '*'))  0.38
 Taped.append() x50000                                              0.02
-Taped.each() x125                                                  1.15
-Taped.delete_if() x375                                             0.97
-50000 facts: read-only txn (no copy needed)                        5.30
-50000 facts: rollback txn (no copy needed)                         5.16
-50000 facts: insert in txn (copy triggered)                        3.23
-50000 facts: modify in txn (copy triggered)                       34.56
-100000 facts: read-only txn (no copy needed)                      12.28
-100000 facts: rollback txn (no copy needed)                       12.19
-100000 facts: insert in txn (copy triggered)                       6.57
-100000 facts: modify in txn (copy triggered)                      70.11
+Taped.each() x125                                                  1.08
+Taped.delete_if() x375                                             0.86
+50000 facts: plain read (no txn)                                   4.06
+50000 facts: read-only txn (no copy)                               4.85
+50000 facts: plain insert (no txn)                                 0.00
+50000 facts: insert in txn (copy triggered)                        3.31
+50000 facts: plain modify (no txn)                                28.21
+50000 facts: modify in txn (copy triggered)                       35.14
+100000 facts: plain read (no txn)                                  8.06
+100000 facts: read-only txn (no copy)                              9.94
+100000 facts: plain insert (no txn)                                0.00
+100000 facts: insert in txn (copy triggered)                       6.68
+100000 facts: plain modify (no txn)                               56.21
+100000 facts: modify in txn (copy triggered)                      70.09
 ```
 
 The results were calculated in [this GHA job][benchmark-gha]
-on 2026-02-04 at 05:19,
+on 2026-02-17 at 18:48,
 on Linux with 4 CPUs.
 <!-- benchmark_end -->
 
-[benchmark-gha]: https://github.com/yegor256/factbase/actions/runs/21659492807
+[benchmark-gha]: https://github.com/yegor256/factbase/actions/runs/22111136309

data/Rakefile

@@ -88,7 +88,7 @@ desc 'Profile a benchmark (e.g., flamegraph[bench_slow_query])'
 task :flamegraph, [:name] do |_t, args|
   require 'stackprof'
   bname = args[:name] || 'all'
-  puts "Starting profiling for '#{bname}'..."
+  puts "Starting profiling for '#{bname}'..." # rubocop:disable Lint/Debugger
   StackProf.run(mode: :cpu, out: 'stackprof-cpu-myapp.dump', raw: true) do
     Rake::Task['benchmark'].invoke(bname)
   end

data/lib/factbase/indexed/indexed_absent.rb

@@ -11,25 +11,21 @@ class Factbase::IndexedAbsent
   end
 
   def predict(maps, _fb, _params)
-    return nil if @idx.nil?
-    key = [maps.object_id, @term.operands.first, @term.op]
+    prop = @term.operands[0].to_s
+    key = [maps.object_id, prop, @term.op]
+    @idx[key] ||= { facts: [], count: 0 }
     entry = @idx[key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { facts: [], indexed_count: 0 }
-      @idx[key] = entry
-    end
-    if entry[:indexed_count] < maps_array.size
-      prop = @term.operands.first.to_s
-      maps_array[entry[:indexed_count]..].each do |m|
-        entry[:facts] << m if m[prop].nil?
-      end
-      entry[:indexed_count] = maps_array.size
-    end
-    if maps.respond_to?(:ensure_copied!)
-      maps & entry[:facts]
-    else
-      (maps & []) | entry[:facts]
+    _feed(maps.to_a, entry, prop)
+    maps.respond_to?(:repack) ? maps.repack(entry[:facts]) : entry[:facts]
+  end
+
+  private
+
+  def _feed(facts, entry, prop)
+    return unless entry[:count] < facts.size
+    facts[entry[:count]..].each do |f|
+      entry[:facts] << f if f[prop].nil?
     end
+    entry[:count] = facts.size
   end
 end

data/lib/factbase/indexed/indexed_and.rb

@@ -43,12 +43,7 @@ class Factbase::IndexedAnd
         end
       )
       j = tuples.flat_map { |t| entry[:index][t] || [] }.uniq(&:object_id)
-      r =
-        if maps.respond_to?(:inserted)
-          maps & j
-        else
-          j
-        end
+      r = maps.respond_to?(:repack) ? maps.repack(j) : j
     else
       @term.operands.each do |o|
         n = o.predict(maps, fb, params)
@@ -56,7 +51,8 @@ class Factbase::IndexedAnd
         if r.nil?
           r = n
         elsif n.size < r.size * 8 # to skip some obvious matchings
-          r &= n.to_a
+          ids = n.to_set(&:object_id)
+          r = r.select { |f| ids.include?(f.object_id) }
         end
         break if r.size < maps.size / 32 # it's already small enough
         break if r.size < 128 # it's obviously already small enough

data/lib/factbase/indexed/indexed_eq.rb

@@ -11,37 +11,18 @@ class Factbase::IndexedEq
   end
 
   def predict(maps, _fb, params)
-    return nil if @idx.nil?
-    key = [maps.object_id, @term.operands.first, @term.op]
-    return unless @term.operands.first.is_a?(Symbol) && _scalar?(@term.operands[1])
+    first_operand = @term.operands[0]
+    second_operand = @term.operands[1]
+    return unless first_operand.is_a?(Symbol) && _scalar?(second_operand)
+    first_operand = first_operand.to_s
+    key = [maps.object_id, first_operand, @term.op]
+    @idx[key] ||= { facts: {}, count: 0 }
     entry = @idx[key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { index: {}, indexed_count: 0 }
-      @idx[key] = entry
-    end
-    if entry[:indexed_count] < maps_array.size
-      prop = @term.operands.first.to_s
-      maps_array[entry[:indexed_count]..].each do |m|
-        m[prop]&.each do |v|
-          entry[:index][v] ||= []
-          entry[:index][v] << m
-        end
-      end
-      entry[:indexed_count] = maps_array.size
-    end
-    vv =
-      if @term.operands[1].is_a?(Symbol)
-        params[@term.operands[1].to_s] || []
-      else
-        [@term.operands[1]]
-      end
-    j = vv.flat_map { |v| entry[:index][v] || [] }.uniq(&:object_id)
-    if maps.respond_to?(:inserted)
-      maps & j
-    else
-      j
-    end
+    _feed(maps.to_a, entry, first_operand)
+    keys = _resolve(second_operand, params)
+    matches = keys.flat_map { |k| entry[:facts][k] || [] }
+    matches = matches.uniq(&:object_id) if keys.size > 1
+    maps.respond_to?(:repack) ? maps.repack(matches) : matches
   end
 
   private
@@ -49,4 +30,20 @@ class Factbase::IndexedEq
   def _scalar?(item)
     item.is_a?(String) || item.is_a?(Time) || item.is_a?(Integer) || item.is_a?(Float) || item.is_a?(Symbol)
   end
+
+  def _feed(facts, entry, operand)
+    return unless entry[:count] < facts.size
+    facts[entry[:count]..].each do |m|
+      m[operand]&.each do |v|
+        entry[:facts][v] ||= []
+        entry[:facts][v] << m
+      end
+    end
+    entry[:count] = facts.size
+  end
+
+  def _resolve(operand, params)
+    return Array(operand) unless operand.is_a?(Symbol)
+    params[operand.to_s] || []
+  end
 end

data/lib/factbase/indexed/indexed_exists.rb

@@ -20,14 +20,13 @@ class Factbase::IndexedExists
     key = [maps.object_id, operand, @term.op]
     @idx[key] = { facts: [], count: 0 } if @idx[key].nil?
     entry = @idx[key]
-    feed(maps.to_a, entry, operand)
-    return maps.repack(entry[:facts]) if maps.respond_to?(:repack)
-    entry[:facts]
+    _feed(maps.to_a, entry, operand)
+    maps.respond_to?(:repack) ? maps.repack(entry[:facts]) : entry[:facts]
   end
 
   private
 
-  def feed(facts, entry, operand)
+  def _feed(facts, entry, operand)
     facts[entry[:count]..].each do |m|
       entry[:facts] << m unless m[operand].nil?
     end

data/lib/factbase/indexed/indexed_gt.rb

@@ -11,36 +11,17 @@ class Factbase::IndexedGt
   end
 
   def predict(maps, _fb, params)
-    return nil if @idx.nil?
-    return unless @term.operands.first.is_a?(Symbol) && _scalar?(@term.operands[1])
-    prop = @term.operands.first.to_s
-    cache_key = [maps.object_id, @term.operands.first, :sorted]
-    entry = @idx[cache_key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { sorted: [], indexed_count: 0 }
-      @idx[cache_key] = entry
-    end
-    if entry[:indexed_count] < maps_array.size
-      maps_array[entry[:indexed_count]..].each do |m|
-        values = m[prop]
-        next if values.nil?
-        values.each do |v|
-          entry[:sorted] << [v, m]
-        end
-      end
-      entry[:sorted].sort_by! { |pair| pair[0] }
-      entry[:indexed_count] = maps_array.size
-    end
-    threshold = @term.operands[1].is_a?(Symbol) ? params[@term.operands[1].to_s]&.first : @term.operands[1]
-    return nil if threshold.nil?
-    i = entry[:sorted].bsearch_index { |pair| pair[0] > threshold } || entry[:sorted].size
-    result = entry[:sorted][i..].map { |pair| pair[1] }.uniq
-    if maps.respond_to?(:ensure_copied!)
-      maps & result
-    else
-      (maps & []) | result
-    end
+    op1, op2 = @term.operands
+    return unless op1.is_a?(Symbol) && _scalar?(op2)
+    prop = op1.to_s
+    target = op2.is_a?(Symbol) ? params[op2.to_s]&.first : op2
+    return maps || [] if target.nil?
+    key = [maps.object_id, prop, :facts]
+    @idx[key] ||= { facts: [], count: 0 }
+    entry = @idx[key]
+    _feed(maps.to_a, entry, prop)
+    matched = _search(entry, target)
+    maps.respond_to?(:repack) ? maps.repack(matched) : matched
   end
 
   private
@@ -48,4 +29,21 @@ class Factbase::IndexedGt
   def _scalar?(item)
     item.is_a?(String) || item.is_a?(Time) || item.is_a?(Integer) || item.is_a?(Float) || item.is_a?(Symbol)
   end
+
+  def _feed(facts, entry, prop)
+    return unless entry[:count] < facts.size
+    facts[entry[:count]..].each do |fact|
+      fact[prop]&.each do |v|
+        entry[:facts] << [v, fact]
+      end
+    end
+    entry[:facts].sort_by! { |pair| pair[0] }
+    entry[:count] = facts.size
+  end
+
+  def _search(entry, target)
+    idx = entry[:facts].bsearch_index { |v, _| v > target }
+    return [] if idx.nil?
+    entry[:facts][idx..].map { |_, f| f }.uniq(&:object_id)
+  end
 end

data/lib/factbase/indexed/indexed_lt.rb

@@ -11,41 +11,17 @@ class Factbase::IndexedLt
   end
 
   def predict(maps, _fb, params)
-    return nil if @idx.nil?
-    return unless @term.operands.first.is_a?(Symbol) && _scalar?(@term.operands[1])
-    prop = @term.operands.first.to_s
-    cache_key = [maps.object_id, @term.operands.first, :sorted]
-    entry = @idx[cache_key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { sorted: [], indexed_count: 0 }
-      @idx[cache_key] = entry
-    end
-    if entry[:indexed_count] < maps_array.size
-      new_pairs = []
-      maps_array[entry[:indexed_count]..].each do |m|
-        values = m[prop]
-        next if values.nil?
-        values.each do |v|
-          new_pairs << [v, m]
-        end
-      end
-      unless new_pairs.empty?
-        entry[:sorted].concat(new_pairs)
-        entry[:sorted].sort_by! { |pair| pair[0] }
-      end
-      entry[:indexed_count] = maps_array.size
-    end
-
-    threshold = @term.operands[1].is_a?(Symbol) ? params[@term.operands[1].to_s]&.first : @term.operands[1]
-    return nil if threshold.nil?
-    i = entry[:sorted].bsearch_index { |pair| pair[0] >= threshold } || entry[:sorted].size
-    result = entry[:sorted][0...i].map { |pair| pair[1] }.uniq
-    if maps.respond_to?(:ensure_copied!)
-      maps & result
-    else
-      (maps & []) | result
-    end
+    op1, op2 = @term.operands
+    return unless op1.is_a?(Symbol) && _scalar?(op2)
+    prop = op1.to_s
+    target = op2.is_a?(Symbol) ? params[op2.to_s]&.first : op2
+    return maps || [] if target.nil?
+    key = [maps.object_id, prop, :facts]
+    @idx[key] ||= { facts: [], count: 0 }
+    entry = @idx[key]
+    _feed(maps.to_a, entry, prop)
+    matched = _search(entry, target)
+    maps.respond_to?(:repack) ? maps.repack(matched) : matched
   end
 
   private
@@ -53,4 +29,21 @@ class Factbase::IndexedLt
   def _scalar?(item)
     item.is_a?(String) || item.is_a?(Time) || item.is_a?(Integer) || item.is_a?(Float) || item.is_a?(Symbol)
   end
+
+  def _feed(facts, entry, prop)
+    return unless entry[:count] < facts.size
+    facts[entry[:count]..].each do |fact|
+      fact[prop]&.each do |v|
+        entry[:facts] << [v, fact]
+      end
+    end
+    entry[:facts].sort_by! { |pair| pair[0] }
+    entry[:count] = facts.size
+  end
+
+  def _search(entry, target)
+    idx = entry[:facts].bsearch_index { |v, _| v >= target }
+    res = idx.nil? ? entry[:facts] : entry[:facts][0...idx]
+    res.map { |_, f| f }.uniq(&:object_id)
+  end
 end

data/lib/factbase/indexed/indexed_not.rb

@@ -11,33 +11,30 @@ class Factbase::IndexedNot
   end
 
   def predict(maps, fb, params)
-    return nil if @idx.nil?
-    key = [maps.object_id, @term.operands.first, @term.op]
+    sub = @term.operands.first
+    key = [maps.object_id, sub, @term.op]
+    @idx[key] ||= { facts: nil, count: 0, yes_set: nil }
     entry = @idx[key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { facts: nil, indexed_count: 0, yes_set: nil }
-      @idx[key] = entry
+    _feed(maps.to_a, entry) do
+      sub.predict(maps, fb, params)
     end
-    if entry[:indexed_count] < maps_array.size
-      yes = @term.operands.first.predict(maps, fb, params)
-      if yes.nil?
-        entry[:facts] = nil
-        entry[:yes_set] = nil
-      else
-        yes_set = yes.to_a.to_set
-        entry[:yes_set] = yes_set
-        entry[:facts] = maps_array.reject { |m| yes_set.include?(m) }
-      end
-      entry[:indexed_count] = maps_array.size
-    end
-    r = entry[:facts]
-    if r.nil?
-      nil
-    elsif maps.respond_to?(:ensure_copied!)
-      maps & r
+    return nil if entry[:facts].nil?
+    maps.respond_to?(:repack) ? maps.repack(entry[:facts]) : entry[:facts]
+  end
+
+  private
+
+  def _feed(facts, entry)
+    return unless entry[:count] < facts.size
+    yes = yield
+    if yes.nil?
+      entry[:facts] = nil
+      entry[:yes_set] = nil
     else
-      (maps & []) | r
+      yes_set = yes.to_a.to_set
+      entry[:yes_set] = yes_set
+      entry[:facts] = facts.reject { |m| yes_set.include?(m) }
     end
+    entry[:count] = facts.size
   end
 end

data/lib/factbase/indexed/indexed_one.rb

@@ -11,25 +11,21 @@ class Factbase::IndexedOne
   end
 
   def predict(maps, _fb, _params)
-    return nil if @idx.nil?
-    key = [maps.object_id, @term.operands.first, @term.op]
+    prop = @term.operands.first.to_s
+    key = [maps.object_id, prop, @term.op]
+    @idx[key] ||= { facts: [], count: 0 }
     entry = @idx[key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { facts: [], indexed_count: 0 }
-      @idx[key] = entry
-    end
-    if entry[:indexed_count] < maps_array.size
-      prop = @term.operands.first.to_s
-      maps_array[entry[:indexed_count]..].each do |m|
-        entry[:facts] << m if !m[prop].nil? && m[prop].size == 1
-      end
-      entry[:indexed_count] = maps_array.size
-    end
-    if maps.respond_to?(:ensure_copied!)
-      maps & entry[:facts]
-    else
-      (maps & []) | entry[:facts]
+    _feed(maps.to_a, entry, prop)
+    maps.respond_to?(:repack) ? maps.repack(entry[:facts]) : entry[:facts]
+  end
+
+  private
+
+  def _feed(facts, entry, prop)
+    return unless entry[:count] < facts.size
+    facts[entry[:count]..].each do |f|
+      entry[:facts] << f if !f[prop].nil? && f[prop].size == 1
     end
+    entry[:count] = facts.size
   end
 end

data/lib/factbase/indexed/indexed_unique.rb

@@ -33,12 +33,8 @@ class Factbase::IndexedUnique
     idx_key = [maps.object_id, @term.op.to_s, bucket_key]
     entry = (@idx[idx_key] ||= { buckets: {}, count: 0 })
     feed(maps.to_a, entry, operands, bucket_key)
-    bucket = entry[:buckets][bucket_key]
-    if maps.respond_to?(:ensure_copied!)
-      maps & (bucket[:facts] || [])
-    else
-      (maps & []) | (bucket[:facts] || [])
-    end
+    matches = entry[:buckets][bucket_key][:facts]
+    maps.respond_to?(:repack) ? maps.repack(matches) : matches
   end
 
   private

data/lib/factbase/lazy_taped.rb

@@ -11,23 +11,23 @@ require_relative 'lazy_taped_hash'
 class Factbase::LazyTaped
   def initialize(origin)
     @origin = origin
+    @staged = []
     @copied = false
-    @maps = nil
-    @pairs = nil
-    @inverted_pairs = nil
+    @copies = {}.compare_by_identity
     @inserted = []
     @deleted = []
     @added = []
   end
 
-  # Returns a hash mapping copied maps to their originals.
-  # This is used during transaction commit to identify which original facts
-  # were modified, allowing the factbase to update the correct entries.
-  def pairs
-    return {} unless @pairs
-    result = {}.compare_by_identity
-    @pairs.each { |copied, original| result[copied] = original }
-    result
+  # Returns the original map this copy was derived from.
+  # Returns nil if the base hasn't been copied yet or if the fact is new.
+  def source_of(copy)
+    return nil unless @copied
+    @copies.key(copy)
+  end
+
+  def copied?
+    @copied
   end
 
   # Returns the unique object IDs of maps that were inserted (newly created).
@@ -51,101 +51,104 @@ class Factbase::LazyTaped
   end
 
   def find_by_object_id(oid)
-    (@maps || @origin).find { |m| m.object_id == oid }
+    r = @staged.find { |m| m.object_id == oid }
+    r = @origin.find { |m| m.object_id == oid } if r.nil? && !copied?
+    r
   end
 
   def size
-    (@maps || @origin).size
+    copied? ? @staged.size : (@origin.size + @staged.size)
   end
 
   def empty?
-    (@maps || @origin).empty?
+    copied? ? @staged.empty? : (@origin.empty? && @staged.empty?)
   end
 
   def <<(map)
-    ensure_copied!
-    @maps << map
+    @staged << map
+    _track(map, map)
     @inserted.append(map.object_id)
   end
 
   def each
     return to_enum(__method__) unless block_given?
-    if @copied
-      @maps.each do |m|
-        yield Factbase::Taped::TapedHash.new(m, @added)
-      end
-    else
-      @origin.each do |m|
-        yield LazyTapedHash.new(m, self, @added)
+    st_size = @staged.size
+    orig_size = @origin.size
+    unless copied?
+      orig_size.times do |i|
+        m = @origin[i]
+        yield _tape(m) unless m.nil?
       end
     end
+    st_size.times do |i|
+      m = @staged[i]
+      yield _tape(m) unless m.nil?
+    end
   end
 
   def delete_if
     ensure_copied!
-    @maps.delete_if do |m|
+    @staged.delete_if do |m|
       r = yield m
-      @deleted.append(@pairs[m].object_id) if r
+      @deleted.append(source_of(m).object_id) if r
       r
     end
   end
 
   def to_a
-    (@maps || @origin).to_a
+    (copied? ? @staged : (@origin + @staged)).to_a
   end
 
   def repack(other)
     ensure_copied!
-    copied = other.map { |o| @inverted_pairs[o] || o }
+    copied = other.map { |o| @copies[o] || o }
     Factbase::Taped.new(copied, inserted: @inserted, deleted: @deleted, added: @added)
   end
 
   def &(other)
-    if other == [] || (@maps || @origin).empty?
-      return Factbase::Taped.new([], inserted: @inserted, deleted: @deleted, added: @added)
-    end
-    join(other, &:&)
+    return Factbase::Taped.new([], inserted: @inserted, deleted: @deleted, added: @added) if other == []
+    return Factbase::Taped.new([], inserted: @inserted, deleted: @deleted, added: @added) if empty?
+    _join(other, &:&)
   end
 
   def |(other)
     return Factbase::Taped.new(to_a, inserted: @inserted, deleted: @deleted, added: @added) if other == []
-    if (@maps || @origin).empty?
-      return Factbase::Taped.new(other, inserted: @inserted, deleted: @deleted, added: @added)
-    end
-    join(other, &:|)
+    return Factbase::Taped.new(other, inserted: @inserted, deleted: @deleted, added: @added) if empty?
+    _join(other, &:|)
   end
 
   def ensure_copied!
-    return if @copied
-    @pairs = {}.compare_by_identity
-    @inverted_pairs = {}.compare_by_identity
-    @maps =
-      @origin.map do |m|
-        n = m.transform_values(&:dup)
-        @pairs[n] = m
-        @inverted_pairs[m] = n
-        n
-      end
+    return if copied?
+    @origin.each do |o|
+      c = o.transform_values(&:dup)
+      _track(c, o)
+      @staged << c
+    end
     @copied = true
   end
 
   def get_copied_map(original_map)
     ensure_copied!
-    @maps.find { |m| @pairs[m].equal?(original_map) }
+    @copies[original_map] || original_map
   end
 
   private
 
-  def join(other)
+  def _join(other)
     ensure_copied!
-    n = yield (@maps || @origin).to_a, other.to_a
+    n = yield to_a, other.to_a
     raise 'Cannot join with another Taped' if other.respond_to?(:inserted)
     raise 'Can only join with array' unless other.is_a?(Array)
-    Factbase::Taped.new(
-      n,
-      inserted: @inserted,
-      deleted: @deleted,
-      added: @added
-    )
+    Factbase::Taped.new(n, inserted: @inserted, deleted: @deleted, added: @added)
+  end
+
+  def _track(copy, original)
+    @copies[original] = copy
+  end
+
+  def _tape(map)
+    return LazyTapedHash.new(map, self, @added) unless copied?
+    copy = @copies[map] || map
+    Factbase::Taped::TapedHash.new(copy, @added)
   end
 end

data/lib/factbase/lazy_taped_array.rb

@@ -7,10 +7,6 @@ require_relative '../factbase'
 
 class Factbase::LazyTaped
   # Decorator of Array that triggers copy-on-write.
-  # @todo #424:30min Add dedicated unit tests for LazyTapedArray class.
-  #  Currently this class is tested indirectly through LazyTaped tests.
-  #  We should add explicit tests for all public methods including each, [],
-  #  to_a, any?, <<, and uniq! to ensure proper copy-on-write behavior.
   class LazyTapedArray
     # Creates a new lazy array wrapper.
     # @param origin [Array] The original array to wrap

data/lib/factbase/lazy_taped_hash.rb

@@ -8,10 +8,6 @@ require_relative 'lazy_taped_array'
 
 class Factbase::LazyTaped
   # Decorator of Hash that triggers copy-on-write.
-  # @todo #424:30min Add dedicated unit tests for LazyTapedHash class.
-  #  Currently this class is tested indirectly through LazyTaped tests.
-  #  We should add explicit tests for all public methods including keys, map,
-  #  bracket access, bracket assignment, and the copy-on-write behavior.
   class LazyTapedHash
     # Creates a new LazyTapedHash decorator.
     # @param origin [Hash] The original hash being wrapped (not yet copied)

data/lib/factbase/terms/traced.rb

@@ -27,7 +27,7 @@ class Factbase::Traced < Factbase::TermBase
     t = @operands[0]
     raise "A term is expected, but '#{t}' provided" unless t.is_a?(Factbase::Term)
     r = t.evaluate(fact, maps, fb)
-    puts "#{self} -> #{r}"
+    puts "#{self} -> #{r}" # rubocop:disable Lint/Debugger
     r
   end
 end

data/lib/factbase/version.rb

@@ -9,5 +9,5 @@
 # License:: MIT
 class Factbase
   # Current version of the gem (changed by .rultor.yml on every release)
-  VERSION = '0.19.6' unless const_defined?(:VERSION)
+  VERSION = '0.19.8' unless const_defined?(:VERSION)
 end

data/lib/factbase.rb

@@ -181,7 +181,6 @@ class Factbase
     end
     seen = {}.compare_by_identity
     garbage = {}.compare_by_identity
-    pairs = taped.pairs
     taped.deleted.each do |oid|
       original = @maps.find { |m| m.object_id == oid }
       next if original.nil?
@@ -200,7 +199,8 @@ class Factbase
       b = taped.find_by_object_id(oid)
       next if b.nil?
       next if seen.key?(b)
-      garbage[pairs[b]] = true
+      original = taped.source_of(b)
+      garbage[original] = true if original
       @maps << b
       churn.append(0, 0, 1)
     end

data/lib/fuzz.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+# Fuzzing generator for Factbase.
+#
+# Author:: Yegor Bugayenko (yegor256@gmail.com)
+# Author:: Philip Belousov (belousovfilip@gmail.com)
+# Copyright:: Copyright (c) 2024-2026 Yegor Bugayenko
+# License:: MIT
+class Factbase::Fuzz
+  LABELS = ['bug', 'enhancement', 'documentation', 'duplicate', 'question', 'good first issue', 'help wanted'].freeze
+  AUTHORS = ['Noah Williams', 'Mason Jones', 'Rocket Man 🚀', 'Иван Иванович', '黒さん', 'Σωκράτης', 'المنطق سي'].freeze
+  TITLES = ['Clean Code', 'Adding more elegance', 'Удаление статики', 'Re de Müller-Lyer', '纯代码', '✨✨✨'].freeze
+  MESSAGES = [
+    'Good point, thanks',
+    'This is not an object, it is a data holder!',
+    'Why is this method static? Please refactor.',
+    'I dont like this name. It is not a noun.',
+    'Please add a unit test for this change.',
+    'NULL is evil, never use it here.',
+    'Pure elegance! Very object-oriented.',
+    'Finally, a clean decorator! Good job.',
+    'Exquisite! No getters, no setters, just behavior.',
+    'This PR makes me happy. It is very elegant.',
+    'Исправь кодировку!',
+    'デザインが悪い (Poor design)',
+    'C’est magnifique! ',
+    'Λογική χωρίς ',
+    'المنطق سيء للغاية',
+    'Este código no es elegante',
+    '❤️❤️❤️'
+  ].freeze
+
+  def initialize
+    @next_num = 0
+    @max_comments = 10
+    raise 'Not enough messages for fuzzing' if MESSAGES.size < @max_comments
+  end
+
+  def self.make(count = 1000)
+    raise "Count must be positive: #{count}" if count.negative?
+    fb = Factbase.new
+    Factbase::Fuzz.new.feed(fb, count)
+    fb
+  end
+
+  def feed(fb, count = 1)
+    raise "Count must be positive: #{count}" if count.negative?
+    count.times do
+      pull_request(fb, @next_num += 1)
+    end
+  end
+
+  private
+
+  def pull_request(fb, idx)
+    f = fb.insert
+    f.number = idx
+    f.ready = rand(2)
+    f.cost = rand(1..32)
+    f.kind = 'pull_request'
+    f.author = AUTHORS.sample
+    f.diff_size = rand(10..5000)
+    f.state = %w[open merged closed].sample
+    f.title = "#{TITLES.sample} in #{LABELS.sample}"
+    f.test_coverage = rand(0.0..100.0).round(2)
+    f.created_at = Time.now - rand(1..(60 * 60 * 24 * 180))
+    MESSAGES.sample(idx % (@max_comments + 1)).each do |comment|
+      f.comments = comment
+    end
+    f
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: factbase
 version: !ruby/object:Gem::Version
-  version: 0.19.6
+  version: 0.19.8
 platform: ruby
 authors:
 - Yegor Bugayenko
@@ -271,6 +271,7 @@ files:
 - lib/factbase/to_xml.rb
 - lib/factbase/to_yaml.rb
 - lib/factbase/version.rb
+- lib/fuzz.rb
 homepage: https://github.com/yegor256/factbase.rb
 licenses:
 - MIT