activerecord 6.0.0 → 7.2.3

data/CHANGELOG.md

@@ -1,1013 +1,1415 @@
-## Rails 6.0.0 (August 16, 2019) ##
+## Rails 7.2.3 (October 28, 2025) ##
 
-*   Preserve user supplied joins order as much as possible.
+*   Fix SQLite3 data loss during table alterations with CASCADE foreign keys.
 
-    Fixes #36761, #34328, #24281, #12953.
+    When altering a table in SQLite3 that is referenced by child tables with
+    `ON DELETE CASCADE` foreign keys, ActiveRecord would silently delete all
+    data from the child tables. This occurred because SQLite requires table
+    recreation for schema changes, and during this process the original table
+    is temporarily dropped, triggering CASCADE deletes on child tables.
 
-    *Ryuta Kamizono*
-
-*   Make the DATABASE_URL env variable only affect the primary connection. Add new env variables for multiple databases.
-
-    *John Crepezzi*, *Eileen Uchitelle*
+    The root cause was incorrect ordering of operations. The original code
+    wrapped `disable_referential_integrity` inside a transaction, but
+    `PRAGMA foreign_keys` cannot be modified inside a transaction in SQLite -
+    attempting to do so simply has no effect. This meant foreign keys remained
+    enabled during table recreation, causing CASCADE deletes to fire.
 
-*   Add a warning for enum elements with 'not_' prefix.
+    The fix reverses the order to follow the official SQLite 12-step ALTER TABLE
+    procedure: `disable_referential_integrity` now wraps the transaction instead
+    of being wrapped by it. This ensures foreign keys are properly disabled
+    before the transaction starts and re-enabled after it commits, preventing
+    CASCADE deletes while maintaining data integrity through atomic transactions.
 
-        class Foo
-          enum status: [:sent, :not_sent]
-        end
-
-    *Edu Depetris*
+    *Ruy Rocha*
 
-*   Make currency symbols optional for money column type in PostgreSQL
+*   Fix `belongs_to` associations not to clear the entire composite primary key.
 
-    *Joel Schneider*
+    When clearing a `belongs_to` association that references a model with composite primary key,
+    only the optional part of the key should be cleared.
 
+    *zzak*
 
-## Rails 6.0.0.rc2 (July 22, 2019) ##
+*   Fix invalid records being autosaved when distantly associated records are marked for deletion.
 
-*   Add database_exists? method to connection adapters to check if a database exists.
+    *Ian Terrell*, *axlekb AB*
 
-    *Guilherme Mansur*
+*   Prevent persisting invalid record.
 
-*   PostgreSQL: Fix GROUP BY with ORDER BY virtual count attribute.
+    *Edouard Chin*
 
-    Fixes #36022.
+*   Fix count with group by qualified name on loaded relation.
 
     *Ryuta Kamizono*
 
-*   Make ActiveRecord `ConnectionPool.connections` method thread-safe.
+*   Fix `sum` with qualified name on loaded relation.
 
-    Fixes #36465.
+    *Chris Gunther*
 
-    *Jeff Doering*
+*   Fix prepared statements on mysql2 adapter.
 
-*   Fix sqlite3 collation parsing when using decimal columns.
+    *Jean Boussier*
 
-    *Martin R. Schuster*
+*   Fix query cache for pinned connections in multi threaded transactional tests.
 
-*   Fix invalid schema when primary key column has a comment.
+    When a pinned connection is used across separate threads, they now use a separate cache store
+    for each thread.
 
-    Fixes #29966.
+    This improve accuracy of system tests, and any test using multiple threads.
 
-    *Guilherme Goettems Schneider*
+    *Heinrich Lee Yu*, *Jean Boussier*
 
-*   Fix table comment also being applied to the primary key column.
+*   Don't add `id_value` attribute alias when attribute/column with that name already exists.
 
-    *Guilherme Goettems Schneider*
+    *Rob Lewis*
 
-*   Fix merging left_joins to maintain its own `join_type` context.
+*   Fix false positive change detection involving STI and polymorhic has one relationships.
 
-    Fixes #36103.
+    Polymorphic `has_one` relationships would always be considered changed when defined in a STI child
+    class, causing nedless extra autosaves.
 
-    *Ryuta Kamizono*
+    *David Fritsch*
 
+*   Fix stale associaton detection for polymophic `belong_to`.
 
-## Rails 6.0.0.rc1 (April 24, 2019) ##
+    *Florent Beaurain*, *Thomas Crambert*
 
-*   Add `touch` option to `has_one` association.
+*   Fix removal of PostgreSQL version comments in `structure.sql` for latest PostgreSQL versions which include `\restrict`.
 
-    *Abhay Nikam*
+    *Brendan Weibrecht*
 
-*   Deprecate `where.not` working as NOR and will be changed to NAND in Rails 6.1.
+*   Fix `#merge` with `#or` or `#and` and a mixture of attributes and SQL strings resulting in an incorrect query.
 
     ```ruby
-    all = [treasures(:diamond), treasures(:sapphire), cars(:honda), treasures(:sapphire)]
-    assert_equal all, PriceEstimate.all.map(&:estimate_of)
+    base = Comment.joins(:post).where(user_id: 1).where("recent = 1")
+    puts base.merge(base.where(draft: true).or(Post.where(archived: true))).to_sql
     ```
 
-    In Rails 6.0:
+    Before:
 
-    ```ruby
-    sapphire = treasures(:sapphire)
+    ```SQL
+    SELECT "comments".* FROM "comments"
+    INNER JOIN "posts" ON "posts"."id" = "comments"."post_id"
+    WHERE (recent = 1)
+    AND (
+      "comments"."user_id" = 1
+      AND (recent = 1)
+      AND "comments"."draft" = 1
+      OR "posts"."archived" = 1
+    )
+    ```
 
-    nor = all.reject { |e|
-      e.estimate_of_type == sapphire.class.polymorphic_name
-    }.reject { |e|
-      e.estimate_of_id == sapphire.id
-    }
-    assert_equal [cars(:honda)], nor
+    After:
 
-    without_sapphire = PriceEstimate.where.not(
-      estimate_of_type: sapphire.class.polymorphic_name, estimate_of_id: sapphire.id
+    ```SQL
+    SELECT "comments".* FROM "comments"
+    INNER JOIN "posts" ON "posts"."id" = "comments"."post_id"
+    WHERE "comments"."user_id" = 1
+    AND (recent = 1)
+    AND (
+      "comments"."user_id" = 1
+      AND (recent = 1)
+      AND "comments"."draft" = 1
+      OR "posts"."archived" = 1
     )
-    assert_equal nor, without_sapphire.map(&:estimate_of)
     ```
 
-    In Rails 6.1:
+    *Joshua Young*
 
-    ```ruby
-    sapphire = treasures(:sapphire)
+*   Fix inline `has_and_belongs_to_many` fixtures for tables with composite primary keys.
 
-    nand = all - [sapphire]
-    assert_equal [treasures(:diamond), cars(:honda)], nand
+    *fatkodima*
 
-    without_sapphire = PriceEstimate.where.not(
-      estimate_of_type: sapphire.class.polymorphic_name, estimate_of_id: sapphire.id
-    )
-    assert_equal nand, without_sapphire.map(&:estimate_of)
-    ```
+*   Fix `annotate` comments to propagate to `update_all`/`delete_all`.
 
-    *Ryuta Kamizono*
+    *fatkodima*
 
-*   Fix dirty tracking after rollback.
+*   Fix checking whether an unpersisted record is `include?`d in a strictly
+    loaded `has_and_belongs_to_many` association.
 
-    Fixes #15018, #30167, #33868.
+    *Hartley McGuire*
 
-    *Ryuta Kamizono*
+*   Fix inline has_and_belongs_to_many fixtures for tables with composite primary keys.
 
-*   Add `ActiveRecord::Relation#cache_version` to support recyclable cache keys via
-    the versioned entries in `ActiveSupport::Cache`. This also means that
-    `ActiveRecord::Relation#cache_key` will now return a stable key that does not
-    include the max timestamp or count any more.
+    *fatkodima*
 
-    NOTE: This feature is turned off by default, and `cache_key` will still return
-    cache keys with timestamps until you set `ActiveRecord::Base.collection_cache_versioning = true`.
-    That's the setting for all new apps on Rails 6.0+
+*   `create_or_find_by` will now correctly rollback a transaction.
 
-    *Lachlan Sylvester*
+    When using `create_or_find_by`, raising a ActiveRecord::Rollback error
+    in a `after_save` callback had no effect, the transaction was committed
+    and a record created.
 
-*   Fix dirty tracking for `touch` to track saved changes.
+    *Edouard Chin*
 
-    Fixes #33429.
+*   Gracefully handle `Timeout.timeout` firing during connection configuration.
 
-    *Ryuta Kamzono*
+    Use of `Timeout.timeout` could result in improperly initialized database connection.
 
-*   `change_column_comment` and `change_table_comment` are invertible only if
-    `to` and `from` options are specified.
+    This could lead to a partially configured connection being used, resulting in various exceptions,
+    the most common being with the PostgreSQLAdapter raising `undefined method 'key?' for nil`
+    or `TypeError: wrong argument type nil (expected PG::TypeMap)`.
 
-    *Yoshiyuki Kinjo*
+    *Jean Boussier*
 
-*   Don't call commit/rollback callbacks when a record isn't saved.
+*   The SQLite3 adapter quotes non-finite Numeric values like "Infinity" and "NaN".
 
