activerecord 4.0.13 → 4.1.0.beta1

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

@@ -1,128 +1,80 @@
+require 'active_record/associations/join_dependency/join_part'
+
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
       class JoinAssociation < JoinPart # :nodoc:
-        include JoinHelper
-
         # The reflection of the association represented
         attr_reader :reflection
 
-        # The JoinDependency object which this JoinAssociation exists within. This is mainly
-        # relevant for generating aliases which do not conflict with other joins which are
-        # part of the query.
-        attr_reader :join_dependency
-
-        # A JoinBase instance representing the active record we are joining onto.
-        # (So in Author.has_many :posts, the Author would be that base record.)
-        attr_reader :parent
-
-        # What type of join will be generated, either Arel::InnerJoin (default) or Arel::OuterJoin
-        attr_accessor :join_type
-
-        # These implement abstract methods from the superclass
-        attr_reader :aliased_prefix
-
-        attr_reader :tables
-
-        delegate :options, :through_reflection, :source_reflection, :chain, :to => :reflection
-        delegate :table, :table_name, :to => :parent, :prefix => :parent
-        delegate :alias_tracker, :to => :join_dependency
+        attr_accessor :tables
 
-        alias :alias_suffix :parent_table_name
-
-        def initialize(reflection, join_dependency, parent = nil)
-          reflection.check_validity!
-
-          if reflection.options[:polymorphic]
-            raise EagerLoadPolymorphicError.new(reflection)
-          end
-
-          super(reflection.klass)
+        def initialize(reflection, children)
+          super(reflection.klass, children)
 
           @reflection      = reflection
-          @join_dependency = join_dependency
-          @parent          = parent
-          @join_type       = Arel::InnerJoin
-          @aliased_prefix  = "t#{ join_dependency.join_parts.size }"
-          @tables          = construct_tables.reverse
+          @tables          = nil
         end
 
-        def ==(other)
-          other.class == self.class &&
-            other.reflection == reflection &&
-            other.parent == parent
+        def match?(other)
+          return true if self == other
+          super && reflection == other.reflection
         end
 
-        def find_parent_in(other_join_dependency)
-          other_join_dependency.join_parts.detect do |join_part|
-            case parent
-            when JoinBase
-              parent.base_klass == join_part.base_klass
-            else
-              parent == join_part
-            end
-          end
-        end
+        def join_constraints(foreign_table, foreign_klass, node, join_type, tables, scope_chain, chain)
+          joins         = []
+          tables        = tables.reverse
 
-        def join_to(manager)
-          tables        = @tables.dup
-          foreign_table = parent_table
-          foreign_klass = parent.base_klass
+          scope_chain_iter = scope_chain.reverse_each
 
           # The chain starts with the target table, but we want to end with it here (makes
           # more sense in this context), so we reverse
-          chain.reverse.each_with_index do |reflection, i|
+          chain.reverse_each do |reflection|
             table = tables.shift
+            klass = reflection.klass
 
             case reflection.source_macro
             when :belongs_to
               key         = reflection.association_primary_key
               foreign_key = reflection.foreign_key
-            when :has_and_belongs_to_many
-              # Join the join table first...
-              manager.from(join(
-                table,
-                table[reflection.foreign_key].
-                  eq(foreign_table[reflection.active_record_primary_key])
-              ))
-
-              foreign_table, table = table, tables.shift
-
-              key         = reflection.association_primary_key
-              foreign_key = reflection.association_foreign_key
             else
               key         = reflection.foreign_key
               foreign_key = reflection.active_record_primary_key
             end
 
-            constraint = build_constraint(reflection, table, key, foreign_table, foreign_key)
+            constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
 
-            scope_chain_items = scope_chain[i]
+            scope_chain_items = scope_chain_iter.next.map do |item|
+              if item.is_a?(Relation)
+                item
+              else
+                ActiveRecord::Relation.create(klass, table).instance_exec(node, &item)
+              end
+            end
 
             if reflection.type
