Merge branch 'master' into pr/18316

Conflicts:
	activerecord/CHANGELOG.md

213 files changed, 2822 insertions, 1875 deletions

diff --git a/activerecord/CHANGELOG.md b/activerecord/CHANGELOG.md
index dfcf4b92ac..c834f4d5d5 100644
--- a/activerecord/CHANGELOG.md
+++ b/activerecord/CHANGELOG.md
@@ -2,6 +2,223 @@
 
     *Sammy Larbi*
 
+*   Fixed ActiveRecord::Relation#group method when argument is SQL reserved key word:
+
+    Example:
+
+        SplitTest.group(:key).count
+        Property.group(:value).count
+
+    *Bogdan Gusiev*
+
+*   Added the `#or` method on ActiveRecord::Relation, allowing use of the OR
+    operator to combine WHERE or HAVING clauses.
+
+    Example:
+
+        Post.where('id = 1').or(Post.where('id = 2'))
+        # => SELECT * FROM posts WHERE (id = 1) OR (id = 2)
+
+    *Sean Griffin*, *Matthew Draper*, *Gael Muller*, *Olivier El Mekki*
+
+*   Don't define autosave association callbacks twice from
+    `accepts_nested_attributes_for`.
+
+    Fixes #18704.
+
+    *Sean Griffin*
+
+*   Integer types will no longer raise a `RangeError` when assigning an
+    attribute, but will instead raise when going to the database.
+
+    Fixes several vague issues which were never reported directly. See the
+    commit message from the commit which added this line for some examples.
+
+    *Sean Griffin*
+
+*   Values which would error while being sent to the database (such as an
+    ASCII-8BIT string with invalid UTF-8 bytes on Sqlite3), no longer error on
+    assignment. They will still error when sent to the database, but you are
+    given the ability to re-assign it to a valid value.
+
+    Fixes #18580.
+
+    *Sean Griffin*
+
+*   Don't remove join dependencies in `Relation#exists?`
+
+    Fixes #18632.
+
+    *Sean Griffin*
+
+*   Invalid values assigned to a JSON column are assumed to be `nil`.
+
+    Fixes #18629.
+
+    *Sean Griffin*
+
+*   Add `ActiveRecord::Base#accessed_fields`, which can be used to quickly
+    discover which fields were read from a model when you are looking to only
+    select the data you need from the database.
+
+    *Sean Griffin*
+
+*   Introduce the `:if_exists` option for `drop_table`.
+
+    Example:
+
+        drop_table(:posts, if_exists: true)
+
+    That would execute:
+
+        DROP TABLE IF EXISTS posts
+
+    If the table doesn't exist, `if_exists: false` (the default) raises an
+    exception whereas `if_exists: true` does nothing.
+
+    *Cody Cutrer*, *Stefan Kanev*, *Ryuta Kamizono*
+
+*   Don't run SQL if attribute value is not changed for update_attribute method.
+
+    *Prathamesh Sonpatki*
+
+*   `time` columns can now get affected by `time_zone_aware_attributes`. If you have
+    set `config.time_zone` to a value other than `'UTC'`, they will be treated
+    as in that time zone by default in Rails 5.1. If this is not the desired
+    behavior, you can set
+
+        ActiveRecord::Base.time_zone_aware_types = [:datetime]
+
+    A deprecation warning will be emitted if you have a `:time` column, and have
+    not explicitly opted out.
+
+    Fixes #3145.
+
+    *Sean Griffin*
+
+*   Tests now run after_commit callbacks. You no longer have to declare
+    `uses_transaction ‘test name’` to test the results of an after_commit.
+
+    after_commit callbacks run after committing a transaction whose parent
+    is not `joinable?`: un-nested transactions, transactions within test cases,
+    and transactions in `console --sandbox`.
+
+    *arthurnn*, *Ravil Bayramgalin*, *Matthew Draper*
+
+*   `nil` as a value for a binary column in a query no longer logs as
+    "<NULL binary data>", and instead logs as just "nil".
+
+    *Sean Griffin*
+
+*   `attribute_will_change!` will no longer cause non-persistable attributes to
+    be sent to the database.
+
+    Fixes #18407.
+
+    *Sean Griffin*
+
+*   Remove support for the `protected_attributes` gem.
+
+    *Carlos Antonio da Silva*, *Roberto Miranda*
+
+*   Fix accessing of fixtures having non-string labels like Fixnum.
+
+    *Prathamesh Sonpatki*
+
+*   Remove deprecated support to preload instance-dependent associations.
+
+    *Yves Senn*
+
+*   Remove deprecated support for PostgreSQL ranges with exclusive lower bounds.
+
+    *Yves Senn*
+
+*   Remove deprecation when modifying a relation with cached arel.
+    This raises an `ImmutableRelation` error instead.
+
+    *Yves Senn*
+
+*   Added `ActiveRecord::SecureToken` in order to encapsulate generation of
+    unique tokens for attributes in a model using `SecureRandom`.
+
+    *Roberto Miranda*
+
+*   Change the behavior of boolean columns to be closer to Ruby's semantics.
+
+    Before this change we had a small set of "truthy", and all others are "falsy".
+
+    Now, we have a small set of "falsy" values and all others are "truthy" matching
+    Ruby's semantics.
+
+    *Rafael Mendonça França*
+
+*   Deprecate `ActiveRecord::Base.errors_in_transactional_callbacks=`.
+
+    *Rafael Mendonça França*
+
+*   Change transaction callbacks to not swallow errors.
+
+    Before this change any errors raised inside a transaction callback
+    were getting rescued and printed in the logs.
+
+    Now these errors are not rescued anymore and just bubble up, as the other callbacks.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `sanitize_sql_hash_for_conditions`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `Reflection#source_macro`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `symbolized_base_class` and `symbolized_sti_name`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `ActiveRecord::Base.disable_implicit_join_references=`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated access to connection specification using a string accessor.
+
+    Now all strings will be handled as a URL.
+
+    *Rafael Mendonça França*
+
+*   Change the default `null` value for `timestamps` to `false`.
+
+    *Rafael Mendonça França*
+
+*   Return an array of pools from `connection_pools`.
+
+    *Rafael Mendonça França*
+
+*   Return a null column from `column_for_attribute` when no column exists.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `serialized_attributes`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated automatic counter caches on `has_many :through`.
+
+    *Rafael Mendonça França*
+
+*   Change the way in which callback chains can be halted.
+
+    The preferred method to halt a callback chain from now on is to explicitly
+    `throw(:abort)`.
+    In the past, returning `false` in an ActiveRecord `before_` callback had the
+    side effect of halting the callback chain.
+    This is not recommended anymore and, depending on the value of the
+    `config.active_support.halt_callback_chains_on_return_false` option, will
+    either not work at all or display a deprecation warning.
+
+    *claudiob*
+
 *   Clear query cache on rollback.
 
     *Florian Weingarten*
@@ -180,7 +397,7 @@
 
     This option enables to define the column name of associated object's type for polymorphic associations.
 
-    *Ulisses Almeida, Kassio Borges*
+    *Ulisses Almeida*, *Kassio Borges*
 
 *   Remove deprecated behavior allowing nested arrays to be passed as query
     values.
diff --git a/activerecord/RUNNING_UNIT_TESTS.rdoc b/activerecord/RUNNING_UNIT_TESTS.rdoc
index 7e3460365b..bae40604b1 100644
--- a/activerecord/RUNNING_UNIT_TESTS.rdoc
+++ b/activerecord/RUNNING_UNIT_TESTS.rdoc
@@ -16,7 +16,7 @@ To run a set of tests:
 You can also run tests that depend upon a specific database backend. For
 example:
 
-  $ bundle exec rake test_sqlite3
+  $ bundle exec rake test:sqlite3
 
 Simply executing <tt>bundle exec rake test</tt> is equivalent to the following:
 
@@ -24,6 +24,10 @@ Simply executing <tt>bundle exec rake test</tt> is equivalent to the following:
   $ bundle exec rake test:mysql2
   $ bundle exec rake test:postgresql
   $ bundle exec rake test:sqlite3
+
+Using the SQLite3 adapter with an in-memory database is the fastest way
+to run the tests:
+
   $ bundle exec rake test:sqlite3_mem
 
 There should be tests available for each database backend listed in the {Config
diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb
index 2eec62846b..d9d47c3d99 100644
--- a/activerecord/lib/active_record.rb
+++ b/activerecord/lib/active_record.rb
@@ -67,6 +67,7 @@ module ActiveRecord
   autoload :Transactions
   autoload :Translation
   autoload :Validations
+  autoload :SecureToken
 
   eager_autoload do
     autoload :ActiveRecordError, 'active_record/errors'
diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index 14af55f327..35bc09bb10 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -1245,6 +1245,10 @@ module ActiveRecord
       #   that is the inverse of this <tt>has_many</tt> association. Does not work in combination
       #   with <tt>:through</tt> or <tt>:as</tt> options.
       #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
+      # [:extend]
+      #   Specifies a module or array of modules that will be extended into the association object returned.
+      #   Useful for defining methods on associations, especially when they should be shared between multiple
+      #   association objects.
       #
       # Option examples:
       #   has_many :comments, -> { order "posted_on" }
diff --git a/activerecord/lib/active_record/associations/association_scope.rb b/activerecord/lib/active_record/associations/association_scope.rb
index d06b7b3508..2416167834 100644
--- a/activerecord/lib/active_record/associations/association_scope.rb
+++ b/activerecord/lib/active_record/associations/association_scope.rb
@@ -2,42 +2,30 @@ module ActiveRecord
   module Associations
     class AssociationScope #:nodoc:
       def self.scope(association, connection)
-        INSTANCE.scope association, connection
-      end
-
-      class BindSubstitution
-        def initialize(block)
-          @block = block
-        end
-
-        def bind_value(scope, column, value, connection)
-          substitute = connection.substitute_at(column)
-          scope.bind_values += [[column, @block.call(value)]]
-          substitute
-        end
+        INSTANCE.scope(association, connection)
       end
 
       def self.create(&block)
-        block = block ? block : lambda { |val| val }
-        new BindSubstitution.new(block)
+        block ||= lambda { |val| val }
+        new(block)
       end
 
-      def initialize(bind_substitution)
-        @bind_substitution = bind_substitution
+      def initialize(value_transformation)
+        @value_transformation = value_transformation
       end
 
       INSTANCE = create
 
       def scope(association, connection)
-        klass         = association.klass
-        reflection    = association.reflection
-        scope         = klass.unscoped
-        owner         = association.owner
+        klass = association.klass
+        reflection = association.reflection
+        scope = klass.unscoped
+        owner = association.owner
         alias_tracker = AliasTracker.create connection, association.klass.table_name, klass.type_caster
         chain_head, chain_tail = get_chain(reflection, association, alias_tracker)
 
         scope.extending! Array(reflection.options[:extend])
-        add_constraints(scope, owner, klass, reflection, connection, chain_head, chain_tail)
+        add_constraints(scope, owner, klass, reflection, chain_head, chain_tail)
       end
 
       def join_type
@@ -61,43 +49,36 @@ module ActiveRecord
         binds
       end
 
+      protected
+
+      attr_reader :value_transformation
+
       private
       def join(table, constraint)
         table.create_join(table, table.create_on(constraint), join_type)
       end
 
-      def column_for(table_name, column_name, connection)
-        columns = connection.schema_cache.columns_hash(table_name)
-        columns[column_name]
-      end
-
-      def bind_value(scope, column, value, connection)
-        @bind_substitution.bind_value scope, column, value, connection
-      end
-
-      def bind(scope, table_name, column_name, value, connection)
-        column   = column_for table_name, column_name, connection
-        bind_value scope, column, value, connection
-      end
-
-      def last_chain_scope(scope, table, reflection, owner, connection, association_klass)
+      def last_chain_scope(scope, table, reflection, owner, association_klass)
         join_keys = reflection.join_keys(association_klass)
         key = join_keys.key
         foreign_key = join_keys.foreign_key
 
-        bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], connection
-        scope    = scope.where(table[key].eq(bind_val))
+        value = transform_value(owner[foreign_key])
+        scope = scope.where(table.name => { key => value })
 
         if reflection.type
-          value    = owner.class.base_class.name
-          bind_val = bind scope, table.table_name, reflection.type, value, connection
-          scope    = scope.where(table[reflection.type].eq(bind_val))
-        else
-          scope
+          polymorphic_type = transform_value(owner.class.base_class.name)
+          scope = scope.where(table.name => { reflection.type => polymorphic_type })
         end
+
+        scope
+      end
+
+      def transform_value(value)
+        value_transformation.call(value)
       end
 
-      def next_chain_scope(scope, table, reflection, connection, association_klass, foreign_table, next_reflection)
+      def next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
         join_keys = reflection.join_keys(association_klass)
         key = join_keys.key
         foreign_key = join_keys.foreign_key
@@ -105,9 +86,8 @@ module ActiveRecord
         constraint = table[key].eq(foreign_table[foreign_key])
 
         if reflection.type
-          value    = next_reflection.klass.base_class.name
-          bind_val = bind scope, table.table_name, reflection.type, value, connection
-          scope    = scope.where(table[reflection.type].eq(bind_val))
+          value = transform_value(next_reflection.klass.base_class.name)
+          scope = scope.where(table.name => { reflection.type => value })
         end
 
         scope = scope.joins(join(foreign_table, constraint))
@@ -138,10 +118,10 @@ module ActiveRecord
         [runtime_reflection, previous_reflection]
       end
 
-      def add_constraints(scope, owner, association_klass, refl, connection, chain_head, chain_tail)
+      def add_constraints(scope, owner, association_klass, refl, chain_head, chain_tail)
         owner_reflection = chain_tail
         table = owner_reflection.alias_name
-        scope = last_chain_scope(scope, table, owner_reflection, owner, connection, association_klass)
+        scope = last_chain_scope(scope, table, owner_reflection, owner, association_klass)
 
         reflection = chain_head
         loop do
@@ -151,7 +131,7 @@ module ActiveRecord
           unless reflection == chain_tail
             next_reflection = reflection.next
             foreign_table = next_reflection.alias_name
-            scope = next_chain_scope(scope, table, reflection, connection, association_klass, foreign_table, next_reflection)
+            scope = next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
           end
 
           # Exclude the scope of the association itself, because that
@@ -160,15 +140,14 @@ module ActiveRecord
             item  = eval_scope(reflection.klass, scope_chain_item, owner)
 
             if scope_chain_item == refl.scope
-              scope.merge! item.except(:where, :includes, :bind)
+              scope.merge! item.except(:where, :includes)
             end
 
             reflection.all_includes do
               scope.includes! item.includes_values
             end
 
-            scope.where_values += item.where_values
-            scope.bind_values  += item.bind_values
+            scope.where_clause += item.where_clause
             scope.order_values |= item.order_values
           end
 
diff --git a/activerecord/lib/active_record/associations/belongs_to_association.rb b/activerecord/lib/active_record/associations/belongs_to_association.rb
index c63b42e2a0..265a65c4c1 100644
--- a/activerecord/lib/active_record/associations/belongs_to_association.rb
+++ b/activerecord/lib/active_record/associations/belongs_to_association.rb
@@ -68,6 +68,9 @@ module ActiveRecord
         def increment_counter(counter_cache_name)
           if foreign_key_present?
             klass.increment_counter(counter_cache_name, target_id)
+            if target && !stale_target?
+              target.increment(counter_cache_name)
+            end
           end
         end
 
diff --git a/activerecord/lib/active_record/associations/builder/singular_association.rb b/activerecord/lib/active_record/associations/builder/singular_association.rb
index 1369212837..f6274c027e 100644
--- a/activerecord/lib/active_record/associations/builder/singular_association.rb
+++ b/activerecord/lib/active_record/associations/builder/singular_association.rb
@@ -31,7 +31,7 @@ module ActiveRecord::Associations::Builder
     def self.define_validations(model, reflection)
       super
       if reflection.options[:required]
-        model.validates_presence_of reflection.name
+        model.validates_presence_of reflection.name, message: :required
       end
     end
   end
diff --git a/activerecord/lib/active_record/associations/collection_association.rb b/activerecord/lib/active_record/associations/collection_association.rb
index f2c96e9a2a..4b7591e15c 100644
--- a/activerecord/lib/active_record/associations/collection_association.rb
+++ b/activerecord/lib/active_record/associations/collection_association.rb
@@ -151,6 +151,7 @@ module ActiveRecord
       # be chained. Since << flattens its argument list and inserts each record,
       # +push+ and +concat+ behave identically.
       def concat(*records)
+        records = records.flatten
         if owner.new_record?
           load_target
           concat_records(records)
@@ -549,7 +550,7 @@ module ActiveRecord
         def concat_records(records, should_raise = false)
           result = true
 
-          records.flatten.each do |record|
+          records.each do |record|
             raise_on_type_mismatch!(record)
             add_to_target(record) do |rec|
               result &&= insert_record(rec, true, should_raise) unless owner.new_record?
diff --git a/activerecord/lib/active_record/associations/has_many_association.rb b/activerecord/lib/active_record/associations/has_many_association.rb
index d7f655d00c..b574185561 100644
--- a/activerecord/lib/active_record/associations/has_many_association.rb
+++ b/activerecord/lib/active_record/associations/has_many_association.rb
@@ -17,7 +17,7 @@ module ActiveRecord
           unless empty?
             record = klass.human_attribute_name(reflection.name).downcase
             owner.errors.add(:base, :"restrict_dependent_destroy.many", record: record)
-            false
+            throw(:abort)
           end
 
         else
@@ -101,7 +101,7 @@ module ActiveRecord
         end
 
         def update_counter_in_memory(difference, reflection = reflection())
-          if has_cached_counter?(reflection)
+          if counter_must_be_updated_by_has_many?(reflection)
             counter = cached_counter_attribute_name(reflection)
             owner[counter] += difference
             owner.send(:clear_attribute_changes, counter) # eww
@@ -118,18 +118,28 @@ module ActiveRecord
         #     it will be decremented twice.
         #
         # Hence this method.
-        def inverse_updates_counter_cache?(reflection = reflection())
+        def inverse_which_updates_counter_cache(reflection = reflection())
           counter_name = cached_counter_attribute_name(reflection)
-          inverse_updates_counter_named?(counter_name, reflection)
+          inverse_which_updates_counter_named(counter_name, reflection)
         end
+        alias inverse_updates_counter_cache? inverse_which_updates_counter_cache
 
-        def inverse_updates_counter_named?(counter_name, reflection = reflection())
-          reflection.klass._reflections.values.any? { |inverse_reflection|
+        def inverse_which_updates_counter_named(counter_name, reflection)
+          reflection.klass._reflections.values.find { |inverse_reflection|
             inverse_reflection.belongs_to? &&
             inverse_reflection.counter_cache_column == counter_name
           }
         end
 
+        def inverse_updates_counter_in_memory?(reflection)
+          inverse = inverse_which_updates_counter_cache(reflection)
+          inverse && inverse == reflection.inverse_of
+        end
+
+        def counter_must_be_updated_by_has_many?(reflection)
+          !inverse_updates_counter_in_memory?(reflection) && has_cached_counter?(reflection)
+        end
+
         def delete_count(method, scope)
           if method == :delete_all
             scope.delete_all
diff --git a/activerecord/lib/active_record/associations/has_many_through_association.rb b/activerecord/lib/active_record/associations/has_many_through_association.rb
index 7a050ca224..4fcbc98c62 100644
--- a/activerecord/lib/active_record/associations/has_many_through_association.rb
+++ b/activerecord/lib/active_record/associations/has_many_through_association.rb
@@ -1,5 +1,3 @@
-require 'active_support/core_ext/string/filters'
-
 module ActiveRecord
   # = Active Record Has Many Through Association
   module Associations
@@ -49,16 +47,7 @@ module ActiveRecord
         end
 
         save_through_record(record)
-        if has_cached_counter? && !through_reflection_updates_counter_cache?
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Automatic updating of counter caches on through associations has been
-            deprecated, and will be removed in Rails 5. Instead, please set the
-            appropriate `counter_cache` options on the `has_many` and `belongs_to`
-            for your associations to #{through_reflection.name}.
-          MSG
 
-          update_counter_in_database(1)
-        end
         record
       end
 
@@ -154,7 +143,7 @@ module ActiveRecord
               stmt.from scope.klass.arel_table
               stmt.wheres = arel.constraints
 
-              count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
+              count = scope.klass.connection.delete(stmt, 'SQL', scope.bound_attributes)
             end
           when :nullify
             count = scope.update_all(source_reflection.foreign_key => nil)
@@ -211,11 +200,6 @@ module ActiveRecord
         def invertible_for?(record)
           false
         end
-
-        def through_reflection_updates_counter_cache?
-          counter_name = cached_counter_attribute_name
-          inverse_updates_counter_named?(counter_name, through_reflection)
-        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/associations/has_one_association.rb b/activerecord/lib/active_record/associations/has_one_association.rb
index 74b8c53758..41a75b820e 100644
--- a/activerecord/lib/active_record/associations/has_one_association.rb
+++ b/activerecord/lib/active_record/associations/has_one_association.rb
@@ -13,7 +13,7 @@ module ActiveRecord
           if load_target
             record = klass.human_attribute_name(reflection.name).downcase
             owner.errors.add(:base, :"restrict_dependent_destroy.one", record: record)
-            false
+            throw(:abort)
           end
 
         else
diff --git a/activerecord/lib/active_record/associations/join_dependency/join_association.rb b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
index c1ef86a95b..a6ad09a38a 100644
--- a/activerecord/lib/active_record/associations/join_dependency/join_association.rb
+++ b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
@@ -25,7 +25,7 @@ module ActiveRecord
 
         def join_constraints(foreign_table, foreign_klass, node, join_type, tables, scope_chain, chain)
           joins         = []
-          bind_values   = []
+          binds         = []
           tables        = tables.reverse
 
           scope_chain_index = 0
@@ -66,7 +66,7 @@ module ActiveRecord
             end
 
             if rel && !rel.arel.constraints.empty?
-              bind_values.concat rel.bind_values
+              binds += rel.bound_attributes
               constraint = constraint.and rel.arel.constraints
             end
 
@@ -75,7 +75,7 @@ module ActiveRecord
               column = klass.columns_hash[reflection.type.to_s]
 
               substitute = klass.connection.substitute_at(column)
-              bind_values.push [column, value]
+              binds << Relation::QueryAttribute.new(column.name, value, klass.type_for_attribute(column.name))
               constraint = constraint.and table[reflection.type].eq substitute
             end
 
@@ -85,7 +85,7 @@ module ActiveRecord
             foreign_table, foreign_klass = table, klass
           end
 
-          JoinInformation.new joins, bind_values
+          JoinInformation.new joins, binds
         end
 
         #  Builds equality condition.
diff --git a/activerecord/lib/active_record/associations/preloader.rb b/activerecord/lib/active_record/associations/preloader.rb
index 4358f3b581..97f4bd3811 100644
--- a/activerecord/lib/active_record/associations/preloader.rb
+++ b/activerecord/lib/active_record/associations/preloader.rb
@@ -89,7 +89,7 @@ module ActiveRecord
       #   { author: :avatar }
       #   [ :books, { author: :avatar } ]
 
-      NULL_RELATION = Struct.new(:values, :bind_values).new({}, [])
+      NULL_RELATION = Struct.new(:values, :where_clause, :joins_values).new({}, Relation::WhereClause.empty, [])
 
       def preload(records, associations, preload_scope = nil)
         records       = Array.wrap(records).compact.uniq
diff --git a/activerecord/lib/active_record/associations/preloader/association.rb b/activerecord/lib/active_record/associations/preloader/association.rb
index a6e1a24360..1dc8bff193 100644
--- a/activerecord/lib/active_record/associations/preloader/association.rb
+++ b/activerecord/lib/active_record/associations/preloader/association.rb
@@ -131,18 +131,19 @@ module ActiveRecord
         def build_scope
           scope = klass.unscoped
 
-          values         = reflection_scope.values
-          reflection_binds = reflection_scope.bind_values
+          values = reflection_scope.values
           preload_values = preload_scope.values
-          preload_binds  = preload_scope.bind_values
 
-          scope.where_values      = Array(values[:where])      + Array(preload_values[:where])
+          scope.where_clause = reflection_scope.where_clause + preload_scope.where_clause
           scope.references_values = Array(values[:references]) + Array(preload_values[:references])
-          scope.bind_values       = (reflection_binds + preload_binds)
 
-          scope._select!   preload_values[:select] || values[:select] || table[Arel.star]
+          scope._select! preload_values[:select] || values[:select] || table[Arel.star]
           scope.includes! preload_values[:includes] || values[:includes]
-          scope.joins! preload_values[:joins] || values[:joins]
+          if preload_scope.joins_values.any?
+            scope.joins!(preload_scope.joins_values)
+          else
+            scope.joins!(reflection_scope.joins_values)
+          end
           scope.order! preload_values[:order] || values[:order]
 
           if preload_values[:readonly] || values[:readonly]
diff --git a/activerecord/lib/active_record/associations/preloader/through_association.rb b/activerecord/lib/active_record/associations/preloader/through_association.rb
index 12bf3ef138..56aa23b173 100644
--- a/activerecord/lib/active_record/associations/preloader/through_association.rb
+++ b/activerecord/lib/active_record/associations/preloader/through_association.rb
@@ -78,10 +78,9 @@ module ActiveRecord
           if options[:source_type]
             scope.where! reflection.foreign_type => options[:source_type]
           else
-            unless reflection_scope.where_values.empty?
+            unless reflection_scope.where_clause.empty?
               scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
-              scope.where_values    = reflection_scope.values[:where]
-              scope.bind_values     = reflection_scope.bind_values
+              scope.where_clause = reflection_scope.where_clause
             end
 
             scope.references! reflection_scope.values[:references]
diff --git a/activerecord/lib/active_record/associations/through_association.rb b/activerecord/lib/active_record/associations/through_association.rb
index 09828dbd9b..3ce9cffdbc 100644
--- a/activerecord/lib/active_record/associations/through_association.rb
+++ b/activerecord/lib/active_record/associations/through_association.rb
@@ -18,7 +18,7 @@ module ActiveRecord
 
             reflection_scope = reflection.scope
             if reflection_scope && reflection_scope.arity.zero?
-              relation.merge!(reflection_scope)
+              relation = relation.merge(reflection_scope)
             end
 
             scope.merge!(
diff --git a/activerecord/lib/active_record/attribute.rb b/activerecord/lib/active_record/attribute.rb
index 88536eaac0..91886f1324 100644
--- a/activerecord/lib/active_record/attribute.rb
+++ b/activerecord/lib/active_record/attribute.rb
@@ -51,7 +51,7 @@ module ActiveRecord
     end
 
     def changed_in_place_from?(old_value)
-      type.changed_in_place?(old_value, value)
+      has_been_read? && type.changed_in_place?(old_value, value)
     end
 
     def with_value_from_user(value)
@@ -66,6 +66,10 @@ module ActiveRecord
       self.class.with_cast_value(name, value, type)
     end
 
+    def with_type(type)
+      self.class.new(name, value_before_type_cast, type)
+    end
+
     def type_cast(*)
       raise NotImplementedError
     end
@@ -74,12 +78,25 @@ module ActiveRecord
       true
     end
 
+    def came_from_user?
+      false
+    end
+
+    def has_been_read?
+      defined?(@value)
+    end
+
     def ==(other)
       self.class == other.class &&
         name == other.name &&
         value_before_type_cast == other.value_before_type_cast &&
         type == other.type
     end
+    alias eql? ==
+
+    def hash
+      [self.class, name, value_before_type_cast, type].hash
+    end
 
     protected
 
@@ -99,6 +116,10 @@ module ActiveRecord
       def type_cast(value)
         type.type_cast_from_user(value)
       end
+
+      def came_from_user?
+        true
+      end
     end
 
     class WithCastValue < Attribute # :nodoc:
@@ -120,6 +141,10 @@ module ActiveRecord
         nil
       end
 
+      def with_type(type)
+        self.class.with_cast_value(name, nil, type)
+      end
+
       def with_value_from_database(value)
         raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
       end
@@ -144,6 +169,6 @@ module ActiveRecord
         false
       end
     end
-    private_constant :FromDatabase, :FromUser, :Null, :Uninitialized
+    private_constant :FromDatabase, :FromUser, :Null, :Uninitialized, :WithCastValue
   end
 end
diff --git a/activerecord/lib/active_record/attribute_assignment.rb b/activerecord/lib/active_record/attribute_assignment.rb
index bf64830417..fdc90df5b6 100644
--- a/activerecord/lib/active_record/attribute_assignment.rb
+++ b/activerecord/lib/active_record/attribute_assignment.rb
@@ -3,63 +3,32 @@ require 'active_model/forbidden_attributes_protection'
 module ActiveRecord
   module AttributeAssignment
     extend ActiveSupport::Concern
-    include ActiveModel::ForbiddenAttributesProtection
-
-    # Allows you to set all the attributes by passing in a hash of attributes with
-    # keys matching the attribute names (which again matches the column names).
-    #
-    # If the passed hash responds to <tt>permitted?</tt> method and the return value
-    # of this method is +false+ an <tt>ActiveModel::ForbiddenAttributesError</tt>
-    # exception is raised.
-    #
-    #   cat = Cat.new(name: "Gorby", status: "yawning")
-    #   cat.attributes # =>  { "name" => "Gorby", "status" => "yawning", "created_at" => nil, "updated_at" => nil}
-    #   cat.assign_attributes(status: "sleeping")
-    #   cat.attributes # =>  { "name" => "Gorby", "status" => "sleeping", "created_at" => nil, "updated_at" => nil }
-    #
-    # New attributes will be persisted in the database when the object is saved.
-    #
-    # Aliased to <tt>attributes=</tt>.
-    def assign_attributes(new_attributes)
-      if !new_attributes.respond_to?(:stringify_keys)
-        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
-      end
-      return if new_attributes.blank?
+    include ActiveModel::AttributeAssignment
+
+    # Alias for `assign_attributes`. See +ActiveModel::AttributeAssignment+.
+    def attributes=(attributes)
+      assign_attributes(attributes)
+    end
 
-      attributes                  = new_attributes.stringify_keys
-      multi_parameter_attributes  = []
-      nested_parameter_attributes = []
+    private
 
-      attributes = sanitize_for_mass_assignment(attributes)
+    def _assign_attributes(attributes) # :nodoc:
+      multi_parameter_attributes  = {}
+      nested_parameter_attributes = {}
 
       attributes.each do |k, v|
         if k.include?("(")
-          multi_parameter_attributes << [ k, v ]
+          multi_parameter_attributes[k] = attributes.delete(k)
         elsif v.is_a?(Hash)
-          nested_parameter_attributes << [ k, v ]
-        else
-          _assign_attribute(k, v)
+          nested_parameter_attributes[k] = attributes.delete(k)
         end
       end
+      super(attributes)
 
       assign_nested_parameter_attributes(nested_parameter_attributes) unless nested_parameter_attributes.empty?
       assign_multiparameter_attributes(multi_parameter_attributes) unless multi_parameter_attributes.empty?
     end
 
-    alias attributes= assign_attributes
-
-    private
-
-    def _assign_attribute(k, v)
-      public_send("#{k}=", v)
-    rescue NoMethodError
-      if respond_to?("#{k}=")
-        raise
-      else
-        raise UnknownAttributeError.new(self, k)
-      end
-    end
-
     # Assign any deferred nested attributes after the base attributes have been set.
     def assign_nested_parameter_attributes(pairs)
       pairs.each { |k, v| _assign_attribute(k, v) }
diff --git a/activerecord/lib/active_record/attribute_decorators.rb b/activerecord/lib/active_record/attribute_decorators.rb
index 5b96623b6e..7d0ae32411 100644
--- a/activerecord/lib/active_record/attribute_decorators.rb
+++ b/activerecord/lib/active_record/attribute_decorators.rb
@@ -15,7 +15,7 @@ module ActiveRecord
       end
 
       def decorate_matching_attribute_types(matcher, decorator_name, &block)
-        clear_caches_calculated_from_columns
+        reload_schema_from_cache
         decorator_name = decorator_name.to_s
 
         # Create new hashes so we don't modify parent classes
@@ -24,10 +24,11 @@ module ActiveRecord
 
       private
 
-      def add_user_provided_columns(*)
-        super.map do |column|
-          decorated_type = attribute_type_decorations.apply(column.name, column.cast_type)
-          column.with_type(decorated_type)
+      def load_schema!
+        super
+        attribute_types.each do |name, type|
+          decorated_type = attribute_type_decorations.apply(name, type)
+          define_attribute(name, decorated_type)
         end
       end
     end
diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb
index b7edac791e..9d58a19304 100644
--- a/activerecord/lib/active_record/attribute_methods.rb
+++ b/activerecord/lib/active_record/attribute_methods.rb
@@ -83,7 +83,7 @@ module ActiveRecord
         generated_attribute_methods.synchronize do
           return false if @attribute_methods_generated
           superclass.define_attribute_methods unless self == base_class
-          super(column_names)
+          super(attribute_names)
           @attribute_methods_generated = true
         end
         true
@@ -185,14 +185,15 @@ module ActiveRecord
       #   # => ["id", "created_at", "updated_at", "name", "age"]
       def attribute_names
         @attribute_names ||= if !abstract_class? && table_exists?
-            column_names
+            attribute_types.keys
           else
             []
           end
       end
 
       # Returns the column object for the named attribute.
-      # Returns nil if the named attribute does not exist.
+      # Returns a +ActiveRecord::ConnectionAdapters::NullColumn+ if the
+      # named attribute does not exist.
       #
       #   class Person < ActiveRecord::Base
       #   end
@@ -202,17 +203,12 @@ module ActiveRecord
       #   # => #<ActiveRecord::ConnectionAdapters::Column:0x007ff4ab083980 @name="name", @sql_type="varchar(255)", @null=true, ...>
       #
       #   person.column_for_attribute(:nothing)
-      #   # => nil
+      #   # => #<ActiveRecord::ConnectionAdapters::NullColumn:0xXXX @name=nil, @sql_type=nil, @cast_type=#<Type::Value>, ...>
       def column_for_attribute(name)
-        column = columns_hash[name.to_s]
-        if column.nil?
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `#column_for_attribute` will return a null object for non-existent
-            columns in Rails 5. Use `#has_attribute?` if you need to check for
-            an attribute's existence.
-          MSG
+        name = name.to_s
+        columns_hash.fetch(name) do
+          ConnectionAdapters::NullColumn.new(name)
         end
-        column
       end
     end
 
@@ -373,6 +369,39 @@ module ActiveRecord
       write_attribute(attr_name, value)
     end
 
+    # Returns the name of all database fields which have been read from this
+    # model. This can be useful in development mode to determine which fields
+    # need to be selected. For performance critical pages, selecting only the
+    # required fields can be an easy performance win (assuming you aren't using
+    # all of the fields on the model).
+    #
+    # For example:
+    #
+    # class PostsController < ActionController::Base
+    #   after_action :print_accessed_fields, only: :index
+    #
+    #   def index
+    #     @posts = Post.all
+    #   end
+    #
+    #   private
+    #
+    #   def print_accessed_fields
+    #     p @posts.first.accessed_fields
+    #   end
+    # end
+    #
+    # Which allows you to quickly change your code to:
+    #
+    # class PostsController < ActionController::Base
+    #   def index
+    #     @posts = Post.select(:id, :title, :author_id, :updated_at)
+    #   end
+    # end
+    def accessed_fields
+      @attributes.accessed
+    end
+
     protected
 
     def clone_attribute_value(reader_method, attribute_name) # :nodoc:
diff --git a/activerecord/lib/active_record/attribute_methods/before_type_cast.rb b/activerecord/lib/active_record/attribute_methods/before_type_cast.rb
index fd61febd57..56c1898551 100644
--- a/activerecord/lib/active_record/attribute_methods/before_type_cast.rb
+++ b/activerecord/lib/active_record/attribute_methods/before_type_cast.rb
@@ -28,6 +28,7 @@ module ActiveRecord
 
       included do
         attribute_method_suffix "_before_type_cast"
+        attribute_method_suffix "_came_from_user?"
       end
 
       # Returns the value of the attribute identified by +attr_name+ before
@@ -66,6 +67,10 @@ module ActiveRecord
       def attribute_before_type_cast(attribute_name)
         read_attribute_before_type_cast(attribute_name)
       end
+
+      def attribute_came_from_user?(attribute_name)
+        @attributes[attribute_name].came_from_user?
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/attribute_methods/dirty.rb b/activerecord/lib/active_record/attribute_methods/dirty.rb
index d5702accaf..7ba907f786 100644
--- a/activerecord/lib/active_record/attribute_methods/dirty.rb
+++ b/activerecord/lib/active_record/attribute_methods/dirty.rb
@@ -108,7 +108,7 @@ module ActiveRecord
       end
 
       def save_changed_attribute(attr, old_value)
-        if attribute_changed?(attr)
+        if attribute_changed_by_setter?(attr)
           clear_attribute_changes(attr) unless _field_changed?(attr, old_value)
         else
           set_attribute_was(attr, old_value) if _field_changed?(attr, old_value)
@@ -131,10 +131,8 @@ module ActiveRecord
         partial_writes? ? super(keys_for_partial_write) : super
       end
 
-      # Serialized attributes should always be written in case they've been
-      # changed in place.
       def keys_for_partial_write
-        changed
+        changed & self.class.column_names
       end
 
       def _field_changed?(attr, old_value)
@@ -165,7 +163,7 @@ module ActiveRecord
       end
 
       def store_original_raw_attribute(attr_name)
-        original_raw_attributes[attr_name] = @attributes[attr_name].value_for_database
+        original_raw_attributes[attr_name] = @attributes[attr_name].value_for_database rescue nil
       end
 
       def store_original_raw_attributes
diff --git a/activerecord/lib/active_record/attribute_methods/query.rb b/activerecord/lib/active_record/attribute_methods/query.rb
index dc689f399a..83b858aae7 100644
--- a/activerecord/lib/active_record/attribute_methods/query.rb
+++ b/activerecord/lib/active_record/attribute_methods/query.rb
@@ -15,6 +15,7 @@ module ActiveRecord
         when false, nil  then false
         else
           column = self.class.columns_hash[attr_name]
+          type = self.class.type_for_attribute(attr_name)
           if column.nil?
             if Numeric === value || value !~ /[^0-9]/
               !value.to_i.zero?
@@ -22,7 +23,7 @@ module ActiveRecord
               return false if ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.include?(value)
               !value.blank?
             end
-          elsif column.number?
+          elsif type.number?
             !value.zero?
           else
             !value.blank?
diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb
index 20f0936e52..24e30b6608 100644
--- a/activerecord/lib/active_record/attribute_methods/read.rb
+++ b/activerecord/lib/active_record/attribute_methods/read.rb
@@ -1,5 +1,3 @@
-require 'active_support/core_ext/module/method_transplanting'
-
 module ActiveRecord
   module AttributeMethods
     module Read
@@ -36,42 +34,24 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       module ClassMethods
-        [:cache_attributes, :cached_attributes, :cache_attribute?].each do |method_name|
-          define_method method_name do |*|
-            cached_attributes_deprecation_warning(method_name)
-            true
-          end
-        end
-
         protected
 
-        def cached_attributes_deprecation_warning(method_name)
-          ActiveSupport::Deprecation.warn "Calling `#{method_name}` is no longer necessary. All attributes are cached."
-        end
+        def define_method_attribute(name)
+          safe_name = name.unpack('h*').first
+          temp_method = "__temp__#{safe_name}"
 
-        if Module.methods_transplantable?
-          def define_method_attribute(name)
-            method = ReaderMethodCache[name]
-            generated_attribute_methods.module_eval { define_method name, method }
-          end
-        else
-          def define_method_attribute(name)
-            safe_name = name.unpack('h*').first
-            temp_method = "__temp__#{safe_name}"
+          ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
 
-            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
-
-            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def #{temp_method}
-                name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
-                _read_attribute(name) { |n| missing_attribute(n, caller) }
-              end
-            STR
-
-            generated_attribute_methods.module_eval do
-              alias_method name, temp_method
-              undef_method temp_method
+          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def #{temp_method}
+              name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
+              _read_attribute(name) { |n| missing_attribute(n, caller) }
             end
+          STR
+
+          generated_attribute_methods.module_eval do
+            alias_method name, temp_method
+            undef_method temp_method
           end
         end
       end
@@ -92,12 +72,9 @@ module ActiveRecord
       def _read_attribute(attr_name) # :nodoc:
         @attributes.fetch_value(attr_name.to_s) { |n| yield n if block_given? }
       end
+      alias :attribute :_read_attribute
+      private :attribute
 
-      private
-
-      def attribute(attribute_name)
-        _read_attribute(attribute_name)
-      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/attribute_methods/serialization.rb b/activerecord/lib/active_record/attribute_methods/serialization.rb
index e5ec5ddca5..d0d8a968c5 100644
--- a/activerecord/lib/active_record/attribute_methods/serialization.rb
+++ b/activerecord/lib/active_record/attribute_methods/serialization.rb
@@ -1,5 +1,3 @@
-require 'active_support/core_ext/string/filters'
-
 module ActiveRecord
   module AttributeMethods
     module Serialization
@@ -51,19 +49,6 @@ module ActiveRecord
             Type::Serialized.new(type, coder)
           end
         end
-
-        def serialized_attributes
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `serialized_attributes` is deprecated without replacement, and will
-            be removed in Rails 5.0.
-          MSG
-
-          @serialized_attributes ||= Hash[
-            columns.select { |t| t.cast_type.is_a?(Type::Serialized) }.map { |c|
-              [c.name, c.cast_type.coder]
-            }
-          ]
-        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
index 777f7ab4d7..75cc88d4ee 100644
--- a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
+++ b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
@@ -13,7 +13,7 @@ module ActiveRecord
             value.map { |v| type_cast_from_user(v) }
           elsif value.respond_to?(:in_time_zone)
             begin
-              value.in_time_zone || super
+              user_input_in_time_zone(value) || super
             rescue ArgumentError
               nil
             end
@@ -39,6 +39,9 @@ module ActiveRecord
 
         class_attribute :skip_time_zone_conversion_for_attributes, instance_writer: false
         self.skip_time_zone_conversion_for_attributes = []
+
+        class_attribute :time_zone_aware_types, instance_writer: false
+        self.time_zone_aware_types = [:datetime, :not_explicitly_configured]
       end
 
       module ClassMethods
@@ -59,9 +62,31 @@ module ActiveRecord
         end
 
         def create_time_zone_conversion_attribute?(name, cast_type)
-          time_zone_aware_attributes &&
-            !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym) &&
-            (:datetime == cast_type.type)
+          enabled_for_column = time_zone_aware_attributes &&
+            !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym)
+          result = enabled_for_column &&
+            time_zone_aware_types.include?(cast_type.type)
+
+          if enabled_for_column &&
+            !result &&
+            cast_type.type == :time &&
+            time_zone_aware_types.include?(:not_explicitly_configured)
+            ActiveSupport::Deprecation.warn(<<-MESSAGE)
+              Time columns will become time zone aware in Rails 5.1. This
+              still causes `String`s to be parsed as if they were in `Time.zone`,
+              and `Time`s to be converted to `Time.zone`.
+
+              To keep the old behavior, you must add the following to your initializer:
+
+                  config.active_record.time_zone_aware_types = [:datetime]
+
+              To silence this deprecation warning, add the following:
+
+                  config.active_record.time_zone_aware_types << :time
+            MESSAGE
+          end
+
+          result
         end
       end
     end
diff --git a/activerecord/lib/active_record/attribute_methods/write.rb b/activerecord/lib/active_record/attribute_methods/write.rb
index 16804f86bf..ab017c7b54 100644
--- a/activerecord/lib/active_record/attribute_methods/write.rb
+++ b/activerecord/lib/active_record/attribute_methods/write.rb
@@ -1,5 +1,3 @@
-require 'active_support/core_ext/module/method_transplanting'
-
 module ActiveRecord
   module AttributeMethods
     module Write
@@ -25,27 +23,18 @@ module ActiveRecord
       module ClassMethods
         protected
 
-        if Module.methods_transplantable?
-          def define_method_attribute=(name)
-            method = WriterMethodCache[name]
-            generated_attribute_methods.module_eval {
-              define_method "#{name}=", method
-            }
-          end
-        else
-          def define_method_attribute=(name)
-            safe_name = name.unpack('h*').first
-            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+        def define_method_attribute=(name)
+          safe_name = name.unpack('h*').first
+          ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
 
-            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def __temp__#{safe_name}=(value)
-                name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
-                write_attribute(name, value)
-              end
-              alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
-              undef_method :__temp__#{safe_name}=
-            STR
-          end
+          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def __temp__#{safe_name}=(value)
+              name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
+              write_attribute(name, value)
+            end
+            alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
+            undef_method :__temp__#{safe_name}=
+          STR
         end
       end
 
diff --git a/activerecord/lib/active_record/attribute_set.rb b/activerecord/lib/active_record/attribute_set.rb
index 66fcaf6945..9142317646 100644
--- a/activerecord/lib/active_record/attribute_set.rb
+++ b/activerecord/lib/active_record/attribute_set.rb
@@ -10,6 +10,10 @@ module ActiveRecord
       attributes[name] || Attribute.null(name)
     end
 
+    def []=(name, value)
+      attributes[name] = value
+    end
+
     def values_before_type_cast
       attributes.transform_values(&:value_before_type_cast)
     end
@@ -24,7 +28,7 @@ module ActiveRecord
     end
 
     def keys
-      attributes.initialized_keys
+      attributes.each_key.select { |name| self[name].initialized? }
     end
 
     def fetch_value(name)
@@ -49,7 +53,7 @@ module ActiveRecord
     end
 
     def initialize_dup(_)
-      @attributes = attributes.dup
+      @attributes = attributes.deep_dup
       super
     end
 
@@ -64,6 +68,10 @@ module ActiveRecord
       end
     end
 
+    def accessed
+      attributes.select { |_, attr| attr.has_been_read? }.keys
+    end
+
     protected
 
     attr_reader :attributes
diff --git a/activerecord/lib/active_record/attribute_set/builder.rb b/activerecord/lib/active_record/attribute_set/builder.rb
index 3a76f5262d..0f3c285a80 100644
--- a/activerecord/lib/active_record/attribute_set/builder.rb
+++ b/activerecord/lib/active_record/attribute_set/builder.rb
@@ -20,7 +20,7 @@ module ActiveRecord
   end
 
   class LazyAttributeHash # :nodoc:
-    delegate :select, :transform_values, to: :materialize
+    delegate :select, :transform_values, :each_key, to: :materialize
 
     def initialize(types, values, additional_types)
       @types = types
@@ -45,10 +45,6 @@ module ActiveRecord
       delegate_hash[key] = value
     end
 
-    def initialized_keys
-      delegate_hash.keys | values.keys
-    end
-
     def initialize_dup(_)
       @delegate_hash = delegate_hash.transform_values(&:dup)
       super
diff --git a/activerecord/lib/active_record/attributes.rb b/activerecord/lib/active_record/attributes.rb
index aafb990bc1..c1b69092bb 100644
--- a/activerecord/lib/active_record/attributes.rb
+++ b/activerecord/lib/active_record/attributes.rb
@@ -5,14 +5,12 @@ module ActiveRecord
     Type = ActiveRecord::Type
 
     included do
-      class_attribute :user_provided_columns, instance_accessor: false # :internal:
-      class_attribute :user_provided_defaults, instance_accessor: false # :internal:
-      self.user_provided_columns = {}
-      self.user_provided_defaults = {}
+      class_attribute :user_provided_types, instance_accessor: false # :internal:
+      self.user_provided_types = {}
     end
 
     module ClassMethods # :nodoc:
-      # Defines or overrides a attribute on this model. This allows customization of
+      # Defines or overrides an attribute on this model. This allows customization of
       # Active Record's type casting behavior, as well as adding support for user defined
       # types.
       #
@@ -75,65 +73,44 @@ module ActiveRecord
       #
       #   store_listing = StoreListing.new(price_in_cents: '$10.00')
       #   store_listing.price_in_cents # => 1000
-      def attribute(name, cast_type, options = {})
+      def attribute(name, cast_type, **options)
         name = name.to_s
-        clear_caches_calculated_from_columns
-        # Assign a new hash to ensure that subclasses do not share a hash
-        self.user_provided_columns = user_provided_columns.merge(name => cast_type)
+        reload_schema_from_cache
 
-        if options.key?(:default)
-          self.user_provided_defaults = user_provided_defaults.merge(name => options[:default])
-        end
-      end
-
-      # Returns an array of column objects for the table associated with this class.
-      def columns
-        @columns ||= add_user_provided_columns(connection.schema_cache.columns(table_name))
+        self.user_provided_types = user_provided_types.merge(name => [cast_type, options])
       end
 
-      # Returns a hash of column objects for the table associated with this class.
-      def columns_hash
-        @columns_hash ||= Hash[columns.map { |c| [c.name, c] }]
+      def define_attribute(
+        name,
+        cast_type,
+        default: NO_DEFAULT_PROVIDED,
+        user_provided_default: true
+      )
+        attribute_types[name] = cast_type
+        define_default_attribute(name, default, cast_type, from_user: user_provided_default)
       end
 
-      def reset_column_information # :nodoc:
+      def load_schema!
         super
-        clear_caches_calculated_from_columns
+        user_provided_types.each do |name, (type, options)|
+          define_attribute(name, type, **options)
+        end
       end
 
       private
 
-      def add_user_provided_columns(schema_columns)
-        existing_columns = schema_columns.map do |column|
-          new_type = user_provided_columns[column.name]
-          if new_type
-            column.with_type(new_type)
-          else
-            column
-          end
-        end
+      NO_DEFAULT_PROVIDED = Object.new # :nodoc:
+      private_constant :NO_DEFAULT_PROVIDED
 
-        existing_column_names = existing_columns.map(&:name)
-        new_columns = user_provided_columns.except(*existing_column_names).map do |(name, type)|
-          connection.new_column(name, nil, type)
+      def define_default_attribute(name, value, type, from_user:)
+        if value == NO_DEFAULT_PROVIDED
+          default_attribute = _default_attributes[name].with_type(type)
+        elsif from_user
+          default_attribute = Attribute.from_user(name, value, type)
+        else
+          default_attribute = Attribute.from_database(name, value, type)
         end
-
-        existing_columns + new_columns
-      end
-
-      def clear_caches_calculated_from_columns
-        @arel_table = nil
-        @attributes_builder = nil
-        @column_names = nil
-        @column_types = nil
-        @columns = nil
-        @columns_hash = nil
-        @content_columns = nil
-        @default_attributes = nil
-      end
-
-      def raw_default_values
-        super.merge(user_provided_defaults)
+        _default_attributes[name] = default_attribute
       end
     end
   end
diff --git a/activerecord/lib/active_record/autosave_association.rb b/activerecord/lib/active_record/autosave_association.rb
index c39b045a5e..0792d19c3e 100644
--- a/activerecord/lib/active_record/autosave_association.rb
+++ b/activerecord/lib/active_record/autosave_association.rb
@@ -177,10 +177,8 @@ module ActiveRecord
         # before actually defining them.
         def add_autosave_association_callbacks(reflection)
           save_method = :"autosave_associated_records_for_#{reflection.name}"
-          validation_method = :"validate_associated_records_for_#{reflection.name}"
-          collection = reflection.collection?
 
-          if collection
+          if reflection.collection?
             before_save :before_save_collection_association
 
             define_non_cyclic_method(save_method) { save_collection_association(reflection) }
@@ -200,13 +198,29 @@ module ActiveRecord
             after_create save_method
             after_update save_method
           else
-            define_non_cyclic_method(save_method) { save_belongs_to_association(reflection) }
+            define_non_cyclic_method(save_method) { throw(:abort) if save_belongs_to_association(reflection) == false }
             before_save save_method
           end
 
+          define_autosave_validation_callbacks(reflection)
+        end
+
+        def define_autosave_validation_callbacks(reflection)
+          validation_method = :"validate_associated_records_for_#{reflection.name}"
           if reflection.validate? && !method_defined?(validation_method)
-            method = (collection ? :validate_collection_association : :validate_single_association)
-            define_non_cyclic_method(validation_method) { send(method, reflection) }
+            if reflection.collection?
+              method = :validate_collection_association
+            else
+              method = :validate_single_association
+            end
+
+            define_non_cyclic_method(validation_method) do
+              send(method, reflection)
+              # TODO: remove the following line as soon as the return value of
+              # callbacks is ignored, that is, returning `false` does not
+              # display a deprecation warning or halts the callback chain.
+              true
+            end
             validate validation_method
           end
         end
@@ -272,11 +286,18 @@ module ActiveRecord
       # go through nested autosave associations that are loaded in memory (without loading
       # any new ones), and return true if is changed for autosave
       def nested_records_changed_for_autosave?
-        self.class._reflections.values.any? do |reflection|
-          if reflection.options[:autosave]
-            association = association_instance_get(reflection.name)
-            association && Array.wrap(association.target).any?(&:changed_for_autosave?)
+        @_nested_records_changed_for_autosave_already_called ||= false
+        return false if @_nested_records_changed_for_autosave_already_called
+        begin
+          @_nested_records_changed_for_autosave_already_called = true
+          self.class._reflections.values.any? do |reflection|
+            if reflection.options[:autosave]
+              association = association_instance_get(reflection.name)
+              association && Array.wrap(association.target).any?(&:changed_for_autosave?)
+            end
           end
+        ensure
+          @_nested_records_changed_for_autosave_already_called = false
         end
       end
 
diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
index bb01231bca..100d3780f6 100644
--- a/activerecord/lib/active_record/base.rb
+++ b/activerecord/lib/active_record/base.rb
@@ -312,6 +312,7 @@ module ActiveRecord #:nodoc:
     include Reflection
     include Serialization
     include Store
+    include SecureToken
   end
 
   ActiveSupport.run_load_hooks(:active_record, Base)
diff --git a/activerecord/lib/active_record/callbacks.rb b/activerecord/lib/active_record/callbacks.rb
index 497ce8c15c..f44e5af5de 100644
--- a/activerecord/lib/active_record/callbacks.rb
+++ b/activerecord/lib/active_record/callbacks.rb
@@ -192,14 +192,14 @@ module ActiveRecord
   #
   # == <tt>before_validation*</tt> returning statements
   #
-  # If the returning value of a +before_validation+ callback can be evaluated to +false+, the process will be
+  # If the +before_validation+ callback throws +:abort+, the process will be
   # aborted and <tt>Base#save</tt> will return +false+. If Base#save! is called it will raise a
   # ActiveRecord::RecordInvalid exception. Nothing will be appended to the errors object.
   #
   # == Canceling callbacks
   #
-  # If a <tt>before_*</tt> callback returns +false+, all the later callbacks and the associated action are
-  # cancelled. If an <tt>after_*</tt> callback returns +false+, all the later callbacks are cancelled.
+  # If a <tt>before_*</tt> callback throws +:abort+, all the later callbacks and
+  # the associated action are cancelled.
   # Callbacks are generally run in the order they are defined, with the exception of callbacks defined as
   # methods on the model, which are called last.
   #
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
index 6235745fb2..d99dc9a5db 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
@@ -2,7 +2,6 @@ require 'thread'
 require 'thread_safe'
 require 'monitor'
 require 'set'
-require 'active_support/core_ext/string/filters'
 
 module ActiveRecord
   # Raised when a connection could not be obtained within the connection
@@ -454,6 +453,10 @@ module ActiveRecord
           c.verify!
         end
         c
+      rescue
+        remove c
+        c.disconnect!
+        raise
       end
     end
 
@@ -517,15 +520,7 @@ module ActiveRecord
       def connection_pool_list
         owner_to_pool.values.compact
       end
-
-      def connection_pools
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          In the next release, this will return the same as `#connection_pool_list`.
-          (An array of pools, rather than a hash mapping specs to pools.)
-        MSG
-
-        Hash[connection_pool_list.map { |pool| [pool.spec, pool] }]
-      end
+      alias :connection_pools :connection_pool_list
 
       def establish_connection(owner, spec)
         @class_to_pool.clear
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
index 59cdd8e98c..c3e5e9ad61 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -285,10 +285,17 @@ module ActiveRecord
       def insert_fixture(fixture, table_name)
         columns = schema_cache.columns_hash(table_name)
 
-        key_list   = []
-        value_list = fixture.map do |name, value|
-          key_list << quote_column_name(name)
-          quote(value, columns[name])
+        binds = fixture.map do |name, value|
+          type = lookup_cast_type_from_column(columns[name])
+          Relation::QueryAttribute.new(name, value, type)
+        end
+        key_list = fixture.keys.map { |name| quote_column_name(name) }
+        value_list = prepare_binds_for_database(binds).map do |value|
+          begin
+            quote(value)
+          rescue TypeError
+            quote(YAML.dump(value))
+          end
         end
 
         execute "INSERT INTO #{quote_table_name(table_name)} (#{key_list.join(', ')}) VALUES (#{value_list.join(', ')})", 'Fixture Insert'
@@ -375,7 +382,7 @@ module ActiveRecord
 
         def binds_from_relation(relation, binds)
           if relation.is_a?(Relation) && binds.empty?
-            relation, binds = relation.arel, relation.bind_values
+            relation, binds = relation.arel, relation.bound_attributes
           end
           [relation, binds]
         end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 143d7d9574..2456376d6d 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -10,7 +10,13 @@ module ActiveRecord
         return value.quoted_id if value.respond_to?(:quoted_id)
 
         if column
-          value = column.cast_type.type_cast_for_database(value)
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Passing a column to `quote` has been deprecated. It is only used
+            for type casting, which should be handled elsewhere. See
+            https://github.com/rails/arel/commit/6160bfbda1d1781c3b08a33ec4955f170e95be11
+            for more information.
+          MSG
+          value = type_cast_from_column(column, value)
         end
 
         _quote(value)
@@ -25,7 +31,7 @@ module ActiveRecord
         end
 
         if column
-          value = column.cast_type.type_cast_for_database(value)
+          value = type_cast_from_column(column, value)
         end
 
         _type_cast(value)
@@ -34,6 +40,29 @@ module ActiveRecord
         raise TypeError, "can't cast #{value.class}#{to_type}"
       end
 
+      # If you are having to call this function, you are likely doing something
+      # wrong. The column does not have sufficient type information if the user
+      # provided a custom type on the class level either explicitly (via
+      # `attribute`) or implicitly (via `serialize`,
+      # `time_zone_aware_attributes`). In almost all cases, the sql type should
+      # only be used to change quoting behavior, when the primitive to
+      # represent the type doesn't sufficiently reflect the differences
+      # (varchar vs binary) for example. The type used to get this primitive
+      # should have been provided before reaching the connection adapter.
+      def type_cast_from_column(column, value) # :nodoc:
+        if column
+          type = lookup_cast_type_from_column(column)
+          type.type_cast_for_database(value)
+        else
+          value
+        end
+      end
+
+      # See docs for +type_cast_from_column+
+      def lookup_cast_type_from_column(column) # :nodoc:
+        lookup_cast_type(column.sql_type)
+      end
+
       # Quotes a string, escaping any ' (single quote) and \ (backslash)
       # characters.
       def quote_string(s)
@@ -90,6 +119,10 @@ module ActiveRecord
         value.to_s(:db)
       end
 
+      def prepare_binds_for_database(binds) # :nodoc:
+        binds.map(&:value_for_database)
+      end
+
       private
 
       def types_which_need_no_typecasting
@@ -109,8 +142,7 @@ module ActiveRecord
         when Date, Time then "'#{quoted_date(value)}'"
         when Symbol     then "'#{quote_string(value.to_s)}'"
         when Class      then "'#{value}'"
-        else
-          "'#{quote_string(YAML.dump(value))}'"
+        else raise TypeError, "can't quote #{value.class.name}"
         end
       end
 
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_creation.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_creation.rb
index 18ff869ea6..db20b60d60 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_creation.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_creation.rb
@@ -28,8 +28,8 @@ module ActiveRecord
           end
 
           def visit_ColumnDefinition(o)
-            sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale)
-            column_sql = "#{quote_column_name(o.name)} #{sql_type}"
+            o.sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale)
+            column_sql = "#{quote_column_name(o.name)} #{o.sql_type}"
             add_column_options!(column_sql, column_options(o)) unless o.type == :primary_key
             column_sql
           end
@@ -98,9 +98,7 @@ module ActiveRecord
           end
 
           def quote_default_expression(value, column)
-            column.sql_type ||= type_to_sql(column.type, column.limit, column.precision, column.scale)
             value = type_for_column(column).type_cast_for_database(value)
-
             @conn.quote(value)
           end
 
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
index 68d8a2cd6a..7eaa89c9a7 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
@@ -56,18 +56,6 @@ module ActiveRecord
       end
     end
 
-    module TimestampDefaultDeprecation # :nodoc:
-      def emit_warning_if_null_unspecified(options)
-        return if options.key?(:null)
-
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `#timestamp` was called without specifying an option for `null`. In Rails 5,
-          this behavior will change to `null: false`. You should manually specify
-         `null: true` to prevent the behavior of your existing migrations from changing.
-        MSG
-      end
-    end
-
     class ReferenceDefinition # :nodoc:
       def initialize(
         name,
@@ -167,8 +155,6 @@ module ActiveRecord
     # The table definitions
     # The Columns are stored as a ColumnDefinition in the +columns+ attribute.
     class TableDefinition
-      include TimestampDefaultDeprecation
-
       # An array of ColumnDefinition objects, representing the column changes
       # that have been defined.
       attr_accessor :indexes
@@ -375,7 +361,9 @@ module ActiveRecord
       #   t.timestamps null: false
       def timestamps(*args)
         options = args.extract_options!
-        emit_warning_if_null_unspecified(options)
+
+        options[:null] = false if options[:null].nil?
+
         column(:created_at, :datetime, options)
         column(:updated_at, :datetime, options)
       end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
index 42ea599a74..932aaf7aa7 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
@@ -46,9 +46,10 @@ module ActiveRecord
       private
 
       def schema_default(column)
-        default = column.type_cast_from_database(column.default)
+        type = lookup_cast_type_from_column(column)
+        default = type.type_cast_from_database(column.default)
         unless default.nil?
-          column.type_cast_for_schema(default)
+          type.type_cast_for_schema(default)
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
index 34d60493ea..f905669a24 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
@@ -380,7 +380,7 @@ module ActiveRecord
       # it can be helpful to provide these in a migration's +change+ method so it can be reverted.
       # In that case, +options+ and the block will be used by create_table.
       def drop_table(table_name, options = {})
-        execute "DROP TABLE #{quote_table_name(table_name)}"
+        execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}"
       end
 
       # Adds a new column to the named table.
@@ -851,14 +851,14 @@ module ActiveRecord
         columns
       end
 
-      include TimestampDefaultDeprecation
       # Adds timestamps (+created_at+ and +updated_at+) columns to +table_name+.
       # Additional options (like <tt>null: false</tt>) are forwarded to #add_column.
       #
       #   add_timestamps(:suppliers, null: false)
       #
       def add_timestamps(table_name, options = {})
-        emit_warning_if_null_unspecified(options)
+        options[:null] = false if options[:null].nil?
+
         add_column table_name, :created_at, :datetime, options
         add_column table_name, :updated_at, :datetime, options
       end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/transaction.rb b/activerecord/lib/active_record/connection_adapters/abstract/transaction.rb
index fd666c8c39..7f738e89c9 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/transaction.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/transaction.rb
@@ -69,16 +69,11 @@ module ActiveRecord
       def rollback_records
         ite = records.uniq
         while record = ite.shift
-          begin
-            record.rolledback! full_rollback?
-          rescue => e
-            raise if ActiveRecord::Base.raise_in_transactional_callbacks
-            record.logger.error(e) if record.respond_to?(:logger) && record.logger
-          end
+          record.rolledback!(force_restore_state: full_rollback?)
         end
       ensure
         ite.each do |i|
-          i.rolledback!(full_rollback?, false)
+          i.rolledback!(force_restore_state: full_rollback?, should_run_callbacks: false)
         end
       end
 
@@ -89,16 +84,11 @@ module ActiveRecord
       def commit_records
         ite = records.uniq
         while record = ite.shift
-          begin
-            record.committed!
-          rescue => e
-            raise if ActiveRecord::Base.raise_in_transactional_callbacks
-            record.logger.error(e) if record.respond_to?(:logger) && record.logger
-          end
+          record.committed!
         end
       ensure
         ite.each do |i|
-          i.committed!(false)
+          i.committed!(should_run_callbacks: false)
         end
       end
 
@@ -121,14 +111,11 @@ module ActiveRecord
       def rollback
         connection.rollback_to_savepoint(savepoint_name)
         super
-        rollback_records
       end
 
       def commit
         connection.release_savepoint(savepoint_name)
         super
-        parent = connection.transaction_manager.current_transaction
-        records.each { |r| parent.add_record(r) }
       end
 
       def full_rollback?; false; end
@@ -148,13 +135,11 @@ module ActiveRecord
       def rollback
         connection.rollback_db_transaction
         super
-        rollback_records
       end
 
       def commit
         connection.commit_db_transaction
         super
-        commit_records
       end
     end
 
@@ -171,16 +156,28 @@ module ActiveRecord
           else
             SavepointTransaction.new(@connection, "active_record_#{@stack.size}", options)
           end
+
         @stack.push(transaction)
         transaction
       end
 
       def commit_transaction
-        @stack.pop.commit
+        inner_transaction = @stack.pop
+        inner_transaction.commit
+
+        if current_transaction.joinable?
+          inner_transaction.records.each do |r|
+            current_transaction.add_record(r)
+          end
+        else
+          inner_transaction.commit_records
+        end
       end
 
-      def rollback_transaction
-        @stack.pop.rollback
+      def rollback_transaction(transaction = nil)
+        transaction ||= @stack.pop
+        transaction.rollback
+        transaction.rollback_records
       end
 
       def within_new_transaction(options = {})
@@ -197,7 +194,7 @@ module ActiveRecord
             begin
               commit_transaction
             rescue Exception
-              transaction.rollback unless transaction.state.completed?
+              rollback_transaction(transaction) unless transaction.state.completed?
               raise
             end
           end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index fa24d9b43f..436552d300 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -25,7 +25,6 @@ module ActiveRecord
       autoload :TableDefinition
       autoload :Table
       autoload :AlterTable
-      autoload :TimestampDefaultDeprecation
     end
 
     autoload_at 'active_record/connection_adapters/abstract/connection_pool' do
@@ -114,7 +113,8 @@ module ActiveRecord
 
       class BindCollector < Arel::Collectors::Bind
         def compile(bvs, conn)
-          super(bvs.map { |bv| conn.quote(*bv.reverse) })
+          casted_binds = conn.prepare_binds_for_database(bvs)
+          super(casted_binds.map { |value| conn.quote(value) })
         end
       end
 
@@ -393,7 +393,7 @@ module ActiveRecord
       end
 
       def column_name_for_operation(operation, node) # :nodoc:
-        node.to_sql
+        visitor.accept(node, collector).value
       end
 
       protected
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
index e9a3c26c32..b61b717a61 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
@@ -502,7 +502,7 @@ module ActiveRecord
       end
 
       def drop_table(table_name, options = {})
-        execute "DROP#{' TEMPORARY' if options[:temporary]} TABLE #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
+        execute "DROP#{' TEMPORARY' if options[:temporary]} TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
       end
 
       def rename_index(table_name, old_name, new_name)
diff --git a/activerecord/lib/active_record/connection_adapters/column.rb b/activerecord/lib/active_record/connection_adapters/column.rb
index af307b57a4..a489141d1a 100644
--- a/activerecord/lib/active_record/connection_adapters/column.rb
+++ b/activerecord/lib/active_record/connection_adapters/column.rb
@@ -5,7 +5,6 @@ module ActiveRecord
   module ConnectionAdapters
     # An abstract definition of a column in a table.
     class Column
-      TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].to_set
       FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF'].to_set
 
       module Format
@@ -15,11 +14,7 @@ module ActiveRecord
 
       attr_reader :name, :cast_type, :null, :sql_type, :default, :default_function
 
-      delegate :type, :precision, :scale, :limit, :klass, :accessor,
-        :text?, :number?, :binary?, :changed?,
-        :type_cast_from_user, :type_cast_from_database, :type_cast_for_database,
-        :type_cast_for_schema,
-        to: :cast_type
+      delegate :precision, :scale, :limit, :type, to: :cast_type
 
       # Instantiates a new column in the table.
       #
@@ -30,13 +25,13 @@ module ActiveRecord
       # <tt>company_name varchar(60)</tt>.
       # It will be mapped to one of the standard Rails SQL types in the <tt>type</tt> attribute.
       # +null+ determines if this column allows +NULL+ values.
-      def initialize(name, default, cast_type, sql_type = nil, null = true)
+      def initialize(name, default, cast_type, sql_type = nil, null = true, default_function = nil)
         @name             = name
         @cast_type        = cast_type
         @sql_type         = sql_type
         @null             = null
         @default          = default
-        @default_function = nil
+        @default_function = default_function
       end
 
       def has_default?
@@ -77,6 +72,12 @@ module ActiveRecord
         [self.class, name, default, cast_type, sql_type, null, default_function]
       end
     end
+
+    class NullColumn < Column
+      def initialize(name)
+        super name, nil, Type::Value.new
+      end
+    end
   end
   # :startdoc:
 end
diff --git a/activerecord/lib/active_record/connection_adapters/connection_specification.rb b/activerecord/lib/active_record/connection_adapters/connection_specification.rb
index e54e3199ff..08d46fca96 100644
--- a/activerecord/lib/active_record/connection_adapters/connection_specification.rb
+++ b/activerecord/lib/active_record/connection_adapters/connection_specification.rb
@@ -1,5 +1,4 @@
 require 'uri'
-require 'active_support/core_ext/string/filters'
 
 module ActiveRecord
   module ConnectionAdapters
@@ -210,30 +209,12 @@ module ActiveRecord
           when Symbol
             resolve_symbol_connection spec
           when String
-            resolve_string_connection spec
+            resolve_url_connection spec
           when Hash
             resolve_hash_connection spec
           end
         end
 
-        def resolve_string_connection(spec)
-          # Rails has historically accepted a string to mean either
-          # an environment key or a URL spec, so we have deprecated
-          # this ambiguous behaviour and in the future this function
-          # can be removed in favor of resolve_url_connection.
-          if configurations.key?(spec) || spec !~ /:/
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Passing a string to ActiveRecord::Base.establish_connection for a
-              configuration lookup is deprecated, please pass a symbol
-              (#{spec.to_sym.inspect}) instead.
-            MSG
-
-            resolve_symbol_connection(spec)
-          else
-            resolve_url_connection(spec)
-          end
-        end
-
         # Takes the environment such as +:production+ or +:development+.
         # This requires that the @configurations was initialized with a key that
         # matches.
diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
index 23d8389abb..16f50fc594 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
@@ -395,11 +395,9 @@ module ActiveRecord
 
       def exec_stmt(sql, name, binds)
         cache = {}
-        type_casted_binds = binds.map { |col, val|
-          [col, type_cast(val, col)]
-        }
+        type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
 
-        log(sql, name, type_casted_binds) do
+        log(sql, name, binds) do
           if binds.empty?
             stmt = @connection.prepare(sql)
           else
@@ -410,7 +408,7 @@ module ActiveRecord
           end
 
           begin
-            stmt.execute(*type_casted_binds.map { |_, val| val })
+            stmt.execute(*type_casted_binds)
           rescue Mysql::Error => e
             # Older versions of MySQL leave the prepared statement in a bad
             # place when an error occurs. To support older MySQL versions, we
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/column.rb b/activerecord/lib/active_record/connection_adapters/postgresql/column.rb
index 1458fbf496..8f3628ec0e 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/column.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/column.rb
@@ -2,18 +2,19 @@ module ActiveRecord
   module ConnectionAdapters
     # PostgreSQL-specific extensions to column definitions in a table.
     class PostgreSQLColumn < Column #:nodoc:
-      attr_accessor :array
+      attr_reader :array, :oid, :fmod
+      alias :array? :array
 
-      def initialize(name, default, cast_type, sql_type = nil, null = true, default_function = nil)
+      def initialize(name, default, cast_type, sql_type = nil, null = true, default_function = nil, oid = nil, fmod = nil)
         if sql_type =~ /\[\]$/
           @array = true
-          super(name, default, cast_type, sql_type[0..sql_type.length - 3], null)
+          sql_type = sql_type[0..sql_type.length - 3]
         else
           @array = false
-          super(name, default, cast_type, sql_type, null)
         end
-
-        @default_function = default_function
+        @oid = oid
+        @fmod = fmod
+        super(name, default, cast_type, sql_type, null, default_function)
       end
 
       def serial?
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
index c203e6c604..e45a2f59d9 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
@@ -18,7 +18,7 @@ module ActiveRecord
           end
 
           attr_reader :subtype, :delimiter
-          delegate :type, to: :subtype
+          delegate :type, :user_input_in_time_zone, to: :subtype
 
           def initialize(subtype, delimiter = ',')
             @subtype = subtype
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb
index e12ddd9901..7dadc09a44 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb
@@ -11,7 +11,7 @@ module ActiveRecord
 
           def type_cast_from_database(value)
             if value.is_a?(::String)
-              ::ActiveSupport::JSON.decode(value)
+              ::ActiveSupport::JSON.decode(value) rescue nil
             else
               super
             end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
index 961e6224c4..3adfb8b9d8 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
@@ -25,16 +25,7 @@ module ActiveRecord
             to = type_cast_single extracted[:to]
 
             if !infinity?(from) && extracted[:exclude_start]
-              if from.respond_to?(:succ)
-                from = from.succ
-                ActiveSupport::Deprecation.warn(<<-MSG.squish)
-                  Excluding the beginning of a Range is only partialy supported
-                  through `#succ`. This is not reliable and will be removed in
-                  the future.
-                MSG
-              else
-                raise ArgumentError, "The Ruby Range object does not support excluding the beginning of a Range. (unsupported value: '#{value}')"
-              end
+              raise ArgumentError, "The Ruby Range object does not support excluding the beginning of a Range. (unsupported value: '#{value}')"
             end
             ::Range.new(from, to, extracted[:exclude_end])
           end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb b/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb
index 607848884b..464adb4e23 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb
@@ -56,10 +56,15 @@ module ActiveRecord
           if column.type == :uuid && value =~ /\(\)/
             value
           else
-            quote(value, column)
+            value = type_cast_from_column(column, value)
+            quote(value)
           end
         end
 
+        def lookup_cast_type_from_column(column) # :nodoc:
+          type_map.lookup(column.oid, column.fmod, column.sql_type)
+        end
+
         private
 
         def _quote(value)
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
index a90adcf4aa..519a9727fb 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
@@ -112,7 +112,7 @@ module ActiveRecord
         end
 
         def drop_table(table_name, options = {})
-          execute "DROP TABLE #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
+          execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
         end
 
         # Returns true if schema exists.
@@ -183,15 +183,17 @@ module ActiveRecord
         def columns(table_name)
           # Limit, precision, and scale are all handled by the superclass.
           column_definitions(table_name).map do |column_name, type, default, notnull, oid, fmod|
-            oid = get_oid_type(oid.to_i, fmod.to_i, column_name, type)
-            default_value = extract_value_from_default(oid, default)
+            oid = oid.to_i
+            fmod = fmod.to_i
+            cast_type = get_oid_type(oid, fmod, column_name, type)
+            default_value = extract_value_from_default(cast_type, default)
             default_function = extract_default_function(default_value, default)
-            new_column(column_name, default_value, oid, type, notnull == 'f', default_function)
+            new_column(column_name, default_value, cast_type, type, notnull == 'f', default_function, oid, fmod)
           end
         end
 
-        def new_column(name, default, cast_type, sql_type = nil, null = true, default_function = nil) # :nodoc:
-          PostgreSQLColumn.new(name, default, cast_type, sql_type, null, default_function)
+        def new_column(name, default, cast_type, sql_type = nil, null = true, default_function = nil, oid = nil, fmod = nil) # :nodoc:
+          PostgreSQLColumn.new(name, default, cast_type, sql_type, null, default_function, oid, fmod)
         end
 
         # Returns the current database name.
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 13bb5c187e..d789069f0b 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -64,7 +64,7 @@ module ActiveRecord
     #   <tt>SET client_min_messages TO <min_messages></tt> call on the connection.
     # * <tt>:variables</tt> - An optional hash of additional parameters that
     #   will be used in <tt>SET SESSION key = val</tt> calls on the connection.
-    # * <tt>:insert_returning</tt> - An optional boolean to control the use or <tt>RETURNING</tt> for <tt>INSERT</tt> statements
+    # * <tt>:insert_returning</tt> - An optional boolean to control the use of <tt>RETURNING</tt> for <tt>INSERT</tt> statements
     #   defaults to true.
     #
     # Any further options are used as connection parameters to libpq. See
@@ -144,7 +144,7 @@ module ActiveRecord
       # AbstractAdapter
       def prepare_column_options(column) # :nodoc:
         spec = super
-        spec[:array] = 'true' if column.respond_to?(:array) && column.array
+        spec[:array] = 'true' if column.array?
         spec[:default] = "\"#{column.default_function}\"" if column.default_function
         spec
       end
@@ -609,12 +609,10 @@ module ActiveRecord
 
         def exec_cache(sql, name, binds)
           stmt_key = prepare_statement(sql)
-          type_casted_binds = binds.map { |col, val|
-            [col, type_cast(val, col)]
-          }
+          type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
 
-          log(sql, name, type_casted_binds, stmt_key) do
-            @connection.exec_prepared(stmt_key, type_casted_binds.map { |_, val| val })
+          log(sql, name, binds, stmt_key) do
+            @connection.exec_prepared(stmt_key, type_casted_binds)
           end
         rescue ActiveRecord::StatementInvalid => e
           pgerror = e.original_exception
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
index 03dfd29a0a..02a3b65934 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
@@ -50,16 +50,6 @@ module ActiveRecord
       end
     end
 
-    class SQLite3String < Type::String # :nodoc:
-      def type_cast_for_database(value)
-        if value.is_a?(::String) && value.encoding == Encoding::ASCII_8BIT
-          value.encode(Encoding::UTF_8)
-        else
-          super
-        end
-      end
-    end
-
     # The SQLite3 adapter works SQLite 3.6.16 or newer
     # with the sqlite3-ruby drivers (available as gem from https://rubygems.org/gems/sqlite3).
     #
@@ -239,6 +229,12 @@ module ActiveRecord
         case value
         when BigDecimal
           value.to_f
+        when String
+          if value.encoding == Encoding::ASCII_8BIT
+            super(value.encode(Encoding::UTF_8))
+          else
+            super
+          end
         else
           super
         end
@@ -280,11 +276,9 @@ module ActiveRecord
       end
 
       def exec_query(sql, name = nil, binds = [])
-        type_casted_binds = binds.map { |col, val|
-          [col, type_cast(val, col)]
-        }
+        type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
 
-        log(sql, name, type_casted_binds) do
+        log(sql, name, binds) do
           # Don't cache statements if they are not prepared
           if without_prepared_statement?(binds)
             stmt    = @connection.prepare(sql)
@@ -302,7 +296,7 @@ module ActiveRecord
             stmt = cache[:stmt]
             cols = cache[:cols] ||= stmt.columns
             stmt.reset!
-            stmt.bind_params type_casted_binds.map { |_, val| val }
+            stmt.bind_params type_casted_binds
           end
 
           ActiveRecord::Result.new(cols, stmt.to_a)
@@ -498,7 +492,6 @@ module ActiveRecord
         def initialize_type_map(m)
           super
           m.register_type(/binary/i, SQLite3Binary.new)
-          register_class_with_limit m, %r(char)i, SQLite3String
         end
 
         def table_structure(table_name)
diff --git a/activerecord/lib/active_record/core.rb b/activerecord/lib/active_record/core.rb
index 38b2d632d2..4416217897 100644
--- a/activerecord/lib/active_record/core.rb
+++ b/activerecord/lib/active_record/core.rb
@@ -87,13 +87,6 @@ module ActiveRecord
 
       mattr_accessor :maintain_test_schema, instance_accessor: false
 
-      def self.disable_implicit_join_references=(value)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          Implicit join references were removed with Rails 4.1.
-          Make sure to remove this configuration because it does nothing.
-        MSG
-      end
-
       class_attribute :default_connection_handler, instance_writer: false
       class_attribute :find_by_statement_cache
 
@@ -217,7 +210,7 @@ module ActiveRecord
         elsif !connected?
           "#{super} (call '#{super}.connection' to establish a connection)"
         elsif table_exists?
-          attr_list = columns.map { |c| "#{c.name}: #{c.type}" } * ', '
+          attr_list = attribute_types.map { |name, type| "#{name}: #{type.type}" } * ', '
           "#{super}(#{attr_list})"
         else
           "#{super}(Table doesn't exist)"
@@ -281,16 +274,14 @@ module ActiveRecord
     # ==== Example:
     #   # Instantiates a single new object
     #   User.new(first_name: 'Jamie')
-    def initialize(attributes = nil, options = {})
+    def initialize(attributes = nil)
       @attributes = self.class._default_attributes.dup
+      self.class.define_attribute_methods
 
       init_internals
       initialize_internals_callback
 
-      self.class.define_attribute_methods
-      # +options+ argument is only needed to make protected_attributes gem easier to hook.
-      # Remove it when we drop support to this gem.
-      init_attributes(attributes, options) if attributes
+      assign_attributes(attributes) if attributes
 
       yield self if block_given?
       _run_initialize_callbacks
@@ -465,6 +456,7 @@ module ActiveRecord
     # Takes a PP and prettily prints this record to it, allowing you to get a nice result from `pp record`
     # when pp is required.
     def pretty_print(pp)
+      return super if custom_inspect_method_defined?
       pp.object_address_group(self) do
         if defined?(@attributes) && @attributes
           column_names = self.class.column_names.select { |name| has_attribute?(name) || new_record? }
@@ -564,16 +556,14 @@ module ActiveRecord
     def initialize_internals_callback
     end
 
-    # This method is needed to make protected_attributes gem easier to hook.
-    # Remove it when we drop support to this gem.
-    def init_attributes(attributes, options)
-      assign_attributes(attributes)
-    end
-
     def thaw
       if frozen?
         @attributes = @attributes.dup
       end
     end
+
+    def custom_inspect_method_defined?
+      self.class.instance_method(:inspect).owner != ActiveRecord::Base.instance_method(:inspect).owner
+    end
   end
 end
diff --git a/activerecord/lib/active_record/counter_cache.rb b/activerecord/lib/active_record/counter_cache.rb
index 7d8e0a2063..82596b63df 100644
--- a/activerecord/lib/active_record/counter_cache.rb
+++ b/activerecord/lib/active_record/counter_cache.rb
@@ -156,7 +156,7 @@ module ActiveRecord
 
       def each_counter_cached_associations
         _reflections.each do |name, reflection|
-          yield association(name) if reflection.belongs_to? && reflection.counter_cache_column
+          yield association(name.to_sym) if reflection.belongs_to? && reflection.counter_cache_column
         end
       end
 
diff --git a/activerecord/lib/active_record/errors.rb b/activerecord/lib/active_record/errors.rb
index fc28ab585f..d710d96a9a 100644
--- a/activerecord/lib/active_record/errors.rb
+++ b/activerecord/lib/active_record/errors.rb
@@ -178,18 +178,10 @@ module ActiveRecord
   class DangerousAttributeError < ActiveRecordError
   end
 
-  # Raised when unknown attributes are supplied via mass assignment.
-  class UnknownAttributeError < NoMethodError
-
-    attr_reader :record, :attribute
-
-    def initialize(record, attribute)
-      @record = record
-      @attribute = attribute.to_s
-      super("unknown attribute '#{attribute}' for #{@record.class}.")
-    end
-
-  end
+  UnknownAttributeError = ActiveSupport::Deprecation::DeprecatedConstantProxy.new( # :nodoc:
+    'ActiveRecord::UnknownAttributeError', 
+    'ActiveModel::AttributeAssignment::UnknownAttributeError'
+  )
 
   # Raised when an error occurred while doing a mass assignment to an attribute through the
   # +attributes=+ method. The exception has an +attribute+ property that is the name of the
diff --git a/activerecord/lib/active_record/fixtures.rb b/activerecord/lib/active_record/fixtures.rb
index 4732462b05..57db2faaff 100644
--- a/activerecord/lib/active_record/fixtures.rb
+++ b/activerecord/lib/active_record/fixtures.rb
@@ -1,6 +1,7 @@
 require 'erb'
 require 'yaml'
 require 'zlib'
+require 'set'
 require 'active_support/dependencies'
 require 'active_support/core_ext/digest/uuid'
 require 'active_record/fixture_set/file'
@@ -521,12 +522,16 @@ module ActiveRecord
           update_all_loaded_fixtures fixtures_map
 
           connection.transaction(:requires_new => true) do
+            deleted_tables = Set.new 
             fixture_sets.each do |fs|
               conn = fs.model_class.respond_to?(:connection) ? fs.model_class.connection : connection
               table_rows = fs.table_rows
 
               table_rows.each_key do |table|
-                conn.delete "DELETE FROM #{conn.quote_table_name(table)}", 'Fixture Delete'
+                unless deleted_tables.include? table
+                  conn.delete "DELETE FROM #{conn.quote_table_name(table)}", 'Fixture Delete'
+                end
+                deleted_tables << table
               end
 
               table_rows.each do |fixture_set_name, rows|
@@ -633,7 +638,7 @@ module ActiveRecord
 
           # interpolate the fixture label
           row.each do |key, value|
-            row[key] = value.gsub("$LABEL", label) if value.is_a?(String)
+            row[key] = value.gsub("$LABEL", label.to_s) if value.is_a?(String)
           end
 
           # generate a primary key if necessary
@@ -661,7 +666,7 @@ module ActiveRecord
                   row[association.foreign_type] = $1
                 end
 
-                fk_type = association.active_record.columns_hash[fk_name].type
+                fk_type = association.active_record.type_for_attribute(fk_name).type
                 row[fk_name] = ActiveRecord::FixtureSet.identify(value, fk_type)
               end
             when :has_many
@@ -691,7 +696,7 @@ module ActiveRecord
       end
 
       def primary_key_type
-        @association.klass.column_types[@association.klass.primary_key].type
+        @association.klass.type_for_attribute(@association.klass.primary_key).type
       end
     end
 
@@ -711,7 +716,7 @@ module ActiveRecord
       end
 
       def primary_key_type
-        @primary_key_type ||= model_class && model_class.column_types[model_class.primary_key].type
+        @primary_key_type ||= model_class && model_class.type_for_attribute(model_class.primary_key).type
       end
 
       def add_join_records(rows, row, association)
@@ -768,12 +773,6 @@ module ActiveRecord
 
   end
 
-  #--
-  # Deprecate 'Fixtures' in favor of 'FixtureSet'.
-  #++
-  # :nodoc:
-  Fixtures = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('ActiveRecord::Fixtures', 'ActiveRecord::FixtureSet')
-
   class Fixture #:nodoc:
     include Enumerable
 
@@ -888,7 +887,7 @@ module ActiveRecord
               @fixture_cache[fs_name] ||= {}
 
               instances = fixture_names.map do |f_name|
-                f_name = f_name.to_s
+                f_name = f_name.to_s if f_name.is_a?(Symbol)
                 @fixture_cache[fs_name].delete(f_name) if force_reload
 
                 if @loaded_fixtures[fs_name][f_name]
diff --git a/activerecord/lib/active_record/inheritance.rb b/activerecord/lib/active_record/inheritance.rb
index b91e9ac137..24098f72dc 100644
--- a/activerecord/lib/active_record/inheritance.rb
+++ b/activerecord/lib/active_record/inheritance.rb
@@ -79,16 +79,6 @@ module ActiveRecord
         :true == (@finder_needs_type_condition ||= descends_from_active_record? ? :false : :true)
       end
 
-      def symbolized_base_class
-        ActiveSupport::Deprecation.warn('`ActiveRecord::Base.symbolized_base_class` is deprecated and will be removed without replacement.')
-        @symbolized_base_class ||= base_class.to_s.to_sym
-      end
-
-      def symbolized_sti_name
-        ActiveSupport::Deprecation.warn('`ActiveRecord::Base.symbolized_sti_name` is deprecated and will be removed without replacement.')
-        @symbolized_sti_name ||= sti_name.present? ? sti_name.to_sym : symbolized_base_class
-      end
-
       # Returns the class descending directly from ActiveRecord::Base, or
       # an abstract class, if any, in the inheritance hierarchy.
       #
@@ -202,7 +192,7 @@ module ActiveRecord
       # If this is a StrongParameters hash, and access to inheritance_column is not permitted,
       # this will ignore the inheritance column and return nil
       def subclass_from_attributes?(attrs)
-        columns_hash.include?(inheritance_column) && attrs.is_a?(Hash)
+        attribute_names.include?(inheritance_column) && attrs.is_a?(Hash)
       end
 
       def subclass_from_attributes(attrs)
diff --git a/activerecord/lib/active_record/locking/optimistic.rb b/activerecord/lib/active_record/locking/optimistic.rb
index 9f053453bd..008cda46cd 100644
--- a/activerecord/lib/active_record/locking/optimistic.rb
+++ b/activerecord/lib/active_record/locking/optimistic.rb
@@ -66,6 +66,15 @@ module ActiveRecord
           send(lock_col + '=', previous_lock_value + 1)
         end
 
+        def _create_record(attribute_names = self.attribute_names, *) # :nodoc:
+          if locking_enabled?
+            # We always want to persist the locking version, even if we don't detect
+            # a change from the default, since the database might have no default
+            attribute_names |= [self.class.locking_column]
+          end
+          super
+        end
+
         def _update_record(attribute_names = self.attribute_names) #:nodoc:
           return super unless locking_enabled?
           return 0 if attribute_names.empty?
@@ -116,12 +125,8 @@ module ActiveRecord
           relation = super
 
           if locking_enabled?
-            column_name = self.class.locking_column
-            column      = self.class.columns_hash[column_name]
-            substitute  = self.class.connection.substitute_at(column)
-
-            relation = relation.where(self.class.arel_table[column_name].eq(substitute))
-            relation.bind_values << [column, self[column_name].to_i]
+            locking_column = self.class.locking_column
+            relation = relation.where(locking_column => _read_attribute(locking_column))
           end
 
           relation
@@ -139,7 +144,7 @@ module ActiveRecord
 
         # Set the column to use for optimistic locking. Defaults to +lock_version+.
         def locking_column=(value)
-          clear_caches_calculated_from_columns
+          reload_schema_from_cache
           @locking_column = value.to_s
         end
 
@@ -185,11 +190,6 @@ module ActiveRecord
         super.to_i
       end
 
-      def changed?(old_value, *)
-        # Ensure we save if the default was `nil`
-        super || old_value == 0
-      end
-
       def init_with(coder)
         __setobj__(coder['subtype'])
       end
diff --git a/activerecord/lib/active_record/log_subscriber.rb b/activerecord/lib/active_record/log_subscriber.rb
index eb64d197f0..6b26d7be78 100644
--- a/activerecord/lib/active_record/log_subscriber.rb
+++ b/activerecord/lib/active_record/log_subscriber.rb
@@ -20,18 +20,14 @@ module ActiveRecord
       @odd = false
     end
 
-    def render_bind(column, value)
-      if column
-        if column.binary?
-          # This specifically deals with the PG adapter that casts bytea columns into a Hash.
-          value = value[:value] if value.is_a?(Hash)
-          value = value ? "<#{value.bytesize} bytes of binary data>" : "<NULL binary data>"
-        end
-
-        [column.name, value]
+    def render_bind(attribute)
+      value = if attribute.type.binary? && attribute.value
+        "<#{attribute.value.bytesize} bytes of binary data>"
       else
-        [nil, value]
+        attribute.value_for_database
       end
+
+      [attribute.name, value]
     end
 
     def sql(event)
@@ -47,9 +43,7 @@ module ActiveRecord
       binds = nil
 
       unless (payload[:binds] || []).empty?
-        binds = "  " + payload[:binds].map { |col,v|
-          render_bind(col, v)
-        }.inspect
+        binds = "  " + payload[:binds].map { |attr| render_bind(attr) }.inspect
       end
 
       if odd?
diff --git a/activerecord/lib/active_record/model_schema.rb b/activerecord/lib/active_record/model_schema.rb
index 641512d323..293db1c57f 100644
--- a/activerecord/lib/active_record/model_schema.rb
+++ b/activerecord/lib/active_record/model_schema.rb
@@ -111,17 +111,6 @@ module ActiveRecord
       #   class Mouse < ActiveRecord::Base
       #     self.table_name = "mice"
       #   end
-      #
-      # Alternatively, you can override the table_name method to define your
-      # own computation. (Possibly using <tt>super</tt> to manipulate the default
-      # table name.) Example:
-      #
-      #   class Post < ActiveRecord::Base
-      #     def self.table_name
-      #       "special_" + super
-      #     end
-      #   end
-      #   Post.table_name # => "special_posts"
       def table_name
         reset_table_name unless defined?(@table_name)
         @table_name
@@ -132,9 +121,6 @@ module ActiveRecord
       #   class Project < ActiveRecord::Base
       #     self.table_name = "project"
       #   end
-      #
-      # You can also just define your own <tt>self.table_name</tt> method; see
-      # the documentation for ActiveRecord::Base#table_name.
       def table_name=(value)
         value = value && value.to_s
 
@@ -231,28 +217,37 @@ module ActiveRecord
       end
 
       def attributes_builder # :nodoc:
-        @attributes_builder ||= AttributeSet::Builder.new(column_types, primary_key)
+        @attributes_builder ||= AttributeSet::Builder.new(attribute_types, primary_key)
       end
 
-      def column_types # :nodoc:
-        @column_types ||= columns_hash.transform_values(&:cast_type).tap do |h|
-          h.default = Type::Value.new
-        end
+      def columns_hash # :nodoc:
+        load_schema
+        @columns_hash
+      end
+
+      def columns
+        load_schema
+        @columns ||= columns_hash.values
+      end
+
+      def attribute_types # :nodoc:
+        load_schema
+        @attribute_types ||= Hash.new(Type::Value.new)
       end
 
       def type_for_attribute(attr_name) # :nodoc:
-        column_types[attr_name]
+        attribute_types[attr_name]
       end
 
       # Returns a hash where the keys are column names and the values are
       # default values when instantiating the AR object for this table.
       def column_defaults
+        load_schema
         _default_attributes.to_hash
       end
 
       def _default_attributes # :nodoc:
-        @default_attributes ||= attributes_builder.build_from_database(
-          raw_default_values)
+        @default_attributes ||= AttributeSet.new({})
       end
 
       # Returns an array of column names as strings.
@@ -295,19 +290,53 @@ module ActiveRecord
       def reset_column_information
         connection.clear_cache!
         undefine_attribute_methods
-        connection.schema_cache.clear_table_cache!(table_name) if table_exists?
+        connection.schema_cache.clear_table_cache!(table_name)
 
-        @arel_engine        = nil
-        @arel_table         = nil
-        @column_names       = nil
-        @column_types       = nil
-        @content_columns    = nil
-        @default_attributes = nil
-        @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
+        reload_schema_from_cache
       end
 
       private
 
+      def schema_loaded?
+        defined?(@columns_hash) && @columns_hash
+      end
+
+      def load_schema
+        unless schema_loaded?
+          load_schema!
+        end
+      end
+
+      def load_schema!
+        @columns_hash = connection.schema_cache.columns_hash(table_name)
+        @columns_hash.each do |name, column|
+          define_attribute(
+            name,
+            column.cast_type,
+            default: column.default,
+            user_provided_default: false
+          )
+        end
+      end
+
+      def reload_schema_from_cache
+        @arel_engine = nil
+        @arel_table = nil
+        @column_names = nil
+        @attribute_types = nil
+        @content_columns = nil
+        @default_attributes = nil
+        @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
+        @attributes_builder = nil
+        @column_names = nil
+        @attribute_types = nil
+        @columns = nil
+        @columns_hash = nil
+        @content_columns = nil
+        @default_attributes = nil
+        @attribute_names = nil
+      end
+
       # Guesses the table name, but does not decorate it with prefix and suffix information.
       def undecorated_table_name(class_name = base_class.name)
         table_name = class_name.to_s.demodulize.underscore
@@ -331,10 +360,6 @@ module ActiveRecord
           base.table_name
         end
       end
-
-      def raw_default_values
-        columns_hash.transform_values(&:default)
-      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/nested_attributes.rb b/activerecord/lib/active_record/nested_attributes.rb
index 846e1162a9..117a128579 100644
--- a/activerecord/lib/active_record/nested_attributes.rb
+++ b/activerecord/lib/active_record/nested_attributes.rb
@@ -312,7 +312,7 @@ module ActiveRecord
         attr_names.each do |association_name|
           if reflection = _reflect_on_association(association_name)
             reflection.autosave = true
-            add_autosave_association_callbacks(reflection)
+            define_autosave_validation_callbacks(reflection)
 
             nested_attributes_options = self.nested_attributes_options.dup
             nested_attributes_options[association_name.to_sym] = options
diff --git a/activerecord/lib/active_record/null_relation.rb b/activerecord/lib/active_record/null_relation.rb
index b406da14dc..63ca29305d 100644
--- a/activerecord/lib/active_record/null_relation.rb
+++ b/activerecord/lib/active_record/null_relation.rb
@@ -75,5 +75,9 @@ module ActiveRecord
     def exists?(_id = false)
       false
     end
+
+    def or(other)
+      other.spawn
+    end
   end
 end
diff --git a/activerecord/lib/active_record/persistence.rb b/activerecord/lib/active_record/persistence.rb
index f53c5f17ef..22112fe8ff 100644
--- a/activerecord/lib/active_record/persistence.rb
+++ b/activerecord/lib/active_record/persistence.rb
@@ -113,9 +113,9 @@ module ActiveRecord
     # the current time. However, if you supply <tt>touch: false</tt>, these
     # timestamps will not be updated.
     #
-    # There's a series of callbacks associated with +save+. If any of the
-    # <tt>before_*</tt> callbacks return +false+ the action is cancelled and
-    # +save+ returns +false+. See ActiveRecord::Callbacks for further
+    # There's a series of callbacks associated with #save. If any of the
+    # <tt>before_*</tt> callbacks throws +:abort+ the action is cancelled and
+    # #save returns +false+. See ActiveRecord::Callbacks for further
     # details.
     #
     # Attributes marked as readonly are silently ignored if the record is
@@ -139,9 +139,9 @@ module ActiveRecord
     # the current time. However, if you supply <tt>touch: false</tt>, these
     # timestamps will not be updated.
     #
-    # There's a series of callbacks associated with <tt>save!</tt>. If any of
-    # the <tt>before_*</tt> callbacks return +false+ the action is cancelled
-    # and <tt>save!</tt> raises ActiveRecord::RecordNotSaved. See
+    # There's a series of callbacks associated with #save!. If any of
+    # the <tt>before_*</tt> callbacks throws +:abort+ the action is cancelled
+    # and #save! raises ActiveRecord::RecordNotSaved. See
     # ActiveRecord::Callbacks for further details.
     #
     # Attributes marked as readonly are silently ignored if the record is
@@ -171,10 +171,10 @@ module ActiveRecord
     # Deletes the record in the database and freezes this instance to reflect
     # that no changes should be made (since they can't be persisted).
     #
-    # There's a series of callbacks associated with <tt>destroy</tt>. If
-    # the <tt>before_destroy</tt> callback return +false+ the action is cancelled
-    # and <tt>destroy</tt> returns +false+. See
-    # ActiveRecord::Callbacks for further details.
+    # There's a series of callbacks associated with #destroy. If the
+    # <tt>before_destroy</tt> callback throws +:abort+ the action is cancelled
+    # and #destroy returns +false+.
+    # See ActiveRecord::Callbacks for further details.
     def destroy
       raise ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
       destroy_associations
@@ -186,10 +186,10 @@ module ActiveRecord
     # Deletes the record in the database and freezes this instance to reflect
     # that no changes should be made (since they can't be persisted).
     #
-    # There's a series of callbacks associated with <tt>destroy!</tt>. If
-    # the <tt>before_destroy</tt> callback return +false+ the action is cancelled
-    # and <tt>destroy!</tt> raises ActiveRecord::RecordNotDestroyed. See
-    # ActiveRecord::Callbacks for further details.
+    # There's a series of callbacks associated with #destroy!. If the
+    # <tt>before_destroy</tt> callback throws +:abort+ the action is cancelled
+    # and #destroy! raises ActiveRecord::RecordNotDestroyed.
+    # See ActiveRecord::Callbacks for further details.
     def destroy!
       destroy || raise(ActiveRecord::RecordNotDestroyed, self)
     end
@@ -245,8 +245,8 @@ module ActiveRecord
     def update_attribute(name, value)
       name = name.to_s
       verify_readonly_attribute(name)
-      send("#{name}=", value)
-      save(validate: false)
+      public_send("#{name}=", value)
+      save(validate: false) if changed?
     end
 
     # Updates the attributes of the model from the passed-in hash and saves the
@@ -352,7 +352,7 @@ module ActiveRecord
     # method toggles directly the underlying value without calling any setter.
     # Returns +self+.
     def toggle(attribute)
-      self[attribute] = !send("#{attribute}?")
+      self[attribute] = !public_send("#{attribute}?")
       self
     end
 
@@ -495,15 +495,7 @@ module ActiveRecord
     end
 
     def relation_for_destroy
-      pk         = self.class.primary_key
-      column     = self.class.columns_hash[pk]
-      substitute = self.class.connection.substitute_at(column)
-
-      relation = self.class.unscoped.where(
-        self.class.arel_table[pk].eq(substitute))
-
-      relation.bind_values = [[column, id]]
-      relation
+      self.class.unscoped.where(self.class.primary_key => id)
     end
 
     def create_or_update(*args)
diff --git a/activerecord/lib/active_record/querying.rb b/activerecord/lib/active_record/querying.rb
index e8de4db3a7..4e597590e9 100644
--- a/activerecord/lib/active_record/querying.rb
+++ b/activerecord/lib/active_record/querying.rb
@@ -7,7 +7,7 @@ module ActiveRecord
     delegate :find_by, :find_by!, to: :all
     delegate :destroy, :destroy_all, :delete, :delete_all, :update, :update_all, to: :all
     delegate :find_each, :find_in_batches, to: :all
-    delegate :select, :group, :order, :except, :reorder, :limit, :offset, :joins,
+    delegate :select, :group, :order, :except, :reorder, :limit, :offset, :joins, :or,
              :where, :rewhere, :preload, :eager_load, :includes, :from, :lock, :readonly,
              :having, :create_with, :uniq, :distinct, :references, :none, :unscope, to: :all
     delegate :count, :average, :minimum, :maximum, :sum, :calculate, to: :all
@@ -55,11 +55,12 @@ module ActiveRecord
     # The use of this method should be restricted to complicated SQL queries that can't be executed
     # using the ActiveRecord::Calculations class methods. Look into those before using this.
     #
-    # ==== Parameters
+    #   Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
+    #   # => 12
     #
-    # * +sql+ - An SQL statement which should return a count query from the database, see the example below.
+    # ==== Parameters
     #
-    #   Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
+    # * +sql+ - An SQL statement which should return a count query from the database, see the example above.
     def count_by_sql(sql)
       sql = sanitize_conditions(sql)
       connection.select_value(sql, "#{name} Count").to_i
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index 7696ef13c7..dab5a502a5 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -153,15 +153,6 @@ module ActiveRecord
         JoinKeys.new(foreign_key, active_record_primary_key)
       end
 
-      def source_macro
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveRecord::Base.source_macro is deprecated and will be removed
-          without replacement.
-        MSG
-
-        macro
-      end
-
       def constraints
         scope_chain.flatten
       end
@@ -352,13 +343,10 @@ module ActiveRecord
         return unless scope
 
         if scope.arity > 0
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          raise ArgumentError, <<-MSG.squish
             The association scope '#{name}' is instance dependent (the scope
-            block takes an argument). Preloading happens before the individual
-            instances are created. This means that there is no instance being
-            passed to the association scope. This will most likely result in
-            broken or incorrect behavior. Joining, Preloading and eager loading
-            of these associations is deprecated and will be removed in the future.
+            block takes an argument). Preloading instance dependent scopes is
+            not supported.
           MSG
         end
       end
@@ -763,16 +751,6 @@ module ActiveRecord
         source_reflection.join_keys(association_klass)
       end
 
-      # The macro used by the source association
-      def source_macro
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveRecord::Base.source_macro is deprecated and will be removed
-          without replacement.
-        MSG
-
-        source_reflection.source_macro
-      end
-
       # A through association is nested if there would be more than one join table
       def nested?
         chain.length > 2
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index ab3debc03b..8073eb99dd 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -1,18 +1,19 @@
 # -*- coding: utf-8 -*-
-require 'arel/collectors/bind'
+require "arel/collectors/bind"
 
 module ActiveRecord
   # = Active Record Relation
   class Relation
     MULTI_VALUE_METHODS  = [:includes, :eager_load, :preload, :select, :group,
-                            :order, :joins, :where, :having, :bind, :references,
+                            :order, :joins, :references,
                             :extending, :unscope]
 
-    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :from, :reordering,
+    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :reordering,
                             :reverse_order, :distinct, :create_with, :uniq]
+    CLAUSE_METHODS = [:where, :having, :from]
     INVALID_METHODS_FOR_DELETE_ALL = [:limit, :distinct, :offset, :group, :having]
 
-    VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
+    VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS + CLAUSE_METHODS
 
     include FinderMethods, Calculations, SpawnMethods, QueryMethods, Batches, Explain, Delegation
 
@@ -33,7 +34,6 @@ module ActiveRecord
       # This method is a hot spot, so for now, use Hash[] to dup the hash.
       #   https://bugs.ruby-lang.org/issues/7166
       @values        = Hash[@values]
-      @values[:bind] = @values[:bind].dup if @values.key? :bind
       reset
     end
 
@@ -81,7 +81,7 @@ module ActiveRecord
       end
 
       relation = scope.where(@klass.primary_key => (id_was || id))
-      bvs = binds + relation.bind_values
+      bvs = binds + relation.bound_attributes
       um = relation
         .arel
         .compile_update(substitutes, @klass.primary_key)
@@ -95,11 +95,11 @@ module ActiveRecord
 
     def substitute_values(values) # :nodoc:
       binds = values.map do |arel_attr, value|
-        [@klass.columns_hash[arel_attr.name], value]
+        QueryAttribute.new(arel_attr.name, value, klass.type_for_attribute(arel_attr.name))
       end
 
-      substitutes = values.each_with_index.map do |(arel_attr, _), i|
-        [arel_attr, @klass.connection.substitute_at(binds[i][0])]
+      substitutes = values.map do |(arel_attr, _)|
+        [arel_attr, connection.substitute_at(klass.columns_hash[arel_attr.name])]
       end
 
       [substitutes, binds]
@@ -342,8 +342,7 @@ module ActiveRecord
         stmt.wheres = arel.constraints
       end
 
-      bvs = arel.bind_values + bind_values
-      @klass.connection.update stmt, 'SQL', bvs
+      @klass.connection.update stmt, 'SQL', bound_attributes
     end
 
     # Updates an object (or multiple objects) and saves it to the database, if validations pass.
@@ -467,8 +466,10 @@ module ActiveRecord
       invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select { |method|
         if MULTI_VALUE_METHODS.include?(method)
           send("#{method}_values").any?
-        else
+        elsif SINGLE_VALUE_METHODS.include?(method)
           send("#{method}_value")
+        elsif CLAUSE_METHODS.include?(method)
+          send("#{method}_clause").any?
         end
       }
       if invalid_methods.any?
@@ -487,7 +488,7 @@ module ActiveRecord
           stmt.wheres = arel.constraints
         end
 
-        affected = @klass.connection.delete(stmt, 'SQL', bind_values)
+        affected = @klass.connection.delete(stmt, 'SQL', bound_attributes)
 
         reset
         affected
@@ -557,10 +558,10 @@ module ActiveRecord
                       find_with_associations { |rel| relation = rel }
                     end
 
-                    arel  = relation.arel
-                    binds = (arel.bind_values + relation.bind_values).dup
-                    binds.map! { |bv| connection.quote(*bv.reverse) }
-                    collect = visitor.accept(arel.ast, Arel::Collectors::Bind.new)
+                    binds = relation.bound_attributes
+                    binds = connection.prepare_binds_for_database(binds)
+                    binds.map! { |value| connection.quote(value) }
+                    collect = visitor.accept(relation.arel.ast, Arel::Collectors::Bind.new)
                     collect.substitute_binds(binds).join
                   end
     end
@@ -570,22 +571,7 @@ module ActiveRecord
     #   User.where(name: 'Oscar').where_values_hash
     #   # => {name: "Oscar"}
     def where_values_hash(relation_table_name = table_name)
-      equalities = where_values.grep(Arel::Nodes::Equality).find_all { |node|
-        node.left.relation.name == relation_table_name
-      }
-
-      binds = Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }]
-
-      Hash[equalities.map { |where|
-        name = where.left.name
-        [name, binds.fetch(name.to_s) {
-          case where.right
-          when Array then where.right.map(&:val)
-          when Arel::Nodes::Casted, Arel::Nodes::Quoted
-            where.right.val
-          end
-        }]
-      }]
+      where_clause.to_h(relation_table_name)
     end
 
     def scope_for_create
@@ -648,7 +634,7 @@ module ActiveRecord
     private
 
     def exec_queries
-      @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel, arel.bind_values + bind_values)
+      @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel, bound_attributes)
 
       preload = preload_values
       preload +=  includes_values unless eager_loading?
diff --git a/activerecord/lib/active_record/relation/calculations.rb b/activerecord/lib/active_record/relation/calculations.rb
index 1d4cb1a83b..63e0d2fc21 100644
--- a/activerecord/lib/active_record/relation/calculations.rb
+++ b/activerecord/lib/active_record/relation/calculations.rb
@@ -166,8 +166,8 @@ module ActiveRecord
         relation.select_values = column_names.map { |cn|
           columns_hash.key?(cn) ? arel_table[cn] : cn
         }
-        result = klass.connection.select_all(relation.arel, nil, relation.arel.bind_values + bind_values)
-        result.cast_values(klass.column_types)
+        result = klass.connection.select_all(relation.arel, nil, bound_attributes)
+        result.cast_values(klass.attribute_types)
       end
     end
 
@@ -227,14 +227,11 @@ module ActiveRecord
 
       column_alias = column_name
 
-      bind_values = nil
-
       if operation == "count" && (relation.limit_value || relation.offset_value)
         # Shortcut when limit is zero.
         return 0 if relation.limit_value == 0
 
         query_builder = build_count_subquery(relation, column_name, distinct)
-        bind_values = query_builder.bind_values + relation.bind_values
       else
         column = aggregate_column(column_name)
 
@@ -245,10 +242,9 @@ module ActiveRecord
         relation.select_values = [select_value]
 
         query_builder = relation.arel
-        bind_values = query_builder.bind_values + relation.bind_values
       end
 
-      result = @klass.connection.select_all(query_builder, nil, bind_values)
+      result = @klass.connection.select_all(query_builder, nil, bound_attributes)
       row    = result.first
       value  = row && row.values.first
       column = result.column_types.fetch(column_alias) do
@@ -290,7 +286,7 @@ module ActiveRecord
           operation,
           distinct).as(aggregate_alias)
       ]
-      select_values += select_values unless having_values.empty?
+      select_values += select_values unless having_clause.empty?
 
       select_values.concat group_fields.zip(group_aliases).map { |field,aliaz|
         if field.respond_to?(:as)
@@ -304,11 +300,11 @@ module ActiveRecord
       relation.group_values  = group
       relation.select_values = select_values
 
-      calculated_data = @klass.connection.select_all(relation, nil, relation.arel.bind_values + bind_values)
+      calculated_data = @klass.connection.select_all(relation, nil, relation.bound_attributes)
 
       if association
         key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
-        key_records = association.klass.base_class.find(key_ids)
+        key_records = association.klass.base_class.where(association.klass.base_class.primary_key => key_ids)
         key_records = Hash[key_records.map { |r| [r.id, r] }]
       end
 
@@ -378,11 +374,9 @@ module ActiveRecord
 
       aliased_column = aggregate_column(column_name == :all ? 1 : column_name).as(column_alias)
       relation.select_values = [aliased_column]
-      arel = relation.arel
-      subquery = arel.as(subquery_alias)
+      subquery = relation.arel.as(subquery_alias)
 
       sm = Arel::SelectManager.new relation.engine
-      sm.bind_values = arel.bind_values
       select_value = operation_over_aggregate_column(column_alias, 'count', distinct)
       sm.project(select_value).from(subquery)
     end
diff --git a/activerecord/lib/active_record/relation/delegation.rb b/activerecord/lib/active_record/relation/delegation.rb
index 50f4d5c7ab..d4a8823cfe 100644
--- a/activerecord/lib/active_record/relation/delegation.rb
+++ b/activerecord/lib/active_record/relation/delegation.rb
@@ -1,6 +1,5 @@
 require 'set'
 require 'active_support/concern'
-require 'active_support/deprecation'
 
 module ActiveRecord
   module Delegation # :nodoc:
diff --git a/activerecord/lib/active_record/relation/finder_methods.rb b/activerecord/lib/active_record/relation/finder_methods.rb
index 088bc203b7..fb47d915ff 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -307,11 +307,11 @@ module ActiveRecord
         relation = relation.where(conditions)
       else
         unless conditions == :none
-          relation = where(primary_key => conditions)
+          relation = relation.where(primary_key => conditions)
         end
       end
 
-      connection.select_value(relation, "#{name} Exists", relation.arel.bind_values + relation.bind_values) ? true : false
+      connection.select_value(relation, "#{name} Exists", relation.bound_attributes) ? true : false
     end
 
     # This method is called whenever no records are found with either a single
@@ -365,7 +365,7 @@ module ActiveRecord
           []
         else
           arel = relation.arel
-          rows = connection.select_all(arel, 'SQL', arel.bind_values + relation.bind_values)
+          rows = connection.select_all(arel, 'SQL', relation.bound_attributes)
           join_dependency.instantiate(rows, aliases)
         end
       end
@@ -410,7 +410,7 @@ module ActiveRecord
       relation = relation.except(:select).select(values).distinct!
       arel = relation.arel
 
-      id_rows = @klass.connection.select_all(arel, 'SQL', arel.bind_values + relation.bind_values)
+      id_rows = @klass.connection.select_all(arel, 'SQL', relation.bound_attributes)
       id_rows.map {|row| row[primary_key]}
     end
 
diff --git a/activerecord/lib/active_record/relation/from_clause.rb b/activerecord/lib/active_record/relation/from_clause.rb
new file mode 100644
index 0000000000..a93952fa30
--- /dev/null
+++ b/activerecord/lib/active_record/relation/from_clause.rb
@@ -0,0 +1,32 @@
+module ActiveRecord
+  class Relation
+    class FromClause
+      attr_reader :value, :name
+
+      def initialize(value, name)
+        @value = value
+        @name = name
+      end
+
+      def binds
+        if value.is_a?(Relation)
+          value.bound_attributes
+        else
+          []
+        end
+      end
+
+      def merge(other)
+        self
+      end
+
+      def empty?
+        value.nil?
+      end
+
+      def self.empty
+        new(nil, nil)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/relation/merger.rb b/activerecord/lib/active_record/relation/merger.rb
index afb0b208c3..65b607ff1c 100644
--- a/activerecord/lib/active_record/relation/merger.rb
+++ b/activerecord/lib/active_record/relation/merger.rb
@@ -49,9 +49,9 @@ module ActiveRecord
         @other    = other
       end
 
-      NORMAL_VALUES = Relation::SINGLE_VALUE_METHODS +
-                      Relation::MULTI_VALUE_METHODS -
-                      [:joins, :where, :order, :bind, :reverse_order, :lock, :create_with, :reordering, :from] # :nodoc:
+      NORMAL_VALUES = Relation::VALUE_METHODS -
+                      Relation::CLAUSE_METHODS -
+                      [:joins, :order, :reverse_order, :lock, :create_with, :reordering] # :nodoc:
 
       def normal_values
         NORMAL_VALUES
@@ -75,6 +75,7 @@ module ActiveRecord
 
         merge_multi_values
         merge_single_values
+        merge_clauses
         merge_joins
 
         relation
@@ -107,20 +108,6 @@ module ActiveRecord
       end
 
       def merge_multi_values
-        lhs_wheres = relation.where_values
-        rhs_wheres = other.where_values
-
-        lhs_binds  = relation.bind_values
-        rhs_binds  = other.bind_values
-
-        removed, kept = partition_overwrites(lhs_wheres, rhs_wheres)
-
-        where_values = kept + rhs_wheres
-        bind_values  = filter_binds(lhs_binds, removed) + rhs_binds
-
-        relation.where_values = where_values
-        relation.bind_values  = bind_values
-
         if other.reordering_value
           # override any order specified in the original relation
           relation.reorder! other.order_values
@@ -133,36 +120,18 @@ module ActiveRecord
       end
 
       def merge_single_values
-        relation.from_value          = other.from_value unless relation.from_value
-        relation.lock_value          = other.lock_value unless relation.lock_value
+        relation.lock_value ||= other.lock_value
 
         unless other.create_with_value.blank?
           relation.create_with_value = (relation.create_with_value || {}).merge(other.create_with_value)
         end
       end
 
-      def filter_binds(lhs_binds, removed_wheres)
-        return lhs_binds if removed_wheres.empty?
-
-        set = Set.new removed_wheres.map { |x| x.left.name.to_s }
-        lhs_binds.dup.delete_if { |col,_| set.include? col.name }
-      end
-
-      # Remove equalities from the existing relation with a LHS which is
-      # present in the relation being merged in.
-      # returns [things_to_remove, things_to_keep]
-      def partition_overwrites(lhs_wheres, rhs_wheres)
-        if lhs_wheres.empty? || rhs_wheres.empty?
-          return [[], lhs_wheres]
-        end
-
-        nodes = rhs_wheres.find_all do |w|
-          w.respond_to?(:operator) && w.operator == :==
-        end
-        seen = Set.new(nodes) { |node| node.left }
-
-        lhs_wheres.partition do |w|
-          w.respond_to?(:operator) && w.operator == :== && seen.include?(w.left)
+      def merge_clauses
+        CLAUSE_METHODS.each do |name|
+          clause = relation.send("#{name}_clause")
+          other_clause = other.send("#{name}_clause")
+          relation.send("#{name}_clause=", clause.merge(other_clause))
         end
       end
     end
diff --git a/activerecord/lib/active_record/relation/predicate_builder.rb b/activerecord/lib/active_record/relation/predicate_builder.rb
index 567efce8ae..43e9afe853 100644
--- a/activerecord/lib/active_record/relation/predicate_builder.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder.rb
@@ -28,6 +28,11 @@ module ActiveRecord
       expand_from_hash(attributes)
     end
 
+    def create_binds(attributes)
+      attributes = convert_dot_notation_to_hash(attributes.stringify_keys)
+      create_binds_for_hash(attributes)
+    end
+
     def expand(column, value)
       # Find the foreign key when using queries such as:
       # Post.where(author: author)
@@ -80,16 +85,43 @@ module ActiveRecord
 
       attributes.flat_map do |key, value|
         if value.is_a?(Hash)
-          builder = self.class.new(table.associated_table(key))
-          builder.expand_from_hash(value)
+          associated_predicate_builder(key).expand_from_hash(value)
         else
           expand(key, value)
         end
       end
     end
 
+
+    def create_binds_for_hash(attributes)
+      result = attributes.dup
+      binds = []
+
+      attributes.each do |column_name, value|
+        case value
+        when Hash
+          attrs, bvs = associated_predicate_builder(column_name).create_binds_for_hash(value)
+          result[column_name] = attrs
+          binds += bvs
+        when Relation
+          binds += value.bound_attributes
+        else
+          if can_be_bound?(column_name, value)
+            result[column_name] = Arel::Nodes::BindParam.new
+            binds << Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
+          end
+        end
+      end
+
+      [result, binds]
+    end
+
     private
 
+    def associated_predicate_builder(association_name)
+      self.class.new(table.associated_table(association_name))
+    end
+
     def convert_dot_notation_to_hash(attributes)
       dot_notation = attributes.keys.select { |s| s.include?(".") }
 
@@ -107,5 +139,11 @@ module ActiveRecord
     def handler_for(object)
       @handlers.detect { |klass, _| klass === object }.last
     end
+
+    def can_be_bound?(column_name, value)
+      !value.nil? &&
+        handler_for(value).is_a?(BasicObjectHandler) &&
+        !table.associated_with?(column_name)
+    end
   end
 end
diff --git a/activerecord/lib/active_record/relation/predicate_builder/array_handler.rb b/activerecord/lib/active_record/relation/predicate_builder/array_handler.rb
index 4b5f5773a0..95dbd6a77f 100644
--- a/activerecord/lib/active_record/relation/predicate_builder/array_handler.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder/array_handler.rb
@@ -1,5 +1,3 @@
-require 'active_support/core_ext/string/filters'
-
 module ActiveRecord
   class PredicateBuilder
     class ArrayHandler # :nodoc:
diff --git a/activerecord/lib/active_record/relation/query_attribute.rb b/activerecord/lib/active_record/relation/query_attribute.rb
new file mode 100644
index 0000000000..e69319b4de
--- /dev/null
+++ b/activerecord/lib/active_record/relation/query_attribute.rb
@@ -0,0 +1,19 @@
+require 'active_record/attribute'
+
+module ActiveRecord
+  class Relation
+    class QueryAttribute < Attribute
+      def type_cast(value)
+        value
+      end
+
+      def value_for_database
+        @value_for_database ||= super
+      end
+
+      def with_cast_value(value)
+        QueryAttribute.new(name, value, type)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
index ef380abfe8..7514401072 100644
--- a/activerecord/lib/active_record/relation/query_methods.rb
+++ b/activerecord/lib/active_record/relation/query_methods.rb
@@ -1,6 +1,9 @@
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/string/filters'
+require "active_record/relation/from_clause"
+require "active_record/relation/query_attribute"
+require "active_record/relation/where_clause"
+require "active_record/relation/where_clause_factory"
 require 'active_model/forbidden_attributes_protection'
+require 'active_support/core_ext/string/filters'
 
 module ActiveRecord
   module QueryMethods
@@ -39,38 +42,24 @@ module ActiveRecord
       #    User.where.not(name: "Jon", role: "admin")
       #    # SELECT * FROM users WHERE name != 'Jon' AND role != 'admin'
       def not(opts, *rest)
-        where_value = @scope.send(:build_where, opts, rest).map do |rel|
-          case rel
-          when NilClass
-            raise ArgumentError, 'Invalid argument for .where.not(), got nil.'
-          when Arel::Nodes::In
-            Arel::Nodes::NotIn.new(rel.left, rel.right)
-          when Arel::Nodes::Equality
-            Arel::Nodes::NotEqual.new(rel.left, rel.right)
-          when String
-            Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new(rel))
-          else
-            Arel::Nodes::Not.new(rel)
-          end
-        end
+        where_clause = @scope.send(:where_clause_factory).build(opts, rest)
 
         @scope.references!(PredicateBuilder.references(opts)) if Hash === opts
-        @scope.where_values += where_value
+        @scope.where_clause += where_clause.invert
         @scope
       end
     end
 
     Relation::MULTI_VALUE_METHODS.each do |name|
       class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{name}_values                   # def select_values
-          @values[:#{name}] || []            #   @values[:select] || []
-        end                                  # end
-                                             #
-        def #{name}_values=(values)          # def select_values=(values)
-          raise ImmutableRelation if @loaded #   raise ImmutableRelation if @loaded
-          check_cached_relation
-          @values[:#{name}] = values         #   @values[:select] = values
-        end                                  # end
+        def #{name}_values                    # def select_values
+          @values[:#{name}] || []             #   @values[:select] || []
+        end                                   # end
+                                              #
+        def #{name}_values=(values)           # def select_values=(values)
+          assert_mutability!                  #   assert_mutability!
+          @values[:#{name}] = values          #   @values[:select] = values
+        end                                   # end
       CODE
     end
 
@@ -85,21 +74,27 @@ module ActiveRecord
     Relation::SINGLE_VALUE_METHODS.each do |name|
       class_eval <<-CODE, __FILE__, __LINE__ + 1
         def #{name}_value=(value)            # def readonly_value=(value)
-          raise ImmutableRelation if @loaded #   raise ImmutableRelation if @loaded
-          check_cached_relation
+          assert_mutability!                 #   assert_mutability!
           @values[:#{name}] = value          #   @values[:readonly] = value
         end                                  # end
       CODE
     end
 
-    def check_cached_relation # :nodoc:
-      if defined?(@arel) && @arel
-        @arel = nil
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          Modifying already cached Relation. The cache will be reset. Use a
-          cloned Relation to prevent this warning.
-        MSG
-      end
+    Relation::CLAUSE_METHODS.each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}_clause                           # def where_clause
+          @values[:#{name}] || new_#{name}_clause    #   @values[:where] || new_where_clause
+        end                                          # end
+                                                     #
+        def #{name}_clause=(value)                   # def where_clause=(value)
+          assert_mutability!                         #   assert_mutability!
+          @values[:#{name}] = value                  #   @values[:where] = value
+        end                                          # end
+      CODE
+    end
+
+    def bound_attributes
+      from_clause.binds + arel.bind_values + where_clause.binds + having_clause.binds
     end
 
     def create_with_value # :nodoc:
@@ -404,9 +399,8 @@ module ActiveRecord
               raise ArgumentError, "Hash arguments in .unscope(*args) must have :where as the key."
             end
 
-            Array(target_value).each do |val|
-              where_unscoping(val)
-            end
+            target_values = Array(target_value).map(&:to_s)
+            self.where_clause = where_clause.except(*target_values)
           end
         else
           raise ArgumentError, "Unrecognized scoping: #{args.inspect}. Use .unscope(where: :attribute_name) or .unscope(:order), for example."
@@ -437,15 +431,6 @@ module ActiveRecord
       self
     end
 
-    def bind(value) # :nodoc:
-      spawn.bind!(value)
-    end
-
-    def bind!(value) # :nodoc:
-      self.bind_values += [value]
-      self
-    end
-
     # Returns a new relation, which is the result of filtering the current relation
     # according to the conditions in the arguments.
     #
@@ -581,7 +566,7 @@ module ActiveRecord
         references!(PredicateBuilder.references(opts))
       end
 
-      self.where_values += build_where(opts, rest)
+      self.where_clause += where_clause_factory.build(opts, rest)
       self
     end
 
@@ -597,6 +582,37 @@ module ActiveRecord
       unscope(where: conditions.keys).where(conditions)
     end
 
+    # Returns a new relation, which is the logical union of this relation and the one passed as an
+    # argument.
+    #
+    # The two relations must be structurally compatible: they must be scoping the same model, and
+    # they must differ only by +where+ (if no +group+ has been defined) or +having+ (if a +group+ is
+    # present). Neither relation may have a +limit+, +offset+, or +uniq+ set.
+    #
+    #    Post.where("id = 1").or(Post.where("id = 2"))
+    #    # SELECT `posts`.* FROM `posts`  WHERE (('id = 1' OR 'id = 2'))
+    #
+    def or(other)
+      spawn.or!(other)
+    end
+
+    def or!(other) # :nodoc:
+      unless structurally_compatible_for_or?(other)
+        raise ArgumentError, 'Relation passed to #or must be structurally compatible'
+      end
+
+      self.where_clause = self.where_clause.or(other.where_clause)
+      self.having_clause = self.having_clause.or(other.having_clause)
+
+      self
+    end
+
+    private def structurally_compatible_for_or?(other) # :nodoc:
+      Relation::SINGLE_VALUE_METHODS.all? { |m| send("#{m}_value") == other.send("#{m}_value") } &&
+        (Relation::MULTI_VALUE_METHODS - [:extending]).all? { |m| send("#{m}_values") == other.send("#{m}_values") } &&
+        (Relation::CLAUSE_METHODS - [:having, :where]).all? { |m| send("#{m}_clause") != other.send("#{m}_clause") }
+    end
+
     # Allows to specify a HAVING clause. Note that you can't use HAVING
     # without also specifying a GROUP clause.
     #
@@ -608,7 +624,7 @@ module ActiveRecord
     def having!(opts, *rest) # :nodoc:
       references!(PredicateBuilder.references(opts)) if Hash === opts
 
-      self.having_values += build_where(opts, rest)
+      self.having_clause += having_clause_factory.build(opts, rest)
       self
     end
 
@@ -756,7 +772,7 @@ module ActiveRecord
     end
 
     def from!(value, subquery_name = nil) # :nodoc:
-      self.from_value = [value, subquery_name]
+      self.from_clause = Relation::FromClause.new(value, subquery_name)
       self
     end
 
@@ -857,26 +873,28 @@ module ActiveRecord
 
     private
 
+    def assert_mutability!
+      raise ImmutableRelation if @loaded
+      raise ImmutableRelation if defined?(@arel) && @arel
+    end
+
     def build_arel
       arel = Arel::SelectManager.new(table)
 
       build_joins(arel, joins_values.flatten) unless joins_values.empty?
 
-      collapse_wheres(arel, (where_values - [''])) #TODO: Add uniq with real value comparison / ignore uniqs that have binds
-
-      arel.having(*having_values.uniq.reject(&:blank?)) unless having_values.empty?
-
+      arel.where(where_clause.ast) unless where_clause.empty?
+      arel.having(having_clause.ast) unless having_clause.empty?
       arel.take(connection.sanitize_limit(limit_value)) if limit_value
       arel.skip(offset_value.to_i) if offset_value
-
-      arel.group(*group_values.uniq.reject(&:blank?)) unless group_values.empty?
+      arel.group(*arel_columns(group_values.uniq.reject(&:blank?))) unless group_values.empty?
 
       build_order(arel)
 
-      build_select(arel, select_values.uniq)
+      build_select(arel)
 
       arel.distinct(distinct_value)
-      arel.from(build_from) if from_value
+      arel.from(build_from) unless from_clause.empty?
       arel.lock(lock_value) if lock_value
 
       arel
@@ -887,114 +905,24 @@ module ActiveRecord
         raise ArgumentError, "Called unscope() with invalid unscoping argument ':#{scope}'. Valid arguments are :#{VALID_UNSCOPING_VALUES.to_a.join(", :")}."
       end
 
-      single_val_method = Relation::SINGLE_VALUE_METHODS.include?(scope)
-      unscope_code = "#{scope}_value#{'s' unless single_val_method}="
+      clause_method = Relation::CLAUSE_METHODS.include?(scope)
+      multi_val_method = Relation::MULTI_VALUE_METHODS.include?(scope)
+      if clause_method
+        unscope_code = "#{scope}_clause="
+      else
+        unscope_code = "#{scope}_value#{'s' if multi_val_method}="
+      end
 
       case scope
       when :order
         result = []
-      when :where
-        self.bind_values = []
       else
-        result = [] unless single_val_method
+        result = [] if multi_val_method
       end
 
       self.send(unscope_code, result)
     end
 
-    def where_unscoping(target_value)
-      target_value = target_value.to_s
-
-      where_values.reject! do |rel|
-        case rel
-        when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThanOrEqual
-          subrelation = (rel.left.kind_of?(Arel::Attributes::Attribute) ? rel.left : rel.right)
-          subrelation.name.to_s == target_value
-        end
-      end
-
-      bind_values.reject! { |col,_| col.name == target_value }
-    end
-
-    def custom_join_ast(table, joins)
-      joins = joins.reject(&:blank?)
-
-      return [] if joins.empty?
-
-      joins.map! do |join|
-        case join
-        when Array
-          join = Arel.sql(join.join(' ')) if array_of_strings?(join)
-        when String
-          join = Arel.sql(join)
-        end
-        table.create_string_join(join)
-      end
-    end
-
-    def collapse_wheres(arel, wheres)
-      predicates = wheres.map do |where|
-        next where if ::Arel::Nodes::Equality === where
-        where = Arel.sql(where) if String === where
-        Arel::Nodes::Grouping.new(where)
-      end
-
-      arel.where(Arel::Nodes::And.new(predicates)) if predicates.present?
-    end
-
-    def build_where(opts, other = [])
-      case opts
-      when String, Array
-        [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
-      when Hash
-        opts = predicate_builder.resolve_column_aliases(opts)
-
-        tmp_opts, bind_values = create_binds(opts)
-        self.bind_values += bind_values
-
-        attributes = @klass.send(:expand_hash_conditions_for_aggregates, tmp_opts)
-        add_relations_to_bind_values(attributes)
-
-        predicate_builder.build_from_hash(attributes)
-      else
-        [opts]
-      end
-    end
-
-    def create_binds(opts)
-      bindable, non_binds = opts.partition do |column, value|
-        case value
-        when String, Integer, ActiveRecord::StatementCache::Substitute
-          @klass.columns_hash.include? column.to_s
-        else
-          false
-        end
-      end
-
-      association_binds, non_binds = non_binds.partition do |column, value|
-        value.is_a?(Hash) && association_for_table(column)
-      end
-
-      new_opts = {}
-      binds = []
-
-      bindable.each do |(column,value)|
-        binds.push [@klass.columns_hash[column.to_s], value]
-        new_opts[column] = connection.substitute_at(column)
-      end
-
-      association_binds.each do |(column, value)|
-        association_relation = association_for_table(column).klass.send(:relation)
-        association_new_opts, association_bind = association_relation.send(:create_binds, value)
-        new_opts[column] = association_new_opts
-        binds += association_bind
-      end
-
-      non_binds.each { |column,value| new_opts[column] = value }
-
-      [new_opts, binds]
-    end
-
     def association_for_table(table_name)
       table_name = table_name.to_s
       @klass._reflect_on_association(table_name) ||
@@ -1002,11 +930,11 @@ module ActiveRecord
     end
 
     def build_from
-      opts, name = from_value
+      opts = from_clause.value
+      name = from_clause.name
       case opts
       when Relation
         name ||= 'subquery'
-        self.bind_values = opts.bind_values + self.bind_values
         opts.arel.as(name.to_s)
       else
         opts
@@ -1028,13 +956,14 @@ module ActiveRecord
           raise 'unknown class: %s' % join.class.name
         end
       end
+      buckets.default = []
 
-      association_joins         = buckets[:association_join] || []
-      stashed_association_joins = buckets[:stashed_join] || []
-      join_nodes                = (buckets[:join_node] || []).uniq
-      string_joins              = (buckets[:string_join] || []).map(&:strip).uniq
+      association_joins         = buckets[:association_join]
+      stashed_association_joins = buckets[:stashed_join]
+      join_nodes                = buckets[:join_node].uniq
+      string_joins              = buckets[:string_join].map(&:strip).uniq
 
-      join_list = join_nodes + custom_join_ast(manager, string_joins)
+      join_list = join_nodes + convert_join_strings_to_ast(manager, string_joins)
 
       join_dependency = ActiveRecord::Associations::JoinDependency.new(
         @klass,
@@ -1054,22 +983,31 @@ module ActiveRecord
       manager
     end
 
-    def build_select(arel, selects)
-      if !selects.empty?
-        expanded_select = selects.map do |field|
-          if (Symbol === field || String === field) && columns_hash.key?(field.to_s)
-            arel_table[field]
-          else
-            field
-          end
-        end
+    def convert_join_strings_to_ast(table, joins)
+      joins
+        .flatten
+        .reject(&:blank?)
+        .map { |join| table.create_string_join(Arel.sql(join)) }
+    end
 
-        arel.project(*expanded_select)
+    def build_select(arel)
+      if select_values.any?
+        arel.project(*arel_columns(select_values.uniq))
       else
         arel.project(@klass.arel_table[Arel.star])
       end
     end
 
+    def arel_columns(columns)
+      columns.map do |field|
+        if (Symbol === field || String === field) && columns_hash.key?(field.to_s)
+          arel_table[field]
+        else
+          field
+        end
+      end
+    end
+
     def reverse_sql_order(order_query)
       order_query = ["#{quoted_table_name}.#{quoted_primary_key} ASC"] if order_query.empty?
 
@@ -1088,10 +1026,6 @@ module ActiveRecord
       end
     end
 
-    def array_of_strings?(o)
-      o.is_a?(Array) && o.all? { |obj| obj.is_a?(String) }
-    end
-
     def build_order(arel)
       orders = order_values.uniq
       orders.reject!(&:blank?)
@@ -1159,18 +1093,18 @@ module ActiveRecord
       end
     end
 
-    # This function is recursive just for better readablity.
-    # #where argument doesn't support more than one level nested hash in real world.
-    def add_relations_to_bind_values(attributes)
-      if attributes.is_a?(Hash)
-        attributes.each_value do |value|
-          if value.is_a?(ActiveRecord::Relation)
-            self.bind_values += value.bind_values
-          else
-            add_relations_to_bind_values(value)
-          end
-        end
-      end
+    def new_where_clause
+      Relation::WhereClause.empty
+    end
+    alias new_having_clause new_where_clause
+
+    def where_clause_factory
+      @where_clause_factory ||= Relation::WhereClauseFactory.new(klass, predicate_builder)
+    end
+    alias having_clause_factory where_clause_factory
+
+    def new_from_clause
+      Relation::FromClause.empty
     end
   end
 end
diff --git a/activerecord/lib/active_record/relation/spawn_methods.rb b/activerecord/lib/active_record/relation/spawn_methods.rb
index 01bddea6c9..dd3610d7aa 100644
--- a/activerecord/lib/active_record/relation/spawn_methods.rb
+++ b/activerecord/lib/active_record/relation/spawn_methods.rb
@@ -58,9 +58,6 @@ module ActiveRecord
     #   Post.order('id asc').only(:where)         # discards the order condition
     #   Post.order('id asc').only(:where, :order) # uses the specified order
     def only(*onlies)
-      if onlies.any? { |o| o == :where }
-        onlies << :bind
-      end
       relation_with values.slice(*onlies)
     end
 
diff --git a/activerecord/lib/active_record/relation/where_clause.rb b/activerecord/lib/active_record/relation/where_clause.rb
new file mode 100644
index 0000000000..f9b9e640ec
--- /dev/null
+++ b/activerecord/lib/active_record/relation/where_clause.rb
@@ -0,0 +1,173 @@
+module ActiveRecord
+  class Relation
+    class WhereClause # :nodoc:
+      attr_reader :binds
+
+      delegate :any?, :empty?, to: :predicates
+
+      def initialize(predicates, binds)
+        @predicates = predicates
+        @binds = binds
+      end
+
+      def +(other)
+        WhereClause.new(
+          predicates + other.predicates,
+          binds + other.binds,
+        )
+      end
+
+      def merge(other)
+        WhereClause.new(
+          predicates_unreferenced_by(other) + other.predicates,
+          non_conflicting_binds(other) + other.binds,
+        )
+      end
+
+      def except(*columns)
+        WhereClause.new(
+          predicates_except(columns),
+          binds_except(columns),
+        )
+      end
+
+      def or(other)
+        if empty?
+          self
+        elsif other.empty?
+          other
+        else
+          WhereClause.new(
+            [ast.or(other.ast)],
+            binds + other.binds
+          )
+        end
+      end
+
+      def to_h(table_name = nil)
+        equalities = predicates.grep(Arel::Nodes::Equality)
+        if table_name
+          equalities = equalities.select do |node|
+            node.left.relation.name == table_name
+          end
+        end
+
+        binds = self.binds.map { |attr| [attr.name, attr.value] }.to_h
+
+        equalities.map { |node|
+          name = node.left.name
+          [name, binds.fetch(name.to_s) {
+            case node.right
+            when Array then node.right.map(&:val)
+            when Arel::Nodes::Casted, Arel::Nodes::Quoted
+              node.right.val
+            end
+          }]
+        }.to_h
+      end
+
+      def ast
+        Arel::Nodes::And.new(predicates_with_wrapped_sql_literals)
+      end
+
+      def ==(other)
+        other.is_a?(WhereClause) &&
+          predicates == other.predicates &&
+          binds == other.binds
+      end
+
+      def invert
+        WhereClause.new(inverted_predicates, binds)
+      end
+
+      def self.empty
+        new([], [])
+      end
+
+      protected
+
+      attr_reader :predicates
+
+      def referenced_columns
+        @referenced_columns ||= begin
+          equality_nodes = predicates.select { |n| equality_node?(n) }
+          Set.new(equality_nodes, &:left)
+        end
+      end
+
+      private
+
+      def predicates_unreferenced_by(other)
+        predicates.reject do |n|
+          equality_node?(n) && other.referenced_columns.include?(n.left)
+        end
+      end
+
+      def equality_node?(node)
+        node.respond_to?(:operator) && node.operator == :==
+      end
+
+      def non_conflicting_binds(other)
+        conflicts = referenced_columns & other.referenced_columns
+        conflicts.map! { |node| node.name.to_s }
+        binds.reject { |attr| conflicts.include?(attr.name) }
+      end
+
+      def inverted_predicates
+        predicates.map { |node| invert_predicate(node) }
+      end
+
+      def invert_predicate(node)
+        case node
+        when NilClass
+          raise ArgumentError, 'Invalid argument for .where.not(), got nil.'
+        when Arel::Nodes::In
+          Arel::Nodes::NotIn.new(node.left, node.right)
+        when Arel::Nodes::Equality
+          Arel::Nodes::NotEqual.new(node.left, node.right)
+        when String
+          Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new(node))
+        else
+          Arel::Nodes::Not.new(node)
+        end
+      end
+
+      def predicates_except(columns)
+        predicates.reject do |node|
+          case node
+          when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThanOrEqual
+            subrelation = (node.left.kind_of?(Arel::Attributes::Attribute) ? node.left : node.right)
+            columns.include?(subrelation.name.to_s)
+          end
+        end
+      end
+
+      def binds_except(columns)
+        binds.reject do |attr|
+          columns.include?(attr.name)
+        end
+      end
+
+      def predicates_with_wrapped_sql_literals
+        non_empty_predicates.map do |node|
+          if Arel::Nodes::Equality === node
+            node
+          else
+            wrap_sql_literal(node)
+          end
+        end
+      end
+
+      def non_empty_predicates
+        predicates - ['']
+      end
+
+      def wrap_sql_literal(node)
+        if ::String === node
+          node = Arel.sql(node)
+        end
+        Arel::Nodes::Grouping.new(node)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/relation/where_clause_factory.rb b/activerecord/lib/active_record/relation/where_clause_factory.rb
new file mode 100644
index 0000000000..0430922be3
--- /dev/null
+++ b/activerecord/lib/active_record/relation/where_clause_factory.rb
@@ -0,0 +1,34 @@
+module ActiveRecord
+  class Relation
+    class WhereClauseFactory
+      def initialize(klass, predicate_builder)
+        @klass = klass
+        @predicate_builder = predicate_builder
+      end
+
+      def build(opts, other)
+        binds = []
+
+        case opts
+        when String, Array
+          parts = [klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
+        when Hash
+          attributes = predicate_builder.resolve_column_aliases(opts)
+          attributes = klass.send(:expand_hash_conditions_for_aggregates, attributes)
+
+          attributes, binds = predicate_builder.create_binds(attributes)
+
+          parts = predicate_builder.build_from_hash(attributes)
+        else
+          parts = [opts]
+        end
+
+        WhereClause.new(parts, binds)
+      end
+
+      protected
+
+      attr_reader :klass, :predicate_builder
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/sanitization.rb b/activerecord/lib/active_record/sanitization.rb
index f5aa60a69a..313e767dcb 100644
--- a/activerecord/lib/active_record/sanitization.rb
+++ b/activerecord/lib/active_record/sanitization.rb
@@ -3,14 +3,11 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def quote_value(value, column) #:nodoc:
-        connection.quote(value, column)
-      end
-
       # Used to sanitize objects before they're used in an SQL SELECT statement. Delegates to <tt>connection.quote</tt>.
       def sanitize(object) #:nodoc:
         connection.quote(object)
       end
+      alias_method :quote_value, :sanitize
 
       protected
 
@@ -72,35 +69,6 @@ module ActiveRecord
         expanded_attrs
       end
 
-      # Sanitizes a hash of attribute/value pairs into SQL conditions for a WHERE clause.
-      #   { name: "foo'bar", group_id: 4 }
-      #     # => "name='foo''bar' and group_id= 4"
-      #   { status: nil, group_id: [1,2,3] }
-      #     # => "status IS NULL and group_id IN (1,2,3)"
-      #   { age: 13..18 }
-      #     # => "age BETWEEN 13 AND 18"
-      #   { 'other_records.id' => 7 }
-      #     # => "`other_records`.`id` = 7"
-      #   { other_records: { id: 7 } }
-      #     # => "`other_records`.`id` = 7"
-      # And for value objects on a composed_of relationship:
-      #   { address: Address.new("123 abc st.", "chicago") }
-      #     # => "address_street='123 abc st.' and address_city='chicago'"
-      def sanitize_sql_hash_for_conditions(attrs, default_table_name = self.table_name)
-        table = Arel::Table.new(table_name).alias(default_table_name)
-        predicate_builder = PredicateBuilder.new(TableMetadata.new(self, table))
-        ActiveSupport::Deprecation.warn(<<-EOWARN)
-sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
-        EOWARN
-        attrs = predicate_builder.resolve_column_aliases(attrs)
-        attrs = expand_hash_conditions_for_aggregates(attrs)
-
-        predicate_builder.build_from_hash(attrs).map { |b|
-          connection.visitor.compile b
-        }.join(' AND ')
-      end
-      alias_method :sanitize_sql_hash, :sanitize_sql_hash_for_conditions
-
       # Sanitizes a hash of attribute/value pairs into SQL conditions for a SET clause.
       #   { status: nil, group_id: 1 }
       #     # => "status = NULL , group_id = 1"
@@ -185,7 +153,7 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
 
     # TODO: Deprecate this
     def quoted_id
-      self.class.quote_value(id, column_for_attribute(self.class.primary_key))
+      self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
     end
   end
 end
diff --git a/activerecord/lib/active_record/secure_token.rb b/activerecord/lib/active_record/secure_token.rb
new file mode 100644
index 0000000000..07031b6371
--- /dev/null
+++ b/activerecord/lib/active_record/secure_token.rb
@@ -0,0 +1,39 @@
+module ActiveRecord
+  module SecureToken
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Example using has_secure_token
+      #
+      #   # Schema: User(token:string, auth_token:string)
+      #   class User < ActiveRecord::Base
+      #     has_secure_token
+      #     has_secure_token :auth_token
+      #   end
+      #
+      #   user = User.new
+      #   user.save
+      #   user.token # => "4kUgL2pdQMSCQtjE"
+      #   user.auth_token # => "77TMHrHJFvFDwodq8w7Ev2m7"
+      #   user.regenerate_token # => true
+      #   user.regenerate_auth_token # => true
+      #
+      # SecureRandom::base58 is used to generate the 24-character unique token, so collisions are highly unlikely.
+      #
+      # Note that it's still possible to generate a race condition in the database in the same way that
+      # validates_presence_of can. You're encouraged to add a unique index in the database to deal with
+      # this even more unlikely scenario.
+      def has_secure_token(attribute = :token)
+        # Load securerandom only when has_secure_token is used.
+        require 'active_support/core_ext/securerandom'
+        define_method("regenerate_#{attribute}") { update! attribute => self.class.generate_unique_secure_token }
+        before_create { self.send("#{attribute}=", self.class.generate_unique_secure_token) }
+      end
+
+      def generate_unique_secure_token
+        SecureRandom.base58(24)
+      end
+    end
+  end
+end
+
diff --git a/activerecord/lib/active_record/serializers/xml_serializer.rb b/activerecord/lib/active_record/serializers/xml_serializer.rb
index c2484d02ed..89b7e0be82 100644
--- a/activerecord/lib/active_record/serializers/xml_serializer.rb
+++ b/activerecord/lib/active_record/serializers/xml_serializer.rb
@@ -180,9 +180,9 @@ module ActiveRecord #:nodoc:
     class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:
       def compute_type
         klass = @serializable.class
-        column = klass.columns_hash[name] || Type::Value.new
+        cast_type = klass.type_for_attribute(name)
 
-        type = ActiveSupport::XmlMini::TYPE_NAMES[value.class.name] || column.type
+        type = ActiveSupport::XmlMini::TYPE_NAMES[value.class.name] || cast_type.type
 
         { :text => :string,
           :time => :datetime }[type] || type
diff --git a/activerecord/lib/active_record/statement_cache.rb b/activerecord/lib/active_record/statement_cache.rb
index 192a19f05d..95986c820c 100644
--- a/activerecord/lib/active_record/statement_cache.rb
+++ b/activerecord/lib/active_record/statement_cache.rb
@@ -47,8 +47,8 @@ module ActiveRecord
 
       def sql_for(binds, connection)
         val = @values.dup
-        binds = binds.dup
-        @indexes.each { |i| val[i] = connection.quote(*binds.shift.reverse) }
+        binds = connection.prepare_binds_for_database(binds)
+        @indexes.each { |i| val[i] = connection.quote(binds.shift) }
         val.join
       end
     end
@@ -67,21 +67,21 @@ module ActiveRecord
     end
 
     class BindMap # :nodoc:
-      def initialize(bind_values)
+      def initialize(bound_attributes)
         @indexes   = []
-        @bind_values = bind_values
+        @bound_attributes = bound_attributes
 
-        bind_values.each_with_index do |(_, value), i|
-          if Substitute === value
+        bound_attributes.each_with_index do |attr, i|
+          if Substitute === attr.value
             @indexes << i
           end
         end
       end
 
       def bind(values)
-        bvs = @bind_values.map(&:dup)
-        @indexes.each_with_index { |offset,i| bvs[offset][1] = values[i] }
-        bvs
+        bas = @bound_attributes.dup
+        @indexes.each_with_index { |offset,i| bas[offset] = bas[offset].with_cast_value(values[i]) }
+        bas
       end
     end
 
@@ -89,7 +89,7 @@ module ActiveRecord
 
     def self.create(connection, block = Proc.new)
       relation      = block.call Params.new
-      bind_map      = BindMap.new relation.bind_values
+      bind_map      = BindMap.new relation.bound_attributes
       query_builder = connection.cacheable_query relation.arel
       new query_builder, bind_map
     end
diff --git a/activerecord/lib/active_record/table_metadata.rb b/activerecord/lib/active_record/table_metadata.rb
index 11e33e8dfe..6c8792ee80 100644
--- a/activerecord/lib/active_record/table_metadata.rb
+++ b/activerecord/lib/active_record/table_metadata.rb
@@ -22,6 +22,14 @@ module ActiveRecord
       arel_table[column_name]
     end
 
+    def type(column_name)
+      if klass
+        klass.type_for_attribute(column_name.to_s)
+      else
+        Type::Value.new
+      end
+    end
+
     def associated_with?(association_name)
       klass && klass._reflect_on_association(association_name)
     end
@@ -34,7 +42,7 @@ module ActiveRecord
         association_klass = association.klass
         arel_table = association_klass.arel_table
       else
-        type_caster = TypeCaster::Connection.new(klass.connection, table_name)
+        type_caster = TypeCaster::Connection.new(klass, table_name)
         association_klass = nil
         arel_table = Arel::Table.new(table_name, type_caster: type_caster)
       end
diff --git a/activerecord/lib/active_record/transactions.rb b/activerecord/lib/active_record/transactions.rb
index de701edca0..0fd2862b2c 100644
--- a/activerecord/lib/active_record/transactions.rb
+++ b/activerecord/lib/active_record/transactions.rb
@@ -4,24 +4,10 @@ module ActiveRecord
     extend ActiveSupport::Concern
     #:nodoc:
     ACTIONS = [:create, :destroy, :update]
-    #:nodoc:
-    CALLBACK_WARN_MESSAGE = "Currently, Active Record suppresses errors raised " \
-      "within `after_rollback`/`after_commit` callbacks and only print them to " \
-      "the logs. In the next version, these errors will no longer be suppressed. " \
-      "Instead, the errors will propagate normally just like in other Active " \
-      "Record callbacks.\n" \
-      "\n" \
-      "You can opt into the new behavior and remove this warning by setting:\n" \
-      "\n" \
-      "  config.active_record.raise_in_transactional_callbacks = true\n\n"
 
     included do
       define_callbacks :commit, :rollback,
-                       terminator: ->(_, result) { result == false },
                        scope: [:kind, :name]
-
-      mattr_accessor :raise_in_transactional_callbacks, instance_writer: false
-      self.raise_in_transactional_callbacks = false
     end
 
     # = Active Record Transactions
@@ -237,9 +223,6 @@ module ActiveRecord
       def after_commit(*args, &block)
         set_options_for_callbacks!(args)
         set_callback(:commit, :after, *args, &block)
-        unless ActiveRecord::Base.raise_in_transactional_callbacks
-          ActiveSupport::Deprecation.warn(CALLBACK_WARN_MESSAGE)
-        end
       end
 
       # This callback is called after a create, update, or destroy are rolled back.
@@ -248,9 +231,16 @@ module ActiveRecord
       def after_rollback(*args, &block)
         set_options_for_callbacks!(args)
         set_callback(:rollback, :after, *args, &block)
-        unless ActiveRecord::Base.raise_in_transactional_callbacks
-          ActiveSupport::Deprecation.warn(CALLBACK_WARN_MESSAGE)
-        end
+      end
+
+      def raise_in_transactional_callbacks
+        ActiveSupport::Deprecation.warn('ActiveRecord::Base.raise_in_transactional_callbacks is deprecated and will be removed without replacement.')
+        true
+      end
+
+      def raise_in_transactional_callbacks=(value)
+        ActiveSupport::Deprecation.warn('ActiveRecord::Base.raise_in_transactional_callbacks= is deprecated, has no effect and will be removed without replacement.')
+        value
       end
 
       private
@@ -310,7 +300,7 @@ module ActiveRecord
     #
     # Ensure that it is not called if the object was never persisted (failed create),
     # but call it after the commit of a destroyed object.
-    def committed!(should_run_callbacks = true) #:nodoc:
+    def committed!(should_run_callbacks: true) #:nodoc:
       _run_commit_callbacks if should_run_callbacks && destroyed? || persisted?
     ensure
       force_clear_transaction_record_state
@@ -318,7 +308,7 @@ module ActiveRecord
 
     # Call the +after_rollback+ callbacks. The +force_restore_state+ argument indicates if the record
     # state should be rolled back to the beginning or just to the last savepoint.
-    def rolledback!(force_restore_state = false, should_run_callbacks = true) #:nodoc:
+    def rolledback!(force_restore_state: false, should_run_callbacks: true) #:nodoc:
       _run_rollback_callbacks if should_run_callbacks
     ensure
       restore_transaction_record_state(force_restore_state)
@@ -388,7 +378,7 @@ module ActiveRecord
           thaw unless restore_state[:frozen?]
           @new_record = restore_state[:new_record]
           @destroyed  = restore_state[:destroyed]
-          write_attribute(self.class.primary_key, restore_state[:id])
+          write_attribute(self.class.primary_key, restore_state[:id]) if self.class.primary_key
         end
       end
     end
diff --git a/activerecord/lib/active_record/type/boolean.rb b/activerecord/lib/active_record/type/boolean.rb
index 978d16d524..f6a75512fd 100644
--- a/activerecord/lib/active_record/type/boolean.rb
+++ b/activerecord/lib/active_record/type/boolean.rb
@@ -10,19 +10,8 @@ module ActiveRecord
       def cast_value(value)
         if value == ''
           nil
-        elsif ConnectionAdapters::Column::TRUE_VALUES.include?(value)
-          true
         else
-          if !ConnectionAdapters::Column::FALSE_VALUES.include?(value)
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              You attempted to assign a value which is not explicitly `true` or `false`
-              to a boolean column. Currently this value casts to `false`. This will
-              change to match Ruby's semantics, and will cast to `true` in Rails 5.
-              If you would like to maintain the current behavior, you should
-              explicitly handle the values you would like cast to `false`.
-            MSG
-          end
-          false
+          !ConnectionAdapters::Column::FALSE_VALUES.include?(value)
         end
       end
     end
diff --git a/activerecord/lib/active_record/type/integer.rb b/activerecord/lib/active_record/type/integer.rb
index fc260a081a..90ca9f88da 100644
--- a/activerecord/lib/active_record/type/integer.rb
+++ b/activerecord/lib/active_record/type/integer.rb
@@ -3,6 +3,10 @@ module ActiveRecord
     class Integer < Value # :nodoc:
       include Numeric
 
+      # Column storage size in bytes.
+      # 4 bytes means a MySQL int or Postgres integer as opposed to smallint etc.
+      DEFAULT_LIMIT = 4
+
       def initialize(*)
         super
         @range = min_value...max_value
@@ -12,13 +16,19 @@ module ActiveRecord
         :integer
       end
 
-      alias type_cast_for_database type_cast
-
       def type_cast_from_database(value)
         return if value.nil?
         value.to_i
       end
 
+      def type_cast_for_database(value)
+        result = type_cast(value)
+        if result
+          ensure_in_range(result)
+        end
+        result
+      end
+
       protected
 
       attr_reader :range
@@ -30,20 +40,18 @@ module ActiveRecord
         when true then 1
         when false then 0
         else
-          result = value.to_i rescue nil
-          ensure_in_range(result) if result
-          result
+          value.to_i rescue nil
         end
       end
 
       def ensure_in_range(value)
         unless range.cover?(value)
-          raise RangeError, "#{value} is out of range for #{self.class} with limit #{limit || 4}"
+          raise RangeError, "#{value} is out of range for #{self.class} with limit #{limit || DEFAULT_LIMIT}"
         end
       end
 
       def max_value
-        limit = self.limit || 4
+        limit = self.limit || DEFAULT_LIMIT
         1 << (limit * 8 - 1) # 8 bits per byte with one bit for sign
       end
 
diff --git a/activerecord/lib/active_record/type/time.rb b/activerecord/lib/active_record/type/time.rb
index 41f7d97f0c..cab1c7bf1e 100644
--- a/activerecord/lib/active_record/type/time.rb
+++ b/activerecord/lib/active_record/type/time.rb
@@ -7,6 +7,19 @@ module ActiveRecord
         :time
       end
 
+      def user_input_in_time_zone(value)
+        return unless value.present?
+
+        case value
+        when ::String
+          value = "2000-01-01 #{value}"
+        when ::Time
+          value = value.change(year: 2000, day: 1, month: 1)
+        end
+
+        super(value)
+      end
+
       private
 
       def cast_value(value)
diff --git a/activerecord/lib/active_record/type/time_value.rb b/activerecord/lib/active_record/type/time_value.rb
index d611d72dd4..8d9ac25643 100644
--- a/activerecord/lib/active_record/type/time_value.rb
+++ b/activerecord/lib/active_record/type/time_value.rb
@@ -9,6 +9,10 @@ module ActiveRecord
         "'#{value.to_s(:db)}'"
       end
 
+      def user_input_in_time_zone(value)
+        value.in_time_zone
+      end
+
       private
 
       def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
diff --git a/activerecord/lib/active_record/type/value.rb b/activerecord/lib/active_record/type/value.rb
index 60ae47db3d..859b51ca90 100644
--- a/activerecord/lib/active_record/type/value.rb
+++ b/activerecord/lib/active_record/type/value.rb
@@ -3,8 +3,7 @@ module ActiveRecord
     class Value # :nodoc:
       attr_reader :precision, :scale, :limit
 
-      # Valid options are +precision+, +scale+, and +limit+. They are only
-      # used when dumping schema.
+      # Valid options are +precision+, +scale+, and +limit+.
       def initialize(options = {})
         options.assert_valid_keys(:precision, :scale, :limit)
         @precision = options[:precision]
diff --git a/activerecord/lib/active_record/type_caster/connection.rb b/activerecord/lib/active_record/type_caster/connection.rb
index 9e4a130b40..3878270770 100644
--- a/activerecord/lib/active_record/type_caster/connection.rb
+++ b/activerecord/lib/active_record/type_caster/connection.rb
@@ -1,34 +1,29 @@
 module ActiveRecord
   module TypeCaster
     class Connection
-      def initialize(connection, table_name)
-        @connection = connection
+      def initialize(klass, table_name)
+        @klass = klass
         @table_name = table_name
       end
 
       def type_cast_for_database(attribute_name, value)
         return value if value.is_a?(Arel::Nodes::BindParam)
-        type = type_for(attribute_name)
-        type.type_cast_for_database(value)
+        column = column_for(attribute_name)
+        connection.type_cast_from_column(column, value)
       end
 
       protected
 
-      attr_reader :connection, :table_name
+      attr_reader :table_name
+      delegate :connection, to: :@klass
 
       private
 
-      def type_for(attribute_name)
+      def column_for(attribute_name)
         if connection.schema_cache.table_exists?(table_name)
-          column_for(attribute_name).cast_type
-        else
-          Type::Value.new
+          connection.schema_cache.columns_hash(table_name)[attribute_name.to_s]
         end
       end
-
-      def column_for(attribute_name)
-        connection.schema_cache.columns_hash(table_name)[attribute_name.to_s]
-      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/validations/uniqueness.rb b/activerecord/lib/active_record/validations/uniqueness.rb
index f52f91e89c..8f7a46f2c7 100644
--- a/activerecord/lib/active_record/validations/uniqueness.rb
+++ b/activerecord/lib/active_record/validations/uniqueness.rb
@@ -59,7 +59,8 @@ module ActiveRecord
         end
 
         column = klass.columns_hash[attribute_name]
-        value = klass.type_for_attribute(attribute_name).type_cast_for_database(value)
+        cast_type = klass.type_for_attribute(attribute_name)
+        value = cast_type.type_cast_for_database(value)
         value = klass.connection.type_cast(value)
         if value.is_a?(String) && column.limit
           value = value.to_s[0, column.limit]
@@ -67,7 +68,7 @@ module ActiveRecord
 
         value = Arel::Nodes::Quoted.new(value)
 
-        comparison = if !options[:case_sensitive] && value && column.text?
+        comparison = if !options[:case_sensitive] && value && cast_type.text?
           # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
           klass.connection.case_insensitive_comparison(table, attribute, column, value)
         else
diff --git a/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb b/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb
index f7bf6987c4..5b3e57dcf6 100644
--- a/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb
+++ b/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb
@@ -4,14 +4,19 @@ class <%= migration_class_name %> < ActiveRecord::Migration
 <% attributes.each do |attribute| -%>
 <% if attribute.password_digest? -%>
       t.string :password_digest<%= attribute.inject_options %>
+<% elsif attribute.token? -%>
+      t.string :<%= attribute.name %><%= attribute.inject_options %>
 <% else -%>
       t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
 <% end -%>
 <% end -%>
 <% if options[:timestamps] %>
-      t.timestamps null: false
+      t.timestamps
 <% end -%>
     end
+<% attributes.select(&:token?).each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>, unique: true
+<% end -%>
 <% attributes_with_index.each do |attribute| -%>
     add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
 <% end -%>
diff --git a/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb b/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb
index ae9c74fd05..23a377db6a 100644
--- a/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb
+++ b/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb
@@ -4,6 +4,9 @@ class <%= migration_class_name %> < ActiveRecord::Migration
 <% attributes.each do |attribute| -%>
   <%- if attribute.reference? -%>
     add_reference :<%= table_name %>, :<%= attribute.name %><%= attribute.inject_options %>
+  <%- elsif attribute.token? -%>
+    add_column :<%= table_name %>, :<%= attribute.name %>, :string<%= attribute.inject_options %>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>, unique: true
   <%- else -%>
     add_column :<%= table_name %>, :<%= attribute.name %>, :<%= attribute.type %><%= attribute.inject_options %>
     <%- if attribute.has_index? -%>
diff --git a/activerecord/lib/rails/generators/active_record/model/templates/model.rb b/activerecord/lib/rails/generators/active_record/model/templates/model.rb
index 539d969fce..55dc65c8ad 100644
--- a/activerecord/lib/rails/generators/active_record/model/templates/model.rb
+++ b/activerecord/lib/rails/generators/active_record/model/templates/model.rb
@@ -3,6 +3,9 @@ class <%= class_name %> < <%= parent_class_name.classify %>
 <% attributes.select(&:reference?).each do |attribute| -%>
   belongs_to :<%= attribute.name %><%= ', polymorphic: true' if attribute.polymorphic? %><%= ', required: true' if attribute.required? %>
 <% end -%>
+<% attributes.select(&:token?).each do |attribute| -%>
+  has_secure_token<% if attribute.name != "token" %> :<%= attribute.name %><% end %>
+<% end -%>
 <% if attributes.any?(&:password_digest?) -%>
   has_secure_password
 <% end -%>
diff --git a/activerecord/test/active_record/connection_adapters/fake_adapter.rb b/activerecord/test/active_record/connection_adapters/fake_adapter.rb
index 64cde143a1..ad9279aaca 100644
--- a/activerecord/test/active_record/connection_adapters/fake_adapter.rb
+++ b/activerecord/test/active_record/connection_adapters/fake_adapter.rb
@@ -22,7 +22,7 @@ module ActiveRecord
       end
 
       def primary_key(table)
-        @primary_keys[table]
+        @primary_keys[table] || "id"
       end
 
       def merge_column(table_name, name, sql_type = nil, options = {})
@@ -38,6 +38,10 @@ module ActiveRecord
         @columns[table_name]
       end
 
+      def table_exists?(*)
+        true
+      end
+
       def active?
         true
       end
diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index 99e3d7021d..ecf1368a91 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -193,7 +193,7 @@ module ActiveRecord
       author = Author.create!(name: 'john')
       Post.create!(author: author, title: 'foo', body: 'bar')
       query = author.posts.where(title: 'foo').select(:title)
-      assert_equal({"title" => "foo"}, @connection.select_one(query.arel, nil, query.bind_values))
+      assert_equal({"title" => "foo"}, @connection.select_one(query.arel, nil, query.bound_attributes))
       assert_equal({"title" => "foo"}, @connection.select_one(query))
       assert @connection.select_all(query).is_a?(ActiveRecord::Result)
       assert_equal "foo", @connection.select_value(query)
@@ -203,7 +203,7 @@ module ActiveRecord
     def test_select_methods_passing_a_relation
       Post.create!(title: 'foo', body: 'bar')
       query = Post.where(title: 'foo').select(:title)
-      assert_equal({"title" => "foo"}, @connection.select_one(query.arel, nil, query.bind_values))
+      assert_equal({"title" => "foo"}, @connection.select_one(query.arel, nil, query.bound_attributes))
       assert_equal({"title" => "foo"}, @connection.select_one(query))
       assert @connection.select_all(query).is_a?(ActiveRecord::Result)
       assert_equal "foo", @connection.select_value(query)
diff --git a/activerecord/test/cases/adapters/mysql/connection_test.rb b/activerecord/test/cases/adapters/mysql/connection_test.rb
index ce01b16362..4762ef43b5 100644
--- a/activerecord/test/cases/adapters/mysql/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql/connection_test.rb
@@ -94,7 +94,7 @@ class MysqlConnectionTest < ActiveRecord::TestCase
     with_example_table do
       @connection.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
       result = @connection.exec_query(
-        'SELECT id, data FROM ex WHERE id = ?', nil, [[nil, 1]])
+        'SELECT id, data FROM ex WHERE id = ?', nil, [ActiveRecord::Relation::QueryAttribute.new("id", 1, ActiveRecord::Type::Value.new)])
 
       assert_equal 1, result.rows.length
       assert_equal 2, result.columns.length
@@ -106,10 +106,10 @@ class MysqlConnectionTest < ActiveRecord::TestCase
   def test_exec_typecasts_bind_vals
     with_example_table do
       @connection.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
-      column = @connection.columns('ex').find { |col| col.name == 'id' }
+      bind = ActiveRecord::Relation::QueryAttribute.new("id", "1-fuu", ActiveRecord::Type::Integer.new)
 
       result = @connection.exec_query(
-        'SELECT id, data FROM ex WHERE id = ?', nil, [[column, '1-fuu']])
+        'SELECT id, data FROM ex WHERE id = ?', nil, [bind])
 
       assert_equal 1, result.rows.length
       assert_equal 2, result.columns.length
diff --git a/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb b/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
index 85db8f4614..1e6511620a 100644
--- a/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
@@ -129,10 +129,10 @@ module ActiveRecord
 
       private
       def insert(ctx, data, table='ex')
-        binds   = data.map { |name, value|
-          [ctx.columns(table).find { |x| x.name == name }, value]
+        binds = data.map { |name, value|
+          Relation::QueryAttribute.new(name, value, Type::Value.new)
         }
-        columns = binds.map(&:first).map(&:name)
+        columns = binds.map(&:name)
 
         sql = "INSERT INTO #{table} (#{columns.join(", ")})
                VALUES (#{(['?'] * columns.length).join(', ')})"
diff --git a/activerecord/test/cases/adapters/mysql2/schema_migrations_test.rb b/activerecord/test/cases/adapters/mysql2/schema_migrations_test.rb
index 9c49599d34..06b0cb5515 100644
--- a/activerecord/test/cases/adapters/mysql2/schema_migrations_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/schema_migrations_test.rb
@@ -16,7 +16,7 @@ module ActiveRecord
 
         def test_initializes_schema_migrations_for_encoding_utf8mb4
           smtn = ActiveRecord::Migrator.schema_migrations_table_name
-          connection.drop_table(smtn) if connection.table_exists?(smtn)
+          connection.drop_table smtn, if_exists: true
 
           config = connection.instance_variable_get(:@config)
           original_encoding = config[:encoding]
diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index 042beab23f..b908b9b394 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -25,6 +25,7 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
       end
     end
     @column = PgArray.columns_hash['tags']
+    @type = PgArray.type_for_attribute("tags")
   end
 
   teardown do
@@ -35,14 +36,15 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
   def test_column
     assert_equal :string, @column.type
     assert_equal "character varying", @column.sql_type
-    assert @column.array
-    assert_not @column.number?
-    assert_not @column.binary?
+    assert @column.array?
+    assert_not @type.number?
+    assert_not @type.binary?
 
     ratings_column = PgArray.columns_hash['ratings']
     assert_equal :integer, ratings_column.type
-    assert ratings_column.array
-    assert_not ratings_column.number?
+    type = PgArray.type_for_attribute("ratings")
+    assert ratings_column.array?
+    assert_not type.number?
   end
 
   def test_default
@@ -74,7 +76,7 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
 
     assert_equal :text, column.type
     assert_equal [], PgArray.column_defaults['snippets']
-    assert column.array
+    assert column.array?
   end
 
   def test_change_column_cant_make_non_array_column_to_array
@@ -94,9 +96,9 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
   end
 
   def test_type_cast_array
-    assert_equal(['1', '2', '3'], @column.type_cast_from_database('{1,2,3}'))
-    assert_equal([], @column.type_cast_from_database('{}'))
-    assert_equal([nil], @column.type_cast_from_database('{NULL}'))
+    assert_equal(['1', '2', '3'], @type.type_cast_from_database('{1,2,3}'))
+    assert_equal([], @type.type_cast_from_database('{}'))
+    assert_equal([nil], @type.type_cast_from_database('{NULL}'))
   end
 
   def test_type_cast_integers
@@ -112,8 +114,8 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
 
   def test_schema_dump_with_shorthand
     output = dump_table_schema "pg_arrays"
-    assert_match %r[t.string\s+"tags",\s+array: true], output
-    assert_match %r[t.integer\s+"ratings",\s+array: true], output
+    assert_match %r[t\.string\s+"tags",\s+array: true], output
+    assert_match %r[t\.integer\s+"ratings",\s+array: true], output
   end
 
   def test_select_with_strings
@@ -208,7 +210,7 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
     x = PgArray.create!(tags: tags)
     x.reload
 
-    assert_equal x.tags_before_type_cast, PgArray.columns_hash['tags'].type_cast_for_database(tags)
+    assert_equal x.tags_before_type_cast, PgArray.type_for_attribute('tags').type_cast_for_database(tags)
   end
 
   def test_quoting_non_standard_delimiters
diff --git a/activerecord/test/cases/adapters/postgresql/bit_string_test.rb b/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
index 72222c01fd..ad433b9d1b 100644
--- a/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
@@ -26,18 +26,22 @@ class PostgresqlBitStringTest < ActiveRecord::TestCase
     column = PostgresqlBitString.columns_hash["a_bit"]
     assert_equal :bit, column.type
     assert_equal "bit(8)", column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = PostgresqlBitString.type_for_attribute("a_bit")
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_bit_string_varying_column
     column = PostgresqlBitString.columns_hash["a_bit_varying"]
     assert_equal :bit_varying, column.type
     assert_equal "bit varying(4)", column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = PostgresqlBitString.type_for_attribute("a_bit_varying")
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_default
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
index aeebec034d..99a7e88178 100644
--- a/activerecord/test/cases/adapters/postgresql/bytea_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
@@ -17,6 +17,7 @@ class PostgresqlByteaTest < ActiveRecord::TestCase
       end
     end
     @column = ByteaDataType.columns_hash['payload']
+    @type = ByteaDataType.type_for_attribute("payload")
   end
 
   teardown do
@@ -40,16 +41,16 @@ class PostgresqlByteaTest < ActiveRecord::TestCase
 
     data = "\u001F\x8B"
     assert_equal('UTF-8', data.encoding.name)
-    assert_equal('ASCII-8BIT', @column.type_cast_from_database(data).encoding.name)
+    assert_equal('ASCII-8BIT', @type.type_cast_from_database(data).encoding.name)
   end
 
   def test_type_cast_binary_value
     data = "\u001F\x8B".force_encoding("BINARY")
-    assert_equal(data, @column.type_cast_from_database(data))
+    assert_equal(data, @type.type_cast_from_database(data))
   end
 
   def test_type_case_nil
-    assert_equal(nil, @column.type_cast_from_database(nil))
+    assert_equal(nil, @type.type_cast_from_database(nil))
   end
 
   def test_read_value
diff --git a/activerecord/test/cases/adapters/postgresql/citext_test.rb b/activerecord/test/cases/adapters/postgresql/citext_test.rb
index 85bff979c9..d7e611ac46 100644
--- a/activerecord/test/cases/adapters/postgresql/citext_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/citext_test.rb
@@ -32,9 +32,11 @@ if ActiveRecord::Base.connection.supports_extensions?
       column = Citext.columns_hash['cival']
       assert_equal :citext, column.type
       assert_equal 'citext', column.sql_type
-      assert_not column.number?
-      assert_not column.binary?
-      assert_not column.array
+      assert_not column.array?
+
+      type = Citext.type_for_attribute('cival')
+      assert_not type.number?
+      assert_not type.binary?
     end
 
     def test_change_table_supports_json
@@ -72,7 +74,7 @@ if ActiveRecord::Base.connection.supports_extensions?
 
     def test_schema_dump_with_shorthand
       output = dump_table_schema("citexts")
-      assert_match %r[t.citext "cival"], output
+      assert_match %r[t\.citext "cival"], output
     end
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/composite_test.rb b/activerecord/test/cases/adapters/postgresql/composite_test.rb
index cfab5ca902..be0025218e 100644
--- a/activerecord/test/cases/adapters/postgresql/composite_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/composite_test.rb
@@ -50,9 +50,11 @@ class PostgresqlCompositeTest < ActiveRecord::TestCase
     column = PostgresqlComposite.columns_hash["address"]
     assert_nil column.type
     assert_equal "full_address", column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = PostgresqlComposite.type_for_attribute("address")
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_composite_mapping
@@ -111,9 +113,11 @@ class PostgresqlCompositeWithCustomOIDTest < ActiveRecord::TestCase
     column = PostgresqlComposite.columns_hash["address"]
     assert_equal :full_address, column.type
     assert_equal "full_address", column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = PostgresqlComposite.type_for_attribute("address")
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_composite_mapping
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index ab7fd3c6d5..7bf8d12eae 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -126,11 +126,11 @@ module ActiveRecord
     end
 
     def test_statement_key_is_logged
-      bindval = 1
-      @connection.exec_query('SELECT $1::integer', 'SQL', [[nil, bindval]])
+      bind = Relation::QueryAttribute.new(nil, 1, Type::Value.new)
+      @connection.exec_query('SELECT $1::integer', 'SQL', [bind])
       name = @subscriber.payloads.last[:statement_name]
       assert name
-      res = @connection.exec_query("EXPLAIN (FORMAT JSON) EXECUTE #{name}(#{bindval})")
+      res = @connection.exec_query("EXPLAIN (FORMAT JSON) EXECUTE #{name}(1)")
       plan = res.column_types['QUERY PLAN'].type_cast_from_database res.rows.first.first
       assert_operator plan.length, :>, 0
     end
diff --git a/activerecord/test/cases/adapters/postgresql/domain_test.rb b/activerecord/test/cases/adapters/postgresql/domain_test.rb
index 1500adb42d..d0d70122e9 100644
--- a/activerecord/test/cases/adapters/postgresql/domain_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/domain_test.rb
@@ -29,9 +29,11 @@ class PostgresqlDomainTest < ActiveRecord::TestCase
     column = PostgresqlDomain.columns_hash["price"]
     assert_equal :decimal, column.type
     assert_equal "custom_money", column.sql_type
-    assert column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = PostgresqlDomain.type_for_attribute("price")
+    assert type.number?
+    assert_not type.binary?
   end
 
   def test_domain_acts_like_basetype
diff --git a/activerecord/test/cases/adapters/postgresql/enum_test.rb b/activerecord/test/cases/adapters/postgresql/enum_test.rb
index 83cedc5a7b..dab3f92ab2 100644
--- a/activerecord/test/cases/adapters/postgresql/enum_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/enum_test.rb
@@ -31,9 +31,11 @@ class PostgresqlEnumTest < ActiveRecord::TestCase
     column = PostgresqlEnum.columns_hash["current_mood"]
     assert_equal :enum, column.type
     assert_equal "mood", column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = PostgresqlEnum.type_for_attribute("current_mood")
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_enum_defaults
diff --git a/activerecord/test/cases/adapters/postgresql/full_text_test.rb b/activerecord/test/cases/adapters/postgresql/full_text_test.rb
index dca35422b9..a38291cb0a 100644
--- a/activerecord/test/cases/adapters/postgresql/full_text_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/full_text_test.rb
@@ -21,9 +21,11 @@ class PostgresqlFullTextTest < ActiveRecord::TestCase
     column = Tsvector.columns_hash["text_vector"]
     assert_equal :tsvector, column.type
     assert_equal "tsvector", column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = Tsvector.type_for_attribute("text_vector")
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_update_tsvector
@@ -39,6 +41,6 @@ class PostgresqlFullTextTest < ActiveRecord::TestCase
 
   def test_schema_dump_with_shorthand
     output = dump_table_schema("tsvectors")
-    assert_match %r{t.tsvector "text_vector"}, output
+    assert_match %r{t\.tsvector "text_vector"}, output
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/geometric_test.rb b/activerecord/test/cases/adapters/postgresql/geometric_test.rb
index 228221e034..39b8daaa83 100644
--- a/activerecord/test/cases/adapters/postgresql/geometric_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/geometric_test.rb
@@ -26,9 +26,11 @@ class PostgresqlPointTest < ActiveRecord::TestCase
     column = PostgresqlPoint.columns_hash["x"]
     assert_equal :point, column.type
     assert_equal "point", column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = PostgresqlPoint.type_for_attribute("x")
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_default
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 00ff456e16..7ed15b2be0 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -29,6 +29,7 @@ if ActiveRecord::Base.connection.supports_extensions?
         end
       end
       @column = Hstore.columns_hash['tags']
+      @type = Hstore.type_for_attribute("tags")
     end
 
     teardown do
@@ -54,9 +55,10 @@ if ActiveRecord::Base.connection.supports_extensions?
     def test_column
       assert_equal :hstore, @column.type
       assert_equal "hstore", @column.sql_type
-      assert_not @column.number?
-      assert_not @column.binary?
-      assert_not @column.array
+      assert_not @column.array?
+
+      assert_not @type.number?
+      assert_not @type.binary?
     end
 
     def test_default
@@ -110,10 +112,10 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_type_cast_hstore
-      assert_equal({'1' => '2'}, @column.type_cast_from_database("\"1\"=>\"2\""))
-      assert_equal({}, @column.type_cast_from_database(""))
-      assert_equal({'key'=>nil}, @column.type_cast_from_database('key => NULL'))
-      assert_equal({'c'=>'}','"a"'=>'b "a b'}, @column.type_cast_from_database(%q(c=>"}", "\"a\""=>"b \"a b")))
+      assert_equal({'1' => '2'}, @type.type_cast_from_database("\"1\"=>\"2\""))
+      assert_equal({}, @type.type_cast_from_database(""))
+      assert_equal({'key'=>nil}, @type.type_cast_from_database('key => NULL'))
+      assert_equal({'c'=>'}','"a"'=>'b "a b'}, @type.type_cast_from_database(%q(c=>"}", "\"a\""=>"b \"a b")))
     end
 
     def test_with_store_accessors
@@ -165,47 +167,47 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_gen1
-      assert_equal(%q(" "=>""), @column.cast_type.type_cast_for_database({' '=>''}))
+      assert_equal(%q(" "=>""), @type.type_cast_for_database({' '=>''}))
     end
 
     def test_gen2
-      assert_equal(%q(","=>""), @column.cast_type.type_cast_for_database({','=>''}))
+      assert_equal(%q(","=>""), @type.type_cast_for_database({','=>''}))
     end
 
     def test_gen3
-      assert_equal(%q("="=>""), @column.cast_type.type_cast_for_database({'='=>''}))
+      assert_equal(%q("="=>""), @type.type_cast_for_database({'='=>''}))
     end
 
     def test_gen4
-      assert_equal(%q(">"=>""), @column.cast_type.type_cast_for_database({'>'=>''}))
+      assert_equal(%q(">"=>""), @type.type_cast_for_database({'>'=>''}))
     end
 
     def test_parse1
-      assert_equal({'a'=>nil,'b'=>nil,'c'=>'NuLl','null'=>'c'}, @column.type_cast_from_database('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
+      assert_equal({'a'=>nil,'b'=>nil,'c'=>'NuLl','null'=>'c'}, @type.type_cast_from_database('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
     end
 
     def test_parse2
-      assert_equal({" " => " "},  @column.type_cast_from_database("\\ =>\\ "))
+      assert_equal({" " => " "},  @type.type_cast_from_database("\\ =>\\ "))
     end
 
     def test_parse3
-      assert_equal({"=" => ">"},  @column.type_cast_from_database("==>>"))
+      assert_equal({"=" => ">"},  @type.type_cast_from_database("==>>"))
     end
 
     def test_parse4
-      assert_equal({"=a"=>"q=w"},   @column.type_cast_from_database('\=a=>q=w'))
+      assert_equal({"=a"=>"q=w"},   @type.type_cast_from_database('\=a=>q=w'))
     end
 
     def test_parse5
-      assert_equal({"=a"=>"q=w"},   @column.type_cast_from_database('"=a"=>q\=w'))
+      assert_equal({"=a"=>"q=w"},   @type.type_cast_from_database('"=a"=>q\=w'))
     end
 
     def test_parse6
-      assert_equal({"\"a"=>"q>w"},  @column.type_cast_from_database('"\"a"=>q>w'))
+      assert_equal({"\"a"=>"q>w"},  @type.type_cast_from_database('"\"a"=>q>w'))
     end
 
     def test_parse7
-      assert_equal({"\"a"=>"q\"w"}, @column.type_cast_from_database('\"a=>q"w'))
+      assert_equal({"\"a"=>"q\"w"}, @type.type_cast_from_database('\"a=>q"w'))
     end
 
     def test_rewrite
@@ -317,7 +319,7 @@ if ActiveRecord::Base.connection.supports_extensions?
 
     def test_schema_dump_with_shorthand
       output = dump_table_schema("hstores")
-      assert_match %r[t.hstore "tags",\s+default: {}], output
+      assert_match %r[t\.hstore "tags",\s+default: {}], output
     end
 
     private
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index 340ca29c0e..ba72a1fdcb 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -34,9 +34,11 @@ module PostgresqlJSONSharedTestCases
     column = JsonDataType.columns_hash["payload"]
     assert_equal column_type, column.type
     assert_equal column_type.to_s, column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = JsonDataType.type_for_attribute("payload")
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_default
@@ -66,7 +68,7 @@ module PostgresqlJSONSharedTestCases
 
   def test_schema_dumping
     output = dump_table_schema("json_data_type")
-    assert_match(/t.#{column_type.to_s}\s+"payload",\s+default: {}/, output)
+    assert_match(/t\.#{column_type.to_s}\s+"payload",\s+default: {}/, output)
   end
 
   def test_cast_value_on_write
@@ -78,16 +80,16 @@ module PostgresqlJSONSharedTestCases
   end
 
   def test_type_cast_json
-    column = JsonDataType.columns_hash["payload"]
+    type = JsonDataType.type_for_attribute("payload")
 
     data = "{\"a_key\":\"a_value\"}"
-    hash = column.type_cast_from_database(data)
+    hash = type.type_cast_from_database(data)
     assert_equal({'a_key' => 'a_value'}, hash)
-    assert_equal({'a_key' => 'a_value'}, column.type_cast_from_database(data))
+    assert_equal({'a_key' => 'a_value'}, type.type_cast_from_database(data))
 
-    assert_equal({}, column.type_cast_from_database("{}"))
-    assert_equal({'key'=>nil}, column.type_cast_from_database('{"key": null}'))
-    assert_equal({'c'=>'}','"a"'=>'b "a b'}, column.type_cast_from_database(%q({"c":"}", "\"a\"":"b \"a b"})))
+    assert_equal({}, type.type_cast_from_database("{}"))
+    assert_equal({'key'=>nil}, type.type_cast_from_database('{"key": null}'))
+    assert_equal({'c'=>'}','"a"'=>'b "a b'}, type.type_cast_from_database(%q({"c":"}", "\"a\"":"b \"a b"})))
   end
 
   def test_rewrite
@@ -179,6 +181,14 @@ module PostgresqlJSONSharedTestCases
     assert_equal({ 'one' => 'two', 'three' => 'four' }, json.payload)
     assert_not json.changed?
   end
+
+  def test_assigning_invalid_json
+    json = JsonDataType.new
+
+    json.payload = 'foo'
+
+    assert_nil json.payload
+  end
 end
 
 class PostgresqlJSONTest < ActiveRecord::TestCase
diff --git a/activerecord/test/cases/adapters/postgresql/ltree_test.rb b/activerecord/test/cases/adapters/postgresql/ltree_test.rb
index 5a0f505072..cdc3269408 100644
--- a/activerecord/test/cases/adapters/postgresql/ltree_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/ltree_test.rb
@@ -30,9 +30,11 @@ class PostgresqlLtreeTest < ActiveRecord::TestCase
     column = Ltree.columns_hash['path']
     assert_equal :ltree, column.type
     assert_equal "ltree", column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = Ltree.type_for_attribute('path')
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_write
@@ -48,6 +50,6 @@ class PostgresqlLtreeTest < ActiveRecord::TestCase
 
   def test_schema_dump_with_shorthand
     output = dump_table_schema("ltrees")
-    assert_match %r[t.ltree "path"], output
+    assert_match %r[t\.ltree "path"], output
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/money_test.rb b/activerecord/test/cases/adapters/postgresql/money_test.rb
index 54cff192c1..ed1b7d0a1c 100644
--- a/activerecord/test/cases/adapters/postgresql/money_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/money_test.rb
@@ -25,9 +25,11 @@ class PostgresqlMoneyTest < ActiveRecord::TestCase
     assert_equal :money, column.type
     assert_equal "money", column.sql_type
     assert_equal 2, column.scale
-    assert column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = PostgresqlMoney.type_for_attribute("wealth")
+    assert type.number?
+    assert_not type.binary?
   end
 
   def test_default
@@ -46,17 +48,17 @@ class PostgresqlMoneyTest < ActiveRecord::TestCase
   end
 
   def test_money_type_cast
-    column = PostgresqlMoney.columns_hash['wealth']
-    assert_equal(12345678.12, column.type_cast_from_user("$12,345,678.12"))
-    assert_equal(12345678.12, column.type_cast_from_user("$12.345.678,12"))
-    assert_equal(-1.15, column.type_cast_from_user("-$1.15"))
-    assert_equal(-2.25, column.type_cast_from_user("($2.25)"))
+    type = PostgresqlMoney.type_for_attribute('wealth')
+    assert_equal(12345678.12, type.type_cast_from_user("$12,345,678.12"))
+    assert_equal(12345678.12, type.type_cast_from_user("$12.345.678,12"))
+    assert_equal(-1.15, type.type_cast_from_user("-$1.15"))
+    assert_equal(-2.25, type.type_cast_from_user("($2.25)"))
   end
 
   def test_schema_dumping
     output = dump_table_schema("postgresql_moneys")
     assert_match %r{t\.money\s+"wealth",\s+scale: 2$}, output
-    assert_match %r{t\.money\s+"depth",\s+scale: 2,\s+default: 150.55$}, output
+    assert_match %r{t\.money\s+"depth",\s+scale: 2,\s+default: 150\.55$}, output
   end
 
   def test_create_and_update_money
diff --git a/activerecord/test/cases/adapters/postgresql/network_test.rb b/activerecord/test/cases/adapters/postgresql/network_test.rb
index 4e49ea1e02..cb75faa1e5 100644
--- a/activerecord/test/cases/adapters/postgresql/network_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/network_test.rb
@@ -23,27 +23,33 @@ class PostgresqlNetworkTest < ActiveRecord::TestCase
     column = PostgresqlNetworkAddress.columns_hash["cidr_address"]
     assert_equal :cidr, column.type
     assert_equal "cidr", column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = PostgresqlNetworkAddress.type_for_attribute("cidr_address")
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_inet_column
     column = PostgresqlNetworkAddress.columns_hash["inet_address"]
     assert_equal :inet, column.type
     assert_equal "inet", column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = PostgresqlNetworkAddress.type_for_attribute("inet_address")
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_macaddr_column
     column = PostgresqlNetworkAddress.columns_hash["mac_address"]
     assert_equal :macaddr, column.type
     assert_equal "macaddr", column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = PostgresqlNetworkAddress.type_for_attribute("mac_address")
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_network_types
@@ -85,8 +91,8 @@ class PostgresqlNetworkTest < ActiveRecord::TestCase
 
   def test_schema_dump_with_shorthand
     output = dump_table_schema("postgresql_network_addresses")
-    assert_match %r{t.inet\s+"inet_address",\s+default: "192.168.1.1"}, output
-    assert_match %r{t.cidr\s+"cidr_address",\s+default: "192.168.1.0/24"}, output
-    assert_match %r{t.macaddr\s+"mac_address",\s+default: "ff:ff:ff:ff:ff:ff"}, output
+    assert_match %r{t\.inet\s+"inet_address",\s+default: "192\.168\.1\.1"}, output
+    assert_match %r{t\.cidr\s+"cidr_address",\s+default: "192\.168\.1\.0/24"}, output
+    assert_match %r{t\.macaddr\s+"mac_address",\s+default: "ff:ff:ff:ff:ff:ff"}, output
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index 6bb2b26cd5..15c2f48ede 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -284,7 +284,7 @@ module ActiveRecord
           string = @connection.quote('foo')
           @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
           result = @connection.exec_query(
-                                          'SELECT id, data FROM ex WHERE id = $1', nil, [[nil, 1]])
+                                          'SELECT id, data FROM ex WHERE id = $1', nil, [bind_param(1)])
 
           assert_equal 1, result.rows.length
           assert_equal 2, result.columns.length
@@ -298,9 +298,9 @@ module ActiveRecord
           string = @connection.quote('foo')
           @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
 
-          column = @connection.columns('ex').find { |col| col.name == 'id' }
+          bind = ActiveRecord::Relation::QueryAttribute.new("id", "1-fuu", ActiveRecord::Type::Integer.new)
           result = @connection.exec_query(
-                                          'SELECT id, data FROM ex WHERE id = $1', nil, [[column, '1-fuu']])
+                                          'SELECT id, data FROM ex WHERE id = $1', nil, [bind])
 
           assert_equal 1, result.rows.length
           assert_equal 2, result.columns.length
@@ -437,10 +437,10 @@ module ActiveRecord
 
       private
       def insert(ctx, data)
-        binds   = data.map { |name, value|
-          [ctx.columns('ex').find { |x| x.name == name }, value]
+        binds = data.map { |name, value|
+          bind_param(value, name)
         }
-        columns = binds.map(&:first).map(&:name)
+        columns = binds.map(&:name)
 
         bind_subs = columns.length.times.map { |x| "$#{x + 1}" }
 
@@ -457,6 +457,10 @@ module ActiveRecord
       def connection_without_insert_returning
         ActiveRecord::Base.postgresql_connection(ActiveRecord::Base.configurations['arunit'].merge(:insert_returning => false))
       end
+
+      def bind_param(value, name = nil)
+        ActiveRecord::Relation::QueryAttribute.new(name, value, ActiveRecord::Type::Value.new)
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/quoting_test.rb b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
index 9ac0036d66..894cf1ffa2 100644
--- a/activerecord/test/cases/adapters/postgresql/quoting_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
@@ -34,13 +34,14 @@ module ActiveRecord
 
         def test_quote_range
           range = "1,2]'; SELECT * FROM users; --".."a"
-          c = PostgreSQLColumn.new(nil, nil, OID::Range.new(Type::Integer.new, :int8range))
-          assert_equal "'[1,0]'", @conn.quote(range, c)
+          type = OID::Range.new(Type::Integer.new, :int8range)
+          assert_equal "'[1,0]'", @conn.quote(type.type_cast_for_database(range))
         end
 
         def test_quote_bit_string
-          c = PostgreSQLColumn.new(nil, 1, OID::Bit.new)
-          assert_equal nil, @conn.quote("'); SELECT * FROM users; /*\n01\n*/--", c)
+          value = "'); SELECT * FROM users; /*\n01\n*/--"
+          type = OID::Bit.new
+          assert_equal nil, @conn.quote(type.type_cast_for_database(value))
         end
       end
     end
diff --git a/activerecord/test/cases/adapters/postgresql/range_test.rb b/activerecord/test/cases/adapters/postgresql/range_test.rb
index d812cd01c4..70cf21100a 100644
--- a/activerecord/test/cases/adapters/postgresql/range_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/range_test.rb
@@ -230,36 +230,14 @@ _SQL
       assert_nil_round_trip(@first_range, :int8_range, 39999...39999)
     end
 
-    def test_exclude_beginning_for_subtypes_with_succ_method_is_deprecated
-      tz = ::ActiveRecord::Base.default_timezone
-
-      silence_warnings {
-        assert_deprecated {
-          range = PostgresqlRange.create!(date_range: "(''2012-01-02'', ''2012-01-04'']")
-          assert_equal Date.new(2012, 1, 3)..Date.new(2012, 1, 4), range.date_range
-        }
-        assert_deprecated {
-          range = PostgresqlRange.create!(ts_range: "(''2010-01-01 14:30'', ''2011-01-01 14:30'']")
-          assert_equal Time.send(tz, 2010, 1, 1, 14, 30, 1)..Time.send(tz, 2011, 1, 1, 14, 30, 0), range.ts_range
-        }
-        assert_deprecated {
-          range = PostgresqlRange.create!(tstz_range: "(''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'']")
-          assert_equal Time.parse('2010-01-01 09:30:01 UTC')..Time.parse('2011-01-01 17:30:00 UTC'), range.tstz_range
-        }
-        assert_deprecated {
-          range = PostgresqlRange.create!(int4_range: "(1, 10]")
-          assert_equal 2..10, range.int4_range
-        }
-        assert_deprecated {
-          range = PostgresqlRange.create!(int8_range: "(10, 100]")
-          assert_equal 11..100, range.int8_range
-        }
-      }
-    end
-
     def test_exclude_beginning_for_subtypes_without_succ_method_is_not_supported
       assert_raises(ArgumentError) { PostgresqlRange.create!(num_range: "(0.1, 0.2]") }
       assert_raises(ArgumentError) { PostgresqlRange.create!(float_range: "(0.5, 0.7]") }
+      assert_raises(ArgumentError) { PostgresqlRange.create!(int4_range: "(1, 10]") }
+      assert_raises(ArgumentError) { PostgresqlRange.create!(int8_range: "(10, 100]") }
+      assert_raises(ArgumentError) { PostgresqlRange.create!(date_range: "(''2012-01-02'', ''2012-01-04'']") }
+      assert_raises(ArgumentError) { PostgresqlRange.create!(ts_range: "(''2010-01-01 14:30'', ''2011-01-01 14:30'']") }
+      assert_raises(ArgumentError) { PostgresqlRange.create!(tstz_range: "(''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'']") }
     end
 
     def test_update_all_with_ranges
diff --git a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
index 99c26c4bf7..6937145439 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
@@ -55,7 +55,7 @@ class SchemaAuthorizationTest < ActiveRecord::TestCase
       set_session_auth
       USERS.each do |u|
         set_session_auth u
-        assert_equal u, @connection.exec_query("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [[nil, 1]]).first['name']
+        assert_equal u, @connection.exec_query("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [bind_param(1)]).first['name']
         set_session_auth
       end
     end
@@ -67,7 +67,7 @@ class SchemaAuthorizationTest < ActiveRecord::TestCase
       USERS.each do |u|
         @connection.clear_cache!
         set_session_auth u
-        assert_equal u, @connection.exec_query("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [[nil, 1]]).first['name']
+        assert_equal u, @connection.exec_query("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [bind_param(1)]).first['name']
         set_session_auth
       end
     end
@@ -111,4 +111,7 @@ class SchemaAuthorizationTest < ActiveRecord::TestCase
        @connection.session_auth =  auth || 'default'
     end
 
+    def bind_param(value)
+      ActiveRecord::Relation::QueryAttribute.new(nil, value, ActiveRecord::Type::Value.new)
+    end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/schema_test.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index e99f1e2867..83e35ad1a1 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -151,10 +151,10 @@ class SchemaTest < ActiveRecord::TestCase
 
   def test_schema_change_with_prepared_stmt
     altered = false
-    @connection.exec_query "select * from developers where id = $1", 'sql', [[nil, 1]]
+    @connection.exec_query "select * from developers where id = $1", 'sql', [bind_param(1)]
     @connection.exec_query "alter table developers add column zomg int", 'sql', []
     altered = true
-    @connection.exec_query "select * from developers where id = $1", 'sql', [[nil, 1]]
+    @connection.exec_query "select * from developers where id = $1", 'sql', [bind_param(1)]
   ensure
     # We are not using DROP COLUMN IF EXISTS because that syntax is only
     # supported by pg 9.X
@@ -435,6 +435,10 @@ class SchemaTest < ActiveRecord::TestCase
       assert_equal this_index_column, this_index.columns[0]
       assert_equal this_index_name, this_index.name
     end
+
+    def bind_param(value)
+      ActiveRecord::Relation::QueryAttribute.new(nil, value, ActiveRecord::Type::Value.new)
+    end
 end
 
 class SchemaForeignKeyTest < ActiveRecord::TestCase
@@ -454,7 +458,7 @@ class SchemaForeignKeyTest < ActiveRecord::TestCase
     end
     @connection.add_foreign_key "wagons", "my_schema.trains", column: "train_id"
     output = dump_table_schema "wagons"
-    assert_match %r{\s+add_foreign_key "wagons", "my_schema.trains", column: "train_id"$}, output
+    assert_match %r{\s+add_foreign_key "wagons", "my_schema\.trains", column: "train_id"$}, output
   ensure
     @connection.execute "DROP TABLE IF EXISTS wagons"
     @connection.execute "DROP TABLE IF EXISTS my_schema.trains"
diff --git a/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb b/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
index c88259d274..4506e874bc 100644
--- a/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
@@ -18,8 +18,8 @@ class PostgresqlTypeLookupTest < ActiveRecord::TestCase
     bigint_array = @connection.type_map.lookup(1016, -1, "bigint[]")
     big_array = [123456789123456789]
 
-    assert_raises(RangeError) { int_array.type_cast_from_user(big_array) }
-    assert_equal big_array, bigint_array.type_cast_from_user(big_array)
+    assert_raises(RangeError) { int_array.type_cast_for_database(big_array) }
+    assert_equal "{123456789123456789}", bigint_array.type_cast_for_database(big_array)
   end
 
   test "range types correctly respect registration of subtypes" do
diff --git a/activerecord/test/cases/adapters/postgresql/uuid_test.rb b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
index d5d2dd16e2..ad86d617b8 100644
--- a/activerecord/test/cases/adapters/postgresql/uuid_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
@@ -49,9 +49,11 @@ class PostgresqlUUIDTest < ActiveRecord::TestCase
     column = UUIDType.columns_hash["guid"]
     assert_equal :uuid, column.type
     assert_equal "uuid", column.sql_type
-    assert_not column.number?
-    assert_not column.binary?
-    assert_not column.array
+    assert_not column.array?
+
+    type = UUIDType.type_for_attribute("guid")
+    assert_not type.number?
+    assert_not type.binary?
   end
 
   def test_treat_blank_uuid_as_nil
@@ -114,7 +116,7 @@ class PostgresqlUUIDTest < ActiveRecord::TestCase
 
   def test_schema_dump_with_shorthand
     output = dump_table_schema "uuid_data_type"
-    assert_match %r{t.uuid "guid"}, output
+    assert_match %r{t\.uuid "guid"}, output
   end
 
   def test_uniqueness_validation_ignores_uuid
diff --git a/activerecord/test/cases/adapters/postgresql/xml_test.rb b/activerecord/test/cases/adapters/postgresql/xml_test.rb
index 5aba118518..ac8464a65d 100644
--- a/activerecord/test/cases/adapters/postgresql/xml_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/xml_test.rb
@@ -50,6 +50,6 @@ class PostgresqlXMLTest < ActiveRecord::TestCase
 
   def test_schema_dump_with_shorthand
     output = dump_table_schema("xml_data_type")
-    assert_match %r{t.xml "payload"}, output
+    assert_match %r{t\.xml "payload"}, output
   end
 end
diff --git a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
index df497e761c..c1d9b7c273 100644
--- a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
@@ -85,9 +85,9 @@ module ActiveRecord
 
         def test_quoting_binary_strings
           value = "hello".encode('ascii-8bit')
-          column = Column.new(nil, 1, SQLite3String.new)
+          type = Type::String.new
 
-          assert_equal "'hello'", @conn.quote(value, column)
+          assert_equal "'hello'", @conn.quote(type.type_cast_for_database(value))
         end
       end
     end
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
index 029663e7f4..0527bf8b15 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -83,8 +83,7 @@ module ActiveRecord
 
       def test_exec_insert
         with_example_table do
-          column = @conn.columns('ex').find { |col| col.name == 'number' }
-          vals   = [[column, 10]]
+          vals = [Relation::QueryAttribute.new("number", 10, Type::Value.new)]
           @conn.exec_insert('insert into ex (number) VALUES (?)', 'SQL', vals)
 
           result = @conn.exec_query(
@@ -157,7 +156,7 @@ module ActiveRecord
         with_example_table 'id int, data string' do
           @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
           result = @conn.exec_query(
-            'SELECT id, data FROM ex WHERE id = ?', nil, [[nil, 1]])
+            'SELECT id, data FROM ex WHERE id = ?', nil, [Relation::QueryAttribute.new(nil, 1, Type::Value.new)])
 
           assert_equal 1, result.rows.length
           assert_equal 2, result.columns.length
@@ -169,10 +168,9 @@ module ActiveRecord
       def test_exec_query_typecasts_bind_vals
         with_example_table 'id int, data string' do
           @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
-          column = @conn.columns('ex').find { |col| col.name == 'id' }
 
           result = @conn.exec_query(
-            'SELECT id, data FROM ex WHERE id = ?', nil, [[column, '1-fuu']])
+            'SELECT id, data FROM ex WHERE id = ?', nil, [Relation::QueryAttribute.new("id", "1-fuu", Type::Integer.new)])
 
           assert_equal 1, result.rows.length
           assert_equal 2, result.columns.length
diff --git a/activerecord/test/cases/ar_schema_test.rb b/activerecord/test/cases/ar_schema_test.rb
index 025c9fe6f9..f4e8003bc3 100644
--- a/activerecord/test/cases/ar_schema_test.rb
+++ b/activerecord/test/cases/ar_schema_test.rb
@@ -93,69 +93,38 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_equal "20131219224947", ActiveRecord::SchemaMigration.normalize_migration_number("20131219224947")
     end
 
-    def test_timestamps_without_null_is_deprecated_on_create_table
-      assert_deprecated do
-        ActiveRecord::Schema.define do
-          create_table :has_timestamps do |t|
-            t.timestamps
-          end
+    def test_timestamps_without_null_set_null_to_false_on_create_table
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps do |t|
+          t.timestamps
         end
       end
+
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'created_at' }.null
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'updated_at' }.null
     end
 
-    def test_timestamps_without_null_is_deprecated_on_change_table
-      assert_deprecated do
-        ActiveRecord::Schema.define do
-          create_table :has_timestamps
+    def test_timestamps_without_null_set_null_to_false_on_change_table
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps
 
-          change_table :has_timestamps do |t|
-            t.timestamps
-          end
+        change_table :has_timestamps do |t|
+          t.timestamps default: Time.now
         end
       end
-    end
 
-    def test_timestamps_without_null_is_deprecated_on_add_timestamps
-      assert_deprecated do
-        ActiveRecord::Schema.define do
-          create_table :has_timestamps
-          add_timestamps :has_timestamps
-        end
-      end
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'created_at' }.null
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'updated_at' }.null
     end
 
-    def test_no_deprecation_warning_from_timestamps_on_create_table
-      assert_not_deprecated do
-        ActiveRecord::Schema.define do
-          create_table :has_timestamps do |t|
-            t.timestamps null: true
-          end
-
-          drop_table :has_timestamps
-
-          create_table :has_timestamps do |t|
-            t.timestamps null: false
-          end
-        end
+    def test_timestamps_without_null_set_null_to_false_on_add_timestamps
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps
+        add_timestamps :has_timestamps, default: Time.now
       end
-    end
-
-    def test_no_deprecation_warning_from_timestamps_on_change_table
-      assert_not_deprecated do
-        ActiveRecord::Schema.define do
-          create_table :has_timestamps
-          change_table :has_timestamps do |t|
-            t.timestamps null: true
-          end
 
-          drop_table :has_timestamps
-
-          create_table :has_timestamps
-          change_table :has_timestamps do |t|
-            t.timestamps null: false, default: Time.now
-          end
-        end
-      end
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'created_at' }.null
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'updated_at' }.null
     end
   end
 end
diff --git a/activerecord/test/cases/associations/association_scope_test.rb b/activerecord/test/cases/associations/association_scope_test.rb
index 3e0032ec73..472e270f8c 100644
--- a/activerecord/test/cases/associations/association_scope_test.rb
+++ b/activerecord/test/cases/associations/association_scope_test.rb
@@ -8,12 +8,7 @@ module ActiveRecord
       test 'does not duplicate conditions' do
         scope = AssociationScope.scope(Author.new.association(:welcome_posts),
                                         Author.connection)
-        wheres = scope.where_values.map(&:right)
-        binds = scope.bind_values.map(&:last)
-        wheres = scope.where_values.map(&:right).reject { |node|
-          Arel::Nodes::BindParam === node
-        }
-        assert_equal wheres.uniq, wheres
+        binds = scope.where_clause.binds.map(&:value)
         assert_equal binds.uniq, binds
       end
     end
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 17394cb6f7..a425b3ed88 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -122,14 +122,14 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
     citibank_result = Client.all.merge!(:where => {:name => "Citibank"}, :includes => :firm_with_primary_key).first
-    assert citibank_result.association_cache.key?(:firm_with_primary_key)
+    assert citibank_result.association(:firm_with_primary_key).loaded?
   end
 
   def test_eager_loading_with_primary_key_as_symbol
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
     citibank_result = Client.all.merge!(:where => {:name => "Citibank"}, :includes => :firm_with_primary_key_symbols).first
-    assert citibank_result.association_cache.key?(:firm_with_primary_key_symbols)
+    assert citibank_result.association(:firm_with_primary_key_symbols).loaded?
   end
 
   def test_creating_the_belonging_object
diff --git a/activerecord/test/cases/associations/deprecated_counter_cache_on_has_many_through_test.rb b/activerecord/test/cases/associations/deprecated_counter_cache_on_has_many_through_test.rb
deleted file mode 100644
index 48f7ddbe83..0000000000
--- a/activerecord/test/cases/associations/deprecated_counter_cache_on_has_many_through_test.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-require "cases/helper"
-
-class DeprecatedCounterCacheOnHasManyThroughTest < ActiveRecord::TestCase
-  class Post < ActiveRecord::Base
-    has_many :taggings, as: :taggable
-    has_many :tags, through: :taggings
-  end
-
-  class Tagging < ActiveRecord::Base
-    belongs_to :taggable, polymorphic: true
-    belongs_to :tag
-  end
-
-  class Tag < ActiveRecord::Base
-  end
-
-  test "counter caches are updated in the database if the belongs_to association doesn't specify a counter cache" do
-    post = Post.create!(title: 'Hello', body: 'World!')
-    assert_deprecated { post.tags << Tag.create!(name: 'whatever') }
-
-    assert_equal 1, post.tags.size
-    assert_equal 1, post.tags_count
-    assert_equal 1, post.reload.tags.size
-    assert_equal 1, post.reload.tags_count
-  end
-end
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 1d00177405..7d8b933992 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -834,18 +834,6 @@ class EagerAssociationTest < ActiveRecord::TestCase
     )
   end
 
-  def test_preload_with_interpolation
-    assert_deprecated do
-      post = Post.includes(:comments_with_interpolated_conditions).find(posts(:welcome).id)
-      assert_equal [comments(:greetings)], post.comments_with_interpolated_conditions
-    end
-
-    assert_deprecated do
-      post = Post.joins(:comments_with_interpolated_conditions).find(posts(:welcome).id)
-      assert_equal [comments(:greetings)], post.comments_with_interpolated_conditions
-    end
-  end
-
   def test_polymorphic_type_condition
     post = Post.all.merge!(:includes => :taggings).find(posts(:thinking).id)
     assert post.taggings.include?(taggings(:thinking_general))
@@ -1302,23 +1290,22 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_equal pets(:parrot), Owner.including_last_pet.first.last_pet
   end
 
-  test "include instance dependent associations is deprecated" do
+  test "preloading and eager loading of instance dependent associations is not supported" do
     message = "association scope 'posts_with_signature' is"
-    assert_deprecated message do
-      begin
-        Author.includes(:posts_with_signature).to_a
-      rescue NoMethodError
-        # it's expected that preloading of this association fails
-      end
+    error = assert_raises(ArgumentError) do
+      Author.includes(:posts_with_signature).to_a
     end
+    assert_match message, error.message
 
-    assert_deprecated message do
-      Author.preload(:posts_with_signature).to_a rescue NoMethodError
+    error = assert_raises(ArgumentError) do
+      Author.preload(:posts_with_signature).to_a
     end
+    assert_match message, error.message
 
-    assert_deprecated message do
+    error = assert_raises(ArgumentError) do
       Author.eager_load(:posts_with_signature).to_a
     end
+    assert_match message, error.message
   end
 
   test "preloading readonly association" do
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 21a45042fa..19f4384e83 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -316,16 +316,16 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   # would be convenient), because this would cause that scope to be applied to any callbacks etc.
   def test_build_and_create_should_not_happen_within_scope
     car = cars(:honda)
-    scoped_count = car.foo_bulbs.where_values.count
+    scope = car.foo_bulbs.where_values_hash
 
     bulb = car.foo_bulbs.build
-    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
+    assert_not_equal scope, bulb.scope_after_initialize.where_values_hash
 
     bulb = car.foo_bulbs.create
-    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
+    assert_not_equal scope, bulb.scope_after_initialize.where_values_hash
 
     bulb = car.foo_bulbs.create!
-    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
+    assert_not_equal scope, bulb.scope_after_initialize.where_values_hash
   end
 
   def test_no_sql_should_be_fired_if_association_already_loaded
@@ -1307,7 +1307,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_nothing_raised { topic.destroy }
   end
 
-  uses_transaction :test_dependence_with_transaction_support_on_failure
   def test_dependence_with_transaction_support_on_failure
     firm = companies(:first_firm)
     clients = firm.clients
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index 9b6757e256..3b6a4038cd 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -237,16 +237,16 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
   def test_build_and_create_should_not_happen_within_scope
     pirate = pirates(:blackbeard)
-    scoped_count = pirate.association(:foo_bulb).scope.where_values.count
+    scope = pirate.association(:foo_bulb).scope.where_values_hash
 
     bulb = pirate.build_foo_bulb
-    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
+    assert_not_equal scope, bulb.scope_after_initialize.where_values_hash
 
     bulb = pirate.create_foo_bulb
-    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
+    assert_not_equal scope, bulb.scope_after_initialize.where_values_hash
 
     bulb = pirate.create_foo_bulb!
-    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
+    assert_not_equal scope, bulb.scope_after_initialize.where_values_hash
   end
 
   def test_create_association
@@ -276,7 +276,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   def test_create_with_inexistent_foreign_key_failing
     firm = Firm.create(name: 'GlobalMegaCorp')
 
-    assert_raises(ActiveRecord::UnknownAttributeError) do
+    assert_raises(ActiveModel::AttributeAssignment::UnknownAttributeError) do
       firm.create_account_with_inexistent_foreign_key
     end
   end
diff --git a/activerecord/test/cases/associations/required_test.rb b/activerecord/test/cases/associations/required_test.rb
index 321fb6c8dd..8b765a2e0c 100644
--- a/activerecord/test/cases/associations/required_test.rb
+++ b/activerecord/test/cases/associations/required_test.rb
@@ -18,8 +18,8 @@ class RequiredAssociationsTest < ActiveRecord::TestCase
   end
 
   teardown do
-    @connection.drop_table 'parents' if @connection.table_exists? 'parents'
-    @connection.drop_table 'children' if @connection.table_exists? 'children'
+    @connection.drop_table 'parents', if_exists: true
+    @connection.drop_table 'children', if_exists: true
   end
 
   test "belongs_to associations are not required by default" do
@@ -40,7 +40,7 @@ class RequiredAssociationsTest < ActiveRecord::TestCase
 
     record = model.new
     assert_not record.save
-    assert_equal ["Parent can't be blank"], record.errors.full_messages
+    assert_equal ["Parent must exist"], record.errors.full_messages
 
     record.parent = Parent.new
     assert record.save
@@ -64,12 +64,32 @@ class RequiredAssociationsTest < ActiveRecord::TestCase
 
     record = model.new
     assert_not record.save
-    assert_equal ["Child can't be blank"], record.errors.full_messages
+    assert_equal ["Child must exist"], record.errors.full_messages
 
     record.child = Child.new
     assert record.save
   end
 
+  test "required has_one associations have a correct error message" do
+    model = subclass_of(Parent) do
+      has_one :child, required: true, inverse_of: false,
+      class_name: "RequiredAssociationsTest::Child"
+    end
+
+    record = model.create
+    assert_equal ["Child must exist"], record.errors.full_messages
+  end
+
+  test "required belongs_to associations have a correct error message" do
+    model = subclass_of(Child) do
+      belongs_to :parent, required: true, inverse_of: false,
+      class_name: "RequiredAssociationsTest::Parent"
+    end
+
+    record = model.create
+    assert_equal ["Parent must exist"], record.errors.full_messages
+  end
+
   private
 
   def subclass_of(klass, &block)
diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index 72963fd56c..de358114ab 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -141,7 +141,7 @@ class AssociationsTest < ActiveRecord::TestCase
 
   def test_association_with_references
     firm = companies(:first_firm)
-    assert_equal ['foo'], firm.association_with_references.references_values
+    assert_includes firm.association_with_references.references_values, 'foo'
   end
 
 end
@@ -238,7 +238,7 @@ class AssociationProxyTest < ActiveRecord::TestCase
   end
 
   def test_scoped_allows_conditions
-    assert developers(:david).projects.merge!(where: 'foo').where_values.include?('foo')
+    assert developers(:david).projects.merge(where: 'foo').to_sql.include?('foo')
   end
 
   test "getting a scope from an association" do
diff --git a/activerecord/test/cases/attribute_decorators_test.rb b/activerecord/test/cases/attribute_decorators_test.rb
index 53bd58e22e..9ad02ffae8 100644
--- a/activerecord/test/cases/attribute_decorators_test.rb
+++ b/activerecord/test/cases/attribute_decorators_test.rb
@@ -28,7 +28,7 @@ module ActiveRecord
 
     teardown do
       return unless @connection
-      @connection.drop_table 'attribute_decorators_model' if @connection.table_exists? 'attribute_decorators_model'
+      @connection.drop_table 'attribute_decorators_model', if_exists: true
       Model.attribute_type_decorations.clear
       Model.reset_column_information
     end
diff --git a/activerecord/test/cases/attribute_methods/read_test.rb b/activerecord/test/cases/attribute_methods/read_test.rb
index e38b32d7fc..74e556211b 100644
--- a/activerecord/test/cases/attribute_methods/read_test.rb
+++ b/activerecord/test/cases/attribute_methods/read_test.rb
@@ -17,7 +17,7 @@ module ActiveRecord
 
           include ActiveRecord::AttributeMethods
 
-          def self.column_names
+          def self.attribute_names
             %w{ one two three }
           end
 
@@ -25,11 +25,11 @@ module ActiveRecord
           end
 
           def self.columns
-            column_names.map { FakeColumn.new(name) }
+            attribute_names.map { FakeColumn.new(name) }
           end
 
           def self.columns_hash
-            Hash[column_names.map { |name|
+            Hash[attribute_names.map { |name|
               [name, FakeColumn.new(name)]
             }]
           end
@@ -39,13 +39,13 @@ module ActiveRecord
       def test_define_attribute_methods
         instance = @klass.new
 
-        @klass.column_names.each do |name|
+        @klass.attribute_names.each do |name|
           assert !instance.methods.map(&:to_s).include?(name)
         end
 
         @klass.define_attribute_methods
 
-        @klass.column_names.each do |name|
+        @klass.attribute_names.each do |name|
           assert instance.methods.map(&:to_s).include?(name), "#{name} is not defined"
         end
       end
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 731d433706..243c90e945 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -502,7 +502,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   def test_typecast_attribute_from_select_to_false
     Topic.create(:title => 'Budget')
     # Oracle does not support boolean expressions in SELECT
-    if current_adapter?(:OracleAdapter)
+    if current_adapter?(:OracleAdapter, :FbAdapter)
       topic = Topic.all.merge!(:select => "topics.*, 0 as is_test").first
     else
       topic = Topic.all.merge!(:select => "topics.*, 1=2 as is_test").first
@@ -513,7 +513,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   def test_typecast_attribute_from_select_to_true
     Topic.create(:title => 'Budget')
     # Oracle does not support boolean expressions in SELECT
-    if current_adapter?(:OracleAdapter)
+    if current_adapter?(:OracleAdapter, :FbAdapter)
       topic = Topic.all.merge!(:select => "topics.*, 1 as is_test").first
     else
       topic = Topic.all.merge!(:select => "topics.*, 2=2 as is_test").first
@@ -531,20 +531,6 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_deprecated_cache_attributes
-    assert_deprecated do
-      Topic.cache_attributes :replies_count
-    end
-
-    assert_deprecated do
-      Topic.cached_attributes
-    end
-
-    assert_deprecated do
-      Topic.cache_attribute? :replies_count
-    end
-  end
-
   def test_converted_values_are_returned_after_assignment
     developer = Developer.new(name: 1337, salary: "50000")
 
@@ -671,7 +657,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_setting_time_zone_aware_attribute_in_current_time_zone
+  def test_setting_time_zone_aware_datetime_in_current_time_zone
     utc_time = Time.utc(2008, 1, 1)
     in_time_zone "Pacific Time (US & Canada)" do
       record   = @target.new
@@ -690,6 +676,47 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_setting_time_zone_aware_time_in_current_time_zone
+    in_time_zone "Pacific Time (US & Canada)" do
+      record = @target.new
+      time_string = "10:00:00"
+      expected_time = Time.zone.parse("2000-01-01 #{time_string}")
+
+      record.bonus_time = time_string
+      assert_equal expected_time, record.bonus_time
+      assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.bonus_time.time_zone
+
+      record.bonus_time = ''
+      assert_nil record.bonus_time
+    end
+  end
+
+  def test_setting_time_zone_aware_time_with_dst
+    in_time_zone "Pacific Time (US & Canada)" do
+      current_time = Time.zone.local(2014, 06, 15, 10)
+      record = @target.new(bonus_time: current_time)
+      time_before_save = record.bonus_time
+
+      record.save
+      record.reload
+
+      assert_equal time_before_save, record.bonus_time
+      assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.bonus_time.time_zone
+    end
+  end
+
+  def test_removing_time_zone_aware_types
+    with_time_zone_aware_types(:datetime) do
+      in_time_zone "Pacific Time (US & Canada)" do
+        record = @target.new(bonus_time: "10:00:00")
+        expected_time = Time.utc(2000, 01, 01, 10)
+
+        assert_equal expected_time, record.bonus_time
+        assert record.bonus_time.utc?
+      end
+    end
+  end
+
   def test_setting_time_zone_conversion_for_attributes_should_write_value_on_class_variable
     Topic.skip_time_zone_conversion_for_attributes = [:field_a]
     Minimalistic.skip_time_zone_conversion_for_attributes = [:field_b]
@@ -731,12 +758,12 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   def test_bulk_update_respects_access_control
     privatize("title=(value)")
 
-    assert_raise(ActiveRecord::UnknownAttributeError) { @target.new(:title => "Rants about pants") }
-    assert_raise(ActiveRecord::UnknownAttributeError) { @target.new.attributes = { :title => "Ants in pants" } }
+    assert_raise(ActiveModel::AttributeAssignment::UnknownAttributeError) { @target.new(:title => "Rants about pants") }
+    assert_raise(ActiveModel::AttributeAssignment::UnknownAttributeError) { @target.new.attributes = { :title => "Ants in pants" } }
   end
 
   def test_bulk_update_raise_unknown_attribute_error
-    error = assert_raises(ActiveRecord::UnknownAttributeError) {
+    error = assert_raises(ActiveModel::AttributeAssignment::UnknownAttributeError) {
       Topic.new(hello: "world")
     }
     assert_instance_of Topic, error.record
@@ -902,6 +929,24 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_not_equal ['id'], @target.column_names
   end
 
+  def test_came_from_user
+    model = @target.first
+
+    assert_not model.id_came_from_user?
+    model.id = "omg"
+    assert model.id_came_from_user?
+  end
+
+  def test_accessed_fields
+    model = @target.first
+
+    assert_equal [], model.accessed_fields
+
+    model.title
+
+    assert_equal ["title"], model.accessed_fields
+  end
+
   private
 
   def new_topic_like_ar_class(&block)
@@ -914,6 +959,14 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     klass
   end
 
+  def with_time_zone_aware_types(*types)
+    old_types = ActiveRecord::Base.time_zone_aware_types
+    ActiveRecord::Base.time_zone_aware_types = types
+    yield
+  ensure
+    ActiveRecord::Base.time_zone_aware_types = old_types
+  end
+
   def cached_columns
     Topic.columns.map(&:name)
   end
diff --git a/activerecord/test/cases/attribute_set_test.rb b/activerecord/test/cases/attribute_set_test.rb
index ba53612d30..8025c7c4d2 100644
--- a/activerecord/test/cases/attribute_set_test.rb
+++ b/activerecord/test/cases/attribute_set_test.rb
@@ -186,5 +186,16 @@ module ActiveRecord
       attributes.freeze
       assert_equal({ foo: "1" }, attributes.to_hash)
     end
+
+    test "#accessed_attributes returns only attributes which have been read" do
+      builder = AttributeSet::Builder.new(foo: Type::Value.new, bar: Type::Value.new)
+      attributes = builder.build_from_database(foo: "1", bar: "2")
+
+      assert_equal [], attributes.accessed
+
+      attributes.fetch_value(:foo)
+
+      assert_equal [:foo], attributes.accessed
+    end
   end
 end
diff --git a/activerecord/test/cases/attribute_test.rb b/activerecord/test/cases/attribute_test.rb
index 7b325abf1d..eac73e11e8 100644
--- a/activerecord/test/cases/attribute_test.rb
+++ b/activerecord/test/cases/attribute_test.rb
@@ -5,6 +5,7 @@ module ActiveRecord
   class AttributeTest < ActiveRecord::TestCase
     setup do
       @type = Minitest::Mock.new
+      @type.expect(:==, false, [false])
     end
 
     teardown do
@@ -168,5 +169,24 @@ module ActiveRecord
       second = Attribute.from_user(:foo, 1, Type::Integer.new)
       assert_not_equal first, second
     end
+
+    test "an attribute has not been read by default" do
+      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
+      assert_not attribute.has_been_read?
+    end
+
+    test "an attribute has been read when its value is calculated" do
+      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
+      attribute.value
+      assert attribute.has_been_read?
+    end
+
+    test "an attribute can not be mutated if it has not been read,
+      and skips expensive calculations" do
+      type_which_raises_from_all_methods = Object.new
+      attribute = Attribute.from_database(:foo, "bar", type_which_raises_from_all_methods)
+
+      assert_not attribute.changed_in_place_from?("bar")
+    end
   end
 end
diff --git a/activerecord/test/cases/attributes_test.rb b/activerecord/test/cases/attributes_test.rb
index dbe1eb48db..6f331c5985 100644
--- a/activerecord/test/cases/attributes_test.rb
+++ b/activerecord/test/cases/attributes_test.rb
@@ -50,15 +50,15 @@ module ActiveRecord
     end
 
     test "overloaded properties with limit" do
-      assert_equal 50, OverloadedType.columns_hash['overloaded_string_with_limit'].limit
-      assert_equal 255, UnoverloadedType.columns_hash['overloaded_string_with_limit'].limit
+      assert_equal 50, OverloadedType.type_for_attribute('overloaded_string_with_limit').limit
+      assert_equal 255, UnoverloadedType.type_for_attribute('overloaded_string_with_limit').limit
     end
 
     test "nonexistent attribute" do
       data = OverloadedType.new(non_existent_decimal: 1)
 
       assert_equal BigDecimal.new(1), data.non_existent_decimal
-      assert_raise ActiveRecord::UnknownAttributeError do
+      assert_raise ActiveModel::AttributeAssignment::UnknownAttributeError do
         UnoverloadedType.new(non_existent_decimal: 1)
       end
     end
@@ -87,29 +87,42 @@ module ActiveRecord
       assert_equal 4.4, data.overloaded_float
     end
 
-    test "overloading properties does not change column order" do
-      column_names = OverloadedType.column_names
-      assert_equal %w(id overloaded_float unoverloaded_float overloaded_string_with_limit string_with_default non_existent_decimal), column_names
+    test "overloading properties does not attribute method order" do
+      attribute_names = OverloadedType.attribute_names
+      assert_equal %w(id overloaded_float unoverloaded_float overloaded_string_with_limit string_with_default non_existent_decimal), attribute_names
     end
 
     test "caches are cleared" do
       klass = Class.new(OverloadedType)
 
-      assert_equal 6, klass.columns.length
-      assert_not klass.columns_hash.key?('wibble')
-      assert_equal 6, klass.column_types.length
+      assert_equal 6, klass.attribute_types.length
       assert_equal 6, klass.column_defaults.length
-      assert_not klass.column_names.include?('wibble')
-      assert_equal 5, klass.content_columns.length
+      assert_not klass.attribute_types.include?('wibble')
 
       klass.attribute :wibble, Type::Value.new
 
-      assert_equal 7, klass.columns.length
-      assert klass.columns_hash.key?('wibble')
-      assert_equal 7, klass.column_types.length
+      assert_equal 7, klass.attribute_types.length
       assert_equal 7, klass.column_defaults.length
-      assert klass.column_names.include?('wibble')
-      assert_equal 6, klass.content_columns.length
+      assert klass.attribute_types.include?('wibble')
+    end
+
+    test "the given default value is cast from user" do
+      custom_type = Class.new(Type::Value) do
+        def type_cast_from_user(*)
+          "from user"
+        end
+
+        def type_cast_from_database(*)
+          "from database"
+        end
+      end
+
+      klass = Class.new(OverloadedType) do
+        attribute :wibble, custom_type.new, default: "default"
+      end
+      model = klass.new
+
+      assert_equal "from user", model.wibble
     end
   end
 end
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index 04d5a2869c..859afc4553 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -1030,6 +1030,16 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
     assert_equal 'The Vile Insanity', @pirate.reload.ship.name
   end
 
+  def test_changed_for_autosave_should_handle_cycles
+    @ship.pirate = @pirate
+    assert_queries(0) { @ship.save! }
+
+    @parrot = @pirate.parrots.create(name: "some_name")
+    @parrot.name="changed_name"
+    assert_queries(1) { @ship.save! }
+    assert_queries(0) { @ship.save! }
+  end
+
   def test_should_automatically_save_bang_the_associated_model
     @pirate.ship.name = 'The Vile Insanity'
     @pirate.save!
@@ -1051,11 +1061,16 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
   end
 
   def test_should_not_ignore_different_error_messages_on_the_same_attribute
+    old_validators = Ship._validators.deep_dup
+    old_callbacks = Ship._validate_callbacks.deep_dup
     Ship.validates_format_of :name, :with => /\w/
     @pirate.ship.name   = ""
     @pirate.catchphrase = nil
     assert @pirate.invalid?
     assert_equal ["can't be blank", "is invalid"], @pirate.errors[:"ship.name"]
+  ensure
+    Ship._validators = old_validators if old_validators
+    Ship._validate_callbacks = old_callbacks if old_callbacks
   end
 
   def test_should_still_allow_to_bypass_validations_on_the_associated_model
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 6acd9aa39f..0debd30e5c 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -88,6 +88,7 @@ class BasicsTest < ActiveRecord::TestCase
       'Mysql2Adapter'     => '`',
       'PostgreSQLAdapter' => '"',
       'OracleAdapter'     => '"',
+      'FbAdapter'         => '"'
     }.fetch(classname) {
       raise "need a bad char for #{classname}"
     }
@@ -111,7 +112,7 @@ class BasicsTest < ActiveRecord::TestCase
     assert_nil Edge.primary_key
   end
 
-  unless current_adapter?(:PostgreSQLAdapter, :OracleAdapter, :SQLServerAdapter)
+  unless current_adapter?(:PostgreSQLAdapter, :OracleAdapter, :SQLServerAdapter, :FbAdapter)
     def test_limit_with_comma
       assert Topic.limit("1,2").to_a
     end
diff --git a/activerecord/test/cases/bind_parameter_test.rb b/activerecord/test/cases/bind_parameter_test.rb
index c4634d11e2..68d5a232ba 100644
--- a/activerecord/test/cases/bind_parameter_test.rb
+++ b/activerecord/test/cases/bind_parameter_test.rb
@@ -1,9 +1,11 @@
 require 'cases/helper'
 require 'models/topic'
+require 'models/author'
+require 'models/post'
 
 module ActiveRecord
   class BindParameterTest < ActiveRecord::TestCase
-    fixtures :topics
+    fixtures :topics, :authors, :posts
 
     class LogListener
       attr_accessor :calls
@@ -20,8 +22,8 @@ module ActiveRecord
     def setup
       super
       @connection = ActiveRecord::Base.connection
-      @subscriber   = LogListener.new
-      @pk         = Topic.columns_hash[Topic.primary_key]
+      @subscriber = LogListener.new
+      @pk = ConnectionAdapters::Column.new(Topic.primary_key, nil, Topic.type_for_attribute(Topic.primary_key))
       @subscription = ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
     end
 
@@ -30,40 +32,34 @@ module ActiveRecord
     end
 
     if ActiveRecord::Base.connection.supports_statement_cache?
-      def test_binds_are_logged
-        sub   = @connection.substitute_at(@pk)
-        binds = [[@pk, 1]]
-        sql   = "select * from topics where id = #{sub.to_sql}"
-
-        @connection.exec_query(sql, 'SQL', binds)
-
-        message = @subscriber.calls.find { |args| args[4][:sql] == sql }
-        assert_equal binds, message[4][:binds]
+      def test_bind_from_join_in_subquery
+        subquery = Author.joins(:thinking_posts).where(name: 'David')
+        scope = Author.from(subquery, 'authors').where(id: 1)
+        assert_equal 1, scope.count
       end
 
-      def test_binds_are_logged_after_type_cast
+      def test_binds_are_logged
         sub   = @connection.substitute_at(@pk)
-        binds = [[@pk, "3"]]
+        binds = [Relation::QueryAttribute.new("id", 1, Type::Value.new)]
         sql   = "select * from topics where id = #{sub.to_sql}"
 
         @connection.exec_query(sql, 'SQL', binds)
 
         message = @subscriber.calls.find { |args| args[4][:sql] == sql }
-        assert_equal [[@pk, 3]], message[4][:binds]
+        assert_equal binds, message[4][:binds]
       end
 
       def test_find_one_uses_binds
         Topic.find(1)
-        binds = [[@pk, 1]]
-        message = @subscriber.calls.find { |args| args[4][:binds] == binds }
+        message = @subscriber.calls.find { |args| args[4][:binds].any? { |attr| attr.value == 1 } }
         assert message, 'expected a message with binds'
       end
 
-      def test_logs_bind_vars
+      def test_logs_bind_vars_after_type_cast
         payload = {
           :name  => 'SQL',
           :sql   => 'select * from topics where id = ?',
-          :binds => [[@pk, 10]]
+          :binds => [Relation::QueryAttribute.new("id", "10", Type::Integer.new)]
         }
         event  = ActiveSupport::Notifications::Event.new(
           'foo',
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index 299217214e..f47568f2f5 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -631,4 +631,9 @@ class CalculationsTest < ActiveRecord::TestCase
 
     assert_equal({ "has trinket" => part.id }, ShipPart.joins(:trinkets).group("ship_parts.name").sum(:id))
   end
+
+  def test_calculation_grouped_by_association_doesnt_error_when_no_records_have_association
+    Client.update_all(client_of: nil)
+    assert_equal({ nil => Client.count }, Client.group(:firm).count)
+  end
 end
diff --git a/activerecord/test/cases/callbacks_test.rb b/activerecord/test/cases/callbacks_test.rb
index d4cc081f32..3ae4a6eade 100644
--- a/activerecord/test/cases/callbacks_test.rb
+++ b/activerecord/test/cases/callbacks_test.rb
@@ -49,6 +49,11 @@ class CallbackDeveloperWithFalseValidation < CallbackDeveloper
   before_validation proc { |model| model.history << [:before_validation, :should_never_get_here] }
 end
 
+class CallbackDeveloperWithHaltedValidation < CallbackDeveloper
+  before_validation proc { |model| model.history << [:before_validation, :throwing_abort]; throw(:abort) }
+  before_validation proc { |model| model.history << [:before_validation, :should_never_get_here] }
+end
+
 class ParentDeveloper < ActiveRecord::Base
   self.table_name = 'developers'
   attr_accessor :after_save_called
@@ -73,6 +78,20 @@ class ImmutableDeveloper < ActiveRecord::Base
     end
 end
 
+class DeveloperWithCanceledCallbacks < ActiveRecord::Base
+  self.table_name = 'developers'
+
+  validates_inclusion_of :salary, in: 50000..200000
+
+  before_save :cancel
+  before_destroy :cancel
+
+  private
+    def cancel
+      throw(:abort)
+    end
+end
+
 class OnCallbacksDeveloper < ActiveRecord::Base
   self.table_name = 'developers'
 
@@ -136,6 +155,23 @@ class CallbackCancellationDeveloper < ActiveRecord::Base
   after_destroy { @after_destroy_called = true }
 end
 
+class CallbackHaltedDeveloper < ActiveRecord::Base
+  self.table_name = 'developers'
+
+  attr_reader   :after_save_called, :after_create_called, :after_update_called, :after_destroy_called
+  attr_accessor :cancel_before_save, :cancel_before_create, :cancel_before_update, :cancel_before_destroy
+
+  before_save    { throw(:abort) if defined?(@cancel_before_save) }
+  before_create  { throw(:abort) if @cancel_before_create  }
+  before_update  { throw(:abort) if @cancel_before_update  }
+  before_destroy { throw(:abort) if @cancel_before_destroy }
+
+  after_save    { @after_save_called    = true }
+  after_update  { @after_update_called  = true }
+  after_create  { @after_create_called  = true }
+  after_destroy { @after_destroy_called = true }
+end
+
 class CallbacksTest < ActiveRecord::TestCase
   fixtures :developers
 
@@ -252,7 +288,12 @@ class CallbacksTest < ActiveRecord::TestCase
       [ :after_save,                  :string ],
       [ :after_save,                  :proc   ],
       [ :after_save,                  :object ],
-      [ :after_save,                  :block  ]
+      [ :after_save,                  :block  ],
+      [ :after_commit,                :block  ],
+      [ :after_commit,                :object ],
+      [ :after_commit,                :proc   ],
+      [ :after_commit,                :string ],
+      [ :after_commit,                :method ]
     ], david.history
   end
 
@@ -321,7 +362,12 @@ class CallbacksTest < ActiveRecord::TestCase
       [ :after_save,                  :string ],
       [ :after_save,                  :proc   ],
       [ :after_save,                  :object ],
-      [ :after_save,                  :block  ]
+      [ :after_save,                  :block  ],
+      [ :after_commit,                :block  ],
+      [ :after_commit,                :object ],
+      [ :after_commit,                :proc   ],
+      [ :after_commit,                :string ],
+      [ :after_commit,                :method ]
     ], david.history
   end
 
@@ -372,7 +418,12 @@ class CallbacksTest < ActiveRecord::TestCase
       [ :after_destroy,               :string ],
       [ :after_destroy,               :proc   ],
       [ :after_destroy,               :object ],
-      [ :after_destroy,               :block  ]
+      [ :after_destroy,               :block  ],
+      [ :after_commit,                :block  ],
+      [ :after_commit,                :object ],
+      [ :after_commit,                :proc   ],
+      [ :after_commit,                :string ],
+      [ :after_commit,                :method ]
     ], david.history
   end
 
@@ -393,12 +444,14 @@ class CallbacksTest < ActiveRecord::TestCase
     ], david.history
   end
 
-  def test_before_save_returning_false
+  def test_deprecated_before_save_returning_false
     david = ImmutableDeveloper.find(1)
-    assert david.valid?
-    assert !david.save
-    exc = assert_raise(ActiveRecord::RecordNotSaved) { david.save! }
-    assert_equal exc.record, david
+    assert_deprecated do
+      assert david.valid?
+      assert !david.save
+      exc = assert_raise(ActiveRecord::RecordNotSaved) { david.save! }
+      assert_equal exc.record, david
+    end
 
     david = ImmutableDeveloper.find(1)
     david.salary = 10_000_000
@@ -408,38 +461,48 @@ class CallbacksTest < ActiveRecord::TestCase
 
     someone = CallbackCancellationDeveloper.find(1)
     someone.cancel_before_save = true
-    assert someone.valid?
-    assert !someone.save
+    assert_deprecated do
+      assert someone.valid?
+      assert !someone.save
+    end
     assert_save_callbacks_not_called(someone)
   end
 
-  def test_before_create_returning_false
+  def test_deprecated_before_create_returning_false
     someone = CallbackCancellationDeveloper.new
     someone.cancel_before_create = true
-    assert someone.valid?
-    assert !someone.save
+    assert_deprecated do
+      assert someone.valid?
+      assert !someone.save
+    end
     assert_save_callbacks_not_called(someone)
   end
 
-  def test_before_update_returning_false
+  def test_deprecated_before_update_returning_false
     someone = CallbackCancellationDeveloper.find(1)
     someone.cancel_before_update = true
-    assert someone.valid?
-    assert !someone.save
+    assert_deprecated do
+      assert someone.valid?
+      assert !someone.save
+    end
     assert_save_callbacks_not_called(someone)
   end
 
-  def test_before_destroy_returning_false
+  def test_deprecated_before_destroy_returning_false
     david = ImmutableDeveloper.find(1)
-    assert !david.destroy
-    exc = assert_raise(ActiveRecord::RecordNotDestroyed) { david.destroy! }
-    assert_equal exc.record, david
+    assert_deprecated do
+      assert !david.destroy
+      exc = assert_raise(ActiveRecord::RecordNotDestroyed) { david.destroy! }
+      assert_equal exc.record, david
+    end
     assert_not_nil ImmutableDeveloper.find_by_id(1)
 
     someone = CallbackCancellationDeveloper.find(1)
     someone.cancel_before_destroy = true
-    assert !someone.destroy
-    assert_raise(ActiveRecord::RecordNotDestroyed) { someone.destroy! }
+    assert_deprecated do
+      assert !someone.destroy
+      assert_raise(ActiveRecord::RecordNotDestroyed) { someone.destroy! }
+    end
     assert !someone.after_destroy_called
   end
 
@@ -450,9 +513,59 @@ class CallbacksTest < ActiveRecord::TestCase
   end
   private :assert_save_callbacks_not_called
 
+  def test_before_create_throwing_abort
+    someone = CallbackHaltedDeveloper.new
+    someone.cancel_before_create = true
+    assert someone.valid?
+    assert !someone.save
+    assert_save_callbacks_not_called(someone)
+  end
+
+  def test_before_save_throwing_abort
+    david = DeveloperWithCanceledCallbacks.find(1)
+    assert david.valid?
+    assert !david.save
+    exc = assert_raise(ActiveRecord::RecordNotSaved) { david.save! }
+    assert_equal exc.record, david
+
+    david = DeveloperWithCanceledCallbacks.find(1)
+    david.salary = 10_000_000
+    assert !david.valid?
+    assert !david.save
+    assert_raise(ActiveRecord::RecordInvalid) { david.save! }
+
+    someone = CallbackHaltedDeveloper.find(1)
+    someone.cancel_before_save = true
+    assert someone.valid?
+    assert !someone.save
+    assert_save_callbacks_not_called(someone)
+  end
+
+  def test_before_update_throwing_abort
+    someone = CallbackHaltedDeveloper.find(1)
+    someone.cancel_before_update = true
+    assert someone.valid?
+    assert !someone.save
+    assert_save_callbacks_not_called(someone)
+  end
+
+  def test_before_destroy_throwing_abort
+    david = DeveloperWithCanceledCallbacks.find(1)
+    assert !david.destroy
+    exc = assert_raise(ActiveRecord::RecordNotDestroyed) { david.destroy! }
+    assert_equal exc.record, david
+    assert_not_nil ImmutableDeveloper.find_by_id(1)
+
+    someone = CallbackHaltedDeveloper.find(1)
+    someone.cancel_before_destroy = true
+    assert !someone.destroy
+    assert_raise(ActiveRecord::RecordNotDestroyed) { someone.destroy! }
+    assert !someone.after_destroy_called
+  end
+
   def test_callback_returning_false
     david = CallbackDeveloperWithFalseValidation.find(1)
-    david.save
+    assert_deprecated { david.save }
     assert_equal [
       [ :after_find,            :method ],
       [ :after_find,            :string ],
@@ -478,6 +591,34 @@ class CallbacksTest < ActiveRecord::TestCase
     ], david.history
   end
 
+  def test_callback_throwing_abort
+    david = CallbackDeveloperWithHaltedValidation.find(1)
+    david.save
+    assert_equal [
+      [ :after_find,        :method ],
+      [ :after_find,        :string ],
+      [ :after_find,        :proc   ],
+      [ :after_find,        :object ],
+      [ :after_find,        :block  ],
+      [ :after_initialize,  :method ],
+      [ :after_initialize,  :string ],
+      [ :after_initialize,  :proc   ],
+      [ :after_initialize,  :object ],
+      [ :after_initialize,  :block  ],
+      [ :before_validation, :method ],
+      [ :before_validation, :string ],
+      [ :before_validation, :proc   ],
+      [ :before_validation, :object ],
+      [ :before_validation, :block  ],
+      [ :before_validation, :throwing_abort ],
+      [ :after_rollback,    :block  ],
+      [ :after_rollback,    :object ],
+      [ :after_rollback,    :proc   ],
+      [ :after_rollback,    :string ],
+      [ :after_rollback,    :method ],
+    ], david.history
+  end
+
   def test_inheritance_of_callbacks
     parent = ParentDeveloper.new
     assert !parent.after_save_called
diff --git a/activerecord/test/cases/connection_adapters/connection_handler_test.rb b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
index 3e33b30144..b72f8ca88c 100644
--- a/activerecord/test/cases/connection_adapters/connection_handler_test.rb
+++ b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
@@ -44,9 +44,7 @@ module ActiveRecord
       end
 
       def test_connection_pools
-        assert_deprecated do
-          assert_equal({ Base.connection_pool.spec => @pool }, @handler.connection_pools)
-        end
+        assert_equal([@pool], @handler.connection_pools)
       end
     end
   end
diff --git a/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb b/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
index 37ad469476..9ee92a3cd2 100644
--- a/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
+++ b/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
@@ -51,34 +51,6 @@ module ActiveRecord
         assert_equal expected, actual
       end
 
-      def test_resolver_with_database_uri_and_and_current_env_string_key
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        config   = { "default_env" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
-        actual   = assert_deprecated { resolve_spec("default_env", config) }
-        expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
-        assert_equal expected, actual
-      end
-
-      def test_resolver_with_database_uri_and_and_current_env_string_key_and_rails_env
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        ENV['RAILS_ENV'] = "foo"
-
-        config   = { "not_production" => {"adapter" => "not_postgres", "database" => "not_foo" } }
-        actual   = assert_deprecated { resolve_spec("foo", config) }
-        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost" }
-        assert_equal expected, actual
-      end
-
-      def test_resolver_with_database_uri_and_and_current_env_string_key_and_rack_env
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        ENV['RACK_ENV'] = "foo"
-
-        config   = { "not_production" => {"adapter" => "not_postgres", "database" => "not_foo" } }
-        actual   = assert_deprecated { resolve_spec("foo", config) }
-        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost" }
-        assert_equal expected, actual
-      end
-
       def test_resolver_with_database_uri_and_known_key
         ENV['DATABASE_URL'] = "postgres://localhost/foo"
         config   = { "production" => { "adapter" => "not_postgres", "database" => "not_foo", "host" => "localhost" } }
@@ -95,16 +67,6 @@ module ActiveRecord
         end
       end
 
-      def test_resolver_with_database_uri_and_unknown_string_key
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        config   = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
-        assert_deprecated do
-          assert_raises AdapterNotSpecified do
-           resolve_spec("production", config)
-          end
-        end
-      end
-
       def test_resolver_with_database_uri_and_supplied_url
         ENV['DATABASE_URL'] = "not-postgres://not-localhost/not_foo"
         config   = { "production" => {  "adapter" => "also_not_postgres", "database" => "also_not_foo" } }
diff --git a/activerecord/test/cases/core_test.rb b/activerecord/test/cases/core_test.rb
index 715d92af99..3cb98832c5 100644
--- a/activerecord/test/cases/core_test.rb
+++ b/activerecord/test/cases/core_test.rb
@@ -98,4 +98,15 @@ class CoreTest < ActiveRecord::TestCase
     assert actual.start_with?(expected.split('XXXXXX').first)
     assert actual.end_with?(expected.split('XXXXXX').last)
   end
+
+  def test_pretty_print_overridden_by_inspect
+    subtopic = Class.new(Topic) do
+      def inspect
+        "inspecting topic"
+      end
+    end
+    actual = ''
+    PP.pp(subtopic.new, StringIO.new(actual))
+    assert_equal "inspecting topic\n", actual
+  end
 end
diff --git a/activerecord/test/cases/counter_cache_test.rb b/activerecord/test/cases/counter_cache_test.rb
index 07a182070b..1f5055b2a2 100644
--- a/activerecord/test/cases/counter_cache_test.rb
+++ b/activerecord/test/cases/counter_cache_test.rb
@@ -180,4 +180,22 @@ class CounterCacheTest < ActiveRecord::TestCase
       SpecialTopic.reset_counters(special.id, :lightweight_special_replies)
     end
   end
+
+  test "counters are updated both in memory and in the database on create" do
+    car = Car.new(engines_count: 0)
+    car.engines = [Engine.new, Engine.new]
+    car.save!
+
+    assert_equal 2, car.engines_count
+    assert_equal 2, car.reload.engines_count
+  end
+
+  test "counter caches are updated in memory when the default value is nil" do
+    car = Car.new(engines_count: nil)
+    car.engines = [Engine.new, Engine.new]
+    car.save!
+
+    assert_equal 2, car.engines_count
+    assert_equal 2, car.reload.engines_count
+  end
 end
diff --git a/activerecord/test/cases/date_time_test.rb b/activerecord/test/cases/date_time_test.rb
index 330232cee2..4cbff564aa 100644
--- a/activerecord/test/cases/date_time_test.rb
+++ b/activerecord/test/cases/date_time_test.rb
@@ -55,7 +55,7 @@ class DateTimeTest < ActiveRecord::TestCase
     now = DateTime.now
     with_timezone_config default: :local do
       task = Task.new starting: now
-      assert now, task.starting
+      assert_equal now, task.starting
     end
   end
 end
diff --git a/activerecord/test/cases/defaults_test.rb b/activerecord/test/cases/defaults_test.rb
index e9bc583bf4..b9db0d0123 100644
--- a/activerecord/test/cases/defaults_test.rb
+++ b/activerecord/test/cases/defaults_test.rb
@@ -40,7 +40,7 @@ class DefaultNumbersTest < ActiveRecord::TestCase
   end
 
   teardown do
-    @connection.drop_table "default_numbers" if @connection.table_exists? 'default_numbers'
+    @connection.drop_table :default_numbers, if_exists: true
   end
 
   def test_default_positive_integer
diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index 98cf60a8c4..192ba6f7cd 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -165,18 +165,6 @@ class DirtyTest < ActiveRecord::TestCase
     assert_equal parrot.name_change, parrot.title_change
   end
 
-  def test_reset_attribute!
-    pirate = Pirate.create!(:catchphrase => 'Yar!')
-    pirate.catchphrase = 'Ahoy!'
-
-    assert_deprecated do
-      pirate.reset_catchphrase!
-    end
-    assert_equal "Yar!", pirate.catchphrase
-    assert_equal Hash.new, pirate.changes
-    assert !pirate.catchphrase_changed?
-  end
-
   def test_restore_attribute!
     pirate = Pirate.create!(:catchphrase => 'Yar!')
     pirate.catchphrase = 'Ahoy!'
@@ -720,6 +708,27 @@ class DirtyTest < ActiveRecord::TestCase
     assert model.first_name_changed?
   end
 
+  test "attribute_will_change! doesn't try to save non-persistable attributes" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'people'
+      attribute :non_persisted_attribute, ActiveRecord::Type::String.new
+    end
+
+    record = klass.new(first_name: "Sean")
+    record.non_persisted_attribute_will_change!
+
+    assert record.non_persisted_attribute_changed?
+    assert record.save
+  end
+
+  test "mutating and then assigning doesn't remove the change" do
+    pirate = Pirate.create!(catchphrase: "arrrr")
+    pirate.catchphrase << " matey!"
+    pirate.catchphrase = "arrrr matey!"
+
+    assert pirate.catchphrase_changed?(from: "arrrr", to: "arrrr matey!")
+  end
+
   private
     def with_partial_writes(klass, on = true)
       old = klass.partial_writes?
diff --git a/activerecord/test/cases/explain_test.rb b/activerecord/test/cases/explain_test.rb
index 9d25bdd82a..f1d5511bb8 100644
--- a/activerecord/test/cases/explain_test.rb
+++ b/activerecord/test/cases/explain_test.rb
@@ -28,7 +28,7 @@ if ActiveRecord::Base.connection.supports_explain?
       assert_match "SELECT", sql
       if binds.any?
         assert_equal 1, binds.length
-        assert_equal "honda", binds.flatten.last
+        assert_equal "honda", binds.last.value
       else
         assert_match 'honda', sql
       end
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 02dc5d3ad3..39308866ee 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -55,7 +55,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_symbols_table_ref
-    gc_disabled = GC.disable if RUBY_VERSION >= '2.2.0'
+    gc_disabled = GC.disable
     Post.where("author_id" => nil)  # warm up
     x = Symbol.all_symbols.count
     Post.where("title" => {"xxxqqqq" => "bar"})
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index 9edeb8b47f..f41245dfd2 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -672,7 +672,8 @@ class FasterFixturesTest < ActiveRecord::TestCase
 end
 
 class FoxyFixturesTest < ActiveRecord::TestCase
-  fixtures :parrots, :parrots_pirates, :pirates, :treasures, :mateys, :ships, :computers, :developers, :"admin/accounts", :"admin/users"
+  fixtures :parrots, :parrots_pirates, :pirates, :treasures, :mateys, :ships, :computers,
+           :developers, :"admin/accounts", :"admin/users", :live_parrots, :dead_parrots
 
   if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
     require 'models/uuid_parent'
@@ -792,6 +793,10 @@ class FoxyFixturesTest < ActiveRecord::TestCase
     assert_equal("X marks the spot!", pirates(:mark).catchphrase)
   end
 
+  def test_supports_label_interpolation_for_fixnum_label
+    assert_equal("#1 pirate!", pirates(1).catchphrase)
+  end
+
   def test_supports_polymorphic_belongs_to
     assert_equal(pirates(:redbeard), treasures(:sapphire).looter)
     assert_equal(parrots(:louis), treasures(:ruby).looter)
@@ -808,6 +813,12 @@ class FoxyFixturesTest < ActiveRecord::TestCase
     assert_equal pirates(:blackbeard), parrots(:polly).killer
   end
 
+  def test_supports_sti_with_respective_files
+    assert_kind_of LiveParrot, live_parrots(:dusty)
+    assert_kind_of DeadParrot, dead_parrots(:deadbird)
+    assert_equal pirates(:blackbeard), dead_parrots(:deadbird).killer
+  end
+
   def test_namespaced_models
     assert admin_accounts(:signals37).users.include?(admin_users(:david))
     assert_equal 2, admin_accounts(:signals37).users.size
@@ -830,9 +841,9 @@ class CustomNameForFixtureOrModelTest < ActiveRecord::TestCase
   set_fixture_class :randomly_named_a9         =>
                         ClassNameThatDoesNotFollowCONVENTIONS,
                     :'admin/randomly_named_a9' =>
-                        Admin::ClassNameThatDoesNotFollowCONVENTIONS,
+                        Admin::ClassNameThatDoesNotFollowCONVENTIONS1,
                     'admin/randomly_named_b0'  =>
-                        Admin::ClassNameThatDoesNotFollowCONVENTIONS
+                        Admin::ClassNameThatDoesNotFollowCONVENTIONS2
 
   fixtures :randomly_named_a9, 'admin/randomly_named_a9',
            :'admin/randomly_named_b0'
@@ -843,15 +854,15 @@ class CustomNameForFixtureOrModelTest < ActiveRecord::TestCase
   end
 
   def test_named_accessor_for_randomly_named_namespaced_fixture_and_class
-    assert_kind_of Admin::ClassNameThatDoesNotFollowCONVENTIONS,
+    assert_kind_of Admin::ClassNameThatDoesNotFollowCONVENTIONS1,
                    admin_randomly_named_a9(:first_instance)
-    assert_kind_of Admin::ClassNameThatDoesNotFollowCONVENTIONS,
+    assert_kind_of Admin::ClassNameThatDoesNotFollowCONVENTIONS2,
                    admin_randomly_named_b0(:second_instance)
   end
 
   def test_table_name_is_defined_in_the_model
-    assert_equal 'randomly_named_table', ActiveRecord::FixtureSet::all_loaded_fixtures["admin/randomly_named_a9"].table_name
-    assert_equal 'randomly_named_table', Admin::ClassNameThatDoesNotFollowCONVENTIONS.table_name
+    assert_equal 'randomly_named_table2', ActiveRecord::FixtureSet::all_loaded_fixtures["admin/randomly_named_a9"].table_name
+    assert_equal 'randomly_named_table2', Admin::ClassNameThatDoesNotFollowCONVENTIONS1.table_name
   end
 end
 
diff --git a/activerecord/test/cases/helper.rb b/activerecord/test/cases/helper.rb
index 80ac57ec7c..0a577fa2f5 100644
--- a/activerecord/test/cases/helper.rb
+++ b/activerecord/test/cases/helper.rb
@@ -24,15 +24,15 @@ ActiveSupport::Deprecation.debug = true
 # Disable available locale checks to avoid warnings running the test suite.
 I18n.enforce_available_locales = false
 
-# Enable raise errors in after_commit and after_rollback.
-ActiveRecord::Base.raise_in_transactional_callbacks = true
-
 # Connect to the database
 ARTest.connect
 
 # Quote "type" if it's a reserved word for the current connection.
 QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type')
 
+# FIXME: Remove this when the deprecation cycle on TZ aware types by default ends.
+ActiveRecord::Base.time_zone_aware_types << :time
+
 def current_adapter?(*types)
   types.any? do |type|
     ActiveRecord::ConnectionAdapters.const_defined?(type) &&
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index fe6323ab02..6b18bfe84f 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -294,12 +294,12 @@ class InheritanceTest < ActiveRecord::TestCase
 
   def test_eager_load_belongs_to_something_inherited
     account = Account.all.merge!(:includes => :firm).find(1)
-    assert account.association_cache.key?(:firm), "nil proves eager load failed"
+    assert account.association(:firm).loaded?, "association was not eager loaded"
   end
 
   def test_alt_eager_loading
     cabbage = RedCabbage.all.merge!(:includes => :seller).find(4)
-    assert cabbage.association_cache.key?(:seller), "nil proves eager load failed"
+    assert cabbage.association(:seller).loaded?, "association was not eager loaded"
   end
 
   def test_eager_load_belongs_to_primary_key_quoting
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index ee43f07dd7..848174df06 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -215,10 +215,12 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   def test_lock_with_custom_column_without_default_sets_version_to_zero
     t1 = LockWithCustomColumnWithoutDefault.new
     assert_equal 0, t1.custom_lock_version
+    assert_nil t1.custom_lock_version_before_type_cast
 
-    t1.save
-    t1 = LockWithCustomColumnWithoutDefault.find(t1.id)
+    t1.save!
+    t1.reload
     assert_equal 0, t1.custom_lock_version
+    assert [0, "0"].include?(t1.custom_lock_version_before_type_cast)
   end
 
   def test_readonly_attributes
diff --git a/activerecord/test/cases/log_subscriber_test.rb b/activerecord/test/cases/log_subscriber_test.rb
index a578e81844..4192d12ff4 100644
--- a/activerecord/test/cases/log_subscriber_test.rb
+++ b/activerecord/test/cases/log_subscriber_test.rb
@@ -63,14 +63,6 @@ class LogSubscriberTest < ActiveRecord::TestCase
     assert_match(/ruby   rails/, logger.debugs.first)
   end
 
-  def test_ignore_binds_payload_with_nil_column
-    event = Struct.new(:duration, :payload)
-
-    logger = TestDebugLogSubscriber.new
-    logger.sql(event.new(0, sql: 'hi mom!', binds: [[nil, 1]]))
-    assert_equal 1, logger.debugs.length
-  end
-
   def test_basic_query_logging
     Developer.all.load
     wait
@@ -125,12 +117,5 @@ class LogSubscriberTest < ActiveRecord::TestCase
       wait
       assert_match(/<16 bytes of binary data>/, @logger.logged(:debug).join)
     end
-
-    def test_nil_binary_data_is_logged
-      binary = Binary.create(data: "")
-      binary.update_attributes(data: nil)
-      wait
-      assert_match(/<NULL binary data>/, @logger.logged(:debug).join)
-    end
   end
 end
diff --git a/activerecord/test/cases/migration/change_schema_test.rb b/activerecord/test/cases/migration/change_schema_test.rb
index d774cfebc4..3cd4073a38 100644
--- a/activerecord/test/cases/migration/change_schema_test.rb
+++ b/activerecord/test/cases/migration/change_schema_test.rb
@@ -68,8 +68,8 @@ module ActiveRecord
         five = columns.detect { |c| c.name == "five" } unless mysql
 
         assert_equal "hello", one.default
-        assert_equal true, two.type_cast_from_database(two.default)
-        assert_equal false, three.type_cast_from_database(three.default)
+        assert_equal true, connection.lookup_cast_type_from_column(two).type_cast_from_database(two.default)
+        assert_equal false, connection.lookup_cast_type_from_column(three).type_cast_from_database(three.default)
         assert_equal '1', four.default
         assert_equal "hello", five.default unless mysql
       end
@@ -82,7 +82,7 @@ module ActiveRecord
           columns = connection.columns(:testings)
           array_column = columns.detect { |c| c.name == "foo" }
 
-          assert array_column.array
+          assert array_column.array?
         end
 
         def test_create_table_with_array_column
@@ -93,7 +93,7 @@ module ActiveRecord
           columns = connection.columns(:testings)
           array_column = columns.detect { |c| c.name == "foo" }
 
-          assert array_column.array
+          assert array_column.array?
         end
       end
 
@@ -195,32 +195,29 @@ module ActiveRecord
       end
 
       def test_create_table_with_timestamps_should_create_datetime_columns
-        # FIXME: Remove the silence when we change the default `null` behavior
-        ActiveSupport::Deprecation.silence do
-          connection.create_table table_name do |t|
-            t.timestamps
-          end
+        connection.create_table table_name do |t|
+          t.timestamps
         end
         created_columns = connection.columns(table_name)
 
         created_at_column = created_columns.detect {|c| c.name == 'created_at' }
         updated_at_column = created_columns.detect {|c| c.name == 'updated_at' }
 
-        assert created_at_column.null
-        assert updated_at_column.null
+        assert !created_at_column.null
+        assert !updated_at_column.null
       end
 
       def test_create_table_with_timestamps_should_create_datetime_columns_with_options
         connection.create_table table_name do |t|
-          t.timestamps :null => false
+          t.timestamps null: true
         end
         created_columns = connection.columns(table_name)
 
         created_at_column = created_columns.detect {|c| c.name == 'created_at' }
         updated_at_column = created_columns.detect {|c| c.name == 'updated_at' }
 
-        assert !created_at_column.null
-        assert !updated_at_column.null
+        assert created_at_column.null
+        assert updated_at_column.null
       end
 
       def test_create_table_without_a_block
@@ -406,6 +403,17 @@ module ActiveRecord
         end
       end
 
+      def test_drop_table_if_exists
+        connection.create_table(:testings)
+        assert connection.table_exists?(:testings)
+        connection.drop_table(:testings, if_exists: true)
+        assert_not connection.table_exists?(:testings)
+      end
+
+      def test_drop_table_if_exists_nothing_raised
+        assert_nothing_raised { connection.drop_table(:nonexistent, if_exists: true) }
+      end
+
       private
       def testing_table_with_only_foo_attribute
         connection.create_table :testings, :id => false do |t|
@@ -429,7 +437,7 @@ module ActiveRecord
 
         teardown do
           [:wagons, :trains].each do |table|
-            @connection.drop_table(table) if @connection.table_exists?(table)
+            @connection.drop_table table, if_exists: true
           end
         end
 
diff --git a/activerecord/test/cases/migration/column_positioning_test.rb b/activerecord/test/cases/migration/column_positioning_test.rb
index 62186e13a5..4637970ce0 100644
--- a/activerecord/test/cases/migration/column_positioning_test.rb
+++ b/activerecord/test/cases/migration/column_positioning_test.rb
@@ -3,7 +3,7 @@ require 'cases/helper'
 module ActiveRecord
   class Migration
     class ColumnPositioningTest < ActiveRecord::TestCase
-      attr_reader :connection, :table_name
+      attr_reader :connection
       alias :conn :connection
 
       def setup
diff --git a/activerecord/test/cases/migration/columns_test.rb b/activerecord/test/cases/migration/columns_test.rb
index e6aa901814..54d3a729c3 100644
--- a/activerecord/test/cases/migration/columns_test.rb
+++ b/activerecord/test/cases/migration/columns_test.rb
@@ -196,7 +196,7 @@ module ActiveRecord
 
         old_columns = connection.columns(TestModel.table_name)
         assert old_columns.find { |c|
-          default = c.type_cast_from_database(c.default)
+          default = connection.lookup_cast_type_from_column(c).type_cast_from_database(c.default)
           c.name == 'approved' && c.type == :boolean && default == true
         }
 
@@ -204,11 +204,11 @@ module ActiveRecord
         new_columns = connection.columns(TestModel.table_name)
 
         assert_not new_columns.find { |c|
-          default = c.type_cast_from_database(c.default)
+          default = connection.lookup_cast_type_from_column(c).type_cast_from_database(c.default)
           c.name == 'approved' and c.type == :boolean and default == true
         }
         assert new_columns.find { |c|
-          default = c.type_cast_from_database(c.default)
+          default = connection.lookup_cast_type_from_column(c).type_cast_from_database(c.default)
           c.name == 'approved' and c.type == :boolean and default == false
         }
         change_column :test_models, :approved, :boolean, :default => true
diff --git a/activerecord/test/cases/migration/foreign_key_test.rb b/activerecord/test/cases/migration/foreign_key_test.rb
index 51e21528c2..78d9dd90a3 100644
--- a/activerecord/test/cases/migration/foreign_key_test.rb
+++ b/activerecord/test/cases/migration/foreign_key_test.rb
@@ -29,8 +29,8 @@ module ActiveRecord
 
       teardown do
         if defined?(@connection)
-          @connection.drop_table "astronauts" if @connection.table_exists? 'astronauts' 
-          @connection.drop_table "rockets" if @connection.table_exists? 'rockets'
+          @connection.drop_table "astronauts", if_exists: true
+          @connection.drop_table "rockets", if_exists: true
         end
       end
 
@@ -220,6 +220,18 @@ module ActiveRecord
       ensure
         silence_stream($stdout) { migration.migrate(:down) }
       end
+
+      private
+
+      def silence_stream(stream)
+        old_stream = stream.dup
+        stream.reopen(IO::NULL)
+        stream.sync = true
+        yield
+      ensure
+        stream.reopen(old_stream)
+        old_stream.close
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/migration/references_foreign_key_test.rb b/activerecord/test/cases/migration/references_foreign_key_test.rb
index bba8897a0d..99de7db70c 100644
--- a/activerecord/test/cases/migration/references_foreign_key_test.rb
+++ b/activerecord/test/cases/migration/references_foreign_key_test.rb
@@ -10,8 +10,8 @@ module ActiveRecord
       end
 
       teardown do
-        @connection.execute("drop table if exists testings")
-        @connection.execute("drop table if exists testing_parents")
+        @connection.drop_table("testings") if @connection.table_exists? "testings"
+        @connection.drop_table("testing_parents") if @connection.table_exists? "testing_parents"
       end
 
       test "foreign keys can be created with the table" do
diff --git a/activerecord/test/cases/migration/rename_table_test.rb b/activerecord/test/cases/migration/rename_table_test.rb
index c8b3f75e10..3eef308428 100644
--- a/activerecord/test/cases/migration/rename_table_test.rb
+++ b/activerecord/test/cases/migration/rename_table_test.rb
@@ -39,33 +39,35 @@ module ActiveRecord
         end
       end
 
-      def test_rename_table
-        rename_table :test_models, :octopi
+      unless current_adapter?(:FbAdapter) # Firebird cannot rename tables
+        def test_rename_table
+          rename_table :test_models, :octopi
 
-        connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
+          connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
 
-        assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', connection.select_value("SELECT url FROM octopi WHERE id=1")
-      end
+          assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', connection.select_value("SELECT url FROM octopi WHERE id=1")
+        end
 
-      def test_rename_table_with_an_index
-        add_index :test_models, :url
+        def test_rename_table_with_an_index
+          add_index :test_models, :url
 
-        rename_table :test_models, :octopi
+          rename_table :test_models, :octopi
 
-        connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
+          connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
 
-        assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', connection.select_value("SELECT url FROM octopi WHERE id=1")
-        index = connection.indexes(:octopi).first
-        assert index.columns.include?("url")
-        assert_equal 'index_octopi_on_url', index.name
-      end
+          assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', connection.select_value("SELECT url FROM octopi WHERE id=1")
+          index = connection.indexes(:octopi).first
+          assert index.columns.include?("url")
+          assert_equal 'index_octopi_on_url', index.name
+        end
 
-      def test_rename_table_does_not_rename_custom_named_index
-        add_index :test_models, :url, name: 'special_url_idx'
+        def test_rename_table_does_not_rename_custom_named_index
+          add_index :test_models, :url, name: 'special_url_idx'
 
-        rename_table :test_models, :octopi
+          rename_table :test_models, :octopi
 
-        assert_equal ['special_url_idx'], connection.indexes(:octopi).map(&:name)
+          assert_equal ['special_url_idx'], connection.indexes(:octopi).map(&:name)
+        end
       end
 
       if current_adapter?(:PostgreSQLAdapter)
@@ -84,8 +86,8 @@ module ActiveRecord
           assert connection.table_exists? :felines
         ensure
           disable_extension!('uuid-ossp', connection)
-          connection.drop_table :cats if connection.table_exists? :cats
-          connection.drop_table :felines if connection.table_exists? :felines
+          connection.drop_table :cats, if_exists: true
+          connection.drop_table :felines, if_exists: true
         end
       end
     end
diff --git a/activerecord/test/cases/migration/table_and_index_test.rb b/activerecord/test/cases/migration/table_and_index_test.rb
index 8fd770abd1..24cba84a09 100644
--- a/activerecord/test/cases/migration/table_and_index_test.rb
+++ b/activerecord/test/cases/migration/table_and_index_test.rb
@@ -6,11 +6,11 @@ module ActiveRecord
       def test_add_schema_info_respects_prefix_and_suffix
         conn = ActiveRecord::Base.connection
 
-        conn.drop_table(ActiveRecord::Migrator.schema_migrations_table_name) if conn.table_exists?(ActiveRecord::Migrator.schema_migrations_table_name)
+        conn.drop_table(ActiveRecord::Migrator.schema_migrations_table_name, if_exists: true)
         # Use shorter prefix and suffix as in Oracle database identifier cannot be larger than 30 characters
         ActiveRecord::Base.table_name_prefix = 'p_'
         ActiveRecord::Base.table_name_suffix = '_s'
-        conn.drop_table(ActiveRecord::Migrator.schema_migrations_table_name) if conn.table_exists?(ActiveRecord::Migrator.schema_migrations_table_name)
+        conn.drop_table(ActiveRecord::Migrator.schema_migrations_table_name, if_exists: true)
 
         conn.initialize_schema_migrations_table
 
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index 3192b797b4..6ea8b93be7 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -90,7 +90,7 @@ class MigrationTest < ActiveRecord::TestCase
   end
 
   def test_migration_detection_without_schema_migration_table
-    ActiveRecord::Base.connection.drop_table('schema_migrations') if ActiveRecord::Base.connection.table_exists?('schema_migrations')
+    ActiveRecord::Base.connection.drop_table 'schema_migrations', if_exists: true
 
     migrations_path = MIGRATIONS_ROOT + "/valid"
     old_path = ActiveRecord::Migrator.migrations_paths
@@ -162,6 +162,7 @@ class MigrationTest < ActiveRecord::TestCase
 
     assert !BigNumber.table_exists?
     GiveMeBigNumbers.up
+    BigNumber.reset_column_information
 
     assert BigNumber.create(
       :bank_balance => 1586.43,
@@ -397,6 +398,7 @@ class MigrationTest < ActiveRecord::TestCase
     Thing.reset_table_name
     Thing.reset_sequence_name
     WeNeedThings.up
+    Thing.reset_column_information
 
     assert Thing.create("content" => "hello world")
     assert_equal "hello world", Thing.first.content
@@ -416,6 +418,7 @@ class MigrationTest < ActiveRecord::TestCase
     ActiveRecord::Base.table_name_suffix = '_suffix'
     Reminder.reset_table_name
     Reminder.reset_sequence_name
+    Reminder.reset_column_information
     WeNeedReminders.up
     assert Reminder.create("content" => "hello world", "remind_at" => Time.now)
     assert_equal "hello world", Reminder.first.content
@@ -936,4 +939,14 @@ class CopyMigrationsTest < ActiveRecord::TestCase
       end
     end
   end
+
+  def silence_stream(stream)
+    old_stream = stream.dup
+    stream.reopen(IO::NULL)
+    stream.sync = true
+    yield
+  ensure
+    stream.reopen(old_stream)
+    old_stream.close
+  end
 end
diff --git a/activerecord/test/cases/multiparameter_attributes_test.rb b/activerecord/test/cases/multiparameter_attributes_test.rb
index 14d4ef457d..4aaf6f8b5f 100644
--- a/activerecord/test/cases/multiparameter_attributes_test.rb
+++ b/activerecord/test/cases/multiparameter_attributes_test.rb
@@ -250,8 +250,8 @@ class MultiParameterAttributeTest < ActiveRecord::TestCase
         }
         topic = Topic.find(1)
         topic.attributes = attributes
-        assert_equal Time.utc(2000, 1, 1, 16, 24, 0), topic.bonus_time
-        assert topic.bonus_time.utc?
+        assert_equal Time.zone.local(2000, 1, 1, 16, 24, 0), topic.bonus_time
+        assert_not topic.bonus_time.utc?
       end
     end
   end
diff --git a/activerecord/test/cases/multiple_db_test.rb b/activerecord/test/cases/multiple_db_test.rb
index 3831de6ae3..15c60d5562 100644
--- a/activerecord/test/cases/multiple_db_test.rb
+++ b/activerecord/test/cases/multiple_db_test.rb
@@ -93,6 +93,13 @@ class MultipleDbTest < ActiveRecord::TestCase
     assert_not_equal Entrant.arel_engine.connection, Course.arel_engine.connection
   end
 
+  def test_count_on_custom_connection
+    ActiveRecord::Base.remove_connection
+    assert_equal 1, College.count
+  ensure
+    ActiveRecord::Base.establish_connection :arunit
+  end
+
   unless in_memory_db?
     def test_associations_should_work_when_model_has_no_connection
       begin
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index 5c7e8a65d2..198cd6f341 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -672,7 +672,7 @@ module NestedAttributesOnACollectionAssociationTests
   end
 
   def test_should_not_assign_destroy_key_to_a_record
-    assert_nothing_raised ActiveRecord::UnknownAttributeError do
+    assert_nothing_raised ActiveModel::AttributeAssignment::UnknownAttributeError do
       @pirate.send(association_setter, { 'foo' => { '_destroy' => '0' }})
     end
   end
@@ -1037,4 +1037,21 @@ class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveR
     ShipPart.create!(:ship => @ship, :name => "Stern")
     assert_no_queries { @ship.valid? }
   end
+
+  test "circular references do not perform unnecessary queries" do
+    ship = Ship.new(name: "The Black Rock")
+    part = ship.parts.build(name: "Stern")
+    ship.treasures.build(looter: part)
+
+    assert_queries 3 do
+      ship.save!
+    end
+  end
+
+  test "nested singular associations are validated" do
+    part = ShipPart.new(name: "Stern", ship_attributes: { name: nil })
+
+    assert_not part.valid?
+    assert_equal ["Ship name can't be blank"], part.errors.full_messages
+  end
 end
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index d6816041bc..2803ad2de0 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -356,6 +356,16 @@ class PersistenceTest < ActiveRecord::TestCase
     assert_equal("David", topic_reloaded.author_name)
   end
 
+  def test_update_attribute_does_not_run_sql_if_attribute_is_not_changed
+    klass = Class.new(Topic) do
+      def self.name; 'Topic'; end
+    end
+    topic = klass.create(title: 'Another New Topic')
+    assert_queries(0) do
+      topic.update_attribute(:title, 'Another New Topic')
+    end
+  end
+
   def test_delete
     topic = Topic.find(1)
     assert_equal topic, topic.delete, 'topic.delete did not return self'
diff --git a/activerecord/test/cases/primary_keys_test.rb b/activerecord/test/cases/primary_keys_test.rb
index 751eccc015..4b668f84dd 100644
--- a/activerecord/test/cases/primary_keys_test.rb
+++ b/activerecord/test/cases/primary_keys_test.rb
@@ -210,7 +210,7 @@ class PrimaryKeyAnyTypeTest < ActiveRecord::TestCase
   end
 
   teardown do
-    @connection.execute("DROP TABLE IF EXISTS barcodes")
+    @connection.drop_table(:barcodes) if @connection.table_exists? :barcodes
   end
 
   def test_any_type_primary_key
diff --git a/activerecord/test/cases/quoting_test.rb b/activerecord/test/cases/quoting_test.rb
index 1d6ae2f67f..ad09340518 100644
--- a/activerecord/test/cases/quoting_test.rb
+++ b/activerecord/test/cases/quoting_test.rb
@@ -125,14 +125,11 @@ module ActiveRecord
       end
 
       def test_crazy_object
-        crazy = Class.new.new
-        expected = "'#{YAML.dump(crazy)}'"
-        assert_equal expected, @quoter.quote(crazy, nil)
-      end
-
-      def test_crazy_object_calls_quote_string
-        crazy = Class.new { def initialize; @lol = 'lo\l' end }.new
-        assert_match "lo\\\\l", @quoter.quote(crazy, nil)
+        crazy = Object.new
+        e = assert_raises(TypeError) do
+          @quoter.quote(crazy, nil)
+        end
+        assert_equal "can't quote Object", e.message
       end
 
       def test_quote_string_no_column
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index e86b892a0a..b0e40c7145 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -80,10 +80,21 @@ class ReflectionTest < ActiveRecord::TestCase
     assert_equal :integer, @first.column_for_attribute("id").type
   end
 
-  def test_non_existent_columns_return_nil
-    assert_deprecated do
-      assert_nil @first.column_for_attribute("attribute_that_doesnt_exist")
-    end
+  def test_non_existent_columns_return_null_object
+    column = @first.column_for_attribute("attribute_that_doesnt_exist")
+    assert_instance_of ActiveRecord::ConnectionAdapters::NullColumn, column
+    assert_equal "attribute_that_doesnt_exist", column.name
+    assert_equal nil, column.sql_type
+    assert_equal nil, column.type
+  end
+
+  def test_non_existent_types_are_identity_types
+    type = @first.type_for_attribute("attribute_that_doesnt_exist")
+    object = Object.new
+
+    assert_equal object, type.type_cast_from_database(object)
+    assert_equal object, type.type_cast_from_user(object)
+    assert_equal object, type.type_cast_for_database(object)
   end
 
   def test_reflection_klass_for_nested_class_name
diff --git a/activerecord/test/cases/relation/merging_test.rb b/activerecord/test/cases/relation/merging_test.rb
index eb76ef6328..0a2e874e4f 100644
--- a/activerecord/test/cases/relation/merging_test.rb
+++ b/activerecord/test/cases/relation/merging_test.rb
@@ -82,26 +82,15 @@ class RelationMergingTest < ActiveRecord::TestCase
     left  = Post.where(title: "omg").where(comments_count: 1)
     right = Post.where(title: "wtf").where(title: "bbq")
 
-    expected = [left.bind_values[1]] + right.bind_values
+    expected = [left.bound_attributes[1]] + right.bound_attributes
     merged   = left.merge(right)
 
-    assert_equal expected, merged.bind_values
+    assert_equal expected, merged.bound_attributes
     assert !merged.to_sql.include?("omg")
     assert merged.to_sql.include?("wtf")
     assert merged.to_sql.include?("bbq")
   end
 
-  def test_merging_keeps_lhs_bind_parameters
-    column = Post.columns_hash['id']
-    binds = [[column, 20]]
-
-    right  = Post.where(id: 20)
-    left   = Post.where(id: 10)
-
-    merged = left.merge(right)
-    assert_equal binds, merged.bind_values
-  end
-
   def test_merging_reorders_bind_params
     post  = Post.first
     right = Post.where(id: 1)
diff --git a/activerecord/test/cases/relation/mutation_test.rb b/activerecord/test/cases/relation/mutation_test.rb
index 2443f10269..45ead08bd5 100644
--- a/activerecord/test/cases/relation/mutation_test.rb
+++ b/activerecord/test/cases/relation/mutation_test.rb
@@ -81,7 +81,7 @@ module ActiveRecord
       assert_equal [], relation.extending_values
     end
 
-    (Relation::SINGLE_VALUE_METHODS - [:from, :lock, :reordering, :reverse_order, :create_with]).each do |method|
+    (Relation::SINGLE_VALUE_METHODS - [:lock, :reordering, :reverse_order, :create_with]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal :foo, relation.public_send("#{method}_value")
@@ -90,7 +90,7 @@ module ActiveRecord
 
     test '#from!' do
       assert relation.from!('foo').equal?(relation)
-      assert_equal ['foo', nil], relation.from_value
+      assert_equal 'foo', relation.from_clause.value
     end
 
     test '#lock!' do
@@ -136,12 +136,12 @@ module ActiveRecord
     end
 
     test 'test_merge!' do
-      assert relation.merge!(where: :foo).equal?(relation)
-      assert_equal [:foo], relation.where_values
+      assert relation.merge!(select: :foo).equal?(relation)
+      assert_equal [:foo], relation.select_values
     end
 
     test 'merge with a proc' do
-      assert_equal [:foo], relation.merge(-> { where(:foo) }).where_values
+      assert_equal [:foo], relation.merge(-> { select(:foo) }).select_values
     end
 
     test 'none!' do
diff --git a/activerecord/test/cases/relation/or_test.rb b/activerecord/test/cases/relation/or_test.rb
new file mode 100644
index 0000000000..2006fc9611
--- /dev/null
+++ b/activerecord/test/cases/relation/or_test.rb
@@ -0,0 +1,84 @@
+require "cases/helper"
+require 'models/post'
+
+module ActiveRecord
+  class OrTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    def test_or_with_relation
+      expected = Post.where('id = 1 or id = 2').to_a
+      assert_equal expected, Post.where('id = 1').or(Post.where('id = 2')).to_a
+    end
+
+    def test_or_identity
+      expected = Post.where('id = 1').to_a
+      assert_equal expected, Post.where('id = 1').or(Post.where('id = 1')).to_a
+    end
+
+    def test_or_with_null_left
+      expected = Post.where('id = 1').to_a
+      assert_equal expected, Post.none.or(Post.where('id = 1')).to_a
+    end
+
+    def test_or_with_null_right
+      expected = Post.where('id = 1').to_a
+      assert_equal expected, Post.where('id = 1').or(Post.none).to_a
+    end
+
+    def test_or_with_bind_params
+      assert_equal Post.find([1, 2]), Post.where(id: 1).or(Post.where(id: 2)).to_a
+    end
+
+    def test_or_with_null_both
+      expected = Post.none.to_a
+      assert_equal expected, Post.none.or(Post.none).to_a
+    end
+
+    def test_or_without_left_where
+      expected = Post.all
+      assert_equal expected, Post.or(Post.where('id = 1')).to_a
+    end
+
+    def test_or_without_right_where
+      expected = Post.all
+      assert_equal expected, Post.where('id = 1').or(Post.all).to_a
+    end
+
+    def test_or_preserves_other_querying_methods
+      expected = Post.where('id = 1 or id = 2 or id = 3').order('body asc').to_a
+      partial = Post.order('body asc')
+      assert_equal expected, partial.where('id = 1').or(partial.where(:id => [2, 3])).to_a
+      assert_equal expected, Post.order('body asc').where('id = 1').or(Post.order('body asc').where(:id => [2, 3])).to_a
+    end
+
+    def test_or_with_incompatible_relations
+      assert_raises ArgumentError do
+        Post.order('body asc').where('id = 1').or(Post.order('id desc').where(:id => [2, 3])).to_a
+      end
+    end
+
+    def test_or_when_grouping
+      groups = Post.where('id < 10').group('body').select('body, COUNT(*) AS c')
+      expected = groups.having("COUNT(*) > 1 OR body like 'Such%'").to_a.map {|o| [o.body, o.c] }
+      assert_equal expected, groups.having('COUNT(*) > 1').or(groups.having("body like 'Such%'")).to_a.map {|o| [o.body, o.c] }
+    end
+
+    def test_or_with_named_scope
+      expected = Post.where("id = 1 or body LIKE '\%a\%'").to_a
+      assert_equal expected, Post.where('id = 1').or(Post.containing_the_letter_a)
+    end
+
+    def test_or_inside_named_scope
+      expected = Post.where("body LIKE '\%a\%' OR title LIKE ?", "%'%").order('id DESC').to_a
+      assert_equal expected, Post.order(id: :desc).typographically_interesting
+    end
+
+    def test_or_on_loaded_relation
+      expected = Post.where('id = 1 or id = 2').to_a
+      p = Post.where('id = 1')
+      p.load
+      assert_equal p.loaded?, true
+      assert_equal expected, p.or(Post.where('id = 2')).to_a
+    end
+  end
+end
diff --git a/activerecord/test/cases/relation/predicate_builder_test.rb b/activerecord/test/cases/relation/predicate_builder_test.rb
index 0cc081fced..8f62014622 100644
--- a/activerecord/test/cases/relation/predicate_builder_test.rb
+++ b/activerecord/test/cases/relation/predicate_builder_test.rb
@@ -8,7 +8,7 @@ module ActiveRecord
         Arel::Nodes::InfixOperation.new('~', column, Arel.sql(value.source))
       end)
 
-      assert_match %r{["`]topics["`].["`]title["`] ~ rails}i, Topic.where(title: /rails/).to_sql
+      assert_match %r{["`]topics["`]\.["`]title["`] ~ rails}i, Topic.where(title: /rails/).to_sql
     ensure
       Topic.reset_column_information
     end
diff --git a/activerecord/test/cases/relation/where_chain_test.rb b/activerecord/test/cases/relation/where_chain_test.rb
index 619055f1e7..27bbd80f79 100644
--- a/activerecord/test/cases/relation/where_chain_test.rb
+++ b/activerecord/test/cases/relation/where_chain_test.rb
@@ -11,22 +11,11 @@ module ActiveRecord
       @name = 'title'
     end
 
-    def test_not_eq
+    def test_not_inverts_where_clause
       relation = Post.where.not(title: 'hello')
+      expected_where_clause = Post.where(title: 'hello').where_clause.invert
 
-      assert_equal 1, relation.where_values.length
-
-      value = relation.where_values.first
-      bind  = relation.bind_values.first
-
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
-      assert_equal 'hello', bind.last
-    end
-
-    def test_not_null
-      expected = Post.arel_table[@name].not_eq(nil)
-      relation = Post.where.not(title: nil)
-      assert_equal([expected], relation.where_values)
+      assert_equal expected_where_clause, relation.where_clause
     end
 
     def test_not_with_nil
@@ -35,146 +24,81 @@ module ActiveRecord
       end
     end
 
-    def test_not_in
-      expected = Post.arel_table[@name].not_in(%w[hello goodbye])
-      relation = Post.where.not(title: %w[hello goodbye])
-      assert_equal([expected], relation.where_values)
-    end
-
     def test_association_not_eq
-      expected = Comment.arel_table[@name].not_eq('hello')
+      expected = Arel::Nodes::Grouping.new(Comment.arel_table[@name].not_eq(Arel::Nodes::BindParam.new))
       relation = Post.joins(:comments).where.not(comments: {title: 'hello'})
-      assert_equal(expected.to_sql, relation.where_values.first.to_sql)
+      assert_equal(expected.to_sql, relation.where_clause.ast.to_sql)
     end
 
     def test_not_eq_with_preceding_where
       relation = Post.where(title: 'hello').where.not(title: 'world')
+      expected_where_clause =
+        Post.where(title: 'hello').where_clause +
+        Post.where(title: 'world').where_clause.invert
 
-      value = relation.where_values.first
-      bind  = relation.bind_values.first
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
-      assert_equal 'hello', bind.last
-
-      value = relation.where_values.last
-      bind  = relation.bind_values.last
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
-      assert_equal 'world', bind.last
+      assert_equal expected_where_clause, relation.where_clause
     end
 
     def test_not_eq_with_succeeding_where
       relation = Post.where.not(title: 'hello').where(title: 'world')
+      expected_where_clause =
+        Post.where(title: 'hello').where_clause.invert +
+        Post.where(title: 'world').where_clause
 
-      value = relation.where_values.first
-      bind  = relation.bind_values.first
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
-      assert_equal 'hello', bind.last
-
-      value = relation.where_values.last
-      bind  = relation.bind_values.last
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
-      assert_equal 'world', bind.last
-    end
-
-    def test_not_eq_with_string_parameter
-      expected = Arel::Nodes::Not.new("title = 'hello'")
-      relation = Post.where.not("title = 'hello'")
-      assert_equal([expected], relation.where_values)
-    end
-
-    def test_not_eq_with_array_parameter
-      expected = Arel::Nodes::Not.new("title = 'hello'")
-      relation = Post.where.not(['title = ?', 'hello'])
-      assert_equal([expected], relation.where_values)
+      assert_equal expected_where_clause, relation.where_clause
     end
 
     def test_chaining_multiple
       relation = Post.where.not(author_id: [1, 2]).where.not(title: 'ruby on rails')
+      expected_where_clause =
+        Post.where(author_id: [1, 2]).where_clause.invert +
+        Post.where(title: 'ruby on rails').where_clause.invert
 
-      expected = Post.arel_table['author_id'].not_in([1, 2])
-      assert_equal(expected, relation.where_values[0])
-
-      value = relation.where_values[1]
-      bind  = relation.bind_values.first
-
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
-      assert_equal 'ruby on rails', bind.last
+      assert_equal expected_where_clause, relation.where_clause
     end
 
     def test_rewhere_with_one_condition
       relation = Post.where(title: 'hello').where(title: 'world').rewhere(title: 'alone')
+      expected = Post.where(title: 'alone')
 
-      assert_equal 1, relation.where_values.size
-      value = relation.where_values.first
-      bind = relation.bind_values.first
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
-      assert_equal 'alone', bind.last
+      assert_equal expected.where_clause, relation.where_clause
     end
 
     def test_rewhere_with_multiple_overwriting_conditions
       relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone', body: 'again')
+      expected = Post.where(title: 'alone', body: 'again')
 
-      assert_equal 2, relation.where_values.size
-
-      value = relation.where_values.first
-      bind = relation.bind_values.first
-      assert_bound_ast value, Post.arel_table['title'], Arel::Nodes::Equality
-      assert_equal 'alone', bind.last
-
-      value = relation.where_values[1]
-      bind = relation.bind_values[1]
-      assert_bound_ast value, Post.arel_table['body'], Arel::Nodes::Equality
-      assert_equal 'again', bind.last
-    end
-
-    def assert_bound_ast value, table, type
-      assert_equal table, value.left
-      assert_kind_of type, value
-      assert_kind_of Arel::Nodes::BindParam, value.right
+      assert_equal expected.where_clause, relation.where_clause
     end
 
     def test_rewhere_with_one_overwriting_condition_and_one_unrelated
       relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone')
+      expected = Post.where(body: 'world', title: 'alone')
 
-      assert_equal 2, relation.where_values.size
-
-      value = relation.where_values.first
-      bind  = relation.bind_values.first
-
-      assert_bound_ast value, Post.arel_table['body'], Arel::Nodes::Equality
-      assert_equal 'world', bind.last
-
-      value = relation.where_values.second
-      bind  = relation.bind_values.second
-
-      assert_bound_ast value, Post.arel_table['title'], Arel::Nodes::Equality
-      assert_equal 'alone', bind.last
+      assert_equal expected.where_clause, relation.where_clause
     end
 
     def test_rewhere_with_range
       relation = Post.where(comments_count: 1..3).rewhere(comments_count: 3..5)
 
-      assert_equal 1, relation.where_values.size
       assert_equal Post.where(comments_count: 3..5), relation
     end
 
     def test_rewhere_with_infinite_upper_bound_range
       relation = Post.where(comments_count: 1..Float::INFINITY).rewhere(comments_count: 3..5)
 
-      assert_equal 1, relation.where_values.size
       assert_equal Post.where(comments_count: 3..5), relation
     end
 
     def test_rewhere_with_infinite_lower_bound_range
       relation = Post.where(comments_count: -Float::INFINITY..1).rewhere(comments_count: 3..5)
 
-      assert_equal 1, relation.where_values.size
       assert_equal Post.where(comments_count: 3..5), relation
     end
 
     def test_rewhere_with_infinite_range
       relation = Post.where(comments_count: -Float::INFINITY..Float::INFINITY).rewhere(comments_count: 3..5)
 
-      assert_equal 1, relation.where_values.size
       assert_equal Post.where(comments_count: 3..5), relation
     end
   end
diff --git a/activerecord/test/cases/relation/where_clause_test.rb b/activerecord/test/cases/relation/where_clause_test.rb
new file mode 100644
index 0000000000..c20ed94d90
--- /dev/null
+++ b/activerecord/test/cases/relation/where_clause_test.rb
@@ -0,0 +1,182 @@
+require "cases/helper"
+
+class ActiveRecord::Relation
+  class WhereClauseTest < ActiveRecord::TestCase
+    test "+ combines two where clauses" do
+      first_clause = WhereClause.new([table["id"].eq(bind_param)], [["id", 1]])
+      second_clause = WhereClause.new([table["name"].eq(bind_param)], [["name", "Sean"]])
+      combined = WhereClause.new(
+        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
+        [["id", 1], ["name", "Sean"]],
+      )
+
+      assert_equal combined, first_clause + second_clause
+    end
+
+    test "+ is associative, but not commutative" do
+      a = WhereClause.new(["a"], ["bind a"])
+      b = WhereClause.new(["b"], ["bind b"])
+      c = WhereClause.new(["c"], ["bind c"])
+
+      assert_equal a + (b + c), (a + b) + c
+      assert_not_equal a + b, b + a
+    end
+
+    test "an empty where clause is the identity value for +" do
+      clause = WhereClause.new([table["id"].eq(bind_param)], [["id", 1]])
+
+      assert_equal clause, clause + WhereClause.empty
+    end
+
+    test "merge combines two where clauses" do
+      a = WhereClause.new([table["id"].eq(1)], [])
+      b = WhereClause.new([table["name"].eq("Sean")], [])
+      expected = WhereClause.new([table["id"].eq(1), table["name"].eq("Sean")], [])
+
+      assert_equal expected, a.merge(b)
+    end
+
+    test "merge keeps the right side, when two equality clauses reference the same column" do
+      a = WhereClause.new([table["id"].eq(1), table["name"].eq("Sean")], [])
+      b = WhereClause.new([table["name"].eq("Jim")], [])
+      expected = WhereClause.new([table["id"].eq(1), table["name"].eq("Jim")], [])
+
+      assert_equal expected, a.merge(b)
+    end
+
+    test "merge removes bind parameters matching overlapping equality clauses" do
+      a = WhereClause.new(
+        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
+        [attribute("id", 1), attribute("name", "Sean")],
+      )
+      b = WhereClause.new(
+        [table["name"].eq(bind_param)],
+        [attribute("name", "Jim")]
+      )
+      expected = WhereClause.new(
+        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
+        [attribute("id", 1), attribute("name", "Jim")],
+      )
+
+      assert_equal expected, a.merge(b)
+    end
+
+    test "merge allows for columns with the same name from different tables" do
+      skip "This is not possible as of 4.2, and the binds do not yet contain sufficient information for this to happen"
+      # We might be able to change the implementation to remove conflicts by index, rather than column name
+    end
+
+    test "a clause knows if it is empty" do
+      assert WhereClause.empty.empty?
+      assert_not WhereClause.new(["anything"], []).empty?
+    end
+
+    test "invert cannot handle nil" do
+      where_clause = WhereClause.new([nil], [])
+
+      assert_raises ArgumentError do
+        where_clause.invert
+      end
+    end
+
+    test "invert replaces each part of the predicate with its inverse" do
+      random_object = Object.new
+      original = WhereClause.new([
+        table["id"].in([1, 2, 3]),
+        table["id"].eq(1),
+        "sql literal",
+        random_object
+      ], [])
+      expected = WhereClause.new([
+        table["id"].not_in([1, 2, 3]),
+        table["id"].not_eq(1),
+        Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new("sql literal")),
+        Arel::Nodes::Not.new(random_object)
+      ], [])
+
+      assert_equal expected, original.invert
+    end
+
+    test "accept removes binary predicates referencing a given column" do
+      where_clause = WhereClause.new([
+        table["id"].in([1, 2, 3]),
+        table["name"].eq(bind_param),
+        table["age"].gteq(bind_param),
+      ], [
+        attribute("name", "Sean"),
+        attribute("age", 30),
+      ])
+      expected = WhereClause.new([table["age"].gteq(bind_param)], [attribute("age", 30)])
+
+      assert_equal expected, where_clause.except("id", "name")
+    end
+
+    test "ast groups its predicates with AND" do
+      predicates = [
+        table["id"].in([1, 2, 3]),
+        table["name"].eq(bind_param),
+      ]
+      where_clause = WhereClause.new(predicates, [])
+      expected = Arel::Nodes::And.new(predicates)
+
+      assert_equal expected, where_clause.ast
+    end
+
+    test "ast wraps any SQL literals in parenthesis" do
+      random_object = Object.new
+      where_clause = WhereClause.new([
+        table["id"].in([1, 2, 3]),
+        "foo = bar",
+        random_object,
+      ], [])
+      expected = Arel::Nodes::And.new([
+        table["id"].in([1, 2, 3]),
+        Arel::Nodes::Grouping.new(Arel.sql("foo = bar")),
+        Arel::Nodes::Grouping.new(random_object),
+      ])
+
+      assert_equal expected, where_clause.ast
+    end
+
+    test "ast removes any empty strings" do
+      where_clause = WhereClause.new([table["id"].in([1, 2, 3])], [])
+      where_clause_with_empty = WhereClause.new([table["id"].in([1, 2, 3]), ''], [])
+
+      assert_equal where_clause.ast, where_clause_with_empty.ast
+    end
+
+    test "or joins the two clauses using OR" do
+      where_clause = WhereClause.new([table["id"].eq(bind_param)], [attribute("id", 1)])
+      other_clause = WhereClause.new([table["name"].eq(bind_param)], [attribute("name", "Sean")])
+      expected_ast =
+        Arel::Nodes::Grouping.new(
+          Arel::Nodes::Or.new(table["id"].eq(bind_param), table["name"].eq(bind_param))
+        )
+      expected_binds = where_clause.binds + other_clause.binds
+
+      assert_equal expected_ast.to_sql, where_clause.or(other_clause).ast.to_sql
+      assert_equal expected_binds, where_clause.or(other_clause).binds
+    end
+
+    test "or returns an empty where clause when either side is empty" do
+      where_clause = WhereClause.new([table["id"].eq(bind_param)], [attribute("id", 1)])
+
+      assert_equal WhereClause.empty, where_clause.or(WhereClause.empty)
+      assert_equal WhereClause.empty, WhereClause.empty.or(where_clause)
+    end
+
+    private
+
+    def table
+      Arel::Table.new("table")
+    end
+
+    def bind_param
+      Arel::Nodes::BindParam.new
+    end
+
+    def attribute(name, value)
+      ActiveRecord::Attribute.with_cast_value(name, value, ActiveRecord::Type::Value.new)
+    end
+  end
+end
diff --git a/activerecord/test/cases/relation/where_test.rb b/activerecord/test/cases/relation/where_test.rb
index d675953da6..537937decd 100644
--- a/activerecord/test/cases/relation/where_test.rb
+++ b/activerecord/test/cases/relation/where_test.rb
@@ -1,13 +1,15 @@
 require "cases/helper"
-require 'models/author'
-require 'models/price_estimate'
-require 'models/treasure'
-require 'models/post'
-require 'models/comment'
-require 'models/edge'
-require 'models/topic'
-require 'models/binary'
-require 'models/vertex'
+require "models/author"
+require "models/binary"
+require "models/cake_designer"
+require "models/chef"
+require "models/comment"
+require "models/edge"
+require "models/post"
+require "models/price_estimate"
+require "models/topic"
+require "models/treasure"
+require "models/vertex"
 
 module ActiveRecord
   class WhereTest < ActiveRecord::TestCase
@@ -26,6 +28,24 @@ module ActiveRecord
       }
     end
 
+    def test_where_copies_bind_params_in_the_right_order
+      author = authors(:david)
+      posts = author.posts.where.not(id: 1)
+      joined = Post.where(id: posts, title: posts.first.title)
+
+      assert_equal joined, [posts.first]
+    end
+
+    def test_where_copies_arel_bind_params
+      chef = Chef.create!
+      CakeDesigner.create!(chef: chef)
+
+      cake_designers = CakeDesigner.joins(:chef).where(chefs: { id: chef.id })
+      chefs = Chef.where(employable: cake_designers)
+
+      assert_equal [chef], chefs.to_a
+    end
+
     def test_rewhere_on_root
       assert_equal posts(:welcome), Post.rewhere(title: 'Welcome to the weblog').first
     end
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index f7cb471984..194faa9473 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -156,12 +156,12 @@ module ActiveRecord
       relation = Relation.new(FakeKlass, :b, nil)
       relation = relation.merge where: :lol, readonly: true
 
-      assert_equal [:lol], relation.where_values
+      assert_equal Relation::WhereClause.new([:lol], []), relation.where_clause
       assert_equal true, relation.readonly_value
     end
 
     test 'merging an empty hash into a relation' do
-      assert_equal [], Relation.new(FakeKlass, :b, nil).merge({}).where_values
+      assert_equal Relation::WhereClause.empty, Relation.new(FakeKlass, :b, nil).merge({}).where_clause
     end
 
     test 'merging a hash with unknown keys raises' do
@@ -173,18 +173,12 @@ module ActiveRecord
       values   = relation.values
 
       values[:where] = nil
-      assert_not_nil relation.where_values
+      assert_not_nil relation.where_clause
     end
 
     test 'relations can be created with a values hash' do
-      relation = Relation.new(FakeKlass, :b, nil, where: [:foo])
-      assert_equal [:foo], relation.where_values
-    end
-
-    test 'merging a single where value' do
-      relation = Relation.new(FakeKlass, :b, nil)
-      relation.merge!(where: :foo)
-      assert_equal [:foo], relation.where_values
+      relation = Relation.new(FakeKlass, :b, nil, select: [:foo])
+      assert_equal [:foo], relation.select_values
     end
 
     test 'merging a hash interpolates conditions' do
@@ -197,7 +191,7 @@ module ActiveRecord
 
       relation = Relation.new(klass, :b, nil)
       relation.merge!(where: ['foo = ?', 'bar'])
-      assert_equal ['foo = bar'], relation.where_values
+      assert_equal Relation::WhereClause.new(['foo = bar'], []), relation.where_clause
     end
 
     def test_merging_readonly_false
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index fb9258c038..5c5ab499a0 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -16,6 +16,7 @@ require 'models/engine'
 require 'models/tyre'
 require 'models/minivan'
 require 'models/aircraft'
+require "models/possession"
 
 
 class RelationTest < ActiveRecord::TestCase
@@ -39,15 +40,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal van, Minivan.where(:minivan_id => [van]).to_a.first
   end
 
-  def test_bind_values
-    relation = Post.all
-    assert_equal [], relation.bind_values
-
-    relation2 = relation.bind 'foo'
-    assert_equal %w{ foo }, relation2.bind_values
-    assert_equal [], relation.bind_values
-  end
-
   def test_two_scopes_with_includes_should_not_drop_any_include
     # heat habtm cache
     car = Car.incl_engines.incl_tyres.first
@@ -857,6 +849,12 @@ class RelationTest < ActiveRecord::TestCase
     assert ! fake.exists?(authors(:david).id)
   end
 
+  def test_exists_uses_existing_scope
+    post = authors(:david).posts.first
+    authors = Author.includes(:posts).where(name: "David", posts: { id: post.id })
+    assert authors.exists?(authors(:david).id)
+  end
+
   def test_last
     authors = Author.all
     assert_equal authors(:bob), authors.last
@@ -1382,12 +1380,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal "id", Post.all.primary_key
   end
 
-  def test_disable_implicit_join_references_is_deprecated
-    assert_deprecated do
-      ActiveRecord::Base.disable_implicit_join_references = true
-    end
-  end
-
   def test_ordering_with_extra_spaces
     assert_equal authors(:david), Author.order('id DESC , name DESC').last
   end
@@ -1468,10 +1460,31 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_doesnt_add_having_values_if_options_are_blank
     scope = Post.having('')
-    assert_equal [], scope.having_values
+    assert scope.having_clause.empty?
 
     scope = Post.having([])
-    assert_equal [], scope.having_values
+    assert scope.having_clause.empty?
+  end
+
+  def test_having_with_binds_for_both_where_and_having
+    post = Post.first
+    having_then_where = Post.having(id: post.id).where(title: post.title).group(:id)
+    where_then_having = Post.where(title: post.title).having(id: post.id).group(:id)
+
+    assert_equal [post], having_then_where
+    assert_equal [post], where_then_having
+  end
+
+  def test_multiple_where_and_having_clauses
+    post = Post.first
+    having_then_where = Post.having(id: post.id).where(title: post.title)
+      .having(id: post.id).where(title: post.title).group(:id)
+
+    assert_equal [post], having_then_where
+  end
+
+  def test_grouping_by_column_with_reserved_name
+    assert_equal [], Possession.select(:where).group(:where).to_a
   end
 
   def test_references_triggers_eager_loading
@@ -1657,6 +1670,14 @@ class RelationTest < ActiveRecord::TestCase
     end
   end
 
+  test "relations with cached arel can't be mutated [internal API]" do
+    relation = Post.all
+    relation.count
+
+    assert_raises(ActiveRecord::ImmutableRelation) { relation.limit!(5) }
+    assert_raises(ActiveRecord::ImmutableRelation) { relation.where!("1 = 2") }
+  end
+
   test "relations show the records in #inspect" do
     relation = Post.limit(2)
     assert_equal "#<ActiveRecord::Relation [#{Post.limit(2).map(&:inspect).join(', ')}]>", relation.inspect
@@ -1742,14 +1763,13 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_merging_keeps_lhs_bind_parameters
-    column = Post.columns_hash['id']
-    binds = [[column, 20]]
+    binds = [ActiveRecord::Relation::QueryAttribute.new("id", 20, Post.type_for_attribute("id"))]
 
     right  = Post.where(id: 20)
     left   = Post.where(id: 10)
 
     merged = left.merge(right)
-    assert_equal binds, merged.bind_values
+    assert_equal binds, merged.bound_attributes
   end
 
   def test_merging_reorders_bind_params
diff --git a/activerecord/test/cases/sanitize_test.rb b/activerecord/test/cases/sanitize_test.rb
index f477cf7d92..262e0abc22 100644
--- a/activerecord/test/cases/sanitize_test.rb
+++ b/activerecord/test/cases/sanitize_test.rb
@@ -7,17 +7,6 @@ class SanitizeTest < ActiveRecord::TestCase
   def setup
   end
 
-  def test_sanitize_sql_hash_handles_associations
-    quoted_bambi = ActiveRecord::Base.connection.quote("Bambi")
-    quoted_column_name = ActiveRecord::Base.connection.quote_column_name("name")
-    quoted_table_name = ActiveRecord::Base.connection.quote_table_name("adorable_animals")
-    expected_value = "#{quoted_table_name}.#{quoted_column_name} = #{quoted_bambi}"
-
-    assert_deprecated do
-      assert_equal expected_value, Binary.send(:sanitize_sql_hash, {adorable_animals: {name: 'Bambi'}})
-    end
-  end
-
   def test_sanitize_sql_array_handles_string_interpolation
     quoted_bambi = ActiveRecord::Base.connection.quote_string("Bambi")
     assert_equal "name=#{quoted_bambi}", Binary.send(:sanitize_sql_array, ["name=%s", "Bambi"])
diff --git a/activerecord/test/cases/schema_dumper_test.rb b/activerecord/test/cases/schema_dumper_test.rb
index 57b7346503..c8ea702488 100644
--- a/activerecord/test/cases/schema_dumper_test.rb
+++ b/activerecord/test/cases/schema_dumper_test.rb
@@ -204,25 +204,25 @@ class SchemaDumperTest < ActiveRecord::TestCase
   if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
     def test_schema_dump_should_add_default_value_for_mysql_text_field
       output = standard_dump
-      assert_match %r{t.text\s+"body",\s+limit: 65535,\s+null: false$}, output
+      assert_match %r{t\.text\s+"body",\s+limit: 65535,\s+null: false$}, output
     end
 
     def test_schema_dump_includes_length_for_mysql_binary_fields
       output = standard_dump
-      assert_match %r{t.binary\s+"var_binary",\s+limit: 255$}, output
-      assert_match %r{t.binary\s+"var_binary_large",\s+limit: 4095$}, output
+      assert_match %r{t\.binary\s+"var_binary",\s+limit: 255$}, output
+      assert_match %r{t\.binary\s+"var_binary_large",\s+limit: 4095$}, output
     end
 
     def test_schema_dump_includes_length_for_mysql_blob_and_text_fields
       output = standard_dump
-      assert_match %r{t.binary\s+"tiny_blob",\s+limit: 255$}, output
-      assert_match %r{t.binary\s+"normal_blob",\s+limit: 65535$}, output
-      assert_match %r{t.binary\s+"medium_blob",\s+limit: 16777215$}, output
-      assert_match %r{t.binary\s+"long_blob",\s+limit: 4294967295$}, output
-      assert_match %r{t.text\s+"tiny_text",\s+limit: 255$}, output
-      assert_match %r{t.text\s+"normal_text",\s+limit: 65535$}, output
-      assert_match %r{t.text\s+"medium_text",\s+limit: 16777215$}, output
-      assert_match %r{t.text\s+"long_text",\s+limit: 4294967295$}, output
+      assert_match %r{t\.binary\s+"tiny_blob",\s+limit: 255$}, output
+      assert_match %r{t\.binary\s+"normal_blob",\s+limit: 65535$}, output
+      assert_match %r{t\.binary\s+"medium_blob",\s+limit: 16777215$}, output
+      assert_match %r{t\.binary\s+"long_blob",\s+limit: 4294967295$}, output
+      assert_match %r{t\.text\s+"tiny_text",\s+limit: 255$}, output
+      assert_match %r{t\.text\s+"normal_text",\s+limit: 65535$}, output
+      assert_match %r{t\.text\s+"medium_text",\s+limit: 16777215$}, output
+      assert_match %r{t\.text\s+"long_text",\s+limit: 4294967295$}, output
     end
 
     def test_schema_dumps_index_type
@@ -235,19 +235,19 @@ class SchemaDumperTest < ActiveRecord::TestCase
   if mysql_56?
     def test_schema_dump_includes_datetime_precision
       output = standard_dump
-      assert_match %r{t.datetime\s+"written_on",\s+precision: 6$}, output
+      assert_match %r{t\.datetime\s+"written_on",\s+precision: 6$}, output
     end
   end
 
   def test_schema_dump_includes_decimal_options
     output = dump_all_table_schema([/^[^n]/])
-    assert_match %r{precision: 3,[[:space:]]+scale: 2,[[:space:]]+default: 2.78}, output
+    assert_match %r{precision: 3,[[:space:]]+scale: 2,[[:space:]]+default: 2\.78}, output
   end
 
   if current_adapter?(:PostgreSQLAdapter)
     def test_schema_dump_includes_bigint_default
       output = standard_dump
-      assert_match %r{t.integer\s+"bigint_default",\s+limit: 8,\s+default: 0}, output
+      assert_match %r{t\.integer\s+"bigint_default",\s+limit: 8,\s+default: 0}, output
     end
 
     if ActiveRecord::Base.connection.supports_extensions?
@@ -271,9 +271,11 @@ class SchemaDumperTest < ActiveRecord::TestCase
     output = standard_dump
     # Oracle supports precision up to 38 and it identifies decimals with scale 0 as integers
     if current_adapter?(:OracleAdapter)
-      assert_match %r{t.integer\s+"atoms_in_universe",\s+precision: 38}, output
+      assert_match %r{t\.integer\s+"atoms_in_universe",\s+precision: 38}, output
+    elsif current_adapter?(:FbAdapter)
+      assert_match %r{t\.integer\s+"atoms_in_universe",\s+precision: 18}, output
     else
-      assert_match %r{t.decimal\s+"atoms_in_universe",\s+precision: 55}, output
+      assert_match %r{t\.decimal\s+"atoms_in_universe",\s+precision: 55}, output
     end
   end
 
@@ -282,7 +284,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
     match = output.match(%r{create_table "goofy_string_id"(.*)do.*\n(.*)\n})
     assert_not_nil(match, "goofy_string_id table not found")
     assert_match %r(id: false), match[1], "no table id not preserved"
-    assert_match %r{t.string\s+"id",.*?null: false$}, match[2], "non-primary key id column not preserved"
+    assert_match %r{t\.string\s+"id",.*?null: false$}, match[2], "non-primary key id column not preserved"
   end
 
   def test_schema_dump_keeps_id_false_when_id_is_false_and_unique_not_null_column_added
diff --git a/activerecord/test/cases/scoping/default_scoping_test.rb b/activerecord/test/cases/scoping/default_scoping_test.rb
index 0738df1b54..4137b20c4a 100644
--- a/activerecord/test/cases/scoping/default_scoping_test.rb
+++ b/activerecord/test/cases/scoping/default_scoping_test.rb
@@ -284,8 +284,8 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_unscope_merging
     merged = Developer.where(name: "Jamis").merge(Developer.unscope(:where))
-    assert merged.where_values.empty?
-    assert !merged.where(name: "Jon").where_values.empty?
+    assert merged.where_clause.empty?
+    assert !merged.where(name: "Jon").where_clause.empty?
   end
 
   def test_order_in_default_scope_should_not_prevail
@@ -426,19 +426,19 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   test "additional conditions are ANDed with the default scope" do
     scope = DeveloperCalledJamis.where(name: "David")
-    assert_equal 2, scope.where_values.length
+    assert_equal 2, scope.where_clause.ast.children.length
     assert_equal [], scope.to_a
   end
 
   test "additional conditions in a scope are ANDed with the default scope" do
     scope = DeveloperCalledJamis.david
-    assert_equal 2, scope.where_values.length
+    assert_equal 2, scope.where_clause.ast.children.length
     assert_equal [], scope.to_a
   end
 
   test "a scope can remove the condition from the default scope" do
     scope = DeveloperCalledJamis.david2
-    assert_equal 1, scope.where_values.length
-    assert_equal Developer.where(name: "David").map(&:id), scope.map(&:id)
+    assert_equal 1, scope.where_clause.ast.children.length
+    assert_equal Developer.where(name: "David"), scope
   end
 end
diff --git a/activerecord/test/cases/scoping/named_scoping_test.rb b/activerecord/test/cases/scoping/named_scoping_test.rb
index 41f3449828..8cd94ebcc2 100644
--- a/activerecord/test/cases/scoping/named_scoping_test.rb
+++ b/activerecord/test/cases/scoping/named_scoping_test.rb
@@ -380,8 +380,8 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_should_not_duplicates_where_values
-    where_values = Topic.where("1=1").scope_with_lambda.where_values
-    assert_equal ["1=1"], where_values
+    relation = Topic.where("1=1")
+    assert_equal relation.where_clause, relation.scope_with_lambda.where_clause
   end
 
   def test_chaining_with_duplicate_joins
diff --git a/activerecord/test/cases/scoping/relation_scoping_test.rb b/activerecord/test/cases/scoping/relation_scoping_test.rb
index d7bcbf6203..02b32abebf 100644
--- a/activerecord/test/cases/scoping/relation_scoping_test.rb
+++ b/activerecord/test/cases/scoping/relation_scoping_test.rb
@@ -184,7 +184,7 @@ class RelationScopingTest < ActiveRecord::TestCase
     rescue
     end
 
-    assert !Developer.all.where_values.include?("name = 'Jamis'")
+    assert_not Developer.all.to_sql.include?("name = 'Jamis'"), "scope was not restored"
   end
 
   def test_default_scope_filters_on_joins
diff --git a/activerecord/test/cases/secure_token_test.rb b/activerecord/test/cases/secure_token_test.rb
new file mode 100644
index 0000000000..3f7455d12d
--- /dev/null
+++ b/activerecord/test/cases/secure_token_test.rb
@@ -0,0 +1,25 @@
+require 'cases/helper'
+require 'models/user'
+
+class SecureTokenTest < ActiveRecord::TestCase
+  setup do
+    @user = User.new
+  end
+
+  def test_token_values_are_generated_for_specified_attributes_and_persisted_on_save
+    @user.save
+    assert_not_nil @user.token
+    assert_not_nil @user.auth_token
+  end
+
+  def test_regenerating_the_secure_token
+    @user.save
+    old_token = @user.token
+    old_auth_token = @user.auth_token
+    @user.regenerate_token
+    @user.regenerate_auth_token
+
+    assert_not_equal @user.token, old_token
+    assert_not_equal @user.auth_token, old_auth_token
+  end
+end
diff --git a/activerecord/test/cases/serialized_attribute_test.rb b/activerecord/test/cases/serialized_attribute_test.rb
index c261a5b1c0..e29f7462c8 100644
--- a/activerecord/test/cases/serialized_attribute_test.rb
+++ b/activerecord/test/cases/serialized_attribute_test.rb
@@ -22,12 +22,6 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     end
   end
 
-  def test_list_of_serialized_attributes
-    assert_deprecated do
-      assert_equal %w(content), Topic.serialized_attributes.keys
-    end
-  end
-
   def test_serialized_attribute
     Topic.serialize("content", MyObject)
 
diff --git a/activerecord/test/cases/transaction_callbacks_test.rb b/activerecord/test/cases/transaction_callbacks_test.rb
index 0f5caa52e3..f185cda263 100644
--- a/activerecord/test/cases/transaction_callbacks_test.rb
+++ b/activerecord/test/cases/transaction_callbacks_test.rb
@@ -4,7 +4,6 @@ require 'models/pet'
 require 'models/topic'
 
 class TransactionCallbacksTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
   fixtures :topics, :owners, :pets
 
   class ReplyWithCallbacks < ActiveRecord::Base
@@ -200,21 +199,21 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
   end
 
   def test_call_after_rollback_when_commit_fails
-    @first.class.connection.singleton_class.send(:alias_method, :real_method_commit_db_transaction, :commit_db_transaction)
-    begin
-      @first.class.connection.singleton_class.class_eval do
-        def commit_db_transaction; raise "boom!"; end
-      end
+    @first.after_commit_block { |r| r.history << :after_commit }
+    @first.after_rollback_block { |r| r.history << :after_rollback }
 
-      @first.after_commit_block{|r| r.history << :after_commit}
-      @first.after_rollback_block{|r| r.history << :after_rollback}
+    assert_raises RuntimeError do
+      @first.transaction do
+        tx = @first.class.connection.transaction_manager.current_transaction
+        def tx.commit
+          raise
+        end
 
-      assert !@first.save rescue nil
-      assert_equal [:after_rollback], @first.history
-    ensure
-      @first.class.connection.singleton_class.send(:remove_method, :commit_db_transaction)
-      @first.class.connection.singleton_class.send(:alias_method, :commit_db_transaction, :real_method_commit_db_transaction)
+        @first.save
+      end
     end
+
+    assert_equal [:after_rollback], @first.history
   end
 
   def test_only_call_after_rollback_on_records_rolled_back_to_a_savepoint
@@ -266,47 +265,6 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
     assert_equal 2, @first.rollbacks
   end
 
-  def test_after_transaction_callbacks_should_prevent_callbacks_from_being_called
-    old_transaction_config = ActiveRecord::Base.raise_in_transactional_callbacks
-    ActiveRecord::Base.raise_in_transactional_callbacks = false
-
-    def @first.last_after_transaction_error=(e); @last_transaction_error = e; end
-    def @first.last_after_transaction_error; @last_transaction_error; end
-    @first.after_commit_block{|r| r.last_after_transaction_error = :commit; raise "fail!";}
-    @first.after_rollback_block{|r| r.last_after_transaction_error = :rollback; raise "fail!";}
-
-    second = TopicWithCallbacks.find(3)
-    second.after_commit_block{|r| r.history << :after_commit}
-    second.after_rollback_block{|r| r.history << :after_rollback}
-
-    Topic.transaction do
-      @first.save!
-      second.save!
-    end
-    assert_equal :commit, @first.last_after_transaction_error
-    assert_equal [:after_commit], second.history
-
-    second.history.clear
-    Topic.transaction do
-      @first.save!
-      second.save!
-      raise ActiveRecord::Rollback
-    end
-    assert_equal :rollback, @first.last_after_transaction_error
-    assert_equal [:after_rollback], second.history
-  ensure
-    ActiveRecord::Base.raise_in_transactional_callbacks = old_transaction_config
-  end
-
-  def test_after_commit_should_not_raise_when_raise_in_transactional_callbacks_false
-    old_transaction_config = ActiveRecord::Base.raise_in_transactional_callbacks
-    ActiveRecord::Base.raise_in_transactional_callbacks = false
-    @first.after_commit_block{ fail "boom" }
-    Topic.transaction { @first.save! }
-  ensure
-    ActiveRecord::Base.raise_in_transactional_callbacks = old_transaction_config
-  end
-
   def test_after_commit_callback_should_not_swallow_errors
     @first.after_commit_block{ fail "boom" }
     assert_raises(RuntimeError) do
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index 0bbb4bb79e..d1d8e71c34 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -194,6 +194,16 @@ class TransactionTest < ActiveRecord::TestCase
     assert_equal posts_count, author.posts(true).size
   end
 
+  def test_cancellation_from_returning_false_in_before_filter
+    def @first.before_save_for_transaction
+      false
+    end
+
+    assert_deprecated do
+      @first.save
+    end
+  end
+
   def test_cancellation_from_before_destroy_rollbacks_in_destroy
     add_cancelling_before_destroy_with_db_side_effect_to_topic @first
     nbooks_before_destroy = Book.count
@@ -493,35 +503,32 @@ class TransactionTest < ActiveRecord::TestCase
     assert topic.frozen?, 'not frozen'
   end
 
-  # The behavior of killed threads having a status of "aborting" was changed
-  # in Ruby 2.0, so Thread#kill on 1.9 will prematurely commit the transaction
-  # and there's nothing we can do about it.
-  if !RUBY_VERSION.start_with?('1.9') && !in_memory_db?
-    def test_rollback_when_thread_killed
-      queue = Queue.new
-      thread = Thread.new do
-        Topic.transaction do
-          @first.approved  = true
-          @second.approved = false
-          @first.save
+  def test_rollback_when_thread_killed
+    return if in_memory_db?
 
-          queue.push nil
-          sleep
+    queue = Queue.new
+    thread = Thread.new do
+      Topic.transaction do
+        @first.approved  = true
+        @second.approved = false
+        @first.save
 
-          @second.save
-        end
+        queue.push nil
+        sleep
+
+        @second.save
       end
+    end
 
-      queue.pop
-      thread.kill
-      thread.join
+    queue.pop
+    thread.kill
+    thread.join
 
-      assert @first.approved?, "First should still be changed in the objects"
-      assert !@second.approved?, "Second should still be changed in the objects"
+    assert @first.approved?, "First should still be changed in the objects"
+    assert !@second.approved?, "Second should still be changed in the objects"
 
-      assert !Topic.find(1).approved?, "First shouldn't have been approved"
-      assert Topic.find(2).approved?, "Second should still be approved"
-    end
+    assert !Topic.find(1).approved?, "First shouldn't have been approved"
+    assert Topic.find(2).approved?, "Second should still be approved"
   end
 
   def test_restore_active_record_state_for_all_records_in_a_transaction
@@ -643,6 +650,27 @@ class TransactionTest < ActiveRecord::TestCase
     assert transaction.state.committed?
   end
 
+  def test_transaction_rollback_with_primarykeyless_tables
+    connection = ActiveRecord::Base.connection
+    connection.create_table(:transaction_without_primary_keys, force: true, id: false) do |t|
+       t.integer :thing_id
+    end
+
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'transaction_without_primary_keys'
+      after_commit { } # necessary to trigger the has_transactional_callbacks branch
+    end
+
+    assert_no_difference(-> { klass.count }) do
+      ActiveRecord::Base.transaction do
+        klass.create!
+        raise ActiveRecord::Rollback
+      end
+    end
+  ensure
+    connection.execute("DROP TABLE IF EXISTS transaction_without_primary_keys")
+  end
+
   private
 
   %w(validation save destroy).each do |filter|
@@ -650,7 +678,7 @@ class TransactionTest < ActiveRecord::TestCase
       meta = class << topic; self; end
       meta.send("define_method", "before_#{filter}_for_transaction") do
         Book.create
-        false
+        throw(:abort)
       end
     end
   end
diff --git a/activerecord/test/cases/type/integer_test.rb b/activerecord/test/cases/type/integer_test.rb
index ff956b7680..0c60f0690c 100644
--- a/activerecord/test/cases/type/integer_test.rb
+++ b/activerecord/test/cases/type/integer_test.rb
@@ -60,55 +60,68 @@ module ActiveRecord
 
       test "values below int min value are out of range" do
         assert_raises(::RangeError) do
-          Integer.new.type_cast_from_user("-2147483649")
+          Integer.new.type_cast_for_database(-2147483649)
         end
       end
 
       test "values above int max value are out of range" do
         assert_raises(::RangeError) do
-          Integer.new.type_cast_from_user("2147483648")
+          Integer.new.type_cast_for_database(2147483648)
         end
       end
 
       test "very small numbers are out of range" do
         assert_raises(::RangeError) do
-          Integer.new.type_cast_from_user("-9999999999999999999999999999999")
+          Integer.new.type_cast_for_database(-9999999999999999999999999999999)
         end
       end
 
       test "very large numbers are out of range" do
         assert_raises(::RangeError) do
-          Integer.new.type_cast_from_user("9999999999999999999999999999999")
+          Integer.new.type_cast_for_database(9999999999999999999999999999999)
         end
       end
 
       test "normal numbers are in range" do
         type = Integer.new
-        assert_equal(0, type.type_cast_from_user("0"))
-        assert_equal(-1, type.type_cast_from_user("-1"))
-        assert_equal(1, type.type_cast_from_user("1"))
+        assert_equal(0, type.type_cast_for_database(0))
+        assert_equal(-1, type.type_cast_for_database(-1))
+        assert_equal(1, type.type_cast_for_database(1))
       end
 
       test "int max value is in range" do
-        assert_equal(2147483647, Integer.new.type_cast_from_user("2147483647"))
+        assert_equal(2147483647, Integer.new.type_cast_for_database(2147483647))
       end
 
       test "int min value is in range" do
-        assert_equal(-2147483648, Integer.new.type_cast_from_user("-2147483648"))
+        assert_equal(-2147483648, Integer.new.type_cast_for_database(-2147483648))
       end
 
       test "columns with a larger limit have larger ranges" do
         type = Integer.new(limit: 8)
 
-        assert_equal(9223372036854775807, type.type_cast_from_user("9223372036854775807"))
-        assert_equal(-9223372036854775808, type.type_cast_from_user("-9223372036854775808"))
+        assert_equal(9223372036854775807, type.type_cast_for_database(9223372036854775807))
+        assert_equal(-9223372036854775808, type.type_cast_for_database(-9223372036854775808))
         assert_raises(::RangeError) do
-          type.type_cast_from_user("-9999999999999999999999999999999")
+          type.type_cast_for_database(-9999999999999999999999999999999)
         end
         assert_raises(::RangeError) do
-          type.type_cast_from_user("9999999999999999999999999999999")
+          type.type_cast_for_database(9999999999999999999999999999999)
         end
       end
+
+      test "values which are out of range can be re-assigned" do
+        klass = Class.new(ActiveRecord::Base) do
+          self.table_name = 'posts'
+          attribute :foo, Type::Integer.new
+        end
+        model = klass.new
+
+        model.foo = 2147483648
+        model.foo = 1
+
+        assert_equal 1, model.foo
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/type/unsigned_integer_test.rb b/activerecord/test/cases/type/unsigned_integer_test.rb
index b6f673109e..4b8e2fb518 100644
--- a/activerecord/test/cases/type/unsigned_integer_test.rb
+++ b/activerecord/test/cases/type/unsigned_integer_test.rb
@@ -4,12 +4,12 @@ module ActiveRecord
   module Type
     class UnsignedIntegerTest < ActiveRecord::TestCase
       test "unsigned int max value is in range" do
-        assert_equal(4294967295, UnsignedInteger.new.type_cast_from_user("4294967295"))
+        assert_equal(4294967295, UnsignedInteger.new.type_cast_for_database(4294967295))
       end
 
       test "minus value is out of range" do
         assert_raises(::RangeError) do
-          UnsignedInteger.new.type_cast_from_user("-1")
+          UnsignedInteger.new.type_cast_for_database(-1)
         end
       end
     end
diff --git a/activerecord/test/cases/types_test.rb b/activerecord/test/cases/types_test.rb
index b0979cbe1f..d35d34ff2d 100644
--- a/activerecord/test/cases/types_test.rb
+++ b/activerecord/test/cases/types_test.rb
@@ -17,6 +17,10 @@ module ActiveRecord
         assert type.type_cast_from_user('TRUE')
         assert type.type_cast_from_user('on')
         assert type.type_cast_from_user('ON')
+        assert type.type_cast_from_user(' ')
+        assert type.type_cast_from_user("\u3000\r\n")
+        assert type.type_cast_from_user("\u0000")
+        assert type.type_cast_from_user('SOMETHING RANDOM')
 
         # explicitly check for false vs nil
         assert_equal false, type.type_cast_from_user(false)
@@ -28,12 +32,6 @@ module ActiveRecord
         assert_equal false, type.type_cast_from_user('FALSE')
         assert_equal false, type.type_cast_from_user('off')
         assert_equal false, type.type_cast_from_user('OFF')
-        assert_deprecated do
-          assert_equal false, type.type_cast_from_user(' ')
-          assert_equal false, type.type_cast_from_user("\u3000\r\n")
-          assert_equal false, type.type_cast_from_user("\u0000")
-          assert_equal false, type.type_cast_from_user('SOMETHING RANDOM')
-        end
       end
 
       def test_type_cast_float
@@ -119,6 +117,23 @@ module ActiveRecord
           assert_equal Encoding::ASCII_8BIT, type_cast.encoding
         end
       end
+
+      def test_attributes_which_are_invalid_for_database_can_still_be_reassigned
+        type_which_cannot_go_to_the_database = Type::Value.new
+        def type_which_cannot_go_to_the_database.type_cast_for_database(*)
+          raise
+        end
+        klass = Class.new(ActiveRecord::Base) do
+          self.table_name = 'posts'
+          attribute :foo, type_which_cannot_go_to_the_database
+        end
+        model = klass.new
+
+        model.foo = "foo"
+        model.foo = "bar"
+
+        assert_equal "bar", model.foo
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/xml_serialization_test.rb b/activerecord/test/cases/xml_serialization_test.rb
index c34e7d5a30..b30b50f597 100644
--- a/activerecord/test/cases/xml_serialization_test.rb
+++ b/activerecord/test/cases/xml_serialization_test.rb
@@ -19,7 +19,7 @@ class XmlSerializationTest < ActiveRecord::TestCase
 
   def test_should_serialize_default_root_with_namespace
     @xml = Contact.new.to_xml :namespace=>"http://xml.rubyonrails.org/contact"
-    assert_match %r{^<contact xmlns="http://xml.rubyonrails.org/contact">},  @xml
+    assert_match %r{^<contact xmlns="http://xml\.rubyonrails\.org/contact">},  @xml
     assert_match %r{</contact>$}, @xml
   end
 
diff --git a/activerecord/test/fixtures/dead_parrots.yml b/activerecord/test/fixtures/dead_parrots.yml
new file mode 100644
index 0000000000..da5529dd27
--- /dev/null
+++ b/activerecord/test/fixtures/dead_parrots.yml
@@ -0,0 +1,5 @@
+deadbird:
+  name: "Dusty DeadBird"
+  treasures: [ruby, sapphire]
+  parrot_sti_class: DeadParrot
+  killer: blackbeard
diff --git a/activerecord/test/fixtures/live_parrots.yml b/activerecord/test/fixtures/live_parrots.yml
new file mode 100644
index 0000000000..95b2078da7
--- /dev/null
+++ b/activerecord/test/fixtures/live_parrots.yml
@@ -0,0 +1,4 @@
+dusty:
+  name: "Dusty Bluebird"
+  treasures: [ruby, sapphire]
+  parrot_sti_class: LiveParrot
diff --git a/activerecord/test/fixtures/pirates.yml b/activerecord/test/fixtures/pirates.yml
index 1bb3bf0051..0b1a785853 100644
--- a/activerecord/test/fixtures/pirates.yml
+++ b/activerecord/test/fixtures/pirates.yml
@@ -10,3 +10,6 @@ redbeard:
 
 mark:
   catchphrase: "X $LABELs the spot!"
+
+1:
+  catchphrase: "#$LABEL pirate!"
diff --git a/activerecord/test/models/admin/randomly_named_c1.rb b/activerecord/test/models/admin/randomly_named_c1.rb
index 2f81d5b831..b64ae7fc41 100644
--- a/activerecord/test/models/admin/randomly_named_c1.rb
+++ b/activerecord/test/models/admin/randomly_named_c1.rb
@@ -1,3 +1,7 @@
-class Admin::ClassNameThatDoesNotFollowCONVENTIONS < ActiveRecord::Base

-  self.table_name = :randomly_named_table

+class Admin::ClassNameThatDoesNotFollowCONVENTIONS1 < ActiveRecord::Base

+  self.table_name = :randomly_named_table2

+end

+

+class Admin::ClassNameThatDoesNotFollowCONVENTIONS2 < ActiveRecord::Base

+  self.table_name = :randomly_named_table3

 end

diff --git a/activerecord/test/models/bird.rb b/activerecord/test/models/bird.rb
index dff099c1fb..2a51d903b8 100644
--- a/activerecord/test/models/bird.rb
+++ b/activerecord/test/models/bird.rb
@@ -7,6 +7,6 @@ class Bird < ActiveRecord::Base
   attr_accessor :cancel_save_from_callback
   before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
   def cancel_save_callback_method
-    false
+    throw(:abort)
   end
 end
diff --git a/activerecord/test/models/bulb.rb b/activerecord/test/models/bulb.rb
index 831a0d5387..a6e83fe353 100644
--- a/activerecord/test/models/bulb.rb
+++ b/activerecord/test/models/bulb.rb
@@ -46,6 +46,6 @@ end
 
 class FailedBulb < Bulb
   before_destroy do
-    false
+    throw(:abort)
   end
 end
diff --git a/activerecord/test/models/car.rb b/activerecord/test/models/car.rb
index db0f93f63b..81263b79d1 100644
--- a/activerecord/test/models/car.rb
+++ b/activerecord/test/models/car.rb
@@ -8,7 +8,7 @@ class Car < ActiveRecord::Base
   has_one :bulb
 
   has_many :tyres
-  has_many :engines, :dependent => :destroy
+  has_many :engines, :dependent => :destroy, inverse_of: :my_car
   has_many :wheels, :as => :wheelable, :dependent => :destroy
 
   scope :incl_tyres, -> { includes(:tyres) }
diff --git a/activerecord/test/models/parrot.rb b/activerecord/test/models/parrot.rb
index 8c83de573f..b26035d944 100644
--- a/activerecord/test/models/parrot.rb
+++ b/activerecord/test/models/parrot.rb
@@ -11,7 +11,7 @@ class Parrot < ActiveRecord::Base
   attr_accessor :cancel_save_from_callback
   before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
   def cancel_save_callback_method
-    false
+    throw(:abort)
   end
 end
 
diff --git a/activerecord/test/models/pirate.rb b/activerecord/test/models/pirate.rb
index 641a33f9be..366c70f902 100644
--- a/activerecord/test/models/pirate.rb
+++ b/activerecord/test/models/pirate.rb
@@ -56,7 +56,7 @@ class Pirate < ActiveRecord::Base
   attr_accessor :cancel_save_from_callback, :parrots_limit
   before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
   def cancel_save_callback_method
-    false
+    throw(:abort)
   end
 
   private
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index 56073cc588..052b1c9690 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -18,6 +18,7 @@ class Post < ActiveRecord::Base
   end
 
   scope :containing_the_letter_a, -> { where("body LIKE '%a%'") }
+  scope :titled_with_an_apostrophe, -> { where("title LIKE '%''%'") }
   scope :ranked_by_comments,      -> { order("comments_count DESC") }
 
   scope :limit_by, lambda {|l| limit(l) }
@@ -43,6 +44,8 @@ class Post < ActiveRecord::Base
   scope :tagged_with, ->(id) { joins(:taggings).where(taggings: { tag_id: id }) }
   scope :tagged_with_comment, ->(comment) { joins(:taggings).where(taggings: { comment: comment }) }
 
+  scope :typographically_interesting, -> { containing_the_letter_a.or(titled_with_an_apostrophe) }
+
   has_many   :comments do
     def find_most_recent
       order("id DESC").first
@@ -72,10 +75,6 @@ class Post < ActiveRecord::Base
     through: :author_with_address,
     source: :author_address_extra
 
-  has_many :comments_with_interpolated_conditions,
-    ->(p) { where "#{"#{p.aliased_table_name}." rescue ""}body = ?", 'Thank you for the welcome' },
-    :class_name => 'Comment'
-
   has_one  :very_special_comment
   has_one  :very_special_comment_with_post, -> { includes(:post) }, :class_name => "VerySpecialComment"
   has_one :very_special_comment_with_post_with_joins, -> { joins(:post).order('posts.id') }, class_name: "VerySpecialComment"
diff --git a/activerecord/test/models/randomly_named_c1.rb b/activerecord/test/models/randomly_named_c1.rb
index 18a86c4989..d4be1e13b4 100644
--- a/activerecord/test/models/randomly_named_c1.rb
+++ b/activerecord/test/models/randomly_named_c1.rb
@@ -1,3 +1,3 @@
 class ClassNameThatDoesNotFollowCONVENTIONS < ActiveRecord::Base

-  self.table_name = :randomly_named_table

+  self.table_name = :randomly_named_table1

 end

diff --git a/activerecord/test/models/ship.rb b/activerecord/test/models/ship.rb
index 5f618a50d2..312caef604 100644
--- a/activerecord/test/models/ship.rb
+++ b/activerecord/test/models/ship.rb
@@ -4,6 +4,7 @@ class Ship < ActiveRecord::Base
   belongs_to :pirate
   belongs_to :update_only_pirate, :class_name => 'Pirate'
   has_many :parts, :class_name => 'ShipPart'
+  has_many :treasures
 
   accepts_nested_attributes_for :parts, :allow_destroy => true
   accepts_nested_attributes_for :pirate, :allow_destroy => true, :reject_if => proc(&:empty?)
@@ -14,7 +15,7 @@ class Ship < ActiveRecord::Base
   attr_accessor :cancel_save_from_callback
   before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
   def cancel_save_callback_method
-    false
+    throw(:abort)
   end
 end
 
diff --git a/activerecord/test/models/ship_part.rb b/activerecord/test/models/ship_part.rb
index b6a8a506b4..05c65f8a4a 100644
--- a/activerecord/test/models/ship_part.rb
+++ b/activerecord/test/models/ship_part.rb
@@ -2,6 +2,7 @@ class ShipPart < ActiveRecord::Base
   belongs_to :ship
   has_many :trinkets, :class_name => "Treasure", :as => :looter
   accepts_nested_attributes_for :trinkets, :allow_destroy => true
+  accepts_nested_attributes_for :ship
 
   validates_presence_of :name
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/models/treasure.rb b/activerecord/test/models/treasure.rb
index a69d3fd3df..ffc65466d5 100644
--- a/activerecord/test/models/treasure.rb
+++ b/activerecord/test/models/treasure.rb
@@ -1,6 +1,7 @@
 class Treasure < ActiveRecord::Base
   has_and_belongs_to_many :parrots
   belongs_to :looter, :polymorphic => true
+  belongs_to :ship
 
   has_many :price_estimates, :as => :estimate_of
   has_and_belongs_to_many :rich_people, join_table: 'peoples_treasures', validate: false
diff --git a/activerecord/test/models/user.rb b/activerecord/test/models/user.rb
new file mode 100644
index 0000000000..23cd2e0e1c
--- /dev/null
+++ b/activerecord/test/models/user.rb
@@ -0,0 +1,4 @@
+class User < ActiveRecord::Base
+  has_secure_token
+  has_secure_token :auth_token
+end
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 5907d6ef97..49dbc5dabf 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -479,6 +479,8 @@ ActiveRecord::Schema.define do
     # Oracle/SQLServer supports precision up to 38
     if current_adapter?(:OracleAdapter, :SQLServerAdapter)
       t.decimal :atoms_in_universe, precision: 38, scale: 0
+    elsif current_adapter?(:FbAdapter)
+      t.decimal :atoms_in_universe, precision: 18, scale: 0
     else
       t.decimal :atoms_in_universe, precision: 55, scale: 0
     end
@@ -621,7 +623,17 @@ ActiveRecord::Schema.define do
     t.string :type
   end
 
-  create_table :randomly_named_table, force: true do |t|
+  create_table :randomly_named_table1, force: true do |t|
+    t.string  :some_attribute
+    t.integer :another_attribute
+  end
+
+  create_table :randomly_named_table2, force: true do |t|
+    t.string  :some_attribute
+    t.integer :another_attribute
+  end
+
+  create_table :randomly_named_table3, force: true do |t|
     t.string  :some_attribute
     t.integer :another_attribute
   end
@@ -770,6 +782,7 @@ ActiveRecord::Schema.define do
     t.column :type, :string
     t.column :looter_id, :integer
     t.column :looter_type, :string
+    t.belongs_to :ship
   end
 
   create_table :tyres, force: true do |t|
@@ -892,6 +905,11 @@ ActiveRecord::Schema.define do
     t.string :overloaded_string_with_limit, limit: 255
     t.string :string_with_default, default: 'the original default'
   end
+
+  create_table :users, force: true do |t|
+    t.string :token
+    t.string :auth_token
+  end
 end
 
 Course.connection.create_table :courses, force: true do |t|