factbase 0.19.4 → 0.19.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc6cb6bd378d266fcaa401091228e6dc4084474f5f16e89c9fb29dd56d577c77
-  data.tar.gz: 8c1e86c86b01371f159d29c0187a263598d7d5b6c2949200b7813dff22fd6fca
+  metadata.gz: 99e8fdb60e5fb1e8083b76db845cfad8a7b6be35700c543819ce631f8ac3ca19
+  data.tar.gz: 1fd106429c8a3aa39e56683060b5e61395e705abe336290da63fb1a35e748ec5
 SHA512:
-  metadata.gz: afa7d0dd3cace0292ce9de22c102dfed04772f568f9ad725e5d937024918b6c2c103a87221bbee3e3902167f0c3ec886567cb791593e8693e2723e66fa2d62f7
-  data.tar.gz: 55891ef31903c5d07a6d153bb23bff4264e3d2c414ed4655e2388702d51d1bcdcb75a490f40b8e62007a32dbe571ee0146ab190b890bb5935ad9393d215e0e54
+  metadata.gz: e03d29fb285a301e48723690f3bdad751a0bc229bd559d901e22fdb196a4e263d5b75bbc6fef2da5480f07f1a4d22d510e630f7f7a7af8988d2b981d6a4b0b10
+  data.tar.gz: c41be62abd514f4ea0fde5e47fba206f27a8bd89a82a17e03c55a3908e5d9c98e909eca6bb571e183f8c2f11421617f0a20b31db132c1107a91eea0fb12cb0c1

data/README.md

