ar_cache 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8eab4ff7873091b901a45bfa48e948679d7feda3e0e547201d3f5ab931bbf77e
-  data.tar.gz: 642654c010e8ced742980a0657480305be9904835a23715d884df3a90d42eef8
+  metadata.gz: '09eeda930c7263476f3b09e53747f9ec87ac070e65f18031856cdb05ad57a083'
+  data.tar.gz: 425c321debdcc05d81d4c0815abecb0d9e19fa417bb251265ba6dab420dd03e1
 SHA512:
-  metadata.gz: a41629683860591506020f8ee516d6d3948ac0daf5381dff1c1b3410fc659be978a4f27d31c0ba49be3fbdf9fd608e7c424a215f5efd75842f5fbe47b31a2d75
-  data.tar.gz: 71dc11fbccc0816af45df3a1e3e3b3460c595f67fed0376afb9202237367970593441937131e80514d7dfd6bd601d4d2bdc3e3329267c9f6370efb36708291ec
+  metadata.gz: 827f0ecdf9e583870a454c16cfaa44c95b9d7b0ba4f3942097daf1c76fed218adfdafcd5733b68fa6476297c8b6d35c728e1a1b6f66db615d9fde834183ea4e8
+  data.tar.gz: 273bef3daea68391d681045c384488bf9266a1f75cd5ea7057b6aaf70928ebe97934cb65daadf3f6a3442177d948923116867be503f479c6ac8ab06ac23bb286

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Change log
+
+## main
+
+## 1.0.0 (2021-03-02)
+
+- Initial version.
+
+## 1.1.0 (2021-03-11)
+
+- Fully automatic delete cache when call delete_all/update_all method.
+- Optimize has_one(through:) cache implementation.
+- ActiveRecord::Relation#reload and ActiveRecord::Associations::Association#reload should skip read cache if associated target is already loaded.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ar_cache (1.0.0)
+    ar_cache (1.1.0)
       activerecord (>= 6.1, < 7)
 
 GEM
@@ -129,9 +129,9 @@ GEM
       thor (~> 1.0)
     rainbow (3.0.0)
     rake (13.0.3)
-    regexp_parser (2.0.3)
+    regexp_parser (2.1.1)
     rexml (3.2.4)
-    rubocop (1.9.0)
+    rubocop (1.11.0)
       parallel (~> 1.10)
       parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)

data/README.md

@@ -1,7 +1,10 @@
 # ArCache
 
