activerecord 7.2.2.1 → 8.1.2

data/CHANGELOG.md

@@ -1,1098 +1,909 @@
-## Rails 7.2.2.1 (December 10, 2024) ##
+## Rails 8.1.2 (January 08, 2026) ##
 
-*   No changes.
-
-
-## Rails 7.2.2 (October 30, 2024) ##
-
-*   Fix support for `query_cache: false` in `database.yml`.
-
-    `query_cache: false` would no longer entirely disable the Active Record query cache.
-
-    *zzak*
-
-*   Set `.attributes_for_inspect` to `:all` by default.
-
-    For new applications it is set to `[:id]` in config/environment/production.rb.
-
-    In the console all the attributes are always shown.
-
-    *Andrew Novoselac*
+*   Fix counting cached queries in `ActiveRecord::RuntimeRegistry`.
 
-*   `PG::UnableToSend: no connection to the server` is now retryable as a connection-related exception
-
-    *Kazuma Watanabe*
-
-*   Fix marshalling of unsaved associated records in 7.1 format.
-
-    The 7.1 format would only marshal associated records if the association was loaded.
-    But associations that would only contain unsaved records would be skipped.
+    *fatkodima*
 
-    *Jean Boussier*
+*   Fix merging relations with arel equality predicates with null relations.
 
-*   Fix incorrect SQL query when passing an empty hash to `ActiveRecord::Base.insert`.
+    *fatkodima*
 
-    *David Stosik*
+*   Fix SQLite3 schema dump for non-autoincrement integer primary keys.
 
-*   Allow to save records with polymorphic join tables that have `inverse_of`
-    specified.
+    Previously, `schema.rb` should incorrectly restore that table with an auto incrementing
+    primary key.
 
-    *Markus Doits*
+    *Chris Hasiński*
 
-*   Fix association scopes applying on the incorrect join when using a polymorphic `has_many through:`.
+*   Fix PostgreSQL `schema_search_path` not being reapplied after `reset!` or `reconnect!`.
 
-    *Joshua Young*
+    The `schema_search_path` configured in `database.yml` is now correctly
+    reapplied instead of falling back to PostgreSQL defaults.
 
-*   Fix `dependent: :destroy` for bi-directional has one through association.
+    *Tobias Egli*
 
-    Fixes #50948.
+*   Restore the ability of enum to be foats.
 
     ```ruby
-    class Left < ActiveRecord::Base
-      has_one :middle, dependent: :destroy
-      has_one :right, through: :middle
-    end
-
-    class Middle < ActiveRecord::Base
-      belongs_to :left, dependent: :destroy
-      belongs_to :right, dependent: :destroy
-    end
-
-    class Right < ActiveRecord::Base
-      has_one :middle, dependent: :destroy
-      has_one :left, through: :middle
-    end
+    enum :rating, { low: 0.0, medium: 0.5, high: 1.0 },
     ```
-    In the above example `left.destroy` wouldn't destroy its associated `Right`
-    record.
-
-    *Andy Stewart*
 
-*   Properly handle lazily pinned connection pools.
+    In Rails 8.1.0, enum values are eagerly validated, and floats weren't expected.
 
-    Fixes #53147.
+    *Said Kaldybaev*
 
-    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.
+*   Ensure batched preloaded associations accounts for klass when grouping to avoid issues with STI.
 
-    *Jean Boussier*
+    *zzak*, *Stjepan Hadjic*
 
-*   Fix `ActiveRecord::Base.with` to accept more than two sub queries.
+*   Fix `ActiveRecord::SoleRecordExceeded#record` to return the relation.
 
-    Fixes #53110.
+    This was the case until Rails 7.2, but starting from 8.0 it
+    started mistakenly returning the model class.
 
-    ```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)
-    ```
-
-    The above now works as expected.
+    *Jean Boussier*
 
-    *fatkodima*
+*   Improve PostgreSQLAdapter resilience to Timeout.timeout.
 
-*   Properly release pinned connections with non joinable connections.
+    Better handle asynchronous exceptions being thrown inside
+    the `reconnect!` method.
 
-    Fixes #52973
+    This may fixes some deep errors such as:
 
-    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.
+    ```
+    undefined method `key?' for nil:NilClass (NoMethodError)
+              if !type_map.key?(oid)
+    ```
 
     *Jean Boussier*
 
-*   Make Float distinguish between `float4` and `float8` in PostgreSQL.
+*   Fix structured events for Active Record was not being emitted.
 
-    Fixes #52742
+    *Yuji Yaginuma*
 
-    *Ryota Kitazawa*, *Takayuki Nagatomi*
+*   Fix `eager_load` when loading `has_many` assocations with composite primary keys.
 
-*   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.
+    This would result in some records being loaded multiple times.
 
-    Previously, using `.left_outer_joins` with the same child association would only join one of the parents.
+    *Martin-Alexander*
 
-    Now it will correctly join both parents.
 
-    Fixes #41498.
+## Rails 8.1.1 (October 28, 2025) ##
 
-    *Garrett Blehm*
-
-*   Ensure `ActiveRecord::Encryption.config` is always ready before access.
+*   No changes.
 
-    Previously, `ActiveRecord::Encryption` configuration was deferred until `ActiveRecord::Base`
-    was loaded. Therefore, accessing `ActiveRecord::Encryption.config` properties before
-    `ActiveRecord::Base` was loaded would give incorrect results.
 
-    `ActiveRecord::Encryption` now has its own loading hook so that its configuration is set as
-    soon as needed.
+## Rails 8.1.0 (October 22, 2025) ##
 
-    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`.
+*   Fix SQLite3 data loss during table alterations with CASCADE foreign keys.
 
