activerecord 8.0.0 → 8.1.4

data/CHANGELOG.md

@@ -1,454 +1,1594 @@
-## Rails 8.0.0 (November 07, 2024) ##
+## Rails 8.1.4 (September 24, 2026) ##
 
-*   Fix support for `query_cache: false` in `database.yml`.
+*   Avoid deadlocks when concurrent `find_or_create_by` calls read back the same
+    record within MySQL transactions.
 
-    `query_cache: false` would no longer entirely disable the Active Record query cache.
+    Use a shared lock for the read after a duplicate insert, preserving visibility
+    under REPEATABLE READ without upgrading competing shared locks to exclusive locks.
+    This also applies to `create_or_find_by` and the bang variants of both methods.
 
-    *zzak*
+    Fixes #54281.
 
-## Rails 8.0.0.rc2 (October 30, 2024) ##
+    *Kirsten Westeinde*
 
-*   NULLS NOT DISTINCT works with UNIQUE CONSTRAINT as well as UNIQUE INDEX.
+*   Filter the database password out of failed `db:` task command error messages.
 
-    *Ryuta Kamizono*
+    *Ngan Pham*
 
-*   The `db:prepare` task no longer loads seeds when a non-primary database is created.
+*   Fix `ActiveRecord::TypeCaster::Connection` sometimes leaking a checked-out
+    connection.
 
-    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.
+    *Hartley McGuire*
 
-    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.
+*   Fix PostgreSQL exclusion constraints with multiline expressions being parsed
+    incorrectly during schema introspection.
 
-    Fixes #53348.
+    *Jake McAllister*
 
-    *Mike Dalessio*
+*   Fix async `ActiveRecord::StatementCache#execute` raising an error for
+    out-of-range bind values instead of returning an empty result.
 
-*   `PG::UnableToSend: no connection to the server` is now retryable as a connection-related exception
+    *viralpraxis*
 
-    *Kazuma Watanabe*
+*   Fix `where` clauses with column-tuple syntax not resolving references to
+    other tables.
 
-*   Fix strict loading propagation even if statement cache is not used.
+    *Chris Gunther*
 
-    *Ryuta Kamizono*
+*   Fix `distinct: true` being ignored by `average`.
 
-*   Allow `rename_enum` accepts two from/to name arguments as `rename_table` does so.
+    *Kenta Ishizaki*
 
-    *Ryuta Kamizono*
+*   Fix `belongs_to` change tracking for composite foreign keys.
 
+    Only the first foreign key column was checked for changes; now all foreign
+    key columns are checked.
 
-## Rails 8.0.0.rc1 (October 19, 2024) ##
+    *Anas Khan*
 
-*   Remove deprecated support to setting `ENV["SCHEMA_CACHE"]`.
+*   Make `add_column(if_not_exists: true)` reversible.
 
-    *Rafael Mendonça França*
+    *Kenta Ishizaki*
 
-*   Remove deprecated support to passing a database name to `cache_dump_filename`.
+*   Quote the index name in MySQL `enable_index` and `disable_index`.
 
-    *Rafael Mendonça França*
+    Unquoted index names containing special characters could cause SQL syntax
+    errors.
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::ConnectionPool#connection`.
+    *Kenta Ishizaki*
 
-    *Rafael Mendonça França*
+*   Make `remove_foreign_key(if_exists: true)` reversible.
 
-*   Remove deprecated `config.active_record.sqlite3_deprecated_warning`.
+    *Kenta Ishizaki*
 
-    *Rafael Mendonça França*
+*   Fix `distinct: true` being ignored by grouped `sum`.
 
-*   Remove deprecated `config.active_record.warn_on_records_fetched_greater_than`.
+    *Kenta Ishizaki*
 
-    *Rafael Mendonça França*
+*   Return an `ActiveRecord::Promise` from `async_ids` on a contradictory
+    relation, instead of a plain `ActiveRecord::Result`.
 
-*   Remove deprecated support for defining `enum` with keyword arguments.
+    *Kenta Ishizaki*
 
-    *Rafael Mendonça França*
+*   Fix reversibility check for `drop_virtual_table`.
 
-*   Remove deprecated support to finding database adapters that aren't registered to Active Record.
+    The wrong argument was extracted, so the check for whether options were
+    given could pass or fail incorrectly.
 
-    *Rafael Mendonça França*
+    *Kenta Ishizaki*
 
-*   Remove deprecated `config.active_record.allow_deprecated_singular_associations_name`.
+*   Fix `remove_check_constraint(if_exists: true)` incorrectly raising when
+    removing by expression.
 
-    *Rafael Mendonça França*
+    The `if_exists` check did not pass the expression to
+    `check_constraint_exists?`, so it could not find the constraint.
 
-*   Remove deprecated `config.active_record.commit_transaction_on_non_local_return`.
+    *Kenta Ishizaki*
 
-    *Rafael Mendonça França*
+*   Clear PostgreSQL notices as they are handled, preventing warnings from
+    leaking to subsequent queries.
 
-*   Fix incorrect SQL query when passing an empty hash to `ActiveRecord::Base.insert`.
+    *Matthew Draper*
 
-    *David Stosik*
+*   Fix `WeakThreadKeyMap` raising "can't add a new key into hash during
+    iteration" when connections are checked in from multiple threads.
 
-*   Allow to save records with polymorphic join tables that have `inverse_of`
-    specified.
+    *Matthew Draper*
 
-    *Markus Doits*
+*   Continue pool disconnect after a connection's cleanup or disconnect raises.
 
-*   Fix association scopes applying on the incorrect join when using a polymorphic `has_many through:`.
+    Previously, a failure on one connection aborted the teardown, stranding
+    remaining connections and their resources.
 