@@ -80,6 +80,21 @@ churn = fb.churn
 assert churn.inserted == 1
 ```
 
+Properties are accumulative.
+Setting a property again adds a value instead of overwriting:
+
+```ruby
+f = fb.insert
+f.foo = 42
+f.foo = 43
+assert(f.foo == 42)
+assert(f['foo'] == [42, 43])
+fb.query('(eq foo 43)').each do |f|
+  assert(f.foo == 42)
+  assert(f['foo'].include?(43))
+end
+```
+
 ## Terms
 
 There are some boolean terms available in a query

data/lib/factbase/indexed/indexed_absent.rb

@@ -26,6 +26,10 @@ class Factbase::IndexedAbsent
       end
       entry[:indexed_count] = maps_array.size
     end
-    (maps & []) | entry[:facts]
+    if maps.respond_to?(:ensure_copied!)
+      maps & entry[:facts]
+    else
+      (maps & []) | entry[:facts]
+    end
   end
 end

data/lib/factbase/indexed/indexed_and.rb

@@ -45,7 +45,7 @@ class Factbase::IndexedAnd
       j = tuples.flat_map { |t| entry[:index][t] || [] }.uniq(&:object_id)
       r =
         if maps.respond_to?(:inserted)
-          Factbase::Taped.new(j, inserted: maps.inserted, deleted: maps.deleted, added: maps.added)
+          maps & j
         else
           j
         end

data/lib/factbase/indexed/indexed_eq.rb

@@ -38,7 +38,7 @@ class Factbase::IndexedEq
       end
     j = vv.flat_map { |v| entry[:index][v] || [] }.uniq(&:object_id)
     if maps.respond_to?(:inserted)
-      Factbase::Taped.new(j, inserted: maps.inserted, deleted: maps.deleted, added: maps.added)
+      maps & j
     else
       j
     end

data/lib/factbase/indexed/indexed_exists.rb

@@ -4,6 +4,11 @@
 # SPDX-License-Identifier: MIT
 
 # Indexed term 'exists'.
+# The @idx[key] structure:
+# {
+#   count: Integer (number of facts already processed),
+#   facts: Array (facts found),
+# }
 class Factbase::IndexedExists
   def initialize(term, idx)
     @term = term
@@ -11,21 +16,21 @@ class Factbase::IndexedExists
   end
 
   def predict(maps, _fb, _params)
-    return nil if @idx.nil?
-    key = [maps.object_id, @term.operands.first, @term.op]
+    operand = @term.operands.first.to_s
+    key = [maps.object_id, operand, @term.op]
+    @idx[key] = { facts: [], count: 0 } if @idx[key].nil?
     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 unless m[prop].nil?
-      end
-      entry[:indexed_count] = maps_array.size
+    feed(maps.to_a, entry, operand)
+    return maps.repack(entry[:facts]) if maps.respond_to?(:repack)
+    entry[:facts]
+  end
+
+  private
+
+  def feed(facts, entry, operand)
+    facts[entry[:count]..].each do |m|
+      entry[:facts] << m unless m[operand].nil?
     end
-    (maps & []) | entry[:facts]
+    entry[:count] = facts.size
   end
 end

data/lib/factbase/indexed/indexed_gt.rb

@@ -36,7 +36,11 @@ class Factbase::IndexedGt
     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
-    (maps & []) | result
+    if maps.respond_to?(:ensure_copied!)
+      maps & result
+    else
+      (maps & []) | result
+    end
   end
 
   private

data/lib/factbase/indexed/indexed_lt.rb

@@ -41,7 +41,11 @@ class Factbase::IndexedLt
     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
-    (maps & []) | result
+    if maps.respond_to?(:ensure_copied!)
+      maps & result
+    else
+      (maps & []) | result
+    end
   end
 
   private

data/lib/factbase/indexed/indexed_not.rb

@@ -34,6 +34,8 @@ class Factbase::IndexedNot
     r = entry[:facts]
     if r.nil?
       nil
+    elsif maps.respond_to?(:ensure_copied!)
+      maps & r
     else
       (maps & []) | r
     end

data/lib/factbase/indexed/indexed_one.rb

@@ -26,6 +26,10 @@ class Factbase::IndexedOne
       end
       entry[:indexed_count] = maps_array.size
     end
-    (maps & []) | entry[:facts]
+    if maps.respond_to?(:ensure_copied!)
+      maps & entry[:facts]
+    else
+      (maps & []) | entry[:facts]
+    end
   end
 end

data/lib/factbase/indexed/indexed_unique.rb

@@ -4,9 +4,23 @@
 # SPDX-License-Identifier: MIT
 
 # Indexed term 'unique'.
-# @todo #249:30min Improve prediction for 'unique' term. Current prediction is quite naive and
-#  returns many false positives because it just filters facts which have exactly the same set
-#  of keys regardless the values. We should introduce more smart prediction.
+# The @idx[ikey] structure:
+# {
+#   count: Integer (number of facts already processed),
+#   buckets: {
+#     key => {
+#       facts: Array (unique facts found),
+#       seen: Set (composite values already indexed to skip duplicates)
+#     }
+#   }
+# }
+# Example 1: (unique "fruit")
+#   - Apple, Apple, Banana
+#   - count: 3, facts: [Apple, Banana], seen: { [Apple], [Banana] }
+#
+# Example 2: (unique "fruit" "color")
+#   - [Apple, Red], [Apple, Green], [Apple, Red]
+#   - count: 3, facts: [[Apple, Red], [Apple, Green]], seen: { [Apple, Red], [Apple, Green] }
 class Factbase::IndexedUnique
   def initialize(term, idx)
     @term = term
@@ -14,21 +28,29 @@ class Factbase::IndexedUnique
   end
 
   def predict(maps, _fb, _params)
-    return nil if @idx.nil?
-    key = [maps.object_id, @term.operands.first, @term.op]
-    entry = @idx[key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { facts: [], indexed_count: 0 }
-      @idx[key] = entry
+    operands = @term.operands.map(&:to_s)
+    bucket_key = operands.join('|')
+    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
-    if entry[:indexed_count] < maps_array.size
-      props = @term.operands.map(&:to_s)
-      maps_array[entry[:indexed_count]..].each do |m|
-        entry[:facts] << m if props.all? { |p| !m[p].nil? }
-      end
-      entry[:indexed_count] = maps_array.size
+  end
+
+  private
+
+  def feed(facts, entry, operands, bucket_key)
+    entry[:buckets][bucket_key] ||= { facts: [], seen: Set.new }
+    bucket = entry[:buckets][bucket_key]
+    (facts[entry[:count]..] || []).each do |fact|
+      composite_val = operands.map { |o| fact[o] }
+      next if composite_val.any?(&:nil?)
+      bucket[:facts] << fact if bucket[:seen].add?(composite_val)
     end
-    (maps & []) | entry[:facts]
+    entry[:count] = facts.size
   end
 end

data/lib/factbase/lazy_taped.rb

@@ -14,6 +14,7 @@ class Factbase::LazyTaped
     @copied = false
     @maps = nil
     @pairs = nil
+    @inverted_pairs = nil
     @inserted = []
     @deleted = []
     @added = []
@@ -62,7 +63,7 @@ class Factbase::LazyTaped
   end
 
   def <<(map)
-    ensure_copied
+    ensure_copied!
     @maps << map
     @inserted.append(map.object_id)
   end
@@ -81,7 +82,7 @@ class Factbase::LazyTaped
   end
 
   def delete_if
-    ensure_copied
+    ensure_copied!
     @maps.delete_if do |m|
       r = yield m
       @deleted.append(@pairs[m].object_id) if r
@@ -93,6 +94,12 @@ class Factbase::LazyTaped
     (@maps || @origin).to_a
   end
 
+  def repack(other)
+    ensure_copied!
+    copied = other.map { |o| @inverted_pairs[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)
@@ -108,26 +115,29 @@ class Factbase::LazyTaped
     join(other, &:|)
   end
 
-  def ensure_copied
+  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
     @copied = true
   end
 
   def get_copied_map(original_map)
-    ensure_copied
+    ensure_copied!
     @maps.find { |m| @pairs[m].equal?(original_map) }
   end
 
   private
 
   def join(other)
+    ensure_copied!
     n = yield (@maps || @origin).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)

data/lib/factbase/taped.rb

@@ -68,6 +68,10 @@ class Factbase::Taped
     @origin.to_a
   end
 
+  def repack(other)
+    Factbase::Taped.new(other, inserted: @inserted, deleted: @deleted, added: @added)
+  end
+
   def &(other)
     if other == [] || @origin.empty?
       return Factbase::Taped.new([], inserted: @inserted, deleted: @deleted, added: @added)

data/lib/factbase/term.rb

@@ -176,7 +176,7 @@ class Factbase::Term < Factbase::TermBase
   # Try to predict which facts from the provided list
   # should be evaluated. If no prediction can be made,
   # the same list is returned.
-  # @param [Array<Hash>] maps Records to iterate, maybe
+  # @param [Array<Hash>, Factbase::Taped, Factbase::LazyTaped] maps Records to iterate, maybe
   # @param [Hash] params Params to use (keys must be strings, not symbols, with values as arrays)
   # @return [Array<Hash>] Records to iterate
   def predict(maps, fb, params)

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.4' unless const_defined?(:VERSION)
+  VERSION = '0.19.6' unless const_defined?(:VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: factbase
 version: !ruby/object:Gem::Version
-  version: 0.19.4
+  version: 0.19.6
 platform: ruby
 authors:
 - Yegor Bugayenko