activerecord 7.2.2.2 → 7.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9269c9c015fecf44abaa1366dde339c7c068c1a1f26f977060e50d2d91d9aed7
-  data.tar.gz: 7718209bdff5867bb7df1bf94f975bac4a9e0807530c7bf8a51b1245a96229e1
+  metadata.gz: 0ebb786463cf3ba2ac8e8adc2945547e4e44a159d339035f4bbc4dc25cdd7bbc
+  data.tar.gz: d04ff22052095e10d2c4ab9f7bafdaedc550169faab2da5854095985acdb2f8f
 SHA512:
-  metadata.gz: e7f135f22b059f74b1d6cbd64035d02f1c27b8d2cc767daf098165f41f0a76d283aeeec15db26589e303938ac1967f7c7a71a498d764b34b514020743c7eecea
-  data.tar.gz: 8b2f0a0b826252e9bc5120dc3aa25e2aec88dc66e3bc09dfc71fd2baf6f6cfe25055db30d9554ceab80ef9cc035319e72b0fea1d83091b0a244d9d728c095174
+  metadata.gz: 9478c4f3eed1c66d601b1e0b8ba16c1585ccb7514b7cff14c2d1e84a7bd1255296243be1cb71e9f49ef1d8390c4e2ff7ad0bc26525dd2868bd1b46eb2922dbd7
+  data.tar.gz: 60aa9ebbf14c4ecb5afe54b02714a4802eafce2e99f84930170c1b28b639d762fd7a70d7d3afe4a1e9079b5f45bdc9c513ca6ac47927a4f1860ada9e6a25a0e4

data/CHANGELOG.md

