redis-memo 0.0.0.beta → 0.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1316982523363ce87b0ada30b82b8200559a07b2f1a6bea54168b40b2afd397e
-  data.tar.gz: 1278e1ff6b7cc2275416c7af9b8668a13128c105a4cde74640deccd0a4380373
+  metadata.gz: 3e64eaaecf192519453c1accb0d10ca25ed2cf8274c10b6cb128a14e9a2e616e
+  data.tar.gz: fd98fce04f77660b8fc5960e491695504ef438394a882fb80d36b706038d10e5
 SHA512:
-  metadata.gz: 121069c8de985a8977234776ad15fd209c1c0db523c361a5caf9181ed7120533350af16c354d7f76dfc03168230248e37c64b37eb8ce9f6af16cfdc9160448f3
-  data.tar.gz: 133d18912a95eb599554b9cacb5c5932471772930165249381baaa8aeb403a3a6b21c6e17711a11eda56a1fa6dbf347396c7fe513cec3b53ec6f0c592d5b7d9a
+  metadata.gz: 20ca8f3efa4ca8591d073960c5fd5b9c8fbcd920b58ae6fe378ec3511af082c2cf964c72cda93739b6bef7294d5be9ceb77eb6000cb3df567f18b2bd581cf4c8
+  data.tar.gz: 1c485024e2eb3f541139bbd8f136279f5b1010b7b81ab30929d2e87a8917c4f0d8fb35d2ae39d94fd14d2f918b6476f53d589026f4412a8b118d6b2b6d732a93

data/lib/redis_memo.rb

@@ -5,7 +5,7 @@ require 'json'
 
 module RedisMemo
   require 'redis_memo/memoize_method'
-  require 'redis_memo/memoize_records'
+  require 'redis_memo/memoize_query'
 
   DefaultOptions = RedisMemo::Options.new
 

data/lib/redis_memo/memoizable/dependency.rb

@@ -16,7 +16,7 @@ class RedisMemo::Memoizable::Dependency
     if !memo_or_model.is_a?(RedisMemo::Memoizable)
       [
         memo_or_model.redis_memo_class_memoizable,
-        RedisMemo::MemoizeRecords.create_memo(memo_or_model, **conditions),
+        RedisMemo::MemoizeQuery.create_memo(memo_or_model, **conditions),
       ].each do |memo|
         nodes[memo.cache_key] = memo
       end

data/lib/redis_memo/memoize_method.rb

@@ -6,7 +6,7 @@ require_relative 'middleware'
 require_relative 'options'
 
 module RedisMemo::MemoizeMethod
-  def memoize_method(method_name, **options, &depends_on)
+  def memoize_method(method_name, method_id: nil, **options, &depends_on)
     method_name_without_memo = :"_redis_memo_#{method_name}_without_memo"
     method_name_with_memo = :"_redis_memo_#{method_name}_with_memo"
 
