deprecated

Fixes activerecord-deprecated_finders build.

https://travis-ci.org/rails/activerecord-deprecated_finders/builds/5964703

Closes #9712.

The similarity of `Relation#uniq` to `Array#uniq` is confusing. Since our
Relation API is close to SQL terms I renamed `#uniq` to `#distinct`.

There is no deprecation. `#uniq` and `#uniq!` are aliases and will continue
to work. I also updated the documentation to promote the use of `#distinct`.

We discussed that the auto explain feature is rarely used.
This PR removes only the automatic explain. You can still display
the explain output for any given relation using `ActiveRecord::Relation#explain`.

As a side-effect this should also fix the connection problem during
asset compilation (#9385). The auto explain initializer in the `ActiveRecord::Railtie`
forced a connection.

* User class instead of Users.
* #where_values_hash does not change the value to downcase as the
  example was showing.

[ci skip]

in a default_scope.

`Model.joins(...).where(condition_on_joined_table).update_all` /
`delete_all` worked, but the same operation implemented with a
default_scope generated a SQL error because ActiveRecord ignored the
join but implemented the where condition anyways.

They was extracted from a plugin.

See https://github.com/rails/rails-observers

[Rafael Mendonça França + Steve Klabnik]

Another batch of hash syntax changes to comment, this time around, I tried to keep 'output' messages untouched.

This is similar to #first_or_create, but slightly different and a nicer
API. See the CHANGELOG/docs in the commit.

Fixes #7853

https://bugs.ruby-lang.org/issues/7166

This doesn't change the exernal behavior, but it moves some code around
to where I think it properly belongs.

This method explicitly loads the records and then returns `self`.

Rather than deciding between "do I want an array or a relation?",
most people are actually asking themselves "do I want to eager load
or lazy load?" Therefore, this method provides a way to explicitly
eager-load without having to switch from a `Relation` to an array.

Example:

    @posts = Post.where(published: true).load

A test was failing due to the way that Relation#inspect causes
association proxies to ignore unsaved records added to the association.

This is fixed by simply calling to_a and letting to_a figure out how to
get the records (which, in the case of associations, takes into account
new records).

I think it is acceptable to do this rather than limiting the query at
the database level:

* It's what we've done in all released Rails versions up to this point
* The goal of the limit is to not flood the console with output - this
  is the problem we're targeting, rather than the actual loading of the
  records from the database
* You probably want to do something with those records later anyway,
  otherwise you wouldn't have built a relation for them.

While it's interesting to have the results array, it can make a console or a webpage freeze if there are a lot of them.
So this limits the number of records displayed in #inspect to 10 and tells how much were effectively found.

The reason for removing the previous implementation of `#inspect` was
that it hid from you that you were dealing with a `Relation` rather than
an `Array`.

But it is still useful to be able to see the records, particularly if you're
writing something like the following in tests:

    assert_equal [foo], Post.where(:bar)

If the assertion fails, you want to see what records were actually
loaded.

So this implementation makes it clear that you've got a `Relation`, but
also shows your records.