activerecord 6.1.7 → 7.1.5

data/CHANGELOG.md

@@ -1,1767 +1,2777 @@
-## Rails 6.1.7 (September 09, 2022) ##
+## Rails 7.1.5 (October 30, 2024) ##
 
-*   Symbol is allowed by default for YAML columns
+*   Fix marshalling of unsaved associated records in 7.1 format.
 
-    *Étienne Barrié*
-
-*   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.
+    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.
 
     *Jean Boussier*
 
-*   Fix PG.connect keyword arguments deprecation warning on ruby 2.7
-
-    Fixes #44307.
+*   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.
 
-    *Nikita Vasilevsky*
+    Previously, using `.left_outer_joins` with the same child association would only join one of the parents.
 
-## Rails 6.1.6.1 (July 12, 2022) ##
+    Now it will correctly join both parents.
 
-*   Change ActiveRecord::Coders::YAMLColumn default to safe_load
+    Fixes #41498.
 
-    This adds two new configuration options The configuration options are as
-    follows:
-    
-    * `config.active_storage.use_yaml_unsafe_load`
-    
-    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.
-    
-    * `config.active_record.yaml_column_permitted_classes`
-    
-    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:
-    
-    ```
-    config.active_record.yaml_column_permitted_classes = [Symbol, Date, Time]
-    ```
+    *Garrett Blehm*
 
-    [CVE-2022-32224]
+*   Ensure `ActiveRecord::Encryption.config` is always ready before access.
 
+    Previously, `ActiveRecord::Encryption` configuration was deferred until `ActiveRecord::Base`
+    was loaded. Therefore, accessing `ActiveRecord::Encryption.config` properties before
+    `ActiveRecord::Base` was loaded would give incorrect results.
 
-## Rails 6.1.6 (May 09, 2022) ##
+    `ActiveRecord::Encryption` now has its own loading hook so that its configuration is set as
+    soon as needed.
 
-*   No changes.
+    When `ActiveRecord::Base` is loaded, even lazily, it in turn triggers the loading of
+    `ActiveRecord::Encryption`, thus preserving the original behavior of having its config ready
+    before any use of `ActiveRecord::Base`.
 
+    *Maxime Réty*
 
-## Rails 6.1.5.1 (April 26, 2022) ##
+*   Add `TimeZoneConverter#==` method, so objects will be properly compared by
+    their type, scale, limit & precision.
 
-*   No changes.
+    Address #52699.
 
+    *Ruy Rocha*
 
-## Rails 6.1.5 (March 09, 2022) ##
 
-*   Fix `ActiveRecord::ConnectionAdapters::SchemaCache#deep_deduplicate` for Ruby 2.6.
+## Rails 7.1.4.2 (October 23, 2024) ##
 
