activerecord 7.2.4 → 8.1.4

data/CHANGELOG.md

@@ -1,1459 +1,1594 @@
-## Rails 7.2.4 (September 24, 2026) ##
+## Rails 8.1.4 (September 24, 2026) ##
 
-*   Fix performance regression in `method_missing` for virtual SELECT alias
-    attributes.
-
-    Fixes #57183.
+*   Avoid deadlocks when concurrent `find_or_create_by` calls read back the same
+    record within MySQL transactions.
 
-    *Hammad Khan*
+    Use a shared lock for the read after a duplicate insert, preserving visibility
+    under REPEATABLE READ without upgrading competing shared locks to exclusive locks.
+    This also applies to `create_or_find_by` and the bang variants of both methods.
 
-*   Fix support for table names containing hyphens.
+    Fixes #54281.
 
-    *Evgeniy Demin*
+    *Kirsten Westeinde*
 
-*   Improve PostgreSQLAdapter resilience to Timeout.timeout.
-
-    Better handle asynchronous exceptions being thrown inside
-    the `reconnect!` method.
-
-    This may fixes some deep errors such as:
-
-    ```
-    undefined method `key?' for nil:NilClass (NoMethodError)
-              if !type_map.key?(oid)
-    ```
+*   Filter the database password out of failed `db:` task command error messages.
 
-    *Jean Boussier*
+    *Ngan Pham*
 
-*   Fix `eager_load` when loading `has_many` assocations with composite primary keys.
+*   Fix `ActiveRecord::TypeCaster::Connection` sometimes leaking a checked-out
+    connection.
 
-    This would result in some records being loaded multiple times.
+    *Hartley McGuire*
 
-    *Martin-Alexander*
+*   Fix PostgreSQL exclusion constraints with multiline expressions being parsed
+    incorrectly during schema introspection.
 
+    *Jake McAllister*
 
-## Rails 7.2.3.2 (July 29, 2026) ##
+*   Fix async `ActiveRecord::StatementCache#execute` raising an error for
+    out-of-range bind values instead of returning an empty result.
 
-*   No changes.
+    *viralpraxis*
 
+*   Fix `where` clauses with column-tuple syntax not resolving references to
+    other tables.
 
-## Rails 7.2.3.1 (March 23, 2026) ##
+    *Chris Gunther*
 
-*   No changes.
+*   Fix `distinct: true` being ignored by `average`.
 
+    *Kenta Ishizaki*
 
-## Rails 7.2.3 (October 28, 2025) ##
+*   Fix `belongs_to` change tracking for composite foreign keys.
 
-*   Fix SQLite3 data loss during table alterations with CASCADE foreign keys.
+    Only the first foreign key column was checked for changes; now all foreign
+    key columns are checked.
 
-    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.
+    *Anas Khan*
 
-    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.
+*   Make `add_column(if_not_exists: true)` reversible.
 
-    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.
+    *Kenta Ishizaki*
 
-    *Ruy Rocha*
+*   Quote the index name in MySQL `enable_index` and `disable_index`.
 
-*   Fix `belongs_to` associations not to clear the entire composite primary key.
+    Unquoted index names containing special characters could cause SQL syntax
+    errors.
 
-    When clearing a `belongs_to` association that references a model with composite primary key,
-    only the optional part of the key should be cleared.
+    *Kenta Ishizaki*
 
-    *zzak*
+*   Make `remove_foreign_key(if_exists: true)` reversible.
 
-*   Fix invalid records being autosaved when distantly associated records are marked for deletion.
+    *Kenta Ishizaki*
 
-    *Ian Terrell*, *axlekb AB*
+*   Fix `distinct: true` being ignored by grouped `sum`.
 
-*   Prevent persisting invalid record.
+    *Kenta Ishizaki*
 
-    *Edouard Chin*
+*   Return an `ActiveRecord::Promise` from `async_ids` on a contradictory
+    relation, instead of a plain `ActiveRecord::Result`.
 
-*   Fix count with group by qualified name on loaded relation.
+    *Kenta Ishizaki*
 
-    *Ryuta Kamizono*
+*   Fix reversibility check for `drop_virtual_table`.
 
-*   Fix `sum` with qualified name on loaded relation.
+    The wrong argument was extracted, so the check for whether options were
+    given could pass or fail incorrectly.
 
-    *Chris Gunther*
+    *Kenta Ishizaki*
 
-*   Fix prepared statements on mysql2 adapter.
+*   Fix `remove_check_constraint(if_exists: true)` incorrectly raising when
+    removing by expression.
 
-    *Jean Boussier*
+    The `if_exists` check did not pass the expression to
+    `check_constraint_exists?`, so it could not find the constraint.
 
-*   Fix query cache for pinned connections in multi threaded transactional tests.
+    *Kenta Ishizaki*
 
-    When a pinned connection is used across separate threads, they now use a separate cache store
-    for each thread.
+*   Clear PostgreSQL notices as they are handled, preventing warnings from
+    leaking to subsequent queries.
 
-    This improve accuracy of system tests, and any test using multiple threads.
+    *Matthew Draper*
 
-    *Heinrich Lee Yu*, *Jean Boussier*
+*   Fix `WeakThreadKeyMap` raising "can't add a new key into hash during
+    iteration" when connections are checked in from multiple threads.
 
-*   Don't add `id_value` attribute alias when attribute/column with that name already exists.
+    *Matthew Draper*
 
-    *Rob Lewis*
+*   Continue pool disconnect after a connection's cleanup or disconnect raises.
 
-*   Fix false positive change detection involving STI and polymorhic has one relationships.
+    Previously, a failure on one connection aborted the teardown, stranding
+    remaining connections and their resources.
 
-    Polymorphic `has_one` relationships would always be considered changed when defined in a STI child
-    class, causing nedless extra autosaves.
+    *Matthew Draper*
 
-    *David Fritsch*
+*   Fix race condition between `preconnect` and the connection pool reaper.
 
-*   Fix stale associaton detection for polymophic `belong_to`.
+    *Yasuo Honda*
 
-    *Florent Beaurain*, *Thomas Crambert*
+*   Fix `in_order_of` raising when the column is a CTE reference.
 
-*   Fix removal of PostgreSQL version comments in `structure.sql` for latest PostgreSQL versions which include `\restrict`.
+    *viralpraxis*
 
-    *Brendan Weibrecht*
+*   Fix `content_columns` including composite primary key components.
 
-*   Fix `#merge` with `#or` or `#and` and a mixture of attributes and SQL strings resulting in an incorrect query.
+    Only the first primary key column was excluded; now all primary key columns
+    are excluded.
 
-    ```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
-    ```
+    *Kenta Ishizaki*
 
-    Before:
+*   Treat `remove_column` with options but no type as irreversible.
 
-    ```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
-    )
-    ```
+    Previously, `remove_column(:table, :column, default: nil)` would not raise
+    `IrreversibleMigration` because the options hash was mistaken for a column
+    type.
 
-    After:
+    *Kenta Ishizaki*
 
-    ```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
-    )
-    ```
+*   Fix `counter_cache_column` crashing when `:counter_cache` is given as a
+    Hash without a `:column` key.
 
-    *Joshua Young*
+    *Kenta Ishizaki*
 
-*   Fix inline `has_and_belongs_to_many` fixtures for tables with composite primary keys.
+*   Coerce `seeds` and `use_metadata_table` to booleans in `UrlConfig`.
 
-    *fatkodima*
+    When configured via `DATABASE_URL`, these options were left as strings
+    instead of being coerced to booleans like `replica` and `database_tasks`.
 
-*   Fix `annotate` comments to propagate to `update_all`/`delete_all`.
+    *Kenta Ishizaki*
 
-    *fatkodima*
+*   Fix `excluding` (and its `without` alias) to work with composite primary key
+    models. Records passed to `excluding` are now matched by their full composite id
+    instead of being looked up by a single primary key column.
 
-*   Fix checking whether an unpersisted record is `include?`d in a strictly
-    loaded `has_and_belongs_to_many` association.
+    *Kenta Ishizaki*
 
-    *Hartley McGuire*
+*   Fix `Relation#delete` raising on a single composite primary key id.
 
-*   Fix inline has_and_belongs_to_many fixtures for tables with composite primary keys.
+    `Model.delete(id)` now wraps a single composite id in an array before building
+    the `WHERE` clause, so a single record can be deleted by its composite id.
 
-    *fatkodima*
+    *Kenta Ishizaki*
 
-*   `create_or_find_by` will now correctly rollback a transaction.
+*   Fix reading a composite primary key after a partial `select` returning the
+    raw value instead of `nil` for unselected key columns.
 
-    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.
+    The attribute defaults builder excluded only the single primary key column from
+    defaults; for composite primary keys it left the unselected key columns in the
+    defaults, so `record.id` returned an array of raw column values instead of
+    `[nil, nil]`. All primary key columns are now excluded.
 
-    *Edouard Chin*
+    *Kenta Ishizaki*
 
-*   Gracefully handle `Timeout.timeout` firing during connection configuration.
+*   Fix `find` with an empty array on a composite primary key model returning the
+    argument array instead of `[]`.
 
-    Use of `Timeout.timeout` could result in improperly initialized database connection.
+    `Model.find([])` now returns a fresh empty array for composite primary key
+    models, matching single-key models.
 
-    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)`.
+    *Kenta Ishizaki*
 
-    *Jean Boussier*
+*   Fix `find` with an order clause and an offset past the end of the ids raising
+    `RecordNotFound` instead of returning an empty result.
 
-*   The SQLite3 adapter quotes non-finite Numeric values like "Infinity" and "NaN".
+    *Kenta Ishizaki*
 
-    *Mike Dalessio*
+*   Fix `in_order_of` dropping values that cannot be serialized for the column
+    instead of turning them into an `IS NULL` match.
 
-*   Handle libpq returning a database version of 0 on no/bad connection in `PostgreSQLAdapter`.
+    Out-of-range integers and unknown enum keys are now ignored rather than
+    silently matching rows with `NULL` in that column. When all requested values
+    are unrepresentable, the relation returns no rows instead of building an empty
+    `CASE` expression.
 
-    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.
+    *Kenta Ishizaki*
 
-    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.
+*   Fix stale `finder_needs_type_condition?` memo after the schema cache is reloaded.
 
-    *Joshua Young*, *Rian McGuire*
+    When an STI model's `type` column was removed and re-added (e.g. via a
+    migration) and `reset_column_information` was called, the cached
+    `finder_needs_type_condition` value was not cleared, so queries could omit the
+    STI type condition. The memo is now reset on `reload_schema_from_cache`.
 
-*   Fix error handling during connection configuration.
+    *Kenta Ishizaki*
 
-    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)`.
+*   Fix PostgreSQL schema dump to qualify `enum_type` when the same enum name exists
+    in different schemas.
 
-    *Jean Boussier*
+    Previously the dumped `enum_type` used the bare type name, which could resolve to
+    the wrong enum in another schema. It now uses the schema-qualified name.
 
-*   Fix a case where a non-retryable query could be marked retryable.
+    *fatkodima*
 
-    *Hartley McGuire*
+*   Fix PostgreSQL index introspection to parse opclasses from another schema.
 
-*   Handle circular references when autosaving associations.
+    Index expressions using a schema-qualified opclass (e.g.
+    `USING gin(position test_schema.gin_trgm_ops)`) are now parsed correctly so the
+    opclass is captured without the schema prefix.
 
-    *zzak*
+    *Nicolas Vandenboegaerde*
 
-*   Prevent persisting invalid record.
+*   Fix `belongs_to` `:touch` with composite foreign keys.
 
-    *Edouard Chin*
+    Touching the parent record when a `belongs_to` with a composite foreign key
+    changes or is destroyed now correctly resolves the old and new parent by all
+    foreign key columns.
 