-    *Joshua Young*
+    *Matthew Draper*
+
+*   Fix race condition between `preconnect` and the connection pool reaper.
+
+    *Yasuo Honda*
+
+*   Fix `in_order_of` raising when the column is a CTE reference.
+
+    *viralpraxis*
+
+*   Fix `content_columns` including composite primary key components.
+
+    Only the first primary key column was excluded; now all primary key columns
+    are excluded.
+
+    *Kenta Ishizaki*
+
+*   Treat `remove_column` with options but no type as irreversible.
+
+    Previously, `remove_column(:table, :column, default: nil)` would not raise
+    `IrreversibleMigration` because the options hash was mistaken for a column
+    type.
+
+    *Kenta Ishizaki*
+
+*   Fix `counter_cache_column` crashing when `:counter_cache` is given as a
+    Hash without a `:column` key.
+
+    *Kenta Ishizaki*
+
+*   Coerce `seeds` and `use_metadata_table` to booleans in `UrlConfig`.
+
+    When configured via `DATABASE_URL`, these options were left as strings
+    instead of being coerced to booleans like `replica` and `database_tasks`.
+
+    *Kenta Ishizaki*
+
+*   Fix `excluding` (and its `without` alias) to work with composite primary key
+    models. Records passed to `excluding` are now matched by their full composite id
+    instead of being looked up by a single primary key column.
+
+    *Kenta Ishizaki*
+
+*   Fix `Relation#delete` raising on a single composite primary key id.
+
+    `Model.delete(id)` now wraps a single composite id in an array before building
+    the `WHERE` clause, so a single record can be deleted by its composite id.
+
+    *Kenta Ishizaki*
+
+*   Fix reading a composite primary key after a partial `select` returning the
+    raw value instead of `nil` for unselected key columns.
+
+    The attribute defaults builder excluded only the single primary key column from
+    defaults; for composite primary keys it left the unselected key columns in the
+    defaults, so `record.id` returned an array of raw column values instead of
+    `[nil, nil]`. All primary key columns are now excluded.
+
+    *Kenta Ishizaki*
+
+*   Fix `find` with an empty array on a composite primary key model returning the
+    argument array instead of `[]`.
+
+    `Model.find([])` now returns a fresh empty array for composite primary key
+    models, matching single-key models.
+
+    *Kenta Ishizaki*
+
+*   Fix `find` with an order clause and an offset past the end of the ids raising
+    `RecordNotFound` instead of returning an empty result.
+
+    *Kenta Ishizaki*
+
+*   Fix `in_order_of` dropping values that cannot be serialized for the column
+    instead of turning them into an `IS NULL` match.
+
+    Out-of-range integers and unknown enum keys are now ignored rather than
+    silently matching rows with `NULL` in that column. When all requested values
+    are unrepresentable, the relation returns no rows instead of building an empty
+    `CASE` expression.
+
+    *Kenta Ishizaki*
+
+*   Fix stale `finder_needs_type_condition?` memo after the schema cache is reloaded.
+
+    When an STI model's `type` column was removed and re-added (e.g. via a
+    migration) and `reset_column_information` was called, the cached
+    `finder_needs_type_condition` value was not cleared, so queries could omit the
+    STI type condition. The memo is now reset on `reload_schema_from_cache`.
+
+    *Kenta Ishizaki*
+
+*   Fix PostgreSQL schema dump to qualify `enum_type` when the same enum name exists
+    in different schemas.
+
+    Previously the dumped `enum_type` used the bare type name, which could resolve to
+    the wrong enum in another schema. It now uses the schema-qualified name.
+
+    *fatkodima*
+
+*   Fix PostgreSQL index introspection to parse opclasses from another schema.
+
+    Index expressions using a schema-qualified opclass (e.g.
+    `USING gin(position test_schema.gin_trgm_ops)`) are now parsed correctly so the
+    opclass is captured without the schema prefix.
+
+    *Nicolas Vandenboegaerde*
+
+*   Fix `belongs_to` `:touch` with composite foreign keys.
+
+    Touching the parent record when a `belongs_to` with a composite foreign key
+    changes or is destroyed now correctly resolves the old and new parent by all
+    foreign key columns.
+
+    *Romulo Storel*
+
+*   Fix `add_index` `comment:` option on a schema-qualified PostgreSQL table.
 
-*   Allow `ActiveRecord::Base#pluck` to accept hash arguments with symbol and string values.
+    The `COMMENT ON INDEX` statement now schema-qualifies the index name, so the
+    comment is applied to the index in the correct schema instead of raising.
+
+    *Tobias Egli*
+
+*   Fix `check_all_foreign_keys_valid!` on PostgreSQL partitioned tables.
+
+    The validation query previously matched constraints by name across all tables in
+    the schema, marking unrelated constraints (including partition children) as not
+    validated. It now scopes the update to the specific table.
+
+    *Alexis Andrieu*
+
+*   Revert stable sorting of columns and indexes in serialized schema caches.
+
+    `SchemaCache#encode_with` no longer sorts a table's columns and indexes by name
+    when writing the cache, restoring the pre-8.1 behavior.
+
+    *Jean Boussier*
+
+*   Fix `only_columns` to enumerate columns in the `SELECT` clause.
+
+    Models using `only_columns` were generating `SELECT *` instead of an explicit
+    column list, which could select columns that were meant to be excluded.
+
+    *sarub0b0*
+
+*   Fix `eager_load` with a composite primary key and an explicit `select`.
+
+    The join dependency used the single primary key value to build aliases; for
+    composite primary keys it now uses the full array of primary key columns, so
+    eager loading with a custom `select` no longer drops the association records.
+
+    *fatkodima*
+
+*   Fix `find_signed` with a composite primary key.
+
+    `find_signed` now wraps the decoded id in an array so `find_by` matches against
+    all primary key columns, instead of silently returning `nil`.
+
+    *Kenta Ishizaki*
+
+*   Fix `with_connection(prevent_permanent_checkout: true)` clearing a sticky lease
+    that was already set by `lease_connection`.
+
+    A `with_connection` call with `prevent_permanent_checkout: true` no longer resets
+    `lease.sticky` to its previous value when the connection was already sticky, so
+    the connection remains checked out after the block.
+
+    *Ben Sheldon*
+
+*   Fix `reset_counters` to cast string ids to the primary key type.
+
+    `reset_counters` called with a string id (the form ids take from request params)
+    failed to find the record for both single and composite primary keys. Each id is
+    now cast against its own column type.
+
+    *fatkodima*
+
+*   Fix `belongs_to` presence validation for composite foreign keys.
+
+    The required-association validation only checked the first foreign key column.
+    For composite foreign keys it now considers the association present only when
+    none of the foreign key columns are `nil`, and changed when any of them changed.
+
+    *Felix Descoteaux*
+
+*   Fix preloading a `belongs_to` with a composite foreign key when some key columns
+    are `nil`.
+
+    The preloader now skips owners whose composite key has any `nil` component
+    instead of issuing a query that matches unrelated rows.
+
+    *Rose Wiegley*
+
+*   Fix `belongs_to` inverse matching with composite foreign keys.
+
+    `inversable?` compared a single foreign key column against a single primary key,
+    so `belongs_to` associations with composite foreign keys never matched their
+    inverse. Foreign key and primary key values are now compared component by
+    component.
+
+    *Martin Samson*
+
+*   Fix `validate_table_length!` to ignore the schema prefix on PostgreSQL.
+
+    Schema-qualified table names (e.g. `"schema.very_long_table_name"`) were
+    incorrectly rejected as exceeding the table name length limit because the schema
+    prefix was counted. The schema is now stripped before checking the length.
+
+    *fatkodima*
+
+*   Fix passing Trilogy SSL options to `mysql` and `mysqldump` commands.
+
+    *Ngan Pham*
+
+*   Fix `keepalive: false` in `database.yml` falling back to the
+    600 second default.
+
+    *Joe Sak*
+
+*   Fix connection checkout blocking past the configured `checkout_timeout` while
+    waiting behind background connection maintenance.
+
+    `ConnectionPool#try_to_queue_for_background_connection` waited up to a
+    hardcoded 100 seconds for a connection tied up in maintenance (e.g. a keepalive
+    ping), regardless of the pool's configured `checkout_timeout`. If maintenance
+    stalled (a slow or unresponsive database server), checkout could block for far
+    longer than the caller asked for.
+
+    *Joe Sak*
+
+*   Fix encrypted fixtures for JSON columns.
+
+    Encrypted fixture values were serialized twice: once by the encrypted
+    attribute type and again by the column type when the rows were inserted.
+    For `json`/`jsonb` columns this stored the encrypted payload as a JSON
+    string, which then failed to decrypt. The payload is now handed back in
+    the column's cast form so it round-trips through the column type.
+
+    *Carlos Daniel Pohlod*
+
+*   Fix performance regression in `method_missing` for virtual SELECT alias
+    attributes.
+
+    Fixes #57183.
+
+    *Hammad Khan*
+
+*   Column defaults are no longer eagerly deserialized.
+
+    Restore the Active Record 8.0 and older behavior.
+    Column defaults are now whatever is returned by the database, generally a string.
+
+    This was changed in 8.1.0 to make the attribute API more consistent,
+    however it caused problems when the attribute type is later changed in the model.
+
+    Typically, some databases treat boolean columns as small integers, ance once the
+    default integer is casted to a boolean, it's not longer possible to change the
+    attribute back into an integer in the model.
+
+    Before:
 
     ```ruby
-    Post.joins(:comments).pluck(:id, comments: :id)
-    Post.joins(:comments).pluck("id", "comments" => "id")
+    Person.columns_hash["age"].default # => 0
     ```
 
