activerecord 6.1.7 → 7.0.8

data/CHANGELOG.md

@@ -1,1767 +1,2376 @@
-## Rails 6.1.7 (September 09, 2022) ##
+## Rails 7.0.8 (September 09, 2023) ##
 
-*   Symbol is allowed by default for YAML columns
+*   Fix `change_column` not setting `precision: 6` on `datetime` columns when
+    using 7.0+ Migrations and SQLite.
 
-    *Étienne Barrié*
+    *Hartley McGuire*
 
-*   Fix `ActiveRecord::Store` to serialize as a regular Hash
+*   Fix unscope is not working in specific case
 
-    Previously it would serialize as an `ActiveSupport::HashWithIndifferentAccess`
-    which is wasteful and cause problem with YAML safe_load.
+    Before:
+    ```ruby
+    Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts` WHERE `posts`.`id` >= 1 AND `posts`.`id` < 3"
 
-    *Jean Boussier*
+    ```
 
-*   Fix PG.connect keyword arguments deprecation warning on ruby 2.7
+    After:
+    ```ruby
+    Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts`"
+    ```
 
-    Fixes #44307.
+    Fixes #48094.
 
-    *Nikita Vasilevsky*
+    *Kazuya Hatanaka*
 
-## Rails 6.1.6.1 (July 12, 2022) ##
+*   Fix associations to a STI model including a `class_name` parameter
 
-*   Change ActiveRecord::Coders::YAMLColumn default to safe_load
+    ```ruby
+    class Product < ApplicationRecord
+      has_many :requests, as: :requestable, class_name: "ProductRequest", dependent: :destroy
+    end
 
-    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:
-    
+    # STI tables
+    class Request < ApplicationRecord
+      belongs_to :requestable, polymorphic: true
+
+      validate :request_type, presence: true
+    end
+
+    class ProductRequest < Request
+      belongs_to :user
+    end
     ```
-    config.active_record.yaml_column_permitted_classes = [Symbol, Date, Time]
+
+    Accessing such association would lead to:
+
+    ```
+    table_metadata.rb:22:in `has_column?': undefined method `key?' for nil:NilClass (NoMethodError)
     ```
 
-    [CVE-2022-32224]
+    *Romain Filinto*
+
+*   Fix `change_table` setting datetime precision for 6.1 Migrations
+
+    *Hartley McGuire*
 
+*   Fix change_column setting datetime precision for 6.1 Migrations
 
-## Rails 6.1.6 (May 09, 2022) ##
+    *Hartley McGuire*
+
+## Rails 7.0.7.2 (August 22, 2023) ##
 
 *   No changes.
 
 
-## Rails 6.1.5.1 (April 26, 2022) ##
+## Rails 7.0.7.1 (August 22, 2023) ##
 
 *   No changes.
 
 
-## Rails 6.1.5 (March 09, 2022) ##
+## Rails 7.0.7 (August 09, 2023) ##
 
-*   Fix `ActiveRecord::ConnectionAdapters::SchemaCache#deep_deduplicate` for Ruby 2.6.
+*   Restores functionality to the missing method when using enums and fixes.
 
-    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.
+    *paulreece*
 
-    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.
+*   Fix `StatementCache::Substitute` with serialized type.
 
-    Fixes #43056
+    *ywenc*
 
-    *Eric O'Hanlon*
+*   Fix `:db_runtime` on notification payload when application have multiple databases.
 
-*   Fix migration compatibility to create SQLite references/belongs_to column as integer when
-    migration version is 6.0.
+    *Eileen M. Uchitelle*
 
-    `reference`/`belongs_to` in migrations with version 6.0 were creating columns as
-    bigint instead of integer for the SQLite Adapter.
+*   Correctly dump check constraints for MySQL 8.0.16+.
 
-    *Marcelo Lauxen*
+    *Steve Hill*
 
-*   Fix dbconsole for 3-tier config.
+*   Fix `ActiveRecord::QueryMethods#in_order_of` to include `nil`s, to match the
+    behavior of `Enumerable#in_order_of`.
 
-    *Eileen M. Uchitelle*
+    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"])`.
 
-*   Better handle SQL queries with invalid encoding.
+    *fatkodima*
 
-    ```ruby
-    Post.create(name: "broken \xC8 UTF-8")
-    ```
+*   Revert "Fix autosave associations with validations added on `:base` of the associated objects."
 
-    Would cause all adapters to fail in a non controlled way in the code
-    responsible to detect write queries.
+    This change intended to remove the :base attribute from the message,
+    but broke many assumptions which key these errors were stored.
 
-    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.
+    *zzak*
+
+*   Fix `#previously_new_record?` to return true for destroyed records.
+
+    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*
+
+*   Revert breaking changes to `has_one` relationship deleting the old record before the new one is validated.
+
+    *zzak*
+
+*   Fix support for Active Record instances being uses in queries.
+
+    As of `7.0.5`, query arguments were deep duped to avoid mutations impacting
+    the query cache, but this had the adverse effect to clearing the primary key when
+    the query argument contained an `ActiveRecord::Base` instance.
+
+    This broke the `noticed` gem.
 
     *Jean Boussier*
 
-*   Ignore persisted in-memory records when merging target lists.
 
-    *Kevin Sjöberg*
+## Rails 7.0.6 (June 29, 2023) ##
 
-*   Fix regression bug that caused ignoring additional conditions for preloading
-    `has_many` through relations.
+*   Fix autosave associations with validations added on `:base` of the associated objects.
 
-    Fixes #43132
+    *fatkodima*
 
-    *Alexander Pauly*
+*   Fix result with anonymous PostgreSQL columns of different type from json.
 
-*   Fix `ActiveRecord::InternalMetadata` to not be broken by
-    `config.active_record.record_timestamps = false`
+    *Oleksandr Avoiants*
 
-    Since the model always create the timestamp columns, it has to set them, otherwise it breaks
-    various DB management tasks.
+*   Preserve timestamp when setting an `ActiveSupport::TimeWithZone` value to `timestamptz` attribute.
 
-    Fixes #42983
+    *fatkodima*
+
+*   Fix assignment into an `has_one` relationship deleting the old record before the new one is validated.
 
     *Jean Boussier*
 
-*   Fix duplicate active record objects on `inverse_of`.
+*   Fix where on association with has_one/has_many polymorphic relations.
+
+    Before:
+    ```ruby
+    Treasure.where(price_estimates: PriceEstimate.all)
+    #=> SELECT (...) WHERE "treasures"."id" IN (SELECT "price_estimates"."estimate_of_id" FROM "price_estimates")
+    ```
+
+    Later:
+    ```ruby
+    Treasure.where(price_estimates: PriceEstimate.all)
+    #=> SELECT (...) WHERE "treasures"."id" IN (SELECT "price_estimates"."estimate_of_id" FROM "price_estimates" WHERE "price_estimates"."estimate_of_type" = 'Treasure')
+    ```
+
+    *Lázaro Nixon*
+
+*   Fix decrementing counter caches on optimistically locked record deletion
+
+    *fatkodima*
+
+*   Ensure binary-destined values have binary encoding during type cast.
+
+    *Matthew Draper*
+
+*   Preserve existing column default functions when altering table in SQLite.
+
+    *fatkodima*
+
+*   Remove table alias added when using `where.missing` or `where.associated`.
 
-    *Justin Carvalho*
+    *fatkodima*
+
+*   Fix `Enumerable#in_order_of` to only flatten first level to preserve nesting.
+
+    *Miha Rekar*
+
+
+## Rails 7.0.5.1 (June 26, 2023) ##
+
+*   No changes.
+
+## Rails 7.0.5 (May 24, 2023) ##
+
+*   Type cast `#attribute_changed?` `:from` and `:to` options.
+
+    *Andrew Novoselac*
+
+*   Fix `index_exists?` when column is an array.
 
-*   Fix duplicate objects stored in has many association after save.
+    *Eileen M. Uchitelle*
 
-    Fixes #42549.
+*   Handle `Date` objects for PostgreSQL `timestamptz` columns.
 
     *Alex Ghiculescu*
 
-*   Fix performance regression in `CollectionAssocation#build`.
+*   Fix collation for changing column to non-string.
+
+    *Hartley McGuire*
+
+*   Map through subtype in `PostgreSQL::OID::Array`.
+
+    *Jonathan Hefner*
+
+*   Store correct environment in `internal_metadata` when run rails `db:prepare`.
+
+    *fatkodima*
+
+*   Make sure `ActiveRecord::Relation#sum` works with objects that implement `#coerce` without deprecation.
 
     *Alex Ghiculescu*
 
-*   Fix retrieving default value for text column for MariaDB.
+*   Fix retrieving foreign keys referencing tables named like keywords in PostgreSQL and MySQL.
 
     *fatkodima*
 
+*   Support UUIDs in Disable Joins.
 
-## Rails 6.1.4.7 (March 08, 2022) ##
+    *Samuel Cochran*
 
-*   No changes.
+*   Fix Active Record's explain for queries starting with comments.
 
+    *fatkodima*
 
-## Rails 6.1.4.6 (February 11, 2022) ##
+*   Fix incorrectly preloading through association records when middle association has been loaded.
 
-*   No changes.
+    *Joshua Young*
 
+*   Fix where.missing and where.associated for parent/child associations.
 
-## Rails 6.1.4.5 (February 11, 2022) ##
+    *fatkodima*
 
-*   No changes.
+*   Fix Enumerable#in_order_of to preserve duplicates.
 
+    *fatkodima*
 
-## Rails 6.1.4.4 (December 15, 2021) ##
+*   Fix autoincrement on primary key for mysql.
 
-*   No changes.
+    *Eileen M. Uchitelle*
 
+*   Restore ability to redefine column in `create_table` for Rails 5.2 migrations.
 
-## Rails 6.1.4.3 (December 14, 2021) ##
+    *fatkodima*
 
-*   No changes.
+*   Fix schema cache dumping of virtual columns.
+
+    *fatkodima*
+
+*   Fix Active Record grouped calculations on joined tables on column present in both tables.
+
+    *fatkodima*
+
+*   Fix mutation detection for serialized attributes backed by binary columns.
+
+    *Jean Boussier*
+
+*   Fix a bug where using groups and counts with long table names would return incorrect results.
+
+    *Shota Toguchi*, *Yusaku Ono*
+
+*   Fix erroneous nil default precision on virtual datetime columns.
+
+    Prior to this change, virtual datetime columns did not have the same
+    default precision as regular datetime columns, resulting in the following
+    being erroneously equivalent:
+
+        t.virtual :name, type: datetime,                 as: "expression"
+        t.virtual :name, type: datetime, precision: nil, as: "expression"
+
+    This change fixes the default precision lookup, so virtual and regular
+    datetime column default precisions match.
+
+    *Sam Bostock*
 
+*   Fix a case where the query cache can return wrong values. See #46044
 
-## Rails 6.1.4.2 (December 14, 2021) ##
+    *Aaron Patterson*
+
+
+## Rails 7.0.4.3 (March 13, 2023) ##
 
 *   No changes.
 
 
-## Rails 6.1.4.1 (August 19, 2021) ##
+## Rails 7.0.4.2 (January 24, 2023) ##
 
 *   No changes.
 
 
-## Rails 6.1.4 (June 24, 2021) ##
+## Rails 7.0.4.1 (January 17, 2023) ##
 
-*   Do not try to rollback transactions that failed due to a `ActiveRecord::TransactionRollbackError`.
+*   Make sanitize_as_sql_comment more strict
 
-    *Jamie McCarthy*
+    Though this method was likely never meant to take user input, it was
+    attempting sanitization. That sanitization could be bypassed with
+    carefully crafted input.
 
-*   Raise an error if `pool_config` is `nil` in `set_pool_config`.
+    This commit makes the sanitization more robust by replacing any
+    occurrences of "/*" or "*/" with "/ *" or "* /". It also performs a
+    first pass to remove one surrounding comment to avoid compatibility
+    issues for users relying on the existing removal.
 
-    *Eileen M. Uchitelle*
+    This also clarifies in the documentation of annotate that it should not
+    be provided user input.
 
-*   Fix compatibility with `psych >= 4`.
+    [CVE-2023-22794]
 
-    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.
+*   Added integer width check to PostgreSQL::Quoting
+
+    Given a value outside the range for a 64bit signed integer type
+    PostgreSQL will treat the column type as numeric. Comparing
+    integer values against numeric values can result in a slow
+    sequential scan.
+
+    This behavior is configurable via
+    ActiveRecord::Base.raise_int_wider_than_64bit which defaults to true.
+
+    [CVE-2022-44566]
+
+
+## Rails 7.0.4 (September 09, 2022) ##
+
+*   Symbol is allowed by default for YAML columns
+
+    *É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.
 
     *Jean Boussier*
 
-*   Support using replicas when using `rails dbconsole`.
+*   Add `timestamptz` as a time zone aware type for PostgreSQL
 
-    *Christopher Thornton*
+    This is required for correctly parsing `timestamp with time zone` values in your database.
 
-*   Restore connection pools after transactional tests.
+    If you don't want this, you can opt out by adding this initializer:
 
-    *Eugene Kenny*
+    ```ruby
+    ActiveRecord::Base.time_zone_aware_types -= [:timestamptz]
+    ```
 
-*   Change `upsert_all` to fails cleanly for MySQL when `:unique_by` is used.
+    *Alex Ghiculescu*
 
-    *Bastian Bartmann*
+*   Fix supporting timezone awareness for `tsrange` and `tstzrange` array columns.
 
-*   Fix user-defined `self.default_scope` to respect table alias.
+    ```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])
+    ```
 
