activerecord 5.2.8 → 7.0.2

data/CHANGELOG.md

@@ -1,1056 +1,1862 @@
-## Rails 5.2.8 (May 09, 2022) ##
+## Rails 7.0.2 (February 08, 2022) ##
 
-*   No changes.
+*   Fix `PG.connect` keyword arguments deprecation warning on ruby 2.7.
 
+    *Nikita Vasilevsky*
 
-## Rails 5.2.7.1 (April 26, 2022) ##
+*   Fix the ability to exclude encryption params from being autofiltered.
 
-*   No changes.
+    *Mark Gangl*
 
+*   Dump the precision for datetime columns following the new defaults.
 
-## Rails 5.2.7 (March 10, 2022) ##
+    *Rafael Mendonça França*
 
-*   No changes.
+*   Make sure encrypted attributes are not being filtered twice.
 
+    *Nikita Vasilevsky*
 
-## Rails 5.2.6.3 (March 08, 2022) ##
+*   Dump the database schema containing the current Rails version.
 
-*   No changes.
+    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:
 
-## Rails 5.2.6.2 (February 11, 2022) ##
+    ```
+    ActiveRecord::Schema[7.0].define
+    ```
 
-*   No changes.
+    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*
 
-## Rails 5.2.6.1 (February 11, 2022) ##
+*   Fix parsing expression for PostgreSQL generated column.
 
-*   No changes.
+    *fatkodima*
 
+*   Fix `Mysql2::Error: Commands out of sync; you can't run this command now`
+    when bulk-inserting fixtures that exceed `max_allowed_packet` configuration.
 
-## Rails 5.2.6 (May 05, 2021) ##
+    *Nikita Vasilevsky*
 
-*   No changes.
+*   Fix error when saving an association with a relation named `record`.
 
+    *Dorian Marié*
 
-## Rails 5.2.5 (March 26, 2021) ##
+*   Fix `MySQL::SchemaDumper` behavior about datetime precision value.
 
-*   No changes.
+    *y0t4*
 
+*   Improve associated with no reflection error.
 
-## Rails 5.2.4.6 (May 05, 2021) ##
+    *Nikolai*
 
-*   No changes.
+*   Fix PG.connect keyword arguments deprecation warning on ruby 2.7.
 
+    Fixes #44307.
 
-## Rails 5.2.4.5 (February 10, 2021) ##
+    *Nikita Vasilevsky*
 
-*   Fix possible DoS vector in PostgreSQL money type
+*   Fix passing options to `check_constraint` from `change_table`.
 
-    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.
+    *Frederick Cheung*
 
-    Thanks to @dee-see from Hackerone for this patch!
 
-    [CVE-2021-22880]
+## Rails 7.0.1 (January 06, 2022) ##
 
-    *Aaron Patterson*
 
+*   Change `QueryMethods#in_order_of` to drop records not listed in values.
 
-## Rails 5.2.4.4 (September 09, 2020) ##
+    `in_order_of` now filters down to the values provided, to match the behavior of the `Enumerable` version.
 
-*   No changes.
+    *Kevin Newton*
 
+*   Allow named expression indexes to be revertible.
 
-## Rails 5.2.4.3 (May 18, 2020) ##
+    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.
 
-*   No changes.
+    ```ruby
+    add_index(:settings, "(data->'property')", using: :gin, name: :index_settings_data_property)
+    ```
 
-## Rails 5.2.4.2 (March 19, 2020) ##
+    Fixes #43331.
 
-*   No changes.
+    *Oliver Günther*
 
+*   Better error messages when association name is invalid in the argument of `ActiveRecord::QueryMethods::WhereChain#missing`.
 
-## Rails 5.2.4.1 (December 18, 2019) ##
+    *ykpythemind*
 
-*   No changes.
+*   Fix ordered migrations for single db in multi db environment.
 
+    *Himanshu*
 
-## Rails 5.2.4 (November 27, 2019) ##
+*   Extract `on update CURRENT_TIMESTAMP` for mysql2 adapter.
 
-*   Fix circular `autosave: true` causes invalid records to be saved.
+    *Kazuhiro Masuda*
 
-    Prior to the fix, when there was a circular series of `autosave: true`
-    associations, the callback for a `has_many` association was run while
-    another instance of the same callback on the same association hadn't
-    finished running. When control returned to the first instance of the
-    callback, the instance variable had changed, and subsequent associated
-    records weren't saved correctly. Specifically, the ID field for the
-    `belongs_to` corresponding to the `has_many` was `nil`.
+*   Fix incorrect argument in PostgreSQL structure dump tasks.
 
-    Fixes #28080.
+    Updating the `--no-comment` argument added in Rails 7 to the correct `--no-comments` argument.
 
-    *Larry Reid*
+    *Alex Dent*
 
-*   PostgreSQL: Fix GROUP BY with ORDER BY virtual count attribute.
+*   Fix schema dumping column default SQL values for sqlite3.
 
-    Fixes #36022.
+    *fatkodima*
 
-    *Ryuta Kamizono*
+*   Correctly parse complex check constraint expressions for PostgreSQL.
 
-*   Fix sqlite3 collation parsing when using decimal columns.
+    *fatkodima*
 
-    *Martin R. Schuster*
+*   Fix `timestamptz` attributes on PostgreSQL handle blank inputs.
 
-*   Make ActiveRecord `ConnectionPool.connections` method thread-safe.
+    *Alex Ghiculescu*
 
-    Fixes #36465.
+*   Fix migration compatibility to create SQLite references/belongs_to column as integer when migration version is 6.0.
 
-    *Jeff Doering*
+    Reference/belongs_to in migrations with version 6.0 were creating columns as
+    bigint instead of integer for the SQLite Adapter.
 
-*   Assign all attributes before calling `build` to ensure the child record is visible in
-    `before_add` and `after_add` callbacks for `has_many :through` associations.
+    *Marcelo Lauxen*
 
-    Fixes #33249.
+*   Fix joining through a polymorphic association.
 
-    *Ryan H. Kerr*
+    *Alexandre Ruban*
 
+*   Fix `QueryMethods#in_order_of` to handle empty order list.
 
-## Rails 5.2.3 (March 27, 2019) ##
+    ```ruby
+    Post.in_order_of(:id, []).to_a
+    ```
 
-*   Fix different `count` calculation when using `size` with manual `select` with DISTINCT.
+    Also more explicitly set the column as secondary order, so that any other
+    value is still ordered.
 
-    Fixes #35214.
+    *Jean Boussier*
 
-    *Juani Villarejo*
+*   Fix `rails dbconsole` for 3-tier config.
 
-*   Fix prepared statements caching to be enabled even when query caching is enabled.
+    *Eileen M. Uchitelle*
 
-    *Ryuta Kamizono*
+*   Fix quoting of column aliases generated by calculation methods.
 
-*   Don't allow `where` with invalid value matches to nil values.
+    Since the alias is derived from the table name, we can't assume the result
+    is a valid identifier.
 
-    Fixes #33624.
+    ```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...
+    ```
 
-    *Ryuta Kamizono*
+    *Jean Boussier*
 
-*   Restore an ability that class level `update` without giving ids.
 
-    Fixes #34743.
+## Rails 7.0.0 (December 15, 2021) ##
 
-    *Ryuta Kamizono*
+*   Better handle SQL queries with invalid encoding.
 
-*   Fix join table column quoting with SQLite.
+    ```ruby
+    Post.create(name: "broken \xC8 UTF-8")
+    ```
 
-    *Gannon McGibbon*
+    Would cause all adapters to fail in a non controlled way in the code
+    responsible to detect write queries.
 
-*   Ensure that `delete_all` on collection proxy returns affected count.
+    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.
 
-    *Ryuta Kamizono*
+    *Jean Boussier*
 
-*   Reset scope after delete on collection association to clear stale offsets of removed records.
+*   Move database and shard selection config options to a generator.
 
-    *Gannon McGibbon*
+    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*
 
 
-## Rails 5.2.2.1 (March 11, 2019) ##
+## Rails 7.0.0.rc3 (December 14, 2021) ##
 
 *   No changes.
 
 
-## Rails 5.2.2 (December 04, 2018) ##
+## Rails 7.0.0.rc2 (December 14, 2021) ##
+
+*   No changes.
 
-*   Do not ignore the scoping with query methods in the scope block.
 
-    *Ryuta Kamizono*
+## Rails 7.0.0.rc1 (December 06, 2021) ##
 
-*   Allow aliased attributes to be used in `#update_columns` and `#update`.
+*   Remove deprecated `ActiveRecord::DatabaseConfigurations::DatabaseConfig#spec_name`.
 
-    *Gannon McGibbon*
+    *Rafael Mendonça França*
 
-*   Allow spaces in postgres table names.
+*   Remove deprecated `ActiveRecord::Connection#in_clause_length`.
 
-    Fixes issue where "user post" is misinterpreted as "\"user\".\"post\"" when quoting table names with the postgres
-    adapter.
+    *Rafael Mendonça França*
 
-    *Gannon McGibbon*
+*   Remove deprecated `ActiveRecord::Connection#allowed_index_name_length`.
 
-*   Cached columns_hash fields should be excluded from ResultSet#column_types
+    *Rafael Mendonça França*
 
-    PR #34528 addresses the inconsistent behaviour when attribute is defined for an ignored column. The following test
-    was passing for SQLite and MySQL, but failed for PostgreSQL:
+*   Remove deprecated `ActiveRecord::Base#remove_connection`.
+
+    *Rafael Mendonça França*
+
+*   Load STI Models in fixtures
+
+    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`
+
+    *Andres Howard*
+
+*   `#authenticate` returns false when the password is blank instead of raising an error.
+
+    *Muhammad Muhammad Ibrahim*
+
+*   Fix `ActiveRecord::QueryMethods#in_order_of` behavior for integer enums.
+
+    `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.
+
+    The following example now works as expected:
 
     ```ruby
