activerecord 4.0.4 → 4.1.16

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

@@ -2,7 +2,6 @@ module ActiveRecord
   module Associations
     class Preloader
       module ThroughAssociation #:nodoc:
-
         def through_reflection
           reflection.through_reflection
         end
@@ -11,51 +10,84 @@ module ActiveRecord
           reflection.source_reflection
         end
 
-        def associated_records_by_owner
-          through_records = through_records_by_owner
+        def associated_records_by_owner(preloader)
+          preloader.preload(owners,
+                            through_reflection.name,
+                            through_scope)
 
-          Preloader.new(through_records.values.flatten, source_reflection.name, reflection_scope).run
+          through_records = owners.map do |owner|
+            association = owner.association through_reflection.name
 
-          through_records.each do |owner, records|
-            records.map! { |r| r.send(source_reflection.name) }.flatten!
-            records.compact!
+            [owner, Array(association.reader)]
           end
-        end
 
-        private
+          reset_association owners, through_reflection.name
+
+          middle_records = through_records.map { |(_,rec)| rec }.flatten
+
+          preloaders = preloader.preload(middle_records,
+                                         source_reflection.name,
+                                         reflection_scope)
 
-        def through_records_by_owner
-          Preloader.new(owners, through_reflection.name, through_scope).run
+          @preloaded_records = preloaders.flat_map(&:preloaded_records)
+
+          middle_to_pl = preloaders.each_with_object({}) do |pl,h|
+            pl.owners.each { |middle|
+              h[middle] = pl
+            }
+          end
+
+          record_offset = {}
+          @preloaded_records.each_with_index do |record,i|
+            record_offset[record] = i
+          end
 
-          Hash[owners.map do |owner|
-            through_records = Array.wrap(owner.send(through_reflection.name))
+          through_records.each_with_object({}) { |(lhs,center),records_by_owner|
+            pl_to_middle = center.group_by { |record| middle_to_pl[record] }
 
-            # Dont cache the association - we would only be caching a subset
-            if (through_scope != through_reflection.klass.unscoped) ||
-               (reflection.options[:source_type] && through_reflection.collection?)
-              owner.association(through_reflection.name).reset
+            records_by_owner[lhs] = pl_to_middle.flat_map do |pl, middles|
+              rhs_records = middles.flat_map { |r|
+                association = r.association source_reflection.name
+
+                association.reader
+              }.compact
+
+              rhs_records.sort_by { |rhs| record_offset[rhs] }
             end
+          }
+        end
+
+        private
+
+        def reset_association(owners, association_name)
+          should_reset = (through_scope != through_reflection.klass.unscoped) ||
+             (reflection.options[:source_type] && through_reflection.collection?)
 
-            [owner, through_records]
-          end]
+          # Dont cache the association - we would only be caching a subset
+          if should_reset
+            owners.each { |owner|
+              owner.association(association_name).reset
+            }
+          end
         end
 
+
         def through_scope
-          through_scope = through_reflection.klass.unscoped
+          scope = through_reflection.klass.unscoped
 
           if options[:source_type]
-            through_scope.where! reflection.foreign_type => options[:source_type]
+            scope.where! reflection.foreign_type => options[:source_type]
           else
             unless reflection_scope.where_values.empty?
-              through_scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
-              through_scope.where_values    = reflection_scope.values[:where]
+              scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
+              scope.where_values    = reflection_scope.values[:where]
             end
 
-            through_scope.references! reflection_scope.values[:references]
-            through_scope.order! reflection_scope.values[:order] if through_scope.eager_loading?
+            scope.references! reflection_scope.values[:references]
+            scope.order! reflection_scope.values[:order] if scope.eager_loading?
           end
 
-          through_scope
+          scope
         end
       end
     end

data/lib/active_record/associations/preloader.rb