-    *Ryuta Kamizono*
+    *Wojciech Wnętrzak*
 
-*   Clear `@cache_keys` cache after `update_all`, `delete_all`, `destroy_all`.
+*   Resolve issue where a relation cache_version could be left stale.
 
-    *Ryuta Kamizono*
+    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.
 
-*   Changed Arel predications `contains` and `overlaps` to use
-    `quoted_node` so that PostgreSQL arrays are quoted properly.
+    Usage:
 
-    *Bradley Priest*
+    ```ruby
+    developers = Developer.all
+    developers.cache_version
 
-*   Fix `merge` when the `where` clauses have string contents.
+    Developer.update_all(updated_at: Time.now.utc + 1.second)
 
-    *Ryuta Kamizono*
+    developers.cache_version # Stale cache_version
+    developers.reset
+    developers.cache_version # Returns the current correct cache_version
+    ```
 
-*   Fix rollback of parent destruction with nested `dependent: :destroy`.
+    Fixes #45341.
 
-    *Jacopo Beschi*
+    *Austen Madden*
+
+*   Fix `load_async` when called on an association proxy.
 
-*   Fix binds logging for `"WHERE ... IN ..."` statements.
+    Calling `load_async` directly an association would schedule
+    a query but never use it.
 
-    *Ricardo Díaz*
+    ```ruby
+    comments = post.comments.load_async # schedule a query
+    comments.to_a # perform an entirely new sync query
+    ```
+
+    Now it does use the async query, however note that it doesn't
+    cause the association to be loaded.
+
+    *Jean Boussier*
 
-*   Handle `false` in relation strict loading checks.
+*   Fix eager loading for models without primary keys.
 
-    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.
+    *Anmol Chopra*, *Matt Lawrence*, and *Jonathan Hefner*
 
+*   `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
     ```
-    class Dog < ActiveRecord::Base
-      self.strict_loading_by_default = true
 
-      has_many :treats, strict_loading: false
-    end
+    *Alex Ghiculescu*
+
+*   Fix Hstore deserialize regression.
+
+    *edsharp*
+
+
+## Rails 7.0.3.1 (July 12, 2022) ##
+
+*   Change ActiveRecord::Coders::YAMLColumn default to safe_load
+
+    This adds two new configuration options The configuration options are as
+    follows:
+
+    * `config.active_record.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]
     ```
 
-    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.
+    [CVE-2022-32224]
 
-    *Eileen M. Uchitelle*, *Radamés Roriz*
 
-*   Fix numericality validator without precision.
+## Rails 7.0.3 (May 09, 2022) ##
 