-    class DeveloperName < ActiveRecord::Type::String
-      def deserialize(value)
-        "Developer: #{value}"
-      end
+    class Book < ApplicationRecord
+      enum status: [:proposed, :written, :published]
     end
 
-    class AttributedDeveloper < ActiveRecord::Base
-      self.table_name = "developers"
+    Book.in_order_of(:status, %w[written published proposed])
+    ```
 
-      attribute :name, DeveloperName.new
+    *Alexandre Ruban*
 
-      self.ignored_columns += ["name"]
-    end
+*   Ignore persisted in-memory records when merging target lists.
 
-    developer = AttributedDeveloper.create
-    developer.update_column :name, "name"
+    *Kevin Sjöberg*
 
-    loaded_developer = AttributedDeveloper.where(id: developer.id).select("*").first
-    puts loaded_developer.name # should be "Developer: name" but it's just "name"
+*   Add a new option `:update_only` to `upsert_all` to configure the list of columns to update in case of conflict.
+
+    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:
+
+    ```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
+    )
     ```
 
-    *Dmitry Tsepelev*
+    *Jorge Manrubia*
 
-*   Values of enum are frozen, raising an error when attempting to modify them.
+*   Remove deprecated `ActiveRecord::Result#map!` and `ActiveRecord::Result#collect!`.
 
-    *Emmanuel Byrd*
+    *Rafael Mendonça França*
 
-*   `update_columns` now correctly raises `ActiveModel::MissingAttributeError`
-    if the attribute does not exist.
+*   Remove deprecated `ActiveRecord::Base.configurations.to_h`.
 
-    *Sean Griffin*
+    *Rafael Mendonça França*
 
-*   Do not use prepared statement in queries that have a large number of binds.
+*   Remove deprecated `ActiveRecord::Base.configurations.default_hash`.
 
-    *Ryuta Kamizono*
+    *Rafael Mendonça França*
 
-*   Fix query cache to load before first request.
+*   Remove deprecated `ActiveRecord::Base.arel_attribute`.
 
-    *Eileen M. Uchitelle*
+    *Rafael Mendonça França*
 
-*   Fix collection cache key with limit and custom select to avoid ambiguous timestamp column error.
+*   Remove deprecated `ActiveRecord::Base.connection_config`.
 
-    Fixes #33056.
+    *Rafael Mendonça França*
 
-    *Federico Martinez*
+*   Filter attributes in SQL logs
 
-*   Fix duplicated record creation when using nested attributes with `create_with`.
+    Previously, SQL queries in logs containing `ActiveRecord::Base.filter_attributes` were not filtered.
 
-    *Darwin Wu*
+    Now, the filter attributes will be masked `[FILTERED]` in the logs when `prepared_statement` is enabled.
 
-*   Fix regression setting children record in parent `before_save` callback.
+    ```
+    # Before:
+      Foo Load (0.2ms)  SELECT "foos".* FROM "foos" WHERE "foos"."passw" = ? LIMIT ?  [["passw", "hello"], ["LIMIT", 1]]
 
-    *Guo Xiang Tan*
+    # After:
+      Foo Load (0.5ms)  SELECT "foos".* FROM "foos" WHERE "foos"."passw" = ? LIMIT ?  [["passw", "[FILTERED]"], ["LIMIT", 1]]
+    ```
 
-*   Prevent leaking of user's DB credentials on `rails db:create` failure.
+    *Aishwarya Subramanian*
 
-    *bogdanvlviv*
+*   Remove deprecated `Tasks::DatabaseTasks.spec`.
 
-*   Clear mutation tracker before continuing the around callbacks.
+    *Rafael Mendonça França*
 
-    *Yuya Tanaka*
+*   Remove deprecated `Tasks::DatabaseTasks.current_config`.
 
-*   Prevent deadlocks when waiting for connection from pool.
+    *Rafael Mendonça França*
 
-    *Brent Wheeldon*
+*   Deprecate `Tasks::DatabaseTasks.schema_file_type`.
 
-*   Avoid extra scoping when using `Relation#update` that was causing this method to change the current scope.
+    *Rafael Mendonça França*
 
-    *Ryuta Kamizono*
+*   Remove deprecated `Tasks::DatabaseTasks.dump_filename`.
 
-*   Fix numericality validator not to be affected by custom getter.
+    *Rafael Mendonça França*
 
-    *Ryuta Kamizono*
+*   Remove deprecated `Tasks::DatabaseTasks.schema_file`.
 
-*   Fix bulk change table ignores comment option on PostgreSQL.
+    *Rafael Mendonça França*
 
-    *Yoshiyuki Kinjo*
+*   Remove deprecated `environment` and `name` arguments from `Tasks::DatabaseTasks.schema_up_to_date?`.
 
+    *Rafael Mendonça França*
 
-## Rails 5.2.1.1 (November 27, 2018) ##
+*   Merging conditions on the same column no longer maintain both conditions,
+    and will be consistently replaced by the latter condition.
 
-*   No changes.
+    ```ruby
+    # Rails 6.1 (IN clause is replaced by merger side equality condition)
+    Author.where(id: [david.id, mary.id]).merge(Author.where(id: bob)) # => [bob]
+    # Rails 6.1 (both conflict conditions exists, deprecated)
+    Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => []
+    # Rails 6.1 with rewhere to migrate to Rails 7.0's behavior
+    Author.where(id: david.id..mary.id).merge(Author.where(id: bob), rewhere: true) # => [bob]
+    # Rails 7.0 (same behavior with IN clause, mergee side condition is consistently replaced)
+    Author.where(id: [david.id, mary.id]).merge(Author.where(id: bob)) # => [bob]
+    Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => [bob]
 
+    *Rafael Mendonça França*
 
-## Rails 5.2.1 (August 07, 2018) ##
+*   Remove deprecated support to `Model.reorder(nil).first` to search using non-deterministic order.
 
-*   PostgreSQL: Support new relkind for partitioned tables.
+    *Rafael Mendonça França*
 
-    Fixes #33008.
+*   Remove deprecated rake tasks:
 
-    *Yannick Schutz*
+    * `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}`
 
-*   Rollback parent transaction when children fails to update.
+    *Rafael Mendonça França*
 
-    *Guillaume Malette*
+*   Remove deprecated `DatabaseConfig#config` method.
 
-*   Fix default value for MySQL time types with specified precision.
+    *Rafael Mendonça França*
 
-    *Nikolay Kondratyev*
+*   Rollback transactions when the block returns earlier than expected.
 
-*   Fix `touch` option to behave consistently with `Persistence#touch` method.
+    Before this change, when a transaction block returned early, the transaction would be committed.
 
-    *Ryuta Kamizono*
+    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.
 
-*   Fix `save` in `after_create_commit` won't invoke extra `after_create_commit`.
+    *Rafael Mendonça França*
 
-    Fixes #32831.
+*   Add middleware for automatic shard swapping.
 
-    *Ryuta Kamizono*
+    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:
 
-*   Fix logic on disabling commit callbacks so they are not called unexpectedly when errors occur.
+    ```ruby
+    config.active_record.shard_resolver = ->(request) {
+      subdomain = request.subdomain
+      tenant = Tenant.find_by_subdomain!(subdomain)
+      tenant.shard
+    }
+    ```
 
-    *Brian Durand*
+    See guides for more details.
 
-*   Fix parent record should not get saved with duplicate children records.
+    *Eileen M. Uchitelle*, *John Crepezzi*
 
-    Fixes #32940.
+*   Remove deprecated support to pass a column to `type_cast`.
 
-    *Santosh Wadghule*
+    *Rafael Mendonça França*
 
-*   Fix that association's after_touch is not called with counter cache.
+*   Remove deprecated support to type cast to database values `ActiveRecord::Base` objects.
 
-    Fixes #31559.
+    *Rafael Mendonça França*
 
-    *Ryuta Kamizono*
+*   Remove deprecated support to quote `ActiveRecord::Base` objects.
 
-*   `becomes` should clear the mutation tracker which is created in `after_initialize`.
+    *Rafael Mendonça França*
 
-    Fixes #32867.
+*   Remove deprecacated support to resolve connection using `"primary"` as connection specification name.
 
-    *Ryuta Kamizono*
+    *Rafael Mendonça França*
 
-*   Allow a belonging to parent object to be created from a new record.
+*   Remove deprecation warning when using `:interval` column is used in PostgreSQL database.
 
-    *Jolyon Pawlyn*
+    Now, interval columns will return `ActiveSupport::Duration` objects instead of strings.
 
-*   Fix that building record with assigning multiple has_one associations
-    wrongly persists through record.
+    To keep the old behavior, you can add this line to your model:
 
-    Fixes #32511.
+    ```ruby
+    attribute :column, :string
+    ```
 
-    *Sam DeCesare*
+    *Rafael Mendonça França*
 
-*   Fix relation merging when one of the relations is going to skip the
-    query cache.
+*   Remove deprecated support to YAML load `ActiveRecord::Base` instance in the Rails 4.2 and 4.1 formats.
 
-    *James Williams*
+    *Rafael Mendonça França*
 
+*   Remove deprecated option `:spec_name` in the `configs_for` method.
 
-## Rails 5.2.0 (April 09, 2018) ##
+    *Rafael Mendonça França*
 
-*   MySQL: Support mysql2 0.5.x.
+*   Remove deprecated  `ActiveRecord::Base.allow_unsafe_raw_sql`.
 
-    *Aaron Stone*
+    *Rafael Mendonça França*
 
-*   Apply time column precision on assignment.
+*   Fix regression bug that caused ignoring additional conditions for preloading has_many-through relations.
 
-    PR #20317 changed the behavior of datetime columns so that when they
-    have a specified precision then on assignment the value is rounded to
-    that precision. This behavior is now applied to time columns as well.
+    Fixes #43132
 