-    *Maxime Réty*
+    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.
 
-*   Add `TimeZoneConverter#==` method, so objects will be properly compared by
-    their type, scale, limit & precision.
+    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.
 
-    Address #52699.
+    The fix reverses the order to follow the official SQLite 12-step ALTER TABLE
+    procedure: `disable_referential_integrity` now wraps the transaction instead
+    of being wrapped by it. This ensures foreign keys are properly disabled
+    before the transaction starts and re-enabled after it commits, preventing
+    CASCADE deletes while maintaining data integrity through atomic transactions.
 
     *Ruy Rocha*
 
+*   Add replicas to test database parallelization setup.
 
-## Rails 7.2.1.2 (October 23, 2024) ##
+    Setup and configuration of databases for parallel testing now includes replicas.
 
-*   No changes.
+    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}`.
 
+    *Adam Maas*
 
-## Rails 7.2.1.1 (October 15, 2024) ##
+*   Support virtual (not persisted) generated columns on PostgreSQL 18+
 
-*   No changes.
+    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
+    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
+    ```
 
-## Rails 7.2.1 (August 22, 2024) ##
+    *Yasuo Honda*
 
-*   Fix detection for `enum` columns with parallelized tests and PostgreSQL.
+*   Optimize schema dumping to prevent duplicate file generation.
 
-    *Rafael Mendonça França*
+    `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.
 
-*   Allow to eager load nested nil associations.
+    *Mikey Gough*, *Hartley McGuire*
 
-    *fatkodima*
+*   Add structured events for Active Record:
+    - `active_record.strict_loading_violation`
+    - `active_record.sql`
 
-*   Fix swallowing ignore order warning when batching using `BatchEnumerator`.
+    *Gannon McGibbon*
 
-    *fatkodima*
+*   Add support for integer shard keys.
+    ```ruby
+    # 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
+    ```
 
-*   Fix memory bloat on the connection pool when using the Fiber `IsolatedExecutionState`.
+    *Nony Dutton*
 
-    *Jean Boussier*
+*   Add `ActiveRecord::Base.only_columns`
 
-*   Restore inferred association class with the same modularized name.
+    Similar in use case to `ignored_columns` but listing columns to consider rather than the ones
+    to ignore.
 
-    *Justin Ko*
+    Can be useful when working with a legacy or shared database schema, or to make safe schema change
+    in two deploys rather than three.
 
-*   Fix `ActiveRecord::Base.inspect` to properly explain how to load schema information.
+    *Anton Kandratski*
 
-    *Jean Boussier*
+*   Use `PG::Connection#close_prepared` (protocol level Close) to deallocate
+    prepared statements when available.
 
-*   Check invalid `enum` options for the new syntax.
+    To enable its use, you must have pg >= 1.6.0, libpq >= 17, and a PostgreSQL
+    database version >= 17.
 
-    The options using `_` prefix in the old syntax are invalid in the new syntax.
+    *Hartley McGuire*, *Andrew Jackson*
 
-    *Rafael Mendonça França*
+*   Fix query cache for pinned connections in multi threaded transactional tests
 
-*   Fix `ActiveRecord::Encryption::EncryptedAttributeType#type` to return
-    actual cast type.
+    When a pinned connection is used across separate threads, they now use a separate cache store
+    for each thread.
 
-    *Vasiliy Ermolovich*
+    This improve accuracy of system tests, and any test using multiple threads.
 
-*   Fix `create_table` with `:auto_increment` option for MySQL adapter.
+    *Heinrich Lee Yu*, *Jean Boussier*
 
-    *fatkodima*
+*   Fix time attribute dirty tracking with timezone conversions.
 
+    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.
 
-## Rails 7.2.0 (August 09, 2024) ##
+    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.
 
-*   Handle commas in Sqlite3 default function definitions.
+    *Prateek Choudhary*
 
-    *Stephen Margheim*
+*   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.
 
-*   Fixes `validates_associated` raising an exception when configured with a
-    singular association and having `index_nested_attribute_errors` enabled.
+    *Yasuo Honda*, *Lars Kanis*
 
-    *Martin Spickermann*
+*   Don't add `id_value` attribute alias when attribute/column with that name already exists.
 
-*   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.
+    *Rob Lewis*
 
-    *Xavier Noria*
+*   Remove deprecated `:unsigned_float` and `:unsigned_decimal` column methods for MySQL.
 
-*   Add condensed `#inspect` for `ConnectionPool`, `AbstractAdapter`, and
-    `DatabaseConfig`.
+    *Rafael Mendonça França*
 
-    *Hartley McGuire*
+*   Remove deprecated `:retries` option for the SQLite3 adapter.
 
-*   Fixed a memory performance issue in Active Record attribute methods definition.
+    *Rafael Mendonça França*
 
