activerecord 7.1.3 → 7.1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f7c51f040979b7650eb209b0dc856a0877bccc968dd99cde06e3cf1776dd638
-  data.tar.gz: b81eca56b185f087c95b6691b307ff1c9c63d0d03ff650b729e943888f053152
+  metadata.gz: 53c82b47d80060218db2fd5a44483fe30a9ce2a7e235c30e894d4d6a9c0e7d35
+  data.tar.gz: b5432955eae8f100ceb96c40759de6932288b1aedf78d6c4b08cfb223b7adb8d
 SHA512:
-  metadata.gz: 6f68dc9e6cdccf23f5467810a68083564760601aa3c82b4c85720cfb2c39500439a86bb63c2ce8fea37337de6fc4f157722300c691cfd239e92732569b5c20f6
-  data.tar.gz: 6f8382df74c2c16b873cab0effeda0a3ef3e578d5087e435d7d2f8c6890dcf0d85e2211f2bc890182af49e836b09e4e345e2b9bc37eb8472814e98bb6636b005
+  metadata.gz: 935ee9fbc8c855663b10de47bffa2b7d51328a9cc7575f4aa5c9b26eaf0cc1ed9c4271e3c3f5982ceafbb00a679b0262b18782f165b31454fafc4ce6966b1575
+  data.tar.gz: 53dba913a6174f80766bc995dcfad80c1fbdf2f461474ed8b7e13a1cc8e6a321076f1e74a8a5ace878fce08154dd3a6dff51263365d982d22be50bd4c928de9e

data/CHANGELOG.md

