#192: cache works

Author: yegor256

Rakefile

@@ -46,8 +46,8 @@ task :benchmark do
   fb = Factbase.new
   require_relative 'lib/factbase/cached/cached_factbase'
   fb = Factbase::CachedFactbase.new(fb)
-  require_relative 'lib/factbase/indexed/indexed_factbase'
-  fb = Factbase::IndexedFactbase.new(fb)
+  # require_relative 'lib/factbase/indexed/indexed_factbase'
+  # fb = Factbase::IndexedFactbase.new(fb)
   require_relative 'lib/factbase/sync/sync_factbase'
   fb = Factbase::SyncFactbase.new(fb)
   require 'benchmark'

lib/factbase.rb

@@ -135,11 +135,19 @@ def insert
   # @param [Array<Hash>|nil] maps The subset of maps (if provided)
   def query(term, maps = nil)
     maps ||= @maps
+    term = to_term(term) if term.is_a?(String)
     require_relative 'factbase/query'
-    term = Factbase::Syntax.new(term).to_term(self) if term.is_a?(String)
     Factbase::Query.new(maps, term)
   end
 
+  # Convert a query to a term.
+  # @param [String] query The query to convert
+  # @return [Factbase::Term] The term
+  def to_term(query)
+    require_relative 'factbase/syntax'
+    Factbase::Syntax.new(query).to_term(self)
+  end
+
   # Run an ACID transaction, which will either modify the factbase
   # or rollback in case of an error.
   #

lib/factbase/cached/cached_factbase.rb

@@ -31,14 +31,22 @@ def insert
     Factbase::CachedFact.new(@origin.insert, @cache)
   end
 
+  # Convert a query to a term.
+  # @param [String] query The query to convert
+  # @return [Factbase::Term] The term
+  def to_term(query)
+    require_relative 'cached_term'
+    @origin.to_term(query).redress(Factbase::CachedTerm, cache: @cache)
+  end
+
   # Create a query capable of iterating.
   # @param [String] term The term to use
   # @param [Array<Hash>] maps Possible maps to use
   def query(term, maps = nil)
-    require_relative 'cached_term'
     if term.is_a?(String)
-      term = Factbase::Syntax.new(term, term: Factbase::CachedTerm).to_term(self)
-      term.inject_cache(@cache)
+      term = to_term(term)
+    else
+      term = term.redress(Factbase::CachedTerm)
     end
     q = @origin.query(term, maps)
     unless term.abstract?

lib/factbase/cached/cached_term.rb

@@ -15,19 +15,10 @@ class Factbase::CachedTerm < Factbase::Term
   # @param [Symbol] operator Operator
   # @param [Array] operands Operands
   # @param [Factbase] fb Optional factbase reference
-  def initialize(operator, operands, fb: nil)
-    super
-    @cacheable = static? && !abstract?
-  end
-
-  # Inject cache into this term and all others inside.
-  # @param [Hash] cache The cache
-  def inject_cache(cache)
+  def initialize(operator, operands, fb: nil, cache: {})
+    super(operator, operands, fb: fb)
     @cache = cache
-    @operands.each do |o|
-      next unless o.is_a?(Factbase::CachedTerm)
-      o.inject_cache(cache)
-    end
+    @cacheable = static? && !abstract?
   end
 
   # Does it match the fact?

lib/factbase/indexed/indexed_factbase.rb

@@ -31,11 +31,18 @@ def insert
     Factbase::IndexedFact.new(@origin.insert, @idx)
   end
 
+  # Convert a query to a term.
+  # @param [String] query The query to convert
+  # @return [Factbase::Term] The term
+  def to_term(query)
+    @origin.to_term(query)
+  end
+
   # Create a query capable of iterating.
   # @param [String] term The term to use
   # @param [Array<Hash>] maps Possible maps to use
   def query(term, maps = nil)
-    term = Factbase::Syntax.new(term).to_term(self) if term.is_a?(String)
+    term = to_term(term) if term.is_a?(String)
     require_relative 'indexed_query'
     Factbase::IndexedQuery.new(@origin.query(term, maps), @idx)
   end

lib/factbase/light.rb

@@ -23,6 +23,10 @@ def insert
     @fb.insert
   end
 
+  def to_term(query)
+    @fb.to_term(query)
+  end
+
   def query(query, maps = nil)
     @fb.query(query, maps)
   end

lib/factbase/sync/sync_factbase.rb

@@ -30,11 +30,18 @@ def insert
     end
   end
 