-    *Jean Boussier*
+*   Introduce new database configuration options `keepalive`, `max_age`, and
+    `min_connections` -- and rename `pool` to `max_connections` to match.
 
-*   Define the new Active Support notification event `start_transaction.active_record`.
+    There are no changes to default behavior, but these allow for more specific
+    control over pool behavior.
 
-    This event is fired when database transactions or savepoints start, and
-    complements `transaction.active_record`, which is emitted when they finish.
+    *Matthew Draper*, *Chris AtLee*, *Rachael Wright-Munn*
 
-    The payload has the transaction (`:transaction`) and the connection (`:connection`).
+*   Move `LIMIT` validation from query generation to when `limit()` is called.
 
-    *Xavier Noria*
+    *Hartley McGuire*, *Shuyang*
 
-*   Fix an issue where the IDs reader method did not return expected results
-    for preloaded associations in models using composite primary keys.
+*   Add `ActiveRecord::CheckViolation` error class for check constraint violations.
 
-    *Jay Ang*
+    *Ryuta Kamizono*
 
-*   The payload of `sql.active_record` Active Support notifications now has the current transaction in the `:transaction` key.
+*   Add `ActiveRecord::ExclusionViolation` error class for exclusion constraint violations.
 
-    *Xavier Noria*
+    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.
 
-*   The payload of `transaction.active_record` Active Support notifications now has the transaction the event is related to in the `:transaction` key.
+    This follows the same pattern as other constraint violation error classes like
+    `RecordNotUnique` for unique constraint violations and `InvalidForeignKey` for
+    foreign key constraint violations.
 
-    *Xavier Noria*
+    *Ryuta Kamizono*
 
-*   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.
+*   Attributes filtered by `filter_attributes` will now also be filtered by `filter_parameters`
+    so sensitive information is not leaked.
 
-    *Xavier Noria*
+    *Jill Klang*
 
-*   Fix inference of association model on nested models with the same demodularized name.
+*   Add `connection.current_transaction.isolation` API to check current transaction's isolation level.
 
-    E.g. with the following setup:
+    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
-    class Nested::Post < ApplicationRecord
-      has_one :post, through: :other
-    end
-    ```
-
-    Before, `#post` would infer the model as `Nested::Post`, but now it correctly infers `Post`.
-
-    *Joshua Young*
-
-*   PostgreSQL `Cidr#change?` detects the address prefix change.
+    # Returns nil when no transaction
+    User.connection.current_transaction.isolation # => nil
 
-    *Taketo Takashima*
+    # Returns explicitly set isolation level
+    User.transaction(isolation: :serializable) do
+      User.connection.current_transaction.isolation # => :serializable
+    end
 
-*   Change `BatchEnumerator#destroy_all` to return the total number of affected rows.
+    # Returns nil when isolation not explicitly set
+    User.transaction do
+      User.connection.current_transaction.isolation # => nil
+    end
 
-    Previously, it always returned `nil`.
+    # Nested transactions inherit parent's isolation
+    User.transaction(isolation: :read_committed) do
+      User.transaction do
+        User.connection.current_transaction.isolation # => :read_committed
+      end
+    end
+    ```
 
-    *fatkodima*
+    *Kir Shatrov*
 
-*   Support `touch_all` in batches.
+*   Fix `#merge` with `#or` or `#and` and a mixture of attributes and SQL strings resulting in an incorrect query.
 
     ```ruby
-    Post.in_batches.touch_all
+    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
     ```
 
-    *fatkodima*
-
-*   Add support for `:if_not_exists` and `:force` options to `create_schema`.
-
-    *fatkodima*
-
-*   Fix `index_errors` having incorrect index in association validation errors.
-
-    *lulalala*
-
-*   Add `index_errors: :nested_attributes_order` mode.
-
-    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.
-
-    *lulalala*
-
-*   Add `Rails.application.config.active_record.postgresql_adapter_decode_dates` to opt out of decoding dates automatically with the postgresql adapter. Defaults to true.
-
-    *Joé Dupuis*
-
-*   Association option `query_constraints` is deprecated in favor of `foreign_key`.
-
-    *Nikita Vasilevsky*
-
-*   Add `ENV["SKIP_TEST_DATABASE_TRUNCATE"]` flag to speed up multi-process test runs on large DBs when all tests run within default transaction.
-
-    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.
-
-    *DHH*
-
-*   Added support for recursive common table expressions.
+    Before:
 
-    ```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'),
-      ]
+    ```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
     )
     ```
 
-    Generates the following SQL:
+    After:
 
-    ```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)
+    ```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
     )
-    SELECT "posts".* FROM "posts"
     ```
 
-    *ClearlyClaire*
-
-*   `validate_constraint` can be called in a `change_table` block.
+    *Joshua Young*
 
-    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
-    ```
+*   Make schema dumper to account for `ActiveRecord.dump_schemas` when dumping in `:ruby` format.
 
-    *Cody Cutrer*
+    *fatkodima*
 
-*   `PostgreSQLAdapter` now decodes columns of type date to `Date` instead of string.
+*   Add `:touch` option to `update_column`/`update_columns` methods.
 
-    Ex:
     ```ruby
