Relation.where with no args can be chained with not, like, and not_like

examples:

  Model.where.not field: nil
  #=> "SELECT * FROM models WHERE field IS NOT NULL

  Model.where.like name: 'Jeremy%'
  #=> "SELECT * FROM models WHERE name LIKE 'Jeremy%'

this feature was originally suggested by Jeremy Kemper https://github.com/rails/rails/pull/5950#issuecomment-5591330

Closes #5950
Run rake tasks all at once in rake dbs test for a speed up

Before:

    Finished tests in 56.245787s, 0.2133 tests/s, 0.0000 assertions/s.
    12 tests, 0 assertions, 0 failures, 0 errors, 0 skips

After:
    Finished tests in 42.401416s, 0.2830 tests/s, 0.0000 assertions/s.
    12 tests, 0 assertions, 0 failures, 0 errors, 0 skips
Use CURRENT_TIMESTAMP since it has apparently better cross db support

LOCALTIMESTAMP is not support by sqlite3, and travis was giving us these
errors: https://travis-ci.org/rails/rails/jobs/3535241/#L570
Remove method redefined warnings
Improve AR changelog
Unscope update_column(s) query to ignore default scope

When applying default_scope to a class with a where clause, using
update_column(s) could generate a query that would not properly update
the record due to the where clause from the default_scope being applied
to the update query.

    class User < ActiveRecord::Base
      default_scope where(active: true)
    end

    user = User.first
    user.active = false
    user.save!

    user.update_column(:active, true) # => false

In this situation we want to skip the default_scope clause and just
update the record based on the primary key. With this change:

    user.update_column(:active, true) # => true

Fixes #8436.
Stop shelling out more than necessary
Merge pull request #8332 from amatsuda/ar_where_chain

Relation.where with no args can be chained with not, like, and not_like

Conflicts:
	activerecord/CHANGELOG.md
	activerecord/lib/active_record/relation/query_methods.rb
Ensure there won't be any regression with where(nil) calls

Consider this scenario:

    if params[:foo]
      conditions = { foo: true }
    end

    foos = Foo.where(conditions).order(:id)

When params[:foo] is nil, this would call:

    foos = Foo.where(nil).order(:id)

In this scenario, we want Foo.where(conditions) to be the same as calling
Foo.all, otherwise we'd get a "NoMethodError order for WhereChain".

Related to #8332.
Move where with blank conditions test to the correct where tests file

This test does not belong to has many associations test.
Revert "Invert precedence of content in ActionDispatch::Static"

This reverts commit c59734f756b79c39486c45273d2cc5d42cd0c864.
Update #where rdoc to match 6ba0f97 [ci skip]

This commit updates the rdoc of AR#where to match the changes applied
in https://github.com/rails/rails/commit/6ba0f97 that is:

* `where(nil)` has the same effect of `where('')`: a no op
* `where` (no args) has the same effect of `where(:chain)`: to create a WhereChain
Merge pull request #8445 from claudiob/match_rdoc_with_6ba0f97

Update #where rdoc to match 6ba0f97 [ci skip]
Fix where.not with in clause

Arel::Nodes::In inherits from Arel::Nodes::Equality, so the case
statement was always using the Equality operator for both scenarios,
resulting in a not equal query instead.