-    Fixes #30301.
+    *Alexander Pauly*
 
-    *Andrew White*
+*   Fix `has_many` inversing recursion on models with recursive associations.
 
-*   Normalize time column values for SQLite database.
+    *Gannon McGibbon*
 
-    For legacy reasons, time columns in SQLite are stored as full datetimes
-    because until #24542 the quoting for time columns didn't remove the date
-    component. To ensure that values are consistent we now normalize the
-    date component to 2001-01-01 on reading and writing.
+*   Add `accepts_nested_attributes_for` support for `delegated_type`
 
-    *Andrew White*
+    ```ruby
+    class Entry < ApplicationRecord
+      delegated_type :entryable, types: %w[ Message Comment ]
+      accepts_nested_attributes_for :entryable
+    end
 
-*   Ensure that the date component is removed when quoting times.
+    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'
+    # ...>
+    ```
 
-    PR #24542 altered the quoting for time columns so that the date component
-    was removed however it only removed it when it was 2001-01-01. Now the
-    date component is removed irrespective of what the date is.
+    Previously it would raise an error:
 
-    *Andrew White*
+    ```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?
+    ```
 
-*   Fix `dependent: :destroy` issue for has_one/belongs_to relationship where
-    the parent class was getting deleted when the child was not.
+    *Sjors Baltus*
 
-    Fixes #32022.
+*   Use subquery for DELETE with GROUP_BY and HAVING clauses.
 
-    *Fernando Gorodscy*
+    Prior to this change, deletes with GROUP_BY and HAVING were returning an error.
 
-*   Whitelist `NULLS FIRST` and `NULLS LAST` in order clauses too.
+    After this change, GROUP_BY and HAVING are valid clauses in DELETE queries, generating the following query:
 
-    *Xavier Noria*
+    ```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"]]
+    ```
 
-*   Fix that after commit callbacks on update does not triggered when optimistic locking is enabled.
+    *Ignacio Chiazzo Cardarello*
 
-    *Ryuta Kamizono*
+*   Use subquery for UPDATE with GROUP_BY and HAVING clauses.
 
-*   Fix `#columns_for_distinct` of MySQL and PostgreSQL to make
-    `ActiveRecord::FinderMethods#limited_ids_for` use correct primary key values
-    even if `ORDER BY` columns include other table's primary key.
+    Prior to this change, updates with GROUP_BY and HAVING were being ignored, generating a SQL like this:
 
-    Fixes #28364.
+    ```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"]]
+    ```
+
+    After this change, GROUP_BY and HAVING clauses are used as a subquery in updates, like this:
 
-    *Takumi Kagiyama*
+    ```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"]]
+    ```
 
-*   Make `reflection.klass` raise if `polymorphic?` not to be misused.
+    *Ignacio Chiazzo Cardarello*
 
-    Fixes #31876.
+*   Add support for setting the filename of the schema or structure dump in the database config.
 
-    *Ryuta Kamizono*
+    Applications may now set their the filename or path of the schema / structure dump file in their database configuration.
 
-*   PostgreSQL: Allow pg-1.0 gem to be used with Active Record.
+    ```yaml
+    production:
+      primary:
+        database: my_db
+        schema_dump: my_schema_dump_filename.rb
+      animals:
+        database: animals_db
+        schema_dump: false
+    ```
 
-    *Lars Kanis*
+    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`.
 
-*   Deprecate `expand_hash_conditions_for_aggregates` without replacement.
-    Using a `Relation` for performing queries is the prefered API.
+    *Eileen M. Uchitelle*, *Ryan Kerr*
 
-    *Ryuta Kamizono*
+*   Add `ActiveRecord::Base.prohibit_shard_swapping` to prevent attempts to change the shard within a block.
+
+    *John Crepezzi*, *Eileen M. Uchitelle*
+
+*   Filter unchanged attributes with default function from insert query when `partial_inserts` is disabled.
+
+    *Akshay Birajdar*, *Jacopo Beschi*
+
+*   Add support for FILTER clause (SQL:2003) to Arel.
+
+    Currently supported by PostgreSQL 9.4+ and SQLite 3.30+.
+
+    *Andrey Novikov*
+
+*   Automatically set timestamps on record creation during bulk insert/upsert
+
+    Prior to this change, only updates during an upsert operation (e.g. `upsert_all`) would touch timestamps (`updated_{at,on}`). Now, record creations also touch timestamp columns (`{created,updated}_{at,on}`).
+
+    This behaviour is controlled by the `<model>.record_timestamps` config, matching the behaviour of `create`, `update`, etc. It can also be overridden by using the `record_timestamps:` keyword argument.
 
-*   Fix not expanded problem when passing an Array object as argument to the where method using `composed_of` column.
+    Note that this means `upsert_all` on models with `record_timestamps = false` will no longer touch `updated_{at,on}` automatically.
 
+    *Sam Bostock*
+
+*   Don't require `role` when passing `shard` to `connected_to`.
+
+    `connected_to` can now be called with a `shard` only. Note that `role` is still inherited if `connected_to` calls are nested.
+
+    *Eileen M. Uchitelle*
+
+*   Add option to lazily load the schema cache on the connection.
+
+    Previously, the only way to load the schema cache in Active Record was through the Railtie on boot. This option provides the ability to load the schema cache on the connection after it's been established. Loading the cache lazily on the connection can be beneficial for Rails applications that use multiple databases because it will load the cache at the time the connection is established. Currently Railties doesn't have access to the connections before boot.
+
+    To use the cache, set `config.active_record.lazily_load_schema_cache = true` in your application configuration. In addition a `schema_cache_path` should be set in your database configuration if you don't want to use the default "db/schema_cache.yml" path.
+
+    *Eileen M. Uchitelle*
+
+*   Allow automatic `inverse_of` detection for associations with scopes.
+
+    Automatic `inverse_of` detection now works for associations with scopes. For
+    example, the `comments` association here now automatically detects
+    `inverse_of: :post`, so we don't need to pass that option:
+
+    ```ruby
+    class Post < ActiveRecord::Base
+      has_many :comments, -> { visible }
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
     ```
-    david_balance = customers(:david).balance
-    Customer.where(balance: [david_balance]).to_sql
 
-    # Before: WHERE `customers`.`balance` = NULL
-    # After : WHERE `customers`.`balance` = 50
+    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
     ```
 
-    Fixes #31723.
+    *Daniel Colson*, *Chris Bloom*
 
-    *Yutaro Kanagawa*
+*   Accept optional transaction args to `ActiveRecord::Locking::Pessimistic#with_lock`
 
-*   Fix `count(:all)` with eager loading and having an order other than the driving table.
+    `#with_lock` now accepts transaction options like `requires_new:`,
+    `isolation:`, and `joinable:`
 
-    Fixes #31783.
+    *John Mileham*
 
-    *Ryuta Kamizono*
+*   Adds support for deferrable foreign key constraints in PostgreSQL.
 
-*   Clear the transaction state when an Active Record object is duped.
+    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.
 
-    Fixes #31670.
+    ```ruby
+    Person.transaction do
+      alias = Alias
+        .create_with(user_id: SecureRandom.uuid)
+        .create_or_find_by(name: "DHH")
+
+      person = Person
+        .create_with(name: "David Heinemeier Hansson")
+        .create_or_find_by(id: alias.user_id)
+    end
+    ```
 
-    *Yuriy Ustushenko*
+    Using the default behavior, the transaction would fail when executing the first `INSERT` statement.
 
-*   Support for PostgreSQL foreign tables.
+    By passing the `:deferrable` option to the `add_foreign_key` statement in migrations, it's possible to defer this
+    check.
 
-    *fatkodima*
+    ```ruby
+    add_foreign_key :aliases, :person, deferrable: true
+    ```
 
-*   Fix relation merger issue with `left_outer_joins`.
+    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.
 
-    *Mehmet Emin İNAÇ*
+    It's also possible to adjust the default behavior from an immediate check (after the statement), to a deferred check
+    (after the transaction):
 
-*   Don't allow destroyed object mutation after `save` or `save!` is called.
+    ```ruby
+    add_foreign_key :aliases, :person, deferrable: :deferred
+    ```
 
-    *Ryuta Kamizono*
+    *Benedikt Deicke*
 
-*   Take into account association conditions when deleting through records.
+*   Allow configuring Postgres password through the socket URL.
 
-    Fixes #18424.
+    For example:
+    ```ruby
+    ActiveRecord::DatabaseConfigurations::UrlConfig.new(
+      :production, :production, 'postgres:///?user=user&password=secret&dbname=app', {}
+    ).configuration_hash
+    ```
 
-    *Piotr Jakubowski*
+    will now return,
 
-*   Fix nested `has_many :through` associations on unpersisted parent instances.
+    ```ruby
+    { :user=>"user", :password=>"secret", :dbname=>"app", :adapter=>"postgresql" }
+    ```
 
-    For example, if you have
+    *Abeid Ahmed*
 
-        class Post < ActiveRecord::Base
-          belongs_to :author
-          has_many :books, through: :author
-          has_many :subscriptions, through: :books
-        end
+*   PostgreSQL: support custom enum types
 
-        class Author < ActiveRecord::Base
-          has_one :post
-          has_many :books
-          has_many :subscriptions, through: :books
-        end
+    In migrations, use `create_enum` to add a new enum type, and `t.enum` to add a column.
 
-        class Book < ActiveRecord::Base
-          belongs_to :author
-          has_many :subscriptions
-        end
+    ```ruby
+    def up
+      create_enum :mood, ["happy", "sad"]
 
-        class Subscription < ActiveRecord::Base
-          belongs_to :book
-        end
+      change_table :cats do |t|
+        t.enum :current_mood, enum_type: "mood", default: "happy", null: false
+      end
+    end
+    ```
 
