activerecord 6.1.7 → 7.1.5

data/lib/active_record/associations/builder/belongs_to.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class BelongsTo < SingularAssociation #:nodoc:
+  class BelongsTo < SingularAssociation # :nodoc:
     def self.macro
       :belongs_to
     end
@@ -30,17 +30,17 @@ module ActiveRecord::Associations::Builder # :nodoc:
       model.after_update lambda { |record|
         association = association(reflection.name)
 
-        if association.target_changed?
+        if association.saved_change_to_target?
           association.increment_counters
           association.decrement_counters_before_last_save
         end
       }
 
       klass = reflection.class_name.safe_constantize
-      klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
+      klass._counter_cache_columns |= [cache_column] if klass && klass.respond_to?(:_counter_cache_columns)
     end
 
-    def self.touch_record(o, changes, foreign_key, name, touch, touch_method) # :nodoc:
+    def self.touch_record(o, changes, foreign_key, name, touch) # :nodoc:
       old_foreign_id = changes[foreign_key] && changes[foreign_key].first
 
       if old_foreign_id
@@ -49,7 +49,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
         if reflection.polymorphic?
           foreign_type = reflection.foreign_type
           klass = changes[foreign_type] && changes[foreign_type].first || o.public_send(foreign_type)
-          klass = klass.constantize
+          klass = o.class.polymorphic_class_for(klass)
         else
           klass = association.klass
         end
@@ -58,9 +58,9 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
         if old_record
           if touch != true
-            old_record.public_send(touch_method, touch)
+            old_record.touch_later(touch)
           else
-            old_record.public_send(touch_method)
+            old_record.touch_later
           end
         end
       end
@@ -68,9 +68,9 @@ module ActiveRecord::Associations::Builder # :nodoc:
       record = o.public_send name
       if record && record.persisted?
         if touch != true
-          record.public_send(touch_method, touch)
+          record.touch_later(touch)
         else
-          record.public_send(touch_method)
+          record.touch_later
         end
       end
     end
@@ -81,13 +81,13 @@ module ActiveRecord::Associations::Builder # :nodoc:
       touch       = reflection.options[:touch]
 
       callback = lambda { |changes_method| lambda { |record|
-        BelongsTo.touch_record(record, record.send(changes_method), foreign_key, name, touch, belongs_to_touch_method)
+        BelongsTo.touch_record(record, record.send(changes_method), foreign_key, name, touch)
       }}
 
       if reflection.counter_cache_column
         touch_callback = callback.(:saved_changes)
         update_callback = lambda { |record|
-          instance_exec(record, &touch_callback) unless association(reflection.name).target_changed?
+          instance_exec(record, &touch_callback) unless association(reflection.name).saved_change_to_target?
         }
         model.after_update update_callback, if: :saved_changes?
       else
@@ -123,11 +123,37 @@ module ActiveRecord::Associations::Builder # :nodoc:
       super
 
       if required
-        model.validates_presence_of reflection.name, message: :required
+        if ActiveRecord.belongs_to_required_validates_foreign_key
+          model.validates_presence_of reflection.name, message: :required
+        else
+          condition = lambda { |record|
+            foreign_key = reflection.foreign_key
+            foreign_type = reflection.foreign_type
+
+            record.read_attribute(foreign_key).nil? ||
+              record.attribute_changed?(foreign_key) ||
+              (reflection.polymorphic? && (record.read_attribute(foreign_type).nil? || record.attribute_changed?(foreign_type)))
+          }
+
+          model.validates_presence_of reflection.name, message: :required, if: condition
+        end
       end
     end
 
