factbase 0.16.7 → 0.17.0

data/lib/factbase/indexed/indexed_or.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+# Indexed term 'or'.
+class Factbase::IndexedOr
+  def initialize(term, idx)
+    @term = term
+    @idx = idx
+  end
+
+  def predict(maps, fb, params)
+    return nil if @idx.nil?
+    r = nil
+    @term.operands.each do |o|
+      n = o.predict(maps, fb, params)
+      if n.nil?
+        r = nil
+        break
+      end
+      r = maps & [] if r.nil?
+      r |= n.to_a
+      return maps if r.size > maps.size / 4 # it's big enough already
+    end
+    r
+  end
+end

data/lib/factbase/indexed/indexed_query.rb

@@ -12,6 +12,8 @@ require_relative 'indexed_fact'
 # Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class Factbase::IndexedQuery
+  include Enumerable
+
   # Constructor.
   # @param [Factbase::Query] origin Original query
   # @param [Hash] idx The index

data/lib/factbase/indexed/indexed_term.rb

@@ -5,6 +5,16 @@
 
 require 'tago'
 require_relative '../../factbase'
+require_relative '../indexed/indexed_eq'
+require_relative '../indexed/indexed_lt'
+require_relative '../indexed/indexed_gt'
+require_relative '../indexed/indexed_one'
+require_relative '../indexed/indexed_not'
+require_relative '../indexed/indexed_exists'
+require_relative '../indexed/indexed_and'
+require_relative '../indexed/indexed_or'
+require_relative '../indexed/indexed_absent'
+require_relative '../indexed/indexed_unique'
 
 # Term with an index.
 #
@@ -20,196 +30,30 @@ module Factbase::IndexedTerm
   # @param [Hash] params Key/value params to use
   # @return [Array<Hash>|nil] Returns a new array, or NIL if the original array must be used
   def predict(maps, fb, params)
+    if @terms.key?(@op)
+      t = @terms[@op]
+      return t.predict(maps, fb, params) if t.respond_to?(:predict)
+    end
     m = :"#{@op}_predict"
     return send(m, maps, fb, params) if respond_to?(m)
