activerecord 7.0.8.7 → 7.1.5.1

data/CHANGELOG.md

@@ -1,2411 +1,2782 @@
-## Rails 7.0.8.7 (December 10, 2024) ##
+## Rails 7.1.5.1 (December 10, 2024) ##
 
 *   No changes.
 
 
-## Rails 7.0.8.6 (October 23, 2024) ##
+## Rails 7.1.5 (October 30, 2024) ##
 
-*   No changes.
-
-
-## Rails 7.0.8.5 (October 15, 2024) ##
-
-*   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.8.4 (June 04, 2024) ##
+    *Jean Boussier*
 
-*   No changes.
+*   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.
 
+    Previously, using `.left_outer_joins` with the same child association would only join one of the parents.
 
-## Rails 7.0.8.3 (May 17, 2024) ##
+    Now it will correctly join both parents.
 
-*   No changes.
+    Fixes #41498.
 
+    *Garrett Blehm*
 
-## Rails 7.0.8.2 (May 16, 2024) ##
+*   Ensure `ActiveRecord::Encryption.config` is always ready before access.
 
-*   No changes.
+    Previously, `ActiveRecord::Encryption` configuration was deferred until `ActiveRecord::Base`
+    was loaded. Therefore, accessing `ActiveRecord::Encryption.config` properties before
+    `ActiveRecord::Base` was loaded would give incorrect results.
 
+    `ActiveRecord::Encryption` now has its own loading hook so that its configuration is set as
+    soon as needed.
 
-## Rails 7.0.8.1 (February 21, 2024) ##
+    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`.
 
-*   No changes.
+    *Maxime Réty*
 
+*   Add `TimeZoneConverter#==` method, so objects will be properly compared by
+    their type, scale, limit & precision.
 
-## Rails 7.0.8 (September 09, 2023) ##
+    Address #52699.
 
-*   Fix `change_column` not setting `precision: 6` on `datetime` columns when
-    using 7.0+ Migrations and SQLite.
+    *Ruy Rocha*
 
-    *Hartley McGuire*
 
-*   Fix unscope is not working in specific case
+## Rails 7.1.4.2 (October 23, 2024) ##
 
-    Before:
-    ```ruby
-    Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts` WHERE `posts`.`id` >= 1 AND `posts`.`id` < 3"
+*   No changes.
 
-    ```
 
-    After:
-    ```ruby
-    Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts`"
-    ```
+## Rails 7.1.4.1 (October 15, 2024) ##
 
-    Fixes #48094.
+*   No changes.
 
-    *Kazuya Hatanaka*
 
-*   Fix associations to a STI model including a `class_name` parameter
+## Rails 7.1.4 (August 22, 2024) ##
 
-    ```ruby
-    class Product < ApplicationRecord
-      has_many :requests, as: :requestable, class_name: "ProductRequest", dependent: :destroy
-    end
+*   Allow to eager load nested nil associations.
 
-    # STI tables
-    class Request < ApplicationRecord
-      belongs_to :requestable, polymorphic: true
+    *fatkodima*
 
-      validate :request_type, presence: true
-    end
+*   Fix `create_table` with `:auto_increment` option for MySQL adapter.
 
-    class ProductRequest < Request
-      belongs_to :user
-    end
-    ```
+    *fatkodima*
 
-    Accessing such association would lead to:
+*   Don't load has_one associations during autosave.
 
-    ```
-    table_metadata.rb:22:in `has_column?': undefined method `key?' for nil:NilClass (NoMethodError)
-    ```
+    *Eugene Kenny*
 
-    *Romain Filinto*
+*   Fix migration ordering for `bin/rails db:prepare` across databases.
 
-*   Fix `change_table` setting datetime precision for 6.1 Migrations
+    *fatkodima*
 
-    *Hartley McGuire*
+*   Fix `alias_attribute` to ignore methods defined in parent classes.
 
-*   Fix change_column setting datetime precision for 6.1 Migrations
+    *Jean Boussier*
 
-    *Hartley McGuire*
+*   Fix a performance regression in attribute methods.
 
-## Rails 7.0.7.2 (August 22, 2023) ##
+    *Jean Boussier*
 
-*   No changes.
+*   Fix Active Record configs variable shadowing.
 
+    *Joel Lubrano*
 
-## Rails 7.0.7.1 (August 22, 2023) ##
+*   Fix running migrations on other databases when `database_tasks: false` on primary.
 
-*   No changes.
+    *fatkodima*
 
+*   Fix non-partial inserts for models with composite identity primary keys.
 
-## Rails 7.0.7 (August 09, 2023) ##
+    *fatkodima*
 
-*   Restores functionality to the missing method when using enums and fixes.
+*   Fix `ActiveRecord::Relation#touch_all` with custom attribute aliased as attribute for update.
 
-    *paulreece*
+    *fatkodima*
 
-*   Fix `StatementCache::Substitute` with serialized type.
+*   Fix a crash when an Executor wrapped fork exit.
 
-    *ywenc*
+    *Joé Dupuis*
 
-*   Fix `:db_runtime` on notification payload when application have multiple databases.
+*   Fix `destroy_async` job for owners with composite primary keys.
 
-    *Eileen M. Uchitelle*
+    *fatkodima*
 
-*   Correctly dump check constraints for MySQL 8.0.16+.
+*   Ensure pre-7.1 migrations use legacy index names when using `rename_table`.
 
-    *Steve Hill*
+    *fatkodima*
 
-*   Fix `ActiveRecord::QueryMethods#in_order_of` to include `nil`s, to match the
-    behavior of `Enumerable#in_order_of`.
+*   Allow `primary_key:` association option to be composite.
 
-    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"])`.
+    *Nikita Vasilevsky*
 
-    *fatkodima*
+*   Do not try to alias on key update when raw SQL is supplied.
 
-*   Revert "Fix autosave associations with validations added on `:base` of the associated objects."
+    *Gabriel Amaral*
 
-    This change intended to remove the :base attribute from the message,
-    but broke many assumptions which key these errors were stored.
+*   Memoize `key_provider` from `key` or deterministic `key_provider` if any.
 
-    *zzak*
+    *Rosa Gutierrez*
 
-*   Fix `#previously_new_record?` to return true for destroyed records.
+*   Fix `upsert` warning for MySQL.
 
-    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.
+    *fatkodima*
 
-    *Adrianna Chang*
+*   Fix predicate builder for polymorphic models referencing models with composite primary keys.
 
-*   Revert breaking changes to `has_one` relationship deleting the old record before the new one is validated.
+    *fatkodima*
 
-    *zzak*
+*   Fix `update_all/delete_all` on CPK model relation with join subquery.
 
-*   Fix support for Active Record instances being uses in queries.
+    *Nikita Vasilevsky*
 
-    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.
+*   Remove memoization to accept `key_provider` overridden by `with_encryption_context`.
 
-    This broke the `noticed` gem.
+    *John Hawthorn*
 
-    *Jean Boussier*
+*   Raise error for Trilogy when prepared_statements is true.
 
+    Trilogy doesn't currently support prepared statements. The error that
+    applications would see is a `StatementInvalid` error. This doesn't quite point
+    you to the fact this isn't supported. So raise a more appropriate error
+    pointing to what to change.
 
-## Rails 7.0.6 (June 29, 2023) ##
+    *Eileen M. Uchitelle*
 
-*   Fix autosave associations with validations added on `:base` of the associated objects.
+*   Fix loading schema cache when all databases have disabled database tasks.
 
     *fatkodima*
 
-*   Fix result with anonymous PostgreSQL columns of different type from json.
+*   Always request `primary_key` in `RETURNING` if no other columns requested.
 
-    *Oleksandr Avoiants*
-
-*   Preserve timestamp when setting an `ActiveSupport::TimeWithZone` value to `timestamptz` attribute.
+    *Nikita Vasilevsky*
 
-    *fatkodima*
+*   Handle records being loaded with Marshal without triggering schema load
 
-*   Fix assignment into an `has_one` relationship deleting the old record before the new one is validated.
+    When using the old marshalling format for Active Record and loading
+    a serialized instance, it didn't trigger loading the schema and defining
+    attribute methods.
 
     *Jean Boussier*
 
-*   Fix where on association with has_one/has_many polymorphic relations.
-
-    Before:
-    ```ruby
-    Treasure.where(price_estimates: PriceEstimate.all)
-    #=> SELECT (...) WHERE "treasures"."id" IN (SELECT "price_estimates"."estimate_of_id" FROM "price_estimates")
-    ```
+*   Prevent some constant redefinition warnings when defining `inherited` on models.
 
-    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')
-    ```
+    *Adrian Hirt*
 
-    *Lázaro Nixon*
+*   Fix a memory perfomance regression in attribute methods.
 
-*   Fix decrementing counter caches on optimistically locked record deletion
+    Attribute methods used much more memory and were slower to define than
+    they should have been.
 
-    *fatkodima*
+    *Jean Boussier*
 
-*   Ensure binary-destined values have binary encoding during type cast.
+*   Fix an issue that could cause database connection leaks.
 
-    *Matthew Draper*
+    If Active Record successfully connected to the database, but then failed
+    to read the server informations, the connection would be leaked until the
+    Ruby garbage collector triggers.
 
-*   Preserve existing column default functions when altering table in SQLite.
+    *Jean Boussier*
 
-    *fatkodima*
+*   Fix an issue where the IDs reader method did not return expected results
+    for preloaded associations in models using composite primary keys.
 
-*   Remove table alias added when using `where.missing` or `where.associated`.
+    *Jay Ang*
 
-    *fatkodima*
+*   PostgreSQL `Cidr#change?` detects the address prefix change.
 
-*   Fix `Enumerable#in_order_of` to only flatten first level to preserve nesting.
+    *Taketo Takashima*
 
-    *Miha Rekar*
+*   Fix Active Record serialization to not include instantiated but not loaded associations
 
+    *Jean Boussier*, *Ben Kyriakou*
 
-## Rails 7.0.5.1 (June 26, 2023) ##
+*   Allow `Sqlite3Adapter` to use `sqlite3` gem version `2.x`
 
-*   No changes.
+    *Mike Dalessio*
 
-## Rails 7.0.5 (May 24, 2023) ##
+*   Strict loading using `:n_plus_one_only` does not eagerly load child associations.
 
-*   Type cast `#attribute_changed?` `:from` and `:to` options.
+    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.
 
-    *Andrew Novoselac*
+    Before:
 
-*   Fix `index_exists?` when column is an array.
+    ```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
+    ```
 
-    *Eileen M. Uchitelle*
+    After:
 
-*   Handle `Date` objects for PostgreSQL `timestamptz` columns.
+    ```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
+    ```
 
-    *Alex Ghiculescu*
+    *Reid Lynch*
 
-*   Fix collation for changing column to non-string.
+*   Using `Model.query_constraints` with a single non-primary-key column used to raise as expected, but with an
+    incorrect error message. This has been fixed to raise with a more appropriate error message.
 
-    *Hartley McGuire*
+    *Joshua Young*
 
-*   Map through subtype in `PostgreSQL::OID::Array`.
+*   Fix `has_one` association autosave setting the foreign key attribute when it is unchanged.
 
-    *Jonathan Hefner*
+    This behaviour 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.
 
-*   Store correct environment in `internal_metadata` when run rails `db:prepare`.
+    *Joshua Young*
 
-    *fatkodima*
+*   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.
 
-*   Make sure `ActiveRecord::Relation#sum` works with objects that implement `#coerce` without deprecation.
+    *Maxime Réty*
 
-    *Alex Ghiculescu*
+*   Properly synchronize `Mysql2Adapter#active?` and `TrilogyAdapter#active?`
 
-*   Fix retrieving foreign keys referencing tables named like keywords in PostgreSQL and MySQL.
+    As well as `disconnect!` and `verify!`.
 
-    *fatkodima*
+    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.
 
-*   Support UUIDs in Disable Joins.
+    *Jean Boussier*
 
-    *Samuel Cochran*
+*   Fix counter caches when the foreign key is composite.
 
-*   Fix Active Record's explain for queries starting with comments.
+    If the model holding the counter cache had a composite primary key,
+    inserting a dependent record would fail with an `ArgumentError`
+    `Expected corresponding value for...`
 
     *fatkodima*
 
-*   Fix incorrectly preloading through association records when middle association has been loaded.
-
-    *Joshua Young*
-
-*   Fix where.missing and where.associated for parent/child associations.
+*   Fix loading of schema cache for multiple databases.
 
-    *fatkodima*
+    Before this change, if you have multiple databases configured in your
+    application, and had schema cache present, Rails would load the same
+    cache to all databases.
 
-*   Fix Enumerable#in_order_of to preserve duplicates.
+    *Rafael Mendonça França*
 
-    *fatkodima*
+*   Fix eager loading of composite primary key associations.
 
-*   Fix autoincrement on primary key for mysql.
+    `relation.eager_load(:other_model)` could load the wrong records if `other_model`
+    had a composite primary key.
 
-    *Eileen M. Uchitelle*
+    *Nikita Vasilevsky*
 
-*   Restore ability to redefine column in `create_table` for Rails 5.2 migrations.
+*   Fix async queries returning a doubly wrapped result when hitting the query cache.
 
     *fatkodima*
 
-*   Fix schema cache dumping of virtual columns.
-
-    *fatkodima*
+*   Fix single quote escapes on default generated MySQL columns
 
-*   Fix Active Record grouped calculations on joined tables on column present in both tables.
+    MySQL 5.7.5+ supports generated columns, which can be used to create a column that is computed from an expression.
 
-    *fatkodima*
+    Previously, the schema dump would output a string with double escapes for generated columns with single quotes in the default expression.
 
-*   Fix mutation detection for serialized attributes backed by binary columns.
+    This would result in issues when importing the schema on a fresh instance of a MySQL database.
 
-    *Jean Boussier*
+    Now, the string will not be escaped and will be valid Ruby upon importing of the schema.
 
-*   Fix a bug where using groups and counts with long table names would return incorrect results.
+    *Yash Kapadia*
 
-    *Shota Toguchi*, *Yusaku Ono*
+*   Fix Migrations with versions older than 7.1 validating options given to
+    `t.references`.
 
-*   Fix erroneous nil default precision on virtual datetime columns.
+    *Hartley McGuire*
 
-    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.1.3.4 (June 04, 2024) ##
 
-    This change fixes the default precision lookup, so virtual and regular
-    datetime column default precisions match.
+*   No changes.
 
-    *Sam Bostock*
 
-*   Fix a case where the query cache can return wrong values. See #46044
+## Rails 7.1.3.3 (May 16, 2024) ##
 
-    *Aaron Patterson*
+*   No changes.
 
 
-## Rails 7.0.4.3 (March 13, 2023) ##
+## Rails 7.1.3.2 (February 21, 2024) ##
 
 *   No changes.
 
 
-## Rails 7.0.4.2 (January 24, 2023) ##
+## Rails 7.1.3.1 (February 21, 2024) ##
 
 *   No changes.
 
 
-## Rails 7.0.4.1 (January 17, 2023) ##
+## Rails 7.1.3 (January 16, 2024) ##
 
-*   Make sanitize_as_sql_comment more strict
+*   Fix Migrations with versions older than 7.1 validating options given to
+    `add_reference`.
 
-    Though this method was likely never meant to take user input, it was
-    attempting sanitization. That sanitization could be bypassed with
-    carefully crafted input.
+    *Hartley McGuire*
 
-    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.
+*   Ensure `reload` sets correct owner for each association.
 
-    This also clarifies in the documentation of annotate that it should not
-    be provided user input.
+    *Dmytro Savochkin*
 
-    [CVE-2023-22794]
+*   Fix view runtime for controllers with async queries.
 
-*   Added integer width check to PostgreSQL::Quoting
+    *fatkodima*
 
-    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 `load_async` to work with query cache.
 
-    This behavior is configurable via
-    ActiveRecord::Base.raise_int_wider_than_64bit which defaults to true.
+    *fatkodima*
 
-    [CVE-2022-44566]
+*   Fix polymorphic `belongs_to` to correctly use parent's `query_constraints`.
 
+    *fatkodima*
 
-## Rails 7.0.4 (September 09, 2022) ##
+*   Fix `Preloader` to not generate a query for already loaded association with `query_constraints`.
 
-*   Symbol is allowed by default for YAML columns
+    *fatkodima*
 
-    *Étienne Barrié*
+*   Fix multi-database polymorphic preloading with equivalent table names.
 
-*   Fix `ActiveRecord::Store` to serialize as a regular Hash
+    When preloading polymorphic associations, if two models pointed to two
+    tables with the same name but located in different databases, the
+    preloader would only load one.
 
-    Previously it would serialize as an `ActiveSupport::HashWithIndifferentAccess`
-    which is wasteful and cause problem with YAML safe_load.
+    *Ari Summer*
 
-    *Jean Boussier*
+*   Fix `encrypted_attribute?` to take into account context properties passed to `encrypts`.
 
-*   Add `timestamptz` as a time zone aware type for PostgreSQL
+    *Maxime Réty*
 
-    This is required for correctly parsing `timestamp with time zone` values in your database.
+*   Fix `find_by` to work correctly in presence of composite primary keys.
 
-    If you don't want this, you can opt out by adding this initializer:
+    *fatkodima*
 
-    ```ruby
-    ActiveRecord::Base.time_zone_aware_types -= [:timestamptz]
-    ```
+*   Fix async queries sometimes returning a raw result if they hit the query cache.
 