@@ -1,3 +1,315 @@
+## Rails 7.2.3 (October 28, 2025) ##
+
+*   Fix SQLite3 data loss during table alterations with CASCADE foreign keys.
+
+    When altering a table in SQLite3 that is referenced by child tables with
+    `ON DELETE CASCADE` foreign keys, ActiveRecord would silently delete all
+    data from the child tables. This occurred because SQLite requires table
+    recreation for schema changes, and during this process the original table
+    is temporarily dropped, triggering CASCADE deletes on child tables.
+
+    The root cause was incorrect ordering of operations. The original code
+    wrapped `disable_referential_integrity` inside a transaction, but
+    `PRAGMA foreign_keys` cannot be modified inside a transaction in SQLite -
+    attempting to do so simply has no effect. This meant foreign keys remained
+    enabled during table recreation, causing CASCADE deletes to fire.
+
+    The fix reverses the order to follow the official SQLite 12-step ALTER TABLE
+    procedure: `disable_referential_integrity` now wraps the transaction instead
+    of being wrapped by it. This ensures foreign keys are properly disabled
+    before the transaction starts and re-enabled after it commits, preventing
+    CASCADE deletes while maintaining data integrity through atomic transactions.
+
+    *Ruy Rocha*
+
+*   Fix `belongs_to` associations not to clear the entire composite primary key.
+
+    When clearing a `belongs_to` association that references a model with composite primary key,
+    only the optional part of the key should be cleared.
+
+    *zzak*
+
+*   Fix invalid records being autosaved when distantly associated records are marked for deletion.
+
+    *Ian Terrell*, *axlekb AB*
+
+*   Prevent persisting invalid record.
+
+    *Edouard Chin*
+
+*   Fix count with group by qualified name on loaded relation.
+
+    *Ryuta Kamizono*
+
+*   Fix `sum` with qualified name on loaded relation.
+
+    *Chris Gunther*
+
+*   Fix prepared statements on mysql2 adapter.
+
+    *Jean Boussier*
+
+*   Fix query cache for pinned connections in multi threaded transactional tests.
+
+    When a pinned connection is used across separate threads, they now use a separate cache store
+    for each thread.
+
+    This improve accuracy of system tests, and any test using multiple threads.
+
+    *Heinrich Lee Yu*, *Jean Boussier*
+
+*   Don't add `id_value` attribute alias when attribute/column with that name already exists.
+
+    *Rob Lewis*
+
+*   Fix false positive change detection involving STI and polymorhic has one relationships.
+
+    Polymorphic `has_one` relationships would always be considered changed when defined in a STI child
+    class, causing nedless extra autosaves.
+
+    *David Fritsch*
+
+*   Fix stale associaton detection for polymophic `belong_to`.
+
+    *Florent Beaurain*, *Thomas Crambert*
+
+*   Fix removal of PostgreSQL version comments in `structure.sql` for latest PostgreSQL versions which include `\restrict`.
+
+    *Brendan Weibrecht*
+
+*   Fix `#merge` with `#or` or `#and` and a mixture of attributes and SQL strings resulting in an incorrect query.
+
+    ```ruby
+    base = Comment.joins(:post).where(user_id: 1).where("recent = 1")
+    puts base.merge(base.where(draft: true).or(Post.where(archived: true))).to_sql
+    ```
+
+    Before:
+
+    ```SQL
+    SELECT "comments".* FROM "comments"
+    INNER JOIN "posts" ON "posts"."id" = "comments"."post_id"
+    WHERE (recent = 1)
+    AND (
+      "comments"."user_id" = 1
+      AND (recent = 1)
+      AND "comments"."draft" = 1
+      OR "posts"."archived" = 1
+    )
+    ```
+
+    After:
+
+    ```SQL
+    SELECT "comments".* FROM "comments"
+    INNER JOIN "posts" ON "posts"."id" = "comments"."post_id"
+    WHERE "comments"."user_id" = 1
+    AND (recent = 1)
+    AND (
+      "comments"."user_id" = 1
+      AND (recent = 1)
+      AND "comments"."draft" = 1
+      OR "posts"."archived" = 1
+    )
+    ```
+
+    *Joshua Young*
+
+*   Fix inline `has_and_belongs_to_many` fixtures for tables with composite primary keys.
+
+    *fatkodima*
+
+*   Fix `annotate` comments to propagate to `update_all`/`delete_all`.
+
+    *fatkodima*
+
+*   Fix checking whether an unpersisted record is `include?`d in a strictly
+    loaded `has_and_belongs_to_many` association.
+
+    *Hartley McGuire*
+
+*   Fix inline has_and_belongs_to_many fixtures for tables with composite primary keys.
+
+    *fatkodima*
+
+*   `create_or_find_by` will now correctly rollback a transaction.
+
+    When using `create_or_find_by`, raising a ActiveRecord::Rollback error
+    in a `after_save` callback had no effect, the transaction was committed
+    and a record created.
+
+    *Edouard Chin*
+
+*   Gracefully handle `Timeout.timeout` firing during connection configuration.
+
+    Use of `Timeout.timeout` could result in improperly initialized database connection.
+
+    This could lead to a partially configured connection being used, resulting in various exceptions,
+    the most common being with the PostgreSQLAdapter raising `undefined method 'key?' for nil`
+    or `TypeError: wrong argument type nil (expected PG::TypeMap)`.
+
+    *Jean Boussier*
+
+*   The SQLite3 adapter quotes non-finite Numeric values like "Infinity" and "NaN".
+
+    *Mike Dalessio*
+
+*   Handle libpq returning a database version of 0 on no/bad connection in `PostgreSQLAdapter`.
+
+    Before, this version would be cached and an error would be raised during connection configuration when
+    comparing it with the minimum required version for the adapter. This meant that the connection could
+    never be successfully configured on subsequent reconnection attempts.
+
+    Now, this is treated as a connection failure consistent with libpq, raising a `ActiveRecord::ConnectionFailed`
+    and ensuring the version isn't cached, which allows the version to be retrieved on the next connection attempt.
+
+    *Joshua Young*, *Rian McGuire*
+
+*   Fix error handling during connection configuration.
+
+    Active Record wasn't properly handling errors during the connection configuration phase.
+    This could lead to a partially configured connection being used, resulting in various exceptions,
+    the most common being with the PostgreSQLAdapter raising `undefined method `key?' for nil`
+    or `TypeError: wrong argument type nil (expected PG::TypeMap)`.
+
+    *Jean Boussier*
+
+*   Fix a case where a non-retryable query could be marked retryable.
+
+    *Hartley McGuire*
+
+*   Handle circular references when autosaving associations.
+
+    *zzak*
+
+*   Prevent persisting invalid record.
+
+    *Edouard Chin*
+
+*   Fix support for PostgreSQL enum types with commas in their name.
+
+    *Arthur Hess*
+
+*   Fix inserts on MySQL with no RETURNING support for a table with multiple auto populated columns.
+
+    *Nikita Vasilevsky*
+
+*   Fix joining on a scoped association with string joins and bind parameters.
+
+    ```ruby
+    class Instructor < ActiveRecord::Base
+      has_many :instructor_roles, -> { active }
+    end
+
+    class InstructorRole < ActiveRecord::Base
+      scope :active, -> {
+        joins("JOIN students ON instructor_roles.student_id = students.id")
+        .where(students { status: 1 })
+      }
+    end
+
+    Instructor.joins(:instructor_roles).first
+    ```
+
+    The above example would result in `ActiveRecord::StatementInvalid` because the
+    `active` scope bind parameters would be lost.
+
+    *Jean Boussier*
+
+*   Fix a potential race condition with system tests and transactional fixtures.
+
+    *Sjoerd Lagarde*
+
+*   Fix count with group by qualified name on loaded relation.
+
+    *Ryuta Kamizono*
+
+*   Fix sum with qualified name on loaded relation.
+
+    *Chris Gunther*
+
+*   Fix autosave associations to no longer validated unmodified associated records.
+
+    Active Record was incorrectly performing validation on associated record that
+    weren't created nor modified as part of the transaction:
+
+    ```ruby
+    Post.create!(author: User.find(1)) # Fail if user is invalid
+    ```
+
+    *Jean Boussier*
+
+*   Remember when a database connection has recently been verified (for
+    two seconds, by default), to avoid repeated reverifications during a
+    single request.
+
+    This should recreate a similar rate of verification as in Rails 7.1,
+    where connections are leased for the duration of a request, and thus
+    only verified once.
+
+    *Matthew Draper*
+
+*   Fix prepared statements on mysql2 adapter.
+
+    *Jean Boussier*
+
+*   Fix a race condition in `ActiveRecord::Base#method_missing` when lazily defining attributes.
+
+    If multiple thread were concurrently triggering attribute definition on the same model,
+    it could result in a `NoMethodError` being raised.
+
+    *Jean Boussier*
+
+*   Fix MySQL default functions getting dropped when changing a column's nullability.
+
+    *Bastian Bartmann*
+
+*   Fix `add_unique_constraint`/`add_check_constraint`/`/`add_foreign_key` to be revertible when
+    given invalid options.
+
+    *fatkodima*
+
+*   Fix asynchronous destroying of polymorphic `belongs_to` associations.
+
+    *fatkodima*
+
+*   NOT VALID constraints should not dump in `create_table`.
+
+    *Ryuta Kamizono*
+
+*   Fix finding by nil composite primary key association.
+
+    *fatkodima*
+
+*   Fix parsing of SQLite foreign key names when they contain non-ASCII characters
+
+    *Zacharias Knudsen*
+
+*   Fix parsing of MySQL 8.0.16+ CHECK constraints when they contain new lines.
+
+    *Steve Hill*
+
+*   Ensure normalized attribute queries use `IS NULL` consistently for `nil` and normalized `nil` values.
+
+    *Joshua Young*
+
+*   Restore back the ability to pass only database name for `DATABASE_URL`.
+
+    *fatkodima*
+
+*   Fix `order` with using association name as an alias.
+
+    *Ryuta Kamizono*
+
+*   Improve invalid argument error for with.
+
+    *Ryuta Kamizono*
+
+*   Deduplicate `with` CTE expressions.
+
+    *fatkodima*
+
+
 ## Rails 7.2.2.2 (August 13, 2025) ##
 
 *   Call inspect on ids in RecordNotFound error
@@ -6,6 +318,7 @@
 
     *Gannon McGibbon*, *John Hawthorn*
 
+
 ## Rails 7.2.2.1 (December 10, 2024) ##
 
 *   No changes.
@@ -736,20 +1049,16 @@
 
     *Jason Nochlin*
 
-*   The fix ensures that the association is joined using the appropriate join type
-    (either inner join or left outer join) based on the existing joins in the scope.
-
-    This prevents unintentional overrides of existing join types and ensures consistency in the generated SQL queries.
+*   Fix an issue with `where.associated` losing the current join type scope.
 
     Example:
 
-
-
     ```ruby