-    *Ryuta Kamizono*
+*   Some internal housekeeping on reloads could break custom `respond_to?`
+    methods in class objects that referenced reloadable constants. See
+    [#44125](https://github.com/rails/rails/issues/44125) for details.
 
-*   Fix aggregate attribute on Enum types.
+    *Xavier Noria*
 
-    *Ryuta Kamizono*
+*   Fixed MariaDB default function support.
 
-*   Fix `CREATE INDEX` statement generation for PostgreSQL.
+    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.
 
-    *eltongo*
+    *kaspernj*
 
-*   Fix where clause on enum attribute when providing array of strings.
+*   Fix `remove_foreign_key` with `:if_exists` option when foreign key actually exists.
 
-    *Ryuta Kamizono*
+    *fatkodima*
 
-*   Fix `unprepared_statement` to work it when nesting.
+*   Remove `--no-comments` flag in structure dumps for PostgreSQL
 
-    *Ryuta Kamizono*
+    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*
+
+*   Use the model name as a prefix when filtering encrypted attributes from logs.
+
+    For example, when encrypting `Person#name` it will add `person.name` as a filter
+    parameter, instead of just `name`. This prevents unintended filtering of parameters
+    with a matching name in other models.
+
+    *Jorge Manrubia*
 
+*   Fix quoting of `ActiveSupport::Duration` and `Rational` numbers in the MySQL adapter.
 
-## Rails 6.1.3.2 (May 05, 2021) ##
+    *Kevin McPhillips*
+
+*   Fix `change_column_comment` to preserve column's AUTO_INCREMENT in the MySQL adapter
+
+    *fatkodima*
+
+## Rails 7.0.2.4 (April 26, 2022) ##
+
+*   No changes.
+
+
+## Rails 7.0.2.3 (March 08, 2022) ##
+
+*   No changes.
+
+
+## Rails 7.0.2.2 (February 11, 2022) ##
 
 *   No changes.
 
 
-## Rails 6.1.3.1 (March 26, 2021) ##
+## Rails 7.0.2.1 (February 11, 2022) ##
 
 *   No changes.
 
 
-## Rails 6.1.3 (February 17, 2021) ##
+## Rails 7.0.2 (February 08, 2022) ##
+
+*   Fix `PG.connect` keyword arguments deprecation warning on ruby 2.7.
+
+    *Nikita Vasilevsky*
+
+*   Fix the ability to exclude encryption params from being autofiltered.
+
+    *Mark Gangl*
 
-*   Fix the MySQL adapter to always set the right collation and charset
-    to the connection session.
+*   Dump the precision for datetime columns following the new defaults.
 
     *Rafael Mendonça França*
 
-*   Fix MySQL adapter handling of time objects when prepared statements
-    are enabled.
+*   Make sure encrypted attributes are not being filtered twice.
+
+    *Nikita Vasilevsky*
+
+*   Dump the database schema containing the current Rails version.
+
+    Since https://github.com/rails/rails/pull/42297, Rails now generate datetime columns
+    with a default precision of 6. This means that users upgrading to Rails 7.0 from 6.1,
+    when loading the database schema, would get the new precision value, which would not match
+    the production schema.
+
+    To avoid this the schema dumper will generate the new format which will include the Rails
+    version and will look like this:
+
+    ```
+    ActiveRecord::Schema[7.0].define
+    ```
+
+    When upgrading from Rails 6.1 to Rails 7.0, you can run the `rails app:update` task that will
+    set the current schema version to 6.1.
 
     *Rafael Mendonça França*
 
-*   Fix scoping in enum fields using conditions that would generate
-    an `IN` clause.
+*   Fix parsing expression for PostgreSQL generated column.
 
-    *Ryuta Kamizono*
+    *fatkodima*
 
-*   Skip optimised #exist? query when #include? is called on a relation
-    with a having clause
+*   Fix `Mysql2::Error: Commands out of sync; you can't run this command now`
+    when bulk-inserting fixtures that exceed `max_allowed_packet` configuration.
 
-    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.
+    *Nikita Vasilevsky*
+
+*   Fix error when saving an association with a relation named `record`.
+
+    *Dorian Marié*
+
+*   Fix `MySQL::SchemaDumper` behavior about datetime precision value.
+
+    *y0t4*
+
+*   Improve associated with no reflection error.
 
-    An sample query affected by this problem:
+    *Nikolai*
+
+*   Fix PG.connect keyword arguments deprecation warning on ruby 2.7.
+
+    Fixes #44307.
+
+    *Nikita Vasilevsky*
+
+*   Fix passing options to `check_constraint` from `change_table`.
+
+    *Frederick Cheung*
+
+
+## Rails 7.0.1 (January 06, 2022) ##
+
+
+*   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
-    Author.select('COUNT(*) as total_posts', 'authors.*')
-          .joins(:posts)
-          .group(:id)
-          .having('total_posts > 2')
-          .include?(Author.first)
+    add_index(:settings, "(data->'property')", using: :gin, name: :index_settings_data_property)
     ```
 
-    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 #43331.
 
-    Fixes #41417
+    *Oliver Günther*
 
-    *Michael Smart*
+*   Better error messages when association name is invalid in the argument of `ActiveRecord::QueryMethods::WhereChain#missing`.
 
-*   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.
+    *ykpythemind*
 
-    *wbharding*, *Martin Tepper*
+*   Fix ordered migrations for single db in multi db environment.
 
+    *Himanshu*
 
-## Rails 6.1.2.1 (February 10, 2021) ##
+*   Extract `on update CURRENT_TIMESTAMP` for mysql2 adapter.
 
-*   Fix possible DoS vector in PostgreSQL money type
+    *Kazuhiro Masuda*
 
-    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.
+*   Fix incorrect argument in PostgreSQL structure dump tasks.
 
-    Thanks to @dee-see from Hackerone for this patch!
+    Updating the `--no-comment` argument added in Rails 7 to the correct `--no-comments` argument.
 
-    [CVE-2021-22880]
+    *Alex Dent*
 
-    *Aaron Patterson*
+*   Fix schema dumping column default SQL values for sqlite3.
+
+    *fatkodima*
+
+*   Correctly parse complex check constraint expressions for PostgreSQL.
+
+    *fatkodima*
+
+*   Fix `timestamptz` attributes on PostgreSQL handle blank inputs.
 
+    *Alex Ghiculescu*
+
+*   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*
 
-## Rails 6.1.2 (February 09, 2021) ##
+*   Fix joining through a polymorphic association.
+
+    *Alexandre Ruban*
+
+*   Fix `QueryMethods#in_order_of` to handle empty order list.
+
+    ```ruby
+    Post.in_order_of(:id, []).to_a
+    ```
 
-*   Fix timestamp type for sqlite3.
+    Also more explicitly set the column as secondary order, so that any other
+    value is still ordered.
+
+    *Jean Boussier*
+
+*   Fix `rails dbconsole` for 3-tier config.
 
     *Eileen M. Uchitelle*
 
-*   Make destroy async transactional.
+*   Fix quoting of column aliases generated by calculation methods.
 
-    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.
+    Since the alias is derived from the table name, we can't assume the result
+    is a valid identifier.
 
-    Now the jobs are only enqueued until after the db transaction has been committed.
+    ```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...
+    ```
 
-    *Cory Gwin*
+    *Jean Boussier*
 
-*   Fix malformed packet error in MySQL statement for connection configuration.
 
-    *robinroestenburg*
+## Rails 7.0.0 (December 15, 2021) ##
 
-*   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.
+*   Better handle SQL queries with invalid encoding.
 
-    Fixes #41137.
+    ```ruby
+    Post.create(name: "broken \xC8 UTF-8")
+    ```
 
-    *Jonathan Bracy*
+    Would cause all adapters to fail in a non controlled way in the code
+    responsible to detect write queries.
 
-*   Fix granular connection swapping when there are multiple abstract classes.
+    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.
+
+    *Jean Boussier*
+
+*   Move database and shard selection config options to a generator.
+
+    Rather than generating the config options in `production.rb` when applications are created, applications can now run a generator to create an initializer and uncomment / update options as needed. All multi-db configuration can be implemented in this initializer.
 
     *Eileen M. Uchitelle*
 
-*   Fix `find_by` with custom primary key for belongs_to association.
 
-    *Ryuta Kamizono*
+## Rails 7.0.0.rc3 (December 14, 2021) ##
+
+*   No changes.
+
+
+## Rails 7.0.0.rc2 (December 14, 2021) ##
+
+*   No changes.
+
+
+## Rails 7.0.0.rc1 (December 06, 2021) ##
+
+*   Remove deprecated `ActiveRecord::DatabaseConfigurations::DatabaseConfig#spec_name`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `ActiveRecord::Connection#in_clause_length`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `ActiveRecord::Connection#allowed_index_name_length`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `ActiveRecord::Base#remove_connection`.
 
-*   Add support for `rails console --sandbox` for multiple database applications.
+    *Rafael Mendonça França*
 
-    *alpaca-tc*
+*   Load STI Models in fixtures
 
-*   Fix `where` on polymorphic association with empty array.
+    Data from Fixtures now loads based on the specific class for models with
+    Single Table Inheritance. This affects enums defined in subclasses, previously
+    the value of these fields was not parsed and remained `nil`
 
-    *Ryuta Kamizono*
+    *Andres Howard*
 
-*   Fix preventing writes for `ApplicationRecord`.
+*   `#authenticate` returns false when the password is blank instead of raising an error.
 
-    *Eileen M. Uchitelle*
+    *Muhammad Muhammad Ibrahim*
 
+*   Fix `ActiveRecord::QueryMethods#in_order_of` behavior for integer enums.
 
-## Rails 6.1.1 (January 07, 2021) ##
+    `ActiveRecord::QueryMethods#in_order_of` didn't work as expected for enums stored as integers in the database when passing an array of strings or symbols as the order argument. This unexpected behavior occurred because the string or symbol values were not casted to match the integers in the database.
 
-*   Fix fixtures loading when strict loading is enabled for the association.
+    The following example now works as expected:
 
-    *Alex Ghiculescu*
+    ```ruby
+    class Book < ApplicationRecord
+      enum status: [:proposed, :written, :published]
+    end
 
-*   Fix `where` with custom primary key for belongs_to association.
+    Book.in_order_of(:status, %w[written published proposed])
+    ```
 
-    *Ryuta Kamizono*
+    *Alexandre Ruban*
 
-*   Fix `where` with aliased associations.
+*   Ignore persisted in-memory records when merging target lists.
 
-    *Ryuta Kamizono*
+    *Kevin Sjöberg*
 
-*   Fix `composed_of` with symbol mapping.
+*   Add a new option `:update_only` to `upsert_all` to configure the list of columns to update in case of conflict.
 
-    *Ryuta Kamizono*
+    Before, you could only customize the update SQL sentence via `:on_duplicate`. There is now a new option `:update_only` that lets you provide a list of columns to update in case of conflict:
 
-*   Don't skip money's type cast for pluck and calculations.
+    ```ruby
+    Commodity.upsert_all(
+      [
+        { id: 2, name: "Copper", price: 4.84 },
+        { id: 4, name: "Gold", price: 1380.87 },
+        { id: 6, name: "Aluminium", price: 0.35 }
+      ],
+      update_only: [:price] # Only prices will be updated
+    )
+    ```
 
-    *Ryuta Kamizono*
+    *Jorge Manrubia*
 
-*   Fix `where` on polymorphic association with non Active Record object.
+*   Remove deprecated `ActiveRecord::Result#map!` and `ActiveRecord::Result#collect!`.
 
-    *Ryuta Kamizono*
+    *Rafael Mendonça França*
 
-*   Make sure `db:prepare` works even the schema file doesn't exist.
+*   Remove deprecated `ActiveRecord::Base.configurations.to_h`.
 
     *Rafael Mendonça França*
 
-*   Fix complicated `has_many :through` with nested where condition.
+*   Remove deprecated `ActiveRecord::Base.configurations.default_hash`.
 
-    *Ryuta Kamizono*
+    *Rafael Mendonça França*
 
-*   Handle STI models for `has_many dependent: :destroy_async`.
+*   Remove deprecated `ActiveRecord::Base.arel_attribute`.
 
-    *Muhammad Usman*
+    *Rafael Mendonça França*
 
-*   Restore possibility of passing `false` to :polymorphic option of `belongs_to`.
+*   Remove deprecated `ActiveRecord::Base.connection_config`.
 
-    Previously, passing `false` would trigger the option validation logic
-    to throw an error saying :polymorphic would not be a valid option.
+    *Rafael Mendonça França*
 
-    *glaszig*
+*   Filter attributes in SQL logs
 
-*   Allow adding nonnamed expression indexes to be revertible.
+    Previously, SQL queries in logs containing `ActiveRecord::Base.filter_attributes` were not filtered.
 
-    Fixes #40732.
+    Now, the filter attributes will be masked `[FILTERED]` in the logs when `prepared_statement` is enabled.
 
-    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.
+    ```
+    # Before:
+      Foo Load (0.2ms)  SELECT "foos".* FROM "foos" WHERE "foos"."passw" = ? LIMIT ?  [["passw", "hello"], ["LIMIT", 1]]
 
-    ```ruby
-    add_index(:items, "to_tsvector('english', description)")
+    # After:
+      Foo Load (0.5ms)  SELECT "foos".* FROM "foos" WHERE "foos"."passw" = ? LIMIT ?  [["passw", "[FILTERED]"], ["LIMIT", 1]]
     ```
 
-    *fatkodima*
+    *Aishwarya Subramanian*
 
+*   Remove deprecated `Tasks::DatabaseTasks.spec`.
 
-## Rails 6.1.0 (December 09, 2020) ##
+    *Rafael Mendonça França*
 
-*   Only warn about negative enums if a positive form that would cause conflicts exists.
+*   Remove deprecated `Tasks::DatabaseTasks.current_config`.
 
-    Fixes #39065.
+    *Rafael Mendonça França*
 
-    *Alex Ghiculescu*
+*   Deprecate `Tasks::DatabaseTasks.schema_file_type`.
 
-*   Change `attribute_for_inspect` to take `filter_attributes` in consideration.
+    *Rafael Mendonça França*
+
+*   Remove deprecated `Tasks::DatabaseTasks.dump_filename`.
 
     *Rafael Mendonça França*
 
-*   Fix odd behavior of inverse_of with multiple belongs_to to same class.
+*   Remove deprecated `Tasks::DatabaseTasks.schema_file`.
+
+    *Rafael Mendonça França*
 
-    Fixes #35204.
+*   Remove deprecated `environment` and `name` arguments from `Tasks::DatabaseTasks.schema_up_to_date?`.
 
-    *Tomoyuki Kai*
+    *Rafael Mendonça França*
 
-*   Build predicate conditions with objects that delegate `#id` and primary key:
+*   Merging conditions on the same column no longer maintain both conditions,
+    and will be consistently replaced by the latter condition.
 
     ```ruby
-    class AdminAuthor
-      delegate_missing_to :@author
+    # Rails 6.1 (IN clause is replaced by merger side equality condition)
+    Author.where(id: [david.id, mary.id]).merge(Author.where(id: bob)) # => [bob]
+    # Rails 6.1 (both conflict conditions exists, deprecated)
+    Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => []
+    # Rails 6.1 with rewhere to migrate to Rails 7.0's behavior
+    Author.where(id: david.id..mary.id).merge(Author.where(id: bob), rewhere: true) # => [bob]
+    # Rails 7.0 (same behavior with IN clause, mergee side condition is consistently replaced)
+    Author.where(id: [david.id, mary.id]).merge(Author.where(id: bob)) # => [bob]
+    Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => [bob]
 
-      def initialize(author)
-        @author = author
-      end
-    end
+    *Rafael Mendonça França*
 
-    Post.where(author: AdminAuthor.new(author))
-    ```
+*   Remove deprecated support to `Model.reorder(nil).first` to search using non-deterministic order.
 
-    *Sean Doyle*
+    *Rafael Mendonça França*
 
-*   Add `connected_to_many` API.
+*   Remove deprecated rake tasks:
 
-    This API allows applications to connect to multiple databases at once without switching all of them or implementing a deeply nested stack.
+    * `db:schema:load_if_ruby`
+    * `db:structure:dump`
+    * `db:structure:load`
+    * `db:structure:load_if_sql`
+    * `db:structure:dump:#{name}`
+    * `db:structure:load:#{name}`
+    * `db:test:load_structure`
+    * `db:test:load_structure:#{name}`
 
-    Before:
+    *Rafael Mendonça França*
 
-        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
+*   Remove deprecated `DatabaseConfig#config` method.
 
-    After:
+    *Rafael Mendonça França*
 
-        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
+*   Rollback transactions when the block returns earlier than expected.
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    Before this change, when a transaction block returned early, the transaction would be committed.
+
+    The problem is that timeouts triggered inside the transaction block was also making the incomplete transaction
+    to be committed, so in order to avoid this mistake, the transaction block is rolled back.
 
-*   Add option to raise or log for `ActiveRecord::StrictLoadingViolationError`.
+    *Rafael Mendonça França*
 
-    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.
+*   Add middleware for automatic shard swapping.
 
-    Set `config.active_record.action_on_strict_loading_violation` to `:log` errors instead of raising.
+    Provides a basic middleware to perform automatic shard swapping. Applications will provide a resolver which will determine for an individual request which shard should be used. Example:
 
-    *Eileen M. Uchitelle*
+    ```ruby
+    config.active_record.shard_resolver = ->(request) {
+      subdomain = request.subdomain
+      tenant = Tenant.find_by_subdomain!(subdomain)
+      tenant.shard
+    }
+    ```
 
-*   Allow the inverse of a `has_one` association that was previously autosaved to be loaded.
+    See guides for more details.
 
-    Fixes #34255.
+    *Eileen M. Uchitelle*, *John Crepezzi*
 
-    *Steven Weber*
+*   Remove deprecated support to pass a column to `type_cast`.
 
-*   Optimise the length of index names for polymorphic references by using the reference name rather than the type and id column names.
+    *Rafael Mendonça França*
 
-    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.
+*   Remove deprecated support to type cast to database values `ActiveRecord::Base` objects.
 
-    This change reduces the chance of that happening by using the reference name, e.g. `index_my_table_on_my_reference`.
+    *Rafael Mendonça França*
 
-    Fixes #38655.
+*   Remove deprecated support to quote `ActiveRecord::Base` objects.
 
-    *Luke Redpath*
+    *Rafael Mendonça França*
 
-*   MySQL: Uniqueness validator now respects default database collation,
-    no longer enforce case sensitive comparison by default.
+*   Remove deprecacated support to resolve connection using `"primary"` as connection specification name.
 
-    *Ryuta Kamizono*
+    *Rafael Mendonça França*
 
-*   Remove deprecated methods from `ActiveRecord::ConnectionAdapters::DatabaseLimits`.
+*   Remove deprecation warning when using `:interval` column is used in PostgreSQL database.
 
-    `column_name_length`
-    `table_name_length`
-    `columns_per_table`
-    `indexes_per_table`
-    `columns_per_multicolumn_index`
-    `sql_query_length`
-    `joins_per_query`
+    Now, interval columns will return `ActiveSupport::Duration` objects instead of strings.
 
-    *Rafael Mendonça França*
+    To keep the old behavior, you can add this line to your model:
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::AbstractAdapter#supports_multi_insert?`.
+    ```ruby
+    attribute :column, :string
+    ```
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::AbstractAdapter#supports_foreign_keys_in_create?`.
+*   Remove deprecated support to YAML load `ActiveRecord::Base` instance in the Rails 4.2 and 4.1 formats.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter#supports_ranges?`.
+*   Remove deprecated option `:spec_name` in the `configs_for` method.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `ActiveRecord::Base#update_attributes` and `ActiveRecord::Base#update_attributes!`.
+*   Remove deprecated  `ActiveRecord::Base.allow_unsafe_raw_sql`.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `migrations_path` argument in `ActiveRecord::ConnectionAdapter::SchemaStatements#assume_migrated_upto_version`.
+*   Fix regression bug that caused ignoring additional conditions for preloading has_many-through relations.
 
-    *Rafael Mendonça França*
+    Fixes #43132
 
-*   Remove deprecated `config.active_record.sqlite3.represent_boolean_as_integer`.
+    *Alexander Pauly*
 
-    *Rafael Mendonça França*
+*   Fix `has_many` inversing recursion on models with recursive associations.
 
-*   `relation.create` does no longer leak scope to class level querying methods
-    in initialization block and callbacks.
+    *Gannon McGibbon*
 
-    Before:
+*   Add `accepts_nested_attributes_for` support for `delegated_type`
 
-        User.where(name: "John").create do |john|
-          User.find_by(name: "David") # => nil
-        end
+    ```ruby
+    class Entry < ApplicationRecord
+      delegated_type :entryable, types: %w[ Message Comment ]
+      accepts_nested_attributes_for :entryable
+    end
 
-    After:
+    entry = Entry.create(entryable_type: 'Message', entryable_attributes: { content: 'Hello world' })
+    # => #<Entry:0x00>
+    # id: 1
+    # entryable_id: 1,
+    # entryable_type: 'Message'
+    # ...>
+
+    entry.entryable
+    # => #<Message:0x01>
+    # id: 1
+    # content: 'Hello world'
+    # ...>
+    ```
 
-        User.where(name: "John").create do |john|
-          User.find_by(name: "David") # => #<User name: "David", ...>
-        end
+    Previously it would raise an error:
 
-    *Ryuta Kamizono*
+    ```ruby
+    Entry.create(entryable_type: 'Message', entryable_attributes: { content: 'Hello world' })
+    # ArgumentError: Cannot build association `entryable'. Are you trying to build a polymorphic one-to-one association?
+    ```
 
-*   Named scope chain does no longer leak scope to class level querying methods.
+    *Sjors Baltus*
 
-        class User < ActiveRecord::Base
-          scope :david, -> { User.where(name: "David") }
-        end
+*   Use subquery for DELETE with GROUP_BY and HAVING clauses.
 
-    Before:
+    Prior to this change, deletes with GROUP_BY and HAVING were returning an error.
 
-        User.where(name: "John").david
-        # SELECT * FROM users WHERE name = 'John' AND name = 'David'
+    After this change, GROUP_BY and HAVING are valid clauses in DELETE queries, generating the following query:
 
-    After:
+    ```sql
+    DELETE FROM "posts" WHERE "posts"."id" IN (
+        SELECT "posts"."id" FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" GROUP BY "posts"."id" HAVING (count(comments.id) >= 2))
+    )  [["flagged", "t"]]
+    ```
 
-        User.where(name: "John").david
-        # SELECT * FROM users WHERE name = 'David'
+    *Ignacio Chiazzo Cardarello*
 
-    *Ryuta Kamizono*
+*   Use subquery for UPDATE with GROUP_BY and HAVING clauses.
 
-*   Remove deprecated methods from `ActiveRecord::DatabaseConfigurations`.
+    Prior to this change, updates with GROUP_BY and HAVING were being ignored, generating a SQL like this:
 
-    `fetch`
-    `each`
-    `first`
-    `values`
-    `[]=`
+    ```sql
+    UPDATE "posts" SET "flagged" = ? WHERE "posts"."id" IN (
+        SELECT "posts"."id" FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+    )  [["flagged", "t"]]
+    ```
 
-    *Rafael Mendonça França*
+    After this change, GROUP_BY and HAVING clauses are used as a subquery in updates, like this:
 
-*   `where.not` now generates NAND predicates instead of NOR.
+    ```sql
+    UPDATE "posts" SET "flagged" = ? WHERE "posts"."id" IN (
+        SELECT "posts"."id" FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+        GROUP BY posts.id HAVING (count(comments.id) >= 2)
+    )  [["flagged", "t"]]
+    ```
 
-     Before:
+    *Ignacio Chiazzo Cardarello*
 
-        User.where.not(name: "Jon", role: "admin")
-        # SELECT * FROM users WHERE name != 'Jon' AND role != 'admin'
+*   Add support for setting the filename of the schema or structure dump in the database config.
 
-     After:
+    Applications may now set their the filename or path of the schema / structure dump file in their database configuration.
 
-        User.where.not(name: "Jon", role: "admin")
-        # SELECT * FROM users WHERE NOT (name == 'Jon' AND role == 'admin')
+    ```yaml
+    production:
+      primary:
+        database: my_db
+        schema_dump: my_schema_dump_filename.rb
+      animals:
+        database: animals_db
+        schema_dump: false
+    ```
 
-    *Rafael Mendonça França*
+    The filename set in `schema_dump` will be used by the application. If set to `false` the schema will not be dumped. The database tasks are responsible for adding the database directory to the filename. If a full path is provided, the Rails tasks will use that instead of `ActiveRecord::DatabaseTasks.db_dir`.
 
-*   Remove deprecated `ActiveRecord::Result#to_hash` method.
+    *Eileen M. Uchitelle*, *Ryan Kerr*
 
-    *Rafael Mendonça França*
+*   Add `ActiveRecord::Base.prohibit_shard_swapping` to prevent attempts to change the shard within a block.
 
-*   Deprecate `ActiveRecord::Base.allow_unsafe_raw_sql`.
+    *John Crepezzi*, *Eileen M. Uchitelle*
 
-    *Rafael Mendonça França*
+*   Filter unchanged attributes with default function from insert query when `partial_inserts` is disabled.
 
-*   Remove deprecated support for using unsafe raw SQL in `ActiveRecord::Relation` methods.
+    *Akshay Birajdar*, *Jacopo Beschi*
 
-    *Rafael Mendonça França*
+*   Add support for FILTER clause (SQL:2003) to Arel.
 
-*   Allow users to silence the "Rails couldn't infer whether you are using multiple databases..."
-    message using `config.active_record.suppress_multiple_database_warning`.
+    Currently supported by PostgreSQL 9.4+ and SQLite 3.30+.
 
-    *Omri Gabay*
+    *Andrey Novikov*
 
-*   Connections can be granularly switched for abstract classes when `connected_to` is called.
+*   Automatically set timestamps on record creation during bulk insert/upsert
 
-    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.
+    Prior to this change, only updates during an upsert operation (e.g. `upsert_all`) would touch timestamps (`updated_{at,on}`). Now, record creations also touch timestamp columns (`{created,updated}_{at,on}`).
 
-    Example usage:
+    This behaviour is controlled by the `<model>.record_timestamps` config, matching the behaviour of `create`, `update`, etc. It can also be overridden by using the `record_timestamps:` keyword argument.
 
-    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`.
+    Note that this means `upsert_all` on models with `record_timestamps = false` will no longer touch `updated_{at,on}` automatically.
 
-    ```ruby
-    ActiveRecord::Base.connected_to(role: :reading) do
-      User.first # reads from default replica
-      Dog.first # reads from default replica
+    *Sam Bostock*
 
-      AnimalsRecord.connected_to(role: :writing, shard: :one) do
-        User.first # reads from default replica
-        Dog.first # reads from shard one primary
-      end
+*   Don't require `role` when passing `shard` to `connected_to`.
 
-      User.first # reads from default replica
-      Dog.first # reads from default replica
+    `connected_to` can now be called with a `shard` only. Note that `role` is still inherited if `connected_to` calls are nested.
 
-      ApplicationRecord.connected_to(role: :writing, shard: :two) do
-        User.first # reads from shard two primary
-        Dog.first # reads from default replica
-      end
+    *Eileen M. Uchitelle*
+
+*   Add option to lazily load the schema cache on the connection.
+
+    Previously, the only way to load the schema cache in Active Record was through the Railtie on boot. This option provides the ability to load the schema cache on the connection after it's been established. Loading the cache lazily on the connection can be beneficial for Rails applications that use multiple databases because it will load the cache at the time the connection is established. Currently Railties doesn't have access to the connections before boot.
+
+    To use the cache, set `config.active_record.lazily_load_schema_cache = true` in your application configuration. In addition a `schema_cache_path` should be set in your database configuration if you don't want to use the default "db/schema_cache.yml" path.
+
+    *Eileen M. Uchitelle*
+
+*   Allow automatic `inverse_of` detection for associations with scopes.
+
+    Automatic `inverse_of` detection now works for associations with scopes. For
+    example, the `comments` association here now automatically detects
+    `inverse_of: :post`, so we don't need to pass that option:
+
+    ```ruby
+    class Post < ActiveRecord::Base
+      has_many :comments, -> { visible }
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
     end
     ```
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    Note that the automatic detection still won't work if the inverse
+    association has a scope. In this example a scope on the `post` association
+    would still prevent Rails from finding the inverse for the `comments`
+    association.
+
+    This will be the default for new apps in Rails 7. To opt in:
+
+    ```ruby
+    config.active_record.automatic_scope_inversing = true
+    ```
+
+    *Daniel Colson*, *Chris Bloom*
+
+*   Accept optional transaction args to `ActiveRecord::Locking::Pessimistic#with_lock`
 
-*   Allow double-dash comment syntax when querying read-only databases
+    `#with_lock` now accepts transaction options like `requires_new:`,
+    `isolation:`, and `joinable:`
 
-    *James Adam*
+    *John Mileham*
 
-*   Add `values_at` method.
+*   Adds support for deferrable foreign key constraints in PostgreSQL.
 
-    Returns an array containing the values associated with the given methods.
+    By default, foreign key constraints in PostgreSQL are checked after each statement. This works for most use cases,
+    but becomes a major limitation when creating related records before the parent record is inserted into the database.
+    One example of this is looking up / creating a person via one or more unique alias.
 
     ```ruby
-    topic = Topic.first
-    topic.values_at(:title, :author_name)
-    # => ["Budget", "Jason"]
+    Person.transaction do
+      alias = Alias
+        .create_with(user_id: SecureRandom.uuid)
+        .create_or_find_by(name: "DHH")
+
+      person = Person
+        .create_with(name: "David Heinemeier Hansson")
+        .create_or_find_by(id: alias.user_id)
+    end
     ```
 
-    Similar to `Hash#values_at` but on an Active Record instance.
+    Using the default behavior, the transaction would fail when executing the first `INSERT` statement.
 
-    *Guillaume Briday*
+    By passing the `:deferrable` option to the `add_foreign_key` statement in migrations, it's possible to defer this
+    check.
 
-*   Fix `read_attribute_before_type_cast` to consider attribute aliases.
+    ```ruby
+    add_foreign_key :aliases, :person, deferrable: true
+    ```
 
-    *Marcelo Lauxen*
+    Passing `deferrable: true` doesn't change the default behavior, but allows manually deferring the check using
+    `SET CONSTRAINTS ALL DEFERRED` within a transaction. This will cause the foreign keys to be checked after the
+    transaction.
 
-*   Support passing record to uniqueness validator `:conditions` callable:
+    It's also possible to adjust the default behavior from an immediate check (after the statement), to a deferred check
+    (after the transaction):
 
     ```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
+    add_foreign_key :aliases, :person, deferrable: :deferred
     ```
 
-    *Eliot Sykes*
+    *Benedikt Deicke*
+
+*   Allow configuring Postgres password through the socket URL.
+
+    For example:
+    ```ruby
+    ActiveRecord::DatabaseConfigurations::UrlConfig.new(
+      :production, :production, 'postgres:///?user=user&password=secret&dbname=app', {}
+    ).configuration_hash
+    ```
 
-*   `BatchEnumerator#update_all` and `BatchEnumerator#delete_all` now return the
-    total number of rows affected, just like their non-batched counterparts.
+    will now return,
 
     ```ruby
-    Person.in_batches.update_all("first_name = 'Eugene'") # => 42
-    Person.in_batches.delete_all # => 42
+    { :user=>"user", :password=>"secret", :dbname=>"app", :adapter=>"postgresql" }
     ```
 
-    Fixes #40287.
+    *Abeid Ahmed*
 
-    *Eugene Kenny*
+*   PostgreSQL: support custom enum types
 
-*   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.
+    In migrations, use `create_enum` to add a new enum type, and `t.enum` to add a column.
 
-    To use this in 6.1, you need to place the next string to your model file:
+    ```ruby
+    def up
+      create_enum :mood, ["happy", "sad"]
 
-        attribute :duration, :interval
+      change_table :cats do |t|
+        t.enum :current_mood, enum_type: "mood", default: "happy", null: false
+      end
+    end
+    ```
 
-    To keep old behavior until 7.0 is released:
+    Enums will be presented correctly in `schema.rb`. Note that this is only supported by
+    the PostgreSQL adapter.
 
-        attribute :duration, :string
+    *Alex Ghiculescu*
 
-    Example:
+*   Avoid COMMENT statements in PostgreSQL structure dumps
 
-        create_table :events do |t|
-          t.string   :name
-          t.interval :duration
-        end
+    COMMENT statements are now omitted from the output of `db:structure:dump` when using PostgreSQL >= 11.
+    This allows loading the dump without a pgsql superuser account.
 
-        class Event < ApplicationRecord
-          attribute :duration, :interval
-        end
+    Fixes #36816, #43107.
 
-        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
+    *Janosch Müller*
 
-    *Andrey Novikov*
+*   Add support for generated columns in PostgreSQL adapter
 
-*   Allow associations supporting the `dependent:` key to take `dependent: :destroy_async`.
+    Generated columns are supported since version 12.0 of PostgreSQL. This adds
+    support of those to the PostgreSQL adapter.
 
     ```ruby
-    class Account < ActiveRecord::Base
-        belongs_to :supplier, dependent: :destroy_async
+    create_table :users do |t|
+      t.string :name
+      t.virtual :name_upcased, type: :string, as: 'upper(name)', stored: true
     end
     ```
 
-    `:destroy_async` will enqueue a job to destroy associated records in the background.
+    *Michał Begejowicz*
 
-    *DHH*, *George Claghorn*, *Cory Gwin*, *Rafael Mendonça França*, *Adrianna Chang*
 
-*   Add `SKIP_TEST_DATABASE` environment variable to disable modifying the test database when `rails db:create` and `rails db:drop` are called.
+## Rails 7.0.0.alpha2 (September 15, 2021) ##
 
-    *Jason Schweier*
+*   No changes.
 
-*   `connects_to` can only be called on `ActiveRecord::Base` or abstract classes.
 
-    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.
+## Rails 7.0.0.alpha1 (September 15, 2021) ##
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+*   Remove warning when overwriting existing scopes
 
-*   All connection adapters `execute` now raises `ActiveRecord::ConnectionNotEstablished` rather than
-    `ActiveRecord::StatementInvalid` when they encounter a connection error.
+    Removes the following unnecessary warning message that appeared when overwriting existing scopes
 
-    *Jean Boussier*
+    ```
+    Creating scope :my_scope_name. Overwriting existing method "MyClass.my_scope_name" when overwriting existing scopes
+    ```
 
-*   `Mysql2Adapter#quote_string` now raises `ActiveRecord::ConnectionNotEstablished` rather than
-    `ActiveRecord::StatementInvalid` when it can't connect to the MySQL server.
+     *Weston Ganger*
 
-    *Jean Boussier*
+*   Use full precision for `updated_at` in `insert_all`/`upsert_all`
 
-*   Add support for check constraints that are `NOT VALID` via `validate: false` (PostgreSQL-only).
+    `CURRENT_TIMESTAMP` provides differing precision depending on the database,
+    and not all databases support explicitly specifying additional precision.
 
-    *Alex Robbin*
+    Instead, we delegate to the new `connection.high_precision_current_timestamp`
+    for the SQL to produce a high precision timestamp on the current database.
 
-*   Ensure the default configuration is considered primary or first for an environment
+    Fixes #42992
 
-    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.
+    *Sam Bostock*
 
-    *Eileen M. Uchitelle*
+*   Add ssl support for postgresql database tasks
 
-*   Allow `where` references association names as joined table name aliases.
+    Add `PGSSLMODE`, `PGSSLCERT`, `PGSSLKEY` and `PGSSLROOTCERT` to pg_env from database config
+    when running postgresql database tasks.
 
-    ```ruby
-    class Comment < ActiveRecord::Base
-      enum label: [:default, :child]
-      has_many :children, class_name: "Comment", foreign_key: :parent_id
-    end
+    ```yaml
+    # config/database.yml
 
-    # ... FROM comments LEFT OUTER JOIN comments children ON ... WHERE children.label = 1
-    Comment.includes(:children).where("children.label": "child")
+    production:
+      sslmode: verify-full
+      sslcert: client.crt
+      sslkey: client.key
+      sslrootcert: ca.crt
     ```
 
-    *Ryuta Kamizono*
+    Environment variables
 
-*   Support storing demodulized class name for polymorphic type.
+    ```
+    PGSSLMODE=verify-full
+    PGSSLCERT=client.crt
+    PGSSLKEY=client.key
+    PGSSLROOTCERT=ca.crt
+    ```
 
-    Before Rails 6.1, storing demodulized class name is supported only for STI type
-    by `store_full_sti_class` class attribute.
+    Fixes #42994
 
-    Now `store_full_class_name` class attribute can handle both STI and polymorphic types.
+    *Michael Bayucot*
 
-    *Ryuta Kamizono*
+*   Avoid scoping update callbacks in `ActiveRecord::Relation#update!`.
 
-*   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.
+    Making it consistent with how scoping is applied only to the query in `ActiveRecord::Relation#update`
+    and not also to the callbacks from the update itself.
 
-    *fatkodima*
+    *Dylan Thacker-Smith*
 
-*   Respect the `select` values for eager loading.
+*   Fix 2 cases that inferred polymorphic class from the association's `foreign_type`
+    using `String#constantize` instead of the model's `polymorphic_class_for`.
 
-    ```ruby
-    post = Post.select("UPPER(title) AS title").first
-    post.title # => "WELCOME TO THE WEBLOG"
-    post.body  # => ActiveModel::MissingAttributeError
+    When updating a polymorphic association, the old `foreign_type` was not inferred correctly when:
+    1. `touch`ing the previously associated record
+    2. updating the previously associated record's `counter_cache`
 
-    # 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"
+    *Jimmy Bourassa*
 
-    # 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
-    ```
+*   Add config option for ignoring tables when dumping the schema cache.
 
-    *Ryuta Kamizono*
+    Applications can now be configured to ignore certain tables when dumping the schema cache.
 
-*   Allow attribute's default to be configured but keeping its own type.
+    The configuration option can table an array of tables:
 
     ```ruby
-    class Post < ActiveRecord::Base
-      attribute :written_at, default: -> { Time.now.utc }
-    end
+    config.active_record.schema_cache_ignored_tables = ["ignored_table", "another_ignored_table"]
+    ```
 
-    # Rails 6.0
-    Post.type_for_attribute(:written_at) # => #<Type::Value ... precision: nil, ...>
+    Or a regex:
 
-    # Rails 6.1
-    Post.type_for_attribute(:written_at) # => #<Type::DateTime ... precision: 6, ...>
+    ```ruby
+    config.active_record.schema_cache_ignored_tables = [/^_/]
     ```
 
-    *Ryuta Kamizono*
+    *Eileen M. Uchitelle*
 
-*   Allow default to be configured for Enum.
+*   Make schema cache methods return consistent results.
 
-    ```ruby
-    class Book < ActiveRecord::Base
-      enum status: [:proposed, :written, :published], _default: :published
-    end
+    Previously the schema cache methods `primary_keys`, `columns`, `columns_hash`, and `indexes`
+    would behave differently than one another when a table didn't exist and differently across
+    database adapters. This change unifies the behavior so each method behaves the same regardless
+    of adapter.
 
-    Book.new.status # => "published"
-    ```
+    The behavior now is:
 
-    *Ryuta Kamizono*
+    `columns`: (unchanged) raises a db error if the table does not exist.
+    `columns_hash`: (unchanged) raises a db error if the table does not exist.
+    `primary_keys`: (unchanged) returns `nil` if the table does not exist.
+    `indexes`: (changed for mysql2) returns `[]` if the table does not exist.
 
-*   Deprecate YAML loading from legacy format older than Rails 5.0.
+    *Eileen M. Uchitelle*
 
-    *Ryuta Kamizono*
+*   Reestablish connection to previous database after after running `db:schema:load:name`
 
-*   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.
+    After running `db:schema:load:name` the previous connection is restored.
 
-    *Sean Griffin*, *Ryuta Kamizono*
+    *Jacopo Beschi*
 
-*   Deprecate `map!` and `collect!` on `ActiveRecord::Result`.
+*   Add database config option `database_tasks`
 
-    *Ryuta Kamizono*
+    If you would like to connect to an external database without any database
+    management tasks such as schema management, migrations, seeds, etc. you can set
+    the per database config option `database_tasks: false`
 
-*   Support `relation.and` for intersection as Set theory.
+    ```yaml
+    # config/database.yml
 
-    ```ruby
-    david_and_mary = Author.where(id: [david, mary])
-    mary_and_bob   = Author.where(id: [mary, bob])
+    production:
+      primary:
+        database: my_database
+        adapter: mysql2
+      animals:
+        database: my_animals_database
+        adapter: mysql2
+        database_tasks: false
+    ```
 
-    david_and_mary.merge(mary_and_bob) # => [mary, bob]
+    *Weston Ganger*
 
-    david_and_mary.and(mary_and_bob) # => [mary]
-    david_and_mary.or(mary_and_bob)  # => [david, mary, bob]
-    ```
+*   Fix `ActiveRecord::InternalMetadata` to not be broken by `config.active_record.record_timestamps = false`
 
-    *Ryuta Kamizono*
+    Since the model always create the timestamp columns, it has to set them, otherwise it breaks
+    various DB management tasks.
 
-*   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)`.
+    Fixes #42983
+
+*   Add `ActiveRecord::QueryLogs`.
+
+    Configurable tags can be automatically added to all SQL queries generated by Active Record.
 
     ```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]
