activerecord 6.1.4.1 → 7.0.1

data/lib/active_record/associations/preloader/through_association.rb

@@ -4,26 +4,22 @@ module ActiveRecord
   module Associations
     class Preloader
       class ThroughAssociation < Association # :nodoc:
-        PRELOADER = ActiveRecord::Associations::Preloader.new(associate_by_default: false)
-
-        def initialize(*)
-          super
-          @already_loaded = owners.first.association(through_reflection.name).loaded?
-        end
-
         def preloaded_records
           @preloaded_records ||= source_preloaders.flat_map(&:preloaded_records)
         end
 
         def records_by_owner
           return @records_by_owner if defined?(@records_by_owner)
-          source_records_by_owner = source_preloaders.map(&:records_by_owner).reduce(:merge)
-          through_records_by_owner = through_preloaders.map(&:records_by_owner).reduce(:merge)
 
           @records_by_owner = owners.each_with_object({}) do |owner, result|
+            if loaded?(owner)
+              result[owner] = target_for(owner)
+              next
+            end
+
             through_records = through_records_by_owner[owner] || []
 
-            if @already_loaded
+            if owners.first.association(through_reflection.name).loaded?
               if source_type = reflection.options[:source_type]
                 through_records = through_records.select do |record|
                   record[reflection.foreign_type] == source_type
@@ -42,9 +38,39 @@ module ActiveRecord
           end
         end
 
+        def runnable_loaders
+          if data_available?
+            [self]
+          elsif through_preloaders.all?(&:run?)
+            source_preloaders.flat_map(&:runnable_loaders)
+          else
+            through_preloaders.flat_map(&:runnable_loaders)
+          end
+        end
+
+        def future_classes
+          if run?
+            []
+          elsif through_preloaders.all?(&:run?)
+            source_preloaders.flat_map(&:future_classes).uniq
+          else
+            through_classes = through_preloaders.flat_map(&:future_classes)
+            source_classes = source_reflection.
+              chain.
+              reject { |reflection| reflection.respond_to?(:polymorphic?) && reflection.polymorphic? }.
+              map(&:klass)
+            (through_classes + source_classes).uniq
+          end
+        end
+
         private
+          def data_available?
+            owners.all? { |owner| loaded?(owner) } ||
+              through_preloaders.all?(&:run?) && source_preloaders.all?(&:run?)
+          end
+
           def source_preloaders
-            @source_preloaders ||= PRELOADER.preload(middle_records, source_reflection.name, scope)
+            @source_preloaders ||= ActiveRecord::Associations::Preloader.new(records: middle_records, associations: source_reflection.name, scope: scope, associate_by_default: false).loaders
           end
 
           def middle_records
@@ -52,7 +78,7 @@ module ActiveRecord
           end
 
           def through_preloaders
-            @through_preloaders ||= PRELOADER.preload(owners, through_reflection.name, through_scope)
+            @through_preloaders ||= ActiveRecord::Associations::Preloader.new(records: owners, associations: through_reflection.name, scope: through_scope, associate_by_default: false).loaders
           end
 
           def through_reflection
@@ -63,6 +89,14 @@ module ActiveRecord
             reflection.source_reflection
           end
 
+          def source_records_by_owner
+            @source_records_by_owner ||= source_preloaders.map(&:records_by_owner).reduce(:merge)
+          end
+
+          def through_records_by_owner
+            @through_records_by_owner ||= through_preloaders.map(&:records_by_owner).reduce(:merge)
+          end
+
           def preload_index
             @preload_index ||= preloaded_records.each_with_object({}).with_index do |(record, result), index|
               result[record] = index
@@ -73,6 +107,8 @@ module ActiveRecord
             scope = through_reflection.klass.unscoped
             options = reflection.options
 
+            return scope if options[:disable_joins]
+
             values = reflection_scope.values
             if annotations = values[:annotate]
               scope.annotate!(*annotations)
