activerecord 5.0.7.2 → 6.1.1

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

@@ -1,19 +1,19 @@
-require 'active_record/associations/join_dependency/join_part'
+# frozen_string_literal: true
+
+require "active_record/associations/join_dependency/join_part"
+require "active_support/core_ext/array/extract"
 
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
       class JoinAssociation < JoinPart # :nodoc:
-        # The reflection of the association represented
-        attr_reader :reflection
-
-        attr_accessor :tables
+        attr_reader :reflection, :tables
+        attr_accessor :table
 
         def initialize(reflection, children)
           super(reflection.klass, children)
 
-          @reflection      = reflection
-          @tables          = nil
+          @reflection = reflection
         end
 
         def match?(other)
@@ -21,108 +21,82 @@ module ActiveRecord
           super && reflection == other.reflection
         end
 
-        JoinInformation = Struct.new :joins, :binds
+        def join_constraints(foreign_table, foreign_klass, join_type, alias_tracker)
+          joins = []
+          chain = []
 
-        def join_constraints(foreign_table, foreign_klass, node, join_type, tables, scope_chain, chain)
-          joins         = []
-          binds         = []
-          tables        = tables.reverse
+          reflection.chain.each do |reflection|
+            table, terminated = yield reflection
+            @table ||= table
 
-          scope_chain_index = 0
-          scope_chain = scope_chain.reverse
+            if terminated
+              foreign_table, foreign_klass = table, reflection.klass
+              break
+            end
+
+            chain << [reflection, table]
+          end
 
           # 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 do |reflection|
-            table = tables.shift
+          chain.reverse_each do |reflection, table|
             klass = reflection.klass
 
-            join_keys   = reflection.join_keys(klass)
-            key         = join_keys.key
-            foreign_key = join_keys.foreign_key
+            scope = reflection.join_scope(table, foreign_table, foreign_klass)
 
-            constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
+            unless scope.references_values.empty?
+              associations = scope.eager_load_values | scope.includes_values
 
-            predicate_builder = PredicateBuilder.new(TableMetadata.new(klass, table))
-            scope_chain_items = scope_chain[scope_chain_index].map do |item|
-              if item.is_a?(Relation)
-                item
-              else
-                ActiveRecord::Relation.create(klass, table, predicate_builder)
-                  .instance_exec(node, &item)
+              unless associations.empty?
+                scope.joins! scope.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
               end
             end
-            scope_chain_index += 1
 
-            relation = ActiveRecord::Relation.create(klass, table, predicate_builder)
-            current_scope = klass.current_scope
+            arel = scope.arel(alias_tracker.aliases)
+            nodes = arel.constraints.first
 
-            klass_scope =
-              if current_scope && current_scope.empty_scope?
-                relation
-              else
-                klass.send(:build_default_scope, relation)
+            if nodes.is_a?(Arel::Nodes::And)
+              others = nodes.children.extract! do |node|
+                !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
               end
-
-            rel = scope_chain_items.inject(klass_scope || scope_chain_items.shift, &:merge!)
-
-            if rel && !rel.arel.constraints.empty?
-              binds += rel.bound_attributes
-              constraint = constraint.and rel.arel.constraints
             end
 
-            if reflection.type
-              value = foreign_klass.base_class.name
-              column = klass.columns_hash[reflection.type.to_s]
+            joins << join_type.new(table, Arel::Nodes::On.new(nodes))
 
-              binds << Relation::QueryAttribute.new(column.name, value, klass.type_for_attribute(column.name))
-              constraint = constraint.and klass.arel_attribute(reflection.type, table).eq(Arel::Nodes::BindParam.new)
+            if others && !others.empty?
+              joins.concat arel.join_sources
+              append_constraints(joins.last, others)
             end
 
-            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, klass
           end
 
-          JoinInformation.new joins, binds
+          joins
         end
 
-        #  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 klass.finder_needs_type_condition?
-            constraint = table.create_and([
-              constraint,
-              klass.send(:type_condition, table)
-            ])
-          end
+        def readonly?
+          return @readonly if defined?(@readonly)
 
-          constraint
+          @readonly = reflection.scope && reflection.scope_for(base_klass.unscoped).readonly_value
         end
 
-        def table
-          tables.first
-        end
+        def strict_loading?
+          return @strict_loading if defined?(@strict_loading)
 