-    Before:
+    Enums will be presented correctly in `schema.rb`. Note that this is only supported by
+    the PostgreSQL adapter.
 
-    If `post` is not persisted, then `post.subscriptions` will be empty.
+    *Alex Ghiculescu*
 
-    After:
+*   Avoid COMMENT statements in PostgreSQL structure dumps
 
-    If `post` is not persisted, then `post.subscriptions` can be set and used
-    just like it would if `post` were persisted.
+    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.
 
-    Fixes #16313.
+    Fixes #36816, #43107.
 
-    *Zoltan Kiss*
+    *Janosch Müller*
 
-*   Fixed inconsistency with `first(n)` when used with `limit()`.
-    The `first(n)` finder now respects the `limit()`, making it consistent
-    with `relation.to_a.first(n)`, and also with the behavior of `last(n)`.
+*   Add support for generated columns in PostgreSQL adapter
 
-    Fixes #23979.
+    Generated columns are supported since version 12.0 of PostgreSQL. This adds
+    support of those to the PostgreSQL adapter.
 
-    *Brian Christian*
+    ```ruby
+    create_table :users do |t|
+      t.string :name
+      t.virtual :name_upcased, type: :string, as: 'upper(name)', stored: true
+    end
+    ```
 
-*   Use `count(:all)` in `HasManyAssociation#count_records` to prevent invalid
-    SQL queries for association counting.
+    *Michał Begejowicz*
 
-    *Klas Eskilson*
 
-*   Fix to invoke callbacks when using `update_attribute`.
+## Rails 7.0.0.alpha2 (September 15, 2021) ##
 
-    *Mike Busch*
+*   No changes.
 
-*   Fix `count(:all)` to correctly work `distinct` with custom SELECT list.
 
-    *Ryuta Kamizono*
+## Rails 7.0.0.alpha1 (September 15, 2021) ##
 
-*   Using subselect for `delete_all` with `limit` or `offset`.
+*   Remove warning when overwriting existing scopes
 
-    *Ryuta Kamizono*
+    Removes the following unnecessary warning message that appeared when overwriting existing scopes
 
-*   Undefine attribute methods on descendants when resetting column
-    information.
+    ```
+    Creating scope :my_scope_name. Overwriting existing method "MyClass.my_scope_name" when overwriting existing scopes
+    ```
 
-    *Chris Salzberg*
+     *Weston Ganger*
+
+*   Use full precision for `updated_at` in `insert_all`/`upsert_all`
+
+    `CURRENT_TIMESTAMP` provides differing precision depending on the database,
+    and not all databases support explicitly specifying additional precision.
+
+    Instead, we delegate to the new `connection.high_precision_current_timestamp`
+    for the SQL to produce a high precision timestamp on the current database.
+
+    Fixes #42992
+
+    *Sam Bostock*
+
+*   Add ssl support for postgresql database tasks
+
+    Add `PGSSLMODE`, `PGSSLCERT`, `PGSSLKEY` and `PGSSLROOTCERT` to pg_env from database config
+    when running postgresql database tasks.
+
+    ```yaml
+    # config/database.yml
+
+    production:
+      sslmode: verify-full
+      sslcert: client.crt
+      sslkey: client.key
+      sslrootcert: ca.crt
+    ```
+
+    Environment variables
+
+    ```
+    PGSSLMODE=verify-full
+    PGSSLCERT=client.crt
+    PGSSLKEY=client.key
+    PGSSLROOTCERT=ca.crt
+    ```
+
+    Fixes #42994
 
-*   Log database query callers.
+    *Michael Bayucot*
 
-    Add `verbose_query_logs` configuration option to display the caller
-    of database queries in the log to facilitate N+1 query resolution
-    and other debugging.
+*   Avoid scoping update callbacks in `ActiveRecord::Relation#update!`.
 
-    Enabled in development only for new and upgraded applications. Not
-    recommended for use in the production environment since it relies
-    on Ruby's `Kernel#caller_locations` which is fairly slow.
+    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.
 
-    *Olivier Lacan*
+    *Dylan Thacker-Smith*
 
-*   Fix conflicts `counter_cache` with `touch: true` by optimistic locking.
+*   Fix 2 cases that inferred polymorphic class from the association's `foreign_type`
+    using `String#constantize` instead of the model's `polymorphic_class_for`.
 
+    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`
+
+    *Jimmy Bourassa*
+
+*   Add config option for ignoring tables when dumping the schema cache.
+
+    Applications can now be configured to ignore certain tables when dumping the schema cache.
+
+    The configuration option can table an array of tables:
+
+    ```ruby
+    config.active_record.schema_cache_ignored_tables = ["ignored_table", "another_ignored_table"]
+    ```
+
+    Or a regex:
+
+    ```ruby
+    config.active_record.schema_cache_ignored_tables = [/^_/]
+    ```
+
+    *Eileen M. Uchitelle*
+
+*   Make schema cache methods return consistent results.
+
+    Previously the schema cache methods `primary_keys`, `columns`, `columns_hash`, and `indexes`
+    would behave differently than one another when a table didn't exist and differently across
+    database adapters. This change unifies the behavior so each method behaves the same regardless
+    of adapter.
+
+    The behavior now is:
+
+    `columns`: (unchanged) raises a db error if the table does not exist.
+    `columns_hash`: (unchanged) raises a db error if the table does not exist.
+    `primary_keys`: (unchanged) returns `nil` if the table does not exist.
+    `indexes`: (changed for mysql2) returns `[]` if the table does not exist.
+
+    *Eileen M. Uchitelle*
+
+*   Reestablish connection to previous database after after running `db:schema:load:name`
+
+    After running `db:schema:load:name` the previous connection is restored.
+
+    *Jacopo Beschi*
+
+*   Add database config option `database_tasks`
+
+    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`
+
+    ```yaml
+    # config/database.yml
+
+    production:
+      primary:
+        database: my_database
+        adapter: mysql2
+      animals:
+        database: my_animals_database
+        adapter: mysql2
+        database_tasks: false
     ```
-    # create_table :posts do |t|
-    #   t.integer :comments_count, default: 0
-    #   t.integer :lock_version
-    #   t.timestamps
-    # end
-    class Post < ApplicationRecord
+
+    *Weston Ganger*
+
+*   Fix `ActiveRecord::InternalMetadata` to not be broken by `config.active_record.record_timestamps = false`
+
+    Since the model always create the timestamp columns, it has to set them, otherwise it breaks
+    various DB management tasks.
+
+    Fixes #42983
+
+*   Add `ActiveRecord::QueryLogs`.
+
+    Configurable tags can be automatically added to all SQL queries generated by Active Record.
+
+    ```ruby
+    # config/application.rb
+    module MyApp
+      class Application < Rails::Application
+        config.active_record.query_log_tags_enabled = true
+      end
     end
+    ```
 
-    # create_table :comments do |t|
-    #   t.belongs_to :post
-    # end
-    class Comment < ApplicationRecord
-      belongs_to :post, touch: true, counter_cache: true
+    By default the application, controller and action details are added to the query tags:
+
+    ```ruby
+    class BooksController < ApplicationController
+      def index
+        @books = Book.all
+      end
     end
     ```
 
-    Before:
+    ```ruby
+    GET /books
+    # SELECT * FROM books /*application:MyApp;controller:books;action:index*/
+    ```
+
+    Custom tags containing static values and Procs can be defined in the application configuration:
+
+    ```ruby
+    config.active_record.query_log_tags = [
+      :application,
+      :controller,
+      :action,
+      {
+        custom_static: "foo",
+        custom_dynamic: -> { Time.now }
+      }
+    ]
     ```
-    post = Post.create!
-    # => begin transaction
-         INSERT INTO "posts" ("created_at", "updated_at", "lock_version")
-         VALUES ("2017-12-11 21:27:11.387397", "2017-12-11 21:27:11.387397", 0)
-         commit transaction
 
-    comment = Comment.create!(post: post)
-    # => begin transaction
-         INSERT INTO "comments" ("post_id") VALUES (1)
+    *Keeran Raj Hawoldar*, *Eileen M. Uchitelle*, *Kasper Timm Hansen*
+
+*   Added support for multiple databases to `rails db:setup` and `rails db:reset`.
+
+    *Ryan Hall*
+
+*   Add `ActiveRecord::Relation#structurally_compatible?`.
 
-         UPDATE "posts" SET "comments_count" = COALESCE("comments_count", 0) + 1,
-         "lock_version" = COALESCE("lock_version", 0) + 1 WHERE "posts"."id" = 1
+    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.
 
-         UPDATE "posts" SET "updated_at" = '2017-12-11 21:27:11.398330',
-         "lock_version" = 1 WHERE "posts"."id" = 1 AND "posts"."lock_version" = 0
-         rollback transaction
-    # => ActiveRecord::StaleObjectError: Attempted to touch a stale object: Post.
+    *Kevin Newton*
 
-    Comment.take.destroy!
-    # => begin transaction
-         DELETE FROM "comments" WHERE "comments"."id" = 1
+*   Add `ActiveRecord::QueryMethods#in_order_of`.
 
-         UPDATE "posts" SET "comments_count" = COALESCE("comments_count", 0) - 1,
-         "lock_version" = COALESCE("lock_version", 0) + 1 WHERE "posts"."id" = 1
+    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:
 
-         UPDATE "posts" SET "updated_at" = '2017-12-11 21:42:47.785901',
-         "lock_version" = 1 WHERE "posts"."id" = 1 AND "posts"."lock_version" = 0
-         rollback transaction
-    # => ActiveRecord::StaleObjectError: Attempted to touch a stale object: Post.
+    ```ruby
+    Post.in_order_of(:id, [3, 5, 1])
     ```
 