-*   Fix support for PostgreSQL enum types with commas in their name.
+    *Romulo Storel*
 
-    *Arthur Hess*
+*   Fix `add_index` `comment:` option on a schema-qualified PostgreSQL table.
 
-*   Fix inserts on MySQL with no RETURNING support for a table with multiple auto populated columns.
+    The `COMMENT ON INDEX` statement now schema-qualifies the index name, so the
+    comment is applied to the index in the correct schema instead of raising.
 
-    *Nikita Vasilevsky*
+    *Tobias Egli*
 
-*   Fix joining on a scoped association with string joins and bind parameters.
+*   Fix `check_all_foreign_keys_valid!` on PostgreSQL partitioned tables.
 
-    ```ruby
-    class Instructor < ActiveRecord::Base
-      has_many :instructor_roles, -> { active }
-    end
+    The validation query previously matched constraints by name across all tables in
+    the schema, marking unrelated constraints (including partition children) as not
+    validated. It now scopes the update to the specific table.
 
-    class InstructorRole < ActiveRecord::Base
-      scope :active, -> {
-        joins("JOIN students ON instructor_roles.student_id = students.id")
-        .where(students { status: 1 })
-      }
-    end
+    *Alexis Andrieu*
 
-    Instructor.joins(:instructor_roles).first
-    ```
+*   Revert stable sorting of columns and indexes in serialized schema caches.
 
-    The above example would result in `ActiveRecord::StatementInvalid` because the
-    `active` scope bind parameters would be lost.
+    `SchemaCache#encode_with` no longer sorts a table's columns and indexes by name
+    when writing the cache, restoring the pre-8.1 behavior.
 
     *Jean Boussier*
 
-*   Fix a potential race condition with system tests and transactional fixtures.
+*   Fix `only_columns` to enumerate columns in the `SELECT` clause.
 
-    *Sjoerd Lagarde*
+    Models using `only_columns` were generating `SELECT *` instead of an explicit
+    column list, which could select columns that were meant to be excluded.
 
-*   Fix count with group by qualified name on loaded relation.
+    *sarub0b0*
 
-    *Ryuta Kamizono*
+*   Fix `eager_load` with a composite primary key and an explicit `select`.
 
-*   Fix sum with qualified name on loaded relation.
+    The join dependency used the single primary key value to build aliases; for
+    composite primary keys it now uses the full array of primary key columns, so
+    eager loading with a custom `select` no longer drops the association records.
 
-    *Chris Gunther*
+    *fatkodima*
 
-*   Fix autosave associations to no longer validated unmodified associated records.
+*   Fix `find_signed` with a composite primary key.
 
-    Active Record was incorrectly performing validation on associated record that
-    weren't created nor modified as part of the transaction:
+    `find_signed` now wraps the decoded id in an array so `find_by` matches against
+    all primary key columns, instead of silently returning `nil`.
 
-    ```ruby
-    Post.create!(author: User.find(1)) # Fail if user is invalid
-    ```
+    *Kenta Ishizaki*
 
-    *Jean Boussier*
+*   Fix `with_connection(prevent_permanent_checkout: true)` clearing a sticky lease
+    that was already set by `lease_connection`.
 
-*   Remember when a database connection has recently been verified (for
-    two seconds, by default), to avoid repeated reverifications during a
-    single request.
+    A `with_connection` call with `prevent_permanent_checkout: true` no longer resets
+    `lease.sticky` to its previous value when the connection was already sticky, so
+    the connection remains checked out after the block.
 
-    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.
+    *Ben Sheldon*
 
-    *Matthew Draper*
+*   Fix `reset_counters` to cast string ids to the primary key type.
 
-*   Fix prepared statements on mysql2 adapter.
+    `reset_counters` called with a string id (the form ids take from request params)
+    failed to find the record for both single and composite primary keys. Each id is
+    now cast against its own column type.
 
-    *Jean Boussier*
-
-*   Fix a race condition in `ActiveRecord::Base#method_missing` when lazily defining attributes.
+    *fatkodima*
 
-    If multiple thread were concurrently triggering attribute definition on the same model,
-    it could result in a `NoMethodError` being raised.
+*   Fix `belongs_to` presence validation for composite foreign keys.
 
-    *Jean Boussier*
+    The required-association validation only checked the first foreign key column.
+    For composite foreign keys it now considers the association present only when
+    none of the foreign key columns are `nil`, and changed when any of them changed.
 
-*   Fix MySQL default functions getting dropped when changing a column's nullability.
+    *Felix Descoteaux*
 
-    *Bastian Bartmann*
+*   Fix preloading a `belongs_to` with a composite foreign key when some key columns
+    are `nil`.
 
-*   Fix `add_unique_constraint`/`add_check_constraint`/`/`add_foreign_key` to be revertible when
-    given invalid options.
+    The preloader now skips owners whose composite key has any `nil` component
+    instead of issuing a query that matches unrelated rows.
 
-    *fatkodima*
+    *Rose Wiegley*
 
-*   Fix asynchronous destroying of polymorphic `belongs_to` associations.
+*   Fix `belongs_to` inverse matching with composite foreign keys.
 
-    *fatkodima*
+    `inversable?` compared a single foreign key column against a single primary key,
+    so `belongs_to` associations with composite foreign keys never matched their
+    inverse. Foreign key and primary key values are now compared component by
+    component.
 
-*   NOT VALID constraints should not dump in `create_table`.
+    *Martin Samson*
 
-    *Ryuta Kamizono*
+*   Fix `validate_table_length!` to ignore the schema prefix on PostgreSQL.
 
-*   Fix finding by nil composite primary key association.
+    Schema-qualified table names (e.g. `"schema.very_long_table_name"`) were
+    incorrectly rejected as exceeding the table name length limit because the schema
+    prefix was counted. The schema is now stripped before checking the length.
 
     *fatkodima*
 
-*   Fix parsing of SQLite foreign key names when they contain non-ASCII characters
+*   Fix passing Trilogy SSL options to `mysql` and `mysqldump` commands.
 
-    *Zacharias Knudsen*
+    *Ngan Pham*
 
-*   Fix parsing of MySQL 8.0.16+ CHECK constraints when they contain new lines.
+*   Fix `keepalive: false` in `database.yml` falling back to the
+    600 second default.
 
-    *Steve Hill*
+    *Joe Sak*
 
-*   Ensure normalized attribute queries use `IS NULL` consistently for `nil` and normalized `nil` values.
+*   Fix connection checkout blocking past the configured `checkout_timeout` while
+    waiting behind background connection maintenance.
 
-    *Joshua Young*
+    `ConnectionPool#try_to_queue_for_background_connection` waited up to a
+    hardcoded 100 seconds for a connection tied up in maintenance (e.g. a keepalive
+    ping), regardless of the pool's configured `checkout_timeout`. If maintenance
+    stalled (a slow or unresponsive database server), checkout could block for far
+    longer than the caller asked for.
 
-*   Restore back the ability to pass only database name for `DATABASE_URL`.
+    *Joe Sak*
 
-    *fatkodima*
+*   Fix encrypted fixtures for JSON columns.
 
-*   Fix `order` with using association name as an alias.
+    Encrypted fixture values were serialized twice: once by the encrypted
+    attribute type and again by the column type when the rows were inserted.
+    For `json`/`jsonb` columns this stored the encrypted payload as a JSON
+    string, which then failed to decrypt. The payload is now handed back in
+    the column's cast form so it round-trips through the column type.
 
-    *Ryuta Kamizono*
+    *Carlos Daniel Pohlod*
 
-*   Improve invalid argument error for with.
+*   Fix performance regression in `method_missing` for virtual SELECT alias
+    attributes.
 
-    *Ryuta Kamizono*
+    Fixes #57183.
 
-*   Deduplicate `with` CTE expressions.
+    *Hammad Khan*
 
-    *fatkodima*
+*   Column defaults are no longer eagerly deserialized.
 
+    Restore the Active Record 8.0 and older behavior.
+    Column defaults are now whatever is returned by the database, generally a string.
 
-## Rails 7.2.2.2 (August 13, 2025) ##
+    This was changed in 8.1.0 to make the attribute API more consistent,
+    however it caused problems when the attribute type is later changed in the model.
 
-*   Call inspect on ids in RecordNotFound error
+    Typically, some databases treat boolean columns as small integers, ance once the
+    default integer is casted to a boolean, it's not longer possible to change the
+    attribute back into an integer in the model.
 
-    [CVE-2025-55193]
+    Before:
 
-    *Gannon McGibbon*, *John Hawthorn*
+    ```ruby
+    Person.columns_hash["age"].default # => 0
+    ```
 
+    After:
 
-## Rails 7.2.2.1 (December 10, 2024) ##
+    ```ruby
+    Person.columns_hash["age"].default # => "0"
+    ```
 
-*   No changes.
+    See https://github.com/rails/rails/issues/58292.
 
+    *Jean Boussier*
 
-## Rails 7.2.2 (October 30, 2024) ##
+*   Preserve the declared parent order when dumping PostgreSQL `INHERITS` table options.
 
-*   Fix support for `query_cache: false` in `database.yml`.
+    The schema dumper read a table's inherited parents without an `ORDER BY`, so the
+    `INHERITS (...)` clause in `schema.rb` could be emitted in a nondeterministic order.
+    Parents are now ordered by `pg_inherits.inhseqno`.
 
-    `query_cache: false` would no longer entirely disable the Active Record query cache.
+    *viralpraxis*
 
-    *zzak*
+*   Preserve SQLite partial and expression indexes when their stored SQL contains newlines.
 
-*   Set `.attributes_for_inspect` to `:all` by default.
+    *Javi Ramírez*
 
-    For new applications it is set to `[:id]` in config/environment/production.rb.
+*   Only use multi statement for `SET TRANSACTION ISOLATION LEVEL; BEGIN` if
+    MySQL connection is configured to use multi statement.
 
-    In the console all the attributes are always shown.
+    *Eliseu Daroit*, *Hartley McGuire*, *Matthew Draper*
 
-    *Andrew Novoselac*
+*   Mark a connection unverified when a non-`StandardError` interrupts a query.
 
-*   `PG::UnableToSend: no connection to the server` is now retryable as a connection-related exception
+    A query interrupted by a non-`StandardError`, such as a fiber scheduler's
+    cancel or a `Timeout`, leaves the connection desynced. Active Record
+    previously returned it to the pool still marked verified, so the next
+    checkout reused it and failed on a dead socket. The connection is now
+    marked unverified, so it re-verifies and reconnects before its next use.
 
-    *Kazuma Watanabe*
+    *Eliseu Daroit*
 
-*   Fix marshalling of unsaved associated records in 7.1 format.
+*   Fix `has_many` and `has_one` associations on a new record returning an empty
+    result when the owner has a composite primary key, even when every primary
+    key column is populated.
 
-    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-Samuel Aubry-Guzzi*
 
-    *Jean Boussier*
+*   Fix inverse association matching for `has_many` and `has_one` associations
+    with association-specific composite primary keys.
 
-*   Fix incorrect SQL query when passing an empty hash to `ActiveRecord::Base.insert`.
+    *Hugo Vacher*
 
-    *David Stosik*
+*   Fix `ActiveRecord::Base.with` to call `Object#with` when given a block.
 
-*   Allow to save records with polymorphic join tables that have `inverse_of`
-    specified.
+    The class-level `with` delegates to the relation's CTE query method, which
+    does not accept a block. When a block is passed, it now delegates to
+    `Object#with` instead, so it can be used to temporarily set attributes on
+    the class for the duration of the block.
 
-    *Markus Doits*
+    *Janko Marohnić*
 
-*   Fix association scopes applying on the incorrect join when using a polymorphic `has_many through:`.
+*   Fix `serialize` with `coder: ActiveRecord::Coders::JSON` silently double-encoding
+    a native `json`/`jsonb` column.
 