+    # config/application.rb
+    module MyApp
+      class Application < Rails::Application
+        config.active_record.query_log_tags_enabled = true
+      end
+    end
+    ```
 
-    # Rails 6.1 (both conflict conditions exists, deprecated)
-    Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => []
+    By default the application, controller and action details are added to the query tags:
 
-    # 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]
+    ```ruby
+    class BooksController < ApplicationController
+      def index
+        @books = Book.all
+      end
+    end
+    ```
 
-    # 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]
+    ```ruby
+    GET /books
+    # SELECT * FROM books /*application:MyApp;controller:books;action:index*/
     ```
 
-    *Ryuta Kamizono*
+    Custom tags containing static values and Procs can be defined in the application configuration:
 
-*   Do not mark Postgresql MAC address and UUID attributes as changed when the assigned value only varies by case.
+    ```ruby
+    config.active_record.query_log_tags = [
+      :application,
+      :controller,
+      :action,
+      {
+        custom_static: "foo",
+        custom_dynamic: -> { Time.now }
+      }
+    ]
+    ```
 
-    *Peter Fry*
+    *Keeran Raj Hawoldar*, *Eileen M. Uchitelle*, *Kasper Timm Hansen*
 
-*   Resolve issue with insert_all unique_by option when used with expression index.
+*   Added support for multiple databases to `rails db:setup` and `rails db:reset`.
 
-    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.
+    *Ryan Hall*
 
-    Usage:
+*   Add `ActiveRecord::Relation#structurally_compatible?`.
+
+    Adds a query method by which a user can tell if the relation that they're
+    about to use for `#or` or `#and` is structurally compatible with the
+    receiver.
+
+    *Kevin Newton*
+
+*   Add `ActiveRecord::QueryMethods#in_order_of`.
+
+    This allows you to specify an explicit order that you'd like records
+    returned in based on a SQL expression. By default, this will be accomplished
+    using a case statement, as in:
 
     ```ruby
-    create_table :books, id: :integer, force: true do |t|
-      t.column :name, :string
-      t.index "lower(name)", unique: true
-    end
+    Post.in_order_of(:id, [3, 5, 1])
+    ```
 