-    Ruby 2.6 and 2.7 have slightly different implementations of the `String#-@` method.
-    In Ruby 2.6, the receiver of the `String#-@` method is modified under certain circumstances.
-    This was later identified as a bug (https://bugs.ruby-lang.org/issues/15926) and only
-    fixed in Ruby 2.7.
+*   No changes.
 
-    Before the changes in this commit, the
-    `ActiveRecord::ConnectionAdapters::SchemaCache#deep_deduplicate` method, which internally
-    calls the `String#-@` method, could also modify an input string argument in Ruby 2.6 --
-    changing a tainted, unfrozen string into a tainted, frozen string.
 
-    Fixes #43056
+## Rails 7.1.4.1 (October 15, 2024) ##
 
-    *Eric O'Hanlon*
+*   No changes.
 
-*   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.
+## Rails 7.1.4 (August 22, 2024) ##
 
-    *Marcelo Lauxen*
+*   Allow to eager load nested nil associations.
 
-*   Fix dbconsole for 3-tier config.
+    *fatkodima*
 
-    *Eileen M. Uchitelle*
+*   Fix `create_table` with `:auto_increment` option for MySQL adapter.
 
-*   Better handle SQL queries with invalid encoding.
+    *fatkodima*
 
-    ```ruby
-    Post.create(name: "broken \xC8 UTF-8")
-    ```
+*   Don't load has_one associations during autosave.
 
-    Would cause all adapters to fail in a non controlled way in the code
-    responsible to detect write queries.
+    *Eugene Kenny*
 
-    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.
+*   Fix migration ordering for `bin/rails db:prepare` across databases.
 
-    *Jean Boussier*
+    *fatkodima*
 
-*   Ignore persisted in-memory records when merging target lists.
+*   Fix `alias_attribute` to ignore methods defined in parent classes.
 
-    *Kevin Sjöberg*
+    *Jean Boussier*
 
-*   Fix regression bug that caused ignoring additional conditions for preloading
-    `has_many` through relations.
+*   Fix a performance regression in attribute methods.
 
-    Fixes #43132
+    *Jean Boussier*
 
-    *Alexander Pauly*
+*   Fix Active Record configs variable shadowing.
 
-*   Fix `ActiveRecord::InternalMetadata` to not be broken by
-    `config.active_record.record_timestamps = false`
+    *Joel Lubrano*
 
-    Since the model always create the timestamp columns, it has to set them, otherwise it breaks
-    various DB management tasks.
+*   Fix running migrations on other databases when `database_tasks: false` on primary.
 
-    Fixes #42983
+    *fatkodima*
 
-    *Jean Boussier*
+*   Fix non-partial inserts for models with composite identity primary keys.
 
-*   Fix duplicate active record objects on `inverse_of`.
+    *fatkodima*
 
-    *Justin Carvalho*
+*   Fix `ActiveRecord::Relation#touch_all` with custom attribute aliased as attribute for update.
 
-*   Fix duplicate objects stored in has many association after save.
+    *fatkodima*
 
-    Fixes #42549.
+*   Fix a crash when an Executor wrapped fork exit.
 
-    *Alex Ghiculescu*
+    *Joé Dupuis*
 
-*   Fix performance regression in `CollectionAssocation#build`.
+*   Fix `destroy_async` job for owners with composite primary keys.
 
-    *Alex Ghiculescu*
+    *fatkodima*
 
-*   Fix retrieving default value for text column for MariaDB.
+*   Ensure pre-7.1 migrations use legacy index names when using `rename_table`.
 
     *fatkodima*
 
+*   Allow `primary_key:` association option to be composite.
 
-## Rails 6.1.4.7 (March 08, 2022) ##
-
-*   No changes.
+    *Nikita Vasilevsky*
 
+*   Do not try to alias on key update when raw SQL is supplied.
 
-## Rails 6.1.4.6 (February 11, 2022) ##
+    *Gabriel Amaral*
 
-*   No changes.
+*   Memoize `key_provider` from `key` or deterministic `key_provider` if any.
 
+    *Rosa Gutierrez*
 
-## Rails 6.1.4.5 (February 11, 2022) ##
+*   Fix `upsert` warning for MySQL.
 
-*   No changes.
+    *fatkodima*
 
+*   Fix predicate builder for polymorphic models referencing models with composite primary keys.
 
-## Rails 6.1.4.4 (December 15, 2021) ##
+    *fatkodima*
 
-*   No changes.
+*   Fix `update_all/delete_all` on CPK model relation with join subquery.
 
+    *Nikita Vasilevsky*
 
-## Rails 6.1.4.3 (December 14, 2021) ##
+*   Remove memoization to accept `key_provider` overridden by `with_encryption_context`.
 
-*   No changes.
+    *John Hawthorn*
 
+*   Raise error for Trilogy when prepared_statements is true.
 
-## Rails 6.1.4.2 (December 14, 2021) ##
+    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.
 
-*   No changes.
+    *Eileen M. Uchitelle*
 
+*   Fix loading schema cache when all databases have disabled database tasks.
 
-## Rails 6.1.4.1 (August 19, 2021) ##
+    *fatkodima*
 
-*   No changes.
+*   Always request `primary_key` in `RETURNING` if no other columns requested.
 
+    *Nikita Vasilevsky*
 
-## Rails 6.1.4 (June 24, 2021) ##
+*   Handle records being loaded with Marshal without triggering schema load
 
-*   Do not try to rollback transactions that failed due to a `ActiveRecord::TransactionRollbackError`.
+    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.
 
-    *Jamie McCarthy*
+    *Jean Boussier*
 
-*   Raise an error if `pool_config` is `nil` in `set_pool_config`.
+*   Prevent some constant redefinition warnings when defining `inherited` on models.
 
-    *Eileen M. Uchitelle*
+    *Adrian Hirt*
 
-*   Fix compatibility with `psych >= 4`.
+*   Fix a memory perfomance regression in attribute methods.
 
-    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.
+    Attribute methods used much more memory and were slower to define than
+    they should have been.
 
     *Jean Boussier*
 
-*   Support using replicas when using `rails dbconsole`.
+*   Fix an issue that could cause database connection leaks.
 
-    *Christopher Thornton*
+    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.
 
-*   Restore connection pools after transactional tests.
-
-    *Eugene Kenny*
+    *Jean Boussier*
 
-*   Change `upsert_all` to fails cleanly for MySQL when `:unique_by` is used.
+*   Fix an issue where the IDs reader method did not return expected results
+    for preloaded associations in models using composite primary keys.
 
-    *Bastian Bartmann*
+    *Jay Ang*
 
-*   Fix user-defined `self.default_scope` to respect table alias.
+*   PostgreSQL `Cidr#change?` detects the address prefix change.
 
-    *Ryuta Kamizono*
+    *Taketo Takashima*
 
-*   Clear `@cache_keys` cache after `update_all`, `delete_all`, `destroy_all`.
+*   Fix Active Record serialization to not include instantiated but not loaded associations
 
-    *Ryuta Kamizono*
+    *Jean Boussier*, *Ben Kyriakou*
 
-*   Changed Arel predications `contains` and `overlaps` to use
-    `quoted_node` so that PostgreSQL arrays are quoted properly.
+*   Allow `Sqlite3Adapter` to use `sqlite3` gem version `2.x`
 
-    *Bradley Priest*
+    *Mike Dalessio*
 
-*   Fix `merge` when the `where` clauses have string contents.
+*   Strict loading using `:n_plus_one_only` does not eagerly load child associations.
 
-    *Ryuta Kamizono*
+    With this change, child associations are no longer eagerly loaded, to
+    match intended behavior and to prevent non-deterministic order issues caused
+    by calling methods like `first` or `last`. As `first` and `last` don't cause
+    an N+1 by themselves, calling child associations will no longer raise.
+    Fixes #49473.
 
-*   Fix rollback of parent destruction with nested `dependent: :destroy`.
+    Before:
 
-    *Jacopo Beschi*
+    ```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
+    ```
 
-*   Fix binds logging for `"WHERE ... IN ..."` statements.
+    After:
 
-    *Ricardo Díaz*
+    ```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
+    ```
 
-*   Handle `false` in relation strict loading checks.
+    *Reid Lynch*
 
-    Previously when a model had strict loading set to true and then had a
-    relation set `strict_loading` to false the false wasn't considered when
-    deciding whether to raise/warn about strict loading.
+*   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.
 
-    ```
-    class Dog < ActiveRecord::Base
-      self.strict_loading_by_default = true
+    *Joshua Young*
 
-      has_many :treats, strict_loading: false
-    end
-    ```
+*   Fix `has_one` association autosave setting the foreign key attribute when it is unchanged.
 
-    In the example, `dog.treats` would still raise even though
-    `strict_loading` was set to false. This is a bug affecting more than
-    Active Storage which is why I made this PR superseding #41461. We need
-    to fix this for all applications since the behavior is a little
-    surprising. I took the test from #41461 and the code suggestion from #41453
-    with some additions.
+    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.
 
-    *Eileen M. Uchitelle*, *Radamés Roriz*
+    *Joshua Young*
 
-*   Fix numericality validator without precision.
+*   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.
 
-    *Ryuta Kamizono*
+    *Maxime Réty*
 
-*   Fix aggregate attribute on Enum types.
+*   Properly synchronize `Mysql2Adapter#active?` and `TrilogyAdapter#active?`
 
-    *Ryuta Kamizono*
+    As well as `disconnect!` and `verify!`.
 
-*   Fix `CREATE INDEX` statement generation for PostgreSQL.
+    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.
 
-    *eltongo*
+    *Jean Boussier*
 
-*   Fix where clause on enum attribute when providing array of strings.
+*   Fix counter caches when the foreign key is composite.
 
-    *Ryuta Kamizono*
+    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...`
 
-*   Fix `unprepared_statement` to work it when nesting.
+    *fatkodima*
 
-    *Ryuta Kamizono*
+*   Fix loading of schema cache for multiple databases.
 
+    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.
 
-## Rails 6.1.3.2 (May 05, 2021) ##
+    *Rafael Mendonça França*
 
-*   No changes.
+*   Fix eager loading of composite primary key associations.
 
+    `relation.eager_load(:other_model)` could load the wrong records if `other_model`
+    had a composite primary key.
 
-## Rails 6.1.3.1 (March 26, 2021) ##
+    *Nikita Vasilevsky*
 
-*   No changes.
+*   Fix async queries returning a doubly wrapped result when hitting the query cache.
 
+    *fatkodima*
 
-## Rails 6.1.3 (February 17, 2021) ##
+*   Fix single quote escapes on default generated MySQL columns
 
-*   Fix the MySQL adapter to always set the right collation and charset
-    to the connection session.
+    MySQL 5.7.5+ supports generated columns, which can be used to create a column that is computed from an expression.
 
-    *Rafael Mendonça França*
+    Previously, the schema dump would output a string with double escapes for generated columns with single quotes in the default expression.
 
-*   Fix MySQL adapter handling of time objects when prepared statements
-    are enabled.
+    This would result in issues when importing the schema on a fresh instance of a MySQL database.
 
-    *Rafael Mendonça França*
+    Now, the string will not be escaped and will be valid Ruby upon importing of the schema.
 
-*   Fix scoping in enum fields using conditions that would generate
-    an `IN` clause.
+    *Yash Kapadia*
 
-    *Ryuta Kamizono*
+*   Fix Migrations with versions older than 7.1 validating options given to
+    `t.references`.
 
-*   Skip optimised #exist? query when #include? is called on a relation
-    with a having clause
+    *Hartley McGuire*
 
-    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.
 
-    An sample query affected by this problem:
+## Rails 7.1.3.4 (June 04, 2024) ##
 
-    ```ruby
-    Author.select('COUNT(*) as total_posts', 'authors.*')
-          .joins(:posts)
-          .group(:id)
-          .having('total_posts > 2')
-          .include?(Author.first)
-    ```
+*   No changes.
 
-    This change adds an addition check to the condition that skips the
-    simplified #exists? query, which simply checks for the presence of
-    a having clause.
 
-    Fixes #41417
+## Rails 7.1.3.3 (May 16, 2024) ##
 
-    *Michael Smart*
+*   No changes.
 
-*   Increment postgres prepared statement counter before making a prepared statement, so if the statement is aborted
-    without Rails knowledge (e.g., if app gets kill -9d during long-running query or due to Rack::Timeout), app won't end
-    up in perpetual crash state for being inconsistent with Postgres.
 
-    *wbharding*, *Martin Tepper*
+## Rails 7.1.3.2 (February 21, 2024) ##
 
+*   No changes.
 
-## Rails 6.1.2.1 (February 10, 2021) ##
 
-*   Fix possible DoS vector in PostgreSQL money type
+## Rails 7.1.3.1 (February 21, 2024) ##
 
-    Carefully crafted input can cause a DoS via the regular expressions used
-    for validating the money format in the PostgreSQL adapter.  This patch
-    fixes the regexp.
+*   No changes.
 
-    Thanks to @dee-see from Hackerone for this patch!
 
-    [CVE-2021-22880]
+## Rails 7.1.3 (January 16, 2024) ##
 
-    *Aaron Patterson*
+*   Fix Migrations with versions older than 7.1 validating options given to
+    `add_reference`.
 
+    *Hartley McGuire*
 
-## Rails 6.1.2 (February 09, 2021) ##
+*   Ensure `reload` sets correct owner for each association.
 
-*   Fix timestamp type for sqlite3.
+    *Dmytro Savochkin*
 
-    *Eileen M. Uchitelle*
+*   Fix view runtime for controllers with async queries.
 
-*   Make destroy async transactional.
+    *fatkodima*
 
-    An active record rollback could occur while enqueuing a job. In this
-    case the job would enqueue even though the database deletion
-    rolledback putting things in a funky state.
+*   Fix `load_async` to work with query cache.
 
-    Now the jobs are only enqueued until after the db transaction has been committed.
+    *fatkodima*
 
-    *Cory Gwin*
+*   Fix polymorphic `belongs_to` to correctly use parent's `query_constraints`.
 
-*   Fix malformed packet error in MySQL statement for connection configuration.
+    *fatkodima*
 
-    *robinroestenburg*
+*   Fix `Preloader` to not generate a query for already loaded association with `query_constraints`.
 
-*   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.
+    *fatkodima*
 
-    Fixes #41137.
+*   Fix multi-database polymorphic preloading with equivalent table names.
 
-    *Jonathan Bracy*
+    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.
 
-*   Fix granular connection swapping when there are multiple abstract classes.
+    *Ari Summer*
 
-    *Eileen M. Uchitelle*
+*   Fix `encrypted_attribute?` to take into account context properties passed to `encrypts`.
 
-*   Fix `find_by` with custom primary key for belongs_to association.
+    *Maxime Réty*
 
-    *Ryuta Kamizono*
+*   Fix `find_by` to work correctly in presence of composite primary keys.
 
-*   Add support for `rails console --sandbox` for multiple database applications.
+    *fatkodima*
 
-    *alpaca-tc*
+*   Fix async queries sometimes returning a raw result if they hit the query cache.
 
-*   Fix `where` on polymorphic association with empty array.
+    `ShipPart.async_count` could return a raw integer rather than a Promise
+    if it found the result in the query cache.
 
-    *Ryuta Kamizono*
+    *fatkodima*
 
-*   Fix preventing writes for `ApplicationRecord`.
+*   Fix `Relation#transaction` to not apply a default scope.
 
-    *Eileen M. Uchitelle*
+    The method was incorrectly setting a default scope around its block:
 
+    ```ruby
+    Post.where(published: true).transaction do
+      Post.count # SELECT COUNT(*) FROM posts WHERE published = FALSE;
+    end
+    ```
 
-## Rails 6.1.1 (January 07, 2021) ##
+    *Jean Boussier*
 
-*   Fix fixtures loading when strict loading is enabled for the association.
+*   Fix calling `async_pluck` on a `none` relation.
 
-    *Alex Ghiculescu*
+    `Model.none.async_pluck(:id)` was returning a naked value
+    instead of a promise.
 
-*   Fix `where` with custom primary key for belongs_to association.
+    *Jean Boussier*
 
-    *Ryuta Kamizono*
+*   Fix calling `load_async` on a `none` relation.
 
-*   Fix `where` with aliased associations.
+    `Model.none.load_async` was returning a broken result.
 
-    *Ryuta Kamizono*
+    *Lucas Mazza*
 
-*   Fix `composed_of` with symbol mapping.
+*   TrilogyAdapter: ignore `host` if `socket` parameter is set.
 
-    *Ryuta Kamizono*
+    This allows to configure a connection on a UNIX socket via DATABASE_URL:
 
-*   Don't skip money's type cast for pluck and calculations.
+    ```
+    DATABASE_URL=trilogy://does-not-matter/my_db_production?socket=/var/run/mysql.sock
+    ```
 
-    *Ryuta Kamizono*
+    *Jean Boussier*
 
-*   Fix `where` on polymorphic association with non Active Record object.
+*   Fix `has_secure_token` calls the setter method on initialize.
 
-    *Ryuta Kamizono*
+    *Abeid Ahmed*
 
-*   Make sure `db:prepare` works even the schema file doesn't exist.
+*   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.
 
-    *Rafael Mendonça França*
+    *Mikhail Doronin*
 
-*   Fix complicated `has_many :through` with nested where condition.
+*   Fix `rails db:create:all` to not touch databases before they are created.
 
-    *Ryuta Kamizono*
+    *fatkodima*
 
-*   Handle STI models for `has_many dependent: :destroy_async`.
 
-    *Muhammad Usman*
+## Rails 7.1.2 (November 10, 2023) ##
 
-*   Restore possibility of passing `false` to :polymorphic option of `belongs_to`.
+*   Fix renaming primary key index when renaming a table with a UUID primary key
+    in PostgreSQL.
 
-    Previously, passing `false` would trigger the option validation logic
-    to throw an error saying :polymorphic would not be a valid option.
+    *fatkodima*
 
-    *glaszig*
+*   Fix `where(field: values)` queries when `field` is a serialized attribute
+    (for example, when `field` uses `ActiveRecord::Base.serialize` or is a JSON
+    column).
 
-*   Allow adding nonnamed expression indexes to be revertible.
+    *João Alves*
 
-    Fixes #40732.
+*   Prevent marking broken connections as verified.
 
-    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.
+    *Daniel Colson*
 
-    ```ruby
-    add_index(:items, "to_tsvector('english', description)")
-    ```
+*   Don't mark Float::INFINITY as changed when reassigning it
 
-    *fatkodima*
+    When saving a record with a float infinite value, it shouldn't mark as changed
 
+    *Maicol Bentancor*
 
-## Rails 6.1.0 (December 09, 2020) ##
+*   `ActiveRecord::Base.table_name` now returns `nil` instead of raising
+    "undefined method `abstract_class?` for Object:Class".
 
-*   Only warn about negative enums if a positive form that would cause conflicts exists.
+    *a5-stable*
 
-    Fixes #39065.
+*   Fix upserting for custom `:on_duplicate` and `:unique_by` consisting of all
+    inserts keys.
 
-    *Alex Ghiculescu*
+    *fatkodima*
 
-*   Change `attribute_for_inspect` to take `filter_attributes` in consideration.
+*   Fixed an [issue](https://github.com/rails/rails/issues/49809) where saving a
+    record could innappropriately `dup` its attributes.
 
-    *Rafael Mendonça França*
+    *Jonathan Hefner*
 
-*   Fix odd behavior of inverse_of with multiple belongs_to to same class.
+*   Dump schema only for a specific db for rollback/up/down tasks for multiple dbs.
 
-    Fixes #35204.
+    *fatkodima*
 
-    *Tomoyuki Kai*
+*   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"`.
 
-*   Build predicate conditions with objects that delegate `#id` and primary key:
+    *Andreas Reischuck* and *Jonathan Hefner*
 
-    ```ruby
-    class AdminAuthor
-      delegate_missing_to :@author
+*   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:
 
-      def initialize(author)
-        @author = author
+      ```ruby
+      class Post < ActiveRecord::Base
+        attribute :topic, :string
+        enum topic: %i[science tech engineering math]
       end
-    end
-
-    Post.where(author: AdminAuthor.new(author))
-    ```
+      ```
 
-    *Sean Doyle*
+    *Jonathan Hefner*
 
-*   Add `connected_to_many` API.
+*   Raise on `foreign_key:` being passed as an array in associations
 
-    This API allows applications to connect to multiple databases at once without switching all of them or implementing a deeply nested stack.
+    *Nikita Vasilevsky*
 
-    Before:
+*   Return back maximum allowed PostgreSQL table name to 63 characters.
 
-        AnimalsRecord.connected_to(role: :reading) do
-          MealsRecord.connected_to(role: :reading) do
-            Dog.first # read from animals replica
-            Dinner.first # read from meals replica
-            Person.first # read from primary writer
-          end
-        end
+    *fatkodima*
 
-    After:
+*   Fix detecting `IDENTITY` columns for PostgreSQL < 10.
 
-        ActiveRecord::Base.connected_to_many([AnimalsRecord, MealsRecord], role: :reading) do
-          Dog.first # read from animals replica
-          Dinner.first # read from meals replica
-          Person.first # read from primary writer
-        end
+    *fatkodima*
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
 
-*   Add option to raise or log for `ActiveRecord::StrictLoadingViolationError`.
+## Rails 7.1.1 (October 11, 2023) ##
 
-    Some applications may not want to raise an error in production if using `strict_loading`. This would allow an application to set strict loading to log for the production environment while still raising in development and test environments.
+*   Fix auto populating IDENTITY columns for PostgreSQL.
 
-    Set `config.active_record.action_on_strict_loading_violation` to `:log` errors instead of raising.
+    *fatkodima*
 
-    *Eileen M. Uchitelle*
+*   Fix "ArgumentError: wrong number of arguments (given 3, expected 2)" when
+    down migrating `rename_table` in older migrations.
 
-*   Allow the inverse of a `has_one` association that was previously autosaved to be loaded.
+    *fatkodima*
 
-    Fixes #34255.
+*   Do not require the Action Text, Active Storage and Action Mailbox tables
+    to be present when running when running test on CI.
 
-    *Steven Weber*
+    *Rafael Mendonça França*
 
-*   Optimise the length of index names for polymorphic references by using the reference name rather than the type and id column names.
 
-    Because the default behaviour when adding an index with multiple columns is to use all column names in the index name, this could frequently lead to overly long index names for polymorphic references which would fail the migration if it exceeded the database limit.
+## Rails 7.1.0 (October 05, 2023) ##
 
-    This change reduces the chance of that happening by using the reference name, e.g. `index_my_table_on_my_reference`.
+*   No changes.
 
-    Fixes #38655.
 
-    *Luke Redpath*
+## Rails 7.1.0.rc2 (October 01, 2023) ##
 
-*   MySQL: Uniqueness validator now respects default database collation,
-    no longer enforce case sensitive comparison by default.
+*   Remove -shm and -wal SQLite files when `rails db:drop` is run.
 
-    *Ryuta Kamizono*
+    *Niklas Häusele*
 
-*   Remove deprecated methods from `ActiveRecord::ConnectionAdapters::DatabaseLimits`.
+*   Revert the change to raise an `ArgumentError` when `#accepts_nested_attributes_for` is declared more than once for
+    an association in the same class.
 
-    `column_name_length`
-    `table_name_length`
-    `columns_per_table`
-    `indexes_per_table`
-    `columns_per_multicolumn_index`
-    `sql_query_length`
-    `joins_per_query`
+    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*
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::AbstractAdapter#supports_multi_insert?`.
 
-    *Rafael Mendonça França*
+## Rails 7.1.0.rc1 (September 27, 2023) ##
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::AbstractAdapter#supports_foreign_keys_in_create?`.
+*   Better naming for unique constraints support.
 
-    *Rafael Mendonça França*
+    Naming unique keys leads to misunderstanding it's a short-hand of unique indexes.
+    Just naming it unique constraints is not misleading.
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter#supports_ranges?`.
+    In Rails 7.1.0.beta1 or before:
 
-    *Rafael Mendonça França*
+    ```ruby
+    add_unique_key :sections, [:position], deferrable: :deferred, name: "unique_section_position"
+    remove_unique_key :sections, name: "unique_section_position"
+    ```
 
-*   Remove deprecated `ActiveRecord::Base#update_attributes` and `ActiveRecord::Base#update_attributes!`.
+    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"
+    ```
 
-*   Remove deprecated `migrations_path` argument in `ActiveRecord::ConnectionAdapter::SchemaStatements#assume_migrated_upto_version`.
+    *Ryuta Kamizono*
 
-    *Rafael Mendonça França*
+*   Fix duplicate quoting for check constraint expressions in schema dump when using MySQL
 
-*   Remove deprecated `config.active_record.sqlite3.represent_boolean_as_integer`.
+    A check constraint with an expression, that already contains quotes, lead to an invalid schema
+    dump with the mysql2 adapter.
 
-    *Rafael Mendonça França*
+    Fixes #42424.
 
-*   `relation.create` does no longer leak scope to class level querying methods
-    in initialization block and callbacks.
+    *Felix Tscheulin*
 
-    Before:
+*   Performance tune the SQLite3 adapter connection configuration
 
-        User.where(name: "John").create do |john|
-          User.find_by(name: "David") # => nil
-        end
+    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.
 
-    After:
+    *Stephen Margheim*
 
-        User.where(name: "John").create do |john|
-          User.find_by(name: "David") # => #<User name: "David", ...>
-        end
+*   Allow SQLite3 `busy_handler` to be configured with simple max number of `retries`
 
-    *Ryuta Kamizono*
+    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`.
 
-*   Named scope chain does no longer leak scope to class level querying methods.
+    *Stephen Margheim*
 
-        class User < ActiveRecord::Base
-          scope :david, -> { User.where(name: "David") }
-        end
+*   The SQLite3 adapter now supports `supports_insert_returning?`
 
-    Before:
+    Implementing the full `supports_insert_returning?` contract means the SQLite3 adapter supports auto-populated columns (#48241) as well as custom primary keys.
 
-        User.where(name: "John").david
-        # SELECT * FROM users WHERE name = 'John' AND name = 'David'
+    *Stephen Margheim*
 
-    After:
+*   Ensure the SQLite3 adapter handles default functions with the `||` concatenation operator
 
-        User.where(name: "John").david
-        # SELECT * FROM users WHERE name = 'David'
+    Previously, this default function would produce the static string `"'Ruby ' || 'on ' || 'Rails'"`.
+    Now, the adapter will appropriately receive and use `"Ruby on Rails"`.
 
-    *Ryuta Kamizono*
+    ```ruby
+    change_column_default "test_models", "ruby_on_rails", -> { "('Ruby ' || 'on ' || 'Rails')" }
+    ```
 
-*   Remove deprecated methods from `ActiveRecord::DatabaseConfigurations`.
+    *Stephen Margheim*
 
-    `fetch`
-    `each`
-    `first`
-    `values`
-    `[]=`
+*   Dump PostgreSQL schemas as part of the schema dump.
 
-    *Rafael Mendonça França*
+    *Lachlan Sylvester*
 
-*   `where.not` now generates NAND predicates instead of NOR.
 
-     Before:
+## Rails 7.1.0.beta1 (September 13, 2023) ##
 
-        User.where.not(name: "Jon", role: "admin")
-        # SELECT * FROM users WHERE name != 'Jon' AND role != 'admin'
+*   Encryption now supports `support_unencrypted_data` being set per-attribute.
 
-     After:
+    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`.
 
-        User.where.not(name: "Jon", role: "admin")
-        # SELECT * FROM users WHERE NOT (name == 'Jon' AND role == 'admin')
+    ```ruby
+    class User < ActiveRecord::Base
+      encrypts :name, deterministic: true, support_unencrypted_data: false
+      encrypts :email, deterministic: true
+    end
+    ```
 
-    *Rafael Mendonça França*
+    *Alex Ghiculescu*
 
-*   Remove deprecated `ActiveRecord::Result#to_hash` method.
+*   Add instrumentation for Active Record transactions
 
-    *Rafael Mendonça França*
+    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.
 
-*   Deprecate `ActiveRecord::Base.allow_unsafe_raw_sql`.
+    ```ruby
+    ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      puts "Transaction event occurred!"
+      connection = event.payload[:connection]
+      puts "Connection: #{connection.inspect}"
+    end
+    ```
 
-    *Rafael Mendonça França*
+    *Daniel Colson*, *Ian Candy*
 
-*   Remove deprecated support for using unsafe raw SQL in `ActiveRecord::Relation` methods.
+*   Support composite foreign keys via migration helpers.
 
-    *Rafael Mendonça França*
+    ```ruby
+    # Assuming "carts" table has "(shop_id, user_id)" as a primary key.
 
-*   Allow users to silence the "Rails couldn't infer whether you are using multiple databases..."
-    message using `config.active_record.suppress_multiple_database_warning`.
+    add_foreign_key(:orders, :carts, primary_key: [:shop_id, :user_id])
 
-    *Omri Gabay*
+    remove_foreign_key(:orders, :carts, primary_key: [:shop_id, :user_id])
+    foreign_key_exists?(:orders, :carts, primary_key: [:shop_id, :user_id])
+    ```
 
-*   Connections can be granularly switched for abstract classes when `connected_to` is called.
+    *fatkodima*
 
-    This change allows `connected_to` to switch a `role` and/or `shard` for a single abstract class instead of all classes globally. Applications that want to use the new feature need to set `config.active_record.legacy_connection_handling` to `false` in their application configuration.
+*   Adds support for `if_not_exists` when adding a check constraint.
 
-    Example usage:
+    ```ruby
+    add_check_constraint :posts, "post_type IN ('blog', 'comment', 'share')", if_not_exists: true
+    ```
 
-    Given an application we have a `User` model that inherits from `ApplicationRecord` and a `Dog` model that inherits from `AnimalsRecord`. `AnimalsRecord` and `ApplicationRecord` have writing and reading connections as well as shard `default`, `one`, and `two`.
+    *Cody Cutrer*
 
-    ```ruby
-    ActiveRecord::Base.connected_to(role: :reading) do
-      User.first # reads from default replica
-      Dog.first # reads from default replica
+*   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.
 
-      AnimalsRecord.connected_to(role: :writing, shard: :one) do
-        User.first # reads from default replica
-        Dog.first # reads from shard one primary
-      end
+    *Joshua Young*
 
-      User.first # reads from default replica
-      Dog.first # reads from default replica
+*   Deprecate `rewhere` argument on `#merge`.
 
-      ApplicationRecord.connected_to(role: :writing, shard: :two) do
-        User.first # reads from shard two primary
-        Dog.first # reads from default replica
-      end
-    end
-    ```
+    The `rewhere` argument on `#merge`is deprecated without replacement and
+    will be removed in Rails 7.2.
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    *Adam Hess*
 
-*   Allow double-dash comment syntax when querying read-only databases
+*   Deprecate aliasing non-attributes with `alias_attribute`.
 
-    *James Adam*
+    *Ian Candy*
 
-*   Add `values_at` method.
+*   Fix unscope is not working in specific case
+
+    Before:
+    ```ruby
+    Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts` WHERE `posts`.`id` >= 1 AND `posts`.`id` < 3"
 
-    Returns an array containing the values associated with the given methods.
+    ```
 
+    After:
     ```ruby
-    topic = Topic.first
-    topic.values_at(:title, :author_name)
-    # => ["Budget", "Jason"]
+    Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts`"
     ```
 
-    Similar to `Hash#values_at` but on an Active Record instance.
+    Fixes #48094.
 
-    *Guillaume Briday*
+    *Kazuya Hatanaka*
 
-*   Fix `read_attribute_before_type_cast` to consider attribute aliases.
+*   Change `has_secure_token` default to `on: :initialize`
 
-    *Marcelo Lauxen*
+    Change the new default value from `on: :create` to `on: :initialize`
 
-*   Support passing record to uniqueness validator `:conditions` callable:
+    Can be controlled by the `config.active_record.generate_secure_token_on`
+    configuration:
 
     ```ruby
-    class Article < ApplicationRecord
-      validates_uniqueness_of :title, conditions: ->(article) {
-        published_at = article.published_at
-        where(published_at: published_at.beginning_of_year..published_at.end_of_year)
-      }
-    end
+    config.active_record.generate_secure_token_on = :create
     ```
 
-    *Eliot Sykes*
+    *Sean Doyle*
 
-*   `BatchEnumerator#update_all` and `BatchEnumerator#delete_all` now return the
-    total number of rows affected, just like their non-batched counterparts.
+*   Fix `change_column` not setting `precision: 6` on `datetime` columns when
+    using 7.0+ Migrations and SQLite.
 
-    ```ruby
-    Person.in_batches.update_all("first_name = 'Eugene'") # => 42
-    Person.in_batches.delete_all # => 42
-    ```
+    *Hartley McGuire*
 
-    Fixes #40287.
+*   Support composite identifiers in `to_key`
 
-    *Eugene Kenny*
+    `to_key` avoids wrapping `#id` value into an `Array` if `#id` already an array
 
-*   Add support for PostgreSQL `interval` data type with conversion to
-    `ActiveSupport::Duration` when loading records from database and
-    serialization to ISO 8601 formatted duration string on save.
-    Add support to define a column in migrations and get it in a schema dump.
-    Optional column precision is supported.
+    *Nikita Vasilevsky*
 
-    To use this in 6.1, you need to place the next string to your model file:
+*   Add validation option for `enum`
 
-        attribute :duration, :interval
+    ```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
 
-    To keep old behavior until 7.0 is released:
+    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
+    ```
 
-        attribute :duration, :string
+    *Edem Topuzov*, *Ryuta Kamizono*
 
-    Example:
+*   Allow batching methods to use already loaded relation if available
 
-        create_table :events do |t|
-          t.string   :name
-          t.interval :duration
-        end
+    Calling batch methods on already loaded relations will use the records previously loaded instead of retrieving
+    them from the database again.
 
-        class Event < ApplicationRecord
-          attribute :duration, :interval
-        end
+    *Adam Hess*
 
-        Event.create!(name: 'Rock Fest', duration: 2.days)
-        Event.last.duration # => 2 days
-        Event.last.duration.iso8601 # => "P2D"
-        Event.new(duration: 'P1DT12H3S').duration # => 1 day, 12 hours, and 3 seconds
-        Event.new(duration: '1 day') # Unknown value will be ignored and NULL will be written to database
+*   Deprecate `read_attribute(:id)` returning the primary key if the primary key is not `:id`.
 
-    *Andrey Novikov*
+    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.
 
-*   Allow associations supporting the `dependent:` key to take `dependent: :destroy_async`.
+    *Adrianna Chang*
 
-    ```ruby
-    class Account < ActiveRecord::Base
-        belongs_to :supplier, dependent: :destroy_async
-    end
-    ```
+*   Fix `change_table` setting datetime precision for 6.1 Migrations
 
-    `:destroy_async` will enqueue a job to destroy associated records in the background.
+    *Hartley McGuire*
 
-    *DHH*, *George Claghorn*, *Cory Gwin*, *Rafael Mendonça França*, *Adrianna Chang*
+*   Fix change_column setting datetime precision for 6.1 Migrations
 
-*   Add `SKIP_TEST_DATABASE` environment variable to disable modifying the test database when `rails db:create` and `rails db:drop` are called.
+    *Hartley McGuire*
 
-    *Jason Schweier*
+*   Add `ActiveRecord::Base#id_value` alias to access the raw value of a record's id column.
 
-*   `connects_to` can only be called on `ActiveRecord::Base` or abstract classes.
+    This alias is only provided for models that declare an `:id` column.
 
-    Ensure that `connects_to` can only be called from `ActiveRecord::Base` or abstract classes. This protects the application from opening duplicate or too many connections.
+    *Adrianna Chang*
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+*   Fix previous change tracking for `ActiveRecord::Store` when using a column with JSON structured database type
 
-*   All connection adapters `execute` now raises `ActiveRecord::ConnectionNotEstablished` rather than
-    `ActiveRecord::StatementInvalid` when they encounter a connection error.
+    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
 
-    *Jean Boussier*
+    *Robert DiMartino*
 
-*   `Mysql2Adapter#quote_string` now raises `ActiveRecord::ConnectionNotEstablished` rather than
-    `ActiveRecord::StatementInvalid` when it can't connect to the MySQL server.
+*   Fully support `NULLS [NOT] DISTINCT` for PostgreSQL 15+ indexes.
 
-    *Jean Boussier*
+    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.
 
-*   Add support for check constraints that are `NOT VALID` via `validate: false` (PostgreSQL-only).
+    *Gregory Jones*
 
-    *Alex Robbin*
+*   Allow escaping of literal colon characters in `sanitize_sql_*` methods when named bind variables are used
 
-*   Ensure the default configuration is considered primary or first for an environment
+    *Justin Bull*
 
-    If a multiple database application provides a configuration named primary, that will be treated as default. In applications that do not have a primary entry, the default database configuration will be the first configuration for an environment.
+*   Fix `#previously_new_record?` to return true for destroyed records.
 
-    *Eileen M. Uchitelle*
+    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.
+
+    *Adrianna Chang*
 
-*   Allow `where` references association names as joined table name aliases.
+*   Specify callback in `has_secure_token`
 
     ```ruby
-    class Comment < ActiveRecord::Base
-      enum label: [:default, :child]
-      has_many :children, class_name: "Comment", foreign_key: :parent_id
+    class User < ApplicationRecord
+      has_secure_token on: :initialize
     end
 
-    # ... FROM comments LEFT OUTER JOIN comments children ON ... WHERE children.label = 1
-    Comment.includes(:children).where("children.label": "child")
+    User.new.token # => "abc123...."
     ```
 
-    *Ryuta Kamizono*
-
-*   Support storing demodulized class name for polymorphic type.
-
-    Before Rails 6.1, storing demodulized class name is supported only for STI type
-    by `store_full_sti_class` class attribute.
+    *Sean Doyle*
 
-    Now `store_full_class_name` class attribute can handle both STI and polymorphic types.
+*   Fix incrementation of in memory counter caches when associations overlap
 
-    *Ryuta Kamizono*
+    When two associations had a similarly named counter cache column, Active Record
+    could sometime increment the wrong one.
 
-*   Deprecate `rails db:structure:{load, dump}` tasks and extend
-    `rails db:schema:{load, dump}` tasks to work with either `:ruby` or `:sql` format,
-    depending on `config.active_record.schema_format` configuration value.
+    *Jacopo Beschi*, *Jean Boussier*
 
-    *fatkodima*
+*   Don't show secrets for Active Record's `Cipher::Aes256Gcm#inspect`.
 
-*   Respect the `select` values for eager loading.
+    Before:
 
     ```ruby
-    post = Post.select("UPPER(title) AS title").first
-    post.title # => "WELCOME TO THE WEBLOG"
-    post.body  # => ActiveModel::MissingAttributeError
+    ActiveRecord::Encryption::Cipher::Aes256Gcm.new(secret).inspect
+    "#<ActiveRecord::Encryption::Cipher::Aes256Gcm:0x0000000104888038 ... @secret=\"\\xAF\\bFh]LV}q\\nl\\xB2U\\xB3 ... >"
+    ```
 
-    # Rails 6.0 (ignore the `select` values)
-    post = Post.select("UPPER(title) AS title").eager_load(:comments).first
-    post.title # => "Welcome to the weblog"
-    post.body  # => "Such a lovely day"
+    After:
 
-    # Rails 6.1 (respect the `select` values)
-    post = Post.select("UPPER(title) AS title").eager_load(:comments).first
-    post.title # => "WELCOME TO THE WEBLOG"
-    post.body  # => ActiveModel::MissingAttributeError
+    ```ruby
+    ActiveRecord::Encryption::Cipher::Aes256Gcm(secret).inspect
+    "#<ActiveRecord::Encryption::Cipher::Aes256Gcm:0x0000000104888038>"
     ```
 
-    *Ryuta Kamizono*
+    *Petrik de Heus*
 
-*   Allow attribute's default to be configured but keeping its own type.
+*   Bring back the historical behavior of committing transaction on non-local return.
 
     ```ruby
-    class Post < ActiveRecord::Base
-      attribute :written_at, default: -> { Time.now.utc }
+    Model.transaction do
+      model.save
+      return
+      other_model.save # not executed
     end
+    ```
 
-    # Rails 6.0
-    Post.type_for_attribute(:written_at) # => #<Type::Value ... precision: nil, ...>
+    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.
 
-    # Rails 6.1
-    Post.type_for_attribute(:written_at) # => #<Type::DateTime ... precision: 6, ...>
-    ```
+    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.
 
-    *Ryuta Kamizono*
+    Using `return`, `break` or `throw` inside a `transaction` block was essentially deprecated from Rails 6.1 onwards.
 
-*   Allow default to be configured for Enum.
+    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.
 
-    ```ruby
-    class Book < ActiveRecord::Base
-      enum status: [:proposed, :written, :published], _default: :published
-    end
+    This historical behavior can now be opt-ed in via:
 
-    Book.new.status # => "published"
+    ```
+    Rails.application.config.active_record.commit_transaction_on_non_local_return = true
     ```
 
-    *Ryuta Kamizono*
+    And is the default for new applications created in Rails 7.1.
 
-*   Deprecate YAML loading from legacy format older than Rails 5.0.
+    *Jean Boussier*
 
-    *Ryuta Kamizono*
+*   Deprecate `name` argument on `#remove_connection`.
 
-*   Added the setting `ActiveRecord::Base.immutable_strings_by_default`, which
-    allows you to specify that all string columns should be frozen unless
-    otherwise specified. This will reduce memory pressure for applications which
-    do not generally mutate string properties of Active Record objects.
+    The `name` argument is deprecated on `#remove_connection` without replacement. `#remove_connection` should be called directly on the class that established the connection.
 
-    *Sean Griffin*, *Ryuta Kamizono*
+    *Eileen M. Uchitelle*
 
-*   Deprecate `map!` and `collect!` on `ActiveRecord::Result`.
+*   Fix has_one through singular building with inverse.
 
-    *Ryuta Kamizono*
+    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.
 
-*   Support `relation.and` for intersection as Set theory.
+    *Gannon McGibbon*
 
-    ```ruby
-    david_and_mary = Author.where(id: [david, mary])
-    mary_and_bob   = Author.where(id: [mary, bob])
+*   Disable database prepared statements when query logs are enabled
 
-    david_and_mary.merge(mary_and_bob) # => [mary, bob]
+    Prepared Statements and Query Logs are incompatible features due to query logs making every query unique.
 
-    david_and_mary.and(mary_and_bob) # => [mary]
-    david_and_mary.or(mary_and_bob)  # => [david, mary, bob]
-    ```
+    *zzak, Jean Boussier*
 
-    *Ryuta Kamizono*
+*   Support decrypting data encrypted non-deterministically with a SHA1 hash digest.
 
-*   Merging conditions on the same column no longer maintain both conditions,
-    and will be consistently replaced by the latter condition in Rails 7.0.
-    To migrate to Rails 7.0's behavior, use `relation.merge(other, rewhere: true)`.
+    This adds a new Active Record encryption option to support decrypting data encrypted
+    non-deterministically with a SHA1 hash digest:
 
-    ```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.application.config.active_record.encryption.support_sha1_for_non_deterministic_encryption = true
+    ```
 
-    # Rails 6.1 (both conflict conditions exists, deprecated)
-    Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => []
+    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`.
 
-    # 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]
+    *Cadu Ribeiro and Jorge Manrubia*
 
-    # 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]
-    ```
+*   Added PostgreSQL migration commands for enum rename, add value, and rename value.
 
-    *Ryuta Kamizono*
+    `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
+    rename_enum :article_status, to: :article_state
+    ```
 
-*   Do not mark Postgresql MAC address and UUID attributes as changed when the assigned value only varies by case.
+    ```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"
+    ```
 
-    *Peter Fry*
+    ```ruby
+    rename_enum_value :article_state, from: "archived", to: "deleted"
+    ```
 
-*   Resolve issue with insert_all unique_by option when used with expression index.
+    *Ray Faddis*
 
-    When the `:unique_by` option of `ActiveRecord::Persistence.insert_all` and
-    `ActiveRecord::Persistence.upsert_all` was used with the name of an expression index, an error
-    was raised. Adding a guard around the formatting behavior for the `:unique_by` corrects this.
+*   Allow composite primary key to be derived from schema
 
-    Usage:
+    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.
 
+    Given a `travel_routes` table definition and a `TravelRoute` model like:
     ```ruby
-    create_table :books, id: :integer, force: true do |t|
-      t.column :name, :string
-      t.index "lower(name)", unique: true
+    create_table :travel_routes, primary_key: [:origin, :destination], force: true do |t|
+      t.string :origin
+      t.string :destination
     end
 
-    Book.insert_all [{ name: "MyTest" }], unique_by: :index_books_on_lower_name
+    class TravelRoute < ActiveRecord::Base; end
     ```
+    The `TravelRoute.primary_key` value will be automatically derived to `["origin", "destination"]`
 
-    Fixes #39516.
+    *Nikita Vasilevsky*
 
-    *Austen Madden*
+*   Include the `connection_pool` with exceptions raised from an adapter.
 
-*   Add basic support for CHECK constraints to database migrations.
+    The `connection_pool` provides added context such as the connection used
+    that led to the exception as well as which role and shard.
 
-    Usage:
+    *Luan Vieira*
+
+*   Support multiple column ordering for `find_each`, `find_in_batches` and `in_batches`.
+
+    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
-    add_check_constraint :products, "price > 0", name: "price_check"
-    remove_check_constraint :products, name: "price_check"
+    Person.find_each(order: [:desc, :asc]) do |person|
+      person.party_all_night!
+    end
     ```
 
-    *fatkodima*
+    *Takuya Kurimoto*
 
-*   Add `ActiveRecord::Base.strict_loading_by_default` and `ActiveRecord::Base.strict_loading_by_default=`
-    to enable/disable strict_loading mode by default for a model. The configuration's value is
-    inheritable by subclasses, but they can override that value and it will not impact parent class.
+*   Fix where on association with has_one/has_many polymorphic relations.
 
-    Usage:
+    Before:
+    ```ruby
+    Treasure.where(price_estimates: PriceEstimate.all)
+    #=> SELECT (...) WHERE "treasures"."id" IN (SELECT "price_estimates"."estimate_of_id" FROM "price_estimates")
+    ```
 
+    Later:
     ```ruby
-    class Developer < ApplicationRecord
-      self.strict_loading_by_default = true
+    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')
+    ```
 
-      has_many :projects
-    end
+    *Lázaro Nixon*
 
-    dev = Developer.first
-    dev.projects.first
-    # => ActiveRecord::StrictLoadingViolationError Exception: Developer is marked as strict_loading and Project cannot be lazily loaded.
-    ```
+*   Assign auto populated columns on Active Record record creation.
 
-    *bogdanvlviv*
+    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.
 
-*   Deprecate passing an Active Record object to `quote`/`type_cast` directly.
+    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.
 
-    *Ryuta Kamizono*
+    *Nikita Vasilevsky*
 
-*   Default engine `ENGINE=InnoDB` is no longer dumped to make schema more agnostic.
+*   Use the first key in the `shards` hash from `connected_to` for the `default_shard`.
 
-    Before:
+    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.
+
+    For example if your model looked like this:
 
     ```ruby
-    create_table "accounts", options: "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci", force: :cascade do |t|
-    end
+    class ShardRecord < ApplicationRecord
+      self.abstract_class = true
+
+      connects_to shards: {
+        shard_one: { writing: :shard_one },
+        shard_two: { writing: :shard_two }
+      }
     ```
 
-    After:
+    Then the `default_shard` for this class would be set to `shard_one`.
 
-    ```ruby
-    create_table "accounts", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
-    end
-    ```
+    Fixes: #45390
 
-    *Ryuta Kamizono*
+    *Eileen M. Uchitelle*
 
-*   Added delegated type as an alternative to single-table inheritance for representing class hierarchies.
-    See ActiveRecord::DelegatedType for the full description.
+*   Fix mutation detection for serialized attributes backed by binary columns.
 
-    *DHH*
+    *Jean Boussier*
 
-*   Deprecate aggregations with group by duplicated fields.
+*   Add `ActiveRecord.disconnect_all!` method to immediately close all connections from all pools.
 
-    To migrate to Rails 7.0's behavior, use `uniq!(:group)` to deduplicate group fields.
+    *Jean Boussier*
 
-    ```ruby
-    accounts = Account.group(:firm_id)
+*   Discard connections which may have been left in a transaction.
 
-    # duplicated group fields, deprecated.
-    accounts.merge(accounts.where.not(credit_limit: nil)).sum(:credit_limit)
-    # => {
-    #   [1, 1] => 50,
-    #   [2, 2] => 60
-    # }
+    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.
 
-    # use `uniq!(:group)` to deduplicate group fields.
-    accounts.merge(accounts.where.not(credit_limit: nil)).uniq!(:group).sum(:credit_limit)
-    # => {
-    #   1 => 50,
-    #   2 => 60
-    # }
-    ```
+    Previously, the following case was detected:
+    - An error is encountered during the transaction, then another error is encountered while attempting to roll it back.
 
-    *Ryuta Kamizono*
+    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.
 
-*   Deprecate duplicated query annotations.
+    *Nick Dower*
 
-    To migrate to Rails 7.0's behavior, use `uniq!(:annotate)` to deduplicate query annotations.
+*   Active Record query cache now evicts least recently used entries
 
-    ```ruby
-    accounts = Account.where(id: [1, 2]).annotate("david and mary")
+    By default it only keeps the `100` most recently used queries.
 
-    # duplicated annotations, deprecated.
-    accounts.merge(accounts.rewhere(id: 3))
-    # SELECT accounts.* FROM accounts WHERE accounts.id = 3 /* david and mary */ /* david and mary */
+    The cache size can be configured via `database.yml`
 
-    # use `uniq!(:annotate)` to deduplicate annotations.
-    accounts.merge(accounts.rewhere(id: 3)).uniq!(:annotate)
-    # SELECT accounts.* FROM accounts WHERE accounts.id = 3 /* david and mary */
+    ```yaml
+    development:
+      adapter: mysql2
+      query_cache: 200
     ```
 
-    *Ryuta Kamizono*
+    It can also be entirely disabled:
+
+    ```yaml
+    development:
+      adapter: mysql2
+      query_cache: false
+    ```
 
-*   Resolve conflict between counter cache and optimistic locking.
+    *Jean Boussier*
 
-    Bump an Active Record instance's lock version after updating its counter
-    cache. This avoids raising an unnecessary `ActiveRecord::StaleObjectError`
-    upon subsequent transactions by maintaining parity with the corresponding
-    database record's `lock_version` column.
+*   Deprecate `check_pending!` in favor of `check_all_pending!`.
 
-    Fixes #16449.
+    `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.
 
-    *Aaron Lipman*
+    *Eileen M. Uchitelle*
 
-*   Support merging option `:rewhere` to allow mergee side condition to be replaced exactly.
+*   Make `increment_counter`/`decrement_counter` accept an amount argument
 
     ```ruby
-    david_and_mary = Author.where(id: david.id..mary.id)
+    Post.increment_counter(:comments_count, 5, by: 3)
+    ```
 
-    # both conflict conditions exists
-    david_and_mary.merge(Author.where(id: bob)) # => []
+    *fatkodima*
 
-    # mergee side condition is replaced by rewhere
-    david_and_mary.merge(Author.rewhere(id: bob)) # => [bob]
+*   Add support for `Array#intersect?` to `ActiveRecord::Relation`.
 
-    # mergee side condition is replaced by rewhere option
-    david_and_mary.merge(Author.where(id: bob), rewhere: true) # => [bob]
-    ```
+    `Array#intersect?` is only available on Ruby 3.1 or later.
 
-    *Ryuta Kamizono*
+    This allows the Rubocop `Style/ArrayIntersect` cop to work with `ActiveRecord::Relation` objects.
 
-*   Add support for finding records based on signed ids, which are tamper-proof, verified ids that can be
-    set to expire and scoped with a purpose. This is particularly useful for things like password reset
-    or email verification, where you want the bearer of the signed id to be able to interact with the
-    underlying record, but usually only within a certain time period.
+    *John Harry Kelly*
 
-    ```ruby
-    signed_id = User.first.signed_id expires_in: 15.minutes, purpose: :password_reset
+*   The deferrable foreign key can be passed to `t.references`.
 
-    User.find_signed signed_id # => nil, since the purpose does not match
+    *Hiroyuki Ishii*
+
+*   Deprecate `deferrable: true` option of `add_foreign_key`.
+
+    `deferrable: true` is deprecated in favor of `deferrable: :immediate`, and
+    will be removed in Rails 7.2.
+
+    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.
+
+    *Hiroyuki Ishii*
+
+*   `AbstractAdapter#execute` and `#exec_query` now clear the query cache
+
+    If you need to perform a read only SQL query without clearing the query
+    cache, use `AbstractAdapter#select_all`.
 
-    travel 16.minutes
-    User.find_signed signed_id, purpose: :password_reset # => nil, since the signed id has expired
+    *Jean Boussier*
+
+*   Make `.joins` / `.left_outer_joins` work with CTEs.
 
-    travel_back
-    User.find_signed signed_id, purpose: :password_reset # => User.first
+    For example:
 
-    User.find_signed! "bad data" # => ActiveSupport::MessageVerifier::InvalidSignature
+    ```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
     ```
 
-    *DHH*
+    *Vladimir Dementyev*
 
-*   Support `ALGORITHM = INSTANT` DDL option for index operations on MySQL.
+*   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.
 
-    *Ryuta Kamizono*
+    *fatkodima*
 
-*   Fix index creation to preserve index comment in bulk change table on MySQL.
+*   Introduce adapter for Trilogy database client
 
-    *Ryuta Kamizono*
+    Trilogy is a MySQL-compatible database client. Rails applications can use Trilogy
+    by configuring their `config/database.yml`:
 
-*   Allow `unscope` to be aware of table name qualified values.
+    ```yaml
+    development:
+    adapter: trilogy
+    database: blog_development
+    pool: 5
+    ```
 
-    It is possible to unscope only the column in the specified table.
+    Or by using the `DATABASE_URL` environment variable:
 
     ```ruby
-    posts = Post.joins(:comments).group(:"posts.hidden")
-    posts = posts.where("posts.hidden": false, "comments.hidden": false)
+    ENV['DATABASE_URL'] # => "trilogy://localhost/blog_development?pool=5"
+    ```
+
+    *Adrianna Chang*
 
-    posts.count
-    # => { false => 10 }
+*   `after_commit` callbacks defined on models now execute in the correct order.
+
+    ```ruby
+    class User < ActiveRecord::Base
+      after_commit { puts("this gets called first") }
+      after_commit { puts("this gets called second") }
+    end
+    ```
 
-    # unscope both hidden columns
-    posts.unscope(where: :hidden).count
-    # => { false => 11, true => 1 }
+    Previously, the callbacks executed in the reverse order. To opt in to the new behaviour:
 
-    # unscope only comments.hidden column
-    posts.unscope(where: :"comments.hidden").count
-    # => { false => 11 }
+    ```ruby
+    config.active_record.run_after_transaction_callbacks_in_order_defined = true
     ```
 
-    *Ryuta Kamizono*, *Slava Korolev*
+    This is the default for new apps.
+
+    *Alex Ghiculescu*
 
-*   Fix `rewhere` to truly overwrite collided where clause by new where clause.
+*   Infer `foreign_key` when `inverse_of` is present on `has_one` and `has_many` associations.
 
     ```ruby
-    steve = Person.find_by(name: "Steve")
-    david = Author.find_by(name: "David")
+    has_many :citations, foreign_key: "book1_id", inverse_of: :book
+    ```
 
-    relation = Essay.where(writer: steve)
+    can be simplified to
 
-    # Before
-    relation.rewhere(writer: david).to_a # => []
+    ```ruby
+    has_many :citations, inverse_of: :book
+    ```
 
-    # After
-    relation.rewhere(writer: david).to_a # => [david]
+    and the foreign_key will be read from the corresponding `belongs_to` association.
+
+    *Daniel Whitney*
+
+*   Limit max length of auto generated index names
+
+    Auto generated index names are now limited to 62 bytes, which fits within
+    the default index name length limits for MySQL, Postgres and SQLite.
+
+    Any index name over the limit will fallback to the new short format.
+
+    Before (too long):
+    ```
+    index_testings_on_foo_and_bar_and_first_name_and_last_name_and_administrator
     ```
 
-    *Ryuta Kamizono*
+    After (short format):
+    ```
+    idx_on_foo_bar_first_name_last_name_administrator_5939248142
+    ```
+
+    The short format includes a hash to ensure the name is unique database-wide.
+
+    *Mike Coutermarsh*
+
+*   Introduce a more stable and optimized Marshal serializer for Active Record models.
+
+    Can be enabled with `config.active_record.marshalling_format_version = 7.1`.
+
+    *Jean Boussier*
+
+*   Allow specifying where clauses with column-tuple syntax.
 
-*   Inspect time attributes with subsec and time zone offset.
+    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
-    p Knot.create
-    => #<Knot id: 1, created_at: "2016-05-05 01:29:47.116928000 +0000">
+    # Cpk::Book => Cpk::Book(author_id: integer, number: integer, title: string, revision: integer)
+    # Cpk::Book.primary_key => ["author_id", "number"]
+
+    book = Cpk::Book.create!(author_id: 1, number: 1)
+    Cpk::Book.where(Cpk::Book.primary_key => [[1, 2]]) # => [book]
+
+    # Topic => Topic(id: integer, title: string, author_name: string...)
+
+    Topic.where([:title, :author_name] => [["The Alchemist", "Paulo Coelho"], ["Harry Potter", "J.K Rowling"]])
     ```
 
-    *akinomaeni*, *Jonathan Hefner*
+    *Paarth Madan*
 
-*   Deprecate passing a column to `type_cast`.
+*   Allow warning codes to be ignore when reporting SQL warnings.
 
-    *Ryuta Kamizono*
+    Active Record config that can ignore warning codes
 
-*   Deprecate `in_clause_length` and `allowed_index_name_length` in `DatabaseLimits`.
+    ```ruby
+    # Configure allowlist of warnings that should always be ignored
+    config.active_record.db_warnings_ignore = [
+      "1062", # MySQL Error 1062: Duplicate entry
+    ]
+    ```
 
-    *Ryuta Kamizono*
+    This is supported for the MySQL and PostgreSQL adapters.
 
-*   Support bulk insert/upsert on relation to preserve scope values.
+    *Nick Borromeo*
 
-    *Josef Šimánek*, *Ryuta Kamizono*
+*   Introduce `:active_record_fixtures` lazy load hook.
 
-*   Preserve column comment value on changing column name on MySQL.
+    Hooks defined with this name will be run whenever `TestFixtures` is included
+    in a class.
 
-    *Islam Taha*
+    ```ruby
+    ActiveSupport.on_load(:active_record_fixtures) do
+      self.fixture_paths << "test/fixtures"
+    end
 
-*   Add support for `if_exists` option for removing an index.
+    klass = Class.new
+    klass.include(ActiveRecord::TestFixtures)
 
-    The `remove_index` method can take an `if_exists` option. If this is set to true an error won't be raised if the index doesn't exist.
+    klass.fixture_paths # => ["test/fixtures"]
+    ```
 
-    *Eileen M. Uchitelle*
+    *Andrew Novoselac*
 
-*   Remove ibm_db, informix, mssql, oracle, and oracle12 Arel visitors which are not used in the code base.
+*   Introduce `TestFixtures#fixture_paths`.
 
-    *Ryuta Kamizono*
+    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.
 
-*   Prevent `build_association` from `touching` a parent record if the record isn't persisted for `has_one` associations.
+    ```ruby
+    ActiveSupport::TestCase.fixture_paths << "component1/test/fixtures"
+    ActiveSupport::TestCase.fixture_paths << "component2/test/fixtures"
+    ```
 
-    Fixes #38219.
+    `TestFixtures#fixture_path` is now deprecated.
 
-    *Josh Brody*
+    *Andrew Novoselac*
 
-*   Add support for `if_not_exists` option for adding index.
+*   Adds support for deferrable exclude constraints in PostgreSQL.
 
-    The `add_index` method respects `if_not_exists` option. If it is set to true
-    index won't be added.
+    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.
 
-    Usage:
+    ```ruby
+    exclusion_constraint :users, "daterange(valid_from, valid_to) WITH &&", deferrable: :immediate
+    ```
+
+    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):
 
     ```ruby
-      add_index :users, :account_id, if_not_exists: true
+    exclusion_constraint :users, "daterange(valid_from, valid_to) WITH &&", deferrable: :deferred
     ```
 
-    The `if_not_exists` option passed to `create_table` also gets propagated to indexes
-    created within that migration so that if table and its indexes exist then there is no
-    attempt to create them again.
+    *Hiroyuki Ishii*
+
+*   Respect `foreign_type` option to `delegated_type` for `{role}_class` method.
 
-    *Prathamesh Sonpatki*
+    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.
 
-*   Add `ActiveRecord::Base#previously_new_record?` to show if a record was new before the last save.
+    *Jason Karns*
 
-    *Tom Ward*
+*   Add support for unique constraints (PostgreSQL-only).
 
-*   Support descending order for `find_each`, `find_in_batches`, and `in_batches`.
+    ```ruby
+    add_unique_key :sections, [:position], deferrable: :deferred, name: "unique_section_position"
+    remove_unique_key :sections, name: "unique_section_position"
+    ```
 
-    Batch processing methods allow you to work with the records in batches, greatly reducing memory consumption, but records are always batched from oldest id to newest.
+    See PostgreSQL's [Unique Constraints](https://www.postgresql.org/docs/current/ddl-constraints.html#DDL-CONSTRAINTS-UNIQUE-CONSTRAINTS) documentation for more on unique constraints.
 
-    This change allows reversing the order, batching from newest to oldest. This is useful when you need to process newer batches of records first.
+    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.
 
-    Pass `order: :desc` to yield batches in descending order. The default remains `order: :asc`.
+    An example of swapping unique columns between records.
 
     ```ruby
-    Person.find_each(order: :desc) do |person|
-      person.party_all_night!
+    # position is unique column
+    old_item = Item.create!(position: 1)
+    new_item = Item.create!(position: 2)
+
+    Item.transaction do
+      old_item.update!(position: 2)
+      new_item.update!(position: 1)
     end
     ```
 
-    *Alexey Vasiliev*
+    Using the default behavior, the transaction would fail when executing the
+    first `UPDATE` statement.
 
-*   Fix `insert_all` with enum values.
+    By passing the `:deferrable` option to the `add_unique_key` statement in
+    migrations, it's possible to defer this check.
 
-    Fixes #38716.
-
-    *Joel Blum*
+    ```ruby
+    add_unique_key :items, [:position], deferrable: :immediate
+    ```
 
-*   Add support for `db:rollback:name` for multiple database applications.
+    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.
 
-    Multiple database applications will now raise if `db:rollback` is call and recommend using the `db:rollback:[NAME]` to rollback migrations.
+    It's also possible to adjust the default behavior from an immediate
+    check (after the statement), to a deferred check (after the transaction):
 
-    *Eileen M. Uchitelle*
+    ```ruby
+    add_unique_key :items, [:position], deferrable: :deferred
+    ```
 
-*   `Relation#pick` now uses already loaded results instead of making another query.
+    If you want to change an existing unique index to deferrable, you can use :using_index
+    to create deferrable unique constraints.
 
-    *Eugene Kenny*
+    ```ruby
+    add_unique_key :items, deferrable: :deferred, using_index: "index_items_on_position"
+    ```
 
-*   Deprecate using `return`, `break` or `throw` to exit a transaction block after writes.
+    *Hiroyuki Ishii*
 
-    *Dylan Thacker-Smith*
+*   Remove deprecated `Tasks::DatabaseTasks.schema_file_type`.
 
-*   Dump the schema or structure of a database when calling `db:migrate:name`.
+    *Rafael Mendonça França*
 
-    In previous versions of Rails, `rails db:migrate` would dump the schema of the database. In Rails 6, that holds true (`rails db:migrate` dumps all databases' schemas), but `rails db:migrate:name` does not share that behavior.
+*   Remove deprecated `config.active_record.partial_writes`.
 
-    Going forward, calls to `rails db:migrate:name` will dump the schema (or structure) of the database being migrated.
+    *Rafael Mendonça França*
 
-    *Kyle Thompson*
+*   Remove deprecated `ActiveRecord::Base` config accessors.
 
-*   Reset the `ActiveRecord::Base` connection after `rails db:migrate:name`.
+    *Rafael Mendonça França*
 
-    When `rails db:migrate` has finished, it ensures the `ActiveRecord::Base` connection is reset to its original configuration. Going forward, `rails db:migrate:name` will have the same behavior.
+*   Remove the `:include_replicas` argument from `configs_for`. Use `:include_hidden` argument instead.
 
-    *Kyle Thompson*
+    *Eileen M. Uchitelle*
 
-*   Disallow calling `connected_to` on subclasses of `ActiveRecord::Base`.
+*   Allow applications to lookup a config via a custom hash key.
 
-    Behavior has not changed here but the previous API could be misleading to people who thought it would switch connections for only that class. `connected_to` switches the context from which we are getting connections, not the connections themselves.
+    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.
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    ```ruby
+    ActiveRecord::Base.configurations.configs_for(env_name: "development", name: "primary", config_key: :vitess)
+    ActiveRecord::Base.configurations.configs_for(env_name: "development", config_key: :vitess)
+    ```
 
-*   Add support for horizontal sharding to `connects_to` and `connected_to`.
+    *Eileen M. Uchitelle*
 
-    Applications can now connect to multiple shards and switch between their shards in an application. Note that the shard swapping is still a manual process as this change does not include an API for automatic shard swapping.
+*   Allow applications to register a custom database configuration handler.
 
-    Usage:
+    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`.
 
-    Given the following configuration:
+    Given the following database YAML we want the `animals` db to create a `CustomConfig` object instead while the `primary` database will be a `UrlConfig`:
 
     ```yaml
-    # config/database.yml
-    production:
+    development:
       primary:
-        database: my_database
-      primary_shard_one:
-        database: my_database_shard_one
+        url: postgres://localhost/primary
+      animals:
+        url: postgres://localhost/animals
+        custom_config:
+          sharded: 1
     ```
 
-    Connect to multiple shards:
+    To register a custom handler first make a class that has your custom methods:
 
     ```ruby
-    class ApplicationRecord < ActiveRecord::Base
-      self.abstract_class = true
+    class CustomConfig < ActiveRecord::DatabaseConfigurations::UrlConfig
+      def sharded?
+        custom_config.fetch("sharded", false)
+      end
 
-      connects_to shards: {
-        default: { writing: :primary },
-        shard_one: { writing: :primary_shard_one }
-      }
+      private
+        def custom_config
+          configuration_hash.fetch(:custom_config)
+        end
+    end
     ```
 
-    Swap between shards in your controller / model code:
+    Then register the config in an initializer:
 
     ```ruby
-    ActiveRecord::Base.connected_to(shard: :shard_one) do
-      # Read from shard one
+    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
     ```
 
-    The horizontal sharding API also supports read replicas. See guides for more details.
+    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*
+
+*   `ActiveRecord::Base.serialize` no longer uses YAML by default.
+
+    YAML isn't particularly performant and can lead to security issues
+    if not used carefully.
+
+    Unfortunately there isn't really any good serializers in Ruby's stdlib
+    to replace it.
+
+    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.
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    Some third party JSON libraries like `Oj` have a suitable strict mode.
 
-*   Deprecate `spec_name` in favor of `name` on database configurations.
+    So it's preferable that users choose a serializer based on their own constraints.
 
-    The accessors for `spec_name` on `configs_for` and `DatabaseConfig` are deprecated. Please use `name` instead.
+    The original default can be restored by setting `config.active_record.default_column_serializer = YAML`.
 
-    Deprecated behavior:
+    *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
-    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "development", spec_name: "primary")
-    db_config.spec_name
+    serialize :content, JSON
+    serialize :backtrace, Array
     ```
 
-    New behavior:
+    After:
 
     ```ruby
-    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "development", name: "primary")
-    db_config.name
+    serialize :content, coder: JSON
+    serialize :backtrace, type: Array
     ```
 
-    *Eileen M. Uchitelle*
+    *Jean Boussier*
 
-*   Add additional database-specific rake tasks for multi-database users.
+*   YAML columns use `YAML.safe_dump` if available.
 
-    Previously, `rails db:create`, `rails db:drop`, and `rails db:migrate` were the only rails tasks that could operate on a single
-    database. For example:
+    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
     ```
-    rails db:create
-    rails db:create:primary
-    rails db:create:animals
-    rails db:drop
-    rails db:drop:primary
-    rails db:drop:animals
-    rails db:migrate
-    rails db:migrate:primary
-    rails db:migrate:animals
+    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
     ```
 
-    With these changes, `rails db:schema:dump`, `rails db:schema:load`, `rails db:structure:dump`, `rails db:structure:load` and
-    `rails db:test:prepare` can additionally operate on a single database. For example:
+    *Spencer Neste*
 
-    ```
-    rails db:schema:dump
-    rails db:schema:dump:primary
-    rails db:schema:dump:animals
-    rails db:schema:load
-    rails db:schema:load:primary
-    rails db:schema:load:animals
-    rails db:structure:dump
-    rails db:structure:dump:primary
-    rails db:structure:dump:animals
-    rails db:structure:load
-    rails db:structure:load:primary
-    rails db:structure:load:animals
-    rails db:test:prepare
-    rails db:test:prepare:primary
-    rails db:test:prepare:animals
+*   `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
+    Customer.where(id: 1).joins(:orders).explain(:analyze, :verbose)
     ```
 
-    *Kyle Thompson*
+    *Reid Lynch*
 
-*   Add support for `strict_loading` mode on association declarations.
+*   Multiple `Arel::Nodes::SqlLiteral` nodes can now be added together to
+    form `Arel::Nodes::Fragments` nodes. This allows joining several pieces
+    of SQL.
 
-    Raise an error if attempting to load a record from an association that has been marked as `strict_loading` unless it was explicitly eager loaded.
+    *Matthew Draper*, *Ole Friis*
 
-    Usage:
+*   `ActiveRecord::Base#signed_id` raises if called on a new record.
 
-    ```ruby
-    class Developer < ApplicationRecord
-      has_many :projects, strict_loading: true
-    end
+    Previously it would return an ID that was not usable, since it was based on `id = nil`.
+
+    *Alex Ghiculescu*
 
-    dev = Developer.first
-    dev.projects.first
-    # => ActiveRecord::StrictLoadingViolationError: The projects association is marked as strict_loading and cannot be lazily loaded.
+*   Allow SQL warnings to be reported.
+
+    Active Record configs can be set to enable SQL warning reporting.
+
+    ```ruby
+    # 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",
+    ]
     ```
 
-    *Kevin Deisz*
+    This is supported for the MySQL and PostgreSQL adapters.
 
-*   Add support for `strict_loading` mode to prevent lazy loading of records.
+    *Adrianna Chang*, *Paarth Madan*
 
-    Raise an error if a parent record is marked as `strict_loading` and attempts to lazily load its associations. This is useful for finding places you may want to preload an association and avoid additional queries.
+*   Add `#regroup` query method as a short-hand for `.unscope(:group).group(fields)`
 
-    Usage:
+    Example:
 
     ```ruby
-    dev = Developer.strict_loading.first
-    dev.audit_logs.to_a
-    # => ActiveRecord::StrictLoadingViolationError: Developer is marked as strict_loading and AuditLog cannot be lazily loaded.
+    Post.group(:title).regroup(:author)
+    # SELECT `posts`.`*` FROM `posts` GROUP BY `posts`.`author`
     ```
 
-    *Eileen M. Uchitelle*, *Aaron Patterson*
+    *Danielius Visockas*
 
-*   Add support for PostgreSQL 11+ partitioned indexes when using `upsert_all`.
+*   PostgreSQL adapter method `enable_extension` now allows parameter to be `[schema_name.]<extension_name>`
+    if the extension must be installed on another schema.
 
-    *Sebastián Palma*
+    Example: `enable_extension('heroku_ext.hstore')`
 
-*   Adds support for `if_not_exists` to `add_column` and `if_exists` to `remove_column`.
+    *Leonardo Luarte*
 
-    Applications can set their migrations to ignore exceptions raised when adding a column that already exists or when removing a column that does not exist.
+*   Add `:include` option to `add_index`.
 
-    Example Usage:
+    Add support for including non-key columns in indexes for PostgreSQL
+    with the `INCLUDE` parameter.
 
     ```ruby
-    class AddColumnTitle < ActiveRecord::Migration[6.1]
-      def change
-        add_column :posts, :title, :string, if_not_exists: true
-      end
-    end
+    add_index(:users, :email, include: [:id, :created_at])
     ```
 
-    ```ruby
-    class RemoveColumnTitle < ActiveRecord::Migration[6.1]
-      def change
-        remove_column :posts, :title, if_exists: true
-      end
-    end
+    will result in:
+
+    ```sql
+    CREATE INDEX index_users_on_email USING btree (email) INCLUDE (id, created_at)
     ```
 
-    *Eileen M. Uchitelle*
+    *Steve Abrams*
 
-*   Regexp-escape table name for MS SQL Server.
+*   `ActiveRecord::Relation`’s `#any?`, `#none?`, and `#one?` methods take an optional pattern
+    argument, more closely matching their `Enumerable` equivalents.
 
-    Add `Regexp.escape` to one method in ActiveRecord, so that table names with regular expression characters in them work as expected. Since MS SQL Server uses "[" and "]" to quote table and column names, and those characters are regular expression characters, methods like `pluck` and `select` fail in certain cases when used with the MS SQL Server adapter.
+    *George Claghorn*
 
-    *Larry Reid*
+*   Add `ActiveRecord::Base.normalizes` for declaring attribute normalizations.
 
-*   Store advisory locks on their own named connection.
+    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.
 
-    Previously advisory locks were taken out against a connection when a migration started. This works fine in single database applications but doesn't work well when migrations need to open new connections which results in the lock getting dropped.
+    For example:
 
-    In order to fix this we are storing the advisory lock on a new connection with the connection specification name `AdvisoryLockBase`. The caveat is that we need to maintain at least 2 connections to a database while migrations are running in order to do this.
+      ```ruby
+      class User < ActiveRecord::Base
+        normalizes :email, with: -> email { email.strip.downcase }
+        normalizes :phone, with: -> phone { phone.delete("^0-9").delete_prefix("1") }
+      end
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+      user = User.create(email: " CRUISE-CONTROL@EXAMPLE.COM\n")
+      user.email                  # => "cruise-control@example.com"
 
-*   Allow schema cache path to be defined in the database configuration file.
+      user = User.find_by(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")
+      user.email                  # => "cruise-control@example.com"
+      user.email_before_type_cast # => "cruise-control@example.com"
 
-    For example:
+      User.where(email: "\tCRUISE-CONTROL@EXAMPLE.COM ").count         # => 1
+      User.where(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]).count # => 0
 
-    ```yaml
-    development:
-      adapter: postgresql
-      database: blog_development
-      pool: 5
-      schema_cache_path: tmp/schema/main.yml
-    ```
+      User.exists?(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")         # => true
+      User.exists?(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]) # => false
 
-    *Katrina Owen*
+      User.normalize_value_for(:phone, "+1 (555) 867-5309") # => "5558675309"
+      ```
 
-*   Deprecate `#remove_connection` in favor of `#remove_connection_pool` when called on the handler.
+    *Jonathan Hefner*
 
-    `#remove_connection` is deprecated in order to support returning a `DatabaseConfig` object instead of a `Hash`. Use `#remove_connection_pool`, `#remove_connection` will be removed in Rails 7.0.
+*   Hide changes to before_committed! callback behaviour behind flag.
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    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.
 
-*   Deprecate `#default_hash` and it's alias `#[]` on database configurations.
+    *Adrianna Chang*
 
-    Applications should use `configs_for`. `#default_hash` and `#[]` will be removed in Rails 7.0.
+*   The `namespaced_controller` Query Log tag now matches the `controller` format
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    For example, a request processed by `NameSpaced::UsersController` will now log as:
 
-*   Add scale support to `ActiveRecord::Validations::NumericalityValidator`.
+    ```
+    :controller # "users"
+    :namespaced_controller # "name_spaced/users"
+    ```
 
-    *Gannon McGibbon*
+    *Alex Ghiculescu*
 
-*   Find orphans by looking for missing relations through chaining `where.missing`:
+*   Return only unique ids from ActiveRecord::Calculations#ids
 
-    Before:
+    Updated ActiveRecord::Calculations#ids to only return the unique ids of the base model
+    when using eager_load, preload and includes.
 
     ```ruby
-    Post.left_joins(:author).where(authors: { id: nil })
+    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]
     ```
 
-    After:
+    *Joshua Young*
 
-    ```ruby
-    Post.where.missing(:author)
-    ```
+*   Stop using `LOWER()` for case-insensitive queries on `citext` columns
 
-    *Tom Rossi*
+    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.
 
-*   Ensure `:reading` connections always raise if a write is attempted.
+    *Phil Pirozhkov*
 
-    Now Rails will raise an `ActiveRecord::ReadOnlyError` if any connection on the reading handler attempts to make a write. If your reading role needs to write you should name the role something other than `:reading`.
+*   Extract `#sync_timezone_changes` method in AbstractMysqlAdapter to enable subclasses
+    to sync database timezone changes without overriding `#raw_execute`.
 
-    *Eileen M. Uchitelle*
+    *Adrianna Chang*, *Paarth Madan*
 
-*   Deprecate `"primary"` as the `connection_specification_name` for `ActiveRecord::Base`.
+*   Do not write additional new lines when dumping sql migration versions
 
-    `"primary"` has been deprecated as the `connection_specification_name` for `ActiveRecord::Base` in favor of using `"ActiveRecord::Base"`. This change affects calls to `ActiveRecord::Base.connection_handler.retrieve_connection` and `ActiveRecord::Base.connection_handler.remove_connection`. If you're calling these methods with `"primary"`, please switch to `"ActiveRecord::Base"`.
+    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.
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    *Misha Schwartz*
 
-*   Add `ActiveRecord::Validations::NumericalityValidator` with
-    support for casting floats using a database columns' precision value.
+*   Fix `composed_of` value freezing and duplication.
 
-    *Gannon McGibbon*
+    Previously composite values exhibited two confusing behaviors:
 
-*   Enforce fresh ETag header after a collection's contents change by adding
-    ActiveRecord::Relation#cache_key_with_version. This method will be used by
-    ActionController::ConditionalGet to ensure that when collection cache versioning
-    is enabled, requests using ConditionalGet don't return the same ETag header
-    after a collection is modified.
+    - 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.
 
-    Fixes #38078.
+    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).
 