-    Fixes #29747.
+    *Mike Dalessio*
 
-    *Ryuta Kamizono*
+*   Handle libpq returning a database version of 0 on no/bad connection in `PostgreSQLAdapter`.
 
-*   Fix circular `autosave: true` causes invalid records to be saved.
+    Before, this version would be cached and an error would be raised during connection configuration when
+    comparing it with the minimum required version for the adapter. This meant that the connection could
+    never be successfully configured on subsequent reconnection attempts.
 
-    Prior to the fix, when there was a circular series of `autosave: true`
-    associations, the callback for a `has_many` association was run while
-    another instance of the same callback on the same association hadn't
-    finished running. When control returned to the first instance of the
-    callback, the instance variable had changed, and subsequent associated
-    records weren't saved correctly. Specifically, the ID field for the
-    `belongs_to` corresponding to the `has_many` was `nil`.
+    Now, this is treated as a connection failure consistent with libpq, raising a `ActiveRecord::ConnectionFailed`
+    and ensuring the version isn't cached, which allows the version to be retrieved on the next connection attempt.
 
-    Fixes #28080.
+    *Joshua Young*, *Rian McGuire*
 
-    *Larry Reid*
+*   Fix error handling during connection configuration.
 
-*   Raise `ArgumentError` for invalid `:limit` and `:precision` like as other options.
+    Active Record wasn't properly handling errors during the connection configuration phase.
+    This could lead to a partially configured connection being used, resulting in various exceptions,
+    the most common being with the PostgreSQLAdapter raising `undefined method `key?' for nil`
+    or `TypeError: wrong argument type nil (expected PG::TypeMap)`.
 
-    Before:
+    *Jean Boussier*
+
+*   Fix a case where a non-retryable query could be marked retryable.
+
+    *Hartley McGuire*
+
+*   Handle circular references when autosaving associations.
+
+    *zzak*
+
+*   Prevent persisting invalid record.
+
+    *Edouard Chin*
+
+*   Fix support for PostgreSQL enum types with commas in their name.
+
+    *Arthur Hess*
+
+*   Fix inserts on MySQL with no RETURNING support for a table with multiple auto populated columns.
+
+    *Nikita Vasilevsky*
+
+*   Fix joining on a scoped association with string joins and bind parameters.
 
     ```ruby
-    add_column :items, :attr1, :binary,   size: 10      # => ArgumentError
-    add_column :items, :attr2, :decimal,  scale: 10     # => ArgumentError
-    add_column :items, :attr3, :integer,  limit: 10     # => ActiveRecordError
-    add_column :items, :attr4, :datetime, precision: 10 # => ActiveRecordError
+    class Instructor < ActiveRecord::Base
+      has_many :instructor_roles, -> { active }
+    end
+
+    class InstructorRole < ActiveRecord::Base
+      scope :active, -> {
+        joins("JOIN students ON instructor_roles.student_id = students.id")
+        .where(students { status: 1 })
+      }
+    end
+
+    Instructor.joins(:instructor_roles).first
     ```
 
-    After:
+    The above example would result in `ActiveRecord::StatementInvalid` because the
+    `active` scope bind parameters would be lost.
+
+    *Jean Boussier*
+
+*   Fix a potential race condition with system tests and transactional fixtures.
+
+    *Sjoerd Lagarde*
+
+*   Fix count with group by qualified name on loaded relation.
+
+    *Ryuta Kamizono*
+
+*   Fix sum with qualified name on loaded relation.
+
+    *Chris Gunther*
+
+*   Fix autosave associations to no longer validated unmodified associated records.
+
+    Active Record was incorrectly performing validation on associated record that
+    weren't created nor modified as part of the transaction:
 
     ```ruby
-    add_column :items, :attr1, :binary,   size: 10      # => ArgumentError
-    add_column :items, :attr2, :decimal,  scale: 10     # => ArgumentError
-    add_column :items, :attr3, :integer,  limit: 10     # => ArgumentError
-    add_column :items, :attr4, :datetime, precision: 10 # => ArgumentError
+    Post.create!(author: User.find(1)) # Fail if user is invalid
     ```
 
+    *Jean Boussier*
+
+*   Remember when a database connection has recently been verified (for
+    two seconds, by default), to avoid repeated reverifications during a
+    single request.
+
+    This should recreate a similar rate of verification as in Rails 7.1,
+    where connections are leased for the duration of a request, and thus
+    only verified once.
+
+    *Matthew Draper*
+
+*   Fix prepared statements on mysql2 adapter.
+
+    *Jean Boussier*
+
+*   Fix a race condition in `ActiveRecord::Base#method_missing` when lazily defining attributes.
+
+    If multiple thread were concurrently triggering attribute definition on the same model,
+    it could result in a `NoMethodError` being raised.
+
+    *Jean Boussier*
+
+*   Fix MySQL default functions getting dropped when changing a column's nullability.
+
+    *Bastian Bartmann*
+
+*   Fix `add_unique_constraint`/`add_check_constraint`/`/`add_foreign_key` to be revertible when
+    given invalid options.
+
+    *fatkodima*
+
+*   Fix asynchronous destroying of polymorphic `belongs_to` associations.
+
+    *fatkodima*
+
+*   NOT VALID constraints should not dump in `create_table`.
+
     *Ryuta Kamizono*
 
-*   Association loading isn't to be affected by scoping consistently
-    whether preloaded / eager loaded or not, with the exception of `unscoped`.
+*   Fix finding by nil composite primary key association.
 
-    Before:
+    *fatkodima*
+
+*   Fix parsing of SQLite foreign key names when they contain non-ASCII characters
+
+    *Zacharias Knudsen*
+
+*   Fix parsing of MySQL 8.0.16+ CHECK constraints when they contain new lines.
+
+    *Steve Hill*
+
+*   Ensure normalized attribute queries use `IS NULL` consistently for `nil` and normalized `nil` values.
+
+    *Joshua Young*
+
+*   Restore back the ability to pass only database name for `DATABASE_URL`.
+
+    *fatkodima*
+
+*   Fix `order` with using association name as an alias.
+
+    *Ryuta Kamizono*
+
+*   Improve invalid argument error for with.
+
+    *Ryuta Kamizono*
+
+*   Deduplicate `with` CTE expressions.
+
+    *fatkodima*
+
+
+## Rails 7.2.2.2 (August 13, 2025) ##
+
+*   Call inspect on ids in RecordNotFound error
+
+    [CVE-2025-55193]
+
+    *Gannon McGibbon*, *John Hawthorn*
+
+
+## Rails 7.2.2.1 (December 10, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.2.2 (October 30, 2024) ##
+
+*   Fix support for `query_cache: false` in `database.yml`.
+
+    `query_cache: false` would no longer entirely disable the Active Record query cache.
+
+    *zzak*
+
+*   Set `.attributes_for_inspect` to `:all` by default.
+
+    For new applications it is set to `[:id]` in config/environment/production.rb.
+
+    In the console all the attributes are always shown.
+
+    *Andrew Novoselac*
+
+*   `PG::UnableToSend: no connection to the server` is now retryable as a connection-related exception
+
+    *Kazuma Watanabe*
+
+*   Fix marshalling of unsaved associated records in 7.1 format.
+
+    The 7.1 format would only marshal associated records if the association was loaded.
+    But associations that would only contain unsaved records would be skipped.
+
+    *Jean Boussier*
+
+*   Fix incorrect SQL query when passing an empty hash to `ActiveRecord::Base.insert`.
+
+    *David Stosik*
+
+*   Allow to save records with polymorphic join tables that have `inverse_of`
+    specified.
+
+    *Markus Doits*
+
+*   Fix association scopes applying on the incorrect join when using a polymorphic `has_many through:`.
+
+    *Joshua Young*
+
+*   Fix `dependent: :destroy` for bi-directional has one through association.
+
+    Fixes #50948.
 
     ```ruby
-    Post.where("1=0").scoping do
-      Comment.find(1).post                   # => nil
-      Comment.preload(:post).find(1).post    # => #<Post id: 1, ...>
-      Comment.eager_load(:post).find(1).post # => #<Post id: 1, ...>
+    class Left < ActiveRecord::Base
+      has_one :middle, dependent: :destroy
+      has_one :right, through: :middle
+    end
+
+    class Middle < ActiveRecord::Base
+      belongs_to :left, dependent: :destroy
+      belongs_to :right, dependent: :destroy
+    end
+
+    class Right < ActiveRecord::Base
+      has_one :middle, dependent: :destroy
+      has_one :left, through: :middle
     end
     ```
+    In the above example `left.destroy` wouldn't destroy its associated `Right`
+    record.
 
-    After:
+    *Andy Stewart*
+
+*   Properly handle lazily pinned connection pools.
+
+    Fixes #53147.
+
+    When using transactional fixtures with system tests to similar tools
+    such as capybara, it could happen that a connection end up pinned by the
+    server thread rather than the test thread, causing
+    `"Cannot expire connection, it is owned by a different thread"` errors.
+
+    *Jean Boussier*
+
+*   Fix `ActiveRecord::Base.with` to accept more than two sub queries.
+
+    Fixes #53110.
 
     ```ruby
-    Post.where("1=0").scoping do
-      Comment.find(1).post                   # => #<Post id: 1, ...>
-      Comment.preload(:post).find(1).post    # => #<Post id: 1, ...>
-      Comment.eager_load(:post).find(1).post # => #<Post id: 1, ...>
-    end
+    User.with(foo: [User.select(:id), User.select(:id), User.select(:id)]).to_sql
+    undefined method `union' for an instance of Arel::Nodes::UnionAll (NoMethodError)
     ```
 
