activerecord 8.0.2 → 8.1.0

data/CHANGELOG.md

@@ -1,667 +1,834 @@
-## Rails 8.0.2 (March 12, 2025) ##
+## Rails 8.1.0 (October 22, 2025) ##
 
-*   No changes.
+*   Fix SQLite3 data loss during table alterations with CASCADE foreign keys.
 
+    When altering a table in SQLite3 that is referenced by child tables with
+    `ON DELETE CASCADE` foreign keys, ActiveRecord would silently delete all
+    data from the child tables. This occurred because SQLite requires table
+    recreation for schema changes, and during this process the original table
+    is temporarily dropped, triggering CASCADE deletes on child tables.
 
-## Rails 8.0.2 (March 12, 2025) ##
+    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.
 
-*   Fix inverting `rename_enum_value` when `:from`/`:to` are provided.
+    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.
 
-    *fatkodima*
-
-*   Prevent persisting invalid record.
-
-    *Edouard Chin*
+    *Ruy Rocha*
 
-*   Fix inverting `drop_table` without options.
+*   Add replicas to test database parallelization setup.
 
-    *fatkodima*
+    Setup and configuration of databases for parallel testing now includes replicas.
 
-*   Fix count with group by qualified name on loaded relation.
+    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}`.
 
-    *Ryuta Kamizono*
+    *Adam Maas*
 
-*   Fix `sum` with qualified name on loaded relation.
+*   Support virtual (not persisted) generated columns on PostgreSQL 18+
 
-    *Chris Gunther*
+    PostgreSQL 18 introduces virtual (not persisted) generated columns,
+    which are now the default unless the `stored: true` option is explicitly specified on PostgreSQL 18+.
 
-*   The SQLite3 adapter quotes non-finite Numeric values like "Infinity" and "NaN".
+    ```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
+    ```
 
-    *Mike Dalessio*
+    *Yasuo Honda*
 
-*   Handle libpq returning a database version of 0 on no/bad connection in `PostgreSQLAdapter`.
+*   Optimize schema dumping to prevent duplicate file generation.
 
-    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.
+    `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.
 
-    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.
+    *Mikey Gough*, *Hartley McGuire*
 
-    *Joshua Young*, *Rian McGuire*
+*   Add structured events for Active Record:
+    - `active_record.strict_loading_violation`
+    - `active_record.sql`
 
-*   Fix error handling during connection configuration.
+    *Gannon McGibbon*
 
-    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)`.
+*   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},
+    })
 
-    *Jean Boussier*
+    ActiveRecord::Base.connected_to(shard: 1) do
+      # ..
+    end
+    ```
 
-*   Fix a case where a non-retryable query could be marked retryable.
+    *Nony Dutton*
 
-    *Hartley McGuire*
+*   Add `ActiveRecord::Base.only_columns`
 
-*   Handle circular references when autosaving associations.
+    Similar in use case to `ignored_columns` but listing columns to consider rather than the ones
+    to ignore.
 
-    *zzak*
+    Can be useful when working with a legacy or shared database schema, or to make safe schema change
+    in two deploys rather than three.
 
-*   PoolConfig no longer keeps a reference to the connection class.
+    *Anton Kandratski*
 
-    Keeping a reference to the class caused subtle issues when combined with reloading in
-    development. Fixes #54343.
+*   Use `PG::Connection#close_prepared` (protocol level Close) to deallocate
+    prepared statements when available.
 
-    *Mike Dalessio*
+    To enable its use, you must have pg >= 1.6.0, libpq >= 17, and a PostgreSQL
+    database version >= 17.
 
-*   Fix SQL notifications sometimes not sent when using async queries.
+    *Hartley McGuire*, *Andrew Jackson*
 
-    ```ruby
-    Post.async_count
-    ActiveSupport::Notifications.subscribed(->(*) { "Will never reach here" }) do
-      Post.count
-    end
-    ```
+*   Fix query cache for pinned connections in multi threaded transactional tests
 
-    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.
+    When a pinned connection is used across separate threads, they now use a separate cache store
+    for each thread.
 
-    *Edouard Chin*
+    This improve accuracy of system tests, and any test using multiple threads.
 
-*   Fix support for PostgreSQL enum types with commas in their name.
+    *Heinrich Lee Yu*, *Jean Boussier*
 
-    *Arthur Hess*
+*   Fix time attribute dirty tracking with timezone conversions.
 
-*   Fix inserts on MySQL with no RETURNING support for a table with multiple auto populated columns.
+    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.
 
-*   Fix joining on a scoped association with string joins and bind parameters.
+    *Prateek Choudhary*
 