@@ -1,3 +1,327 @@
+## Rails 7.1.5.1 (December 10, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.5 (October 30, 2024) ##
+
+*   Fix marshalling of unsaved associated records in 7.1 format.
+
+    The 7.1 format would only marshal associated records if the association was loaded.
+    But associations that would only contain unsaved records would be skipped.
+
+    *Jean Boussier*
+
+*   Fix an issue where `.left_outer_joins` used with multiple associations that have
+    the same child association but different parents does not join all parents.
+
+    Previously, using `.left_outer_joins` with the same child association would only join one of the parents.
+
+    Now it will correctly join both parents.
+
+    Fixes #41498.
+
+    *Garrett Blehm*
+
+*   Ensure `ActiveRecord::Encryption.config` is always ready before access.
+
+    Previously, `ActiveRecord::Encryption` configuration was deferred until `ActiveRecord::Base`
+    was loaded. Therefore, accessing `ActiveRecord::Encryption.config` properties before
+    `ActiveRecord::Base` was loaded would give incorrect results.
+
+    `ActiveRecord::Encryption` now has its own loading hook so that its configuration is set as
+    soon as needed.
+
+    When `ActiveRecord::Base` is loaded, even lazily, it in turn triggers the loading of
+    `ActiveRecord::Encryption`, thus preserving the original behavior of having its config ready
+    before any use of `ActiveRecord::Base`.
+
+    *Maxime Réty*
+
+*   Add `TimeZoneConverter#==` method, so objects will be properly compared by
+    their type, scale, limit & precision.
+
+    Address #52699.
+
+    *Ruy Rocha*
+
+
+## Rails 7.1.4.2 (October 23, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.4.1 (October 15, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.4 (August 22, 2024) ##
+
+*   Allow to eager load nested nil associations.
+
+    *fatkodima*
+
+*   Fix `create_table` with `:auto_increment` option for MySQL adapter.
+
+    *fatkodima*
+
+*   Don't load has_one associations during autosave.
+
+    *Eugene Kenny*
+
+*   Fix migration ordering for `bin/rails db:prepare` across databases.
+
+    *fatkodima*
+
+*   Fix `alias_attribute` to ignore methods defined in parent classes.
+
+    *Jean Boussier*
+
+*   Fix a performance regression in attribute methods.
+
+    *Jean Boussier*
+
+*   Fix Active Record configs variable shadowing.
+
+    *Joel Lubrano*
+
+*   Fix running migrations on other databases when `database_tasks: false` on primary.
+
+    *fatkodima*
+
+*   Fix non-partial inserts for models with composite identity primary keys.
+
+    *fatkodima*
+
+*   Fix `ActiveRecord::Relation#touch_all` with custom attribute aliased as attribute for update.
+
+    *fatkodima*
+
+*   Fix a crash when an Executor wrapped fork exit.
+
+    *Joé Dupuis*
+
+*   Fix `destroy_async` job for owners with composite primary keys.
+
+    *fatkodima*
+
+*   Ensure pre-7.1 migrations use legacy index names when using `rename_table`.
+
+    *fatkodima*
+
+*   Allow `primary_key:` association option to be composite.
+
+    *Nikita Vasilevsky*
+
+*   Do not try to alias on key update when raw SQL is supplied.
+
+    *Gabriel Amaral*
+
+*   Memoize `key_provider` from `key` or deterministic `key_provider` if any.
+
+    *Rosa Gutierrez*
+
+*   Fix `upsert` warning for MySQL.
+
+    *fatkodima*
+
+*   Fix predicate builder for polymorphic models referencing models with composite primary keys.
+
+    *fatkodima*
+
+*   Fix `update_all/delete_all` on CPK model relation with join subquery.
+
+    *Nikita Vasilevsky*
+
+*   Remove memoization to accept `key_provider` overridden by `with_encryption_context`.
+
+    *John Hawthorn*
+
+*   Raise error for Trilogy when prepared_statements is true.
+
+    Trilogy doesn't currently support prepared statements. The error that
+    applications would see is a `StatementInvalid` error. This doesn't quite point
+    you to the fact this isn't supported. So raise a more appropriate error
+    pointing to what to change.
+
+    *Eileen M. Uchitelle*
+
+*   Fix loading schema cache when all databases have disabled database tasks.
+
+    *fatkodima*
+
+*   Always request `primary_key` in `RETURNING` if no other columns requested.
+
+    *Nikita Vasilevsky*
+
+*   Handle records being loaded with Marshal without triggering schema load
+
+    When using the old marshalling format for Active Record and loading
+    a serialized instance, it didn't trigger loading the schema and defining
+    attribute methods.
+
+    *Jean Boussier*
+
+*   Prevent some constant redefinition warnings when defining `inherited` on models.
+
+    *Adrian Hirt*
+
+*   Fix a memory perfomance regression in attribute methods.
+
+    Attribute methods used much more memory and were slower to define than
+    they should have been.
+
+    *Jean Boussier*
+
+*   Fix an issue that could cause database connection leaks.
+
+    If Active Record successfully connected to the database, but then failed
+    to read the server informations, the connection would be leaked until the
+    Ruby garbage collector triggers.
+
+    *Jean Boussier*
+
+*   Fix an issue where the IDs reader method did not return expected results
+    for preloaded associations in models using composite primary keys.
+
+    *Jay Ang*
+
+*   PostgreSQL `Cidr#change?` detects the address prefix change.
+
+    *Taketo Takashima*
+
+*   Fix Active Record serialization to not include instantiated but not loaded associations
+
+    *Jean Boussier*, *Ben Kyriakou*
+
+*   Allow `Sqlite3Adapter` to use `sqlite3` gem version `2.x`
+
+    *Mike Dalessio*
+
+*   Strict loading using `:n_plus_one_only` does not eagerly load child associations.
+
+    With this change, child associations are no longer eagerly loaded, to
+    match intended behavior and to prevent non-deterministic order issues caused
+    by calling methods like `first` or `last`. As `first` and `last` don't cause
+    an N+1 by themselves, calling child associations will no longer raise.
+    Fixes #49473.
+
+    Before:
+
+    ```ruby
+    person = Person.find(1)
+    person.strict_loading!(mode: :n_plus_one_only)
+    person.posts.first
+    # SELECT * FROM posts WHERE person_id = 1; -- non-deterministic order
+    person.posts.first.firm # raises ActiveRecord::StrictLoadingViolationError
+    ```
+
+    After:
+
+    ```ruby
+    person = Person.find(1)
+    person.strict_loading!(mode: :n_plus_one_only)
+    person.posts.first # this is 1+1, not N+1
+    # SELECT * FROM posts WHERE person_id = 1 ORDER BY id LIMIT 1;
+    person.posts.first.firm # no longer raises
+    ```
+
+    *Reid Lynch*
+
+*   Using `Model.query_constraints` with a single non-primary-key column used to raise as expected, but with an
+    incorrect error message. This has been fixed to raise with a more appropriate error message.
+
+    *Joshua Young*
+
+*   Fix `has_one` association autosave setting the foreign key attribute when it is unchanged.
+
+    This behaviour is also inconsistent with autosaving `belongs_to` and can have unintended side effects like raising
+    an `ActiveRecord::ReadonlyAttributeError` when the foreign key attribute is marked as read-only.
+
+    *Joshua Young*
+
+*   Fix an issue where `ActiveRecord::Encryption` configurations are not ready before the loading
+    of Active Record models, when an application is eager loaded. As a result, encrypted attributes
+    could be misconfigured in some cases.
+
+    *Maxime Réty*
+
+*   Properly synchronize `Mysql2Adapter#active?` and `TrilogyAdapter#active?`
+
+    As well as `disconnect!` and `verify!`.
+
+    This generally isn't a big problem as connections must not be shared between
+    threads, but is required when running transactional tests or system tests
+    and could lead to a SEGV.
+
+    *Jean Boussier*
+
+*   Fix counter caches when the foreign key is composite.
+
+    If the model holding the counter cache had a composite primary key,
+    inserting a dependent record would fail with an `ArgumentError`
+    `Expected corresponding value for...`
+
+    *fatkodima*
+
+*   Fix loading of schema cache for multiple databases.
+
+    Before this change, if you have multiple databases configured in your
+    application, and had schema cache present, Rails would load the same
+    cache to all databases.
+
+    *Rafael Mendonça França*
+
+*   Fix eager loading of composite primary key associations.
+
+    `relation.eager_load(:other_model)` could load the wrong records if `other_model`
+    had a composite primary key.
+
+    *Nikita Vasilevsky*
+
+*   Fix async queries returning a doubly wrapped result when hitting the query cache.
+
+    *fatkodima*
+
+*   Fix single quote escapes on default generated MySQL columns
+
+    MySQL 5.7.5+ supports generated columns, which can be used to create a column that is computed from an expression.
+
+    Previously, the schema dump would output a string with double escapes for generated columns with single quotes in the default expression.
+
+    This would result in issues when importing the schema on a fresh instance of a MySQL database.
+
+    Now, the string will not be escaped and will be valid Ruby upon importing of the schema.
+
+    *Yash Kapadia*
+
+*   Fix Migrations with versions older than 7.1 validating options given to
+    `t.references`.
+
+    *Hartley McGuire*
+
+
+## Rails 7.1.3.4 (June 04, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.3.3 (May 16, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.3.2 (February 21, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.3.1 (February 21, 2024) ##
+
+*   No changes.
+
+
 ## Rails 7.1.3 (January 16, 2024) ##
 
 *   Fix Migrations with versions older than 7.1 validating options given to