-    Book.insert_all [{ name: "MyTest" }], unique_by: :index_books_on_lower_name
+    will generate the SQL:
+
+    ```sql
+    SELECT "posts".* FROM "posts" ORDER BY CASE "posts"."id" WHEN 3 THEN 1 WHEN 5 THEN 2 WHEN 1 THEN 3 ELSE 4 END ASC
     ```
 
-    Fixes #39516.
+    However, because this functionality is built into MySQL in the form of the
+    `FIELD` function, that connection adapter will generate the following SQL
+    instead:
 
-    *Austen Madden*
+    ```sql
+    SELECT "posts".* FROM "posts" ORDER BY FIELD("posts"."id", 1, 5, 3) DESC
+    ```
 
-*   Add basic support for CHECK constraints to database migrations.
+    *Kevin Newton*
 
-    Usage:
+*   Fix `eager_loading?` when ordering with `Symbol`.
+
+    `eager_loading?` is triggered correctly when using `order` with symbols.
 
     ```ruby
-    add_check_constraint :products, "price > 0", name: "price_check"
-    remove_check_constraint :products, name: "price_check"
+    scope = Post.includes(:comments).order(:"comments.label")
+    => true
     ```
 
-    *fatkodima*
+    *Jacopo Beschi*
 
-*   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.
+*   Two change tracking methods are added for `belongs_to` associations.
 
-    Usage:
+    The `association_changed?` method (assuming an association named `:association`) returns true
+    if a different associated object has been assigned and the foreign key will be updated in the
+    next save.
 
-    ```ruby
-    class Developer < ApplicationRecord
-      self.strict_loading_by_default = true
+    The `association_previously_changed?` method returns true if the previous save updated the
+    association to reference a different associated object.
 
-      has_many :projects
-    end
+    *George Claghorn*
 
-    dev = Developer.first
-    dev.projects.first
-    # => ActiveRecord::StrictLoadingViolationError Exception: Developer is marked as strict_loading and Project cannot be lazily loaded.
-    ```
+*   Add option to disable schema dump per-database.
 
-    *bogdanvlviv*
+    Dumping the schema is on by default for all databases in an application. To turn it off for a
+    specific database, use the `schema_dump` option:
 
-*   Deprecate passing an Active Record object to `quote`/`type_cast` directly.
+    ```yaml
+    # config/database.yml
 
-    *Ryuta Kamizono*
+    production:
+      schema_dump: false
+    ```
 
-*   Default engine `ENGINE=InnoDB` is no longer dumped to make schema more agnostic.
+    *Luis Vasconcellos*, *Eileen M. Uchitelle*
 
-    Before:
+*   Fix `eager_loading?` when ordering with `Hash` syntax.
+
+    `eager_loading?` is triggered correctly when using `order` with hash syntax
+    on an outer table.
 
     ```ruby
-    create_table "accounts", options: "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci", force: :cascade do |t|
-    end
+    Post.includes(:comments).order({ "comments.label": :ASC }).eager_loading?
+    # => true
     ```
 
-    After:
+    *Jacopo Beschi*
+
+*   Move the forcing of clear text encoding to the `ActiveRecord::Encryption::Encryptor`.
+
+    Fixes #42699.
+
+    *J Smith*
+
+*   `partial_inserts` is now disabled by default in new apps.
+
+    This will be the default for new apps in Rails 7. To opt in:
 
     ```ruby
-    create_table "accounts", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
-    end
+    config.active_record.partial_inserts = true
     ```
 
-    *Ryuta Kamizono*
+    If a migration removes the default value of a column, this option
+    would cause old processes to no longer be able to create new records.
 
-*   Added delegated type as an alternative to single-table inheritance for representing class hierarchies.
-    See ActiveRecord::DelegatedType for the full description.
+    If you need to remove a column, you should first use `ignored_columns`
+    to stop using it.
 
-    *DHH*
+    *Jean Boussier*
 
-*   Deprecate aggregations with group by duplicated fields.
+*   Rails can now verify foreign keys after loading fixtures in tests.
 
-    To migrate to Rails 7.0's behavior, use `uniq!(:group)` to deduplicate group fields.
+    This will be the default for new apps in Rails 7. To opt in:
 
     ```ruby
-    accounts = Account.group(:firm_id)
-
-    # duplicated group fields, deprecated.
-    accounts.merge(accounts.where.not(credit_limit: nil)).sum(:credit_limit)
-    # => {
-    #   [1, 1] => 50,
-    #   [2, 2] => 60
-    # }
-
-    # use `uniq!(:group)` to deduplicate group fields.
-    accounts.merge(accounts.where.not(credit_limit: nil)).uniq!(:group).sum(:credit_limit)
-    # => {
-    #   1 => 50,
-    #   2 => 60
-    # }
+    config.active_record.verify_foreign_keys_for_fixtures = true
     ```
 
-    *Ryuta Kamizono*
+    Tests will not run if there is a foreign key constraint violation in your fixture data.
 
-*   Deprecate duplicated query annotations.
+    The feature is supported by SQLite and PostgreSQL, other adapters can also add support for it.
 
-    To migrate to Rails 7.0's behavior, use `uniq!(:annotate)` to deduplicate query annotations.
+    *Alex Ghiculescu*
 
-    ```ruby
-    accounts = Account.where(id: [1, 2]).annotate("david and mary")
+*   Clear cached `has_one` association after setting `belongs_to` association to `nil`.
 
-    # duplicated annotations, deprecated.
-    accounts.merge(accounts.rewhere(id: 3))
-    # SELECT accounts.* FROM accounts WHERE accounts.id = 3 /* david and mary */ /* david and mary */
+    After setting a `belongs_to` relation to `nil` and updating an unrelated attribute on the owner,
+    the owner should still return `nil` on the `has_one` relation.
 
-    # 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 */
-    ```
+    Fixes #42597.
 
-    *Ryuta Kamizono*
+    *Michiel de Mare*
 
-*   Resolve conflict between counter cache and optimistic locking.
+*   OpenSSL constants are now used for Digest computations.
 
-    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.
+    *Dirkjan Bussink*
 
-    Fixes #16449.
+*   Adds support for `if_not_exists` to `add_foreign_key` and `if_exists` to `remove_foreign_key`.
 
-    *Aaron Lipman*
+    Applications can set their migrations to ignore exceptions raised when adding a foreign key
+    that already exists or when removing a foreign key that does not exist.
+
+    Example Usage:
 
-*   Support merging option `:rewhere` to allow mergee side condition to be replaced exactly.
+    ```ruby
+    class AddAuthorsForeignKeyToArticles < ActiveRecord::Migration[7.0]
+      def change
+        add_foreign_key :articles, :authors, if_not_exists: true
+      end
+    end
+    ```
 
     ```ruby
-    david_and_mary = Author.where(id: david.id..mary.id)
+    class RemoveAuthorsForeignKeyFromArticles < ActiveRecord::Migration[7.0]
+      def change
+        remove_foreign_key :articles, :authors, if_exists: true
+      end
+    end
+    ```
 
-    # both conflict conditions exists
-    david_and_mary.merge(Author.where(id: bob)) # => []
+    *Roberto Miranda*
 
-    # mergee side condition is replaced by rewhere
-    david_and_mary.merge(Author.rewhere(id: bob)) # => [bob]
+*   Prevent polluting ENV during postgresql structure dump/load.
 
-    # mergee side condition is replaced by rewhere option
-    david_and_mary.merge(Author.where(id: bob), rewhere: true) # => [bob]
-    ```
+    Some configuration parameters were provided to pg_dump / psql via
+    environment variables which persisted beyond the command being run, and may
+    have caused subsequent commands and connections to fail. Tasks running
+    across multiple postgresql databases like `rails db:test:prepare` may have
+    been affected.
 
-    *Ryuta Kamizono*
+    *Samuel Cochran*
 
-*   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.
+*   Set precision 6 by default for `datetime` columns.
 
-    ```ruby
-    signed_id = User.first.signed_id expires_in: 15.minutes, purpose: :password_reset
+    By default, datetime columns will have microseconds precision instead of seconds precision.
 