-    *Aaron Lipman*
+    *Greg Navis*
 
-*   Skip test database when running `db:create` or `db:drop` in development
-    with `DATABASE_URL` set.
+*   Fix redundant updates to the column insensitivity cache
 
-    *Brian Buchalter*
+    Fixed redundant queries checking column capability for insensitive
+    comparison.
 
-*   Don't allow mutations on the database configurations hash.
+    *Phil Pirozhkov*
 
-    Freeze the configurations hash to disallow directly changing it. If applications need to change the hash, for example to create databases for parallelization, they should use the `DatabaseConfig` object directly.
+*   Allow disabling methods generated by `ActiveRecord.enum`.
 
-    Before:
+    *Alfred Dominic*
 
-    ```ruby
-    @db_config = ActiveRecord::Base.configurations.configs_for(env_name: "test", spec_name: "primary")
-    @db_config.configuration_hash.merge!(idle_timeout: "0.02")
-    ```
+*   Avoid validating `belongs_to` association if it has not changed.
 
-    After:
+    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
-    @db_config = ActiveRecord::Base.configurations.configs_for(env_name: "test", spec_name: "primary")
-    config = @db_config.configuration_hash.merge(idle_timeout: "0.02")
-    db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new(@db_config.env_name, @db_config.spec_name, config)
+    config.active_record.belongs_to_required_validates_foreign_key = false
     ```
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    and will be disabled by default with `config.load_defaults 7.1`.
+
+    *fatkodima*
 
-*   Remove `:connection_id` from the `sql.active_record` notification.
+*   `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.
 
