ar_cache 1.2.0 → 2.1.0

data/ar_cache.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'activerecord', '>= 6.1', '< 7'
+  spec.add_runtime_dependency 'oj', '>= 3', '< 4'
 
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html

data/lib/ar_cache.rb

@@ -2,11 +2,10 @@
 
 require 'active_support/cache'
 require 'active_record'
+require 'oj'
 
 require 'ar_cache/version'
 require 'ar_cache/configuration'
-require 'ar_cache/record'
-require 'ar_cache/store'
 require 'ar_cache/marshal'
 require 'ar_cache/table'
 require 'ar_cache/mock_table'
@@ -18,31 +17,65 @@ require 'ar_cache/active_record'
 require_relative './generators/ar_cache/install_generator' if defined?(Rails)
 
 module ArCache
-  PRELOADER = ::ActiveRecord::Associations::Preloader.new
+  PLACEHOLDER = ''
+
+  @cache_reflection = {}
 
   class << self
-    delegate :configure, to: Configuration
+    delegate :configure, :memcached?, :redis?, :cache_store, to: ArCache::Configuration
+    delegate :read, :read_multi, :write, :write_multi, :delete, :delete_multi, :exist?, :clear, to: :cache_store
+
+    def skip_cache?
+      Thread.current[:ar_cache_skip_cache]
+    end
+
+    def skip_cache
+      return yield if skip_cache?
+
+      begin
+        Thread.current[:ar_cache_skip_cache] = true
+        yield
+      ensure
+        Thread.current[:ar_cache_skip_cache] = false
+      end
+    end
 
-    def skip?
-      Thread.current[:ar_cache_skip]
+    def skip_expire?
+      Thread.current[:ar_cache_skip_expire]
     end
 
-    def skip
-      Thread.current[:ar_cache_skip] = true
-      yield
-    ensure
-      Thread.current[:ar_cache_skip] = false
+    def skip_expire
+      return yield if skip_expire?
+
+      begin
+        Thread.current[:ar_cache_skip_expire] = true
+        yield
+      ensure
+        Thread.current[:ar_cache_skip_expire] = false
+      end
+    end
+
+    def cache_reflection?(reflection)
+      @cache_reflection.fetch(reflection) do
+        Thread.current[:ar_cache_reflection] = true
+        @cache_reflection[reflection] = yield
+      ensure
+        Thread.current[:ar_cache_reflection] = false
+      end
     end
 
-    def expire?
-      Thread.current[:ar_cache_expire]
+    def dump_attributes(attributes)
+      memcached? || redis? ? Oj.dump(attributes) : attributes
     end
 
-    def expire
-      Thread.current[:ar_cache_expire] = true
-      yield
-    ensure
-      Thread.current[:ar_cache_expire] = false
+    def load_attributes(attributes)
+      memcached? || redis? ? Oj.load(attributes) : attributes
+    end
+
+    def lock_key(key)
+      ArCache.write(key, PLACEHOLDER, raw: true, expires_in: 1.hour)
     end
   end
 end
+
+require_relative './generators/ar_cache/templates/configuration'

data/lib/ar_cache/active_record/associations/association.rb

@@ -5,7 +5,7 @@ module ArCache
     module Associations
       module Association
         def reload(...)
-          loaded? ? ArCache.skip { super } : super
+          loaded? ? ArCache.skip_cache { super } : super
         end
       end
     end

data/lib/ar_cache/active_record/associations/has_one_through_association.rb

@@ -4,19 +4,21 @@ module ArCache
   module ActiveRecord
     module Associations
       module HasOneThroughAssociation
-        private def find_target # rubocop:disable Metrics/CyclomaticComplexity
-          return super if ArCache.skip?
-          return super if reflection.klass.ar_cache_table.disabled?
-          return super if reflection.through_reflection.klass.ar_cache_table.disabled?
+        PRELOADER = ::ActiveRecord::Associations::Preloader.new
+
+        private def find_target
+          return super if ArCache.skip_cache?
+          return super unless ArCache.cache_reflection?(reflection) do
+            ArCache::Query.new(owner.association(through_reflection.name).scope).exec_queries_cacheable? &&
+            ArCache::Query.new(source_reflection.active_record.new.association(source_reflection.name).scope).exec_queries_cacheable? # rubocop:disable Layout/LineLength
+          end
 
           if (owner.strict_loading? || reflection.strict_loading?) && owner.validation_context.nil?