data/lib/active_record/associations/belongs_to_association.rb

@@ -12,11 +12,11 @@ module ActiveRecord
           raise ActiveRecord::Rollback unless target.destroy
         when :destroy_async
           if reflection.foreign_key.is_a?(Array)
-            primary_key_column = reflection.active_record_primary_key.map(&:to_sym)
-            id = reflection.foreign_key.map { |col| owner.public_send(col.to_sym) }
+            primary_key_column = reflection.active_record_primary_key
+            id = reflection.foreign_key.map { |col| owner.public_send(col) }
           else
-            primary_key_column = reflection.active_record_primary_key.to_sym
-            id = owner.public_send(reflection.foreign_key.to_sym)
+            primary_key_column = reflection.active_record_primary_key
+            id = owner.public_send(reflection.foreign_key)
           end
 
           enqueue_destroy_association(

data/lib/active_record/associations/collection_association.rb

@@ -48,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
 
@@ -303,7 +303,7 @@ 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? }

data/lib/active_record/associations/has_many_association.rb

@@ -35,10 +35,10 @@ module ActiveRecord
           unless target.empty?
             association_class = target.first.class
             if association_class.query_constraints_list
-              primary_key_column = association_class.query_constraints_list.map(&:to_sym)
+              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.to_sym
+              primary_key_column = association_class.primary_key
               ids = target.collect { |assoc| assoc.public_send(primary_key_column) }
             end
 

data/lib/active_record/associations/has_one_association.rb

@@ -34,10 +34,10 @@ module ActiveRecord
             throw(:abort) unless target.destroyed?
           when :destroy_async
             if target.class.query_constraints_list
