ar_cache 1.0.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8eab4ff7873091b901a45bfa48e948679d7feda3e0e547201d3f5ab931bbf77e
-  data.tar.gz: 642654c010e8ced742980a0657480305be9904835a23715d884df3a90d42eef8
+  metadata.gz: 86d921c69c8ac7d8cbc0cefdb5614120a60f5663c5a2b8e3bc07a1c9c1d8d8a0
+  data.tar.gz: ced6d5cf673fb6e83070ba95e4daf6fb9d0994a93f8963de63692317c9c77081
 SHA512:
-  metadata.gz: a41629683860591506020f8ee516d6d3948ac0daf5381dff1c1b3410fc659be978a4f27d31c0ba49be3fbdf9fd608e7c424a215f5efd75842f5fbe47b31a2d75
-  data.tar.gz: 71dc11fbccc0816af45df3a1e3e3b3460c595f67fed0376afb9202237367970593441937131e80514d7dfd6bd601d4d2bdc3e3329267c9f6370efb36708291ec
+  metadata.gz: 5affbd42eed0837bc8fc40fd317eac39fa79b0e18c8e27f65eefb2873b381064539374dde7b963c1993f66068177707e72421499d7ff81b5fdc394e91261f8c3
+  data.tar.gz: 1c7f9930f0a726201afa735d208c229c01693432adc1631ea5bcd6417210ad079587c18ac9e908890e4ae4fac2307361048f017a28308c92c22d9136dd36e5ce

