Add tests to make sure scopes cannot be create with names such as:
private, protected, public.
Make sure enum values don't collide with those methods too.

It was causing error when using `with_options` passing a lambda as its
last argument.

    class User < ActiveRecord::Base
      with_options dependent: :destroy do |assoc|
        assoc.has_many :profiles, -> { where(active: true) }
      end
    end

It was happening because the `option_merger` was taking the last
argument and checking if it was a Hash. This breaks the HasMany usage,
because its last argument can be a Hash or a Proc.

As the behavior described in this test:
https://github.com/rails/rails/blob/master/activesupport/test/option_merger_test.rb#L69
the method will only accept the lambda, this way it will keep the expected behavior. See 9eaa0a34

This is all about the case where we have a `DATABASE_URL`, and we have a
`database.yml` present, but the latter doesn't contain the key we're
looking for.

If the key is a symbol, we'll always connect to `DATABASE_URL`, per the
new behaviour in 283a2ede.

If the key is a string, on the other hand, it should always be a URL:
the ability to specify a name not present in `database.yml` is new in
this version of Rails, and that ability does not stretch to the
deprecated use of a string in place of a symbol.

Uncovered by @guilleiguaran while investigating #14495 -- this actually
may be related to the original report, but we don't have enough info to
confirm.

That which was now relative is now absolute.

Restore the 4.0 behaviour for 'sqlite3:///', but deprecate it. We'll
change to the absolute-path interpretation in 4.2.

The current "correct" spellings for in-memory, relative, and absolute
URLs, respectively, are:

    sqlite3::memory:
    sqlite3:relative/path
    sqlite3:/full/path

Substantially reverses/defers fbb79b51.
Uncovered by @guilleiguaran while investigating #14495, though that
sounds like a different issue.

connection.

Expand the query used in #table_exists? to include materialized views in the
kinds of relations it searches.

Also do not use transactional fixtures. We drop the type and the
table after every run, so there is nothing for the transaction to clean up.

Creating and dropping similar tables within the same connection causes postgresql to look up old values in the cache of tables which have already been dropped.

This patch registers custom domains in our OID-type_map.
They will behave exactly as the type specified by `pg_type.typbasetype`.

/cc @matthewd

I ran the whole test suite and compared the old to the new types.
Following is the list of types that did change with this patch:

```
DIFFERENT TYPE FOR mood: NEW: enum, BEFORE:
DIFFERENT TYPE FOR floatrange: NEW: floatrange, BEFORE: float
```

The `floatrange` is a custom type. The old type `float` was simply a coincidence
form the name `floatrange` and our type-guessing.

set assert_sql to reuse the capture_sql method from above
instead of repeating the code

in response to comments on issue #14546

delete_all sql if an association is not loaded should behave
the same as if the association is loaded. This test ensures
the SQL statements are exactly the same.

Other methods compare specific patterns, this method outputs
the actual sql query that is generated.

The new method relies on AR::Associations::Association knowing about both reflection and a model class.

AR::Base#association now raises a descriptive error when trying to access non-existent associations. Previously it would blow up with a confusing NoMethodError: undefined method `association_class' for nil:NilClass.

Defer to Association#klass instead of having a custom/duplicate code.

fixes #10613

Follow-Up to https://github.com/rails/rails/pull/14400

This ensures that all tables are removed after each test and thereby
allowing us to run the tests in a random order.

460eb83d cused `ActiveRecord::Base#==` to sometimes return `nil` in some cases,
this ensures we always return a boolean value. Also fixed a similar problem in
AR reflections.

See https://github.com/rails/rails/blob/master/activesupport/lib/active_support/notifications.rb#L131

Swap Timestamp/Callbacks order in ActiveRecord::Base

custom primary_key that didn't save due to validation error

It's unintuitive to call '#valid?' when you want to run validations but
don't care about the return value.

The alias in ActiveRecord isn't strictly necessary (the ActiveModel
alias is still in effect), but it clarifies.

When the tests are executed in order, the dependency is loaded at the right time.
However this makes it impossible to execute a single test later down the line.
Let's require the dependecy at the beginning to get them working independent of the order.

This resolves the following error:

```
$ ARCONN=postgresql ruby -Itest /Users/senny/Projects/rails/activerecord/test/cases/xml_serialization_test.rb -n test_to_xml
Using postgresql
Run options: -n test_to_xml --seed 51819

E

Finished in 0.081320s, 12.2971 runs/s, 0.0000 assertions/s.

  1) Error:
DatabaseConnectedXmlSerializationTest#test_to_xml:
NameError: uninitialized constant DatabaseConnectedXmlSerializationTest::REXML
    /Users/senny/Projects/rails/activerecord/test/cases/xml_serialization_test.rb:226:in `test_to_xml'
```

/cc @tgxworld fyi

This will keep the test suite passing with older PG installations.

It is supposed to raise ActiveRecord::InvalidForeignKey when the
database has a fk constraint.

Also:
  - updates tests by stubbing table_exists? method
  - adds entry for creating indexes in CREATE TABLE to changelog

This is important, because adding an index on a temporary table after
it has been created would commit the transaction

Conflicts:
	activerecord/CHANGELOG.md

This reverts commit 6e3ab3e1, reversing
changes made to 39e07b64.

Conflicts:
	activerecord/CHANGELOG.md
	activerecord/test/cases/autosave_association_test.rb

arel methods are not supposed to be public API for ActiveRecord

This abstracts us from the actual construction of the nodes

Follow-Up to https://github.com/rails/rails/pull/14400

This ensures that all tables are removed after each test and thereby
allowing us to run the tests in a random order.