-    ```ruby
-    class Instructor < ActiveRecord::Base
-      has_many :instructor_roles, -> { active }
-    end
+*   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.
 
-    class InstructorRole < ActiveRecord::Base
-      scope :active, -> {
-        joins("JOIN students ON instructor_roles.student_id = students.id")
-        .where(students { status: 1 })
-      }
-    end
+    *Yasuo Honda*, *Lars Kanis*
 
-    Instructor.joins(:instructor_roles).first
-    ```
+*   Don't add `id_value` attribute alias when attribute/column with that name already exists.
 
-    The above example would result in `ActiveRecord::StatementInvalid` because the
-    `active` scope bind parameters would be lost.
+    *Rob Lewis*
 
-    *Jean Boussier*
+*   Remove deprecated `:unsigned_float` and `:unsigned_decimal` column methods for MySQL.
 
-*   Fix a potential race condition with system tests and transactional fixtures.
+    *Rafael Mendonça França*
 
-    *Sjoerd Lagarde*
+*   Remove deprecated `:retries` option for the SQLite3 adapter.
 
-*   Fix autosave associations to no longer validated unmodified associated records.
+    *Rafael Mendonça França*
 
-    Active Record was incorrectly performing validation on associated record that
-    weren't created nor modified as part of the transaction:
+*   Introduce new database configuration options `keepalive`, `max_age`, and
+    `min_connections` -- and rename `pool` to `max_connections` to match.
 
-    ```ruby
-    Post.create!(author: User.find(1)) # Fail if user is invalid
-    ```
+    There are no changes to default behavior, but these allow for more specific
+    control over pool behavior.
 
-    *Jean Boussier*
+    *Matthew Draper*, *Chris AtLee*, *Rachael Wright-Munn*
 
-*   Remember when a database connection has recently been verified (for
-    two seconds, by default), to avoid repeated reverifications during a
-    single request.
+*   Move `LIMIT` validation from query generation to when `limit()` is called.
 
-    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.
+    *Hartley McGuire*, *Shuyang*
 
-    *Matthew Draper*
+*   Add `ActiveRecord::CheckViolation` error class for check constraint violations.
 
+    *Ryuta Kamizono*
 
-## Rails 8.0.1 (December 13, 2024) ##
+*   Add `ActiveRecord::ExclusionViolation` error class for exclusion constraint violations.
 
-*   Fix removing foreign keys with :restrict action for MySQL.
+    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.
 
-    *fatkodima*
+    This follows the same pattern as other constraint violation error classes like
+    `RecordNotUnique` for unique constraint violations and `InvalidForeignKey` for
+    foreign key constraint violations.
 
-*   Fix a race condition in `ActiveRecord::Base#method_missing` when lazily defining attributes.
+    *Ryuta Kamizono*
 
-    If multiple thread were concurrently triggering attribute definition on the same model,
-    it could result in a `NoMethodError` being raised.
+*   Attributes filtered by `filter_attributes` will now also be filtered by `filter_parameters`
+    so sensitive information is not leaked.
 
-    *Jean Boussier*
+    *Jill Klang*
 
-*   Fix MySQL default functions getting dropped when changing a column's nullability.
+*   Add `connection.current_transaction.isolation` API to check current transaction's isolation level.
 
-    *Bastian Bartmann*
+    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.
 
-*   Fix `add_unique_constraint`/`add_check_constraint`/`add_foreign_key` to be revertible when given invalid options.
+    ```ruby
+    # Returns nil when no transaction
+    User.connection.current_transaction.isolation # => nil
 
-    *fatkodima*
+    # Returns explicitly set isolation level
+    User.transaction(isolation: :serializable) do
+      User.connection.current_transaction.isolation # => :serializable
+    end
 
-*   Fix asynchronous destroying of polymorphic `belongs_to` associations.
+    # Returns nil when isolation not explicitly set
+    User.transaction do
+      User.connection.current_transaction.isolation # => nil
+    end
 
-    *fatkodima*
+    # Nested transactions inherit parent's isolation
+    User.transaction(isolation: :read_committed) do
+      User.transaction do
+        User.connection.current_transaction.isolation # => :read_committed
+      end
+    end
+    ```
 
-*   Fix `insert_all` to not update existing records.
+    *Kir Shatrov*
 
-    *fatkodima*
+*   Fix `#merge` with `#or` or `#and` and a mixture of attributes and SQL strings resulting in an incorrect query.
 
-*   `NOT VALID` constraints should not dump in `create_table`.
+    ```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
+    ```
 
-    *Ryuta Kamizono*
+    Before:
+
+    ```SQL
+    SELECT "comments".* FROM "comments"
+    INNER JOIN "posts" ON "posts"."id" = "comments"."post_id"
+    WHERE (recent = 1)
+    AND (
+      "comments"."user_id" = 1
+      AND (recent = 1)
+      AND "comments"."draft" = 1
+      OR "posts"."archived" = 1
+    )
+    ```
 