-    ActiveRecord::Base.connection
-         .select_value("select '2024-01-01'::date").class #=> Date
-    ```
-
-    *Joé Dupuis*
+    # Will update :updated_at/:updated_on alongside :nice column.
+    user.update_column(:nice, true, touch: true)
 
-*   Strict loading using `:n_plus_one_only` does not eagerly load child associations.
+    # Will update :updated_at/:updated_on alongside :last_ip column
+    user.update_columns(last_ip: request.remote_ip, touch: true)
+    ```
 
-    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.
+    *Dmitrii Ivliev*
 
-    Before:
+*   Optimize Active Record batching further when using ranges.
 
-    ```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
-    ```
+    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`).
 
-    After:
+    *Maxime Réty*, *fatkodima*
 
-    ```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
-    ```
+*   Include current character length in error messages for index and table name length validations.
 
-    *Reid Lynch*
+    *Joshua Young*
 
-*   Allow `Sqlite3Adapter` to use `sqlite3` gem version `2.x`.
+*   Add `rename_schema` method for PostgreSQL.
 
-    *Mike Dalessio*
+    *T S Vallender*
 
-*   Allow `ActiveRecord::Base#pluck` to accept hash values.
+*   Implement support for deprecating associations:
 
     ```ruby
-    # Before
-    Post.joins(:comments).pluck("posts.id", "comments.id", "comments.body")
-
-    # After
-    Post.joins(:comments).pluck(posts: [:id], comments: [:id, :body])
+    has_many :posts, deprecated: true
     ```
 
-    *fatkodima*
+    With that, Active Record will report any usage of the `posts` association.
 
-*   Raise an `ActiveRecord::ActiveRecordError` error when the MySQL database returns an invalid version string.
+    Three reporting modes are supported (`:warn`, `:raise`, and `:notify`), and
+    backtraces can be enabled or disabled. Defaults are `:warn` mode and
+    disabled backtraces.
 
-    *Kevin McPhillips*
+    Please, check the docs for further details.
 
-*   `ActiveRecord::Base.transaction` now yields an `ActiveRecord::Transaction` object.
+    *Xavier Noria*
 
-    This allows to register callbacks on it.
+*   PostgreSQL adapter create DB now supports `locale_provider` and `locale`.
 
-    ```ruby
-    Article.transaction do |transaction|
-      article.update(published: true)
-      transaction.after_commit do
-        PublishNotificationMailer.with(article: article).deliver_later
-      end
-    end
-    ```
+    *Bengt-Ove Hollaender*
 
-    *Jean Boussier*
+*   Use ntuples to populate row_count instead of count for Postgres
 
-*   Add `ActiveRecord::Base.current_transaction`.
+    *Jonathan Calvert*
 
-    Returns the current transaction, to allow registering callbacks on it.
+*   Fix checking whether an unpersisted record is `include?`d in a strictly
+    loaded `has_and_belongs_to_many` association.
 
-    ```ruby
-    Article.current_transaction.after_commit do
-      PublishNotificationMailer.with(article: article).deliver_later
-    end
-    ```
+    *Hartley McGuire*
 
-    *Jean Boussier*
+*   Add ability to change transaction isolation for all pools within a block.
 
-*   Add `ActiveRecord.after_all_transactions_commit` callback.
+    This functionality is useful if your application needs to change the database
+    transaction isolation for a request or action.
 
-    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.
+    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.
+
+    This works with explicit and implicit transactions:
 
     ```ruby
-    def publish_article(article)
-      article.update(published: true)
-      ActiveRecord.after_all_transactions_commit do
-        PublishNotificationMailer.with(article: article).deliver_later
+    ActiveRecord.with_transaction_isolation_level(:read_committed) do
+      Tag.transaction do # opens a transaction explicitly
+        Tag.create!
       end
     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.
-
-    If the transaction is rolled back, the block isn't called.
-
-    *Jean Boussier*
-
-*   Add the ability to ignore counter cache columns until they are backfilled.
-
-    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.
-
-    Now, to safely backfill the column, while keeping the column updated with child records added/removed, use:
-
     ```ruby
-    class Comment < ApplicationRecord
-      belongs_to :post, counter_cache: { active: false }
+    ActiveRecord.with_transaction_isolation_level(:read_committed) do
+      Tag.create! # opens a transaction implicitly
     end
     ```
 
-    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.
-
-    *fatkodima*
+    *Eileen M. Uchitelle*
 
-*   Retry known idempotent SELECT queries on connection-related exceptions.
+*   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.
 
-    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 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.
 
-    *Adrianna Chang*
+    ```ruby
+    config.active_record.raise_on_missing_required_finder_order_columns = true
+    ```
 
-*   Allow association's `foreign_key` to be composite.
+    *Joshua Young*
 
-    `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.
+*   `:class_name` is now invalid in polymorphic `belongs_to` associations.
 
-    *Nikita Vasilevsky*
+    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.
 
-*   Allow association's `primary_key` to be composite.
+    Existing polymorphic associations setting this option can just delete it.
+    While it did not raise, it had no effect anyway.
 
-    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.
+    *Xavier Noria*
 
-    *Nikita Vasilevsky*
+*   Add support for multiple databases to `db:migrate:reset`.
 
-*   Add `config.active_record.permanent_connection_checkout` setting.
+    *Joé Dupuis*
 