@@ -108,7 +144,7 @@ module ActiveRecord
               end
             end
 
-            scope
+            cascade_strict_loading(scope)
           end
       end
     end

data/lib/active_record/associations/preloader.rb

@@ -41,15 +41,18 @@ module ActiveRecord
     #
     # This could result in many rows that contain redundant data and it performs poorly at scale
     # and is therefore only used when necessary.
-    #
-    class Preloader #:nodoc:
+    class Preloader # :nodoc:
       extend ActiveSupport::Autoload
 
       eager_autoload do
         autoload :Association,        "active_record/associations/preloader/association"
+        autoload :Batch,              "active_record/associations/preloader/batch"
+        autoload :Branch,             "active_record/associations/preloader/branch"
         autoload :ThroughAssociation, "active_record/associations/preloader/through_association"
       end
 
+      attr_reader :records, :associations, :scope, :associate_by_default
+
       # Eager loads the named associations for the given Active Record record(s).
       #
       # In this description, 'association name' shall refer to the name passed
@@ -77,130 +80,53 @@ module ActiveRecord
       #   example, specifying <tt>{ author: :avatar }</tt> will preload a
       #   book's author, as well as that author's avatar.
       #
-      # +:associations+ has the same format as the +:include+ option for
-      # <tt>ActiveRecord::Base.find</tt>. So +associations+ could look like this:
+      # +:associations+ has the same format as the +:include+ method in
+      # <tt>ActiveRecord::QueryMethods</tt>. So +associations+ could look like this:
       #
       #   :books
       #   [ :books, :author ]
       #   { author: :avatar }
       #   [ :books, { author: :avatar } ]
-      def preload(records, associations, preload_scope = nil)
-        records = Array.wrap(records).compact
+      #
+      # +available_records+ is an array of ActiveRecord::Base. The Preloader
+      # will try to use the objects in this array to preload the requested
+      # associations before querying the database. This can save database
+      # queries by reusing in-memory objects. The optimization is only applied
+      # to single associations (i.e. :belongs_to, :has_one) with no scopes.
+      def initialize(records:, associations:, scope: nil, available_records: [], associate_by_default: true)
+        @records = records
+        @associations = associations
+        @scope = scope
+        @available_records = available_records || []
+        @associate_by_default = associate_by_default
 
-        if records.empty?
-          []
-        else
-          Array.wrap(associations).flat_map { |association|
-            preloaders_on association, records, preload_scope
-          }
-        end
+        @tree = Branch.new(
+          parent: nil,
+          association: nil,
+          children: @associations,
+          associate_by_default: @associate_by_default,
+          scope: @scope
+        )
+        @tree.preloaded_records = @records
       end
 
-      def initialize(associate_by_default: true)
-        @associate_by_default = associate_by_default
+      def empty?
+        associations.nil? || records.length == 0
       end
 
-      private
-        # Loads all the given data into +records+ for the +association+.
-        def preloaders_on(association, records, scope, polymorphic_parent = false)
-          case association
-          when Hash
-            preloaders_for_hash(association, records, scope, polymorphic_parent)
-          when Symbol, String
-            preloaders_for_one(association, records, scope, polymorphic_parent)
-          else
-            raise ArgumentError, "#{association.inspect} was not recognized for preload"
-          end
-        end
-
-        def preloaders_for_hash(association, records, scope, polymorphic_parent)
-          association.flat_map { |parent, child|
-            grouped_records(parent, records, polymorphic_parent).flat_map do |reflection, reflection_records|
-              loaders = preloaders_for_reflection(reflection, reflection_records, scope)
-              recs = loaders.flat_map(&:preloaded_records).uniq
-              child_polymorphic_parent = reflection && reflection.options[:polymorphic]
-              loaders.concat Array.wrap(child).flat_map { |assoc|
-                preloaders_on assoc, recs, scope, child_polymorphic_parent
-              }
-              loaders
-            end
-          }
-        end
-
-        # Loads all the given data into +records+ for a singular +association+.
-        #
-        # Functions by instantiating a preloader class such as Preloader::Association and
-        # call the +run+ method for each passed in class in the +records+ argument.
-        #
-        # Not all records have the same class, so group then preload group on the reflection
-        # itself so that if various subclass share the same association then we do not split
-        # them unnecessarily
-        #
-        # Additionally, polymorphic belongs_to associations can have multiple associated
-        # classes, depending on the polymorphic_type field. So we group by the classes as
-        # well.
-        def preloaders_for_one(association, records, scope, polymorphic_parent)
-          grouped_records(association, records, polymorphic_parent)
-            .flat_map do |reflection, reflection_records|
-              preloaders_for_reflection reflection, reflection_records, scope
-            end
-        end
-
-        def preloaders_for_reflection(reflection, records, scope)
-          records.group_by { |record| record.association(reflection.name).klass }.map do |rhs_klass, rs|
-            preloader_for(reflection, rs).new(rhs_klass, rs, reflection, scope, @associate_by_default).run
-          end
-        end
+      def call
+        Batch.new([self], available_records: @available_records).call
 