-        def aliased_table_name
-          table.table_alias || table.name
+          @strict_loading = reflection.scope && reflection.scope_for(base_klass.unscoped).strict_loading_value
         end
+
+        private
+          def append_constraints(join, constraints)
+            if join.is_a?(Arel::Nodes::StringJoin)
+              join_string = Arel::Nodes::And.new(constraints.unshift join.left)
+              join.left = Arel.sql(base_klass.connection.visitor.compile(join_string))
+            else
+              right = join.right
+              right.expr = Arel::Nodes::And.new(constraints.unshift right.expr)
+            end
+          end
       end
     end
   end

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

@@ -1,20 +1,21 @@
-require 'active_record/associations/join_dependency/join_part'
+# frozen_string_literal: true
+
+require "active_record/associations/join_dependency/join_part"
 
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
       class JoinBase < JoinPart # :nodoc:
-        def match?(other)
-          return true if self == other
-          super && base_klass == other.base_klass
-        end
+        attr_reader :table
 
-        def table
-          base_klass.arel_table
+        def initialize(base_klass, table, children)
+          super(base_klass, children)
+          @table = table
         end
 
-        def aliased_table_name
-          base_klass.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,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
@@ -15,17 +17,13 @@ module ActiveRecord
         # association.
         attr_reader :base_klass, :children
 
-        delegate :table_name, :column_names, :primary_key, :to => :base_klass
+        delegate :table_name, :column_names, :primary_key, :attribute_types, 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
@@ -35,13 +33,15 @@ module ActiveRecord
           children.each { |child| child.each(&block) }
         end
 
-        # An Arel::Table for the active_record
-        def table
-          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
 
@@ -54,16 +54,16 @@ module ActiveRecord
           length = column_names_with_alias.length
 
           while index < length
-            column_name, alias_name = column_names_with_alias[index]
-            hash[column_name] = row[alias_name]
+            column = column_names_with_alias[index]
+            hash[column.name] = row[column.alias]
             index += 1
           end
 
           hash
         end
 
-        def instantiate(row, aliases, &block)
-          base_klass.instantiate(extract_record(row, aliases), &block)
+        def instantiate(row, aliases, column_types = {}, &block)
+          base_klass.instantiate(extract_record(row, aliases), column_types, &block)
         end
       end
     end

data/lib/active_record/associations/preloader.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+
 module ActiveRecord
   module Associations
     # Implements the details of eager loading of Active Record associations.
@@ -42,20 +46,10 @@ module ActiveRecord
       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'
+        autoload :Association,        "active_record/associations/preloader/association"
+        autoload :ThroughAssociation, "active_record/associations/preloader/through_association"
       end
 
-      NULL_RELATION = Struct.new(:values, :where_clause, :joins_values).new({}, Relation::WhereClause.empty, [])
-
       # Eager loads the named associations for the given Active Record record(s).
       #
       # In this description, 'association name' shall refer to the name passed
@@ -66,7 +60,7 @@ module ActiveRecord
       # == 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
+      # +preload_associations+ will preload all associations records by
       # flattening +records+.
       #
       # +associations+ specifies one or more associations that you want to
@@ -91,123 +85,122 @@ module ActiveRecord
       #   { author: :avatar }
       #   [ :books, { author: :avatar } ]
       def preload(records, associations, preload_scope = nil)
-        records       = Array.wrap(records).compact.uniq
-        associations  = Array.wrap(associations)
-        preload_scope = preload_scope || NULL_RELATION
+        records = Array.wrap(records).compact
 
         if records.empty?
           []
         else