-    *Aaron Patterson*, *Rafael Mendonça França*
+    *George Claghorn*
 
-*   The `:name` key will no longer be returned as part of `DatabaseConfig#configuration_hash`. Please use `DatabaseConfig#owner_name` instead.
+*   Allow per attribute setting of YAML permitted classes (safe load) and unsafe load.
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    *Carlos Palhares*
 
-*   ActiveRecord's `belongs_to_required_by_default` flag can now be set per model.
+*   Add a build persistence method
 
-    You can now opt-out/opt-in specific models from having their associations required
-    by default.
+    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.
 
-    This change is meant to ease the process of migrating all your models to have
-    their association required.
+    *Sean Denny*
 
-    *Edouard Chin*
+*   Raise on assignment to readonly attributes
 
-*   The `connection_config` method has been deprecated, please use `connection_db_config` instead which will return a `DatabaseConfigurations::DatabaseConfig` instead of a `Hash`.
+    ```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
+    ```
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    Previously, assignment would succeed but silently not write to the database.
 
-*   Retain explicit selections on the base model after applying `includes` and `joins`.
+    This behavior can be controlled by configuration:
 
-    Resolves #34889.
+    ```ruby
+    config.active_record.raise_on_assign_to_attr_readonly = true
+    ```
 
-    *Patrick Rebsch*
+    and will be enabled by default with `config.load_defaults 7.1`.
 
