activerecord 7.0.8.7 → 7.2.3

data/CHANGELOG.md

@@ -1,2411 +1,1415 @@
-## Rails 7.0.8.7 (December 10, 2024) ##
-
-*   No changes.
+## Rails 7.2.3 (October 28, 2025) ##
 
+*   Fix SQLite3 data loss during table alterations with CASCADE foreign keys.
 
-## Rails 7.0.8.6 (October 23, 2024) ##
+    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.
 
-*   No changes.
+    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.
 
-## Rails 7.0.8.5 (October 15, 2024) ##
+    *Ruy Rocha*
 
-*   No changes.
+*   Fix `belongs_to` associations not to clear the entire composite primary key.
 
+    When clearing a `belongs_to` association that references a model with composite primary key,
+    only the optional part of the key should be cleared.
 
-## Rails 7.0.8.4 (June 04, 2024) ##
+    *zzak*
 
-*   No changes.
+*   Fix invalid records being autosaved when distantly associated records are marked for deletion.
 
+    *Ian Terrell*, *axlekb AB*
 
-## Rails 7.0.8.3 (May 17, 2024) ##
+*   Prevent persisting invalid record.
 
-*   No changes.
+    *Edouard Chin*
 
+*   Fix count with group by qualified name on loaded relation.
 
-## Rails 7.0.8.2 (May 16, 2024) ##
+    *Ryuta Kamizono*
 
-*   No changes.
+*   Fix `sum` with qualified name on loaded relation.
 
+    *Chris Gunther*
 
-## Rails 7.0.8.1 (February 21, 2024) ##
+*   Fix prepared statements on mysql2 adapter.
 
-*   No changes.
+    *Jean Boussier*
 
+*   Fix query cache for pinned connections in multi threaded transactional tests.
 
-## Rails 7.0.8 (September 09, 2023) ##
+    When a pinned connection is used across separate threads, they now use a separate cache store
+    for each thread.
 
-*   Fix `change_column` not setting `precision: 6` on `datetime` columns when
-    using 7.0+ Migrations and SQLite.
+    This improve accuracy of system tests, and any test using multiple threads.
 
-    *Hartley McGuire*
+    *Heinrich Lee Yu*, *Jean Boussier*
 
-*   Fix unscope is not working in specific case
+*   Don't add `id_value` attribute alias when attribute/column with that name already exists.
 
-    Before:
-    ```ruby
-    Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts` WHERE `posts`.`id` >= 1 AND `posts`.`id` < 3"
+    *Rob Lewis*
 
-    ```
+*   Fix false positive change detection involving STI and polymorhic has one relationships.
 
-    After:
-    ```ruby
-    Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts`"
-    ```
+    Polymorphic `has_one` relationships would always be considered changed when defined in a STI child
+    class, causing nedless extra autosaves.
 
-    Fixes #48094.
+    *David Fritsch*
 
-    *Kazuya Hatanaka*
+*   Fix stale associaton detection for polymophic `belong_to`.
 
-*   Fix associations to a STI model including a `class_name` parameter
+    *Florent Beaurain*, *Thomas Crambert*
 
-    ```ruby
-    class Product < ApplicationRecord
-      has_many :requests, as: :requestable, class_name: "ProductRequest", dependent: :destroy
-    end
+*   Fix removal of PostgreSQL version comments in `structure.sql` for latest PostgreSQL versions which include `\restrict`.
 
-    # STI tables
-    class Request < ApplicationRecord
-      belongs_to :requestable, polymorphic: true
+    *Brendan Weibrecht*
 
-      validate :request_type, presence: true
-    end
+*   Fix `#merge` with `#or` or `#and` and a mixture of attributes and SQL strings resulting in an incorrect query.
 
-    class ProductRequest < Request
-      belongs_to :user
-    end
+    ```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
     ```
 
-    Accessing such association would lead to:
+    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
+    )
     ```
-    table_metadata.rb:22:in `has_column?': undefined method `key?' for nil:NilClass (NoMethodError)
-    ```
-
-    *Romain Filinto*
-
-*   Fix `change_table` setting datetime precision for 6.1 Migrations
-
-    *Hartley McGuire*
-
-*   Fix change_column setting datetime precision for 6.1 Migrations
-
-    *Hartley McGuire*
-
-## Rails 7.0.7.2 (August 22, 2023) ##
-
-*   No changes.
 
+    After:
 
-## Rails 7.0.7.1 (August 22, 2023) ##
-
-*   No changes.
+    ```SQL
+    SELECT "comments".* FROM "comments"
+    INNER JOIN "posts" ON "posts"."id" = "comments"."post_id"
+    WHERE "comments"."user_id" = 1
+    AND (recent = 1)
+    AND (
+      "comments"."user_id" = 1
+      AND (recent = 1)
+      AND "comments"."draft" = 1
+      OR "posts"."archived" = 1
+    )
+    ```
 
+    *Joshua Young*
 
-## Rails 7.0.7 (August 09, 2023) ##
+*   Fix inline `has_and_belongs_to_many` fixtures for tables with composite primary keys.
 
-*   Restores functionality to the missing method when using enums and fixes.
+    *fatkodima*
 
-    *paulreece*
+*   Fix `annotate` comments to propagate to `update_all`/`delete_all`.
 
-*   Fix `StatementCache::Substitute` with serialized type.
+    *fatkodima*
 
-    *ywenc*
+*   Fix checking whether an unpersisted record is `include?`d in a strictly
+    loaded `has_and_belongs_to_many` association.
 
-*   Fix `:db_runtime` on notification payload when application have multiple databases.
+    *Hartley McGuire*
 
-    *Eileen M. Uchitelle*
+*   Fix inline has_and_belongs_to_many fixtures for tables with composite primary keys.
 
-*   Correctly dump check constraints for MySQL 8.0.16+.
+    *fatkodima*
 
-    *Steve Hill*
+*   `create_or_find_by` will now correctly rollback a transaction.
 
-*   Fix `ActiveRecord::QueryMethods#in_order_of` to include `nil`s, to match the
-    behavior of `Enumerable#in_order_of`.
+    When using `create_or_find_by`, raising a ActiveRecord::Rollback error
+    in a `after_save` callback had no effect, the transaction was committed
+    and a record created.
 
-    For example, `Post.in_order_of(:title, [nil, "foo"])` will now include posts
-    with `nil` titles, the same as `Post.all.to_a.in_order_of(:title, [nil, "foo"])`.
+    *Edouard Chin*
 
-    *fatkodima*
+*   Gracefully handle `Timeout.timeout` firing during connection configuration.
 
-*   Revert "Fix autosave associations with validations added on `:base` of the associated objects."
+    Use of `Timeout.timeout` could result in improperly initialized database connection.
 
-    This change intended to remove the :base attribute from the message,
-    but broke many assumptions which key these errors were stored.
+    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)`.
 
-    *zzak*
+    *Jean Boussier*
 
-*   Fix `#previously_new_record?` to return true for destroyed records.
+*   The SQLite3 adapter quotes non-finite Numeric values like "Infinity" and "NaN".
 
-    Before, if a record was created and then destroyed, `#previously_new_record?` would return true.
-    Now, any UPDATE or DELETE to a record is considered a change, and will result in `#previously_new_record?`
-    returning false.
+    *Mike Dalessio*
 
-    *Adrianna Chang*
+*   Handle libpq returning a database version of 0 on no/bad connection in `PostgreSQLAdapter`.
 
-*   Revert breaking changes to `has_one` relationship deleting the old record before the new one is validated.
+    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.
 
-    *zzak*
+    Now, this is treated as a connection failure consistent with libpq, raising a `ActiveRecord::ConnectionFailed`
+    and ensuring the version isn't cached, which allows the version to be retrieved on the next connection attempt.
 
-*   Fix support for Active Record instances being uses in queries.
+    *Joshua Young*, *Rian McGuire*
 
-    As of `7.0.5`, query arguments were deep duped to avoid mutations impacting
-    the query cache, but this had the adverse effect to clearing the primary key when
-    the query argument contained an `ActiveRecord::Base` instance.
+*   Fix error handling during connection configuration.
 
-    This broke the `noticed` gem.
+    Active Record wasn't properly handling errors during the connection configuration phase.
+    This could lead to a partially configured connection being used, resulting in various exceptions,
+    the most common being with the PostgreSQLAdapter raising `undefined method `key?' for nil`
+    or `TypeError: wrong argument type nil (expected PG::TypeMap)`.
 
     *Jean Boussier*
 
+*   Fix a case where a non-retryable query could be marked retryable.
 
-## Rails 7.0.6 (June 29, 2023) ##
+    *Hartley McGuire*
 
-*   Fix autosave associations with validations added on `:base` of the associated objects.
+*   Handle circular references when autosaving associations.
 
-    *fatkodima*
+    *zzak*
 
-*   Fix result with anonymous PostgreSQL columns of different type from json.
+*   Prevent persisting invalid record.
 
-    *Oleksandr Avoiants*
+    *Edouard Chin*
 
-*   Preserve timestamp when setting an `ActiveSupport::TimeWithZone` value to `timestamptz` attribute.
+*   Fix support for PostgreSQL enum types with commas in their name.
 
-    *fatkodima*
+    *Arthur Hess*
 
-*   Fix assignment into an `has_one` relationship deleting the old record before the new one is validated.
+*   Fix inserts on MySQL with no RETURNING support for a table with multiple auto populated columns.
 
-    *Jean Boussier*
+    *Nikita Vasilevsky*
 
-*   Fix where on association with has_one/has_many polymorphic relations.
+*   Fix joining on a scoped association with string joins and bind parameters.
 
-    Before:
     ```ruby
-    Treasure.where(price_estimates: PriceEstimate.all)
-    #=> SELECT (...) WHERE "treasures"."id" IN (SELECT "price_estimates"."estimate_of_id" FROM "price_estimates")
-    ```
+    class Instructor < ActiveRecord::Base
+      has_many :instructor_roles, -> { active }
+    end
 
-    Later:
-    ```ruby
-    Treasure.where(price_estimates: PriceEstimate.all)
-    #=> SELECT (...) WHERE "treasures"."id" IN (SELECT "price_estimates"."estimate_of_id" FROM "price_estimates" WHERE "price_estimates"."estimate_of_type" = 'Treasure')
-    ```
+    class InstructorRole < ActiveRecord::Base
+      scope :active, -> {
+        joins("JOIN students ON instructor_roles.student_id = students.id")
+        .where(students { status: 1 })
+      }
+    end
 
-    *Lázaro Nixon*
+    Instructor.joins(:instructor_roles).first
+    ```
 
-*   Fix decrementing counter caches on optimistically locked record deletion
+    The above example would result in `ActiveRecord::StatementInvalid` because the
+    `active` scope bind parameters would be lost.
 
-    *fatkodima*
+    *Jean Boussier*
 
-*   Ensure binary-destined values have binary encoding during type cast.
+*   Fix a potential race condition with system tests and transactional fixtures.
 
-    *Matthew Draper*
+    *Sjoerd Lagarde*
 
-*   Preserve existing column default functions when altering table in SQLite.
+*   Fix count with group by qualified name on loaded relation.
 
-    *fatkodima*
+    *Ryuta Kamizono*
 
-*   Remove table alias added when using `where.missing` or `where.associated`.
+*   Fix sum with qualified name on loaded relation.
 
-    *fatkodima*
+    *Chris Gunther*
 
-*   Fix `Enumerable#in_order_of` to only flatten first level to preserve nesting.
+*   Fix autosave associations to no longer validated unmodified associated records.
 
-    *Miha Rekar*
+    Active Record was incorrectly performing validation on associated record that
+    weren't created nor modified as part of the transaction:
 
+    ```ruby
+    Post.create!(author: User.find(1)) # Fail if user is invalid
+    ```
 
-## Rails 7.0.5.1 (June 26, 2023) ##
+    *Jean Boussier*
 
-*   No changes.
+*   Remember when a database connection has recently been verified (for
+    two seconds, by default), to avoid repeated reverifications during a
+    single request.
 
-## Rails 7.0.5 (May 24, 2023) ##
+    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.
 
-*   Type cast `#attribute_changed?` `:from` and `:to` options.
+    *Matthew Draper*
 
-    *Andrew Novoselac*
+*   Fix prepared statements on mysql2 adapter.
 
-*   Fix `index_exists?` when column is an array.
+    *Jean Boussier*
 
-    *Eileen M. Uchitelle*
+*   Fix a race condition in `ActiveRecord::Base#method_missing` when lazily defining attributes.
 
-*   Handle `Date` objects for PostgreSQL `timestamptz` columns.
+    If multiple thread were concurrently triggering attribute definition on the same model,
+    it could result in a `NoMethodError` being raised.
 
-    *Alex Ghiculescu*
+    *Jean Boussier*
 
-*   Fix collation for changing column to non-string.
+*   Fix MySQL default functions getting dropped when changing a column's nullability.
 
-    *Hartley McGuire*
+    *Bastian Bartmann*
 
-*   Map through subtype in `PostgreSQL::OID::Array`.
+*   Fix `add_unique_constraint`/`add_check_constraint`/`/`add_foreign_key` to be revertible when
+    given invalid options.
 
-    *Jonathan Hefner*
+    *fatkodima*
 
-*   Store correct environment in `internal_metadata` when run rails `db:prepare`.
+*   Fix asynchronous destroying of polymorphic `belongs_to` associations.
 
     *fatkodima*
 
-*   Make sure `ActiveRecord::Relation#sum` works with objects that implement `#coerce` without deprecation.
+*   NOT VALID constraints should not dump in `create_table`.
 
-    *Alex Ghiculescu*
+    *Ryuta Kamizono*
 
-*   Fix retrieving foreign keys referencing tables named like keywords in PostgreSQL and MySQL.
+*   Fix finding by nil composite primary key association.
 
     *fatkodima*
 
-*   Support UUIDs in Disable Joins.
+*   Fix parsing of SQLite foreign key names when they contain non-ASCII characters
 
-    *Samuel Cochran*
+    *Zacharias Knudsen*
 
-*   Fix Active Record's explain for queries starting with comments.
+*   Fix parsing of MySQL 8.0.16+ CHECK constraints when they contain new lines.
 
-    *fatkodima*
+    *Steve Hill*
 
-*   Fix incorrectly preloading through association records when middle association has been loaded.
+*   Ensure normalized attribute queries use `IS NULL` consistently for `nil` and normalized `nil` values.
 
     *Joshua Young*
 
