Some tests does not work for unprepared statements.
Add `if ActiveRecord::Base.connection.prepared_statements` and fix a
regex for fix tests failure with `prepared_statements: false`.

The error occurs with `prepared_statements: false`:

```
$ ARCONN=postgresql bundle exec ruby -w -Itest test/cases/associations_test.rb
Using postgresql
Run options: --seed 27753

...E....................................

Finished in 0.713115s, 56.0919 runs/s, 91.1494 assertions/s.

  1) Error:
AssociationsTest#test_force_reload_is_uncached:
NoMethodError: undefined method `preparable' for #<Arel::Visitors::PostgreSQL:0x007f8699702570>
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb:68:in `block in select_all'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb:83:in `cache_sql'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb:68:in `select_all'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/querying.rb:39:in `find_by_sql'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/relation.rb:699:in `exec_queries'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/association_relation.rb:32:in `exec_queries'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/relation.rb:580:in `load'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/relation.rb:260:in `records'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/relation.rb:256:in `to_a'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/associations/collection_association.rb:458:in `get_records'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/associations/collection_association.rb:473:in `find_target'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/associations/collection_association.rb:412:in `load_target'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/associations/collection_proxy.rb:45:in `load_target'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/associations/collection_proxy.rb:983:in `records'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/relation/delegation.rb:39:in `each'
    test/cases/associations_test.rb:116:in `block (2 levels) in test_force_reload_is_uncached'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb:32:in `cache'
    /Users/kamipo/src/github.com/rails/rails/activerecord/lib/active_record/query_cache.rb:9:in `cache'
    test/cases/associations_test.rb:115:in `block in test_force_reload_is_uncached'
    /Users/kamipo/src/github.com/rails/rails/activesupport/lib/active_support/deprecation/reporting.rb:36:in `silence'
    /Users/kamipo/src/github.com/rails/rails/activesupport/lib/active_support/deprecation/instance_delegator.rb:19:in `silence'
    test/cases/associations_test.rb:114:in `test_force_reload_is_uncached'
```

record.id_was is nil in after_create/after_save, so we should use
id in these cases.

While this logic feels incomplete, the existing update_record uses the same
logic:
https://github.com/rails/rails/blob/2fda4e0874a97a76107ab9e88305169f2c625933/activerecord/lib/active_record/relation.rb#L83

This logic was originally added for a similar problem:
updates not working with after_create hook.

See: 482f8c15

Followup to #23581
Fixes #23844

Follow up to 1813b29f

I ran into an issue where validations on a suppressed record were
causing validation errors to be thrown on a record that was never going
to be saved.

There isn't a reason to run the validations on a record that doesn't
matter.

This change moves the suppressor up the chain to be run on the `save` or
`save!` in the validations rather than in persistence. The issue with
running it when we hit persistence is that the validations are run
first, then we hit persistance, and then we hit the suppressor. The
suppressor comes first.

The change to the test was required since I added the
`validates_presence_of` validations. Adding this alone was enough to
demonstrate the issue. I added a new test to demonstrate the new
behavior is explict.

Adds changelog headers for beta3 release

I was encountered remaining `:binary_testings` table by tests failure.
When remaining `:binary_testings` table, never reach `drop_table` due to
`create_table` in the test always fails.

I had to revert changes made for this CHANGELOG entry so this is no
longer valid. The change for this entry was removed in 2c02bc0a.

Follow up to 3b017856.

In order to fix issue #17621 we added a check to validations that
determined if a record should be validated. Based on the existing tests
and behavior we wanted we determined the best way to do that was by
checking if `!record.peristed? || record.changed? || record.marked_for_destruction?`

This change didn't make it into a release until now. When #23790 was
opened we realized that `valid?` and `invalid?` were broken and did not
work on persisted records because of the `!record.persisted?`.

While there is still a bug that #17621 brought up, this change was too
drastic and should not be a RC blocker. I will work on fixing this so
that we don't break `valid?` but also aren't validating parent records
through child records if that parent record is validate false. This
change removes the code changes to validate and the corresponding tests.
It adds tests for two of the bugs found since Rails 5 beta2 release.

Fixes #17621

creating all databases mutates the connection pool.  This patch restores
the connection pool to the connection spec established before creating
all databases.  Fixes #23279

We are creating the table but not deleting after the test.

A `:test_limits` table has not been created.

Once RubyGems 2.5.0 is required, then the duplicated files can be
removed, and symlinks can be used instead.

[ci skip]

Clarifying this separation and enforcing relation immutability is the
culmination of the previous efforts to remove the mutator method
delegations.

Fixes #23645

When you're using an `attr_accessor` for a record instead of an
attribute in the database there's no way for the record to know if it
has `changed?` unless you tell it `attribute_will_change!("attribute")`.

The change made in 27aa4dda updated validations to check if a record was
`changed?` or `marked_for_destruction?` or not `persisted?`. It did not
take into account virtual attributes that do not affect the model's
dirty status.