-    User.find_signed signed_id # => nil, since the purpose does not match
+    *Roberto Miranda*
 
-    travel 16.minutes
-    User.find_signed signed_id, purpose: :password_reset # => nil, since the signed id has expired
+*   Allow preloading of associations with instance dependent scopes.
 
-    travel_back
-    User.find_signed signed_id, purpose: :password_reset # => User.first
+    *John Hawthorn*, *John Crepezzi*, *Adam Hess*, *Eileen M. Uchitelle*, *Dinah Shi*
 
-    User.find_signed! "bad data" # => ActiveSupport::MessageVerifier::InvalidSignature
-    ```
+*   Do not try to rollback transactions that failed due to a `ActiveRecord::TransactionRollbackError`.
 
-    *DHH*
+    *Jamie McCarthy*
 
-*   Support `ALGORITHM = INSTANT` DDL option for index operations on MySQL.
+*   Active Record Encryption will now encode values as UTF-8 when using deterministic
+    encryption. The encoding is part of the encrypted payload, so different encodings for
+    different values result in different ciphertexts. This can break unique constraints and
+    queries.
 
-    *Ryuta Kamizono*
+    The new behavior is configurable via `active_record.encryption.forced_encoding_for_deterministic_encryption`
+    that is `Encoding::UTF_8` by default. It can be disabled by setting it to `nil`.
 
-*   Fix index creation to preserve index comment in bulk change table on MySQL.
+    *Jorge Manrubia*
 
-    *Ryuta Kamizono*
+*   The MySQL adapter now cast numbers and booleans bind parameters to string for safety reasons.
 
-*   Allow `unscope` to be aware of table name qualified values.
+    When comparing a string and a number in a query, MySQL converts the string to a number. So for
+    instance `"foo" = 0`, will implicitly cast `"foo"` to `0` and will evaluate to `TRUE` which can
+    lead to security vulnerabilities.
 
-    It is possible to unscope only the column in the specified table.
+    Active Record already protect against that vulnerability when it knows the type of the column
+    being compared, however until now it was still vulnerable when using bind parameters:
 
     ```ruby
-    posts = Post.joins(:comments).group(:"posts.hidden")
-    posts = posts.where("posts.hidden": false, "comments.hidden": false)
-
-    posts.count
-    # => { false => 10 }
+    User.where("login_token = ?", 0).first
+    ```
 
-    # unscope both hidden columns
-    posts.unscope(where: :hidden).count
-    # => { false => 11, true => 1 }
+    Would perform:
 
-    # unscope only comments.hidden column
-    posts.unscope(where: :"comments.hidden").count
-    # => { false => 11 }
+    ```sql
+    SELECT * FROM `users` WHERE `login_token` = 0 LIMIT 1;
     ```
 
-    *Ryuta Kamizono*, *Slava Korolev*
+    Now it will perform:
 
-*   Fix `rewhere` to truly overwrite collided where clause by new where clause.
+    ```sql
+    SELECT * FROM `users` WHERE `login_token` = '0' LIMIT 1;
+    ```
 
-    ```ruby
-    steve = Person.find_by(name: "Steve")
-    david = Author.find_by(name: "David")
+    *Jean Boussier*
 
-    relation = Essay.where(writer: steve)
+*   Fixture configurations (`_fixture`) are now strictly validated.
 
-    # Before
-    relation.rewhere(writer: david).to_a # => []
+    If an error will be raised if that entry contains unknown keys while previously it
+    would silently have no effects.
 
-    # After
-    relation.rewhere(writer: david).to_a # => [david]
-    ```
+    *Jean Boussier*
 
-    *Ryuta Kamizono*
+*   Add `ActiveRecord::Base.update!` that works like `ActiveRecord::Base.update` but raises exceptions.
 
-*   Inspect time attributes with subsec and time zone offset.
+    This allows for the same behavior as the instance method `#update!` at a class level.
 
     ```ruby
-    p Knot.create
-    => #<Knot id: 1, created_at: "2016-05-05 01:29:47.116928000 +0000">
+    Person.update!(:all, state: "confirmed")
     ```
 
-    *akinomaeni*, *Jonathan Hefner*
+    *Dorian Marié*
 
-*   Deprecate passing a column to `type_cast`.
+*   Add `ActiveRecord::Base#attributes_for_database`.
 
-    *Ryuta Kamizono*
+    Returns attributes with values for assignment to the database.
 
-*   Deprecate `in_clause_length` and `allowed_index_name_length` in `DatabaseLimits`.
+    *Chris Salzberg*
 
-    *Ryuta Kamizono*
+*   Use an empty query to check if the PostgreSQL connection is still active.
 
-*   Support bulk insert/upsert on relation to preserve scope values.
+    An empty query is faster than `SELECT 1`.
 
-    *Josef Šimánek*, *Ryuta Kamizono*
+    *Heinrich Lee Yu*
 
-*   Preserve column comment value on changing column name on MySQL.
+*   Add `ActiveRecord::Base#previously_persisted?`.
 
-    *Islam Taha*
+    Returns `true` if the object has been previously persisted but now it has been deleted.
 
-*   Add support for `if_exists` option for removing an index.
+*   Deprecate `partial_writes` in favor of `partial_inserts` and `partial_updates`.
 
-    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.
+    This allows to have a different behavior on update and create.
 
-    *Eileen M. Uchitelle*
+    *Jean Boussier*
 
-*   Remove ibm_db, informix, mssql, oracle, and oracle12 Arel visitors which are not used in the code base.
+*   Fix compatibility with `psych >= 4`.
 
-    *Ryuta Kamizono*
+    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.
 
-*   Prevent `build_association` from `touching` a parent record if the record isn't persisted for `has_one` associations.
+    *Jean Boussier*
 
-    Fixes #38219.
+*   `ActiveRecord::Base.logger` is now a `class_attribute`.
 
-    *Josh Brody*
+    This means it can no longer be accessed directly through `@@logger`, and that setting `logger =`
+    on a subclass won't change the parent's logger.
 
-*   Add support for `if_not_exists` option for adding index.
+    *Jean Boussier*
 
-    The `add_index` method respects `if_not_exists` option. If it is set to true
-    index won't be added.
+*   Add `.asc.nulls_first` for all databases. Unfortunately MySQL still doesn't like `nulls_last`.
 
-    Usage:
+    *Keenan Brock*
 
-    ```ruby
-      add_index :users, :account_id, if_not_exists: true
-    ```
+*   Improve performance of `one?` and `many?` by limiting the generated count query to 2 results.
+
+    *Gonzalo Riestra*
+
+*   Don't check type when using `if_not_exists` on `add_column`.
+
+    Previously, if a migration called `add_column` with the `if_not_exists` option set to true
+    the `column_exists?` check would look for a column with the same name and type as the migration.
 
-    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.
+    Recently it was discovered that the type passed to the migration is not always the same type
+    as the column after migration. For example a column set to `:mediumblob` in the migration will
+    be casted to `binary` when calling `column.type`. Since there is no straightforward way to cast
+    the type to the database type without running the migration, we opted to drop the type check from
+    `add_column`. This means that migrations adding a duplicate column with a different type will no
+    longer raise an error.
 
-    *Prathamesh Sonpatki*
+    *Eileen M. Uchitelle*
+
+*   Log a warning message when running SQLite in production.
 
-*   Add `ActiveRecord::Base#previously_new_record?` to show if a record was new before the last save.
+    Using SQLite in production ENV is generally discouraged. SQLite is also the default adapter
+    in a new Rails application.
+    For the above reasons log a warning message when running SQLite in production.
 
-    *Tom Ward*
+    The warning can be disabled by setting `config.active_record.sqlite3_production_warning=false`.
 
-*   Support descending order for `find_each`, `find_in_batches`, and `in_batches`.
+    *Jacopo Beschi*
 
-    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.
+*   Add option to disable joins for `has_one` associations.
 
-    This change allows reversing the order, batching from newest to oldest. This is useful when you need to process newer batches of records first.
+    In a multiple database application, associations can't join across
+    databases. When set, this option instructs Rails to generate 2 or
+    more queries rather than generating joins for `has_one` associations.
 
-    Pass `order: :desc` to yield batches in descending order. The default remains `order: :asc`.
+    Set the option on a has one through association:
 
     ```ruby
-    Person.find_each(order: :desc) do |person|
-      person.party_all_night!
+    class Person
+      has_one :dog
+      has_one :veterinarian, through: :dog, disable_joins: true
     end
     ```
 
-    *Alexey Vasiliev*
+    Then instead of generating join SQL, two queries are used for `@person.veterinarian`:
+
+    ```
+    SELECT "dogs"."id" FROM "dogs" WHERE "dogs"."person_id" = ?  [["person_id", 1]]
+    SELECT "veterinarians".* FROM "veterinarians" WHERE "veterinarians"."dog_id" = ?  [["dog_id", 1]]
+    ```
 
-*   Fix `insert_all` with enum values.
+    *Sarah Vessels*, *Eileen M. Uchitelle*
 
-    Fixes #38716.
+*   `Arel::Visitors::Dot` now renders a complete set of properties when visiting
+    `Arel::Nodes::SelectCore`, `SelectStatement`, `InsertStatement`, `UpdateStatement`, and
+    `DeleteStatement`, which fixes #42026. Previously, some properties were omitted.
 
-    *Joel Blum*
+    *Mike Dalessio*
 
-*   Add support for `db:rollback:name` for multiple database applications.
+*   `Arel::Visitors::Dot` now supports `Arel::Nodes::Bin`, `Case`, `CurrentRow`, `Distinct`,
+    `DistinctOn`, `Else`, `Except`, `InfixOperation`, `Intersect`, `Lock`, `NotRegexp`, `Quoted`,
+    `Regexp`, `UnaryOperation`, `Union`, `UnionAll`, `When`, and `With`. Previously, these node
+    types caused an exception to be raised by `Arel::Visitors::Dot#accept`.
 
-    Multiple database applications will now raise if `db:rollback` is call and recommend using the `db:rollback:[NAME]` to rollback migrations.
+    *Mike Dalessio*
 
-    *Eileen M. Uchitelle*
+*   Optimize `remove_columns` to use a single SQL statement.
 
-*   `Relation#pick` now uses already loaded results instead of making another query.
+    ```ruby
+    remove_columns :my_table, :col_one, :col_two
+    ```
 
-    *Eugene Kenny*
+    Now results in the following SQL:
 
-*   Deprecate using `return`, `break` or `throw` to exit a transaction block after writes.
+    ```sql
+    ALTER TABLE "my_table" DROP COLUMN "col_one", DROP COLUMN "col_two"
+    ```
 
-    *Dylan Thacker-Smith*
+    *Jon Dufresne*
 
-*   Dump the schema or structure of a database when calling `db:migrate:name`.
+*   Ensure `has_one` autosave association callbacks get called once.
 
-    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.
+    Change the `has_one` autosave callback to be non cyclic as well.
+    By doing this the autosave callback are made more consistent for
+    all 3 cases: `has_many`, `has_one`, and `belongs_to`.
 
-    Going forward, calls to `rails db:migrate:name` will dump the schema (or structure) of the database being migrated.
+    *Petrik de Heus*
 
-    *Kyle Thompson*
+*   Add option to disable joins for associations.
 
-*   Reset the `ActiveRecord::Base` connection after `rails db:migrate:name`.
+    In a multiple database application, associations can't join across
+    databases. When set, this option instructs Rails to generate 2 or
+    more queries rather than generating joins for associations.
 
-    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.
+    Set the option on a has many through association:
 
-    *Kyle Thompson*
+    ```ruby
+    class Dog
+      has_many :treats, through: :humans, disable_joins: true
+      has_many :humans
+    end
+    ```
 
-*   Disallow calling `connected_to` on subclasses of `ActiveRecord::Base`.
+    Then instead of generating join SQL, two queries are used for `@dog.treats`:
 
-    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.
+    ```
+    SELECT "humans"."id" FROM "humans" WHERE "humans"."dog_id" = ?  [["dog_id", 1]]
+    SELECT "treats".* FROM "treats" WHERE "treats"."human_id" IN (?, ?, ?)  [["human_id", 1], ["human_id", 2], ["human_id", 3]]
+    ```
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    *Eileen M. Uchitelle*, *Aaron Patterson*, *Lee Quarella*
 
-*   Add support for horizontal sharding to `connects_to` and `connected_to`.
+*   Add setting for enumerating column names in SELECT statements.
 
-    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.
+    Adding a column to a PostgreSQL database, for example, while the application is running can
+    change the result of wildcard `SELECT *` queries, which invalidates the result
+    of cached prepared statements and raises a `PreparedStatementCacheExpired` error.
 
-    Usage:
+    When enabled, Active Record will avoid wildcards and always include column names
+    in `SELECT` queries, which will return consistent results and avoid prepared
+    statement errors.
 
-    Given the following configuration:
+    Before:
 
-    ```yaml
-    # config/database.yml
-    production:
-      primary:
-        database: my_database
-      primary_shard_one:
-        database: my_database_shard_one
+    ```ruby
+    Book.limit(5)
+    # SELECT * FROM books LIMIT 5
     ```
 
-    Connect to multiple shards:
+    After:
 
     ```ruby
-    class ApplicationRecord < ActiveRecord::Base
-      self.abstract_class = true
+    # config/application.rb
+    module MyApp
+      class Application < Rails::Application
+        config.active_record.enumerate_columns_in_select_statements = true
+      end
+    end
 
