activerecord 4.2.0

data/lib/active_record/associations/join_dependency/join_part.rb

@@ -0,0 +1,71 @@
+module ActiveRecord
+  module Associations
+    class JoinDependency # :nodoc:
+      # A JoinPart represents a part of a JoinDependency. It is inherited
+      # by JoinBase and JoinAssociation. A JoinBase represents the Active Record which
+      # everything else is being joined onto. A JoinAssociation represents an association which
+      # is joining to the base. A JoinAssociation may result in more than one actual join
+      # operations (for example a has_and_belongs_to_many JoinAssociation would result in
+      # two; one for the join table and one for the target table).
+      class JoinPart # :nodoc:
+        include Enumerable
+
+        # The Active Record class which this join part is associated 'about'; for a JoinBase
+        # this is the actual base model, for a JoinAssociation this is the target model of the
+        # association.
+        attr_reader :base_klass, :children
+
+        delegate :table_name, :column_names, :primary_key, :to => :base_klass
+
+        def initialize(base_klass, children)
+          @base_klass = base_klass
+          @children = children
+        end
+
+        def name
+          reflection.name
+        end
+
+        def match?(other)
+          self.class == other.class
+        end
+
+        def each(&block)
+          yield self
+          children.each { |child| child.each(&block) }
+        end
+
+        # An Arel::Table for the active_record
+        def table
+          raise NotImplementedError
+        end
+
+        # The alias for the active_record's table
+        def aliased_table_name
+          raise NotImplementedError
+        end
+
+        def extract_record(row, column_names_with_alias)
+          # This code is performance critical as it is called per row.
+          # see: https://github.com/rails/rails/pull/12185
+          hash = {}
+
+          index = 0
+          length = column_names_with_alias.length
+
+          while index < length
+            column_name, alias_name = column_names_with_alias[index]
+            hash[column_name] = row[alias_name]
+            index += 1
+          end
+
+          hash
+        end
+
+        def instantiate(row, aliases)
+          base_klass.instantiate(extract_record(row, aliases))
+        end
+      end
+    end
+  end
+end

data/lib/active_record/associations/preloader.rb

