activerecord 7.0.0 → 7.1.2

data/lib/active_record/associations/collection_proxy.rb

@@ -2,6 +2,8 @@
 
 module ActiveRecord
   module Associations
+    # = Active Record Collection Proxy
+    #
     # Collection proxies in Active Record are middlemen between an
     # <tt>association</tt>, and its <tt>target</tt> result set.
     #
@@ -94,12 +96,12 @@ module ActiveRecord
       # receive:
       #
       #   person.pets.select(:name).first.person_id
-      #   # => ActiveModel::MissingAttributeError: missing attribute: person_id
+      #   # => ActiveModel::MissingAttributeError: missing attribute 'person_id' for Pet
       #
-      # *Second:* You can pass a block so it can be used just like Array#select.
+      # *Second:* You can pass a block so it can be used just like <tt>Array#select</tt>.
       # This builds an array of objects from the database for the scope,
       # converting them into an array and iterating through them using
-      # Array#select.
+      # <tt>Array#select</tt>.
       #
       #   person.pets.select { |pet| /oo/.match?(pet.name) }
       #   # => [
@@ -108,7 +110,7 @@ module ActiveRecord
       #   #    ]
 
       # Finds an object in the collection responding to the +id+. Uses the same
-      # rules as ActiveRecord::Base.find. Returns ActiveRecord::RecordNotFound
+      # rules as ActiveRecord::FinderMethods.find. Returns ActiveRecord::RecordNotFound
       # error if the object cannot be found.
       #
       #   class Person < ActiveRecord::Base
@@ -218,7 +220,7 @@ module ActiveRecord
       # :call-seq:
       #   third_to_last()
       #
-      # Same as #first except returns only the third-to-last record.
+      # Same as #last except returns only the third-to-last record.
 
       ##
       # :method: second_to_last
@@ -226,7 +228,7 @@ module ActiveRecord
       # :call-seq:
       #   second_to_last()
       #
-      # Same as #first except returns only the second-to-last record.
+      # Same as #last except returns only the second-to-last record.
 
       # Returns the last record, or the last +n+ records, from the collection.
       # If the collection is empty, the first form returns +nil+, and the second
@@ -260,7 +262,7 @@ module ActiveRecord
       end
 
       # Gives a record (or N records if a parameter is supplied) from the collection
-      # using the same rules as <tt>ActiveRecord::Base.take</tt>.
+      # using the same rules as ActiveRecord::FinderMethods.take.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets
@@ -382,7 +384,7 @@ module ActiveRecord
       #   # => [#<Pet id: 2, name: "Puff", group: "celebrities", person_id: 1>]
       #
       # If the supplied array has an incorrect association type, it raises
-      # an <tt>ActiveRecord::AssociationTypeMismatch</tt> error:
+      # an ActiveRecord::AssociationTypeMismatch error:
       #
       #   person.pets.replace(["doo", "ggie", "gaga"])
       #   # => ActiveRecord::AssociationTypeMismatch: Pet expected, got String
@@ -475,7 +477,7 @@ module ActiveRecord
 
       # Deletes the records of the collection directly from the database
       # ignoring the +:dependent+ option. Records are instantiated and it
-      # invokes +before_remove+, +after_remove+ , +before_destroy+ and
+      # invokes +before_remove+, +after_remove+, +before_destroy+, and
       # +after_destroy+ callbacks.
       #
       #   class Person < ActiveRecord::Base
@@ -930,7 +932,7 @@ module ActiveRecord
         @association
       end
 
-      # Returns a <tt>Relation</tt> object for the records in this association
+      # Returns a Relation object for the records in this association
       def scope
         @scope ||= @association.scope
       end
@@ -955,10 +957,13 @@ module ActiveRecord
       #   person.pets == other
       #   # => true
       #
+      #
+      # Note that unpersisted records can still be seen as equal:
+      #
       #   other = [Pet.new(id: 1), Pet.new(id: 2)]
       #
       #   person.pets == other
-      #   # => false
+      #   # => true
       def ==(other)
         load_target == other
       end
