identity_cache 1.3.1 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3abed29487ae94532060d1a35e2bc86f8b4187cbc9a3074c8c304ab4f8426b4b
-  data.tar.gz: ddcaf494c9bc48055ee4e1ddc83a5caf61e047e4d053eb2b4e87a086a73f97ae
+  metadata.gz: acfed214f7a98554a2a32f066e1de02da09c69f2ccd46cd5cfbc2b343ecebe30
+  data.tar.gz: 428ce88a990db844ea32dab391b85cf65046af1a5f4462b2596752637ab94ee7
 SHA512:
-  metadata.gz: e0c8e9d0996d6f7f3f3e760fbf1ec2f7b8fa819bbeeaa3dc8b1286125265da45c6b174a77d3b13f763e6db104d613a55562f0a0ff13eb6d0c800e455ae30020c
-  data.tar.gz: 03a5cffffa5a0971f0d12a4d449c518a471d579410c2f7b8dfe32ad82234fb08115fa44cc99e726ed28352ead0287c5e966f47fb0b607758ddb29b1baa4667a4
+  metadata.gz: febcac0077ff5e20d9e6c42dd472c147dca5baa5e37a86db7f3c2839ac61020cb770bb781ecef98d9d8c7cf47b347b3f7810210c5f1e620fc4f052ba5cf6496f
+  data.tar.gz: 4f630185bd4c0b5cf372de27aed7e40d484c94b35ae6f271d89d45e02adf7fa9648ad5151714e9646d01f559f05f2cdd989af6edb6536633f72640133f6b4de9

data/CHANGELOG.md

@@ -2,33 +2,51 @@
 
 ## Unreleased
 
+## 1.4.1
+
+### Fixes
+
+- Fix `fetch_multi_by` bug for queries having a single field with distinct values. (#536)
+
+## 1.4.0
+
+### Features
+
+- Add `fetch_multi_by` support for composite-key indexes. (#534)
+
 ## 1.3.1
 
 ### Fixes
+
 - Remove N+1 queries from embedded associations when using `fetch` while `should_use_cache` is false. (#531)
 
 ## 1.3.0
 
 ### Features
+
 - Return meaningful value from `expire_cache` indicating whenever it succeeded or failed in the process. (#523)
 
 ### Fixes
+
 - Expire parents cache when when calling `expire_cache`. (#523)
 - Avoid creating too many shapes on Ruby 3.2+. (#526)
 
 ## 1.2.0
 
 ### Fixes
+
 - Fix mem_cache_store adapter with pool_size (#489)
 - Fix dalli deprecation warning about requiring 'dalli/cas/client' (#511)
 - Make transitionary method IdentityCache.with_fetch_read_only_records thread-safe (#503)
 
 ### Features
+
 - Add support for fill lock with lock wait to avoid thundering herd problem (#373)
 
 ## 1.1.0
 
 ### Fixes
+
 - Fix double debug logging of cache hits and misses (#474)
 - Fix a Rails 6.1 deprecation warning for Rails 7.0 compatibility (#482)
 - Recursively install parent expiry hooks when expiring parent caches (#476)
@@ -40,10 +58,12 @@
 - Fix fetch `has_many` embedded association on record after adding to it (#449)
 
 ### Features
+
 - Support multiple databases and transactional tests in `IdentityCache.should_use_cache?` (#293)
 - Add support for the default `MemCacheStore` from `ActiveSupport` (#465)
 
 ### Breaking Changes
+
 - Drop ruby 2.4 support, since it is no longer supported upstream (#468)
 
 ## 1.0.1
@@ -115,7 +135,7 @@
 - Remove support for 3.2
 - Fix N+1 from fetching embedded ids on a cache miss
 - Raise when trying to cache a through association. Previously it wouldn't be invalidated properly.
-- Raise if a class method is called on a scope.  Previously the scope was ignored.
+- Raise if a class method is called on a scope. Previously the scope was ignored.
 - Raise if a class method is called on a subclass of one that included IdentityCache. This never worked properly.
 - Fix cache_belongs_to on polymorphic assocations.
 - Fetching a cache_belongs_to association no longer loads the belongs_to association
@@ -176,7 +196,6 @@
 
 ## 0.0.5
 
-
 ## 0.0.4
 
 - Fix: only marshal attributes, embedded associations and normalized association IDs

data/README.md

@@ -101,7 +101,15 @@ product = Product.fetch_by_handle(handle)
 # Fetch multiple products by providing an array of index values.
 products = Product.fetch_multi_by_handle(handles)
 
+# Fetch a single product by providing composite attributes.
 products = Product.fetch_by_vendor_and_product_type(vendor, product_type)
+
+# Fetch multiple products by providing an array of composite attributes.
+products = Product.fetch_multi_by_vendor_and_product_type([
+  [vendor_1, product_type_1],
+  [vendor_2, product_type_2],
+  # ...
+])
 ```
 
 This gives you a lot of freedom to use your objects the way you want to, and doesn't get in your way. This does keep an independent cache copy in Memcached so you might want to watch the number of different caches that are being added.

data/lib/identity_cache/cached/attribute.rb

@@ -63,6 +63,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
@@ -80,6 +122,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

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/version.rb

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

data/lib/identity_cache/with_primary_index.rb

@@ -35,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:
       #
@@ -45,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
       #
@@ -82,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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: identity_cache
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.4.1
 platform: ruby
 authors:
 - Camilo Lopez
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-23 00:00:00.000000000 Z
+date: 2023-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -190,7 +190,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.9
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: IdentityCache lets you specify how you want to cache your model objects,