@@ -0,0 +1,203 @@
+module ActiveRecord
+  module Associations
+    # Implements the details of eager loading of Active Record associations.
+    #
+    # Suppose that you have the following two Active Record models:
+    #
+    #   class Author < ActiveRecord::Base
+    #     # columns: name, age
+    #     has_many :books
+    #   end
+    #
+    #   class Book < ActiveRecord::Base
+    #     # columns: title, sales
+    #   end
+    #
+    # 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.
+    #
+    class Preloader #:nodoc:
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :Association,           'active_record/associations/preloader/association'
+        autoload :SingularAssociation,   'active_record/associations/preloader/singular_association'
+        autoload :CollectionAssociation, 'active_record/associations/preloader/collection_association'
+        autoload :ThroughAssociation,    'active_record/associations/preloader/through_association'
+
+        autoload :HasMany,             'active_record/associations/preloader/has_many'
+        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 :BelongsTo,           'active_record/associations/preloader/belongs_to'
+      end
+
+      # Eager loads the named associations for the given Active Record record(s).
+      #
+      # In this description, 'association name' shall refer to the name passed
+      # to an association creation method. For example, a model that specifies
+      # <tt>belongs_to :author</tt>, <tt>has_many :buyers</tt> has association
+      # names +:author+ and +:buyers+.
+      #
+      # == 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
+      # flattening +records+.
+      #
+      # +associations+ specifies one or more associations that you want to
+      # preload. It may be:
+      # - a Symbol or a String which specifies a single association name. For
+      #   example, specifying +:books+ allows this method to preload all books
+      #   for an Author.
+      # - an Array which specifies multiple association names. This array
+      #   is processed recursively. For example, specifying <tt>[:avatar, :books]</tt>
+      #   allows this method to preload an author's avatar as well as all of his
+      #   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
+      #   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:
+      #
+      #   :books
+      #   [ :books, :author ]
+      #   { author: :avatar }
+      #   [ :books, { author: :avatar } ]
+
+      NULL_RELATION = Struct.new(:values, :bind_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 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 recognised 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
+
+      # 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, rhs_klass).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)
+          klasses = h[assoc.reflection] ||= {}
+          (klasses[assoc.klass] ||= []) << record
+        end
+        h
+      end
+
+      class AlreadyLoaded
+        attr_reader :owners, :reflection
+
+        def initialize(klass, owners, reflection, preload_scope)
+          @owners = owners
+          @reflection = reflection
+        end
+
+        def run(preloader); end
+
+        def preloaded_records
+          owners.flat_map { |owner| owner.association(reflection.name).target }
+        end
+      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, 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 :belongs_to
+          BelongsTo
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Association #:nodoc:
+        attr_reader :owners, :reflection, :preload_scope, :model, :klass
+        attr_reader :preloaded_records
+
+        def initialize(klass, owners, reflection, preload_scope)
+          @klass         = klass
+          @owners        = owners
+          @reflection    = reflection
+          @preload_scope = preload_scope
+          @model         = owners.first && owners.first.class
+          @scope         = nil
+          @owners_by_key = nil
+          @preloaded_records = []
+        end
+
+        def run(preloader)
+          preload(preloader)
+        end
+
+        def preload(preloader)
+          raise NotImplementedError
+        end
+
+        def scope
+          @scope ||= build_scope
+        end
+
+        def records_for(ids)
+          query_scope(ids)
+        end
+
+        def query_scope(ids)
+          scope.where(association_key.in(ids))
+        end
+
+        def table
+          klass.arel_table
+        end
+
+        # The name of the key on the associated records
+        def association_key_name
+          raise NotImplementedError
+        end
+
+        # This is overridden by HABTM as the condition should be on the foreign_key column in
+        # the join table
+        def association_key
+          table[association_key_name]
+        end
+
+        # The name of the key on the model which declares the association
+        def owner_key_name
+          raise NotImplementedError
+        end
+
+        def owners_by_key
+          @owners_by_key ||= if key_conversion_required?
+                               owners.group_by do |owner|
+                                 owner[owner_key_name].to_s
+                               end
+                             else
+                               owners.group_by do |owner|
+                                 owner[owner_key_name]
+                               end
+                             end
+        end
+
+        def options
+          reflection.options
+        end
+
+        private
+
+        def associated_records_by_owner(preloader)
+          owners_map = owners_by_key
+          owner_keys = owners_map.keys.compact
+
+          # Each record may have multiple owners, and vice-versa
+          records_by_owner = owners.each_with_object({}) do |owner,h|
+            h[owner] = []
+          end
+
+          if owner_keys.any?
+            # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
+            # Make several smaller queries if necessary or make one query if the adapter supports it
+            sliced  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
+
+            records = load_slices sliced
+            records.each do |record, owner_key|
+              owners_map[owner_key].each do |owner|
+                records_by_owner[owner] << record
+              end
+            end
+          end
+
+          records_by_owner
+        end
+
+        def key_conversion_required?
+          association_key_type != owner_key_type
+        end
+
+        def association_key_type
+          @klass.type_for_attribute(association_key_name.to_s).type
+        end
+
+        def owner_key_type
+          @model.type_for_attribute(owner_key_name.to_s).type
+        end
+
+        def load_slices(slices)
+          @preloaded_records = slices.flat_map { |slice|
+            records_for(slice)
+          }
+
+          @preloaded_records.map { |record|
+            key = record[association_key_name]
+            key = key.to_s if key_conversion_required?
+
+            [record, key]
+          }
+        end
+
+        def reflection_scope
+          @reflection_scope ||= reflection.scope ? klass.unscoped.instance_exec(nil, &reflection.scope) : klass.unscoped
+        end
+
+        def build_scope
+          scope = klass.unscoped
+
+          values         = reflection_scope.values
+          reflection_binds = reflection_scope.bind_values
+          preload_values = preload_scope.values
+          preload_binds  = preload_scope.bind_values
+
+          scope.where_values      = Array(values[:where])      + Array(preload_values[:where])
+          scope.references_values = Array(values[:references]) + Array(preload_values[:references])
+          scope.bind_values       = (reflection_binds + preload_binds)
+
+          scope._select!   preload_values[:select] || values[:select] || table[Arel.star]
+          scope.includes! preload_values[:includes] || values[:includes]
+          scope.joins! preload_values[:joins] || values[:joins]
+          scope.order! preload_values[:order] || values[:order]
+
+          if preload_values[:readonly] || values[:readonly]
+            scope.readonly!
+          end
+
+          if options[:as]
+            scope.where!(klass.table_name => { reflection.type => model.base_class.sti_name })
+          end
+
+          scope.unscope_values = Array(values[:unscope])
+          klass.default_scoped.merge(scope)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class BelongsTo < SingularAssociation #:nodoc:
+
+        def association_key_name
+          reflection.options[:primary_key] || klass && klass.primary_key
+        end
+
+        def owner_key_name
+          reflection.foreign_key
+        end
+
+      end
+    end
+  end
+end