-*   Fix where.missing and where.associated for parent/child associations.
+*   Restore back the ability to pass only database name for `DATABASE_URL`.
 
     *fatkodima*
 
-*   Fix Enumerable#in_order_of to preserve duplicates.
+*   Fix `order` with using association name as an alias.
 
-    *fatkodima*
+    *Ryuta Kamizono*
 
-*   Fix autoincrement on primary key for mysql.
+*   Improve invalid argument error for with.
 
-    *Eileen M. Uchitelle*
+    *Ryuta Kamizono*
 
-*   Restore ability to redefine column in `create_table` for Rails 5.2 migrations.
+*   Deduplicate `with` CTE expressions.
 
     *fatkodima*
 
-*   Fix schema cache dumping of virtual columns.
-
-    *fatkodima*
 
-*   Fix Active Record grouped calculations on joined tables on column present in both tables.
+## Rails 7.2.2.2 (August 13, 2025) ##
 
-    *fatkodima*
+*   Call inspect on ids in RecordNotFound error
 
-*   Fix mutation detection for serialized attributes backed by binary columns.
+    [CVE-2025-55193]
 
-    *Jean Boussier*
+    *Gannon McGibbon*, *John Hawthorn*
 
-*   Fix a bug where using groups and counts with long table names would return incorrect results.
 
-    *Shota Toguchi*, *Yusaku Ono*
+## Rails 7.2.2.1 (December 10, 2024) ##
 
-*   Fix erroneous nil default precision on virtual datetime columns.
+*   No changes.
 
-    Prior to this change, virtual datetime columns did not have the same
-    default precision as regular datetime columns, resulting in the following
-    being erroneously equivalent:
 
-        t.virtual :name, type: datetime,                 as: "expression"
-        t.virtual :name, type: datetime, precision: nil, as: "expression"
+## Rails 7.2.2 (October 30, 2024) ##
 
-    This change fixes the default precision lookup, so virtual and regular
-    datetime column default precisions match.
+*   Fix support for `query_cache: false` in `database.yml`.
 
-    *Sam Bostock*
+    `query_cache: false` would no longer entirely disable the Active Record query cache.
 
-*   Fix a case where the query cache can return wrong values. See #46044
+    *zzak*
 
-    *Aaron Patterson*
+*   Set `.attributes_for_inspect` to `:all` by default.
 
+    For new applications it is set to `[:id]` in config/environment/production.rb.
 
-## Rails 7.0.4.3 (March 13, 2023) ##
+    In the console all the attributes are always shown.
 
-*   No changes.
+    *Andrew Novoselac*
 
+*   `PG::UnableToSend: no connection to the server` is now retryable as a connection-related exception
 
-## Rails 7.0.4.2 (January 24, 2023) ##
+    *Kazuma Watanabe*
 
-*   No changes.
+*   Fix marshalling of unsaved associated records in 7.1 format.
 
+    The 7.1 format would only marshal associated records if the association was loaded.
+    But associations that would only contain unsaved records would be skipped.
 
-## Rails 7.0.4.1 (January 17, 2023) ##
+    *Jean Boussier*
 
-*   Make sanitize_as_sql_comment more strict
+*   Fix incorrect SQL query when passing an empty hash to `ActiveRecord::Base.insert`.
 
-    Though this method was likely never meant to take user input, it was
-    attempting sanitization. That sanitization could be bypassed with
-    carefully crafted input.
+    *David Stosik*
 
-    This commit makes the sanitization more robust by replacing any
-    occurrences of "/*" or "*/" with "/ *" or "* /". It also performs a
-    first pass to remove one surrounding comment to avoid compatibility
-    issues for users relying on the existing removal.
+*   Allow to save records with polymorphic join tables that have `inverse_of`
+    specified.
 
-    This also clarifies in the documentation of annotate that it should not
-    be provided user input.
+    *Markus Doits*
 
-    [CVE-2023-22794]
+*   Fix association scopes applying on the incorrect join when using a polymorphic `has_many through:`.
 
-*   Added integer width check to PostgreSQL::Quoting
+    *Joshua Young*
 
-    Given a value outside the range for a 64bit signed integer type
-    PostgreSQL will treat the column type as numeric. Comparing
-    integer values against numeric values can result in a slow
-    sequential scan.
+*   Fix `dependent: :destroy` for bi-directional has one through association.
 
-    This behavior is configurable via
-    ActiveRecord::Base.raise_int_wider_than_64bit which defaults to true.
+    Fixes #50948.
 
-    [CVE-2022-44566]
+    ```ruby
+    class Left < ActiveRecord::Base
+      has_one :middle, dependent: :destroy
+      has_one :right, through: :middle
+    end
 
+    class Middle < ActiveRecord::Base
+      belongs_to :left, dependent: :destroy
+      belongs_to :right, dependent: :destroy
+    end
 
-## Rails 7.0.4 (September 09, 2022) ##
+    class Right < ActiveRecord::Base
+      has_one :middle, dependent: :destroy
+      has_one :left, through: :middle
+    end
+    ```
+    In the above example `left.destroy` wouldn't destroy its associated `Right`
+    record.
 
-*   Symbol is allowed by default for YAML columns
+    *Andy Stewart*
 
-    *Étienne Barrié*
+*   Properly handle lazily pinned connection pools.
 
-*   Fix `ActiveRecord::Store` to serialize as a regular Hash
+    Fixes #53147.
 
-    Previously it would serialize as an `ActiveSupport::HashWithIndifferentAccess`
-    which is wasteful and cause problem with YAML safe_load.
+    When using transactional fixtures with system tests to similar tools
+    such as capybara, it could happen that a connection end up pinned by the
+    server thread rather than the test thread, causing
+    `"Cannot expire connection, it is owned by a different thread"` errors.
 
     *Jean Boussier*
 
-*   Add `timestamptz` as a time zone aware type for PostgreSQL
-
-    This is required for correctly parsing `timestamp with time zone` values in your database.
+*   Fix `ActiveRecord::Base.with` to accept more than two sub queries.
 
-    If you don't want this, you can opt out by adding this initializer:
+    Fixes #53110.
 
     ```ruby
-    ActiveRecord::Base.time_zone_aware_types -= [:timestamptz]
+    User.with(foo: [User.select(:id), User.select(:id), User.select(:id)]).to_sql
+    undefined method `union' for an instance of Arel::Nodes::UnionAll (NoMethodError)
     ```
 
-    *Alex Ghiculescu*
+    The above now works as expected.
 
-*   Fix supporting timezone awareness for `tsrange` and `tstzrange` array columns.
+    *fatkodima*
 
-    ```ruby
-    # In database migrations
-    add_column :shops, :open_hours, :tsrange, array: true
-    # In app config
-    ActiveRecord::Base.time_zone_aware_types += [:tsrange]
-    # In the code times are properly converted to app time zone
-    Shop.create!(open_hours: [Time.current..8.hour.from_now])
-    ```
+*   Properly release pinned connections with non joinable connections.
 
-    *Wojciech Wnętrzak*
+    Fixes #52973
 
-*   Resolve issue where a relation cache_version could be left stale.
+    When running system tests with transactional fixtures on, it could happen that
+    the connection leased by the Puma thread wouldn't be properly released back to the pool,
+    causing "Cannot expire connection, it is owned by a different thread" errors in later tests.
 
-    Previously, when `reset` was called on a relation object it did not reset the cache_versions
-    ivar. This led to a confusing situation where despite having the correct data the relation
-    still reported a stale cache_version.
+    *Jean Boussier*
 
-    Usage:
+*   Make Float distinguish between `float4` and `float8` in PostgreSQL.
 
-    ```ruby
-    developers = Developer.all
-    developers.cache_version
+    Fixes #52742
 
-    Developer.update_all(updated_at: Time.now.utc + 1.second)
+    *Ryota Kitazawa*, *Takayuki Nagatomi*
 
-    developers.cache_version # Stale cache_version
-    developers.reset
-    developers.cache_version # Returns the current correct cache_version
-    ```
+*   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.
 
-    Fixes #45341.
+    Previously, using `.left_outer_joins` with the same child association would only join one of the parents.
 
-    *Austen Madden*
+    Now it will correctly join both parents.
 
-*   Fix `load_async` when called on an association proxy.
+    Fixes #41498.
 
-    Calling `load_async` directly an association would schedule
-    a query but never use it.
+    *Garrett Blehm*
 
-    ```ruby
-    comments = post.comments.load_async # schedule a query
-    comments.to_a # perform an entirely new sync query
-    ```
+*   Ensure `ActiveRecord::Encryption.config` is always ready before access.
 
-    Now it does use the async query, however note that it doesn't
-    cause the association to be loaded.
+    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.
 
-    *Jean Boussier*
+    `ActiveRecord::Encryption` now has its own loading hook so that its configuration is set as
+    soon as needed.
 
-*   Fix eager loading for models without primary keys.
+    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`.
 
-    *Anmol Chopra*, *Matt Lawrence*, and *Jonathan Hefner*
+    *Maxime Réty*
 
-*   `rails db:schema:{dump,load}` now checks `ENV["SCHEMA_FORMAT"]` before config
+*   Add `TimeZoneConverter#==` method, so objects will be properly compared by
+    their type, scale, limit & precision.
 
-    Since `rails db:structure:{dump,load}` was deprecated there wasn't a simple
-    way to dump a schema to both SQL and Ruby formats. You can now do this with
-    an environment variable. For example:
+    Address #52699.
 
-    ```
-    SCHEMA_FORMAT=sql rake db:schema:dump
-    ```
+    *Ruy Rocha*
 
-    *Alex Ghiculescu*
 
-*   Fix Hstore deserialize regression.
+## Rails 7.2.1.2 (October 23, 2024) ##
 
-    *edsharp*
+*   No changes.
 
 
-## Rails 7.0.3.1 (July 12, 2022) ##
+## Rails 7.2.1.1 (October 15, 2024) ##
 
-*   Change ActiveRecord::Coders::YAMLColumn default to safe_load
+*   No changes.
 
-    This adds two new configuration options The configuration options are as
-    follows:
 
-    * `config.active_record.use_yaml_unsafe_load`
+## Rails 7.2.1 (August 22, 2024) ##
 
-    When set to true, this configuration option tells Rails to use the old
-    "unsafe" YAML loading strategy, maintaining the existing behavior but leaving
-    the possible escalation vulnerability in place.  Setting this option to true
-    is *not* recommended, but can aid in upgrading.
+*   Fix detection for `enum` columns with parallelized tests and PostgreSQL.
 
-    * `config.active_record.yaml_column_permitted_classes`
+    *Rafael Mendonça França*
 
-    The "safe YAML" loading method does not allow all classes to be deserialized
-    by default.  This option allows you to specify classes deemed "safe" in your
-    application.  For example, if your application uses Symbol and Time in
-    serialized data, you can add Symbol and Time to the allowed list as follows:
+*   Allow to eager load nested nil associations.
 
-    ```
-    config.active_record.yaml_column_permitted_classes = [Symbol, Date, Time]
-    ```
+    *fatkodima*
 
-    [CVE-2022-32224]
+*   Fix swallowing ignore order warning when batching using `BatchEnumerator`.
 
+    *fatkodima*
 
-## Rails 7.0.3 (May 09, 2022) ##
+*   Fix memory bloat on the connection pool when using the Fiber `IsolatedExecutionState`.
 
