This option was added in b9fa3541. But it does not seem to work.

load_schema! is overridden by attribute modules, so we need to wait
until it has returned.

Follow up of #29077.

Before:

```sql
SELECT sql FROM sqlite_master WHERE tbl_name NOT IN ("foo") ORDER BY tbl_name, type DESC, name
```

After:

```sql
SELECT sql FROM sqlite_master WHERE tbl_name NOT IN ('foo') ORDER BY tbl_name, type DESC, name
```

> If a keyword in double quotes (ex: "key" or "glob") is used in a
context where it cannot be resolved to an identifier but where a string
literal is allowed, then the token is understood to be a string literal
instead of an identifier.

http://www.sqlite.org/lang_keywords.html

This regression is caused by d1249c1a.

If STI model is defined `default_scope`, `base_rel` is not respected.
I fixed to merge `base_rel` in that case.

If casted value is nil, generated SQL should be `IS NULL`. But currently
it is generated as `= NULL`. To prevent this behavior, avoid making bind
param if casted value is nil.

Fixes #28945.

Another fix for #28780 based on discussions at #28789

- In PostgreSQL 10 each sequence does not know its `min_value`.
A new system catalog `pg_sequence` shows it as `seqmin`.
Refer https://github.com/postgres/postgres/commit/1753b1b027035029c2a2a1649065762fafbf63f3

- `setval` 3rd argument needs to set to `false` only when the table has no rows
to avoid `nextval(<sequence_name>)` returns `2` where `1` is expected.

- `min_value` is only necessary when the table has no rows. It used to be necessary
since the 3rd argument of `setval` is always `false`.

`quote_default_expression` can be passed nil value when `null: true` and
`default: nil`. This addressed in that case.

Fixes #29222.

Structured type values sometimes caused representation problems (keys
sort order, spaces, etc). A raw value from the database should be
deserialized (normalized) to prevent the problems.

As @matthewd's suggestion, if `klass` has no default scope, it will more
faster.

* Allow a default value to be declared for class_attribute

* Convert to using class_attribute default rather than explicit setter

* Removed instance_accessor option by mistake

* False is a valid default value

* Documentation

Formerly, `rename_table` only renamed primary key index name if the
column's data type was sequential (serial, etc in PostgreSQL). The
problem with that is tables whose primary keys had other data types
(e.g. UUID) maintained the old primary key name. So for example,
if the `cats` table has a UUID primary key, and the table is renamed to
`felines`, the primary key index will still be called `cats_pkey`
instead of `felines_pkey`. This PR corrects it.

Deprecate passing arguments and block at the same time to `count` and `sum` in `ActiveRecord::Calculations`

`select`, `count`, and `sum` in `Relation` are also `Enumerable` method
that can be passed block. `select` with block already doesn't take
arguments since 4fc3366d. This is follow up of that.

Using `Association#interpolate` was removed since #11251.

Some third party modules expects that association returns same proxy
object each time (e.g. for stubbing collection methods:
https://github.com/rspec/rspec-rails/issues/1817).
So I decided that cache the proxy object and reset scope in the proxy
object each time.

Related context: https://github.com/rails/rails/commit/c86a32d7451c5d901620ac58630460915292f88b#commitcomment-2784312

This fixes the following issues.

* `association_scope` doesn't include `default_scope`. Should use `scope` instead.
* We can't use `method_missing` for customizing existing method.
* We can't use `relation_delegate_class` for sharing extensions. Should extend per association.

[ci skip]

This change preserves the speedup made in a24912cb (by avoiding
the wasted shallow dup of @attributes) while ensuring that the
performance of #deep_dup won't be tied to the performance of #initialize

[Vikrant Chaudhary, David Abdemoulaie, Matthew Draper]

Memoize the #column_defaults class property, as ActiveRecord does
for other properties in this module.

This change addresses slowness in ActiveRecord initialization
introduced starting in Rails 5.0. This method's performance has not
changed with Rails 5, but it is now called much more frequently than
before: every time an STI model is instantiated.

This change addresses slowness in ActiveRecord initialization
introduced starting in Rails 5.0.

Skip the call to #dup, since it does a shallow copy of attributes,
which is wasted effort, since #deep_dup then replaces that
shallow copy with a #deep_dup of the given attributes.

This change addresses slowness in ActiveRecord initialization
introduced starting in Rails 5.0.

Follow up of #27399.

Follow up of #25702.

The only difference between `make_inner_joins` and
`make_left_outer_joins` is the `join_type`.

This was added at #22125 but `left_joins_values` is never used.

```ruby
require "benchmark/ips"
require "set"

array = [:asc, :desc, :ASC, :DESC, "asc", "desc", "ASC", "DESC"]
set   = array.to_set
item  = "DESC"

Benchmark.ips do |x|
  x.report "array" do
    array.include?(item)
  end
  x.report "set" do
    set.include?(item)
  end
end
```

```
% ruby array_vs_set.rb
Warming up --------------------------------------
               array   188.441k i/100ms
                 set   229.531k i/100ms
Calculating -------------------------------------
               array      3.508M (± 9.0%) i/s -     17.525M in   5.043058s
                 set      5.134M (± 7.6%) i/s -     25.707M in   5.038921s
```