activerecord 6.1.7 → 7.2.2

data/lib/active_record/associations/has_one_association.rb

@@ -3,7 +3,7 @@
 module ActiveRecord
   module Associations
     # = Active Record Has One Association
-    class HasOneAssociation < SingularAssociation #:nodoc:
+    class HasOneAssociation < SingularAssociation # :nodoc:
       include ForeignAssociation
 
       def handle_dependency
@@ -33,8 +33,13 @@ module ActiveRecord
             target.destroy
             throw(:abort) unless target.destroyed?
           when :destroy_async
-            primary_key_column = target.class.primary_key.to_sym
-            id = target.public_send(primary_key_column)
+            if target.class.query_constraints_list
+              primary_key_column = target.class.query_constraints_list
+              id = primary_key_column.map { |col| target.public_send(col) }
+            else
+              primary_key_column = target.class.primary_key
+              id = target.public_send(primary_key_column)
+            end
 
             enqueue_destroy_association(
               owner_model_name: owner.class.to_s,
@@ -70,7 +75,7 @@ module ActiveRecord
                 if save && !record.save
                   nullify_owner_attributes(record)
                   set_owner_attributes(target) if target
-                  raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+                  raise RecordNotSaved.new("Failed to save the new associated #{reflection.name}.", record)
                 end
               end
             end
@@ -102,19 +107,24 @@ module ActiveRecord
 
             if target.persisted? && owner.persisted? && !target.save
               set_owner_attributes(target)
-              raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " \
-                                    "The record failed to save after its foreign key was set to nil."
+              raise RecordNotSaved.new(
+                "Failed to remove the existing associated #{reflection.name}. " \
+                "The record failed to save after its foreign key was set to nil.",
+                target
+              )
             end
           end
         end
 
         def nullify_owner_attributes(record)
-          record[reflection.foreign_key] = nil
+          Array(reflection.foreign_key).each do |foreign_key_column|
+            record[foreign_key_column] = nil unless foreign_key_column.in?(Array(record.class.primary_key))
+          end
         end
 
-        def transaction_if(value)
+        def transaction_if(value, &block)
           if value
-            reflection.klass.transaction { yield }
+            reflection.klass.transaction(&block)
           else
             yield
           end
@@ -122,7 +132,7 @@ module ActiveRecord
 
         def _create_record(attributes, raise_error = false, &block)
           unless owner.persisted?
-            raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
+            raise ActiveRecord::RecordNotSaved.new("You cannot call create unless the parent is saved", owner)
           end
 
           super

data/lib/active_record/associations/has_one_through_association.rb

@@ -3,7 +3,7 @@
 module ActiveRecord
   module Associations
     # = Active Record Has One Through Association
-    class HasOneThroughAssociation < HasOneAssociation #:nodoc:
+    class HasOneThroughAssociation < HasOneAssociation # :nodoc:
       include ThroughAssociation
 
       private

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

@@ -25,8 +25,9 @@ module ActiveRecord
           joins = []
           chain = []
 
-          reflection.chain.each do |reflection|
-            table, terminated = yield reflection
+          reflection_chain = reflection.chain
+          reflection_chain.each_with_index do |reflection, index|
+            table, terminated = yield reflection, reflection_chain[index..]
             @table ||= table
 
             if terminated
@@ -37,39 +38,41 @@ module ActiveRecord
             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|
-            klass = reflection.klass
+          base_klass.with_connection do |connection|
+            # 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|
+              klass = reflection.klass
 
-            scope = reflection.join_scope(table, foreign_table, foreign_klass)
+              scope = reflection.join_scope(table, foreign_table, foreign_klass)
 
-            unless scope.references_values.empty?
-              associations = scope.eager_load_values | scope.includes_values
+              unless scope.references_values.empty?
+                associations = scope.eager_load_values | scope.includes_values
 
-              unless associations.empty?
-                scope.joins! scope.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
+                unless associations.empty?
+                  scope.joins! scope.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
+                end
               end
-            end
 
-            arel = scope.arel(alias_tracker.aliases)
-            nodes = arel.constraints.first
+              arel = scope.arel(alias_tracker.aliases)
+              nodes = arel.constraints.first
 
-            if nodes.is_a?(Arel::Nodes::And)
-              others = nodes.children.extract! do |node|
-                !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+              if nodes.is_a?(Arel::Nodes::And)
+                others = nodes.children.extract! do |node|
+                  !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+                end
               end
-            end
 
-            joins << join_type.new(table, Arel::Nodes::On.new(nodes))
+              joins << join_type.new(table, Arel::Nodes::On.new(nodes))
 
-            if others && !others.empty?
-              joins.concat arel.join_sources
-              append_constraints(joins.last, others)
-            end
+              if others && !others.empty?
+                joins.concat arel.join_sources
+                append_constraints(connection, joins.last, others)
+              end
 
-            # The current table in this iteration becomes the foreign table in the next
-            foreign_table, foreign_klass = table, klass
+              # The current table in this iteration becomes the foreign table in the next
+              foreign_table, foreign_klass = table, klass
+            end
           end
 
           joins
@@ -88,10 +91,10 @@ module ActiveRecord
         end
 
         private
-          def append_constraints(join, constraints)
+          def append_constraints(connection, 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))
+              join.left = Arel.sql(connection.visitor.compile(join_string))
             else
               right = join.right
               right.expr = Arel::Nodes::And.new(constraints.unshift right.expr)