-    key = [maps.object_id, @operands.first, @op]
-    case @op
-    when :one
-      if @idx[key].nil?
-        @idx[key] = []
-        prop = @operands.first.to_s
-        maps.to_a.each do |m|
-          @idx[key].append(m) if !m[prop].nil? && m[prop].size == 1
-        end
-      end
-      (maps & []) | @idx[key]
-    when :exists
-      if @idx[key].nil?
-        @idx[key] = []
-        prop = @operands.first.to_s
-        maps.to_a.each do |m|
-          @idx[key].append(m) unless m[prop].nil?
-        end
-      end
-      (maps & []) | @idx[key]
-    when :absent
-      if @idx[key].nil?
-        @idx[key] = []
-        prop = @operands.first.to_s
-        maps.to_a.each do |m|
-          @idx[key].append(m) if m[prop].nil?
-        end
-      end
-      (maps & []) | @idx[key]
-    when :eq
-      if @operands.first.is_a?(Symbol) && _scalar?(@operands[1])
-        if @idx[key].nil?
-          @idx[key] = {}
-          prop = @operands.first.to_s
-          maps.to_a.each do |m|
-            m[prop]&.each do |v|
-              @idx[key][v] = [] if @idx[key][v].nil?
-              @idx[key][v].append(m)
-            end
-          end
-        end
-        vv =
-          if @operands[1].is_a?(Symbol)
-            params[@operands[1].to_s] || []
-          else
-            [@operands[1]]
-          end
-        if vv.empty?
-          (maps & [])
-        else
-          j = vv.map { |v| @idx[key][v] || [] }.reduce(&:|)
-          (maps & []) | j
-        end
-      end
-    when :gt
-      if @operands.first.is_a?(Symbol) && _scalar?(@operands[1])
-        prop = @operands.first.to_s
-        cache_key = [maps.object_id, @operands.first, :sorted]
-        if @idx[cache_key].nil?
-          @idx[cache_key] = []
-          maps.to_a.each do |m|
-            values = m[prop]
-            next if values.nil?
-            values.each do |v|
-              @idx[cache_key] << [v, m]
-            end
-          end
-          @idx[cache_key].sort_by! { |pair| pair[0] }
-        end
-        threshold = @operands[1].is_a?(Symbol) ? params[@operands[1].to_s]&.first : @operands[1]
-        return nil if threshold.nil?
-        i = @idx[cache_key].bsearch_index { |pair| pair[0] > threshold } || @idx[cache_key].size
-        result = @idx[cache_key][i..].map { |pair| pair[1] }.uniq
-        (maps & []) | result
-      end
-    when :lt
-      if @operands.first.is_a?(Symbol) && _scalar?(@operands[1])
-        prop = @operands.first.to_s
-        cache_key = [maps.object_id, @operands.first, :sorted]
-        if @idx[cache_key].nil?
-          @idx[cache_key] = []
-          maps.to_a.each do |m|
-            values = m[prop]
-            next if values.nil?
-            values.each do |v|
-              @idx[cache_key] << [v, m]
-            end
-          end
-          @idx[cache_key].sort_by! { |pair| pair[0] }
-        end
-        threshold = @operands[1].is_a?(Symbol) ? params[@operands[1].to_s]&.first : @operands[1]
-        return nil if threshold.nil?
-        i = @idx[cache_key].bsearch_index { |pair| pair[0] >= threshold } || @idx[cache_key].size
-        result = @idx[cache_key][0...i].map { |pair| pair[1] }.uniq
-        (maps & []) | result
-      end
-    when :and
-      r = nil
-      if @operands.all? { |o| o.op == :eq } && @operands.size > 1 \
-        && @operands.all? { |o| o.operands.first.is_a?(Symbol) && _scalar?(o.operands[1]) }
-        props = @operands.map { |o| o.operands.first }.sort
-        key = [maps.object_id, props, :multi_and_eq]
-        if @idx[key].nil?
-          @idx[key] = {}
-          maps.to_a.each do |m|
-            _all_tuples(m, props).each do |t|
-              @idx[key][t] = [] if @idx[key][t].nil?
-              @idx[key][t].append(m)
-            end
-          end
-        end
-        tuples = Enumerator.product(
-          *@operands.sort_by { |o| o.operands.first }.map do |o|
-            if o.operands[1].is_a?(Symbol)
-              params[o.operands[1].to_s] || []
-            else
-              [o.operands[1]]
-            end
-          end
-        )
-        j = tuples.map { |t| @idx[key][t] || [] }.reduce(&:|)
-        r = (maps & []) | j
-      else
-        @operands.each do |o|
-          n = o.predict(maps, fb, params)
-          break if n.nil?
-          if r.nil?
-            r = n
-          elsif n.size < r.size * 8 # to skip some obvious matchings
-            r &= n.to_a
-          end
-          break if r.size < maps.size / 32 # it's already small enough
-          break if r.size < 128 # it's obviously already small enough
-        end
-      end
-      r
-    when :or
-      r = nil
-      @operands.each do |o|
-        n = o.predict(maps, fb, params)
-        if n.nil?
-          r = nil
-          break
-        end
-        r = maps & [] if r.nil?
-        r |= n.to_a
-        return maps if r.size > maps.size / 4 # it's big enough already
-      end
-      r
-    when :not
-      if @idx[key].nil?
-        yes = @operands.first.predict(maps, fb, params)
-        if yes.nil?
-          @idx[key] = { r: nil }
-        else
-          yes = yes.to_a.to_set
-          @idx[key] = { r: maps.to_a.reject { |m| yes.include?(m) } }
-        end
-      end
-      r = @idx[key][:r]
-      if r.nil?
-        nil
-      else
-        (maps & []) | r
-      end
-    end
+    _init_indexes unless @indexes
+    @indexes[@op].predict(maps, fb, params) if @indexes.key?(@op)
   end
 
   private
 
-  def _all_tuples(fact, props)
-    prop = props.first.to_s
-    tuples = []
-    tuples += (fact[prop] || []).zip
-    if props.size > 1
-      tails = _all_tuples(fact, props[1..])
-      ext = []
-      tuples.each do |t|
-        tails.each do |tail|
-          ext << (t + tail)
-        end
-      end
-      tuples = ext
-    end
-    tuples
-  end
-
-  def _scalar?(item)
-    item.is_a?(String) || item.is_a?(Time) || item.is_a?(Integer) || item.is_a?(Float) || item.is_a?(Symbol)
+  def _init_indexes
+    @indexes = {
+      eq: Factbase::IndexedEq.new(self, @idx),
+      lt: Factbase::IndexedLt.new(self, @idx),
+      gt: Factbase::IndexedGt.new(self, @idx),
+      one: Factbase::IndexedOne.new(self, @idx),
+      exists: Factbase::IndexedExists.new(self, @idx),
+      absent: Factbase::IndexedAbsent.new(self, @idx),
+      unique: Factbase::IndexedUnique.new(self, @idx),
+      and: Factbase::IndexedAnd.new(self, @idx),
+      not: Factbase::IndexedNot.new(self, @idx),
+      or: Factbase::IndexedOr.new(self, @idx)
+    }
   end
 end

