activerecord 3.2.19 → 5.0.0

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

@@ -2,22 +2,16 @@ module ActiveRecord
   module Associations
     class Preloader
       class CollectionAssociation < Association #:nodoc:
-
         private
 
-        def build_scope
-          super.order(preload_options[:order] || options[:order])
-        end
-
-        def preload
-          associated_records_by_owner.each do |owner, records|
+        def preload(preloader)
+          associated_records_by_owner(preloader).each do |owner, records|
             association = owner.association(reflection.name)
             association.loaded!
             association.target.concat(records)
             records.each { |record| association.set_inverse_instance(record) }
           end
         end
-
       end
     end
   end

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

@@ -4,10 +4,14 @@ module ActiveRecord
       class HasManyThrough < CollectionAssociation #:nodoc:
         include ThroughAssociation
 
-        def associated_records_by_owner
-          super.each do |owner, records|
-            records.uniq! if options[:uniq]
+        def associated_records_by_owner(preloader)
+          records_by_owner = super
+
+          if reflection_scope.distinct_value
+            records_by_owner.each_value(&:uniq!)
           end
+
+          records_by_owner
         end
       end
     end

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

@@ -2,7 +2,6 @@ module ActiveRecord
   module Associations
     class Preloader
       class HasOne < SingularAssociation #:nodoc:
-
         def association_key_name
           reflection.foreign_key
         end
@@ -10,13 +9,6 @@ module ActiveRecord
         def owner_key_name
           reflection.active_record_primary_key
         end
-
-        private
-
-        def build_scope
-          super.order(preload_options[:order] || options[:order])
-        end
-
       end
     end
   end

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

@@ -5,13 +5,13 @@ module ActiveRecord
 
         private
 
-        def preload
-          associated_records_by_owner.each do |owner, associated_records|
+        def preload(preloader)
+          associated_records_by_owner(preloader).each do |owner, associated_records|
             record = associated_records.first
 
             association = owner.association(reflection.name)
             association.target = record
-            association.set_inverse_instance(record)
+            association.set_inverse_instance(record) if record
           end
         end
 

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,55 +10,98 @@ 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)
 
-          ActiveRecord::Associations::Preloader.new(
-            through_records.values.flatten,
-            source_reflection.name, options
-          ).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!
+            center = target_records_from_association(association)
+            [owner, Array(center)]
           end
-        end
 
-        private
+          reset_association owners, through_reflection.name
 
-        def through_records_by_owner
-          ActiveRecord::Associations::Preloader.new(
-            owners, through_reflection.name,
-            through_options
-          ).run
+          middle_records = through_records.flat_map { |(_,rec)| rec }
 
-          Hash[owners.map do |owner|
-            through_records = Array.wrap(owner.send(through_reflection.name))
+          preloaders = preloader.preload(middle_records,
+                                         source_reflection.name,
+                                         reflection_scope)
+
+          @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
 
-            # Dont cache the association - we would only be caching a subset
-            if (preload_options != through_options) ||
-               (reflection.options[:source_type] && through_reflection.collection?)
-              owner.association(through_reflection.name).reset
+          through_records.each_with_object({}) do |(lhs,center), records_by_owner|
+            pl_to_middle = center.group_by { |record| middle_to_pl[record] }
+
+            records_by_owner[lhs] = pl_to_middle.flat_map do |pl, middles|
+              rhs_records = middles.flat_map { |r|
+                association = r.association source_reflection.name
+
+                target_records_from_association(association)
+              }.compact
+
+              # Respect the order on `reflection_scope` if it exists, else use the natural order.
+              if reflection_scope.values[:order].present?
+                @id_map ||= id_to_index_map @preloaded_records
+                rhs_records.sort_by { |rhs| @id_map[rhs] }
+              else
+                rhs_records
+              end
             end
+          end
+        end
 
-            [owner, through_records]
-          end]
+        private
+
+        def id_to_index_map(ids)
+          id_map = {}
+          ids.each_with_index { |id, index| id_map[id] = index }
+          id_map
+        end
+
+        def reset_association(owners, association_name)
+          should_reset = (through_scope != through_reflection.klass.unscoped) ||
+             (reflection.options[:source_type] && through_reflection.collection?)
+
+          # Don't 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_options
-          through_options = {}
+
+        def through_scope
+          scope = through_reflection.klass.unscoped
 
           if options[:source_type]
-            through_options[:conditions] = { reflection.foreign_type => options[:source_type] }
+            scope.where! reflection.foreign_type => options[:source_type]
           else
-            if options[:conditions]
-              through_options[:include]    = options[:include] || options[:source]
-              through_options[:conditions] = options[:conditions]
+            unless reflection_scope.where_clause.empty?
+              scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
+              scope.where_clause = reflection_scope.where_clause
+            end
+
+            scope.references! reflection_scope.values[:references]
+            if scope.eager_loading? && order_values = reflection_scope.values[:order]
+              scope = scope.order(order_values)
             end
