activerecord 5.2.8 → 7.0.2

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Branch # :nodoc:
+        attr_reader :association, :children, :parent
+        attr_reader :scope, :associate_by_default
+        attr_writer :preloaded_records
+
+        def initialize(association:, children:, parent:, associate_by_default:, scope:)
+          @association = association
+          @parent = parent
+          @scope = scope
+          @associate_by_default = associate_by_default
+
+          @children = build_children(children)
+          @loaders = nil
+        end
+
+        def future_classes
+          (immediate_future_classes + children.flat_map(&:future_classes)).uniq
+        end
+
+        def immediate_future_classes
+          if parent.done?
+            loaders.flat_map(&:future_classes).uniq
+          else
+            likely_reflections.reject(&:polymorphic?).flat_map do |reflection|
+              reflection.
+                chain.
+                map(&:klass)
+            end.uniq
+          end
+        end
+
+        def target_classes
+          if done?
+            preloaded_records.map(&:klass).uniq
+          elsif parent.done?
+            loaders.map(&:klass).uniq
+          else
+            likely_reflections.reject(&:polymorphic?).map(&:klass).uniq
+          end
+        end
+
+        def likely_reflections
+          parent_classes = parent.target_classes
+          parent_classes.filter_map do |parent_klass|
+            parent_klass._reflect_on_association(@association)
+          end
+        end
+
+        def root?
+          parent.nil?
+        end
+
+        def source_records
+          @parent.preloaded_records
+        end
+
+        def preloaded_records
+          @preloaded_records ||= loaders.flat_map(&:preloaded_records)
+        end
+
+        def done?
+          root? || (@loaders && @loaders.all?(&:run?))
+        end
+
+        def runnable_loaders
+          loaders.flat_map(&:runnable_loaders).reject(&:run?)
+        end
+
+        def grouped_records
+          h = {}
+          polymorphic_parent = !root? && parent.polymorphic?
+          source_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
+
+        def preloaders_for_reflection(reflection, reflection_records)
+          reflection_records.group_by do |record|
+            klass = record.association(association).klass
+
+            if reflection.scope && reflection.scope.arity != 0
+              # For instance dependent scopes, the scope is potentially
+              # different for each record. To allow this we'll group each
+              # object separately into its own preloader
+              reflection_scope = reflection.join_scopes(klass.arel_table, klass.predicate_builder, klass, record).inject(&:merge!)
+            end
+
+            [klass, reflection_scope]
+          end.map do |(rhs_klass, reflection_scope), rs|
+            preloader_for(reflection).new(rhs_klass, rs, reflection, scope, reflection_scope, associate_by_default)
+          end
+        end
+
+        def polymorphic?
+          return false if root?
+          return @polymorphic if defined?(@polymorphic)
+
+          @polymorphic = source_records.any? do |record|
+            reflection = record.class._reflect_on_association(association)
+            reflection && reflection.options[:polymorphic]
+          end
+        end
+
+        def loaders
+          @loaders ||=
+            grouped_records.flat_map do |reflection, reflection_records|
+              preloaders_for_reflection(reflection, reflection_records)
+            end
+        end
+
+        private
+          def build_children(children)
+            Array.wrap(children).flat_map { |association|
+              Array(association).flat_map { |parent, child|
+                Branch.new(
+                  parent: self,
+                  association: parent,
+                  children: child,
+                  associate_by_default: associate_by_default,
+                  scope: scope
+                )
+              }
+            }
+          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)
+            if reflection.options[:through]
+              ThroughAssociation
+            else
+              Association
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -4,42 +4,83 @@ module ActiveRecord
   module Associations
     class Preloader
       class ThroughAssociation < Association # :nodoc:
-        def run(preloader)
-          already_loaded     = owners.first.association(through_reflection.name).loaded?
-          through_scope      = through_scope()
-          reflection_scope   = target_reflection_scope
-          through_preloaders = preloader.preload(owners, through_reflection.name, through_scope)
-          middle_records     = through_preloaders.flat_map(&:preloaded_records)
-          preloaders         = preloader.preload(middle_records, source_reflection.name, reflection_scope)
-          @preloaded_records = preloaders.flat_map(&:preloaded_records)
-
-          owners.each do |owner|
-            through_records = Array(owner.association(through_reflection.name).target)
-            if already_loaded
+        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)
+
+          @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 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
                 end
               end
-            else
-              owner.association(through_reflection.name).reset if through_scope
-            end
-            result = through_records.flat_map do |record|
-              association = record.association(source_reflection.name)
-              target = association.target
-              association.reset if preload_scope
-              target
             end
-            result.compact!
-            if reflection_scope
-              result.sort_by! { |rhs| preload_index[rhs] } if reflection_scope.order_values.any?
-              result.uniq! if reflection_scope.distinct_value
+
+            records = through_records.flat_map do |record|
+              source_records_by_owner[record]
             end
-            associate_records_to_owner(owner, result)
+
+            records.compact!
+            records.sort_by! { |rhs| preload_index[rhs] } if scope.order_values.any?
+            records.uniq! if scope.distinct_value
+            result[owner] = records
+          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 ||= ActiveRecord::Associations::Preloader.new(records: middle_records, associations: source_reflection.name, scope: scope, associate_by_default: false).loaders
+          end
+
+          def middle_records
+            through_preloaders.flat_map(&:preloaded_records)
+          end
+
+          def through_preloaders
+            @through_preloaders ||= ActiveRecord::Associations::Preloader.new(records: owners, associations: through_reflection.name, scope: through_scope, associate_by_default: false).loaders
+          end
+
           def through_reflection
             reflection.through_reflection
           end
@@ -48,9 +89,17 @@ 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 |(id, result), index|
-              result[id] = index
+            @preload_index ||= preloaded_records.each_with_object({}).with_index do |(record, result), index|
+              result[record] = index
             end
           end
 
@@ -58,11 +107,17 @@ 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)
+            end
+
             if options[:source_type]
               scope.where! reflection.foreign_type => options[:source_type]
             elsif !reflection_scope.where_clause.empty?
               scope.where_clause = reflection_scope.where_clause
-              values = reflection_scope.values
 
               if includes = values[:includes]
                 scope.includes!(source_reflection.name => includes)
@@ -71,7 +126,7 @@ module ActiveRecord
               end
 
               if values[:references] && !values[:references].empty?
-                scope.references!(values[:references])
+                scope.references_values |= values[:references]
               else
                 scope.references!(source_reflection.table_name)
               end
@@ -89,17 +144,7 @@ module ActiveRecord
               end
             end
 
-            scope unless scope.empty_scope?
-          end
-
-          def target_reflection_scope
-            if preload_scope
-              reflection_scope.merge(preload_scope)
-            elsif reflection.scope
-              reflection_scope
-            else
-              nil
-            end
+            cascade_strict_loading(scope)
           end
       end
     end

data/lib/active_record/associations/preloader.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/enumerable"
+
 module ActiveRecord
   module Associations
     # Implements the details of eager loading of Active Record associations.
@@ -39,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
@@ -58,7 +63,7 @@ module ActiveRecord
       # == Parameters
       # +records+ is an array of ActiveRecord::Base. This array needs not be flat,
       # i.e. +records+ itself may also contain arrays of records. In any case,
-      # +preload_associations+ will preload the all associations records by
+      # +preload_associations+ will preload all associations records by
       # flattening +records+.
       #
       # +associations+ specifies one or more associations that you want to
@@ -75,119 +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
-
-        if records.empty?
-          []
-        else
-          records.uniq!
-          Array.wrap(associations).flat_map { |association|
-            preloaders_on association, records, preload_scope
-          }
-        end
+      #
+      # +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
+
+        @tree = Branch.new(
+          parent: nil,
+          association: nil,
+          children: @associations,
+          associate_by_default: @associate_by_default,
+          scope: @scope
+        )
+        @tree.preloaded_records = @records
       end
 