-*   Fix finding by nil composite primary key association.
+    After:
+
+    ```SQL
+    SELECT "comments".* FROM "comments"
+    INNER JOIN "posts" ON "posts"."id" = "comments"."post_id"
+    WHERE "comments"."user_id" = 1
+    AND (recent = 1)
+    AND (
+      "comments"."user_id" = 1
+      AND (recent = 1)
+      AND "comments"."draft" = 1
+      OR "posts"."archived" = 1
+    )
+    ```
 
-    *fatkodima*
+    *Joshua Young*
 
-*   Properly reset composite primary key configuration when setting a primary key.
+*   Make schema dumper to account for `ActiveRecord.dump_schemas` when dumping in `:ruby` format.
 
     *fatkodima*
 
-*   Fix Mysql2Adapter support for prepared statements
+*   Add `:touch` option to `update_column`/`update_columns` methods.
 
-    Using prepared statements with MySQL could result in a `NoMethodError` exception.
+    ```ruby
+    # Will update :updated_at/:updated_on alongside :nice column.
+    user.update_column(:nice, true, touch: true)
 
-    *Jean Boussier*, *Leo Arnold*, *zzak*
+    # Will update :updated_at/:updated_on alongside :last_ip column
+    user.update_columns(last_ip: request.remote_ip, touch: true)
+    ```
 
-*   Fix parsing of SQLite foreign key names when they contain non-ASCII characters
+    *Dmitrii Ivliev*
 
-    *Zacharias Knudsen*
+*   Optimize Active Record batching further when using ranges.
 
-*   Fix parsing of MySQL 8.0.16+ CHECK constraints when they contain new lines.
+    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`).
 
-    *Steve Hill*
+    *Maxime Réty*, *fatkodima*
 
-*   Ensure normalized attribute queries use `IS NULL` consistently for `nil` and normalized `nil` values.
+*   Include current character length in error messages for index and table name length validations.
 
     *Joshua Young*
 
-*   Fix `sum` when performing a grouped calculation.
+*   Add `rename_schema` method for PostgreSQL.
 
-    `User.group(:friendly).sum` no longer worked. This is fixed.
+    *T S Vallender*
 
-    *Edouard Chin*
+*   Implement support for deprecating associations:
 
-*   Restore back the ability to pass only database name to `DATABASE_URL`.
+    ```ruby
+    has_many :posts, deprecated: true
+    ```
 
-    *fatkodima*
+    With that, Active Record will report any usage of the `posts` association.
 
+    Three reporting modes are supported (`:warn`, `:raise`, and `:notify`), and
+    backtraces can be enabled or disabled. Defaults are `:warn` mode and
+    disabled backtraces.
 
-## Rails 8.0.0.1 (December 10, 2024) ##
+    Please, check the docs for further details.
 
-*   No changes.
+    *Xavier Noria*
 
+*   PostgreSQL adapter create DB now supports `locale_provider` and `locale`.
 
-## Rails 8.0.0 (November 07, 2024) ##
+    *Bengt-Ove Hollaender*
 
-*   Fix support for `query_cache: false` in `database.yml`.
+*   Use ntuples to populate row_count instead of count for Postgres
 
-    `query_cache: false` would no longer entirely disable the Active Record query cache.
+    *Jonathan Calvert*
 
-    *zzak*
+*   Fix checking whether an unpersisted record is `include?`d in a strictly
+    loaded `has_and_belongs_to_many` association.
 
+    *Hartley McGuire*
 
-## Rails 8.0.0.rc2 (October 30, 2024) ##
+*   Add ability to change transaction isolation for all pools within a block.
 
-*   NULLS NOT DISTINCT works with UNIQUE CONSTRAINT as well as UNIQUE INDEX.
+    This functionality is useful if your application needs to change the database
+    transaction isolation for a request or action.
 
-    *Ryuta Kamizono*
+    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.
 
-*   The `db:prepare` task no longer loads seeds when a non-primary database is created.
+    This works with explicit and implicit transactions:
 
-    Previously, the `db:prepare` task would load seeds whenever a new database
-    is created, leading to potential loss of data if a database is added to an
-    existing environment.
+    ```ruby
+    ActiveRecord.with_transaction_isolation_level(:read_committed) do
+      Tag.transaction do # opens a transaction explicitly
+        Tag.create!
+      end
+    end
+    ```
 
-    Introduces a new database config property `seeds` to control whether seeds
-    are loaded during `db:prepare` which defaults to `true` for primary database
-    configs and `false` otherwise.
+    ```ruby
+    ActiveRecord.with_transaction_isolation_level(:read_committed) do
+      Tag.create! # opens a transaction implicitly
+    end
+    ```
 
-    Fixes #53348.
+    *Eileen M. Uchitelle*
 
-    *Mike Dalessio*
+*   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.
 
-*   `PG::UnableToSend: no connection to the server` is now retryable as a connection-related exception
+    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.
 
-    *Kazuma Watanabe*
+    ```ruby
+    config.active_record.raise_on_missing_required_finder_order_columns = true
+    ```
 
-*   Fix strict loading propagation even if statement cache is not used.
+    *Joshua Young*
 
-    *Ryuta Kamizono*
+*   `:class_name` is now invalid in polymorphic `belongs_to` associations.
 
-*   Allow `rename_enum` accepts two from/to name arguments as `rename_table` does so.
+    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.
 
-    *Ryuta Kamizono*
+    Existing polymorphic associations setting this option can just delete it.
+    While it did not raise, it had no effect anyway.
 
+    *Xavier Noria*
 
-## Rails 8.0.0.rc1 (October 19, 2024) ##
+*   Add support for multiple databases to `db:migrate:reset`.
 
-*   Remove deprecated support to setting `ENV["SCHEMA_CACHE"]`.
+    *Joé Dupuis*
 
-    *Rafael Mendonça França*
+*   Add `affected_rows` to `ActiveRecord::Result`.
 
-*   Remove deprecated support to passing a database name to `cache_dump_filename`.
+    *Jenny Shen*
 
-    *Rafael Mendonça França*
+*   Enable passing retryable SqlLiterals to `#where`.
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::ConnectionPool#connection`.
+    *Hartley McGuire*
 