@@ -42,12 +42,9 @@ module ActiveRecord
         autoload :HasManyThrough,      'active_record/associations/preloader/has_many_through'
         autoload :HasOne,              'active_record/associations/preloader/has_one'
         autoload :HasOneThrough,       'active_record/associations/preloader/has_one_through'
-        autoload :HasAndBelongsToMany, 'active_record/associations/preloader/has_and_belongs_to_many'
         autoload :BelongsTo,           'active_record/associations/preloader/belongs_to'
       end
 
-      attr_reader :records, :associations, :preload_scope, :model
-
       # Eager loads the named associations for the given Active Record record(s).
       #
       # In this description, 'association name' shall refer to the name passed
@@ -82,38 +79,48 @@ module ActiveRecord
       #   [ :books, :author ]
       #   { author: :avatar }
       #   [ :books, { author: :avatar } ]
-      def initialize(records, associations, preload_scope = nil)
-        @records       = Array.wrap(records).compact.uniq
-        @associations  = Array.wrap(associations)
-        @preload_scope = preload_scope || Relation.new(nil, nil)
-      end
 
-      def run
-        unless records.empty?
-          associations.each { |association| preload(association) }
+      NULL_RELATION = Struct.new(:values).new({})
+
+      def preload(records, associations, preload_scope = nil)
+        records       = Array.wrap(records).compact.uniq
+        associations  = Array.wrap(associations)
+        preload_scope = preload_scope || NULL_RELATION
+
+        if records.empty?
+          []
+        else
+          associations.flat_map { |association|
+            preloaders_on association, records, preload_scope
+          }
         end
       end
 
       private
 
-      def preload(association)
+      def preloaders_on(association, records, scope)
         case association
         when Hash
-          preload_hash(association)
+          preloaders_for_hash(association, records, scope)
         when Symbol
-          preload_one(association)
+          preloaders_for_one(association, records, scope)
         when String
-          preload_one(association.to_sym)
+          preloaders_for_one(association.to_sym, records, scope)
         else
           raise ArgumentError, "#{association.inspect} was not recognised for preload"
         end
       end
 
-      def preload_hash(association)
-        association.each do |parent, child|
-          Preloader.new(records, parent, preload_scope).run
-          Preloader.new(records.map { |record| record.send(parent) }.flatten, child).run
-        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
 
       # Not all records have the same class, so group then preload group on the reflection
@@ -123,53 +130,60 @@ module ActiveRecord
       # 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 preload_one(association)
-        grouped_records(association).each do |reflection, klasses|
-          klasses.each do |klass, records|
-            preloader_for(reflection).new(klass, records, reflection, preload_scope).run
+      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, rhs_klass).new(rhs_klass, rs, reflection, scope)
+            loader.run self
+            loader
           end
         end
       end
 
-      def grouped_records(association)
-        Hash[
-          records_by_reflection(association).map do |reflection, records|
-            [reflection, records.group_by { |record| association_klass(reflection, record) }]
-          end
-        ]
+      def grouped_records(association, records)
+        h = {}
+        records.each do |record|
+          next unless record
+          assoc = record.association(association)
+          klasses = h[assoc.reflection] ||= {}
+          (klasses[assoc.klass] ||= []) << record
+        end
+        h
       end
 
-      def records_by_reflection(association)
-        records.group_by do |record|
-          record_class = record.class
-          reflection = record_class.reflections[association]
+      class AlreadyLoaded
+        attr_reader :owners, :reflection
 
-          unless reflection
-            raise ActiveRecord::ConfigurationError, "Association named '#{association}' was not found on #{record_class.name}; " \
-                                                    "perhaps you misspelled it?"
-          end
+        def initialize(klass, owners, reflection, preload_scope)
+          @owners = owners
+          @reflection = reflection
+        end
 
-          reflection
+        def run(preloader); end
+
+        def preloaded_records
+          owners.flat_map { |owner| owner.association(reflection.name).target }
         end
       end
 