-    Controls whether `ActiveRecord::Base.connection` raises an error, emits a deprecation warning, or neither.
+*   Add `affected_rows` to `ActiveRecord::Result`.
 
-    `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.
+    *Jenny Shen*
 
-    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.
+*   Enable passing retryable SqlLiterals to `#where`.
 
-    The default behavior remains unchanged, and there is currently no plans to change the default.
+    *Hartley McGuire*
 
-    *Jean Boussier*
+*   Set default for primary keys in `insert_all`/`upsert_all`.
 
-*   Add dirties option to uncached.
+    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.
 
-    This adds a `dirties` option to `ActiveRecord::Base.uncached` and
-    `ActiveRecord::ConnectionAdapters::ConnectionPool#uncached`.
+    *Jenny Shen*
 
-    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.
+*   Add a load hook `active_record_database_configurations` for `ActiveRecord::DatabaseConfigurations`
 
-    This is needed by Solid Cache so that cache writes do not clear query caches.
+    *Mike Dalessio*
 
-    *Donal McBreen*
+*   Use `TRUE` and `FALSE` for SQLite queries with boolean columns.
 
-*   Deprecate `ActiveRecord::Base.connection` in favor of `.lease_connection`.
+    *Hartley McGuire*
 
-    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.
+*   Bump minimum supported SQLite to 3.23.0.
 
-    This deprecation is a soft deprecation, no warnings will be issued and there is no
-    current plan to remove the method.
+    *Hartley McGuire*
 
-    *Jean Boussier*
+*   Allow allocated Active Records to lookup associations.
 
-*   Deprecate `ActiveRecord::ConnectionAdapters::ConnectionPool#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.
 
-    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.
+    *Gannon McGibbon*
 
-    *Jean Boussier*
+*   Encryption now supports `support_unencrypted_data: true` being set per-attribute.
 
-*   Expose a generic fixture accessor for fixture names that may conflict with Minitest.
+    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.
 
     ```ruby
-    assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
-    assert_equal "Ruby on Rails", fixture(:web_sites, :rubyonrails).name
+    # 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
     ```
 
-    *Jean Boussier*
-
-*   Using `Model.query_constraints` with a single non-primary-key column used to raise as expected, but with an
-    incorrect error message.
-
-    This has been fixed to raise with a more appropriate error message.
-
-    *Joshua Young*
-
-*   Fix `has_one` association autosave setting the foreign key attribute when it is unchanged.
-
-    This 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.
-
-    *Joshua Young*
-
-*   Remove deprecated behavior that would rollback a transaction block when exited using `return`, `break` or `throw`.
-
-    *Rafael Mendonça França*
-
-*   Deprecate `Rails.application.config.active_record.commit_transaction_on_non_local_return`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support to pass `rewhere` to `ActiveRecord::Relation#merge`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support to pass `deferrable: true` to `add_foreign_key`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support to quote `ActiveSupport::Duration`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `#quote_bound_value`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::ConnectionPool#connection_klass`.
-
-    *Rafael Mendonça França*
-
-*   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.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `#all_connection_pools`.
+    ```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
+    ```
 
-    *Rafael Mendonça França*
+    *Alex Ghiculescu*
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::SchemaCache#data_sources`.
+*   Model generator no longer needs a database connection to validate column types.
 
-    *Rafael Mendonça França*
+    *Mike Dalessio*
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::SchemaCache.load_from`.
+*   Allow signed ID verifiers to be configurable via `Rails.application.message_verifiers`
 
-    *Rafael Mendonça França*
+    Prior to this change, the primary way to configure signed ID verifiers was
+    to set `signed_id_verifier` on each model class:
 
-*   Remove deprecated `#all_foreign_keys_valid?` from database adapters.
+      ```ruby
+      Post.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      Comment.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      ```
 
-    *Rafael Mendonça França*
+    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:
 
-*   Remove deprecated support to passing coder and class as second argument to `serialize`.
+      ```ruby
+      { digest: "SHA256", serializer: JSON, url_safe: true }
+      ```
 
-    *Rafael Mendonça França*
+    Thus it was cumbersome to rotate configuration for all verifiers.
 
-*   Remove deprecated support to `ActiveRecord::Base#read_attribute(:id)` to return the custom primary key value.
+    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.
 
-    *Rafael Mendonça França*
+    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:
 
-*   Remove deprecated `TestFixtures.fixture_path`.
+      ```ruby
+      # BEFORE
+      Post.signed_id_verifier_secret = "my secret"
 
-    *Rafael Mendonça França*
+      # AFTER
+      Post.signed_id_verifier = ActiveSupport::MessageVerifier.new("my secret", digest: "SHA256", serializer: JSON, url_safe: true)
+      ```
 
-*   Remove deprecated behavior to support referring to a singular association by its plural name.
+    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_:
 
-    *Rafael Mendonça França*
+      ```ruby
+      # BEFORE
+      ActiveRecord::Base.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      Post.signed_id_verifier == ActiveRecord::Base.signed_id_verifier # => false
 
-*   Deprecate `Rails.application.config.active_record.allow_deprecated_singular_associations_name`.
+      # AFTER
+      ActiveRecord::Base.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      Post.signed_id_verifier == ActiveRecord::Base.signed_id_verifier # => true
 
-    *Rafael Mendonça França*
+      Post.signed_id_verifier_secret = "my secret" # => deprecation warning
+      Post.signed_id_verifier == ActiveRecord::Base.signed_id_verifier # => false
+      ```
 