+    After:
+
+    ```ruby
+    Person.columns_hash["age"].default # => "0"
+    ```
+
+    See https://github.com/rails/rails/issues/58292.
+
+    *Jean Boussier*
+
+*   Preserve the declared parent order when dumping PostgreSQL `INHERITS` table options.
+
+    The schema dumper read a table's inherited parents without an `ORDER BY`, so the
+    `INHERITS (...)` clause in `schema.rb` could be emitted in a nondeterministic order.
+    Parents are now ordered by `pg_inherits.inhseqno`.
+
+    *viralpraxis*
+
+*   Preserve SQLite partial and expression indexes when their stored SQL contains newlines.
+
+    *Javi Ramírez*
+
+*   Only use multi statement for `SET TRANSACTION ISOLATION LEVEL; BEGIN` if
+    MySQL connection is configured to use multi statement.
+
+    *Eliseu Daroit*, *Hartley McGuire*, *Matthew Draper*
+
+*   Mark a connection unverified when a non-`StandardError` interrupts a query.
+
+    A query interrupted by a non-`StandardError`, such as a fiber scheduler's
+    cancel or a `Timeout`, leaves the connection desynced. Active Record
+    previously returned it to the pool still marked verified, so the next
+    checkout reused it and failed on a dead socket. The connection is now
+    marked unverified, so it re-verifies and reconnects before its next use.
+
+    *Eliseu Daroit*
+
+*   Fix `has_many` and `has_one` associations on a new record returning an empty
+    result when the owner has a composite primary key, even when every primary
+    key column is populated.
+
+    *Jean-Samuel Aubry-Guzzi*
+
+*   Fix inverse association matching for `has_many` and `has_one` associations
+    with association-specific composite primary keys.
+
+    *Hugo Vacher*
+
+*   Fix `ActiveRecord::Base.with` to call `Object#with` when given a block.
+
+    The class-level `with` delegates to the relation's CTE query method, which
+    does not accept a block. When a block is passed, it now delegates to
+    `Object#with` instead, so it can be used to temporarily set attributes on
+    the class for the duration of the block.
+
+    *Janko Marohnić*
+
+*   Fix `serialize` with `coder: ActiveRecord::Coders::JSON` silently double-encoding
+    a native `json`/`jsonb` column.
+
+    *Kenta Ishizaki*
+
+*   Fix `update_all` / `delete_all` ignoring `group` and `having`, updating or
+    deleting every row in the table instead of only the rows that satisfy the
+    `HAVING` clause.
+
+    *Kenta Ishizaki*
+
+*   Fix `ActiveRecord::Relation#cache_key` / `cache_version` for a loaded collection
+    containing a record without a timestamp.
+
+    *Kenta Ishizaki*
+
+*   Fix model `filter_attributes` to not add useless filters into `config.filter_parameters`.
+
+    Proc and Regexp filters would be improperly turned into string matchers.
+    Now they are skipped.
+
+    *Jonathan Calvert*
+
+*   Fix `ActiveRecord::MessagePack` serialization raising `NoMethodError`
+    for any record with a populated `time` column, which made such records
+    uncacheable through the MessagePack cache serializer.
+
+    *Kenta Ishizaki*
+
+*   Fix replacing or clearing a polymorphic `has_one` leaving a stale type column
+    on the removed record.
+
+    *Kenta Ishizaki*
+
+*   Fix `accepts_nested_attributes_for` `:limit` miscounting a single-record hash.
+
+    *Kenta Ishizaki*
+
+*   Fix `rename_index` to preserve a partial index's `WHERE` for SQLite and older MySQL/MariaDB versions.
+
+    *Kenta Ishizaki*
+
+*   Fix PostgreSQL `foreign_keys` returning a corrupted `to_table` for a foreign key
+    that references a table in a quoted schema.
+
+    *Kenta Ishizaki*
+
+*   Fix grouped calculations (e.g. `count`) grouped by a `belongs_to` association
+    that points to a composite primary key model.
+
+    `Book.group(:order).count`, where `Book belongs_to :order` and `Order` has a
+    composite primary key, raised `ArgumentError: Expected corresponding value
+    for ["shop_id", "id"] to be an Array`. The grouped result is now keyed by the
+    associated records as it already is for single-column keys.
+
+    *Kenta Ishizaki*
+
+*   Fix `has_many`/`has_one :through` associations with `disable_joins: true`
+    silently returning an empty result when the source points to a composite
+    primary key model.
+
+    *Kenta Ishizaki*
+
+*   Fix collection association `ids=` writers (e.g. `author.book_ids=`) raising
+    `ActiveRecord::RecordNotFound` for existing records when a composite primary
+    key model is assigned string ids (the shape ids take from request params).
+
+    Each id component is now cast against its own column type, instead of casting
+    the whole tuple against an array of column names, which `type_for_attribute`
+    can't resolve to a real type (so the cast was a no-op and the string ids
+    never matched the loaded records).
+
+    *Kenta Ishizaki*
+
+*   Fix `find` with multiple composite primary key ids passed as strings
+    silently returning `[]`.
+
+    `Model.find([["1", "10"], ["1", "20"]])` (the shape ids take when they come
+    from request parameters) returned an empty array instead of the records and
+    without raising `RecordNotFound`. The ids were cast against the array of key
+    column names as a whole — which is a no-op — so the string tuples never
+    compared equal to the records' integer ids when ordering the result. Each
+    component is now cast against its own column type, matching the documented
+    coercion already performed for single-column keys.
+
+    *Kenta Ishizaki*
+
+*   Fix PostgreSQL `daterange` / `tsrange` / `tstzrange` schema dump producing
+    invalid Ruby.
+
+    The schema dumper used to render range defaults via `Range#inspect`, which
+    falls back to `Date#inspect` / `Time#inspect` for the bounds. The resulting
+    `schema.rb` literal (for example `default: Mon, 01 Jan 2024..Wed, 01 Jan 2025`)
+    raised a `SyntaxError` on `db:schema:load`. The bounds are now rendered via
+    the subtype's `type_cast_for_schema`, so date and timestamp range defaults
+    round-trip through `schema.rb` like any other column.
+
+    *Kenta Ishizaki*
+
+*   Fix deadlock when pool-less connection materializes while fetching database
+    server version.
+
+    *Hartley McGuire*
+
+*   Fix PostgreSQL range columns corrupting bounds that contain a comma.
+
+    `PostgreSQL::OID::Range#extract_bounds` split a range's textual
+    representation on the first comma, but PostgreSQL double-quotes any bound
+    that itself contains a comma (e.g. a range over a text subtype). A value
+    such as `["a,b","c,d")` was therefore split inside the first quoted bound
+    and read back with both endpoints corrupted. The split now skips over
+    double-quoted segments when locating the separating comma.
+
+    *Kenta Ishizaki*
+
+*   Fix store accessor `*_change` and `saved_change_to_*` reporting a change
+    for unchanged keys.
+
+    When one key of a `store` column changed, the generated `<key>_change` and
+    `saved_change_to_<key>` methods returned a `[value, value]` pair for the
+    column's *other* keys too, even though their matching `<key>_changed?` /
+    `saved_change_to_<key>?` correctly returned `false` and standard attribute
+    `_change` / `saved_change_to_*` methods return `nil` when unchanged. The
+    methods now return `nil` unless that specific key actually changed,
+    matching their predicate counterparts.
+
+    *Kenta Ishizaki*
+
+*   Reduce number of queries when introspecting MySQL/MariaDB tables.
+
+    A fix to support MariaDB function defaults caused the MySQL adapters to
+    issue one query per column when introspecting tables.
+
+    Now it only issue a single extra query per table, and only when using MariaDB.
+
+    *Iliana Hadzhiatanasova*
+
+*   Fully qualify query criterias in `has_and_belongs_to_many` associations.
+
+    Ensure that scopes with the same column name but in different tables aren't lost
+    when following an HABTM association.
+
+    *Philip Maina*
+
+*   Fix Active Record Pool Reaper thread leak after `Parallelization#shutdown`.
+
+    After parallelized test runs, the parent process leaked the Active Record Pool
+    Reaper thread, holding open connection pools and file descriptors for up to
+    `reaping_frequency` seconds (or indefinitely if never reaped).
+
+    Three fixes: `Parallelization#shutdown` now calls `run_cleanup_hooks`;
+    Active Record registers a cleanup hook that discards all connection pools; and
+    `ConnectionPool#discard!` now calls `Reaper.discard_pool`, which immediately
+    kills and joins the reaper thread when no pools remain at that frequency.
+
+    *Ruy Rocha*
+
+*   Fix duplicate `WHERE` conditions in `create_or_find_by`.
+
+    When `create_or_find_by` catches a `RecordNotUnique` error and retries the query, it now uses `rewhere` and `take!` to prevent duplicating existing scope conditions.
+
+    *Yavor Dashev*
+
+*   Fix `ActiveRecord::QueryMethods#in_order_of` when passing an out-of-range Integer
+
+    To match the behavior of the `Enumerable` version, `in_order_of` now ignores an out-of-range Integer.
+
+    *tejanium*
+
+*   Revert alphabetical sorting of table columns inside `schema.rb`.
+
+    Alphabetical sorting of table columns inside the schema creates improper production tables when using `db:prepare`.
+
+    *Bert McCutchen*
+
+*   Fix `strict_loading` violations ignored when using `pluck`
+
+    *Johnson Chan*
+
+*   Fix incorrect callback execution order when `config.active_record.run_after_transaction_callbacks_in_order_defined = true`
+    and using `after_commit` and `after_rollback` callbacks with `prepend: true`.
+
     *Joshua Young*
 
