activerecord 7.0.8.7 → 7.2.2.1

data/lib/active_record/associations/has_many_association.rb

@@ -3,6 +3,7 @@
 module ActiveRecord
   module Associations
     # = Active Record Has Many Association
+    #
     # This is the proxy that handles a has many association.
     #
     # If the association has a <tt>:through</tt> option further specialization
@@ -33,20 +34,24 @@ module ActiveRecord
 
           unless target.empty?
             association_class = target.first.class
-            primary_key_column = association_class.primary_key.to_sym
-
-            ids = target.collect do |assoc|
-              assoc.public_send(primary_key_column)
+            if association_class.query_constraints_list
+              primary_key_column = association_class.query_constraints_list
+              ids = target.collect { |assoc| primary_key_column.map { |col| assoc.public_send(col) } }
+            else
+              primary_key_column = association_class.primary_key
+              ids = target.collect { |assoc| assoc.public_send(primary_key_column) }
             end
 
-            enqueue_destroy_association(
-              owner_model_name: owner.class.to_s,
-              owner_id: owner.id,
-              association_class: reflection.klass.to_s,
-              association_ids: ids,
-              association_primary_key_column: primary_key_column,
-              ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
-            )
+            ids.each_slice(owner.class.destroy_association_async_batch_size || ids.size) do |ids_batch|
+              enqueue_destroy_association(
+                owner_model_name: owner.class.to_s,
+                owner_id: owner.id,
+                association_class: reflection.klass.to_s,
+                association_ids: ids_batch,
+                association_primary_key_column: primary_key_column,
+                ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
+              )
+            end
           end
         else
           delete_all
@@ -73,7 +78,7 @@ module ActiveRecord
         # If the collection is empty the target is set to an empty array and
         # the loaded flag is set to true as well.
         def count_records
-          count = if reflection.has_cached_counter?
+          count = if reflection.has_active_cached_counter?
             owner.read_attribute(reflection.counter_cache_column).to_i
           else
             scope.count(:all)
@@ -124,7 +129,9 @@ module ActiveRecord
             records.each(&:destroy!)
             update_counter(-records.length) unless reflection.inverse_updates_counter_cache?
           else
-            scope = self.scope.where(reflection.klass.primary_key => records)
+            query_constraints = reflection.klass.composite_query_constraints_list
+            values = records.map { |r| query_constraints.map { |col| r._read_attribute(col) } }
+            scope = self.scope.where(query_constraints => values)
             update_counter(-delete_count(method, scope))
           end
         end

data/lib/active_record/associations/has_many_through_association.rb

@@ -59,9 +59,10 @@ module ActiveRecord
 
             attributes = through_scope_attributes
             attributes[source_reflection.name] = record
-            attributes[source_reflection.foreign_type] = options[:source_type] if options[:source_type]
 
-            through_association.build(attributes)
+            through_association.build(attributes).tap do |new_record|
+              new_record.send("#{source_reflection.foreign_type}=", options[:source_type]) if options[:source_type]
+            end
           end
         end
 
@@ -69,9 +70,12 @@ module ActiveRecord
 
         def through_scope_attributes
           scope = through_scope || self.scope
-          scope.where_values_hash(through_association.reflection.name.to_s).
-            except!(through_association.reflection.foreign_key,
-                    through_association.reflection.klass.inheritance_column)
+          attributes = scope.where_values_hash(through_association.reflection.klass.table_name)
+          except_keys = [
+            *Array(through_association.reflection.foreign_key),
+            through_association.reflection.klass.inheritance_column
+          ]
+          attributes.except!(*except_keys)
         end
 
         def save_through_record(record)
@@ -89,7 +93,13 @@ module ActiveRecord
           @through_scope = scope
           record = super
 
-          inverse = source_reflection.inverse_of
+          inverse =
+            if source_reflection.polymorphic?
+              source_reflection.polymorphic_inverse_of(record.class)
+            else
+              source_reflection.inverse_of
+            end
+
           if inverse
             if inverse.collection?
               record.send(inverse.name) << build_through_record(record)
@@ -109,7 +119,7 @@ module ActiveRecord
         end
 
         def target_reflection_has_associated_record?
-          !(through_reflection.belongs_to? && owner[through_reflection.foreign_key].blank?)
+          !(through_reflection.belongs_to? && Array(through_reflection.foreign_key).all? { |foreign_key_column| owner[foreign_key_column].blank? })
         end
 
         def update_through_counter?(method)

data/lib/active_record/associations/has_one_association.rb

@@ -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,
@@ -112,7 +117,9 @@ module ActiveRecord
         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, &block)

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

@@ -61,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
@@ -190,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
 