-    *Alex Ghiculescu*
+    `ShipPart.async_count` could return a raw integer rather than a Promise
+    if it found the result in the query cache.
 
-*   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])
-    ```
+*   Fix `Relation#transaction` to not apply a default scope.
 
-    *Wojciech Wnętrzak*
+    The method was incorrectly setting a default scope around its block:
 
-*   Resolve issue where a relation cache_version could be left stale.
+    ```ruby
+    Post.where(published: true).transaction do
+      Post.count # SELECT COUNT(*) FROM posts WHERE published = FALSE;
+    end
+    ```
 
-    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:
+*   Fix calling `async_pluck` on a `none` relation.
 
-    ```ruby
-    developers = Developer.all
-    developers.cache_version
+    `Model.none.async_pluck(:id)` was returning a naked value
+    instead of a promise.
 
-    Developer.update_all(updated_at: Time.now.utc + 1.second)
+    *Jean Boussier*
 
-    developers.cache_version # Stale cache_version
-    developers.reset
-    developers.cache_version # Returns the current correct cache_version
-    ```
+*   Fix calling `load_async` on a `none` relation.
 
-    Fixes #45341.
+    `Model.none.load_async` was returning a broken result.
 
-    *Austen Madden*
+    *Lucas Mazza*
 
-*   Fix `load_async` when called on an association proxy.
+*   TrilogyAdapter: ignore `host` if `socket` parameter is set.
 
-    Calling `load_async` directly an association would schedule
-    a query but never use it.
+    This allows to configure a connection on a UNIX socket via DATABASE_URL:
 
-    ```ruby
-    comments = post.comments.load_async # schedule a query
-    comments.to_a # perform an entirely new sync query
     ```
-
-    Now it does use the async query, however note that it doesn't
-    cause the association to be loaded.
+    DATABASE_URL=trilogy://does-not-matter/my_db_production?socket=/var/run/mysql.sock
+    ```
 
     *Jean Boussier*
 
-*   Fix eager loading for models without primary keys.
-
-    *Anmol Chopra*, *Matt Lawrence*, and *Jonathan Hefner*
-
-*   `rails db:schema:{dump,load}` now checks `ENV["SCHEMA_FORMAT"]` before config
+*   Fix `has_secure_token` calls the setter method on initialize.
 
-    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:
+    *Abeid Ahmed*
 
-    ```
-    SCHEMA_FORMAT=sql rake db:schema:dump
-    ```
+*   Allow using `object_id` as a database column name.
+    It was available before rails 7.1 and may be used as a part of polymorphic relationship to `object` where `object` can be any other database record.
 
-    *Alex Ghiculescu*
+    *Mikhail Doronin*
 
-*   Fix Hstore deserialize regression.
+*   Fix `rails db:create:all` to not touch databases before they are created.
 
-    *edsharp*
+    *fatkodima*
 
 
-## Rails 7.0.3.1 (July 12, 2022) ##
+## Rails 7.1.2 (November 10, 2023) ##
 
-*   Change ActiveRecord::Coders::YAMLColumn default to safe_load
+*   Fix renaming primary key index when renaming a table with a UUID primary key
+    in PostgreSQL.
 
-    This adds two new configuration options The configuration options are as
-    follows:
+    *fatkodima*
 
-    * `config.active_record.use_yaml_unsafe_load`
+*   Fix `where(field: values)` queries when `field` is a serialized attribute
+    (for example, when `field` uses `ActiveRecord::Base.serialize` or is a JSON
+    column).
 
-    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.
+    *João Alves*
 
-    * `config.active_record.yaml_column_permitted_classes`
+*   Prevent marking broken connections as verified.
 
-    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:
+    *Daniel Colson*
 
-    ```
-    config.active_record.yaml_column_permitted_classes = [Symbol, Date, Time]
-    ```
+*   Don't mark Float::INFINITY as changed when reassigning it
 
-    [CVE-2022-32224]
+    When saving a record with a float infinite value, it shouldn't mark as changed
 
+    *Maicol Bentancor*
 
-## Rails 7.0.3 (May 09, 2022) ##
+*   `ActiveRecord::Base.table_name` now returns `nil` instead of raising
+    "undefined method `abstract_class?` for Object:Class".
 
-*   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.
+    *a5-stable*
 
-    *Xavier Noria*
+*   Fix upserting for custom `:on_duplicate` and `:unique_by` consisting of all
+    inserts keys.
 
-*   Fixed MariaDB default function support.
+    *fatkodima*
 
-    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.
+*   Fixed an [issue](https://github.com/rails/rails/issues/49809) where saving a
+    record could innappropriately `dup` its attributes.
 
-    *kaspernj*
+    *Jonathan Hefner*
 
-*   Fix `remove_foreign_key` with `:if_exists` option when foreign key actually exists.
+*   Dump schema only for a specific db for rollback/up/down tasks for multiple dbs.
 
     *fatkodima*
 
-*   Remove `--no-comments` flag in structure dumps for PostgreSQL
+*   Fix `NoMethodError` when casting a PostgreSQL `money` value that uses a
+    comma as its radix point and has no leading currency symbol.  For example,
+    when casting `"3,50"`.
 
-    This broke some apps that used custom schema comments. If you don't want
-    comments in your structure dump, you can use:
+    *Andreas Reischuck* and *Jonathan Hefner*
 
-    ```ruby
-    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = ['--no-comments']
-    ```
+*   Re-enable support for using `enum` with non-column-backed attributes.
+    Non-column-backed attributes must be previously declared with an explicit
+    type. For example:
 
-    *Alex Ghiculescu*
+      ```ruby
+      class Post < ActiveRecord::Base
+        attribute :topic, :string
+        enum topic: %i[science tech engineering math]
+      end
+      ```
 
-*   Use the model name as a prefix when filtering encrypted attributes from logs.
+    *Jonathan Hefner*
 
-    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.
+*   Raise on `foreign_key:` being passed as an array in associations
 
-    *Jorge Manrubia*
+    *Nikita Vasilevsky*
 
-*   Fix quoting of `ActiveSupport::Duration` and `Rational` numbers in the MySQL adapter.
+*   Return back maximum allowed PostgreSQL table name to 63 characters.
 
-    *Kevin McPhillips*
+    *fatkodima*
 
-*   Fix `change_column_comment` to preserve column's AUTO_INCREMENT in the MySQL adapter
+*   Fix detecting `IDENTITY` columns for PostgreSQL < 10.
 
     *fatkodima*
 
-## Rails 7.0.2.4 (April 26, 2022) ##
 
-*   No changes.
+## Rails 7.1.1 (October 11, 2023) ##
 
+*   Fix auto populating IDENTITY columns for PostgreSQL.
 
-## Rails 7.0.2.3 (March 08, 2022) ##
+    *fatkodima*
 
-*   No changes.
+*   Fix "ArgumentError: wrong number of arguments (given 3, expected 2)" when
+    down migrating `rename_table` in older migrations.
 
+    *fatkodima*
 
-## Rails 7.0.2.2 (February 11, 2022) ##
+*   Do not require the Action Text, Active Storage and Action Mailbox tables
+    to be present when running when running test on CI.
 
-*   No changes.
+    *Rafael Mendonça França*
 
 
-## Rails 7.0.2.1 (February 11, 2022) ##
+## Rails 7.1.0 (October 05, 2023) ##
 
 *   No changes.
 
 
-## Rails 7.0.2 (February 08, 2022) ##
+## Rails 7.1.0.rc2 (October 01, 2023) ##
 
-*   Fix `PG.connect` keyword arguments deprecation warning on ruby 2.7.
-
-    *Nikita Vasilevsky*
+*   Remove -shm and -wal SQLite files when `rails db:drop` is run.
 
-*   Fix the ability to exclude encryption params from being autofiltered.
+    *Niklas Häusele*
 
-    *Mark Gangl*
+*   Revert the change to raise an `ArgumentError` when `#accepts_nested_attributes_for` is declared more than once for
+    an association in the same class.
 
-*   Dump the precision for datetime columns following the new defaults.
+    The reverted behavior broke the case where the `#accepts_nested_attributes_for` was defined in a concern and
+    where overridden in the class that included the concern.
 
     *Rafael Mendonça França*
 
-*   Make sure encrypted attributes are not being filtered twice.
 
-    *Nikita Vasilevsky*
+## Rails 7.1.0.rc1 (September 27, 2023) ##
 
-*   Dump the database schema containing the current Rails version.
+*   Better naming for unique constraints support.
 
-    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.
+    Naming unique keys leads to misunderstanding it's a short-hand of unique indexes.
+    Just naming it unique constraints is not misleading.
 
-    To avoid this the schema dumper will generate the new format which will include the Rails
-    version and will look like this:
+    In Rails 7.1.0.beta1 or before:
 
-    ```
-    ActiveRecord::Schema[7.0].define
+    ```ruby
+    add_unique_key :sections, [:position], deferrable: :deferred, name: "unique_section_position"
+    remove_unique_key :sections, name: "unique_section_position"
     ```
 
-    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.
+    Now:
 
-    *Rafael Mendonça França*
+    ```ruby
+    add_unique_constraint :sections, [:position], deferrable: :deferred, name: "unique_section_position"
+    remove_unique_constraint :sections, name: "unique_section_position"
+    ```
 
-*   Fix parsing expression for PostgreSQL generated column.
+    *Ryuta Kamizono*
 
-    *fatkodima*
+*   Fix duplicate quoting for check constraint expressions in schema dump when using MySQL
 
-*   Fix `Mysql2::Error: Commands out of sync; you can't run this command now`
-    when bulk-inserting fixtures that exceed `max_allowed_packet` configuration.
+    A check constraint with an expression, that already contains quotes, lead to an invalid schema
+    dump with the mysql2 adapter.
 
-    *Nikita Vasilevsky*
+    Fixes #42424.
 
-*   Fix error when saving an association with a relation named `record`.
+    *Felix Tscheulin*
 
-    *Dorian Marié*
+*   Performance tune the SQLite3 adapter connection configuration
 
-*   Fix `MySQL::SchemaDumper` behavior about datetime precision value.
+    For Rails applications, the Write-Ahead-Log in normal syncing mode with a capped journal size, a healthy shared memory buffer and a shared cache will perform, on average, 2× better.
 
-    *y0t4*
+    *Stephen Margheim*
 
-*   Improve associated with no reflection error.
+*   Allow SQLite3 `busy_handler` to be configured with simple max number of `retries`
 
-    *Nikolai*
+    Retrying busy connections without delay is a preferred practice for performance-sensitive applications. Add support for a `database.yml` `retries` integer, which is used in a simple `busy_handler` function to retry busy connections without exponential backoff up to the max number of `retries`.
 
-*   Fix PG.connect keyword arguments deprecation warning on ruby 2.7.
+    *Stephen Margheim*
 
-    Fixes #44307.
+*   The SQLite3 adapter now supports `supports_insert_returning?`
 