-    *Joshua Young*
+    *Kenta Ishizaki*
 
-*   Fix `dependent: :destroy` for bi-directional has one through association.
+*   Fix `update_all` / `delete_all` ignoring `group` and `having`, updating or
+    deleting every row in the table instead of only the rows that satisfy the
+    `HAVING` clause.
 
-    Fixes #50948.
+    *Kenta Ishizaki*
 
-    ```ruby
-    class Left < ActiveRecord::Base
-      has_one :middle, dependent: :destroy
-      has_one :right, through: :middle
-    end
+*   Fix `ActiveRecord::Relation#cache_key` / `cache_version` for a loaded collection
+    containing a record without a timestamp.
 
-    class Middle < ActiveRecord::Base
-      belongs_to :left, dependent: :destroy
-      belongs_to :right, dependent: :destroy
-    end
+    *Kenta Ishizaki*
 
-    class Right < ActiveRecord::Base
-      has_one :middle, dependent: :destroy
-      has_one :left, through: :middle
-    end
-    ```
-    In the above example `left.destroy` wouldn't destroy its associated `Right`
-    record.
+*   Fix model `filter_attributes` to not add useless filters into `config.filter_parameters`.
 
-    *Andy Stewart*
+    Proc and Regexp filters would be improperly turned into string matchers.
+    Now they are skipped.
 
-*   Properly handle lazily pinned connection pools.
+    *Jonathan Calvert*
 
-    Fixes #53147.
+*   Fix `ActiveRecord::MessagePack` serialization raising `NoMethodError`
+    for any record with a populated `time` column, which made such records
+    uncacheable through the MessagePack cache serializer.
 
-    When using transactional fixtures with system tests to similar tools
-    such as capybara, it could happen that a connection end up pinned by the
-    server thread rather than the test thread, causing
-    `"Cannot expire connection, it is owned by a different thread"` errors.
+    *Kenta Ishizaki*
 
-    *Jean Boussier*
+*   Fix replacing or clearing a polymorphic `has_one` leaving a stale type column
+    on the removed record.
 
-*   Fix `ActiveRecord::Base.with` to accept more than two sub queries.
+    *Kenta Ishizaki*
 
-    Fixes #53110.
+*   Fix `accepts_nested_attributes_for` `:limit` miscounting a single-record hash.
 
-    ```ruby
-    User.with(foo: [User.select(:id), User.select(:id), User.select(:id)]).to_sql
-    undefined method `union' for an instance of Arel::Nodes::UnionAll (NoMethodError)
-    ```
+    *Kenta Ishizaki*
 
-    The above now works as expected.
+*   Fix `rename_index` to preserve a partial index's `WHERE` for SQLite and older MySQL/MariaDB versions.
 
-    *fatkodima*
+    *Kenta Ishizaki*
 
-*   Properly release pinned connections with non joinable connections.
+*   Fix PostgreSQL `foreign_keys` returning a corrupted `to_table` for a foreign key
+    that references a table in a quoted schema.
 
-    Fixes #52973
+    *Kenta Ishizaki*
 
-    When running system tests with transactional fixtures on, it could happen that
-    the connection leased by the Puma thread wouldn't be properly released back to the pool,
-    causing "Cannot expire connection, it is owned by a different thread" errors in later tests.
+*   Fix grouped calculations (e.g. `count`) grouped by a `belongs_to` association
+    that points to a composite primary key model.
 
-    *Jean Boussier*
+    `Book.group(:order).count`, where `Book belongs_to :order` and `Order` has a
+    composite primary key, raised `ArgumentError: Expected corresponding value
+    for ["shop_id", "id"] to be an Array`. The grouped result is now keyed by the
+    associated records as it already is for single-column keys.
 
-*   Make Float distinguish between `float4` and `float8` in PostgreSQL.
+    *Kenta Ishizaki*
 
-    Fixes #52742
+*   Fix `has_many`/`has_one :through` associations with `disable_joins: true`
+    silently returning an empty result when the source points to a composite
+    primary key model.
 
-    *Ryota Kitazawa*, *Takayuki Nagatomi*
+    *Kenta Ishizaki*
 
-*   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.
+*   Fix collection association `ids=` writers (e.g. `author.book_ids=`) raising
+    `ActiveRecord::RecordNotFound` for existing records when a composite primary
+    key model is assigned string ids (the shape ids take from request params).
 
-    Previously, using `.left_outer_joins` with the same child association would only join one of the parents.
+    Each id component is now cast against its own column type, instead of casting
+    the whole tuple against an array of column names, which `type_for_attribute`
+    can't resolve to a real type (so the cast was a no-op and the string ids
+    never matched the loaded records).
 
-    Now it will correctly join both parents.
+    *Kenta Ishizaki*
 
-    Fixes #41498.
+*   Fix `find` with multiple composite primary key ids passed as strings
+    silently returning `[]`.
 
-    *Garrett Blehm*
+    `Model.find([["1", "10"], ["1", "20"]])` (the shape ids take when they come
+    from request parameters) returned an empty array instead of the records and
+    without raising `RecordNotFound`. The ids were cast against the array of key
+    column names as a whole — which is a no-op — so the string tuples never
+    compared equal to the records' integer ids when ordering the result. Each
+    component is now cast against its own column type, matching the documented
+    coercion already performed for single-column keys.
 
-*   Ensure `ActiveRecord::Encryption.config` is always ready before access.
+    *Kenta Ishizaki*
 
-    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.
+*   Fix PostgreSQL `daterange` / `tsrange` / `tstzrange` schema dump producing
+    invalid Ruby.
 
-    `ActiveRecord::Encryption` now has its own loading hook so that its configuration is set as
-    soon as needed.
+    The schema dumper used to render range defaults via `Range#inspect`, which
+    falls back to `Date#inspect` / `Time#inspect` for the bounds. The resulting
+    `schema.rb` literal (for example `default: Mon, 01 Jan 2024..Wed, 01 Jan 2025`)
+    raised a `SyntaxError` on `db:schema:load`. The bounds are now rendered via
+    the subtype's `type_cast_for_schema`, so date and timestamp range defaults
+    round-trip through `schema.rb` like any other column.
 
-    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`.
+    *Kenta Ishizaki*
 
-    *Maxime Réty*
+*   Fix deadlock when pool-less connection materializes while fetching database
+    server version.
 
-*   Add `TimeZoneConverter#==` method, so objects will be properly compared by
-    their type, scale, limit & precision.
+    *Hartley McGuire*
 
-    Address #52699.
+*   Fix PostgreSQL range columns corrupting bounds that contain a comma.
 
-    *Ruy Rocha*
+    `PostgreSQL::OID::Range#extract_bounds` split a range's textual
+    representation on the first comma, but PostgreSQL double-quotes any bound
+    that itself contains a comma (e.g. a range over a text subtype). A value
+    such as `["a,b","c,d")` was therefore split inside the first quoted bound
+    and read back with both endpoints corrupted. The split now skips over
+    double-quoted segments when locating the separating comma.
 
+    *Kenta Ishizaki*
 
-## Rails 7.2.1.2 (October 23, 2024) ##
+*   Fix store accessor `*_change` and `saved_change_to_*` reporting a change
+    for unchanged keys.
 
-*   No changes.
+    When one key of a `store` column changed, the generated `<key>_change` and
+    `saved_change_to_<key>` methods returned a `[value, value]` pair for the
+    column's *other* keys too, even though their matching `<key>_changed?` /
+    `saved_change_to_<key>?` correctly returned `false` and standard attribute
+    `_change` / `saved_change_to_*` methods return `nil` when unchanged. The
+    methods now return `nil` unless that specific key actually changed,
+    matching their predicate counterparts.
 
+    *Kenta Ishizaki*
 
-## Rails 7.2.1.1 (October 15, 2024) ##
+*   Reduce number of queries when introspecting MySQL/MariaDB tables.
 
-*   No changes.
+    A fix to support MariaDB function defaults caused the MySQL adapters to
+    issue one query per column when introspecting tables.
 
+    Now it only issue a single extra query per table, and only when using MariaDB.
 
-## Rails 7.2.1 (August 22, 2024) ##
+    *Iliana Hadzhiatanasova*
 
-*   Fix detection for `enum` columns with parallelized tests and PostgreSQL.
+*   Fully qualify query criterias in `has_and_belongs_to_many` associations.
 
-    *Rafael Mendonça França*
+    Ensure that scopes with the same column name but in different tables aren't lost
+    when following an HABTM association.
 
-*   Allow to eager load nested nil associations.
+    *Philip Maina*
 
-    *fatkodima*
+*   Fix Active Record Pool Reaper thread leak after `Parallelization#shutdown`.
 
-*   Fix swallowing ignore order warning when batching using `BatchEnumerator`.
+    After parallelized test runs, the parent process leaked the Active Record Pool
+    Reaper thread, holding open connection pools and file descriptors for up to
+    `reaping_frequency` seconds (or indefinitely if never reaped).
 
-    *fatkodima*
+    Three fixes: `Parallelization#shutdown` now calls `run_cleanup_hooks`;
+    Active Record registers a cleanup hook that discards all connection pools; and
+    `ConnectionPool#discard!` now calls `Reaper.discard_pool`, which immediately
+    kills and joins the reaper thread when no pools remain at that frequency.
 
-*   Fix memory bloat on the connection pool when using the Fiber `IsolatedExecutionState`.
+    *Ruy Rocha*
 
-    *Jean Boussier*
+*   Fix duplicate `WHERE` conditions in `create_or_find_by`.
 
-*   Restore inferred association class with the same modularized name.
+    When `create_or_find_by` catches a `RecordNotUnique` error and retries the query, it now uses `rewhere` and `take!` to prevent duplicating existing scope conditions.
 
-    *Justin Ko*
+    *Yavor Dashev*
 
-*   Fix `ActiveRecord::Base.inspect` to properly explain how to load schema information.
+*   Fix `ActiveRecord::QueryMethods#in_order_of` when passing an out-of-range Integer
 
-    *Jean Boussier*
+    To match the behavior of the `Enumerable` version, `in_order_of` now ignores an out-of-range Integer.
 
-*   Check invalid `enum` options for the new syntax.
+    *tejanium*
 
-    The options using `_` prefix in the old syntax are invalid in the new syntax.
+*   Revert alphabetical sorting of table columns inside `schema.rb`.
 
-    *Rafael Mendonça França*
+    Alphabetical sorting of table columns inside the schema creates improper production tables when using `db:prepare`.
 
-*   Fix `ActiveRecord::Encryption::EncryptedAttributeType#type` to return
-    actual cast type.
+    *Bert McCutchen*
 
-    *Vasiliy Ermolovich*
+*   Fix `strict_loading` violations ignored when using `pluck`
 
-*   Fix `create_table` with `:auto_increment` option for MySQL adapter.
+    *Johnson Chan*
 
-    *fatkodima*
+*   Fix incorrect callback execution order when `config.active_record.run_after_transaction_callbacks_in_order_defined = true`
+    and using `after_commit` and `after_rollback` callbacks with `prepend: true`.
 
+    *Joshua Young*
 
-## Rails 7.2.0 (August 09, 2024) ##
+*   Fix `becomes` to preserve `marked_for_destruction?`.
 
-*   Handle commas in Sqlite3 default function definitions.
+    *Vincent Robert*
 
-    *Stephen Margheim*
+*   MySQL error 1046 (`ER_NO_DB_ERROR: No database selected`) is now retryable as a `ConnectionFailed` exception
 
-*   Fixes `validates_associated` raising an exception when configured with a
-    singular association and having `index_nested_attribute_errors` enabled.
+    *Clay Harmon*
 
-    *Martin Spickermann*
 
-*   The constant `ActiveRecord::ImmutableRelation` has been deprecated because
-    we want to reserve that name for a stronger sense of "immutable relation".
-    Please use `ActiveRecord::UnmodifiableRelation` instead.
+## Rails 8.1.3.1 (July 29, 2026) ##
 