-    # `associated` will use `LEFT JOIN` instead of using `JOIN`
     Post.left_joins(:author).where.associated(:author)
     ```
 
+    Previously, the `LEFT OUTER JOIN` would be lost and converted to an `INNER JOIN`.
+
     *Saleh Alhaddad*
 
 *   Fix an issue where `ActiveRecord::Encryption` configurations are not ready before the loading

data/README.rdoc

@@ -214,6 +214,6 @@ Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
 * https://discuss.rubyonrails.org/c/rubyonrails-core

data/lib/active_record/associations/alias_tracker.rb

@@ -26,16 +26,18 @@ module ActiveRecord
       end
 
       def self.initial_count_for(connection, name, table_joins)
-        quoted_name = nil
+        quoted_name_escaped = nil
+        name_escaped = nil
 
         counts = table_joins.map do |join|
           if join.is_a?(Arel::Nodes::StringJoin)
-            # quoted_name should be case ignored as some database adapters (Oracle) return quoted name in uppercase
-            quoted_name ||= connection.quote_table_name(name)
+            # quoted_name_escaped should be case ignored as some database adapters (Oracle) return quoted name in uppercase
+            quoted_name_escaped ||= Regexp.escape(connection.quote_table_name(name))
+            name_escaped ||= Regexp.escape(name)
 
             # Table names + table aliases
             join.left.scan(
-              /JOIN(?:\s+\w+)?\s+(?:\S+\s+)?(?:#{quoted_name}|#{name})\sON/i
+              /JOIN(?:\s+\w+)?\s+(?:\S+\s+)?(?:#{quoted_name_escaped}|#{name_escaped})\sON/i
             ).size
           elsif join.is_a?(Arel::Nodes::Join)
             join.left.name == name ? 1 : 0

data/lib/active_record/associations/belongs_to_association.rb

@@ -19,10 +19,16 @@ module ActiveRecord
             id = owner.public_send(reflection.foreign_key)
           end
 
+          association_class = if reflection.polymorphic?
+            owner.public_send(reflection.foreign_type)
+          else
+            reflection.klass
+          end
+
           enqueue_destroy_association(
             owner_model_name: owner.class.to_s,
             owner_id: owner.id,
-            association_class: reflection.klass.to_s,
+            association_class: association_class.to_s,
             association_ids: [id],
             association_primary_key_column: primary_key_column,
             ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
@@ -129,7 +135,9 @@ module ActiveRecord
             target_key_values = record ? Array(primary_key(record.class)).map { |key| record._read_attribute(key) } : []
 
             if force || reflection_fk.map { |fk| owner._read_attribute(fk) } != target_key_values
+              owner_pk = Array(owner.class.primary_key)
               reflection_fk.each_with_index do |key, index|
+                next if record.nil? && owner_pk.include?(key)
                 owner[key] = target_key_values[index]
               end
             end
@@ -156,7 +164,15 @@ module ActiveRecord
         end
 
         def stale_state
-          owner._read_attribute(reflection.foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
+          foreign_key = reflection.foreign_key
+          if foreign_key.is_a?(Array)
+            attributes = foreign_key.map do |fk|
+              owner._read_attribute(fk) { |n| owner.send(:missing_attribute, n, caller) }
+            end
+            attributes if attributes.any?
+          else
+            owner._read_attribute(foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
+          end
         end
     end
   end

data/lib/active_record/associations/collection_association.rb

@@ -256,14 +256,16 @@ module ActiveRecord
       end
 
       def include?(record)
-        if record.is_a?(reflection.klass)
-          if record.new_record?
-            include_in_memory?(record)
-          else
-            loaded? ? target.include?(record) : scope.exists?(record.id)
-          end
+        klass = reflection.klass
+        return false unless record.is_a?(klass)
+
+        if loaded?
+          target.include?(record)
+        elsif record.new_record?
+          include_in_memory?(record)
         else
-          false
+          record_id = klass.composite_primary_key? ? klass.primary_key.zip(record.id).to_h : record.id
+          scope.exists?(record_id)
         end
       end
 

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -38,41 +38,39 @@ module ActiveRecord
             chain << [reflection, table]
           end
 
-          base_klass.with_connection do |connection|
-            # The chain starts with the target table, but we want to end with it here (makes
-            # more sense in this context), so we reverse
-            chain.reverse_each do |reflection, table|
-              klass = reflection.klass
+          # The chain starts with the target table, but we want to end with it here (makes
+          # more sense in this context), so we reverse
+          chain.reverse_each do |reflection, table|
+            klass = reflection.klass
 
-              scope = reflection.join_scope(table, foreign_table, foreign_klass)
+            scope = reflection.join_scope(table, foreign_table, foreign_klass)
 
-              unless scope.references_values.empty?
-                associations = scope.eager_load_values | scope.includes_values
+            unless scope.references_values.empty?
+              associations = scope.eager_load_values | scope.includes_values
 
-                unless associations.empty?
-                  scope.joins! scope.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
-                end
+              unless associations.empty?
+                scope.joins! scope.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
               end
+            end
 
-              arel = scope.arel(alias_tracker.aliases)
-              nodes = arel.constraints.first
+            arel = scope.arel(alias_tracker.aliases)
+            nodes = arel.constraints.first
 
-              if nodes.is_a?(Arel::Nodes::And)
-                others = nodes.children.extract! do |node|
-                  !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
-                end
+            if nodes.is_a?(Arel::Nodes::And)
+              others = nodes.children.extract! do |node|
+                !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
               end
+            end
 
-              joins << join_type.new(table, Arel::Nodes::On.new(nodes))
+            joins << join_type.new(table, Arel::Nodes::On.new(nodes))
 
-              if others && !others.empty?
-                joins.concat arel.join_sources
-                append_constraints(connection, joins.last, others)
-              end
-
-              # The current table in this iteration becomes the foreign table in the next
-              foreign_table, foreign_klass = table, klass
+            if others && !others.empty?
+              joins.concat arel.join_sources
+              append_constraints(joins.last, others)
             end
+
+            # The current table in this iteration becomes the foreign table in the next
+            foreign_table, foreign_klass = table, klass
           end
 
           joins
@@ -91,10 +89,10 @@ module ActiveRecord
         end
 
         private
-          def append_constraints(connection, join, constraints)
+          def append_constraints(join, constraints)
             if join.is_a?(Arel::Nodes::StringJoin)
               join_string = Arel::Nodes::And.new(constraints.unshift join.left)
-              join.left = Arel.sql(connection.visitor.compile(join_string))
+              join.left = join_string
             else
               right = join.right
               right.expr = Arel::Nodes::And.new(constraints.unshift right.expr)

data/lib/active_record/attribute_methods/serialization.rb

@@ -130,7 +130,7 @@ module ActiveRecord
         # silently cast unsupported types to +String+:
         #
         #   >> JSON.parse(JSON.dump(Struct.new(:foo)))
-        #   => "#<Class:0x000000013090b4c0>"
+        #   # => "#<Class:0x000000013090b4c0>"
         #
         # ==== Examples
         #

data/lib/active_record/attribute_methods.rb

@@ -84,7 +84,7 @@ module ActiveRecord
         attribute_method_patterns_cache.clear
       end
 
-      def alias_attribute_method_definition(code_generator, pattern, new_name, old_name)
+      def alias_attribute_method_definition(code_generator, pattern, new_name, old_name) # :nodoc:
         old_name = old_name.to_s
 
         if !abstract_class? && !has_attribute?(old_name)
@@ -113,13 +113,14 @@ module ActiveRecord
           unless abstract_class?
             load_schema
             super(attribute_names)
-            alias_attribute :id_value, :id if _has_attribute?("id")
+            alias_attribute :id_value, :id if _has_attribute?("id") && !_has_attribute?("id_value")
           end
 
-          @attribute_methods_generated = true
-
           generate_alias_attributes
+
+          @attribute_methods_generated = true
         end
+
         true
       end
 
@@ -472,23 +473,27 @@ module ActiveRecord
       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 step.
-            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
-            # Some attribute methods weren't generated yet, we retry the call
-            return public_send(name, ...)
-          end
+        # We can't know whether some method was defined or not because
+        # multiple thread might be concurrently be in this code path.
+        # So the first one would define the methods and the others would
+        # appear to already have them.
+        self.class.define_attribute_methods
+
+        # So in all cases we must behave as if the method was just defined.
+        method = begin
+          self.class.public_instance_method(name)
+        rescue NameError
+          nil
         end
 
-        super
+        # The method might be explicitly defined in the model, but call a generated
+        # method with super. So we must resume the call chain at the right step.
+        method = method.super_method while method && !method.owner.is_a?(GeneratedAttributeMethods)
+        if method
+          method.bind_call(self, ...)
+        else
+          super
+        end
       end
 
       def attribute_method?(attr_name)