-*   The `database` kwarg is deprecated without replacement because it can't be used for sharding and creates an issue if it's used during a request. Applications that need to create new connections should use `connects_to` instead.
+    *Alex Ghiculescu*, *Hartley McGuire*
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+*   Allow unscoping of preload and eager_load associations
 
-*   Allow attributes to be fetched from Arel node groupings.
+    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.
 
-    *Jeff Emminger*, *Gannon McGibbon*
+    ```ruby
+    query.unscope(:eager_load, :preload).group(:id).select(:id)
+    ```
 
-*   A database URL can now contain a querystring value that contains an equal sign. This is needed to support passing PostgreSQL `options`.
+    *David Morehouse*
 
-    *Joshua Flanagan*
+*   Add automatic filtering of encrypted attributes on inspect
 
-*   Calling methods like `establish_connection` with a `Hash` which is invalid (eg: no `adapter`) will now raise an error the same way as connections defined in `config/database.yml`.
+    This feature is enabled by default but can be disabled with
 
-    *John Crepezzi*
+    ```ruby
+    config.active_record.encryption.add_to_filter_parameters = false
+    ```
 
-*   Specifying `implicit_order_column` now subsorts the records by primary key if available to ensure deterministic results.
+    *Hartley McGuire*
 
-    *Paweł Urbanek*
+*   Clear locking column on #dup
 
