identity_cache 1.2.0 → 1.6.3

data/lib/identity_cache/cache_fetcher.rb

@@ -60,14 +60,23 @@ module IdentityCache
       @cache_backend.write(key, IdentityCache::DELETED, expires_in: IdentityCache::DELETED_TTL.seconds)
     end
 
+    def delete_multi(keys)
+      key_values = keys.map { |key| [key, IdentityCache::DELETED] }.to_h
+      @cache_backend.write_multi(key_values, expires_in: IdentityCache::DELETED_TTL.seconds)
+    end
+
     def clear
       @cache_backend.clear
     end
 
     def fetch_multi(keys, &block)
-      results = cas_multi(keys, &block)
-      results = add_multi(keys, &block) if results.nil?
-      results
+      if IdentityCache.should_use_cache?
+        results = cas_multi(keys, &block)
+        results = add_multi(keys, &block) if results.nil?
+        results
+      else
+        {}
+      end
     end
 
     def fetch(key, fill_lock_duration: nil, lock_wait_tries: 2, &block)

data/lib/identity_cache/cache_key_loader.rb

@@ -44,7 +44,7 @@ module IdentityCache
       # @param db_key [Array] Reference to what to load from the database.
       # @return [Hash] A hash mapping each database key to its corresponding value
       def load_multi(cache_fetcher, db_keys)
-        load_batch(cache_fetcher => db_keys).fetch(cache_fetcher)
+        load_batch({ cache_fetcher => db_keys }).fetch(cache_fetcher)
       end
 
       # Load multiple keys for multiple cache fetchers

data/lib/identity_cache/cached/attribute.rb

@@ -35,16 +35,32 @@ module IdentityCache
       end
 
       def expire(record)
+        all_deleted = true
+
         unless record.send(:was_new_record?)
           old_key = old_cache_key(record)
-          IdentityCache.cache.delete(old_key)
+
+          if Thread.current[:idc_deferred_expiration]
+            Thread.current[:idc_attributes_to_expire] << old_key
+            # defer the deletion, and don't block the following deletion
+            all_deleted = true
+          else
+            all_deleted = IdentityCache.cache.delete(old_key)
+          end
         end
         unless record.destroyed?
           new_key = new_cache_key(record)
           if new_key != old_key
-            IdentityCache.cache.delete(new_key)
+            if Thread.current[:idc_deferred_expiration]
+              Thread.current[:idc_attributes_to_expire] << new_key
+              all_deleted = true
+            else
+              all_deleted = IdentityCache.cache.delete(new_key) && all_deleted
+            end
           end
         end
+
+        all_deleted
       end
 
       def cache_key(index_key)
@@ -59,6 +75,48 @@ module IdentityCache
         unique ? results.first : results
       end
 
+      def fetch_multi(keys)
+        keys = keys.map { |key| cast_db_key(key) }
+
+        unless model.should_use_cache?
+          return load_multi_from_db(keys)
+        end
+
+        unordered_hash = CacheKeyLoader.load_multi(self, keys)
+
+        # Calling `values` on the result is expected to return the values in the same order as their
+        # corresponding keys. The fetch_multi_by_#{field_list} generated methods depend on this.
+        keys.each_with_object({}) do |key, ordered_hash|
+          ordered_hash[key] = unordered_hash.fetch(key)
+        end
+      end
+
+      def load_multi_from_db(keys)
+        result = {}
+        return result if keys.empty?
+
+        rows = load_multi_rows(keys)
+        default = unique ? nil : []
+        keys.each do |index_value|
+          result[index_value] = default.try!(:dup)
+        end
+        if unique
+          rows.each do |index_value, attribute_value|
+            result[index_value] = attribute_value
+          end
+        else
+          rows.each do |index_value, attribute_value|
+            result[index_value] << attribute_value
+          end
+        end
+        result
+      end
+
+      def cache_encode(db_value)
+        db_value
+      end
+      alias_method :cache_decode, :cache_encode
+
       private
 
       # @abstract
@@ -76,6 +134,11 @@ module IdentityCache
         raise NotImplementedError
       end
 
+      # @abstract
+      def load_multi_rows(_index_keys)
+        raise NotImplementedError
+      end
+
       # @abstract
       def cache_key_from_key_values(_key_values)
         raise NotImplementedError
@@ -101,9 +164,9 @@ module IdentityCache
       end
 
       def old_cache_key(record)