-    After:
+    will generate the SQL:
+
+    ```sql
+    SELECT "posts".* FROM "posts" ORDER BY CASE "posts"."id" WHEN 3 THEN 1 WHEN 5 THEN 2 WHEN 1 THEN 3 ELSE 4 END ASC
+    ```
+
+    However, because this functionality is built into MySQL in the form of the
+    `FIELD` function, that connection adapter will generate the following SQL
+    instead:
+
+    ```sql
+    SELECT "posts".* FROM "posts" ORDER BY FIELD("posts"."id", 1, 5, 3) DESC
     ```
-    post = Post.create!
-    # => begin transaction
-         INSERT INTO "posts" ("created_at", "updated_at", "lock_version")
-         VALUES ("2017-12-11 21:27:11.387397", "2017-12-11 21:27:11.387397", 0)
-         commit transaction
 
-    comment = Comment.create!(post: post)
-    # => begin transaction
-         INSERT INTO "comments" ("post_id") VALUES (1)
+    *Kevin Newton*
 
-         UPDATE "posts" SET "comments_count" = COALESCE("comments_count", 0) + 1,
-         "lock_version" = COALESCE("lock_version", 0) + 1,
-         "updated_at" = '2017-12-11 21:37:09.802642' WHERE "posts"."id" = 1
-         commit transaction
+*   Fix `eager_loading?` when ordering with `Symbol`.
 
-    comment.destroy!
-    # => begin transaction
-         DELETE FROM "comments" WHERE "comments"."id" = 1
+    `eager_loading?` is triggered correctly when using `order` with symbols.
 
-         UPDATE "posts" SET "comments_count" = COALESCE("comments_count", 0) - 1,
-         "lock_version" = COALESCE("lock_version", 0) + 1,
-         "updated_at" = '2017-12-11 21:39:02.685520' WHERE "posts"."id" = 1
-         commit transaction
+    ```ruby
+    scope = Post.includes(:comments).order(:"comments.label")
+    => true
     ```
 
-    Fixes #31199.
+    *Jacopo Beschi*
 
-    *bogdanvlviv*
+*   Two change tracking methods are added for `belongs_to` associations.
 
-*   Add support for PostgreSQL operator classes to `add_index`.
+    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.
 
-    Example:
+    The `association_previously_changed?` method returns true if the previous save updated the
+    association to reference a different associated object.
 
-        add_index :users, :name, using: :gist, opclass: { name: :gist_trgm_ops }
+    *George Claghorn*
 
-    *Greg Navis*
+*   Add option to disable schema dump per-database.
 
-*   Don't allow scopes to be defined which conflict with instance methods on `Relation`.
+    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:
 
-    Fixes #31120.
+    ```yaml
+    # config/database.yml
 
-    *kinnrot*
+    production:
+      schema_dump: false
+    ```
 
-*   Add new error class `QueryCanceled` which will be raised
-    when canceling statement due to user request.
+    *Luis Vasconcellos*, *Eileen M. Uchitelle*
 
-    *Ryuta Kamizono*
+*   Fix `eager_loading?` when ordering with `Hash` syntax.
 
-*   Add `#up_only` to database migrations for code that is only relevant when
-    migrating up, e.g. populating a new column.
+    `eager_loading?` is triggered correctly when using `order` with hash syntax
+    on an outer table.
 
-    *Rich Daley*
+    ```ruby
+    Post.includes(:comments).order({ "comments.label": :ASC }).eager_loading?
+    # => true
+    ```
 
-*   Require raw SQL fragments to be explicitly marked when used in
-    relation query methods.
+    *Jacopo Beschi*
 
-    Before:
+*   Move the forcing of clear text encoding to the `ActiveRecord::Encryption::Encryptor`.
+
+    Fixes #42699.
+
+    *J Smith*
+
+*   `partial_inserts` is now disabled by default in new apps.
+
+    This will be the default for new apps in Rails 7. To opt in:
+
+    ```ruby
+    config.active_record.partial_inserts = true
     ```
-    Article.order("LENGTH(title)")
+
+    If a migration removes the default value of a column, this option
+    would cause old processes to no longer be able to create new records.
+
+    If you need to remove a column, you should first use `ignored_columns`
+    to stop using it.
+
+    *Jean Boussier*
+
+*   Rails can now verify foreign keys after loading fixtures in tests.
+
+    This will be the default for new apps in Rails 7. To opt in:
+
+    ```ruby
+    config.active_record.verify_foreign_keys_for_fixtures = true
     ```
 
-    After:
+    Tests will not run if there is a foreign key constraint violation in your fixture data.
+
+    The feature is supported by SQLite and PostgreSQL, other adapters can also add support for it.
+
+    *Alex Ghiculescu*
+
+*   Clear cached `has_one` association after setting `belongs_to` association to `nil`.
+
+    After setting a `belongs_to` relation to `nil` and updating an unrelated attribute on the owner,
+    the owner should still return `nil` on the `has_one` relation.
+
+    Fixes #42597.
+
+    *Michiel de Mare*
+
+*   OpenSSL constants are now used for Digest computations.
+
+    *Dirkjan Bussink*
+
+*   Adds support for `if_not_exists` to `add_foreign_key` and `if_exists` to `remove_foreign_key`.
+
+    Applications can set their migrations to ignore exceptions raised when adding a foreign key
+    that already exists or when removing a foreign key that does not exist.
+
+    Example Usage:
+
+    ```ruby
+    class AddAuthorsForeignKeyToArticles < ActiveRecord::Migration[7.0]
+      def change
+        add_foreign_key :articles, :authors, if_not_exists: true
+      end
+    end
     ```
-    Article.order(Arel.sql("LENGTH(title)"))
+
+    ```ruby
+    class RemoveAuthorsForeignKeyFromArticles < ActiveRecord::Migration[7.0]
+      def change
+        remove_foreign_key :articles, :authors, if_exists: true
+      end
+    end
     ```
 
-    This prevents SQL injection if applications use the [strongly
-    discouraged] form `Article.order(params[:my_order])`, under the
-    mistaken belief that only column names will be accepted.
+    *Roberto Miranda*
+
+*   Prevent polluting ENV during postgresql structure dump/load.
+
+    Some configuration parameters were provided to pg_dump / psql via
+    environment variables which persisted beyond the command being run, and may
+    have caused subsequent commands and connections to fail. Tasks running
+    across multiple postgresql databases like `rails db:test:prepare` may have
+    been affected.
 
-    Raw SQL strings will now cause a deprecation warning, which will
-    become an UnknownAttributeReference error in Rails 6.0. Applications
-    can opt in to the future behavior by setting `allow_unsafe_raw_sql`
-    to `:disabled`.
+    *Samuel Cochran*
 
-    Common and judged-safe string values (such as simple column
-    references) are unaffected:
+*   Set precision 6 by default for `datetime` columns.
+
+    By default, datetime columns will have microseconds precision instead of seconds precision.
+
+    *Roberto Miranda*
+
+*   Allow preloading of associations with instance dependent scopes.
+
+    *John Hawthorn*, *John Crepezzi*, *Adam Hess*, *Eileen M. Uchitelle*, *Dinah Shi*
+
+*   Do not try to rollback transactions that failed due to a `ActiveRecord::TransactionRollbackError`.
+
+    *Jamie McCarthy*
+
+*   Active Record Encryption will now encode values as UTF-8 when using deterministic
+    encryption. The encoding is part of the encrypted payload, so different encodings for
+    different values result in different ciphertexts. This can break unique constraints and
+    queries.
+
+    The new behavior is configurable via `active_record.encryption.forced_encoding_for_deterministic_encryption`
+    that is `Encoding::UTF_8` by default. It can be disabled by setting it to `nil`.
+
+    *Jorge Manrubia*
+
+*   The MySQL adapter now cast numbers and booleans bind parameters to string for safety reasons.
+
+    When comparing a string and a number in a query, MySQL converts the string to a number. So for
+    instance `"foo" = 0`, will implicitly cast `"foo"` to `0` and will evaluate to `TRUE` which can
+    lead to security vulnerabilities.
+
+    Active Record already protect against that vulnerability when it knows the type of the column
+    being compared, however until now it was still vulnerable when using bind parameters:
+
+    ```ruby
+    User.where("login_token = ?", 0).first
     ```
-    Article.order("title DESC")
+
+    Would perform:
+
+    ```sql
+    SELECT * FROM `users` WHERE `login_token` = 0 LIMIT 1;
     ```
 
-    *Ben Toews*
+    Now it will perform:
 
-*   `update_all` will now pass its values to `Type#cast` before passing them to
-    `Type#serialize`. This means that `update_all(foo: 'true')` will properly
-    persist a boolean.
+    ```sql
+    SELECT * FROM `users` WHERE `login_token` = '0' LIMIT 1;
+    ```
 
-    *Sean Griffin*
+    *Jean Boussier*
 
-*   Add new error class `StatementTimeout` which will be raised
-    when statement timeout exceeded.
+*   Fixture configurations (`_fixture`) are now strictly validated.
 
-    *Ryuta Kamizono*
+    If an error will be raised if that entry contains unknown keys while previously it
+    would silently have no effects.
 
-*   Fix `bin/rails db:migrate` with specified `VERSION`.
-    `bin/rails db:migrate` with empty VERSION behaves as without `VERSION`.
-    Check a format of `VERSION`: Allow a migration version number
-    or name of a migration file. Raise error if format of `VERSION` is invalid.
-    Raise error if target migration doesn't exist.
+    *Jean Boussier*
 
-    *bogdanvlviv*
+*   Add `ActiveRecord::Base.update!` that works like `ActiveRecord::Base.update` but raises exceptions.
 
-*   Fixed a bug where column orders for an index weren't written to
-    `db/schema.rb` when using the sqlite adapter.
+    This allows for the same behavior as the instance method `#update!` at a class level.
 
-    Fixes #30902.
+    ```ruby
+    Person.update!(:all, state: "confirmed")
+    ```
 