-*   `where(attr => [])` now loads an empty result without making a query.
+    This change fixes not to duplicate locking_column like id and timestamps.
 
-    *John Hawthorn*
+    ```
+    car = Car.create!
+    car.touch
+    car.lock_version #=> 1
+    car.dup.lock_version #=> 0
+    ```
 
-*   Fixed the performance regression for `primary_keys` introduced MySQL 8.0.
+    *Shouichi Kamiya*, *Seonggi Yang*, *Ryohei UEDA*
 
-    *Hiroyuki Ishii*
+*   Invalidate transaction as early as possible
 
-*   Add support for `belongs_to` to `has_many` inversing.
+    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.
 
-    *Gannon McGibbon*
+    *Nikita Vasilevsky*
 
-*   Allow length configuration for `has_secure_token` method. The minimum length
-    is set at 24 characters.
+*   Allow configuring columns list to be used in SQL queries issued by an `ActiveRecord::Base` object
 
-    Before:
+    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
-    has_secure_token :auth_token
+    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
     ```
 
-    After:
+    *Nikita Vasilevsky*
 
-    ```ruby
-    has_secure_token :default_token             # 24 characters
-    has_secure_token :auth_token, length: 36    # 36 characters
-    has_secure_token :invalid_token, length: 12 # => ActiveRecord::SecureToken::MinimumLengthError
-    ```
+*   Adds `validate` to foreign keys and check constraints in schema.rb
 
-    *Bernardo de Araujo*
+    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.
 
-*   Deprecate `DatabaseConfigurations#to_h`. These connection hashes are still available via `ActiveRecord::Base.configurations.configs_for`.
+    *Tommy Graves*
 