-    *Nikita Vasilevsky*
+    Implementing the full `supports_insert_returning?` contract means the SQLite3 adapter supports auto-populated columns (#48241) as well as custom primary keys.
+
+    *Stephen Margheim*
 
-*   Fix passing options to `check_constraint` from `change_table`.
+*   Ensure the SQLite3 adapter handles default functions with the `||` concatenation operator
 
-    *Frederick Cheung*
+    Previously, this default function would produce the static string `"'Ruby ' || 'on ' || 'Rails'"`.
+    Now, the adapter will appropriately receive and use `"Ruby on Rails"`.
 
+    ```ruby
+    change_column_default "test_models", "ruby_on_rails", -> { "('Ruby ' || 'on ' || 'Rails')" }
+    ```
 
-## Rails 7.0.1 (January 06, 2022) ##
+    *Stephen Margheim*
 
+*   Dump PostgreSQL schemas as part of the schema dump.
 
-*   Change `QueryMethods#in_order_of` to drop records not listed in values.
+    *Lachlan Sylvester*
 
-    `in_order_of` now filters down to the values provided, to match the behavior of the `Enumerable` version.
 
-    *Kevin Newton*
+## Rails 7.1.0.beta1 (September 13, 2023) ##
 
-*   Allow named expression indexes to be revertible.
+*   Encryption now supports `support_unencrypted_data` being set per-attribute.
 
-    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.
+    You can now opt out of `support_unencrypted_data` on a specific encrypted attribute.
+    This only has an effect if `ActiveRecord::Encryption.config.support_unencrypted_data == true`.
 
     ```ruby
-    add_index(:settings, "(data->'property')", using: :gin, name: :index_settings_data_property)
+    class User < ActiveRecord::Base
+      encrypts :name, deterministic: true, support_unencrypted_data: false
+      encrypts :email, deterministic: true
+    end
     ```
 
-    Fixes #43331.
+    *Alex Ghiculescu*
 
-    *Oliver Günther*
+*   Add instrumentation for Active Record transactions
 
-*   Better error messages when association name is invalid in the argument of `ActiveRecord::QueryMethods::WhereChain#missing`.
+    Allows subscribing to transaction events for tracking/instrumentation. The event payload contains the connection and the outcome (commit, rollback, restart, incomplete), as well as timing details.
 
-    *ykpythemind*
+    ```ruby
+    ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      puts "Transaction event occurred!"
+      connection = event.payload[:connection]
+      puts "Connection: #{connection.inspect}"
+    end
+    ```
 
-*   Fix ordered migrations for single db in multi db environment.
+    *Daniel Colson*, *Ian Candy*
 
-    *Himanshu*
+*   Support composite foreign keys via migration helpers.
 
-*   Extract `on update CURRENT_TIMESTAMP` for mysql2 adapter.
+    ```ruby
+    # Assuming "carts" table has "(shop_id, user_id)" as a primary key.
 
-    *Kazuhiro Masuda*
+    add_foreign_key(:orders, :carts, primary_key: [:shop_id, :user_id])
 
-*   Fix incorrect argument in PostgreSQL structure dump tasks.
+    remove_foreign_key(:orders, :carts, primary_key: [:shop_id, :user_id])
+    foreign_key_exists?(:orders, :carts, primary_key: [:shop_id, :user_id])
+    ```
 
-    Updating the `--no-comment` argument added in Rails 7 to the correct `--no-comments` argument.
+    *fatkodima*
 
-    *Alex Dent*
+*   Adds support for `if_not_exists` when adding a check constraint.
 
-*   Fix schema dumping column default SQL values for sqlite3.
+    ```ruby
+    add_check_constraint :posts, "post_type IN ('blog', 'comment', 'share')", if_not_exists: true
+    ```
 
-    *fatkodima*
+    *Cody Cutrer*
 
-*   Correctly parse complex check constraint expressions for PostgreSQL.
+*   Raise an `ArgumentError` when `#accepts_nested_attributes_for` is declared more than once for an association in
+    the same class. Previously, the last declaration would silently override the previous one. Overriding in a subclass
+    is still allowed.
 
-    *fatkodima*
+    *Joshua Young*
 
-*   Fix `timestamptz` attributes on PostgreSQL handle blank inputs.
+*   Deprecate `rewhere` argument on `#merge`.
 
-    *Alex Ghiculescu*
+    The `rewhere` argument on `#merge`is deprecated without replacement and
+    will be removed in Rails 7.2.
 
-*   Fix migration compatibility to create SQLite references/belongs_to column as integer when migration version is 6.0.
+    *Adam Hess*
 
-    Reference/belongs_to in migrations with version 6.0 were creating columns as
-    bigint instead of integer for the SQLite Adapter.
+*   Deprecate aliasing non-attributes with `alias_attribute`.
 
-    *Marcelo Lauxen*
+    *Ian Candy*
 
-*   Fix joining through a polymorphic association.
+*   Fix unscope is not working in specific case
 
-    *Alexandre Ruban*
+    Before:
+    ```ruby
+    Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts` WHERE `posts`.`id` >= 1 AND `posts`.`id` < 3"
 
-*   Fix `QueryMethods#in_order_of` to handle empty order list.
+    ```
 
+    After:
     ```ruby
-    Post.in_order_of(:id, []).to_a
+    Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts`"
     ```
 
-    Also more explicitly set the column as secondary order, so that any other
-    value is still ordered.
-
-    *Jean Boussier*
+    Fixes #48094.
 
-*   Fix `rails dbconsole` for 3-tier config.
+    *Kazuya Hatanaka*
 
-    *Eileen M. Uchitelle*
+*   Change `has_secure_token` default to `on: :initialize`
 
-*   Fix quoting of column aliases generated by calculation methods.
+    Change the new default value from `on: :create` to `on: :initialize`
 
-    Since the alias is derived from the table name, we can't assume the result
-    is a valid identifier.
+    Can be controlled by the `config.active_record.generate_secure_token_on`
+    configuration:
 
     ```ruby
-    class Test < ActiveRecord::Base
-      self.table_name = '1abc'
-    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...
+    config.active_record.generate_secure_token_on = :create
     ```
 
-    *Jean Boussier*
+    *Sean Doyle*
 
+*   Fix `change_column` not setting `precision: 6` on `datetime` columns when
+    using 7.0+ Migrations and SQLite.
 
-## Rails 7.0.0 (December 15, 2021) ##
+    *Hartley McGuire*
 
-*   Better handle SQL queries with invalid encoding.
+*   Support composite identifiers in `to_key`
 
-    ```ruby
-    Post.create(name: "broken \xC8 UTF-8")
-    ```
+    `to_key` avoids wrapping `#id` value into an `Array` if `#id` already an array
 
-    Would cause all adapters to fail in a non controlled way in the code
-    responsible to detect write queries.
+    *Nikita Vasilevsky*
 
-    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.
+*   Add validation option for `enum`
 
-    *Jean Boussier*
+    ```ruby
+    class Contract < ApplicationRecord
+      enum :status, %w[in_progress completed], validate: true
+    end
+    Contract.new(status: "unknown").valid? # => false
+    Contract.new(status: nil).valid? # => false
+    Contract.new(status: "completed").valid? # => true
 
-*   Move database and shard selection config options to a generator.
+    class Contract < ApplicationRecord
+      enum :status, %w[in_progress completed], validate: { allow_nil: true }
+    end
+    Contract.new(status: "unknown").valid? # => false
+    Contract.new(status: nil).valid? # => true
+    Contract.new(status: "completed").valid? # => true
+    ```
 
-    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.
+    *Edem Topuzov*, *Ryuta Kamizono*
 
-    *Eileen M. Uchitelle*
+*   Allow batching methods to use already loaded relation if available
 
+    Calling batch methods on already loaded relations will use the records previously loaded instead of retrieving
+    them from the database again.
 
-## Rails 7.0.0.rc3 (December 14, 2021) ##
+    *Adam Hess*
 
-*   No changes.
+*   Deprecate `read_attribute(:id)` returning the primary key if the primary key is not `:id`.
 
+    Starting in Rails 7.2, `read_attribute(:id)` will return the value of the id column, regardless of the model's
+    primary key. To retrieve the value of the primary key, use `#id` instead. `read_attribute(:id)` for composite
+    primary key models will now return the value of the id column.
 
-## Rails 7.0.0.rc2 (December 14, 2021) ##
+    *Adrianna Chang*
 
-*   No changes.
+*   Fix `change_table` setting datetime precision for 6.1 Migrations
 
+    *Hartley McGuire*
 
-## Rails 7.0.0.rc1 (December 06, 2021) ##
+*   Fix change_column setting datetime precision for 6.1 Migrations
 
-*   Remove deprecated `ActiveRecord::DatabaseConfigurations::DatabaseConfig#spec_name`.
+    *Hartley McGuire*
 
-    *Rafael Mendonça França*
+*   Add `ActiveRecord::Base#id_value` alias to access the raw value of a record's id column.
 
-*   Remove deprecated `ActiveRecord::Connection#in_clause_length`.
+    This alias is only provided for models that declare an `:id` column.
 
-    *Rafael Mendonça França*
+    *Adrianna Chang*
 
-*   Remove deprecated `ActiveRecord::Connection#allowed_index_name_length`.
+*   Fix previous change tracking for `ActiveRecord::Store` when using a column with JSON structured database type
 
-    *Rafael Mendonça França*
+    Before, the methods to access the changes made during the last save `#saved_change_to_key?`, `#saved_change_to_key`, and `#key_before_last_save` did not work if the store was defined as a `store_accessor` on a column with a JSON structured database type
 
-*   Remove deprecated `ActiveRecord::Base#remove_connection`.
+    *Robert DiMartino*
 
-    *Rafael Mendonça França*
+*   Fully support `NULLS [NOT] DISTINCT` for PostgreSQL 15+ indexes.
 
-*   Load STI Models in fixtures
+    Previous work was done to allow the index to be created in a migration, but it was not
+    supported in schema.rb. Additionally, the matching for `NULLS [NOT] DISTINCT` was not
+    in the correct order, which could have resulted in inconsistent schema detection.
 
-    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`
+    *Gregory Jones*
 
-    *Andres Howard*
+*   Allow escaping of literal colon characters in `sanitize_sql_*` methods when named bind variables are used
 
-*   `#authenticate` returns false when the password is blank instead of raising an error.
+    *Justin Bull*
 
-    *Muhammad Muhammad Ibrahim*
+*   Fix `#previously_new_record?` to return true for destroyed records.
 
-*   Fix `ActiveRecord::QueryMethods#in_order_of` behavior for integer enums.
+    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.
 
-    `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.
+    *Adrianna Chang*
 
-    The following example now works as expected:
+*   Specify callback in `has_secure_token`
 
     ```ruby
-    class Book < ApplicationRecord
-      enum status: [:proposed, :written, :published]
+    class User < ApplicationRecord
+      has_secure_token on: :initialize
     end
 
-    Book.in_order_of(:status, %w[written published proposed])
+    User.new.token # => "abc123...."
     ```
 
-    *Alexandre Ruban*
+    *Sean Doyle*
 
-*   Ignore persisted in-memory records when merging target lists.
+*   Fix incrementation of in memory counter caches when associations overlap
 
-    *Kevin Sjöberg*
+    When two associations had a similarly named counter cache column, Active Record
+    could sometime increment the wrong one.
 
-*   Add a new option `:update_only` to `upsert_all` to configure the list of columns to update in case of conflict.
+    *Jacopo Beschi*, *Jean Boussier*
 
-    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:
+*   Don't show secrets for Active Record's `Cipher::Aes256Gcm#inspect`.
+
+    Before:
 
     ```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
-    )
+    ActiveRecord::Encryption::Cipher::Aes256Gcm.new(secret).inspect
+    "#<ActiveRecord::Encryption::Cipher::Aes256Gcm:0x0000000104888038 ... @secret=\"\\xAF\\bFh]LV}q\\nl\\xB2U\\xB3 ... >"
     ```
 
-    *Jorge Manrubia*
-
-*   Remove deprecated `ActiveRecord::Result#map!` and `ActiveRecord::Result#collect!`.
+    After:
 
-    *Rafael Mendonça França*
+    ```ruby
+    ActiveRecord::Encryption::Cipher::Aes256Gcm(secret).inspect
+    "#<ActiveRecord::Encryption::Cipher::Aes256Gcm:0x0000000104888038>"
+    ```
 
-*   Remove deprecated `ActiveRecord::Base.configurations.to_h`.
+    *Petrik de Heus*
 
-    *Rafael Mendonça França*
+*   Bring back the historical behavior of committing transaction on non-local return.
 
-*   Remove deprecated `ActiveRecord::Base.configurations.default_hash`.
+    ```ruby
+    Model.transaction do
+      model.save
+      return
+      other_model.save # not executed
+    end
+    ```
 
-    *Rafael Mendonça França*
+    Historically only raised errors would trigger a rollback, but in Ruby `2.3`, the `timeout` library
+    started using `throw` to interrupt execution which had the adverse effect of committing open transactions.
 
-*   Remove deprecated `ActiveRecord::Base.arel_attribute`.
+    To solve this, in Active Record 6.1 the behavior was changed to instead rollback the transaction as it was safer
+    than to potentially commit an incomplete transaction.
 
-    *Rafael Mendonça França*
+    Using `return`, `break` or `throw` inside a `transaction` block was essentially deprecated from Rails 6.1 onwards.
 
-*   Remove deprecated `ActiveRecord::Base.connection_config`.
+    However with the release of `timeout 0.4.0`, `Timeout.timeout` now raises an error again, and Active Record is able
+    to return to its original, less surprising, behavior.
 
-    *Rafael Mendonça França*
+    This historical behavior can now be opt-ed in via:
 
-*   Filter attributes in SQL logs
+    ```
+    Rails.application.config.active_record.commit_transaction_on_non_local_return = true
+    ```
 
-    Previously, SQL queries in logs containing `ActiveRecord::Base.filter_attributes` were not filtered.
+    And is the default for new applications created in Rails 7.1.
 
-    Now, the filter attributes will be masked `[FILTERED]` in the logs when `prepared_statement` is enabled.
+    *Jean Boussier*
 
-    ```
-    # Before:
-      Foo Load (0.2ms)  SELECT "foos".* FROM "foos" WHERE "foos"."passw" = ? LIMIT ?  [["passw", "hello"], ["LIMIT", 1]]
+*   Deprecate `name` argument on `#remove_connection`.
 
-    # After:
-      Foo Load (0.5ms)  SELECT "foos".* FROM "foos" WHERE "foos"."passw" = ? LIMIT ?  [["passw", "[FILTERED]"], ["LIMIT", 1]]
-    ```
+    The `name` argument is deprecated on `#remove_connection` without replacement. `#remove_connection` should be called directly on the class that established the connection.
 
-    *Aishwarya Subramanian*
+    *Eileen M. Uchitelle*
 
-*   Remove deprecated `Tasks::DatabaseTasks.spec`.
+*   Fix has_one through singular building with inverse.
 
-    *Rafael Mendonça França*
+    Allows building of records from an association with a has_one through a
+    singular association with inverse. For belongs_to through associations,
+    linking the foreign key to the primary key model isn't needed.
+    For has_one, we cannot build records due to the association not being mutable.
 
-*   Remove deprecated `Tasks::DatabaseTasks.current_config`.
+    *Gannon McGibbon*
 
-    *Rafael Mendonça França*
+*   Disable database prepared statements when query logs are enabled
 
-*   Deprecate `Tasks::DatabaseTasks.schema_file_type`.
+    Prepared Statements and Query Logs are incompatible features due to query logs making every query unique.
 
-    *Rafael Mendonça França*
+    *zzak, Jean Boussier*
 
-*   Remove deprecated `Tasks::DatabaseTasks.dump_filename`.
+*   Support decrypting data encrypted non-deterministically with a SHA1 hash digest.
 
-    *Rafael Mendonça França*
+    This adds a new Active Record encryption option to support decrypting data encrypted
+    non-deterministically with a SHA1 hash digest:
 
-*   Remove deprecated `Tasks::DatabaseTasks.schema_file`.
+    ```
+    Rails.application.config.active_record.encryption.support_sha1_for_non_deterministic_encryption = true
+    ```
 
-    *Rafael Mendonça França*
+    The new option addresses a problem when upgrading from 7.0 to 7.1. Due to a bug in how Active Record
+    Encryption was getting initialized, the key provider used for non-deterministic encryption were using
+    SHA-1 as its digest class, instead of the one configured globally by Rails via
+    `Rails.application.config.active_support.key_generator_hash_digest_class`.
 
-*   Remove deprecated `environment` and `name` arguments from `Tasks::DatabaseTasks.schema_up_to_date?`.
+    *Cadu Ribeiro and Jorge Manrubia*
 
-    *Rafael Mendonça França*
+*   Added PostgreSQL migration commands for enum rename, add value, and rename value.
 
-*   Merging conditions on the same column no longer maintain both conditions,
-    and will be consistently replaced by the latter condition.
+    `rename_enum` and `rename_enum_value` are reversible. Due to Postgres
+    limitation, `add_enum_value` is not reversible since you cannot delete enum
+    values. As an alternative you should drop and recreate the enum entirely.
 
     ```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]
-
-    *Rafael Mendonça França*
+    rename_enum :article_status, to: :article_state
+    ```
 
-*   Remove deprecated support to `Model.reorder(nil).first` to search using non-deterministic order.
+    ```ruby
+    add_enum_value :article_state, "archived" # will be at the end of existing values
+    add_enum_value :article_state, "in review", before: "published"
+    add_enum_value :article_state, "approved", after: "in review"
+    ```
 
-    *Rafael Mendonça França*
+    ```ruby
+    rename_enum_value :article_state, from: "archived", to: "deleted"
+    ```
 
-*   Remove deprecated rake tasks:
+    *Ray Faddis*
 
-    * `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}`
+*   Allow composite primary key to be derived from schema
 
-    *Rafael Mendonça França*
+    Booting an application with a schema that contains composite primary keys
+    will not issue warning and won't `nil`ify the `ActiveRecord::Base#primary_key` value anymore.
 
-*   Remove deprecated `DatabaseConfig#config` method.
+    Given a `travel_routes` table definition and a `TravelRoute` model like:
+    ```ruby
+    create_table :travel_routes, primary_key: [:origin, :destination], force: true do |t|
+      t.string :origin
+      t.string :destination
+    end
 
-    *Rafael Mendonça França*
+    class TravelRoute < ActiveRecord::Base; end
+    ```
+    The `TravelRoute.primary_key` value will be automatically derived to `["origin", "destination"]`
 
-*   Rollback transactions when the block returns earlier than expected.
+    *Nikita Vasilevsky*
 
-    Before this change, when a transaction block returned early, the transaction would be committed.
+*   Include the `connection_pool` with exceptions raised from an adapter.
 
-    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.
+    The `connection_pool` provides added context such as the connection used
+    that led to the exception as well as which role and shard.
 
-    *Rafael Mendonça França*
+    *Luan Vieira*
 
-*   Add middleware for automatic shard swapping.
+*   Support multiple column ordering for `find_each`, `find_in_batches` and `in_batches`.
 
-    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:
+    When find_each/find_in_batches/in_batches are performed on a table with composite primary keys, ascending or descending order can be selected for each key.
 
     ```ruby
-    config.active_record.shard_resolver = ->(request) {
-      subdomain = request.subdomain
-      tenant = Tenant.find_by_subdomain!(subdomain)
-      tenant.shard
-    }
+    Person.find_each(order: [:desc, :asc]) do |person|
+      person.party_all_night!
+    end
     ```
 
-    See guides for more details.
+    *Takuya Kurimoto*
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
-
-*   Remove deprecated support to pass a column to `type_cast`.
+*   Fix where on association with has_one/has_many polymorphic relations.
 
-    *Rafael Mendonça França*
+    Before:
+    ```ruby
+    Treasure.where(price_estimates: PriceEstimate.all)
+    #=> SELECT (...) WHERE "treasures"."id" IN (SELECT "price_estimates"."estimate_of_id" FROM "price_estimates")
+    ```
 
-*   Remove deprecated support to type cast to database values `ActiveRecord::Base` objects.
+    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')
+    ```
 
-    *Rafael Mendonça França*
+    *Lázaro Nixon*
 
-*   Remove deprecated support to quote `ActiveRecord::Base` objects.
+*   Assign auto populated columns on Active Record record creation.
 
-    *Rafael Mendonça França*
+    Changes record creation logic to allow for the `auto_increment` column to be assigned
+    immediately after creation regardless of it's relation to the model's primary key.
 
-*   Remove deprecacated support to resolve connection using `"primary"` as connection specification name.
+    The PostgreSQL adapter benefits the most from the change allowing for any number of auto-populated
+    columns to be assigned on the object immediately after row insertion utilizing the `RETURNING` statement.
 
-    *Rafael Mendonça França*
+    *Nikita Vasilevsky*
 
-*   Remove deprecation warning when using `:interval` column is used in PostgreSQL database.
+*   Use the first key in the `shards` hash from `connected_to` for the `default_shard`.
 
-    Now, interval columns will return `ActiveSupport::Duration` objects instead of strings.
+    Some applications may not want to use `:default` as a shard name in their connection model. Unfortunately Active Record expects there to be a `:default` shard because it must assume a shard to get the right connection from the pool manager. Rather than force applications to manually set this, `connects_to` can infer the default shard name from the hash of shards and will now assume that the first shard is your default.
 
-    To keep the old behavior, you can add this line to your model:
+    For example if your model looked like this:
 
     ```ruby
-    attribute :column, :string
+    class ShardRecord < ApplicationRecord
+      self.abstract_class = true
+
+      connects_to shards: {
+        shard_one: { writing: :shard_one },
+        shard_two: { writing: :shard_two }
+      }
     ```
 
-    *Rafael Mendonça França*
+    Then the `default_shard` for this class would be set to `shard_one`.
 
-*   Remove deprecated support to YAML load `ActiveRecord::Base` instance in the Rails 4.2 and 4.1 formats.
+    Fixes: #45390
 
-    *Rafael Mendonça França*
+    *Eileen M. Uchitelle*
 
-*   Remove deprecated option `:spec_name` in the `configs_for` method.
+*   Fix mutation detection for serialized attributes backed by binary columns.
 
-    *Rafael Mendonça França*
+    *Jean Boussier*
 
-*   Remove deprecated  `ActiveRecord::Base.allow_unsafe_raw_sql`.
+*   Add `ActiveRecord.disconnect_all!` method to immediately close all connections from all pools.
 
-    *Rafael Mendonça França*
+    *Jean Boussier*
 
-*   Fix regression bug that caused ignoring additional conditions for preloading has_many-through relations.
+*   Discard connections which may have been left in a transaction.
 
-    Fixes #43132
+    There are cases where, due to an error, `within_new_transaction` may unexpectedly leave a connection in an open transaction. In these cases the connection may be reused, and the following may occur:
+    - Writes appear to fail when they actually succeed.
+    - Writes appear to succeed when they actually fail.
+    - Reads return stale or uncommitted data.
 
-    *Alexander Pauly*
+    Previously, the following case was detected:
+    - An error is encountered during the transaction, then another error is encountered while attempting to roll it back.
 
-*   Fix `has_many` inversing recursion on models with recursive associations.
+    Now, the following additional cases are detected:
+    - An error is encountered just after successfully beginning a transaction.
+    - An error is encountered while committing a transaction, then another error is encountered while attempting to roll it back.
+    - An error is encountered while rolling back a transaction.
 
-    *Gannon McGibbon*
+    *Nick Dower*
 
-*   Add `accepts_nested_attributes_for` support for `delegated_type`
+*   Active Record query cache now evicts least recently used entries
 
-    ```ruby
-    class Entry < ApplicationRecord
-      delegated_type :entryable, types: %w[ Message Comment ]
-      accepts_nested_attributes_for :entryable
-    end
+    By default it only keeps the `100` most recently used queries.
 
-    entry = Entry.create(entryable_type: 'Message', entryable_attributes: { content: 'Hello world' })
-    # => #<Entry:0x00>
-    # id: 1
-    # entryable_id: 1,
-    # entryable_type: 'Message'
-    # ...>
+    The cache size can be configured via `database.yml`
 
-    entry.entryable
-    # => #<Message:0x01>
-    # id: 1
-    # content: 'Hello world'
-    # ...>
+    ```yaml
+    development:
+      adapter: mysql2
+      query_cache: 200
     ```
 
-    Previously it would raise an error:
+    It can also be entirely disabled:
 
-    ```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?
+    ```yaml
+    development:
+      adapter: mysql2
+      query_cache: false
     ```
 
-    *Sjors Baltus*
+    *Jean Boussier*
+
+*   Deprecate `check_pending!` in favor of `check_all_pending!`.
 
-*   Use subquery for DELETE with GROUP_BY and HAVING clauses.
+    `check_pending!` will only check for pending migrations on the current database connection or the one passed in. This has been deprecated in favor of `check_all_pending!` which will find all pending migrations for the database configurations in a given environment.
 
-    Prior to this change, deletes with GROUP_BY and HAVING were returning an error.
+    *Eileen M. Uchitelle*
 
-    After this change, GROUP_BY and HAVING are valid clauses in DELETE queries, generating the following query:
+*   Make `increment_counter`/`decrement_counter` accept an amount argument
 
-    ```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"]]
+    ```ruby
+    Post.increment_counter(:comments_count, 5, by: 3)
     ```
 
-    *Ignacio Chiazzo Cardarello*
+    *fatkodima*
 
-*   Use subquery for UPDATE with GROUP_BY and HAVING clauses.
+*   Add support for `Array#intersect?` to `ActiveRecord::Relation`.
 
-    Prior to this change, updates with GROUP_BY and HAVING were being ignored, generating a SQL like this:
+    `Array#intersect?` is only available on Ruby 3.1 or later.
 
-    ```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"]]
-    ```
+    This allows the Rubocop `Style/ArrayIntersect` cop to work with `ActiveRecord::Relation` objects.
 
-    After this change, GROUP_BY and HAVING clauses are used as a subquery in updates, like this:
+    *John Harry Kelly*
 
-    ```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"]]
-    ```
+*   The deferrable foreign key can be passed to `t.references`.
 
-    *Ignacio Chiazzo Cardarello*
+    *Hiroyuki Ishii*
 
-*   Add support for setting the filename of the schema or structure dump in the database config.
+*   Deprecate `deferrable: true` option of `add_foreign_key`.
 
-    Applications may now set their the filename or path of the schema / structure dump file in their database configuration.
+    `deferrable: true` is deprecated in favor of `deferrable: :immediate`, and
+    will be removed in Rails 7.2.
 
-    ```yaml
-    production:
-      primary:
-        database: my_db
-        schema_dump: my_schema_dump_filename.rb
-      animals:
-        database: animals_db
-        schema_dump: false
-    ```
+    Because `deferrable: true` and `deferrable: :deferred` are hard to understand.
+    Both true and :deferred are truthy values.
+    This behavior is the same as the deferrable option of the add_unique_key method, added in #46192.
 
-    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`.
+    *Hiroyuki Ishii*
 
-    *Eileen M. Uchitelle*, *Ryan Kerr*
+*   `AbstractAdapter#execute` and `#exec_query` now clear the query cache
 
-*   Add `ActiveRecord::Base.prohibit_shard_swapping` to prevent attempts to change the shard within a block.
+    If you need to perform a read only SQL query without clearing the query
+    cache, use `AbstractAdapter#select_all`.
 
-    *John Crepezzi*, *Eileen M. Uchitelle*
+    *Jean Boussier*
 
-*   Filter unchanged attributes with default function from insert query when `partial_inserts` is disabled.
+*   Make `.joins` / `.left_outer_joins` work with CTEs.
 
-    *Akshay Birajdar*, *Jacopo Beschi*
+    For example:
 
-*   Add support for FILTER clause (SQL:2003) to Arel.
+    ```ruby
+    Post
+     .with(commented_posts: Comment.select(:post_id).distinct)
+     .joins(:commented_posts)
+    #=> WITH (...) SELECT ... INNER JOIN commented_posts on posts.id = commented_posts.post_id
+    ```
 
-    Currently supported by PostgreSQL 9.4+ and SQLite 3.30+.
+    *Vladimir Dementyev*
 
-    *Andrey Novikov*
+*   Add a load hook for `ActiveRecord::ConnectionAdapters::Mysql2Adapter`
+    (named `active_record_mysql2adapter`) to allow for overriding aspects of the
+    `ActiveRecord::ConnectionAdapters::Mysql2Adapter` class. This makes `Mysql2Adapter`
+    consistent with `PostgreSQLAdapter` and `SQLite3Adapter` that already have load hooks.
 
-*   Automatically set timestamps on record creation during bulk insert/upsert
+    *fatkodima*
 
-    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}`).
+*   Introduce adapter for Trilogy database client
 
-    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.
+    Trilogy is a MySQL-compatible database client. Rails applications can use Trilogy
+    by configuring their `config/database.yml`:
 
-    Note that this means `upsert_all` on models with `record_timestamps = false` will no longer touch `updated_{at,on}` automatically.
+    ```yaml
+    development:
+    adapter: trilogy
+    database: blog_development
+    pool: 5
+    ```
 
-    *Sam Bostock*
+    Or by using the `DATABASE_URL` environment variable:
 
-*   Don't require `role` when passing `shard` to `connected_to`.
+    ```ruby
+    ENV['DATABASE_URL'] # => "trilogy://localhost/blog_development?pool=5"
+    ```
 
-    `connected_to` can now be called with a `shard` only. Note that `role` is still inherited if `connected_to` calls are nested.
+    *Adrianna Chang*
 
-    *Eileen M. Uchitelle*
+*   `after_commit` callbacks defined on models now execute in the correct order.
 
-*   Add option to lazily load the schema cache on the connection.
+    ```ruby
+    class User < ActiveRecord::Base
+      after_commit { puts("this gets called first") }
+      after_commit { puts("this gets called second") }
+    end
+    ```
 
-    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.
+    Previously, the callbacks executed in the reverse order. To opt in to the new behaviour:
 
-    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.
+    ```ruby
+    config.active_record.run_after_transaction_callbacks_in_order_defined = true
+    ```
 
-    *Eileen M. Uchitelle*
+    This is the default for new apps.
 
-*   Allow automatic `inverse_of` detection for associations with scopes.
+    *Alex Ghiculescu*
 
-    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:
+*   Infer `foreign_key` when `inverse_of` is present on `has_one` and `has_many` associations.
 
     ```ruby