-*   Remove deprecated support to passing `SchemaMigration` and `InternalMetadata` classes as arguments to
-    `ActiveRecord::MigrationContext`.
+    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:
 
-    *Rafael Mendonça França*
+      ```ruby
+      # BEFORE
+      # Generate and verify signed Post IDs using Post-specific configuration
+      Post.signed_id_verifier = ActiveSupport::MessageVerifier.new("post secret", ...)
 
-*   Remove deprecated `ActiveRecord::Migration.check_pending!` method.
+      # 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", ...)
+      ```
 
-    *Rafael Mendonça França*
+    [`config.active_record.use_legacy_signed_id_verifier`]: https://guides.rubyonrails.org/v8.1/configuring.html#config-active-record-use-legacy-signed-id-verifier
 
-*   Remove deprecated `ActiveRecord::LogSubscriber.runtime` method.
+    *Ali Sepehri*, *Jonathan Hefner*
 
-    *Rafael Mendonça França*
+*   Prepend `extra_flags` in postgres' `structure_load`
 
-*   Remove deprecated `ActiveRecord::LogSubscriber.runtime=` method.
+    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.
 
-    *Rafael Mendonça França*
+    *Alice Loeser*
 
-*   Remove deprecated `ActiveRecord::LogSubscriber.reset_runtime` method.
+*   Allow bypassing primary key/constraint addition in `implicit_order_column`
 
-    *Rafael Mendonça França*
+    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.
 
-*   Remove deprecated support to define `explain` in the connection adapter with 2 arguments.
+    *Issy Long*
 
-    *Rafael Mendonça França*
+*   Allow setting the `schema_format` via database configuration.
 
-*   Remove deprecated `ActiveRecord::ActiveJobRequiredError`.
+    ```
+    primary:
+      schema_format: ruby
+    ```
 
-    *Rafael Mendonça França*
+    Useful for multi-database setups when apps require different formats per-database.
 
-*   Remove deprecated `ActiveRecord::Base.clear_active_connections!`.
+    *T S Vallender*
 
-    *Rafael Mendonça França*
+*   Support disabling indexes for MySQL v8.0.0+ and MariaDB v10.6.0+
 
-*   Remove deprecated `ActiveRecord::Base.clear_reloadable_connections!`.
+    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.
 
-    *Rafael Mendonça França*
+    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.
 
-*   Remove deprecated `ActiveRecord::Base.clear_all_connections!`.
+    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:
 
-    *Rafael Mendonça França*
+    ```ruby
+    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
 
-*   Remove deprecated `ActiveRecord::Base.flush_idle_connections!`.
+    create_table :users do |t|
+      t.string :name, index: { enabled: false }
+      t.string :email
+      t.index :email, enabled: false
+    end
+    ```
 
-    *Rafael Mendonça França*
+    *Merve Taner*
 
-*   Remove deprecated `name` argument from `ActiveRecord::Base.remove_connection`.
+*   Respect `implicit_order_column` in `ActiveRecord::Relation#reverse_order`.
 
-    *Rafael Mendonça França*
+    *Joshua Young*
 
-*   Remove deprecated support to call `alias_attribute` with non-existent attribute names.
+*   Add column types to `ActiveRecord::Result` for SQLite3.
 
-    *Rafael Mendonça França*
+    *Andrew Kane*
 
-*   Remove deprecated `Rails.application.config.active_record.suppress_multiple_database_warning`.
+*   Raise `ActiveRecord::ReadOnlyError` when pessimistically locking with a readonly role.
 
-    *Rafael Mendonça França*
+    *Joshua Young*
 
-*   Add `ActiveRecord::Encryption::MessagePackMessageSerializer`.
+*   Fix using the `SQLite3Adapter`'s `dbconsole` method outside of a Rails application.
 
-    Serialize data to the MessagePack format, for efficient storage in binary columns.
+    *Hartley McGuire*
 
-    The binary encoding requires around 30% less space than the base64 encoding
-    used by the default serializer.
+*   Fix migrating multiple databases with `ActiveRecord::PendingMigration` action.
 
-    *Donal McBreen*
+    *Gannon McGibbon*
 
-*   Add support for encrypting binary columns.
+*   Enable automatically retrying idempotent association queries on connection
+    errors.
 
-    Ensure encryption and decryption pass `Type::Binary::Data` around for binary data.
+    *Hartley McGuire*
 
-    Previously encrypting binary columns with the `ActiveRecord::Encryption::MessageSerializer`
-    incidentally worked for MySQL and SQLite, but not PostgreSQL.
+*   Add `allow_retry` to `sql.active_record` instrumentation.
 
-    *Donal McBreen*
+    This enables identifying queries which queries are automatically retryable on connection errors.
 
-*   Deprecated `ENV["SCHEMA_CACHE"]` in favor of `schema_cache_path` in the database configuration.
+    *Hartley McGuire*
 
-    *Rafael Mendonça França*
+*   Better support UPDATE with JOIN for Postgresql and SQLite3
 
-*   Add `ActiveRecord::Base.with_connection` as a shortcut for leasing a connection for a short duration.
+    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:
 