-    *Paul Kuruvilla*
+    *Dorian Marié*
 
-*   Remove deprecated method `#sanitize_conditions`.
+*   Add `ActiveRecord::Base#attributes_for_database`.
 
-    *Rafael Mendonça França*
+    Returns attributes with values for assignment to the database.
 
-*   Remove deprecated method `#scope_chain`.
+    *Chris Salzberg*
 
-    *Rafael Mendonça França*
+*   Use an empty query to check if the PostgreSQL connection is still active.
 
-*   Remove deprecated configuration `.error_on_ignored_order_or_limit`.
+    An empty query is faster than `SELECT 1`.
 
-    *Rafael Mendonça França*
+    *Heinrich Lee Yu*
 
-*   Remove deprecated arguments from `#verify!`.
+*   Add `ActiveRecord::Base#previously_persisted?`.
 
-    *Rafael Mendonça França*
+    Returns `true` if the object has been previously persisted but now it has been deleted.
 
-*   Remove deprecated argument `name` from `#indexes`.
+*   Deprecate `partial_writes` in favor of `partial_inserts` and `partial_updates`.
 
-    *Rafael Mendonça França*
+    This allows to have a different behavior on update and create.
 
-*   Remove deprecated method `ActiveRecord::Migrator.schema_migrations_table_name`.
+    *Jean Boussier*
 
-    *Rafael Mendonça França*
+*   Fix compatibility with `psych >= 4`.
 
-*   Remove deprecated method `supports_primary_key?`.
+    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.
 
-    *Rafael Mendonça França*
+    *Jean Boussier*
 
-*   Remove deprecated method `supports_migrations?`.
+*   `ActiveRecord::Base.logger` is now a `class_attribute`.
 
-    *Rafael Mendonça França*
+    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.
 
-*   Remove deprecated methods `initialize_schema_migrations_table` and `initialize_internal_metadata_table`.
+    *Jean Boussier*
 
-    *Rafael Mendonça França*
+*   Add `.asc.nulls_first` for all databases. Unfortunately MySQL still doesn't like `nulls_last`.
 
-*   Raises when calling `lock!` in a dirty record.
+    *Keenan Brock*
 
-    *Rafael Mendonça França*
+*   Improve performance of `one?` and `many?` by limiting the generated count query to 2 results.
 
-*   Remove deprecated support to passing a class to `:class_name` on associations.
+    *Gonzalo Riestra*
 
-    *Rafael Mendonça França*
+*   Don't check type when using `if_not_exists` on `add_column`.
 
-*   Remove deprecated argument `default` from `index_name_exists?`.
+    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.
 
-    *Rafael Mendonça França*
+    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.
 
-*   Remove deprecated support to `quoted_id` when typecasting an Active Record object.
+    *Eileen M. Uchitelle*
 
-    *Rafael Mendonça França*
+*   Log a warning message when running SQLite in production.
 
-*   Fix `bin/rails db:setup` and `bin/rails db:test:prepare` create wrong
-    ar_internal_metadata's data for a test database.
+    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.
 
-    Before:
+    The warning can be disabled by setting `config.active_record.sqlite3_production_warning=false`.
+
+    *Jacopo Beschi*
+
+*   Add option to disable joins for `has_one` associations.
+
+    In a multiple database application, associations can't join across
+    databases. When set, this option instructs Rails to generate 2 or
+    more queries rather than generating joins for `has_one` associations.
+
+    Set the option on a has one through association:
+
+    ```ruby
+    class Person
+      has_one :dog
+      has_one :veterinarian, through: :dog, disable_joins: true
+    end
     ```
-    $ RAILS_ENV=test rails dbconsole
-    > SELECT * FROM ar_internal_metadata;
-    key|value|created_at|updated_at
-    environment|development|2017-09-11 23:14:10.815679|2017-09-11 23:14:10.815679
+
+    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]]
     ```
 
-    After:
+    *Sarah Vessels*, *Eileen M. Uchitelle*
+
+*   `Arel::Visitors::Dot` now renders a complete set of properties when visiting
+    `Arel::Nodes::SelectCore`, `SelectStatement`, `InsertStatement`, `UpdateStatement`, and
+    `DeleteStatement`, which fixes #42026. Previously, some properties were omitted.
+
+    *Mike Dalessio*
+
+*   `Arel::Visitors::Dot` now supports `Arel::Nodes::Bin`, `Case`, `CurrentRow`, `Distinct`,
+    `DistinctOn`, `Else`, `Except`, `InfixOperation`, `Intersect`, `Lock`, `NotRegexp`, `Quoted`,
+    `Regexp`, `UnaryOperation`, `Union`, `UnionAll`, `When`, and `With`. Previously, these node
+    types caused an exception to be raised by `Arel::Visitors::Dot#accept`.
+
+    *Mike Dalessio*
+
+*   Optimize `remove_columns` to use a single SQL statement.
+
+    ```ruby
+    remove_columns :my_table, :col_one, :col_two
     ```
-    $ RAILS_ENV=test rails dbconsole
-    > SELECT * FROM ar_internal_metadata;
-    key|value|created_at|updated_at
-    environment|test|2017-09-11 23:14:10.815679|2017-09-11 23:14:10.815679
+
+    Now results in the following SQL:
+
+    ```sql
+    ALTER TABLE "my_table" DROP COLUMN "col_one", DROP COLUMN "col_two"
     ```
 
-    Fixes #26731.
+    *Jon Dufresne*
 
-    *bogdanvlviv*
+*   Ensure `has_one` autosave association callbacks get called once.
 
-*   Fix longer sequence name detection for serial columns.
+    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`.
 
-    Fixes #28332.
+    *Petrik de Heus*
 
-    *Ryuta Kamizono*
+*   Add option to disable joins for associations.
 
-*   MySQL: Don't lose `auto_increment: true` in the `db/schema.rb`.
+    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.
 
-    Fixes #30894.
+    Set the option on a has many through association:
 
-    *Ryuta Kamizono*
+    ```ruby
+    class Dog
+      has_many :treats, through: :humans, disable_joins: true
+      has_many :humans
+    end
+    ```
 
-*   Fix `COUNT(DISTINCT ...)` for `GROUP BY` with `ORDER BY` and `LIMIT`.
+    Then instead of generating join SQL, two queries are used for `@dog.treats`:
 
-    Fixes #30886.
+    ```
+    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]]
+    ```
 
-    *Ryuta Kamizono*
+    *Eileen M. Uchitelle*, *Aaron Patterson*, *Lee Quarella*
+
+*   Add setting for enumerating column names in SELECT statements.
 
-*   PostgreSQL `tsrange` now preserves subsecond precision.
+    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.
 
-    PostgreSQL 9.1+ introduced range types, and Rails added support for using
-    this datatype in Active Record. However, the serialization of
-    `PostgreSQL::OID::Range` was incomplete, because it did not properly
-    cast the bounds that make up the range. This led to subseconds being
-    dropped in SQL commands:
+    When enabled, Active Record will avoid wildcards and always include column names
+    in `SELECT` queries, which will return consistent results and avoid prepared
+    statement errors.
 
     Before:
 
-        connection.type_cast(tsrange.serialize(range_value))
-        # => "[2010-01-01 13:30:00 UTC,2011-02-02 19:30:00 UTC)"
+    ```ruby
+    Book.limit(5)
+    # SELECT * FROM books LIMIT 5
+    ```
+
+    After:
+
+    ```ruby
+    # config/application.rb
+    module MyApp
+      class Application < Rails::Application
+        config.active_record.enumerate_columns_in_select_statements = true
+      end
+    end
+
+    # or, configure per-model
+    class Book < ApplicationRecord
+      self.enumerate_columns_in_select_statements = true
+    end
+    ```
+
+    ```ruby
+    Book.limit(5)
+    # SELECT id, author_id, name, format, status, language, etc FROM books LIMIT 5
+    ```
+
+    *Matt Duszynski*
+
+*   Allow passing SQL as `on_duplicate` value to `#upsert_all` to make it possible to use raw SQL to update columns on conflict:
+
+    ```ruby
+    Book.upsert_all(
+      [{ id: 1, status: 1 }, { id: 2, status: 1 }],
+      on_duplicate: Arel.sql("status = GREATEST(books.status, EXCLUDED.status)")
+    )
+    ```
+
+    *Vladimir Dementyev*
+
+*   Allow passing SQL as `returning` statement to `#upsert_all`:
+
+    ```ruby
+    Article.insert_all(
+      [
+        { title: "Article 1", slug: "article-1", published: false },
+        { title: "Article 2", slug: "article-2", published: false }
+      ],
+      returning: Arel.sql("id, (xmax = '0') as inserted, name as new_name")
+    )
+    ```
+
+    *Vladimir Dementyev*
+
+*   Deprecate `legacy_connection_handling`.
+
+    *Eileen M. Uchitelle*
+
+*   Add attribute encryption support.
 
-    Now:
+    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.
 
-        connection.type_cast(tsrange.serialize(range_value))
-        # => "[2010-01-01 13:30:00.670277,2011-02-02 19:30:00.745125)"
 
