Fix `COUNT(DISTINCT ...)` with `ORDER BY` and `LIMIT`

Post.where(id: 1).or(Post.where(id: 2)).where(foo: 3).unscope(where: :foo).where_clause.binds.map(&:value)
Would return [2, 3] instead of the expected [1,2]

Fix association with extension issues

Doc updates for ActiveRecord::Batches

Don't eager loading if unneeded for `FinderMethods#exists?`

Mixin `CollectionProxy::DelegateExtending` after `ClassSpecificRelation`

Extract `construct_relation_for_exists` in `FinderMethods`

Fix where_clause#except with specific where value
(cherry picked from commit 81b2cd11)

Since b644964b `ActiveRecord::Relation` includes `Enumerable` so
delegating `collect`, `all?`, and `include?` are also unneeded.
`collect` without block returns `Enumerable` without preloading by that.
We should use `load` rather than `collect` for force loading.

This fixes CI failure due to 48f3be8c.

`Enumerable#uniq` was introduced since Ruby 2.4. We should delegate
`uniq` to `records` explicitly.

And since b644964b `ActiveRecord::Relation` includes `Enumerable` so
delegating `map` is unneeded.

Follow up of #24203.

Since b644964b `ActiveRecord::Relation` includes `Enumerable` so it is
enough to call `super` simply.

When `order` is given a hash, the keys are currently assumed to be
attribute names and are quoted as such in the query, which makes it
impossible to pass an expression instead:

    Post.order("LENGTH(title)" => :asc).last
    # SELECT  `posts`.* FROM `posts` ORDER BY `posts`.`LENGTH(title)` DESC LIMIT 1

If the key is an `Arel::Nodes::SqlLiteral`, we now use it directly in
the query. This provides a way to build a relation with a complex order
clause that can still be reversed with `reverse_order` or `last`.

When a grouped calculation contains a having clause that references a
selected value, we need to include that selected value in the query.

Postgres doesn't support referencing a selected value in a having
clause, but other databases do; we can skip the test on the pg adapter
but run it for the others.

This was fixed before in 9a298a16, but
the test coverage was lost in 5a05207d.
The fix regressed in 6311975f and was
removed in 97d46c17.

If the `index` exceeds a `limit`, simply return an empty result without
querying the database.

`select_values` is a local variable defined at previous line.
`select_values += select_values` is totally useless.

`DISTINCT` clause is applied inside aggregate function by
`operation_over_aggregate_column` if needed. Unneeded outside aggregate
function.

```ruby
  # Before
  author.unique_categorized_posts.count
  # => SELECT DISTINCT COUNT(DISTINCT "posts"."id") FROM "posts" INNER JOIN "categorizations" ON "posts"."id" = "categorizations"."post_id" WHERE "categorizations"."author_id" = ?  [["author_id", 2]]

  # After
  author.unique_categorized_posts.count
  # => SELECT COUNT(DISTINCT "posts"."id") FROM "posts" INNER JOIN "categorizations" ON "posts"."id" = "categorizations"."post_id" WHERE "categorizations"."author_id" = ?  [["author_id", 2]]
```

Closes #27615

This reverts commit 28977f1f.

If select clause is specified and last column has a column alias,
additional column alias causes a statement invalid.

Add test coverage for counting a single column with NULL values.

Fixes #27676, #27682, and #27705.

Actually, private methods cannot be called with `self.`, so it's not just redundant, it's a bad habit in Ruby

find and exists?

Closes #14640

Some methods were added to public API in
5b14129d and they should be not part of
the public API.

Currently uniqueness validator is coupled with building Arel ASTs.
This commit extracts `WhereClauseFactory#build_for_case_sensitive` for
decouple the building Arel ASTs.

Raise `ActiveRecord::RangeError` when values that executed are out of range.