data/lib/active_record/associations/join_dependency.rb

@@ -3,8 +3,12 @@
 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"
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :JoinBase
+        autoload :JoinAssociation
+      end
 
       class Aliases # :nodoc:
         def initialize(tables)
@@ -57,7 +61,7 @@ module ActiveRecord
         when Hash
           associations.each do |k, v|
             cache = hash[k] ||= {}
-            walk_tree v, cache
+            walk_tree v, cache if v
           end
         else
           raise ConfigurationError, associations.inspect
@@ -186,12 +190,12 @@ module ActiveRecord
         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]
+          child.join_constraints(foreign_table, foreign_klass, join_type, alias_tracker) do |reflection, remaining_reflection_chain|
+            table, terminated = @joined_tables[remaining_reflection_chain]
             root = reflection == child.reflection
 
             if table && (!root || !terminated)
-              @joined_tables[reflection] = [table, root] if root
+              @joined_tables[remaining_reflection_chain] = [table, root] if root
               next table, true
             end
 
@@ -202,7 +206,7 @@ module ActiveRecord
               root ? name : "#{name}_join"
             end
 
-            @joined_tables[reflection] ||= [table, root] if join_type == Arel::Nodes::OuterJoin
+            @joined_tables[remaining_reflection_chain] ||= [table, root] if join_type == Arel::Nodes::OuterJoin
             table
           end.concat child.children.flat_map { |c| make_constraints(child, c, join_type) }
         end
@@ -248,35 +252,39 @@ module ActiveRecord
               next
             end
 
-            key = aliases.column_alias(node, node.primary_key)
-            id = row[key]
-            if id.nil?
+            if node.primary_key
+              keys = Array(node.primary_key).map { |column| aliases.column_alias(node, column) }
+              id = keys.map { |key| row[key] }
+            else
+              keys = Array(node.reflection.join_primary_key).map { |column| aliases.column_alias(node, column.to_s) }
+              id = keys.map { nil } # Avoid id-based model caching.
+            end
+
+            if keys.any? { |key| row[key].nil? }
               nil_association = ar_parent.association(node.reflection.name)
               nil_association.loaded!
               next
             end
 
-            model = seen[ar_parent][node][id]
-
-            if model
-              construct(model, node, row, seen, model_cache, strict_loading_value)
-            else
+            unless model = seen[ar_parent][node][id]
               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)
+              seen[ar_parent][node][id] = model if id
             end
+
+            construct(model, node, row, seen, model_cache, strict_loading_value)
           end
         end
 
         def construct_model(record, node, row, model_cache, id, strict_loading_value)
           other = record.association(node.reflection.name)
 
-          model = model_cache[node][id] ||=
-            node.instantiate(row, aliases.column_aliases(node)) do |m|
+          unless model = model_cache[node][id]
+            model = node.instantiate(row, aliases.column_aliases(node)) do |m|
               m.strict_loading! if strict_loading_value
               other.set_inverse_instance(m)
             end
+            model_cache[node][id] = model if id
+          end
 
           if node.reflection.collection?
             other.target.push(model)

data/lib/active_record/associations/nested_error.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Validation error class to wrap association records' errors,
+# with index_errors support.
+module ActiveRecord
+  module Associations
+    class NestedError < ::ActiveModel::NestedError
+      def initialize(association, inner_error)
+        @base = association.owner
+        @association = association
+        @inner_error = inner_error
+        super(@base, inner_error, { attribute: compute_attribute(inner_error) })
+      end
+
+      private
+        attr_reader :association
+
+        def compute_attribute(inner_error)
+          association_name = association.reflection.name
+
+          if association.collection? && index_errors_setting && index
+            "#{association_name}[#{index}].#{inner_error.attribute}".to_sym
+          else
+            "#{association_name}.#{inner_error.attribute}".to_sym
+          end
+        end
+
+        def index_errors_setting
+          @index_errors_setting ||=
+            association.options.fetch(:index_errors, ActiveRecord.index_nested_attribute_errors)
+        end
+
+        def index
+          @index ||= ordered_records&.find_index(inner_error.base)
+        end
+
+        def ordered_records
+          case index_errors_setting
+          when true # default is association order
+            association.target
+          when :nested_attributes_order
+            association.nested_attributes_target
+          end
+        end
+    end
+  end
+end