data/lib/factbase/indexed/indexed_unique.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
+# 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.
+class Factbase::IndexedUnique
+  def initialize(term, idx)
+    @term = term
+    @idx = idx
+  end
+
+  def predict(maps, _fb, _params)
+    return nil if @idx.nil?
+    key = [maps.object_id, @term.operands.first, @term.op]
+    if @idx[key].nil?
+      props = @term.operands.map(&:to_s)
+      @idx[key] = maps.to_a.select { |m| props.all? { |p| !m[p].nil? } }
+    end
+    (maps & []) | @idx[key]
+  end
+end

data/lib/factbase/query.rb

@@ -20,6 +20,8 @@ require_relative 'tee'
 # Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class Factbase::Query
+  include Enumerable
+
   # Constructor.
   # @param [Array<Fact>] maps Array of facts to start with
   # @param [String|Factbase::Term] term The query term
@@ -77,17 +79,29 @@ class Factbase::Query
 
   # Delete all facts that match the query.
   # @param [Factbase] fb The factbase to delete from
+  # @param [String] id The id of facts that uniquely identify them
   # @return [Integer] Total number of facts deleted
-  def delete!(fb = @fb)
+  def delete!(fb = @fb, id: '_id')
     deleted = 0
-    @maps.delete_if do |m|
-      f = Factbase::Fact.new(m)
-      if @term.evaluate(f, @maps, fb)
-        deleted += 1
-        true
-      else
-        false
+    ids = []
+    each(fb) do |f|
+      i = f[id]
+      unless i
+        ids = nil
+        break
       end
+      ids << i.first
+    end
+    @maps.delete_if do |m|
+      d =
+        if ids
+          i = m[id]&.first
+          i && ids.include?(i)
+        else
+          @term.evaluate(Factbase::Fact.new(m), @maps, fb)
+        end
+      deleted += 1 if d
+      d
     end
     deleted
   end

data/lib/factbase/sync/sync_factbase.rb

@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: MIT
 
 require 'decoor'
+require 'monitor'
 require_relative '../../factbase'
 
 # A synchronous thread-safe factbase.
@@ -16,10 +17,10 @@ class Factbase::SyncFactbase
 
   # Constructor.
   # @param [Factbase] origin Original factbase to decorate
-  # @param [Mutex] mutex Mutex to use for synchronization
-  def initialize(origin, mutex = Mutex.new)
+  # @param [Monitor] monitor Monitor to use for synchronization
+  def initialize(origin, monitor = Monitor.new)
     @origin = origin
-    @mutex = mutex
+    @monitor = monitor
   end
 
   # Insert a new fact and return it.
@@ -43,24 +44,23 @@ class Factbase::SyncFactbase
   def query(term, maps = nil)
     term = to_term(term) if term.is_a?(String)
     require_relative 'sync_query'
-    Factbase::SyncQuery.new(@origin.query(term, maps), @mutex, self)
+    Factbase::SyncQuery.new(@origin.query(term, maps), @monitor, self)
   end
 
   # Run an ACID transaction.
   # @return [Factbase::Churn] How many facts have been changed (zero if rolled back)
   # @yield [Factbase] Block to execute in transaction
   def txn
-    @origin.txn do |fbt|
-      yield Factbase::SyncFactbase.new(fbt, @mutex)
+    try_lock do
+      @origin.txn do |fbt|
+        yield Factbase::SyncFactbase.new(fbt, @monitor)
+      end
     end
   end
 
   private
 
-  def try_lock
-    locked = @mutex.try_lock
-    r = yield
-    @mutex.unlock if locked
-    r
+  def try_lock(&)
+    @monitor.synchronize(&)
   end
 end

data/lib/factbase/sync/sync_query.rb

@@ -11,12 +11,14 @@ require_relative '../../factbase'
 # Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class Factbase::SyncQuery
+  include Enumerable
+
   # Constructor.
   # @param [Factbase::Query] origin Original query
-  # @param [Mutex] mutex The mutex
-  def initialize(origin, mutex, fb)
+  # @param [Monitor] monitor The monitor
+  def initialize(origin, monitor, fb)
     @origin = origin
-    @mutex = mutex
+    @monitor = monitor
     @fb = fb
   end
 