-    *Rafael Mendonça França*
+*   Set default for primary keys in `insert_all`/`upsert_all`.
 
-*   Remove deprecated `config.active_record.sqlite3_deprecated_warning`.
+    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.
 
-    *Rafael Mendonça França*
+    *Jenny Shen*
 
-*   Remove deprecated `config.active_record.warn_on_records_fetched_greater_than`.
+*   Add a load hook `active_record_database_configurations` for `ActiveRecord::DatabaseConfigurations`
 
-    *Rafael Mendonça França*
+    *Mike Dalessio*
 
-*   Remove deprecated support for defining `enum` with keyword arguments.
+*   Use `TRUE` and `FALSE` for SQLite queries with boolean columns.
 
-    *Rafael Mendonça França*
+    *Hartley McGuire*
 
-*   Remove deprecated support to finding database adapters that aren't registered to Active Record.
+*   Bump minimum supported SQLite to 3.23.0.
 
-    *Rafael Mendonça França*
+    *Hartley McGuire*
 
-*   Remove deprecated `config.active_record.allow_deprecated_singular_associations_name`.
+*   Allow allocated Active Records to lookup associations.
 
-    *Rafael Mendonça França*
+    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.
 
-*   Remove deprecated `config.active_record.commit_transaction_on_non_local_return`.
+    *Gannon McGibbon*
 
-    *Rafael Mendonça França*
+*   Encryption now supports `support_unencrypted_data: true` being set per-attribute.
 
-*   Fix incorrect SQL query when passing an empty hash to `ActiveRecord::Base.insert`.
+    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.
 
-    *David Stosik*
+    ```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
+    ```
 
-*   Allow to save records with polymorphic join tables that have `inverse_of`
-    specified.
+    ```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
+    ```
 
-    *Markus Doits*
+    *Alex Ghiculescu*
 
-*   Fix association scopes applying on the incorrect join when using a polymorphic `has_many through:`.
+*   Model generator no longer needs a database connection to validate column types.
 
-    *Joshua Young*
+    *Mike Dalessio*
 
-*   Allow `ActiveRecord::Base#pluck` to accept hash arguments with symbol and string values.
+*   Allow signed ID verifiers to be configurable via `Rails.application.message_verifiers`
 
-    ```ruby
-    Post.joins(:comments).pluck(:id, comments: :id)
-    Post.joins(:comments).pluck("id", "comments" => "id")
-    ```
+    Prior to this change, the primary way to configure signed ID verifiers was
+    to set `signed_id_verifier` on each model class:
 
-    *Joshua Young*
+      ```ruby
+      Post.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      Comment.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      ```
 
-*   Make Float distinguish between `float4` and `float8` in 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:
 
-    Fixes #52742
+      ```ruby
+      { digest: "SHA256", serializer: JSON, url_safe: true }
+      ```
 
-    *Ryota Kitazawa*, *Takayuki Nagatomi*
+    Thus it was cumbersome to rotate configuration for all verifiers.
 
+    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.
 