-              primary_key_column = target.class.query_constraints_list.map(&:to_sym)
+              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.to_sym
+              primary_key_column = target.class.primary_key
               id = target.public_send(primary_key_column)
             end
 

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

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
@@ -254,10 +254,10 @@ module ActiveRecord
 
             if node.primary_key
               keys = Array(node.primary_key).map { |column| aliases.column_alias(node, column) }
-              ids = keys.map { |key| row[key] }
+              id = 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.
+              id = keys.map { nil } # Avoid id-based model caching.
             end
 
             if keys.any? { |key| row[key].nil? }
@@ -266,11 +266,9 @@ module ActiveRecord
               next
             end
 
-            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
+            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
 
             construct(model, node, row, seen, model_cache, strict_loading_value)

data/lib/active_record/associations.rb

@@ -1506,6 +1506,11 @@ module ActiveRecord
         #   Serves as a composite foreign key. Defines the list of columns to be used to query the associated object.
         #   This is an optional option. By default Rails will attempt to derive the value automatically.
         #   When the value is set the Array size must match associated model's primary key or +query_constraints+ size.
+        # [+:index_errors+]
+        #   Enables differentiation of multiple validation errors from the association records, by including
+        #   an index in the error attribute name, e.g. +roles[2].level+.
+        #   The index is based on association order, i.e. database order, with yet to be
+        #   persisted new records placed at the end.
         #
         # Option examples:
         #   has_many :comments, -> { order("posted_on") }
@@ -1519,6 +1524,7 @@ module ActiveRecord
         #   has_many :subscribers, through: :subscriptions, disable_joins: true
         #   has_many :comments, strict_loading: true
         #   has_many :comments, query_constraints: [:blog_id, :post_id]
+        #   has_many :comments, index_errors: true
         def has_many(name, scope = nil, **options, &extension)
           reflection = Builder::HasMany.build(self, name, scope, options, &extension)
           Reflection.add_reflection self, name, reflection

data/lib/active_record/attribute_methods/dirty.rb

@@ -31,7 +31,7 @@ module ActiveRecord
     #   person.name_in_database        # => "Alice"
     #   person.saved_change_to_name?   # => true
     #   person.saved_change_to_name    # => ["Allison", "Alice"]
-    #   person.name_before_last_change # => "Allison"
+    #   person.name_before_last_save   # => "Allison"
     #
     # Similar to ActiveModel::Dirty, methods can be invoked as
     # +saved_change_to_name?+ or by passing an argument to the generic method
@@ -251,7 +251,7 @@ module ActiveRecord
             changed_attribute_names_to_save
           else
             attribute_names.reject do |attr_name|
-              if column_for_attribute(attr_name).default_function
+              if column_for_attribute(attr_name).auto_populated?
                 !attribute_changed?(attr_name)
               end
             end

data/lib/active_record/attribute_methods/read.rb

@@ -8,11 +8,11 @@ module ActiveRecord
 
       module ClassMethods # :nodoc:
         private
-          def define_method_attribute(name, owner:)
+          def define_method_attribute(canonical_name, owner:, as: canonical_name)
             ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-              owner, name
+              owner, canonical_name
             ) do |temp_method_name, attr_name_expr|
-              owner.define_cached_method(name, as: temp_method_name, namespace: :active_record) do |batch|
+              owner.define_cached_method(temp_method_name, as: as, namespace: :active_record) do |batch|
                 batch <<
                   "def #{temp_method_name}" <<
                   "  _read_attribute(#{attr_name_expr}) { |n| missing_attribute(n, caller) }" <<

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -32,6 +32,10 @@ module ActiveRecord
           end
         end
 
+        def ==(other)
+          other.is_a?(self.class) && __getobj__ == other.__getobj__
+        end
+
         private
           def convert_time_to_time_zone(value)
             return if value.nil?

data/lib/active_record/attribute_methods/write.rb

@@ -12,11 +12,11 @@ module ActiveRecord
 
       module ClassMethods # :nodoc:
         private
-          def define_method_attribute=(name, owner:)
+          def define_method_attribute=(canonical_name, owner:, as: canonical_name)
             ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-              owner, name, writer: true,
+              owner, canonical_name, writer: true,
             ) do |temp_method_name, attr_name_expr|