-*   Make Float distinguish between `float4` and `float8` in PostgreSQL.
+*   Fix `becomes` to preserve `marked_for_destruction?`.
 
-    Fixes #52742
+    *Vincent Robert*
 
-    *Ryota Kitazawa*, *Takayuki Nagatomi*
+*   MySQL error 1046 (`ER_NO_DB_ERROR: No database selected`) is now retryable as a `ConnectionFailed` exception
 
+    *Clay Harmon*
 
-## Rails 8.0.0.beta1 (September 26, 2024) ##
 
-*   Allow `drop_table` to accept an array of table names.
+## Rails 8.1.3.1 (July 29, 2026) ##
 
-    This will let you to drop multiple tables in a single call.
+*   No changes.
 
-    ```ruby
-    ActiveRecord::Base.lease_connection.drop_table(:users, :posts)
-    ```
+
+## Rails 8.1.3 (March 24, 2026) ##
+
+*   Fix `insert_all` and `upsert_all` log message when called on anonymous classes.
 
     *Gabriel Sobrinho*
 
-*   Add support for PostgreSQL `IF NOT EXISTS` via the `:if_not_exists` option
-    on the `add_enum_value` method.
+*   Respect `ActiveRecord::SchemaDumper.ignore_tables` when dumping SQLite virtual tables.
 
-    *Ariel Rzezak*
+    *Hans Schnedlitz*
 
-*   When running `db:migrate` on a fresh database, load the databases schemas before running migrations.
+*   Restore previous instrumenter after `execute_or_skip`
 
-    *Andrew Novoselac*, *Marek Kasztelnik*
+    `FutureResult#execute_or_skip` replaces the thread's instrumenter with an
+    `EventBuffer` to collect events published during async query execution.
+    If the global async executor is saturated and the `caller_runs` fallback
+    executes the task on the calling thread, we need to make sure the previous
+    instrumenter is restored or the stale `EventBuffer` would stay in place and
+    permanently swallow all subsequent `sql.active_record` notifications on
+    that thread.
 
-*   Fix an issue where `.left_outer_joins` used with multiple associations that have
-    the same child association but different parents does not join all parents.
+    *Rosa Gutierrez*
 
-    Previously, using `.left_outer_joins` with the same child association would only join one of the parents.
+*   Bump the minimum PostgreSQL version to 9.5, due to usage of `array_position` function.
 
-    Now it will correctly join both parents.
+    *Ivan Kuchin*
 
-    Fixes #41498.
+*   Fix Ruby 4.0 delegator warning when calling inspect on ActiveRecord::Type::Serialized.
 
-    *Garrett Blehm*
+    *Hammad Khan*
 
-*   Deprecate `unsigned_float` and `unsigned_decimal` short-hand column methods.
+*   Fix support for table names containing hyphens.
 
-    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.
+    *Evgeniy Demin*
 
-    https://dev.mysql.com/doc/refman/8.0/en/numeric-type-syntax.html
+*   Fix column deduplication for SQLite3 and PostgreSQL virtual (generated) columns.
 
-    *Ryuta Kamizono*
+    `Column#==` and `Column#hash` now account for `virtual?` so that the
+    `Deduplicable` registry does not treat a generated column and a regular
+    column with the same name and type as identical. Previously, if a
+    generated column was registered first, a regular column on a different
+    table could be deduplicated to the generated instance, silently
+    excluding it from INSERT/UPDATE statements.
 
-*   Drop MySQL 5.5 support.
+    *Jay Huber*
 
-    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.
+*   Fix PostgreSQL schema dumping to handle schema-qualified table names in foreign_key references that span different schemas.
 
-    *Ryuta Kamizono*
+        # before
+        add_foreign_key "hst.event_log_attributes", "hst.event_logs" # emits correctly because they're in the same schema (hst)
+        add_foreign_key "hst.event_log_attributes", "hst.usr.user_profiles", column: "created_by_id" # emits hst.user.* when user.* is expected
+
+        # after
+        add_foreign_key "hst.event_log_attributes", "hst.event_logs"
+        add_foreign_key "hst.event_log_attributes", "usr.user_profiles", column: "created_by_id"
+
+    *Chiperific*
+
+
+## Rails 8.1.2.1 (March 23, 2026) ##
+
+*   No changes.
+
+
+## Rails 8.1.2 (January 08, 2026) ##
+
+*   Fix counting cached queries in `ActiveRecord::RuntimeRegistry`.
 