-    Fixes #34638, #35398.
+    The above now works as expected.
 
-    *Ryuta Kamizono*
+    *fatkodima*
 
-*   Add `rails db:prepare` to migrate or setup a database.
+*   Properly release pinned connections with non joinable connections.
 
-    Runs `db:migrate` if the database exists or `db:setup` if it doesn't.
+    Fixes #52973
 
-    *Roberto Miranda*
+    When running system tests with transactional fixtures on, it could happen that
+    the connection leased by the Puma thread wouldn't be properly released back to the pool,
+    causing "Cannot expire connection, it is owned by a different thread" errors in later tests.
 
-*   Add `after_save_commit` callback as shortcut for `after_commit :hook, on: [ :create, :update ]`.
+    *Jean Boussier*
 
-    *DHH*
+*   Make Float distinguish between `float4` and `float8` in PostgreSQL.
 
-*   Assign all attributes before calling `build` to ensure the child record is visible in
-    `before_add` and `after_add` callbacks for `has_many :through` associations.
+    Fixes #52742
 
-    Fixes #33249.
+    *Ryota Kitazawa*, *Takayuki Nagatomi*
 
-    *Ryan H. Kerr*
+*   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.
 
-*   Add `ActiveRecord::Relation#extract_associated` for extracting associated records from a relation.
+    Previously, using `.left_outer_joins` with the same child association would only join one of the parents.
 
-    ```
-    account.memberships.extract_associated(:user)
-    # => Returns collection of User records
-    ```
+    Now it will correctly join both parents.
 
-    *DHH*
+    Fixes #41498.
 
-*   Add `ActiveRecord::Relation#annotate` for adding SQL comments to its queries.
+    *Garrett Blehm*
 
-    For example:
+*   Ensure `ActiveRecord::Encryption.config` is always ready before access.
 
-    ```
-    Post.where(id: 123).annotate("this is a comment").to_sql
-    # SELECT "posts".* FROM "posts" WHERE "posts"."id" = 123 /* this is a comment */
-    ```
+    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.
 
-    This can be useful in instrumentation or other analysis of issued queries.
+    `ActiveRecord::Encryption` now has its own loading hook so that its configuration is set as
+    soon as needed.
 
-    *Matt Yoho*
+    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`.
 
-*   Support Optimizer Hints.
+    *Maxime Réty*
 
-    In most databases, a way to control the optimizer is by using optimizer hints,
-    which can be specified within individual statements.
+*   Add `TimeZoneConverter#==` method, so objects will be properly compared by
+    their type, scale, limit & precision.
 
-    Example (for MySQL):
+    Address #52699.
 
-        Topic.optimizer_hints("MAX_EXECUTION_TIME(50000)", "NO_INDEX_MERGE(topics)")
-        # SELECT /*+ MAX_EXECUTION_TIME(50000) NO_INDEX_MERGE(topics) */ `topics`.* FROM `topics`
+    *Ruy Rocha*
 
-    Example (for PostgreSQL with pg_hint_plan):
 
-        Topic.optimizer_hints("SeqScan(topics)", "Parallel(topics 8)")
-        # SELECT /*+ SeqScan(topics) Parallel(topics 8) */ "topics".* FROM "topics"
+## Rails 7.2.1.2 (October 23, 2024) ##
 
-    See also:
+*   No changes.
 
-    * https://dev.mysql.com/doc/refman/8.0/en/optimizer-hints.html
-    * https://pghintplan.osdn.jp/pg_hint_plan.html
-    * https://docs.oracle.com/en/database/oracle/oracle-database/12.2/tgsql/influencing-the-optimizer.html
-    * https://docs.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-query?view=sql-server-2017
-    * https://www.ibm.com/support/knowledgecenter/en/SSEPGG_11.1.0/com.ibm.db2.luw.admin.perf.doc/doc/c0070117.html
 
-    *Ryuta Kamizono*
+## Rails 7.2.1.1 (October 15, 2024) ##
 
-*   Fix query attribute method on user-defined attribute to be aware of typecasted value.
+*   No changes.
 
-    For example, the following code no longer return false as casted non-empty string:
 
-    ```
-    class Post < ActiveRecord::Base
-      attribute :user_defined_text, :text
-    end
+## Rails 7.2.1 (August 22, 2024) ##
 
-    Post.new(user_defined_text: "false").user_defined_text? # => true
-    ```
+*   Fix detection for `enum` columns with parallelized tests and PostgreSQL.
 
-    *Yuji Kamijima*
+    *Rafael Mendonça França*
 
-*   Quote empty ranges like other empty enumerables.
+*   Allow to eager load nested nil associations.
 
-    *Patrick Rebsch*
+    *fatkodima*
 
-*   Add `insert_all`/`insert_all!`/`upsert_all` methods to `ActiveRecord::Persistence`,
-    allowing bulk inserts akin to the bulk updates provided by `update_all` and
-    bulk deletes by `delete_all`.
+*   Fix swallowing ignore order warning when batching using `BatchEnumerator`.
 
-    Supports skipping or upserting duplicates through the `ON CONFLICT` syntax
-    for PostgreSQL (9.5+) and SQLite (3.24+) and `ON DUPLICATE KEY UPDATE` syntax
-    for MySQL.
+    *fatkodima*
 
-    *Bob Lail*
+*   Fix memory bloat on the connection pool when using the Fiber `IsolatedExecutionState`.
 
-*   Add `rails db:seed:replant` that truncates tables of each database
-    for current environment and loads the seeds.
+    *Jean Boussier*
 
-    *bogdanvlviv*, *DHH*
+*   Restore inferred association class with the same modularized name.
 
-*   Add `ActiveRecord::Base.connection.truncate` for SQLite3 adapter.
+    *Justin Ko*
 
-    *bogdanvlviv*
+*   Fix `ActiveRecord::Base.inspect` to properly explain how to load schema information.
 
-*   Deprecate mismatched collation comparison for uniqueness validator.
+    *Jean Boussier*
 
-    Uniqueness validator will no longer enforce case sensitive comparison in Rails 6.1.
-    To continue case sensitive comparison on the case insensitive column,
-    pass `case_sensitive: true` option explicitly to the uniqueness validator.
+*   Check invalid `enum` options for the new syntax.
 
-    *Ryuta Kamizono*
+    The options using `_` prefix in the old syntax are invalid in the new syntax.
 
-*   Add `reselect` method. This is a short-hand for `unscope(:select).select(fields)`.
+    *Rafael Mendonça França*
 
-    Fixes #27340.
+*   Fix `ActiveRecord::Encryption::EncryptedAttributeType#type` to return
+    actual cast type.
 
-    *Willian Gustavo Veiga*
+    *Vasiliy Ermolovich*
 
-*   Add negative scopes for all enum values.
+*   Fix `create_table` with `:auto_increment` option for MySQL adapter.
 
-    Example:
+    *fatkodima*
 
-        class Post < ActiveRecord::Base
-          enum status: %i[ drafted active trashed ]
-        end
 
-        Post.not_drafted # => where.not(status: :drafted)
-        Post.not_active  # => where.not(status: :active)
-        Post.not_trashed # => where.not(status: :trashed)
+## Rails 7.2.0 (August 09, 2024) ##
 
-    *DHH*
+*   Handle commas in Sqlite3 default function definitions.
 
-*   Fix different `count` calculation when using `size` with manual `select` with DISTINCT.
+    *Stephen Margheim*
 
-    Fixes #35214.
+*   Fixes `validates_associated` raising an exception when configured with a
+    singular association and having `index_nested_attribute_errors` enabled.
 
-    *Juani Villarejo*
+    *Martin Spickermann*
 
+*   The constant `ActiveRecord::ImmutableRelation` has been deprecated because
+    we want to reserve that name for a stronger sense of "immutable relation".
+    Please use `ActiveRecord::UnmodifiableRelation` instead.
 
-## Rails 6.0.0.beta3 (March 11, 2019) ##
+    *Xavier Noria*
 
-*   No changes.
+*   Add condensed `#inspect` for `ConnectionPool`, `AbstractAdapter`, and
+    `DatabaseConfig`.
 
+    *Hartley McGuire*
 
-## Rails 6.0.0.beta2 (February 25, 2019) ##
+*   Fixed a memory performance issue in Active Record attribute methods definition.
 
-*   Fix prepared statements caching to be enabled even when query caching is enabled.
+    *Jean Boussier*
 
-    *Ryuta Kamizono*
+*   Define the new Active Support notification event `start_transaction.active_record`.
 
-*   Ensure `update_all` series cares about optimistic locking.
+    This event is fired when database transactions or savepoints start, and
+    complements `transaction.active_record`, which is emitted when they finish.
 
-    *Ryuta Kamizono*
+    The payload has the transaction (`:transaction`) and the connection (`:connection`).
 
-*   Don't allow `where` with non numeric string matches to 0 values.
+    *Xavier Noria*
 
-    *Ryuta Kamizono*
+*   Fix an issue where the IDs reader method did not return expected results
+    for preloaded associations in models using composite primary keys.
 
-*   Introduce `ActiveRecord::Relation#destroy_by` and `ActiveRecord::Relation#delete_by`.
+    *Jay Ang*
 