-            Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
+            ::ActiveRecord::Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
           end
 
-          ArCache::PRELOADER.preload(owner, reflection.name)
-          owner.send(reflection.name)
-        rescue StandardError
-          super
+          PRELOADER.preload(owner, reflection.name)
+          target
         end
       end
     end

data/lib/ar_cache/active_record/associations/singular_association.rb

@@ -5,12 +5,8 @@ module ArCache
     module Associations
       module SingularAssociation
         private def skip_statement_cache?(...)
-          return super if ArCache.skip?
-
-          # Polymorphic associations do not support computing the class, so can't judge ArCache status.
-          # But SingularAssociation query usually can hit the unique index, so here return true directly.
-          return true if is_a?(::ActiveRecord::Associations::BelongsToPolymorphicAssociation)
-          return true unless reflection.klass.ar_cache_table.disabled?
+          return super if ArCache.skip_cache?
+          return true if ArCache.cache_reflection?(reflection) { ArCache::Query.new(scope).exec_queries_cacheable? }
 
           super
         end

data/lib/ar_cache/active_record/connection_adapters/abstract/database_statements.rb

@@ -4,18 +4,23 @@ module ArCache
   module ActiveRecord
     module ConnectionAdapters
       module DatabaseStatements
+        def select_all(arel, ...)
+          result = super
+          klass, select_values = arel.try(:klass_and_select_values)
+          return result if klass.nil?
+
+          klass.ar_cache_table.write(result.to_a)
+
+          if select_values
+            result.to_a.each { |r| r.slice!(*select_values) }
+          elsif klass.ignored_columns.any?
+            result.to_a.each { |r| r.except!(*klass.ignored_columns) }
+          end
+
+          result
+        end
+
         # def insert(arel, ...)
-        #   super.tap do
-        #     if arel.is_a?(String)
-        #       sql = arel.downcase
-        #       ArCache::Table.all.each do |table|
-        #         current_transaction.add_changed_table(table.name) if sql.include?(table.name)
-        #       end
-        #     else # is Arel::InsertManager
-        #       klass = arel.ast.relation.instance_variable_get(:@klass)
-        #       current_transaction.add_changed_table(klass.table_name)
-        #     end
-        #   end
         # end
         # alias create insert
 
@@ -46,24 +51,24 @@ module ArCache
         end
 
         private def update_ar_cache_by_arel(arel)
-          return if ArCache.expire?
+          return if ArCache.skip_expire?
 
           arel_table = arel.ast.relation.is_a?(Arel::Table) ? arel.ast.relation : arel.ast.relation.left
           klass = arel_table.instance_variable_get(:@klass)
-          current_transaction.update_ar_cache_table(klass.ar_cache_table) unless klass.ar_cache_table.disabled?
+          current_transaction.update_ar_cache_table(klass.ar_cache_table)
         end
 
         private def update_ar_cache_by_sql(sql)
           sql = sql.downcase
 
           ArCache::Table.all.each do |table|
-            current_transaction.update_ar_cache_table(table) if !table.disabled? && sql.include?(table.name)
+            current_transaction.update_ar_cache_table(table) if sql.include?(table.name)
           end
         end
 
         private def update_ar_cache_by_table(table_name)
           ArCache::Table.all.each do |table|
-            current_transaction.update_ar_cache_table(table) if !table.disabled? && table_name.casecmp?(table.name)
+            break current_transaction.update_ar_cache_table(table) if table_name == table.name
           end
         end
       end

data/lib/ar_cache/active_record/connection_adapters/abstract/transaction.rb

@@ -4,75 +4,80 @@ module ArCache
   module ActiveRecord
     module ConnectionAdapters
       module NullTransaction
-        def delete_ar_cache_keys(keys, delay: false) # rubocop:disable Lint/UnusedMethodArgument
-          ArCache::Store.delete_multi(keys)
+        def delete_ar_cache_primary_keys(keys, table)
+          handle_ar_cache_primary_keys(keys) unless table.disabled?
         end
 