-*   Make Active Record asynchronous queries compatible with transactional fixtures.
+    *fatkodima*
+
+*   Fix merging relations with arel equality predicates with null relations.
+
+    *fatkodima*
+
+*   Fix SQLite3 schema dump for non-autoincrement integer primary keys.
+
+    Previously, `schema.rb` should incorrectly restore that table with an auto incrementing
+    primary key.
+
+    *Chris Hasiński*
+
+*   Fix PostgreSQL `schema_search_path` not being reapplied after `reset!` or `reconnect!`.
+
+    The `schema_search_path` configured in `database.yml` is now correctly
+    reapplied instead of falling back to PostgreSQL defaults.
+
+    *Tobias Egli*
+
+*   Restore the ability of enum to be foats.
+
+    ```ruby
+    enum :rating, { low: 0.0, medium: 0.5, high: 1.0 },
+    ```
+
+    In Rails 8.1.0, enum values are eagerly validated, and floats weren't expected.
+
+    *Said Kaldybaev*
 
-    Previously transactional fixtures would disable asynchronous queries, because transactional
-    fixtures impose all queries use the same connection.
+*   Ensure batched preloaded associations accounts for klass when grouping to avoid issues with STI.
 
-    Now asynchronous queries will use the connection pinned by transactional fixtures, and behave
-    much closer to production.
+    *zzak*, *Stjepan Hadjic*
+
+*   Fix `ActiveRecord::SoleRecordExceeded#record` to return the relation.
+
+    This was the case until Rails 7.2, but starting from 8.0 it
+    started mistakenly returning the model class.
+
+    *Jean Boussier*
+
+*   Improve PostgreSQLAdapter resilience to Timeout.timeout.
+
+    Better handle asynchronous exceptions being thrown inside
+    the `reconnect!` method.
+
+    This may fixes some deep errors such as:
+
+    ```
+    undefined method `key?' for nil:NilClass (NoMethodError)
+              if !type_map.key?(oid)
+    ```
 
     *Jean Boussier*
 
-*   Deserialize binary data before decrypting
+*   Fix structured events for Active Record was not being emitted.
+
+    *Yuji Yaginuma*
+
+*   Fix `eager_load` when loading `has_many` assocations with composite primary keys.
 
-    This ensures that we call `PG::Connection.unescape_bytea` on PostgreSQL before decryption.
+    This would result in some records being loaded multiple times.
 
-    *Donal McBreen*
+    *Martin-Alexander*
 
-*   Ensure `ActiveRecord::Encryption.config` is always ready before access.
 
-    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.
+## Rails 8.1.1 (October 28, 2025) ##
 
-    `ActiveRecord::Encryption` now has its own loading hook so that its configuration is set as
-    soon as needed.
+*   No changes.
 
-    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`.
 
-    *Maxime Réty*
+## Rails 8.1.0 (October 22, 2025) ##
 
-*   Add `TimeZoneConverter#==` method, so objects will be properly compared by
-    their type, scale, limit & precision.
+*   Fix SQLite3 data loss during table alterations with CASCADE foreign keys.
 
-    Address #52699.
+    When altering a table in SQLite3 that is referenced by child tables with
+    `ON DELETE CASCADE` foreign keys, ActiveRecord would silently delete all
+    data from the child tables. This occurred because SQLite requires table
+    recreation for schema changes, and during this process the original table
+    is temporarily dropped, triggering CASCADE deletes on child tables.
+
+    The root cause was incorrect ordering of operations. The original code
+    wrapped `disable_referential_integrity` inside a transaction, but
+    `PRAGMA foreign_keys` cannot be modified inside a transaction in SQLite -
+    attempting to do so simply has no effect. This meant foreign keys remained
+    enabled during table recreation, causing CASCADE deletes to fire.
+
+    The fix reverses the order to follow the official SQLite 12-step ALTER TABLE
+    procedure: `disable_referential_integrity` now wraps the transaction instead
+    of being wrapped by it. This ensures foreign keys are properly disabled
+    before the transaction starts and re-enabled after it commits, preventing
+    CASCADE deletes while maintaining data integrity through atomic transactions.
 
     *Ruy Rocha*
 
-*   Add support for SQLite3 full-text-search and other virtual tables.
+*   Add replicas to test database parallelization setup.
 
-    Previously, adding sqlite3 virtual tables messed up `schema.rb`.
+    Setup and configuration of databases for parallel testing now includes replicas.
 
-    Now, virtual tables can safely be added using `create_virtual_table`.
+    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}`.
 
-    *Zacharias Knudsen*
+    *Adam Maas*
 
-*   Support use of alternative database interfaces via the `database_cli` ActiveRecord configuration option.
+*   Support virtual (not persisted) generated columns on PostgreSQL 18+
+
+    PostgreSQL 18 introduces virtual (not persisted) generated columns,
+    which are now the default unless the `stored: true` option is explicitly specified on PostgreSQL 18+.
 
     ```ruby
-    Rails.application.configure do
-      config.active_record.database_cli = { postgresql: "pgcli" }
+    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
     ```
 
-    *T S Vallender*
+    *Yasuo Honda*
 
-*   Add support for dumping table inheritance and native partitioning table definitions for PostgeSQL adapter
+*   Optimize schema dumping to prevent duplicate file generation.
 
-    *Justin Talbott*
+    `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.
 
-*   Add support for `ActiveRecord::Point` type casts using `Hash` values
+    *Mikey Gough*, *Hartley McGuire*
 
-    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.
+*   Add structured events for Active Record:
+    - `active_record.strict_loading_violation`
+    - `active_record.sql`
 
+    *Gannon McGibbon*
+
+*   Add support for integer shard keys.
     ```ruby
-    class PostgresqlPoint < ActiveRecord::Base
-      attribute :x, :point
-      attribute :y, :point
-      attribute :z, :point
+    # 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
+    ```
 