@@ -206,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
@@ -253,14 +253,14 @@ module ActiveRecord
             end
 
             if node.primary_key
-              key = aliases.column_alias(node, node.primary_key)
-              id = row[key]
+              keys = Array(node.primary_key).map { |column| aliases.column_alias(node, column) }
+              id = keys.map { |key| row[key] }
             else
-              key = aliases.column_alias(node, node.reflection.join_primary_key.to_s)
-              id = nil # Avoid id-based model caching.
+              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 row[key].nil?
+            if keys.any? { |key| row[key].nil? }
               nil_association = ar_parent.association(node.reflection.name)
               nil_association.loaded!
               next

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,5 +1,7 @@
 # frozen_string_literal: true
 
+# :enddoc:
+
 module ActiveRecord
   module Associations
     class Preloader
@@ -15,11 +17,12 @@ module ActiveRecord
           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.values_for_queries].hash
+            [association_key_name, scope.table_name, scope.connection_specification_name, scope.values_for_queries].hash
           end
 
           def records_for(loaders)
@@ -36,7 +39,21 @@ module ActiveRecord
           end
 
           def load_records_for_keys(keys, &block)
-            scope.where(association_key_name => keys).load(&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
 
@@ -151,7 +168,7 @@ module ActiveRecord
 
         def owners_by_key
           @owners_by_key ||= owners.each_with_object({}) do |owner, result|
-            key = convert_key(owner[owner_key_name])
+            key = derive_key(owner, owner_key_name)
             (result[key] ||= []) << owner if key
           end
         end
@@ -169,7 +186,7 @@ module ActiveRecord
         end
 
         def set_inverse(record)
-          if owners = owners_by_key[convert_key(record[association_key_name])]
+          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)
@@ -182,11 +199,10 @@ module ActiveRecord
           # #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[convert_key(record[association_key_name])]&.each do |owner|
+            owners_by_key[derive_key(record, association_key_name)]&.each do |owner|
               entries = (@records_by_owner[owner] ||= [])
 
               if reflection.collection? || entries.empty?
@@ -206,7 +222,7 @@ module ActiveRecord
           return if reflection.collection?
 
           unscoped_records.select { |r| r[association_key_name].present? }.each do |record|
-            owners = owners_by_key[convert_key(record[association_key_name])]
+            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
@@ -232,7 +248,8 @@ module ActiveRecord
             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
@@ -246,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

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

@@ -9,7 +9,13 @@ module ActiveRecord
         attr_writer :preloaded_records
 
         def initialize(association:, children:, parent:, associate_by_default:, scope:)
-          @association = association
+          @association = if association
+            begin
+              @association = association.to_sym
+            rescue NoMethodError
+              raise ArgumentError, "Association names must be Symbol or String, got: #{association.class.name}"
+            end
+          end
           @parent = parent
           @scope = scope
           @associate_by_default = associate_by_default

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

@@ -9,9 +9,7 @@ module ActiveRecord
         end
 
         def records_by_owner
-          return @records_by_owner if defined?(@records_by_owner)
-
-          @records_by_owner = owners.each_with_object({}) do |owner, result|
+          @records_by_owner ||= owners.each_with_object({}) do |owner, result|
             if loaded?(owner)
               result[owner] = target_for(owner)
               next

data/lib/active_record/associations/preloader.rb

@@ -4,6 +4,8 @@ require "active_support/core_ext/enumerable"
 
 module ActiveRecord
   module Associations
+    # = Active Record \Preloader
+    #
     # Implements the details of eager loading of Active Record associations.
     #
     # Suppose that you have the following two Active Record models:
@@ -22,8 +24,8 @@ module ActiveRecord
     #
     #   Author.includes(:books).where(name: ['bell hooks', 'Homer']).to_a
     #
-    #   => SELECT `authors`.* FROM `authors` WHERE `name` IN ('bell hooks', 'Homer')
-    #   => SELECT `books`.* FROM `books` WHERE `author_id` IN (2, 5)
+    #   # SELECT `authors`.* FROM `authors` WHERE `name` IN ('bell hooks', 'Homer')
+    #   # SELECT `books`.* FROM `books` WHERE `author_id` IN (2, 5)
     #
     # Active Record saves the ids of the records from the first query to use in
     # the second. Depending on the number of associations involved there can be
@@ -33,11 +35,11 @@ module ActiveRecord
     # Record will fall back to a slightly more resource-intensive single query:
     #
     #   Author.includes(:books).where(books: {title: 'Illiad'}).to_a