-    `destroy_by` allows relation to find all the records matching the condition and perform
-    `destroy_all` on the matched records.
+*   The payload of `sql.active_record` Active Support notifications now has the current transaction in the `:transaction` key.
 
-    Example:
+    *Xavier Noria*
 
-        Person.destroy_by(name: 'David')
-        Person.destroy_by(name: 'David', rating: 4)
+*   The payload of `transaction.active_record` Active Support notifications now has the transaction the event is related to in the `:transaction` key.
 
-        david = Person.find_by(name: 'David')
-        david.posts.destroy_by(id: [1, 2, 3])
+    *Xavier Noria*
 
-    `delete_by` allows relation to find all the records matching the condition and perform
-    `delete_all` on the matched records.
+*   Define `ActiveRecord::Transaction#uuid`, which returns a UUID for the database transaction. This may be helpful when tracing database activity. These UUIDs are generated only on demand.
 
-    Example:
+    *Xavier Noria*
 
-        Person.delete_by(name: 'David')
-        Person.delete_by(name: 'David', rating: 4)
+*   Fix inference of association model on nested models with the same demodularized name.
 
-        david = Person.find_by(name: 'David')
-        david.posts.delete_by(id: [1, 2, 3])
+    E.g. with the following setup:
 
-    *Abhay Nikam*
+    ```ruby
+    class Nested::Post < ApplicationRecord
+      has_one :post, through: :other
+    end
+    ```
 
-*   Don't allow `where` with invalid value matches to nil values.
+    Before, `#post` would infer the model as `Nested::Post`, but now it correctly infers `Post`.
 
-    Fixes #33624.
+    *Joshua Young*
 
-    *Ryuta Kamizono*
+*   PostgreSQL `Cidr#change?` detects the address prefix change.
 
-*   SQLite3: Implement `add_foreign_key` and `remove_foreign_key`.
+    *Taketo Takashima*
 
-    *Ryuta Kamizono*
+*   Change `BatchEnumerator#destroy_all` to return the total number of affected rows.
 
-*   Deprecate using class level querying methods if the receiver scope
-    regarded as leaked. Use `klass.unscoped` to avoid the leaking scope.
+    Previously, it always returned `nil`.
 
-    *Ryuta Kamizono*
+    *fatkodima*
+
+*   Support `touch_all` in batches.
+
+    ```ruby
+    Post.in_batches.touch_all
+    ```
+
+    *fatkodima*
 
-*   Allow applications to automatically switch connections.
+*   Add support for `:if_not_exists` and `:force` options to `create_schema`.
 
-    Adds a middleware and configuration options that can be used in your
-    application to automatically switch between the writing and reading
-    database connections.
+    *fatkodima*
 
-    `GET` and `HEAD` requests will read from the replica unless there was
-    a write in the last 2 seconds, otherwise they will read from the primary.
-    Non-get requests will always write to the primary. The middleware accepts
-    an argument for a Resolver class and an Operations class where you are able
-    to change how the auto-switcher works to be most beneficial for your
-    application.
+*   Fix `index_errors` having incorrect index in association validation errors.
+
+    *lulalala*
+
+*   Add `index_errors: :nested_attributes_order` mode.
+
+    This indexes the association validation errors based on the order received by nested attributes setter, and respects the `reject_if` configuration. This enables API to provide enough information to the frontend to map the validation errors back to their respective form fields.
+
+    *lulalala*
+
+*   Add `Rails.application.config.active_record.postgresql_adapter_decode_dates` to opt out of decoding dates automatically with the postgresql adapter. Defaults to true.
+
+    *Joé Dupuis*
+
+*   Association option `query_constraints` is deprecated in favor of `foreign_key`.
+
+    *Nikita Vasilevsky*
+
+*   Add `ENV["SKIP_TEST_DATABASE_TRUNCATE"]` flag to speed up multi-process test runs on large DBs when all tests run within default transaction.
+
+    This cuts ~10s from the test run of HEY when run by 24 processes against the 178 tables, since ~4,000 table truncates can then be skipped.
+
+    *DHH*
 
-    To use the middleware in your application you can use the following
-    configuration options:
+*   Added support for recursive common table expressions.
 
+    ```ruby
+    Post.with_recursive(
+      post_and_replies: [
+        Post.where(id: 42),
+        Post.joins('JOIN post_and_replies ON posts.in_reply_to_id = post_and_replies.id'),
+      ]
+    )
     ```
-    config.active_record.database_selector = { delay: 2.seconds }
-    config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
-    config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+
+    Generates the following SQL:
+
+    ```sql
+    WITH RECURSIVE "post_and_replies" AS (
+      (SELECT "posts".* FROM "posts" WHERE "posts"."id" = 42)
+      UNION ALL
+      (SELECT "posts".* FROM "posts" JOIN post_and_replies ON posts.in_reply_to_id = post_and_replies.id)
+    )
+    SELECT "posts".* FROM "posts"
     ```
 
-    To change the database selection strategy, pass a custom class to the
-    configuration options:
+    *ClearlyClaire*
 
+*   `validate_constraint` can be called in a `change_table` block.
+
+    ex:
+    ```ruby
+    change_table :products do |t|
+      t.check_constraint "price > discounted_price", name: "price_check", validate: false
+      t.validate_check_constraint "price_check"
+    end
     ```
-    config.active_record.database_selector = { delay: 10.seconds }
-    config.active_record.database_resolver = MyResolver
-    config.active_record.database_resolver_context = MyResolver::MyCookies
+
+    *Cody Cutrer*
+
+*   `PostgreSQLAdapter` now decodes columns of type date to `Date` instead of string.
+
+    Ex:
+    ```ruby
+    ActiveRecord::Base.connection
+         .select_value("select '2024-01-01'::date").class #=> Date
     ```
 
-    *Eileen M. Uchitelle*
+    *Joé Dupuis*
 
-*   MySQL: Support `:size` option to change text and blob size.
+*   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.
 
-*   Make `t.timestamps` with precision by default.
+    Before:
 
-    *Ryuta Kamizono*
+    ```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
+    ```
 
+    After:
 
-## Rails 6.0.0.beta1 (January 18, 2019) ##
+    ```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
+    ```
 
-*   Remove deprecated `#set_state` from the transaction object.
+    *Reid Lynch*
 
-    *Rafael Mendonça França*
+*   Allow `Sqlite3Adapter` to use `sqlite3` gem version `2.x`.
 
-*   Remove deprecated `#supports_statement_cache?` from the database adapters.
+    *Mike Dalessio*
 
-    *Rafael Mendonça França*
+*   Allow `ActiveRecord::Base#pluck` to accept hash values.
 
-*   Remove deprecated `#insert_fixtures` from the database adapters.
+    ```ruby
+    # Before
+    Post.joins(:comments).pluck("posts.id", "comments.id", "comments.body")
 
-    *Rafael Mendonça França*
+    # After
+    Post.joins(:comments).pluck(posts: [:id], comments: [:id, :body])
+    ```
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::SQLite3Adapter#valid_alter_table_type?`.
+    *fatkodima*
 
-    *Rafael Mendonça França*
+*   Raise an `ActiveRecord::ActiveRecordError` error when the MySQL database returns an invalid version string.
 
-*   Do not allow passing the column name to `sum` when a block is passed.
+    *Kevin McPhillips*
 
-    *Rafael Mendonça França*
+*   `ActiveRecord::Base.transaction` now yields an `ActiveRecord::Transaction` object.
+
+    This allows to register callbacks on it.
+
+    ```ruby
+    Article.transaction do |transaction|
+      article.update(published: true)
+      transaction.after_commit do
+        PublishNotificationMailer.with(article: article).deliver_later
+      end
+    end
+    ```
+
+    *Jean Boussier*
+
+*   Add `ActiveRecord::Base.current_transaction`.
+
+    Returns the current transaction, to allow registering callbacks on it.
+
+    ```ruby
+    Article.current_transaction.after_commit do
+      PublishNotificationMailer.with(article: article).deliver_later
+    end
+    ```
+
+    *Jean Boussier*
+
+*   Add `ActiveRecord.after_all_transactions_commit` callback.
+
+    Useful for code that may run either inside or outside a transaction and needs
+    to perform work after the state changes have been properly persisted.
+
+    ```ruby
+    def publish_article(article)
+      article.update(published: true)
+      ActiveRecord.after_all_transactions_commit do
+        PublishNotificationMailer.with(article: article).deliver_later
+      end
+    end
+    ```
+
+    In the above example, the block is either executed immediately if called outside
+    of a transaction, or called after the open transaction is committed.
+
+    If the transaction is rolled back, the block isn't called.
+
+    *Jean Boussier*
+
+*   Add the ability to ignore counter cache columns until they are backfilled.
+
+    Starting to use counter caches on existing large tables can be troublesome, because the column
+    values must be backfilled separately of the column addition (to not lock the table for too long)
+    and before the use of `:counter_cache` (otherwise methods like `size`/`any?`/etc, which use
+    counter caches internally, can produce incorrect results). People usually use database triggers
+    or callbacks on child associations while backfilling before introducing a counter cache
+    configuration to the association.
+
+    Now, to safely backfill the column, while keeping the column updated with child records added/removed, use:
+
+    ```ruby
+    class Comment < ApplicationRecord
+      belongs_to :post, counter_cache: { active: false }
+    end
+    ```
+
+    While the counter cache is not "active", the methods like `size`/`any?`/etc will not use it,
+    but get the results directly from the database. After the counter cache column is backfilled, simply
+    remove the `{ active: false }` part from the counter cache definition, and it will now be used by the
+    mentioned methods.
+
+    *fatkodima*
+
+*   Retry known idempotent SELECT queries on connection-related exceptions.
+
+    SELECT queries we construct by walking the Arel tree and / or with known model attributes
+    are idempotent and can safely be retried in the case of a connection error. Previously,
+    adapters such as `TrilogyAdapter` would raise `ActiveRecord::ConnectionFailed: Trilogy::EOFError`
+    when encountering a connection error mid-request.
+
+    *Adrianna Chang*
+
+*   Allow association's `foreign_key` to be composite.
+
+    `query_constraints` option was the only way to configure a composite foreign key by passing an `Array`.
+    Now it's possible to pass an Array value as `foreign_key` to achieve the same behavior of an association.
+
+    *Nikita Vasilevsky*
+
+*   Allow association's `primary_key` to be composite.
+
+    Association's `primary_key` can be composite when derived from associated model `primary_key` or `query_constraints`.
+    Now it's possible to explicitly set it as composite on the association.
+
+    *Nikita Vasilevsky*
+
+*   Add `config.active_record.permanent_connection_checkout` setting.
 