+        changes = record.transaction_changed_attributes
         old_key_values = key_fields.map do |field|
           field_string = field.to_s
-          changes = record.transaction_changed_attributes
           if record.destroyed? && changes.key?(field_string)
             changes[field_string]
           elsif record.persisted? && changes.key?(field_string)

data/lib/identity_cache/cached/attribute_by_multi.rb

@@ -6,9 +6,14 @@ module IdentityCache
       def build
         cached_attribute = self
 
-        model.define_singleton_method(:"fetch_#{fetch_method_suffix}") do |*key_values|
+        model.define_singleton_method(:"fetch_#{fetch_method_suffix}") do |*keys|
           raise_if_scoped
-          cached_attribute.fetch(key_values)
+          cached_attribute.fetch(keys)
+        end
+
+        model.define_singleton_method(:"fetch_multi_#{fetch_method_suffix}") do |keys|
+          raise_if_scoped
+          cached_attribute.fetch_multi(keys)
         end
       end
 
@@ -16,22 +21,102 @@ module IdentityCache
 
       # Attribute method overrides
 
-      def cast_db_key(key_values)
+      def cast_db_key(keys)
         field_types.each_with_index do |type, i|
-          key_values[i] = type.cast(key_values[i])
+          keys[i] = type.cast(keys[i])
         end
-        key_values
+        keys
       end
 
-      def unhashed_values_cache_key_string(key_values)
-        key_values.map { |v| v.try!(:to_s).inspect }.join("/")
+      def unhashed_values_cache_key_string(keys)
+        keys.map { |v| v.try!(:to_s).inspect }.join("/")
       end
 
-      def load_from_db_where_conditions(key_values)
-        Hash[key_fields.zip(key_values)]
+      def load_from_db_where_conditions(keys)
+        Hash[key_fields.zip(keys)]
+      end
+
+      def load_multi_rows(keys)
+        query = load_multi_rows_query(keys)
+        fields = key_fields
+        if (attribute_index = key_fields.index(attribute))
+          fields = fields.dup
+          fields.delete(attribute)
+        end
+
+        query.pluck(attribute, *fields).map do |attribute, *key_values|
+          key_values.insert(attribute_index, attribute) if attribute_index
+          [key_values, attribute]
+        end
       end
 
       alias_method :cache_key_from_key_values, :cache_key
+
+      # Helper methods
+
+      def load_multi_rows_query(keys)
+        # Find fields with a common value for the below common_query optimization
+        common_conditions = {}
+        other_field_indexes = []
+        key_fields.each_with_index do |field, i|
+          first_value = keys.first[i]
+          is_unique = keys.all? { |key_values| first_value == key_values[i] }
+
+          if is_unique
+            common_conditions[field] = first_value
+          else
+            other_field_indexes << i
+          end
+        end
+
+        common_query = if common_conditions.any?
+          # Optimization for the case of fields in which the key being searched
+          # for is always the same. This results in simple equality conditions
+          # being produced for these fields (e.g. "WHERE field = value").
+          unsorted_model.where(common_conditions)
+        end
+
+        case other_field_indexes.size
+        when 0
+          common_query
+        when 1
+          # Micro-optimization for the case of a single unique field.
+          # This results in a single "WHERE field IN (values)" statement being
+          # produced from a single query.
+          field_idx = other_field_indexes.first
+          field_name = key_fields[field_idx]
+          field_values = keys.map { |key| key[field_idx] }
+          (common_query || unsorted_model).where(field_name => field_values)
+        else
+          # More than one unique field, so we need to generate a query for each
+          # set of values for each unique field.
+          #
+          # This results in multiple
+          #   "WHERE field = value AND field_2 = value_2 OR ..."
+          # statements being produced from an object like
+          #   [{ field: value, field_2: value_2 }, ...]
+          query = keys.reduce(nil) do |query, key|
+            condition = {}
+            other_field_indexes.each do |field_idx|
+              field = key_fields[field_idx]
+              condition[field] = key[field_idx]
+            end
+            subquery = unsorted_model.where(condition)
+
+            query ? query.or(subquery) : subquery
+          end
+
+          if common_query
+            common_query.merge(query)
+          else
+            query
+          end
+        end
+      end
+
+      def unsorted_model
+        model.reorder(nil)
+      end
     end
   end
 end

data/lib/identity_cache/cached/attribute_by_one.rb