-    *Xavier Noria*
+*   No changes.
 
-*   Add condensed `#inspect` for `ConnectionPool`, `AbstractAdapter`, and
-    `DatabaseConfig`.
 
-    *Hartley McGuire*
+## Rails 8.1.3 (March 24, 2026) ##
 
-*   Fixed a memory performance issue in Active Record attribute methods definition.
+*   Fix `insert_all` and `upsert_all` log message when called on anonymous classes.
 
-    *Jean Boussier*
+    *Gabriel Sobrinho*
 
-*   Define the new Active Support notification event `start_transaction.active_record`.
+*   Respect `ActiveRecord::SchemaDumper.ignore_tables` when dumping SQLite virtual tables.
 
-    This event is fired when database transactions or savepoints start, and
-    complements `transaction.active_record`, which is emitted when they finish.
+    *Hans Schnedlitz*
 
-    The payload has the transaction (`:transaction`) and the connection (`:connection`).
+*   Restore previous instrumenter after `execute_or_skip`
 
-    *Xavier Noria*
+    `FutureResult#execute_or_skip` replaces the thread's instrumenter with an
+    `EventBuffer` to collect events published during async query execution.
+    If the global async executor is saturated and the `caller_runs` fallback
+    executes the task on the calling thread, we need to make sure the previous
+    instrumenter is restored or the stale `EventBuffer` would stay in place and
+    permanently swallow all subsequent `sql.active_record` notifications on
+    that thread.
 
-*   Fix an issue where the IDs reader method did not return expected results
-    for preloaded associations in models using composite primary keys.
+    *Rosa Gutierrez*
 
-    *Jay Ang*
+*   Bump the minimum PostgreSQL version to 9.5, due to usage of `array_position` function.
 
-*   The payload of `sql.active_record` Active Support notifications now has the current transaction in the `:transaction` key.
+    *Ivan Kuchin*
 
-    *Xavier Noria*
+*   Fix Ruby 4.0 delegator warning when calling inspect on ActiveRecord::Type::Serialized.
 
-*   The payload of `transaction.active_record` Active Support notifications now has the transaction the event is related to in the `:transaction` key.
+    *Hammad Khan*
 
-    *Xavier Noria*
+*   Fix support for table names containing hyphens.
 
-*   Define `ActiveRecord::Transaction#uuid`, which returns a UUID for the database transaction. This may be helpful when tracing database activity. These UUIDs are generated only on demand.
+    *Evgeniy Demin*
 
-    *Xavier Noria*
+*   Fix column deduplication for SQLite3 and PostgreSQL virtual (generated) columns.
 
-*   Fix inference of association model on nested models with the same demodularized name.
+    `Column#==` and `Column#hash` now account for `virtual?` so that the
+    `Deduplicable` registry does not treat a generated column and a regular
+    column with the same name and type as identical. Previously, if a
+    generated column was registered first, a regular column on a different
+    table could be deduplicated to the generated instance, silently
+    excluding it from INSERT/UPDATE statements.
 
-    E.g. with the following setup:
+    *Jay Huber*
 
-    ```ruby
-    class Nested::Post < ApplicationRecord
-      has_one :post, through: :other
-    end
-    ```
+*   Fix PostgreSQL schema dumping to handle schema-qualified table names in foreign_key references that span different schemas.
 
-    Before, `#post` would infer the model as `Nested::Post`, but now it correctly infers `Post`.
+        # before
+        add_foreign_key "hst.event_log_attributes", "hst.event_logs" # emits correctly because they're in the same schema (hst)
+        add_foreign_key "hst.event_log_attributes", "hst.usr.user_profiles", column: "created_by_id" # emits hst.user.* when user.* is expected
 
-    *Joshua Young*
+        # after
+        add_foreign_key "hst.event_log_attributes", "hst.event_logs"
+        add_foreign_key "hst.event_log_attributes", "usr.user_profiles", column: "created_by_id"
 
-*   PostgreSQL `Cidr#change?` detects the address prefix change.
+    *Chiperific*
 
-    *Taketo Takashima*
 
-*   Change `BatchEnumerator#destroy_all` to return the total number of affected rows.
+## Rails 8.1.2.1 (March 23, 2026) ##
 
-    Previously, it always returned `nil`.
+*   No changes.
 
-    *fatkodima*
 
-*   Support `touch_all` in batches.
+## Rails 8.1.2 (January 08, 2026) ##
 
-    ```ruby
-    Post.in_batches.touch_all
-    ```
+*   Fix counting cached queries in `ActiveRecord::RuntimeRegistry`.
 
     *fatkodima*
 
-*   Add support for `:if_not_exists` and `:force` options to `create_schema`.
+*   Fix merging relations with arel equality predicates with null relations.
 
     *fatkodima*
 
-*   Fix `index_errors` having incorrect index in association validation errors.
+*   Fix SQLite3 schema dump for non-autoincrement integer primary keys.
 
-    *lulalala*
+    Previously, `schema.rb` should incorrectly restore that table with an auto incrementing
+    primary key.
 
-*   Add `index_errors: :nested_attributes_order` mode.
+    *Chris Hasiński*
 
-    This indexes the association validation errors based on the order received by nested attributes setter, and respects the `reject_if` configuration. This enables API to provide enough information to the frontend to map the validation errors back to their respective form fields.
+*   Fix PostgreSQL `schema_search_path` not being reapplied after `reset!` or `reconnect!`.
 
-    *lulalala*
+    The `schema_search_path` configured in `database.yml` is now correctly
+    reapplied instead of falling back to PostgreSQL defaults.
 
-*   Add `Rails.application.config.active_record.postgresql_adapter_decode_dates` to opt out of decoding dates automatically with the postgresql adapter. Defaults to true.
+    *Tobias Egli*
 
-    *Joé Dupuis*
+*   Restore the ability of enum to be foats.
 
-*   Association option `query_constraints` is deprecated in favor of `foreign_key`.
+    ```ruby
+    enum :rating, { low: 0.0, medium: 0.5, high: 1.0 },
+    ```
 
-    *Nikita Vasilevsky*
+    In Rails 8.1.0, enum values are eagerly validated, and floats weren't expected.
 
-*   Add `ENV["SKIP_TEST_DATABASE_TRUNCATE"]` flag to speed up multi-process test runs on large DBs when all tests run within default transaction.
+    *Said Kaldybaev*
 
-    This cuts ~10s from the test run of HEY when run by 24 processes against the 178 tables, since ~4,000 table truncates can then be skipped.
+*   Ensure batched preloaded associations accounts for klass when grouping to avoid issues with STI.
 
-    *DHH*
+    *zzak*, *Stjepan Hadjic*
 
-*   Added support for recursive common table expressions.
+*   Fix `ActiveRecord::SoleRecordExceeded#record` to return the relation.
 
-    ```ruby
-    Post.with_recursive(
-      post_and_replies: [
-        Post.where(id: 42),
-        Post.joins('JOIN post_and_replies ON posts.in_reply_to_id = post_and_replies.id'),
-      ]
-    )
-    ```
+    This was the case until Rails 7.2, but starting from 8.0 it
+    started mistakenly returning the model class.
 
-    Generates the following SQL:
+    *Jean Boussier*
 
-    ```sql
-    WITH RECURSIVE "post_and_replies" AS (
-      (SELECT "posts".* FROM "posts" WHERE "posts"."id" = 42)
-      UNION ALL
-      (SELECT "posts".* FROM "posts" JOIN post_and_replies ON posts.in_reply_to_id = post_and_replies.id)
-    )
-    SELECT "posts".* FROM "posts"
-    ```
+*   Improve PostgreSQLAdapter resilience to Timeout.timeout.
 
-    *ClearlyClaire*
+    Better handle asynchronous exceptions being thrown inside
+    the `reconnect!` method.
 
-*   `validate_constraint` can be called in a `change_table` block.
+    This may fixes some deep errors such as:
 
-    ex:
-    ```ruby
-    change_table :products do |t|
-      t.check_constraint "price > discounted_price", name: "price_check", validate: false
-      t.validate_check_constraint "price_check"
-    end
+    ```
+    undefined method `key?' for nil:NilClass (NoMethodError)
+              if !type_map.key?(oid)
     ```
 
-    *Cody Cutrer*
+    *Jean Boussier*
 
-*   `PostgreSQLAdapter` now decodes columns of type date to `Date` instead of string.
+*   Fix structured events for Active Record was not being emitted.
 
-    Ex:
-    ```ruby
-    ActiveRecord::Base.connection
-         .select_value("select '2024-01-01'::date").class #=> Date
-    ```
+    *Yuji Yaginuma*
 
-    *Joé Dupuis*
+*   Fix `eager_load` when loading `has_many` assocations with composite primary keys.
 
-*   Strict loading using `:n_plus_one_only` does not eagerly load child associations.
+    This would result in some records being loaded multiple times.
 
-    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.
+    *Martin-Alexander*
 
-    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
-    ```
+## Rails 8.1.1 (October 28, 2025) ##
 
-    After:
+*   No changes.
 
-    ```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*
+## Rails 8.1.0 (October 22, 2025) ##
 
-*   Allow `Sqlite3Adapter` to use `sqlite3` gem version `2.x`.
+*   Fix SQLite3 data loss during table alterations with CASCADE foreign keys.
 
-    *Mike Dalessio*
+    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.
 
-*   Allow `ActiveRecord::Base#pluck` to accept hash values.
+    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.
 
-    ```ruby
-    # Before
-    Post.joins(:comments).pluck("posts.id", "comments.id", "comments.body")
+    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.
 
-    # After
-    Post.joins(:comments).pluck(posts: [:id], comments: [:id, :body])
-    ```
+    *Ruy Rocha*
 
-    *fatkodima*
+*   Add replicas to test database parallelization setup.
 
-*   Raise an `ActiveRecord::ActiveRecordError` error when the MySQL database returns an invalid version string.
+    Setup and configuration of databases for parallel testing now includes replicas.
 
-    *Kevin McPhillips*
+    This fixes an issue when using a replica database, database selector middleware,
+    and non-transactional tests, where integration tests running in parallel would select
+    the base test database, i.e. `db_test`, instead of the numbered parallel worker database,
+    i.e. `db_test_{n}`.
 
-*   `ActiveRecord::Base.transaction` now yields an `ActiveRecord::Transaction` object.
+    *Adam Maas*
 
-    This allows to register callbacks on it.
+*   Support virtual (not persisted) generated columns on PostgreSQL 18+
+
+    PostgreSQL 18 introduces virtual (not persisted) generated columns,
+    which are now the default unless the `stored: true` option is explicitly specified on PostgreSQL 18+.
 
     ```ruby
-    Article.transaction do |transaction|
-      article.update(published: true)
-      transaction.after_commit do
-        PublishNotificationMailer.with(article: article).deliver_later
-      end
+    create_table :users do |t|
+      t.string :name
+      t.virtual :lower_name,  type: :string,  as: "LOWER(name)", stored: false
+      t.virtual :name_length, type: :integer, as: "LENGTH(name)"
     end
     ```
 
-    *Jean Boussier*
-
-*   Add `ActiveRecord::Base.current_transaction`.
+    *Yasuo Honda*
 
-    Returns the current transaction, to allow registering callbacks on it.
+*   Optimize schema dumping to prevent duplicate file generation.
 
-    ```ruby
-    Article.current_transaction.after_commit do
-      PublishNotificationMailer.with(article: article).deliver_later
-    end
-    ```
+    `ActiveRecord::Tasks::DatabaseTasks.dump_all` now tracks which schema files
+    have already been dumped and skips dumping the same file multiple times.
+    This improves performance when multiple database configurations share the
+    same schema dump path.
 
-    *Jean Boussier*
+    *Mikey Gough*, *Hartley McGuire*
 
