identity_cache 0.4.1 → 1.1.0

data/lib/identity_cache/cached/attribute_by_multi.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module Cached
+    class AttributeByMulti < Attribute
+      def build
+        cached_attribute = self
+
+        model.define_singleton_method(:"fetch_#{fetch_method_suffix}") do |*key_values|
+          raise_if_scoped
+          cached_attribute.fetch(key_values)
+        end
+      end
+
+      private
+
+      # Attribute method overrides
+
+      def cast_db_key(key_values)
+        field_types.each_with_index do |type, i|
+          key_values[i] = type.cast(key_values[i])
+        end
+        key_values
+      end
+
+      def unhashed_values_cache_key_string(key_values)
+        key_values.map { |v| v.try!(:to_s).inspect }.join('/')
+      end
+
+      def load_from_db_where_conditions(key_values)
+        Hash[key_fields.zip(key_values)]
+      end
+
+      alias_method :cache_key_from_key_values, :cache_key
+    end
+  end
+end

data/lib/identity_cache/cached/attribute_by_one.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module Cached
+    class AttributeByOne < Attribute
+      attr_reader :key_field
+
+      def initialize(*)
+        super
+        @key_field = key_fields.first
+      end
+
+      def build
+        cached_attribute = self
+
+        model.define_singleton_method(:"fetch_#{fetch_method_suffix}") do |key|
+          raise_if_scoped
+          cached_attribute.fetch(key)
+        end
+
+        model.define_singleton_method(:"fetch_multi_#{fetch_method_suffix}") do |keys|
+          raise_if_scoped
+          cached_attribute.fetch_multi(keys)
+        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
+
+      def cast_db_key(key)
+        field_types.first.cast(key)
+      end
+
+      def unhashed_values_cache_key_string(key)
+        key.try!(:to_s).inspect
+      end
+
+      def load_from_db_where_conditions(key_values)
+        { key_field => key_values }
+      end
+
+      def cache_key_from_key_values(key_values)
+        cache_key(key_values.first)
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/belongs_to.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    class BelongsTo < Association # :nodoc:
+      attr_reader :records_variable_name
+
+      def build
+        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 defined?(#{records_variable_name})
+                #{records_variable_name}
+              else
+                #{records_variable_name} = association_klass.fetch_by_id(#{reflection.foreign_key})
+              end
+            else
+              #{name}
+            end
+          end
+        RUBY
+      end
+
+      def clear(record)
+        if record.instance_variable_defined?(records_variable_name)
+          record.remove_instance_variable(records_variable_name)
+        end
+      end
+
+      def write(owner_record, associated_record)
+        owner_record.instance_variable_set(records_variable_name, associated_record)
+      end
+
+      def fetch(records)
+        fetch_async(LoadStrategy::Eager, records) { |associated_records| associated_records }
+      end
+
+      def fetch_async(load_strategy, records)
+        if reflection.polymorphic?
+          type_fetcher_to_db_ids_hash = {}
+
+          records.each do |owner_record|
+            associated_id = owner_record.send(reflection.foreign_key)
+            next unless associated_id && !owner_record.instance_variable_defined?(records_variable_name)
+            foreign_type_fetcher = Object.const_get(
+              owner_record.send(reflection.foreign_type)
+            ).cached_model.cached_primary_index
+            db_ids = type_fetcher_to_db_ids_hash[foreign_type_fetcher] ||= []
+            db_ids << associated_id
+          end
+
+          load_strategy.load_batch(type_fetcher_to_db_ids_hash) do |batch_load_result|
+            batch_records = []
+
+            records.each do |owner_record|
+              associated_id = owner_record.send(reflection.foreign_key)
+              next unless associated_id && !owner_record.instance_variable_defined?(records_variable_name)
+              foreign_type_fetcher = Object.const_get(
+                owner_record.send(reflection.foreign_type)
+              ).cached_model.cached_primary_index
+
+              associated_record = batch_load_result.fetch(foreign_type_fetcher).fetch(associated_id)
+              batch_records << owner_record
+              write(owner_record, associated_record)
+            end
+
+            yield batch_records
+          end
+        else
+          ids_to_owner_record = records.each_with_object({}) do |owner_record, hash|
+            associated_id = owner_record.send(reflection.foreign_key)
+            if associated_id && !owner_record.instance_variable_defined?(records_variable_name)
+              hash[associated_id] = owner_record
+            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
+
+            yield associated_records_by_id.values.compact
+          end
+        end
+      end
+
+      def embedded_recursively?
+        false
+      end
+
+      def embedded_by_reference?
+        false
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/embedded_fetching.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module EmbeddedFetching
+      private
+
+      def fetch_embedded(records)
+        fetch_embedded_async(LoadStrategy::Eager, records) {}
+      end
+
+      def fetch_embedded_async(load_strategy, records)
+        return yield if embedded_fetched?(records)
+
+        klass = reflection.active_record
+        cached_associations = klass.send(:embedded_associations)
+
+        return yield if cached_associations.empty?
+
+        return yield unless klass.primary_cache_index_enabled
+
+        load_strategy.load_multi(klass.cached_primary_index, records.map(&:id)) do |cached_records_by_id|
+          cached_associations.each_value do |cached_association|
+            records.each do |record|
+              next unless (cached_record = cached_records_by_id[record.id])
+              cached_value = cached_association.read(cached_record)
+              cached_association.write(record, cached_value)
+            end
+          end
+
+          yield
+        end
+      end
+
+      def embedded_fetched?(records)
+        # NOTE: Assume all records are the same, so just check the first one.
+        record = records.first
+        record.association(name).loaded? || record.instance_variable_defined?(records_variable_name)
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/prefetcher.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module Cached
+    module Prefetcher
+      ASSOCIATION_FETCH_EVENT = "association_fetch.identity_cache"
+
+      class << self
+        def prefetch(klass, associations, records, load_strategy: LoadStrategy::Eager)
+          return if (records = records.to_a).empty?
+
+          case associations
+          when Symbol
+            fetch_association(load_strategy, klass, associations, records) {}
+          when Array
+            load_strategy.lazy_load do |lazy_loader|
+              associations.each do |association|
+                prefetch(klass, association, records, load_strategy: lazy_loader)
+              end
+            end
+          when Hash
+            load_strategy.lazy_load do |lazy_loader|
+              associations.each do |association, sub_associations|
+                fetch_association(lazy_loader, klass, association, records) do |next_level_records|
+                  if sub_associations.present?
+                    association_class = klass.reflect_on_association(association).klass
+                    prefetch(association_class, sub_associations, next_level_records, load_strategy: lazy_loader)
+                  end
+                end
+              end
+            end
+          else
+            raise TypeError, "Invalid associations class #{associations.class}"
+          end
+        end
+
+        private
+
+        def fetch_association(load_strategy, klass, association, records, &block)
+          unless klass.should_use_cache?
+            preload_records(records, association)
+            return yield
+          end
+
+          cached_association = klass.cached_association(association)
+          cached_association.fetch_async(load_strategy, records, &block)
+        end
+
+        if ActiveRecord.gem_version < Gem::Version.new("6.2.0.alpha")
+          def preload_records(records, association)
+            ActiveRecord::Associations::Preloader.new.preload(records, association)
+          end
+        else
+          def preload_records(records, association)
+            ActiveRecord::Associations::Preloader.new(records: records, associations: association).call
+          end
+        end
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/primary_index.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module Cached
+    class PrimaryIndex
+      attr_reader :model
+
+      def initialize(model)
+        @model = model
+      end
+
+      def fetch(id)
+        id = cast_id(id)
+        return unless id
+        record = if model.should_use_cache?
+          object = CacheKeyLoader.load(self, id)
+          if object && object.id != id
+            IdentityCache.logger.error(
+              <<~MSG.squish
+                [IDC id mismatch] fetch_by_id_requested=#{id}
+                fetch_by_id_got=#{object.id}
+                for #{object.inspect[(0..100)]}
+              MSG
+            )
+          end
+          object
+        else
+          load_one_from_db(id)
+        end
+        record
+      end
+
+      def fetch_multi(ids)
+        ids.map! { |id| cast_id(id) }.compact!
+        id_to_record_hash = if model.should_use_cache?
+          id_to_record_hash = CacheKeyLoader.load_multi(self, ids)
+        else
+          load_multi_from_db(ids)
+        end
+        records = ids.map { |id| id_to_record_hash[id] }
+        records.compact!
+        records
+      end
+
+      def expire(id)
+        id = cast_id(id)
+        IdentityCache.cache.delete(cache_key(id))
+      end
+
+      def cache_key(id)
+        "#{model.rails_cache_key_namespace}#{cache_key_prefix}#{id}"
+      end
+
+      def load_one_from_db(id)
+        record = build_query(id).take
+        model.send(:setup_embedded_associations_on_miss, [record]) if record
+        record
+      end
+
+      def load_multi_from_db(ids)
+        return {} if ids.empty?
+
+        records = build_query(ids).to_a
+        model.send(:setup_embedded_associations_on_miss, records)
+        records.index_by(&:id)
+      end
+
+      def cache_encode(record)
+        Encoder.encode(record)
+      end
+
+      def cache_decode(cache_value)
+        Encoder.decode(cache_value, model)
+      end
+
+      private
+
+      def cast_id(id)
+        model.type_for_attribute(model.primary_key).cast(id)
+      end
+
+      def id_column
+        @id_column ||= model.columns.detect { |c| c.name == model.primary_key }
+      end
+
+      def build_query(id_or_ids)
+        model.where(model.primary_key => id_or_ids).includes(model.send(:cache_fetch_includes))
+      end
+
+      def cache_key_prefix
+        @cache_key_prefix ||= "blob:#{model.base_class.name}:" \
+          "#{IdentityCache::CacheKeyGeneration.denormalized_schema_hash(model)}:"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module Recursive
+      class Association < Cached::Association # :nodoc:
+        def initialize(name, reflection:)
+          super
+          @dehydrated_variable_name = :"@dehydrated_#{name}"
+        end
+
+        attr_reader :dehydrated_variable_name
+
+        def build
+          cached_association = self
+
+          model = reflection.active_record
+          model.define_method(cached_accessor_name) do
+            cached_association.read(self)
+          end
+
+          ParentModelExpiration.add_parent_expiry_hook(self)
+        end
+
+        def read(record)
+          assoc = record.association(name)
+
+          if assoc.klass.should_use_cache? && !assoc.loaded? && assoc.target.blank?
+            if record.instance_variable_defined?(records_variable_name)
+              record.instance_variable_get(records_variable_name)
+            elsif record.instance_variable_defined?(dehydrated_variable_name)
+              dehydrated_target = record.instance_variable_get(dehydrated_variable_name)
+              association_target = hydrate_association_target(assoc.klass, dehydrated_target)
+              record.remove_instance_variable(dehydrated_variable_name)
+              set_with_inverse(record, association_target)
+            else
+              assoc.load_target
+            end
+          else
+            assoc.load_target
+          end
+        end
+
+        def write(record, association_target)
+          record.instance_variable_set(records_variable_name, association_target)
+        end
+
+        def set_with_inverse(record, association_target)
+          set_inverse(record, association_target)
+          write(record, association_target)
+        end
+
+        def clear(record)
+          if record.instance_variable_defined?(records_variable_name)
+            record.remove_instance_variable(records_variable_name)
+          end
+        end
+
+        def fetch(records)
+          fetch_async(LoadStrategy::Eager, records) { |child_records| child_records }
+        end
+
+        def fetch_async(load_strategy, records)
+          fetch_embedded_async(load_strategy, records) do
+            yield records.flat_map(&cached_accessor_name).tap(&:compact!)
+          end
+        end
+
+        def embedded_by_reference?
+          false
+        end
+
+        def embedded_recursively?
+          true
+        end
+
+        private
+
+        def set_inverse(record, association_target)
+          return if association_target.nil?
+          associated_class = reflection.klass
+          inverse_cached_association = associated_class.cached_belongs_tos[inverse_name]
+          return unless inverse_cached_association
+
+          if association_target.is_a?(Array)
+            association_target.each do |child_record|
+              inverse_cached_association.write(child_record, record)
+            end
+          else
+            inverse_cached_association.write(association_target, record)
+          end
+        end
+
+        def hydrate_association_target(associated_class, dehydrated_value)
+          dehydrated_value = IdentityCache.unmap_cached_nil_for(dehydrated_value)
+          if dehydrated_value.is_a?(Array)
+            dehydrated_value.map { |coder| Encoder.decode(coder, associated_class) }
+          else
+            Encoder.decode(dehydrated_value, associated_class)
+          end
+        end
+
+        def embedded_fetched?(records)
+          record = records.first
+          super || record.instance_variable_defined?(dehydrated_variable_name)
+        end
+      end
+    end
+  end
+end