activerecord 3.1.10 → 4.2.11

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

@@ -1,153 +1,127 @@
+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|
-            parent == join_part
-          end
-        end
+        JoinInformation = Struct.new :joins, :binds
+
+        def join_constraints(foreign_table, foreign_klass, node, join_type, tables, scope_chain, chain)
+          joins         = []
+          bind_values   = []
+          tables        = tables.reverse
 
-        def join_to(relation)
-          tables        = @tables.dup
-          foreign_table = parent_table
-          foreign_klass = parent.active_record
+          scope_chain_index = 0
+          scope_chain = scope_chain.reverse
 
           # 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...
-              relation.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
+            join_keys   = reflection.join_keys(klass)
+            key         = join_keys.key
+            foreign_key = join_keys.foreign_key
+
+            constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
+
+            scope_chain_items = scope_chain[scope_chain_index].map do |item|
+              if item.is_a?(Relation)
+                item
+              else
+                ActiveRecord::Relation.create(klass, table).instance_exec(node, &item)
+              end
+            end
+            scope_chain_index += 1
+
+            klass_scope =
+              if klass.current_scope && klass.current_scope.values.blank?
+                klass.unscoped
+              else
+                klass.send(:build_default_scope, ActiveRecord::Relation.create(klass, table))
+              end
+            scope_chain_items.concat [klass_scope].compact
+
+            rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
+              left.merge right
             end
 
-            constraint = build_constraint(reflection, table, key, foreign_table, foreign_key)
+            if rel && !rel.arel.constraints.empty?
+              bind_values.concat rel.bind_values
+              constraint = constraint.and rel.arel.constraints
+            end
 
-            conditions = self.conditions[i].dup
-            conditions << { reflection.type => foreign_klass.base_class.name } if reflection.type
+            if reflection.type
+              value = foreign_klass.base_class.name
+              column = klass.columns_hash[reflection.type.to_s]
 
-            unless conditions.empty?
-              constraint = constraint.and(sanitize(conditions, table))
+              substitute = klass.connection.substitute_at(column)
+              bind_values.push [column, value]
+              constraint = constraint.and table[reflection.type].eq substitute
             end
 
-            relation.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
 
-          relation
+          JoinInformation.new joins, bind_values
         end
 
-        def build_constraint(reflection, table, key, foreign_table, foreign_key)
+        #  Builds equality condition.
+        #
+        #  Example:
+        #
+        #  class Physician < ActiveRecord::Base
+        #    has_many :appointments
+        #  end
+        #
+        #  If I execute `Physician.joins(:appointments).to_a` then
+        #    klass         # => Physician
+        #    table         # => #<Arel::Table @name="appointments" ...>
+        #    key           # =>  physician_id
+        #    foreign_table # => #<Arel::Table @name="physicians" ...>
+        #    foreign_key   # => id
+        #
+        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 conditions
-          @conditions ||= reflection.conditions.reverse
-        end
-
-        private
-
-        def interpolate(conditions)
-          if conditions.respond_to?(:to_proc)
-            instance_eval(&conditions)
-          else
-            conditions
-          end
-        end
-
       end
     end
   end

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

@@ -1,22 +1,20 @@
+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.active_record == active_record
-        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
-          active_record.table_name
+          base_klass.table_name
         end
       end
     end

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

@@ -1,41 +1,42 @@
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
-      # A JoinPart represents a part of a JoinDependency. It is an abstract class, inherited
+      # 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 :active_record
+        attr_reader :base_klass, :children
 
-        delegate :table_name, :column_names, :primary_key, :reflections, :arel_engine, :to => :active_record
+        delegate :table_name, :column_names, :primary_key, :to => :base_klass
 
-        def initialize(active_record)
-          @active_record = active_record
-          @cached_record = {}
-          @column_names_with_alias = nil
+        def initialize(base_klass, children)
+          @base_klass = base_klass
+          @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,33 +45,25 @@ 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
+        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 = {}
 
-        # An array of [column_name, alias] pairs for the table
-        def column_names_with_alias
-          unless @column_names_with_alias
-            @column_names_with_alias = []
+          index = 0
+          length = column_names_with_alias.length
 
-            ([primary_key] + (column_names - [primary_key])).each_with_index do |column_name, i|
-              @column_names_with_alias << [column_name, "#{aliased_prefix}_r#{i}"]
-            end
+          while index < length
+            column_name, alias_name = column_names_with_alias[index]
+            hash[column_name] = row[alias_name]
+            index += 1
           end
-          @column_names_with_alias
-        end
-
-        def extract_record(row)
-          Hash[column_names_with_alias.map{|cn, an| [cn, row[an]]}]
-        end
 
-        def record_id(row)
-          row[aliased_primary_key]
+          hash
         end
 
-        def instantiate(row)
-          @cached_record[record_id(row)] ||= active_record.send(:instantiate, extract_record(row))
+        def instantiate(row, aliases)
+          base_klass.instantiate(extract_record(row, aliases))
         end
       end
     end