-    class Post < ActiveRecord::Base
-      has_many :comments, -> { visible }
-    end
-
-    class Comment < ActiveRecord::Base
-      belongs_to :post
-    end
+    has_many :citations, foreign_key: "book1_id", inverse_of: :book
     ```
 
-    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:
+    can be simplified to
 
     ```ruby
-    config.active_record.automatic_scope_inversing = true
+    has_many :citations, inverse_of: :book
     ```
 
-    *Daniel Colson*, *Chris Bloom*
-
-*   Accept optional transaction args to `ActiveRecord::Locking::Pessimistic#with_lock`
+    and the foreign_key will be read from the corresponding `belongs_to` association.
 
-    `#with_lock` now accepts transaction options like `requires_new:`,
-    `isolation:`, and `joinable:`
+    *Daniel Whitney*
 
-    *John Mileham*
+*   Limit max length of auto generated index names
 
-*   Adds support for deferrable foreign key constraints in PostgreSQL.
+    Auto generated index names are now limited to 62 bytes, which fits within
+    the default index name length limits for MySQL, Postgres and SQLite.
 
-    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.
+    Any index name over the limit will fallback to the new short format.
 
-    ```ruby
-    Person.transaction do
-      alias = Alias
-        .create_with(user_id: SecureRandom.uuid)
-        .create_or_find_by(name: "DHH")
+    Before (too long):
+    ```
+    index_testings_on_foo_and_bar_and_first_name_and_last_name_and_administrator
+    ```
 
-      person = Person
-        .create_with(name: "David Heinemeier Hansson")
-        .create_or_find_by(id: alias.user_id)
-    end
+    After (short format):
+    ```
+    idx_on_foo_bar_first_name_last_name_administrator_5939248142
     ```
 
-    Using the default behavior, the transaction would fail when executing the first `INSERT` statement.
+    The short format includes a hash to ensure the name is unique database-wide.
 
-    By passing the `:deferrable` option to the `add_foreign_key` statement in migrations, it's possible to defer this
-    check.
+    *Mike Coutermarsh*
 
-    ```ruby
-    add_foreign_key :aliases, :person, deferrable: true
-    ```
+*   Introduce a more stable and optimized Marshal serializer for Active Record models.
+
+    Can be enabled with `config.active_record.marshalling_format_version = 7.1`.
 
-    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.
+    *Jean Boussier*
+
+*   Allow specifying where clauses with column-tuple syntax.
 
-    It's also possible to adjust the default behavior from an immediate check (after the statement), to a deferred check
-    (after the transaction):
+    Querying through `#where` now accepts a new tuple-syntax which accepts, as
+    a key, an array of columns and, as a value, an array of corresponding tuples.
+    The key specifies a list of columns, while the value is an array of
+    ordered-tuples that conform to the column list.
+
+    For instance:
 
     ```ruby
-    add_foreign_key :aliases, :person, deferrable: :deferred
-    ```
+    # Cpk::Book => Cpk::Book(author_id: integer, number: integer, title: string, revision: integer)
+    # Cpk::Book.primary_key => ["author_id", "number"]
 
-    *Benedikt Deicke*
+    book = Cpk::Book.create!(author_id: 1, number: 1)
+    Cpk::Book.where(Cpk::Book.primary_key => [[1, 2]]) # => [book]
 
-*   Allow configuring Postgres password through the socket URL.
+    # Topic => Topic(id: integer, title: string, author_name: string...)
 
-    For example:
-    ```ruby
-    ActiveRecord::DatabaseConfigurations::UrlConfig.new(
-      :production, :production, 'postgres:///?user=user&password=secret&dbname=app', {}
-    ).configuration_hash
+    Topic.where([:title, :author_name] => [["The Alchemist", "Paulo Coelho"], ["Harry Potter", "J.K Rowling"]])
     ```
 
-    will now return,
+    *Paarth Madan*
+
+*   Allow warning codes to be ignore when reporting SQL warnings.
+
+    Active Record config that can ignore warning codes
 
     ```ruby
-    { :user=>"user", :password=>"secret", :dbname=>"app", :adapter=>"postgresql" }
+    # Configure allowlist of warnings that should always be ignored
+    config.active_record.db_warnings_ignore = [
+      "1062", # MySQL Error 1062: Duplicate entry
+    ]
     ```
 
-    *Abeid Ahmed*
+    This is supported for the MySQL and PostgreSQL adapters.
 
-*   PostgreSQL: support custom enum types
+    *Nick Borromeo*
 
-    In migrations, use `create_enum` to add a new enum type, and `t.enum` to add a column.
+*   Introduce `:active_record_fixtures` lazy load hook.
 
-    ```ruby
-    def up
-      create_enum :mood, ["happy", "sad"]
+    Hooks defined with this name will be run whenever `TestFixtures` is included
+    in a class.
 
-      change_table :cats do |t|
-        t.enum :current_mood, enum_type: "mood", default: "happy", null: false
-      end
+    ```ruby
+    ActiveSupport.on_load(:active_record_fixtures) do
+      self.fixture_paths << "test/fixtures"
     end
+
+    klass = Class.new
+    klass.include(ActiveRecord::TestFixtures)
+
+    klass.fixture_paths # => ["test/fixtures"]
     ```
 
-    Enums will be presented correctly in `schema.rb`. Note that this is only supported by
-    the PostgreSQL adapter.
+    *Andrew Novoselac*
 
-    *Alex Ghiculescu*
+*   Introduce `TestFixtures#fixture_paths`.
 
-*   Avoid COMMENT statements in PostgreSQL structure dumps
+    Multiple fixture paths can now be specified using the `#fixture_paths` accessor.
+    Apps will continue to have `test/fixtures` as their one fixture path by default,
+    but additional fixture paths can be specified.
 
-    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.
+    ```ruby
+    ActiveSupport::TestCase.fixture_paths << "component1/test/fixtures"
+    ActiveSupport::TestCase.fixture_paths << "component2/test/fixtures"
+    ```
 
-    Fixes #36816, #43107.
+    `TestFixtures#fixture_path` is now deprecated.
 
-    *Janosch Müller*
+    *Andrew Novoselac*
 
-*   Add support for generated columns in PostgreSQL adapter
+*   Adds support for deferrable exclude constraints in PostgreSQL.
 
-    Generated columns are supported since version 12.0 of PostgreSQL. This adds
-    support of those to the PostgreSQL adapter.
+    By default, exclude constraints in PostgreSQL are checked after each statement.
+    This works for most use cases, but becomes a major limitation when replacing
+    records with overlapping ranges by using multiple statements.
 
     ```ruby
-    create_table :users do |t|
-      t.string :name
-      t.virtual :name_upcased, type: :string, as: 'upper(name)', stored: true
-    end
+    exclusion_constraint :users, "daterange(valid_from, valid_to) WITH &&", deferrable: :immediate
     ```
 
-    *Michał Begejowicz*
+    Passing `deferrable: :immediate` checks constraint after each statement,
+    but allows manually deferring the check using `SET CONSTRAINTS ALL DEFERRED`
+    within a transaction. This will cause the excludes to be checked after the transaction.
 
+    It's also possible to change the default behavior from an immediate check
+    (after the statement), to a deferred check (after the transaction):
 
-## Rails 7.0.0.alpha2 (September 15, 2021) ##
+    ```ruby
+    exclusion_constraint :users, "daterange(valid_from, valid_to) WITH &&", deferrable: :deferred
+    ```
 
-*   No changes.
+    *Hiroyuki Ishii*
 
+*   Respect `foreign_type` option to `delegated_type` for `{role}_class` method.
 
-## Rails 7.0.0.alpha1 (September 15, 2021) ##
+    Usage of `delegated_type` with non-conventional `{role}_type` column names can now be specified with `foreign_type` option.
+    This option is the same as `foreign_type` as forwarded to the underlying `belongs_to` association that `delegated_type` wraps.
 
-*   Remove warning when overwriting existing scopes
+    *Jason Karns*
 
-    Removes the following unnecessary warning message that appeared when overwriting existing scopes
+*   Add support for unique constraints (PostgreSQL-only).
 
+    ```ruby
+    add_unique_key :sections, [:position], deferrable: :deferred, name: "unique_section_position"
+    remove_unique_key :sections, name: "unique_section_position"
     ```
-    Creating scope :my_scope_name. Overwriting existing method "MyClass.my_scope_name" when overwriting existing scopes
-    ```
-
-     *Weston Ganger*
-
-*   Use full precision for `updated_at` in `insert_all`/`upsert_all`
 
-    `CURRENT_TIMESTAMP` provides differing precision depending on the database,
-    and not all databases support explicitly specifying additional precision.
+    See PostgreSQL's [Unique Constraints](https://www.postgresql.org/docs/current/ddl-constraints.html#DDL-CONSTRAINTS-UNIQUE-CONSTRAINTS) documentation for more on unique constraints.
 
-    Instead, we delegate to the new `connection.high_precision_current_timestamp`
-    for the SQL to produce a high precision timestamp on the current database.
+    By default, unique constraints in PostgreSQL are checked after each statement.
+    This works for most use cases, but becomes a major limitation when replacing
+    records with unique column by using multiple statements.
 
-    Fixes #42992
+    An example of swapping unique columns between records.
 
-    *Sam Bostock*
+    ```ruby
+    # position is unique column
+    old_item = Item.create!(position: 1)
+    new_item = Item.create!(position: 2)
 
-*   Add ssl support for postgresql database tasks
+    Item.transaction do
+      old_item.update!(position: 2)
+      new_item.update!(position: 1)
+    end
+    ```
 
-    Add `PGSSLMODE`, `PGSSLCERT`, `PGSSLKEY` and `PGSSLROOTCERT` to pg_env from database config
-    when running postgresql database tasks.
+    Using the default behavior, the transaction would fail when executing the
+    first `UPDATE` statement.
 
-    ```yaml
-    # config/database.yml
+    By passing the `:deferrable` option to the `add_unique_key` statement in
+    migrations, it's possible to defer this check.
 
-    production:
-      sslmode: verify-full
-      sslcert: client.crt
-      sslkey: client.key
-      sslrootcert: ca.crt
+    ```ruby
+    add_unique_key :items, [:position], deferrable: :immediate
     ```
 
-    Environment variables
+    Passing `deferrable: :immediate` does not change the behaviour of the previous example,
+    but allows manually deferring the check using `SET CONSTRAINTS ALL DEFERRED` within a transaction.
+    This will cause the unique constraints to be checked after the transaction.
 