-## Rails 8.0.0.beta1 (September 26, 2024) ##
+    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:
 
-*   Allow `drop_table` to accept an array of table names.
+      ```ruby
+      # BEFORE
+      Post.signed_id_verifier_secret = "my secret"
 
-    This will let you to drop multiple tables in a single call.
+      # AFTER
+      Post.signed_id_verifier = ActiveSupport::MessageVerifier.new("my secret", digest: "SHA256", serializer: JSON, url_safe: true)
+      ```
 
-    ```ruby
-    ActiveRecord::Base.lease_connection.drop_table(:users, :posts)
-    ```
+    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_:
 
-    *Gabriel Sobrinho*
+      ```ruby
+      # BEFORE
+      ActiveRecord::Base.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      Post.signed_id_verifier == ActiveRecord::Base.signed_id_verifier # => false
 
-*   Add support for PostgreSQL `IF NOT EXISTS` via the `:if_not_exists` option
-    on the `add_enum_value` method.
+      # AFTER
+      ActiveRecord::Base.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      Post.signed_id_verifier == ActiveRecord::Base.signed_id_verifier # => true
 
-    *Ariel Rzezak*
+      Post.signed_id_verifier_secret = "my secret" # => deprecation warning
+      Post.signed_id_verifier == ActiveRecord::Base.signed_id_verifier # => false
+      ```
 
-*   When running `db:migrate` on a fresh database, load the databases schemas before running migrations.
+    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:
 
-    *Andrew Novoselac*, *Marek Kasztelnik*
+      ```ruby
+      # BEFORE
+      # Generate and verify signed Post IDs using Post-specific configuration
+      Post.signed_id_verifier = ActiveSupport::MessageVerifier.new("post secret", ...)
 
-*   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.
+      # 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", ...)
+      ```
 
-    Previously, using `.left_outer_joins` with the same child association would only join one of the parents.
+    [`config.active_record.use_legacy_signed_id_verifier`]: https://guides.rubyonrails.org/v8.1/configuring.html#config-active-record-use-legacy-signed-id-verifier
 
-    Now it will correctly join both parents.
+    *Ali Sepehri*, *Jonathan Hefner*
 
-    Fixes #41498.
+*   Prepend `extra_flags` in postgres' `structure_load`
 
-    *Garrett Blehm*
+    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.
 
-*   Deprecate `unsigned_float` and `unsigned_decimal` short-hand column methods.
+    *Alice Loeser*
 
-    As of MySQL 8.0.17, the UNSIGNED attribute is deprecated for columns of type FLOAT, DOUBLE,
-    and DECIMAL. Consider using a simple CHECK constraint instead for such columns.
+*   Allow bypassing primary key/constraint addition in `implicit_order_column`
 
-    https://dev.mysql.com/doc/refman/8.0/en/numeric-type-syntax.html
+    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.
 
-    *Ryuta Kamizono*
+    *Issy Long*
 
-*   Drop MySQL 5.5 support.
+*   Allow setting the `schema_format` via database configuration.
 
-    MySQL 5.5 is the only version that does not support datetime with precision,
-    which we have supported in the core. Now we support MySQL 5.6.4 or later, which
-    is the first version to support datetime with precision.
-
-    *Ryuta Kamizono*
+    ```
+    primary:
+      schema_format: ruby
+    ```
 
-*   Make Active Record asynchronous queries compatible with transactional fixtures.
+    Useful for multi-database setups when apps require different formats per-database.
 
-    Previously transactional fixtures would disable asynchronous queries, because transactional
-    fixtures impose all queries use the same connection.
+    *T S Vallender*
 
-    Now asynchronous queries will use the connection pinned by transactional fixtures, and behave
-    much closer to production.
+*   Support disabling indexes for MySQL v8.0.0+ and MariaDB v10.6.0+
 
-    *Jean Boussier*
+    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.
 
-*   Deserialize binary data before decrypting
+    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.
 
-    This ensures that we call `PG::Connection.unescape_bytea` on PostgreSQL before decryption.
+    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:
 
-    *Donal McBreen*
+    ```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
 
-*   Ensure `ActiveRecord::Encryption.config` is always ready before access.
+    create_table :users do |t|
+      t.string :name, index: { enabled: false }
+      t.string :email
+      t.index :email, enabled: false
+    end
+    ```
 
-    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.
+    *Merve Taner*
 
-    `ActiveRecord::Encryption` now has its own loading hook so that its configuration is set as
-    soon as needed.
+*   Respect `implicit_order_column` in `ActiveRecord::Relation#reverse_order`.
 
-    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`.
+    *Joshua Young*
 
-    *Maxime Réty*
+*   Add column types to `ActiveRecord::Result` for SQLite3.
 
-*   Add `TimeZoneConverter#==` method, so objects will be properly compared by
-    their type, scale, limit & precision.
+    *Andrew Kane*
 