@@ -57,10 +59,7 @@ class Factbase::SyncQuery
 
   private
 
-  def try_lock
-    locked = @mutex.try_lock
-    r = yield
-    @mutex.unlock if locked
-    r
+  def try_lock(&)
+    @monitor.synchronize(&)
   end
 end

data/lib/factbase/term.rb

@@ -7,6 +7,51 @@ require 'backtrace'
 require_relative '../factbase'
 require_relative 'fact'
 require_relative 'tee'
+require_relative 'terms/unique'
+require_relative 'terms/prev'
+require_relative 'terms/concat'
+require_relative 'terms/sprintf'
+require_relative 'terms/matches'
+require_relative 'terms/traced'
+require_relative 'terms/assert'
+require_relative 'terms/env'
+require_relative 'terms/defn'
+require_relative 'terms/undef'
+require_relative 'terms/as'
+require_relative 'terms/join'
+require_relative 'terms/exists'
+require_relative 'terms/absent'
+require_relative 'terms/size'
+require_relative 'terms/type'
+require_relative 'terms/nil'
+require_relative 'terms/many'
+require_relative 'terms/one'
+require_relative 'terms/to_string'
+require_relative 'terms/to_integer'
+require_relative 'terms/to_float'
+require_relative 'terms/to_time'
+require_relative 'terms/sorted'
+require_relative 'terms/inverted'
+require_relative 'terms/head'
+require_relative 'terms/plus'
+require_relative 'terms/minus'
+require_relative 'terms/times'
+require_relative 'terms/div'
+require_relative 'terms/zero'
+require_relative 'terms/eq'
+require_relative 'terms/lt'
+require_relative 'terms/lte'
+require_relative 'terms/gt'
+require_relative 'terms/gte'
+require_relative 'terms/always'
+require_relative 'terms/never'
+require_relative 'terms/not'
+require_relative 'terms/or'
+require_relative 'terms/and'
+require_relative 'terms/when'
+require_relative 'terms/either'
+require_relative 'terms/count'
+require_relative 'terms/first'
 
 # Term.
 #
@@ -44,41 +89,14 @@ class Factbase::Term
   # @return [Array] The operands
   attr_reader :operands
 
-  require_relative 'terms/math'
-  include Factbase::Math
-
   require_relative 'terms/logical'
   include Factbase::Logical
 
   require_relative 'terms/aggregates'
   include Factbase::Aggregates
 
-  require_relative 'terms/lists'
-  include Factbase::Lists
-
-  require_relative 'terms/strings'
-  include Factbase::Strings
-
-  require_relative 'terms/casting'
-  include Factbase::Casting
-
-  require_relative 'terms/meta'
-  include Factbase::Meta
-
-  require_relative 'terms/aliases'
-  include Factbase::Aliases
-
-  require_relative 'terms/ordering'
-  include Factbase::Ordering
-
-  require_relative 'terms/defn'
-  include Factbase::Defn
-
-  require_relative 'terms/system'
-  include Factbase::System
-
-  require_relative 'terms/debug'
-  include Factbase::Debug
+  require_relative 'terms/shared'
+  include Factbase::TermShared
 
   # Ctor.
   # @param [Symbol] operator Operator
@@ -86,6 +104,53 @@ class Factbase::Term
   def initialize(operator, operands)
     @op = operator
     @operands = operands
+    @terms = {
+      unique: Factbase::Unique.new(operands),
+      prev: Factbase::Prev.new(operands),
+      concat: Factbase::Concat.new(operands),
+      sprintf: Factbase::Sprintf.new(operands),
+      matches: Factbase::Matches.new(operands),
+      traced: Factbase::Traced.new(operands),
+      assert: Factbase::Assert.new(operands),
+      env: Factbase::Env.new(operands),
+      defn: Factbase::Defn.new(operands),
+      undef: Factbase::Undef.new(operands),
+      as: Factbase::As.new(operands),
+      join: Factbase::Join.new(operands),
+      exists: Factbase::Exists.new(operands),
+      absent: Factbase::Absent.new(operands),
+      size: Factbase::Size.new(operands),
+      type: Factbase::Type.new(operands),
+      nil: Factbase::Nil.new(operands),
+      many: Factbase::Many.new(operands),
+      one: Factbase::One.new(operands),
+      to_string: Factbase::ToString.new(operands),
+      to_integer: Factbase::ToInteger.new(operands),
+      to_float: Factbase::ToFloat.new(operands),
+      to_time: Factbase::ToTime.new(operands),
+      sorted: Factbase::Sorted.new(operands),
+      inverted: Factbase::Inverted.new(operands),
+      head: Factbase::Head.new(operands),
+      plus: Factbase::Plus.new(operands),
+      minus: Factbase::Minus.new(operands),
+      times: Factbase::Times.new(operands),
+      div: Factbase::Div.new(operands),
+      zero: Factbase::Zero.new(operands),
+      eq: Factbase::Eq.new(operands),
+      lt: Factbase::Lt.new(operands),
+      lte: Factbase::Lte.new(operands),
+      gt: Factbase::Gt.new(operands),
+      gte: Factbase::Gte.new(operands),
+      always: Factbase::Always.new(operands),
+      never: Factbase::Never.new(operands),
+      not: Factbase::Not.new(operands),
+      or: Factbase::Or.new(operands),
+      and: Factbase::And.new(operands),
+      when: Factbase::When.new(operands),
+      either: Factbase::Either.new(operands),
+      count: Factbase::Count.new(operands),
+      first: Factbase::First.new(operands)
+    }
   end
 
   # Extend it with the module.