-    ```
-    PGSSLMODE=verify-full
-    PGSSLCERT=client.crt
-    PGSSLKEY=client.key
-    PGSSLROOTCERT=ca.crt
+    It's also possible to adjust the default behavior from an immediate
+    check (after the statement), to a deferred check (after the transaction):
+
+    ```ruby
+    add_unique_key :items, [:position], deferrable: :deferred
     ```
 
-    Fixes #42994
+    If you want to change an existing unique index to deferrable, you can use :using_index
+    to create deferrable unique constraints.
 
-    *Michael Bayucot*
+    ```ruby
+    add_unique_key :items, deferrable: :deferred, using_index: "index_items_on_position"
+    ```
 
-*   Avoid scoping update callbacks in `ActiveRecord::Relation#update!`.
+    *Hiroyuki Ishii*
 
-    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.
+*   Remove deprecated `Tasks::DatabaseTasks.schema_file_type`.
 
-    *Dylan Thacker-Smith*
+    *Rafael Mendonça França*
 
-*   Fix 2 cases that inferred polymorphic class from the association's `foreign_type`
-    using `String#constantize` instead of the model's `polymorphic_class_for`.
+*   Remove deprecated `config.active_record.partial_writes`.
 
-    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`
+    *Rafael Mendonça França*
 
-    *Jimmy Bourassa*
+*   Remove deprecated `ActiveRecord::Base` config accessors.
 
-*   Add config option for ignoring tables when dumping the schema cache.
+    *Rafael Mendonça França*
 
-    Applications can now be configured to ignore certain tables when dumping the schema cache.
+*   Remove the `:include_replicas` argument from `configs_for`. Use `:include_hidden` argument instead.
 
-    The configuration option can table an array of tables:
+    *Eileen M. Uchitelle*
 
-    ```ruby
-    config.active_record.schema_cache_ignored_tables = ["ignored_table", "another_ignored_table"]
-    ```
+*   Allow applications to lookup a config via a custom hash key.
 
-    Or a regex:
+    If you have registered a custom config or want to find configs where the hash matches a specific key, now you can pass `config_key` to `configs_for`. For example if you have a `db_config` with the key `vitess` you can look up a database configuration hash by  matching that key.
 
     ```ruby
-    config.active_record.schema_cache_ignored_tables = [/^_/]
+    ActiveRecord::Base.configurations.configs_for(env_name: "development", name: "primary", config_key: :vitess)
+    ActiveRecord::Base.configurations.configs_for(env_name: "development", config_key: :vitess)
     ```
 
     *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.
+*   Allow applications to register a custom database configuration handler.
 
-    The behavior now is:
+    Adds a mechanism for registering a custom handler for cases where you want database configurations to respond to custom methods. This is useful for non-Rails database adapters or tools like Vitess that you may want to configure differently from a standard `HashConfig` or `UrlConfig`.
 
-    `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*
+    Given the following database YAML we want the `animals` db to create a `CustomConfig` object instead while the `primary` database will be a `UrlConfig`:
 
-*   Reestablish connection to previous database after after running `db:schema:load:name`
-
-    After running `db:schema:load:name` the previous connection is restored.
+    ```yaml
+    development:
+      primary:
+        url: postgres://localhost/primary
+      animals:
+        url: postgres://localhost/animals
+        custom_config:
+          sharded: 1
+    ```
 
-    *Jacopo Beschi*
+    To register a custom handler first make a class that has your custom methods:
 
-*   Add database config option `database_tasks`
+    ```ruby
+    class CustomConfig < ActiveRecord::DatabaseConfigurations::UrlConfig
+      def sharded?
+        custom_config.fetch("sharded", false)
+      end
 
-    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`
+      private
+        def custom_config
+          configuration_hash.fetch(:custom_config)
+        end
+    end
+    ```
 
-    ```yaml
-    # config/database.yml
+    Then register the config in an initializer:
 
-    production:
-      primary:
-        database: my_database
-        adapter: mysql2
-      animals:
-        database: my_animals_database
-        adapter: mysql2
-        database_tasks: false
+    ```ruby
+    ActiveRecord::DatabaseConfigurations.register_db_config_handler do |env_name, name, url, config|
+      next unless config.key?(:custom_config)
+      CustomConfig.new(env_name, name, url, config)
+    end
     ```
 
-    *Weston Ganger*
+    When the application is booted, configuration hashes with the `:custom_config` key will be `CustomConfig` objects and respond to `sharded?`. Applications must handle the condition in which Active Record should use their custom handler.
+
+    *Eileen M. Uchitelle and John Crepezzi*
 
-*   Fix `ActiveRecord::InternalMetadata` to not be broken by `config.active_record.record_timestamps = false`
+*   `ActiveRecord::Base.serialize` no longer uses YAML by default.
 
-    Since the model always create the timestamp columns, it has to set them, otherwise it breaks
-    various DB management tasks.
+    YAML isn't particularly performant and can lead to security issues
+    if not used carefully.
 
-    Fixes #42983
+    Unfortunately there isn't really any good serializers in Ruby's stdlib
+    to replace it.
 
-*   Add `ActiveRecord::QueryLogs`.
+    The obvious choice would be JSON, which is a fine format for this use case,
+    however the JSON serializer in Ruby's stdlib isn't strict enough, as it fallback
+    to casting unknown types to strings, which could lead to corrupted data.
 
-    Configurable tags can be automatically added to all SQL queries generated by Active Record.
+    Some third party JSON libraries like `Oj` have a suitable strict mode.
+
+    So it's preferable that users choose a serializer based on their own constraints.
+
+    The original default can be restored by setting `config.active_record.default_column_serializer = YAML`.
+
+    *Jean Boussier*
+
+*   `ActiveRecord::Base.serialize` signature changed.
+
+    Rather than a single positional argument that accepts two possible
+    types of values, `serialize` now accepts two distinct keyword arguments.
+
+    Before:
 
     ```ruby
-    # config/application.rb
-    module MyApp
-      class Application < Rails::Application
-        config.active_record.query_log_tags_enabled = true
-      end
-    end
+    serialize :content, JSON
+    serialize :backtrace, Array
     ```
 
-    By default the application, controller and action details are added to the query tags:
+    After:
 
     ```ruby
-    class BooksController < ApplicationController
-      def index
-        @books = Book.all
-      end
-    end
+    serialize :content, coder: JSON
+    serialize :backtrace, type: Array
     ```
 
-    ```ruby
-    GET /books
-    # SELECT * FROM books /*application:MyApp;controller:books;action:index*/
+    *Jean Boussier*
+
+*   YAML columns use `YAML.safe_dump` if available.
+
+    As of `psych 5.1.0`, `YAML.safe_dump` can now apply the same permitted
+    types restrictions than `YAML.safe_load`.
+
+    It's preferable to ensure the payload only use allowed types when we first
+    try to serialize it, otherwise you may end up with invalid records in the
+    database.
+
+    *Jean Boussier*
+
+*   `ActiveRecord::QueryLogs` better handle broken encoding.
+
+    It's not uncommon when building queries with BLOB fields to contain
+    binary data. Unless the call carefully encode the string in ASCII-8BIT
+    it generally end up being encoded in `UTF-8`, and `QueryLogs` would
+    end up failing on it.
+
+    `ActiveRecord::QueryLogs` no longer depend on the query to be properly encoded.
+
+    *Jean Boussier*
+
+*   Fix a bug where `ActiveRecord::Generators::ModelGenerator` would not respect create_table_migration template overrides.
+
+    ```
+    rails g model create_books title:string content:text
+    ```
+    will now read from the create_table_migration.rb.tt template in the following locations in order:
     ```
+    lib/templates/active_record/model/create_table_migration.rb
+    lib/templates/active_record/migration/create_table_migration.rb
+    ```
+
+    *Spencer Neste*
 
-    Custom tags containing static values and Procs can be defined in the application configuration:
+*   `ActiveRecord::Relation#explain` now accepts options.
+
+    For databases and adapters which support them (currently PostgreSQL
+    and MySQL), options can be passed to `explain` to provide more
+    detailed query plan analysis:
 
     ```ruby
-    config.active_record.query_log_tags = [
-      :application,
-      :controller,
-      :action,
-      {
-        custom_static: "foo",
-        custom_dynamic: -> { Time.now }
-      }
-    ]
+    Customer.where(id: 1).joins(:orders).explain(:analyze, :verbose)
     ```
 
-    *Keeran Raj Hawoldar*, *Eileen M. Uchitelle*, *Kasper Timm Hansen*
+    *Reid Lynch*
 
-*   Added support for multiple databases to `rails db:setup` and `rails db:reset`.
+*   Multiple `Arel::Nodes::SqlLiteral` nodes can now be added together to
+    form `Arel::Nodes::Fragments` nodes. This allows joining several pieces
+    of SQL.
 
-    *Ryan Hall*
+    *Matthew Draper*, *Ole Friis*
 
-*   Add `ActiveRecord::Relation#structurally_compatible?`.
+*   `ActiveRecord::Base#signed_id` raises if called on a new record.
 
-    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.
+    Previously it would return an ID that was not usable, since it was based on `id = nil`.
 
-    *Kevin Newton*
+    *Alex Ghiculescu*
 
-*   Add `ActiveRecord::QueryMethods#in_order_of`.
+*   Allow SQL warnings to be reported.
 
-    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:
+    Active Record configs can be set to enable SQL warning reporting.
 
     ```ruby
-    Post.in_order_of(:id, [3, 5, 1])
+    # Configure action to take when SQL query produces warning
+    config.active_record.db_warnings_action = :raise
+
+    # Configure allowlist of warnings that should always be ignored
+    config.active_record.db_warnings_ignore = [
+      /Invalid utf8mb4 character string/,
+      "An exact warning message",
+    ]
     ```
 
-    will generate the SQL:
+    This is supported for the MySQL and PostgreSQL adapters.
 
-    ```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
-    ```
+    *Adrianna Chang*, *Paarth Madan*
 
-    However, because this functionality is built into MySQL in the form of the
-    `FIELD` function, that connection adapter will generate the following SQL
-    instead:
+*   Add `#regroup` query method as a short-hand for `.unscope(:group).group(fields)`
 
-    ```sql
-    SELECT "posts".* FROM "posts" ORDER BY FIELD("posts"."id", 1, 5, 3) DESC
+    Example:
+
+    ```ruby
+    Post.group(:title).regroup(:author)
+    # SELECT `posts`.`*` FROM `posts` GROUP BY `posts`.`author`
     ```
 
-    *Kevin Newton*
+    *Danielius Visockas*
+
+*   PostgreSQL adapter method `enable_extension` now allows parameter to be `[schema_name.]<extension_name>`
+    if the extension must be installed on another schema.
+
+    Example: `enable_extension('heroku_ext.hstore')`
+
+    *Leonardo Luarte*
 
-*   Fix `eager_loading?` when ordering with `Symbol`.
+*   Add `:include` option to `add_index`.
 
-    `eager_loading?` is triggered correctly when using `order` with symbols.
+    Add support for including non-key columns in indexes for PostgreSQL
+    with the `INCLUDE` parameter.
 
     ```ruby
-    scope = Post.includes(:comments).order(:"comments.label")
-    => true
+    add_index(:users, :email, include: [:id, :created_at])
     ```
 
-    *Jacopo Beschi*
+    will result in:
 
-*   Two change tracking methods are added for `belongs_to` associations.
+    ```sql
+    CREATE INDEX index_users_on_email USING btree (email) INCLUDE (id, created_at)
+    ```
 
-    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.
+    *Steve Abrams*
 
-    The `association_previously_changed?` method returns true if the previous save updated the
-    association to reference a different associated object.
+*   `ActiveRecord::Relation`’s `#any?`, `#none?`, and `#one?` methods take an optional pattern
+    argument, more closely matching their `Enumerable` equivalents.
 
     *George Claghorn*
 
-*   Add option to disable schema dump per-database.
+*   Add `ActiveRecord::Base.normalizes` for declaring attribute normalizations.
 
-    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:
+    An attribute normalization is applied when the attribute is assigned or
+    updated, and the normalized value will be persisted to the database.  The
+    normalization is also applied to the corresponding keyword argument of query
+    methods, allowing records to be queried using unnormalized values.
 
-    ```yaml
-    # config/database.yml
+    For example:
 
-    production:
-      schema_dump: false
-    ```
+      ```ruby
+      class User < ActiveRecord::Base
+        normalizes :email, with: -> email { email.strip.downcase }
+        normalizes :phone, with: -> phone { phone.delete("^0-9").delete_prefix("1") }
+      end
 
-    *Luis Vasconcellos*, *Eileen M. Uchitelle*
+      user = User.create(email: " CRUISE-CONTROL@EXAMPLE.COM\n")
+      user.email                  # => "cruise-control@example.com"
 
-*   Fix `eager_loading?` when ordering with `Hash` syntax.
+      user = User.find_by(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")
+      user.email                  # => "cruise-control@example.com"
+      user.email_before_type_cast # => "cruise-control@example.com"
 
-    `eager_loading?` is triggered correctly when using `order` with hash syntax
-    on an outer table.
+      User.where(email: "\tCRUISE-CONTROL@EXAMPLE.COM ").count         # => 1
+      User.where(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]).count # => 0
 
-    ```ruby
-    Post.includes(:comments).order({ "comments.label": :ASC }).eager_loading?
-    # => true
-    ```
+      User.exists?(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")         # => true
+      User.exists?(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]) # => false
 
-    *Jacopo Beschi*
+      User.normalize_value_for(:phone, "+1 (555) 867-5309") # => "5558675309"
+      ```
 
-*   Move the forcing of clear text encoding to the `ActiveRecord::Encryption::Encryptor`.
+    *Jonathan Hefner*
 
-    Fixes #42699.
+*   Hide changes to before_committed! callback behaviour behind flag.
 
-    *J Smith*
+    In #46525, behavior around before_committed! callbacks was changed so that callbacks
+    would run on every enrolled record in a transaction, not just the first copy of a record.
+    This change in behavior is now controlled by a configuration option,
+    `config.active_record.before_committed_on_all_records`. It will be enabled by default on Rails 7.1.
 
-*   `partial_inserts` is now disabled by default in new apps.
+    *Adrianna Chang*
 
-    This will be the default for new apps in Rails 7. To opt in:
+*   The `namespaced_controller` Query Log tag now matches the `controller` format
+
+    For example, a request processed by `NameSpaced::UsersController` will now log as:
+
+    ```
+    :controller # "users"
+    :namespaced_controller # "name_spaced/users"
+    ```
+
+    *Alex Ghiculescu*
+
+*   Return only unique ids from ActiveRecord::Calculations#ids
+
+    Updated ActiveRecord::Calculations#ids to only return the unique ids of the base model
+    when using eager_load, preload and includes.
 
     ```ruby
-    config.active_record.partial_inserts = true
+    Post.find_by(id: 1).comments.count
+    # => 5
+    Post.includes(:comments).where(id: 1).pluck(:id)
+    # => [1, 1, 1, 1, 1]
+    Post.includes(:comments).where(id: 1).ids
+    # => [1]
     ```
 
-    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.
+    *Joshua Young*
 
-    If you need to remove a column, you should first use `ignored_columns`
-    to stop using it.
+*   Stop using `LOWER()` for case-insensitive queries on `citext` columns
 
-    *Jean Boussier*
+    Previously, `LOWER()` was added for e.g. uniqueness validations with
+    `case_sensitive: false`.
+    It wasn't mentioned in the documentation that the index without `LOWER()`
+    wouldn't be used in this case.
 
-*   Rails can now verify foreign keys after loading fixtures in tests.
+    *Phil Pirozhkov*
 
-    This will be the default for new apps in Rails 7. To opt in:
+*   Extract `#sync_timezone_changes` method in AbstractMysqlAdapter to enable subclasses
+    to sync database timezone changes without overriding `#raw_execute`.
 
-    ```ruby
-    config.active_record.verify_foreign_keys_for_fixtures = true
-    ```
+    *Adrianna Chang*, *Paarth Madan*
 
-    Tests will not run if there is a foreign key constraint violation in your fixture data.
+*   Do not write additional new lines when dumping sql migration versions
 
-    The feature is supported by SQLite and PostgreSQL, other adapters can also add support for it.
+    This change updates the `insert_versions_sql` function so that the database insert string containing the current database migration versions does not end with two additional new lines.
 
-    *Alex Ghiculescu*
+    *Misha Schwartz*
 
-*   Clear cached `has_one` association after setting `belongs_to` association to `nil`.
+*   Fix `composed_of` value freezing and duplication.
 
-    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.
+    Previously composite values exhibited two confusing behaviors:
 
-    Fixes #42597.
+    - When reading a compositve value it'd _NOT_ be frozen, allowing it to get out of sync with its underlying database
+      columns.
+    - When writing a compositve value the argument would be frozen, potentially confusing the caller.
 
-    *Michiel de Mare*
+    Currently, composite values instantiated based on database columns are frozen (addressing the first issue) and
+    assigned compositve values are duplicated and the duplicate is frozen (addressing the second issue).
 
-*   OpenSSL constants are now used for Digest computations.
+    *Greg Navis*
 
-    *Dirkjan Bussink*
+*   Fix redundant updates to the column insensitivity cache
 
-*   Adds support for `if_not_exists` to `add_foreign_key` and `if_exists` to `remove_foreign_key`.
+    Fixed redundant queries checking column capability for insensitive
+    comparison.
 
-    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.
+    *Phil Pirozhkov*
 
-    Example Usage:
+*   Allow disabling methods generated by `ActiveRecord.enum`.
 