-      connects_to shards: {
-        default: { writing: :primary },
-        shard_one: { writing: :primary_shard_one }
-      }
+    # or, configure per-model
+    class Book < ApplicationRecord
+      self.enumerate_columns_in_select_statements = true
+    end
     ```
 
-    Swap between shards in your controller / model code:
-
     ```ruby
-    ActiveRecord::Base.connected_to(shard: :shard_one) do
-      # Read from shard one
-    end
+    Book.limit(5)
+    # SELECT id, author_id, name, format, status, language, etc FROM books LIMIT 5
     ```
 
-    The horizontal sharding API also supports read replicas. See guides for more details.
+    *Matt Duszynski*
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+*   Allow passing SQL as `on_duplicate` value to `#upsert_all` to make it possible to use raw SQL to update columns on conflict:
 
-*   Deprecate `spec_name` in favor of `name` on database configurations.
+    ```ruby
+    Book.upsert_all(
+      [{ id: 1, status: 1 }, { id: 2, status: 1 }],
+      on_duplicate: Arel.sql("status = GREATEST(books.status, EXCLUDED.status)")
+    )
+    ```
 
-    The accessors for `spec_name` on `configs_for` and `DatabaseConfig` are deprecated. Please use `name` instead.
+    *Vladimir Dementyev*
 
-    Deprecated behavior:
+*   Allow passing SQL as `returning` statement to `#upsert_all`:
 
     ```ruby
-    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "development", spec_name: "primary")
-    db_config.spec_name
+    Article.insert_all(
+      [
+        { title: "Article 1", slug: "article-1", published: false },
+        { title: "Article 2", slug: "article-2", published: false }
+      ],
+      returning: Arel.sql("id, (xmax = '0') as inserted, name as new_name")
+    )
     ```
 
-    New behavior:
+    *Vladimir Dementyev*
 
-    ```ruby
-    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "development", name: "primary")
-    db_config.name
-    ```
+*   Deprecate `legacy_connection_handling`.
 
     *Eileen M. Uchitelle*
 
-*   Add additional database-specific rake tasks for multi-database users.
+*   Add attribute encryption support.
 
-    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:
+    Encrypted attributes are declared at the model level. These
+    are regular Active Record attributes backed by a column with
+    the same name. The system will transparently encrypt these
+    attributes before saving them into the database and will
+    decrypt them when retrieving their values.
 
-    ```
-    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
+
+    ```ruby
+    class Person < ApplicationRecord
+      encrypts :name
+      encrypts :email_address, deterministic: true
+    end
     ```
 
-    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:
+    You can learn more in the [Active Record Encryption
+    guide](https://edgeguides.rubyonrails.org/active_record_encryption.html).
 
-    ```
-    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
-    ```
+    *Jorge Manrubia*
 
-    *Kyle Thompson*
+*   Changed Arel predications `contains` and `overlaps` to use
+    `quoted_node` so that PostgreSQL arrays are quoted properly.
 
-*   Add support for `strict_loading` mode on association declarations.
+    *Bradley Priest*
 
-    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.
+*   Add mode argument to record level `strict_loading!`.
 
-    Usage:
+    This argument can be used when enabling strict loading for a single record
+    to specify that we only want to raise on n plus one queries.
 
     ```ruby
-    class Developer < ApplicationRecord
-      has_many :projects, strict_loading: true
-    end
+    developer.strict_loading!(mode: :n_plus_one_only)
 
-    dev = Developer.first
-    dev.projects.first
-    # => ActiveRecord::StrictLoadingViolationError: The projects association is marked as strict_loading and cannot be lazily loaded.
+    developer.projects.to_a # Does not raise
+    developer.projects.first.client # Raises StrictLoadingViolationError
     ```
 
-    *Kevin Deisz*
+    Previously, enabling strict loading would cause any lazily loaded
+    association to raise an error. Using `n_plus_one_only` mode allows us to
+    lazily load belongs_to, has_many, and other associations that are fetched
+    through a single query.
 
-*   Add support for `strict_loading` mode to prevent lazy loading of records.
+    *Dinah Shi*
 
-    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.
+*   Fix Float::INFINITY assignment to datetime column with postgresql adapter.
 
-    Usage:
+    Before:
 
     ```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.
-    ```
+    # With this config
+    ActiveRecord::Base.time_zone_aware_attributes = true
 
-    *Eileen M. Uchitelle*, *Aaron Patterson*
+    # and the following schema:
+    create_table "postgresql_infinities" do |t|
+      t.datetime "datetime"
+    end
 
-*   Add support for PostgreSQL 11+ partitioned indexes when using `upsert_all`.
+    # This test fails
+    record = PostgresqlInfinity.create!(datetime: Float::INFINITY)
+    assert_equal Float::INFINITY, record.datetime # record.datetime gets nil
+    ```
 
-    *Sebastián Palma*
+    After this commit, `record.datetime` gets `Float::INFINITY` as expected.
 
-*   Adds support for `if_not_exists` to `add_column` and `if_exists` to `remove_column`.
+    *Shunichi Ikegami*
 
-    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.
+*   Type cast enum values by the original attribute type.
 
-    Example Usage:
+    The notable thing about this change is that unknown labels will no longer match 0 on MySQL.
 
     ```ruby
-    class AddColumnTitle < ActiveRecord::Migration[6.1]
-      def change
-        add_column :posts, :title, :string, if_not_exists: true
-      end
+    class Book < ActiveRecord::Base
+      enum :status, { proposed: 0, written: 1, published: 2 }
     end
     ```
 
+    Before:
+
     ```ruby
-    class RemoveColumnTitle < ActiveRecord::Migration[6.1]
-      def change
-        remove_column :posts, :title, if_exists: true
-      end
-    end
+    # SELECT `books`.* FROM `books` WHERE `books`.`status` = 'prohibited' LIMIT 1
+    Book.find_by(status: :prohibited)
+    # => #<Book id: 1, status: "proposed", ...> (for mysql2 adapter)
+    # => ActiveRecord::StatementInvalid: PG::InvalidTextRepresentation: ERROR:  invalid input syntax for type integer: "prohibited" (for postgresql adapter)
+    # => nil (for sqlite3 adapter)
     ```
 
-    *Eileen M. Uchitelle*
-
-*   Regexp-escape table name for MS SQL Server.
-
-    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.
-
-    *Larry Reid*
-
-*   Store advisory locks on their own named connection.
+    After:
 
-    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.
+    ```ruby
+    # SELECT `books`.* FROM `books` WHERE `books`.`status` IS NULL LIMIT 1
+    Book.find_by(status: :prohibited)
+    # => nil (for all adapters)
+    ```
 
-    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.
+    *Ryuta Kamizono*
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+*   Fixtures for `has_many :through` associations now load timestamps on join tables.
 
-*   Allow schema cache path to be defined in the database configuration file.
+    Given this fixture:
 
-    For example:
+    ```yml
+    ### monkeys.yml
+    george:
+      name: George the Monkey
+      fruits: apple
 
-    ```yaml
-    development:
-      adapter: postgresql
-      database: blog_development
-      pool: 5
-      schema_cache_path: tmp/schema/main.yml
+    ### fruits.yml
+    apple:
+      name: apple
     ```
 
-    *Katrina Owen*
-
-*   Deprecate `#remove_connection` in favor of `#remove_connection_pool` when called on the handler.
+    If the join table (`fruit_monkeys`) contains `created_at` or `updated_at` columns,
+    these will now be populated when loading the fixture. Previously, fixture loading
+    would crash if these columns were required, and leave them as null otherwise.
 
-    `#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.
-
-    *Eileen M. Uchitelle*, *John Crepezzi*
-
-*   Deprecate `#default_hash` and it's alias `#[]` on database configurations.
+    *Alex Ghiculescu*
 
-    Applications should use `configs_for`. `#default_hash` and `#[]` will be removed in Rails 7.0.
+*   Allow applications to configure the thread pool for async queries.
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    Some applications may want one thread pool per database whereas others want to use
+    a single global thread pool for all queries. By default, Rails will set `async_query_executor`
+    to `nil` which will not initialize any executor. If `load_async` is called and no executor
+    has been configured, the query will be executed in the foreground.
 
-*   Add scale support to `ActiveRecord::Validations::NumericalityValidator`.
+    To create one thread pool for all database connections to use applications can set
+    `config.active_record.async_query_executor` to `:global_thread_pool` and optionally define
+    `config.active_record.global_executor_concurrency`. This defaults to 4. For applications that want
+    to have a thread pool for each database connection, `config.active_record.async_query_executor` can
+    be set to `:multi_thread_pool`. The configuration for each thread pool is set in the database
+    configuration.
 
-    *Gannon McGibbon*
+    *Eileen M. Uchitelle*
 
-*   Find orphans by looking for missing relations through chaining `where.missing`:
+*   Allow new syntax for `enum` to avoid leading `_` from reserved options.
 
     Before:
 
     ```ruby
-    Post.left_joins(:author).where(authors: { id: nil })
+    class Book < ActiveRecord::Base
+      enum status: [ :proposed, :written ], _prefix: true, _scopes: false
+      enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
+    end
     ```
 
     After:
 
     ```ruby
-    Post.where.missing(:author)
+    class Book < ActiveRecord::Base
+      enum :status, [ :proposed, :written ], prefix: true, scopes: false
+      enum :cover, [ :hard, :soft ], suffix: true, default: :hard
+    end
     ```
 
-    *Tom Rossi*
-
-*   Ensure `:reading` connections always raise if a write is attempted.
-
-    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`.
-
-    *Eileen M. Uchitelle*
-
-*   Deprecate `"primary"` as the `connection_specification_name` for `ActiveRecord::Base`.
-
-    `"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"`.
+    *Ryuta Kamizono*
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+*   Add `ActiveRecord::Relation#load_async`.
 
-*   Add `ActiveRecord::Validations::NumericalityValidator` with
-    support for casting floats using a database columns' precision value.
+    This method schedules the query to be performed asynchronously from a thread pool.
 
-    *Gannon McGibbon*
+    If the result is accessed before a background thread had the opportunity to perform
+    the query, it will be performed in the foreground.
 
-*   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.
+    This is useful for queries that can be performed long enough before their result will be
+    needed, or for controllers which need to perform several independent queries.
 
-    Fixes #38078.
+    ```ruby
+    def index
+      @categories = Category.some_complex_scope.load_async
+      @posts = Post.some_complex_scope.load_async
+    end
+    ```
 
-    *Aaron Lipman*
+    Active Record logs will also include timing info for the duration of how long
+    the main thread had to wait to access the result. This timing is useful to know
+    whether or not it's worth to load the query asynchronously.
 
-*   Skip test database when running `db:create` or `db:drop` in development
-    with `DATABASE_URL` set.
+    ```
+    DEBUG -- :   Category Load (62.1ms)  SELECT * FROM `categories` LIMIT 50
+    DEBUG -- :   ASYNC Post Load (64ms) (db time 126.1ms)  SELECT * FROM `posts` LIMIT 100
+    ```
 
-    *Brian Buchalter*
+    The duration in the first set of parens is how long the main thread was blocked
+    waiting for the results, and the second set of parens with "db time" is how long
+    the entire query took to execute.
 
-*   Don't allow mutations on the database configurations hash.
+    *Jean Boussier*
 
-    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.
+*   Implemented `ActiveRecord::Relation#excluding` method.
 
-    Before:
+    This method excludes the specified record (or collection of records) from
+    the resulting relation:
 
     ```ruby
-    @db_config = ActiveRecord::Base.configurations.configs_for(env_name: "test", spec_name: "primary")
-    @db_config.configuration_hash.merge!(idle_timeout: "0.02")
+    Post.excluding(post)
+    Post.excluding(post_one, post_two)
     ```
 
-    After:
+    Also works on associations:
 
     ```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)
+    post.comments.excluding(comment)
+    post.comments.excluding(comment_one, comment_two)
     ```
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
-
-*   Remove `:connection_id` from the `sql.active_record` notification.
+    This is short-hand for `Post.where.not(id: post.id)` (for a single record)
+    and `Post.where.not(id: [post_one.id, post_two.id])` (for a collection).
 
-    *Aaron Patterson*, *Rafael Mendonça França*
+    *Glen Crawford*
 
-*   The `:name` key will no longer be returned as part of `DatabaseConfig#configuration_hash`. Please use `DatabaseConfig#owner_name` instead.
+*   Skip optimised #exist? query when #include? is called on a relation
+    with a having clause.
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    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.
 
-*   ActiveRecord's `belongs_to_required_by_default` flag can now be set per model.
+    A sample query affected by this problem:
 
-    You can now opt-out/opt-in specific models from having their associations required
-    by default.
+    ```ruby
+    Author.select('COUNT(*) as total_posts', 'authors.*')
+          .joins(:posts)
+          .group(:id)
+          .having('total_posts > 2')
+          .include?(Author.first)
+    ```
 
-    This change is meant to ease the process of migrating all your models to have
-    their association required.
+    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.
 
-    *Edouard Chin*
+    Fixes #41417.
 
-*   The `connection_config` method has been deprecated, please use `connection_db_config` instead which will return a `DatabaseConfigurations::DatabaseConfig` instead of a `Hash`.
+    *Michael Smart*
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+*   Increment postgres prepared statement counter before making a prepared statement, so if the statement is aborted
+    without Rails knowledge (e.g., if app gets killed during long-running query or due to Rack::Timeout), app won't end
+    up in perpetual crash state for being inconsistent with PostgreSQL.
 
-*   Retain explicit selections on the base model after applying `includes` and `joins`.
+    *wbharding*, *Martin Tepper*
 