-*   Do not allow passing the column name to `count` when a block is passed.
+    Controls whether `ActiveRecord::Base.connection` raises an error, emits a deprecation warning, or neither.
+
+    `ActiveRecord::Base.connection` checkouts a database connection from the pool and keeps it leased until the end of
+    the request or job. This behavior can be undesirable in environments that use many more threads or fibers than there
+    is available connections.
+
+    This configuration can be used to track down and eliminate code that calls `ActiveRecord::Base.connection` and
+    migrate it to use `ActiveRecord::Base.with_connection` instead.
+
+    The default behavior remains unchanged, and there is currently no plans to change the default.
+
+    *Jean Boussier*
+
+*   Add dirties option to uncached.
+
+    This adds a `dirties` option to `ActiveRecord::Base.uncached` and
+    `ActiveRecord::ConnectionAdapters::ConnectionPool#uncached`.
+
+    When set to `true` (the default), writes will clear all query caches belonging to the current thread.
+    When set to `false`, writes to the affected connection pool will not clear any query cache.
+
+    This is needed by Solid Cache so that cache writes do not clear query caches.
+
+    *Donal McBreen*
+
+*   Deprecate `ActiveRecord::Base.connection` in favor of `.lease_connection`.
+
+    The method has been renamed as `lease_connection` to better reflect that the returned
+    connection will be held for the duration of the request or job.
+
+    This deprecation is a soft deprecation, no warnings will be issued and there is no
+    current plan to remove the method.
+
+    *Jean Boussier*
+
+*   Deprecate `ActiveRecord::ConnectionAdapters::ConnectionPool#connection`.
+
+    The method has been renamed as `lease_connection` to better reflect that the returned
+    connection will be held for the duration of the request or job.
+
+    *Jean Boussier*
+
+*   Expose a generic fixture accessor for fixture names that may conflict with Minitest.
+
+    ```ruby
+    assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
+    assert_equal "Ruby on Rails", fixture(:web_sites, :rubyonrails).name
+    ```
+
+    *Jean Boussier*
+
+*   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.
+
+    *Joshua Young*
+
+*   Fix `has_one` association autosave setting the foreign key attribute when it is unchanged.
+
+    This behavior is also inconsistent with autosaving `belongs_to` and can have unintended side effects like raising
+    an `ActiveRecord::ReadonlyAttributeError` when the foreign key attribute is marked as read-only.
+
+    *Joshua Young*
+
+*   Remove deprecated behavior that would rollback a transaction block when exited using `return`, `break` or `throw`.
 
     *Rafael Mendonça França*
 
-*   Remove delegation of missing methods in a relation to arel.
+*   Deprecate `Rails.application.config.active_record.commit_transaction_on_non_local_return`.
 
     *Rafael Mendonça França*
 
-*   Remove delegation of missing methods in a relation to private methods of the class.
+*   Remove deprecated support to pass `rewhere` to `ActiveRecord::Relation#merge`.
 
     *Rafael Mendonça França*
 
-*   Deprecate `config.activerecord.sqlite3.represent_boolean_as_integer`.
+*   Remove deprecated support to pass `deferrable: true` to `add_foreign_key`.
 
     *Rafael Mendonça França*
 
-*   Change `SQLite3Adapter` to always represent boolean values as integers.
+*   Remove deprecated support to quote `ActiveSupport::Duration`.
 
     *Rafael Mendonça França*
 
-*   Remove ability to specify a timestamp name for `#cache_key`.
+*   Remove deprecated `#quote_bound_value`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `ActiveRecord::Migrator.migrations_path=`.
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::ConnectionPool#connection_klass`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `expand_hash_conditions_for_aggregates`.
+*   Remove deprecated support to apply `#connection_pool_list`, `#active_connections?`, `#clear_active_connections!`,
+    `#clear_reloadable_connections!`, `#clear_all_connections!` and `#flush_idle_connections!` to the connections pools
+    for the current role when the `role` argument isn't provided.
 
     *Rafael Mendonça França*
 
-*   Set polymorphic type column to NULL on `dependent: :nullify` strategy.
+*   Remove deprecated `#all_connection_pools`.
 
-    On polymorphic associations both the foreign key and the foreign type columns will be set to NULL.
+    *Rafael Mendonça França*
 
-    *Laerti Papa*
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::SchemaCache#data_sources`.
 
-*   Allow permitted instance of `ActionController::Parameters` as argument of `ActiveRecord::Relation#exists?`.
+    *Rafael Mendonça França*
 
-    *Gannon McGibbon*
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::SchemaCache.load_from`.
 
-*   Add support for endless ranges introduces in Ruby 2.6.
+    *Rafael Mendonça França*
 
-    *Greg Navis*
+*   Remove deprecated `#all_foreign_keys_valid?` from database adapters.
 
-*   Deprecate passing `migrations_paths` to `connection.assume_migrated_upto_version`.
+    *Rafael Mendonça França*
 
-    *Ryuta Kamizono*
+*   Remove deprecated support to passing coder and class as second argument to `serialize`.
 
-*   MySQL: `ROW_FORMAT=DYNAMIC` create table option by default.
+    *Rafael Mendonça França*
 
-    Since MySQL 5.7.9, the `innodb_default_row_format` option defines the default row
-    format for InnoDB tables. The default setting is `DYNAMIC`.
-    The row format is required for indexing on `varchar(255)` with `utf8mb4` columns.
+*   Remove deprecated support to `ActiveRecord::Base#read_attribute(:id)` to return the custom primary key value.
 
-    *Ryuta Kamizono*
+    *Rafael Mendonça França*
 
-*   Fix join table column quoting with SQLite.
+*   Remove deprecated `TestFixtures.fixture_path`.
 
-    *Gannon McGibbon*
+    *Rafael Mendonça França*
 
-*   Allow disabling scopes generated by `ActiveRecord.enum`.
+*   Remove deprecated behavior to support referring to a singular association by its plural name.
 
-    *Alfred Dominic*
+    *Rafael Mendonça França*
 
-*   Ensure that `delete_all` on collection proxy returns affected count.
+*   Deprecate `Rails.application.config.active_record.allow_deprecated_singular_associations_name`.
 
-    *Ryuta Kamizono*
+    *Rafael Mendonça França*
 
-*   Reset scope after delete on collection association to clear stale offsets of removed records.
+*   Remove deprecated support to passing `SchemaMigration` and `InternalMetadata` classes as arguments to
+    `ActiveRecord::MigrationContext`.
 
-    *Gannon McGibbon*
+    *Rafael Mendonça França*
 
-*   Add the ability to prevent writes to a database for the duration of a block.
+*   Remove deprecated `ActiveRecord::Migration.check_pending!` method.
 
-    Allows the application to prevent writes to a database. This can be useful when
-    you're building out multiple databases and want to make sure you're not sending
-    writes when you want a read.
+    *Rafael Mendonça França*
 
-    If `while_preventing_writes` is called and the query is considered a write
-    query the database will raise an exception regardless of whether the database
-    user is able to write.
+*   Remove deprecated `ActiveRecord::LogSubscriber.runtime` method.
 
-    This is not meant to be a catch-all for write queries but rather a way to enforce
-    read-only queries without opening a second connection. One purpose of this is to
-    catch accidental writes, not all writes.
+    *Rafael Mendonça França*
 
-    *Eileen M. Uchitelle*
+*   Remove deprecated `ActiveRecord::LogSubscriber.runtime=` method.
 
-*   Allow aliased attributes to be used in `#update_columns` and `#update`.
+    *Rafael Mendonça França*
 
-    *Gannon McGibbon*
+*   Remove deprecated `ActiveRecord::LogSubscriber.reset_runtime` method.
 
-*   Allow spaces in postgres table names.
+    *Rafael Mendonça França*
 
-    Fixes issue where "user post" is misinterpreted as "\"user\".\"post\"" when quoting table names with the postgres adapter.
+*   Remove deprecated support to define `explain` in the connection adapter with 2 arguments.
 
-    *Gannon McGibbon*
+    *Rafael Mendonça França*
 
-*   Cached `columns_hash` fields should be excluded from `ResultSet#column_types`.
+*   Remove deprecated `ActiveRecord::ActiveJobRequiredError`.
 