-    ```ruby
-    class AddAuthorsForeignKeyToArticles < ActiveRecord::Migration[7.0]
-      def change
-        add_foreign_key :articles, :authors, if_not_exists: true
-      end
-    end
-    ```
+    *Alfred Dominic*
+
+*   Avoid validating `belongs_to` association if it has not changed.
+
+    Previously, when updating a record, Active Record will perform an extra query to check for the presence of
+    `belongs_to` associations (if the presence is configured to be mandatory), even if that attribute hasn't changed.
+
+    Currently, only `belongs_to`-related columns are checked for presence. It is possible to have orphaned records with
+    this approach. To avoid this problem, you need to use a foreign key.
+
+    This behavior can be controlled by configuration:
 
     ```ruby
-    class RemoveAuthorsForeignKeyFromArticles < ActiveRecord::Migration[7.0]
-      def change
-        remove_foreign_key :articles, :authors, if_exists: true
-      end
-    end
+    config.active_record.belongs_to_required_validates_foreign_key = false
     ```
 
-    *Roberto Miranda*
+    and will be disabled by default with `config.load_defaults 7.1`.
 
-*   Prevent polluting ENV during postgresql structure dump/load.
+    *fatkodima*
 
-    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.
+*   `has_one` and `belongs_to` associations now define a `reset_association` method
+    on the owner model (where `association` is the name of the association). This
+    method unloads the cached associate record, if any, and causes the next access
+    to query it from the database.
 
-    *Samuel Cochran*
+    *George Claghorn*
 
-*   Set precision 6 by default for `datetime` columns.
+*   Allow per attribute setting of YAML permitted classes (safe load) and unsafe load.
 
-    By default, datetime columns will have microseconds precision instead of seconds precision.
+    *Carlos Palhares*
 
-    *Roberto Miranda*
+*   Add a build persistence method
 
-*   Allow preloading of associations with instance dependent scopes.
+    Provides a wrapper for `new`, to provide feature parity with `create`s
+    ability to create multiple records from an array of hashes, using the
+    same notation as the `build` method on associations.
 
-    *John Hawthorn*, *John Crepezzi*, *Adam Hess*, *Eileen M. Uchitelle*, *Dinah Shi*
+    *Sean Denny*
 
-*   Do not try to rollback transactions that failed due to a `ActiveRecord::TransactionRollbackError`.
+*   Raise on assignment to readonly attributes
 
-    *Jamie McCarthy*
+    ```ruby
+    class Post < ActiveRecord::Base
+      attr_readonly :content
+    end
+    Post.create!(content: "cannot be updated")
+    post.content # "cannot be updated"
+    post.content = "something else" # => ActiveRecord::ReadonlyAttributeError
+    ```
 
-*   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.
+    Previously, assignment would succeed but silently not write to the database.
 
-    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`.
+    This behavior can be controlled by configuration:
 
-    *Jorge Manrubia*
+    ```ruby
+    config.active_record.raise_on_assign_to_attr_readonly = true
+    ```
 
-*   The MySQL adapter now cast numbers and booleans bind parameters to string for safety reasons.
+    and will be enabled by default with `config.load_defaults 7.1`.
 
-    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.
+    *Alex Ghiculescu*, *Hartley McGuire*
 
-    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:
+*   Allow unscoping of preload and eager_load associations
+
+    Added the ability to unscope preload and eager_load associations just like
+    includes, joins, etc. See ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES
+    for the full list of supported unscopable scopes.
 
     ```ruby
-    User.where("login_token = ?", 0).first
+    query.unscope(:eager_load, :preload).group(:id).select(:id)
     ```
 
-    Would perform:
+    *David Morehouse*
 
-    ```sql
-    SELECT * FROM `users` WHERE `login_token` = 0 LIMIT 1;
+*   Add automatic filtering of encrypted attributes on inspect
+
+    This feature is enabled by default but can be disabled with
+
+    ```ruby
+    config.active_record.encryption.add_to_filter_parameters = false
     ```
 
-    Now it will perform:
+    *Hartley McGuire*
+
+*   Clear locking column on #dup
+
+    This change fixes not to duplicate locking_column like id and timestamps.
 
-    ```sql
-    SELECT * FROM `users` WHERE `login_token` = '0' LIMIT 1;
+    ```
+    car = Car.create!
+    car.touch
+    car.lock_version #=> 1
+    car.dup.lock_version #=> 0
     ```
 
-    *Jean Boussier*
+    *Shouichi Kamiya*, *Seonggi Yang*, *Ryohei UEDA*
 
-*   Fixture configurations (`_fixture`) are now strictly validated.
+*   Invalidate transaction as early as possible
 
-    If an error will be raised if that entry contains unknown keys while previously it
-    would silently have no effects.
+    After rescuing a `TransactionRollbackError` exception Rails invalidates transactions earlier in the flow
+    allowing the framework to skip issuing the `ROLLBACK` statement in more cases.
+    Only affects adapters that have `savepoint_errors_invalidate_transactions?` configured as `true`,
+    which at this point is only applicable to the `mysql2` adapter.
 
-    *Jean Boussier*
+    *Nikita Vasilevsky*
 
-*   Add `ActiveRecord::Base.update!` that works like `ActiveRecord::Base.update` but raises exceptions.
+*   Allow configuring columns list to be used in SQL queries issued by an `ActiveRecord::Base` object
 
-    This allows for the same behavior as the instance method `#update!` at a class level.
+    It is now possible to configure columns list that will be used to build an SQL query clauses when
+    updating, deleting or reloading an `ActiveRecord::Base` object
 
     ```ruby
-    Person.update!(:all, state: "confirmed")
+    class Developer < ActiveRecord::Base
+      query_constraints :company_id, :id
+    end
+    developer = Developer.first.update(name: "Bob")
+    # => UPDATE "developers" SET "name" = 'Bob' WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
     ```
 
-    *Dorian Marié*
+    *Nikita Vasilevsky*
+
+*   Adds `validate` to foreign keys and check constraints in schema.rb
 
-*   Add `ActiveRecord::Base#attributes_for_database`.
+    Previously, `schema.rb` would not record if `validate: false` had been used when adding a foreign key or check
+    constraint, so restoring a database from the schema could result in foreign keys or check constraints being
+    incorrectly validated.
 
-    Returns attributes with values for assignment to the database.
+    *Tommy Graves*
 
-    *Chris Salzberg*
+*   Adapter `#execute` methods now accept an `allow_retry` option. When set to `true`, the SQL statement will be
+    retried, up to the database's configured `connection_retries` value, upon encountering connection-related errors.
 
-*   Use an empty query to check if the PostgreSQL connection is still active.
+    *Adrianna Chang*
 
-    An empty query is faster than `SELECT 1`.
+*   Only trigger `after_commit :destroy` callbacks when a database row is deleted.
 
-    *Heinrich Lee Yu*
+    This prevents `after_commit :destroy` callbacks from being triggered again
+    when `destroy` is called multiple times on the same record.
 
-*   Add `ActiveRecord::Base#previously_persisted?`.
+    *Ben Sheldon*
 
-    Returns `true` if the object has been previously persisted but now it has been deleted.
+*   Fix `ciphertext_for` for yet-to-be-encrypted values.
 
-*   Deprecate `partial_writes` in favor of `partial_inserts` and `partial_updates`.
+    Previously, `ciphertext_for` returned the cleartext of values that had not
+    yet been encrypted, such as with an unpersisted record:
 
-    This allows to have a different behavior on update and create.
+      ```ruby
+      Post.encrypts :body
 
-    *Jean Boussier*
+      post = Post.create!(body: "Hello")
+      post.ciphertext_for(:body)
+      # => "{\"p\":\"abc..."
 
-*   Fix compatibility with `psych >= 4`.
+      post.body = "World"
+      post.ciphertext_for(:body)
+      # => "World"
+      ```
 
-    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.
+    Now, `ciphertext_for` will always return the ciphertext of encrypted
+    attributes:
 
-    *Jean Boussier*
+      ```ruby
+      Post.encrypts :body
 
-*   `ActiveRecord::Base.logger` is now a `class_attribute`.
+      post = Post.create!(body: "Hello")
+      post.ciphertext_for(:body)
+      # => "{\"p\":\"abc..."
 
-    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.
+      post.body = "World"
+      post.ciphertext_for(:body)
+      # => "{\"p\":\"xyz..."
+      ```
 
-    *Jean Boussier*
+    *Jonathan Hefner*
+
+*   Fix a bug where using groups and counts with long table names would return incorrect results.
+
+    *Shota Toguchi*, *Yusaku Ono*
+
+*   Fix encryption of column default values.
+
+    Previously, encrypted attributes that used column default values appeared to
+    be encrypted on create, but were not:
 
-*   Add `.asc.nulls_first` for all databases. Unfortunately MySQL still doesn't like `nulls_last`.
+      ```ruby
+      Book.encrypts :name
 
-    *Keenan Brock*
+      book = Book.create!
+      book.name
+      # => "<untitled>"
+      book.name_before_type_cast
+      # => "{\"p\":\"abc..."
+      book.reload.name_before_type_cast
+      # => "<untitled>"
+      ```
 
-*   Improve performance of `one?` and `many?` by limiting the generated count query to 2 results.
+    Now, attributes with column default values are encrypted:
 
-    *Gonzalo Riestra*
+      ```ruby
+      Book.encrypts :name
 
-*   Don't check type when using `if_not_exists` on `add_column`.
+      book = Book.create!
+      book.name
+      # => "<untitled>"
+      book.name_before_type_cast
+      # => "{\"p\":\"abc..."
+      book.reload.name_before_type_cast
+      # => "{\"p\":\"abc..."
+      ```
 
-    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.
+    *Jonathan Hefner*
+
+*   Deprecate delegation from `Base` to `connection_handler`.
 
-    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.
+    Calling `Base.clear_all_connections!`, `Base.clear_active_connections!`, `Base.clear_reloadable_connections!` and `Base.flush_idle_connections!` is deprecated. Please call these methods on the connection handler directly. In future Rails versions, the delegation from `Base` to the `connection_handler` will be removed.
 
     *Eileen M. Uchitelle*
 
-*   Log a warning message when running SQLite in production.
+*   Allow ActiveRecord::QueryMethods#reselect to receive hash values, similar to ActiveRecord::QueryMethods#select
 
-    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.
+    *Sampat Badhe*
 
-    The warning can be disabled by setting `config.active_record.sqlite3_production_warning=false`.
+*   Validate options when managing columns and tables in migrations.
 
-    *Jacopo Beschi*
+    If an invalid option is passed to a migration method like `create_table` and `add_column`, an error will be raised
+    instead of the option being silently ignored. Validation of the options will only be applied for new migrations
+    that are created.
 
-*   Add option to disable joins for `has_one` associations.
+    *Guo Xiang Tan*, *George Wambold*
 