-            through_options[:order] = options[:order] if options.has_key?(:order)
           end
 
-          through_options
+          scope
+        end
+
+        def target_records_from_association(association)
+          association.loaded? ? association.target : association.reader
         end
       end
     end

data/lib/active_record/associations/preloader.rb

@@ -2,33 +2,42 @@ module ActiveRecord
   module Associations
     # Implements the details of eager loading of Active Record associations.
     #
-    # Note that 'eager loading' and 'preloading' are actually the same thing.
-    # However, there are two different eager loading strategies.
+    # Suppose that you have the following two Active Record models:
     #
-    # The first one is by using table joins. This was only strategy available
-    # prior to Rails 2.1. Suppose that you have an Author model with columns
-    # 'name' and 'age', and a Book model with columns 'name' and 'sales'. Using
-    # this strategy, Active Record would try to retrieve all data for an author
-    # and all of its books via a single query:
+    #   class Author < ActiveRecord::Base
+    #     # columns: name, age
+    #     has_many :books
+    #   end
     #
-    #   SELECT * FROM authors
-    #   LEFT OUTER JOIN books ON authors.id = books.id
-    #   WHERE authors.name = 'Ken Akamatsu'
+    #   class Book < ActiveRecord::Base
+    #     # columns: title, sales, author_id
+    #   end
     #
-    # However, this could result in many rows that contain redundant data. After
-    # having received the first row, we already have enough data to instantiate
-    # the Author object. In all subsequent rows, only the data for the joined
-    # 'books' table is useful; the joined 'authors' data is just redundant, and
-    # processing this redundant data takes memory and CPU time. The problem
-    # quickly becomes worse and worse as the level of eager loading increases
-    # (i.e. if Active Record is to eager load the associations' associations as
-    # well).
+    # When you load an author with all associated books Active Record will make
+    # multiple queries like this:
+    #
+    #   Author.includes(:books).where(name: ['bell hooks', 'Homer']).to_a
+    #
+    #   => SELECT `authors`.* FROM `authors` WHERE `name` IN ('bell hooks', 'Homer')
+    #   => SELECT `books`.* FROM `books` WHERE `author_id` IN (2, 5)
+    #
+    # Active Record saves the ids of the records from the first query to use in
+    # the second. Depending on the number of associations involved there can be
+    # arbitrarily many SQL queries made.
+    #
+    # However, if there is a WHERE clause that spans across tables Active
+    # Record will fall back to a slightly more resource-intensive single query:
+    #
+    #   Author.includes(:books).where(books: {title: 'Illiad'}).to_a
+    #   => SELECT `authors`.`id` AS t0_r0, `authors`.`name` AS t0_r1, `authors`.`age` AS t0_r2,
+    #             `books`.`id`   AS t1_r0, `books`.`title`  AS t1_r1, `books`.`sales` AS t1_r2
+    #      FROM `authors`
+    #      LEFT OUTER JOIN `books` ON `authors`.`id` =  `books`.`author_id`
+    #      WHERE `books`.`title` = 'Illiad'
+    #
+    # This could result in many rows that contain redundant data and it performs poorly at scale
+    # and is therefore only used when necessary.
     #
-    # The second strategy is to use multiple database queries, one for each
-    # level of association. Since Rails 2.1, this is the default strategy. In
-    # situations where a table join is necessary (e.g. when the +:conditions+
-    # option references an association's column), it will fallback to the table
-    # join strategy.
     class Preloader #:nodoc:
       extend ActiveSupport::Autoload
 
@@ -42,11 +51,10 @@ 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, :options, :model
+      NULL_RELATION = Struct.new(:values, :where_clause, :joins_values).new({}, Relation::WhereClause.empty, [])
 
       # Eager loads the named associations for the given Active Record record(s).
       #
@@ -72,7 +80,7 @@ module ActiveRecord
       #   books.
       # - a Hash which specifies multiple association names, as well as
       #   association names for the to-be-preloaded association objects. For
-      #   example, specifying <tt>{ :author => :avatar }</tt> will preload a
+      #   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
@@ -80,45 +88,55 @@ module ActiveRecord
       #
       #   :books
       #   [ :books, :author ]
-      #   { :author => :avatar }
-      #   [ :books, { :author => :avatar } ]
-      #
-      # +options+ contains options that will be passed to ActiveRecord::Base#find
-      # (which is called under the hood for preloading records). But it is passed
-      # only one level deep in the +associations+ argument, i.e. it's not passed
-      # to the child associations when +associations+ is a Hash.
-      def initialize(records, associations, options = {})
-        @records      = Array.wrap(records).compact.uniq
-        @associations = Array.wrap(associations)
-        @options      = options
-      end
+      #   { author: :avatar }
+      #   [ :books, { author: :avatar } ]
+      def preload(records, associations, preload_scope = nil)
+        records       = Array.wrap(records).compact.uniq
+        associations  = Array.wrap(associations)
+        preload_scope = preload_scope || NULL_RELATION
 