-              scope_chain_items += [
-                ActiveRecord::Relation.new(reflection.klass, table)
+              scope_chain_items <<
+                ActiveRecord::Relation.create(klass, table)
                   .where(reflection.type => foreign_klass.base_class.name)
-              ]
             end
 
-            scope_chain_items += [reflection.klass.send(:build_default_scope, ActiveRecord::Relation.new(reflection.klass, table))].compact
+            scope_chain_items.concat [klass.send(:build_default_scope)].compact
 
-            scope_chain_items.each do |item|
-              unless item.is_a?(Relation)
-                item = ActiveRecord::Relation.new(reflection.klass, table).instance_exec(self, &item)
-              end
+            rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
+              left.merge right
+            end
 
-              constraint = constraint.and(item.arel.constraints) unless item.arel.constraints.empty?
+            if rel && !rel.arel.constraints.empty?
+              constraint = constraint.and rel.arel.constraints
             end
 
-            manager.from(join(table, constraint))
+            joins << table.create_join(table, table.create_on(constraint), join_type)
 
             # The current table in this iteration becomes the foreign table in the next
-            foreign_table, foreign_klass = table, reflection.klass
+            foreign_table, foreign_klass = table, klass
           end
 
-          manager
+          joins
         end
 
         #  Builds equality condition.
@@ -134,42 +86,32 @@ module ActiveRecord
         #  end
         #
         #  If I execute `Physician.joins(:appointments).to_a` then
-        #    reflection    #=> #<ActiveRecord::Reflection::AssociationReflection @macro=:has_many ...>
-        #    table         #=> #<Arel::Table @name="appointments" ...>
-        #    key           #=>  physician_id
-        #    foreign_table #=> #<Arel::Table @name="physicians" ...>
-        #    foreign_key   #=> id
+        #    reflection    # => #<ActiveRecord::Reflection::AssociationReflection @macro=:has_many ...>
+        #    table         # => #<Arel::Table @name="appointments" ...>
+        #    key           # =>  physician_id
+        #    foreign_table # => #<Arel::Table @name="physicians" ...>
+        #    foreign_key   # => id
         #
-        def build_constraint(reflection, table, key, foreign_table, foreign_key)
+        def build_constraint(klass, table, key, foreign_table, foreign_key)
           constraint = table[key].eq(foreign_table[foreign_key])
 
-          if reflection.klass.finder_needs_type_condition?
+          if klass.finder_needs_type_condition?
             constraint = table.create_and([
               constraint,
-              reflection.klass.send(:type_condition, table)
+              klass.send(:type_condition, table)
             ])
           end
 
           constraint
         end
 
-        def join_relation(joining_relation)
-          self.join_type = Arel::OuterJoin
-          joining_relation.joins(self)
-        end
-
         def table
-          tables.last
+          tables.first
         end
 
         def aliased_table_name
           table.table_alias || table.name
         end
-
-        def scope_chain
-          @scope_chain ||= reflection.scope_chain.reverse
-        end
-
       end
     end
   end

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

@@ -1,18 +1,16 @@
+require 'active_record/associations/join_dependency/join_part'
+
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
       class JoinBase < JoinPart # :nodoc:
-        def ==(other)
-          other.class == self.class &&
-            other.base_klass == base_klass
-        end
-
-        def aliased_prefix
-          "t0"
+        def match?(other)
+          return true if self == other
+          super && base_klass == other.base_klass
         end
 
         def table
-          Arel::Table.new(table_name, arel_engine)
+          base_klass.arel_table
         end
 
         def aliased_table_name

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

@@ -8,34 +8,36 @@ module ActiveRecord
       # 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
+        attr_reader :base_klass, :children
 
-        delegate :table_name, :column_names, :primary_key, :reflections, :arel_engine, :to => :base_klass
+        delegate :table_name, :column_names, :primary_key, :to => :base_klass
 
-        def initialize(base_klass)
+        def initialize(base_klass, children)
           @base_klass = base_klass
-          @cached_record = {}
           @column_names_with_alias = nil
+          @children = children
         end
 