@@ -17,7 +17,14 @@ module RedisMemo::MemoizeMethod
 
       future = RedisMemo::Future.new(
         self,
-        RedisMemo::MemoizeMethod.method_id(self, method_name),
+        case method_id
+        when NilClass
+          RedisMemo::MemoizeMethod.method_id(self, method_name)
+        when String, Symbol
+          method_id
+        else
+          method_id.call(self, *args)
+        end,
         args,
         depends_on,
         options,

data/lib/redis_memo/memoize_query.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+require_relative 'memoize_method'
+
+if defined?(ActiveRecord)
+  # Hook into ActiveRecord to cache SQL queries and perform auto cache
+  # invalidation
+  module RedisMemo::MemoizeQuery
+    require_relative 'memoize_query/cached_select'
+    require_relative 'memoize_query/invalidation'
+    require_relative 'memoize_query/model_callback'
+
+    # Only editable columns will be used to create memos that are invalidatable
+    # after each record save
+    def memoize_table_column(*raw_columns, editable: true)
+      RedisMemo::MemoizeQuery.using_active_record!(self)
+      columns = raw_columns.map(&:to_sym).sort
+
+      RedisMemo::MemoizeQuery.memoized_columns(self, editable_only: true) << columns if editable
+      RedisMemo::MemoizeQuery.memoized_columns(self, editable_only: false) << columns
+
+      RedisMemo::MemoizeQuery::ModelCallback.install(self)
+      RedisMemo::MemoizeQuery::Invalidation.install(self)
+
+      if ENV['REDIS_MEMO_DISABLE_CACHED_SELECT'] != 'true'
+        RedisMemo::MemoizeQuery::CachedSelect.install(ActiveRecord::Base.connection)
+      end
+
+      # The code below might fail due to missing DB/table errors
+      columns.each do |column|
+        unless self.columns_hash.include?(column.to_s)
+          raise(
+            RedisMemo::ArgumentError,
+            "'#{self.name}' does not contain column '#{column}'",
+          )
+        end
+      end
+
+      unless ENV["REDIS_MEMO_DISABLE_QUERY_#{self.table_name.upcase}"] == 'true'
+        RedisMemo::MemoizeQuery::CachedSelect.enabled_models[self.table_name] = self
+      end
+    rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
+      # no-opts: models with memoize_table_column decleared might be loaded in
+      # rake tasks that are used to create databases
+    end
+
+    def self.using_active_record!(model_class)
+      unless model_class.respond_to?(:<) && model_class < ActiveRecord::Base
+        raise RedisMemo::ArgumentError, "'#{model_class.name}' does not use ActiveRecord"
+      end
+    end
+
+    @@memoized_columns = Hash.new { |h, k| h[k] = [Set.new, Set.new] }
+
+    def self.memoized_columns(model_or_table, editable_only: false)
+      table = model_or_table.is_a?(Class) ? model_or_table.table_name : model_or_table
+      @@memoized_columns[table.to_sym][editable_only ? 1 : 0]
+    end
+
+    # extra_props are considered as AND conditions on the model class
+    def self.create_memo(model_class, **extra_props)
+      using_active_record!(model_class)
+
+      keys = extra_props.keys.sort
+      if !keys.empty? && !memoized_columns(model_class).include?(keys)
+        raise(
+          RedisMemo::ArgumentError,
+          "'#{model_class.name}' has not memoized columns: #{keys}",
+        )
+      end
+
+      extra_props.each do |key, values|
+        # The data type is ensured by the database, thus we don't need to cast
+        # types here for better performance
+        column_name = key.to_s
+        values = [values] unless values.is_a?(Enumerable)
+        extra_props[key] =
+          if model_class.defined_enums.include?(column_name)
+            enum_mapping = model_class.defined_enums[column_name]
+            values.map do |value|
+              # Assume a value is a converted enum if it does not exist in the
+              # enum mapping
+              (enum_mapping[value.to_s] || value).to_s
+            end
+          else
+            values.map(&:to_s)
+          end
+      end
+
+      RedisMemo::Memoizable.new(
+        __redis_memo_memoize_query_model_class_name__: model_class.name,
+        **extra_props,
+      )
+    end
+
+    def self.invalidate_all(model_class)
+      RedisMemo::Tracer.trace(
+        'redis_memo.memoizable.invalidate_all',
+        model_class.name,
+      ) do
+        RedisMemo::Memoizable.invalidate([model_class.redis_memo_class_memoizable])
+      end
+    end
+
+    def self.invalidate(record)
+      # Invalidate memos with current values
+      memos_to_invalidate = memoized_columns(record.class).map do |columns|
+        props = {}
+        columns.each do |column|
+          props[column] = record.send(column)
+        end
+
+        create_memo(record.class, **props)
+      end
+
+      # Create memos with previous values if
+      #  - there are saved changes
+      #  - this is not creating a new record
+      if !record.saved_changes.empty? && !record.saved_changes.include?(record.class.primary_key)
+        previous_values = {}
+        record.saved_changes.each do |column, (previous_value, _)|
+          previous_values[column.to_sym] = previous_value
+        end
+
+        memoized_columns(record.class, editable_only: true).each do |columns|
+          props = previous_values.slice(*columns)
+          next if props.empty?
+
+          # Fill the column values that have not changed
+          columns.each do |column|
+            next if props.include?(column)
+
+            props[column] = record.send(column)
+          end
+
+          memos_to_invalidate << create_memo(record.class, **props)
+        end
+      end
+
+      RedisMemo::Memoizable.invalidate(memos_to_invalidate)
+    end
+  end
+end

data/lib/redis_memo/{memoize_records → memoize_query}/cached_select.rb

@@ -38,7 +38,7 @@
 # the `memoize_table_column` declaration on the model class.
 #
 #     class MyRecord < ApplicationRecord
-#       extend RedisMemo::MemoizeRecords
+#       extend RedisMemo::MemoizeQuery
 #       memoize_table_column :value
 #     end
 #
@@ -87,8 +87,17 @@
 #
 # See +extract_bind_params+ for the precise detection logic.
 #
-class RedisMemo::MemoizeRecords::CachedSelect
-  # TODO: merge this into RedisMemo::MemoizeQuery
+class RedisMemo::MemoizeQuery::CachedSelect
+  require_relative 'cached_select/bind_params'
+  require_relative 'cached_select/connection_adapter'
+  require_relative 'cached_select/statement_cache'
+
+  @@enabled_models = {}
+
+  def self.enabled_models
+    @@enabled_models
+  end
+
   def self.install(connection)
     klass = connection.class
     return if klass.singleton_class < RedisMemo::MemoizeMethod
@@ -96,8 +105,14 @@ class RedisMemo::MemoizeRecords::CachedSelect
     klass.class_eval do
       extend RedisMemo::MemoizeMethod
 
-      memoize_method :exec_query do |_, sql, name, binds, **kwargs|
-        RedisMemo::MemoizeRecords::CachedSelect
+      memoize_method(
+        :exec_query,
+        method_id: proc do |_, sql, *args|
+          sql.gsub(/(\$\d+)/, '?')      # $1 -> ?
+             .gsub(/((, *)*\?)+/, '?')  # (?, ?, ? ...) -> (?)
+        end,
+      ) do |_, sql, name, binds, **kwargs|
+        RedisMemo::MemoizeQuery::CachedSelect
           .current_query_bind_params
           .params
           .each do |model, attrs_set|
@@ -107,8 +122,8 @@ class RedisMemo::MemoizeRecords::CachedSelect
           end
 
         depends_on RedisMemo::Memoizable.new(
-          __redis_memo_memoize_records_memoize_query_sql__: sql,
-          __redis_memo_memoize_records_memoize_query_binds__: binds.map(&:value_for_database),
+          __redis_memo_memoize_query_memoize_query_sql__: sql,
+          __redis_memo_memoize_query_memoize_query_binds__: binds.map(&:value_for_database),
         )
       end
     end
@@ -137,64 +152,6 @@ class RedisMemo::MemoizeRecords::CachedSelect
     end
   end
 
-  module ConnectionAdapter
-    def cacheable_query(*args)
-      query, binds = super(*args)
-
-      # Persist the arel object to StatementCache#execute
-      query.instance_variable_set(:@__redis_memo_memoize_records_memoize_query_arel, args.last)
-
-      [query, binds]
-    end
-
-    def exec_query(*args)
-      # An Arel AST in Thread local is set prior to supported query methods
-      if !RedisMemo.without_memo? &&
-          RedisMemo::MemoizeRecords::CachedSelect.extract_bind_params(args[0])
-        # [Reids $model Load] $sql $binds
-        RedisMemo::DefaultOptions.logger&.info(
-          "[Redis] \u001b[36;1m#{args[1]} \u001b[34;1m#{args[0]}\u001b[0m #{
-            args[2].map { |bind| [bind.name, bind.value_for_database]}
-          }"
-        )
-
-        RedisMemo::Tracer.trace(
-          'redis_memo.memoize_query',
-          args[0]
-            .gsub(/(\$\d+)/, '?') # $1 -> ?
-            .gsub(/((, *)*\?)+/, '?'), # (?, ?, ? ...) -> (?)
-        ) do
-          super(*args)
-        end
-      else
-        RedisMemo.without_memo { super(*args) }
-      end
-    end
-
-    def select_all(*args)
-      if args[0].is_a?(Arel::SelectManager)
-        RedisMemo::MemoizeRecords::CachedSelect.current_query = args[0]
-      end
-
-      super(*args)
-    ensure
-      RedisMemo::MemoizeRecords::CachedSelect.reset_current_query
-    end
-  end
-
-  module StatementCache
-    def execute(*args)
-      arel = query_builder.instance_variable_get(:@__redis_memo_memoize_records_memoize_query_arel)
-      RedisMemo::MemoizeRecords::CachedSelect.current_query = arel
-      RedisMemo::MemoizeRecords::CachedSelect.current_substitutes =
-        bind_map.map_substitutes(args[0])
-
-      super(*args)
-    ensure
-      RedisMemo::MemoizeRecords::CachedSelect.reset_current_query
-    end
-  end
-
   def self.extract_bind_params(sql)
     ast = Thread.current[THREAD_KEY_AREL]&.ast
     return false unless ast.is_a?(Arel::Nodes::SelectStatement)