-    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
+    *Nony Dutton*
+
+*   Add `ActiveRecord::Base.only_columns`
+
+    Similar in use case to `ignored_columns` but listing columns to consider rather than the ones
+    to ignore.
+
+    Can be useful when working with a legacy or shared database schema, or to make safe schema change
+    in two deploys rather than three.
+
+    *Anton Kandratski*
+
+*   Use `PG::Connection#close_prepared` (protocol level Close) to deallocate
+    prepared statements when available.
+
+    To enable its use, you must have pg >= 1.6.0, libpq >= 17, and a PostgreSQL
+    database version >= 17.
+
+    *Hartley McGuire*, *Andrew Jackson*
+
+*   Fix query cache for pinned connections in multi threaded transactional tests
+
+    When a pinned connection is used across separate threads, they now use a separate cache store
+    for each thread.
+
+    This improve accuracy of system tests, and any test using multiple threads.
+
+    *Heinrich Lee Yu*, *Jean Boussier*
+
+*   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.
+
+    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.
+
+    *Prateek Choudhary*
+
+*   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.
+
+    *Yasuo Honda*, *Lars Kanis*
+
+*   Don't add `id_value` attribute alias when attribute/column with that name already exists.
+
+    *Rob Lewis*
+
+*   Remove deprecated `:unsigned_float` and `:unsigned_decimal` column methods for MySQL.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `:retries` option for the SQLite3 adapter.
+
+    *Rafael Mendonça França*
+
+*   Introduce new database configuration options `keepalive`, `max_age`, and
+    `min_connections` -- and rename `pool` to `max_connections` to match.
+
+    There are no changes to default behavior, but these allow for more specific
+    control over pool behavior.
+
+    *Matthew Draper*, *Chris AtLee*, *Rachael Wright-Munn*
+
+*   Move `LIMIT` validation from query generation to when `limit()` is called.
+
+    *Hartley McGuire*, *Shuyang*
+
+*   Add `ActiveRecord::CheckViolation` error class for check constraint violations.
+
+    *Ryuta Kamizono*
+
+*   Add `ActiveRecord::ExclusionViolation` error class for exclusion constraint violations.
+
+    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.
+
+    This follows the same pattern as other constraint violation error classes like
+    `RecordNotUnique` for unique constraint violations and `InvalidForeignKey` for
+    foreign key constraint violations.
+
+    *Ryuta Kamizono*
+
+*   Attributes filtered by `filter_attributes` will now also be filtered by `filter_parameters`
+    so sensitive information is not leaked.
+
+    *Jill Klang*
+
+*   Add `connection.current_transaction.isolation` API to check current transaction's isolation level.
+
+    Returns the isolation level if it was explicitly set via the `isolation:` parameter
+    or through `ActiveRecord.with_transaction_isolation_level`, otherwise returns `nil`.
+    Nested transactions return the parent transaction's isolation level.
+
+    ```ruby
+    # Returns nil when no transaction
+    User.connection.current_transaction.isolation # => nil
+
+    # Returns explicitly set isolation level
+    User.transaction(isolation: :serializable) do
+      User.connection.current_transaction.isolation # => :serializable
+    end
+
+    # Returns nil when isolation not explicitly set
+    User.transaction do
+      User.connection.current_transaction.isolation # => nil
+    end
+
+    # Nested transactions inherit parent's isolation
+    User.transaction(isolation: :read_committed) do
+      User.transaction do
+        User.connection.current_transaction.isolation # => :read_committed
+      end
+    end
     ```
 
-    *Stephen Drew*
+    *Kir Shatrov*
 
-*   Replace `SQLite3::Database#busy_timeout` with `#busy_handler_timeout=`.
+*   Fix `#merge` with `#or` or `#and` and a mixture of attributes and SQL strings resulting in an incorrect query.
 
-    Provides a non-GVL-blocking, fair retry interval busy handler implementation.
+    ```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
+    ```
 
-    *Stephen Margheim*
+    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
+    )
+    ```
 
-*   SQLite3Adapter: Translate `SQLite3::BusyException` into `ActiveRecord::StatementTimeout`.
+    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
+    )
+    ```
 
-    *Matthew Nguyen*
+    *Joshua Young*
 
-*   Include schema name in `enable_extension` statements in `db/schema.rb`.
+*   Make schema dumper to account for `ActiveRecord.dump_schemas` when dumping in `:ruby` format.
 
-    The schema dumper will now include the schema name in generated
-    `enable_extension` statements if they differ from the current schema.
+    *fatkodima*
 
-    For example, if you have a migration:
+*   Add `:touch` option to `update_column`/`update_columns` methods.
 
     ```ruby
-    enable_extension "heroku_ext.pgcrypto"
-    enable_extension "pg_stat_statements"
+    # Will update :updated_at/:updated_on alongside :nice column.
+    user.update_column(:nice, true, touch: true)
+
+    # Will update :updated_at/:updated_on alongside :last_ip column
+    user.update_columns(last_ip: request.remote_ip, touch: true)
     ```
 
-    then the generated schema dump will also contain:
+    *Dmitrii Ivliev*
+
+*   Optimize Active Record batching further when using ranges.
+
+    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`).
+
+    *Maxime Réty*, *fatkodima*
+
+*   Include current character length in error messages for index and table name length validations.
+
+    *Joshua Young*
+
+*   Add `rename_schema` method for PostgreSQL.
+
+    *T S Vallender*
+
+*   Implement support for deprecating associations:
 
     ```ruby
-    enable_extension "heroku_ext.pgcrypto"
-    enable_extension "pg_stat_statements"
+    has_many :posts, deprecated: true
     ```
 
-    *Tony Novak*
+    With that, Active Record will report any usage of the `posts` association.
 
-*   Fix `ActiveRecord::Encryption::EncryptedAttributeType#type` to return
-    actual cast type.
+    Three reporting modes are supported (`:warn`, `:raise`, and `:notify`), and
+    backtraces can be enabled or disabled. Defaults are `:warn` mode and
+    disabled backtraces.
 
-    *Vasiliy Ermolovich*
+    Please, check the docs for further details.
+
+    *Xavier Noria*
 
-*   SQLite3Adapter: Bulk insert fixtures.
+*   PostgreSQL adapter create DB now supports `locale_provider` and `locale`.
 
-    Previously one insert command was executed for each fixture, now they are
-    aggregated in a single bulk insert command.
+    *Bengt-Ove Hollaender*
 
-    *Lázaro Nixon*
+*   Use ntuples to populate row_count instead of count for Postgres
 
-*   PostgreSQLAdapter: Allow `disable_extension` to be called with schema-qualified name.
+    *Jonathan Calvert*
 
-    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"`.
+*   Fix checking whether an unpersisted record is `include?`d in a strictly
+    loaded `has_and_belongs_to_many` association.
 
-    *Tony Novak*
+    *Hartley McGuire*
 
-*   Make `create_schema` / `drop_schema` reversible in migrations.
+*   Add ability to change transaction isolation for all pools within a block.
 
-    Previously, `create_schema` and `drop_schema` were irreversible migration operations.
+    This functionality is useful if your application needs to change the database
+    transaction isolation for a request or action.
 
-    *Tony Novak*
+    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.
 
-*   Support batching using custom columns.
+    This works with explicit and implicit transactions:
 
     ```ruby
-    Product.in_batches(cursor: [:shop_id, :id]) do |relation|
-      # do something with relation
+    ActiveRecord.with_transaction_isolation_level(:read_committed) do
+      Tag.transaction do # opens a transaction explicitly
+        Tag.create!
+      end
     end
     ```
 
-    *fatkodima*
+    ```ruby
+    ActiveRecord.with_transaction_isolation_level(:read_committed) do
+      Tag.create! # opens a transaction implicitly
+    end
+    ```
+
+    *Eileen M. Uchitelle*
 
-*   Use SQLite `IMMEDIATE` transactions when possible.
+*   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.
 
-    Transactions run against the SQLite3 adapter default to IMMEDIATE mode to improve concurrency support and avoid busy exceptions.
+    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.
 
-    *Stephen Margheim*
+    ```ruby
+    config.active_record.raise_on_missing_required_finder_order_columns = true
+    ```
 
-*   Raise specific exception when a connection is not defined.
+    *Joshua Young*
 
-    The new `ConnectionNotDefined` exception provides connection name, shard and role accessors indicating the details of the connection that was requested.
+*   `:class_name` is now invalid in polymorphic `belongs_to` associations.
 
-    *Hana Harencarova*, *Matthew Draper*
+    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.
 
-*   Delete the deprecated constant `ActiveRecord::ImmutableRelation`.
+    Existing polymorphic associations setting this option can just delete it.
+    While it did not raise, it had no effect anyway.
 
     *Xavier Noria*
 