-        def aliased_table
-          Arel::Nodes::TableAlias.new table, aliased_table_name
+        def name
+          reflection.name
         end
 
-        def ==(other)
-          raise NotImplementedError
+        def match?(other)
+          self.class == other.class
         end
 
-        # An Arel::Table for the active_record
-        def table
-          raise NotImplementedError
+        def each(&block)
+          yield self
+          children.each { |child| child.each(&block) }
         end
 
-        # The prefix to be used when aliasing columns in the active_record's table
-        def aliased_prefix
+        # An Arel::Table for the active_record
+        def table
           raise NotImplementedError
         end
 
@@ -44,24 +46,7 @@ module ActiveRecord
           raise NotImplementedError
         end
 
-        # The alias for the primary key of the active_record's table
-        def aliased_primary_key
-          "#{aliased_prefix}_r0"
-        end
-
-        # An array of [column_name, alias] pairs for the table
-        def column_names_with_alias
-          unless @column_names_with_alias
-            @column_names_with_alias = []
-
-            ([primary_key] + (column_names - [primary_key])).compact.each_with_index do |column_name, i|
-              @column_names_with_alias << [column_name, "#{aliased_prefix}_r#{i}"]
-            end
-          end
-          @column_names_with_alias
-        end
-
-        def extract_record(row)
+        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 = {}
@@ -78,12 +63,8 @@ module ActiveRecord
           hash
         end
 
-        def record_id(row)
-          row[aliased_primary_key]
-        end
-
-        def instantiate(row)
-          @cached_record[record_id(row)] ||= base_klass.instantiate(extract_record(row))
+        def instantiate(row, aliases)
+          base_klass.instantiate(extract_record(row, aliases))
         end
       end
     end

data/lib/active_record/associations/join_helper.rb

@@ -10,21 +10,12 @@ module ActiveRecord
       private
 
       def construct_tables
-        tables = []
-        chain.each do |reflection|
-          tables << alias_tracker.aliased_table_for(
+        chain.map do |reflection|
+          alias_tracker.aliased_table_for(
             table_name_for(reflection),
             table_alias_for(reflection, reflection != self.reflection)
           )
-
-          if reflection.source_macro == :has_and_belongs_to_many
-            tables << alias_tracker.aliased_table_for(
-              (reflection.source_reflection || reflection).join_table,
-              table_alias_for(reflection, true)
-            )
-          end
         end
-        tables
       end
 
       def table_name_for(reflection)

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,47 @@ 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)
+        parent, child = association.to_a.first # hash should only be of length 1
+
+        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
+        }
       end
 
       # Not all records have the same class, so group then preload group on the reflection
@@ -123,32 +129,81 @@ 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)
-        h = {}
-        records.each do |record|
-          assoc = record.association(association)
-          klasses = h[assoc.reflection] ||= {}
-          (klasses[assoc.klass] ||= []) << record
+      def grouped_records(association, records)
+        reflection_records = records_by_reflection(association, records)
+
+        reflection_records.each_with_object({}) do |(reflection, r_records),h|
+          h[reflection] = r_records.group_by { |record|
+            association_klass(reflection, record)
+          }
+        end
+      end
+
+      def records_by_reflection(association, records)
+        records.group_by do |record|
+          reflection = record.class.reflect_on_association(association)
+
+          reflection || raise_config_error(record, association)
         end
-        h
       end
 
-      def preloader_for(reflection)
+      def raise_config_error(record, association)
+        raise ActiveRecord::ConfigurationError,
+              "Association named '#{association}' was not found on #{record.class.name}; " \
+              "perhaps you misspelled it?"
+      end
+
+      def association_klass(reflection, record)
+        if reflection.macro == :belongs_to && reflection.options[:polymorphic]
+          klass = record.read_attribute(reflection.foreign_type.to_s)
+          klass && klass.constantize
+        else
+          reflection.klass
+        end
+      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.read_attribute reflection.name }
+        end
+      end
+
+      class NullPreloader
+        def self.new(klass, owners, reflection, preload_scope); self; end
+        def self.run(preloader); end
+      end
+
+      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