The only way to fix this is to always validate the record if the
attribute does not belong to the set of attributes the record expects
(in `record.attributes`) because virtual attributes will not be in that
hash.

I think we should consider deprecating this particular behavior in the
future and requiring that the user mark the record dirty by noting that
the virtual attribute will change. Unfortunately this isn't easy because
we have no way of knowing that you did the "right thing" in your
application by marking it dirty and will get the deprecation warning
even if you are doing the correct thing.

For now this restores expected behavior when using a virtual attribute
by always validating the record, as well as adds tests for this case.

I was going to add the `!record.attributes.include?(attribute)` to the
`should_validate?` method but `uniqueness` cannot validate a virtual
attribute with nothing to hold on to the attribute. Because of this
`should_validate?` was about to become a very messy method so I decided
to split them up so we can handle it specifically for each case.

habtm join tables commonly have two id columns and it's OK to make those
two id columns a primary key.  This commit eliminates the warnings for
join tables that have this setup.

  ManageIQ/manageiq#6713

Delegation of some `Array` methods was removed in commit 9d79334a. That
change did add explicit delegation of a few methods that `Array` has but
which aren't on `Enumerable`.  However, a few non-mutation methods were
omitted.  This adds `Array` delegation of `#in_groups`, `#in_groups_of`,
`#shuffle` and `#split`.  This allows things like
`MyThing.all.in_groups_of(3) { ... }` to continue working as they did
before commit 9d79334a.

This alias was for compatibility with legacy mysql adapter.
But the return value of both methods is already inconsistent.

`exec_query` returns `ActiveRecord::Result` instance.
But `exec_without_stmt` returns `[result_set, affected_rows]`

https://github.com/rails/rails/blob/v4.2.5.1/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb#L335-L364

Legacy mysql adapter was already removed in Rails 5.0.
I think we can remove this inconsistent alias.

Add assertions to MySQL `ORDER BY FIELD()` with empty data.
These tests examine to sanitize `ORDER BY FIELD()` with empty data
appropriately.

```ruby
  Tag.order(['field(id, ?)', []]).to_sql
  # => SELECT "tags".* FROM "tags" ORDER BY field(id, NULL)

  Tag.order(['field(id, ?)', nil]).to_sql
  # => SELECT "tags".* FROM "tags" ORDER BY field(id, NULL)
```

This resolves a bug where if the primary key used is not `id` (ex:
`uuid`), and has a `validates_uniqueness_of` in the model, a uniqueness error
would be raised. This is a partial revert of commit `119b9181`, which introduced this behavior.

`#` was removed at f57092ad but this `#` is intentional.
e.g. https://github.com/rails/rails/blame/v5.0.0.beta2/activerecord/CHANGELOG.md#L1423-L1426

This was showing up as an H1. Fixing the indentation here fixes the codeblock.

Simply it is sufficient to override `can_perform_case_insensitive_comparison_for?`.

- Previously it used to show error message
    <"undefined method `limit_value' for {:title=>\"Rails\"}:Hash">

- Now it shows following error message.

    >> Post.where.not(name: 'DHH').or(name: 'Tenderlove')
    ArgumentError: You have passed Hash object to #or. Pass an ActiveRecord::Relation object instead.

- Fixes #23714.

- The change was added in #23099

When passing in an array of different types of objects to `where`, it would only take into account the class of the first object in the array.

    PriceEstimate.where(estimate_of: [Treasure.find(1), Car.find(2)])
	# => SELECT "price_estimates".* FROM "price_estimates"
         WHERE ("price_estimates"."estimate_of_type" = 'Treasure' AND "price_estimates"."estimate_of_id" IN (1, 2))

This is fixed to properly look for any records matching both type and id:

    PriceEstimate.where(estimate_of: [Treasure.find(1), Car.find(2)])
    # => SELECT "price_estimates".* FROM "price_estimates"
         WHERE (("price_estimates"."estimate_of_type" = 'Treasure' AND "price_estimates"."estimate_of_id" = 1)
         OR ("price_estimates"."estimate_of_type" = 'Car' AND "price_estimates"."estimate_of_id" = 2))

Saw the `merge!` and had to prove to myself that the parent model's local_stored_attributes was not being changed when stored_attributes is called on a child model. Proved to be working as expected but this test is probably still useful to keep around.

[ci skip]

Previously if you used `t.foreign_key` twice within the same
`create_table` block using the same `to_table`, all statements except
the final one would fail silently. For example, the following code:

    def change
      create_table :flights do |t|
        t.integer :from_id, index: true, null: false
        t.integer :to_id,   index: true, null: false

        t.foreign_key :airports, column: :from_id
        t.foreign_key :airports, column: :to_id
      end
    end

Would only create one foreign key, on the column `from_id`.

This commit allows multiple foreign keys to the same table to be created
within one `create_table` block.