-*   Fix duplicate callback execution when child autosaves parent with `has_one` and `belongs_to`.
+*   Add support for multiple databases to `db:migrate:reset`.
 
-    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.
+    *Joé Dupuis*
 
-    Now, these callbacks are only executed once as expected.
+*   Add `affected_rows` to `ActiveRecord::Result`.
 
-    *Joshua Young*
+    *Jenny Shen*
 
-*   `ActiveRecord::Encryption::Encryptor` now supports a `:compressor` option to customize the compression algorithm used.
+*   Enable passing retryable SqlLiterals to `#where`.
 
-    ```ruby
-    module ZstdCompressor
-      def self.deflate(data)
-        Zstd.compress(data)
-      end
+    *Hartley McGuire*
 
-      def self.inflate(data)
-        Zstd.decompress(data)
-      end
+*   Set default for primary keys in `insert_all`/`upsert_all`.
+
+    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.
+
+    *Jenny Shen*
+
+*   Add a load hook `active_record_database_configurations` for `ActiveRecord::DatabaseConfigurations`
+
+    *Mike Dalessio*
+
+*   Use `TRUE` and `FALSE` for SQLite queries with boolean columns.
+
+    *Hartley McGuire*
+
+*   Bump minimum supported SQLite to 3.23.0.
+
+    *Hartley McGuire*
+
+*   Allow allocated Active Records to lookup associations.
+
+    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.
+
+    *Gannon McGibbon*
+
+*   Encryption now supports `support_unencrypted_data: true` being set per-attribute.
+
+    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
+    # 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
+    ```
 
-    class User
-      encrypts :name, compressor: ZstdCompressor
+    ```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
     ```
 
-    You disable compression by passing `compress: false`.
+    *Alex Ghiculescu*
+
+*   Model generator no longer needs a database connection to validate column types.
+
+    *Mike Dalessio*
+
+*   Allow signed ID verifiers to be configurable via `Rails.application.message_verifiers`
+
+    Prior to this change, the primary way to configure signed ID verifiers was
+    to set `signed_id_verifier` on each model class:
+
+      ```ruby
+      Post.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      Comment.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      ```
+
+    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:
+
+      ```ruby
+      { digest: "SHA256", serializer: JSON, url_safe: true }
+      ```
+
+    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.
+
+    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:
+
+      ```ruby
+      # BEFORE
+      Post.signed_id_verifier_secret = "my secret"
+
+      # AFTER
+      Post.signed_id_verifier = ActiveSupport::MessageVerifier.new("my secret", digest: "SHA256", serializer: JSON, url_safe: true)
+      ```
+
+    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_:
+
+      ```ruby
+      # BEFORE
+      ActiveRecord::Base.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      Post.signed_id_verifier == ActiveRecord::Base.signed_id_verifier # => false
+
+      # AFTER
+      ActiveRecord::Base.signed_id_verifier = ActiveSupport::MessageVerifier.new(...)
+      Post.signed_id_verifier == ActiveRecord::Base.signed_id_verifier # => true
+
+      Post.signed_id_verifier_secret = "my secret" # => deprecation warning
+      Post.signed_id_verifier == ActiveRecord::Base.signed_id_verifier # => false
+      ```
+
+    Note, however, that it is recommended to eventually migrate from
+    model-specific verifiers to a unified configuration managed by
+    `Rails.application.message_verifiers`. `ActiveSupport::MessageVerifier#rotate`
+    can facilitate that transition. For example:
+
+      ```ruby
+      # BEFORE
+      # Generate and verify signed Post IDs using Post-specific configuration
+      Post.signed_id_verifier = ActiveSupport::MessageVerifier.new("post secret", ...)
+
+      # 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", ...)
+      ```
+
+    [`config.active_record.use_legacy_signed_id_verifier`]: https://guides.rubyonrails.org/v8.1/configuring.html#config-active-record-use-legacy-signed-id-verifier
+
+    *Ali Sepehri*, *Jonathan Hefner*
+
+*   Prepend `extra_flags` in postgres' `structure_load`
+
+    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.
+
+    *Alice Loeser*
+
+*   Allow bypassing primary key/constraint addition in `implicit_order_column`
+
+    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.
+
+    *Issy Long*
+
+*   Allow setting the `schema_format` via database configuration.
+
+    ```
+    primary:
+      schema_format: ruby
+    ```
+
+    Useful for multi-database setups when apps require different formats per-database.
+
+    *T S Vallender*
+
+*   Support disabling indexes for MySQL v8.0.0+ and MariaDB v10.6.0+
+
+    MySQL 8.0.0 added an option to disable indexes from being used by the query
+    optimizer by making them "invisible". This allows the index to still be maintained
+    and updated but no queries will be permitted to use it. This can be useful for adding
+    new invisible indexes or making existing indexes invisible before dropping them
+    to ensure queries are not negatively affected.
+    See https://dev.mysql.com/blog-archive/mysql-8-0-invisible-indexes/ for more details.
+
+    MariaDB 10.6.0 also added support for this feature by allowing indexes to be "ignored"
+    in queries. See https://mariadb.com/kb/en/ignored-indexes/ for more details.
+
+    Active Record now supports this option for MySQL 8.0.0+ and MariaDB 10.6.0+ for
+    index creation and alteration where the new index option `enabled: true/false` can be
+    passed to column and index methods as below:
 
     ```ruby
-    class User
-      encrypts :name, compress: false
+    add_index :users, :email, enabled: false
+    enable_index :users, :email
+    add_column :users, :dob, :string, index: { enabled: false }
+
+    change_table :users do |t|
+      t.index :name, enabled: false
+      t.index :dob
+      t.disable_index :dob
+      t.column :username, :string, index: { enabled: false }
+      t.references :account, index: { enabled: false }
+    end
+
+    create_table :users do |t|
+      t.string :name, index: { enabled: false }
+      t.string :email
+      t.index :email, enabled: false
     end
     ```
 
-    *heka1024*
+    *Merve Taner*
+
+*   Respect `implicit_order_column` in `ActiveRecord::Relation#reverse_order`.
+
+    *Joshua Young*
+
+*   Add column types to `ActiveRecord::Result` for SQLite3.
+
+    *Andrew Kane*
+
+*   Raise `ActiveRecord::ReadOnlyError` when pessimistically locking with a readonly role.
+
+    *Joshua Young*
+
+*   Fix using the `SQLite3Adapter`'s `dbconsole` method outside of a Rails application.
+
+    *Hartley McGuire*
+
+*   Fix migrating multiple databases with `ActiveRecord::PendingMigration` action.
+
+    *Gannon McGibbon*
+
+*   Enable automatically retrying idempotent association queries on connection
+    errors.
+
+    *Hartley McGuire*
+
+*   Add `allow_retry` to `sql.active_record` instrumentation.
 
-*   Add condensed `#inspect` for `ConnectionPool`, `AbstractAdapter`, and
-    `DatabaseConfig`.
+    This enables identifying queries which queries are automatically retryable on connection errors.
 
     *Hartley McGuire*
 