-      def association_klass(reflection, record)
-        if reflection.macro == :belongs_to && reflection.options[:polymorphic]
-          klass = record.send(reflection.foreign_type)
-          klass && klass.constantize
-        else
-          reflection.klass
-        end
+      class NullPreloader
+        def self.new(klass, owners, reflection, preload_scope); self; end
+        def self.run(preloader); end
+        def self.preloaded_records; []; end
       end
 
-      def preloader_for(reflection)
+      def preloader_for(reflection, owners, rhs_klass)
+        return NullPreloader unless rhs_klass
+
+        if owners.first.association(reflection.name).loaded?
+          return AlreadyLoaded
+        end
+
         case reflection.macro
         when :has_many
           reflection.options[:through] ? HasManyThrough : HasMany
         when :has_one
           reflection.options[:through] ? HasOneThrough : HasOne
-        when :has_and_belongs_to_many
-          HasAndBelongsToMany
         when :belongs_to
           BelongsTo
         end

data/lib/active_record/associations/singular_association.rb

@@ -18,11 +18,11 @@ module ActiveRecord
       end
 
       def create(attributes = {}, &block)
-        create_record(attributes, &block)
+        _create_record(attributes, &block)
       end
 
       def create!(attributes = {}, &block)
-        create_record(attributes, true, &block)
+        _create_record(attributes, true, &block)
       end
 
       def build(attributes = {})
@@ -39,10 +39,11 @@ module ActiveRecord
         end
 
         def find_target
-          scope.take.tap { |record| set_inverse_instance(record) }
+          if record = scope.take
+            set_inverse_instance record
+          end
         end
 
-        # Implemented by subclasses
         def replace(record)
           raise NotImplementedError, "Subclasses must implement a replace(record) method"
         end
@@ -51,7 +52,7 @@ module ActiveRecord
           replace(record)
         end
 
-        def create_record(attributes, raise_error = false)
+        def _create_record(attributes, raise_error = false)
           record = build_record(attributes)
           yield(record) if block_given?
           saved = record.save

data/lib/active_record/associations/through_association.rb

@@ -13,10 +13,16 @@ module ActiveRecord
         #   2. To get the type conditions for any STI models in the chain
         def target_scope
           scope = super
-          chain[1..-1].each do |reflection|
+          chain.drop(1).each do |reflection|
+            relation = reflection.klass.all
+
+            reflection_scope = reflection.scope
+            if reflection_scope && reflection_scope.arity.zero?
+              relation.merge!(reflection_scope)
+            end
+
             scope.merge!(
-              reflection.klass.all.with_default_scope.
-                except(:select, :create_with, :includes, :preload, :joins, :eager_load)
+              relation.except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )
           end
           scope
@@ -39,12 +45,16 @@ module ActiveRecord
         def construct_join_attributes(*records)
           ensure_mutable
 
-          join_attributes = {
-            source_reflection.foreign_key =>
-              records.map { |record|
-                record.send(source_reflection.association_primary_key(reflection.klass))
-              }
-          }
+          if source_reflection.association_primary_key(reflection.klass) == reflection.klass.primary_key
+            join_attributes = { source_reflection.name => records }
+          else
+            join_attributes = {
+              source_reflection.foreign_key =>
+                records.map { |record|
+                  record.send(source_reflection.association_primary_key(reflection.klass))
+                }
+            }
+          end
 
           if options[:source_type]
             join_attributes[source_reflection.foreign_type] =
@@ -82,6 +92,17 @@ module ActiveRecord
             raise HasManyThroughNestedAssociationsAreReadonly.new(owner, reflection)
           end
         end
+
+        def build_record(attributes)
+          inverse = source_reflection.inverse_of
+          target = through_association.target
+
+          if inverse && target && !target.is_a?(Array)
+            attributes[inverse.foreign_key] = target.id
+          end
+
+          super(attributes)
+        end
     end
   end
 end