@@ -24,46 +24,6 @@ module IdentityCache
         end
       end
 
-      def fetch_multi(keys)
-        keys = keys.map { |key| cast_db_key(key) }
-
-        unless model.should_use_cache?
-          return load_multi_from_db(keys)
-        end
-
-        unordered_hash = CacheKeyLoader.load_multi(self, keys)
-
-        # Calling `values` on the result is expected to return the values in the same order as their
-        # corresponding keys. The fetch_multi_by_#{field_list} generated methods depend on this.
-        ordered_hash = {}
-        keys.each { |key| ordered_hash[key] = unordered_hash.fetch(key) }
-        ordered_hash
-      end
-
-      def load_multi_from_db(keys)
-        rows = model.reorder(nil).where(load_from_db_where_conditions(keys)).pluck(key_field, attribute)
-        result = {}
-        default = unique ? nil : []
-        keys.each do |index_value|
-          result[index_value] = default.try!(:dup)
-        end
-        if unique
-          rows.each do |index_value, attribute_value|
-            result[index_value] = attribute_value
-          end
-        else
-          rows.each do |index_value, attribute_value|
-            result[index_value] << attribute_value
-          end
-        end
-        result
-      end
-
-      def cache_encode(db_value)
-        db_value
-      end
-      alias_method :cache_decode, :cache_encode
-
       private
 
       # Attribute method overrides
@@ -80,6 +40,10 @@ module IdentityCache
         { key_field => key_values }
       end
 
+      def load_multi_rows(keys)
+        model.reorder(nil).where(load_from_db_where_conditions(keys)).pluck(key_field, attribute)
+      end
+
       def cache_key_from_key_values(key_values)
         cache_key(key_values.first)
       end

data/lib/identity_cache/cached/belongs_to.rb