@@ -255,16 +212,8 @@ class RedisMemo::MemoizeRecords::CachedSelect
           return
         end
 
-      type_caster = table_node.send(:type_caster)
-      binding_relation =
-        case type_caster
-        when ActiveRecord::TypeCaster::Map
-          type_caster.send(:types)
-        when ActiveRecord::TypeCaster::Connection
-          type_caster.instance_variable_get(:@klass)
-        else
-          return
-        end
+      binding_relation = extract_binding_relation(table_node)
+      return unless binding_relation
 
       rights = node.right.is_a?(Array) ? node.right : [node.right]
       substitutes = Thread.current[THREAD_KEY_SUBSTITUTES]
@@ -303,11 +252,17 @@ class RedisMemo::MemoizeRecords::CachedSelect
       return unless node.orders.empty?
 
       node.cores.each do |core|
+        # We don't support JOINs
+        return unless core.source.right.empty?
+
         # Should have a WHERE if directly selecting from a table
         source_node = core.source.left
+        binding_relation = nil
         case source_node
         when Arel::Table
-          return if core.wheres.empty?
+          binding_relation = extract_binding_relation(source_node)
+
+          return if core.wheres.empty? || binding_relation.nil?
         when Arel::Nodes::TableAlias
           bind_params = bind_params.union(
             extract_bind_params_recurse(source_node.left)
@@ -334,6 +289,9 @@ class RedisMemo::MemoizeRecords::CachedSelect
 
           return unless bind_params
         end
+
+        # Reject any unbound select queries
+        return if binding_relation && bind_params.params[binding_relation].empty?
       end
 
       bind_params
@@ -352,7 +310,7 @@ class RedisMemo::MemoizeRecords::CachedSelect
       end
 
       bind_params
-    when Arel::Nodes::Join, Arel::Nodes::Union, Arel::Nodes::Or
+    when Arel::Nodes::Union, Arel::Nodes::Or
       [node.left, node.right].each do |child|
         bind_params = bind_params.union(
           extract_bind_params_recurse(child)
@@ -368,132 +326,12 @@ class RedisMemo::MemoizeRecords::CachedSelect
     end
   end
 
-  class BindParams
-    def params
-      #
-      # Bind params is hash of sets: each key is a model class, each value is a
-      # set of hashes for memoized column conditions. Example:
-      #
-      #   {
-      #      Site => [
-      #        {name: 'a', city: 'b'},
-      #        {name: 'a', city: 'c'},
-      #        {name: 'b', city: 'b'},
-      #        {name: 'b', city: 'c'},
-      #      ],
-      #   }
-      #
-      @params ||= Hash.new do |models, model|
-        models[model] = []
-      end
-    end
-
-    def union(other)
-      return unless other
-
-      # The tree is almost always right-heavy. Merge into the right node for better
-      # performance.
-      other.params.merge!(params) do |_, other_attrs_set, attrs_set|
-        if other_attrs_set.empty?
-          attrs_set
-        elsif attrs_set.empty?
-          other_attrs_set
-        else
-          attrs_set + other_attrs_set
-        end
-      end
-
-      other
-    end
-
-    def product(other)
-      #  Example:
-      #
-      #  and(
-      #    [{a: 1}, {a: 2}],
-      #    [{b: 1}, {b: 2}],
-      #  )
-      #
-      #  =>
-      #
-      #  [
-      #    {a: 1, b: 1},
-      #    {a: 1, b: 2},
-      #    {a: 2, b: 1},
-      #    {a: 2, b: 2},
-      #  ]
-      return unless other
-
-      # The tree is almost always right-heavy. Merge into the right node for better
-      # performance.
-      params.each do |model, attrs_set|
-        next if attrs_set.empty?
-
-        # The other model does not have any conditions so far: carry the
-        # attributes over to the other node
-        if other.params[model].empty?
-          other.params[model] = attrs_set
-          next
-        end
-
-        # Distribute the current attrs into the other
-        other_attrs_set_size = other.params[model].size
-        other_attrs_set = other.params[model]
-        merged_attrs_set = Array.new(other_attrs_set_size * attrs_set.size)
-
-        attrs_set.each_with_index do |attrs, i|
-          other_attrs_set.each_with_index do |other_attrs, j|
-            k = i * other_attrs_set_size + j
-            merged_attrs = merged_attrs_set[k] = other_attrs.dup
-            attrs.each do |name, val|
-              # Conflict detected. For example:
-              #
-              #   (a = 1 or b = 1) and (a = 2 or b = 2)
-              #
-              #  Keep:     a = 1 and b = 2, a = 2 and b = 1
-              #  Discard:  a = 1 and a = 2, b = 1 and b = 2
-              if merged_attrs.include?(name) && merged_attrs[name] != val
-                merged_attrs_set[k] = nil
-                break
-              end
-
-              merged_attrs[name] = val
-            end
-          end
-        end
-
-        merged_attrs_set.compact!
-        other.params[model] = merged_attrs_set
-      end
-
-      other
-    end
-
-    def uniq!
-      params.each do |_, attrs_set|
-        attrs_set.uniq!
-      end
-    end
-
-    def memoizable?
-      return false if params.empty?
-
-      params.each do |model, attrs_set|
-        return false if attrs_set.empty?
-
-        attrs_set.each do |attrs|
-          return false unless RedisMemo::MemoizeRecords
-            .memoized_columns(model)
-            .include?(attrs.keys.sort)
-        end
-      end
-
-      true
-    end
+  def self.extract_binding_relation(table_node)
+    enabled_models[table_node.try(:name)]
   end
 
   # Thread locals to exchange information between RedisMemo and ActiveRecord
-  THREAD_KEY_AREL = :__redis_memo_memoize_records_cached_select_arel__
-  THREAD_KEY_SUBSTITUTES = :__redis_memo_memoize_records_cached_select_substitues__
-  THREAD_KEY_AREL_BIND_PARAMS = :__redis_memo_memoize_records_cached_select_arel_bind_params__
+  THREAD_KEY_AREL = :__redis_memo_memoize_query_cached_select_arel__
+  THREAD_KEY_SUBSTITUTES = :__redis_memo_memoize_query_cached_select_substitues__
+  THREAD_KEY_AREL_BIND_PARAMS = :__redis_memo_memoize_query_cached_select_arel_bind_params__
 end

data/lib/redis_memo/memoize_query/cached_select/bind_params.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+class RedisMemo::MemoizeQuery::CachedSelect
+  class BindParams
+    def params
+      #
+      # Bind params is hash of sets: each key is a model class, each value is a
+      # set of hashes for memoized column conditions. Example:
+      #
+      #   {
+      #      Site => [
+      #        {name: 'a', city: 'b'},
+      #        {name: 'a', city: 'c'},
+      #        {name: 'b', city: 'b'},
+      #        {name: 'b', city: 'c'},
+      #      ],
+      #   }
+      #
+      @params ||= Hash.new do |models, model|
+        models[model] = []
+      end
+    end
+
+    def union(other)
+      return unless other
+
+      # The tree is almost always right-heavy. Merge into the right node for better
+      # performance.
+      other.params.merge!(params) do |_, other_attrs_set, attrs_set|
+        if other_attrs_set.empty?
+          attrs_set
+        elsif attrs_set.empty?
+          other_attrs_set
+        else
+          attrs_set + other_attrs_set
+        end
+      end
+
+      other
+    end
+
+    def product(other)
+      #  Example:
+      #
+      #  and(
+      #    [{a: 1}, {a: 2}],
+      #    [{b: 1}, {b: 2}],
+      #  )
+      #
+      #  =>
+      #
+      #  [
+      #    {a: 1, b: 1},
+      #    {a: 1, b: 2},
+      #    {a: 2, b: 1},
+      #    {a: 2, b: 2},
+      #  ]
+      return unless other
+
+      # The tree is almost always right-heavy. Merge into the right node for better
+      # performance.
+      params.each do |model, attrs_set|
+        next if attrs_set.empty?
+
+        # The other model does not have any conditions so far: carry the
+        # attributes over to the other node
+        if other.params[model].empty?
+          other.params[model] = attrs_set
+          next
+        end
+
+        # Distribute the current attrs into the other
+        other_attrs_set_size = other.params[model].size
+        other_attrs_set = other.params[model]
+        merged_attrs_set = Array.new(other_attrs_set_size * attrs_set.size)
+
+        attrs_set.each_with_index do |attrs, i|
+          other_attrs_set.each_with_index do |other_attrs, j|
+            k = i * other_attrs_set_size + j
+            merged_attrs = merged_attrs_set[k] = other_attrs.dup
+            attrs.each do |name, val|
+              # Conflict detected. For example:
+              #
+              #   (a = 1 or b = 1) and (a = 2 or b = 2)
+              #
+              #  Keep:     a = 1 and b = 2, a = 2 and b = 1
+              #  Discard:  a = 1 and a = 2, b = 1 and b = 2
+              if merged_attrs.include?(name) && merged_attrs[name] != val
+                merged_attrs_set[k] = nil
+                break
+              end
+
+              merged_attrs[name] = val
+            end
+          end
+        end
+
+        merged_attrs_set.compact!
+        other.params[model] = merged_attrs_set
+      end
+
+      other
+    end
+
+    def uniq!
+      params.each do |_, attrs_set|
+        attrs_set.uniq!
+      end
+    end
+
+    def memoizable?
+      return false if params.empty?
+
+      params.each do |model, attrs_set|
+        return false if attrs_set.empty?
+
+        attrs_set.each do |attrs|
+          return false unless RedisMemo::MemoizeQuery
+            .memoized_columns(model)
+            .include?(attrs.keys.sort)
+        end
+      end
+
+      true
+    end
+  end
+end

data/lib/redis_memo/memoize_query/cached_select/connection_adapter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class RedisMemo::MemoizeQuery::CachedSelect
+  module ConnectionAdapter
+    def cacheable_query(*args)
+      query, binds = super(*args)
+
+      # Persist the arel object to StatementCache#execute
+      query.instance_variable_set(:@__redis_memo_memoize_query_memoize_query_arel, args.last)
+
+      [query, binds]
+    end
+
+    def exec_query(*args)
+      # An Arel AST in Thread local is set prior to supported query methods
+      if !RedisMemo.without_memo? &&
+          RedisMemo::MemoizeQuery::CachedSelect.extract_bind_params(args[0])
+        # [Reids $model Load] $sql $binds
+        RedisMemo::DefaultOptions.logger&.info(
+          "[Redis] \u001b[36;1m#{args[1]} \u001b[34;1m#{args[0]}\u001b[0m #{
+            args[2].map { |bind| [bind.name, bind.value_for_database]}
+          }"
+        )
+
+        super(*args)
+      else
+        RedisMemo.without_memo { super(*args) }
+      end
+    end
+
+    def select_all(*args)
+      if args[0].is_a?(Arel::SelectManager)
+        RedisMemo::MemoizeQuery::CachedSelect.current_query = args[0]
+      end
+
+      super(*args)
+    ensure
+      RedisMemo::MemoizeQuery::CachedSelect.reset_current_query
+    end
+  end
+end

data/lib/redis_memo/memoize_query/cached_select/statement_cache.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class RedisMemo::MemoizeQuery::CachedSelect
+  module StatementCache
+    def execute(*args)
+      arel = query_builder.instance_variable_get(:@__redis_memo_memoize_query_memoize_query_arel)
+      RedisMemo::MemoizeQuery::CachedSelect.current_query = arel
+      RedisMemo::MemoizeQuery::CachedSelect.current_substitutes =
+        bind_map.map_substitutes(args[0])
+
+      super(*args)
+    ensure
+      RedisMemo::MemoizeQuery::CachedSelect.reset_current_query
+    end
+  end
+end

data/lib/redis_memo/{memoize_records → memoize_query}/invalidation.rb

@@ -1,15 +1,20 @@
 # frozen_string_literal: true
 
-class RedisMemo::MemoizeRecords::Invalidation
+#
+# Automatically invalidate memoizable when modifying ActiveRecords objects.
+# You still need to invalidate memos when you are using SQL queries to perform
+# update / delete (does not trigger record callbacks)
+#
+class RedisMemo::MemoizeQuery::Invalidation
   def self.install(model_class)
-    var_name = :@@__redis_memo_memoize_records_invalidation_installed__
+    var_name = :@@__redis_memo_memoize_query_invalidation_installed__
     return if model_class.class_variable_defined?(var_name)
 
     model_class.class_eval do
       # A memory-persistent memoizable used for invalidating all queries of a
       # particular model
       def self.redis_memo_class_memoizable
-        @redis_memo_class_memoizable ||= RedisMemo::MemoizeRecords.create_memo(self)
+        @redis_memo_class_memoizable ||= RedisMemo::MemoizeQuery.create_memo(self)
       end
 
       %i(delete decrement! increment!).each do |method_name|
@@ -18,7 +23,7 @@ class RedisMemo::MemoizeRecords::Invalidation
         define_method method_name do |*args|
           result = send(:"without_redis_memo_invalidation_#{method_name}", *args)
 
-          RedisMemo::MemoizeRecords.invalidate(self)
+          RedisMemo::MemoizeQuery.invalidate(self)
 
           result
         end
@@ -77,7 +82,7 @@ class RedisMemo::MemoizeRecords::Invalidation
 
       define_method method_name do |*args|
         result = send(:"#{method_name}_without_redis_memo_invalidation", *args)
-        RedisMemo::MemoizeRecords.invalidate_all(model_class)
+        RedisMemo::MemoizeQuery.invalidate_all(model_class)
         result
       end
     end

data/lib/redis_memo/memoize_query/memoize_table_column.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+require_relative 'memoize_method'
+
+module RedisMemo::MemoizeQuery
+end

data/lib/redis_memo/{memoize_records → memoize_query}/model_callback.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class RedisMemo::MemoizeRecords::ModelCallback
+class RedisMemo::MemoizeQuery::ModelCallback
   def self.install(model_class)
     var_name = :@@__redis_memo_memoize_record_after_save_callback_installed__
     return if model_class.class_variable_defined?(var_name)
@@ -12,10 +12,10 @@ class RedisMemo::MemoizeRecords::ModelCallback
   end
 
   def after_save(record)
-    RedisMemo::MemoizeRecords.invalidate(record)
+    RedisMemo::MemoizeQuery.invalidate(record)
   end
 
   def after_destroy(record)
-    RedisMemo::MemoizeRecords.invalidate(record)
+    RedisMemo::MemoizeQuery.invalidate(record)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-memo
 version: !ruby/object:Gem::Version
-  version: 0.0.0.beta
+  version: 0.0.0.beta.1
 platform: ruby
 authors:
 - Chan Zuckerberg Initiative
@@ -152,11 +152,14 @@ files:
 - lib/redis_memo/memoizable/dependency.rb
 - lib/redis_memo/memoizable/invalidation.rb
 - lib/redis_memo/memoize_method.rb
-- lib/redis_memo/memoize_method.rbi
-- lib/redis_memo/memoize_records.rb
-- lib/redis_memo/memoize_records/cached_select.rb
-- lib/redis_memo/memoize_records/invalidation.rb
-- lib/redis_memo/memoize_records/model_callback.rb
+- lib/redis_memo/memoize_query.rb
+- lib/redis_memo/memoize_query/cached_select.rb
+- lib/redis_memo/memoize_query/cached_select/bind_params.rb
+- lib/redis_memo/memoize_query/cached_select/connection_adapter.rb
+- lib/redis_memo/memoize_query/cached_select/statement_cache.rb
+- lib/redis_memo/memoize_query/invalidation.rb
+- lib/redis_memo/memoize_query/memoize_table_column.rb
+- lib/redis_memo/memoize_query/model_callback.rb
 - lib/redis_memo/middleware.rb
 - lib/redis_memo/options.rb
 - lib/redis_memo/redis.rb

data/lib/redis_memo/memoize_method.rbi

@@ -1,10 +0,0 @@
-# typed: true
-
-module RedisMemo::MemoizeMethod
-  include Kernel
-
-  def class; end
-  def name; end
-  def alias_method(*); end
-  def define_method(*); end
-end

data/lib/redis_memo/memoize_records.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-require_relative 'memoize_method'
-
-#
-# Automatically invalidate memoizable when modifying ActiveRecords objects.
-# You still need to invalidate memos when you are using SQL queries to perform
-# update / delete (does not trigger record callbacks)
-#
-module RedisMemo::MemoizeRecords
-  require_relative 'memoize_records/cached_select'
-  require_relative 'memoize_records/invalidation'
-  require_relative 'memoize_records/model_callback'
-
-  # TODO: MemoizeRecords -> MemoizeQuery
-  def memoize_records
-    RedisMemo::MemoizeRecords.using_active_record!(self)
-
-    memoize_table_column(primary_key.to_sym, editable: false)
-  end
-
-  # Only editable columns will be used to create memos that are invalidatable
-  # after each record save
-  def memoize_table_column(*raw_columns, editable: true)
-    RedisMemo::MemoizeRecords.using_active_record!(self)
-
-    columns = raw_columns.map(&:to_sym).sort
-
-    RedisMemo::MemoizeRecords.memoized_columns(self, editable_only: true) << columns if editable
-    RedisMemo::MemoizeRecords.memoized_columns(self, editable_only: false) << columns
-
-    RedisMemo::MemoizeRecords::ModelCallback.install(self)
-    RedisMemo::MemoizeRecords::Invalidation.install(self)
-
-    if ENV['REDIS_MEMO_DISABLE_CACHED_SELECT'] != 'true'
-      RedisMemo::MemoizeRecords::CachedSelect.install(ActiveRecord::Base.connection)
-    end
-
-    columns.each do |column|
-      unless self.columns_hash.include?(column.to_s)
-        raise(
-          RedisMemo::ArgumentError,
-          "'#{self.name}' does not contain column '#{column}'",
-        )
-      end
-    end
-  rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
-    # no-opts: models with memoize_table_column decleared might be loaded in
-    # rake tasks that are used to create databases
-  end
-
-  def self.using_active_record!(model_class)
-    unless model_class.respond_to?(:<) && model_class < ActiveRecord::Base
-      raise RedisMemo::ArgumentError, "'#{model_class.name}' does not use ActiveRecord"
-    end
-  end
-
-  @@memoized_columns = Hash.new { |h, k| h[k] = [Set.new, Set.new] }
-
-  def self.memoized_columns(model_or_table, editable_only: false)
-    table = model_or_table.is_a?(Class) ? model_or_table.table_name : model_or_table
-    @@memoized_columns[table.to_sym][editable_only ? 1 : 0]
-  end
-
-  # extra_props are considered as AND conditions on the model class
-  def self.create_memo(model_class, **extra_props)
-    RedisMemo::MemoizeRecords.using_active_record!(model_class)
-
-    keys = extra_props.keys.sort
-    if !keys.empty? && !RedisMemo::MemoizeRecords.memoized_columns(model_class).include?(keys)
-      raise(
-        RedisMemo::ArgumentError,
-        "'#{model_class.name}' has not memoized columns: #{keys}",
-      )
-    end
-
-    extra_props.each do |key, values|
-      # The data type is ensured by the database, thus we don't need to cast
-      # types here for better performance
-      column_name = key.to_s
-      values = [values] unless values.is_a?(Enumerable)
-      extra_props[key] =
-        if model_class.defined_enums.include?(column_name)
-          enum_mapping = model_class.defined_enums[column_name]
-          values.map do |value|
-            # Assume a value is a converted enum if it does not exist in the
-            # enum mapping
-            (enum_mapping[value.to_s] || value).to_s
-          end
-        else
-          values.map(&:to_s)
-        end
-    end
-
-    RedisMemo::Memoizable.new(
-      __redis_memo_memoize_records_model_class_name__: model_class.name,
-      **extra_props,
-    )
-  end
-
-  def self.invalidate_all(model_class)
-    RedisMemo::Tracer.trace(
-      'redis_memo.memoizable.invalidate_all',
-      model_class.name,
-    ) do
-      RedisMemo::Memoizable.invalidate([model_class.redis_memo_class_memoizable])
-    end
-  end
-
-  def self.invalidate(record)
-    # Invalidate memos with current values
-    memos_to_invalidate = memoized_columns(record.class).map do |columns|
-      props = {}
-      columns.each do |column|
-        props[column] = record.send(column)
-      end
-
-      RedisMemo::MemoizeRecords.create_memo(record.class, **props)
-    end
-
-    # Create memos with previous values if
-    #  - there are saved changes
-    #  - this is not creating a new record
-    if !record.saved_changes.empty? && !record.saved_changes.include?(record.class.primary_key)
-      previous_values = {}
-      record.saved_changes.each do |column, (previous_value, _)|
-        previous_values[column.to_sym] = previous_value
-      end
-
-      memoized_columns(record.class, editable_only: true).each do |columns|
-        props = previous_values.slice(*columns)
-        next if props.empty?
-
-        # Fill the column values that have not changed
-        columns.each do |column|
-          next if props.include?(column)
-
-          props[column] = record.send(column)
-        end
-
-        memos_to_invalidate << RedisMemo::MemoizeRecords.create_memo(record.class, **props)
-      end
-    end
-
-    RedisMemo::Memoizable.invalidate(memos_to_invalidate)
-  end
-end