-    *Eileen Uchitelle*, *John Crepezzi*
+*   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.
 
-*   Add `DatabaseConfig#configuration_hash` to return database configuration hashes with symbol keys, and use all symbol-key configuration hashes internally. Deprecate `DatabaseConfig#config` which returns a String-keyed `Hash` with the same values.
+    *Adrianna Chang*
 
-    *John Crepezzi*, *Eileen Uchitelle*
+*   Only trigger `after_commit :destroy` callbacks when a database row is deleted.
 
-*   Allow column names to be passed to `remove_index` positionally along with other options.
+    This prevents `after_commit :destroy` callbacks from being triggered again
+    when `destroy` is called multiple times on the same record.
 
-    Passing other options can be necessary to make `remove_index` correctly reversible.
+    *Ben Sheldon*
 
-    Before:
+*   Fix `ciphertext_for` for yet-to-be-encrypted values.
 
-        add_index    :reports, :report_id               # => works
-        add_index    :reports, :report_id, unique: true # => works
-        remove_index :reports, :report_id               # => works
-        remove_index :reports, :report_id, unique: true # => ArgumentError
+    Previously, `ciphertext_for` returned the cleartext of values that had not
+    yet been encrypted, such as with an unpersisted record:
 
-    After:
+      ```ruby
+      Post.encrypts :body
 
-        remove_index :reports, :report_id, unique: true # => works
+      post = Post.create!(body: "Hello")
+      post.ciphertext_for(:body)
+      # => "{\"p\":\"abc..."
 
-    *Eugene Kenny*
+      post.body = "World"
+      post.ciphertext_for(:body)
+      # => "World"
+      ```
 
-*   Allow bulk `ALTER` statements to drop and recreate indexes with the same name.
+    Now, `ciphertext_for` will always return the ciphertext of encrypted
+    attributes:
 
-    *Eugene Kenny*
+      ```ruby
+      Post.encrypts :body
 
-*   `insert`, `insert_all`, `upsert`, and `upsert_all` now clear the query cache.
+      post = Post.create!(body: "Hello")
+      post.ciphertext_for(:body)
+      # => "{\"p\":\"abc..."
 
-    *Eugene Kenny*
+      post.body = "World"
+      post.ciphertext_for(:body)
+      # => "{\"p\":\"xyz..."
+      ```
 
-*   Call `while_preventing_writes` directly from `connected_to`.
+    *Jonathan Hefner*
 
-    In some cases application authors want to use the database switching middleware and make explicit calls with `connected_to`. It's possible for an app to turn off writes and not turn them back on by the time we call `connected_to(role: :writing)`.
+*   Fix a bug where using groups and counts with long table names would return incorrect results.
 
-    This change allows apps to fix this by assuming if a role is writing we want to allow writes, except in the case it's explicitly turned off.
+    *Shota Toguchi*, *Yusaku Ono*
 
-    *Eileen M. Uchitelle*
+*   Fix encryption of column default values.
 
-*   Improve detection of ActiveRecord::StatementTimeout with mysql2 adapter in the edge case when the query is terminated during filesort.
+    Previously, encrypted attributes that used column default values appeared to
+    be encrypted on create, but were not:
 
-    *Kir Shatrov*
+      ```ruby
+      Book.encrypts :name
 
-*   Stop trying to read yaml file fixtures when loading Active Record fixtures.
+      book = Book.create!
+      book.name
+      # => "<untitled>"
+      book.name_before_type_cast
+      # => "{\"p\":\"abc..."
+      book.reload.name_before_type_cast
+      # => "<untitled>"
+      ```
 
-    *Gannon McGibbon*
+    Now, attributes with column default values are encrypted:
 
-*   Deprecate `.reorder(nil)` with `.first` / `.first!` taking non-deterministic result.
+      ```ruby
+      Book.encrypts :name
 
-    To continue taking non-deterministic result, use `.take` / `.take!` instead.
+      book = Book.create!
+      book.name
+      # => "<untitled>"
+      book.name_before_type_cast
+      # => "{\"p\":\"abc..."
+      book.reload.name_before_type_cast
+      # => "{\"p\":\"abc..."
+      ```
 
-    *Ryuta Kamizono*
+    *Jonathan Hefner*
 
-*   Preserve user supplied joins order as much as possible.
+*   Deprecate delegation from `Base` to `connection_handler`.
 
-    Fixes #36761, #34328, #24281, #12953.
+    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.
 
-    *Ryuta Kamizono*
+    *Eileen M. Uchitelle*
 
-*   Allow `matches_regex` and `does_not_match_regexp` on the MySQL Arel visitor.
+*   Allow ActiveRecord::QueryMethods#reselect to receive hash values, similar to ActiveRecord::QueryMethods#select
 
-    *James Pearson*
+    *Sampat Badhe*
 
-*   Allow specifying fixtures to be ignored by setting `ignore` in YAML file's '_fixture' section.
+*   Validate options when managing columns and tables in migrations.
 
-    *Tongfei Gao*
+    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.
 
-*   Make the DATABASE_URL env variable only affect the primary connection. Add new env variables for multiple databases.
+    *Guo Xiang Tan*, *George Wambold*
 
-    *John Crepezzi*, *Eileen Uchitelle*
+*   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)
 
