activerecord 7.1.3.1 → 7.1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c29973d598bdc0ac426db1a97047ba9052c41ec75af68e2264a94ef6bf044a4
-  data.tar.gz: e419114f0171e99f19dddc824868b6aaf77fea4206b0fbe2e1612bdb3ea0b5d3
+  metadata.gz: a200f8abed48ce6ab97abf8451e08f9178d634f1b6186b61ee4a81552e246109
+  data.tar.gz: c379bb65f3b1819ed78702da8bb8167ca21c34a9a35d54e67bacff74ce3fefc3
 SHA512:
-  metadata.gz: 6d88c9882cffebcaea6515a88c6ca9a79a57ba6b178b1b2079f8d188302dfcdbbe22f554bf14d3052924301385f9e7605185715bacc7c94c3ba534ac0a651cc1
-  data.tar.gz: eabb2fc6dfd14ac4b525804254f6ce05a982f3a1f31250f049b61f4f87cde4a8ef62469b926873c7f2c5ff82ca5696c58f190373d3ea4a611f8fcdbba1d78111
+  metadata.gz: 3a1564536513adb015b00aa10817bc0f672199788ede2b3ff7cef755622fde07c02c3410c6d7f223127998da69cfd2ff3033fef2615bbd778ea3f26dbdf62f1f
+  data.tar.gz: 44838c96abc346df10cf6ad6aae9083f09a96345b53cdc78cd216a0db2c2c10a0831c66d8ce17d7e1f11a897c4d9bb8eb81b06dbc231589624565da4275f2f96

data/CHANGELOG.md

@@ -1,3 +1,269 @@
+## 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.

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.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
@@ -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/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

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -675,7 +675,14 @@ module ActiveRecord
         def new_connection
           connection = Base.public_send(db_config.adapter_method, db_config.configuration_hash)
           connection.pool = self
-          connection.check_version
+
+          begin
+            connection.check_version
+          rescue
+            connection.disconnect!
+            raise
+          end
+
           connection
         rescue ConnectionNotEstablished => ex
           raise ex.set_pool(self)

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -629,7 +629,7 @@ module ActiveRecord
 
           result = internal_exec_query(sql, name, binds, prepare: prepare)
           if async
-            FutureResult::Complete.new(result)
+            FutureResult.wrap(result)
           else
             result
           end

data/lib/active_record/connection_adapters/abstract/query_cache.rb

@@ -107,7 +107,7 @@ module ActiveRecord
 
           if async
             result = lookup_sql_cache(sql, name, binds) || super(sql, name, binds, preparable: preparable, async: async)
-            FutureResult::Complete.new(result)
+            FutureResult.wrap(result)
           else
             cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable, async: async) }
           end

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -963,7 +963,11 @@ module ActiveRecord
       def index_name(table_name, options) # :nodoc:
         if Hash === options
           if options[:column]
-            generate_index_name(table_name, options[:column])
+            if options[:_uses_legacy_index_name]
+              "index_#{table_name}_on_#{Array(options[:column]) * '_and_'}"
+            else
+              generate_index_name(table_name, options[:column])
+            end
           elsif options[:name]
             options[:name]
           else
@@ -1636,11 +1640,11 @@ module ActiveRecord
           end
         end
 
-        def rename_table_indexes(table_name, new_name)
+        def rename_table_indexes(table_name, new_name, **options)
           indexes(new_name).each do |index|
-            generated_index_name = index_name(table_name, column: index.columns)
+            generated_index_name = index_name(table_name, column: index.columns, **options)
             if generated_index_name == index.name
-              rename_index new_name, generated_index_name, index_name(new_name, column: index.columns)
+              rename_index new_name, generated_index_name, index_name(new_name, column: index.columns, **options)
             end
           end
         end