@@ -108,24 +173,35 @@ class Factbase::Term
   # should be evaluated. If no prediction can be made,
   # the same list is returned.
   # @param [Array<Hash>] maps Records to iterate, maybe
-  # @param [Hash] _params Params to use (keys must be strings, not symbols, with values as arrays)
+  # @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)
     m = :"#{@op}_predict"
-    if respond_to?(m)
+    if @terms.key?(@op)
+      t = @terms[@op]
+      if t.respond_to?(:predict)
+        t.predict(maps, fb, params)
+      else
+        maps
+      end
+    elsif respond_to?(m)
       send(m, maps, fb, params)
     else
       maps
     end
   end
 
-  # Does it match the fact?
+  # Evaluate term on a fact
   # @param [Factbase::Fact] fact The fact
   # @param [Array<Factbase::Fact>] maps All maps available
   # @param [Factbase] fb Factbase to use for sub-queries
-  # @return [Boolean] TRUE if matches
+  # @return [Object] The result of evaluation
   def evaluate(fact, maps, fb)
-    send(@op, fact, maps, fb)
+    if @terms.key?(@op)
+      @terms[@op].evaluate(fact, maps, fb)
+    else
+      send(@op, fact, maps, fb)
+    end
   rescue NoMethodError => e
     raise "Probably the term '#{@op}' is not defined at #{self}: #{e.message}"
   rescue StandardError => e
@@ -169,27 +245,6 @@ class Factbase::Term
     false
   end
 
-  # Turns it into a string.
-  # @return [String] The string of it
-  def to_s
-    @to_s ||=
-      begin
-        items = []
-        items << @op
-        items +=
-          @operands.map do |o|
-            if o.is_a?(String)
-              "'#{o.gsub("'", "\\\\'").gsub('"', '\\\\"')}'"
-            elsif o.is_a?(Time)
-              o.utc.iso8601
-            else
-              o.to_s
-            end
-          end
-        "(#{items.join(' ')})"
-      end
-  end
-
   def at(fact, maps, fb)
     assert_args(2)
     i = _values(0, fact, maps, fb)
@@ -200,40 +255,4 @@ class Factbase::Term
     return nil if v.nil?
     v[i]
   end
-
-  private
-
-  def assert_args(num)
-    c = @operands.size
-    raise "Too many (#{c}) operands for '#{@op}' (#{num} expected)" if c > num
-    raise "Too few (#{c}) operands for '#{@op}' (#{num} expected)" if c < num
-  end
-
-  def _by_symbol(pos, fact)
-    o = @operands[pos]
-    raise "A symbol expected at ##{pos}, but '#{o}' (#{o.class}) provided" unless o.is_a?(Symbol)
-    k = o.to_s
-    fact[k]
-  end
-
-  # @return [Array|nil] Either array of values or NIL
-  def _values(pos, fact, maps, fb)
-    v = @operands[pos]
-    v = v.evaluate(fact, maps, fb) if v.is_a?(Factbase::Term)
-    v = fact[v.to_s] if v.is_a?(Symbol)
-    return v if v.nil?
-    unless v.is_a?(Array)
-      v =
-        if v.respond_to?(:each)
-          v.to_a
-        else
-          [v]
-        end
-    end
-    raise 'Why not array?' unless v.is_a?(Array)
-    unless v.all? { |i| [Float, Integer, String, Time, TrueClass, FalseClass].any? { |t| i.is_a?(t) } }
-      raise 'Wrong type inside'
-    end
-    v
-  end
 end