-*   Add `ActiveRecord.after_all_transactions_commit` callback.
+*   Add structured events for Active Record:
+    - `active_record.strict_loading_violation`
+    - `active_record.sql`
 
-    Useful for code that may run either inside or outside a transaction and needs
-    to perform work after the state changes have been properly persisted.
+    *Gannon McGibbon*
 
+*   Add support for integer shard keys.
     ```ruby
-    def publish_article(article)
-      article.update(published: true)
-      ActiveRecord.after_all_transactions_commit do
-        PublishNotificationMailer.with(article: article).deliver_later
-      end
+    # Now accepts symbols as shard keys.
+    ActiveRecord::Base.connects_to(shards: {
+      1: { writing: :primary_shard_one, reading: :primary_shard_one },
+      2: { writing: :primary_shard_two, reading: :primary_shard_two},
+    })
+
+    ActiveRecord::Base.connected_to(shard: 1) do
+      # ..
     end
     ```
 
-    In the above example, the block is either executed immediately if called outside
-    of a transaction, or called after the open transaction is committed.
+    *Nony Dutton*
 
-    If the transaction is rolled back, the block isn't called.
+*   Add `ActiveRecord::Base.only_columns`
 
-    *Jean Boussier*
+    Similar in use case to `ignored_columns` but listing columns to consider rather than the ones
+    to ignore.
 
-*   Add the ability to ignore counter cache columns until they are backfilled.
+    Can be useful when working with a legacy or shared database schema, or to make safe schema change
+    in two deploys rather than three.
 
-    Starting to use counter caches on existing large tables can be troublesome, because the column
-    values must be backfilled separately of the column addition (to not lock the table for too long)
-    and before the use of `:counter_cache` (otherwise methods like `size`/`any?`/etc, which use
-    counter caches internally, can produce incorrect results). People usually use database triggers
-    or callbacks on child associations while backfilling before introducing a counter cache
-    configuration to the association.
+    *Anton Kandratski*
 
-    Now, to safely backfill the column, while keeping the column updated with child records added/removed, use:
+*   Use `PG::Connection#close_prepared` (protocol level Close) to deallocate
+    prepared statements when available.
 
-    ```ruby
-    class Comment < ApplicationRecord
-      belongs_to :post, counter_cache: { active: false }
-    end
-    ```
+    To enable its use, you must have pg >= 1.6.0, libpq >= 17, and a PostgreSQL
+    database version >= 17.
 
-    While the counter cache is not "active", the methods like `size`/`any?`/etc will not use it,
-    but get the results directly from the database. After the counter cache column is backfilled, simply
-    remove the `{ active: false }` part from the counter cache definition, and it will now be used by the
-    mentioned methods.
+    *Hartley McGuire*, *Andrew Jackson*
 
-    *fatkodima*
+*   Fix query cache for pinned connections in multi threaded transactional tests
 
-*   Retry known idempotent SELECT queries on connection-related exceptions.
+    When a pinned connection is used across separate threads, they now use a separate cache store
+    for each thread.
 
-    SELECT queries we construct by walking the Arel tree and / or with known model attributes
-    are idempotent and can safely be retried in the case of a connection error. Previously,
-    adapters such as `TrilogyAdapter` would raise `ActiveRecord::ConnectionFailed: Trilogy::EOFError`
-    when encountering a connection error mid-request.
+    This improve accuracy of system tests, and any test using multiple threads.
 
-    *Adrianna Chang*
+    *Heinrich Lee Yu*, *Jean Boussier*
 
-*   Allow association's `foreign_key` to be composite.
+*   Fix time attribute dirty tracking with timezone conversions.
 
-    `query_constraints` option was the only way to configure a composite foreign key by passing an `Array`.
-    Now it's possible to pass an Array value as `foreign_key` to achieve the same behavior of an association.
+    Time-only attributes now maintain a fixed date of 2000-01-01 during timezone conversions,
+    preventing them from being incorrectly marked as changed due to date shifts.
 
-    *Nikita Vasilevsky*
+    This fixes an issue where time attributes would be marked as changed when setting the same time value
+    due to timezone conversion causing internal date shifts.
 
-*   Allow association's `primary_key` to be composite.
+    *Prateek Choudhary*
 
-    Association's `primary_key` can be composite when derived from associated model `primary_key` or `query_constraints`.
-    Now it's possible to explicitly set it as composite on the association.
+*   Skip calling `PG::Connection#cancel` in `cancel_any_running_query`
+    when using libpq >= 18 with pg < 1.6.0, due to incompatibility.
+    Rollback still runs, but may take longer.
 
-    *Nikita Vasilevsky*
+    *Yasuo Honda*, *Lars Kanis*
 
-*   Add `config.active_record.permanent_connection_checkout` setting.
+*   Don't add `id_value` attribute alias when attribute/column with that name already exists.
 
-    Controls whether `ActiveRecord::Base.connection` raises an error, emits a deprecation warning, or neither.
+    *Rob Lewis*
 
-    `ActiveRecord::Base.connection` checkouts a database connection from the pool and keeps it leased until the end of
-    the request or job. This behavior can be undesirable in environments that use many more threads or fibers than there
-    is available connections.
+*   Remove deprecated `:unsigned_float` and `:unsigned_decimal` column methods for MySQL.
 
-    This configuration can be used to track down and eliminate code that calls `ActiveRecord::Base.connection` and
-    migrate it to use `ActiveRecord::Base.with_connection` instead.
+    *Rafael Mendonça França*
 
-    The default behavior remains unchanged, and there is currently no plans to change the default.
+*   Remove deprecated `:retries` option for the SQLite3 adapter.
 
-    *Jean Boussier*
+    *Rafael Mendonça França*
+
+*   Introduce new database configuration options `keepalive`, `max_age`, and
+    `min_connections` -- and rename `pool` to `max_connections` to match.
 
-*   Add dirties option to uncached.
+    There are no changes to default behavior, but these allow for more specific
+    control over pool behavior.
 
-    This adds a `dirties` option to `ActiveRecord::Base.uncached` and
-    `ActiveRecord::ConnectionAdapters::ConnectionPool#uncached`.
+    *Matthew Draper*, *Chris AtLee*, *Rachael Wright-Munn*
 
-    When set to `true` (the default), writes will clear all query caches belonging to the current thread.
-    When set to `false`, writes to the affected connection pool will not clear any query cache.
+*   Move `LIMIT` validation from query generation to when `limit()` is called.
 
-    This is needed by Solid Cache so that cache writes do not clear query caches.
+    *Hartley McGuire*, *Shuyang*
 
-    *Donal McBreen*
+*   Add `ActiveRecord::CheckViolation` error class for check constraint violations.
 
-*   Deprecate `ActiveRecord::Base.connection` in favor of `.lease_connection`.
+    *Ryuta Kamizono*
 
-    The method has been renamed as `lease_connection` to better reflect that the returned
-    connection will be held for the duration of the request or job.
+*   Add `ActiveRecord::ExclusionViolation` error class for exclusion constraint violations.
 
-    This deprecation is a soft deprecation, no warnings will be issued and there is no
-    current plan to remove the method.
+    When an exclusion constraint is violated in PostgreSQL, the error will now be raised
+    as `ActiveRecord::ExclusionViolation` instead of the generic `ActiveRecord::StatementInvalid`,
+    making it easier to handle these specific constraint violations in application code.
 
-    *Jean Boussier*
+    This follows the same pattern as other constraint violation error classes like
+    `RecordNotUnique` for unique constraint violations and `InvalidForeignKey` for
+    foreign key constraint violations.
 
-*   Deprecate `ActiveRecord::ConnectionAdapters::ConnectionPool#connection`.
+    *Ryuta Kamizono*
 
-    The method has been renamed as `lease_connection` to better reflect that the returned
-    connection will be held for the duration of the request or job.
+*   Attributes filtered by `filter_attributes` will now also be filtered by `filter_parameters`
+    so sensitive information is not leaked.
 
-    *Jean Boussier*
+    *Jill Klang*
 
-*   Expose a generic fixture accessor for fixture names that may conflict with Minitest.
+*   Add `connection.current_transaction.isolation` API to check current transaction's isolation level.
+
+    Returns the isolation level if it was explicitly set via the `isolation:` parameter
+    or through `ActiveRecord.with_transaction_isolation_level`, otherwise returns `nil`.
+    Nested transactions return the parent transaction's isolation level.
 
     ```ruby
-    assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
-    assert_equal "Ruby on Rails", fixture(:web_sites, :rubyonrails).name
+    # Returns nil when no transaction
+    User.connection.current_transaction.isolation # => nil
+
+    # Returns explicitly set isolation level
+    User.transaction(isolation: :serializable) do
+      User.connection.current_transaction.isolation # => :serializable
+    end
+
+    # Returns nil when isolation not explicitly set
+    User.transaction do
+      User.connection.current_transaction.isolation # => nil
+    end
+
+    # Nested transactions inherit parent's isolation
+    User.transaction(isolation: :read_committed) do
+      User.transaction do
+        User.connection.current_transaction.isolation # => :read_committed
+      end
+    end
     ```
 
-    *Jean Boussier*
+    *Kir Shatrov*
 
-*   Using `Model.query_constraints` with a single non-primary-key column used to raise as expected, but with an
-    incorrect error message.
+*   Fix `#merge` with `#or` or `#and` and a mixture of attributes and SQL strings resulting in an incorrect query.
 
-    This has been fixed to raise with a more appropriate error message.
+    ```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
+    ```
 
-    *Joshua Young*
+    Before:
 
-*   Fix `has_one` association autosave setting the foreign key attribute when it is unchanged.
+    ```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:
 
-    This behavior 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.
+    ```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*
 
-*   Remove deprecated behavior that would rollback a transaction block when exited using `return`, `break` or `throw`.
+*   Make schema dumper to account for `ActiveRecord.dump_schemas` when dumping in `:ruby` format.
 
-    *Rafael Mendonça França*
+    *fatkodima*
 
-*   Deprecate `Rails.application.config.active_record.commit_transaction_on_non_local_return`.
+*   Add `:touch` option to `update_column`/`update_columns` methods.
 
-    *Rafael Mendonça França*
+    ```ruby
+    # Will update :updated_at/:updated_on alongside :nice column.
+    user.update_column(:nice, true, touch: true)
 
-*   Remove deprecated support to pass `rewhere` to `ActiveRecord::Relation#merge`.
+    # Will update :updated_at/:updated_on alongside :last_ip column
+    user.update_columns(last_ip: request.remote_ip, touch: true)
+    ```
 
-    *Rafael Mendonça França*
+    *Dmitrii Ivliev*
 
-*   Remove deprecated support to pass `deferrable: true` to `add_foreign_key`.
+*   Optimize Active Record batching further when using ranges.
 
-    *Rafael Mendonça França*
+    Tested on a PostgreSQL table with 10M records and batches of 10k records, the generation
+    of relations for the 1000 batches was `4.8x` faster (`6.8s` vs. `1.4s`), used `900x`
+    less bandwidth (`180MB` vs. `0.2MB`) and allocated `45x` less memory (`490MB` vs. `11MB`).
 
-*   Remove deprecated support to quote `ActiveSupport::Duration`.
+    *Maxime Réty*, *fatkodima*
 
-    *Rafael Mendonça França*
+*   Include current character length in error messages for index and table name length validations.
 
-*   Remove deprecated `#quote_bound_value`.
+    *Joshua Young*
 
-    *Rafael Mendonça França*
+*   Add `rename_schema` method for PostgreSQL.
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::ConnectionPool#connection_klass`.
+    *T S Vallender*
 
-    *Rafael Mendonça França*
+*   Implement support for deprecating associations:
 