@@ -1102,13 +1107,18 @@ module ActiveRecord
         super
       end
 
+      def pretty_print(pp) # :nodoc:
+        load_target if find_from_target?
+        super
+      end
+
       delegate_methods = [
         QueryMethods,
         SpawnMethods,
       ].flat_map { |klass|
         klass.public_instance_methods(false)
       } - self.public_instance_methods(false) - [:select] + [
-        :scoping, :values, :insert, :insert_all, :insert!, :insert_all!, :upsert, :upsert_all
+        :scoping, :values, :insert, :insert_all, :insert!, :insert_all!, :upsert, :upsert_all, :load_async
       ]
 
       delegate(*delegate_methods, to: :scope)

data/lib/active_record/associations/foreign_association.rb

@@ -12,7 +12,7 @@ module ActiveRecord::Associations
 
     def nullified_owner_attributes
       Hash.new.tap do |attrs|
-        attrs[reflection.foreign_key] = nil
+        Array(reflection.foreign_key).each { |foreign_key| attrs[foreign_key] = nil }
         attrs[reflection.type] = nil if reflection.type.present?
       end
     end
@@ -22,8 +22,15 @@ module ActiveRecord::Associations
       def set_owner_attributes(record)
         return if options[:through]
 
-        key = owner._read_attribute(reflection.join_foreign_key)
-        record._write_attribute(reflection.join_primary_key, key)
+        primary_key_attribute_names = Array(reflection.join_primary_key)
+        foreign_key_attribute_names = Array(reflection.join_foreign_key)
+
+        primary_key_foreign_key_pairs = primary_key_attribute_names.zip(foreign_key_attribute_names)
+
+        primary_key_foreign_key_pairs.each do |primary_key, foreign_key|
+          value = owner._read_attribute(foreign_key)
+          record._write_attribute(primary_key, value)
+        end
 
         if reflection.type
           record._write_attribute(reflection.type, owner.class.polymorphic_name)

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.map(&:to_sym)
+              ids = target.collect { |assoc| primary_key_column.map { |col| assoc.public_send(col) } }
+            else
+              primary_key_column = association_class.primary_key.to_sym
+              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
@@ -79,10 +84,13 @@ module ActiveRecord
             scope.count(:all)
           end
 
-          # If there's nothing in the database and @target has no new records
-          # we are certain the current target is an empty array. This is a
-          # documented side-effect of the method that may avoid an extra SELECT.
-          loaded! if count == 0
+          # If there's nothing in the database, @target should only contain new
+          # records or be an empty array. This is a documented side-effect of
+          # the method that may avoid an extra SELECT.
+          if count == 0
+            target.select!(&:new_record?)
+            loaded!
+          end
 
           [association_scope.limit_value, count].compact.min
         end
@@ -121,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)
@@ -109,7 +113,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.map(&:to_sym)
+              id = primary_key_column.map { |col| target.public_send(col) }
+            else
+              primary_key_column = target.class.primary_key.to_sym
+              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.rb

@@ -252,35 +252,41 @@ 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) }
+              ids = keys.map { |key| row[key] }
+            else
+              keys = Array(node.reflection.join_primary_key).map { |column| aliases.column_alias(node, column.to_s) }
+              ids = 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
-              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)
+            ids.each do |id|
+              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 if id
+              end
             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/preloader/association.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :enddoc:
+
 module ActiveRecord
   module Associations
     class Preloader
@@ -36,7 +38,19 @@ module ActiveRecord
           end
 
           def load_records_for_keys(keys, &block)
-            scope.where(association_key_name => keys).load(&block)
+            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 +165,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 +183,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 +196,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 +219,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
@@ -246,6 +259,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/through_association.rb

@@ -74,7 +74,7 @@ module ActiveRecord
           end
 
           def middle_records
-            through_preloaders.flat_map(&:preloaded_records)
+            through_records_by_owner.values.flatten
           end
 
           def through_preloaders

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

@@ -34,7 +34,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] && owner[foreign_key_column].to_s
+            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