data/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Change log
+
+## main
+
+## 1.5.0 (2021-03-22 UTC)
+
+[Compare [#7cc9ec8..10f9eea](https://github.com/OuYangJinTing/ar_cache/compare/7cc9ec8..10f9eea)]:
+
+- Fix `has_one thtough:` strict loading error.
+- Fix `#detect_wrong_key`, should check `nil` value match.
+- Rename `ArCache::Configuration#index_column_max_size` => `ArCache::Configuration#column_length`
+
+## 1.4.0 (2021-03-15 UTC)
+
+[Compare [#3ff0bb8..7cc9ec8](https://github.com/OuYangJinTing/ar_cache/compare/3ff0bb8..7cc9ec8)]:
+
+- Remove `ArCache::Table` `ignored_columns` configuration.
+- Fix `ActiveRecord` call `#select` write to cache data is incomplete.
+
+## 1.3.0 (2021-03-13 UTC)
+
+[Compare [#4328f38..4ec14e9](https://github.com/OuYangJinTing/ar_cache/compare/4328f38..4ec14e9)]:
+
+- Optimize association cache, only cacheable association use ArCache query now.
+
+## 1.2.0 (2021-03-12 UTC)
+
+[Compare [#eb27f99..c830907](https://github.com/OuYangJinTing/ar_cache/compare/eb27f99..c830907)]:
+
+- Remove methods: `ArCache::MockTable#enabled?`, `ArCache::MockTable#select_enabled?`, `ArCache::Table.enabled?`, `ArCache::Table.select_enabled?`, `ActiveRecord::Relation#skip_ar_cache`.
+- Rename methods: `ArCache#skip_cache? => ArCache#skip?`, `ArCache#skip_cache => ArCache#skip`, `ArCache#pre_expire? => ArCache#expire?`, `ArCache#pre_expire => ArCache#expire`.
+- Now, `ArCache#skip` method only skip read cache, but still try delete cache.
+
+## 1.1.0 (2021-03-10 UTC)
+
+[Compare [#a15d5f5..ce5444c](https://github.com/OuYangJinTing/ar_cache/compare/a15d5f5...ce5444c)]:
+
+- 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.
+
+## 1.0.0 (2021-03-02 UTC)
+
+- Initial version.

data/Gemfile.lock

@@ -1,66 +1,66 @@
 PATH
   remote: .
   specs:
-    ar_cache (1.0.0)
+    ar_cache (1.5.0)
       activerecord (>= 6.1, < 7)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    actioncable (6.1.1)
-      actionpack (= 6.1.1)
-      activesupport (= 6.1.1)
+    actioncable (6.1.3)
+      actionpack (= 6.1.3)
+      activesupport (= 6.1.3)
       nio4r (~> 2.0)
       websocket-driver (>= 0.6.1)
-    actionmailbox (6.1.1)
-      actionpack (= 6.1.1)
-      activejob (= 6.1.1)
-      activerecord (= 6.1.1)
-      activestorage (= 6.1.1)
-      activesupport (= 6.1.1)
+    actionmailbox (6.1.3)
+      actionpack (= 6.1.3)
+      activejob (= 6.1.3)
+      activerecord (= 6.1.3)
+      activestorage (= 6.1.3)
+      activesupport (= 6.1.3)
       mail (>= 2.7.1)
-    actionmailer (6.1.1)
-      actionpack (= 6.1.1)
-      actionview (= 6.1.1)
-      activejob (= 6.1.1)
-      activesupport (= 6.1.1)
+    actionmailer (6.1.3)
+      actionpack (= 6.1.3)
+      actionview (= 6.1.3)
+      activejob (= 6.1.3)
+      activesupport (= 6.1.3)
       mail (~> 2.5, >= 2.5.4)
       rails-dom-testing (~> 2.0)
-    actionpack (6.1.1)
-      actionview (= 6.1.1)
-      activesupport (= 6.1.1)
+    actionpack (6.1.3)
+      actionview (= 6.1.3)
+      activesupport (= 6.1.3)
       rack (~> 2.0, >= 2.0.9)
       rack-test (>= 0.6.3)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.0, >= 1.2.0)
-    actiontext (6.1.1)
-      actionpack (= 6.1.1)
-      activerecord (= 6.1.1)
-      activestorage (= 6.1.1)
-      activesupport (= 6.1.1)
+    actiontext (6.1.3)
+      actionpack (= 6.1.3)
+      activerecord (= 6.1.3)
+      activestorage (= 6.1.3)
+      activesupport (= 6.1.3)
       nokogiri (>= 1.8.5)
-    actionview (6.1.1)
-      activesupport (= 6.1.1)
+    actionview (6.1.3)
+      activesupport (= 6.1.3)
       builder (~> 3.1)
       erubi (~> 1.4)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.1, >= 1.2.0)
-    activejob (6.1.1)
-      activesupport (= 6.1.1)
+    activejob (6.1.3)
+      activesupport (= 6.1.3)
       globalid (>= 0.3.6)
-    activemodel (6.1.1)
-      activesupport (= 6.1.1)
-    activerecord (6.1.1)
-      activemodel (= 6.1.1)
-      activesupport (= 6.1.1)
-    activestorage (6.1.1)
-      actionpack (= 6.1.1)
-      activejob (= 6.1.1)
-      activerecord (= 6.1.1)
-      activesupport (= 6.1.1)
+    activemodel (6.1.3)
+      activesupport (= 6.1.3)
+    activerecord (6.1.3)
+      activemodel (= 6.1.3)
+      activesupport (= 6.1.3)
+    activestorage (6.1.3)
+      actionpack (= 6.1.3)
+      activejob (= 6.1.3)
+      activerecord (= 6.1.3)
+      activesupport (= 6.1.3)
       marcel (~> 0.3.1)
       mimemagic (~> 0.3.2)
-    activesupport (6.1.1)
+    activesupport (6.1.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
@@ -71,11 +71,16 @@ GEM
     coderay (1.1.3)
     concurrent-ruby (1.1.8)
     crass (1.0.6)
-    database_cleaner (1.8.5)
+    database_cleaner (2.0.1)
+      database_cleaner-active_record (~> 2.0.0)
+    database_cleaner-active_record (2.0.0)
+      activerecord (>= 5.a)
+      database_cleaner-core (~> 2.0.0)
+    database_cleaner-core (2.0.1)
     erubi (1.10.0)
     globalid (0.4.2)
       activesupport (>= 4.2.0)
-    i18n (1.8.7)
+    i18n (1.8.9)
       concurrent-ruby (~> 1.0)
     loofah (2.9.0)
       crass (~> 1.0.2)
@@ -87,51 +92,51 @@ GEM
     method_source (1.0.0)
     mimemagic (0.3.5)
     mini_mime (1.0.2)
-    minitest (5.14.3)
-    nio4r (2.5.4)
-    nokogiri (1.11.1-x86_64-linux)
+    minitest (5.14.4)
+    nio4r (2.5.7)
+    nokogiri (1.11.2-x86_64-linux)
       racc (~> 1.4)
     parallel (1.20.1)
     parser (3.0.0.0)
       ast (~> 2.4.1)
-    pry (0.13.1)
+    pry (0.14.0)
       coderay (~> 1.1)
       method_source (~> 1.0)
     racc (1.5.2)
     rack (2.2.3)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
-    rails (6.1.1)
-      actioncable (= 6.1.1)
-      actionmailbox (= 6.1.1)
-      actionmailer (= 6.1.1)
-      actionpack (= 6.1.1)
-      actiontext (= 6.1.1)
-      actionview (= 6.1.1)
-      activejob (= 6.1.1)
-      activemodel (= 6.1.1)
-      activerecord (= 6.1.1)
-      activestorage (= 6.1.1)
-      activesupport (= 6.1.1)
+    rails (6.1.3)
+      actioncable (= 6.1.3)
+      actionmailbox (= 6.1.3)
+      actionmailer (= 6.1.3)
+      actionpack (= 6.1.3)
+      actiontext (= 6.1.3)
+      actionview (= 6.1.3)
+      activejob (= 6.1.3)
+      activemodel (= 6.1.3)
+      activerecord (= 6.1.3)
+      activestorage (= 6.1.3)
+      activesupport (= 6.1.3)
       bundler (>= 1.15.0)
-      railties (= 6.1.1)
+      railties (= 6.1.3)
       sprockets-rails (>= 2.0.0)
     rails-dom-testing (2.0.3)
       activesupport (>= 4.2.0)
       nokogiri (>= 1.6)
     rails-html-sanitizer (1.3.0)
       loofah (~> 2.3)
-    railties (6.1.1)
-      actionpack (= 6.1.1)
-      activesupport (= 6.1.1)
+    railties (6.1.3)
+      actionpack (= 6.1.3)
+      activesupport (= 6.1.3)
       method_source
       rake (>= 0.8.7)
       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)
@@ -142,9 +147,9 @@ GEM
       unicode-display_width (>= 1.4.0, < 3.0)
     rubocop-ast (1.4.1)
       parser (>= 2.7.1.5)
-    rubocop-minitest (0.10.3)
-      rubocop (>= 0.87, < 2.0)
-    rubocop-performance (1.9.2)
+    rubocop-minitest (0.11.0)
+      rubocop (>= 0.90, < 2.0)
+    rubocop-performance (1.10.1)
       rubocop (>= 0.90.0, < 2.0)
       rubocop-ast (>= 0.4.0)
     rubocop-rails (2.9.1)

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.
 
@@ -52,17 +55,31 @@ rake db:migrate
 
 Skip cache:
 
+- `ArCache#skip`, eg:
+
+```ruby
+# All queries in the block will not use the cache.
+ArCache.skip { User.find(1) }
+```
+
 - `ActiveRecord::Persistence#reload`, eg:
 
 ```ruby
 User.find(1).reload
 ```
 
-- `ActiveRecord::Relation#skip_ar_cache`, eg:
+- `ActiveRecord::Relation#reload`, eg:
 
 ```ruby
-User.skip_ar_cache.find(1)
-User.where(id: [1, 2]).skip_ar_cache.load
+# When reload is called after the associated target has been loaded, the cache will be skipped.
+User.where(id: 1).load.reload
+```
+
+- `ActiveRecord::Associations::Association#reload`, eg:
+
+```ruby
+# When reload is called after the associated target has been loaded, the cache will be skipped.
+user.association(:account).load_target.reload
 ```
 
 Delete cache:
@@ -82,41 +99,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!`, `#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 +141,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,43 @@ require 'ar_cache/active_record'
 require_relative './generators/ar_cache/install_generator' if defined?(Rails)
 
 module ArCache
-  singleton_class.delegate :configure, to: Configuration
+  @cache_reflection = {}
+
+  class << self
+    delegate :configure, to: Configuration
+
+    def skip?
+      Thread.current[:ar_cache_skip]
+    end
+
+    def skip
+      return yield if skip?
+
+      begin
+        Thread.current[:ar_cache_skip] = true
+        yield
+      ensure
+        Thread.current[:ar_cache_skip] = false
+      end
+    end
+
+    def expire?
+      Thread.current[:ar_cache_expire]
+    end
+
+    def expire
+      return yield if expire?
+
+      begin
+        Thread.current[:ar_cache_expire] = true
+        yield
+      ensure
+        Thread.current[:ar_cache_expire] = false
+      end
+    end
+
+    def cache_reflection?(reflection)
+      @cache_reflection.fetch(reflection) { @cache_reflection[reflection] = yield }
+    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 { super } : super
+        end
+      end
+    end
+  end
+end

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

@@ -4,34 +4,22 @@ module ArCache
   module ActiveRecord
     module Associations
       module HasOneThroughAssociation
-        private def find_target # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-          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
 
-          if owner.strict_loading? && owner.validation_context.nil?
-            Base.strict_loading_violation!(owner: owner.class, association: reflection.klass)
+        private def find_target
+          return super if ArCache.skip?
+          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?
           end
 
-          if reflection.strict_loading? && owner.validation_context.nil?
-            Base.strict_loading_violation!(owner: owner.class, association: reflection.name)
+          if (owner.strict_loading? || reflection.strict_loading?) && owner.validation_context.nil?
+            ::ActiveRecord::Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
           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
-          super
+          PRELOADER.preload(owner, reflection.name)
+          target
         end
       end
     end

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

@@ -5,10 +5,8 @@ module ArCache
     module Associations
       module SingularAssociation
         private def skip_statement_cache?(...)
-          # 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 if reflection.klass.ar_cache_table.enabled?
+          return super if ArCache.skip?
+          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,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.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) unless klass.ar_cache_table.disabled?
         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.disabled? && 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.disabled? && 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/core.rb

@@ -4,16 +4,14 @@ module ArCache
   module ActiveRecord
     module Core
       module ClassMethods
-        delegate :skip_ar_cache, to: :all
-
         # The #find use statement cache execute querying first, so need force skip.
         def find(...)
-          ar_cache_table.enabled? ? all.find(...) : super
+          ArCache.skip? || ar_cache_table.disabled? ? super : all.find(...)
         end
 
         # The #find_by use statement cache execute querying first, so need force skip.
         def find_by(...)
-          ar_cache_table.enabled? ? all.find_by(...) : super
+          ArCache.skip? || ar_cache_table.disabled? ? super : all.find_by(...)
         end
       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/model_schema.rb

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

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.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.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 { super }
       end
     end
   end

data/lib/ar_cache/active_record/relation.rb

@@ -3,45 +3,41 @@
 module ArCache
   module ActiveRecord
     module Relation
-      def skip_ar_cache
-        tap { @skip_ar_cache = true }
+      def reload
+        loaded? ? ArCache.skip { super } : super
       end
 
       def explain
-        @skip_ar_cache = true
-        super
+        ArCache.skip { 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.expire { delete_ar_cache_keys ? super : 0 }
+      end
+
+      def delete_all
+        ArCache.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)
+        ArCache.skip? ? super : ArCache::Query.new(self).exec_queries(&block).freeze
       end
     end
   end

data/lib/ar_cache/configuration.rb

@@ -4,7 +4,7 @@ require 'yaml'
 
 module ArCache
   class Configuration
-    singleton_class.attr_accessor :disabled, :select_disabled, :expires_in, :read_uncommitted, :index_column_max_size
+    singleton_class.attr_accessor :disabled, :select_disabled, :expires_in, :read_uncommitted, :column_length
     singleton_class.attr_reader :cache_store, :tables_options, :coder
 
     def self.configure
@@ -41,7 +41,6 @@ module ArCache
       options = tables_options[name.to_sym] || {}
       options[:disabled] = disabled unless options.key?(:disabled)
       options[:select_disabled] = select_disabled unless options.key?(:select_disabled)
-      options[:ignored_columns] = Array(options[:ignored_columns]).map(&:to_s)
       options[:unique_indexes] = Array(options[:unique_indexes]).map { |index| Array(index).map(&:to_s).uniq }.uniq
       options
     end
@@ -54,6 +53,6 @@ module ArCache
     @select_disabled = true
     @expires_in = 604_800 # 1 week
     @read_uncommitted = false
-    @index_column_max_size = 64
+    @column_length = 64
   end
 end

data/lib/ar_cache/marshal.rb

@@ -59,9 +59,9 @@ module ArCache
 
     private def detect_wrong_key(entry, where_values_hash)
       where_values_hash.detect do |k, v|
-        value = entry[k]
-        next if value.nil?
+        next unless entry.key?(k)
 
+        value = entry[k]
         if v.is_a?(Array)
           return k unless v.include?(value)
         else

data/lib/ar_cache/mock_table.rb

@@ -7,18 +7,10 @@ module ArCache
         true
       end
 
-      def enabled?
-        false
-      end
-
       def select_disabled?
         true
       end
 
-      def select_enabled?
-        false
-      end
-
       def version
         -1
       end

data/lib/ar_cache/query.rb

@@ -10,8 +10,9 @@ module ArCache
       @where_clause = ArCache::WhereClause.new(@relation.klass, @relation.where_clause.send(:predicates))
     end
 
-    def exec_queries(&block)
-      return relation.skip_ar_cache.send(:exec_queries, &block) unless exec_queries_cacheable?
+    def exec_queries(&block) # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      return [] if relation.where_clause.contradiction?
+      return ArCache.skip { relation.send(:exec_queries, &block) } unless exec_queries_cacheable?
 
       records = table.read(where_clause, @select_values, &block)
 
@@ -22,22 +23,32 @@ module ArCache
                         end
 
       if missed_relation
-        if table.ignored_columns.any? && relation.select_values.any?
-          missed_relation = missed_relation.reselect(table.column_names)
+        records += relation.find_by_sql(missed_relation.arel, &block).tap do |rs|
+          table.write(rs) if relation.select_values.empty?
         end
-        records += relation.find_by_sql(missed_relation.arel, &block).tap { |rs| table.write(rs) }
       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
+    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.distinct_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?
@@ -55,7 +66,7 @@ module ArCache
       (@select_values - table.column_names).empty?
     end
 
-    private def order_values_cacheable?
+    private def order_values_cacheable? # rubocop:disable Metrics/CyclomaticComplexity
       return true if where_clause.single?
 
       size = relation.order_values.size
@@ -70,6 +81,7 @@ module ArCache
       when String
         @order_name, @order_desc = first_order_value.downcase.split
         return false unless table.column_names.include?(@order_name)
+        return false unless ['asc', 'desc', nil].include?(@order_desc)
 
         @order_desc = @order_desc == 'desc'
       else

data/lib/ar_cache/record.rb

@@ -4,8 +4,6 @@ module ArCache
   class Record < ActiveRecord::Base # rubocop:disable Rails/ApplicationRecord
     self.table_name = 'ar_cache_records'
 
-    default_scope { skip_ar_cache }
-
     def self.get(table_name)
       find_by(table_name: table_name)
     end

data/lib/ar_cache/table.rb

@@ -4,12 +4,11 @@ module ArCache
   class Table
     include Marshal
 
-    OPTIONS = %i[disabled select_disabled unique_indexes ignored_columns].freeze
+    OPTIONS = %i[disabled select_disabled unique_indexes].freeze
 
     singleton_class.attr_reader :all
 
-    attr_reader :name, :primary_key, :unique_indexes, :column_indexes, :column_names, :md5,
-                :ignored_columns, :cache_key_prefix
+    attr_reader :name, :primary_key, :unique_indexes, :column_indexes, :column_names, :md5, :cache_key_prefix
 
     delegate :connection, to: ActiveRecord::Base, private: true
 
@@ -32,10 +31,10 @@ module ArCache
       @unique_indexes = normalize_unique_indexes(options.delete(:unique_indexes), columns).freeze
       options.each { |k, v| instance_variable_set("@#{k}", v) }
       @disabled = true if @primary_key.nil? # ArCache is depend on primary key implementation.
-      @column_names = (columns.map(&:name) - @ignored_columns).freeze
+      @column_names = columns.map(&:name).freeze
       @column_indexes = @unique_indexes.flatten.uniq.freeze
       coder = ArCache::Configuration.coder
-      @md5 = Digest::MD5.hexdigest("#{coder}-#{@disabled}-#{columns.to_json}-#{@ignored_columns.to_json}")
+      @md5 = Digest::MD5.hexdigest("#{coder}-#{@disabled}-#{columns.to_json}")
 
       ArCache::Record.store(self)
 
@@ -46,18 +45,10 @@ module ArCache
       @disabled
     end
 
-    def enabled?
-      !disabled?
-    end
-
     def select_disabled?
       @select_disabled
     end
 
-    def select_enabled?
-      !@select_disabled
-    end
-
     def version
       version = ArCache::Store.read(cache_key_prefix)
       unless version
@@ -110,14 +101,14 @@ module ArCache
       end
     end
 
-    private def custom_unique_indexes(indexes)
+    private def custom_unique_indexes(indexes, columns)
       indexes.each do |index|
-        index.each do |column|
-          column = columns.find { |c| c.name == column }
-          raise ArgumentError, "The #{name} table not found #{column.inspect} column" if column.nil?
+        index.each do |field|
+          column = columns.find { |c| c.name == field }
+          raise ArgumentError, "The #{name} table not found #{field.inspect} column" if column.nil?
 
           if column.type == :datetime
-            raise ArgumentError, "The #{column.inspect} is datetime type, ArCache do't support datetime type"
+            raise ArgumentError, "The #{field.inspect} is datetime type, ArCache do't support datetime type"
           end
         end
       end

data/lib/ar_cache/version.rb

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

data/lib/ar_cache/where_clause.rb

@@ -2,7 +2,7 @@
 
 module ArCache
   class WhereClause
-    attr_reader :klass, :table, :predicates
+    attr_reader :klass, :table, :predicates, :invalid_keys
 
     def initialize(klass, predicates)
       @klass = klass
@@ -24,8 +24,8 @@ module ArCache
         count = 0
 
         bool = index.all? do |column|
-          where_values_hash[column].tap do |value|
-            if value.is_a?(Array)
+          where_values_hash.key?(column).tap do
+            if where_values_hash[column].is_a?(Array)
               @multi_values_key = column
               count += 1
             end
@@ -52,7 +52,7 @@ module ArCache
       @cache_hash = {}
       multi_values_key = @multi_values_key || @index.first
 
-      Array(where_values_hash[multi_values_key]).each do |v|
+      Array.wrap(where_values_hash[multi_values_key]).each do |v|
         @cache_hash[table.cache_key(where_values_hash, @index, multi_values_key, v)] = v
       end
 
@@ -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
@@ -106,7 +105,7 @@ module ArCache
 
           name = node.left.name.to_s
           value = extract_node_value(node.right)
-          next if value.respond_to?(:size) && value.size > ArCache::Configuration.index_column_max_size
+          next if value.respond_to?(:size) && value.size > ArCache::Configuration.column_length
 
           hash[name] = value
         end

data/lib/generators/ar_cache/templates/configuration.rb

@@ -14,7 +14,7 @@ ArCache.configure do |config|
   # config.coder = [YAML|JSON] # default YAML
 
   # Support the maximum length of index column value.
-  # config.index_column_max_size = Integer # default 64
+  # config.column_length = Integer # default 64
 
   # ArCache switch.
   # config.disabled = Boolean # default false
@@ -27,7 +27,6 @@ ArCache.configure do |config|
   #     disabled: Boolean,
   #     select_disabled: Boolean,
   #     unique_indexes: Array # eg: [:id, [:name, :statue]], The default is the unique index column of the table.
-  #     ignored_columns: Array # eg: [:created_at, :updated_at], defaule [].
   #   },
   #   ...
   # }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ar_cache
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.5.0
 platform: ruby
 authors:
 - OuYangJinTing
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-02 00:00:00.000000000 Z
+date: 2021-03-22 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