-    *Thomas Cannon*
+    ```ruby
+    class Person < ApplicationRecord
+      encrypts :name
+      encrypts :email_address, deterministic: true
+    end
+    ```
+
+    You can learn more in the [Active Record Encryption
+    guide](https://edgeguides.rubyonrails.org/active_record_encryption.html).
+
+    *Jorge Manrubia*
+
+*   Changed Arel predications `contains` and `overlaps` to use
+    `quoted_node` so that PostgreSQL arrays are quoted properly.
+
+    *Bradley Priest*
+
+*   Add mode argument to record level `strict_loading!`.
+
+    This argument can be used when enabling strict loading for a single record
+    to specify that we only want to raise on n plus one queries.
+
+    ```ruby
+    developer.strict_loading!(mode: :n_plus_one_only)
+
+    developer.projects.to_a # Does not raise
+    developer.projects.first.client # Raises StrictLoadingViolationError
+    ```
+
+    Previously, enabling strict loading would cause any lazily loaded
+    association to raise an error. Using `n_plus_one_only` mode allows us to
+    lazily load belongs_to, has_many, and other associations that are fetched
+    through a single query.
+
+    *Dinah Shi*
+
+*   Fix Float::INFINITY assignment to datetime column with postgresql adapter.
 
-*   Passing a `Set` to `Relation#where` now behaves the same as passing an
-    array.
+    Before:
+
+    ```ruby
+    # With this config
+    ActiveRecord::Base.time_zone_aware_attributes = true
+
+    # and the following schema:
+    create_table "postgresql_infinities" do |t|
+      t.datetime "datetime"
+    end
 
-    *Sean Griffin*
+    # This test fails
+    record = PostgresqlInfinity.create!(datetime: Float::INFINITY)
+    assert_equal Float::INFINITY, record.datetime # record.datetime gets nil
+    ```
 
-*   Use given algorithm while removing index from database.
+    After this commit, `record.datetime` gets `Float::INFINITY` as expected.
 
-    Fixes #24190.
+    *Shunichi Ikegami*
 
-    *Mehmet Emin İNAÇ*
+*   Type cast enum values by the original attribute type.
 
-*   Update payload names for `sql.active_record` instrumentation to be
-    more descriptive.
+    The notable thing about this change is that unknown labels will no longer match 0 on MySQL.
 
-    Fixes #30586.
+    ```ruby
+    class Book < ActiveRecord::Base
+      enum :status, { proposed: 0, written: 1, published: 2 }
+    end
+    ```
 
-    *Jeremy Green*
+    Before:
 
-*   Add new error class `LockWaitTimeout` which will be raised
-    when lock wait timeout exceeded.
+    ```ruby
+    # SELECT `books`.* FROM `books` WHERE `books`.`status` = 'prohibited' LIMIT 1
+    Book.find_by(status: :prohibited)
+    # => #<Book id: 1, status: "proposed", ...> (for mysql2 adapter)
+    # => ActiveRecord::StatementInvalid: PG::InvalidTextRepresentation: ERROR:  invalid input syntax for type integer: "prohibited" (for postgresql adapter)
+    # => nil (for sqlite3 adapter)
+    ```
 
-    *Gabriel Courtemanche*
+    After:
 
-*   Remove deprecated `#migration_keys`.
+    ```ruby
+    # SELECT `books`.* FROM `books` WHERE `books`.`status` IS NULL LIMIT 1
+    Book.find_by(status: :prohibited)
+    # => nil (for all adapters)
+    ```
 
     *Ryuta Kamizono*
 
-*   Automatically guess the inverse associations for STI.
+*   Fixtures for `has_many :through` associations now load timestamps on join tables.
 
-    *Yuichiro Kaneko*
+    Given this fixture:
 
-*   Ensure `sum` honors `distinct` on `has_many :through` associations.
+    ```yml
+    ### monkeys.yml
+    george:
+      name: George the Monkey
+      fruits: apple
 
-    Fixes #16791.
+    ### fruits.yml
+    apple:
+      name: apple
+    ```
 
-    *Aaron Wortham*
+    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.
 
-*   Add `binary` fixture helper method.
+    *Alex Ghiculescu*
 
-    *Atsushi Yoshida*
+*   Allow applications to configure the thread pool for async queries.
 
-*   When using `Relation#or`, extract the common conditions and put them before the OR condition.
+    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.
 
-    *Maxime Handfield Lapointe*
+    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.
 
-*   `Relation#or` now accepts two relations who have different values for
-    `references` only, as `references` can be implicitly called by `where`.
+    *Eileen M. Uchitelle*
 
-    Fixes #29411.
+*   Allow new syntax for `enum` to avoid leading `_` from reserved options.
 
-    *Sean Griffin*
+    Before:
 
-*   `ApplicationRecord` is no longer generated when generating models. If you
-    need to generate it, it can be created with `rails g application_record`.
+    ```ruby
+    class Book < ActiveRecord::Base
+      enum status: [ :proposed, :written ], _prefix: true, _scopes: false
+      enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
+    end
+    ```
 
-    *Lisa Ugray*
+    After:
 
-*   Fix `COUNT(DISTINCT ...)` with `ORDER BY` and `LIMIT` to keep the existing select list.
+    ```ruby
+    class Book < ActiveRecord::Base
+      enum :status, [ :proposed, :written ], prefix: true, scopes: false
+      enum :cover, [ :hard, :soft ], suffix: true, default: :hard
+    end
+    ```
 
     *Ryuta Kamizono*
 
-*   When a `has_one` association is destroyed by `dependent: destroy`,
-    `destroyed_by_association` will now be set to the reflection, matching the
-    behaviour of `has_many` associations.
+*   Add `ActiveRecord::Relation#load_async`.
+
+    This method schedules the query to be performed asynchronously from a thread pool.
 
-    *Lisa Ugray*
+    If the result is accessed before a background thread had the opportunity to perform
+    the query, it will be performed in the foreground.
 
-*   Fix `unscoped(where: [columns])` removing the wrong bind values.
+    This is useful for queries that can be performed long enough before their result will be
+    needed, or for controllers which need to perform several independent queries.
+
+    ```ruby
+    def index
+      @categories = Category.some_complex_scope.load_async
+      @posts = Post.some_complex_scope.load_async
+    end
+    ```
 
-    When the `where` is called on a relation after a `or`, unscoping the column of that later `where` removed
-    bind values used by the `or` instead. (possibly other cases too)
+    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.
 
     ```
-    Post.where(id: 1).or(Post.where(id: 2)).where(foo: 3).unscope(where: :foo).to_sql
-    # Currently:
-    #     SELECT "posts".* FROM "posts" WHERE ("posts"."id" = 2 OR "posts"."id" = 3)
-    # With fix:
-    #     SELECT "posts".* FROM "posts" WHERE ("posts"."id" = 1 OR "posts"."id" = 2)
+    DEBUG -- :   Category Load (62.1ms)  SELECT * FROM `categories` LIMIT 50
+    DEBUG -- :   ASYNC Post Load (64ms) (db time 126.1ms)  SELECT * FROM `posts` LIMIT 100
     ```
 
-    *Maxime Handfield Lapointe*
+    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.
 
-*   Values constructed using multi-parameter assignment will now use the
-    post-type-cast value for rendering in single-field form inputs.
+    *Jean Boussier*
 
-    *Sean Griffin*
+*   Implemented `ActiveRecord::Relation#excluding` method.
 
-*   `Relation#joins` is no longer affected by the target model's
-    `current_scope`, with the exception of `unscoped`.
+    This method excludes the specified record (or collection of records) from
+    the resulting relation:
 
-    Fixes #29338.
+    ```ruby
+    Post.excluding(post)
+    Post.excluding(post_one, post_two)
+    ```
 
-    *Sean Griffin*
+    Also works on associations:
 
-*   Change sqlite3 boolean serialization to use 1 and 0.
+    ```ruby
+    post.comments.excluding(comment)
+    post.comments.excluding(comment_one, comment_two)
+    ```
 
-    SQLite natively recognizes 1 and 0 as true and false, but does not natively
-    recognize 't' and 'f' as was previously serialized.
+    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).
 
-    This change in serialization requires a migration of stored boolean data
-    for SQLite databases, so it's implemented behind a configuration flag
-    whose default false value is deprecated.
+    *Glen Crawford*
 
-    *Lisa Ugray*
+*   Skip optimised #exist? query when #include? is called on a relation
+    with a having clause.
 
-*   Skip query caching when working with batches of records (`find_each`, `find_in_batches`,
-    `in_batches`).
+    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.
 
-    Previously, records would be fetched in batches, but all records would be retained in memory
-    until the end of the request or job.
+    A sample query affected by this problem:
 
-    *Eugene Kenny*
+    ```ruby
+    Author.select('COUNT(*) as total_posts', 'authors.*')
+          .joins(:posts)
+          .group(:id)
+          .having('total_posts > 2')
+          .include?(Author.first)
+    ```
 
-*   Prevent errors raised by `sql.active_record` notification subscribers from being converted into
-    `ActiveRecord::StatementInvalid` exceptions.
+    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.
 
-    *Dennis Taylor*
+    Fixes #41417.
 
-*   Fix eager loading/preloading association with scope including joins.
+    *Michael Smart*
 
-    Fixes #28324.
+*   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.
 
-    *Ryuta Kamizono*
+    *wbharding*, *Martin Tepper*
 
-*   Fix transactions to apply state to child transactions.
+*   Add ability to apply `scoping` to `all_queries`.
 
-    Previously, if you had a nested transaction and the outer transaction was rolledback, the record from the
-    inner transaction would still be marked as persisted.
+    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.
 
-    This change fixes that by applying the state of the parent transaction to the child transaction when the
-    parent transaction is rolledback. This will correctly mark records from the inner transaction as not persisted.
+    ```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*, *Aaron Patterson*
+    *Eileen M. Uchitelle*
 
-*   Deprecate `set_state` method in `TransactionState`.
+*   `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`.
 
-    Deprecated the `set_state` method in favor of setting the state via specific methods. If you need to mark the
-    state of the transaction you can now use `rollback!`, `commit!` or `nullify!` instead of
-    `set_state(:rolledback)`, `set_state(:committed)`, or `set_state(nil)`.
+    Integers are handled as a special case returning `BigDecimal` always
+    (this was the case before already).
 
-    *Eileen M. Uchitelle*, *Aaron Patterson*
+    ```ruby
+    # With the following schema:
+    create_table "measurements" do |t|
+      t.float "temperature"
+    end
 