-    #   => SELECT `authors`.`id` AS t0_r0, `authors`.`name` AS t0_r1, `authors`.`age` AS t0_r2,
-    #             `books`.`id`   AS t1_r0, `books`.`title`  AS t1_r1, `books`.`sales` AS t1_r2
-    #      FROM `authors`
-    #      LEFT OUTER JOIN `books` ON `authors`.`id` =  `books`.`author_id`
-    #      WHERE `books`.`title` = 'Illiad'
+    #   # SELECT `authors`.`id` AS t0_r0, `authors`.`name` AS t0_r1, `authors`.`age` AS t0_r2,
+    #   #        `books`.`id`   AS t1_r0, `books`.`title`  AS t1_r1, `books`.`sales` AS t1_r2
+    #   # FROM `authors`
+    #   # LEFT OUTER JOIN `books` ON `authors`.`id` =  `books`.`author_id`
+    #   # WHERE `books`.`title` = 'Illiad'
     #
     # This could result in many rows that contain redundant data and it performs poorly at scale
     # and is therefore only used when necessary.
@@ -73,15 +75,16 @@ module ActiveRecord
       #   for an Author.
       # - an Array which specifies multiple association names. This array
       #   is processed recursively. For example, specifying <tt>[:avatar, :books]</tt>
-      #   allows this method to preload an author's avatar as well as all of his
+      #   allows this method to preload an author's avatar as well as all of their
       #   books.
       # - a Hash which specifies multiple association names, as well as
       #   association names for the to-be-preloaded association objects. For
       #   example, specifying <tt>{ author: :avatar }</tt> will preload a
       #   book's author, as well as that author's avatar.
       #
-      # +:associations+ has the same format as the +:include+ method in
-      # <tt>ActiveRecord::QueryMethods</tt>. So +associations+ could look like this:
+      # +:associations+ has the same format as the arguments to
+      # ActiveRecord::QueryMethods#includes. So +associations+ could look like
+      # this:
       #
       #   :books
       #   [ :books, :author ]

data/lib/active_record/associations/singular_association.rb

@@ -14,6 +14,12 @@ module ActiveRecord
         target
       end
 
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        super
+        @target = nil
+      end
+
       # Implements the writer method, e.g. foo.bar= for Foo.belongs_to :bar
       def writer(record)
         replace(record)
@@ -34,7 +40,7 @@ module ActiveRecord
 
       private
         def scope_for_create
-          super.except!(klass.primary_key)
+          super.except!(*Array(klass.primary_key))
         end
 
         def find_target

data/lib/active_record/associations/through_association.rb

@@ -7,6 +7,10 @@ module ActiveRecord
       delegate :source_reflection, to: :reflection
 
       private
+        def transaction(&block)
+          through_reflection.klass.transaction(&block)
+        end
+
         def through_reflection
           @through_reflection ||= begin
             refl = reflection.through_reflection
@@ -55,12 +59,11 @@ module ActiveRecord
 
           association_primary_key = source_reflection.association_primary_key(reflection.klass)
 
-          if association_primary_key == reflection.klass.primary_key && !options[:source_type]
+          if Array(association_primary_key) == reflection.klass.composite_query_constraints_list && !options[:source_type]
             join_attributes = { source_reflection.name => records }
           else
-            join_attributes = {
-              source_reflection.foreign_key => records.map(&association_primary_key.to_sym)
-            }
+            assoc_pk_values = records.map { |record| record._read_attribute(association_primary_key) }
+            join_attributes = { source_reflection.foreign_key => assoc_pk_values }
           end
 
           if options[:source_type]
@@ -78,12 +81,16 @@ module ActiveRecord
         # to try to properly support stale-checking for nested associations.
         def stale_state
           if through_reflection.belongs_to?
-            owner[through_reflection.foreign_key] && owner[through_reflection.foreign_key].to_s
+            Array(through_reflection.foreign_key).filter_map do |foreign_key_column|
+              owner[foreign_key_column]
+            end.presence
           end
         end
 
         def foreign_key_present?
-          through_reflection.belongs_to? && !owner[through_reflection.foreign_key].nil?
+          through_reflection.belongs_to? && Array(through_reflection.foreign_key).all? do |foreign_key_column|
+            !owner[foreign_key_column].nil?
+          end
         end
 
         def ensure_mutable
@@ -107,11 +114,15 @@ module ActiveRecord
         end
 
         def build_record(attributes)
-          inverse = source_reflection.inverse_of
-          target = through_association.target
-
-          if inverse && target && !target.is_a?(Array)
-            attributes[inverse.foreign_key] = target.id
+          if source_reflection.collection?
+            inverse = source_reflection.inverse_of
+            target = through_association.target
+
+            if inverse && target && !target.is_a?(Array)
+              Array(target.id).zip(Array(inverse.foreign_key)).map do |primary_key_value, foreign_key_column|
+                attributes[foreign_key_column] = primary_key_value
+              end
+            end
           end
 
           super