-*   Remove deprecated support to apply `#connection_pool_list`, `#active_connections?`, `#clear_active_connections!`,
-    `#clear_reloadable_connections!`, `#clear_all_connections!` and `#flush_idle_connections!` to the connections pools
-    for the current role when the `role` argument isn't provided.
+    ```ruby
+    has_many :posts, deprecated: true
+    ```
 
-    *Rafael Mendonça França*
+    With that, Active Record will report any usage of the `posts` association.
 
-*   Remove deprecated `#all_connection_pools`.
+    Three reporting modes are supported (`:warn`, `:raise`, and `:notify`), and
+    backtraces can be enabled or disabled. Defaults are `:warn` mode and
+    disabled backtraces.
 
-    *Rafael Mendonça França*
+    Please, check the docs for further details.
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::SchemaCache#data_sources`.
+    *Xavier Noria*
 
-    *Rafael Mendonça França*
+*   PostgreSQL adapter create DB now supports `locale_provider` and `locale`.
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::SchemaCache.load_from`.
+    *Bengt-Ove Hollaender*
 
-    *Rafael Mendonça França*
+*   Use ntuples to populate row_count instead of count for Postgres
 
-*   Remove deprecated `#all_foreign_keys_valid?` from database adapters.
+    *Jonathan Calvert*
 
-    *Rafael Mendonça França*
+*   Fix checking whether an unpersisted record is `include?`d in a strictly
+    loaded `has_and_belongs_to_many` association.
 
-*   Remove deprecated support to passing coder and class as second argument to `serialize`.
+    *Hartley McGuire*
 
-    *Rafael Mendonça França*
+*   Add ability to change transaction isolation for all pools within a block.
 
-*   Remove deprecated support to `ActiveRecord::Base#read_attribute(:id)` to return the custom primary key value.
+    This functionality is useful if your application needs to change the database
+    transaction isolation for a request or action.
 
-    *Rafael Mendonça França*
+    Calling `ActiveRecord.with_transaction_isolation_level(level) {}` in an around filter or
+    middleware will set the transaction isolation for all pools accessed within the block,
+    but not for the pools that aren't.
 
-*   Remove deprecated `TestFixtures.fixture_path`.
+    This works with explicit and implicit transactions:
 
-    *Rafael Mendonça França*
+    ```ruby
+    ActiveRecord.with_transaction_isolation_level(:read_committed) do
+      Tag.transaction do # opens a transaction explicitly
+        Tag.create!
+      end
+    end
+    ```
 
-*   Remove deprecated behavior to support referring to a singular association by its plural name.
+    ```ruby
+    ActiveRecord.with_transaction_isolation_level(:read_committed) do
+      Tag.create! # opens a transaction implicitly
+    end
+    ```
 
-    *Rafael Mendonça França*
+    *Eileen M. Uchitelle*
 
-*   Deprecate `Rails.application.config.active_record.allow_deprecated_singular_associations_name`.
+*   Raise `ActiveRecord::MissingRequiredOrderError` when order dependent finder methods (e.g. `#first`, `#last`) are
+    called without `order` values on the relation, and the model does not have any order columns (`implicit_order_column`,
+    `query_constraints`, or `primary_key`) to fall back on.
 
-    *Rafael Mendonça França*
+    This change will be introduced with a new framework default for Rails 8.1, and the current behavior of not raising
+    an error has been deprecated with the aim of removing the configuration option in Rails 8.2.
 
-*   Remove deprecated support to passing `SchemaMigration` and `InternalMetadata` classes as arguments to
-    `ActiveRecord::MigrationContext`.
+    ```ruby
+    config.active_record.raise_on_missing_required_finder_order_columns = true
+    ```
 
-    *Rafael Mendonça França*
+    *Joshua Young*
 
-*   Remove deprecated `ActiveRecord::Migration.check_pending!` method.
+*   `:class_name` is now invalid in polymorphic `belongs_to` associations.
 
-    *Rafael Mendonça França*
+    Reason is `:class_name` does not make sense in those associations because
+    the class name of target records is dynamic and stored in the type column.
 
-*   Remove deprecated `ActiveRecord::LogSubscriber.runtime` method.
+    Existing polymorphic associations setting this option can just delete it.
+    While it did not raise, it had no effect anyway.
 
-    *Rafael Mendonça França*
+    *Xavier Noria*
 
-*   Remove deprecated `ActiveRecord::LogSubscriber.runtime=` method.
+*   Add support for multiple databases to `db:migrate:reset`.
 
-    *Rafael Mendonça França*
+    *Joé Dupuis*
 
-*   Remove deprecated `ActiveRecord::LogSubscriber.reset_runtime` method.
+*   Add `affected_rows` to `ActiveRecord::Result`.
 
-    *Rafael Mendonça França*
+    *Jenny Shen*
 
-*   Remove deprecated support to define `explain` in the connection adapter with 2 arguments.
+*   Enable passing retryable SqlLiterals to `#where`.
 
-    *Rafael Mendonça França*
+    *Hartley McGuire*
 
-*   Remove deprecated `ActiveRecord::ActiveJobRequiredError`.
+*   Set default for primary keys in `insert_all`/`upsert_all`.
 
-    *Rafael Mendonça França*
+    Previously in Postgres, updating and inserting new records in one upsert wasn't possible
+    due to null primary key values. `nil` primary key values passed into `insert_all`/`upsert_all`
+    are now implicitly set to the default insert value specified by adapter.
 
-*   Remove deprecated `ActiveRecord::Base.clear_active_connections!`.
+    *Jenny Shen*
 
-    *Rafael Mendonça França*
+*   Add a load hook `active_record_database_configurations` for `ActiveRecord::DatabaseConfigurations`
 
-*   Remove deprecated `ActiveRecord::Base.clear_reloadable_connections!`.
+    *Mike Dalessio*
 
-    *Rafael Mendonça França*
+*   Use `TRUE` and `FALSE` for SQLite queries with boolean columns.
 
-*   Remove deprecated `ActiveRecord::Base.clear_all_connections!`.
+    *Hartley McGuire*
 
-    *Rafael Mendonça França*
+*   Bump minimum supported SQLite to 3.23.0.
 
-*   Remove deprecated `ActiveRecord::Base.flush_idle_connections!`.
+    *Hartley McGuire*
 
-    *Rafael Mendonça França*
+*   Allow allocated Active Records to lookup associations.
 
-*   Remove deprecated `name` argument from `ActiveRecord::Base.remove_connection`.
+    Previously, the association cache isn't setup on allocated record objects, so association
+    lookups will crash. Test frameworks like mocha use allocate to check for stubbable instance
+    methods, which can trigger an association lookup.
 
-    *Rafael Mendonça França*
+    *Gannon McGibbon*
 
-*   Remove deprecated support to call `alias_attribute` with non-existent attribute names.
+*   Encryption now supports `support_unencrypted_data: true` being set per-attribute.
 
-    *Rafael Mendonça França*
+    Previously this only worked if `ActiveRecord::Encryption.config.support_unencrypted_data == true`.
+    Now, if the global config is turned off, you can still opt in for a specific attribute.
 
-*   Remove deprecated `Rails.application.config.active_record.suppress_multiple_database_warning`.
+    ```ruby
+    # ActiveRecord::Encryption.config.support_unencrypted_data = true
+    class User < ActiveRecord::Base
+      encrypts :name, support_unencrypted_data: false # only supports encrypted data
+      encrypts :email # supports encrypted or unencrypted data
+    end
+    ```
 
-    *Rafael Mendonça França*
+    ```ruby
+    # ActiveRecord::Encryption.config.support_unencrypted_data = false
+    class User < ActiveRecord::Base
+      encrypts :name, support_unencrypted_data: true # supports encrypted or unencrypted data
+      encrypts :email  # only supports encrypted data
+    end
+    ```
 
-*   Add `ActiveRecord::Encryption::MessagePackMessageSerializer`.
+    *Alex Ghiculescu*
 
-    Serialize data to the MessagePack format, for efficient storage in binary columns.
+*   Model generator no longer needs a database connection to validate column types.
 
-    The binary encoding requires around 30% less space than the base64 encoding
-    used by the default serializer.
+    *Mike Dalessio*
 
-    *Donal McBreen*
+*   Allow signed ID verifiers to be configurable via `Rails.application.message_verifiers`
 
-*   Add support for encrypting binary columns.
+    Prior to this change, the primary way to configure signed ID verifiers was
+    to set `signed_id_verifier` on each model class:
 
-    Ensure encryption and decryption pass `Type::Binary::Data` around for binary data.
+      ```ruby
+      Post.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      Comment.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      ```
 
-    Previously encrypting binary columns with the `ActiveRecord::Encryption::MessageSerializer`
-    incidentally worked for MySQL and SQLite, but not PostgreSQL.
+    And if the developer did not set `signed_id_verifier`, a verifier would be
+    instantiated with a secret derived from `secret_key_base` and the following
+    options:
 
-    *Donal McBreen*
+      ```ruby
+      { digest: "SHA256", serializer: JSON, url_safe: true }
+      ```
 
-*   Deprecated `ENV["SCHEMA_CACHE"]` in favor of `schema_cache_path` in the database configuration.
+    Thus it was cumbersome to rotate configuration for all verifiers.
 
-    *Rafael Mendonça França*
+    This change defines a new Rails config: [`config.active_record.use_legacy_signed_id_verifier`][].
+    The default value is `:generate_and_verify`, which preserves the previous
+    behavior. However, when set to `:verify`, signed ID verifiers will use
+    configuration from `Rails.application.message_verifiers` (specifically,
+    `Rails.application.message_verifiers["active_record/signed_id"]`) to
+    generate and verify signed IDs, but will also verify signed IDs using the
+    older configuration.
 
-*   Add `ActiveRecord::Base.with_connection` as a shortcut for leasing a connection for a short duration.
+    To avoid complication, the new behavior only applies when `signed_id_verifier_secret`
+    is not set on a model class or any of its ancestors. Additionally,
+    `signed_id_verifier_secret` is now deprecated. If you are currently setting
+    `signed_id_verifier_secret` on a model class, you can set `signed_id_verifier`
+    instead:
 
-    The leased connection is yielded, and for the duration of the block, any call to `ActiveRecord::Base.connection`
-    will yield that same connection.
+      ```ruby
+      # BEFORE
+      Post.signed_id_verifier_secret = "my secret"
 
-    This is useful to perform a few database operations without causing a connection to be leased for the
-    entire duration of the request or job.
+      # AFTER
+      Post.signed_id_verifier = ActiveSupport::MessageVerifier.new("my secret", digest: "SHA256", serializer: JSON, url_safe: true)
+      ```
 
-    *Jean Boussier*
+    To ease migration, `signed_id_verifier` has also been changed to behave as a
+    `class_attribute` (i.e. inheritable), but _only when `signed_id_verifier_secret`
+    is not set_:
 
-*   Deprecate `config.active_record.warn_on_records_fetched_greater_than` now that `sql.active_record`
-    notification includes `:row_count` field.
+      ```ruby
+      # BEFORE
+      ActiveRecord::Base.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      Post.signed_id_verifier == ActiveRecord::Base.signed_id_verifier # => false
 
-    *Jason Nochlin*
+      # AFTER
+      ActiveRecord::Base.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      Post.signed_id_verifier == ActiveRecord::Base.signed_id_verifier # => true
 
-*   Fix an issue with `where.associated` losing the current join type scope.
+      Post.signed_id_verifier_secret = "my secret" # => deprecation warning
+      Post.signed_id_verifier == ActiveRecord::Base.signed_id_verifier # => false
+      ```
 
-    Example:
+    Note, however, that it is recommended to eventually migrate from
+    model-specific verifiers to a unified configuration managed by
+    `Rails.application.message_verifiers`. `ActiveSupport::MessageVerifier#rotate`
+    can facilitate that transition. For example:
 
