activerecord 4.2.0 → 6.1.7.1

data/lib/active_record/associations/join_dependency.rb

@@ -1,52 +1,45 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
-      autoload :JoinBase,        'active_record/associations/join_dependency/join_base'
-      autoload :JoinAssociation, 'active_record/associations/join_dependency/join_association'
+      autoload :JoinBase,        "active_record/associations/join_dependency/join_base"
+      autoload :JoinAssociation, "active_record/associations/join_dependency/join_association"
 
       class Aliases # :nodoc:
         def initialize(tables)
           @tables = tables
-          @alias_cache = tables.each_with_object({}) { |table,h|
-            h[table.node] = table.columns.each_with_object({}) { |column,i|
+          @alias_cache = tables.each_with_object({}) { |table, h|
+            h[table.node] = table.columns.each_with_object({}) { |column, i|
               i[column.name] = column.alias
             }
           }
-          @name_and_alias_cache = tables.each_with_object({}) { |table,h|
-            h[table.node] = table.columns.map { |column|
-              [column.name, column.alias]
-            }
+          @columns_cache = tables.each_with_object({}) { |table, h|
+            h[table.node] = table.columns
           }
         end
 
         def columns
-          @tables.flat_map { |t| t.column_aliases }
+          @tables.flat_map(&:column_aliases)
         end
 
-        # An array of [column_name, alias] pairs for the table
         def column_aliases(node)
-          @name_and_alias_cache[node]
+          @columns_cache[node]
         end
 
         def column_alias(node, column)
           @alias_cache[node][column]
         end
 
-        class Table < Struct.new(:node, :columns)
-          def table
-            Arel::Nodes::TableAlias.new node.table, node.aliased_table_name
-          end
-
+        Table = Struct.new(:node, :columns) do # :nodoc:
           def column_aliases
-            t = table
-            columns.map { |column| t[column.name].as Arel.sql column.alias }
+            t = node.table
+            columns.map { |column| t[column.name].as(column.alias) }
           end
         end
         Column = Struct.new(:name, :alias)
       end
 
-      attr_reader :alias_tracker, :base_klass, :join_root
-
       def self.make_tree(associations)
         hash = {}
         walk_tree associations, hash
@@ -62,7 +55,7 @@ module ActiveRecord
             walk_tree assoc, hash
           end
         when Hash
-          associations.each do |k,v|
+          associations.each do |k, v|
             cache = hash[k] ||= {}
             walk_tree v, cache
           end
@@ -71,76 +64,69 @@ module ActiveRecord
         end
       end
 
-      # base is the base class on which operation is taking place.
-      # associations is the list of associations which are joined using hash, symbol or array.
-      # joins is the list of all string join commands and arel nodes.
-      #
-      #  Example :
-      #
-      #  class Physician < ActiveRecord::Base
-      #    has_many :appointments
-      #    has_many :patients, through: :appointments
-      #  end
-      #
-      #  If I execute `@physician.patients.to_a` then
-      #    base # => Physician
-      #    associations # => []
-      #    joins # =>  [#<Arel::Nodes::InnerJoin: ...]
-      #
-      #  However if I execute `Physician.joins(:appointments).to_a` then
-      #    base # => Physician
-      #    associations # => [:appointments]
-      #    joins # =>  []
-      #
-      def initialize(base, associations, joins)
-        @alias_tracker = AliasTracker.create(base.connection, joins)
-        @alias_tracker.aliased_table_for(base.table_name, base.table_name) # Updates the count for base.table_name to 1
+      def initialize(base, table, associations, join_type)
         tree = self.class.make_tree associations
-        @join_root = JoinBase.new base, build(tree, base)
-        @join_root.children.each { |child| construct_tables! @join_root, child }
+        @join_root = JoinBase.new(base, table, build(tree, base))
+        @join_type = join_type
+      end
+
+      def base_klass
+        join_root.base_klass
       end
 
       def reflections
         join_root.drop(1).map!(&:reflection)
       end
 
-      def join_constraints(outer_joins)
-        joins = join_root.children.flat_map { |child|
-          make_inner_joins join_root, child
-        }
+      def join_constraints(joins_to_add, alias_tracker, references)
+        @alias_tracker = alias_tracker
+        @joined_tables = {}
+        @references = {}
+
+        references.each do |table_name|
+          @references[table_name.to_sym] = table_name if table_name.is_a?(Arel::Nodes::SqlLiteral)
+        end unless references.empty?
 
-        joins.concat outer_joins.flat_map { |oj|
+        joins = make_join_constraints(join_root, join_type)
+
+        joins.concat joins_to_add.flat_map { |oj|
           if join_root.match? oj.join_root
-            walk join_root, oj.join_root
+            walk(join_root, oj.join_root, oj.join_type)
           else
-            oj.join_root.children.flat_map { |child|
-              make_outer_joins oj.join_root, child
-            }
+            make_join_constraints(oj.join_root, oj.join_type)
           end
         }
       end
 
-      def aliases
-        Aliases.new join_root.each_with_index.map { |join_part,i|
-          columns = join_part.column_names.each_with_index.map { |column_name,j|
-            Aliases::Column.new column_name, "t#{i}_r#{j}"
-          }
-          Aliases::Table.new(join_part, columns)
-        }
-      end
-
-      def instantiate(result_set, aliases)
+      def instantiate(result_set, strict_loading_value, &block)
         primary_key = aliases.column_alias(join_root, join_root.primary_key)
 
-        seen = Hash.new { |h,parent_klass|
-          h[parent_klass] = Hash.new { |i,parent_id|
-            i[parent_id] = Hash.new { |j,child_klass| j[child_klass] = {} }
+        seen = Hash.new { |i, parent|
+          i[parent] = Hash.new { |j, child_class|
+            j[child_class] = {}
           }
-        }
+        }.compare_by_identity
 
-        model_cache = Hash.new { |h,klass| h[klass] = {} }
+        model_cache = Hash.new { |h, klass| h[klass] = {} }
         parents = model_cache[join_root]
-        column_aliases = aliases.column_aliases join_root
+
+        column_aliases = aliases.column_aliases(join_root)
+        column_names = []
+
+        result_set.columns.each do |name|
+          column_names << name unless /\At\d+_r\d+\z/.match?(name)
+        end
+
+        if column_names.empty?
+          column_types = {}
+        else
+          column_types = result_set.column_types
+          unless column_types.empty?
+            attribute_types = join_root.attribute_types
+            column_types = column_types.slice(*column_names).delete_if { |k, _| attribute_types.key?(k) }
+          end
+          column_aliases += column_names.map! { |name| Aliases::Column.new(name, name) }
+        end
 
         message_bus = ActiveSupport::Notifications.instrumenter
 
@@ -149,134 +135,159 @@ module ActiveRecord
           class_name: join_root.base_klass.name
         }
 
-        message_bus.instrument('instantiation.active_record', payload) do
+        message_bus.instrument("instantiation.active_record", payload) do
           result_set.each { |row_hash|
-            parent = parents[row_hash[primary_key]] ||= join_root.instantiate(row_hash, column_aliases)
-            construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+            parent_key = primary_key ? row_hash[primary_key] : row_hash
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, column_types, &block)
+            construct(parent, join_root, row_hash, seen, model_cache, strict_loading_value)
           }
         end
 
         parents.values
       end
 
-      private
+      def apply_column_aliases(relation)
+        @join_root_alias = relation.select_values.empty?
+        relation._select!(-> { aliases.columns })
+      end
 
-      def make_constraints(parent, child, tables, join_type)
-        chain         = child.reflection.chain
-        foreign_table = parent.table
-        foreign_klass = parent.base_klass
-        child.join_constraints(foreign_table, foreign_klass, child, join_type, tables, child.reflection.scope_chain, chain)
+      def each(&block)
+        join_root.each(&block)
       end
 
-      def make_outer_joins(parent, child)
-        tables    = table_aliases_for(parent, child)
-        join_type = Arel::Nodes::OuterJoin
-        info      = make_constraints parent, child, tables, join_type
+      protected
+        attr_reader :join_root, :join_type
 
-        [info] + child.children.flat_map { |c| make_outer_joins(child, c) }
-      end
+      private
+        attr_reader :alias_tracker, :join_root_alias
+
+        def aliases
+          @aliases ||= Aliases.new join_root.each_with_index.map { |join_part, i|
+            column_names = if join_part == join_root && !join_root_alias
+              primary_key = join_root.primary_key
+              primary_key ? [primary_key] : []
+            else
+              join_part.column_names
+            end
 
-      def make_inner_joins(parent, child)
-        tables    = child.tables
-        join_type = Arel::Nodes::InnerJoin
-        info      = make_constraints parent, child, tables, join_type
+            columns = column_names.each_with_index.map { |column_name, j|
+              Aliases::Column.new column_name, "t#{i}_r#{j}"
+            }
+            Aliases::Table.new(join_part, columns)
+          }
+        end
 
-        [info] + child.children.flat_map { |c| make_inner_joins(child, c) }
-      end
+        def make_join_constraints(join_root, join_type)
+          join_root.children.flat_map do |child|
+            make_constraints(join_root, child, join_type)
+          end
+        end
 
-      def table_aliases_for(parent, node)
-        node.reflection.chain.map { |reflection|
-          alias_tracker.aliased_table_for(
-            reflection.table_name,
-            table_alias_for(reflection, parent, reflection != node.reflection)
-          )
-        }
-      end
+        def make_constraints(parent, child, join_type)
+          foreign_table = parent.table
+          foreign_klass = parent.base_klass
+          child.join_constraints(foreign_table, foreign_klass, join_type, alias_tracker) do |reflection|
+            table, terminated = @joined_tables[reflection]
+            root = reflection == child.reflection
 
-      def construct_tables!(parent, node)
-        node.tables = table_aliases_for(parent, node)
-        node.children.each { |child| construct_tables! node, child }
-      end
+            if table && (!root || !terminated)
+              @joined_tables[reflection] = [table, root] if root
+              next table, true
+            end
 
-      def table_alias_for(reflection, parent, join)
-        name = "#{reflection.plural_name}_#{parent.table_name}"
-        name << "_join" if join
-        name
-      end
+            table_name = @references[reflection.name.to_sym]&.to_s
 
-      def walk(left, right)
-        intersection, missing = right.children.map { |node1|
-          [left.children.find { |node2| node1.match? node2 }, node1]
-        }.partition(&:first)
+            table = alias_tracker.aliased_table_for(reflection.klass.arel_table, table_name) do
+              name = reflection.alias_candidate(parent.table_name)
+              root ? name : "#{name}_join"
+            end
 
-        ojs = missing.flat_map { |_,n| make_outer_joins left, n }
-        intersection.flat_map { |l,r| walk l, r }.concat ojs
-      end
+            @joined_tables[reflection] ||= [table, root] if join_type == Arel::Nodes::OuterJoin
+            table
+          end.concat child.children.flat_map { |c| make_constraints(child, c, join_type) }
+        end
 
-      def find_reflection(klass, name)
-        klass._reflect_on_association(name) or
-          raise ConfigurationError, "Association named '#{ name }' was not found on #{ klass.name }; perhaps you misspelled it?"
-      end
+        def walk(left, right, join_type)
+          intersection, missing = right.children.map { |node1|
+            [left.children.find { |node2| node1.match? node2 }, node1]
+          }.partition(&:first)
 
-      def build(associations, base_klass)
-        associations.map do |name, right|
-          reflection = find_reflection base_klass, name
-          reflection.check_validity!
-          reflection.check_eager_loadable!
+          joins = intersection.flat_map { |l, r| r.table = l.table; walk(l, r, join_type) }
+          joins.concat missing.flat_map { |_, n| make_constraints(left, n, join_type) }
+        end
 
-          if reflection.polymorphic?
-            raise EagerLoadPolymorphicError.new(reflection)
-          end
+        def find_reflection(klass, name)
+          klass._reflect_on_association(name) ||
+            raise(ConfigurationError, "Can't join '#{klass.name}' to association named '#{name}'; perhaps you misspelled it?")
+        end
+
+        def build(associations, base_klass)
+          associations.map do |name, right|
+            reflection = find_reflection base_klass, name
+            reflection.check_validity!
+            reflection.check_eager_loadable!
+
+            if reflection.polymorphic?
+              raise EagerLoadPolymorphicError.new(reflection)
+            end
 
-          JoinAssociation.new reflection, build(right, reflection.klass)
+            JoinAssociation.new(reflection, build(right, reflection.klass))
+          end
         end
-      end
 
-      def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
-        primary_id  = ar_parent.id
+        def construct(ar_parent, parent, row, seen, model_cache, strict_loading_value)
+          return if ar_parent.nil?
 
-        parent.children.each do |node|
-          if node.reflection.collection?
-            other = ar_parent.association(node.reflection.name)
-            other.loaded!
-          else
-            if ar_parent.association_cache.key?(node.reflection.name)
+          parent.children.each do |node|
+            if node.reflection.collection?
+              other = ar_parent.association(node.reflection.name)
+              other.loaded!
+            elsif ar_parent.association_cached?(node.reflection.name)
               model = ar_parent.association(node.reflection.name).target
-              construct(model, node, row, rs, seen, model_cache, aliases)
+              construct(model, node, row, seen, model_cache, strict_loading_value)
               next
             end
-          end
 
-          key = aliases.column_alias(node, node.primary_key)
-          id = row[key]
-          next if id.nil?
+            key = aliases.column_alias(node, node.primary_key)
+            id = row[key]
+            if id.nil?
+              nil_association = ar_parent.association(node.reflection.name)
+              nil_association.loaded!
+              next
+            end
 
-          model = seen[parent.base_klass][primary_id][node.base_klass][id]
+            model = seen[ar_parent][node][id]
 
-          if model
-            construct(model, node, row, rs, seen, model_cache, aliases)
-          else
-            model = construct_model(ar_parent, node, row, model_cache, id, aliases)
-            seen[parent.base_klass][primary_id][node.base_klass][id] = model
-            construct(model, node, row, rs, seen, model_cache, aliases)
+            if model
+              construct(model, node, row, seen, model_cache, strict_loading_value)
+            else
+              model = construct_model(ar_parent, node, row, model_cache, id, strict_loading_value)
+
+              seen[ar_parent][node][id] = model
+              construct(model, node, row, seen, model_cache, strict_loading_value)
+            end
           end
         end
-      end
 
-      def construct_model(record, node, row, model_cache, id, aliases)
-        model = model_cache[node][id] ||= node.instantiate(row,
-                                                           aliases.column_aliases(node))
-        other = record.association(node.reflection.name)
+        def construct_model(record, node, row, model_cache, id, strict_loading_value)
+          other = record.association(node.reflection.name)
 
-        if node.reflection.collection?
-          other.target.push(model)
-        else
-          other.target = model
-        end
+          model = model_cache[node][id] ||=
+            node.instantiate(row, aliases.column_aliases(node)) do |m|
+              m.strict_loading! if strict_loading_value
+              other.set_inverse_instance(m)
+            end
 
-        other.set_inverse_instance(model)
-        model
-      end
+          if node.reflection.collection?
+            other.target.push(model)
+          else
+            other.target = model
+          end
+
+          model.readonly! if node.readonly?
+          model.strict_loading! if node.strict_loading?
+          model
+        end
     end
   end
 end