-    PR #34528 addresses the inconsistent behaviour when attribute is defined for an ignored column. The following test
-    was passing for SQLite and MySQL, but failed for PostgreSQL:
+    *Rafael Mendonça França*
 
-    ```ruby
-    class DeveloperName < ActiveRecord::Type::String
-      def deserialize(value)
-        "Developer: #{value}"
-      end
-    end
+*   Remove deprecated `ActiveRecord::Base.clear_active_connections!`.
 
-    class AttributedDeveloper < ActiveRecord::Base
-      self.table_name = "developers"
+    *Rafael Mendonça França*
 
-      attribute :name, DeveloperName.new
+*   Remove deprecated `ActiveRecord::Base.clear_reloadable_connections!`.
 
-      self.ignored_columns += ["name"]
-    end
+    *Rafael Mendonça França*
 
-    developer = AttributedDeveloper.create
-    developer.update_column :name, "name"
+*   Remove deprecated `ActiveRecord::Base.clear_all_connections!`.
 
-    loaded_developer = AttributedDeveloper.where(id: developer.id).select("*").first
-    puts loaded_developer.name # should be "Developer: name" but it's just "name"
-    ```
+    *Rafael Mendonça França*
 
-    *Dmitry Tsepelev*
+*   Remove deprecated `ActiveRecord::Base.flush_idle_connections!`.
 
-*   Make the implicit order column configurable.
+    *Rafael Mendonça França*
 
-    When calling ordered finder methods such as `first` or `last` without an
-    explicit order clause, ActiveRecord sorts records by primary key. This can
-    result in unpredictable and surprising behaviour when the primary key is
-    not an auto-incrementing integer, for example when it's a UUID. This change
-    makes it possible to override the column used for implicit ordering such
-    that `first` and `last` will return more predictable results.
+*   Remove deprecated `name` argument from `ActiveRecord::Base.remove_connection`.
 
-    Example:
+    *Rafael Mendonça França*
 
-        class Project < ActiveRecord::Base
-          self.implicit_order_column = "created_at"
-        end
+*   Remove deprecated support to call `alias_attribute` with non-existent attribute names.
 
-    *Tekin Suleyman*
+    *Rafael Mendonça França*
 
-*   Bump minimum PostgreSQL version to 9.3.
+*   Remove deprecated `Rails.application.config.active_record.suppress_multiple_database_warning`.
 
-    *Yasuo Honda*
+    *Rafael Mendonça França*
 
-*   Values of enum are frozen, raising an error when attempting to modify them.
+*   Add `ActiveRecord::Encryption::MessagePackMessageSerializer`.
 
-    *Emmanuel Byrd*
+    Serialize data to the MessagePack format, for efficient storage in binary columns.
 
-*   Move `ActiveRecord::StatementInvalid` SQL to error property and include binds as separate error property.
+    The binary encoding requires around 30% less space than the base64 encoding
+    used by the default serializer.
 
-    `ActiveRecord::ConnectionAdapters::AbstractAdapter#translate_exception_class` now requires `binds` to be passed as the last argument.
+    *Donal McBreen*
 
-    `ActiveRecord::ConnectionAdapters::AbstractAdapter#translate_exception` now requires `message`, `sql`, and `binds` to be passed as keyword arguments.
+*   Add support for encrypting binary columns.
 
-    Subclasses of `ActiveRecord::StatementInvalid` must now provide `sql:` and `binds:` arguments to `super`.
+    Ensure encryption and decryption pass `Type::Binary::Data` around for binary data.
 
-    Example:
+    Previously encrypting binary columns with the `ActiveRecord::Encryption::MessageSerializer`
+    incidentally worked for MySQL and SQLite, but not PostgreSQL.
 
-    ```
-    class MySubclassedError < ActiveRecord::StatementInvalid
-      def initialize(message, sql:, binds:)
-        super(message, sql: sql, binds: binds)
-      end
-    end
-    ```
+    *Donal McBreen*
 
-    *Gannon McGibbon*
+*   Deprecated `ENV["SCHEMA_CACHE"]` in favor of `schema_cache_path` in the database configuration.
 
-*   Add an `:if_not_exists` option to `create_table`.
+    *Rafael Mendonça França*
 
-    Example:
+*   Add `ActiveRecord::Base.with_connection` as a shortcut for leasing a connection for a short duration.
 
-        create_table :posts, if_not_exists: true do |t|
-          t.string :title
-        end
+    The leased connection is yielded, and for the duration of the block, any call to `ActiveRecord::Base.connection`
+    will yield that same connection.
 
-    That would execute:
+    This is useful to perform a few database operations without causing a connection to be leased for the
+    entire duration of the request or job.
 
-        CREATE TABLE IF NOT EXISTS posts (
-          ...
-        )
+    *Jean Boussier*
 
-    If the table already exists, `if_not_exists: false` (the default) raises an
-    exception whereas `if_not_exists: true` does nothing.
+*   Deprecate `config.active_record.warn_on_records_fetched_greater_than` now that `sql.active_record`
+    notification includes `:row_count` field.
 
-    *fatkodima*, *Stefan Kanev*
+    *Jason Nochlin*
 
-*   Defining an Enum as a Hash with blank key, or as an Array with a blank value, now raises an `ArgumentError`.
+*   Fix an issue with `where.associated` losing the current join type scope.
 
-    *Christophe Maximin*
+    Example:
 
-*   Adds support for multiple databases to `rails db:schema:cache:dump` and `rails db:schema:cache:clear`.
+    ```ruby
+    Post.left_joins(:author).where.associated(:author)
+    ```
 
-    *Gannon McGibbon*
+    Previously, the `LEFT OUTER JOIN` would be lost and converted to an `INNER JOIN`.
 
-*   `update_columns` now correctly raises `ActiveModel::MissingAttributeError`
-    if the attribute does not exist.
+    *Saleh Alhaddad*
 
-    *Sean Griffin*
+*   Fix an issue where `ActiveRecord::Encryption` configurations are not ready before the loading
+    of Active Record models, when an application is eager loaded. As a result, encrypted attributes
+    could be misconfigured in some cases.
 
-*   Add support for hash and URL configs in database hash of `ActiveRecord::Base.connected_to`.
+    *Maxime Réty*
 
-    ````
-    User.connected_to(database: { writing: "postgres://foo" }) do
-      User.create!(name: "Gannon")
-    end
+*   Deprecate defining an `enum` with keyword arguments.
 
-    config = { "adapter" => "sqlite3", "database" => "db/readonly.sqlite3" }
-    User.connected_to(database: { reading: config }) do
-      User.count
+    ```ruby
+    class Function > ApplicationRecord
+      # BAD
+      enum color: [:red, :blue],
+           type: [:instance, :class]
+
+      # GOOD
+      enum :color, [:red, :blue]
+      enum :type, [:instance, :class]
     end
-    ````
+    ```
 
-    *Gannon McGibbon*
+    *Hartley McGuire*
 
-*   Support default expression for MySQL.
+*   Add `config.active_record.validate_migration_timestamps` option for validating migration timestamps.
 
-    MySQL 8.0.13 and higher supports default value to be a function or expression.
+    When set, validates that the timestamp prefix for a migration is no more than a day ahead of
+    the timestamp associated with the current time. This is designed to prevent migrations prefixes
+    from being hand-edited to future timestamps, which impacts migration generation and other
+    migration commands.
 
-    https://dev.mysql.com/doc/refman/8.0/en/create-table.html
+    *Adrianna Chang*
 
-    *Ryuta Kamizono*
+*   Properly synchronize `Mysql2Adapter#active?` and `TrilogyAdapter#active?`.
 
-*   Support expression indexes for MySQL.
+    As well as `disconnect!` and `verify!`.
 
-    MySQL 8.0.13 and higher supports functional key parts that index
-    expression values rather than column or column prefix values.
+    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.
 
-    https://dev.mysql.com/doc/refman/8.0/en/create-index.html
+    *Jean Boussier*
 
-    *Ryuta Kamizono*
+*   Support `:source_location` tag option for query log tags.
 
-*   Fix collection cache key with limit and custom select to avoid ambiguous timestamp column error.
+    ```ruby
+    config.active_record.query_log_tags << :source_location
+    ```
 
-    Fixes #33056.
+    Calculating the caller location is a costly operation and should be used primarily in development
+    (note, there is also a `config.active_record.verbose_query_logs` that serves the same purpose)
+    or occasionally on production for debugging purposes.
 
-    *Federico Martinez*
+    *fatkodima*
 
-*   Add basic API for connection switching to support multiple databases.
+*   Add an option to `ActiveRecord::Encryption::Encryptor` to disable compression.
 
-    1) Adds a `connects_to` method for models to connect to multiple databases. Example:
+    Allow compression to be disabled by setting `compress: false`
 
+    ```ruby
+      class User
+        encrypts :name, encryptor: ActiveRecord::Encryption::Encryptor.new(compress: false)
+      end
     ```
-    class AnimalsModel < ApplicationRecord
-      self.abstract_class = true
 
-      connects_to database: { writing: :animals_primary, reading: :animals_replica }
-    end
+    *Donal McBreen*
 