-    private_class_method :macro, :valid_options, :valid_dependent_options, :define_callbacks, :define_validations,
-      :add_counter_cache_callbacks, :add_touch_callbacks, :add_default_callbacks, :add_destroy_callbacks
+    def self.define_change_tracking_methods(model, reflection)
+      model.generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{reflection.name}_changed?
+          association(:#{reflection.name}).target_changed?
+        end
+
+        def #{reflection.name}_previously_changed?
+          association(:#{reflection.name}).target_previously_changed?
+        end
+      CODE
+    end
+
+    private_class_method :macro, :valid_options, :valid_dependent_options, :define_callbacks,
+      :define_validations, :define_change_tracking_methods, :add_counter_cache_callbacks,
+      :add_touch_callbacks, :add_default_callbacks, :add_destroy_callbacks
   end
 end

data/lib/active_record/associations/builder/collection_association.rb

@@ -3,7 +3,7 @@
 require "active_record/associations"
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class CollectionAssociation < Association #:nodoc:
+  class CollectionAssociation < Association # :nodoc:
     CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
 
     def self.valid_options(options)
@@ -30,11 +30,18 @@ module ActiveRecord::Associations::Builder # :nodoc:
     def self.define_callback(model, callback_name, name, options)
       full_callback_name = "#{callback_name}_for_#{name}"
 
-      unless model.method_defined?(full_callback_name)
+      callback_values = Array(options[callback_name.to_sym])
+      method_defined = model.respond_to?(full_callback_name)
+
+      # If there are no callbacks, we must also check if a superclass had
+      # previously defined this association
+      return if callback_values.empty? && !method_defined
+
+      unless method_defined
         model.class_attribute(full_callback_name, instance_accessor: false, instance_predicate: false)
       end
 
-      callbacks = Array(options[callback_name.to_sym]).map do |callback|
+      callbacks = callback_values.map do |callback|
         case callback
         when Symbol
           ->(method, owner, record) { owner.send(callback, record) }

data/lib/active_record/associations/builder/has_and_belongs_to_many.rb

@@ -20,6 +20,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
           attr_accessor :right_reflection
         end
 
+        @table_name = nil
         def self.table_name
           # Table name needs to be resolved lazily
           # because RHS class might not have been loaded
@@ -44,11 +45,6 @@ module ActiveRecord::Associations::Builder # :nodoc:
         def self.retrieve_connection
           left_model.retrieve_connection
         end
-
-        private
-          def self.suppress_composite_primary_key(pk)
-            pk unless pk.is_a?(Array)
-          end
       }
 
       join_model.name                = "HABTM_#{association_name.to_s.camelize}"

data/lib/active_record/associations/builder/has_many.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class HasMany < CollectionAssociation #:nodoc:
+  class HasMany < CollectionAssociation # :nodoc:
     def self.macro
       :has_many
     end
 
     def self.valid_options(options)
-      valid = super + [:counter_cache, :join_table, :index_errors, :ensuring_owner_was]
+      valid = super + [:counter_cache, :join_table, :index_errors]
       valid += [:as, :foreign_type] if options[:as]
       valid += [:through, :source, :source_type] if options[:through]
       valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
+      valid += [:disable_joins] if options[:disable_joins] && options[:through]
       valid
     end
 

data/lib/active_record/associations/builder/has_one.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class HasOne < SingularAssociation #:nodoc:
+  class HasOne < SingularAssociation # :nodoc:
     def self.macro
       :has_one
     end
@@ -11,6 +11,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
       valid += [:as, :foreign_type] if options[:as]
       valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
       valid += [:through, :source, :source_type] if options[:through]
+      valid += [:disable_joins] if options[:disable_joins] && options[:through]
       valid
     end
 

data/lib/active_record/associations/builder/singular_association.rb

@@ -3,7 +3,7 @@
 # This class is inherited by the has_one and belongs_to association classes
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class SingularAssociation < Association #:nodoc:
+  class SingularAssociation < Association # :nodoc:
     def self.valid_options(options)
       super + [:required, :touch]
     end
@@ -13,12 +13,16 @@ module ActiveRecord::Associations::Builder # :nodoc:
       mixin = model.generated_association_methods
       name = reflection.name
 
-      define_constructors(mixin, name) if reflection.constructable?
+      define_constructors(mixin, name) unless reflection.polymorphic?
 
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def reload_#{name}
           association(:#{name}).force_reload_reader
         end
+
+        def reset_#{name}
+          association(:#{name}).reset
+        end
       CODE
     end
 

data/lib/active_record/associations/collection_association.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/enumerable"
+
 module ActiveRecord
   module Associations
     # = Active Record Association Collection
@@ -14,7 +16,7 @@ module ActiveRecord
     #
     # The CollectionAssociation class provides common methods to the collections
     # defined by +has_and_belongs_to_many+, +has_many+ or +has_many+ with
-    # the +:through association+ option.
+    # the <tt>:through association</tt> option.
     #
     # You need to be careful with assumptions regarding the target: The proxy
     # does not fetch records from the database until it needs them, but new
@@ -25,9 +27,11 @@ module ActiveRecord
     #
     # If you need to work on all current children, new and existing records,
     # +load_target+ and the +loaded+ flag are your friends.
-    class CollectionAssociation < Association #:nodoc:
+    class CollectionAssociation < Association # :nodoc:
       # Implements the reader method, e.g. foo.items for Foo.has_many :items
       def reader
+        ensure_klass_exists!
+
         if stale_target?
           reload
         end
@@ -44,11 +48,11 @@ module ActiveRecord
       # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
       def ids_reader
         if loaded?
-          target.pluck(reflection.association_primary_key)
+          target.pluck(*reflection.association_primary_key)
         elsif !target.empty?
-          load_target.pluck(reflection.association_primary_key)
+          load_target.pluck(*reflection.association_primary_key)
         else
-          @association_ids ||= scope.pluck(reflection.association_primary_key)
+          @association_ids ||= scope.pluck(*reflection.association_primary_key)
         end
       end
 
@@ -57,14 +61,20 @@ module ActiveRecord
         primary_key = reflection.association_primary_key
         pk_type = klass.type_for_attribute(primary_key)
         ids = Array(ids).compact_blank
-        ids.map! { |i| pk_type.cast(i) }
+        ids.map! { |id| pk_type.cast(id) }
 
-        records = klass.where(primary_key => ids).index_by do |r|
-          r.public_send(primary_key)
+        records = if klass.composite_primary_key?
+          klass.where(primary_key => ids).index_by do |record|
+            primary_key.map { |primary_key| record._read_attribute(primary_key) }
+          end
+        else
+          klass.where(primary_key => ids).index_by do |record|
+            record._read_attribute(primary_key)
+          end
         end.values_at(*ids).compact
 
         if records.size != ids.size
-          found_ids = records.map { |record| record.public_send(primary_key) }
+          found_ids = records.map { |record| record._read_attribute(primary_key) }
           not_found_ids = ids - found_ids
           klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key, not_found_ids)
         else
@@ -75,7 +85,7 @@ module ActiveRecord
       def reset
         super
         @target = []
-        @replaced_or_added_targets = Set.new
+        @replaced_or_added_targets = Set.new.compare_by_identity
         @association_ids = nil
       end
 
@@ -115,28 +125,13 @@ module ActiveRecord
       def concat(*records)
         records = records.flatten
         if owner.new_record?
-          load_target
+          skip_strict_loading { load_target }
           concat_records(records)
         else
           transaction { concat_records(records) }
         end
       end
 
-      # Starts a transaction in the association class's database connection.
-      #
-      #   class Author < ActiveRecord::Base
-      #     has_many :books
-      #   end
-      #
-      #   Author.first.books.transaction do
-      #     # same effect as calling Book.transaction
-      #   end
-      def transaction(*args)
-        reflection.klass.transaction(*args) do
-          yield
-        end
-      end
-
       # Removes all records from the association without calling callbacks
       # on the associated records. It honors the +:dependent+ option. However
       # if the +:dependent+ value is +:destroy+ then in that case the +:delete_all+
@@ -191,7 +186,7 @@ module ActiveRecord
       end
 
       # Deletes the +records+ and removes them from this association calling
-      # +before_remove+ , +after_remove+ , +before_destroy+ and +after_destroy+ callbacks.
+      # +before_remove+, +after_remove+, +before_destroy+ and +after_destroy+ callbacks.
       #
       # Note that this method removes records from the database ignoring the
       # +:dependent+ option.
@@ -244,7 +239,7 @@ module ActiveRecord
       # and delete/add only records that have changed.
       def replace(other_array)
         other_array.each { |val| raise_on_type_mismatch!(val) }
-        original_target = load_target.dup
+        original_target = skip_strict_loading { load_target }.dup
 
         if owner.new_record?
           replace_records(other_array, original_target)
@@ -284,9 +279,11 @@ module ActiveRecord
       end
 
       def target=(record)
-        return super unless ActiveRecord::Base.has_many_inversing
+        return super unless reflection.klass.has_many_inversing
 
         case record
+        when nil
+          # It's not possible to remove the record from the inverse association.
         when Array
           super
         else
@@ -306,13 +303,17 @@ module ActiveRecord
 
       def find_from_target?
         loaded? ||
-          owner.strict_loading? ||
+          (owner.strict_loading? && owner.strict_loading_all?) ||
           reflection.strict_loading? ||
           owner.new_record? ||
           target.any? { |record| record.new_record? || record.changed? }
       end
 
       private
+        def transaction(&block)
+          reflection.klass.transaction(&block)
+        end
+
         # We have some records loaded from the database (persisted) and some that are
         # in-memory (memory). The same record may be represented in the persisted array
         # and in the memory array.
@@ -325,13 +326,12 @@ module ActiveRecord
         #   * Otherwise, attributes should have the value found in the database
         def merge_target_lists(persisted, memory)
           return persisted if memory.empty?
-          return memory    if persisted.empty?
 
           persisted.map! do |record|
             if mem_record = memory.delete(record)
 
-              ((record.attribute_names & mem_record.attribute_names) - mem_record.changed_attribute_names_to_save).each do |name|
-                mem_record[name] = record[name]
+              ((record.attribute_names & mem_record.attribute_names) - mem_record.changed_attribute_names_to_save - mem_record.class._attr_readonly).each do |name|
+                mem_record._write_attribute(name, record[name])
               end
 
               mem_record
@@ -345,7 +345,7 @@ module ActiveRecord
 
         def _create_record(attributes, raise = 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
 
           if attributes.is_a?(Array)
@@ -489,7 +489,11 @@ module ActiveRecord
 
         def callbacks_for(callback_name)
           full_callback_name = "#{callback_name}_for_#{reflection.name}"
-          owner.class.send(full_callback_name)
+          if owner.class.respond_to?(full_callback_name)
+            owner.class.send(full_callback_name)
+          else
+            []
+          end
         end
 
         def include_in_memory?(record)

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.
     #
@@ -27,7 +29,7 @@ module ActiveRecord
     # is computed directly through SQL and does not trigger by itself the
     # instantiation of the actual post records.
     class CollectionProxy < Relation
-      def initialize(klass, association, **) #:nodoc:
+      def initialize(klass, association, **) # :nodoc:
         @association = association
         super klass
 
@@ -46,7 +48,7 @@ module ActiveRecord
       # Returns +true+ if the association has been loaded, otherwise +false+.
       #
       #   person.pets.loaded? # => false
-      #   person.pets
+      #   person.pets.records
       #   person.pets.loaded? # => true
       def loaded?
         @association.loaded?
@@ -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
@@ -813,7 +815,7 @@ module ActiveRecord
       # to <tt>collection.size.zero?</tt>. If the collection has not been loaded,
       # it is equivalent to <tt>!collection.exists?</tt>. If the collection has
       # not already been loaded and you are going to fetch the records anyway it
-      # is better to check <tt>collection.length.zero?</tt>.
+      # is better to check <tt>collection.load.empty?</tt>.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets
@@ -849,6 +851,11 @@ module ActiveRecord
       #   person.pets.count # => 1
       #   person.pets.any?  # => true
       #
+      # Calling it without a block when the collection is not yet
+      # loaded is equivalent to <tt>collection.exists?</tt>.
+      # If you're going to load the collection anyway, it is better
+      # to call <tt>collection.load.any?</tt> to avoid an extra query.
+      #
       # You can also pass a +block+ to define criteria. The behavior
       # is the same, it returns true if the collection based on the
       # criteria is not empty.
@@ -925,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
@@ -950,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
@@ -1097,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/disable_joins_association_scope.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    class DisableJoinsAssociationScope < AssociationScope # :nodoc:
+      def scope(association)
+        source_reflection = association.reflection
+        owner = association.owner
+        unscoped = association.klass.unscoped
+        reverse_chain = get_chain(source_reflection, association, unscoped.alias_tracker).reverse
+
+        last_reflection, last_ordered, last_join_ids = last_scope_chain(reverse_chain, owner)
+
+        add_constraints(last_reflection, last_reflection.join_primary_key, last_join_ids, owner, last_ordered)
+      end
+
+      private
+        def last_scope_chain(reverse_chain, owner)
+          first_item = reverse_chain.shift
+          first_scope = [first_item, false, [owner._read_attribute(first_item.join_foreign_key)]]
+
+          reverse_chain.inject(first_scope) do |(reflection, ordered, join_ids), next_reflection|
+            key = reflection.join_primary_key
+            records = add_constraints(reflection, key, join_ids, owner, ordered)
+            foreign_key = next_reflection.join_foreign_key
+            record_ids = records.pluck(foreign_key)
+            records_ordered = records && records.order_values.any?
+
+            [next_reflection, records_ordered, record_ids]
+          end
+        end
+
+        def add_constraints(reflection, key, join_ids, owner, ordered)
+          scope = reflection.build_scope(reflection.aliased_table).where(key => join_ids)
+
+          relation = reflection.klass.scope_for_association
+          scope.merge!(
+            relation.except(:select, :create_with, :includes, :preload, :eager_load, :joins, :left_outer_joins)
+          )
+
+          scope = reflection.constraints.inject(scope) do |memo, scope_chain_item|
+            item = eval_scope(reflection, scope_chain_item, owner)
+            scope.unscope!(*item.unscope_values)
+            scope.where_clause += item.where_clause
+            scope.order_values = item.order_values | scope.order_values
+            scope
+          end
+
+          if scope.order_values.empty? && ordered
+            split_scope = DisableJoinsAssociationRelation.create(scope.klass, key, join_ids)
+            split_scope.where_clause += scope.where_clause
+            split_scope
+          else
+            scope
+          end
+        end
+    end
+  end
+end

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)