-        def update_ar_cache_table(table, delay: false) # rubocop:disable Lint/UnusedMethodArgument
-          table.update_version
+        def update_ar_cache_table(table)
+          table.update_cache
         end
 
-        def add_changed_table(...); end
+        def handle_ar_cache_primary_keys(keys)
+          if ArCache::Configuration.cache_lock?
+            keys.each { |k| ArCache.lock_key(k) }
+          else
+            ArCache.delete_multi(keys)
+          end
+        end
       end
 
       module Transaction
         include NullTransaction
 
+        attr_reader :ar_cache_primary_keys, :ar_cache_tables
+
         def initialize(...)
           super
-          @ar_cache_keys = []
+          @ar_cache_primary_keys = []
           @ar_cache_tables = []
         end
 
-        def delete_ar_cache_keys(keys, delay: false)
-          super if !delay && read_uncommitted?
-          @ar_cache_keys.push(*keys)
-        end
-
-        def update_ar_cache_table(table, delay: false)
-          add_changed_table(table.name) unless delay
+        def delete_ar_cache_primary_keys(keys, table)
+          connection.transaction_manager.add_transaction_table(table.name)
+          return if table.disabled?
 
-          super if !delay && read_uncommitted?
-          @ar_cache_tables.push(table)
+          super if read_uncommitted?
+          ar_cache_primary_keys.push(*keys)
         end
 
-        def add_changed_table(table_name)
-          connection.transaction_manager.add_changed_table(table_name)
+        def update_ar_cache_table(table)
+          connection.transaction_manager.add_transaction_table(table.name)
+          return if table.disabled?
+
+          super if read_uncommitted?
+          ar_cache_tables.push(table)
         end
 
-        # FIXME: Cache update and transaction commit may cause dirty reads during this period!
+        # FIXME: The cache is removed after transaction commited, so dirty read may occur.
         def commit
           super
         ensure
           if @run_commit_callbacks
-            @ar_cache_tables.uniq(&:name).each(&:update_version) if @ar_cache_tables.any?
-            ArCache::Store.delete_multi(@ar_cache_keys.uniq) if @ar_cache_keys.any?
+            handle_ar_cache_primary_keys(ar_cache_primary_keys.uniq) if ar_cache_primary_keys.any?
+            ar_cache_tables.uniq(&:name).each(&:update_cache) if ar_cache_tables.any?
           else
-            transaction = connection.current_transaction
-            @ar_cache_tables.each { |table| transaction.update_ar_cache_table(table, delay: true) }
-            transaction.delete_ar_cache_keys(@ar_cache_keys, delay: true)
+            connection.current_transaction.ar_cache_tables.push(*ar_cache_tables)
+            connection.current_transaction.ar_cache_primary_keys.push(*ar_cache_primary_keys)
           end
         end
 
         def read_uncommitted?
-          ArCache::Configuration.read_uncommitted ||
-            isolation_level == :read_uncommitted ||
-            !connection.transaction_manager.fully_joinable?
+          isolation_level == :read_uncommitted || !connection.transaction_manager.fully_joinable?
         end
       end
 
       module TransactionManager
         def initialize(...)
           super
-          @changed_tables = {}
+          @transaction_tables = {}
         end
 
-        def add_changed_table(table_name)
-          @changed_tables[table_name] = true if fully_joinable?
+        def add_transaction_table(table_name)
+          @transaction_tables[table_name] = true if fully_joinable?
         end
 
-        def changed_table?(table_name)
-          @changed_tables.key?(table_name)
+        def transaction_table?(table_name)
+          @transaction_tables.key?(table_name)
         end
 
         def fully_joinable?
@@ -82,7 +87,7 @@ module ArCache
         def within_new_transaction(...)
           super
         ensure
-          @changed_tables = {} if @stack.count(&:joinable?).zero?
+          @transaction_tables.clear if @stack.count(&:joinable?).zero?
         end
       end
     end

data/lib/ar_cache/active_record/core.rb

@@ -4,14 +4,15 @@ module ArCache
   module ActiveRecord
     module Core
       module ClassMethods
-        # The #find use statement cache execute querying first, so need force skip.
+        # The #find and #find_by use ActiveRecord::StatementCache to execute querying first.
+        # For ArCache, we need force skip ActiveRecord::StatementCache.
+
         def find(...)