-    The leased connection is yielded, and for the duration of the block, any call to `ActiveRecord::Base.connection`
-    will yield that same connection.
+    ```ruby
+    Comment.joins(:post).update_all("title = posts.title")
+    ```
 
-    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.
+    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.
 
     *Jean Boussier*
 
-*   Deprecate `config.active_record.warn_on_records_fetched_greater_than` now that `sql.active_record`
-    notification includes `:row_count` field.
-
-    *Jason Nochlin*
+*   Introduce a before-fork hook in `ActiveSupport::Testing::Parallelization` to clear existing
+    connections, to avoid fork-safety issues with the mysql2 adapter.
 
-*   The fix ensures that the association is joined using the appropriate join type
-    (either inner join or left outer join) based on the existing joins in the scope.
+    Fixes #41776
 
-    This prevents unintentional overrides of existing join types and ensures consistency in the generated SQL queries.
-
-    Example:
-
-
-
-    ```ruby
-    # `associated` will use `LEFT JOIN` instead of using `JOIN`
-    Post.left_joins(:author).where.associated(:author)
-    ```
+    *Mike Dalessio*, *Donal McBreen*
 
-    *Saleh Alhaddad*
+*   PoolConfig no longer keeps a reference to the connection class.
 
-*   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.
+    Keeping a reference to the class caused subtle issues when combined with reloading in
+    development. Fixes #54343.
 
-    *Maxime Réty*
+    *Mike Dalessio*
 
-*   Deprecate defining an `enum` with keyword arguments.
+*   Fix SQL notifications sometimes not sent when using async queries.
 
     ```ruby
-    class Function > ApplicationRecord
-      # BAD
-      enum color: [:red, :blue],
-           type: [:instance, :class]
-
-      # GOOD
-      enum :color, [:red, :blue]
-      enum :type, [:instance, :class]
+    Post.async_count
+    ActiveSupport::Notifications.subscribed(->(*) { "Will never reach here" }) do
+      Post.count
     end
     ```
 
-    *Hartley McGuire*
-
-*   Add `config.active_record.validate_migration_timestamps` option for validating migration timestamps.
-
-    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.
-
-    *Adrianna Chang*
-
-*   Properly synchronize `Mysql2Adapter#active?` and `TrilogyAdapter#active?`.
-
-    As well as `disconnect!` and `verify!`.
-
-    This generally isn't a big problem as connections must not be shared between
-    threads, but is required when running transactional tests or system tests
-    and could lead to a SEGV.
-
-    *Jean Boussier*
+    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.
 
-*   Support `:source_location` tag option for query log tags.
+    *Edouard Chin*
 
-    ```ruby
-    config.active_record.query_log_tags << :source_location
-    ```
+*   Eliminate queries loading dumped schema cache on Postgres
 
-    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.
-
-    *fatkodima*
+    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.
 
-*   Add an option to `ActiveRecord::Encryption::Encryptor` to disable compression.
+    *James Coleman*
 
-    Allow compression to be disabled by setting `compress: false`
+*   `ActiveRecord::Coder::JSON` can be instantiated
 
+    Options can now be passed to `ActiveRecord::Coder::JSON` when instantiating the coder. This allows:
     ```ruby
-      class User
-        encrypts :name, encryptor: ActiveRecord::Encryption::Encryptor.new(compress: false)
-      end
+    serialize :config, coder: ActiveRecord::Coder::JSON.new(symbolize_names: true)
     ```
+    *matthaigh27*
 
-    *Donal McBreen*
-
-*   Deprecate passing strings to `ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename`.
-
-    A `ActiveRecord::DatabaseConfigurations::DatabaseConfig` object should be passed instead.
-
-    *Rafael Mendonça França*
-
-*   Add `row_count` field to `sql.active_record` notification.
-
-    This field returns the amount of rows returned by the query that emitted the notification.
-
-    This metric is useful in cases where one wants to detect queries with big result sets.
-
-    *Marvin Bitterlich*
-
-*   Consistently raise an `ArgumentError` when passing an invalid argument to a nested attributes association writer.
-
-    Previously, this would only raise on collection associations and produce a generic error on singular associations.
-
-    Now, it will raise on both collection and singular associations.
-
-    *Joshua Young*
-
-*   Fix single quote escapes on default generated MySQL columns.
+*   Deprecate using `insert_all`/`upsert_all` with unpersisted records in associations.
 
-    MySQL 5.7.5+ supports generated columns, which can be used to create a column that is computed from an expression.
+    Using these methods on associations containing unpersisted records will now
+    show a deprecation warning, as the unpersisted records will be lost after
+    the operation.
 
-    Previously, the schema dump would output a string with double escapes for generated columns with single quotes in the default expression.
+    *Nick Schwaderer*
 
-    This would result in issues when importing the schema on a fresh instance of a MySQL database.
+*   Make column name optional for `index_exists?`.
 
-    Now, the string will not be escaped and will be valid Ruby upon importing of the schema.
+    This aligns well with `remove_index` signature as well, where
+    index name doesn't need to be derived from the column names.
 
-    *Yash Kapadia*
+    *Ali Ismayiliov*
 