-      def run
-        unless records.empty?
-          associations.each { |association| preload(association) }
+        if records.empty?
+          []
+        else
+          associations.flat_map { |association|
+            preloaders_on association, records, preload_scope
+          }
         end
       end
 
       private
 
-      def preload(association)
+      # Loads all the given data into +records+ for the +association+.
+      def preloaders_on(association, records, scope)
         case association
         when Hash
-          preload_hash(association)
-        when String, Symbol
-          preload_one(association.to_sym)
+          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 recognised for preload"
+          raise ArgumentError, "#{association.inspect} was not recognized for preload"
         end
       end
 
-      def preload_hash(association)
-        association.each do |parent, child|
-          Preloader.new(records, parent, options).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
 
+      # 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
@@ -126,52 +144,66 @@ 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, options).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|
-          reflection = record.class.reflections[association]
+      class AlreadyLoaded # :nodoc:
+        attr_reader :owners, :reflection
 
-          unless reflection
-            raise ActiveRecord::ConfigurationError, "Association named '#{association}' was not found; " \
-                                                    "perhaps you misspelled it?"
-          end
+        def initialize(klass, owners, reflection, preload_scope)
+          @owners = owners
+          @reflection = reflection
+        end
+
+        def run(preloader); end
 
-          reflection
+        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 # :nodoc:
+        def self.new(klass, owners, reflection, preload_scope); self; end
+        def self.run(preloader); end
+        def self.preloaded_records; []; end
+        def self.owners; []; end
       end
 
-      def preloader_for(reflection)
+      # Returns a class containing the logic needed to load preload the data
+      # and attach it to a relation. For example +Preloader::Association+ or
+      # +Preloader::HasManyThrough+. The class returned implements a `run` method
+      # that accepts a preloader.
+      def preloader_for(reflection, owners, rhs_klass)
+        return NullPreloader unless rhs_klass
+
+        if owners.first.association(reflection.name).loaded?
+          return AlreadyLoaded
+        end
+        reflection.check_preloadable!
+
         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

@@ -3,7 +3,13 @@ module ActiveRecord
     class SingularAssociation < Association #:nodoc:
       # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
       def reader(force_reload = false)
-        if force_reload
+        if force_reload && klass
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Passing an argument to force an association to reload is now
+            deprecated and will be removed in Rails 5.1. Please call `reload`
+            on the parent object instead.
+          MSG
+
           klass.uncached { reload }
         elsif !loaded? || stale_target?
           reload
@@ -12,21 +18,21 @@ module ActiveRecord
         target
       end
 
-      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      # Implements the writer method, e.g. foo.bar= for Foo.belongs_to :bar
       def writer(record)
         replace(record)
       end
 
-      def create(attributes = {}, options = {}, &block)
-        create_record(attributes, options, &block)
+      def create(attributes = {}, &block)
+        _create_record(attributes, &block)
       end
 
-      def create!(attributes = {}, options = {}, &block)
-        create_record(attributes, options, true, &block)
+      def create!(attributes = {}, &block)
+        _create_record(attributes, true, &block)
       end
 
-      def build(attributes = {}, options = {})
-        record = build_record(attributes, options)
+      def build(attributes = {})
+        record = build_record(attributes)
         yield(record) if block_given?
         set_new_record(record)
         record
@@ -35,14 +41,30 @@ module ActiveRecord
       private
 
         def create_scope
-          scoped.scope_for_create.stringify_keys.except(klass.primary_key)
+          scope.scope_for_create.stringify_keys.except(klass.primary_key)
+        end
+
+        def get_records
+          return scope.limit(1).records if skip_statement_cache?
+
+          conn = klass.connection
+          sc = reflection.association_scope_cache(conn, owner) do
+            StatementCache.create(conn) { |params|
+              as = AssociationScope.create { params.bind }
+              target_scope.merge(as.scope(self, conn)).limit(1)
+            }
+          end
+
+          binds = AssociationScope.get_bind_values(owner, reflection.chain)
+          sc.execute binds, klass, klass.connection
         end
 
         def find_target
-          scoped.first.tap { |record| set_inverse_instance(record) }
+          if record = get_records.first
+            set_inverse_instance record
+          end
         end
 
-        # Implemented by subclasses
         def replace(record)
           raise NotImplementedError, "Subclasses must implement a replace(record) method"
         end
@@ -51,8 +73,8 @@ module ActiveRecord
           replace(record)
         end
 
-        def create_record(attributes, options, raise_error = false)
-          record = build_record(attributes, options)
+        def _create_record(attributes, raise_error = false)
+          record = build_record(attributes)
           yield(record) if block_given?
           saved = record.save
           set_new_record(record)