-    class Dog < AnimalsModel
-      # connected to both the animals_primary db for writing and the animals_replica for reading
-    end
-    ```
+*   Deprecate passing strings to `ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename`.
 
-    2) Adds a `connected_to` block method for switching connection roles or connecting to
-    a database that the model didn't connect to. Connecting to the database in this block is
-    useful when you have another defined connection, for example `slow_replica` that you don't
-    want to connect to by default but need in the console, or a specific code block.
+    A `ActiveRecord::DatabaseConfigurations::DatabaseConfig` object should be passed instead.
 
-    ```
-    ActiveRecord::Base.connected_to(role: :reading) do
-      Dog.first # finds dog from replica connected to AnimalsBase
-      Book.first # doesn't have a reading connection, will raise an error
-    end
-    ```
+    *Rafael Mendonça França*
 
-    ```
-    ActiveRecord::Base.connected_to(database: :slow_replica) do
-      SlowReplicaModel.first # if the db config has a slow_replica configuration this will be used to do the lookup, otherwise this will throw an exception
-    end
-    ```
+*   Add `row_count` field to `sql.active_record` notification.
 
-    *Eileen M. Uchitelle*
+    This field returns the amount of rows returned by the query that emitted the notification.
 
-*   Enum raises on invalid definition values
+    This metric is useful in cases where one wants to detect queries with big result sets.
 
-    When defining a Hash enum it can be easy to use `[]` instead of `{}`. This
-    commit checks that only valid definition values are provided, those can
-    be a Hash, an array of Symbols or an array of Strings. Otherwise it
-    raises an `ArgumentError`.
+    *Marvin Bitterlich*
 
-    Fixes #33961
+*   Consistently raise an `ArgumentError` when passing an invalid argument to a nested attributes association writer.
 
-    *Alberto Almagro*
+    Previously, this would only raise on collection associations and produce a generic error on singular associations.
 
-*   Reloading associations now clears the Query Cache like `Persistence#reload` does.
+    Now, it will raise on both collection and singular associations.
 
-    ```
-    class Post < ActiveRecord::Base
-      has_one :category
-      belongs_to :author
-      has_many :comments
-    end
+    *Joshua Young*
 
-    # Each of the following will now clear the query cache.
-    post.reload_category
-    post.reload_author
-    post.comments.reload
-    ```
+*   Fix single quote escapes on default generated MySQL columns.
 
-    *Christophe Maximin*
+    MySQL 5.7.5+ supports generated columns, which can be used to create a column that is computed from an expression.
 
-*   Added `index` option for `change_table` migration helpers.
-    With this change you can create indexes while adding new
-    columns into the existing tables.
+    Previously, the schema dump would output a string with double escapes for generated columns with single quotes in the default expression.
 
-    Example:
+    This would result in issues when importing the schema on a fresh instance of a MySQL database.
 
-        change_table(:languages) do |t|
-          t.string :country_code, index: true
-        end
-
-    *Mehmet Emin İNAÇ*
+    Now, the string will not be escaped and will be valid Ruby upon importing of the schema.
 
-*   Fix `transaction` reverting for migrations.
+    *Yash Kapadia*
 
-    Before: Commands inside a `transaction` in a reverted migration ran uninverted.
-    Now: This change fixes that by reverting commands inside `transaction` block.
+*   Fix Migrations with versions older than 7.1 validating options given to
+    `add_reference` and `t.references`.
 
-    *fatkodima*, *David Verhasselt*
+    *Hartley McGuire*
 
-*   Raise an error instead of scanning the filesystem root when `fixture_path` is blank.
+*   Add `<role>_types` class method to `ActiveRecord::DelegatedType` so that the delegated types can be introspected.
 
-    *Gannon McGibbon*, *Max Albrecht*
+    *JP Rosevear*
 
-*   Allow `ActiveRecord::Base.configurations=` to be set with a symbolized hash.
+*   Make `schema_dump`, `query_cache`, `replica` and `database_tasks` configurable via `DATABASE_URL`.
 
-    *Gannon McGibbon*
+    This wouldn't always work previously because boolean values would be interpreted as strings.
 
-*   Don't update counter cache unless the record is actually saved.
+    e.g. `DATABASE_URL=postgres://localhost/foo?schema_dump=false` now properly disable dumping the schema
+    cache.
 
-    Fixes #31493, #33113, #33117.
+    *Mike Coutermarsh*, *Jean Boussier*
 
-    *Ryuta Kamizono*
+*   Introduce `ActiveRecord::Transactions::ClassMethods#set_callback`.
 
-*   Deprecate `ActiveRecord::Result#to_hash` in favor of `ActiveRecord::Result#to_a`.
+     It is identical to `ActiveSupport::Callbacks::ClassMethods#set_callback`
+     but with support for `after_commit` and `after_rollback` callback options.
 
-    *Gannon McGibbon*, *Kevin Cheng*
+    *Joshua Young*
 
-*   SQLite3 adapter supports expression indexes.
+*   Make `ActiveRecord::Encryption::Encryptor` agnostic of the serialization format used for encrypted data.
 
-    ```
-    create_table :users do |t|
-      t.string :email
-    end
+    Previously, the encryptor instance only allowed an encrypted value serialized as a `String` to be passed to the message serializer.
 
-    add_index :users, 'lower(email)', name: 'index_users_on_email', unique: true
-    ```
+    Now, the encryptor lets the configured `message_serializer` decide which types of serialized encrypted values are supported. A custom serialiser is therefore allowed to serialize `ActiveRecord::Encryption::Message` objects using a type other than `String`.
 
-    *Gray Kemmey*
+    The default `ActiveRecord::Encryption::MessageSerializer` already ensures that only `String` objects are passed for deserialization.
 
-*   Allow subclasses to redefine autosave callbacks for associated records.
+    *Maxime Réty*
 
-    Fixes #33305.
+*   Fix `encrypted_attribute?` to take into account context properties passed to `encrypts`.
 
-    *Andrey Subbota*
+    *Maxime Réty*
 
-*   Bump minimum MySQL version to 5.5.8.
+*   The object returned by `explain` now responds to `pluck`, `first`,
+    `last`, `average`, `count`, `maximum`, `minimum`, and `sum`. Those
+    new methods run `EXPLAIN` on the corresponding queries:
 
-    *Yasuo Honda*
+    ```ruby
+    User.all.explain.count
+    # EXPLAIN SELECT COUNT(*) FROM `users`
+    # ...
 
-*   Use MySQL utf8mb4 character set by default.
+    User.all.explain.maximum(:id)
+    # EXPLAIN SELECT MAX(`users`.`id`) FROM `users`
+    # ...
+    ```
 
-    `utf8mb4` character set with 4-Byte encoding supports supplementary characters including emoji.
-    The previous default 3-Byte encoding character set `utf8` is not enough to support them.
+    *Petrik de Heus*
 
-    *Yasuo Honda*
+*   Fixes an issue where `validates_associated` `:on`  option wasn't respected
+    when validating associated records.
 
-*   Fix duplicated record creation when using nested attributes with `create_with`.
+    *Austen Madden*, *Alex Ghiculescu*, *Rafał Brize*
 
-    *Darwin Wu*
+*   Allow overriding SQLite defaults from `database.yml`.
 
-*   Configuration item `config.filter_parameters` could also filter out
-    sensitive values of database columns when calling `#inspect`.
-    We also added `ActiveRecord::Base::filter_attributes`/`=` in order to
-    specify sensitive attributes to specific model.
+    Any PRAGMA configuration set under the `pragmas` key in the configuration
+    file takes precedence over Rails' defaults, and additional PRAGMAs can be
+    set as well.
 
-    ```
-    Rails.application.config.filter_parameters += [:credit_card_number, /phone/]
-    Account.last.inspect # => #<Account id: 123, name: "DHH", credit_card_number: [FILTERED], telephone_number: [FILTERED] ...>
-    SecureAccount.filter_attributes += [:name]
-    SecureAccount.last.inspect # => #<SecureAccount id: 42, name: [FILTERED], credit_card_number: [FILTERED] ...>
+    ```yaml
+    database: storage/development.sqlite3
+    timeout: 5000
+    pragmas:
+      journal_mode: off
+      temp_store: memory
     ```
 
-    *Zhang Kang*, *Yoshiyuki Kinjo*
+    *Stephen Margheim*
 
-*   Deprecate `column_name_length`, `table_name_length`, `columns_per_table`,
-    `indexes_per_table`, `columns_per_multicolumn_index`, `sql_query_length`,
-    and `joins_per_query` methods in `DatabaseLimits`.
+*   Remove warning message when running SQLite in production, but leave it unconfigured.
 
-    *Ryuta Kamizono*
+    There are valid use cases for running SQLite in production. However, it must be done
+    with care, so instead of a warning most users won't see anyway, it's preferable to
+    leave the configuration commented out to force them to think about having the database
+    on a persistent volume etc.
 
-*   `ActiveRecord::Base.configurations` now returns an object.
+    *Jacopo Beschi*, *Jean Boussier*
 
-    `ActiveRecord::Base.configurations` used to return a hash, but this
-    is an inflexible data model. In order to improve multiple-database
-    handling in Rails, we've changed this to return an object. Some methods
-    are provided to make the object behave hash-like in order to ease the
-    transition process. Since most applications don't manipulate the hash
-    we've decided to add backwards-compatible functionality that will throw
-    a deprecation warning if used, however calling `ActiveRecord::Base.configurations`
-    will use the new version internally and externally.
+*   Add support for generated columns to the SQLite3 adapter.
 
-    For example, the following `database.yml`:
+    Generated columns (both stored and dynamic) are supported since version 3.31.0 of SQLite.
+    This adds support for those to the SQLite3 adapter.
 
-    ```
-    development:
-      adapter: sqlite3
-      database: db/development.sqlite3
+    ```ruby
+    create_table :users do |t|
+      t.string :name
+      t.virtual :name_upper, type: :string, as: 'UPPER(name)'
+      t.virtual :name_lower, type: :string, as: 'LOWER(name)', stored: true
+    end
     ```
 