+  # Convert a query to a term.
+  # @param [String] query The query to convert
+  # @return [Factbase::Term] The term
+  def to_term(query)
+    @origin.to_term(query)
+  end
+
   # Create a query capable of iterating.
   # @param [String] term The query to use for selections
   # @param [Array<Hash>] maps Possible maps to use
   def query(term, maps = nil)
-    term = Factbase::Syntax.new(term).to_term(@origin) if term.is_a?(String)
+    term = to_term(term) if term.is_a?(String)
     @mutex.synchronize do
       require_relative 'sync_query'
       Factbase::SyncQuery.new(@origin.query(term, maps), @mutex)

lib/factbase/syntax.rb

@@ -9,20 +9,10 @@
 require_relative 'fact'
 require_relative 'term'
 
-# Syntax.
+# Syntax parser.
 #
 # This is an internal class, it is not supposed to be instantiated directly.
 #
-# However, you can use it directly, if you need a parser of our syntax. You can
-# create your own "Term" class and let this parser make instances of it for
-# every term it meets in the query:
-#
-#  require 'factbase/syntax'
-#  t = Factbase::Syntax.new('(hello world)', MyTerm).to_term
-#
-# The +MyTerm+ class should have a constructor with two arguments:
-# the operator and the list of operands (Array).
-#
 # Author:: Yegor Bugayenko ([email protected])
 # Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
@@ -37,12 +27,8 @@ class Broken < StandardError; end
   # a child of +Factbase::Term+.
   #
   # @param [String] query The query, for example "(eq id 42)"
-  # @param [Class] term The class to instantiate to make every term
-  def initialize(query, term: Factbase::Term)
+  def initialize(query)
     @query = query
-    raise "Term must be a Class, while #{term.class.name} provided" unless term.is_a?(Class)
-    raise "The 'term' must be a child of Factbase::Term, while #{term.name} provided" unless term <= Factbase::Term
-    @term = term
   end
 
   # Convert it to a term.
@@ -73,7 +59,7 @@ def build(fb)
     raise "Too many terms (#{@ast[1]} != #{@tokens.size})" if @ast[1] != @tokens.size
     t = @ast[0]
     raise 'No terms found in the AST' if t.nil?
-    raise "#{t.class.name} is not an instance of #{@term}, thus not a proper term" unless t.is_a?(@term)
+    raise "#{t.class.name} is not an instance of Term" unless t.is_a?(Factbase::Term)
     t
   end
 
@@ -107,7 +93,7 @@ def to_ast(tokens, at, fb)
       operands << operand
       break if tokens[at] == :close
     end
-    t = @term.new(op, operands, fb:)
+    t = Factbase::Term.new(op, operands, fb:)
     [t, at + 1]
   end
 

lib/factbase/term.rb

@@ -87,6 +87,21 @@ def initialize(operator, operands, fb: Factbase.new)
     @fb = fb
   end
 
+  def redress(type, **args)
+    type.new(
+      @op, 
+      @operands.map do |op| 
+        if op.is_a?(Factbase::Term)
+          op.redress(type, **args) 
+        else
+          op
+        end
+      end, 
+      fb: @fb, 
+      **args
+    )
+  end
+
   # Does it match the fact?
   # @param [Factbase::Fact] fact The fact
   # @param [Array<Factbase::Fact>] maps All maps available

test/factbase/cached/test_cached_query.rb

@@ -31,6 +31,16 @@ def test_aggregates_too
     assert_equal(1, fb.query('(eq foo (agg (exists hello) (min foo)))').each.to_a.size)
   end
 
+  def test_caches_while_being_decorated
+    fb = Factbase::SyncFactbase.new(Factbase::CachedFactbase.new(Factbase.new))
+    10_000.times do |i|
+      f = fb.insert
+      f.foo = i
+      f.hello = 1
+    end
+    assert_equal(1, fb.query('(eq foo (agg (exists hello) (min foo)))').each.to_a.size)
+  end
+
   def test_deletes_too
     fb = Factbase::CachedFactbase.new(Factbase.new)
     fb.insert.foo = 1

test/test_factbase.rb

@@ -41,6 +41,12 @@ def test_query_many_times
     end
   end
 
+  def test_converts_query_to_term
+    fb = Factbase.new
+    term = fb.to_term('(eq foo 42)')
+    assert_equal('(eq foo 42)', term.to_s)
+  end
+
   def test_simple_setting
     fb = Factbase.new
     fb.insert