-*   Add `.shard_keys`, `.sharded?`, & `.connected_to_all_shards` methods.
+*   Better support UPDATE with JOIN for Postgresql and SQLite3
+
+    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 ShardedBase < ActiveRecord::Base
-        self.abstract_class = true
+    Comment.joins(:post).update_all("title = posts.title")
+    ```
 
-        connects_to shards: {
-          shard_one: { writing: :shard_one },
-          shard_two: { writing: :shard_two }
-        }
-    end
+    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*
+
+*   Introduce a before-fork hook in `ActiveSupport::Testing::Parallelization` to clear existing
+    connections, to avoid fork-safety issues with the mysql2 adapter.
 
-    class ShardedModel < ShardedBase
+    Fixes #41776
+
+    *Mike Dalessio*, *Donal McBreen*
+
+*   PoolConfig no longer keeps a reference to the connection class.
+
+    Keeping a reference to the class caused subtle issues when combined with reloading in
+    development. Fixes #54343.
+
+    *Mike Dalessio*
+
+*   Fix SQL notifications sometimes not sent when using async queries.
+
+    ```ruby
+    Post.async_count
+    ActiveSupport::Notifications.subscribed(->(*) { "Will never reach here" }) do
+      Post.count
     end
+    ```
+
+    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.
+
+    *Edouard Chin*
+
+*   Eliminate queries loading dumped schema cache on Postgres
 
-    ShardedModel.shard_keys => [:shard_one, :shard_two]
-    ShardedModel.sharded? => true
-    ShardedBase.connected_to_all_shards { ShardedModel.current_shard } => [:shard_one, :shard_two]
+    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.
+
+    *James Coleman*
+
+*   `ActiveRecord::Coder::JSON` can be instantiated
+
+    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*
 
-    *Nony Dutton*
+*   Deprecate using `insert_all`/`upsert_all` with unpersisted records in associations.
+
+    Using these methods on associations containing unpersisted records will now
+    show a deprecation warning, as the unpersisted records will be lost after
+    the operation.
 
-*   Add a `filter` option to `in_order_of` to prioritize certain values in the sorting without filtering the results
-    by these values.
+    *Nick Schwaderer*
 
-    *Igor Depolli*
+*   Make column name optional for `index_exists?`.
 
-*   Fix an issue where the IDs reader method did not return expected results
-    for preloaded associations in models using composite primary keys.
+    This aligns well with `remove_index` signature as well, where
+    index name doesn't need to be derived from the column names.
 
-    *Jay Ang*
+    *Ali Ismayiliov*
 
-*   Allow to configure `strict_loading_mode` globally or within a model.
+*   Change the payload name of `sql.active_record` notification for eager
+    loading from "SQL" to "#{model.name} Eager Load".
 
-    Defaults to `:all`, can be changed to `:n_plus_one_only`.
+    *zzak*
 
-    *Garen Torikian*
+*   Enable automatically retrying idempotent `#exists?` queries on connection
+    errors.
 
-*   Add `ActiveRecord::Relation#readonly?`.
+    *Hartley McGuire*, *classidied*
 
-    Reflects if the relation has been marked as readonly.
+*   Deprecate usage of unsupported methods in conjunction with `update_all`:
 
-    *Theodor Tonum*
+    `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.
 
-*   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`.
+    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.
 
-    Previously, a `NoMethodError` would be raised when the accessor was read or written:
+    *Edouard Chin*
 
-        NoMethodError: undefined method `accessor' for an instance of ActiveRecord::Type::Text
+*   The table columns inside `schema.rb` are now sorted alphabetically.
 
-    Now, a descriptive `ConfigurationError` is raised:
+    Previously they'd be sorted by creation order, which can cause merge conflicts when two
+    branches modify the same table concurrently.
 
-        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.
+    *John Duff*
 
-    *Mike Dalessio*
+*   Introduce versions formatter for the schema dumper.
+
+    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 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.
+
+    *fatkodima*
 
-*   Fix inference of association model on nested models with the same demodularized name.
+*   Serialized attributes can now be marked as comparable.
 
-    E.g. with the following setup:
+    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.
+
+    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 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
-    class Nested::Post < ApplicationRecord
-      has_one :post, through: :other
-    end
+    serialize :config, type: Hash, coder: JSON, comparable: true
     ```
 
-    Before, `#post` would infer the model as `Nested::Post`, but now it correctly infers `Post`.
+    *Jean Boussier*
+
+*   Fix MySQL default functions getting dropped when changing a column's nullability.
 
-    *Joshua Young*
+    *Bastian Bartmann*
+
+*   SQLite extensions can be configured in `config/database.yml`.
+
+    The database configuration option `extensions:` allows an application to load SQLite extensions
+    when using `sqlite3` >= v2.4.0. The array members may be filesystem paths or the names of
+    modules that respond to `.to_path`:
+
+    ``` yaml
+    development:
+      adapter: sqlite3
+      extensions:
+        - SQLean::UUID                     # module name responding to `.to_path`
+        - .sqlpkg/nalgeon/crypto/crypto.so # or a filesystem path
+        - <%= AppExtensions.location %>    # or ruby code returning a path
+    ```
+
+    *Mike Dalessio*
+
+*   `ActiveRecord::Middleware::ShardSelector` supports granular database connection switching.
+
+    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`:
+
+    ```
+    config.active_record.shard_selector = { class_name: "AnimalsRecord" }
+    ```
+
+    *Mike Dalessio*
+
+*   Reset relations after `insert_all`/`upsert_all`.
+
+    Bulk insert/upsert methods will now call `reset` if used on a relation, matching the behavior of `update_all`.
+
+    *Milo Winningham*
+
+*   Use `_N` as a parallel tests databases suffixes
 
-*   Add public method for checking if a table is ignored by the schema cache.
+    Peviously, `-N` was used as a suffix. This can cause problems for RDBMSes
+    which do not support dashes in database names.
 
-    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.
+    *fatkodima*
+
+*   Remember when a database connection has recently been verified (for
+    two seconds, by default), to avoid repeated reverifications during a
+    single request.
+
+    This should recreate a similar rate of verification as in Rails 7.1,
+    where connections are leased for the duration of a request, and thus
+    only verified once.
+
+    *Matthew Draper*
+
+*   Allow to reset cache counters for multiple records.
+
+    ```
+    Aircraft.reset_counters([1, 2, 3], :wheels_count)
+    ```
+
+    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.
+
+    *fatkodima*
+
+*   Add `affected_rows` to `sql.active_record` Notification.
+
+    *Hartley McGuire*
+
+*   Fix `sum` when performing a grouped calculation.
+
+    `User.group(:friendly).sum` no longer worked. This is fixed.
+
+    *Edouard Chin*
+
+*   Add support for enabling or disabling transactional tests per database.
+
+    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
-    ActiveRecord.schema_cache_ignored_tables = ["developers"]
-    ActiveRecord.schema_cache_ignored_table?("developers")
-    => true
+    class MostlyTransactionalTest < ActiveSupport::TestCase
+      self.use_transactional_tests = true
+      skip_transactional_tests_for_database :shared
+    end
     ```
 
-    *Eileen M. Uchitelle*
+    *Matthew Cheetham*, *Morgan Mareve*
+
+*   Cast `query_cache` value when using URL configuration.
+
+    *zzak*
+
+*   NULLS NOT DISTINCT works with UNIQUE CONSTRAINT as well as UNIQUE INDEX.
+
+    *Ryuta Kamizono*
+
+*   `PG::UnableToSend: no connection to the server` is now retryable as a connection-related exception
+
+    *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.