-    Address #52699.
+*   Raise `ActiveRecord::ReadOnlyError` when pessimistically locking with a readonly role.
 
-    *Ruy Rocha*
+    *Joshua Young*
 
-*   Add support for SQLite3 full-text-search and other virtual tables.
+*   Fix using the `SQLite3Adapter`'s `dbconsole` method outside of a Rails application.
 
-    Previously, adding sqlite3 virtual tables messed up `schema.rb`.
+    *Hartley McGuire*
 
-    Now, virtual tables can safely be added using `create_virtual_table`.
+*   Fix migrating multiple databases with `ActiveRecord::PendingMigration` action.
 
-    *Zacharias Knudsen*
+    *Gannon McGibbon*
 
-*   Support use of alternative database interfaces via the `database_cli` ActiveRecord configuration option.
+*   Enable automatically retrying idempotent association queries on connection
+    errors.
 
-    ```ruby
-    Rails.application.configure do
-      config.active_record.database_cli = { postgresql: "pgcli" }
-    end
-    ```
+    *Hartley McGuire*
 
-    *T S Vallender*
+*   Add `allow_retry` to `sql.active_record` instrumentation.
 
-*   Add support for dumping table inheritance and native partitioning table definitions for PostgeSQL adapter
+    This enables identifying queries which queries are automatically retryable on connection errors.
 
-    *Justin Talbott*
+    *Hartley McGuire*
 
-*   Add support for `ActiveRecord::Point` type casts using `Hash` values
+*   Better support UPDATE with JOIN for Postgresql and SQLite3
 
-    This allows `ActiveRecord::Point` to be cast or serialized from a hash
-    with `:x` and `:y` keys of numeric values, mirroring the functionality of
-    existing casts for string and array values. Both string and symbol keys are
-    supported.
+    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:
 
     ```ruby
-    class PostgresqlPoint < ActiveRecord::Base
-      attribute :x, :point
-      attribute :y, :point
-      attribute :z, :point
-    end
-
-    val = PostgresqlPoint.new({
-      x: '(12.34, -43.21)',
-      y: [12.34, '-43.21'],
-      z: {x: '12.34', y: -43.21}
-    })
-    ActiveRecord::Point.new(12.32, -43.21) == val.x == val.y == val.z
+    Comment.joins(:post).update_all("title = posts.title")
     ```
 
-    *Stephen Drew*
+    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.
 
-*   Replace `SQLite3::Database#busy_timeout` with `#busy_handler_timeout=`.
+    *Jean Boussier*
 
-    Provides a non-GVL-blocking, fair retry interval busy handler implementation.
+*   Introduce a before-fork hook in `ActiveSupport::Testing::Parallelization` to clear existing
+    connections, to avoid fork-safety issues with the mysql2 adapter.
 
-    *Stephen Margheim*
+    Fixes #41776
 
-*   SQLite3Adapter: Translate `SQLite3::BusyException` into `ActiveRecord::StatementTimeout`.
+    *Mike Dalessio*, *Donal McBreen*
 
-    *Matthew Nguyen*
+*   PoolConfig no longer keeps a reference to the connection class.
 
-*   Include schema name in `enable_extension` statements in `db/schema.rb`.
+    Keeping a reference to the class caused subtle issues when combined with reloading in
+    development. Fixes #54343.
 
-    The schema dumper will now include the schema name in generated
-    `enable_extension` statements if they differ from the current schema.
+    *Mike Dalessio*
 
-    For example, if you have a migration:
+*   Fix SQL notifications sometimes not sent when using async queries.
 
     ```ruby
-    enable_extension "heroku_ext.pgcrypto"
-    enable_extension "pg_stat_statements"
+    Post.async_count
+    ActiveSupport::Notifications.subscribed(->(*) { "Will never reach here" }) do
+      Post.count
+    end
     ```
 
-    then the generated schema dump will also contain:
+    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.
 
-    ```ruby
-    enable_extension "heroku_ext.pgcrypto"
-    enable_extension "pg_stat_statements"
-    ```
+    *Edouard Chin*
 
-    *Tony Novak*
+*   Eliminate queries loading dumped schema cache on Postgres
 
-*   Fix `ActiveRecord::Encryption::EncryptedAttributeType#type` to return
-    actual cast type.
+    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.
 
-    *Vasiliy Ermolovich*
+    *James Coleman*
 
-*   SQLite3Adapter: Bulk insert fixtures.
+*   `ActiveRecord::Coder::JSON` can be instantiated
 
-    Previously one insert command was executed for each fixture, now they are
-    aggregated in a single bulk insert command.
+    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*
 