-        def grouped_records(association, records, polymorphic_parent)
-          h = {}
-          records.each do |record|
-            reflection = record.class._reflect_on_association(association)
-            next if polymorphic_parent && !reflection || !record.association(association).klass
-            (h[reflection] ||= []) << record
-          end
-          h
-        end
-
-        class AlreadyLoaded # :nodoc:
-          def initialize(klass, owners, reflection, preload_scope, associate_by_default = true)
-            @owners = owners
-            @reflection = reflection
-          end
-
-          def run
-            self
-          end
-
-          def preloaded_records
-            @preloaded_records ||= records_by_owner.flat_map(&:last)
-          end
-
-          def records_by_owner
-            @records_by_owner ||= owners.index_with do |owner|
-              Array(owner.association(reflection.name).target)
-            end
-          end
-
-          private
-            attr_reader :owners, :reflection
-        end
+        loaders
+      end
 
-        # Returns a class containing the logic needed to load preload the data
-        # and attach it to a relation. The class returned implements a `run` method
-        # that accepts a preloader.
-        def preloader_for(reflection, owners)
-          if owners.all? { |o| o.association(reflection.name).loaded? }
-            return AlreadyLoaded
-          end
-          reflection.check_preloadable!
+      def branches
+        @tree.children
+      end
 
-          if reflection.options[:through]
-            ThroughAssociation
-          else
-            Association
-          end
-        end
+      def loaders
+        branches.flat_map(&:loaders)
+      end
     end
   end
 end

data/lib/active_record/associations/singular_association.rb

@@ -2,9 +2,11 @@
 
 module ActiveRecord
   module Associations
-    class SingularAssociation < Association #:nodoc:
+    class SingularAssociation < Association # :nodoc:
       # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
       def reader
+        ensure_klass_exists!
+
         if !loaded? || stale_target?
           reload
         end
@@ -36,7 +38,11 @@ module ActiveRecord
         end
 
         def find_target
-          super.first
+          if disable_joins
+            scope.first
+          else
+            super.first
+          end
         end
 
         def replace(record)

data/lib/active_record/associations/through_association.rb

@@ -3,7 +3,7 @@
 module ActiveRecord
   module Associations
     # = Active Record Through Association
-    module ThroughAssociation #:nodoc:
+    module ThroughAssociation # :nodoc:
       delegate :source_reflection, to: :reflection
 
       private
@@ -74,8 +74,8 @@ module ActiveRecord
           end
         end
 
-        # Note: this does not capture all cases, for example it would be crazy to try to
-        # properly support stale-checking for nested associations.
+        # Note: this does not capture all cases, for example it would be impractical
+        # to try to properly support stale-checking for nested associations.
         def stale_state
           if through_reflection.belongs_to?
             owner[through_reflection.foreign_key] && owner[through_reflection.foreign_key].to_s