-    Resolves #34889.
+*   Add ability to apply `scoping` to `all_queries`.
 
-    *Patrick Rebsch*
+    Some applications may want to use the `scoping` method but previously it only
+    worked on certain types of queries. This change allows the `scoping` method to apply
+    to all queries for a model in a block.
 
-*   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.
+    ```ruby
+    Post.where(blog_id: post.blog_id).scoping(all_queries: true) do
+      post.update(title: "a post title") # adds `posts.blog_id = 1` to the query
+    end
+    ```
 
-    *Eileen M. Uchitelle*, *John Crepezzi*
+    *Eileen M. Uchitelle*
 
-*   Allow attributes to be fetched from Arel node groupings.
+*   `ActiveRecord::Calculations.calculate` called with `:average`
+    (aliased as `ActiveRecord::Calculations.average`) will now use column-based
+    type casting. This means that floating-point number columns will now be
+    aggregated as `Float` and decimal columns will be aggregated as `BigDecimal`.
 
-    *Jeff Emminger*, *Gannon McGibbon*
+    Integers are handled as a special case returning `BigDecimal` always
+    (this was the case before already).
 
-*   A database URL can now contain a querystring value that contains an equal sign. This is needed to support passing PostgreSQL `options`.
+    ```ruby
+    # With the following schema:
+    create_table "measurements" do |t|
+      t.float "temperature"
+    end
 
-    *Joshua Flanagan*
+    # Before:
+    Measurement.average(:temperature).class
+    # => BigDecimal
 
-*   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`.
+    # After:
+    Measurement.average(:temperature).class
+    # => Float
+    ```
 
-    *John Crepezzi*
+    Before this change, Rails just called `to_d` on average aggregates from the
+    database adapter. This is not the case anymore. If you relied on that kind
+    of magic, you now need to register your own `ActiveRecord::Type`
+    (see `ActiveRecord::Attributes::ClassMethods` for documentation).
 
-*   Specifying `implicit_order_column` now subsorts the records by primary key if available to ensure deterministic results.
+    *Josua Schmid*
 
-    *Paweł Urbanek*
+*   PostgreSQL: introduce `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type`.
 
-*   `where(attr => [])` now loads an empty result without making a query.
+    This setting controls what native type Active Record should use when you call `datetime` in
+    a migration or schema. It takes a symbol which must correspond to one of the configured
+    `NATIVE_DATABASE_TYPES`. The default is `:timestamp`, meaning `t.datetime` in a migration
+    will create a "timestamp without time zone" column. To use "timestamp with time zone",
+    change this to `:timestamptz` in an initializer.
 
-    *John Hawthorn*
+    You should run `bin/rails db:migrate` to rebuild your schema.rb if you change this.
 
-*   Fixed the performance regression for `primary_keys` introduced MySQL 8.0.
+    *Alex Ghiculescu*
 
-    *Hiroyuki Ishii*
+*   PostgreSQL: handle `timestamp with time zone` columns correctly in `schema.rb`.
 
-*   Add support for `belongs_to` to `has_many` inversing.
+    Previously they dumped as `t.datetime :column_name`, now they dump as `t.timestamptz :column_name`,
+    and are created as `timestamptz` columns when the schema is loaded.
 
-    *Gannon McGibbon*
+    *Alex Ghiculescu*
 
-*   Allow length configuration for `has_secure_token` method. The minimum length
-    is set at 24 characters.
+*   Removing trailing whitespace when matching columns in
+    `ActiveRecord::Sanitization.disallow_raw_sql!`.
 
-    Before:
+    *Gannon McGibbon*, *Adrian Hirt*
 
-    ```ruby
-    has_secure_token :auth_token
-    ```
+*   Expose a way for applications to set a `primary_abstract_class`.
 
-    After:
+    Multiple database applications that use a primary abstract class that is not
+    named `ApplicationRecord` can now set a specific class to be the `primary_abstract_class`.
 
     ```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
+    class PrimaryApplicationRecord
+      self.primary_abstract_class
+    end
     ```
 
-    *Bernardo de Araujo*
-
-*   Deprecate `DatabaseConfigurations#to_h`. These connection hashes are still available via `ActiveRecord::Base.configurations.configs_for`.
+    When an application boots it automatically connects to the primary or first database in the
+    database configuration file. In a multiple database application that then call `connects_to`
+    needs to know that the default connection is the same as the `ApplicationRecord` connection.
+    However, some applications have a differently named `ApplicationRecord`. This prevents Active
+    Record from opening duplicate connections to the same database.
 
-    *Eileen Uchitelle*, *John Crepezzi*
+    *Eileen M. Uchitelle*, *John Crepezzi*
 
-*   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.
+*   Support hash config for `structure_dump_flags` and `structure_load_flags` flags.
+    Now that Active Record supports multiple databases configuration,
+    we need a way to pass specific flags for dump/load databases since
+    the options are not the same for different adapters.
+    We can use in the original way:
 
-    *John Crepezzi*, *Eileen Uchitelle*
+    ```ruby
+    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = ['--no-defaults', '--skip-add-drop-table']
+    # or
+    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = '--no-defaults --skip-add-drop-table'
+    ```
 
-*   Allow column names to be passed to `remove_index` positionally along with other options.
+    And also use it passing a hash, with one or more keys, where the key
+    is the adapter
 
-    Passing other options can be necessary to make `remove_index` correctly reversible.
+    ```ruby
+    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = {
+      mysql2: ['--no-defaults', '--skip-add-drop-table'],
+      postgres: '--no-tablespaces'
+    }
+    ```
 
-    Before:
+    *Gustavo Gonzalez*
 
-        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
+*   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.
 
-    After:
+    Fixes #41137.
 
-        remove_index :reports, :report_id, unique: true # => works
+    *Jonathan Bracy*
 
-    *Eugene Kenny*
+*   Allow to opt-out of `strict_loading` mode on a per-record base.
 
-*   Allow bulk `ALTER` statements to drop and recreate indexes with the same name.
+    This is useful when strict loading is enabled application wide or on a
+    model level.
 
-    *Eugene Kenny*
+    ```ruby
+    class User < ApplicationRecord
+      has_many :bookmarks
+      has_many :articles, strict_loading: true
+    end
 
-*   `insert`, `insert_all`, `upsert`, and `upsert_all` now clear the query cache.
+    user = User.first
+    user.articles                        # => ActiveRecord::StrictLoadingViolationError
+    user.bookmarks                       # => #<ActiveRecord::Associations::CollectionProxy>
 
-    *Eugene Kenny*
+    user.strict_loading!(true)           # => true
+    user.bookmarks                       # => ActiveRecord::StrictLoadingViolationError
 
-*   Call `while_preventing_writes` directly from `connected_to`.
+    user.strict_loading!(false)          # => false
+    user.bookmarks                       # => #<ActiveRecord::Associations::CollectionProxy>
+    user.articles.strict_loading!(false) # => #<ActiveRecord::Associations::CollectionProxy>
+    ```
 
-    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)`.
+    *Ayrton De Craene*
 
-    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.
+*   Add `FinderMethods#sole` and `#find_sole_by` to find and assert the
+    presence of exactly one record.
 
-    *Eileen M. Uchitelle*
+    Used when you need a single row, but also want to assert that there aren't
+    multiple rows matching the condition; especially for when database
+    constraints aren't enough or are impractical.
 
-*   Improve detection of ActiveRecord::StatementTimeout with mysql2 adapter in the edge case when the query is terminated during filesort.
+    ```ruby
+    Product.where(["price = %?", price]).sole
+    # => ActiveRecord::RecordNotFound      (if no Product with given price)
+    # => #<Product ...>                    (if one Product with given price)
+    # => ActiveRecord::SoleRecordExceeded  (if more than one Product with given price)
 
-    *Kir Shatrov*
+    user.api_keys.find_sole_by(key: key)
+    # as above
+    ```
 
-*   Stop trying to read yaml file fixtures when loading Active Record fixtures.
+    *Asherah Connor*
 
-    *Gannon McGibbon*
+*   Makes `ActiveRecord::AttributeMethods::Query` respect the getter overrides defined in the model.
 
-*   Deprecate `.reorder(nil)` with `.first` / `.first!` taking non-deterministic result.
+    Before:
 
-    To continue taking non-deterministic result, use `.take` / `.take!` instead.
+    ```ruby
+    class User
+      def admin
+        false # Overriding the getter to always return false
+      end
+    end
 
-    *Ryuta Kamizono*
+    user = User.first
+    user.update(admin: true)
 
-*   Preserve user supplied joins order as much as possible.
+    user.admin # false (as expected, due to the getter overwrite)
+    user.admin? # true (not expected, returned the DB column value)
+    ```
 
-    Fixes #36761, #34328, #24281, #12953.
+    After this commit, `user.admin?` above returns false, as expected.
 
-    *Ryuta Kamizono*
+    Fixes #40771.
 
-*   Allow `matches_regex` and `does_not_match_regexp` on the MySQL Arel visitor.
+    *Felipe*
 
-    *James Pearson*
+*   Allow delegated_type to be specified primary_key and foreign_key.
 
-*   Allow specifying fixtures to be ignored by setting `ignore` in YAML file's '_fixture' section.
+    Since delegated_type assumes that the foreign_key ends with `_id`,
+    `singular_id` defined by it does not work when the foreign_key does
+    not end with `id`. This change fixes it by taking into account
+    `primary_key` and `foreign_key` in the options.
 
-    *Tongfei Gao*
+    *Ryota Egusa*
 
-*   Make the DATABASE_URL env variable only affect the primary connection. Add new env variables for multiple databases.
+*   Expose an `invert_where` method that will invert all scope conditions.
 
-    *John Crepezzi*, *Eileen Uchitelle*
+    ```ruby
+    class User
+      scope :active, -> { where(accepted: true, locked: false) }
+    end
 
-*   Add a warning for enum elements with 'not_' prefix.
+    User.active
+    # ... WHERE `accepted` = 1 AND `locked` = 0
 
-        class Foo
-          enum status: [:sent, :not_sent]
-        end
+    User.active.invert_where
+    # ... WHERE NOT (`accepted` = 1 AND `locked` = 0)
+    ```
 
-    *Edu Depetris*
+    *Kevin Deisz*
 
-*   Make currency symbols optional for money column type in PostgreSQL.
+*   Restore possibility of passing `false` to :polymorphic option of `belongs_to`.
 
-    *Joel Schneider*
+    Previously, passing `false` would trigger the option validation logic
+    to throw an error saying :polymorphic would not be a valid option.
 
-*   Add support for beginless ranges, introduced in Ruby 2.7.
+    *glaszig*
 
-    *Josh Goodall*
+*   Remove deprecated `database` kwarg from `connected_to`.
 
-*   Add `database_exists?` method to connection adapters to check if a database exists.
+    *Eileen M. Uchitelle*, *John Crepezzi*
 
-    *Guilherme Mansur*
+*   Allow adding nonnamed expression indexes to be revertible.
 
-*   Loading the schema for a model that has no `table_name` raises a `TableNotSpecified` error.
+    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.
 
-    *Guilherme Mansur*, *Eugene Kenny*
+    ```ruby
+    add_index(:items, "to_tsvector('english', description)")
+    ```
 
-*   PostgreSQL: Fix GROUP BY with ORDER BY virtual count attribute.
+    Fixes #40732.
 
-    Fixes #36022.
+    *fatkodima*
 
-    *Ryuta Kamizono*
+*   Only warn about negative enums if a positive form that would cause conflicts exists.
 
-*   Make ActiveRecord `ConnectionPool.connections` method thread-safe.
+    Fixes #39065.
 
-    Fixes #36465.
+    *Alex Ghiculescu*
 
-    *Jeff Doering*
+*   Add option to run `default_scope` on all queries.
 
-*   Add support for multiple databases to `rails db:abort_if_pending_migrations`.
+    Previously, a `default_scope` would only run on select or insert queries. In some cases, like non-Rails tenant sharding solutions, it may be desirable to run `default_scope` on all queries in order to ensure queries are including a foreign key for the shard (i.e. `blog_id`).
 
-    *Mark Lee*
+    Now applications can add an option to run on all queries including select, insert, delete, and update by adding an `all_queries` option to the default scope definition.
 
-*   Fix sqlite3 collation parsing when using decimal columns.
+    ```ruby
+    class Article < ApplicationRecord
+      default_scope -> { where(blog_id: Current.blog.id) }, all_queries: true
+    end
+    ```
 
-    *Martin R. Schuster*
+    *Eileen M. Uchitelle*
 
-*   Fix invalid schema when primary key column has a comment.
+*   Add `where.associated` to check for the presence of an association.
 
-    Fixes #29966.
+    ```ruby
+    # Before:
+    account.users.joins(:contact).where.not(contact_id: nil)
 
-    *Guilherme Goettems Schneider*
+    # After:
+    account.users.where.associated(:contact)
+    ```
 
-*   Fix table comment also being applied to the primary key column.
+    Also mirrors `where.missing`.
 
-    *Guilherme Goettems Schneider*
+    *Kasper Timm Hansen*
 
-*   Allow generated `create_table` migrations to include or skip timestamps.
+*   Allow constructors (`build_association` and `create_association`) on
+    `has_one :through` associations.
 
-    *Michael Duchemin*
+    *Santiago Perez Perret*
 
 
-Please check [6-0-stable](https://github.com/rails/rails/blob/6-0-stable/activerecord/CHANGELOG.md) for previous changes.
+Please check [6-1-stable](https://github.com/rails/rails/blob/6-1-stable/activerecord/CHANGELOG.md) for previous changes.