@@ -9,7 +9,7 @@ module IdentityCache
         reflection.active_record.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def #{cached_accessor_name}
             association_klass = association(:#{name}).klass
-            if association_klass.should_use_cache? && #{reflection.foreign_key}.present? && !association(:#{name}).loaded?
+            if #{reflection.foreign_key}.present? && !association(:#{name}).loaded? && (loaded_by_idc? || association_klass.should_use_cache?)
               if defined?(#{records_variable_name})
                 #{records_variable_name}
               else
@@ -77,16 +77,20 @@ module IdentityCache
             end
           end
 
-          load_strategy.load_multi(
-            reflection.klass.cached_primary_index,
-            ids_to_owner_record.keys
-          ) do |associated_records_by_id|
-            associated_records_by_id.each do |id, associated_record|
-              owner_record = ids_to_owner_record.fetch(id)
-              write(owner_record, associated_record)
-            end
+          if ids_to_owner_record.any?
+            load_strategy.load_multi(
+              reflection.klass.cached_primary_index,
+              ids_to_owner_record.keys
+            ) do |associated_records_by_id|
+              associated_records_by_id.each do |id, associated_record|
+                owner_record = ids_to_owner_record.fetch(id)
+                write(owner_record, associated_record)
+              end
 
-            yield associated_records_by_id.values.compact
+              yield associated_records_by_id.values.compact
+            end
+          else
+            yield records.filter_map { |record| record.instance_variable_get(records_variable_name) }
           end
         end
       end

data/lib/identity_cache/cached/primary_index.rb

@@ -45,7 +45,11 @@ module IdentityCache
 
       def expire(id)
         id = cast_id(id)
-        IdentityCache.cache.delete(cache_key(id))
+        if Thread.current[:idc_deferred_expiration]
+          Thread.current[:idc_records_to_expire] << cache_key(id)
+        else
+          IdentityCache.cache.delete(cache_key(id))
+        end
       end
 
       def cache_key(id)
@@ -54,7 +58,10 @@ module IdentityCache
 
       def load_one_from_db(id)
         record = build_query(id).take
-        model.send(:setup_embedded_associations_on_miss, [record]) if record
+        if record
+          model.send(:setup_embedded_associations_on_miss, [record])
+          record.send(:mark_as_loaded_by_idc)
+        end
         record
       end
 
@@ -63,6 +70,7 @@ module IdentityCache
 
         records = build_query(ids).to_a
         model.send(:setup_embedded_associations_on_miss, records)
+        records.each { |record| record.send(:mark_as_loaded_by_idc) }
         records.index_by(&:id)
       end
 

data/lib/identity_cache/cached/recursive/association.rb

@@ -25,7 +25,7 @@ module IdentityCache
         def read(record)
           assoc = record.association(name)
 
-          if assoc.klass.should_use_cache? && !assoc.loaded? && assoc.target.blank?
+          if !assoc.loaded? && assoc.target.blank? && (record.send(:loaded_by_idc?) || assoc.klass.should_use_cache?)
             if record.instance_variable_defined?(records_variable_name)
               record.instance_variable_get(records_variable_name)
             elsif record.instance_variable_defined?(dehydrated_variable_name)

data/lib/identity_cache/cached/reference/has_many.rb

@@ -22,7 +22,7 @@ module IdentityCache
 
             def #{cached_accessor_name}
               assoc = association(:#{name})
-              if assoc.klass.should_use_cache? && !assoc.loaded? && assoc.target.blank?
+              if (loaded_by_idc? || assoc.klass.should_use_cache?) && !assoc.loaded? && assoc.target.blank?
                 #{records_variable_name} ||= #{reflection.class_name}.fetch_multi(#{cached_ids_name})
               else
                 #{name}.to_a

data/lib/identity_cache/configuration_dsl.rb

@@ -143,7 +143,7 @@ module IdentityCache
 
       def check_association_for_caching(association)
         unless (association_reflection = reflect_on_association(association))
-          raise AssociationError, "Association named '#{association}' was not found on #{self.class}"
+          raise AssociationError, "Association named '#{association}' was not found on #{self}"
         end
         if association_reflection.options[:through]
           raise UnsupportedAssociationError, "caching through associations isn't supported"

data/lib/identity_cache/encoder.rb

@@ -69,6 +69,7 @@ module IdentityCache
 
       def record_from_coder(coder, klass) # :nodoc:
         record = klass.instantiate(coder[:attributes].dup)
+        record.send(:mark_as_loaded_by_idc)
 
         if coder.key?(:associations)
           coder[:associations].each do |name, value|

data/lib/identity_cache/fallback_fetcher.rb

@@ -21,7 +21,11 @@ module IdentityCache
     end
 
     def fetch_multi(keys)
-      results = @cache_backend.read_multi(*keys)
+      results = if IdentityCache.should_use_cache?
+        @cache_backend.read_multi(*keys)
+      else
+        {}
+      end
       missed_keys = keys - results.keys
       unless missed_keys.empty?
         replacement_results = yield missed_keys

data/lib/identity_cache/memoized_cache_proxy.rb

@@ -70,6 +70,16 @@ module IdentityCache
       end
     end
 
+    def delete_multi(keys)
+      memoizing = memoizing?
+      ActiveSupport::Notifications.instrument("cache_delete_multi.identity_cache", memoizing: memoizing) do
+        if memoizing
+          keys.each { |key| memoized_key_values.delete(key) }
+        end
+        @cache_fetcher.delete_multi(keys)
+      end
+    end
+
     def fetch(key, cache_fetcher_options = {}, &block)
       memo_misses = 0
       cache_misses = 0

data/lib/identity_cache/parent_model_expiration.rb

@@ -45,8 +45,13 @@ module IdentityCache
     def expire_parent_caches
       parents_to_expire = Set.new
       add_parents_to_cache_expiry_set(parents_to_expire)
-      parents_to_expire.each do |parent|
-        parent.expire_primary_index if parent.class.primary_cache_index_enabled
+      parents_to_expire.select! { |parent| parent.class.primary_cache_index_enabled }
+      parents_to_expire.reduce(true) do |all_expired, parent|
+        if Thread.current[:idc_deferred_parent_expiration]
+          Thread.current[:idc_parent_records_for_cache_expiry] << parent
+          next parent
+        end
+        parent.expire_primary_index && all_expired
       end
     end
 
@@ -65,7 +70,7 @@ module IdentityCache
 
     def parents_to_expire_on_changes(parents_to_expire, association_name, cached_associations)
       parent_association = self.class.reflect_on_association(association_name)
-      foreign_key = parent_association.association_foreign_key
+      foreign_key = parent_association.foreign_key
 
       new_parent = send(association_name)
 

data/lib/identity_cache/query_api.rb

@@ -70,6 +70,8 @@ module IdentityCache
         readonly: IdentityCache.fetch_read_only_records && should_use_cache?)
         return if records.empty?
 
+        return unless should_use_cache?
+
         records.each(&:readonly!) if readonly
         each_id_embedded_association do |cached_association|
           preload_id_embedded_association(records, cached_association)
@@ -166,15 +168,17 @@ module IdentityCache
     def _run_commit_callbacks
       if destroyed? || transaction_changed_attributes.present?
         expire_cache
-        expire_parent_caches
       end
       super
     end
 
-    # Invalidate the cache data associated with the record.
+    # Invalidate the cache data associated with the record. Returns `true` on success,
+    # `false` otherwise.
     def expire_cache
-      expire_attribute_indexes
-      true
+      expired_parent_caches = expire_parent_caches
+      expired_attribute_indexes = expire_attribute_indexes
+
+      expired_parent_caches && expired_attribute_indexes
     end
 
     # @api private
@@ -185,9 +189,11 @@ module IdentityCache
 
     private
 
+    # Even if we have problems with some attributes, carry over the results and expire
+    # all possible attributes without array allocation.
     def expire_attribute_indexes # :nodoc:
-      cache_indexes.each do |cached_attribute|
-        cached_attribute.expire(self)
+      cache_indexes.reduce(true) do |all_expired, cached_attribute|
+        cached_attribute.expire(self) && all_expired
       end
     end
   end

data/lib/identity_cache/should_use_cache.rb

@@ -9,5 +9,15 @@ module IdentityCache
         IdentityCache.should_use_cache?
       end
     end
+
+    private
+
+    def mark_as_loaded_by_idc
+      @loaded_by_idc = true
+    end
+
+    def loaded_by_idc?
+      defined?(@loaded_by_idc)
+    end
   end
 end

data/lib/identity_cache/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module IdentityCache
-  VERSION = "1.2.0"
+  VERSION = "1.6.3"
   CACHE_VERSION = 8
 end

data/lib/identity_cache/with_primary_index.rb

@@ -7,8 +7,9 @@ module IdentityCache
     include WithoutPrimaryIndex
 
     def expire_cache
-      expire_primary_index
-      super
+      expired_primary_index = expire_primary_index
+
+      super && expired_primary_index
     end
 
     # @api private
@@ -34,8 +35,8 @@ module IdentityCache
       # Declares a new index in the cache for the class where IdentityCache was
       # included.
       #
-      # IdentityCache will add a fetch_by_field1_and_field2_and_...field for every
-      # index.
+      # IdentityCache will add a fetch_by_field1_and_field2_and_...field and
+      # fetch_multi_by_field1_and_field2_and_...field for every index.
       #
       # == Example:
       #
@@ -44,7 +45,10 @@ module IdentityCache
       #    cache_index :name, :vendor
       #  end
       #
-      # Will add Product.fetch_by_name_and_vendor
+      # Will add:
+      #
+      #   Product.fetch_by_name_and_vendor
+      #   Product.fetch_multi_by_name_and_vendor
       #
       # == Parameters
       #
@@ -81,15 +85,13 @@ module IdentityCache
           CODE
         end
 
-        if fields.length == 1
-          instance_eval(<<-CODE, __FILE__, __LINE__ + 1)
-            def fetch_multi_by_#{field_list}(index_values, includes: nil)
-              ids = fetch_multi_id_by_#{field_list}(index_values).values.flatten(1)
-              return ids if ids.empty?
-              fetch_multi(ids, includes: includes)
-            end
-          CODE
-        end
+        instance_eval(<<-CODE, __FILE__, __LINE__ + 1)
+          def fetch_multi_by_#{field_list}(index_values, includes: nil)
+            ids = fetch_multi_id_by_#{field_list}(index_values).values.flatten(1)
+            return ids if ids.empty?
+            fetch_multi(ids, includes: includes)
+          end
+        CODE
       end
 
       # Similar to ActiveRecord::Base#exists? will return true if the id can be
@@ -149,6 +151,8 @@ module IdentityCache
         ensure_base_model
         raise_if_scoped
         ids.flatten!(1)
+        return [] if ids.none?
+
         records = cached_primary_index.fetch_multi(ids)
         prefetch_associations(includes, records) if includes
         records
@@ -158,6 +162,15 @@ module IdentityCache
       def expire_primary_key_cache_index(id)
         cached_primary_index.expire(id)
       end
+
+      private
+
+      def inherited(subclass)
+        super
+        subclass.class_eval do
+          @cached_primary_index = nil
+        end
+      end
     end
   end
 end