-    Used to become a hash:
+    *Stephen Margheim*
 
-    ```
-    { "development" => { "adapter" => "sqlite3", "database" => "db/development.sqlite3" } }
-    ```
+*   TrilogyAdapter: ignore `host` if `socket` parameter is set.
 
-    Is now converted into the following object:
+    This allows to configure a connection on a UNIX socket via `DATABASE_URL`:
 
     ```
-    #<ActiveRecord::DatabaseConfigurations:0x00007fd1acbdf800 @configurations=[
-      #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10 @env_name="development",
-        @spec_name="primary", @config={"adapter"=>"sqlite3", "database"=>"db/development.sqlite3"}>
-      ]
+    DATABASE_URL=trilogy://does-not-matter/my_db_production?socket=/var/run/mysql.sock
     ```
 
-    Iterating over the database configurations has also changed. Instead of
-    calling hash methods on the `configurations` hash directly, a new method `configs_for` has
-    been provided that allows you to select the correct configuration. `env_name` and
-    `spec_name` arguments are optional. For example, these return an array of
-    database config objects for the requested environment and a single database config object
-    will be returned for the requested environment and specification name respectively.
+    *Jean Boussier*
 
-    ```
-    ActiveRecord::Base.configurations.configs_for(env_name: "development")
-    ActiveRecord::Base.configurations.configs_for(env_name: "development", spec_name: "primary")
-    ```
+*   Make `assert_queries_count`, `assert_no_queries`, `assert_queries_match`, and
+    `assert_no_queries_match` assertions public.
 
-    *Eileen M. Uchitelle*, *Aaron Patterson*
+    To assert the expected number of queries are made, Rails internally uses `assert_queries_count` and
+    `assert_no_queries`. To assert that specific SQL queries are made, `assert_queries_match` and
+    `assert_no_queries_match` are used. These assertions can now be used in applications as well.
 
-*   Add database configuration to disable advisory locks.
+    ```ruby
+    class ArticleTest < ActiveSupport::TestCase
+      test "queries are made" do
+        assert_queries_count(1) { Article.first }
+      end
 
+      test "creates a foreign key" do
+        assert_queries_match(/ADD FOREIGN KEY/i, include_schema: true) do
+          @connection.add_foreign_key(:comments, :posts)
+        end
+      end
+    end
     ```
-    production:
-      adapter: postgresql
-      advisory_locks: false
-    ```
-
-    *Guo Xiang*
 
-*   SQLite3 adapter `alter_table` method restores foreign keys.
+    *Petrik de Heus*, *fatkodima*
 
-    *Yasuo Honda*
+*   Fix `has_secure_token` calls the setter method on initialize.
 
-*   Allow `:to_table` option to `invert_remove_foreign_key`.
+    *Abeid Ahmed*
 
-    Example:
+*   When using a `DATABASE_URL`, allow for a configuration to map the protocol in the URL to a specific database
+    adapter. This allows decoupling the adapter the application chooses to use from the database connection details
+    set in the deployment environment.
 
-       remove_foreign_key :accounts, to_table: :owners
+    ```ruby
+    # ENV['DATABASE_URL'] = "mysql://localhost/example_database"
+    config.active_record.protocol_adapters.mysql = "trilogy"
+    # will connect to MySQL using the trilogy adapter
+    ```
 
-    *Nikolay Epifanov*, *Rich Chen*
+    *Jean Boussier*, *Kevin McPhillips*
 
-*   Add environment & load_config dependency to `bin/rake db:seed` to enable
-    seed load in environments without Rails and custom DB configuration
+*   In cases where MySQL returns `warning_count` greater than zero, but returns no warnings when
+    the `SHOW WARNINGS` query is executed, `ActiveRecord.db_warnings_action` proc will still be
+    called with a generic warning message rather than silently ignoring the warning(s).
 
-    *Tobias Bielohlawek*
+    *Kevin McPhillips*
 
-*   Fix default value for mysql time types with specified precision.
+*   `DatabaseConfigurations#configs_for` accepts a symbol in the `name` parameter.
 
-    *Nikolay Kondratyev*
+    *Andrew Novoselac*
 
-*   Fix `touch` option to behave consistently with `Persistence#touch` method.
+*   Fix `where(field: values)` queries when `field` is a serialized attribute
+    (for example, when `field` uses `ActiveRecord::Base.serialize` or is a JSON
+    column).
 
-    *Ryuta Kamizono*
+    *João Alves*
 
-*   Migrations raise when duplicate column definition.
+*   Make the output of `ActiveRecord::Core#inspect` configurable.
 
-    Fixes #33024.
+    By default, calling `inspect` on a record will yield a formatted string including just the `id`.
 
-    *Federico Martinez*
+    ```ruby
+    Post.first.inspect #=> "#<Post id: 1>"
+    ```
 
-*   Bump minimum SQLite version to 3.8
+    The attributes to be included in the output of `inspect` can be configured with
+    `ActiveRecord::Core#attributes_for_inspect`.
 
-    *Yasuo Honda*
+    ```ruby
+    Post.attributes_for_inspect = [:id, :title]
+    Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!">"
+    ```
 
-*   Fix parent record should not get saved with duplicate children records.
+    With `attributes_for_inspect` set to `:all`, `inspect` will list all the record's attributes.
 
-    Fixes #32940.
+    ```ruby
+    Post.attributes_for_inspect = :all
+    Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+    ```
 
-    *Santosh Wadghule*
+    In `development` and `test` mode, `attributes_for_inspect` will be set to `:all` by default.
 
-*   Fix logic on disabling commit callbacks so they are not called unexpectedly when errors occur.
+    You can also call `full_inspect` to get an inspection with all the attributes.
 
-    *Brian Durand*
+    The attributes in `attribute_for_inspect` will also be used for `pretty_print`.
 
-*   Ensure `Associations::CollectionAssociation#size` and `Associations::CollectionAssociation#empty?`
-    use loaded association ids if present.
+    *Andrew Novoselac*
 
-    *Graham Turner*
+*   Don't mark attributes as changed when reassigned to `Float::INFINITY` or
+    `-Float::INFINITY`.
 
-*   Add support to preload associations of polymorphic associations when not all the records have the requested associations.
+    *Maicol Bentancor*
 
-    *Dana Sherson*
+*   Support the `RETURNING` clause for MariaDB.
 
-*   Add `touch_all` method to `ActiveRecord::Relation`.
+    *fatkodima*, *Nikolay Kondratyev*
 
-    Example:
+*   The SQLite3 adapter now implements the `supports_deferrable_constraints?` contract.
 
-        Person.where(name: "David").touch_all(time: Time.new(2020, 5, 16, 0, 0, 0))
+    Allows foreign keys to be deferred by adding the `:deferrable` key to the `foreign_key` options.
 
-    *fatkodima*, *duggiefresh*
+    ```ruby
+    add_reference :person, :alias, foreign_key: { deferrable: :deferred }
+    add_reference :alias, :person, foreign_key: { deferrable: :deferred }
+    ```
 
-*   Add `ActiveRecord::Base.base_class?` predicate.
+    *Stephen Margheim*
 
-    *Bogdan Gusiev*
+*   Add the `set_constraints` helper to PostgreSQL connections.
 
-*   Add custom prefix/suffix options to `ActiveRecord::Store.store_accessor`.
+    ```ruby
+    Post.create!(user_id: -1) # => ActiveRecord::InvalidForeignKey
+
+    Post.transaction do
+      Post.connection.set_constraints(:deferred)
+      p = Post.create!(user_id: -1)
+      u = User.create!
+      p.user = u
+      p.save!
+    end
+    ```
 
-    *Tan Huynh*, *Yukio Mizuta*
+    *Cody Cutrer*
 
-*   Rails 6 requires Ruby 2.5.0 or newer.
+*   Include `ActiveModel::API` in `ActiveRecord::Base`.
 
-    *Jeremy Daer*, *Kasper Timm Hansen*
+    *Sean Doyle*
 
-*   Deprecate `update_attributes`/`!` in favor of `update`/`!`.
+*   Ensure `#signed_id` outputs `url_safe` strings.
 
-    *Eddie Lebow*
+    *Jason Meller*
 
-*   Add `ActiveRecord::Base.create_or_find_by`/`!` to deal with the SELECT/INSERT race condition in
-    `ActiveRecord::Base.find_or_create_by`/`!` by leaning on unique constraints in the database.
+*   Add `nulls_last` and working `desc.nulls_first` for MySQL.
 
-    *DHH*
+    *Tristan Fellows*
 
-*   Add `Relation#pick` as short-hand for single-value plucks.
+*   Allow for more complex hash arguments for `order` which mimics `where` in `ActiveRecord::Relation`.
 
-    *DHH*
+    ```ruby
+    Topic.includes(:posts).order(posts: { created_at: :desc })
+    ```
 
+    *Myles Boone*
 
-Please check [5-2-stable](https://github.com/rails/rails/blob/5-2-stable/activerecord/CHANGELOG.md) for previous changes.
+Please check [7-1-stable](https://github.com/rails/rails/blob/7-1-stable/activerecord/CHANGELOG.md) for previous changes.