-      private
-
-        # Loads all the given data into +records+ for the +association+.
-        def preloaders_on(association, records, scope)
-          case association
-          when Hash
-            preloaders_for_hash(association, records, scope)
-          when Symbol
-            preloaders_for_one(association, records, scope)
-          when String
-            preloaders_for_one(association.to_sym, records, scope)
-          else
-            raise ArgumentError, "#{association.inspect} was not recognized for preload"
-          end
-        end
-
-        def preloaders_for_hash(association, records, scope)
-          association.flat_map { |parent, child|
-            loaders = preloaders_for_one parent, records, scope
-
-            recs = loaders.flat_map(&:preloaded_records).uniq
-            loaders.concat Array.wrap(child).flat_map { |assoc|
-              preloaders_on assoc, recs, scope
-            }
-            loaders
-          }
-        end
-
-        # Loads all the given data into +records+ for a singular +association+.
-        #
-        # Functions by instantiating a preloader class such as Preloader::HasManyThrough 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)
-          grouped_records(association, records).flat_map do |reflection, klasses|
-            klasses.map do |rhs_klass, rs|
-              loader = preloader_for(reflection, rs).new(rhs_klass, rs, reflection, scope)
-              loader.run self
-              loader
-            end
-          end
-        end
-
-        def grouped_records(association, records)
-          h = {}
-          records.each do |record|
-            next unless record
-            assoc = record.association(association)
-            next unless assoc.klass
-            klasses = h[assoc.reflection] ||= {}
-            (klasses[assoc.klass] ||= []) << record
-          end
-          h
-        end
-
-        class AlreadyLoaded # :nodoc:
-          def initialize(klass, owners, reflection, preload_scope)
-            @owners = owners
-            @reflection = reflection
-          end
-
-          def run(preloader); end
+      def empty?
+        associations.nil? || records.length == 0
+      end
 
-          def preloaded_records
-            owners.flat_map { |owner| owner.association(reflection.name).target }
-          end
+      def call
+        Batch.new([self], available_records: @available_records).call
 
-          protected
-            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
@@ -17,7 +19,7 @@ module ActiveRecord
         replace(record)
       end
 
-      def build(attributes = {}, &block)
+      def build(attributes = nil, &block)
         record = build_record(attributes, &block)
         set_new_record(record)
         record
@@ -26,7 +28,7 @@ module ActiveRecord
       # Implements the reload reader method, e.g. foo.reload_bar for
       # Foo.has_one :bar
       def force_reload_reader
-        klass.uncached { reload }
+        reload(true)
         target
       end
 
@@ -36,21 +38,11 @@ module ActiveRecord
         end
 
         def find_target
-          scope = self.scope
-          return scope.take if skip_statement_cache?(scope)
-
-          conn = klass.connection
-          sc = reflection.association_scope_cache(conn, owner) do |params|
-            as = AssociationScope.create { params.bind }
-            target_scope.merge!(as.scope(self)).limit(1)
+          if disable_joins
+            scope.first
+          else
+            super.first
           end
-
-          binds = AssociationScope.get_bind_values(owner, reflection.chain)
-          sc.execute(binds, conn) do |record|
-            set_inverse_instance record
-          end.first
-        rescue ::RangeError
-          nil
         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
@@ -32,7 +32,7 @@ module ActiveRecord
           reflection.chain.drop(1).each do |reflection|
             relation = reflection.klass.scope_for_association
             scope.merge!(
-              relation.except(:select, :create_with, :includes, :preload, :joins, :eager_load)
+              relation.except(:select, :create_with, :includes, :preload, :eager_load, :joins, :left_outer_joins)
             )
           end
           scope
@@ -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