activerecord 3.2.22.5 → 5.2.8

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

@@ -1,158 +1,80 @@
+# frozen_string_literal: true
+
+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
-
-        alias :alias_suffix :parent_table_name
+        attr_reader :reflection, :tables
+        attr_accessor :table
 
-        def initialize(reflection, join_dependency, parent = nil)
-          reflection.check_validity!
+        def initialize(reflection, children)
+          super(reflection.klass, children)
 
-          if reflection.options[:polymorphic]
-            raise EagerLoadPolymorphicError.new(reflection)
-          end
-
-          super(reflection.klass)
-
-          @reflection      = reflection
-          @join_dependency = join_dependency
-          @parent          = parent
-          @join_type       = Arel::InnerJoin
-          @aliased_prefix  = "t#{ join_dependency.join_parts.size }"
-          @tables          = construct_tables.reverse
-        end
-
-        def ==(other)
-          other.class == self.class &&
-            other.reflection == reflection &&
-            other.parent == parent
+          @reflection = reflection
+          @tables     = nil
         end
 
-        def find_parent_in(other_join_dependency)
-          other_join_dependency.join_parts.detect do |join_part|
-            case parent
-            when JoinBase
-              parent.active_record == join_part.active_record
-            else
-              parent == join_part
-            end
-          end
+        def match?(other)
+          return true if self == other
+          super && reflection == other.reflection
         end
 
-        def join_to(relation)
-          tables        = @tables.dup
-          foreign_table = parent_table
-          foreign_klass = parent.active_record
+        def join_constraints(foreign_table, foreign_klass, join_type, alias_tracker)
+          joins = []
 
           # 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|
-            table = tables.shift
-
-            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
-            end
+          reflection.chain.reverse_each.with_index(1) do |reflection, i|
+            table = tables[-i]
+            klass = reflection.klass
 
-            constraint = build_constraint(reflection, table, key, foreign_table, foreign_key)
+            join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
 
-            conditions = self.conditions[i].dup
-            conditions << { reflection.type => foreign_klass.base_class.name } if reflection.type
+            arel = join_scope.arel(alias_tracker.aliases)
+            nodes = arel.constraints.first
 
-            unless conditions.empty?
-              constraint = constraint.and(sanitize(conditions, table))
+            others, children = nodes.children.partition do |node|
+              !fetch_arel_attribute(node) { |attr| attr.relation.name == table.name }
             end
+            nodes = table.create_and(children)
 
-            relation.from(join(table, constraint))
+            joins << table.create_join(table, table.create_on(nodes), join_type)
 
-            # The current table in this iteration becomes the foreign table in the next
-            foreign_table, foreign_klass = table, reflection.klass
-          end
-
-          relation
-        end
-
-        def build_constraint(reflection, table, key, foreign_table, foreign_key)
-          constraint = table[key].eq(foreign_table[foreign_key])
+            unless others.empty?
+              joins.concat arel.join_sources
+              append_constraints(joins.last, others)
+            end
 
-          if reflection.klass.finder_needs_type_condition?
-            constraint = table.create_and([
-              constraint,
-              reflection.klass.send(:type_condition, table)
-            ])
+            # The current table in this iteration becomes the foreign table in the next
+            foreign_table, foreign_klass = table, klass
           end
 
-          constraint
+          joins
         end
 
-        def join_relation(joining_relation)
-          self.join_type = Arel::OuterJoin
-          joining_relation.joins(self)
-        end
-
-        def table
-          tables.last
-        end
-
-        def aliased_table_name
-          table.table_alias || table.name
-        end
-
-        def conditions
-          @conditions ||= reflection.conditions.reverse
+        def tables=(tables)
+          @tables = tables
+          @table  = tables.first
         end
 
         private
-
-        def interpolate(conditions)
-          if conditions.respond_to?(:to_proc) && !conditions.is_a?(Hash)
-            instance_eval(&conditions)
-          else
-            conditions
+          def fetch_arel_attribute(value)
+            case value
+            when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
+              yield value.left.is_a?(Arel::Attributes::Attribute) ? value.left : value.right
+            end
           end
-        end
 
+          def append_constraints(join, constraints)
+            if join.is_a?(Arel::Nodes::StringJoin)
+              join_string = table.create_and(constraints.unshift(join.left))
+              join.left = Arel.sql(base_klass.connection.visitor.compile(join_string))
+            else
+              join.right.expr.children.concat(constraints)
+            end
+          end
       end
     end
   end

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

@@ -1,22 +1,21 @@
+# frozen_string_literal: true
+
+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"
-        end
+        attr_reader :table
 
-        def table
-          Arel::Table.new(table_name, arel_engine)
+        def initialize(base_klass, table, children)
+          super(base_klass, children)
+          @table = table
         end
 
-        def aliased_table_name
-          active_record.table_name
+        def match?(other)
+          return true if self == other
+          super && base_klass == other.base_klass
         end
       end
     end

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

@@ -1,76 +1,69 @@
+# frozen_string_literal: true
+
 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
-
-        def initialize(active_record)
-          @active_record = active_record
-          @cached_record = {}
-          @column_names_with_alias = nil
-        end
+        delegate :table_name, :column_names, :primary_key, to: :base_klass
 
-        def aliased_table
-          Arel::Nodes::TableAlias.new table, aliased_table_name
+        def initialize(base_klass, children)
+          @base_klass = base_klass
+          @children = children
         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
-          raise NotImplementedError
+        def each_children(&block)
+          children.each do |child|
+            yield self, child
+            child.each_children(&block)
+          end
         end
 
-        # The alias for the active_record's table
-        def aliased_table_name
+        # An Arel::Table for the active_record
+        def table
           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, &block)
+          base_klass.instantiate(extract_record(row, aliases), &block)
         end
       end
     end