-          associations.flat_map { |association|
+          Array.wrap(associations).flat_map { |association|
             preloaders_on association, records, preload_scope
           }
         end
       end
 
-      private
-
-      # Loads all the given data into +records+ for the +association+.
-      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 recognized for preload"
-        end
+      def initialize(associate_by_default: true)
+        @associate_by_default = associate_by_default
       end
 
-      def preloaders_for_hash(association, records, scope)
-        association.flat_map { |parent, child|
-          loaders = preloaders_for_one parent, records, scope
+      private
+        # Loads all the given data into +records+ for the +association+.
+        def preloaders_on(association, records, scope, polymorphic_parent = false)
+          case association
+          when Hash
+            preloaders_for_hash(association, records, scope, polymorphic_parent)
+          when Symbol, String
+            preloaders_for_one(association, records, scope, polymorphic_parent)
+          else
+            raise ArgumentError, "#{association.inspect} was not recognized for preload"
+          end
+        end
 
-          recs = loaders.flat_map(&:preloaded_records).uniq
-          loaders.concat Array.wrap(child).flat_map { |assoc|
-            preloaders_on assoc, recs, scope
+        def preloaders_for_hash(association, records, scope, polymorphic_parent)
+          association.flat_map { |parent, child|
+            grouped_records(parent, records, polymorphic_parent).flat_map do |reflection, reflection_records|
+              loaders = preloaders_for_reflection(reflection, reflection_records, scope)
+              recs = loaders.flat_map(&:preloaded_records).uniq
+              child_polymorphic_parent = reflection && reflection.options[:polymorphic]
+              loaders.concat Array.wrap(child).flat_map { |assoc|
+                preloaders_on assoc, recs, scope, child_polymorphic_parent
+              }
+              loaders
+            end
           }
-          loaders
-        }
-      end
-
-      # Loads all the given data into +records+ for a singular +association+.
-      #
-      # Functions by instantiating a preloader class such as Preloader::HasManyThrough and
-      # call the +run+ method for each passed in class in the +records+ argument.
-      #
-      # 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
+        # Loads all the given data into +records+ for a singular +association+.
+        #
+        # Functions by instantiating a preloader class such as Preloader::Association and
+        # call the +run+ method for each passed in class in the +records+ argument.
+        #
+        # 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, polymorphic_parent)
+          grouped_records(association, records, polymorphic_parent)
+            .flat_map do |reflection, reflection_records|
+              preloaders_for_reflection reflection, reflection_records, scope
+            end
         end
-        h
-      end
 
-      class AlreadyLoaded # :nodoc:
-        attr_reader :owners, :reflection
+        def preloaders_for_reflection(reflection, records, scope)
+          records.group_by { |record| record.association(reflection.name).klass }.map do |rhs_klass, rs|
+            preloader_for(reflection, rs).new(rhs_klass, rs, reflection, scope, @associate_by_default).run
+          end
+        end
 
-        def initialize(klass, owners, reflection, preload_scope)
-          @owners = owners
-          @reflection = reflection
+        def grouped_records(association, records, polymorphic_parent)
+          h = {}
+          records.each do |record|
+            reflection = record.class._reflect_on_association(association)
+            next if polymorphic_parent && !reflection || !record.association(association).klass
+            (h[reflection] ||= []) << record
+          end
+          h
         end
 
-        def run(preloader); end
+        class AlreadyLoaded # :nodoc:
+          def initialize(klass, owners, reflection, preload_scope, associate_by_default = true)
+            @owners = owners
+            @reflection = reflection
+          end
 
-        def preloaded_records
-          owners.flat_map { |owner| owner.association(reflection.name).target }
-        end
-      end
+          def run
+            self
+          end
 
-      class NullPreloader # :nodoc:
-        def self.new(klass, owners, reflection, preload_scope); self; end
-        def self.run(preloader); end
-        def self.preloaded_records; []; end
-        def self.owners; []; end
-      end
+          def preloaded_records
+            @preloaded_records ||= records_by_owner.flat_map(&:last)
+          end
 
-      # Returns a class containing the logic needed to load preload the data
-      # and attach it to a relation. For example +Preloader::Association+ or
-      # +Preloader::HasManyThrough+. The class returned implements a `run` method
-      # that accepts a preloader.
-      def preloader_for(reflection, owners, rhs_klass)
-        return NullPreloader unless rhs_klass
+          def records_by_owner
+            @records_by_owner ||= owners.index_with do |owner|
+              Array(owner.association(reflection.name).target)
+            end
+          end
 
-        if owners.first.association(reflection.name).loaded?
-          return AlreadyLoaded
+          private
+            attr_reader :owners, :reflection
         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
+
+        # Returns a class containing the logic needed to load preload the data
+        # and attach it to a relation. The class returned implements a `run` method
+        # that accepts a preloader.
+        def preloader_for(reflection, owners)
+          if owners.all? { |o| o.association(reflection.name).loaded? }
+            return AlreadyLoaded
+          end
+          reflection.check_preloadable!
+
+          if reflection.options[:through]
+            ThroughAssociation
+          else
+            Association
+          end
         end
-      end
     end
   end
 end