-    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.
+*   Update query log tags to use the [SQLCommenter](https://open-telemetry.github.io/opentelemetry-sqlcommenter/) format by default. See [#46179](https://github.com/rails/rails/issues/46179)
 
-    Set the option on a has one through association:
+    To opt out of SQLCommenter-formatted query log tags, set `config.active_record.query_log_tags_format = :legacy`. By default, this is set to `:sqlcommenter`.
 
-    ```ruby
-    class Person
-      has_one :dog
-      has_one :veterinarian, through: :dog, disable_joins: true
-    end
-    ```
+    *Modulitos* and *Iheanyi*
 
-    Then instead of generating join SQL, two queries are used for `@person.veterinarian`:
+*   Allow any ERB in the database.yml when creating rake tasks.
 
-    ```
-    SELECT "dogs"."id" FROM "dogs" WHERE "dogs"."person_id" = ?  [["person_id", 1]]
-    SELECT "veterinarians".* FROM "veterinarians" WHERE "veterinarians"."dog_id" = ?  [["dog_id", 1]]
-    ```
+    Any ERB can be used in `database.yml` even if it accesses environment
+    configurations.
 
-    *Sarah Vessels*, *Eileen M. Uchitelle*
+    Deprecates `config.active_record.suppress_multiple_database_warning`.
 
-*   `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.
+    *Eike Send*
 
-    *Mike Dalessio*
+*   Add table to error for duplicate column definitions.
 
-*   `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`.
+    If a migration defines duplicate columns for a table, the error message
+    shows which table it concerns.
 
-    *Mike Dalessio*
+    *Petrik de Heus*
 
-*   Optimize `remove_columns` to use a single SQL statement.
+*   Fix erroneous nil default precision on virtual datetime columns.
 
-    ```ruby
-    remove_columns :my_table, :col_one, :col_two
-    ```
+    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:
 
-    Now results in the following SQL:
+        t.virtual :name, type: datetime,                 as: "expression"
+        t.virtual :name, type: datetime, precision: nil, as: "expression"
 
-    ```sql
-    ALTER TABLE "my_table" DROP COLUMN "col_one", DROP COLUMN "col_two"
-    ```
+    This change fixes the default precision lookup, so virtual and regular
+    datetime column default precisions match.
+
+    *Sam Bostock*
+
+*   Use connection from `#with_raw_connection` in `#quote_string`.
+
+    This ensures that the string quoting is wrapped in the reconnect and retry logic
+    that `#with_raw_connection` offers.
+
+    *Adrianna Chang*
+
+*   Add `expires_at` option to `signed_id`.
 
-    *Jon Dufresne*
+    *Shouichi Kamiya*
 
-*   Ensure `has_one` autosave association callbacks get called once.
+*   Allow applications to set retry deadline for query retries.
 
-    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`.
+    Building on the work done in #44576 and #44591, we extend the logic that automatically
+    reconnects database connections to take into account a timeout limit. We won't retry
+    a query if a given amount of time has elapsed since the query was first attempted. This
+    value defaults to nil, meaning that all retryable queries are retried regardless of time elapsed,
+    but this can be changed via the `retry_deadline` option in the database config.
+
+    *Adrianna Chang*
+
+*   Fix a case where the query cache can return wrong values. See #46044
+
+    *Aaron Patterson*
+
+*   Support MySQL's ssl-mode option for MySQLDatabaseTasks.
+
+    Verifying the identity of the database server requires setting the ssl-mode
+    option to VERIFY_CA or VERIFY_IDENTITY. This option was previously ignored
+    for MySQL database tasks like creating a database and dumping the structure.
 
     *Petrik de Heus*
 
-*   Add option to disable joins for associations.
+*   Move `ActiveRecord::InternalMetadata` to an independent object.
 
-    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.
+    `ActiveRecord::InternalMetadata` no longer inherits from `ActiveRecord::Base` and is now an independent object that should be instantiated with a `connection`. This class is private and should not be used by applications directly. If you want to interact with the schema migrations table, please access it on the connection directly, for example: `ActiveRecord::Base.connection.schema_migration`.
 
-    Set the option on a has many through association:
+    *Eileen M. Uchitelle*
 
-    ```ruby
-    class Dog
-      has_many :treats, through: :humans, disable_joins: true
-      has_many :humans
-    end
+*   Deprecate quoting `ActiveSupport::Duration` as an integer
+
+    Using ActiveSupport::Duration as an interpolated bind parameter in a SQL
+    string template is deprecated. To avoid this warning, you should explicitly
+    convert the duration to a more specific database type. For example, if you
+    want to use a duration as an integer number of seconds:
+    ```
+    Record.where("duration = ?", 1.hour.to_i)
+    ```
+    If you want to use a duration as an ISO 8601 string:
+    ```
+    Record.where("duration = ?", 1.hour.iso8601)
     ```
 
-    Then instead of generating join SQL, two queries are used for `@dog.treats`:
+    *Aram Greenman*
 
-    ```
-    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]]
+*   Allow `QueryMethods#in_order_of` to order by a string column name.
+
+    ```ruby
+    Post.in_order_of("id", [4,2,3,1]).to_a
+    Post.joins(:author).in_order_of("authors.name", ["Bob", "Anna", "John"]).to_a
     ```
 
-    *Eileen M. Uchitelle*, *Aaron Patterson*, *Lee Quarella*
+    *Igor Kasyanchuk*
 
-*   Add setting for enumerating column names in SELECT statements.
+*   Move `ActiveRecord::SchemaMigration` to an independent object.
 
-    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.
+    `ActiveRecord::SchemaMigration` no longer inherits from `ActiveRecord::Base` and is now an independent object that should be instantiated with a `connection`. This class is private and should not be used by applications directly. If you want to interact with the schema migrations table, please access it on the connection directly, for example: `ActiveRecord::Base.connection.schema_migration`.
 
-    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.
+    *Eileen M. Uchitelle*
 
-    Before:
+*   Deprecate `all_connection_pools` and make `connection_pool_list` more explicit.
+
+    Following on #45924 `all_connection_pools` is now deprecated. `connection_pool_list` will either take an explicit role or applications can opt into the new behavior by passing `:all`.
+
+    *Eileen M. Uchitelle*
+
+*   Fix connection handler methods to operate on all pools.
+
+    `active_connections?`, `clear_active_connections!`, `clear_reloadable_connections!`, `clear_all_connections!`, and `flush_idle_connections!` now operate on all pools by default. Previously they would default to using the `current_role` or `:writing` role unless specified.
+
+    *Eileen M. Uchitelle*
+
+
+*   Allow ActiveRecord::QueryMethods#select to receive hash values.
+
+    Currently, `select` might receive only raw sql and symbols to define columns and aliases to select.
+
+    With this change we can provide `hash` as argument, for example:
 
     ```ruby
-    Book.limit(5)
-    # SELECT * FROM books LIMIT 5
+    Post.joins(:comments).select(posts: [:id, :title, :created_at], comments: [:id, :body, :author_id])
+    #=> "SELECT \"posts\".\"id\", \"posts\".\"title\", \"posts\".\"created_at\", \"comments\".\"id\", \"comments\".\"body\", \"comments\".\"author_id\"
+    #   FROM \"posts\" INNER JOIN \"comments\" ON \"comments\".\"post_id\" = \"posts\".\"id\""
+
+    Post.joins(:comments).select(posts: { id: :post_id, title: :post_title }, comments: { id: :comment_id, body: :comment_body })
+    #=> "SELECT posts.id as post_id, posts.title as post_title, comments.id as comment_id, comments.body as comment_body
+    #    FROM \"posts\" INNER JOIN \"comments\" ON \"comments\".\"post_id\" = \"posts\".\"id\""
     ```
+    *Oleksandr Holubenko*, *Josef Šimánek*, *Jean Boussier*
 
-    After:
+*   Adapts virtual attributes on `ActiveRecord::Persistence#becomes`.
+
+    When source and target classes have a different set of attributes adapts
+    attributes such that the extra attributes from target are added.
 
     ```ruby
-    # config/application.rb
-    module MyApp
-      class Application < Rails::Application
-        config.active_record.enumerate_columns_in_select_statements = true
-      end
+    class Person < ApplicationRecord
     end
 
-    # or, configure per-model
-    class Book < ApplicationRecord
-      self.enumerate_columns_in_select_statements = true
+    class WebUser < Person
+      attribute :is_admin, :boolean
+      after_initialize :set_admin
+
+      def set_admin
+        write_attribute(:is_admin, email =~ /@ourcompany\.com$/)
+      end
     end
-    ```
 
-    ```ruby
-    Book.limit(5)
-    # SELECT id, author_id, name, format, status, language, etc FROM books LIMIT 5
+    person = Person.find_by(email: "email@ourcompany.com")
+    person.respond_to? :is_admin
+    # => false
+    person.becomes(WebUser).is_admin?
+    # => true
     ```
 
-    *Matt Duszynski*
+    *Jacopo Beschi*, *Sampson Crowley*
 
-*   Allow passing SQL as `on_duplicate` value to `#upsert_all` to make it possible to use raw SQL to update columns on conflict:
+*   Fix `ActiveRecord::QueryMethods#in_order_of` to include `nil`s, to match the
+    behavior of `Enumerable#in_order_of`.
 
-    ```ruby
-    Book.upsert_all(
-      [{ id: 1, status: 1 }, { id: 2, status: 1 }],
-      on_duplicate: Arel.sql("status = GREATEST(books.status, EXCLUDED.status)")
-    )
-    ```
+    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"])`.
 
-    *Vladimir Dementyev*
+    *fatkodima*
 
-*   Allow passing SQL as `returning` statement to `#upsert_all`:
+*   Optimize `add_timestamps` to use a single SQL statement.
 
     ```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")
-    )
+    add_timestamps :my_table
     ```
 
-    *Vladimir Dementyev*
+    Now results in the following SQL:
 
-*   Deprecate `legacy_connection_handling`.
+    ```sql
+    ALTER TABLE "my_table" ADD COLUMN "created_at" datetime(6) NOT NULL, ADD COLUMN "updated_at" datetime(6) NOT NULL
+    ```
 
-    *Eileen M. Uchitelle*
+    *Iliana Hadzhiatanasova*
+
+*   Add `drop_enum` migration command for PostgreSQL
+
+    This does the inverse of `create_enum`. Before dropping an enum, ensure you have
+    dropped columns that depend on it.
 
-*   Add attribute encryption support.
+    *Alex Ghiculescu*
+
+*   Adds support for `if_exists` option when removing a check constraint.
+
+    The `remove_check_constraint` method now accepts an `if_exists` option. If set
+    to true an error won't be raised if the check constraint doesn't exist.
+
+    *Margaret Parsa* and *Aditya Bhutani*
+
+*   `find_or_create_by` now try to find a second time if it hits a unicity constraint.
+
+    `find_or_create_by` always has been inherently racy, either creating multiple
+    duplicate records or failing with `ActiveRecord::RecordNotUnique` depending on
+    whether a proper unicity constraint was set.
+
+    `create_or_find_by` was introduced for this use case, however it's quite wasteful
+    when the record is expected to exist most of the time, as INSERT require to send
+    more data than SELECT and require more work from the database. Also on some
+    databases it can actually consume a primary key increment which is undesirable.
+
+    So for case where most of the time the record is expected to exist, `find_or_create_by`
+    can be made race-condition free by re-trying the `find` if the `create` failed
+    with `ActiveRecord::RecordNotUnique`. This assumes that the table has the proper
+    unicity constraints, if not, `find_or_create_by` will still lead to duplicated records.
+
+    *Jean Boussier*, *Alex Kitchens*
+
+*   Introduce a simpler constructor API for ActiveRecord database adapters.
+
+    Previously the adapter had to know how to build a new raw connection to
+    support reconnect, but also expected to be passed an initial already-
+    established connection.
+
+    When manually creating an adapter instance, it will now accept a single
+    config hash, and only establish the real connection on demand.
+
+    *Matthew Draper*
 
-    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.
+*   Avoid redundant `SELECT 1` connection-validation query during DB pool
+    checkout when possible.
 
+    If the first query run during a request is known to be idempotent, it can be
+    used directly to validate the connection, saving a network round-trip.
+
+    *Matthew Draper*
+
+*   Automatically reconnect broken database connections when safe, even
+    mid-request.
+
+    When an error occurs while attempting to run a known-idempotent query, and
+    not inside a transaction, it is safe to immediately reconnect to the
+    database server and try again, so this is now the default behavior.
+
+    This new default should always be safe -- to support that, it's consciously
+    conservative about which queries are considered idempotent -- but if
+    necessary it can be disabled by setting the `connection_retries` connection
+    option to `0`.
+
+    *Matthew Draper*
+
+*   Avoid removing a PostgreSQL extension when there are dependent objects.
+
+    Previously, removing an extension also implicitly removed dependent objects. Now, this will raise an error.
+
+    You can force removing the extension:
 
     ```ruby
-    class Person < ApplicationRecord
-      encrypts :name
-      encrypts :email_address, deterministic: true
-    end
+    disable_extension :citext, force: :cascade
     ```
 
-    You can learn more in the [Active Record Encryption
-    guide](https://edgeguides.rubyonrails.org/active_record_encryption.html).
+    Fixes #29091.
 
-    *Jorge Manrubia*
+    *fatkodima*
 
-*   Changed Arel predications `contains` and `overlaps` to use
-    `quoted_node` so that PostgreSQL arrays are quoted properly.
+*   Allow nested functions as safe SQL string
 
-    *Bradley Priest*
+    *Michael Siegfried*
 
-*   Add mode argument to record level `strict_loading!`.
+*   Allow `destroy_association_async_job=` to be configured with a class string instead of a constant.
 
-    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.
+    Defers an autoloading dependency between `ActiveRecord::Base` and `ActiveJob::Base`
+    and moves the configuration of `ActiveRecord::DestroyAssociationAsyncJob`
+    from ActiveJob to ActiveRecord.
 
-    ```ruby
-    developer.strict_loading!(mode: :n_plus_one_only)
+    Deprecates `ActiveRecord::ActiveJobRequiredError` and now raises a `NameError`
+    if the job class is unloadable or an `ActiveRecord::ConfigurationError` if
+    `dependent: :destroy_async` is declared on an association but there is no job
+    class configured.
+
+    *Ben Sheldon*
 
-    developer.projects.to_a # Does not raise
-    developer.projects.first.client # Raises StrictLoadingViolationError
+*   Fix `ActiveRecord::Store` to serialize as a regular Hash
+
+    Previously it would serialize as an `ActiveSupport::HashWithIndifferentAccess`
+    which is wasteful and cause problem with YAML safe_load.
+
+    *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.
+
+    If you don't want this, you can opt out by adding this initializer:
+
+    ```ruby
+    ActiveRecord::Base.time_zone_aware_types -= [:timestamptz]
     ```
 
-    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.
+    *Alex Ghiculescu*
 
-    *Dinah Shi*
+*   Add new `ActiveRecord::Base.generates_token_for` API.
 
-*   Fix Float::INFINITY assignment to datetime column with postgresql adapter.
+    Currently, `signed_id` fulfills the role of generating tokens for e.g.
+    resetting a password.  However, signed IDs cannot reflect record state, so
+    if a token is intended to be single-use, it must be tracked in a database at
+    least until it expires.
 
-    Before:
+    With `generates_token_for`, a token can embed data from a record.  When
+    using the token to fetch the record, the data from the token and the current
+    data from the record will be compared.  If the two do not match, the token
+    will be treated as invalid, the same as if it had expired.  For example:
 
     ```ruby
-    # With this config
-    ActiveRecord::Base.time_zone_aware_attributes = true
+    class User < ActiveRecord::Base
+      has_secure_password
 
-    # and the following schema:
-    create_table "postgresql_infinities" do |t|
-      t.datetime "datetime"
+      generates_token_for :password_reset, expires_in: 15.minutes do
+        # A password's BCrypt salt changes when the password is updated.
+        # By embedding (part of) the salt in a token, the token will
+        # expire when the password is updated.
+        BCrypt::Password.new(password_digest).salt[-10..]
+      end
     end
 
-    # This test fails
-    record = PostgresqlInfinity.create!(datetime: Float::INFINITY)
-    assert_equal Float::INFINITY, record.datetime # record.datetime gets nil
+    user = User.first
+    token = user.generate_token_for(:password_reset)
+
+    User.find_by_token_for(:password_reset, token) # => user
+
+    user.update!(password: "new password")
+    User.find_by_token_for(:password_reset, token) # => nil
     ```
 
-    After this commit, `record.datetime` gets `Float::INFINITY` as expected.
+    *Jonathan Hefner*
+
+*   Optimize Active Record batching for whole table iterations.
 
-    *Shunichi Ikegami*
+    Previously, `in_batches` got all the ids and constructed an `IN`-based query for each batch.
+    When iterating over the whole tables, this approach is not optimal as it loads unneeded ids and
+    `IN` queries with lots of items are slow.
 
-*   Type cast enum values by the original attribute type.
+    Now, whole table iterations use range iteration (`id >= x AND id <= y`) by default which can make iteration
+    several times faster. E.g., tested on a PostgreSQL table with 10 million records: querying (`253s` vs `30s`),
+    updating (`288s` vs `124s`), deleting (`268s` vs `83s`).
 
-    The notable thing about this change is that unknown labels will no longer match 0 on MySQL.
+    Only whole table iterations use this style of iteration by default. You can disable this behavior by passing `use_ranges: false`.
+    If you iterate over the table and the only condition is, e.g., `archived_at: nil` (and only a tiny fraction
+    of the records are archived), it makes sense to opt in to this approach:
 
     ```ruby
-    class Book < ActiveRecord::Base
-      enum :status, { proposed: 0, written: 1, published: 2 }
+    Project.where(archived_at: nil).in_batches(use_ranges: true) do |relation|
+      # do something
     end
     ```
 
-    Before:
+    See #45414 for more details.
+
+    *fatkodima*
+
+*   `.with` query method added. Construct common table expressions with ease and get `ActiveRecord::Relation` back.
 
     ```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)
+    Post.with(posts_with_comments: Post.where("comments_count > ?", 0))
+    # => ActiveRecord::Relation
+    # WITH posts_with_comments AS (SELECT * FROM posts WHERE (comments_count > 0)) SELECT * FROM posts
     ```
 
-    After:
+    *Vlado Cingel*
+
+*   Don't establish a new connection if an identical pool exists already.
+
+    Previously, if `establish_connection` was called on a class that already had an established connection, the existing connection would be removed regardless of whether it was the same config. Now if a pool is found with the same values as the new connection, the existing connection will be returned instead of creating a new one.
+
+    This has a slight change in behavior if application code is depending on a new connection being established regardless of whether it's identical to an existing connection. If the old behavior is desirable, applications should call `ActiveRecord::Base#remove_connection` before establishing a new one. Calling `establish_connection` with a different config works the same way as it did previously.
+
+    *Eileen M. Uchitelle*
+
+*   Update `db:prepare` task to load schema when an uninitialized database exists, and dump schema after migrations.
+
+    *Ben Sheldon*
+
+*   Fix supporting timezone awareness for `tsrange` and `tstzrange` array columns.
 
     ```ruby
-    # SELECT `books`.* FROM `books` WHERE `books`.`status` IS NULL LIMIT 1
-    Book.find_by(status: :prohibited)
-    # => nil (for all adapters)
+    # 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])
     ```
 
-    *Ryuta Kamizono*
+    *Wojciech Wnętrzak*
+
+*   Introduce strategy pattern for executing migrations.
 
-*   Fixtures for `has_many :through` associations now load timestamps on join tables.
+    By default, migrations will use a strategy object that delegates the method
+    to the connection adapter. Consumers can implement custom strategy objects
+    to change how their migrations run.
+
+    *Adrianna Chang*
 
-    Given this fixture:
+*   Add adapter option disallowing foreign keys
 
-    ```yml
-    ### monkeys.yml
-    george:
-      name: George the Monkey
-      fruits: apple
+    This adds a new option to be added to `database.yml` which enables skipping
+    foreign key constraints usage even if the underlying database supports them.
 
-    ### fruits.yml
-    apple:
-      name: apple
+    Usage:
+    ```yaml
+    development:
+        <<: *default
+        database: storage/development.sqlite3
+        foreign_keys: false
     ```
 
-    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.
+    *Paulo Barros*
 
-    *Alex Ghiculescu*
+*   Add configurable deprecation warning for singular associations
 
-*   Allow applications to configure the thread pool for async queries.
+    This adds a deprecation warning when using the plural name of a singular associations in `where`.
+    It is possible to opt into the new more performant behavior with `config.active_record.allow_deprecated_singular_associations_name = false`
 
-    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.
+    *Adam Hess*
 
-    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.
+*   Run transactional callbacks on the freshest instance to save a given
+    record within a transaction.
 
-    *Eileen M. Uchitelle*
+    When multiple Active Record instances change the same record within a
+    transaction, Rails runs `after_commit` or `after_rollback` callbacks for
+    only one of them. `config.active_record.run_commit_callbacks_on_first_saved_instances_in_transaction`
+    was added to specify how Rails chooses which instance receives the
+    callbacks. The framework defaults were changed to use the new logic.
 
-*   Allow new syntax for `enum` to avoid leading `_` from reserved options.
+    When `config.active_record.run_commit_callbacks_on_first_saved_instances_in_transaction`
+    is `true`, transactional callbacks are run on the first instance to save,
+    even though its instance state may be stale.
 
-    Before:
+    When it is `false`, which is the new framework default starting with version
+    7.1, transactional callbacks are run on the instances with the freshest
+    instance state. Those instances are chosen as follows:
 
-    ```ruby
-    class Book < ActiveRecord::Base
-      enum status: [ :proposed, :written ], _prefix: true, _scopes: false
-      enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
-    end
-    ```
+    - In general, run transactional callbacks on the last instance to save a
+      given record within the transaction.
+    - There are two exceptions:
+        - If the record is created within the transaction, then updated by
+          another instance, `after_create_commit` callbacks will be run on the
+          second instance. This is instead of the `after_update_commit`
+          callbacks that would naively be run based on that instance’s state.
+        - If the record is destroyed within the transaction, then
+          `after_destroy_commit` callbacks will be fired on the last destroyed
+          instance, even if a stale instance subsequently performed an update
+          (which will have affected 0 rows).
 
-    After:
+    *Cameron Bothner and Mitch Vollebregt*
+
+*   Enable strict strings mode for `SQLite3Adapter`.
+
+    Configures SQLite with a strict strings mode, which disables double-quoted string literals.
+
+    SQLite has some quirks around double-quoted string literals.
+    It first tries to consider double-quoted strings as identifier names, but if they don't exist
+    it then considers them as string literals. Because of this, typos can silently go unnoticed.
+    For example, it is possible to create an index for a non existing column.
+    See [SQLite documentation](https://www.sqlite.org/quirks.html#double_quoted_string_literals_are_accepted) for more details.
+
+    If you don't want this behavior, you can disable it via:
 
     ```ruby
-    class Book < ActiveRecord::Base
-      enum :status, [ :proposed, :written ], prefix: true, scopes: false
-      enum :cover, [ :hard, :soft ], suffix: true, default: :hard
-    end
+    # config/application.rb
+    config.active_record.sqlite3_adapter_strict_strings_by_default = false
     ```
 
-    *Ryuta Kamizono*
+    Fixes #27782.
 
-*   Add `ActiveRecord::Relation#load_async`.
+    *fatkodima*, *Jean Boussier*
 
-    This method schedules the query to be performed asynchronously from a thread pool.
+*   Resolve issue where a relation cache_version could be left stale.
 
-    If the result is accessed before a background thread had the opportunity to perform
-    the query, it will be performed in the foreground.
+    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.
 
-    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.
+    Usage:
 
     ```ruby
-    def index
-      @categories = Category.some_complex_scope.load_async
-      @posts = Post.some_complex_scope.load_async
-    end
-    ```
+    developers = Developer.all
+    developers.cache_version
 
-    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.
+    Developer.update_all(updated_at: Time.now.utc + 1.second)
 
+    developers.cache_version # Stale cache_version
+    developers.reset
+    developers.cache_version # Returns the current correct cache_version
     ```
-    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*
+    Fixes #45341.
 
-*   Implemented `ActiveRecord::Relation#excluding` method.
+    *Austen Madden*
 
-    This method excludes the specified record (or collection of records) from
-    the resulting relation:
+*   Add support for exclusion constraints (PostgreSQL-only).
 
     ```ruby
-    Post.excluding(post)
-    Post.excluding(post_one, post_two)
+    add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist, name: "invoices_date_overlap"
+    remove_exclusion_constraint :invoices, name: "invoices_date_overlap"
     ```
 
-    Also works on associations:
+    See PostgreSQL's [`CREATE TABLE ... EXCLUDE ...`](https://www.postgresql.org/docs/12/sql-createtable.html#SQL-CREATETABLE-EXCLUDE) documentation for more on exclusion constraints.
+
+    *Alex Robbin*
+
+*   `change_column_null` raises if a non-boolean argument is provided
+
+    Previously if you provided a non-boolean argument, `change_column_null` would
+    treat it as truthy and make your column nullable. This could be surprising, so now
+    the input must be either `true` or `false`.
 
     ```ruby
-    post.comments.excluding(comment)
-    post.comments.excluding(comment_one, comment_two)
+    change_column_null :table, :column, true # good
+    change_column_null :table, :column, false # good
+    change_column_null :table, :column, from: true, to: false # raises (previously this made the column nullable)
     ```
 
-    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).
+    *Alex Ghiculescu*
+
+*   Enforce limit on table names length.
 