-              owner.define_cached_method("#{name}=", as: temp_method_name, namespace: :active_record) do |batch|
+              owner.define_cached_method(temp_method_name, as: "#{as}=", namespace: :active_record) do |batch|
                 batch <<
                   "def #{temp_method_name}(value)" <<
                   "  _write_attribute(#{attr_name_expr}, value)" <<

data/lib/active_record/attribute_methods.rb

@@ -66,7 +66,7 @@ module ActiveRecord
 
       def generate_alias_attributes # :nodoc:
         superclass.generate_alias_attributes unless superclass == Base
-        return if @alias_attributes_mass_generated
+        return false if @alias_attributes_mass_generated
 
         generated_attribute_methods.synchronize do
           return if @alias_attributes_mass_generated
@@ -80,12 +80,19 @@ module ActiveRecord
 
           @alias_attributes_mass_generated = true
         end
+        true
       end
 
-      def alias_attribute_method_definition(code_generator, pattern, new_name, old_name)
+      def generate_alias_attribute_methods(code_generator, new_name, old_name) # :nodoc:
+        attribute_method_patterns.each do |pattern|
+          alias_attribute_method_definition(code_generator, pattern, new_name, old_name)
+        end
+        attribute_method_patterns_cache.clear
+      end
+
+      def alias_attribute_method_definition(code_generator, pattern, new_name, old_name) # :nodoc:
         method_name = pattern.method_name(new_name).to_s
         target_name = pattern.method_name(old_name).to_s
-        parameters = pattern.parameters
         old_name = old_name.to_s
 
         method_defined = method_defined?(target_name) || private_method_defined?(target_name)
@@ -115,9 +122,7 @@ module ActiveRecord
           )
           super
         else
-          define_proxy_call(code_generator, method_name, pattern.proxy_target, parameters, old_name,
-            namespace: :proxy_alias_attribute
-          )
+          define_attribute_method_pattern(pattern, old_name, owner: code_generator, as: new_name, override: true)
         end
       end
 
@@ -133,6 +138,11 @@ module ActiveRecord
           super(attribute_names)
           @attribute_methods_generated = true
         end
+        true
+      end
+
+      def attribute_methods_generated? # :nodoc:
+        @attribute_methods_generated && @alias_attributes_mass_generated
       end
 
       def undefine_attribute_methods # :nodoc:
@@ -459,6 +469,36 @@ module ActiveRecord
     end
 
     private
+      def respond_to_missing?(name, include_private = false)
+        if self.class.define_attribute_methods
+          # Some methods weren't defined yet.
+          return true if self.class.method_defined?(name)
+          return true if include_private && self.class.private_method_defined?(name)
+        end
+
+        super
+      end
+
+      def method_missing(name, ...)
+        unless self.class.attribute_methods_generated?
+          if self.class.method_defined?(name)
+            # The method is explicitly defined in the model, but calls a generated
+            # method with super. So we must resume the call chain at the right setp.
+            last_method = method(name)
+            last_method = last_method.super_method while last_method.super_method
+            self.class.define_attribute_methods
+            if last_method.super_method
+              return last_method.super_method.call(...)
+            end
+          elsif self.class.define_attribute_methods | self.class.generate_alias_attributes
+            # Some attribute methods weren't generated yet, we retry the call
+            return public_send(name, ...)
+          end
+        end
+
+        super
+      end
+
       def attribute_method?(attr_name)
         # We check defined? because Syck calls respond_to? before actually calling initialize.
         defined?(@attributes) && @attributes.key?(attr_name)

data/lib/active_record/autosave_association.rb

@@ -441,7 +441,9 @@ module ActiveRecord
       # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
       def save_has_one_association(reflection)
         association = association_instance_get(reflection.name)
-        record      = association && association.load_target
+        return unless association && association.loaded?
+
+        record = association.load_target
 
         if record && !record.destroyed?
           autosave = reflection.options[:autosave]
@@ -458,7 +460,8 @@ module ActiveRecord
                 primary_key_foreign_key_pairs = primary_key.zip(foreign_key)
 
                 primary_key_foreign_key_pairs.each do |primary_key, foreign_key|
-                  record[foreign_key] = _read_attribute(primary_key)
+                  association_id = _read_attribute(primary_key)
+                  record[foreign_key] = association_id unless record[foreign_key] == association_id
                 end
                 association.set_inverse_instance(record)
               end