data/lib/active_record/associations/preloader/association.rb

@@ -1,19 +1,141 @@
 # frozen_string_literal: true
 
+# :enddoc:
+
 module ActiveRecord
   module Associations
     class Preloader
-      class Association #:nodoc:
-        def initialize(klass, owners, reflection, preload_scope, associate_by_default = true)
+      class Association # :nodoc:
+        class LoaderQuery
+          attr_reader :scope, :association_key_name
+
+          def initialize(scope, association_key_name)
+            @scope = scope
+            @association_key_name = association_key_name
+          end
+
+          def eql?(other)
+            association_key_name == other.association_key_name &&
+              scope.table_name == other.scope.table_name &&
+              scope.connection_specification_name == other.scope.connection_specification_name &&
+              scope.values_for_queries == other.scope.values_for_queries
+          end
+
+          def hash
+            [association_key_name, scope.table_name, scope.connection_specification_name, scope.values_for_queries].hash
+          end
+
+          def records_for(loaders)
+            LoaderRecords.new(loaders, self).records
+          end
+
+          def load_records_in_batch(loaders)
+            raw_records = records_for(loaders)
+
+            loaders.each do |loader|
+              loader.load_records(raw_records)
+              loader.run
+            end
+          end
+
+          def load_records_for_keys(keys, &block)
+            return [] if keys.empty?
+
+            if association_key_name.is_a?(Array)
+              query_constraints = Hash.new { |hsh, key| hsh[key] = Set.new }
+
+              keys.each_with_object(query_constraints) do |values_set, constraints|
+                association_key_name.zip(values_set).each do |key_name, value|
+                  constraints[key_name] << value
+                end
+              end
+
+              scope.where(query_constraints)
+            else
+              scope.where(association_key_name => keys)
+            end.load(&block)
+          end
+        end
+
+        class LoaderRecords
+          def initialize(loaders, loader_query)
+            @loader_query = loader_query
+            @loaders = loaders
+            @keys_to_load = Set.new
+            @already_loaded_records_by_key = {}
+
+            populate_keys_to_load_and_already_loaded_records
+          end
+
+          def records
+            load_records + already_loaded_records
+          end
+
+          private
+            attr_reader :loader_query, :loaders, :keys_to_load, :already_loaded_records_by_key
+
+            def populate_keys_to_load_and_already_loaded_records
+              loaders.each do |loader|
+                loader.owners_by_key.each do |key, owners|
+                  if loaded_owner = owners.find { |owner| loader.loaded?(owner) }
+                    already_loaded_records_by_key[key] = loader.target_for(loaded_owner)
+                  else
+                    keys_to_load << key
+                  end
+                end
+              end
+
+              @keys_to_load.subtract(already_loaded_records_by_key.keys)
+            end
+
+            def load_records
+              loader_query.load_records_for_keys(keys_to_load) do |record|
+                loaders.each { |l| l.set_inverse(record) }
+              end
+            end
+
+            def already_loaded_records
+              already_loaded_records_by_key.values.flatten
+            end
+        end
+
+        attr_reader :klass
+
+        def initialize(klass, owners, reflection, preload_scope, reflection_scope, associate_by_default)
           @klass         = klass
           @owners        = owners.uniq(&:__id__)
           @reflection    = reflection
           @preload_scope = preload_scope
+          @reflection_scope = reflection_scope
           @associate     = associate_by_default || !preload_scope || preload_scope.empty_scope?
           @model         = owners.first && owners.first.class
+          @run = false
+        end
+
+        def table_name
+          @klass.table_name
+        end
+
+        def future_classes
+          if run?
+            []
+          else
+            [@klass]
+          end
+        end
+
+        def runnable_loaders
+          [self]
+        end
+
+        def run?
+          @run
         end
 
         def run
+          return self if run?
+          @run = true
+
           records = records_by_owner
 
           owners.each do |owner|
@@ -35,35 +157,85 @@ module ActiveRecord
           @preloaded_records
         end
 
-        private
-          attr_reader :owners, :reflection, :preload_scope, :model, :klass
+        # The name of the key on the associated records
+        def association_key_name
+          reflection.join_primary_key(klass)
+        end
 
-          def load_records
-            # owners can be duplicated when a relation has a collection association join
-            # #compare_by_identity makes such owners different hash keys
-            @records_by_owner = {}.compare_by_identity
-            raw_records = owner_keys.empty? ? [] : records_for(owner_keys)
+        def loader_query
+          LoaderQuery.new(scope, association_key_name)
+        end
 
-            @preloaded_records = raw_records.select do |record|
-              assignments = false
+        def owners_by_key
+          @owners_by_key ||= owners.each_with_object({}) do |owner, result|
+            key = derive_key(owner, owner_key_name)
+            (result[key] ||= []) << owner if key
+          end
+        end
 