-    *Glen Crawford*
+    Fixes #45130.
 
-*   Skip optimised #exist? query when #include? is called on a relation
-    with a having clause.
+    *fatkodima*
 
-    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.
+*   Adjust the minimum MariaDB version for check constraints support.
 
-    A sample query affected by this problem:
+    *Eddie Lebow*
+
+*   Fix Hstore deserialize regression.
+
+    *edsharp*
+
+*   Add validity for PostgreSQL indexes.
 
     ```ruby
-    Author.select('COUNT(*) as total_posts', 'authors.*')
-          .joins(:posts)
-          .group(:id)
-          .having('total_posts > 2')
-          .include?(Author.first)
+    connection.index_exists?(:users, :email, valid: true)
+    connection.indexes(:users).select(&:valid?)
     ```
 
-    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.
+    *fatkodima*
+
+*   Fix eager loading for models without primary keys.
+
+    *Anmol Chopra*, *Matt Lawrence*, and *Jonathan Hefner*
 
-    Fixes #41417.
+*   Avoid validating a unique field if it has not changed and is backed by a unique index.
 
-    *Michael Smart*
+    Previously, when saving a record, Active Record will perform an extra query to check for the
+    uniqueness of each attribute having a `uniqueness` validation, even if that attribute hasn't changed.
+    If the database has the corresponding unique index, then this validation can never fail for persisted
+    records, and we could safely skip it.
 
-*   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.
+    *fatkodima*
 
-    *wbharding*, *Martin Tepper*
+*   Stop setting `sql_auto_is_null`
 
-*   Add ability to apply `scoping` to `all_queries`.
+    Since version 5.5 the default has been off, we no longer have to manually turn it off.
 
-    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.
+    *Adam Hess*
+
+*   Fix `touch` to raise an error for readonly columns.
+
+    *fatkodima*
+
+*   Add ability to ignore tables by regexp for SQL schema dumps.
 
     ```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
+    ActiveRecord::SchemaDumper.ignore_tables = [/^_/]
     ```
 
-    *Eileen M. Uchitelle*
+    *fatkodima*
 
-*   `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`.
+*   Avoid queries when performing calculations on contradictory relations.
 
-    Integers are handled as a special case returning `BigDecimal` always
-    (this was the case before already).
+    Previously calculations would make a query even when passed a
+    contradiction, such as `User.where(id: []).count`. We no longer perform a
+    query in that scenario.
+
+    This applies to the following calculations: `count`, `sum`, `average`,
+    `minimum` and `maximum`
+
+    *Luan Vieira, John Hawthorn and Daniel Colson*
+
+*   Allow using aliased attributes with `insert_all`/`upsert_all`.
 
     ```ruby
-    # With the following schema:
-    create_table "measurements" do |t|
-      t.float "temperature"
+    class Book < ApplicationRecord
+      alias_attribute :title, :name
     end
 
-    # Before:
-    Measurement.average(:temperature).class
-    # => BigDecimal
-
-    # After:
-    Measurement.average(:temperature).class
-    # => Float
+    Book.insert_all [{ title: "Remote", author_id: 1 }], returning: :title
     ```
 
-    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).
+    *fatkodima*
+
+*   Support encrypted attributes on columns with default db values.
 
-    *Josua Schmid*
+    This adds support for encrypted attributes defined on columns with default values.
+    It will encrypt those values at creation time. Before, it would raise an
+    error unless `config.active_record.encryption.support_unencrypted_data` was true.
 
-*   PostgreSQL: introduce `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type`.
+    *Jorge Manrubia* and *Dima Fatko*
 
-    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.
+*   Allow overriding `reading_request?` in `DatabaseSelector::Resolver`
 
-    You should run `bin/rails db:migrate` to rebuild your schema.rb if you change this.
+    The default implementation checks if a request is a `get?` or `head?`,
+    but you can now change it to anything you like. If the method returns true,
+    `Resolver#read` gets called meaning the request could be served by the
+    replica database.
 
     *Alex Ghiculescu*
 
-*   PostgreSQL: handle `timestamp with time zone` columns correctly in `schema.rb`.
+*   Remove `ActiveRecord.legacy_connection_handling`.
 
-    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.
+    *Eileen M. Uchitelle*
+
+*   `rails db:schema:{dump,load}` now checks `ENV["SCHEMA_FORMAT"]` before config
+
+    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:
+
+    ```
+    SCHEMA_FORMAT=sql rake db:schema:dump
+    ```
 
     *Alex Ghiculescu*
 
-*   Removing trailing whitespace when matching columns in
-    `ActiveRecord::Sanitization.disallow_raw_sql!`.
+*   Fixed MariaDB default function support.
 
-    *Gannon McGibbon*, *Adrian Hirt*
+    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.
 
-*   Expose a way for applications to set a `primary_abstract_class`.
+    *kaspernj*
 
-    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`.
+*   Add `active_record.destroy_association_async_batch_size` configuration
 
-    ```ruby
-    class PrimaryApplicationRecord
-      self.primary_abstract_class
-    end
-    ```
+    This allows applications to specify the maximum number of records that will
+    be destroyed in a single background job by the `dependent: :destroy_async`
+    association option. By default, the current behavior will remain the same:
+    when a parent record is destroyed, all dependent records will be destroyed
+    in a single background job. If the number of dependent records is greater
+    than this configuration, the records will be destroyed in multiple
+    background jobs.
 
-    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.
+    *Nick Holden*
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+*   Fix `remove_foreign_key` with `:if_exists` option when foreign key actually exists.
 
-*   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:
+    *fatkodima*
 
-    ```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'
-    ```
+*   Remove `--no-comments` flag in structure dumps for PostgreSQL
 
-    And also use it passing a hash, with one or more keys, where the key
-    is the adapter
+    This broke some apps that used custom schema comments. If you don't want
+    comments in your structure dump, you can use:
 
     ```ruby
-    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = {
-      mysql2: ['--no-defaults', '--skip-add-drop-table'],
-      postgres: '--no-tablespaces'
-    }
+    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = ['--no-comments']
     ```
 
-    *Gustavo Gonzalez*
+    *Alex Ghiculescu*
 
-*   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.
+*   Reduce the memory footprint of fixtures accessors.
 
-    Fixes #41137.
+    Until now fixtures accessors were eagerly defined using `define_method`.
+    So the memory usage was directly dependent of the number of fixtures and
+    test suites.
 
-    *Jonathan Bracy*
+    Instead fixtures accessors are now implemented with `method_missing`,
+    so they incur much less memory and CPU overhead.
 
-*   Allow to opt-out of `strict_loading` mode on a per-record base.
+    *Jean Boussier*
 
-    This is useful when strict loading is enabled application wide or on a
-    model level.
+*   Fix `config.active_record.destroy_association_async_job` configuration
 
-    ```ruby
-    class User < ApplicationRecord
-      has_many :bookmarks
-      has_many :articles, strict_loading: true
-    end
+    `config.active_record.destroy_association_async_job` should allow
+    applications to specify the job that will be used to destroy associated
+    records in the background for `has_many` associations with the
+    `dependent: :destroy_async` option. Previously, that was ignored, which
+    meant the default `ActiveRecord::DestroyAssociationAsyncJob` always
+    destroyed records in the background.
 
-    user = User.first
-    user.articles                        # => ActiveRecord::StrictLoadingViolationError
-    user.bookmarks                       # => #<ActiveRecord::Associations::CollectionProxy>
+    *Nick Holden*
 
-    user.strict_loading!(true)           # => true
-    user.bookmarks                       # => ActiveRecord::StrictLoadingViolationError
+*   Fix `change_column_comment` to preserve column's AUTO_INCREMENT in the MySQL adapter
 
-    user.strict_loading!(false)          # => false
-    user.bookmarks                       # => #<ActiveRecord::Associations::CollectionProxy>
-    user.articles.strict_loading!(false) # => #<ActiveRecord::Associations::CollectionProxy>
-    ```
+    *fatkodima*
 
-    *Ayrton De Craene*
+*   Fix quoting of `ActiveSupport::Duration` and `Rational` numbers in the MySQL adapter.
 
-*   Add `FinderMethods#sole` and `#find_sole_by` to find and assert the
-    presence of exactly one record.
+    *Kevin McPhillips*
 
-    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.
+*   Allow column name with COLLATE (e.g., title COLLATE "C") as safe SQL string
 
-    ```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)
+    *Shugo Maeda*
 
-    user.api_keys.find_sole_by(key: key)
-    # as above
-    ```
+*   Permit underscores in the VERSION argument to database rake tasks.
 
-    *Asherah Connor*
+    *Eddie Lebow*
 
-*   Makes `ActiveRecord::AttributeMethods::Query` respect the getter overrides defined in the model.
+*   Reversed the order of `INSERT` statements in `structure.sql` dumps
 
-    Before:
+    This should decrease the likelihood of merge conflicts. New migrations
+    will now be added at the top of the list.
 
-    ```ruby
-    class User
-      def admin
-        false # Overriding the getter to always return false
-      end
-    end
+    For existing apps, there will be a large diff the next time `structure.sql`
+    is generated.
 
-    user = User.first
-    user.update(admin: true)
+    *Alex Ghiculescu*, *Matt Larraz*
 
-    user.admin # false (as expected, due to the getter overwrite)
-    user.admin? # true (not expected, returned the DB column value)
-    ```
+*   Fix PG.connect keyword arguments deprecation warning on ruby 2.7
+
+    Fixes #44307.
+
+    *Nikita Vasilevsky*
+
+*   Fix dropping DB connections after serialization failures and deadlocks.
 
-    After this commit, `user.admin?` above returns false, as expected.
+    Prior to 6.1.4, serialization failures and deadlocks caused rollbacks to be
+    issued for both real transactions and savepoints. This breaks MySQL which
+    disallows rollbacks of savepoints following a deadlock.
 
-    Fixes #40771.
+    6.1.4 removed these rollbacks, for both transactions and savepoints, causing
+    the DB connection to be left in an unknown state and thus discarded.
 
-    *Felipe*
+    These rollbacks are now restored, except for savepoints on MySQL.
 
-*   Allow delegated_type to be specified primary_key and foreign_key.
+    *Thomas Morgan*
 
-    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.
+*   Make `ActiveRecord::ConnectionPool` Fiber-safe
 
-    *Ryota Egusa*
+    When `ActiveSupport::IsolatedExecutionState.isolation_level` is set to `:fiber`,
+    the connection pool now supports multiple Fibers from the same Thread checking
+    out connections from the pool.
 
-*   Expose an `invert_where` method that will invert all scope conditions.
+    *Alex Matchneer*
+
+*   Add `update_attribute!` to `ActiveRecord::Persistence`
+
+    Similar to `update_attribute`, but raises `ActiveRecord::RecordNotSaved` when a `before_*` callback throws `:abort`.
 
     ```ruby
-    class User
-      scope :active, -> { where(accepted: true, locked: false) }
-    end
+    class Topic < ActiveRecord::Base
+      before_save :check_title
 
-    User.active
-    # ... WHERE `accepted` = 1 AND `locked` = 0
+      def check_title
+        throw(:abort) if title == "abort"
+      end
+    end
 
-    User.active.invert_where
-    # ... WHERE NOT (`accepted` = 1 AND `locked` = 0)
+    topic = Topic.create(title: "Test Title")
+    # #=> #<Topic title: "Test Title">
+    topic.update_attribute!(:title, "Another Title")
+    # #=> #<Topic title: "Another Title">
+    topic.update_attribute!(:title, "abort")
+    # raises ActiveRecord::RecordNotSaved
     ```
 
-    *Kevin Deisz*
+    *Drew Tempelmeyer*
 
-*   Restore possibility of passing `false` to :polymorphic option of `belongs_to`.
+*   Avoid loading every record in `ActiveRecord::Relation#pretty_print`
 
-    Previously, passing `false` would trigger the option validation logic
-    to throw an error saying :polymorphic would not be a valid option.
+    ```ruby
+    # Before
+    pp Foo.all # Loads the whole table.
 
-    *glaszig*
+    # After
+    pp Foo.all # Shows 10 items and an ellipsis.
+    ```
 
-*   Remove deprecated `database` kwarg from `connected_to`.
+    *Ulysse Buonomo*
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+*   Change `QueryMethods#in_order_of` to drop records not listed in values.
 
-*   Allow adding nonnamed expression indexes to be revertible.
+    `in_order_of` now filters down to the values provided, to match the behavior of the `Enumerable` version.
 
-    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.
+    *Kevin Newton*
+
+*   Allow named expression indexes to be revertible.
+
+    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.
 
     ```ruby
-    add_index(:items, "to_tsvector('english', description)")
+    add_index(:settings, "(data->'property')", using: :gin, name: :index_settings_data_property)
     ```
 
-    Fixes #40732.
+    Fixes #43331.
 
-    *fatkodima*
+    *Oliver Günther*
 
-*   Only warn about negative enums if a positive form that would cause conflicts exists.
+*   Fix incorrect argument in PostgreSQL structure dump tasks.
 
-    Fixes #39065.
+    Updating the `--no-comment` argument added in Rails 7 to the correct `--no-comments` argument.
 
-    *Alex Ghiculescu*
+    *Alex Dent*
+
+*   Fix migration compatibility to create SQLite references/belongs_to column as integer when migration version is 6.0.
+
+    Reference/belongs_to in migrations with version 6.0 were creating columns as
+    bigint instead of integer for the SQLite Adapter.
 
-*   Add option to run `default_scope` on all queries.
+    *Marcelo Lauxen*
 
-    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`).
+*   Fix `QueryMethods#in_order_of` to handle empty order list.
 
-    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.
+    ```ruby
+    Post.in_order_of(:id, []).to_a
+    ```
+
+    Also more explicitly set the column as secondary order, so that any other
+    value is still ordered.
+
+    *Jean Boussier*
+
+*   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.
 
     ```ruby
-    class Article < ApplicationRecord
-      default_scope -> { where(blog_id: Current.blog.id) }, all_queries: true
+    class Test < ActiveRecord::Base
+      self.table_name = '1abc'
     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...
     ```
 
-    *Eileen M. Uchitelle*
+    *Jean Boussier*
 
-*   Add `where.associated` to check for the presence of an association.
+*   Add `authenticate_by` when using `has_secure_password`.
 
-    ```ruby
-    # Before:
-    account.users.joins(:contact).where.not(contact_id: nil)
+    `authenticate_by` is intended to replace code like the following, which
+    returns early when a user with a matching email is not found:
 
-    # After:
-    account.users.where.associated(:contact)
+    ```ruby
+    User.find_by(email: "...")&.authenticate("...")
     ```
 
-    Also mirrors `where.missing`.
+    Such code is vulnerable to timing-based enumeration attacks, wherein an
+    attacker can determine if a user account with a given email exists. After
+    confirming that an account exists, the attacker can try passwords associated
+    with that email address from other leaked databases, in case the user
+    re-used a password across multiple sites (a common practice). Additionally,
+    knowing an account email address allows the attacker to attempt a targeted
+    phishing ("spear phishing") attack.
 
-    *Kasper Timm Hansen*
+    `authenticate_by` addresses the vulnerability by taking the same amount of
+    time regardless of whether a user with a matching email is found:
 
-*   Allow constructors (`build_association` and `create_association`) on
-    `has_one :through` associations.
+    ```ruby
+    User.authenticate_by(email: "...", password: "...")
+    ```
 
-    *Santiago Perez Perret*
+    *Jonathan Hefner*
 
 
-Please check [6-1-stable](https://github.com/rails/rails/blob/6-1-stable/activerecord/CHANGELOG.md) for previous changes.
+Please check [7-0-stable](https://github.com/rails/rails/blob/7-0-stable/activerecord/CHANGELOG.md) for previous changes.