+![Test Status](https://github.com/OuYangJinTing/ar_cache/workflows/CI/badge.svg)
+[![Gem Version](https://badge.fury.io/rb/ar_cache.svg)](https://badge.fury.io/rb/ar_cache)
+
 `ArCache` is an modern cacheing library for `ActiveRecord` inspired by cache-money and second_level_cache.  
-It works automatically by copied `ActiveRecord` related code.
+It works automatically by overridden `ActiveRecord` related CURD code.
 When executing standard `ActiveRecord` query, it will first query the cache, and if there is none in the cache,
 then query the database and write the result to the cache.
 
@@ -82,41 +85,35 @@ For configuration information, please see [configuration](lib/generators/ar_cach
 
 If all the following conditions are met, ArCache will try to read the cache:
 
-- Use hash as `#where` parameter.
+- **Use hash as `#where` parameter**.
 - Query condition contains unique index.
 - Condition of unique index is only one array or no array.
 - No call `#select` or select value is table column.
 - No call `#order` or order value is table column and only one.
 - No call `#limit` or value of the unique index isn't array.
-- No call `#joins`.
-- No call `#left_joins`.
-- No call `#skip_query_cache!`.
-- No call `#skip_ar_cache`.
-- No call `#explain`.
-- No call `#from`.
-- No call `#group`.
-- No call `value`.
+- No call `#joins`, `#left_joins`, `#skip_query_cache!`, `#skip_ar_cache`, `#explain`, `#from`, `#group`, `#offset`, `#lock`
 - ...
 
 **Cacheable example:**
 
 ```ruby
-User.find(1) # primary key cache
-User.where(id: [1, 2]) # array query cache
-User.where(email: 'foobar@gmail.com') # sigle-column unique index cache
-User.where(name: 'foobar', status: :active) # multi-column unique index cache
-User.includes(:account).where(id: [1, 2]) # association cache
-User.first.account # association model cache
+User.find(1) # support primary key cache
+User.where(id: [1, 2]) # support multi-value unique index cache
+User.where(email: 'foobar@gmail.com') # support sigle-column unique index cache
+User.where(name: 'foobar', status: :active) # support multi-column unique index cache
+User.includes(:account).where(id: [1, 2]) # support association preload cache
+User.first.account # support association reader cach
 ```
 
+The association cache support belongs_to and has_one, small amount of complex has_one(scope, through:, as:) don't support, then has_many cache support, please watch to future version.
+
 ## Cache iteration
 
 The following cases will cause cache iteration：
 
 - Table field changes.
-- Open `ArCache` or close `ArCache`.
-- `ActiveRecord` update/delete condition does not hit the unique index.
-- `ActiveRecord` update/delete join other tables.
+- Turn on `ArCache` or turn off `ArCache`.
+- Call `#upsert_all` method.
 
 **Notice: After iteration, all existing caches of the table will be expired!**
 
@@ -130,6 +127,8 @@ The following cases will cause cache iteration：
 - Prohibit use `ActiveRecord` other underlying methods to directly update/delete data! (You is a fake activerecord user if this code appears)
 - Prohibit skip `ActiveRecord` directly update/delete data!
 
+If you have to do this, please consider turning off ArCache.
+
 ## Alternatives
 
 There are some other gems implementations for `ActiveRecord` cache such as:

data/lib/ar_cache.rb

@@ -18,5 +18,31 @@ require 'ar_cache/active_record'
 require_relative './generators/ar_cache/install_generator' if defined?(Rails)
 
 module ArCache
-  singleton_class.delegate :configure, to: Configuration
+  PRELOADER = ::ActiveRecord::Associations::Preloader.new
+
+  class << self
+    delegate :configure, to: Configuration
+
+    def skip_cache?
+      Thread.current[:ar_cache_skip_cache]
+    end
+
+    def skip_cache
+      Thread.current[:ar_cache_skip_cache] = true
+      yield
+    ensure
+      Thread.current[:ar_cache_skip_cache] = false
+    end
+
+    def pre_expire?
+      Thread.current[:ar_cache_pre_expire]
+    end
+
+    def pre_expire
+      Thread.current[:ar_cache_pre_expire] = true
+      yield
+    ensure
+      Thread.current[:ar_cache_pre_expire] = false
+    end
+  end
 end

data/lib/ar_cache/active_record.rb

@@ -5,6 +5,7 @@ require 'ar_cache/active_record/relation'
 require 'ar_cache/active_record/core'
 require 'ar_cache/active_record/persistence'
 require 'ar_cache/active_record/insert_all'
+require 'ar_cache/active_record/associations/association'
 require 'ar_cache/active_record/associations/singular_association'
 require 'ar_cache/active_record/associations/has_one_through_association'
 require 'ar_cache/active_record/connection_adapters/abstract/transaction'
@@ -18,11 +19,13 @@ ActiveSupport.on_load(:active_record, run_once: true) do
   ActiveRecord::ModelSchema::ClassMethods.prepend(ArCache::ActiveRecord::ModelSchema::ClassMethods)
 
   ActiveRecord::Persistence.prepend(ArCache::ActiveRecord::Persistence)
+  ActiveRecord::Persistence::ClassMethods.prepend(ArCache::ActiveRecord::Persistence::ClassMethods)
 
   ActiveRecord::InsertAll.prepend(ArCache::ActiveRecord::InsertAll)
 
   ActiveRecord::Relation.prepend(ArCache::ActiveRecord::Relation)
 
+  ActiveRecord::Associations::Association.prepend(ArCache::ActiveRecord::Associations::Association)
   ActiveRecord::Associations::SingularAssociation.prepend(ArCache::ActiveRecord::Associations::SingularAssociation)
   ActiveRecord::Associations::HasOneThroughAssociation.prepend(ArCache::ActiveRecord::Associations::HasOneThroughAssociation)
 

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ArCache
+  module ActiveRecord
+    module Associations
+      module Association
+        def reload(...)
+          loaded? ? ArCache.skip_cache { super } : super
+        end
+      end
+    end
+  end
+end

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

@@ -4,33 +4,17 @@ module ArCache
   module ActiveRecord
     module Associations
       module HasOneThroughAssociation
-        private def find_target # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+        private def find_target
           return super if reflection.klass.ar_cache_table.disabled?
           return super if reflection.through_reflection.klass.ar_cache_table.disabled?
 
-          if owner.strict_loading? && owner.validation_context.nil?
-            Base.strict_loading_violation!(owner: owner.class, association: reflection.klass)
+          if (owner.strict_loading? || reflection.strict_loading?) && owner.validation_context.nil?
+            Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
           end
 
-          if reflection.strict_loading? && owner.validation_context.nil?
-            Base.strict_loading_violation!(owner: owner.class, association: reflection.name)
-          end
-
-          # TODO: Should not instantiate AR
-          through_record = if reflection.scope
-                             owner.association(reflection.through_reflection.name).scope.merge(reflection.scope).first
-                           else
-                             owner.send(reflection.through_reflection.name)
-                           end
-          return super if through_record.is_a?(::ActiveRecord::Associations::CollectionProxy)
-          return nil if !through_record || through_record.destroyed?
-
-          record = through_record.send(reflection.source_reflection.name)
-          record = record.first if record.is_a?(::ActiveRecord::Associations::CollectionProxy)
-          return nil unless record
-
-          record.tap { |r| set_inverse_instance(r) }
-        rescue StandardError # If scope depend on other table, will raise exception
+          ArCache::PRELOADER.preload(owner, reflection.name)
+          owner.send(reflection.name)
+        rescue StandardError
           super
         end
       end

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

@@ -4,71 +4,67 @@ module ArCache
   module ActiveRecord
     module ConnectionAdapters
       module DatabaseStatements
-        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
+        # 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
 
         def update(arel, ...)
-          super.tap { |num| update_ar_cache_version(arel) unless num.zero? }
+          super.tap { |num| update_ar_cache(arel) unless num.zero? }
         end
 
         def delete(arel, ...)
-          super.tap { |num| update_ar_cache_version(arel) unless num.zero? }
+          super.tap { |num| update_ar_cache(arel) unless num.zero? }
         end
 
         def truncate(table_name, ...)
-          super.tap { update_ar_cache_version_by_table(table_name) }
+          super.tap { update_ar_cache_by_table(table_name) }
         end
 
         def truncate_tables(*table_names)
           super.tap do
-            table_names.each { |table_name| update_ar_cache_version_by_table(table_name) }
+            table_names.each { |table_name| update_ar_cache_by_table(table_name) }
           end
         end
 
-        private def update_ar_cache_version(arel_or_sql_string)
+        private def update_ar_cache(arel_or_sql_string)
           if arel_or_sql_string.is_a?(String)
-            update_ar_cache_version_by_sql(arel_or_sql_string)
+            update_ar_cache_by_sql(arel_or_sql_string)
           else # is Arel::TreeManager
-            update_ar_cache_version_by_arel(arel_or_sql_string)
+            update_ar_cache_by_arel(arel_or_sql_string)
           end
         end
 
-        private def update_ar_cache_version_by_arel(arel)
-          # arel.ast.relation may be of the following types:
-          #   - Arel::Nodes::JoinSource
-          #   - Arel::Table
+        private def update_ar_cache_by_arel(arel)
+          return if ArCache.pre_expire?
+
           arel_table = arel.ast.relation.is_a?(Arel::Table) ? arel.ast.relation : arel.ast.relation.left
           klass = arel_table.instance_variable_get(:@klass)
-          return if klass.ar_cache_table.disabled?
-
-          where_clause = ArCache::WhereClause.new(klass, arel.ast.wheres)
-          if where_clause.cacheable?
-            current_transaction.add_changed_table(klass.table_name)
-            current_transaction.add_ar_cache_keys(where_clause.cache_keys)
-          else
-            current_transaction.add_ar_cache_table(klass.ar_cache_table)
-          end
+          current_transaction.update_ar_cache_table(klass.ar_cache_table) if klass.ar_cache_table.enabled?
         end
 
-        private def update_ar_cache_version_by_sql(sql)
+        private def update_ar_cache_by_sql(sql)
           sql = sql.downcase
-          ArCache::Table.all.each { |table| current_transaction.add_ar_cache_table(table) if sql.include?(table.name) }
+
+          ArCache::Table.all.each do |table|
+            current_transaction.update_ar_cache_table(table) if table.enabled? && sql.include?(table.name)
+          end
         end
 
-        private def update_ar_cache_version_by_table(table_name)
-          ArCache::Table.all.each { |table| table.update_version if table_name.casecmp?(table.name) }
+        private def update_ar_cache_by_table(table_name)
+          ArCache::Table.all.each do |table|
+            current_transaction.update_ar_cache_table(table) if table.enabled? && table_name.casecmp?(table.name)
+          end
         end
       end
     end

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

@@ -4,15 +4,15 @@ module ArCache
   module ActiveRecord
     module ConnectionAdapters
       module NullTransaction
-        def add_ar_cache_keys(keys, delay: false) # rubocop:disable Lint/UnusedMethodArgument
+        def delete_ar_cache_keys(keys, delay: false) # rubocop:disable Lint/UnusedMethodArgument
           ArCache::Store.delete_multi(keys)
         end
 
-        def add_ar_cache_table(table, delay: false) # rubocop:disable Lint/UnusedMethodArgument
+        def update_ar_cache_table(table, delay: false) # rubocop:disable Lint/UnusedMethodArgument
           table.update_version
         end
 
-        def add_changed_table(_); end
+        def add_changed_table(...); end
       end
 
       module Transaction
@@ -24,12 +24,12 @@ module ArCache
           @ar_cache_tables = []
         end
 
-        def add_ar_cache_keys(keys, delay: false)
+        def delete_ar_cache_keys(keys, delay: false)
           super if !delay && read_uncommitted?
           @ar_cache_keys.push(*keys)
         end
 
-        def add_ar_cache_table(table, delay: false)
+        def update_ar_cache_table(table, delay: false)
           add_changed_table(table.name) unless delay
 
           super if !delay && read_uncommitted?
@@ -49,8 +49,8 @@ module ArCache
             ArCache::Store.delete_multi(@ar_cache_keys.uniq) if @ar_cache_keys.any?
           else
             transaction = connection.current_transaction
-            @ar_cache_tables.each { |table| transaction.add_ar_cache_table(table, delay: true) }
-            transaction.add_ar_cache_keys(@ar_cache_keys, delay: true)
+            @ar_cache_tables.each { |table| transaction.update_ar_cache_table(table, delay: true) }
+            transaction.delete_ar_cache_keys(@ar_cache_keys, delay: true)
           end
         end
 

data/lib/ar_cache/active_record/insert_all.rb

@@ -6,9 +6,8 @@ module ArCache
       def execute
         super.tap do
           if on_duplicate == :update
-            connection.current_transaction.add_ar_cache_table(model.ar_cache_table)
-          else
-            connection.transaction_manager.add_changed_table(model.table_name)
+            connection.current_transaction.update_ar_cache_table(model.ar_cache_table)
+            connection.current_transaction.add_changed_table(model.table_name)
           end
         end
       end

data/lib/ar_cache/active_record/persistence.rb

@@ -3,20 +3,30 @@
 module ArCache
   module ActiveRecord
     module Persistence
-      def reload(options = nil)
-        self.class.connection.clear_query_cache
+      module ClassMethods
+        def _update_record(_, constraints)
+          ArCache.pre_expire do
+            delete_ar_cache_key(constraints[@primary_key])
+            super
+          end
+        end
 
-        fresh_object =
-          if options && options[:lock]
-            self.class.unscoped { self.class.skip_ar_cache.lock(options[:lock]).find(id) }
-          else
-            self.class.unscoped { self.class.skip_ar_cache.find(id) }
+        def _delete_record(constraints)
+          ArCache.pre_expire do
+            delete_ar_cache_key(constraints[@primary_key])
+            super
           end
+        end
+
+        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)
+        end
+      end
 
-        @attributes = fresh_object.instance_variable_get(:@attributes)
-        @new_record = false
-        @previously_new_record = false
-        self
+      def reload(...)
+        ArCache.skip_cache { super }
       end
     end
   end

data/lib/ar_cache/active_record/relation.rb

@@ -3,6 +3,11 @@
 module ArCache
   module ActiveRecord
     module Relation
+      def reload
+        @skip_ar_cache = true if loaded?
+        super
+      end
+
       def skip_ar_cache
         tap { @skip_ar_cache = true }
       end
@@ -12,36 +17,33 @@ module ArCache
         super
       end
 
-      private def exec_queries(&block) # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/MethodLength
-        skip_query_cache_if_necessary do
-          records =
-            if where_clause.contradiction?
-              []
-            elsif eager_loading?
-              apply_join_dependency do |relation, join_dependency|
-                if relation.null_relation?
-                  []
-                else
-                  relation = join_dependency.apply_column_aliases(relation)
-                  rows = connection.select_all(relation.arel, 'SQL')
-                  join_dependency.instantiate(rows, strict_loading_value, &block)
-                end.freeze
-              end
-            elsif @skip_ar_cache ||
-                  klass.ar_cache_table.disabled? ||
-                  connection.transaction_manager.changed_table?(table_name)
-              klass.find_by_sql(arel, &block).freeze
-            else
-              ArCache::Query.new(self).exec_queries(&block).freeze
-            end
-
-          preload_associations(records) unless skip_preloading_value
-
-          records.each(&:readonly!) if readonly_value
-          records.each(&:strict_loading!) if strict_loading_value
-
-          records
-        end
+      def update_all(...)
+        ArCache.pre_expire { delete_ar_cache_keys ? super : 0 }
+      end
+
+      def delete_all
+        ArCache.pre_expire { delete_ar_cache_keys ? super : 0 }
+      end
+
+      private def delete_ar_cache_keys
+        return true if klass.ar_cache_table.disabled?
+
+        where_clause = ArCache::WhereClause.new(klass, arel.constraints)
+        keys = if where_clause.cacheable? && where_clause.primary_key_index?
+                 where_clause.primary_cache_keys
+               else
+                 pluck(primary_key).map { |item| klass.ar_cache_table.primary_cache_key(item) }
+               end
+
+        return false if keys.empty?
+
+        @klass.connection.current_transaction.delete_ar_cache_keys(keys)
+        @klass.connection.current_transaction.add_changed_table(@klass.table_name)
+        true
+      end
+
+      private def exec_queries(&block)
+        @skip_ar_cache ? super : ArCache::Query.new(self).exec_queries(&block).freeze
       end
     end
   end

data/lib/ar_cache/query.rb

@@ -10,7 +10,8 @@ module ArCache
       @where_clause = ArCache::WhereClause.new(@relation.klass, @relation.where_clause.send(:predicates))
     end
 
-    def exec_queries(&block)
+    def exec_queries(&block) # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      return [] if relation.where_clause.contradiction?
       return relation.skip_ar_cache.send(:exec_queries, &block) unless exec_queries_cacheable?
 
       records = table.read(where_clause, @select_values, &block)
@@ -29,15 +30,25 @@ module ArCache
       end
 
       records_order(records)
+
+      relation.preload_associations(records) unless relation.skip_preloading_value
+
+      records.each(&:readonly!) if relation.readonly_value
+      records.each(&:strict_loading!) if relation.strict_loading_value
+
+      records
     end
 
     private def exec_queries_cacheable? # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      return false if relation.klass.ar_cache_table.disabled?
       return false if relation.skip_query_cache_value
       return false if relation.lock_value
       return false if relation.group_values.any?
       return false if relation.joins_values.any?
       return false if relation.left_outer_joins_values.any?
       return false if relation.offset_value
+      return false if relation.eager_loading?
+      return false if relation.connection.transaction_manager.changed_table?(table.name)
       return false unless relation.from_clause.empty?
       return false unless where_clause.cacheable?
       return false unless select_values_cacheable?

data/lib/ar_cache/table.rb

@@ -43,7 +43,7 @@ module ArCache
     end
 
     def disabled?
-      @disabled
+      @disabled || ArCache.skip_cache?
     end
 
     def enabled?

data/lib/ar_cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArCache
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/lib/ar_cache/where_clause.rb

@@ -66,11 +66,10 @@ module ArCache
       @cache_hash
     end
 
-    def cache_keys
-      keys = cache_hash.keys
-      keys += cache_hash.values unless primary_key_index?
+    def primary_cache_keys
+      raise 'Does not detect primary key index' unless primary_key_index?
 
-      keys
+      @primary_cache_keys ||= Array(where_values_hash[table.primary_key]).map { |v| table.primary_cache_key(v) }
     end
 
     def missed_hash

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ar_cache
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - OuYangJinTing
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-02 00:00:00.000000000 Z
+date: 2021-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -41,6 +41,7 @@ files:
 - ".github/workflows/main.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.common
@@ -56,6 +57,7 @@ files:
 - gemfiles/rails-edge
 - lib/ar_cache.rb
 - lib/ar_cache/active_record.rb
+- lib/ar_cache/active_record/associations/association.rb
 - lib/ar_cache/active_record/associations/has_one_through_association.rb
 - lib/ar_cache/active_record/associations/singular_association.rb
 - lib/ar_cache/active_record/connection_adapters/abstract/database_statements.rb