-              owners_by_key[convert_key(record[association_key_name])].each do |owner|
-                entries = (@records_by_owner[owner] ||= [])
+        def loaded?(owner)
+          owner.association(reflection.name).loaded?
+        end
 
-                if reflection.collection? || entries.empty?
-                  entries << record
-                  assignments = true
-                end
-              end
+        def target_for(owner)
+          Array.wrap(owner.association(reflection.name).target)
+        end
 
-              assignments
+        def scope
+          @scope ||= build_scope
+        end
+
+        def set_inverse(record)
+          if owners = owners_by_key[derive_key(record, association_key_name)]
+            # Processing only the first owner
+            # because the record is modified but not an owner
+            association = owners.first.association(reflection.name)
+            association.set_inverse_instance(record)
+          end
+        end
+
+        def load_records(raw_records = nil)
+          # owners can be duplicated when a relation has a collection association join
+          # #compare_by_identity makes such owners different hash keys
+          @records_by_owner = {}.compare_by_identity
+          raw_records ||= loader_query.records_for([self])
+          @preloaded_records = raw_records.select do |record|
+            assignments = false
+
+            owners_by_key[derive_key(record, association_key_name)]&.each do |owner|
+              entries = (@records_by_owner[owner] ||= [])
+
+              if reflection.collection? || entries.empty?
+                entries << record
+                assignments = true
+              end
             end
+
+            assignments
           end
+        end
+
+        def associate_records_from_unscoped(unscoped_records)
+          return if unscoped_records.nil? || unscoped_records.empty?
+          return if !reflection_scope.empty_scope?
+          return if preload_scope && !preload_scope.empty_scope?
+          return if reflection.collection?
+
+          unscoped_records.select { |r| r[association_key_name].present? }.each do |record|
+            owners = owners_by_key[derive_key(record, association_key_name)]
+            owners&.each_with_index do |owner, i|
+              association = owner.association(reflection.name)
+              association.target = record
 
-          # The name of the key on the associated records
-          def association_key_name
-            reflection.join_primary_key(klass)
+              if i == 0 # Set inverse on first owner
+                association.set_inverse_instance(record)
+              end
+            end
           end
+        end
+
+        private
+          attr_reader :owners, :reflection, :preload_scope, :model
 
           # The name of the key on the model which declares the association
           def owner_key_name
@@ -71,25 +243,18 @@ module ActiveRecord
           end
 
           def associate_records_to_owner(owner, records)
+            return if loaded?(owner)
+
             association = owner.association(reflection.name)
+
             if reflection.collection?
-              association.target = records
+              not_persisted_records = association.target.reject(&:persisted?)
+              association.target = records + not_persisted_records
             else
               association.target = records.first
             end
           end
 
-          def owner_keys
-            @owner_keys ||= owners_by_key.keys
-          end
-
-          def owners_by_key
-            @owners_by_key ||= owners.each_with_object({}) do |owner, result|
-              key = convert_key(owner[owner_key_name])
-              (result[key] ||= []) << owner if key
-            end
-          end
-
           def key_conversion_required?
             unless defined?(@key_conversion_required)
               @key_conversion_required = (association_key_type != owner_key_type)
@@ -98,6 +263,14 @@ module ActiveRecord
             @key_conversion_required
           end
 
+          def derive_key(owner, key)
+            if key.is_a?(Array)
+              key.map { |k| convert_key(owner._read_attribute(k)) }
+            else
+              convert_key(owner._read_attribute(key))
+            end
+          end
+
           def convert_key(key)
             if key_conversion_required?
               key.to_s
@@ -114,20 +287,6 @@ module ActiveRecord
             @model.type_for_attribute(owner_key_name).type
           end
 
-          def records_for(ids)
-            scope.where(association_key_name => ids).load do |record|
-              # Processing only the first owner
-              # because the record is modified but not an owner
-              owner = owners_by_key[convert_key(record[association_key_name])].first
-              association = owner.association(reflection.name)
-              association.set_inverse_instance(record)
-            end
-          end
-
-          def scope
-            @scope ||= build_scope
-          end
-
           def reflection_scope
             @reflection_scope ||= reflection.join_scopes(klass.arel_table, klass.predicate_builder, klass).inject(klass.unscoped, &:merge!)
           end
@@ -145,11 +304,11 @@ module ActiveRecord
               scope.merge!(preload_scope)
             end
 
-            if preload_scope && preload_scope.strict_loading_value
-              scope.strict_loading
-            else
-              scope
-            end
+            cascade_strict_loading(scope)
+          end
+
+          def cascade_strict_loading(scope)
+            preload_scope&.strict_loading_value ? scope.strict_loading : scope
           end
       end
     end