-*   Some internal housekeeping on reloads could break custom `respond_to?`
-    methods in class objects that referenced reloadable constants. See
-    [#44125](https://github.com/rails/rails/issues/44125) for details.
+    *Jean Boussier*
 
-    *Xavier Noria*
+*   Restore inferred association class with the same modularized name.
 
-*   Fixed MariaDB default function support.
+    *Justin Ko*
 
-    Defaults would be written wrong in "db/schema.rb" and not work correctly
-    if using `db:schema:load`. Further more the function name would be
-    added as string content when saving new records.
+*   Fix `ActiveRecord::Base.inspect` to properly explain how to load schema information.
 
-    *kaspernj*
+    *Jean Boussier*
 
-*   Fix `remove_foreign_key` with `:if_exists` option when foreign key actually exists.
+*   Check invalid `enum` options for the new syntax.
 
-    *fatkodima*
+    The options using `_` prefix in the old syntax are invalid in the new syntax.
 
-*   Remove `--no-comments` flag in structure dumps for PostgreSQL
+    *Rafael Mendonça França*
 
-    This broke some apps that used custom schema comments. If you don't want
-    comments in your structure dump, you can use:
+*   Fix `ActiveRecord::Encryption::EncryptedAttributeType#type` to return
+    actual cast type.
 
-    ```ruby
-    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = ['--no-comments']
-    ```
+    *Vasiliy Ermolovich*
 
-    *Alex Ghiculescu*
+*   Fix `create_table` with `:auto_increment` option for MySQL adapter.
 
-*   Use the model name as a prefix when filtering encrypted attributes from logs.
+    *fatkodima*
 
-    For example, when encrypting `Person#name` it will add `person.name` as a filter
-    parameter, instead of just `name`. This prevents unintended filtering of parameters
-    with a matching name in other models.
 
-    *Jorge Manrubia*
+## Rails 7.2.0 (August 09, 2024) ##
 
-*   Fix quoting of `ActiveSupport::Duration` and `Rational` numbers in the MySQL adapter.
+*   Handle commas in Sqlite3 default function definitions.
 
-    *Kevin McPhillips*
+    *Stephen Margheim*
 
-*   Fix `change_column_comment` to preserve column's AUTO_INCREMENT in the MySQL adapter
+*   Fixes `validates_associated` raising an exception when configured with a
+    singular association and having `index_nested_attribute_errors` enabled.
 
-    *fatkodima*
+    *Martin Spickermann*
 
-## Rails 7.0.2.4 (April 26, 2022) ##
+*   The constant `ActiveRecord::ImmutableRelation` has been deprecated because
+    we want to reserve that name for a stronger sense of "immutable relation".
+    Please use `ActiveRecord::UnmodifiableRelation` instead.
 
-*   No changes.
+    *Xavier Noria*
 
+*   Add condensed `#inspect` for `ConnectionPool`, `AbstractAdapter`, and
+    `DatabaseConfig`.
 
-## Rails 7.0.2.3 (March 08, 2022) ##
+    *Hartley McGuire*
 
-*   No changes.
+*   Fixed a memory performance issue in Active Record attribute methods definition.
 
+    *Jean Boussier*
 
-## Rails 7.0.2.2 (February 11, 2022) ##
+*   Define the new Active Support notification event `start_transaction.active_record`.
 
-*   No changes.
+    This event is fired when database transactions or savepoints start, and
+    complements `transaction.active_record`, which is emitted when they finish.
 
+    The payload has the transaction (`:transaction`) and the connection (`:connection`).
 
-## Rails 7.0.2.1 (February 11, 2022) ##
+    *Xavier Noria*
 
-*   No changes.
+*   Fix an issue where the IDs reader method did not return expected results
+    for preloaded associations in models using composite primary keys.
 
+    *Jay Ang*
 
-## Rails 7.0.2 (February 08, 2022) ##
+*   The payload of `sql.active_record` Active Support notifications now has the current transaction in the `:transaction` key.
 
-*   Fix `PG.connect` keyword arguments deprecation warning on ruby 2.7.
+    *Xavier Noria*
 
-    *Nikita Vasilevsky*
+*   The payload of `transaction.active_record` Active Support notifications now has the transaction the event is related to in the `:transaction` key.
 
-*   Fix the ability to exclude encryption params from being autofiltered.
+    *Xavier Noria*
 
-    *Mark Gangl*
+*   Define `ActiveRecord::Transaction#uuid`, which returns a UUID for the database transaction. This may be helpful when tracing database activity. These UUIDs are generated only on demand.
 
-*   Dump the precision for datetime columns following the new defaults.
+    *Xavier Noria*
 
-    *Rafael Mendonça França*
+*   Fix inference of association model on nested models with the same demodularized name.
 
-*   Make sure encrypted attributes are not being filtered twice.
+    E.g. with the following setup:
 
-    *Nikita Vasilevsky*
+    ```ruby
+    class Nested::Post < ApplicationRecord
+      has_one :post, through: :other
+    end
+    ```
+
+    Before, `#post` would infer the model as `Nested::Post`, but now it correctly infers `Post`.
 
-*   Dump the database schema containing the current Rails version.
+    *Joshua Young*
 
-    Since https://github.com/rails/rails/pull/42297, Rails now generate datetime columns
-    with a default precision of 6. This means that users upgrading to Rails 7.0 from 6.1,
-    when loading the database schema, would get the new precision value, which would not match
-    the production schema.
+*   PostgreSQL `Cidr#change?` detects the address prefix change.
 
-    To avoid this the schema dumper will generate the new format which will include the Rails
-    version and will look like this:
+    *Taketo Takashima*
 
-    ```
-    ActiveRecord::Schema[7.0].define
-    ```
+*   Change `BatchEnumerator#destroy_all` to return the total number of affected rows.
 
-    When upgrading from Rails 6.1 to Rails 7.0, you can run the `rails app:update` task that will
-    set the current schema version to 6.1.
+    Previously, it always returned `nil`.
 
-    *Rafael Mendonça França*
+    *fatkodima*
+
+*   Support `touch_all` in batches.
 
-*   Fix parsing expression for PostgreSQL generated column.
+    ```ruby
+    Post.in_batches.touch_all
+    ```
 
     *fatkodima*
 
-*   Fix `Mysql2::Error: Commands out of sync; you can't run this command now`
-    when bulk-inserting fixtures that exceed `max_allowed_packet` configuration.
+*   Add support for `:if_not_exists` and `:force` options to `create_schema`.
 
-    *Nikita Vasilevsky*
+    *fatkodima*
 
-*   Fix error when saving an association with a relation named `record`.
+*   Fix `index_errors` having incorrect index in association validation errors.
 
-    *Dorian Marié*
+    *lulalala*
 
-*   Fix `MySQL::SchemaDumper` behavior about datetime precision value.
+*   Add `index_errors: :nested_attributes_order` mode.
 
-    *y0t4*
+    This indexes the association validation errors based on the order received by nested attributes setter, and respects the `reject_if` configuration. This enables API to provide enough information to the frontend to map the validation errors back to their respective form fields.
 
-*   Improve associated with no reflection error.
+    *lulalala*
 
-    *Nikolai*
+*   Add `Rails.application.config.active_record.postgresql_adapter_decode_dates` to opt out of decoding dates automatically with the postgresql adapter. Defaults to true.
 
-*   Fix PG.connect keyword arguments deprecation warning on ruby 2.7.
+    *Joé Dupuis*
 
-    Fixes #44307.
+*   Association option `query_constraints` is deprecated in favor of `foreign_key`.
 
     *Nikita Vasilevsky*
 
-*   Fix passing options to `check_constraint` from `change_table`.
+*   Add `ENV["SKIP_TEST_DATABASE_TRUNCATE"]` flag to speed up multi-process test runs on large DBs when all tests run within default transaction.
 
-    *Frederick Cheung*
+    This cuts ~10s from the test run of HEY when run by 24 processes against the 178 tables, since ~4,000 table truncates can then be skipped.
 
+    *DHH*
 
-## Rails 7.0.1 (January 06, 2022) ##
+*   Added support for recursive common table expressions.
 
+    ```ruby
+    Post.with_recursive(
+      post_and_replies: [
+        Post.where(id: 42),
+        Post.joins('JOIN post_and_replies ON posts.in_reply_to_id = post_and_replies.id'),
+      ]
+    )
+    ```
 
-*   Change `QueryMethods#in_order_of` to drop records not listed in values.
-
-    `in_order_of` now filters down to the values provided, to match the behavior of the `Enumerable` version.
+    Generates the following SQL:
 
-    *Kevin Newton*
+    ```sql
+    WITH RECURSIVE "post_and_replies" AS (
+      (SELECT "posts".* FROM "posts" WHERE "posts"."id" = 42)
+      UNION ALL
+      (SELECT "posts".* FROM "posts" JOIN post_and_replies ON posts.in_reply_to_id = post_and_replies.id)
+    )
+    SELECT "posts".* FROM "posts"
+    ```
 
-*   Allow named expression indexes to be revertible.
+    *ClearlyClaire*
 
-    Previously, the following code would raise an error in a reversible migration executed while rolling back, due to the index name not being used in the index removal.
+*   `validate_constraint` can be called in a `change_table` block.
 
+    ex:
     ```ruby
-    add_index(:settings, "(data->'property')", using: :gin, name: :index_settings_data_property)
+    change_table :products do |t|
+      t.check_constraint "price > discounted_price", name: "price_check", validate: false
+      t.validate_check_constraint "price_check"
+    end
     ```
 
-    Fixes #43331.
+    *Cody Cutrer*
+
+*   `PostgreSQLAdapter` now decodes columns of type date to `Date` instead of string.
+
+    Ex:
+    ```ruby
+    ActiveRecord::Base.connection
+         .select_value("select '2024-01-01'::date").class #=> Date
+    ```
 
-    *Oliver Günther*
+    *Joé Dupuis*
 
-*   Better error messages when association name is invalid in the argument of `ActiveRecord::QueryMethods::WhereChain#missing`.
+*   Strict loading using `:n_plus_one_only` does not eagerly load child associations.
 
-    *ykpythemind*
+    With this change, child associations are no longer eagerly loaded, to
+    match intended behavior and to prevent non-deterministic order issues caused
+    by calling methods like `first` or `last`. As `first` and `last` don't cause
+    an N+1 by themselves, calling child associations will no longer raise.
+    Fixes #49473.
 
-*   Fix ordered migrations for single db in multi db environment.
+    Before:
 
-    *Himanshu*
+    ```ruby
+    person = Person.find(1)
+    person.strict_loading!(mode: :n_plus_one_only)
+    person.posts.first
+    # SELECT * FROM posts WHERE person_id = 1; -- non-deterministic order
+    person.posts.first.firm # raises ActiveRecord::StrictLoadingViolationError
+    ```
 
-*   Extract `on update CURRENT_TIMESTAMP` for mysql2 adapter.
+    After:
 
-    *Kazuhiro Masuda*
+    ```ruby
+    person = Person.find(1)
+    person.strict_loading!(mode: :n_plus_one_only)
+    person.posts.first # this is 1+1, not N+1
+    # SELECT * FROM posts WHERE person_id = 1 ORDER BY id LIMIT 1;
+    person.posts.first.firm # no longer raises
+    ```
 
-*   Fix incorrect argument in PostgreSQL structure dump tasks.
+    *Reid Lynch*
 
-    Updating the `--no-comment` argument added in Rails 7 to the correct `--no-comments` argument.
+*   Allow `Sqlite3Adapter` to use `sqlite3` gem version `2.x`.
 
-    *Alex Dent*
+    *Mike Dalessio*
 
-*   Fix schema dumping column default SQL values for sqlite3.
+*   Allow `ActiveRecord::Base#pluck` to accept hash values.
 
-    *fatkodima*
+    ```ruby
+    # Before
+    Post.joins(:comments).pluck("posts.id", "comments.id", "comments.body")
 
-*   Correctly parse complex check constraint expressions for PostgreSQL.
+    # After
+    Post.joins(:comments).pluck(posts: [:id], comments: [:id, :body])
+    ```
 
     *fatkodima*
 
-*   Fix `timestamptz` attributes on PostgreSQL handle blank inputs.
+*   Raise an `ActiveRecord::ActiveRecordError` error when the MySQL database returns an invalid version string.
 
-    *Alex Ghiculescu*
+    *Kevin McPhillips*
 
-*   Fix migration compatibility to create SQLite references/belongs_to column as integer when migration version is 6.0.
+*   `ActiveRecord::Base.transaction` now yields an `ActiveRecord::Transaction` object.
 
-    Reference/belongs_to in migrations with version 6.0 were creating columns as
-    bigint instead of integer for the SQLite Adapter.
+    This allows to register callbacks on it.
 
-    *Marcelo Lauxen*
+    ```ruby
+    Article.transaction do |transaction|
+      article.update(published: true)
+      transaction.after_commit do
+        PublishNotificationMailer.with(article: article).deliver_later
+      end
+    end
+    ```
 
-*   Fix joining through a polymorphic association.
+    *Jean Boussier*
 
-    *Alexandre Ruban*
+*   Add `ActiveRecord::Base.current_transaction`.
 
-*   Fix `QueryMethods#in_order_of` to handle empty order list.
+    Returns the current transaction, to allow registering callbacks on it.
 
     ```ruby
-    Post.in_order_of(:id, []).to_a
+    Article.current_transaction.after_commit do
+      PublishNotificationMailer.with(article: article).deliver_later
+    end
     ```
 
-    Also more explicitly set the column as secondary order, so that any other
-    value is still ordered.
-
     *Jean Boussier*
 
-*   Fix `rails dbconsole` for 3-tier config.
+*   Add `ActiveRecord.after_all_transactions_commit` callback.
 
-    *Eileen M. Uchitelle*
-
-*   Fix quoting of column aliases generated by calculation methods.
-
-    Since the alias is derived from the table name, we can't assume the result
-    is a valid identifier.
+    Useful for code that may run either inside or outside a transaction and needs
+    to perform work after the state changes have been properly persisted.
 
     ```ruby
-    class Test < ActiveRecord::Base
-      self.table_name = '1abc'
+    def publish_article(article)
+      article.update(published: true)
+      ActiveRecord.after_all_transactions_commit do
+        PublishNotificationMailer.with(article: article).deliver_later
+      end
     end
-    Test.group(:id).count
-    # syntax error at or near "1" (ActiveRecord::StatementInvalid)
-    # LINE 1: SELECT COUNT(*) AS count_all, "1abc"."id" AS 1abc_id FROM "1...
     ```
 
+    In the above example, the block is either executed immediately if called outside
+    of a transaction, or called after the open transaction is committed.
+
+    If the transaction is rolled back, the block isn't called.
+
     *Jean Boussier*
 
+*   Add the ability to ignore counter cache columns until they are backfilled.
 
-## Rails 7.0.0 (December 15, 2021) ##
+    Starting to use counter caches on existing large tables can be troublesome, because the column
+    values must be backfilled separately of the column addition (to not lock the table for too long)
+    and before the use of `:counter_cache` (otherwise methods like `size`/`any?`/etc, which use
+    counter caches internally, can produce incorrect results). People usually use database triggers
+    or callbacks on child associations while backfilling before introducing a counter cache
+    configuration to the association.
 
-*   Better handle SQL queries with invalid encoding.
+    Now, to safely backfill the column, while keeping the column updated with child records added/removed, use:
 
     ```ruby
-    Post.create(name: "broken \xC8 UTF-8")
+    class Comment < ApplicationRecord
+      belongs_to :post, counter_cache: { active: false }
+    end
     ```
 
-    Would cause all adapters to fail in a non controlled way in the code
-    responsible to detect write queries.
+    While the counter cache is not "active", the methods like `size`/`any?`/etc will not use it,
+    but get the results directly from the database. After the counter cache column is backfilled, simply
+    remove the `{ active: false }` part from the counter cache definition, and it will now be used by the
+    mentioned methods.
 
-    The query is now properly passed to the database connection, which might or might
-    not be able to handle it, but will either succeed or failed in a more correct way.
+    *fatkodima*
 
-    *Jean Boussier*
+*   Retry known idempotent SELECT queries on connection-related exceptions.
 
-*   Move database and shard selection config options to a generator.
+    SELECT queries we construct by walking the Arel tree and / or with known model attributes
+    are idempotent and can safely be retried in the case of a connection error. Previously,
+    adapters such as `TrilogyAdapter` would raise `ActiveRecord::ConnectionFailed: Trilogy::EOFError`
+    when encountering a connection error mid-request.
 
-    Rather than generating the config options in `production.rb` when applications are created, applications can now run a generator to create an initializer and uncomment / update options as needed. All multi-db configuration can be implemented in this initializer.
+    *Adrianna Chang*
 
-    *Eileen M. Uchitelle*
+*   Allow association's `foreign_key` to be composite.
 
+    `query_constraints` option was the only way to configure a composite foreign key by passing an `Array`.
+    Now it's possible to pass an Array value as `foreign_key` to achieve the same behavior of an association.
 
-## Rails 7.0.0.rc3 (December 14, 2021) ##
+    *Nikita Vasilevsky*
 
-*   No changes.
+*   Allow association's `primary_key` to be composite.
 
+    Association's `primary_key` can be composite when derived from associated model `primary_key` or `query_constraints`.
+    Now it's possible to explicitly set it as composite on the association.
 
-## Rails 7.0.0.rc2 (December 14, 2021) ##
+    *Nikita Vasilevsky*
 
-*   No changes.
+*   Add `config.active_record.permanent_connection_checkout` setting.
 
+    Controls whether `ActiveRecord::Base.connection` raises an error, emits a deprecation warning, or neither.
 
-## Rails 7.0.0.rc1 (December 06, 2021) ##
+    `ActiveRecord::Base.connection` checkouts a database connection from the pool and keeps it leased until the end of
+    the request or job. This behavior can be undesirable in environments that use many more threads or fibers than there
+    is available connections.
 
-*   Remove deprecated `ActiveRecord::DatabaseConfigurations::DatabaseConfig#spec_name`.
+    This configuration can be used to track down and eliminate code that calls `ActiveRecord::Base.connection` and
+    migrate it to use `ActiveRecord::Base.with_connection` instead.
 
-    *Rafael Mendonça França*
+    The default behavior remains unchanged, and there is currently no plans to change the default.
 
-*   Remove deprecated `ActiveRecord::Connection#in_clause_length`.
+    *Jean Boussier*
 
-    *Rafael Mendonça França*
+*   Add dirties option to uncached.
 
-*   Remove deprecated `ActiveRecord::Connection#allowed_index_name_length`.
+    This adds a `dirties` option to `ActiveRecord::Base.uncached` and
+    `ActiveRecord::ConnectionAdapters::ConnectionPool#uncached`.
 
-    *Rafael Mendonça França*
+    When set to `true` (the default), writes will clear all query caches belonging to the current thread.
+    When set to `false`, writes to the affected connection pool will not clear any query cache.
 
-*   Remove deprecated `ActiveRecord::Base#remove_connection`.
+    This is needed by Solid Cache so that cache writes do not clear query caches.
 
-    *Rafael Mendonça França*
+    *Donal McBreen*
 
-*   Load STI Models in fixtures
+*   Deprecate `ActiveRecord::Base.connection` in favor of `.lease_connection`.
 
-    Data from Fixtures now loads based on the specific class for models with
-    Single Table Inheritance. This affects enums defined in subclasses, previously
-    the value of these fields was not parsed and remained `nil`
+    The method has been renamed as `lease_connection` to better reflect that the returned
+    connection will be held for the duration of the request or job.
 
-    *Andres Howard*
+    This deprecation is a soft deprecation, no warnings will be issued and there is no
+    current plan to remove the method.
 
-*   `#authenticate` returns false when the password is blank instead of raising an error.
+    *Jean Boussier*
 
-    *Muhammad Muhammad Ibrahim*
+*   Deprecate `ActiveRecord::ConnectionAdapters::ConnectionPool#connection`.
 
-*   Fix `ActiveRecord::QueryMethods#in_order_of` behavior for integer enums.
+    The method has been renamed as `lease_connection` to better reflect that the returned
+    connection will be held for the duration of the request or job.
 
-    `ActiveRecord::QueryMethods#in_order_of` didn't work as expected for enums stored as integers in the database when passing an array of strings or symbols as the order argument. This unexpected behavior occurred because the string or symbol values were not casted to match the integers in the database.
+    *Jean Boussier*
 
-    The following example now works as expected:
+*   Expose a generic fixture accessor for fixture names that may conflict with Minitest.
 
     ```ruby
-    class Book < ApplicationRecord
-      enum status: [:proposed, :written, :published]
-    end
-
-    Book.in_order_of(:status, %w[written published proposed])
+    assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
+    assert_equal "Ruby on Rails", fixture(:web_sites, :rubyonrails).name
     ```
 
-    *Alexandre Ruban*
+    *Jean Boussier*
 
-*   Ignore persisted in-memory records when merging target lists.
+*   Using `Model.query_constraints` with a single non-primary-key column used to raise as expected, but with an
+    incorrect error message.
 
-    *Kevin Sjöberg*
+    This has been fixed to raise with a more appropriate error message.
 
-*   Add a new option `:update_only` to `upsert_all` to configure the list of columns to update in case of conflict.
+    *Joshua Young*
 
-    Before, you could only customize the update SQL sentence via `:on_duplicate`. There is now a new option `:update_only` that lets you provide a list of columns to update in case of conflict:
+*   Fix `has_one` association autosave setting the foreign key attribute when it is unchanged.
 
-    ```ruby
-    Commodity.upsert_all(
-      [
-        { id: 2, name: "Copper", price: 4.84 },
-        { id: 4, name: "Gold", price: 1380.87 },
-        { id: 6, name: "Aluminium", price: 0.35 }
-      ],
-      update_only: [:price] # Only prices will be updated
-    )
-    ```
+    This behavior is also inconsistent with autosaving `belongs_to` and can have unintended side effects like raising
+    an `ActiveRecord::ReadonlyAttributeError` when the foreign key attribute is marked as read-only.
 
-    *Jorge Manrubia*
+    *Joshua Young*
 
-*   Remove deprecated `ActiveRecord::Result#map!` and `ActiveRecord::Result#collect!`.
+*   Remove deprecated behavior that would rollback a transaction block when exited using `return`, `break` or `throw`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `ActiveRecord::Base.configurations.to_h`.
+*   Deprecate `Rails.application.config.active_record.commit_transaction_on_non_local_return`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `ActiveRecord::Base.configurations.default_hash`.
+*   Remove deprecated support to pass `rewhere` to `ActiveRecord::Relation#merge`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `ActiveRecord::Base.arel_attribute`.
+*   Remove deprecated support to pass `deferrable: true` to `add_foreign_key`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `ActiveRecord::Base.connection_config`.
+*   Remove deprecated support to quote `ActiveSupport::Duration`.
 
     *Rafael Mendonça França*
 
-*   Filter attributes in SQL logs
+*   Remove deprecated `#quote_bound_value`.
 
-    Previously, SQL queries in logs containing `ActiveRecord::Base.filter_attributes` were not filtered.
+    *Rafael Mendonça França*
 
-    Now, the filter attributes will be masked `[FILTERED]` in the logs when `prepared_statement` is enabled.
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::ConnectionPool#connection_klass`.
 
-    ```
-    # Before:
-      Foo Load (0.2ms)  SELECT "foos".* FROM "foos" WHERE "foos"."passw" = ? LIMIT ?  [["passw", "hello"], ["LIMIT", 1]]
+    *Rafael Mendonça França*
 
-    # After:
-      Foo Load (0.5ms)  SELECT "foos".* FROM "foos" WHERE "foos"."passw" = ? LIMIT ?  [["passw", "[FILTERED]"], ["LIMIT", 1]]
-    ```
+*   Remove deprecated support to apply `#connection_pool_list`, `#active_connections?`, `#clear_active_connections!`,
+    `#clear_reloadable_connections!`, `#clear_all_connections!` and `#flush_idle_connections!` to the connections pools
+    for the current role when the `role` argument isn't provided.
 
-    *Aishwarya Subramanian*
+    *Rafael Mendonça França*
 
-*   Remove deprecated `Tasks::DatabaseTasks.spec`.
+*   Remove deprecated `#all_connection_pools`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `Tasks::DatabaseTasks.current_config`.
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::SchemaCache#data_sources`.
 
     *Rafael Mendonça França*
 
-*   Deprecate `Tasks::DatabaseTasks.schema_file_type`.
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::SchemaCache.load_from`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `Tasks::DatabaseTasks.dump_filename`.
+*   Remove deprecated `#all_foreign_keys_valid?` from database adapters.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `Tasks::DatabaseTasks.schema_file`.
+*   Remove deprecated support to passing coder and class as second argument to `serialize`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `environment` and `name` arguments from `Tasks::DatabaseTasks.schema_up_to_date?`.
+*   Remove deprecated support to `ActiveRecord::Base#read_attribute(:id)` to return the custom primary key value.
 
     *Rafael Mendonça França*
 
-*   Merging conditions on the same column no longer maintain both conditions,
-    and will be consistently replaced by the latter condition.
-
-    ```ruby
-    # Rails 6.1 (IN clause is replaced by merger side equality condition)
-    Author.where(id: [david.id, mary.id]).merge(Author.where(id: bob)) # => [bob]
-    # Rails 6.1 (both conflict conditions exists, deprecated)
-    Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => []
-    # Rails 6.1 with rewhere to migrate to Rails 7.0's behavior
-    Author.where(id: david.id..mary.id).merge(Author.where(id: bob), rewhere: true) # => [bob]
-    # Rails 7.0 (same behavior with IN clause, mergee side condition is consistently replaced)
-    Author.where(id: [david.id, mary.id]).merge(Author.where(id: bob)) # => [bob]
-    Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => [bob]
+*   Remove deprecated `TestFixtures.fixture_path`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated support to `Model.reorder(nil).first` to search using non-deterministic order.
+*   Remove deprecated behavior to support referring to a singular association by its plural name.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated rake tasks:
-
-    * `db:schema:load_if_ruby`
-    * `db:structure:dump`
-    * `db:structure:load`
-    * `db:structure:load_if_sql`
-    * `db:structure:dump:#{name}`
-    * `db:structure:load:#{name}`
-    * `db:test:load_structure`
-    * `db:test:load_structure:#{name}`
+*   Deprecate `Rails.application.config.active_record.allow_deprecated_singular_associations_name`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `DatabaseConfig#config` method.
+*   Remove deprecated support to passing `SchemaMigration` and `InternalMetadata` classes as arguments to
+    `ActiveRecord::MigrationContext`.
 
     *Rafael Mendonça França*
 
-*   Rollback transactions when the block returns earlier than expected.
+*   Remove deprecated `ActiveRecord::Migration.check_pending!` method.
 
-    Before this change, when a transaction block returned early, the transaction would be committed.
+    *Rafael Mendonça França*
 
-    The problem is that timeouts triggered inside the transaction block was also making the incomplete transaction
-    to be committed, so in order to avoid this mistake, the transaction block is rolled back.
+*   Remove deprecated `ActiveRecord::LogSubscriber.runtime` method.
 
     *Rafael Mendonça França*
 
-*   Add middleware for automatic shard swapping.
-
-    Provides a basic middleware to perform automatic shard swapping. Applications will provide a resolver which will determine for an individual request which shard should be used. Example:
+*   Remove deprecated `ActiveRecord::LogSubscriber.runtime=` method.
 
-    ```ruby
-    config.active_record.shard_resolver = ->(request) {
-      subdomain = request.subdomain
-      tenant = Tenant.find_by_subdomain!(subdomain)
-      tenant.shard
-    }
-    ```
+    *Rafael Mendonça França*
 
-    See guides for more details.
+*   Remove deprecated `ActiveRecord::LogSubscriber.reset_runtime` method.
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    *Rafael Mendonça França*
 
-*   Remove deprecated support to pass a column to `type_cast`.
+*   Remove deprecated support to define `explain` in the connection adapter with 2 arguments.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated support to type cast to database values `ActiveRecord::Base` objects.
+*   Remove deprecated `ActiveRecord::ActiveJobRequiredError`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated support to quote `ActiveRecord::Base` objects.
+*   Remove deprecated `ActiveRecord::Base.clear_active_connections!`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecacated support to resolve connection using `"primary"` as connection specification name.
+*   Remove deprecated `ActiveRecord::Base.clear_reloadable_connections!`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecation warning when using `:interval` column is used in PostgreSQL database.
+*   Remove deprecated `ActiveRecord::Base.clear_all_connections!`.
 
-    Now, interval columns will return `ActiveSupport::Duration` objects instead of strings.
-
-    To keep the old behavior, you can add this line to your model:
+    *Rafael Mendonça França*
 
-    ```ruby
-    attribute :column, :string
-    ```
+*   Remove deprecated `ActiveRecord::Base.flush_idle_connections!`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated support to YAML load `ActiveRecord::Base` instance in the Rails 4.2 and 4.1 formats.
+*   Remove deprecated `name` argument from `ActiveRecord::Base.remove_connection`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated option `:spec_name` in the `configs_for` method.
+*   Remove deprecated support to call `alias_attribute` with non-existent attribute names.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated  `ActiveRecord::Base.allow_unsafe_raw_sql`.
+*   Remove deprecated `Rails.application.config.active_record.suppress_multiple_database_warning`.
 
     *Rafael Mendonça França*
 
-*   Fix regression bug that caused ignoring additional conditions for preloading has_many-through relations.
+*   Add `ActiveRecord::Encryption::MessagePackMessageSerializer`.
 
-    Fixes #43132
+    Serialize data to the MessagePack format, for efficient storage in binary columns.
 
-    *Alexander Pauly*
+    The binary encoding requires around 30% less space than the base64 encoding
+    used by the default serializer.
 
-*   Fix `has_many` inversing recursion on models with recursive associations.
+    *Donal McBreen*
 
-    *Gannon McGibbon*
+*   Add support for encrypting binary columns.
 
-*   Add `accepts_nested_attributes_for` support for `delegated_type`
+    Ensure encryption and decryption pass `Type::Binary::Data` around for binary data.
 
-    ```ruby
-    class Entry < ApplicationRecord
-      delegated_type :entryable, types: %w[ Message Comment ]
-      accepts_nested_attributes_for :entryable
-    end
+    Previously encrypting binary columns with the `ActiveRecord::Encryption::MessageSerializer`
+    incidentally worked for MySQL and SQLite, but not PostgreSQL.
 
-    entry = Entry.create(entryable_type: 'Message', entryable_attributes: { content: 'Hello world' })
-    # => #<Entry:0x00>
-    # id: 1
-    # entryable_id: 1,
-    # entryable_type: 'Message'
-    # ...>
-
-    entry.entryable
-    # => #<Message:0x01>
-    # id: 1
-    # content: 'Hello world'
-    # ...>
-    ```
+    *Donal McBreen*
 
-    Previously it would raise an error:
+*   Deprecated `ENV["SCHEMA_CACHE"]` in favor of `schema_cache_path` in the database configuration.
 
-    ```ruby
-    Entry.create(entryable_type: 'Message', entryable_attributes: { content: 'Hello world' })
-    # ArgumentError: Cannot build association `entryable'. Are you trying to build a polymorphic one-to-one association?
-    ```
+    *Rafael Mendonça França*
 
-    *Sjors Baltus*
+*   Add `ActiveRecord::Base.with_connection` as a shortcut for leasing a connection for a short duration.
 
-*   Use subquery for DELETE with GROUP_BY and HAVING clauses.
+    The leased connection is yielded, and for the duration of the block, any call to `ActiveRecord::Base.connection`
+    will yield that same connection.
 
-    Prior to this change, deletes with GROUP_BY and HAVING were returning an error.
+    This is useful to perform a few database operations without causing a connection to be leased for the
+    entire duration of the request or job.
 
-    After this change, GROUP_BY and HAVING are valid clauses in DELETE queries, generating the following query:
+    *Jean Boussier*
 
-    ```sql
-    DELETE FROM "posts" WHERE "posts"."id" IN (
-        SELECT "posts"."id" FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" GROUP BY "posts"."id" HAVING (count(comments.id) >= 2))
-    )  [["flagged", "t"]]
-    ```
+*   Deprecate `config.active_record.warn_on_records_fetched_greater_than` now that `sql.active_record`
+    notification includes `:row_count` field.
 
-    *Ignacio Chiazzo Cardarello*
+    *Jason Nochlin*
 
-*   Use subquery for UPDATE with GROUP_BY and HAVING clauses.
+*   Fix an issue with `where.associated` losing the current join type scope.
 
-    Prior to this change, updates with GROUP_BY and HAVING were being ignored, generating a SQL like this:
+    Example:
 
-    ```sql
-    UPDATE "posts" SET "flagged" = ? WHERE "posts"."id" IN (
-        SELECT "posts"."id" FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
-    )  [["flagged", "t"]]
+    ```ruby
+    Post.left_joins(:author).where.associated(:author)
     ```
 
-    After this change, GROUP_BY and HAVING clauses are used as a subquery in updates, like this:
+    Previously, the `LEFT OUTER JOIN` would be lost and converted to an `INNER JOIN`.
 
-    ```sql
-    UPDATE "posts" SET "flagged" = ? WHERE "posts"."id" IN (
-        SELECT "posts"."id" FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
-        GROUP BY posts.id HAVING (count(comments.id) >= 2)
-    )  [["flagged", "t"]]
-    ```
+    *Saleh Alhaddad*
 
-    *Ignacio Chiazzo Cardarello*
+*   Fix an issue where `ActiveRecord::Encryption` configurations are not ready before the loading
+    of Active Record models, when an application is eager loaded. As a result, encrypted attributes
+    could be misconfigured in some cases.
 
-*   Add support for setting the filename of the schema or structure dump in the database config.
+    *Maxime Réty*
 
-    Applications may now set their the filename or path of the schema / structure dump file in their database configuration.
+*   Deprecate defining an `enum` with keyword arguments.
 
-    ```yaml
-    production:
-      primary:
-        database: my_db
-        schema_dump: my_schema_dump_filename.rb
-      animals:
-        database: animals_db
-        schema_dump: false
+    ```ruby
+    class Function > ApplicationRecord
+      # BAD
+      enum color: [:red, :blue],
+           type: [:instance, :class]
+
+      # GOOD
+      enum :color, [:red, :blue]
+      enum :type, [:instance, :class]
+    end
     ```
 
-    The filename set in `schema_dump` will be used by the application. If set to `false` the schema will not be dumped. The database tasks are responsible for adding the database directory to the filename. If a full path is provided, the Rails tasks will use that instead of `ActiveRecord::DatabaseTasks.db_dir`.
+    *Hartley McGuire*
 
-    *Eileen M. Uchitelle*, *Ryan Kerr*
+*   Add `config.active_record.validate_migration_timestamps` option for validating migration timestamps.
 
-*   Add `ActiveRecord::Base.prohibit_shard_swapping` to prevent attempts to change the shard within a block.
+    When set, validates that the timestamp prefix for a migration is no more than a day ahead of
+    the timestamp associated with the current time. This is designed to prevent migrations prefixes
+    from being hand-edited to future timestamps, which impacts migration generation and other
+    migration commands.
 
-    *John Crepezzi*, *Eileen M. Uchitelle*
-
-*   Filter unchanged attributes with default function from insert query when `partial_inserts` is disabled.
-
-    *Akshay Birajdar*, *Jacopo Beschi*
-
-*   Add support for FILTER clause (SQL:2003) to Arel.
-
-    Currently supported by PostgreSQL 9.4+ and SQLite 3.30+.
-
-    *Andrey Novikov*
-
-*   Automatically set timestamps on record creation during bulk insert/upsert
-
-    Prior to this change, only updates during an upsert operation (e.g. `upsert_all`) would touch timestamps (`updated_{at,on}`). Now, record creations also touch timestamp columns (`{created,updated}_{at,on}`).
-
-    This behaviour is controlled by the `<model>.record_timestamps` config, matching the behaviour of `create`, `update`, etc. It can also be overridden by using the `record_timestamps:` keyword argument.
-
-    Note that this means `upsert_all` on models with `record_timestamps = false` will no longer touch `updated_{at,on}` automatically.
-
-    *Sam Bostock*
-
-*   Don't require `role` when passing `shard` to `connected_to`.
-
-    `connected_to` can now be called with a `shard` only. Note that `role` is still inherited if `connected_to` calls are nested.
-
-    *Eileen M. Uchitelle*
-
-*   Add option to lazily load the schema cache on the connection.
-
-    Previously, the only way to load the schema cache in Active Record was through the Railtie on boot. This option provides the ability to load the schema cache on the connection after it's been established. Loading the cache lazily on the connection can be beneficial for Rails applications that use multiple databases because it will load the cache at the time the connection is established. Currently Railties doesn't have access to the connections before boot.
-
-    To use the cache, set `config.active_record.lazily_load_schema_cache = true` in your application configuration. In addition a `schema_cache_path` should be set in your database configuration if you don't want to use the default "db/schema_cache.yml" path.
-
-    *Eileen M. Uchitelle*
-
-*   Allow automatic `inverse_of` detection for associations with scopes.
-
-    Automatic `inverse_of` detection now works for associations with scopes. For
-    example, the `comments` association here now automatically detects
-    `inverse_of: :post`, so we don't need to pass that option:
-
-    ```ruby
-    class Post < ActiveRecord::Base
-      has_many :comments, -> { visible }
-    end
-
-    class Comment < ActiveRecord::Base
-      belongs_to :post
-    end
-    ```
-
-    Note that the automatic detection still won't work if the inverse
-    association has a scope. In this example a scope on the `post` association
-    would still prevent Rails from finding the inverse for the `comments`
-    association.
-
-    This will be the default for new apps in Rails 7. To opt in:
-
-    ```ruby
-    config.active_record.automatic_scope_inversing = true
-    ```
-
-    *Daniel Colson*, *Chris Bloom*
-
-*   Accept optional transaction args to `ActiveRecord::Locking::Pessimistic#with_lock`
-
-    `#with_lock` now accepts transaction options like `requires_new:`,
-    `isolation:`, and `joinable:`
-
-    *John Mileham*
-
-*   Adds support for deferrable foreign key constraints in PostgreSQL.
-
-    By default, foreign key constraints in PostgreSQL are checked after each statement. This works for most use cases,
-    but becomes a major limitation when creating related records before the parent record is inserted into the database.
-    One example of this is looking up / creating a person via one or more unique alias.
-
-    ```ruby
-    Person.transaction do
-      alias = Alias
-        .create_with(user_id: SecureRandom.uuid)
-        .create_or_find_by(name: "DHH")
-
-      person = Person
-        .create_with(name: "David Heinemeier Hansson")
-        .create_or_find_by(id: alias.user_id)
-    end
-    ```
-
-    Using the default behavior, the transaction would fail when executing the first `INSERT` statement.
-
-    By passing the `:deferrable` option to the `add_foreign_key` statement in migrations, it's possible to defer this
-    check.
+    *Adrianna Chang*
 
-    ```ruby
-    add_foreign_key :aliases, :person, deferrable: true
-    ```
+*   Properly synchronize `Mysql2Adapter#active?` and `TrilogyAdapter#active?`.
 
-    Passing `deferrable: true` doesn't change the default behavior, but allows manually deferring the check using
-    `SET CONSTRAINTS ALL DEFERRED` within a transaction. This will cause the foreign keys to be checked after the
-    transaction.
+    As well as `disconnect!` and `verify!`.
 
-    It's also possible to adjust the default behavior from an immediate check (after the statement), to a deferred check
-    (after the transaction):
+    This generally isn't a big problem as connections must not be shared between
+    threads, but is required when running transactional tests or system tests
+    and could lead to a SEGV.
 
-    ```ruby
-    add_foreign_key :aliases, :person, deferrable: :deferred
-    ```
-
-    *Benedikt Deicke*
+    *Jean Boussier*
 
-*   Allow configuring Postgres password through the socket URL.
+*   Support `:source_location` tag option for query log tags.
 
-    For example:
     ```ruby
-    ActiveRecord::DatabaseConfigurations::UrlConfig.new(
-      :production, :production, 'postgres:///?user=user&password=secret&dbname=app', {}
-    ).configuration_hash
+    config.active_record.query_log_tags << :source_location
     ```
 
-    will now return,
-
-    ```ruby
-    { :user=>"user", :password=>"secret", :dbname=>"app", :adapter=>"postgresql" }
-    ```
+    Calculating the caller location is a costly operation and should be used primarily in development
+    (note, there is also a `config.active_record.verbose_query_logs` that serves the same purpose)
+    or occasionally on production for debugging purposes.
 
-    *Abeid Ahmed*
+    *fatkodima*
 
-*   PostgreSQL: support custom enum types
+*   Add an option to `ActiveRecord::Encryption::Encryptor` to disable compression.
 
-    In migrations, use `create_enum` to add a new enum type, and `t.enum` to add a column.
+    Allow compression to be disabled by setting `compress: false`
 
     ```ruby
-    def up
-      create_enum :mood, ["happy", "sad"]
-
-      change_table :cats do |t|
-        t.enum :current_mood, enum_type: "mood", default: "happy", null: false
+      class User
+        encrypts :name, encryptor: ActiveRecord::Encryption::Encryptor.new(compress: false)
       end
-    end
     ```
 
-    Enums will be presented correctly in `schema.rb`. Note that this is only supported by
-    the PostgreSQL adapter.
-
-    *Alex Ghiculescu*
-
-*   Avoid COMMENT statements in PostgreSQL structure dumps
-
-    COMMENT statements are now omitted from the output of `db:structure:dump` when using PostgreSQL >= 11.
-    This allows loading the dump without a pgsql superuser account.
+    *Donal McBreen*
 
-    Fixes #36816, #43107.
+*   Deprecate passing strings to `ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename`.
 
-    *Janosch Müller*
+    A `ActiveRecord::DatabaseConfigurations::DatabaseConfig` object should be passed instead.
 
-*   Add support for generated columns in PostgreSQL adapter
-
-    Generated columns are supported since version 12.0 of PostgreSQL. This adds
-    support of those to the PostgreSQL adapter.
+    *Rafael Mendonça França*
 
-    ```ruby
-    create_table :users do |t|
-      t.string :name
-      t.virtual :name_upcased, type: :string, as: 'upper(name)', stored: true
-    end
-    ```
+*   Add `row_count` field to `sql.active_record` notification.
 
-    *Michał Begejowicz*
+    This field returns the amount of rows returned by the query that emitted the notification.
 
+    This metric is useful in cases where one wants to detect queries with big result sets.
 
-## Rails 7.0.0.alpha2 (September 15, 2021) ##
+    *Marvin Bitterlich*
 
-*   No changes.
+*   Consistently raise an `ArgumentError` when passing an invalid argument to a nested attributes association writer.
 
+    Previously, this would only raise on collection associations and produce a generic error on singular associations.
 
-## Rails 7.0.0.alpha1 (September 15, 2021) ##
+    Now, it will raise on both collection and singular associations.
 
-*   Remove warning when overwriting existing scopes
+    *Joshua Young*
 
-    Removes the following unnecessary warning message that appeared when overwriting existing scopes
+*   Fix single quote escapes on default generated MySQL columns.
 
-    ```
-    Creating scope :my_scope_name. Overwriting existing method "MyClass.my_scope_name" when overwriting existing scopes
-    ```
+    MySQL 5.7.5+ supports generated columns, which can be used to create a column that is computed from an expression.
 
-     *Weston Ganger*
+    Previously, the schema dump would output a string with double escapes for generated columns with single quotes in the default expression.
 
-*   Use full precision for `updated_at` in `insert_all`/`upsert_all`
+    This would result in issues when importing the schema on a fresh instance of a MySQL database.
 
-    `CURRENT_TIMESTAMP` provides differing precision depending on the database,
-    and not all databases support explicitly specifying additional precision.
+    Now, the string will not be escaped and will be valid Ruby upon importing of the schema.
 
-    Instead, we delegate to the new `connection.high_precision_current_timestamp`
-    for the SQL to produce a high precision timestamp on the current database.
+    *Yash Kapadia*
 
-    Fixes #42992
+*   Fix Migrations with versions older than 7.1 validating options given to
+    `add_reference` and `t.references`.
 
-    *Sam Bostock*
+    *Hartley McGuire*
 
-*   Add ssl support for postgresql database tasks
+*   Add `<role>_types` class method to `ActiveRecord::DelegatedType` so that the delegated types can be introspected.
 
-    Add `PGSSLMODE`, `PGSSLCERT`, `PGSSLKEY` and `PGSSLROOTCERT` to pg_env from database config
-    when running postgresql database tasks.
+    *JP Rosevear*
 
-    ```yaml
-    # config/database.yml
+*   Make `schema_dump`, `query_cache`, `replica` and `database_tasks` configurable via `DATABASE_URL`.
 
-    production:
-      sslmode: verify-full
-      sslcert: client.crt
-      sslkey: client.key
-      sslrootcert: ca.crt
-    ```
+    This wouldn't always work previously because boolean values would be interpreted as strings.
 
-    Environment variables
+    e.g. `DATABASE_URL=postgres://localhost/foo?schema_dump=false` now properly disable dumping the schema
+    cache.
 
-    ```
-    PGSSLMODE=verify-full
-    PGSSLCERT=client.crt
-    PGSSLKEY=client.key
-    PGSSLROOTCERT=ca.crt
-    ```
+    *Mike Coutermarsh*, *Jean Boussier*
 
-    Fixes #42994
+*   Introduce `ActiveRecord::Transactions::ClassMethods#set_callback`.
 
-    *Michael Bayucot*
+     It is identical to `ActiveSupport::Callbacks::ClassMethods#set_callback`
+     but with support for `after_commit` and `after_rollback` callback options.
 
-*   Avoid scoping update callbacks in `ActiveRecord::Relation#update!`.
+    *Joshua Young*
 
-    Making it consistent with how scoping is applied only to the query in `ActiveRecord::Relation#update`
-    and not also to the callbacks from the update itself.
+*   Make `ActiveRecord::Encryption::Encryptor` agnostic of the serialization format used for encrypted data.
 
-    *Dylan Thacker-Smith*
+    Previously, the encryptor instance only allowed an encrypted value serialized as a `String` to be passed to the message serializer.
 
-*   Fix 2 cases that inferred polymorphic class from the association's `foreign_type`
-    using `String#constantize` instead of the model's `polymorphic_class_for`.
+    Now, the encryptor lets the configured `message_serializer` decide which types of serialized encrypted values are supported. A custom serialiser is therefore allowed to serialize `ActiveRecord::Encryption::Message` objects using a type other than `String`.
 
-    When updating a polymorphic association, the old `foreign_type` was not inferred correctly when:
-    1. `touch`ing the previously associated record
-    2. updating the previously associated record's `counter_cache`
+    The default `ActiveRecord::Encryption::MessageSerializer` already ensures that only `String` objects are passed for deserialization.
 
-    *Jimmy Bourassa*
+    *Maxime Réty*
 
-*   Add config option for ignoring tables when dumping the schema cache.
+*   Fix `encrypted_attribute?` to take into account context properties passed to `encrypts`.
 
-    Applications can now be configured to ignore certain tables when dumping the schema cache.
+    *Maxime Réty*
 
-    The configuration option can table an array of tables:
+*   The object returned by `explain` now responds to `pluck`, `first`,
+    `last`, `average`, `count`, `maximum`, `minimum`, and `sum`. Those
+    new methods run `EXPLAIN` on the corresponding queries:
 
     ```ruby
-    config.active_record.schema_cache_ignored_tables = ["ignored_table", "another_ignored_table"]
-    ```
-
-    Or a regex:
+    User.all.explain.count
+    # EXPLAIN SELECT COUNT(*) FROM `users`
+    # ...
 
-    ```ruby
-    config.active_record.schema_cache_ignored_tables = [/^_/]
+    User.all.explain.maximum(:id)
+    # EXPLAIN SELECT MAX(`users`.`id`) FROM `users`
+    # ...
     ```
 
-    *Eileen M. Uchitelle*
-
-*   Make schema cache methods return consistent results.
-
-    Previously the schema cache methods `primary_keys`, `columns`, `columns_hash`, and `indexes`
-    would behave differently than one another when a table didn't exist and differently across
-    database adapters. This change unifies the behavior so each method behaves the same regardless
-    of adapter.
-
-    The behavior now is:
-
-    `columns`: (unchanged) raises a db error if the table does not exist.
-    `columns_hash`: (unchanged) raises a db error if the table does not exist.
-    `primary_keys`: (unchanged) returns `nil` if the table does not exist.
-    `indexes`: (changed for mysql2) returns `[]` if the table does not exist.
-
-    *Eileen M. Uchitelle*
-
-*   Reestablish connection to previous database after after running `db:schema:load:name`
+    *Petrik de Heus*
 
-    After running `db:schema:load:name` the previous connection is restored.
+*   Fixes an issue where `validates_associated` `:on`  option wasn't respected
+    when validating associated records.
 
-    *Jacopo Beschi*
+    *Austen Madden*, *Alex Ghiculescu*, *Rafał Brize*
 
-*   Add database config option `database_tasks`
+*   Allow overriding SQLite defaults from `database.yml`.
 
-    If you would like to connect to an external database without any database
-    management tasks such as schema management, migrations, seeds, etc. you can set
-    the per database config option `database_tasks: false`
+    Any PRAGMA configuration set under the `pragmas` key in the configuration
+    file takes precedence over Rails' defaults, and additional PRAGMAs can be
+    set as well.
 
     ```yaml
-    # config/database.yml
-
-    production:
-      primary:
-        database: my_database
-        adapter: mysql2
-      animals:
-        database: my_animals_database
-        adapter: mysql2
-        database_tasks: false
+    database: storage/development.sqlite3
+    timeout: 5000
+    pragmas:
+      journal_mode: off
+      temp_store: memory
     ```
 
-    *Weston Ganger*
+    *Stephen Margheim*
 
-*   Fix `ActiveRecord::InternalMetadata` to not be broken by `config.active_record.record_timestamps = false`
+*   Remove warning message when running SQLite in production, but leave it unconfigured.
 
-    Since the model always create the timestamp columns, it has to set them, otherwise it breaks
-    various DB management tasks.
+    There are valid use cases for running SQLite in production. However, it must be done
+    with care, so instead of a warning most users won't see anyway, it's preferable to
+    leave the configuration commented out to force them to think about having the database
+    on a persistent volume etc.
 
-    Fixes #42983
+    *Jacopo Beschi*, *Jean Boussier*
 
-*   Add `ActiveRecord::QueryLogs`.
+*   Add support for generated columns to the SQLite3 adapter.
 
-    Configurable tags can be automatically added to all SQL queries generated by Active Record.
+    Generated columns (both stored and dynamic) are supported since version 3.31.0 of SQLite.
+    This adds support for those to the SQLite3 adapter.
 
     ```ruby
-    # config/application.rb
-    module MyApp
-      class Application < Rails::Application
-        config.active_record.query_log_tags_enabled = true
-      end
-    end
-    ```
-
-    By default the application, controller and action details are added to the query tags:
-
-    ```ruby
-    class BooksController < ApplicationController
-      def index
-        @books = Book.all
-      end
+    create_table :users do |t|
+      t.string :name
+      t.virtual :name_upper, type: :string, as: 'UPPER(name)'
+      t.virtual :name_lower, type: :string, as: 'LOWER(name)', stored: true
     end
     ```
 
-    ```ruby
-    GET /books
-    # SELECT * FROM books /*application:MyApp;controller:books;action:index*/
-    ```
-
-    Custom tags containing static values and Procs can be defined in the application configuration:
-
-    ```ruby
-    config.active_record.query_log_tags = [
-      :application,
-      :controller,
-      :action,
-      {
-        custom_static: "foo",
-        custom_dynamic: -> { Time.now }
-      }
-    ]
-    ```
-
-    *Keeran Raj Hawoldar*, *Eileen M. Uchitelle*, *Kasper Timm Hansen*
-
-*   Added support for multiple databases to `rails db:setup` and `rails db:reset`.
-
-    *Ryan Hall*
-
-*   Add `ActiveRecord::Relation#structurally_compatible?`.
-
-    Adds a query method by which a user can tell if the relation that they're
-    about to use for `#or` or `#and` is structurally compatible with the
-    receiver.
-
-    *Kevin Newton*
-
-*   Add `ActiveRecord::QueryMethods#in_order_of`.
-
-    This allows you to specify an explicit order that you'd like records
-    returned in based on a SQL expression. By default, this will be accomplished
-    using a case statement, as in:
-
-    ```ruby
-    Post.in_order_of(:id, [3, 5, 1])
-    ```
-
-    will generate the SQL:
-
-    ```sql
-    SELECT "posts".* FROM "posts" ORDER BY CASE "posts"."id" WHEN 3 THEN 1 WHEN 5 THEN 2 WHEN 1 THEN 3 ELSE 4 END ASC
-    ```
-
-    However, because this functionality is built into MySQL in the form of the
-    `FIELD` function, that connection adapter will generate the following SQL
-    instead:
-
-    ```sql
-    SELECT "posts".* FROM "posts" ORDER BY FIELD("posts"."id", 1, 5, 3) DESC
-    ```
-
-    *Kevin Newton*
-
-*   Fix `eager_loading?` when ordering with `Symbol`.
-
-    `eager_loading?` is triggered correctly when using `order` with symbols.
-
-    ```ruby
-    scope = Post.includes(:comments).order(:"comments.label")
-    => true
-    ```
-
-    *Jacopo Beschi*
-
-*   Two change tracking methods are added for `belongs_to` associations.
-
-    The `association_changed?` method (assuming an association named `:association`) returns true
-    if a different associated object has been assigned and the foreign key will be updated in the
-    next save.
-
-    The `association_previously_changed?` method returns true if the previous save updated the
-    association to reference a different associated object.
-
-    *George Claghorn*
+    *Stephen Margheim*
 
-*   Add option to disable schema dump per-database.
+*   TrilogyAdapter: ignore `host` if `socket` parameter is set.
 
-    Dumping the schema is on by default for all databases in an application. To turn it off for a
-    specific database, use the `schema_dump` option:
+    This allows to configure a connection on a UNIX socket via `DATABASE_URL`:
 
-    ```yaml
-    # config/database.yml
-
-    production:
-      schema_dump: false
     ```
-
-    *Luis Vasconcellos*, *Eileen M. Uchitelle*
-
-*   Fix `eager_loading?` when ordering with `Hash` syntax.
-
-    `eager_loading?` is triggered correctly when using `order` with hash syntax
-    on an outer table.
-
-    ```ruby
-    Post.includes(:comments).order({ "comments.label": :ASC }).eager_loading?
-    # => true
+    DATABASE_URL=trilogy://does-not-matter/my_db_production?socket=/var/run/mysql.sock
     ```
 
-    *Jacopo Beschi*
-
-*   Move the forcing of clear text encoding to the `ActiveRecord::Encryption::Encryptor`.
-
-    Fixes #42699.
-
-    *J Smith*
-
-*   `partial_inserts` is now disabled by default in new apps.
-
-    This will be the default for new apps in Rails 7. To opt in:
-
-    ```ruby
-    config.active_record.partial_inserts = true
-    ```
-
-    If a migration removes the default value of a column, this option
-    would cause old processes to no longer be able to create new records.
-
-    If you need to remove a column, you should first use `ignored_columns`
-    to stop using it.
-
     *Jean Boussier*
 
-*   Rails can now verify foreign keys after loading fixtures in tests.
-
-    This will be the default for new apps in Rails 7. To opt in:
-
-    ```ruby
-    config.active_record.verify_foreign_keys_for_fixtures = true
-    ```
-
-    Tests will not run if there is a foreign key constraint violation in your fixture data.
+*   Make `assert_queries_count`, `assert_no_queries`, `assert_queries_match`, and
+    `assert_no_queries_match` assertions public.
 
-    The feature is supported by SQLite and PostgreSQL, other adapters can also add support for it.
-
-    *Alex Ghiculescu*
-
-*   Clear cached `has_one` association after setting `belongs_to` association to `nil`.
-
-    After setting a `belongs_to` relation to `nil` and updating an unrelated attribute on the owner,
-    the owner should still return `nil` on the `has_one` relation.
-
-    Fixes #42597.
-
-    *Michiel de Mare*
-
-*   OpenSSL constants are now used for Digest computations.
-
-    *Dirkjan Bussink*
-
-*   Adds support for `if_not_exists` to `add_foreign_key` and `if_exists` to `remove_foreign_key`.
-
-    Applications can set their migrations to ignore exceptions raised when adding a foreign key
-    that already exists or when removing a foreign key that does not exist.
-
-    Example Usage:
+    To assert the expected number of queries are made, Rails internally uses `assert_queries_count` and
+    `assert_no_queries`. To assert that specific SQL queries are made, `assert_queries_match` and
+    `assert_no_queries_match` are used. These assertions can now be used in applications as well.
 
     ```ruby
-    class AddAuthorsForeignKeyToArticles < ActiveRecord::Migration[7.0]
-      def change
-        add_foreign_key :articles, :authors, if_not_exists: true
+    class ArticleTest < ActiveSupport::TestCase
+      test "queries are made" do
+        assert_queries_count(1) { Article.first }
       end
-    end
-    ```
 
-    ```ruby
-    class RemoveAuthorsForeignKeyFromArticles < ActiveRecord::Migration[7.0]
-      def change
-        remove_foreign_key :articles, :authors, if_exists: true
+      test "creates a foreign key" do
+        assert_queries_match(/ADD FOREIGN KEY/i, include_schema: true) do
+          @connection.add_foreign_key(:comments, :posts)
+        end
       end
     end
     ```
 
-    *Roberto Miranda*
-
-*   Prevent polluting ENV during postgresql structure dump/load.
-
-    Some configuration parameters were provided to pg_dump / psql via
-    environment variables which persisted beyond the command being run, and may
-    have caused subsequent commands and connections to fail. Tasks running
-    across multiple postgresql databases like `rails db:test:prepare` may have
-    been affected.
-
-    *Samuel Cochran*
-
-*   Set precision 6 by default for `datetime` columns.
-
-    By default, datetime columns will have microseconds precision instead of seconds precision.
-
-    *Roberto Miranda*
-
-*   Allow preloading of associations with instance dependent scopes.
-
-    *John Hawthorn*, *John Crepezzi*, *Adam Hess*, *Eileen M. Uchitelle*, *Dinah Shi*
-
-*   Do not try to rollback transactions that failed due to a `ActiveRecord::TransactionRollbackError`.
-
-    *Jamie McCarthy*
-
-*   Active Record Encryption will now encode values as UTF-8 when using deterministic
-    encryption. The encoding is part of the encrypted payload, so different encodings for
-    different values result in different ciphertexts. This can break unique constraints and
-    queries.
-
-    The new behavior is configurable via `active_record.encryption.forced_encoding_for_deterministic_encryption`
-    that is `Encoding::UTF_8` by default. It can be disabled by setting it to `nil`.
-
-    *Jorge Manrubia*
-
-*   The MySQL adapter now cast numbers and booleans bind parameters to string for safety reasons.
-
-    When comparing a string and a number in a query, MySQL converts the string to a number. So for
-    instance `"foo" = 0`, will implicitly cast `"foo"` to `0` and will evaluate to `TRUE` which can
-    lead to security vulnerabilities.
-
-    Active Record already protect against that vulnerability when it knows the type of the column
-    being compared, however until now it was still vulnerable when using bind parameters:
-
-    ```ruby
-    User.where("login_token = ?", 0).first
-    ```
-
-    Would perform:
-
-    ```sql
-    SELECT * FROM `users` WHERE `login_token` = 0 LIMIT 1;
-    ```
-
-    Now it will perform:
-
-    ```sql
-    SELECT * FROM `users` WHERE `login_token` = '0' LIMIT 1;
-    ```
-
-    *Jean Boussier*
-
-*   Fixture configurations (`_fixture`) are now strictly validated.
-
-    If an error will be raised if that entry contains unknown keys while previously it
-    would silently have no effects.
-
-    *Jean Boussier*
-
-*   Add `ActiveRecord::Base.update!` that works like `ActiveRecord::Base.update` but raises exceptions.
-
-    This allows for the same behavior as the instance method `#update!` at a class level.
-
-    ```ruby
-    Person.update!(:all, state: "confirmed")
-    ```
-
-    *Dorian Marié*
-
-*   Add `ActiveRecord::Base#attributes_for_database`.
-
-    Returns attributes with values for assignment to the database.
-
-    *Chris Salzberg*
-
-*   Use an empty query to check if the PostgreSQL connection is still active.
-
-    An empty query is faster than `SELECT 1`.
-
-    *Heinrich Lee Yu*
-
-*   Add `ActiveRecord::Base#previously_persisted?`.
-
-    Returns `true` if the object has been previously persisted but now it has been deleted.
-
-*   Deprecate `partial_writes` in favor of `partial_inserts` and `partial_updates`.
-
-    This allows to have a different behavior on update and create.
+    *Petrik de Heus*, *fatkodima*
 
-    *Jean Boussier*
-
-*   Fix compatibility with `psych >= 4`.
-
-    Starting in Psych 4.0.0 `YAML.load` behaves like `YAML.safe_load`. To preserve compatibility,
-    Active Record's schema cache loader and `YAMLColumn` now uses `YAML.unsafe_load` if available.
-
-    *Jean Boussier*
-
-*   `ActiveRecord::Base.logger` is now a `class_attribute`.
-
-    This means it can no longer be accessed directly through `@@logger`, and that setting `logger =`
-    on a subclass won't change the parent's logger.
-
-    *Jean Boussier*
-
-*   Add `.asc.nulls_first` for all databases. Unfortunately MySQL still doesn't like `nulls_last`.
-
-    *Keenan Brock*
-
-*   Improve performance of `one?` and `many?` by limiting the generated count query to 2 results.
-
-    *Gonzalo Riestra*
-
-*   Don't check type when using `if_not_exists` on `add_column`.
-
-    Previously, if a migration called `add_column` with the `if_not_exists` option set to true
-    the `column_exists?` check would look for a column with the same name and type as the migration.
-
-    Recently it was discovered that the type passed to the migration is not always the same type
-    as the column after migration. For example a column set to `:mediumblob` in the migration will
-    be casted to `binary` when calling `column.type`. Since there is no straightforward way to cast
-    the type to the database type without running the migration, we opted to drop the type check from
-    `add_column`. This means that migrations adding a duplicate column with a different type will no
-    longer raise an error.
+*   Fix `has_secure_token` calls the setter method on initialize.
 
-    *Eileen M. Uchitelle*
-
-*   Log a warning message when running SQLite in production.
-
-    Using SQLite in production ENV is generally discouraged. SQLite is also the default adapter
-    in a new Rails application.
-    For the above reasons log a warning message when running SQLite in production.
-
-    The warning can be disabled by setting `config.active_record.sqlite3_production_warning=false`.
-
-    *Jacopo Beschi*
-
-*   Add option to disable joins for `has_one` associations.
-
-    In a multiple database application, associations can't join across
-    databases. When set, this option instructs Rails to generate 2 or
-    more queries rather than generating joins for `has_one` associations.
-
-    Set the option on a has one through association:
-
-    ```ruby
-    class Person
-      has_one :dog
-      has_one :veterinarian, through: :dog, disable_joins: true
-    end
-    ```
-
-    Then instead of generating join SQL, two queries are used for `@person.veterinarian`:
-
-    ```
-    SELECT "dogs"."id" FROM "dogs" WHERE "dogs"."person_id" = ?  [["person_id", 1]]
-    SELECT "veterinarians".* FROM "veterinarians" WHERE "veterinarians"."dog_id" = ?  [["dog_id", 1]]
-    ```
-
-    *Sarah Vessels*, *Eileen M. Uchitelle*
-
-*   `Arel::Visitors::Dot` now renders a complete set of properties when visiting
-    `Arel::Nodes::SelectCore`, `SelectStatement`, `InsertStatement`, `UpdateStatement`, and
-    `DeleteStatement`, which fixes #42026. Previously, some properties were omitted.
-
-    *Mike Dalessio*
-
-*   `Arel::Visitors::Dot` now supports `Arel::Nodes::Bin`, `Case`, `CurrentRow`, `Distinct`,
-    `DistinctOn`, `Else`, `Except`, `InfixOperation`, `Intersect`, `Lock`, `NotRegexp`, `Quoted`,
-    `Regexp`, `UnaryOperation`, `Union`, `UnionAll`, `When`, and `With`. Previously, these node
-    types caused an exception to be raised by `Arel::Visitors::Dot#accept`.
-
-    *Mike Dalessio*
-
-*   Optimize `remove_columns` to use a single SQL statement.
-
-    ```ruby
-    remove_columns :my_table, :col_one, :col_two
-    ```
-
-    Now results in the following SQL:
-
-    ```sql
-    ALTER TABLE "my_table" DROP COLUMN "col_one", DROP COLUMN "col_two"
-    ```
-
-    *Jon Dufresne*
-
-*   Ensure `has_one` autosave association callbacks get called once.
-
-    Change the `has_one` autosave callback to be non cyclic as well.
-    By doing this the autosave callback are made more consistent for
-    all 3 cases: `has_many`, `has_one`, and `belongs_to`.
-
-    *Petrik de Heus*
-
-*   Add option to disable joins for associations.
-
-    In a multiple database application, associations can't join across
-    databases. When set, this option instructs Rails to generate 2 or
-    more queries rather than generating joins for associations.
-
-    Set the option on a has many through association:
-
-    ```ruby
-    class Dog
-      has_many :treats, through: :humans, disable_joins: true
-      has_many :humans
-    end
-    ```
-
-    Then instead of generating join SQL, two queries are used for `@dog.treats`:
-
-    ```
-    SELECT "humans"."id" FROM "humans" WHERE "humans"."dog_id" = ?  [["dog_id", 1]]
-    SELECT "treats".* FROM "treats" WHERE "treats"."human_id" IN (?, ?, ?)  [["human_id", 1], ["human_id", 2], ["human_id", 3]]
-    ```
-
-    *Eileen M. Uchitelle*, *Aaron Patterson*, *Lee Quarella*
-
-*   Add setting for enumerating column names in SELECT statements.
-
-    Adding a column to a PostgreSQL database, for example, while the application is running can
-    change the result of wildcard `SELECT *` queries, which invalidates the result
-    of cached prepared statements and raises a `PreparedStatementCacheExpired` error.
-
-    When enabled, Active Record will avoid wildcards and always include column names
-    in `SELECT` queries, which will return consistent results and avoid prepared
-    statement errors.
-
-    Before:
-
-    ```ruby
-    Book.limit(5)
-    # SELECT * FROM books LIMIT 5
-    ```
-
-    After:
-
-    ```ruby
-    # config/application.rb
-    module MyApp
-      class Application < Rails::Application
-        config.active_record.enumerate_columns_in_select_statements = true
-      end
-    end
-
-    # or, configure per-model
-    class Book < ApplicationRecord
-      self.enumerate_columns_in_select_statements = true
-    end
-    ```
-
-    ```ruby
-    Book.limit(5)
-    # SELECT id, author_id, name, format, status, language, etc FROM books LIMIT 5
-    ```
-
-    *Matt Duszynski*
-
-*   Allow passing SQL as `on_duplicate` value to `#upsert_all` to make it possible to use raw SQL to update columns on conflict:
-
-    ```ruby
-    Book.upsert_all(
-      [{ id: 1, status: 1 }, { id: 2, status: 1 }],
-      on_duplicate: Arel.sql("status = GREATEST(books.status, EXCLUDED.status)")
-    )
-    ```
-
-    *Vladimir Dementyev*
-
-*   Allow passing SQL as `returning` statement to `#upsert_all`:
-
-    ```ruby
-    Article.insert_all(
-      [
-        { title: "Article 1", slug: "article-1", published: false },
-        { title: "Article 2", slug: "article-2", published: false }
-      ],
-      returning: Arel.sql("id, (xmax = '0') as inserted, name as new_name")
-    )
-    ```
-
-    *Vladimir Dementyev*
-
-*   Deprecate `legacy_connection_handling`.
-
-    *Eileen M. Uchitelle*
-
-*   Add attribute encryption support.
-
-    Encrypted attributes are declared at the model level. These
-    are regular Active Record attributes backed by a column with
-    the same name. The system will transparently encrypt these
-    attributes before saving them into the database and will
-    decrypt them when retrieving their values.
-
-
-    ```ruby
-    class Person < ApplicationRecord
-      encrypts :name
-      encrypts :email_address, deterministic: true
-    end
-    ```
-
-    You can learn more in the [Active Record Encryption
-    guide](https://edgeguides.rubyonrails.org/active_record_encryption.html).
-
-    *Jorge Manrubia*
-
-*   Changed Arel predications `contains` and `overlaps` to use
-    `quoted_node` so that PostgreSQL arrays are quoted properly.
-
-    *Bradley Priest*
-
-*   Add mode argument to record level `strict_loading!`.
-
-    This argument can be used when enabling strict loading for a single record
-    to specify that we only want to raise on n plus one queries.
-
-    ```ruby
-    developer.strict_loading!(mode: :n_plus_one_only)
-
-    developer.projects.to_a # Does not raise
-    developer.projects.first.client # Raises StrictLoadingViolationError
-    ```
-
-    Previously, enabling strict loading would cause any lazily loaded
-    association to raise an error. Using `n_plus_one_only` mode allows us to
-    lazily load belongs_to, has_many, and other associations that are fetched
-    through a single query.
-
-    *Dinah Shi*
-
-*   Fix Float::INFINITY assignment to datetime column with postgresql adapter.
-
-    Before:
-
-    ```ruby
-    # With this config
-    ActiveRecord::Base.time_zone_aware_attributes = true
-
-    # and the following schema:
-    create_table "postgresql_infinities" do |t|
-      t.datetime "datetime"
-    end
-
-    # This test fails
-    record = PostgresqlInfinity.create!(datetime: Float::INFINITY)
-    assert_equal Float::INFINITY, record.datetime # record.datetime gets nil
-    ```
-
-    After this commit, `record.datetime` gets `Float::INFINITY` as expected.
-
-    *Shunichi Ikegami*
-
-*   Type cast enum values by the original attribute type.
-
-    The notable thing about this change is that unknown labels will no longer match 0 on MySQL.
-
-    ```ruby
-    class Book < ActiveRecord::Base
-      enum :status, { proposed: 0, written: 1, published: 2 }
-    end
-    ```
-
-    Before:
-
-    ```ruby
-    # SELECT `books`.* FROM `books` WHERE `books`.`status` = 'prohibited' LIMIT 1
-    Book.find_by(status: :prohibited)
-    # => #<Book id: 1, status: "proposed", ...> (for mysql2 adapter)
-    # => ActiveRecord::StatementInvalid: PG::InvalidTextRepresentation: ERROR:  invalid input syntax for type integer: "prohibited" (for postgresql adapter)
-    # => nil (for sqlite3 adapter)
-    ```
-
-    After:
-
-    ```ruby
-    # SELECT `books`.* FROM `books` WHERE `books`.`status` IS NULL LIMIT 1
-    Book.find_by(status: :prohibited)
-    # => nil (for all adapters)
-    ```
-
-    *Ryuta Kamizono*
-
-*   Fixtures for `has_many :through` associations now load timestamps on join tables.
-
-    Given this fixture:
-
-    ```yml
-    ### monkeys.yml
-    george:
-      name: George the Monkey
-      fruits: apple
-
-    ### fruits.yml
-    apple:
-      name: apple
-    ```
-
-    If the join table (`fruit_monkeys`) contains `created_at` or `updated_at` columns,
-    these will now be populated when loading the fixture. Previously, fixture loading
-    would crash if these columns were required, and leave them as null otherwise.
-
-    *Alex Ghiculescu*
-
-*   Allow applications to configure the thread pool for async queries.
-
-    Some applications may want one thread pool per database whereas others want to use
-    a single global thread pool for all queries. By default, Rails will set `async_query_executor`
-    to `nil` which will not initialize any executor. If `load_async` is called and no executor
-    has been configured, the query will be executed in the foreground.
-
-    To create one thread pool for all database connections to use applications can set
-    `config.active_record.async_query_executor` to `:global_thread_pool` and optionally define
-    `config.active_record.global_executor_concurrency`. This defaults to 4. For applications that want
-    to have a thread pool for each database connection, `config.active_record.async_query_executor` can
-    be set to `:multi_thread_pool`. The configuration for each thread pool is set in the database
-    configuration.
-
-    *Eileen M. Uchitelle*
-
-*   Allow new syntax for `enum` to avoid leading `_` from reserved options.
-
-    Before:
-
-    ```ruby
-    class Book < ActiveRecord::Base
-      enum status: [ :proposed, :written ], _prefix: true, _scopes: false
-      enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
-    end
-    ```
-
-    After:
-
-    ```ruby
-    class Book < ActiveRecord::Base
-      enum :status, [ :proposed, :written ], prefix: true, scopes: false
-      enum :cover, [ :hard, :soft ], suffix: true, default: :hard
-    end
-    ```
-
-    *Ryuta Kamizono*
-
-*   Add `ActiveRecord::Relation#load_async`.
-
-    This method schedules the query to be performed asynchronously from a thread pool.
-
-    If the result is accessed before a background thread had the opportunity to perform
-    the query, it will be performed in the foreground.
-
-    This is useful for queries that can be performed long enough before their result will be
-    needed, or for controllers which need to perform several independent queries.
-
-    ```ruby
-    def index
-      @categories = Category.some_complex_scope.load_async
-      @posts = Post.some_complex_scope.load_async
-    end
-    ```
-
-    Active Record logs will also include timing info for the duration of how long
-    the main thread had to wait to access the result. This timing is useful to know
-    whether or not it's worth to load the query asynchronously.
-
-    ```
-    DEBUG -- :   Category Load (62.1ms)  SELECT * FROM `categories` LIMIT 50
-    DEBUG -- :   ASYNC Post Load (64ms) (db time 126.1ms)  SELECT * FROM `posts` LIMIT 100
-    ```
-
-    The duration in the first set of parens is how long the main thread was blocked
-    waiting for the results, and the second set of parens with "db time" is how long
-    the entire query took to execute.
-
-    *Jean Boussier*
-
-*   Implemented `ActiveRecord::Relation#excluding` method.
-
-    This method excludes the specified record (or collection of records) from
-    the resulting relation:
-
-    ```ruby
-    Post.excluding(post)
-    Post.excluding(post_one, post_two)
-    ```
-
-    Also works on associations:
-
-    ```ruby
-    post.comments.excluding(comment)
-    post.comments.excluding(comment_one, comment_two)
-    ```
-
-    This is short-hand for `Post.where.not(id: post.id)` (for a single record)
-    and `Post.where.not(id: [post_one.id, post_two.id])` (for a collection).
-
-    *Glen Crawford*
-
-*   Skip optimised #exist? query when #include? is called on a relation
-    with a having clause.
-
-    Relations that have aliased select values AND a having clause that
-    references an aliased select value would generate an error when
-    #include? was called, due to an optimisation that would generate
-    call #exists? on the relation instead, which effectively alters
-    the select values of the query (and thus removes the aliased select
-    values), but leaves the having clause intact. Because the having
-    clause is then referencing an aliased column that is no longer
-    present in the simplified query, an ActiveRecord::InvalidStatement
-    error was raised.
-
-    A sample query affected by this problem:
-
-    ```ruby
-    Author.select('COUNT(*) as total_posts', 'authors.*')
-          .joins(:posts)
-          .group(:id)
-          .having('total_posts > 2')
-          .include?(Author.first)
-    ```
-
-    This change adds an addition check to the condition that skips the
-    simplified #exists? query, which simply checks for the presence of
-    a having clause.
-
-    Fixes #41417.
-
-    *Michael Smart*
-
-*   Increment postgres prepared statement counter before making a prepared statement, so if the statement is aborted
-    without Rails knowledge (e.g., if app gets killed during long-running query or due to Rack::Timeout), app won't end
-    up in perpetual crash state for being inconsistent with PostgreSQL.
-
-    *wbharding*, *Martin Tepper*
-
-*   Add ability to apply `scoping` to `all_queries`.
-
-    Some applications may want to use the `scoping` method but previously it only
-    worked on certain types of queries. This change allows the `scoping` method to apply
-    to all queries for a model in a block.
-
-    ```ruby
-    Post.where(blog_id: post.blog_id).scoping(all_queries: true) do
-      post.update(title: "a post title") # adds `posts.blog_id = 1` to the query
-    end
-    ```
-
-    *Eileen M. Uchitelle*
-
-*   `ActiveRecord::Calculations.calculate` called with `:average`
-    (aliased as `ActiveRecord::Calculations.average`) will now use column-based
-    type casting. This means that floating-point number columns will now be
-    aggregated as `Float` and decimal columns will be aggregated as `BigDecimal`.
+    *Abeid Ahmed*
 
-    Integers are handled as a special case returning `BigDecimal` always
-    (this was the case before already).
+*   When using a `DATABASE_URL`, allow for a configuration to map the protocol in the URL to a specific database
+    adapter. This allows decoupling the adapter the application chooses to use from the database connection details
+    set in the deployment environment.
 
     ```ruby
-    # With the following schema:
-    create_table "measurements" do |t|
-      t.float "temperature"
-    end
-
-    # Before:
-    Measurement.average(:temperature).class
-    # => BigDecimal
-
-    # After:
-    Measurement.average(:temperature).class
-    # => Float
+    # ENV['DATABASE_URL'] = "mysql://localhost/example_database"
+    config.active_record.protocol_adapters.mysql = "trilogy"
+    # will connect to MySQL using the trilogy adapter
     ```
 
-    Before this change, Rails just called `to_d` on average aggregates from the
-    database adapter. This is not the case anymore. If you relied on that kind
-    of magic, you now need to register your own `ActiveRecord::Type`
-    (see `ActiveRecord::Attributes::ClassMethods` for documentation).
-
-    *Josua Schmid*
-
-*   PostgreSQL: introduce `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type`.
-
-    This setting controls what native type Active Record should use when you call `datetime` in
-    a migration or schema. It takes a symbol which must correspond to one of the configured
-    `NATIVE_DATABASE_TYPES`. The default is `:timestamp`, meaning `t.datetime` in a migration
-    will create a "timestamp without time zone" column. To use "timestamp with time zone",
-    change this to `:timestamptz` in an initializer.
-
-    You should run `bin/rails db:migrate` to rebuild your schema.rb if you change this.
+    *Jean Boussier*, *Kevin McPhillips*
 
-    *Alex Ghiculescu*
+*   In cases where MySQL returns `warning_count` greater than zero, but returns no warnings when
+    the `SHOW WARNINGS` query is executed, `ActiveRecord.db_warnings_action` proc will still be
+    called with a generic warning message rather than silently ignoring the warning(s).
 
-*   PostgreSQL: handle `timestamp with time zone` columns correctly in `schema.rb`.
+    *Kevin McPhillips*
 
-    Previously they dumped as `t.datetime :column_name`, now they dump as `t.timestamptz :column_name`,
-    and are created as `timestamptz` columns when the schema is loaded.
+*   `DatabaseConfigurations#configs_for` accepts a symbol in the `name` parameter.
 
-    *Alex Ghiculescu*
+    *Andrew Novoselac*
 
-*   Removing trailing whitespace when matching columns in
-    `ActiveRecord::Sanitization.disallow_raw_sql!`.
+*   Fix `where(field: values)` queries when `field` is a serialized attribute
+    (for example, when `field` uses `ActiveRecord::Base.serialize` or is a JSON
+    column).
 
-    *Gannon McGibbon*, *Adrian Hirt*
+    *João Alves*
 
-*   Expose a way for applications to set a `primary_abstract_class`.
+*   Make the output of `ActiveRecord::Core#inspect` configurable.
 
-    Multiple database applications that use a primary abstract class that is not
-    named `ApplicationRecord` can now set a specific class to be the `primary_abstract_class`.
+    By default, calling `inspect` on a record will yield a formatted string including just the `id`.
 
     ```ruby
-    class PrimaryApplicationRecord
-      self.primary_abstract_class
-    end
+    Post.first.inspect #=> "#<Post id: 1>"
     ```
 
-    When an application boots it automatically connects to the primary or first database in the
-    database configuration file. In a multiple database application that then call `connects_to`
-    needs to know that the default connection is the same as the `ApplicationRecord` connection.
-    However, some applications have a differently named `ApplicationRecord`. This prevents Active
-    Record from opening duplicate connections to the same database.
-
-    *Eileen M. Uchitelle*, *John Crepezzi*
-
-*   Support hash config for `structure_dump_flags` and `structure_load_flags` flags.
-    Now that Active Record supports multiple databases configuration,
-    we need a way to pass specific flags for dump/load databases since
-    the options are not the same for different adapters.
-    We can use in the original way:
+    The attributes to be included in the output of `inspect` can be configured with
+    `ActiveRecord::Core#attributes_for_inspect`.
 
     ```ruby
-    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = ['--no-defaults', '--skip-add-drop-table']
-    # or
-    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = '--no-defaults --skip-add-drop-table'
+    Post.attributes_for_inspect = [:id, :title]
+    Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!">"
     ```
 
-    And also use it passing a hash, with one or more keys, where the key
-    is the adapter
+    With `attributes_for_inspect` set to `:all`, `inspect` will list all the record's attributes.
 
     ```ruby
-    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = {
-      mysql2: ['--no-defaults', '--skip-add-drop-table'],
-      postgres: '--no-tablespaces'
-    }
+    Post.attributes_for_inspect = :all
+    Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
     ```
 
-    *Gustavo Gonzalez*
-
-*   Connection specification now passes the "url" key as a configuration for the
-    adapter if the "url" protocol is "jdbc", "http", or "https". Previously only
-    urls with the "jdbc" prefix were passed to the Active Record Adapter, others
-    are assumed to be adapter specification urls.
-
-    Fixes #41137.
-
-    *Jonathan Bracy*
+    In `development` and `test` mode, `attributes_for_inspect` will be set to `:all` by default.
 
-*   Allow to opt-out of `strict_loading` mode on a per-record base.
+    You can also call `full_inspect` to get an inspection with all the attributes.
 
-    This is useful when strict loading is enabled application wide or on a
-    model level.
+    The attributes in `attribute_for_inspect` will also be used for `pretty_print`.
 
-    ```ruby
-    class User < ApplicationRecord
-      has_many :bookmarks
-      has_many :articles, strict_loading: true
-    end
+    *Andrew Novoselac*
 
-    user = User.first
-    user.articles                        # => ActiveRecord::StrictLoadingViolationError
-    user.bookmarks                       # => #<ActiveRecord::Associations::CollectionProxy>
+*   Don't mark attributes as changed when reassigned to `Float::INFINITY` or
+    `-Float::INFINITY`.
 
-    user.strict_loading!(true)           # => true
-    user.bookmarks                       # => ActiveRecord::StrictLoadingViolationError
+    *Maicol Bentancor*
 
-    user.strict_loading!(false)          # => false
-    user.bookmarks                       # => #<ActiveRecord::Associations::CollectionProxy>
-    user.articles.strict_loading!(false) # => #<ActiveRecord::Associations::CollectionProxy>
-    ```
+*   Support the `RETURNING` clause for MariaDB.
 
-    *Ayrton De Craene*
+    *fatkodima*, *Nikolay Kondratyev*
 
-*   Add `FinderMethods#sole` and `#find_sole_by` to find and assert the
-    presence of exactly one record.
+*   The SQLite3 adapter now implements the `supports_deferrable_constraints?` contract.
 
-    Used when you need a single row, but also want to assert that there aren't
-    multiple rows matching the condition; especially for when database
-    constraints aren't enough or are impractical.
+    Allows foreign keys to be deferred by adding the `:deferrable` key to the `foreign_key` options.
 
     ```ruby
-    Product.where(["price = %?", price]).sole
-    # => ActiveRecord::RecordNotFound      (if no Product with given price)
-    # => #<Product ...>                    (if one Product with given price)
-    # => ActiveRecord::SoleRecordExceeded  (if more than one Product with given price)
-
-    user.api_keys.find_sole_by(key: key)
-    # as above
+    add_reference :person, :alias, foreign_key: { deferrable: :deferred }
+    add_reference :alias, :person, foreign_key: { deferrable: :deferred }
     ```
 
-    *Asherah Connor*
-
-*   Makes `ActiveRecord::AttributeMethods::Query` respect the getter overrides defined in the model.
+    *Stephen Margheim*
 
-    Before:
+*   Add the `set_constraints` helper to PostgreSQL connections.
 
     ```ruby
-    class User
-      def admin
-        false # Overriding the getter to always return false
-      end
-    end
-
-    user = User.first
-    user.update(admin: true)
-
-    user.admin # false (as expected, due to the getter overwrite)
-    user.admin? # true (not expected, returned the DB column value)
-    ```
-
-    After this commit, `user.admin?` above returns false, as expected.
-
-    Fixes #40771.
-
-    *Felipe*
+    Post.create!(user_id: -1) # => ActiveRecord::InvalidForeignKey
 
-*   Allow delegated_type to be specified primary_key and foreign_key.
-
-    Since delegated_type assumes that the foreign_key ends with `_id`,
-    `singular_id` defined by it does not work when the foreign_key does
-    not end with `id`. This change fixes it by taking into account
-    `primary_key` and `foreign_key` in the options.
-
-    *Ryota Egusa*
-
-*   Expose an `invert_where` method that will invert all scope conditions.
-
-    ```ruby
-    class User
-      scope :active, -> { where(accepted: true, locked: false) }
+    Post.transaction do
+      Post.connection.set_constraints(:deferred)
+      p = Post.create!(user_id: -1)
+      u = User.create!
+      p.user = u
+      p.save!
     end
-
-    User.active
-    # ... WHERE `accepted` = 1 AND `locked` = 0
-
-    User.active.invert_where
-    # ... WHERE NOT (`accepted` = 1 AND `locked` = 0)
-    ```
-
-    *Kevin Deisz*
-
-*   Restore possibility of passing `false` to :polymorphic option of `belongs_to`.
-
-    Previously, passing `false` would trigger the option validation logic
-    to throw an error saying :polymorphic would not be a valid option.
-
-    *glaszig*
-
-*   Remove deprecated `database` kwarg from `connected_to`.
-
-    *Eileen M. Uchitelle*, *John Crepezzi*
-
-*   Allow adding nonnamed expression indexes to be revertible.
-
-    Previously, the following code would raise an error, when executed while rolling back,
-    and the index name should be specified explicitly. Now, the index name is inferred
-    automatically.
-
-    ```ruby
-    add_index(:items, "to_tsvector('english', description)")
     ```
 
-    Fixes #40732.
+    *Cody Cutrer*
 
-    *fatkodima*
+*   Include `ActiveModel::API` in `ActiveRecord::Base`.
 
-*   Only warn about negative enums if a positive form that would cause conflicts exists.
+    *Sean Doyle*
 
-    Fixes #39065.
+*   Ensure `#signed_id` outputs `url_safe` strings.
 
-    *Alex Ghiculescu*
+    *Jason Meller*
 
-*   Add option to run `default_scope` on all queries.
+*   Add `nulls_last` and working `desc.nulls_first` for MySQL.
 
-    Previously, a `default_scope` would only run on select or insert queries. In some cases, like non-Rails tenant sharding solutions, it may be desirable to run `default_scope` on all queries in order to ensure queries are including a foreign key for the shard (i.e. `blog_id`).
+    *Tristan Fellows*
 
-    Now applications can add an option to run on all queries including select, insert, delete, and update by adding an `all_queries` option to the default scope definition.
+*   Allow for more complex hash arguments for `order` which mimics `where` in `ActiveRecord::Relation`.
 
     ```ruby
-    class Article < ApplicationRecord
-      default_scope -> { where(blog_id: Current.blog.id) }, all_queries: true
-    end
+    Topic.includes(:posts).order(posts: { created_at: :desc })
     ```
 
-    *Eileen M. Uchitelle*
-
-*   Add `where.associated` to check for the presence of an association.
-
-    ```ruby
-    # Before:
-    account.users.joins(:contact).where.not(contact_id: nil)
-
-    # After:
-    account.users.where.associated(:contact)
-    ```
-
-    Also mirrors `where.missing`.
-
-    *Kasper Timm Hansen*
-
-*   Allow constructors (`build_association` and `create_association`) on
-    `has_one :through` associations.
-
-    *Santiago Perez Perret*
-
+    *Myles Boone*
 
-Please check [6-1-stable](https://github.com/rails/rails/blob/6-1-stable/activerecord/CHANGELOG.md) for previous changes.
+Please check [7-1-stable](https://github.com/rails/rails/blob/7-1-stable/activerecord/CHANGELOG.md) for previous changes.