-          ArCache.skip? || ar_cache_table.disabled? ? super : all.find(...)
+          ArCache.skip_cache? || ar_cache_table.disabled? ? super : all.find(...)
         end
 
-        # The #find_by use statement cache execute querying first, so need force skip.
         def find_by(...)
-          ArCache.skip? || ar_cache_table.disabled? ? super : all.find_by(...)
+          ArCache.skip_cache? || ar_cache_table.disabled? ? super : all.find_by(...)
         end
       end
     end

data/lib/ar_cache/active_record/insert_all.rb

@@ -5,10 +5,7 @@ module ArCache
     module InsertAll
       def execute
         super.tap do
-          if on_duplicate == :update
-            connection.current_transaction.update_ar_cache_table(model.ar_cache_table)
-            connection.current_transaction.add_changed_table(model.table_name)
-          end
+          connection.current_transaction.update_ar_cache_table(model.ar_cache_table) if on_duplicate == :update
         end
       end
     end

data/lib/ar_cache/active_record/model_schema.rb

@@ -9,13 +9,7 @@ module ArCache
         end
 
         def ar_cache_table
-          @ar_cache_table ||= begin
-            if abstract_class? || self == ArCache::Record
-              ArCache::MockTable
-            else
-              ArCache::Table.new(table_name)
-            end
-          end
+          @ar_cache_table ||= abstract_class? ? ArCache::MockTable : ArCache::Table.new(table_name)
         end
       end
 

data/lib/ar_cache/active_record/persistence.rb

@@ -5,14 +5,14 @@ module ArCache
     module Persistence
       module ClassMethods
         def _update_record(_, constraints)
-          ArCache.expire do
+          ArCache.skip_expire do
             delete_ar_cache_key(constraints[@primary_key])
             super
           end
         end
 
         def _delete_record(constraints)
-          ArCache.expire do
+          ArCache.skip_expire do
             delete_ar_cache_key(constraints[@primary_key])
             super
           end
@@ -20,13 +20,12 @@ module ArCache
 
         private def delete_ar_cache_key(id)
           key = ar_cache_table.primary_cache_key(id)
-          connection.current_transaction.delete_ar_cache_keys([key])
-          connection.current_transaction.add_changed_table(table_name)
+          connection.current_transaction.delete_ar_cache_primary_keys([key], ar_cache_table)
         end
       end
 
       def reload(...)
-        ArCache.skip { super }
+        ArCache.skip_cache { super }
       end
     end
   end

data/lib/ar_cache/active_record/relation.rb

@@ -4,22 +4,22 @@ module ArCache
   module ActiveRecord
     module Relation
       def reload
-        loaded? ? ArCache.skip { super } : super
+        loaded? ? ArCache.skip_cache { super } : super
       end
 
       def explain
-        ArCache.skip { super }
+        ArCache.skip_cache { super }
       end
 
       def update_all(...)
-        ArCache.expire { delete_ar_cache_keys ? super : 0 }
+        ArCache.skip_expire { delete_ar_cache_primary_keys ? super : 0 }
       end
 
       def delete_all
-        ArCache.expire { delete_ar_cache_keys ? super : 0 }
+        ArCache.skip_expire { delete_ar_cache_primary_keys ? super : 0 }
       end
 
-      private def delete_ar_cache_keys
+      private def delete_ar_cache_primary_keys
         return true if klass.ar_cache_table.disabled?
 
         where_clause = ArCache::WhereClause.new(klass, arel.constraints)
@@ -31,13 +31,12 @@ module ArCache
 
         return false if keys.empty?
 
-        @klass.connection.current_transaction.delete_ar_cache_keys(keys)
-        @klass.connection.current_transaction.add_changed_table(@klass.table_name)
+        @klass.connection.current_transaction.delete_ar_cache_primary_keys(keys, @klass.ar_cache_table)
         true
       end
 
       private def exec_queries(&block)
-        ArCache.skip? ? super : ArCache::Query.new(self).exec_queries(&block).freeze
+        ArCache.skip_cache? ? super : ArCache::Query.new(self).exec_queries(&block).freeze
       end
     end
   end