-*   Add a warning for enum elements with 'not_' prefix.
+    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`.
 
-        class Foo
-          enum status: [:sent, :not_sent]
-        end
+    *Modulitos* and *Iheanyi*
 
-    *Edu Depetris*
+*   Allow any ERB in the database.yml when creating rake tasks.
 
-*   Make currency symbols optional for money column type in PostgreSQL.
+    Any ERB can be used in `database.yml` even if it accesses environment
+    configurations.
 
-    *Joel Schneider*
+    Deprecates `config.active_record.suppress_multiple_database_warning`.
 
-*   Add support for beginless ranges, introduced in Ruby 2.7.
+    *Eike Send*
 
-    *Josh Goodall*
+*   Add table to error for duplicate column definitions.
 
-*   Add `database_exists?` method to connection adapters to check if a database exists.
+    If a migration defines duplicate columns for a table, the error message
+    shows which table it concerns.
 
-    *Guilherme Mansur*
+    *Petrik de Heus*
 
-*   Loading the schema for a model that has no `table_name` raises a `TableNotSpecified` error.
+*   Fix erroneous nil default precision on virtual datetime columns.
 
-    *Guilherme Mansur*, *Eugene Kenny*
+    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:
 
-*   PostgreSQL: Fix GROUP BY with ORDER BY virtual count attribute.
+        t.virtual :name, type: datetime,                 as: "expression"
+        t.virtual :name, type: datetime, precision: nil, as: "expression"
 
-    Fixes #36022.
+    This change fixes the default precision lookup, so virtual and regular
+    datetime column default precisions match.
 
-    *Ryuta Kamizono*
+    *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.
 
-*   Make ActiveRecord `ConnectionPool.connections` method thread-safe.
+    *Adrianna Chang*
 
-    Fixes #36465.
+*   Add `expires_at` option to `signed_id`.
 
-    *Jeff Doering*
+    *Shouichi Kamiya*
 
-*   Add support for multiple databases to `rails db:abort_if_pending_migrations`.
+*   Allow applications to set retry deadline for query retries.
 
-    *Mark Lee*
+    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.
 
-*   Fix sqlite3 collation parsing when using decimal columns.
+    *Adrianna Chang*
 
-    *Martin R. Schuster*
+*   Fix a case where the query cache can return wrong values. See #46044
 
-*   Fix invalid schema when primary key column has a comment.
+    *Aaron Patterson*
+
+*   Support MySQL's ssl-mode option for MySQLDatabaseTasks.
 
-    Fixes #29966.
+    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.
 
-    *Guilherme Goettems Schneider*
+    *Petrik de Heus*
 
-*   Fix table comment also being applied to the primary key column.
+*   Move `ActiveRecord::InternalMetadata` to an independent object.
 
-    *Guilherme Goettems Schneider*
+    `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`.
+
+    *Eileen M. Uchitelle*
 
-*   Allow generated `create_table` migrations to include or skip timestamps.
+*   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)
+    ```
+
+    *Aram Greenman*
+
+*   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
+    ```
+
+    *Igor Kasyanchuk*
+
+*   Move `ActiveRecord::SchemaMigration` to an independent object.
+
+    `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`.
+
+    *Eileen M. Uchitelle*
+
+*   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
+    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*
+
+*   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
+    class Person < ApplicationRecord
+    end
+
+    class WebUser < Person
+      attribute :is_admin, :boolean
+      after_initialize :set_admin
+
+      def set_admin
+        write_attribute(:is_admin, email =~ /@ourcompany\.com$/)
+      end
+    end
+
+    person = Person.find_by(email: "email@ourcompany.com")
+    person.respond_to? :is_admin
+    # => false
+    person.becomes(WebUser).is_admin?
+    # => true
+    ```
+
+    *Jacopo Beschi*, *Sampson Crowley*
+
+*   Fix `ActiveRecord::QueryMethods#in_order_of` to include `nil`s, to match the
+    behavior of `Enumerable#in_order_of`.
+
+    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"])`.
+
+    *fatkodima*
+
+*   Optimize `add_timestamps` to use a single SQL statement.
+
+    ```ruby
+    add_timestamps :my_table
+    ```
+
+    Now results in the following SQL:
+
+    ```sql
+    ALTER TABLE "my_table" ADD COLUMN "created_at" datetime(6) NOT NULL, ADD COLUMN "updated_at" datetime(6) NOT NULL
+    ```
+
+    *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.
+
+    *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*
+
+*   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
+    disable_extension :citext, force: :cascade
+    ```
+
+    Fixes #29091.
+
+    *fatkodima*
+
+*   Allow nested functions as safe SQL string
+
+    *Michael Siegfried*
+
+*   Allow `destroy_association_async_job=` to be configured with a class string instead of a constant.
+
+    Defers an autoloading dependency between `ActiveRecord::Base` and `ActiveJob::Base`
+    and moves the configuration of `ActiveRecord::DestroyAssociationAsyncJob`
+    from ActiveJob to ActiveRecord.
+
+    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*
+
+*   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]
+    ```
+
+    *Alex Ghiculescu*
+
+*   Add new `ActiveRecord::Base.generates_token_for` API.
+
+    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.
+
+    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
+    class User < ActiveRecord::Base
+      has_secure_password
+
+      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
+
+    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
+    ```
+
+    *Jonathan Hefner*
+
+*   Optimize Active Record batching for whole table iterations.
+
+    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.
+
+    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`).
+
+    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
+    Project.where(archived_at: nil).in_batches(use_ranges: true) do |relation|
+      # do something
+    end
+    ```
+
+    See #45414 for more details.
+
+    *fatkodima*
+
+*   `.with` query method added. Construct common table expressions with ease and get `ActiveRecord::Relation` back.
+
+    ```ruby
+    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
+    ```
+
+    *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
+    # 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])
+    ```
+
+    *Wojciech Wnętrzak*
+
+*   Introduce strategy pattern for executing migrations.
+
+    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*
+
+*   Add adapter option disallowing foreign keys
+
+    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.
+
+    Usage:
+    ```yaml
+    development:
+        <<: *default
+        database: storage/development.sqlite3
+        foreign_keys: false
+    ```
+
+    *Paulo Barros*
+
+*   Add configurable deprecation warning for singular associations
+
+    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`
+
+    *Adam Hess*
+
+*   Run transactional callbacks on the freshest instance to save a given
+    record within a transaction.
+
+    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.
+
+    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.
+
+    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:
+
+    - 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).
+
+    *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
+    # config/application.rb
+    config.active_record.sqlite3_adapter_strict_strings_by_default = false
+    ```
+
+    Fixes #27782.
+
+    *fatkodima*, *Jean Boussier*
+
+*   Resolve issue where a relation cache_version could be left stale.
+
+    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.
+
+    Usage:
+
+    ```ruby
+    developers = Developer.all
+    developers.cache_version
+
+    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
+    ```
+
+    Fixes #45341.
+
+    *Austen Madden*
+
+*   Add support for exclusion constraints (PostgreSQL-only).
+
+    ```ruby
+    add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist, name: "invoices_date_overlap"
+    remove_exclusion_constraint :invoices, name: "invoices_date_overlap"
+    ```
+
+    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
+    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)
+    ```
+
+    *Alex Ghiculescu*
+
+*   Enforce limit on table names length.
+
+    Fixes #45130.
+
+    *fatkodima*
+
+*   Adjust the minimum MariaDB version for check constraints support.
+
+    *Eddie Lebow*
+
+*   Fix Hstore deserialize regression.
+
+    *edsharp*
+
+*   Add validity for PostgreSQL indexes.
+
+    ```ruby
+    connection.index_exists?(:users, :email, valid: true)
+    connection.indexes(:users).select(&:valid?)
+    ```
+
+    *fatkodima*
+
+*   Fix eager loading for models without primary keys.
+
+    *Anmol Chopra*, *Matt Lawrence*, and *Jonathan Hefner*
+
+*   Avoid validating a unique field if it has not changed and is backed by a unique index.
+
+    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.
+
+    *fatkodima*
+
+*   Stop setting `sql_auto_is_null`
+
+    Since version 5.5 the default has been off, we no longer have to manually turn it off.
+
+    *Adam Hess*
+
+*   Fix `touch` to raise an error for readonly columns.
+
+    *fatkodima*
+
+*   Add ability to ignore tables by regexp for SQL schema dumps.
+
+    ```ruby
+    ActiveRecord::SchemaDumper.ignore_tables = [/^_/]
+    ```
+
+    *fatkodima*
+
+*   Avoid queries when performing calculations on contradictory relations.
+
+    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
+    class Book < ApplicationRecord
+      alias_attribute :title, :name
+    end
+
+    Book.insert_all [{ title: "Remote", author_id: 1 }], returning: :title
+    ```
+
+    *fatkodima*
+
+*   Support encrypted attributes on columns with default db values.
+
+    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.
+
+    *Jorge Manrubia* and *Dima Fatko*
+
+*   Allow overriding `reading_request?` in `DatabaseSelector::Resolver`
+
+    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*
+
+*   Remove `ActiveRecord.legacy_connection_handling`.
+
+    *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*
+
+*   Fixed MariaDB default function support.
+
+    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.
+
+    *kaspernj*
+
+*   Add `active_record.destroy_association_async_batch_size` configuration
+
+    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.
+
+    *Nick Holden*
+
+*   Fix `remove_foreign_key` with `:if_exists` option when foreign key actually exists.
+
+    *fatkodima*
+
+*   Remove `--no-comments` flag in structure dumps for PostgreSQL
+
+    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 = ['--no-comments']
+    ```
+
+    *Alex Ghiculescu*
+
+*   Reduce the memory footprint of fixtures accessors.
+
+    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.
+
+    Instead fixtures accessors are now implemented with `method_missing`,
+    so they incur much less memory and CPU overhead.
+
+    *Jean Boussier*
+
+*   Fix `config.active_record.destroy_association_async_job` configuration
+
+    `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.
+
+    *Nick Holden*
+
+*   Fix `change_column_comment` to preserve column's AUTO_INCREMENT in the MySQL adapter
+
+    *fatkodima*
+
+*   Fix quoting of `ActiveSupport::Duration` and `Rational` numbers in the MySQL adapter.
+
+    *Kevin McPhillips*
+
+*   Allow column name with COLLATE (e.g., title COLLATE "C") as safe SQL string
+
+    *Shugo Maeda*
+
+*   Permit underscores in the VERSION argument to database rake tasks.
+
+    *Eddie Lebow*
+
+*   Reversed the order of `INSERT` statements in `structure.sql` dumps
+
+    This should decrease the likelihood of merge conflicts. New migrations
+    will now be added at the top of the list.
+
+    For existing apps, there will be a large diff the next time `structure.sql`
+    is generated.
+
+    *Alex Ghiculescu*, *Matt Larraz*
+
+*   Fix PG.connect keyword arguments deprecation warning on ruby 2.7
+
+    Fixes #44307.
+
+    *Nikita Vasilevsky*
+
+*   Fix dropping DB connections after serialization failures and deadlocks.
+
+    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.
+
+    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.
+
+    These rollbacks are now restored, except for savepoints on MySQL.
+
+    *Thomas Morgan*
+
+*   Make `ActiveRecord::ConnectionPool` Fiber-safe
+
+    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.
+
+    *Alex Matchneer*
+
+*   Add `update_attribute!` to `ActiveRecord::Persistence`
+
+    Similar to `update_attribute`, but raises `ActiveRecord::RecordNotSaved` when a `before_*` callback throws `:abort`.
+
+    ```ruby
+    class Topic < ActiveRecord::Base
+      before_save :check_title
+
+      def check_title
+        throw(:abort) if title == "abort"
+      end
+    end
+
+    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
+    ```
+
+    *Drew Tempelmeyer*
+
+*   Avoid loading every record in `ActiveRecord::Relation#pretty_print`
+
+    ```ruby
+    # Before
+    pp Foo.all # Loads the whole table.
+
+    # After
+    pp Foo.all # Shows 10 items and an ellipsis.
+    ```
+
+    *Ulysse Buonomo*
+
+*   Change `QueryMethods#in_order_of` to drop records not listed in values.
+
+    `in_order_of` now filters down to the values provided, to match the behavior of the `Enumerable` version.
+
+    *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(:settings, "(data->'property')", using: :gin, name: :index_settings_data_property)
+    ```
+
+    Fixes #43331.
+
+    *Oliver Günther*
+
+*   Fix incorrect argument in PostgreSQL structure dump tasks.
+
+    Updating the `--no-comment` argument added in Rails 7 to the correct `--no-comments` argument.
+
+    *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.
+
+    *Marcelo Lauxen*
+
+*   Fix `QueryMethods#in_order_of` to handle empty order list.
+
+    ```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 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...
+    ```
+
+    *Jean Boussier*
+
+*   Add `authenticate_by` when using `has_secure_password`.
+
+    `authenticate_by` is intended to replace code like the following, which
+    returns early when a user with a matching email is not found:
+
+    ```ruby
+    User.find_by(email: "...")&.authenticate("...")
+    ```
+
+    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.
+
+    `authenticate_by` addresses the vulnerability by taking the same amount of
+    time regardless of whether a user with a matching email is found:
+
+    ```ruby
+    User.authenticate_by(email: "...", password: "...")
+    ```
 
-    *Michael Duchemin*
+    *Jonathan Hefner*
 
 
-Please check [6-0-stable](https://github.com/rails/rails/blob/6-0-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.