-    ```ruby
-    Post.left_joins(:author).where.associated(:author)
-    ```
+      ```ruby
+      # BEFORE
+      # Generate and verify signed Post IDs using Post-specific configuration
+      Post.signed_id_verifier = ActiveSupport::MessageVerifier.new("post secret", ...)
 
-    Previously, the `LEFT OUTER JOIN` would be lost and converted to an `INNER JOIN`.
+      # AFTER
+      # Generate and verify signed Post IDs using the unified configuration
+      Post.signed_id_verifier = Post.signed_id_verifier.dup
+      # Fall back to Post-specific configuration when verifying signed IDs
+      Post.signed_id_verifier.rotate("post secret", ...)
+      ```
 
-    *Saleh Alhaddad*
+    [`config.active_record.use_legacy_signed_id_verifier`]: https://guides.rubyonrails.org/v8.1/configuring.html#config-active-record-use-legacy-signed-id-verifier
 
-*   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.
+    *Ali Sepehri*, *Jonathan Hefner*
 
-    *Maxime Réty*
+*   Prepend `extra_flags` in postgres' `structure_load`
 
-*   Deprecate defining an `enum` with keyword arguments.
+    When specifying `structure_load_flags` with a postgres adapter, the flags
+    were appended to the default flags, instead of prepended.
+    This caused issues with flags not being taken into account by postgres.
 
-    ```ruby
-    class Function > ApplicationRecord
-      # BAD
-      enum color: [:red, :blue],
-           type: [:instance, :class]
-
-      # GOOD
-      enum :color, [:red, :blue]
-      enum :type, [:instance, :class]
-    end
-    ```
+    *Alice Loeser*
 
-    *Hartley McGuire*
+*   Allow bypassing primary key/constraint addition in `implicit_order_column`
 
-*   Add `config.active_record.validate_migration_timestamps` option for validating migration timestamps.
+    When specifying multiple columns in an array for `implicit_order_column`, adding
+    `nil` as the last element will prevent appending the primary key to order
+    conditions. This allows more precise control of indexes used by
+    generated queries. It should be noted that this feature does introduce the risk
+    of API misbehavior if the specified columns are not fully unique.
 
-    When set, validates that the timestamp prefix for a migration is no more than a day ahead of
-    the timestamp associated with the current time. This is designed to prevent migrations prefixes
-    from being hand-edited to future timestamps, which impacts migration generation and other
-    migration commands.
+    *Issy Long*
 
-    *Adrianna Chang*
+*   Allow setting the `schema_format` via database configuration.
 
-*   Properly synchronize `Mysql2Adapter#active?` and `TrilogyAdapter#active?`.
+    ```
+    primary:
+      schema_format: ruby
+    ```
 
-    As well as `disconnect!` and `verify!`.
+    Useful for multi-database setups when apps require different formats per-database.
 
-    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.
+    *T S Vallender*
 
-    *Jean Boussier*
+*   Support disabling indexes for MySQL v8.0.0+ and MariaDB v10.6.0+
+
+    MySQL 8.0.0 added an option to disable indexes from being used by the query
+    optimizer by making them "invisible". This allows the index to still be maintained
+    and updated but no queries will be permitted to use it. This can be useful for adding
+    new invisible indexes or making existing indexes invisible before dropping them
+    to ensure queries are not negatively affected.
+    See https://dev.mysql.com/blog-archive/mysql-8-0-invisible-indexes/ for more details.
 
-*   Support `:source_location` tag option for query log tags.
+    MariaDB 10.6.0 also added support for this feature by allowing indexes to be "ignored"
+    in queries. See https://mariadb.com/kb/en/ignored-indexes/ for more details.
+
+    Active Record now supports this option for MySQL 8.0.0+ and MariaDB 10.6.0+ for
+    index creation and alteration where the new index option `enabled: true/false` can be
+    passed to column and index methods as below:
 
     ```ruby
-    config.active_record.query_log_tags << :source_location
+    add_index :users, :email, enabled: false
+    enable_index :users, :email
+    add_column :users, :dob, :string, index: { enabled: false }
+
+    change_table :users do |t|
+      t.index :name, enabled: false
+      t.index :dob
+      t.disable_index :dob
+      t.column :username, :string, index: { enabled: false }
+      t.references :account, index: { enabled: false }
+    end
+
+    create_table :users do |t|
+      t.string :name, index: { enabled: false }
+      t.string :email
+      t.index :email, enabled: false
+    end
     ```
 
-    Calculating the caller location is a costly operation and should be used primarily in development
-    (note, there is also a `config.active_record.verbose_query_logs` that serves the same purpose)
-    or occasionally on production for debugging purposes.
+    *Merve Taner*
 
-    *fatkodima*
+*   Respect `implicit_order_column` in `ActiveRecord::Relation#reverse_order`.
 
-*   Add an option to `ActiveRecord::Encryption::Encryptor` to disable compression.
+    *Joshua Young*
 
-    Allow compression to be disabled by setting `compress: false`
+*   Add column types to `ActiveRecord::Result` for SQLite3.
 
-    ```ruby
-      class User
-        encrypts :name, encryptor: ActiveRecord::Encryption::Encryptor.new(compress: false)
-      end
-    ```
+    *Andrew Kane*
 
-    *Donal McBreen*
+*   Raise `ActiveRecord::ReadOnlyError` when pessimistically locking with a readonly role.
 
-*   Deprecate passing strings to `ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename`.
+    *Joshua Young*
 
-    A `ActiveRecord::DatabaseConfigurations::DatabaseConfig` object should be passed instead.
+*   Fix using the `SQLite3Adapter`'s `dbconsole` method outside of a Rails application.
 
-    *Rafael Mendonça França*
+    *Hartley McGuire*
 
-*   Add `row_count` field to `sql.active_record` notification.
+*   Fix migrating multiple databases with `ActiveRecord::PendingMigration` action.
 
-    This field returns the amount of rows returned by the query that emitted the notification.
+    *Gannon McGibbon*
 
-    This metric is useful in cases where one wants to detect queries with big result sets.
+*   Enable automatically retrying idempotent association queries on connection
+    errors.
 
-    *Marvin Bitterlich*
+    *Hartley McGuire*
 
-*   Consistently raise an `ArgumentError` when passing an invalid argument to a nested attributes association writer.
+*   Add `allow_retry` to `sql.active_record` instrumentation.
 
-    Previously, this would only raise on collection associations and produce a generic error on singular associations.
+    This enables identifying queries which queries are automatically retryable on connection errors.
 
-    Now, it will raise on both collection and singular associations.
+    *Hartley McGuire*
 
-    *Joshua Young*
+*   Better support UPDATE with JOIN for Postgresql and SQLite3
 
-*   Fix single quote escapes on default generated MySQL columns.
+    Previously when generating update queries with one or more JOIN clauses,
+    Active Record would use a sub query which would prevent to reference the joined
+    tables in the `SET` clause, for instance:
 
-    MySQL 5.7.5+ supports generated columns, which can be used to create a column that is computed from an expression.
+    ```ruby
+    Comment.joins(:post).update_all("title = posts.title")
+    ```
 
-    Previously, the schema dump would output a string with double escapes for generated columns with single quotes in the default expression.
+    This is now supported as long as the relation doesn't also use a `LIMIT`, `ORDER` or
+    `GROUP BY` clause. This was supported by the MySQL adapter for a long time.
 
-    This would result in issues when importing the schema on a fresh instance of a MySQL database.
+    *Jean Boussier*
 
-    Now, the string will not be escaped and will be valid Ruby upon importing of the schema.
+*   Introduce a before-fork hook in `ActiveSupport::Testing::Parallelization` to clear existing
+    connections, to avoid fork-safety issues with the mysql2 adapter.
 
-    *Yash Kapadia*
+    Fixes #41776
 
-*   Fix Migrations with versions older than 7.1 validating options given to
-    `add_reference` and `t.references`.
+    *Mike Dalessio*, *Donal McBreen*
 
-    *Hartley McGuire*
+*   PoolConfig no longer keeps a reference to the connection class.
 
-*   Add `<role>_types` class method to `ActiveRecord::DelegatedType` so that the delegated types can be introspected.
+    Keeping a reference to the class caused subtle issues when combined with reloading in
+    development. Fixes #54343.
 
-    *JP Rosevear*
+    *Mike Dalessio*
 
-*   Make `schema_dump`, `query_cache`, `replica` and `database_tasks` configurable via `DATABASE_URL`.
+*   Fix SQL notifications sometimes not sent when using async queries.
 
-    This wouldn't always work previously because boolean values would be interpreted as strings.
+    ```ruby
+    Post.async_count
+    ActiveSupport::Notifications.subscribed(->(*) { "Will never reach here" }) do
+      Post.count
+    end
+    ```
 
-    e.g. `DATABASE_URL=postgres://localhost/foo?schema_dump=false` now properly disable dumping the schema
-    cache.
+    In rare circumstances and under the right race condition, Active Support notifications
+    would no longer be dispatched after using an asynchronous query.
+    This is now fixed.
 
-    *Mike Coutermarsh*, *Jean Boussier*
+    *Edouard Chin*
 
-*   Introduce `ActiveRecord::Transactions::ClassMethods#set_callback`.
+*   Eliminate queries loading dumped schema cache on Postgres
 
-     It is identical to `ActiveSupport::Callbacks::ClassMethods#set_callback`
-     but with support for `after_commit` and `after_rollback` callback options.
+    Improve resiliency by avoiding needing to open a database connection to load the
+    type map while defining attribute methods at boot when a schema cache file is
+    configured on PostgreSQL databases.
 
-    *Joshua Young*
+    *James Coleman*
 
-*   Make `ActiveRecord::Encryption::Encryptor` agnostic of the serialization format used for encrypted data.
+*   `ActiveRecord::Coder::JSON` can be instantiated
 
-    Previously, the encryptor instance only allowed an encrypted value serialized as a `String` to be passed to the message serializer.
+    Options can now be passed to `ActiveRecord::Coder::JSON` when instantiating the coder. This allows:
+    ```ruby
+    serialize :config, coder: ActiveRecord::Coder::JSON.new(symbolize_names: true)
+    ```
+    *matthaigh27*
 
-    Now, the encryptor lets the configured `message_serializer` decide which types of serialized encrypted values are supported. A custom serialiser is therefore allowed to serialize `ActiveRecord::Encryption::Message` objects using a type other than `String`.
+*   Deprecate using `insert_all`/`upsert_all` with unpersisted records in associations.
 
-    The default `ActiveRecord::Encryption::MessageSerializer` already ensures that only `String` objects are passed for deserialization.
+    Using these methods on associations containing unpersisted records will now
+    show a deprecation warning, as the unpersisted records will be lost after
+    the operation.
 
-    *Maxime Réty*
+    *Nick Schwaderer*
 
-*   Fix `encrypted_attribute?` to take into account context properties passed to `encrypts`.
+*   Make column name optional for `index_exists?`.
 
-    *Maxime Réty*
+    This aligns well with `remove_index` signature as well, where
+    index name doesn't need to be derived from the column names.
 
-*   The object returned by `explain` now responds to `pluck`, `first`,
-    `last`, `average`, `count`, `maximum`, `minimum`, and `sum`. Those
-    new methods run `EXPLAIN` on the corresponding queries:
+    *Ali Ismayiliov*
 
-    ```ruby
-    User.all.explain.count
-    # EXPLAIN SELECT COUNT(*) FROM `users`
-    # ...
+*   Change the payload name of `sql.active_record` notification for eager
+    loading from "SQL" to "#{model.name} Eager Load".
 
-    User.all.explain.maximum(:id)
-    # EXPLAIN SELECT MAX(`users`.`id`) FROM `users`
-    # ...
-    ```
+    *zzak*
 
-    *Petrik de Heus*
+*   Enable automatically retrying idempotent `#exists?` queries on connection
+    errors.
 
-*   Fixes an issue where `validates_associated` `:on`  option wasn't respected
-    when validating associated records.
+    *Hartley McGuire*, *classidied*
 