-    *Lázaro Nixon*
+*   Deprecate using `insert_all`/`upsert_all` with unpersisted records in associations.
 
-*   PostgreSQLAdapter: Allow `disable_extension` to be called with schema-qualified name.
+    Using these methods on associations containing unpersisted records will now
+    show a deprecation warning, as the unpersisted records will be lost after
+    the operation.
 
-    For parity with `enable_extension`, the `disable_extension` method can be called with a schema-qualified
-    name (e.g. `disable_extension "myschema.pgcrypto"`). Note that PostgreSQL's `DROP EXTENSION` does not
-    actually take a schema name (unlike `CREATE EXTENSION`), so the resulting SQL statement will only name
-    the extension, e.g. `DROP EXTENSION IF EXISTS "pgcrypto"`.
+    *Nick Schwaderer*
 
-    *Tony Novak*
+*   Make column name optional for `index_exists?`.
 
-*   Make `create_schema` / `drop_schema` reversible in migrations.
+    This aligns well with `remove_index` signature as well, where
+    index name doesn't need to be derived from the column names.
 
-    Previously, `create_schema` and `drop_schema` were irreversible migration operations.
+    *Ali Ismayiliov*
 
-    *Tony Novak*
+*   Change the payload name of `sql.active_record` notification for eager
+    loading from "SQL" to "#{model.name} Eager Load".
 
-*   Support batching using custom columns.
+    *zzak*
 
-    ```ruby
-    Product.in_batches(cursor: [:shop_id, :id]) do |relation|
-      # do something with relation
-    end
-    ```
+*   Enable automatically retrying idempotent `#exists?` queries on connection
+    errors.
 
-    *fatkodima*
+    *Hartley McGuire*, *classidied*
 
-*   Use SQLite `IMMEDIATE` transactions when possible.
+*   Deprecate usage of unsupported methods in conjunction with `update_all`:
 
-    Transactions run against the SQLite3 adapter default to IMMEDIATE mode to improve concurrency support and avoid busy exceptions.
+    `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.
 
-    *Stephen Margheim*
+    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.
 
-*   Raise specific exception when a connection is not defined.
+    *Edouard Chin*
 
-    The new `ConnectionNotDefined` exception provides connection name, shard and role accessors indicating the details of the connection that was requested.
+*   The table columns inside `schema.rb` are now sorted alphabetically.
 
-    *Hana Harencarova*, *Matthew Draper*
+    Previously they'd be sorted by creation order, which can cause merge conflicts when two
+    branches modify the same table concurrently.
 
-*   Delete the deprecated constant `ActiveRecord::ImmutableRelation`.
+    *John Duff*
 
-    *Xavier Noria*
+*   Introduce versions formatter for the schema dumper.
 
-*   Fix duplicate callback execution when child autosaves parent with `has_one` and `belongs_to`.
+    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.
 
-    Before, persisting a new child record with a new associated parent record would run `before_validation`,
-    `after_validation`, `before_save` and `after_save` callbacks twice.
+    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.
 
-    Now, these callbacks are only executed once as expected.
+    *fatkodima*
 
-    *Joshua Young*
+*   Serialized attributes can now be marked as comparable.
 
-*   `ActiveRecord::Encryption::Encryptor` now supports a `:compressor` option to customize the compression algorithm used.
+    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.
 
-    ```ruby
-    module ZstdCompressor
-      def self.deflate(data)
-        Zstd.compress(data)
-      end
+    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.
 
-      def self.inflate(data)
-        Zstd.decompress(data)
-      end
-    end
+    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.
 
-    class User
-      encrypts :name, compressor: ZstdCompressor
-    end
+    ```ruby
+    serialize :config, type: Hash, coder: JSON, comparable: true
     ```
 
-    You disable compression by passing `compress: false`.
+    *Jean Boussier*
 
-    ```ruby
-    class User
-      encrypts :name, compress: false
-    end
-    ```
+*   Fix MySQL default functions getting dropped when changing a column's nullability.
 
-    *heka1024*
+    *Bastian Bartmann*
 
-*   Add condensed `#inspect` for `ConnectionPool`, `AbstractAdapter`, and
-    `DatabaseConfig`.
+*   SQLite extensions can be configured in `config/database.yml`.
 
-    *Hartley McGuire*
+    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`:
 
-*   Add `.shard_keys`, `.sharded?`, & `.connected_to_all_shards` methods.
+    ``` 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
+    ```
 
-    ```ruby
-    class ShardedBase < ActiveRecord::Base
-        self.abstract_class = true
+    *Mike Dalessio*
 