-*   Deprecate delegating to `arel` in `Relation`.
+    # Before:
+    Measurement.average(:temperature).class
+    # => BigDecimal
 
-    *Ryuta Kamizono*
+    # After:
+    Measurement.average(:temperature).class
+    # => Float
+    ```
+
+    Before this change, Rails just called `to_d` on average aggregates from the
+    database adapter. This is not the case anymore. If you relied on that kind
+    of magic, you now need to register your own `ActiveRecord::Type`
+    (see `ActiveRecord::Attributes::ClassMethods` for documentation).
+
+    *Josua Schmid*
 
-*   Query cache was unavailable when entering the `ActiveRecord::Base.cache` block
-    without being connected.
+*   PostgreSQL: introduce `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type`.
 
-    *Tsukasa Oishi*
+    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.
 
-*   Previously, when building records using a `has_many :through` association,
-    if the child records were deleted before the parent was saved, they would
-    still be persisted. Now, if child records are deleted before the parent is saved
-    on a `has_many :through` association, the child records will not be persisted.
+    You should run `bin/rails db:migrate` to rebuild your schema.rb if you change this.
 
-    *Tobias Kraze*
+    *Alex Ghiculescu*
 
-*   Merging two relations representing nested joins no longer transforms the joins of
-    the merged relation into LEFT OUTER JOIN.
+*   PostgreSQL: handle `timestamp with time zone` columns correctly in `schema.rb`.
 
-    Example:
+    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.
 
+    *Alex Ghiculescu*
+
+*   Removing trailing whitespace when matching columns in
+    `ActiveRecord::Sanitization.disallow_raw_sql!`.
+
+    *Gannon McGibbon*, *Adrian Hirt*
+
+*   Expose a way for applications to set a `primary_abstract_class`.
+
+    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
+    class PrimaryApplicationRecord
+      self.primary_abstract_class
+    end
     ```
-    Author.joins(:posts).merge(Post.joins(:comments))
-    # Before the change:
-    #=> SELECT ... FROM authors INNER JOIN posts ON ... LEFT OUTER JOIN comments ON...
 
-    # After the change:
-    #=> SELECT ... FROM authors INNER JOIN posts ON ... INNER JOIN comments ON...
+    When an application boots it automatically connects to the primary or first database in the
+    database configuration file. In a multiple database application that then call `connects_to`
+    needs to know that the default connection is the same as the `ApplicationRecord` connection.
+    However, some applications have a differently named `ApplicationRecord`. This prevents Active
+    Record from opening duplicate connections to the same database.
+
+    *Eileen M. Uchitelle*, *John Crepezzi*
+
+*   Support hash config for `structure_dump_flags` and `structure_load_flags` flags.
+    Now that Active Record supports multiple databases configuration,
+    we need a way to pass specific flags for dump/load databases since
+    the options are not the same for different adapters.
+    We can use in the original way:
+
+    ```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'
     ```
 
-    *Maxime Handfield Lapointe*
+    And also use it passing a hash, with one or more keys, where the key
+    is the adapter
 
-*   `ActiveRecord::Persistence#touch` does not work well when optimistic locking enabled and
-    `locking_column`, without default value, is null in the database.
+    ```ruby
+    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = {
+      mysql2: ['--no-defaults', '--skip-add-drop-table'],
+      postgres: '--no-tablespaces'
+    }
+    ```
 
-    *bogdanvlviv*
+    *Gustavo Gonzalez*
 
-*   Fix destroying existing object does not work well when optimistic locking enabled and
-    `locking_column` is null in the database.
+*   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.
 
-    *bogdanvlviv*
+    Fixes #41137.
 
-*   Use bulk INSERT to insert fixtures for better performance.
+    *Jonathan Bracy*
 
-    *Kir Shatrov*
+*   Allow to opt-out of `strict_loading` mode on a per-record base.
 
-*   Prevent creation of bind param if casted value is nil.
+    This is useful when strict loading is enabled application wide or on a
+    model level.
 
-    *Ryuta Kamizono*
+    ```ruby
+    class User < ApplicationRecord
+      has_many :bookmarks
+      has_many :articles, strict_loading: true
+    end
 
-*   Deprecate passing arguments and block at the same time to `count` and `sum` in `ActiveRecord::Calculations`.
+    user = User.first
+    user.articles                        # => ActiveRecord::StrictLoadingViolationError
+    user.bookmarks                       # => #<ActiveRecord::Associations::CollectionProxy>
 
-    *Ryuta Kamizono*
+    user.strict_loading!(true)           # => true
+    user.bookmarks                       # => ActiveRecord::StrictLoadingViolationError
+
+    user.strict_loading!(false)          # => false
+    user.bookmarks                       # => #<ActiveRecord::Associations::CollectionProxy>
+    user.articles.strict_loading!(false) # => #<ActiveRecord::Associations::CollectionProxy>
+    ```
+
+    *Ayrton De Craene*
 
-*   Loading model schema from database is now thread-safe.
+*   Add `FinderMethods#sole` and `#find_sole_by` to find and assert the
+    presence of exactly one record.
 
-    Fixes #28589.
+    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.
 
-    *Vikrant Chaudhary*, *David Abdemoulaie*
+    ```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)
 
-*   Add `ActiveRecord::Base#cache_version` to support recyclable cache keys via the new versioned entries
-    in `ActiveSupport::Cache`. This also means that `ActiveRecord::Base#cache_key` will now return a stable key
-    that does not include a timestamp any more.
+    user.api_keys.find_sole_by(key: key)
+    # as above
+    ```
 
-    NOTE: This feature is turned off by default, and `#cache_key` will still return cache keys with timestamps
-    until you set `ActiveRecord::Base.cache_versioning = true`. That's the setting for all new apps on Rails 5.2+
+    *Asherah Connor*
 
-    *DHH*
+*   Makes `ActiveRecord::AttributeMethods::Query` respect the getter overrides defined in the model.
 
-*   Respect `SchemaDumper.ignore_tables` in rake tasks for databases structure dump.
+    Before:
 
-    *Rusty Geldmacher*, *Guillermo Iguaran*
+    ```ruby
+    class User
+      def admin
+        false # Overriding the getter to always return false
+      end
+    end
 
-*   Add type caster to `RuntimeReflection#alias_name`.
+    user = User.first
+    user.update(admin: true)
 
-    Fixes #28959.
+    user.admin # false (as expected, due to the getter overwrite)
+    user.admin? # true (not expected, returned the DB column value)
+    ```
 
-    *Jon Moss*
+    After this commit, `user.admin?` above returns false, as expected.
 
-*   Deprecate `supports_statement_cache?`.
+    Fixes #40771.
 
-    *Ryuta Kamizono*
+    *Felipe*
 
-*   Raise error `UnknownMigrationVersionError` on the movement of migrations
-    when the current migration does not exist.
+*   Allow delegated_type to be specified primary_key and foreign_key.
 
-    *bogdanvlviv*
+    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.
 
-*   Fix `bin/rails db:forward` first migration.
+    *Ryota Egusa*
 
-    *bogdanvlviv*
+*   Expose an `invert_where` method that will invert all scope conditions.
 
-*   Support Descending Indexes for MySQL.
+    ```ruby
+    class User
+      scope :active, -> { where(accepted: true, locked: false) }
+    end
 
-    MySQL 8.0.1 and higher supports descending indexes: `DESC` in an index definition is no longer ignored.
-    See https://dev.mysql.com/doc/refman/8.0/en/descending-indexes.html.
+    User.active
+    # ... WHERE `accepted` = 1 AND `locked` = 0
 
-    *Ryuta Kamizono*
+    User.active.invert_where
+    # ... WHERE NOT (`accepted` = 1 AND `locked` = 0)
+    ```
+
+    *Kevin Deisz*
+
+*   Restore possibility of passing `false` to :polymorphic option of `belongs_to`.
+
+    Previously, passing `false` would trigger the option validation logic
+    to throw an error saying :polymorphic would not be a valid option.
+
+    *glaszig*
+
+*   Remove deprecated `database` kwarg from `connected_to`.
+
+    *Eileen M. Uchitelle*, *John Crepezzi*
+
+*   Allow adding nonnamed expression indexes to be revertible.
+
+    Previously, the following code would raise an error, when executed while rolling back,
+    and the index name should be specified explicitly. Now, the index name is inferred
+    automatically.
+
+    ```ruby
+    add_index(:items, "to_tsvector('english', description)")
+    ```
+
+    Fixes #40732.
+
+    *fatkodima*
+
+*   Only warn about negative enums if a positive form that would cause conflicts exists.
+
+    Fixes #39065.
+
+    *Alex Ghiculescu*
+
+*   Add option to run `default_scope` on all queries.
+
+    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`).
+
+    Now applications can add an option to run on all queries including select, insert, delete, and update by adding an `all_queries` option to the default scope definition.
+
+    ```ruby
+    class Article < ApplicationRecord
+      default_scope -> { where(blog_id: Current.blog.id) }, all_queries: true
+    end
+    ```
+
+    *Eileen M. Uchitelle*
+
+*   Add `where.associated` to check for the presence of an association.
+
+    ```ruby
+    # Before:
+    account.users.joins(:contact).where.not(contact_id: nil)
+
+    # After:
+    account.users.where.associated(:contact)
+    ```
 
-*   Fix inconsistency with changed attributes when overriding Active Record attribute reader.
+    Also mirrors `where.missing`.
 
-    *bogdanvlviv*
+    *Kasper Timm Hansen*
 
-*   When calling the dynamic fixture accessor method with no arguments, it now returns all fixtures of this type.
-    Previously this method always returned an empty array.
+*   Allow constructors (`build_association` and `create_association`) on
+    `has_one :through` associations.
 
-    *Kevin McPhillips*
+    *Santiago Perez Perret*
 
 
-Please check [5-1-stable](https://github.com/rails/rails/blob/5-1-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.