-    *Austen Madden*, *Alex Ghiculescu*, *Rafał Brize*
+*   Deprecate usage of unsupported methods in conjunction with `update_all`:
 
-*   Allow overriding SQLite defaults from `database.yml`.
+    `update_all` will now print a deprecation message if a query includes either `WITH`,
+    `WITH RECURSIVE` or `DISTINCT` statements. Those were never supported and were ignored
+    when generating the SQL query.
 
-    Any PRAGMA configuration set under the `pragmas` key in the configuration
-    file takes precedence over Rails' defaults, and additional PRAGMAs can be
-    set as well.
+    An error will be raised in a future Rails release. This behavior will be consistent
+    with `delete_all` which currently raises an error for unsupported statements.
 
-    ```yaml
-    database: storage/development.sqlite3
-    timeout: 5000
-    pragmas:
-      journal_mode: off
-      temp_store: memory
-    ```
+    *Edouard Chin*
 
-    *Stephen Margheim*
+*   The table columns inside `schema.rb` are now sorted alphabetically.
 
-*   Remove warning message when running SQLite in production, but leave it unconfigured.
+    Previously they'd be sorted by creation order, which can cause merge conflicts when two
+    branches modify the same table concurrently.
 
-    There are valid use cases for running SQLite in production. However, it must be done
-    with care, so instead of a warning most users won't see anyway, it's preferable to
-    leave the configuration commented out to force them to think about having the database
-    on a persistent volume etc.
+    *John Duff*
 
-    *Jacopo Beschi*, *Jean Boussier*
+*   Introduce versions formatter for the schema dumper.
 
-*   Add support for generated columns to the SQLite3 adapter.
+    It is now possible to override how schema dumper formats versions information inside the
+    `structure.sql` file. Currently, the versions are simply sorted in the decreasing order.
+    Within large teams, this can potentially cause many merge conflicts near the top of the list.
 
-    Generated columns (both stored and dynamic) are supported since version 3.31.0 of SQLite.
-    This adds support for those to the SQLite3 adapter.
+    Now, the custom formatter can be provided with a custom sorting logic (e.g. by hash values
+    of the versions), which can greatly reduce the number of conflicts.
 
-    ```ruby
-    create_table :users do |t|
-      t.string :name
-      t.virtual :name_upper, type: :string, as: 'UPPER(name)'
-      t.virtual :name_lower, type: :string, as: 'LOWER(name)', stored: true
-    end
-    ```
+    *fatkodima*
 
-    *Stephen Margheim*
+*   Serialized attributes can now be marked as comparable.
 
-*   TrilogyAdapter: ignore `host` if `socket` parameter is set.
+    A not rare issue when working with serialized attributes is that the serialized representation of an object
+    can change over time. Either because you are migrating from one serializer to the other (e.g. YAML to JSON or to msgpack),
+    or because the serializer used subtly changed its output.
 
-    This allows to configure a connection on a UNIX socket via `DATABASE_URL`:
+    One example is libyaml that used to have some extra trailing whitespaces, and recently fixed that.
+    When this sorts of thing happen, you end up with lots of records that report being changed even though
+    they aren't, which in the best case leads to a lot more writes to the database and in the worst case lead to nasty bugs.
 
-    ```
-    DATABASE_URL=trilogy://does-not-matter/my_db_production?socket=/var/run/mysql.sock
+    The solution is to instead compare the deserialized representation of the object, however Active Record
+    can't assume the deserialized object has a working `==` method. Hence why this new functionality is opt-in.
+
+    ```ruby
+    serialize :config, type: Hash, coder: JSON, comparable: true
     ```
 
     *Jean Boussier*
 
-*   Make `assert_queries_count`, `assert_no_queries`, `assert_queries_match`, and
-    `assert_no_queries_match` assertions public.
+*   Fix MySQL default functions getting dropped when changing a column's nullability.
 
-    To assert the expected number of queries are made, Rails internally uses `assert_queries_count` and
-    `assert_no_queries`. To assert that specific SQL queries are made, `assert_queries_match` and
-    `assert_no_queries_match` are used. These assertions can now be used in applications as well.
+    *Bastian Bartmann*
 
-    ```ruby
-    class ArticleTest < ActiveSupport::TestCase
-      test "queries are made" do
-        assert_queries_count(1) { Article.first }
-      end
+*   SQLite extensions can be configured in `config/database.yml`.
 
-      test "creates a foreign key" do
-        assert_queries_match(/ADD FOREIGN KEY/i, include_schema: true) do
-          @connection.add_foreign_key(:comments, :posts)
-        end
-      end
-    end
+    The database configuration option `extensions:` allows an application to load SQLite extensions
+    when using `sqlite3` >= v2.4.0. The array members may be filesystem paths or the names of
+    modules that respond to `.to_path`:
+
+    ``` yaml
+    development:
+      adapter: sqlite3
+      extensions:
+        - SQLean::UUID                     # module name responding to `.to_path`
+        - .sqlpkg/nalgeon/crypto/crypto.so # or a filesystem path
+        - <%= AppExtensions.location %>    # or ruby code returning a path
     ```
 
-    *Petrik de Heus*, *fatkodima*
+    *Mike Dalessio*
 
-*   Fix `has_secure_token` calls the setter method on initialize.
+*   `ActiveRecord::Middleware::ShardSelector` supports granular database connection switching.
 
-    *Abeid Ahmed*
+    A new configuration option, `class_name:`, is introduced to
+    `config.active_record.shard_selector` to allow an application to specify the abstract connection
+    class to be switched by the shard selection middleware. The default class is
+    `ActiveRecord::Base`.
 
-*   When using a `DATABASE_URL`, allow for a configuration to map the protocol in the URL to a specific database
-    adapter. This allows decoupling the adapter the application chooses to use from the database connection details
-    set in the deployment environment.
+    For example, this configuration tells `ShardSelector` to switch shards using
+    `AnimalsRecord.connected_to`:
 
-    ```ruby
-    # ENV['DATABASE_URL'] = "mysql://localhost/example_database"
-    config.active_record.protocol_adapters.mysql = "trilogy"
-    # will connect to MySQL using the trilogy adapter
+    ```
+    config.active_record.shard_selector = { class_name: "AnimalsRecord" }
     ```
 
-    *Jean Boussier*, *Kevin McPhillips*
+    *Mike Dalessio*
 
-*   In cases where MySQL returns `warning_count` greater than zero, but returns no warnings when
-    the `SHOW WARNINGS` query is executed, `ActiveRecord.db_warnings_action` proc will still be
-    called with a generic warning message rather than silently ignoring the warning(s).
+*   Reset relations after `insert_all`/`upsert_all`.
 
-    *Kevin McPhillips*
+    Bulk insert/upsert methods will now call `reset` if used on a relation, matching the behavior of `update_all`.
 
-*   `DatabaseConfigurations#configs_for` accepts a symbol in the `name` parameter.
+    *Milo Winningham*
 
-    *Andrew Novoselac*
+*   Use `_N` as a parallel tests databases suffixes
 
-*   Fix `where(field: values)` queries when `field` is a serialized attribute
-    (for example, when `field` uses `ActiveRecord::Base.serialize` or is a JSON
-    column).
+    Peviously, `-N` was used as a suffix. This can cause problems for RDBMSes
+    which do not support dashes in database names.
 
-    *João Alves*
+    *fatkodima*
 
-*   Make the output of `ActiveRecord::Core#inspect` configurable.
+*   Remember when a database connection has recently been verified (for
+    two seconds, by default), to avoid repeated reverifications during a
+    single request.
 
-    By default, calling `inspect` on a record will yield a formatted string including just the `id`.
+    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.
 
-    ```ruby
-    Post.first.inspect #=> "#<Post id: 1>"
-    ```
+    *Matthew Draper*
 
-    The attributes to be included in the output of `inspect` can be configured with
-    `ActiveRecord::Core#attributes_for_inspect`.
+*   Allow to reset cache counters for multiple records.
 
-    ```ruby
-    Post.attributes_for_inspect = [:id, :title]
-    Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!">"
     ```
-
-    With `attributes_for_inspect` set to `:all`, `inspect` will list all the record's attributes.
-
-    ```ruby
-    Post.attributes_for_inspect = :all
-    Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+    Aircraft.reset_counters([1, 2, 3], :wheels_count)
     ```
 
-    In `development` and `test` mode, `attributes_for_inspect` will be set to `:all` by default.
-
-    You can also call `full_inspect` to get an inspection with all the attributes.
-
-    The attributes in `attribute_for_inspect` will also be used for `pretty_print`.
-
-    *Andrew Novoselac*
-
-*   Don't mark attributes as changed when reassigned to `Float::INFINITY` or
-    `-Float::INFINITY`.
+    It produces much fewer queries compared to the custom implementation using looping over ids.
+    Previously: `O(ids.size * counters.size)` queries, now: `O(ids.size + counters.size)` queries.
 
-    *Maicol Bentancor*
+    *fatkodima*
 
-*   Support the `RETURNING` clause for MariaDB.
+*   Add `affected_rows` to `sql.active_record` Notification.
 
-    *fatkodima*, *Nikolay Kondratyev*
+    *Hartley McGuire*
 
-*   The SQLite3 adapter now implements the `supports_deferrable_constraints?` contract.
+*   Fix `sum` when performing a grouped calculation.
 
-    Allows foreign keys to be deferred by adding the `:deferrable` key to the `foreign_key` options.
+    `User.group(:friendly).sum` no longer worked. This is fixed.
 
-    ```ruby
-    add_reference :person, :alias, foreign_key: { deferrable: :deferred }
-    add_reference :alias, :person, foreign_key: { deferrable: :deferred }
-    ```
+    *Edouard Chin*
 
-    *Stephen Margheim*
+*   Add support for enabling or disabling transactional tests per database.
 
-*   Add the `set_constraints` helper to PostgreSQL connections.
+    A test class can now override the default `use_transactional_tests` setting
+    for individual databases, which can be useful if some databases need their
+    current state to be accessible to an external process while tests are running.
 
     ```ruby
-    Post.create!(user_id: -1) # => ActiveRecord::InvalidForeignKey
-
-    Post.transaction do
-      Post.connection.set_constraints(:deferred)
-      p = Post.create!(user_id: -1)
-      u = User.create!
-      p.user = u
-      p.save!
+    class MostlyTransactionalTest < ActiveSupport::TestCase
+      self.use_transactional_tests = true
+      skip_transactional_tests_for_database :shared
     end
     ```
 
-    *Cody Cutrer*
-
-*   Include `ActiveModel::API` in `ActiveRecord::Base`.
-
-    *Sean Doyle*
+    *Matthew Cheetham*, *Morgan Mareve*
 
-*   Ensure `#signed_id` outputs `url_safe` strings.
+*   Cast `query_cache` value when using URL configuration.
 
-    *Jason Meller*
-
-*   Add `nulls_last` and working `desc.nulls_first` for MySQL.
+    *zzak*
 
-    *Tristan Fellows*
+*   NULLS NOT DISTINCT works with UNIQUE CONSTRAINT as well as UNIQUE INDEX.
 
-*   Allow for more complex hash arguments for `order` which mimics `where` in `ActiveRecord::Relation`.
+    *Ryuta Kamizono*
 
-    ```ruby
-    Topic.includes(:posts).order(posts: { created_at: :desc })
-    ```
+*   `PG::UnableToSend: no connection to the server` is now retryable as a connection-related exception
 
-    *Myles Boone*
+    *Kazuma Watanabe*
 
-Please check [7-1-stable](https://github.com/rails/rails/blob/7-1-stable/activerecord/CHANGELOG.md) for previous changes.
+Please check [8-0-stable](https://github.com/rails/rails/blob/8-0-stable/activerecord/CHANGELOG.md) for previous changes.