-        connects_to shards: {
-          shard_one: { writing: :shard_one },
-          shard_two: { writing: :shard_two }
-        }
-    end
+*   `ActiveRecord::Middleware::ShardSelector` supports granular database connection switching.
 
-    class ShardedModel < ShardedBase
-    end
+    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`.
+
+    For example, this configuration tells `ShardSelector` to switch shards using
+    `AnimalsRecord.connected_to`:
 
-    ShardedModel.shard_keys => [:shard_one, :shard_two]
-    ShardedModel.sharded? => true
-    ShardedBase.connected_to_all_shards { ShardedModel.current_shard } => [:shard_one, :shard_two]
+    ```
+    config.active_record.shard_selector = { class_name: "AnimalsRecord" }
     ```
 
-    *Nony Dutton*
+    *Mike Dalessio*
 
-*   Add a `filter` option to `in_order_of` to prioritize certain values in the sorting without filtering the results
-    by these values.
+*   Reset relations after `insert_all`/`upsert_all`.
 
-    *Igor Depolli*
+    Bulk insert/upsert methods will now call `reset` if used on a relation, matching the behavior of `update_all`.
 
-*   Fix an issue where the IDs reader method did not return expected results
-    for preloaded associations in models using composite primary keys.
+    *Milo Winningham*
 
-    *Jay Ang*
+*   Use `_N` as a parallel tests databases suffixes
 
-*   Allow to configure `strict_loading_mode` globally or within a model.
+    Peviously, `-N` was used as a suffix. This can cause problems for RDBMSes
+    which do not support dashes in database names.
 
-    Defaults to `:all`, can be changed to `:n_plus_one_only`.
+    *fatkodima*
 
-    *Garen Torikian*
+*   Remember when a database connection has recently been verified (for
+    two seconds, by default), to avoid repeated reverifications during a
+    single request.
 
-*   Add `ActiveRecord::Relation#readonly?`.
+    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.
 
-    Reflects if the relation has been marked as readonly.
+    *Matthew Draper*
 
-    *Theodor Tonum*
+*   Allow to reset cache counters for multiple records.
 
-*   Improve `ActiveRecord::Store` to raise a descriptive exception if the column is not either
-    structured (e.g., PostgreSQL +hstore+/+json+, or MySQL +json+) or declared serializable via
-    `ActiveRecord.store`.
+    ```
+    Aircraft.reset_counters([1, 2, 3], :wheels_count)
+    ```
 
-    Previously, a `NoMethodError` would be raised when the accessor was read or written:
+    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.
 
-        NoMethodError: undefined method `accessor' for an instance of ActiveRecord::Type::Text
+    *fatkodima*
 
-    Now, a descriptive `ConfigurationError` is raised:
+*   Add `affected_rows` to `sql.active_record` Notification.
 
-        ActiveRecord::ConfigurationError: the column 'metadata' has not been configured as a store.
-          Please make sure the column is declared serializable via 'ActiveRecord.store' or, if your
-          database supports it, use a structured column type like hstore or json.
+    *Hartley McGuire*
 
-    *Mike Dalessio*
+*   Fix `sum` when performing a grouped calculation.
 
-*   Fix inference of association model on nested models with the same demodularized name.
+    `User.group(:friendly).sum` no longer worked. This is fixed.
+
+    *Edouard Chin*
+
+*   Add support for enabling or disabling transactional tests per database.
 
-    E.g. with the following setup:
+    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
-    class Nested::Post < ApplicationRecord
-      has_one :post, through: :other
+    class MostlyTransactionalTest < ActiveSupport::TestCase
+      self.use_transactional_tests = true
+      skip_transactional_tests_for_database :shared
     end
     ```
 
-    Before, `#post` would infer the model as `Nested::Post`, but now it correctly infers `Post`.
+    *Matthew Cheetham*, *Morgan Mareve*
 
-    *Joshua Young*
+*   Cast `query_cache` value when using URL configuration.
+
+    *zzak*
 
-*   Add public method for checking if a table is ignored by the schema cache.
+*   NULLS NOT DISTINCT works with UNIQUE CONSTRAINT as well as UNIQUE INDEX.
 
-    Previously, an application would need to reimplement `ignored_table?` from the schema cache class to check if a table was set to be ignored. This adds a public method to support this and updates the schema cache to use that directly.
+    *Ryuta Kamizono*
 
-    ```ruby
-    ActiveRecord.schema_cache_ignored_tables = ["developers"]
-    ActiveRecord.schema_cache_ignored_table?("developers")
-    => true
-    ```
+*   `PG::UnableToSend: no connection to the server` is now retryable as a connection-related exception
 
-    *Eileen M. Uchitelle*
+    *Kazuma Watanabe*
 
-Please check [7-2-stable](https://github.com/rails/rails/blob/7-2-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.