-*   Fix Migrations with versions older than 7.1 validating options given to
-    `add_reference` and `t.references`.
+*   Change the payload name of `sql.active_record` notification for eager
+    loading from "SQL" to "#{model.name} Eager Load".
 
-    *Hartley McGuire*
+    *zzak*
 
-*   Add `<role>_types` class method to `ActiveRecord::DelegatedType` so that the delegated types can be introspected.
+*   Enable automatically retrying idempotent `#exists?` queries on connection
+    errors.
 
-    *JP Rosevear*
+    *Hartley McGuire*, *classidied*
 
-*   Make `schema_dump`, `query_cache`, `replica` and `database_tasks` configurable via `DATABASE_URL`.
+*   Deprecate usage of unsupported methods in conjunction with `update_all`:
 
-    This wouldn't always work previously because boolean values would be interpreted as strings.
+    `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.
 
-    e.g. `DATABASE_URL=postgres://localhost/foo?schema_dump=false` now properly disable dumping the schema
-    cache.
+    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.
 
-    *Mike Coutermarsh*, *Jean Boussier*
+    *Edouard Chin*
 
-*   Introduce `ActiveRecord::Transactions::ClassMethods#set_callback`.
+*   The table columns inside `schema.rb` are now sorted alphabetically.
 
-     It is identical to `ActiveSupport::Callbacks::ClassMethods#set_callback`
-     but with support for `after_commit` and `after_rollback` callback options.
+    Previously they'd be sorted by creation order, which can cause merge conflicts when two
+    branches modify the same table concurrently.
 
-    *Joshua Young*
+    *John Duff*
 
-*   Make `ActiveRecord::Encryption::Encryptor` agnostic of the serialization format used for encrypted data.
+*   Introduce versions formatter for the schema dumper.
 
-    Previously, the encryptor instance only allowed an encrypted value serialized as a `String` to be passed to the message serializer.
+    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.
 
-    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`.
+    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.
 
-    The default `ActiveRecord::Encryption::MessageSerializer` already ensures that only `String` objects are passed for deserialization.
+    *fatkodima*
 
-    *Maxime Réty*
+*   Serialized attributes can now be marked as comparable.
 
-*   Fix `encrypted_attribute?` to take into account context properties passed to `encrypts`.
+    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.
 
-    *Maxime Réty*
+    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.
 
-*   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:
+    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
-    User.all.explain.count
-    # EXPLAIN SELECT COUNT(*) FROM `users`
-    # ...
-
-    User.all.explain.maximum(:id)
-    # EXPLAIN SELECT MAX(`users`.`id`) FROM `users`
-    # ...
-    ```
-
-    *Petrik de Heus*
-
-*   Fixes an issue where `validates_associated` `:on`  option wasn't respected
-    when validating associated records.
-
-    *Austen Madden*, *Alex Ghiculescu*, *Rafał Brize*
-
-*   Allow overriding SQLite defaults from `database.yml`.
-
-    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.
-
-    ```yaml
-    database: storage/development.sqlite3
-    timeout: 5000
-    pragmas:
-      journal_mode: off
-      temp_store: memory
+    serialize :config, type: Hash, coder: JSON, comparable: true
     ```
 
-    *Stephen Margheim*
-
-*   Remove warning message when running SQLite in production, but leave it unconfigured.
-
-    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.
-
-    *Jacopo Beschi*, *Jean Boussier*
-
-*   Add support for generated columns to the SQLite3 adapter.
-
-    Generated columns (both stored and dynamic) are supported since version 3.31.0 of SQLite.
-    This adds support for those to the SQLite3 adapter.
+    *Jean Boussier*
 
-    ```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
-    ```
+*   Fix MySQL default functions getting dropped when changing a column's nullability.
 
-    *Stephen Margheim*
+    *Bastian Bartmann*
 
-*   TrilogyAdapter: ignore `host` if `socket` parameter is set.
+*   SQLite extensions can be configured in `config/database.yml`.
 
-    This allows to configure a connection on a UNIX socket via `DATABASE_URL`:
+    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`:
 
-    ```
-    DATABASE_URL=trilogy://does-not-matter/my_db_production?socket=/var/run/mysql.sock
+    ``` 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
     ```
 
-    *Jean Boussier*
+    *Mike Dalessio*
 
-*   Make `assert_queries_count`, `assert_no_queries`, `assert_queries_match`, and
-    `assert_no_queries_match` assertions public.
+*   `ActiveRecord::Middleware::ShardSelector` supports granular database connection switching.
 
-    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.
+    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`.
 
-    ```ruby
-    class ArticleTest < ActiveSupport::TestCase
-      test "queries are made" do
-        assert_queries_count(1) { Article.first }
-      end
+    For example, this configuration tells `ShardSelector` to switch shards using
+    `AnimalsRecord.connected_to`:
 
-      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
     ```
-
-    *Petrik de Heus*, *fatkodima*
-
-*   Fix `has_secure_token` calls the setter method on initialize.
-
-    *Abeid Ahmed*
-
-*   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.
-
-    ```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.
+    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.
 
-    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`.
-
-    *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*
-
-*   Ensure `#signed_id` outputs `url_safe` strings.
+    *Matthew Cheetham*, *Morgan Mareve*
 
-    *Jason Meller*
+*   Cast `query_cache` value when using URL configuration.
 
-*   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.