Merge branch 'master' into adequaterecord

* master: (122 commits)
  Rails.application should be set inside before_configuration hook
  remove check for present? from delete_all
  Remove useless begin..end
  Build the reverse_order on its proper method.
  Use connection-specific bytea escaping
  Ignore order when doing count.
  make enums distinct per class
  Remove unused `subclass_controller_with_flash_type_bar` var from flash test.
  fix CollectionProxy delete_all documentation
  Added OS X specific commands to installation guide [ci skip] Recommended using homebrew for installing MySQL and PostgreSQL
  Fix setup of adding _flash_types test.
  Use SVG version of travis build status badge [skip ci]
  W3C CSP document moved to gihub.io URL [ci skip]
  sprockets-rails was released
  Fix the test defining the models in the right place
  Add CHANGELOG entry for #11650 [ci skip]
  Declare the assets dependency
  Use sass-rails 4.0.3
  Make possible to use sprockets-rails 2.1
  add missing parentheses to validates_with documentation [skip ci]
  ...

97 files changed, 1525 insertions, 864 deletions

diff --git a/activerecord/CHANGELOG.md b/activerecord/CHANGELOG.md
index bb2dbba860..d39e808f5b 100644
--- a/activerecord/CHANGELOG.md
+++ b/activerecord/CHANGELOG.md
@@ -1,3 +1,123 @@
+*   Fixed a problem where an enum would overwrite values of another enum
+    with the same name in an unrelated class.
+
+    Fixes #14607.
+
+    *Evan Whalen*
+
+*   PostgreSQL and SQLite string columns no longer have a default limit of 255.
+
+    Fixes #13435, #9153.
+
+    *Vladimir Sazhin*, *Toms Mikoss*, *Yves Senn*
+
+*   Make possible to have an association called `records`.
+
+    Fixes #11645.
+
+    *prathamesh-sonpatki*
+
+*   `to_sql` on an association now matches the query that is actually executed, where it
+    could previously have incorrectly accrued additional conditions (e.g. as a result of
+    a previous query). CollectionProxy now always defers to the association scope's
+    `arel` method so the (incorrect) inherited one should be entirely concealed.
+
+    Fixes #14003.
+
+    *Jefferson Lai*
+
+*   Block a few default Class methods as scope name.
+
+    For instance, this will raise:
+
+        scope :public, -> { where(status: 1) }
+
+    *arthurnn*
+
+*   Fixed error when using `with_options` with lambda.
+
+    Fixes #9805.
+
+    *Lauro Caetano*
+
+*   Switch `sqlite3:///` URLs (which were temporarily
+    deprecated in 4.1) from relative to absolute.
+
+    If you still want the previous interpretation, you should replace
+    `sqlite3:///my/path` with `sqlite3:my/path`.
+
+    *Matthew Draper*
+
+*   Treat blank UUID values as `nil`.
+
+    Example:
+
+        Sample.new(uuid_field: '') #=> <Sample id: nil, uuid_field: nil>
+
+    *Dmitry Lavrov*
+
+*   Enable support for materialized views on PostgreSQL >= 9.3.
+
+    *Dave Lee*
+
+*   The PostgreSQL adapter supports custom domains. Fixes #14305.
+
+    *Yves Senn*
+
+*   PostgreSQL `Column#type` is now determined through the corresponding OID.
+    The column types stay the same except for enum columns. They no longer have
+    `nil` as type but `enum`.
+
+    See #7814.
+
+    *Yves Senn*
+
+*   Fixed error when specifying a non-empty default value on a PostgreSQL array column.
+
+    Fixes #10613.
+
+    *Luke Steensen*
+
+*   Make possible to change `record_timestamps` inside Callbacks.
+
+    *Tieg Zaharia*
+
+*   Fixed error where .persisted? throws SystemStackError for an unsaved model with a
+    custom primary key that didn't save due to validation error.
+
+    Fixes #14393.
+
+    *Chris Finne*
+
+*   Introduce `validate` as an alias for `valid?`.
+
+    This is more intuitive when you want to run validations but don't care about the return value.
+
+    *Henrik Nyh*
+
+*   Create indexes inline in CREATE TABLE for MySQL.
+
+    This is important, because adding an index on a temporary table after it has been created
+    would commit the transaction.
+
+    It also allows creating and dropping indexed tables with fewer queries and fewer permissions
+    required.
+
+    Example:
+
+        create_table :temp, temporary: true, as: "SELECT id, name, zip FROM a_really_complicated_query" do |t|
+          t.index :zip
+        end
+        # => CREATE TEMPORARY TABLE temp (INDEX (zip)) AS SELECT id, name, zip FROM a_really_complicated_query
+
+    *Cody Cutrer*, *Steve Rice*, *Rafael Mendonça Franca*
+
+*   Save `has_one` association even if the record doesn't changed.
+
+    Fixes #14407.
+
+    *Rafael Mendonça França*
+
 *   Use singular table name in generated migrations when
     `ActiveRecord::Base.pluralize_table_names` is `false`.
 
@@ -76,12 +196,6 @@
 
     *Troy Kruthoff*, *Lachlan Sylvester*
 
-*   Only save has_one associations if record has changes.
-    Previously after save related callbacks, such as `#after_commit`, were triggered when the has_one
-    object did not get saved to the db.
-
-    *Alan Kennedy*
-
 *   Allow strings to specify the `#order` value.
 
     Example:
diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index 860e76fa18..4abe2ad0a0 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -4,6 +4,12 @@ require 'active_support/core_ext/module/remove_method'
 require 'active_record/errors'
 
 module ActiveRecord
+  class AssociationNotFoundError < ConfigurationError #:nodoc:
+    def initialize(record, association_name)
+      super("Association named '#{association_name}' was not found on #{record.class.name}; perhaps you misspelled it?")
+    end
+  end
+
   class InverseOfAssociationNotFoundError < ActiveRecordError #:nodoc:
     def initialize(reflection, associated_class = nil)
       super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{associated_class.nil? ? reflection.class_name : associated_class.name})")
@@ -145,7 +151,7 @@ module ActiveRecord
       association = association_instance_get(name)
 
       if association.nil?
-        reflection  = self.class.reflect_on_association(name)
+        raise AssociationNotFoundError.new(self, name) unless reflection = self.class.reflect_on_association(name)
         association = reflection.association_class.new(self, reflection)
         association_instance_set(name, association)
       end
diff --git a/activerecord/lib/active_record/associations/collection_association.rb b/activerecord/lib/active_record/associations/collection_association.rb
index 1f314e0677..803e3ab9ab 100644
--- a/activerecord/lib/active_record/associations/collection_association.rb
+++ b/activerecord/lib/active_record/associations/collection_association.rb
@@ -134,11 +134,11 @@ module ActiveRecord
       end
 
       def create(attributes = {}, &block)
-        create_record(attributes, &block)
+        _create_record(attributes, &block)
       end
 
       def create!(attributes = {}, &block)
-        create_record(attributes, true, &block)
+        _create_record(attributes, true, &block)
       end
 
       # Add +records+ to this association. Returns +self+ so method calls may
@@ -182,11 +182,11 @@ module ActiveRecord
       #
       # See delete for more info.
       def delete_all(dependent = nil)
-        if dependent.present? && ![:nullify, :delete_all].include?(dependent)
+        if dependent && ![:nullify, :delete_all].include?(dependent)
           raise ArgumentError, "Valid values are :nullify or :delete_all"
         end
 
-        dependent = if dependent.present?
+        dependent = if dependent
                       dependent
                     elsif options[:dependent] == :destroy
                       :delete_all
@@ -248,7 +248,7 @@ module ActiveRecord
         dependent = _options[:dependent] || options[:dependent]
 
         if records.first == :all
-          if loaded? || dependent == :destroy
+          if (loaded? || dependent == :destroy) && dependent != :delete_all
             delete_or_destroy(load_target, dependent)
           else
             delete_records(:all, dependent)
@@ -449,13 +449,13 @@ module ActiveRecord
           persisted + memory
         end
 
-        def create_record(attributes, raise = false, &block)
+        def _create_record(attributes, raise = false, &block)
           unless owner.persisted?
             raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
           end
 
           if attributes.is_a?(Array)
-            attributes.collect { |attr| create_record(attr, raise, &block) }
+            attributes.collect { |attr| _create_record(attr, raise, &block) }
           else
             transaction do
               add_to_target(build_record(attributes)) do |record|
diff --git a/activerecord/lib/active_record/associations/collection_proxy.rb b/activerecord/lib/active_record/associations/collection_proxy.rb
index eba688866c..84c8cfe72b 100644
--- a/activerecord/lib/active_record/associations/collection_proxy.rb
+++ b/activerecord/lib/active_record/associations/collection_proxy.rb
@@ -357,7 +357,7 @@ module ActiveRecord
 
       # Deletes all the records from the collection. For +has_many+ associations,
       # the deletion is done according to the strategy specified by the <tt>:dependent</tt>
-      # option. Returns an array with the deleted records.
+      # option.
       #
       # If no <tt>:dependent</tt> option is given, then it will follow the
       # default strategy. The default strategy is <tt>:nullify</tt>. This
@@ -435,11 +435,6 @@ module ActiveRecord
       #   #    ]
       #
       #   person.pets.delete_all
-      #   # => [
-      #   #       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
-      #   #       #<Pet id: 2, name: "Spook", person_id: 1>,
-      #   #       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
-      #   #    ]
       #
       #   Pet.find(1, 2, 3)
       #   # => ActiveRecord::RecordNotFound
@@ -860,6 +855,10 @@ module ActiveRecord
         !!@association.include?(record)
       end
 
+      def arel
+        scope.arel
+      end
+
       def proxy_association
         @association
       end
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 ca36462054..a0e83c0a02 100644
--- a/activerecord/lib/active_record/associations/join_dependency/join_association.rb
+++ b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
@@ -57,7 +57,7 @@ module ActiveRecord
             end
             scope_chain_index += 1
 
-            scope_chain_items.concat [klass.send(:build_default_scope)].compact
+            scope_chain_items.concat [klass.send(:build_default_scope, ActiveRecord::Relation.create(klass, table))].compact
 
             rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
               left.merge right
diff --git a/activerecord/lib/active_record/associations/preloader.rb b/activerecord/lib/active_record/associations/preloader.rb
index e49fc5d5c4..311684d886 100644
--- a/activerecord/lib/active_record/associations/preloader.rb
+++ b/activerecord/lib/active_record/associations/preloader.rb
@@ -140,36 +140,13 @@ module ActiveRecord
       end
 
       def grouped_records(association, records)
-        reflection_records = records_by_reflection(association, records)
-
-        reflection_records.each_with_object({}) do |(reflection, r_records),h|
-          h[reflection] = r_records.group_by { |record|
-            association_klass(reflection, record)
-          }
-        end
-      end
-
-      def records_by_reflection(association, records)
-        records.group_by do |record|
-          reflection = record.class.reflect_on_association(association)
-
-          reflection || raise_config_error(record, association)
-        end
-      end
-
-      def raise_config_error(record, association)
-        raise ActiveRecord::ConfigurationError,
-              "Association named '#{association}' was not found on #{record.class.name}; " \
-              "perhaps you misspelled it?"
-      end
-
-      def association_klass(reflection, record)
-        if reflection.macro == :belongs_to && reflection.options[:polymorphic]
-          klass = record.read_attribute(reflection.foreign_type.to_s)
-          klass && klass.constantize
-        else
-          reflection.klass
+        h = {}
+        records.each do |record|
+          assoc = record.association(association)
+          klasses = h[assoc.reflection] ||= {}
+          (klasses[assoc.klass] ||= []) << record
         end
+        h
       end
 
       class AlreadyLoaded
diff --git a/activerecord/lib/active_record/associations/singular_association.rb b/activerecord/lib/active_record/associations/singular_association.rb
index 399aff378a..747bb5f1d6 100644
--- a/activerecord/lib/active_record/associations/singular_association.rb
+++ b/activerecord/lib/active_record/associations/singular_association.rb
@@ -18,11 +18,11 @@ module ActiveRecord
       end
 
       def create(attributes = {}, &block)
-        create_record(attributes, &block)
+        _create_record(attributes, &block)
       end
 
       def create!(attributes = {}, &block)
-        create_record(attributes, true, &block)
+        _create_record(attributes, true, &block)
       end
 
       def build(attributes = {})
@@ -52,7 +52,7 @@ module ActiveRecord
           replace(record)
         end
 
-        def create_record(attributes, raise_error = false)
+        def _create_record(attributes, raise_error = false)
           record = build_record(attributes)
           yield(record) if block_given?
           saved = record.save
diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb
index ea48a13ea8..4b1733619a 100644
--- a/activerecord/lib/active_record/attribute_methods.rb
+++ b/activerecord/lib/active_record/attribute_methods.rb
@@ -29,6 +29,8 @@ module ActiveRecord
       end
     }
 
+    BLACKLISTED_CLASS_METHODS = %w(private public protected)
+
     class AttributeMethodCache
       def initialize
         @module = Module.new
@@ -132,7 +134,7 @@ module ActiveRecord
       # A class method is 'dangerous' if it is already (re)defined by Active Record, but
       # not by any ancestors. (So 'puts' is not dangerous but 'new' is.)
       def dangerous_class_method?(method_name)
-        class_method_defined_within?(method_name, Base)
+        BLACKLISTED_CLASS_METHODS.include?(method_name.to_s) || class_method_defined_within?(method_name, Base)
       end
 
       def class_method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc
diff --git a/activerecord/lib/active_record/attribute_methods/dirty.rb b/activerecord/lib/active_record/attribute_methods/dirty.rb
index 8a1b199997..99070f127b 100644
--- a/activerecord/lib/active_record/attribute_methods/dirty.rb
+++ b/activerecord/lib/active_record/attribute_methods/dirty.rb
@@ -79,11 +79,11 @@ module ActiveRecord
         end
       end
 
-      def update_record(*)
+      def _update_record(*)
         partial_writes? ? super(keys_for_partial_write) : super
       end
 
-      def create_record(*)
+      def _create_record(*)
         partial_writes? ? super(keys_for_partial_write) : super
       end
 
diff --git a/activerecord/lib/active_record/autosave_association.rb b/activerecord/lib/active_record/autosave_association.rb
index 213b72b933..e9622ca0c1 100644
--- a/activerecord/lib/active_record/autosave_association.rb
+++ b/activerecord/lib/active_record/autosave_association.rb
@@ -377,16 +377,15 @@ module ActiveRecord
       def save_has_one_association(reflection)
         association = association_instance_get(reflection.name)
         record      = association && association.load_target
-
         if record && !record.destroyed?
           autosave = reflection.options[:autosave]
 
           if autosave && record.marked_for_destruction?
             record.destroy
-          elsif autosave != false
+          else
             key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
+            if autosave != false && (autosave || new_record? || record_changed?(reflection, record, key))
 
-            if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
               unless reflection.through_reflection
                 record[reflection.foreign_key] = key
               end
diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
index 9ec1feea97..1d47cba234 100644
--- a/activerecord/lib/active_record/base.rb
+++ b/activerecord/lib/active_record/base.rb
@@ -310,8 +310,8 @@ module ActiveRecord #:nodoc:
     include Locking::Optimistic
     include Locking::Pessimistic
     include AttributeMethods
-    include Callbacks
     include Timestamp
+    include Callbacks
     include Associations
     include ActiveModel::SecurePassword
     include AutosaveAssociation
diff --git a/activerecord/lib/active_record/callbacks.rb b/activerecord/lib/active_record/callbacks.rb
index 35f19f0bc0..5955673b42 100644
--- a/activerecord/lib/active_record/callbacks.rb
+++ b/activerecord/lib/active_record/callbacks.rb
@@ -302,11 +302,11 @@ module ActiveRecord
       run_callbacks(:save) { super }
     end
 
-    def create_record #:nodoc:
+    def _create_record #:nodoc:
       run_callbacks(:create) { super }
     end
 
-    def update_record(*) #:nodoc:
+    def _update_record(*) #:nodoc:
       run_callbacks(:update) { super }
     end
   end
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 deea857a18..e56ece0300 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -324,7 +324,7 @@ module ActiveRecord
       def sanitize_limit(limit)
         if limit.is_a?(Integer) || limit.is_a?(Arel::Nodes::SqlLiteral)
           limit
-        elsif limit.to_s =~ /,/
+        elsif limit.to_s.include?(',')
           Arel.sql limit.to_s.split(',').map{ |i| Integer(i) }.join(',')
         else
           Integer(limit)
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 a51691bfa8..47fe501752 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_creation.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_creation.rb
@@ -13,7 +13,7 @@ module ActiveRecord
         end
 
         def visit_AddColumn(o)
-          sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+          sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale)
           sql = "ADD #{quote_column_name(o.name)} #{sql_type}"
           add_column_options!(sql, column_options(o))
         end
@@ -26,7 +26,7 @@ module ActiveRecord
           end
 
           def visit_ColumnDefinition(o)
-            sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+            sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale)
             column_sql = "#{quote_column_name(o.name)} #{sql_type}"
             add_column_options!(column_sql, column_options(o)) unless o.primary_key?
             column_sql
@@ -64,7 +64,7 @@ module ActiveRecord
           end
 
           def add_column_options!(sql, options)
-            sql << " DEFAULT #{@conn.quote(options[:default], options[:column])}" if options_include_default?(options)
+            sql << " DEFAULT #{quote_value(options[:default], options[:column])}" if options_include_default?(options)
             # must explicitly check for :null to allow change_column to work on migrations
             if options[:null] == false
               sql << " NOT NULL"
@@ -75,6 +75,12 @@ module ActiveRecord
             sql
           end
 
+          def quote_value(value, column)
+            column.sql_type ||= type_to_sql(column.type, column.limit, column.precision, column.scale)
+
+            @conn.quote(value, column)
+          end
+
           def options_include_default?(options)
             options.include?(:default) && !(options[:null] == false && options[:default].nil?)
           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 c39bf15e83..71c3a4378b 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
@@ -15,7 +15,7 @@ module ActiveRecord
     # are typically created by methods in TableDefinition, and added to the
     # +columns+ attribute of said TableDefinition object, in order to be used
     # for generating a number of table creation or table changing SQL statements.
-    class ColumnDefinition < Struct.new(:name, :type, :limit, :precision, :scale, :default, :null, :first, :after, :primary_key) #:nodoc:
+    class ColumnDefinition < Struct.new(:name, :type, :limit, :precision, :scale, :default, :null, :first, :after, :primary_key, :sql_type) #:nodoc:
 
       def primary_key?
         primary_key || type.to_sym == :primary_key
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 7f530ec5e4..aa99822389 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
@@ -186,24 +186,23 @@ module ActiveRecord
       def create_table(table_name, options = {})
         td = create_table_definition table_name, options[:temporary], options[:options], options[:as]
 
-        if !options[:as]
-          unless options[:id] == false
-            pk = options.fetch(:primary_key) {
-              Base.get_primary_key table_name.to_s.singularize
-            }
-
-            td.primary_key pk, options.fetch(:id, :primary_key), options
+        if options[:id] != false && !options[:as]
+          pk = options.fetch(:primary_key) do
+            Base.get_primary_key table_name.to_s.singularize
           end
 
-          yield td if block_given?
+          td.primary_key pk, options.fetch(:id, :primary_key), options
         end
 
+        yield td if block_given?
+
         if options[:force] && table_exists?(table_name)
           drop_table(table_name, options)
         end
 
-        execute schema_creation.accept td
-        td.indexes.each_pair { |c,o| add_index table_name, c, o }
+        result = execute schema_creation.accept td
+        td.indexes.each_pair { |c, o| add_index(table_name, c, o) } unless supports_indexes_in_create?
+        result
       end
 
       # Creates a new join table with the name created using the lexical order of the first two
@@ -740,6 +739,40 @@ module ActiveRecord
         Table.new(table_name, base)
       end
 
+      def add_index_options(table_name, column_name, options = {}) #:nodoc:
+        column_names = Array(column_name)
+        index_name   = index_name(table_name, column: column_names)
+
+        options.assert_valid_keys(:unique, :order, :name, :where, :length, :internal, :using, :algorithm, :type)
+
+        index_type = options[:unique] ? "UNIQUE" : ""
+        index_type = options[:type].to_s if options.key?(:type)
+        index_name = options[:name].to_s if options.key?(:name)
+        max_index_length = options.fetch(:internal, false) ? index_name_length : allowed_index_name_length
+
+        if options.key?(:algorithm)
+          algorithm = index_algorithms.fetch(options[:algorithm]) {
+            raise ArgumentError.new("Algorithm must be one of the following: #{index_algorithms.keys.map(&:inspect).join(', ')}")
+          }
+        end
+
+        using = "USING #{options[:using]}" if options[:using].present?
+
+        if supports_partial_index?
+          index_options = options[:where] ? " WHERE #{options[:where]}" : ""
+        end
+
+        if index_name.length > max_index_length
+          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{max_index_length} characters"
+        end
+        if table_exists?(table_name) && index_name_exists?(table_name, index_name, false)
+          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
+        end
+        index_columns = quoted_columns_for_index(column_names, options).join(", ")
+
+        [index_name, index_type, index_columns, index_options, algorithm, using]
+      end
+
       protected
         def add_index_sort_order(option_strings, column_names, options = {})
           if options.is_a?(Hash) && order = options[:order]
@@ -770,40 +803,6 @@ module ActiveRecord
           options.include?(:default) && !(options[:null] == false && options[:default].nil?)
         end
 
-        def add_index_options(table_name, column_name, options = {})
-          column_names = Array(column_name)
-          index_name   = index_name(table_name, column: column_names)
-
-          options.assert_valid_keys(:unique, :order, :name, :where, :length, :internal, :using, :algorithm, :type)
-
-          index_type = options[:unique] ? "UNIQUE" : ""
-          index_type = options[:type].to_s if options.key?(:type)
-          index_name = options[:name].to_s if options.key?(:name)
-          max_index_length = options.fetch(:internal, false) ? index_name_length : allowed_index_name_length
-
-          if options.key?(:algorithm)
-            algorithm = index_algorithms.fetch(options[:algorithm]) {
-              raise ArgumentError.new("Algorithm must be one of the following: #{index_algorithms.keys.map(&:inspect).join(', ')}")
-            }
-          end
-
-          using = "USING #{options[:using]}" if options[:using].present?
-
-          if supports_partial_index?
-            index_options = options[:where] ? " WHERE #{options[:where]}" : ""
-          end
-
-          if index_name.length > max_index_length
-            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{max_index_length} characters"
-          end
-          if index_name_exists?(table_name, index_name, false)
-            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
-          end
-          index_columns = quoted_columns_for_index(column_names, options).join(", ")
-
-          [index_name, index_type, index_columns, index_options, algorithm, using]
-        end
-
         def index_name_for_remove(table_name, options = {})
           index_name = index_name(table_name, options)
 
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index 2d45079168..78e0cc3d1b 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -152,28 +152,19 @@ module ActiveRecord
         'Abstract'
       end
 
-      # Does this adapter support migrations? Backend specific, as the
-      # abstract adapter always returns +false+.
+      # Does this adapter support migrations?
       def supports_migrations?
         false
       end
 
       # Can this adapter determine the primary key for tables not attached
-      # to an Active Record class, such as join tables? Backend specific, as
-      # the abstract adapter always returns +false+.
+      # to an Active Record class, such as join tables?
       def supports_primary_key?
         false
       end
 
-      # Does this adapter support using DISTINCT within COUNT? This is +true+
-      # for all adapters except sqlite.
-      def supports_count_distinct?
-        true
-      end
-
       # Does this adapter support DDL rollbacks in transactions? That is, would
-      # CREATE TABLE or ALTER TABLE get rolled back by a transaction? PostgreSQL,
-      # SQL Server, and others support this. MySQL and others do not.
+      # CREATE TABLE or ALTER TABLE get rolled back by a transaction?
       def supports_ddl_transactions?
         false
       end
@@ -182,8 +173,7 @@ module ActiveRecord
         false
       end
 
-      # Does this adapter support savepoints? PostgreSQL and MySQL do,
-      # SQLite < 3.6.8 does not.
+      # Does this adapter support savepoints?
       def supports_savepoints?
         false
       end
@@ -191,7 +181,6 @@ module ActiveRecord
       # Should primary key values be selected from their corresponding
       # sequence before the insert statement? If true, next_sequence_value
       # is called before each insert to set the record's primary key.
-      # This is false for all adapters but Firebird.
       def prefetch_primary_key?(table_name = nil)
         false
       end
@@ -206,8 +195,7 @@ module ActiveRecord
         false
       end
 
-      # Does this adapter support explain? As of this writing sqlite3,
-      # mysql2, and postgresql are the only ones that do.
+      # Does this adapter support explain?
       def supports_explain?
         false
       end
@@ -217,12 +205,17 @@ module ActiveRecord
         false
       end
 
-      # Does this adapter support database extensions? As of this writing only
-      # postgresql does.
+      # Does this adapter support database extensions?
       def supports_extensions?
         false
       end
 
+      # Does this adapter support creating indexes in the same statement as
+      # creating the table?
+      def supports_indexes_in_create?
+        false
+      end
+
       # This is meant to be implemented by the adapters that support extensions
       def disable_extension(name)
       end
@@ -231,14 +224,12 @@ module ActiveRecord
       def enable_extension(name)
       end
 
-      # A list of extensions, to be filled in by adapters that support them. At
-      # the moment only postgresql does.
+      # A list of extensions, to be filled in by adapters that support them.
       def extensions
         []
       end
 
       # A list of index algorithms, to be filled by adapters that support them.
-      # MySQL and PostgreSQL have support for them right now.
       def index_algorithms
         {}
       end
@@ -299,7 +290,6 @@ module ActiveRecord
       end
 
       # Returns true if its required to reload the connection between requests for development mode.
-      # This is not the case for Ruby/MySQL and it's not necessary for any adapters except SQLite.
       def requires_reloading?
         false
       end
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 9a819720f7..20eea208ec 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
@@ -6,18 +6,31 @@ module ActiveRecord
       include Savepoints
 
       class SchemaCreation < AbstractAdapter::SchemaCreation
-
         def visit_AddColumn(o)
           add_column_position!(super, column_options(o))
         end
 
         private
+
+        def visit_TableDefinition(o)
+          name = o.name
+          create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(name)} "
+
+          statements = o.columns.map { |c| accept c }
+          statements.concat(o.indexes.map { |column_name, options| index_in_create(name, column_name, options) })
+
+          create_sql << "(#{statements.join(', ')}) " if statements.present?
+          create_sql << "#{o.options}"
+          create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
+          create_sql
+        end
+
         def visit_ChangeColumnDefinition(o)
           column = o.column
           options = o.options
           sql_type = type_to_sql(o.type, options[:limit], options[:precision], options[:scale])
           change_column_sql = "CHANGE #{quote_column_name(column.name)} #{quote_column_name(options[:name])} #{sql_type}"
-          add_column_options!(change_column_sql, options)
+          add_column_options!(change_column_sql, options.merge(column: column))
           add_column_position!(change_column_sql, options)
         end
 
@@ -29,6 +42,11 @@ module ActiveRecord
           end
           sql
         end
+
+        def index_in_create(table_name, column_name, options)
+          index_name, index_type, index_columns, index_options, index_algorithm, index_using = @conn.add_index_options(table_name, column_name, options)
+          "#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_options} #{index_algorithm}"
+        end
       end
 
       def schema_creation
@@ -225,6 +243,10 @@ module ActiveRecord
         version[0] >= 5
       end
 
+      def supports_indexes_in_create?
+        true
+      end
+
       def native_database_types
         NATIVE_DATABASE_TYPES
       end
diff --git a/activerecord/lib/active_record/connection_adapters/connection_specification.rb b/activerecord/lib/active_record/connection_adapters/connection_specification.rb
index 9a133168f8..e0715f7ce9 100644
--- a/activerecord/lib/active_record/connection_adapters/connection_specification.rb
+++ b/activerecord/lib/active_record/connection_adapters/connection_specification.rb
@@ -35,7 +35,12 @@ module ActiveRecord
           @uri     = URI.parse(url)
           @adapter = @uri.scheme
           @adapter = "postgresql" if @adapter == "postgres"
-          @query   = @uri.query || ''
+
+          if @uri.opaque
+            @uri.opaque, @query = @uri.opaque.split('?', 2)
+          else
+            @query = @uri.query
+          end
         end
 
         # Converts the given URL to a full connection hash.
@@ -65,30 +70,38 @@ module ActiveRecord
         #   "localhost"
         #   # => {}
         def query_hash
-          Hash[@query.split("&").map { |pair| pair.split("=") }]
+          Hash[(@query || '').split("&").map { |pair| pair.split("=") }]
         end
 
         def raw_config
-          query_hash.merge({
-            "adapter"  => @adapter,
-            "username" => uri.user,
-            "password" => uri.password,
-            "port"     => uri.port,
-            "database" => database,
-            "host"     => uri.host })
+          if uri.opaque
+            query_hash.merge({
+              "adapter"  => @adapter,
+              "database" => uri.opaque })
+          else
+            query_hash.merge({
+              "adapter"  => @adapter,
+              "username" => uri.user,
+              "password" => uri.password,
+              "port"     => uri.port,
+              "database" => database_from_path,
+              "host"     => uri.host })
+          end
         end
 
         # Returns name of the database.
-        # Sqlite3 expects this to be a full path or `:memory:`.
-        def database
+        def database_from_path
           if @adapter == 'sqlite3'
-            if '/:memory:' == uri.path
-              ':memory:'
-            else
-              uri.path
-            end
+            # 'sqlite3:/foo' is absolute, because that makes sense. The
+            # corresponding relative version, 'sqlite3:foo', is handled
+            # elsewhere, as an "opaque".
+
+            uri.path
           else
-            uri.path.sub(%r{^/},"")
+            # Only SQLite uses a filename as the "database" name; for
+            # anything else, a leading slash would be silly.
+
+            uri.path.sub(%r{^/}, "")
           end
         end
       end
@@ -124,7 +137,7 @@ module ActiveRecord
           if config
             resolve_connection config
           elsif env = ActiveRecord::ConnectionHandling::RAILS_ENV.call
-            resolve_env_connection env.to_sym
+            resolve_symbol_connection env.to_sym
           else
             raise AdapterNotSpecified
           end
@@ -193,42 +206,41 @@ module ActiveRecord
         #
         def resolve_connection(spec)
           case spec
-          when Symbol, String
-            resolve_env_connection spec
+          when Symbol
+            resolve_symbol_connection spec
+          when String
+            resolve_string_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)
+            ActiveSupport::Deprecation.warn "Passing a string to ActiveRecord::Base.establish_connection " \
+              "for a configuration lookup is deprecated, please pass a symbol (#{spec.to_sym.inspect}) instead"
+            resolve_connection(configurations[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.
         #
-        #
-        #   Resolver.new("production" => {}).resolve_env_connection(:production)
+        #   Resolver.new("production" => {}).resolve_symbol_connection(:production)
         #   # => {}
         #
-        # Takes a connection URL.
-        #
-        #   Resolver.new({}).resolve_env_connection("postgresql://localhost/foo")
-        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-        #
-        def resolve_env_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_string_connection and
-          # resolve_symbol_connection.
+        def resolve_symbol_connection(spec)
           if config = configurations[spec.to_s]
-            if spec.is_a?(String)
-              ActiveSupport::Deprecation.warn "Passing a string to ActiveRecord::Base.establish_connection " \
-                "for a configuration lookup is deprecated, please pass a symbol (#{spec.to_sym.inspect}) instead"
-            end
             resolve_connection(config)
-          elsif spec.is_a?(String)
-            resolve_string_connection(spec)
           else
-            raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available configuration: #{configurations.inspect}")
+            raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
           end
         end
 
@@ -244,7 +256,12 @@ module ActiveRecord
           spec
         end
 
-        def resolve_string_connection(url)
+        # Takes a connection URL.
+        #
+        #   Resolver.new({}).resolve_url_connection("postgresql://localhost/foo")
+        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+        #
+        def resolve_url_connection(url)
           ConnectionUrlResolver.new(url).to_hash
         end
       end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
index 81b9703684..6cf0c94eb5 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
@@ -20,9 +20,9 @@ module ActiveRecord
       ConnectionAdapters::Mysql2Adapter.new(client, logger, options, config)
     rescue Mysql2::Error => error
       if error.message.include?("Unknown database")
-        raise ActiveRecord::NoDatabaseError.new(error.message)
+        raise ActiveRecord::NoDatabaseError.new(error.message, error)
       else
-        raise error
+        raise
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
index 49f0bfbcde..e6aa2ba921 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
@@ -36,9 +36,9 @@ module ActiveRecord
       ConnectionAdapters::MysqlAdapter.new(mysql, logger, options, config)
     rescue Mysql::Error => error
       if error.message.include?("Unknown database")
-        raise ActiveRecord::NoDatabaseError.new(error.message)
+        raise ActiveRecord::NoDatabaseError.new(error.message, error)
       else
-        raise error
+        raise
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/column.rb b/activerecord/lib/active_record/connection_adapters/postgresql/column.rb
new file mode 100644
index 0000000000..2cbcd5fd50
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/column.rb
@@ -0,0 +1,158 @@
+module ActiveRecord
+  module ConnectionAdapters
+    # PostgreSQL-specific extensions to column definitions in a table.
+    class PostgreSQLColumn < Column #:nodoc:
+      attr_accessor :array
+
+      def initialize(name, default, oid_type, sql_type = nil, null = true)
+        @oid_type = oid_type
+        default_value     = self.class.extract_value_from_default(default)
+
+        if sql_type =~ /\[\]$/
+          @array = true
+          super(name, default_value, sql_type[0..sql_type.length - 3], null)
+        else
+          @array = false
+          super(name, default_value, sql_type, null)
+        end
+
+        @default_function = default if has_default_function?(default_value, default)
+      end
+
+      def number?
+        !array && super
+      end
+
+      def text?
+        !array && super
+      end
+
+      # :stopdoc:
+      class << self
+        include ConnectionAdapters::PostgreSQLColumn::Cast
+        include ConnectionAdapters::PostgreSQLColumn::ArrayParser
+        attr_accessor :money_precision
+      end
+      # :startdoc:
+
+      # Extracts the value from a PostgreSQL column default definition.
+      def self.extract_value_from_default(default)
+        # This is a performance optimization for Ruby 1.9.2 in development.
+        # If the value is nil, we return nil straight away without checking
+        # the regular expressions. If we check each regular expression,
+        # Regexp#=== will call NilClass#to_str, which will trigger
+        # method_missing (defined by whiny nil in ActiveSupport) which
+        # makes this method very very slow.
+        return default unless default
+
+        case default
+          when /\A'(.*)'::(num|date|tstz|ts|int4|int8)range\z/m
+            $1
+          # Numeric types
+          when /\A\(?(-?\d+(\.\d*)?\)?(::bigint)?)\z/
+            $1
+          # Character types
+          when /\A\(?'(.*)'::.*\b(?:character varying|bpchar|text)\z/m
+            $1.gsub(/''/, "'")
+          # Binary data types
+          when /\A'(.*)'::bytea\z/m
+            $1
+          # Date/time types
+          when /\A'(.+)'::(?:time(?:stamp)? with(?:out)? time zone|date)\z/
+            $1
+          when /\A'(.*)'::interval\z/
+            $1
+          # Boolean type
+          when 'true'
+            true
+          when 'false'
+            false
+          # Geometric types
+          when /\A'(.*)'::(?:point|line|lseg|box|"?path"?|polygon|circle)\z/
+            $1
+          # Network address types
+          when /\A'(.*)'::(?:cidr|inet|macaddr)\z/
+            $1
+          # Bit string types
+          when /\AB'(.*)'::"?bit(?: varying)?"?\z/
+            $1
+          # XML type
+          when /\A'(.*)'::xml\z/m
+            $1
+          # Arrays
+          when /\A'(.*)'::"?\D+"?\[\]\z/
+            $1
+          # Hstore
+          when /\A'(.*)'::hstore\z/
+            $1
+          # JSON
+          when /\A'(.*)'::json\z/
+            $1
+          # Object identifier types
+          when /\A-?\d+\z/
+            $1
+          else
+            # Anything else is blank, some user type, or some function
+            # and we can't know the value of that, so return nil.
+            nil
+        end
+      end
+
+      def type_cast_for_write(value)
+        if @oid_type.respond_to?(:type_cast_for_write)
+          @oid_type.type_cast_for_write(value)
+        else
+          super
+        end
+      end
+
+      def type_cast(value)
+        return if value.nil?
+        return super if encoded?
+
+        @oid_type.type_cast value
+      end
+
+      def accessor
+        @oid_type.accessor
+      end
+
+      private
+
+        def has_default_function?(default_value, default)
+          !default_value && (%r{\w+\(.*\)} === default)
+        end
+
+        def extract_limit(sql_type)
+          case sql_type
+          when /^bigint/i;    8
+          when /^smallint/i;  2
+          when /^timestamp/i; nil
+          else super
+          end
+        end
+
+        # Extracts the scale from PostgreSQL-specific data types.
+        def extract_scale(sql_type)
+          # Money type has a fixed scale of 2.
+          sql_type =~ /^money/ ? 2 : super
+        end
+
+        # Extracts the precision from PostgreSQL-specific data types.
+        def extract_precision(sql_type)
+          if sql_type == 'money'
+            self.class.money_precision
+          elsif sql_type =~ /timestamp/i
+            $1.to_i if sql_type =~ /\((\d+)\)/
+          else
+            super
+          end
+        end
+
+        # Maps PostgreSQL-specific data types to logical Rails types.
+        def simplified_type(field_type)
+          @oid_type.simplified_type(field_type) || super
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid.rb
index 5d32aaed50..9e898015a6 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid.rb
@@ -6,6 +6,7 @@ module ActiveRecord
       module OID
         class Type
           def type; end
+          def simplified_type(sql_type); type end
 
           def infinity(options = {})
             ::Float::INFINITY * (options[:negative] ? -1 : 1)
@@ -18,7 +19,9 @@ module ActiveRecord
           end
         end
 
-        class Text < Type
+        class String < Type
+          def type; :string end
+
           def type_cast(value)
             return if value.nil?
 
@@ -26,9 +29,23 @@ module ActiveRecord
           end
         end
 
+        class SpecializedString < OID::String
+          def type; @type end
+
+          def initialize(type)
+            @type = type
+          end
+        end
+
+        class Text < OID::String
+          def type; :text end
+        end
+
         class Bit < Type
+          def type; :string end
+
           def type_cast(value)
-            if String === value
+            if ::String === value
               ConnectionAdapters::PostgreSQLColumn.string_to_bit value
             else
               value
@@ -37,6 +54,8 @@ module ActiveRecord
         end
 
         class Bytea < Type
+          def type; :binary end
+
           def type_cast(value)
             return if value.nil?
             PGconn.unescape_bytea value
@@ -44,9 +63,11 @@ module ActiveRecord
         end
 
         class Money < Type
+          def type; :decimal end
+
           def type_cast(value)
             return if value.nil?
-            return value unless String === value
+            return value unless ::String === value
 
             # Because money output is formatted according to the locale, there are two
             # cases to consider (note the decimal separators):
@@ -88,8 +109,10 @@ module ActiveRecord
         end
 
         class Point < Type
+          def type; :string end
+
           def type_cast(value)
-            if String === value
+            if ::String === value
               ConnectionAdapters::PostgreSQLColumn.string_to_point value
             else
               value
@@ -98,13 +121,15 @@ module ActiveRecord
         end
 
         class Array < Type
+          def type; @subtype.type end
+
           attr_reader :subtype
           def initialize(subtype)
             @subtype = subtype
           end
 
           def type_cast(value)
-            if String === value
+            if ::String === value
               ConnectionAdapters::PostgreSQLColumn.string_to_array value, @subtype
             else
               value
@@ -114,6 +139,8 @@ module ActiveRecord
 
         class Range < Type
           attr_reader :subtype
+          def simplified_type(sql_type); sql_type.to_sym end
+
           def initialize(subtype)
             @subtype = subtype
           end
@@ -160,6 +187,8 @@ This is not reliable and will be removed in the future.
         end
 
         class Integer < Type
+          def type; :integer end
+
           def type_cast(value)
             return if value.nil?
 
@@ -168,6 +197,8 @@ This is not reliable and will be removed in the future.
         end
 
         class Boolean < Type
+          def type; :boolean end
+
           def type_cast(value)
             return if value.nil?
 
@@ -177,6 +208,14 @@ This is not reliable and will be removed in the future.
 
         class Timestamp < Type
           def type; :timestamp; end
+          def simplified_type(sql_type)
+            case sql_type
+            when /^timestamp with(?:out)? time zone$/
+              :datetime
+            else
+              :timestamp
+            end
+          end
 
           def type_cast(value)
             return if value.nil?
@@ -188,7 +227,7 @@ This is not reliable and will be removed in the future.
         end
 
         class Date < Type
-          def type; :datetime; end
+          def type; :date; end
 
           def type_cast(value)
             return if value.nil?
@@ -200,6 +239,8 @@ This is not reliable and will be removed in the future.
         end
 
         class Time < Type
+          def type; :time end
+
           def type_cast(value)
             return if value.nil?
 
@@ -210,6 +251,8 @@ This is not reliable and will be removed in the future.
         end
 
         class Float < Type
+          def type; :float end
+
           def type_cast(value)
             return if value.nil?
 
@@ -218,6 +261,8 @@ This is not reliable and will be removed in the future.
         end
 
         class Decimal < Type
+          def type; :decimal end
+
           def type_cast(value)
             return if value.nil?
 
@@ -230,12 +275,16 @@ This is not reliable and will be removed in the future.
         end
 
         class Enum < Type
+          def type; :enum end
+
           def type_cast(value)
             value.to_s
           end
         end
 
         class Hstore < Type
+          def type; :hstore end
+
           def type_cast_for_write(value)
             ConnectionAdapters::PostgreSQLColumn.hstore_to_string value
           end
@@ -252,14 +301,20 @@ This is not reliable and will be removed in the future.
         end
 
         class Cidr < Type
+          def type; :cidr end
           def type_cast(value)
             return if value.nil?
 
             ConnectionAdapters::PostgreSQLColumn.string_to_cidr value
           end
         end
+        class Inet < Cidr
+          def type; :inet end
+        end
 
         class Json < Type
+          def type; :json end
+
           def type_cast_for_write(value)
             ConnectionAdapters::PostgreSQLColumn.json_to_string value
           end
@@ -275,6 +330,13 @@ This is not reliable and will be removed in the future.
           end
         end
 
+        class Uuid < Type
+          def type; :uuid end
+          def type_cast(value)
+            value.presence
+          end
+        end
+
         class TypeMap
           def initialize
             @mapping = {}
@@ -321,7 +383,7 @@ This is not reliable and will be removed in the future.
         }
 
         # Register an OID type named +name+ with a typecasting object in
-        # +type+.  +name+ should correspond to the `typname` column in
+        # +type+. +name+ should correspond to the `typname` column in
         # the `pg_type` table.
         def self.register_type(name, type)
           NAMES[name] = type
@@ -338,48 +400,46 @@ This is not reliable and will be removed in the future.
         end
 
         register_type 'int2', OID::Integer.new
-        alias_type    'int4', 'int2'
-        alias_type    'int8', 'int2'
-        alias_type    'oid',  'int2'
-
+        alias_type 'int4', 'int2'
+        alias_type 'int8', 'int2'
+        alias_type 'oid', 'int2'
         register_type 'numeric', OID::Decimal.new
+        register_type 'float4', OID::Float.new
+        alias_type 'float8', 'float4'
         register_type 'text', OID::Text.new
-        alias_type 'varchar', 'text'
-        alias_type 'char', 'text'
-        alias_type 'bpchar', 'text'
-        alias_type 'xml', 'text'
-
-        # FIXME: why are we keeping these types as strings?
-        alias_type 'tsvector', 'text'
-        alias_type 'interval', 'text'
-        alias_type 'macaddr',  'text'
-        alias_type 'uuid',     'text'
-
-        register_type 'money', OID::Money.new
-        register_type 'bytea', OID::Bytea.new
+        register_type 'varchar', OID::String.new
+        alias_type 'char', 'varchar'
+        alias_type 'bpchar', 'varchar'
         register_type 'bool', OID::Boolean.new
         register_type 'bit', OID::Bit.new
-        register_type 'varbit', OID::Bit.new
-
-        register_type 'float4', OID::Float.new
-        alias_type 'float8', 'float4'
-
+        alias_type 'varbit', 'bit'
         register_type 'timestamp', OID::Timestamp.new
-        register_type 'timestamptz', OID::Timestamp.new
+        alias_type 'timestamptz', 'timestamp'
         register_type 'date', OID::Date.new
         register_type 'time', OID::Time.new
 
-        register_type 'path', OID::Text.new
+        register_type 'money', OID::Money.new
+        register_type 'bytea', OID::Bytea.new
         register_type 'point', OID::Point.new
-        register_type 'polygon', OID::Text.new
-        register_type 'circle', OID::Text.new
         register_type 'hstore', OID::Hstore.new
         register_type 'json', OID::Json.new
-        register_type 'citext', OID::Text.new
-        register_type 'ltree', OID::Text.new
-
         register_type 'cidr', OID::Cidr.new
-        alias_type 'inet', 'cidr'
+        register_type 'inet', OID::Inet.new
+        register_type 'uuid', OID::Uuid.new
+        register_type 'xml', SpecializedString.new(:xml)
+        register_type 'tsvector', SpecializedString.new(:tsvector)
+        register_type 'macaddr', SpecializedString.new(:macaddr)
+        register_type 'citext', SpecializedString.new(:citext)
+        register_type 'ltree', SpecializedString.new(:ltree)
+
+        # FIXME: why are we keeping these types as strings?
+        alias_type 'interval', 'varchar'
+        alias_type 'path', 'varchar'
+        alias_type 'line', 'varchar'
+        alias_type 'polygon', 'varchar'
+        alias_type 'circle', 'varchar'
+        alias_type 'lseg', 'varchar'
+        alias_type 'box', 'varchar'
       end
     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 210172cf32..ac3b0f713d 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb
@@ -4,14 +4,14 @@ module ActiveRecord
       module Quoting
         # Escapes binary strings for bytea input to the database.
         def escape_bytea(value)
-          PGconn.escape_bytea(value) if value
+          @connection.escape_bytea(value) if value
         end
 
         # Unescapes bytea output from a database to the binary string it represents.
         # NOTE: This is NOT an inverse of escape_bytea! This is only to be used
         # on escaped binary output from database drive.
         def unescape_bytea(value)
-          PGconn.unescape_bytea(value) if value
+          @connection.unescape_bytea(value) if value
         end
 
         # Quotes PostgreSQL-specific data types for SQL input.
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 e0afa989cd..50a73aa666 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
@@ -104,14 +104,11 @@ module ActiveRecord
           schema, table = Utils.extract_schema_and_table(name.to_s)
           return false unless table
 
-          binds = [[nil, table]]
-          binds << [nil, schema] if schema
-
           exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
               SELECT COUNT(*)
               FROM pg_class c
               LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-              WHERE c.relkind in ('v','r')
+              WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
               AND c.relname = '#{table.gsub(/(^"|"$)/,'')}'
               AND n.nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'}
           SQL
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index bcad9f30d7..3510e4f3b0 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -7,6 +7,7 @@ require 'active_record/connection_adapters/postgresql/quoting'
 require 'active_record/connection_adapters/postgresql/schema_statements'
 require 'active_record/connection_adapters/postgresql/database_statements'
 require 'active_record/connection_adapters/postgresql/referential_integrity'
+require 'active_record/connection_adapters/postgresql/column'
 require 'arel/visitors/bind_visitor'
 
 # Make sure we're using pg high enough for PGResult#values
@@ -43,224 +44,6 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
-    # PostgreSQL-specific extensions to column definitions in a table.
-    class PostgreSQLColumn < Column #:nodoc:
-      attr_accessor :array
-
-      def initialize(name, default, oid_type, sql_type = nil, null = true)
-        @oid_type = oid_type
-        default_value     = self.class.extract_value_from_default(default)
-
-        if sql_type =~ /\[\]$/
-          @array = true
-          super(name, default_value, sql_type[0..sql_type.length - 3], null)
-        else
-          @array = false
-          super(name, default_value, sql_type, null)
-        end
-
-        @default_function = default if has_default_function?(default_value, default)
-      end
-
-      def number?
-        !array && super
-      end
-
-      def text?
-        !array && super
-      end
-
-      # :stopdoc:
-      class << self
-        include ConnectionAdapters::PostgreSQLColumn::Cast
-        include ConnectionAdapters::PostgreSQLColumn::ArrayParser
-        attr_accessor :money_precision
-      end
-      # :startdoc:
-
-      # Extracts the value from a PostgreSQL column default definition.
-      def self.extract_value_from_default(default)
-        # This is a performance optimization for Ruby 1.9.2 in development.
-        # If the value is nil, we return nil straight away without checking
-        # the regular expressions. If we check each regular expression,
-        # Regexp#=== will call NilClass#to_str, which will trigger
-        # method_missing (defined by whiny nil in ActiveSupport) which
-        # makes this method very very slow.
-        return default unless default
-
-        case default
-          when /\A'(.*)'::(num|date|tstz|ts|int4|int8)range\z/m
-            $1
-          # Numeric types
-          when /\A\(?(-?\d+(\.\d*)?\)?(::bigint)?)\z/
-            $1
-          # Character types
-          when /\A\(?'(.*)'::.*\b(?:character varying|bpchar|text)\z/m
-            $1.gsub(/''/, "'")
-          # Binary data types
-          when /\A'(.*)'::bytea\z/m
-            $1
-          # Date/time types
-          when /\A'(.+)'::(?:time(?:stamp)? with(?:out)? time zone|date)\z/
-            $1
-          when /\A'(.*)'::interval\z/
-            $1
-          # Boolean type
-          when 'true'
-            true
-          when 'false'
-            false
-          # Geometric types
-          when /\A'(.*)'::(?:point|line|lseg|box|"?path"?|polygon|circle)\z/
-            $1
-          # Network address types
-          when /\A'(.*)'::(?:cidr|inet|macaddr)\z/
-            $1
-          # Bit string types
-          when /\AB'(.*)'::"?bit(?: varying)?"?\z/
-            $1
-          # XML type
-          when /\A'(.*)'::xml\z/m
-            $1
-          # Arrays
-          when /\A'(.*)'::"?\D+"?\[\]\z/
-            $1
-          # Hstore
-          when /\A'(.*)'::hstore\z/
-            $1
-          # JSON
-          when /\A'(.*)'::json\z/
-            $1
-          # Object identifier types
-          when /\A-?\d+\z/
-            $1
-          else
-            # Anything else is blank, some user type, or some function
-            # and we can't know the value of that, so return nil.
-            nil
-        end
-      end
-
-      def type_cast_for_write(value)
-        if @oid_type.respond_to?(:type_cast_for_write)
-          @oid_type.type_cast_for_write(value)
-        else
-          super
-        end
-      end
-
-      def type_cast(value)
-        return if value.nil?
-        return super if encoded?
-
-        @oid_type.type_cast value
-      end
-
-      def accessor
-        @oid_type.accessor
-      end
-
-      private
-
-        def has_default_function?(default_value, default)
-          !default_value && (%r{\w+\(.*\)} === default)
-        end
-
-        def extract_limit(sql_type)
-          case sql_type
-          when /^bigint/i;    8
-          when /^smallint/i;  2
-          when /^timestamp/i; nil
-          else super
-          end
-        end
-
-        # Extracts the scale from PostgreSQL-specific data types.
-        def extract_scale(sql_type)
-          # Money type has a fixed scale of 2.
-          sql_type =~ /^money/ ? 2 : super
-        end
-
-        # Extracts the precision from PostgreSQL-specific data types.
-        def extract_precision(sql_type)
-          if sql_type == 'money'
-            self.class.money_precision
-          elsif sql_type =~ /timestamp/i
-            $1.to_i if sql_type =~ /\((\d+)\)/
-          else
-            super
-          end
-        end
-
-        # Maps PostgreSQL-specific data types to logical Rails types.
-        def simplified_type(field_type)
-          case field_type
-          # Numeric and monetary types
-          when /^(?:real|double precision)$/
-            :float
-          # Monetary types
-          when 'money'
-            :decimal
-          when 'hstore'
-            :hstore
-          when 'ltree'
-            :ltree
-          # Network address types
-          when 'inet'
-            :inet
-          when 'cidr'
-            :cidr
-          when 'macaddr'
-            :macaddr
-          # Character types
-          when /^(?:character varying|bpchar)(?:\(\d+\))?$/
-            :string
-          when /^citext(?:\(\d+\))?$/
-            :citext
-          # Binary data types
-          when 'bytea'
-            :binary
-          # Date/time types
-          when /^timestamp with(?:out)? time zone$/
-            :datetime
-          when /^interval(?:|\(\d+\))$/
-            :string
-          # Geometric types
-          when /^(?:point|line|lseg|box|"?path"?|polygon|circle)$/
-            :string
-          # Bit strings
-          when /^bit(?: varying)?(?:\(\d+\))?$/
-            :string
-          # XML type
-          when 'xml'
-            :xml
-          # tsvector type
-          when 'tsvector'
-            :tsvector
-          # Arrays
-          when /^\D+\[\]$/
-            :string
-          # Object identifier types
-          when 'oid'
-            :integer
-          # UUID type
-          when 'uuid'
-            :uuid
-          # JSON type
-          when 'json'
-            :json
-          # Small and big integer types
-          when /^(?:small|big)int$/
-            :integer
-          when /(num|date|tstz|ts|int4|int8)range$/
-            field_type.to_sym
-          # Pass through all types that are not specific to PostgreSQL.
-          else
-            super
-          end
-        end
-    end
-
     # The PostgreSQL adapter works with the native C (https://bitbucket.org/ged/ruby-pg) driver.
     #
     # Options:
@@ -426,7 +209,7 @@ module ActiveRecord
 
       NATIVE_DATABASE_TYPES = {
         primary_key: "serial primary key",
-        string:      { name: "character varying", limit: 255 },
+        string:      { name: "character varying" },
         text:        { name: "text" },
         integer:     { name: "integer" },
         float:       { name: "float" },
@@ -671,6 +454,10 @@ module ActiveRecord
         postgresql_version >= 90200
       end
 
+      def supports_materialized_views?
+        postgresql_version >= 90300
+      end
+
       def enable_extension(name)
         exec_query("CREATE EXTENSION IF NOT EXISTS \"#{name}\"").tap {
           reload_type_map
@@ -799,22 +586,23 @@ module ActiveRecord
         def initialize_type_map(type_map)
           if supports_ranges?
             result = execute(<<-SQL, 'SCHEMA')
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype
+              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
               FROM pg_type as t
               LEFT JOIN pg_range as r ON oid = rngtypid
             SQL
           else
             result = execute(<<-SQL, 'SCHEMA')
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput
+              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype
               FROM pg_type as t
             SQL
           end
-          ranges, nodes = result.partition { |row| row['typinput'] == 'range_in' }
-          leaves, nodes = nodes.partition { |row| row['typelem'] == '0' }
+          ranges, nodes = result.partition { |row| row['typtype'] == 'r' }
+          enums, nodes = nodes.partition { |row| row['typtype'] == 'e' }
+          domains, nodes = nodes.partition { |row| row['typtype'] == 'd' }
           arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in' }
+          leaves, nodes = nodes.partition { |row| row['typelem'] == '0' }
 
           # populate the enum types
-          enums, leaves = leaves.partition { |row| row['typinput'] == 'enum_in' }
           enums.each do |row|
             type_map[row['oid'].to_i] = OID::Enum.new
           end
@@ -843,6 +631,16 @@ module ActiveRecord
             range = OID::Range.new subtype
             type_map[row['oid'].to_i] = range
           end
+
+          # populate domain types
+          domains.each do |row|
+            base_type_oid = row["typbasetype"].to_i
+            if base_type = type_map[base_type_oid]
+              type_map[row['oid'].to_i] = base_type
+            else
+              warn "unknown base type (OID: #{base_type_oid}) for domain #{row["typname"]}."
+            end
+          end
         end
 
         FEATURE_NOT_SUPPORTED = "0A000" #:nodoc:
@@ -924,9 +722,9 @@ module ActiveRecord
           configure_connection
         rescue ::PG::Error => error
           if error.message.include?("does not exist")
-            raise ActiveRecord::NoDatabaseError.new(error.message)
+            raise ActiveRecord::NoDatabaseError.new(error.message, error)
           else
-            raise error
+            raise
           end
         end
 
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
index 1e299f12cd..2cb619881a 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
@@ -33,9 +33,9 @@ module ActiveRecord
       ConnectionAdapters::SQLite3Adapter.new(db, logger, config)
     rescue Errno::ENOENT => error
       if error.message.include?("No such file or directory")
-        raise ActiveRecord::NoDatabaseError.new(error.message)
+        raise ActiveRecord::NoDatabaseError.new(error.message, error)
       else
-        raise error
+        raise
       end
     end
   end
@@ -63,7 +63,7 @@ module ActiveRecord
 
       NATIVE_DATABASE_TYPES = {
         primary_key:  'INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL',
-        string:       { name: "varchar", limit: 255 },
+        string:       { name: "varchar" },
         text:         { name: "text" },
         integer:      { name: "integer" },
         float:        { name: "float" },
diff --git a/activerecord/lib/active_record/core.rb b/activerecord/lib/active_record/core.rb
index 73ca468d80..eeb2f5430e 100644
--- a/activerecord/lib/active_record/core.rb
+++ b/activerecord/lib/active_record/core.rb
@@ -366,7 +366,7 @@ module ActiveRecord
     def ==(comparison_object)
       super ||
         comparison_object.instance_of?(self.class) &&
-        id &&
+        !id.nil? &&
         comparison_object.id == id
     end
     alias :eql? :==
diff --git a/activerecord/lib/active_record/enum.rb b/activerecord/lib/active_record/enum.rb
index 4aa323fb00..167f8b7a49 100644
--- a/activerecord/lib/active_record/enum.rb
+++ b/activerecord/lib/active_record/enum.rb
@@ -65,10 +65,13 @@ module ActiveRecord
   #
   # Where conditions on an enum attribute must use the ordinal value of an enum.
   module Enum
-    DEFINED_ENUMS = {} # :nodoc:
+    def self.extended(base)
+      base.class_attribute(:defined_enums)
+      base.defined_enums = {}
+    end
 
     def enum_mapping_for(attr_name) # :nodoc:
-      DEFINED_ENUMS[attr_name.to_s]
+      defined_enums[attr_name.to_s]
     end
 
     def enum(definitions)
@@ -122,9 +125,8 @@ module ActiveRecord
             klass.send(:detect_enum_conflict!, name, value, true)
             klass.scope value, -> { klass.where name => i }
           end
-
-          DEFINED_ENUMS[name.to_s] = enum_values
         end
+        defined_enums[name.to_s] = enum_values
       end
     end
 
diff --git a/activerecord/lib/active_record/errors.rb b/activerecord/lib/active_record/errors.rb
index 7f6228131f..71efbb8f93 100644
--- a/activerecord/lib/active_record/errors.rb
+++ b/activerecord/lib/active_record/errors.rb
@@ -95,15 +95,7 @@ module ActiveRecord
   end
 
   # Raised when a given database does not exist
-  class NoDatabaseError < ActiveRecordError
-    def initialize(message)
-      super extend_message(message)
-    end
-
-    # can be over written to add additional error information.
-    def extend_message(message)
-      message
-    end
+  class NoDatabaseError < StatementInvalid
   end
 
   # Raised on attempt to save stale record. Record is stale when it's being saved in another query after
diff --git a/activerecord/lib/active_record/locking/optimistic.rb b/activerecord/lib/active_record/locking/optimistic.rb
index 6f54729b3c..4d63b04d9f 100644
--- a/activerecord/lib/active_record/locking/optimistic.rb
+++ b/activerecord/lib/active_record/locking/optimistic.rb
@@ -66,7 +66,7 @@ module ActiveRecord
           send(lock_col + '=', previous_lock_value + 1)
         end
 
-        def update_record(attribute_names = @attributes.keys) #:nodoc:
+        def _update_record(attribute_names = @attributes.keys) #:nodoc:
           return super unless locking_enabled?
           return 0 if attribute_names.empty?
 
diff --git a/activerecord/lib/active_record/persistence.rb b/activerecord/lib/active_record/persistence.rb
index c20499d081..13d7432773 100644
--- a/activerecord/lib/active_record/persistence.rb
+++ b/activerecord/lib/active_record/persistence.rb
@@ -455,6 +455,8 @@ module ActiveRecord
         changed_attributes.except!(*changes.keys)
         primary_key = self.class.primary_key
         self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
+      else
+        true
       end
     end
 
@@ -482,24 +484,24 @@ module ActiveRecord
 
     def create_or_update
       raise ReadOnlyRecord if readonly?
-      result = new_record? ? create_record : update_record
+      result = new_record? ? _create_record : _update_record
       result != false
     end
 
     # Updates the associated record with values matching those of the instance attributes.
     # Returns the number of affected rows.
-    def update_record(attribute_names = @attributes.keys)
+    def _update_record(attribute_names = @attributes.keys)
       attributes_values = arel_attributes_with_values_for_update(attribute_names)
       if attributes_values.empty?
         0
       else
-        self.class.unscoped.update_record attributes_values, id, id_was
+        self.class.unscoped._update_record attributes_values, id, id_was
       end
     end
 
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
-    def create_record(attribute_names = @attributes.keys)
+    def _create_record(attribute_names = @attributes.keys)
       attributes_values = arel_attributes_with_values_for_create(attribute_names)
 
       new_id = self.class.unscoped.insert attributes_values
diff --git a/activerecord/lib/active_record/railtie.rb b/activerecord/lib/active_record/railtie.rb
index 11b564f8f9..a4ceacbf44 100644
--- a/activerecord/lib/active_record/railtie.rb
+++ b/activerecord/lib/active_record/railtie.rb
@@ -116,17 +116,22 @@ module ActiveRecord
     # and then establishes the connection.
     initializer "active_record.initialize_database" do |app|
       ActiveSupport.on_load(:active_record) do
+        self.configurations = Rails.application.config.database_configuration
 
-        class ActiveRecord::NoDatabaseError
-          remove_possible_method :extend_message
-          def extend_message(message)
-            message << "Run `$ bin/rake db:create db:migrate` to create your database"
-            message
-          end
-        end
+        begin
+          establish_connection
+        rescue ActiveRecord::NoDatabaseError
+          warn <<-end_warning
+Oops - You have a database configured, but it doesn't exist yet!
 
-        self.configurations = Rails.application.config.database_configuration
-        establish_connection
+Here's how to get started:
+
+  1. Configure your database in config/database.yml.
+  2. Run `bin/rake db:create` to create the database.
+  3. Run `bin/rake db:setup` to load your database schema.
+end_warning
+          raise
+        end
       end
     end
 
diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index ff1f0f5911..6b0459ea37 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -186,7 +186,7 @@ db_namespace = namespace :db do
 
       fixtures_dir = File.join [base_dir, ENV['FIXTURES_DIR']].compact
 
-      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir["#{fixtures_dir}/**/*.yml"].map {|f| f[(fixtures_dir.size + 1)..-5] }).each do |fixture_file|
+      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(',') : Dir["#{fixtures_dir}/**/*.yml"].map {|f| f[(fixtures_dir.size + 1)..-5] }).each do |fixture_file|
         ActiveRecord::FixtureSet.create_fixtures(fixtures_dir, fixture_file)
       end
     end
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index bce7766501..03b5bdc46c 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -151,7 +151,7 @@ module ActiveRecord
         super ||
           other_aggregation.kind_of?(self.class) &&
           name == other_aggregation.name &&
-          other_aggregation.options &&
+          !other_aggregation.options.nil? &&
           active_record == other_aggregation.active_record
       end
 
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index d95f01e89c..915035558c 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -70,7 +70,7 @@ module ActiveRecord
         binds)
     end
 
-    def update_record(values, id, id_was) # :nodoc:
+    def _update_record(values, id, id_was) # :nodoc:
       substitutes, binds = substitute_values values
       um = @klass.unscoped.where(@klass.arel_table[@klass.primary_key].eq(id_was || id)).arel.compile_update(substitutes, @klass.primary_key)
 
diff --git a/activerecord/lib/active_record/relation/calculations.rb b/activerecord/lib/active_record/relation/calculations.rb
index 6e868902c5..5e525340e0 100644
--- a/activerecord/lib/active_record/relation/calculations.rb
+++ b/activerecord/lib/active_record/relation/calculations.rb
@@ -231,7 +231,7 @@ module ActiveRecord
 
     def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
       # Postgresql doesn't like ORDER BY when there are no GROUP BY
-      relation = reorder(nil)
+      relation = unscope(:order)
 
       column_alias = column_name
 
diff --git a/activerecord/lib/active_record/relation/merger.rb b/activerecord/lib/active_record/relation/merger.rb
index 182b9ed89c..be44fccad5 100644
--- a/activerecord/lib/active_record/relation/merger.rb
+++ b/activerecord/lib/active_record/relation/merger.rb
@@ -139,7 +139,6 @@ module ActiveRecord
       def merge_single_values
         relation.from_value          = values[:from] unless relation.from_value
         relation.lock_value          = values[:lock] unless relation.lock_value
-        relation.reverse_order_value = values[:reverse_order]
 
         unless values[:create_with].blank?
           relation.create_with_value = (relation.create_with_value || {}).merge(values[:create_with])
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
index db4ad52592..8cd97a3715 100644
--- a/activerecord/lib/active_record/relation/query_methods.rb
+++ b/activerecord/lib/active_record/relation/query_methods.rb
@@ -170,7 +170,7 @@ module ActiveRecord
 
     # Use to indicate that the given +table_names+ are referenced by an SQL string,
     # and should therefore be JOINed in any query rather than loaded separately.
-    # This method only works in conjuction with +includes+.
+    # This method only works in conjunction with +includes+.
     # See #includes for more details.
     #
     #   User.includes(:posts).where("posts.name = 'foo'")
@@ -263,6 +263,10 @@ module ActiveRecord
     #
     #   User.group('name AS grouped_name, age')
     #   => [#<User id: 3, name: "Foo", age: 21, ...>, #<User id: 2, name: "Oscar", age: 21, ...>, #<User id: 5, name: "Foo", age: 23, ...>]
+    #
+    # Passing in an array of attributes to group by is also supported.
+    #   User.select([:id, :first_name]).group(:id, :first_name).first(3)
+    #   => [#<User id: 1, first_name: "Bill">, #<User id: 2, first_name: "Earl">, #<User id: 3, first_name: "Beto">]
     def group(*args)
       check_if_method_has_arguments!(:group, args)
       spawn.group!(*args)
@@ -821,7 +825,9 @@ module ActiveRecord
     end
 
     def reverse_order! # :nodoc:
-      self.reverse_order_value = !reverse_order_value
+      orders = order_values.uniq
+      orders.reject!(&:blank?)
+      self.order_values = reverse_sql_order(orders)
       self
     end
 
@@ -876,7 +882,6 @@ module ActiveRecord
 
       case scope
       when :order
-        self.reverse_order_value = false
         result = []
       when :where
         self.bind_values = []
@@ -1062,7 +1067,6 @@ module ActiveRecord
     def build_order(arel)
       orders = order_values.uniq
       orders.reject!(&:blank?)
-      orders = reverse_sql_order(orders) if reverse_order_value
 
       arel.order(*orders) unless orders.empty?
     end
diff --git a/activerecord/lib/active_record/scoping/default.rb b/activerecord/lib/active_record/scoping/default.rb
index 73ab3b39aa..18190cb535 100644
--- a/activerecord/lib/active_record/scoping/default.rb
+++ b/activerecord/lib/active_record/scoping/default.rb
@@ -94,14 +94,14 @@ module ActiveRecord
           self.default_scopes += [scope]
         end
 
-        def build_default_scope # :nodoc:
+        def build_default_scope(base_rel = relation) # :nodoc:
           if !Base.is_a?(method(:default_scope).owner)
             # The user has defined their own default scope method, so call that
             evaluate_default_scope { default_scope }
           elsif default_scopes.any?
             evaluate_default_scope do
-              default_scopes.inject(relation) do |default_scope, scope|
-                default_scope.merge(unscoped { scope.call })
+              default_scopes.inject(base_rel) do |default_scope, scope|
+                default_scope.merge(base_rel.scoping { scope.call })
               end
             end
           end
diff --git a/activerecord/lib/active_record/timestamp.rb b/activerecord/lib/active_record/timestamp.rb
index 7178bed560..6c30ccab72 100644
--- a/activerecord/lib/active_record/timestamp.rb
+++ b/activerecord/lib/active_record/timestamp.rb
@@ -43,7 +43,7 @@ module ActiveRecord
 
   private
 
-    def create_record
+    def _create_record
       if self.record_timestamps
         current_time = current_time_from_proper_timezone
 
@@ -57,7 +57,7 @@ module ActiveRecord
       super
     end
 
-    def update_record(*args)
+    def _update_record(*args)
       if should_record_timestamps?
         current_time = current_time_from_proper_timezone
 
diff --git a/activerecord/lib/active_record/transactions.rb b/activerecord/lib/active_record/transactions.rb
index ec3e8f281b..17f76b63b3 100644
--- a/activerecord/lib/active_record/transactions.rb
+++ b/activerecord/lib/active_record/transactions.rb
@@ -369,7 +369,7 @@ module ActiveRecord
           @new_record = restore_state[:new_record]
           @destroyed  = restore_state[:destroyed]
           if restore_state.has_key?(:id)
-            self.id = restore_state[:id]
+            write_attribute(self.class.primary_key, restore_state[:id])
           else
             @attributes.delete(self.class.primary_key)
             @attributes_cache.delete(self.class.primary_key)
diff --git a/activerecord/lib/active_record/validations.rb b/activerecord/lib/active_record/validations.rb
index 26dca415ff..9999624fcf 100644
--- a/activerecord/lib/active_record/validations.rb
+++ b/activerecord/lib/active_record/validations.rb
@@ -60,6 +60,8 @@ module ActiveRecord
     # Runs all the validations within the specified context. Returns +true+ if
     # no errors are found, +false+ otherwise.
     #
+    # Aliased as validate.
+    #
     # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
     # <tt>new_record?</tt> is +true+, and to <tt>:update</tt> if it is not.
     #
@@ -71,6 +73,8 @@ module ActiveRecord
       errors.empty? && output
     end
 
+    alias_method :validate, :valid?
+
   protected
 
     def perform_validations(options={}) # :nodoc:
diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index 696b859b36..90953ce6cd 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -144,9 +144,9 @@ module ActiveRecord
         @connection.execute "INSERT INTO subscribers(nick) VALUES('me')"
       end
     end
-
-    def test_foreign_key_violations_are_translated_to_specific_exception
-      unless @connection.adapter_name == 'SQLite'
+    
+    unless current_adapter?(:SQLite3Adapter)
+      def test_foreign_key_violations_are_translated_to_specific_exception
         assert_raises(ActiveRecord::InvalidForeignKey) do
           # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method
           if @connection.prefetch_primary_key?
@@ -157,6 +157,18 @@ module ActiveRecord
           end
         end
       end
+ 
+      def test_foreign_key_violations_are_translated_to_specific_exception_with_validate_false
+        klass_has_fk = Class.new(ActiveRecord::Base) do
+          self.table_name = 'fk_test_has_fk'
+        end
+
+        assert_raises(ActiveRecord::InvalidForeignKey) do
+          has_fk = klass_has_fk.new
+          has_fk.fk_id = 1231231231
+          has_fk.save(validate: false)
+        end
+      end
     end
 
     def test_disable_referential_integrity
diff --git a/activerecord/test/cases/adapters/mysql/active_schema_test.rb b/activerecord/test/cases/adapters/mysql/active_schema_test.rb
index e77138eb1d..7c0f11b033 100644
--- a/activerecord/test/cases/adapters/mysql/active_schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql/active_schema_test.rb
@@ -1,10 +1,10 @@
 require "cases/helper"
+require 'support/connection_helper'
 
 class ActiveSchemaTest < ActiveRecord::TestCase
-  def setup
-    @connection = ActiveRecord::Base.remove_connection
-    ActiveRecord::Base.establish_connection(@connection)
+  include ConnectionHelper
 
+  def setup
     ActiveRecord::Base.connection.singleton_class.class_eval do
       alias_method :execute_without_stub, :execute
       def execute(sql, name = nil) return sql end
@@ -12,12 +12,12 @@ class ActiveSchemaTest < ActiveRecord::TestCase
   end
 
   teardown do
-    ActiveRecord::Base.remove_connection
-    ActiveRecord::Base.establish_connection(@connection)
+    reset_connection
   end
 
   def test_add_index
-    # add_index calls index_name_exists? which can't work since execute is stubbed
+    # add_index calls table_exists? and index_name_exists? which can't work since execute is stubbed
+    def (ActiveRecord::Base.connection).table_exists?(*); true; end
     def (ActiveRecord::Base.connection).index_name_exists?(*); false; end
 
     expected = "CREATE  INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
@@ -116,6 +116,18 @@ class ActiveSchemaTest < ActiveRecord::TestCase
     end
   end
 
+  def test_indexes_in_create
+    ActiveRecord::Base.connection.stubs(:table_exists?).with(:temp).returns(false)
+    ActiveRecord::Base.connection.stubs(:index_name_exists?).with(:index_temp_on_zip).returns(false)
+
+    expected = "CREATE TEMPORARY TABLE `temp` ( INDEX `index_temp_on_zip`  (`zip`) ) ENGINE=InnoDB AS SELECT id, name, zip FROM a_really_complicated_query"
+    actual = ActiveRecord::Base.connection.create_table(:temp, temporary: true, as: "SELECT id, name, zip FROM a_really_complicated_query") do |t|
+      t.index :zip
+    end
+
+    assert_equal expected, actual
+  end
+
   private
     def with_real_execute
       ActiveRecord::Base.connection.singleton_class.class_eval do
diff --git a/activerecord/test/cases/adapters/mysql/connection_test.rb b/activerecord/test/cases/adapters/mysql/connection_test.rb
index 42ffb91095..412efa22ff 100644
--- a/activerecord/test/cases/adapters/mysql/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql/connection_test.rb
@@ -1,7 +1,9 @@
 require "cases/helper"
+require 'support/connection_helper'
 require 'support/ddl_helper'
 
 class MysqlConnectionTest < ActiveRecord::TestCase
+  include ConnectionHelper
   include DdlHelper
 
   class Klass < ActiveRecord::Base
@@ -160,15 +162,6 @@ class MysqlConnectionTest < ActiveRecord::TestCase
 
   private
 
-  def run_without_connection
-    original_connection = ActiveRecord::Base.remove_connection
-    begin
-      yield original_connection
-    ensure
-      ActiveRecord::Base.establish_connection(original_connection)
-    end
-  end
-
   def with_example_table(&block)
     definition ||= <<-SQL
       `id` int(11) auto_increment PRIMARY KEY,
diff --git a/activerecord/test/cases/adapters/mysql2/active_schema_test.rb b/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
index 7905edaf83..cefc3e3c7e 100644
--- a/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
@@ -1,10 +1,10 @@
 require "cases/helper"
+require 'support/connection_helper'
 
 class ActiveSchemaTest < ActiveRecord::TestCase
-  def setup
-    @connection = ActiveRecord::Base.remove_connection
-    ActiveRecord::Base.establish_connection(@connection)
+  include ConnectionHelper
 
+  def setup
     ActiveRecord::Base.connection.singleton_class.class_eval do
       alias_method :execute_without_stub, :execute
       def execute(sql, name = nil) return sql end
@@ -12,12 +12,12 @@ class ActiveSchemaTest < ActiveRecord::TestCase
   end
 
   teardown do
-    ActiveRecord::Base.remove_connection
-    ActiveRecord::Base.establish_connection(@connection)
+    reset_connection
   end
 
   def test_add_index
-    # add_index calls index_name_exists? which can't work since execute is stubbed
+    # add_index calls table_exists? and index_name_exists? which can't work since execute is stubbed
+    def (ActiveRecord::Base.connection).table_exists?(*); true; end
     def (ActiveRecord::Base.connection).index_name_exists?(*); false; end
 
     expected = "CREATE  INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
@@ -116,6 +116,18 @@ class ActiveSchemaTest < ActiveRecord::TestCase
     end
   end
 
+  def test_indexes_in_create
+    ActiveRecord::Base.connection.stubs(:table_exists?).with(:temp).returns(false)
+    ActiveRecord::Base.connection.stubs(:index_name_exists?).with(:index_temp_on_zip).returns(false)
+
+    expected = "CREATE TEMPORARY TABLE `temp` ( INDEX `index_temp_on_zip`  (`zip`) ) ENGINE=InnoDB AS SELECT id, name, zip FROM a_really_complicated_query"
+    actual = ActiveRecord::Base.connection.create_table(:temp, temporary: true, as: "SELECT id, name, zip FROM a_really_complicated_query") do |t|
+      t.index :zip
+    end
+
+    assert_equal expected, actual
+  end
+
   private
     def with_real_execute
       ActiveRecord::Base.connection.singleton_class.class_eval do
diff --git a/activerecord/test/cases/adapters/mysql2/connection_test.rb b/activerecord/test/cases/adapters/mysql2/connection_test.rb
index 98febd2d75..182d9409c7 100644
--- a/activerecord/test/cases/adapters/mysql2/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/connection_test.rb
@@ -1,15 +1,18 @@
 require "cases/helper"
+require 'support/connection_helper'
 
 class MysqlConnectionTest < ActiveRecord::TestCase
+  include ConnectionHelper
+
   def setup
     super
     @subscriber = SQLSubscriber.new
-    ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
+    @subscription = ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
     @connection = ActiveRecord::Base.connection
   end
 
   def teardown
-    ActiveSupport::Notifications.unsubscribe(@subscriber)
+    ActiveSupport::Notifications.unsubscribe(@subscription)
     super
   end
 
@@ -103,15 +106,4 @@ class MysqlConnectionTest < ActiveRecord::TestCase
       assert_equal "'1970-01-01 00:00:00.000000'", @connection.quote(Time.at(0).to_datetime)
     end
   end
-
-  private
-
-  def run_without_connection
-    original_connection = ActiveRecord::Base.remove_connection
-    begin
-      yield original_connection
-    ensure
-      ActiveRecord::Base.establish_connection(original_connection)
-    end
-  end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index f5f1c791e1..18dd4a6de8 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -25,8 +25,11 @@ 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.text?
+    assert_not @column.number?
+    assert_not @column.binary?
 
     ratings_column = PgArray.columns_hash['ratings']
     assert_equal :integer, ratings_column.type
@@ -34,6 +37,28 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
     assert_not ratings_column.number?
   end
 
+  def test_default
+    @connection.add_column 'pg_arrays', 'score', :integer, array: true, default: [4, 4, 2]
+    PgArray.reset_column_information
+    column = PgArray.columns_hash["score"]
+
+    assert_equal([4, 4, 2], column.default)
+    assert_equal([4, 4, 2], PgArray.new.score)
+  ensure
+    PgArray.reset_column_information
+  end
+
+  def test_default_strings
+    @connection.add_column 'pg_arrays', 'names', :string, array: true, default: ["foo", "bar"]
+    PgArray.reset_column_information
+    column = PgArray.columns_hash["names"]
+
+    assert_equal(["foo", "bar"], column.default)
+    assert_equal(["foo", "bar"], PgArray.new.names)
+  ensure
+    PgArray.reset_column_information
+  end
+
   def test_change_column_with_array
     @connection.add_column :pg_arrays, :snippets, :string, array: true, default: []
     @connection.change_column :pg_arrays, :snippets, :text, array: true, default: "{}"
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
index c3394d7712..84fa199f17 100644
--- a/activerecord/test/cases/adapters/postgresql/bytea_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
@@ -70,6 +70,23 @@ class PostgresqlByteaTest < ActiveRecord::TestCase
     assert_equal(data, record.payload)
   end
 
+  def test_via_to_sql
+    data = "'\u001F\\"
+    record = ByteaDataType.create(payload: data)
+    sql = ByteaDataType.where(payload: data).select(:payload).to_sql
+    result = @connection.query(sql)
+    assert_equal([[data]], result)
+  end
+
+  def test_via_to_sql_with_complicating_connection
+    Thread.new do
+      other_conn = ActiveRecord::Base.connection
+      other_conn.execute('SET standard_conforming_strings = off')
+    end.join
+
+    test_via_to_sql
+  end
+
   def test_write_binary
     data = File.read(File.join(File.dirname(__FILE__), '..', '..', '..', 'assets', 'example.log'))
     assert(data.size > 1)
diff --git a/activerecord/test/cases/adapters/postgresql/citext_test.rb b/activerecord/test/cases/adapters/postgresql/citext_test.rb
index 148dc9d07c..948bf49a54 100644
--- a/activerecord/test/cases/adapters/postgresql/citext_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/citext_test.rb
@@ -4,74 +4,77 @@ require 'cases/helper'
 require 'active_record/base'
 require 'active_record/connection_adapters/postgresql_adapter'
 
-class PostgresqlCitextTest < ActiveRecord::TestCase
-  class Citext < ActiveRecord::Base
-    self.table_name = 'citexts'
-  end
+if ActiveRecord::Base.connection.supports_extensions?
+  class PostgresqlCitextTest < ActiveRecord::TestCase
+    class Citext < ActiveRecord::Base
+      self.table_name = 'citexts'
+    end
 
-  def setup
-    @connection = ActiveRecord::Base.connection
+    def setup
+      @connection = ActiveRecord::Base.connection
 
-    unless @connection.extension_enabled?('citext')
-      @connection.enable_extension 'citext'
-      @connection.commit_db_transaction
-    end
+      unless @connection.extension_enabled?('citext')
+        @connection.enable_extension 'citext'
+        @connection.commit_db_transaction
+      end
 
-    @connection.reconnect!
+      @connection.reconnect!
 
-    @connection.create_table('citexts') do |t|
-      t.citext 'cival'
+      @connection.create_table('citexts') do |t|
+        t.citext 'cival'
+      end
     end
-    @column = Citext.columns_hash['cival']
-  end
 
-  teardown do
-    @connection.execute 'DROP TABLE IF EXISTS citexts;'
-    @connection.execute 'DROP EXTENSION IF EXISTS citext CASCADE;'
-  end
+    teardown do
+      @connection.execute 'DROP TABLE IF EXISTS citexts;'
+      @connection.execute 'DROP EXTENSION IF EXISTS citext CASCADE;'
+    end
 
-  def test_citext_enabled
-    assert @connection.extension_enabled?('citext')
-  end
+    def test_citext_enabled
+      assert @connection.extension_enabled?('citext')
+    end
 
-  def test_column_type
-    assert_equal :citext, @column.type
-  end
+    def test_column
+      column = Citext.columns_hash['cival']
+      assert_equal :citext, column.type
+      assert_equal 'citext', column.sql_type
+      assert_not column.text?
+      assert_not column.number?
+      assert_not column.binary?
+      assert_not column.array
+    end
 
-  def test_column_sql_type
-    assert_equal 'citext', @column.sql_type
-  end
+    def test_change_table_supports_json
+      @connection.transaction do
+        @connection.change_table('citexts') do |t|
+          t.citext 'username'
+        end
+        Citext.reset_column_information
+        column = Citext.columns.find { |c| c.name == 'username' }
+        assert_equal :citext, column.type
 
-  def test_change_table_supports_json
-    @connection.transaction do
-      @connection.change_table('citexts') do |t|
-        t.citext 'username'
+        raise ActiveRecord::Rollback # reset the schema change
       end
+    ensure
       Citext.reset_column_information
-      column = Citext.columns.find { |c| c.name == 'username' }
-      assert_equal :citext, column.type
-
-      raise ActiveRecord::Rollback # reset the schema change
     end
-  ensure
-    Citext.reset_column_information
-  end
 
-  def test_write
-    x = Citext.new(cival: 'Some CI Text')
-    x.save!
-    citext = Citext.first
-    assert_equal "Some CI Text", citext.cival
+    def test_write
+      x = Citext.new(cival: 'Some CI Text')
+      x.save!
+      citext = Citext.first
+      assert_equal "Some CI Text", citext.cival
 
-    citext.cival = "Some NEW CI Text"
-    citext.save!
+      citext.cival = "Some NEW CI Text"
+      citext.save!
 
-    assert_equal "Some NEW CI Text", citext.reload.cival
-  end
+      assert_equal "Some NEW CI Text", citext.reload.cival
+    end
 
-  def test_select_case_insensitive
-    @connection.execute "insert into citexts (cival) values('Cased Text')"
-    x = Citext.where(cival: 'cased text').first
-    assert_equal 'Cased Text', x.cival
+    def test_select_case_insensitive
+      @connection.execute "insert into citexts (cival) values('Cased Text')"
+      x = Citext.where(cival: 'cased text').first
+      assert_equal 'Cased Text', x.cival
+    end
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/composite_test.rb b/activerecord/test/cases/adapters/postgresql/composite_test.rb
index ed39204145..224b1b770b 100644
--- a/activerecord/test/cases/adapters/postgresql/composite_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/composite_test.rb
@@ -29,6 +29,17 @@ class PostgresqlCompositeTest < ActiveRecord::TestCase
     end
   end
 
+  def test_column
+    column = PostgresqlComposite.columns_hash["address"]
+    # TODO: Composite columns should have a type
+    assert_nil column.type
+    assert_equal "full_address", column.sql_type
+    assert_not column.number?
+    assert_not column.text?
+    assert_not column.binary?
+    assert_not column.array
+  end
+
   def test_composite_mapping
     @connection.execute "INSERT INTO postgresql_composites VALUES (1, ROW('Paris', 'Champs-Élysées'));"
     composite = PostgresqlComposite.first
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index aa4996133f..5f84c893c0 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -1,19 +1,22 @@
 require "cases/helper"
+require 'support/connection_helper'
 
 module ActiveRecord
   class PostgresqlConnectionTest < ActiveRecord::TestCase
+    include ConnectionHelper
+
     class NonExistentTable < ActiveRecord::Base
     end
 
     def setup
       super
       @subscriber = SQLSubscriber.new
-      ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
+      @subscription = ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
       @connection = ActiveRecord::Base.connection
     end
 
     def teardown
-      ActiveSupport::Notifications.unsubscribe(@subscriber)
+      ActiveSupport::Notifications.unsubscribe(@subscription)
       super
     end
 
@@ -198,17 +201,5 @@ module ActiveRecord
         ActiveRecord::Base.establish_connection(orig_connection.deep_merge({:variables => {:debug_print_plan => :default}}))
       end
     end
-
-    private
-
-    def run_without_connection
-      original_connection = ActiveRecord::Base.remove_connection
-      begin
-        yield original_connection
-      ensure
-        ActiveRecord::Base.establish_connection(original_connection)
-      end
-    end
-
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/domain_test.rb b/activerecord/test/cases/adapters/postgresql/domain_test.rb
new file mode 100644
index 0000000000..214e89dd7f
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/domain_test.rb
@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+require "cases/helper"
+require 'support/connection_helper'
+require 'active_record/base'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+class PostgresqlDomainTest < ActiveRecord::TestCase
+  include ConnectionHelper
+
+  class PostgresqlDomain < ActiveRecord::Base
+    self.table_name = "postgresql_domains"
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.transaction do
+      @connection.execute "CREATE DOMAIN custom_money as numeric(8,2)"
+      @connection.create_table('postgresql_domains') do |t|
+        t.column :price, :custom_money
+      end
+    end
+
+    # reload type map after creating the enum type
+    @connection.send(:reload_type_map)
+  end
+
+  teardown do
+    @connection.execute 'DROP TABLE IF EXISTS postgresql_domains'
+    @connection.execute 'DROP DOMAIN IF EXISTS custom_money'
+    reset_connection
+  end
+
+  def test_column
+    column = PostgresqlDomain.columns_hash["price"]
+    assert_equal :decimal, column.type
+    assert_equal "custom_money", column.sql_type
+    assert column.number?
+    assert_not column.text?
+    assert_not column.binary?
+    assert_not column.array
+  end
+
+  def test_domain_acts_like_basetype
+    PostgresqlDomain.create price: ""
+    record = PostgresqlDomain.first
+    assert_nil record.price
+
+    record.price = "34.15"
+    record.save!
+
+    assert_equal BigDecimal.new("34.15"), record.reload.price
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/enum_test.rb b/activerecord/test/cases/adapters/postgresql/enum_test.rb
index 7208edef5f..73da5a74ab 100644
--- a/activerecord/test/cases/adapters/postgresql/enum_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/enum_test.rb
@@ -1,18 +1,16 @@
 # -*- coding: utf-8 -*-
 require "cases/helper"
+require 'support/connection_helper'
 require 'active_record/base'
 require 'active_record/connection_adapters/postgresql_adapter'
 
 class PostgresqlEnumTest < ActiveRecord::TestCase
+  include ConnectionHelper
+
   class PostgresqlEnum < ActiveRecord::Base
     self.table_name = "postgresql_enums"
   end
 
-  teardown do
-    @connection.execute 'DROP TABLE IF EXISTS postgresql_enums'
-    @connection.execute 'DROP TYPE IF EXISTS mood'
-  end
-
   def setup
     @connection = ActiveRecord::Base.connection
     @connection.transaction do
@@ -27,6 +25,22 @@ class PostgresqlEnumTest < ActiveRecord::TestCase
     @connection.send(:reload_type_map)
   end
 
+  teardown do
+    @connection.execute 'DROP TABLE IF EXISTS postgresql_enums'
+    @connection.execute 'DROP TYPE IF EXISTS mood'
+    reset_connection
+  end
+
+  def test_column
+    column = PostgresqlEnum.columns_hash["current_mood"]
+    assert_equal :enum, column.type
+    assert_equal "mood", column.sql_type
+    assert_not column.number?
+    assert_not column.text?
+    assert_not column.binary?
+    assert_not column.array
+  end
+
   def test_enum_mapping
     @connection.execute "INSERT INTO postgresql_enums VALUES (1, 'sad');"
     enum = PostgresqlEnum.first
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 90ec1524b5..c24c4b0d56 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -54,6 +54,22 @@ class PostgresqlHstoreTest < ActiveRecord::TestCase
 
     def test_column
       assert_equal :hstore, @column.type
+      assert_equal "hstore", @column.sql_type
+      assert_not @column.number?
+      assert_not @column.text?
+      assert_not @column.binary?
+      assert_not @column.array
+    end
+
+    def test_default
+      @connection.add_column 'hstores', 'permissions', :hstore, default: '"users"=>"read", "articles"=>"write"'
+      Hstore.reset_column_information
+      column = Hstore.columns_hash["permissions"]
+
+      assert_equal({"users"=>"read", "articles"=>"write"}, column.default)
+      assert_equal({"users"=>"read", "articles"=>"write"}, Hstore.new.permissions)
+    ensure
+      Hstore.reset_column_information
     end
 
     def test_change_table_supports_hstore
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index 10c0a6c395..ee793ffff2 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -31,7 +31,24 @@ class PostgresqlJSONTest < ActiveRecord::TestCase
   end
 
   def test_column
-    assert_equal :json, @column.type
+    column = JsonDataType.columns_hash["payload"]
+    assert_equal :json, column.type
+    assert_equal "json", column.sql_type
+    assert_not column.number?
+    assert_not column.text?
+    assert_not column.binary?
+    assert_not column.array
+  end
+
+  def test_default
+    @connection.add_column 'json_data_type', 'permissions', :json, default: '{"users": "read", "posts": ["read", "write"]}'
+    JsonDataType.reset_column_information
+    column = JsonDataType.columns_hash["permissions"]
+
+    assert_equal({"users"=>"read", "posts"=>["read", "write"]}, column.default)
+    assert_equal({"users"=>"read", "posts"=>["read", "write"]}, JsonDataType.new.permissions)
+  ensure
+    JsonDataType.reset_column_information
   end
 
   def test_change_table_supports_json
@@ -57,16 +74,16 @@ class PostgresqlJSONTest < ActiveRecord::TestCase
   end
 
   def test_type_cast_json
-    assert @column
+    column = JsonDataType.columns_hash["payload"]
 
     data = "{\"a_key\":\"a_value\"}"
-    hash = @column.class.string_to_json data
+    hash = column.class.string_to_json data
     assert_equal({'a_key' => 'a_value'}, hash)
-    assert_equal({'a_key' => 'a_value'}, @column.type_cast(data))
+    assert_equal({'a_key' => 'a_value'}, column.type_cast(data))
 
-    assert_equal({}, @column.type_cast("{}"))
-    assert_equal({'key'=>nil}, @column.type_cast('{"key": null}'))
-    assert_equal({'c'=>'}','"a"'=>'b "a b'}, @column.type_cast(%q({"c":"}", "\"a\"":"b \"a b"})))
+    assert_equal({}, column.type_cast("{}"))
+    assert_equal({'key'=>nil}, column.type_cast('{"key": null}'))
+    assert_equal({'c'=>'}','"a"'=>'b "a b'}, column.type_cast(%q({"c":"}", "\"a\"":"b \"a b"})))
   end
 
   def test_rewrite
diff --git a/activerecord/test/cases/adapters/postgresql/ltree_test.rb b/activerecord/test/cases/adapters/postgresql/ltree_test.rb
index e72fd4360d..718f37a380 100644
--- a/activerecord/test/cases/adapters/postgresql/ltree_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/ltree_test.rb
@@ -10,6 +10,11 @@ class PostgresqlLtreeTest < ActiveRecord::TestCase
 
   def setup
     @connection = ActiveRecord::Base.connection
+
+    unless @connection.extension_enabled?('ltree')
+      @connection.enable_extension 'ltree'
+    end
+
     @connection.transaction do
       @connection.create_table('ltrees') do |t|
         t.ltree 'path'
@@ -26,6 +31,11 @@ class PostgresqlLtreeTest < ActiveRecord::TestCase
   def test_column
     column = Ltree.columns_hash['path']
     assert_equal :ltree, column.type
+    assert_equal "ltree", column.sql_type
+    assert_not column.number?
+    assert_not column.text?
+    assert_not column.binary?
+    assert_not column.array
   end
 
   def test_write
diff --git a/activerecord/test/cases/adapters/postgresql/quoting_test.rb b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
index 1122f8b9a1..51846e22d9 100644
--- a/activerecord/test/cases/adapters/postgresql/quoting_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
@@ -10,46 +10,46 @@ module ActiveRecord
         end
 
         def test_type_cast_true
-          c = Column.new(nil, 1, 'boolean')
+          c = PostgreSQLColumn.new(nil, 1, OID::Boolean.new, 'boolean')
           assert_equal 't', @conn.type_cast(true, nil)
           assert_equal 't', @conn.type_cast(true, c)
         end
 
         def test_type_cast_false
-          c = Column.new(nil, 1, 'boolean')
+          c = PostgreSQLColumn.new(nil, 1, OID::Boolean.new, 'boolean')
           assert_equal 'f', @conn.type_cast(false, nil)
           assert_equal 'f', @conn.type_cast(false, c)
         end
 
         def test_type_cast_cidr
           ip = IPAddr.new('255.0.0.0/8')
-          c = Column.new(nil, ip, 'cidr')
+          c = PostgreSQLColumn.new(nil, ip, OID::Cidr.new, 'cidr')
           assert_equal ip, @conn.type_cast(ip, c)
         end
 
         def test_type_cast_inet
           ip = IPAddr.new('255.1.0.0/8')
-          c = Column.new(nil, ip, 'inet')
+          c = PostgreSQLColumn.new(nil, ip, OID::Cidr.new, 'inet')
           assert_equal ip, @conn.type_cast(ip, c)
         end
 
         def test_quote_float_nan
           nan = 0.0/0
-          c = Column.new(nil, 1, 'float')
+          c = PostgreSQLColumn.new(nil, 1, OID::Float.new, 'float')
           assert_equal "'NaN'", @conn.quote(nan, c)
         end
 
         def test_quote_float_infinity
           infinity = 1.0/0
-          c = Column.new(nil, 1, 'float')
+          c = PostgreSQLColumn.new(nil, 1, OID::Float.new, 'float')
           assert_equal "'Infinity'", @conn.quote(infinity, c)
         end
 
         def test_quote_cast_numeric
           fixnum = 666
-          c = Column.new(nil, nil, 'varchar')
+          c = PostgreSQLColumn.new(nil, nil, OID::String.new, 'varchar')
           assert_equal "'666'", @conn.quote(fixnum, c)
-          c = Column.new(nil, nil, 'text')
+          c = PostgreSQLColumn.new(nil, nil, OID::Text.new, 'text')
           assert_equal "'666'", @conn.quote(fixnum, c)
         end
 
diff --git a/activerecord/test/cases/adapters/postgresql/range_test.rb b/activerecord/test/cases/adapters/postgresql/range_test.rb
index a9d4312fb3..57c7da2657 100644
--- a/activerecord/test/cases/adapters/postgresql/range_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/range_test.rb
@@ -1,4 +1,5 @@
 require "cases/helper"
+require 'support/connection_helper'
 require 'active_record/base'
 require 'active_record/connection_adapters/postgresql_adapter'
 
@@ -8,17 +9,13 @@ if ActiveRecord::Base.connection.supports_ranges?
   end
 
   class PostgresqlRangeTest < ActiveRecord::TestCase
-    teardown do
-      @connection.execute 'DROP TABLE IF EXISTS postgresql_ranges'
-      @connection.execute 'DROP TYPE IF EXISTS floatrange'
-    end
+    self.use_transactional_fixtures = false
+    include ConnectionHelper
 
     def setup
       @connection = PostgresqlRange.connection
       begin
         @connection.transaction do
-          @connection.execute 'DROP TABLE IF EXISTS postgresql_ranges'
-          @connection.execute 'DROP TYPE IF EXISTS floatrange'
           @connection.execute <<_SQL
             CREATE TYPE floatrange AS RANGE (
                 subtype = float8,
@@ -96,6 +93,12 @@ _SQL
       @empty_range = PostgresqlRange.find(105)
     end
 
+    teardown do
+      @connection.execute 'DROP TABLE IF EXISTS postgresql_ranges'
+      @connection.execute 'DROP TYPE IF EXISTS floatrange'
+      reset_connection
+    end
+
     def test_data_type_of_range_types
       assert_equal :daterange, @first_range.column_for_attribute(:date_range).type
       assert_equal :numrange, @first_range.column_for_attribute(:num_range).type
diff --git a/activerecord/test/cases/adapters/postgresql/schema_test.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index 5e5f653d17..11ec7599a3 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -271,13 +271,13 @@ class SchemaTest < ActiveRecord::TestCase
   end
 
   def test_with_uppercase_index_name
-    ActiveRecord::Base.connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
-    assert_nothing_raised { ActiveRecord::Base.connection.remove_index! "things", "#{SCHEMA_NAME}.things_Index"}
+    @connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
+    assert_nothing_raised { @connection.remove_index! "things", "#{SCHEMA_NAME}.things_Index"}
+    @connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
 
-    ActiveRecord::Base.connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
-    ActiveRecord::Base.connection.schema_search_path = SCHEMA_NAME
-    assert_nothing_raised { ActiveRecord::Base.connection.remove_index! "things", "things_Index"}
-    ActiveRecord::Base.connection.schema_search_path = "public"
+    with_schema_search_path SCHEMA_NAME do
+      assert_nothing_raised { @connection.remove_index! "things", "things_Index"}
+    end
   end
 
   def test_primary_key_with_schema_specified
@@ -328,18 +328,17 @@ class SchemaTest < ActiveRecord::TestCase
   end
 
   def test_prepared_statements_with_multiple_schemas
+    [SCHEMA_NAME, SCHEMA2_NAME].each do |schema_name|
+      with_schema_search_path schema_name do
+        Thing5.create(:id => 1, :name => "thing inside #{SCHEMA_NAME}", :email => "thing1@localhost", :moment => Time.now)
+      end
+    end
 
-    @connection.schema_search_path = SCHEMA_NAME
-    Thing5.create(:id => 1, :name => "thing inside #{SCHEMA_NAME}", :email => "thing1@localhost", :moment => Time.now)
-
-    @connection.schema_search_path = SCHEMA2_NAME
-    Thing5.create(:id => 1, :name => "thing inside #{SCHEMA2_NAME}", :email => "thing1@localhost", :moment => Time.now)
-
-    @connection.schema_search_path = SCHEMA_NAME
-    assert_equal 1, Thing5.count
-
-    @connection.schema_search_path = SCHEMA2_NAME
-    assert_equal 1, Thing5.count
+    [SCHEMA_NAME, SCHEMA2_NAME].each do |schema_name|
+      with_schema_search_path schema_name do
+        assert_equal 1, Thing5.count
+      end
+    end
   end
 
   def test_schema_exists?
diff --git a/activerecord/test/cases/adapters/postgresql/uuid_test.rb b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
index f581c4cf39..9e03ea6bee 100644
--- a/activerecord/test/cases/adapters/postgresql/uuid_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
@@ -41,7 +41,18 @@ class PostgresqlUUIDTest < ActiveRecord::TestCase
   end
 
   def test_data_type_of_uuid_types
-    assert_equal :uuid, UUIDType.columns_hash["guid"].type
+    column = UUIDType.columns_hash["guid"]
+    assert_equal :uuid, column.type
+    assert_equal "uuid", column.sql_type
+    assert_not column.number?
+    assert_not column.text?
+    assert_not column.binary?
+    assert_not column.array
+  end
+
+  def test_treat_blank_uuid_as_nil
+    UUIDType.create! guid: ''
+    assert_equal(nil, UUIDType.last.guid)
   end
 
   def test_uuid_formats
diff --git a/activerecord/test/cases/adapters/postgresql/view_test.rb b/activerecord/test/cases/adapters/postgresql/view_test.rb
index 08071894c4..47b7d38eda 100644
--- a/activerecord/test/cases/adapters/postgresql/view_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/view_test.rb
@@ -1,11 +1,15 @@
 require "cases/helper"
 
-class ViewTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+module ViewTestConcern
+  extend ActiveSupport::Concern
+
+  included do
+    self.use_transactional_fixtures = false
+    mattr_accessor :view_type
+  end
 
   SCHEMA_NAME = 'test_schema'
   TABLE_NAME = 'things'
-  VIEW_NAME = 'view_things'
   COLUMNS = [
     'id integer',
     'name character varying(50)',
@@ -14,17 +18,19 @@ class ViewTest < ActiveRecord::TestCase
   ]
 
   class ThingView < ActiveRecord::Base
-    self.table_name = 'test_schema.view_things'
   end
 
   def setup
+    super
+    ThingView.table_name = "#{SCHEMA_NAME}.#{view_type}_things"
+
     @connection = ActiveRecord::Base.connection
     @connection.execute "CREATE SCHEMA #{SCHEMA_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
-    @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{TABLE_NAME}.table\" (#{COLUMNS.join(',')})"
-    @connection.execute "CREATE VIEW #{SCHEMA_NAME}.#{VIEW_NAME} AS SELECT id,name,email,moment FROM #{SCHEMA_NAME}.#{TABLE_NAME}"
+    @connection.execute "CREATE #{view_type.humanize} #{ThingView.table_name} AS SELECT * FROM #{SCHEMA_NAME}.#{TABLE_NAME}"
   end
 
-  teardown do
+  def teardown
+    super
     @connection.execute "DROP SCHEMA #{SCHEMA_NAME} CASCADE"
   end
 
@@ -35,7 +41,7 @@ class ViewTest < ActiveRecord::TestCase
 
   def test_column_definitions
     assert_nothing_raised do
-      assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{VIEW_NAME}")
+      assert_equal COLUMNS, columns(ThingView.table_name)
     end
   end
 
@@ -47,3 +53,15 @@ class ViewTest < ActiveRecord::TestCase
     end
 
 end
+
+class ViewTest < ActiveRecord::TestCase
+  include ViewTestConcern
+  self.view_type = 'view'
+end
+
+if ActiveRecord::Base.connection.supports_materialized_views?
+  class MaterializedViewTest < ActiveRecord::TestCase
+    include ViewTestConcern
+    self.view_type = 'materialized_view'
+  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 0a52bc6e6a..2630a0f3a4 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -2,28 +2,22 @@
 require "cases/helper"
 require 'models/owner'
 require 'tempfile'
+require 'support/ddl_helper'
 
 module ActiveRecord
   module ConnectionAdapters
     class SQLite3AdapterTest < ActiveRecord::TestCase
+      include DdlHelper
+
       self.use_transactional_fixtures = false
 
       class DualEncoding < ActiveRecord::Base
       end
 
       def setup
-        @conn = Base.sqlite3_connection :database => ':memory:',
-                                       :adapter => 'sqlite3',
-                                       :timeout => 100
-        @conn.execute <<-eosql
-          CREATE TABLE items (
-            id integer PRIMARY KEY AUTOINCREMENT,
-            number integer
-          )
-        eosql
-
-        @subscriber = SQLSubscriber.new
-        ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
+        @conn = Base.sqlite3_connection database: ':memory:',
+                                        adapter: 'sqlite3',
+                                        timeout: 100
       end
 
       def test_bad_connection
@@ -37,7 +31,7 @@ module ActiveRecord
         def test_connect_with_url
           original_connection = ActiveRecord::Base.remove_connection
           tf = Tempfile.open 'whatever'
-          url = "sqlite3://#{tf.path}"
+          url = "sqlite3:#{tf.path}"
           ActiveRecord::Base.establish_connection(url)
           assert ActiveRecord::Base.connection
         ensure
@@ -48,7 +42,7 @@ module ActiveRecord
 
         def test_connect_memory_with_url
           original_connection = ActiveRecord::Base.remove_connection
-          url = "sqlite3:///:memory:"
+          url = "sqlite3::memory:"
           ActiveRecord::Base.establish_connection(url)
           assert ActiveRecord::Base.connection
         ensure
@@ -57,8 +51,10 @@ module ActiveRecord
       end
 
       def test_valid_column
-        column = @conn.columns('items').find { |col| col.name == 'id' }
-        assert @conn.valid_type?(column.type)
+        with_example_table do
+          column = @conn.columns('ex').find { |col| col.name == 'id' }
+          assert @conn.valid_type?(column.type)
+        end
       end
 
       # sqlite databases should be able to support any type and not
@@ -69,13 +65,8 @@ module ActiveRecord
         assert @conn.valid_type?(:foobar)
       end
 
-      def teardown
-        ActiveSupport::Notifications.unsubscribe(@subscriber)
-        super
-      end
-
       def test_column_types
-        owner = Owner.create!(:name => "hello".encode('ascii-8bit'))
+        owner = Owner.create!(name: "hello".encode('ascii-8bit'))
         owner.reload
         select = Owner.columns.map { |c| "typeof(#{c.name})" }.join ', '
         result = Owner.connection.exec_query <<-esql
@@ -85,23 +76,28 @@ module ActiveRecord
         esql
 
         assert(!result.rows.first.include?("blob"), "should not store blobs")
+      ensure
+        owner.delete
       end
 
       def test_exec_insert
-        column = @conn.columns('items').find { |col| col.name == 'number' }
-        vals   = [[column, 10]]
-        @conn.exec_insert('insert into items (number) VALUES (?)', 'SQL', vals)
+        with_example_table do
+          column = @conn.columns('ex').find { |col| col.name == 'number' }
+          vals   = [[column, 10]]
+          @conn.exec_insert('insert into ex (number) VALUES (?)', 'SQL', vals)
 
-        result = @conn.exec_query(
-          'select number from items where number = ?', 'SQL', vals)
+          result = @conn.exec_query(
+            'select number from ex where number = ?', 'SQL', vals)
 
-        assert_equal 1, result.rows.length
-        assert_equal 10, result.rows.first.first
+          assert_equal 1, result.rows.length
+          assert_equal 10, result.rows.first.first
+        end
       end
 
       def test_primary_key_returns_nil_for_no_pk
-        @conn.exec_query('create table ex(id int, data string)')
-        assert_nil @conn.primary_key('ex')
+        with_example_table 'id int, data string' do
+          assert_nil @conn.primary_key('ex')
+        end
       end
 
       def test_connection_no_db
@@ -112,17 +108,17 @@ module ActiveRecord
 
       def test_bad_timeout
         assert_raises(TypeError) do
-          Base.sqlite3_connection :database => ':memory:',
-                                  :adapter => 'sqlite3',
-                                  :timeout => 'usa'
+          Base.sqlite3_connection database: ':memory:',
+                                  adapter: 'sqlite3',
+                                  timeout: 'usa'
         end
       end
 
       # connection is OK with a nil timeout
       def test_nil_timeout
-        conn = Base.sqlite3_connection :database => ':memory:',
-                                       :adapter => 'sqlite3',
-                                       :timeout => nil
+        conn = Base.sqlite3_connection database: ':memory:',
+                                       adapter: 'sqlite3',
+                                       timeout: nil
         assert conn, 'made a connection'
       end
 
@@ -141,44 +137,47 @@ module ActiveRecord
       end
 
       def test_exec_no_binds
-        @conn.exec_query('create table ex(id int, data string)')
-        result = @conn.exec_query('SELECT id, data FROM ex')
-        assert_equal 0, result.rows.length
-        assert_equal 2, result.columns.length
-        assert_equal %w{ id data }, result.columns
-
-        @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
-        result = @conn.exec_query('SELECT id, data FROM ex')
-        assert_equal 1, result.rows.length
-        assert_equal 2, result.columns.length
-
-        assert_equal [[1, 'foo']], result.rows
+        with_example_table 'id int, data string' do
+          result = @conn.exec_query('SELECT id, data FROM ex')
+          assert_equal 0, result.rows.length
+          assert_equal 2, result.columns.length
+          assert_equal %w{ id data }, result.columns
+
+          @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+          result = @conn.exec_query('SELECT id, data FROM ex')
+          assert_equal 1, result.rows.length
+          assert_equal 2, result.columns.length
+
+          assert_equal [[1, 'foo']], result.rows
+        end
       end
 
       def test_exec_query_with_binds
-        @conn.exec_query('create table ex(id int, data string)')
-        @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]])
+        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]])
 
-        assert_equal 1, result.rows.length
-        assert_equal 2, result.columns.length
+          assert_equal 1, result.rows.length
+          assert_equal 2, result.columns.length
 
-        assert_equal [[1, 'foo']], result.rows
+          assert_equal [[1, 'foo']], result.rows
+        end
       end
 
       def test_exec_query_typecasts_bind_vals
-        @conn.exec_query('create table ex(id int, data string)')
-        @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
-        column = @conn.columns('ex').find { |col| col.name == 'id' }
+        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']])
+          result = @conn.exec_query(
+            'SELECT id, data FROM ex WHERE id = ?', nil, [[column, '1-fuu']])
 
-        assert_equal 1, result.rows.length
-        assert_equal 2, result.columns.length
+          assert_equal 1, result.rows.length
+          assert_equal 2, result.columns.length
 
-        assert_equal [[1, 'foo']], result.rows
+          assert_equal [[1, 'foo']], result.rows
+        end
       end
 
       def test_quote_binary_column_escapes_it
@@ -190,7 +189,7 @@ module ActiveRecord
           )
         eosql
         str = "\x80".force_encoding("ASCII-8BIT")
-        binary = DualEncoding.new :name => 'いただきます！', :data => str
+        binary = DualEncoding.new name: 'いただきます！', data: str
         binary.save!
         assert_equal str, binary.data
       ensure
@@ -201,16 +200,20 @@ module ActiveRecord
         name  = 'hello'.force_encoding(Encoding::ASCII_8BIT)
         Owner.create(name: name)
         assert_equal Encoding::ASCII_8BIT, name.encoding
+      ensure
+        Owner.delete_all
       end
 
       def test_execute
-        @conn.execute "INSERT INTO items (number) VALUES (10)"
-        records = @conn.execute "SELECT * FROM items"
-        assert_equal 1, records.length
-
-        record = records.first
-        assert_equal 10, record['number']
-        assert_equal 1, record['id']
+        with_example_table do
+          @conn.execute "INSERT INTO ex (number) VALUES (10)"
+          records = @conn.execute "SELECT * FROM ex"
+          assert_equal 1, records.length
+
+          record = records.first
+          assert_equal 10, record['number']
+          assert_equal 1, record['id']
+        end
       end
 
       def test_quote_string
@@ -218,128 +221,141 @@ module ActiveRecord
       end
 
       def test_insert_sql
-        2.times do |i|
-          rv = @conn.insert_sql "INSERT INTO items (number) VALUES (#{i})"
-          assert_equal(i + 1, rv)
+        with_example_table do
+          2.times do |i|
+            rv = @conn.insert_sql "INSERT INTO ex (number) VALUES (#{i})"
+            assert_equal(i + 1, rv)
+          end
+
+          records = @conn.execute "SELECT * FROM ex"
+          assert_equal 2, records.length
         end
-
-        records = @conn.execute "SELECT * FROM items"
-        assert_equal 2, records.length
       end
 
       def test_insert_sql_logged
-        sql = "INSERT INTO items (number) VALUES (10)"
-        name = "foo"
-
-        assert_logged([[sql, name, []]]) do
-          @conn.insert_sql sql, name
+        with_example_table do
+          sql = "INSERT INTO ex (number) VALUES (10)"
+          name = "foo"
+          assert_logged [[sql, name, []]] do
+            @conn.insert_sql sql, name
+          end
         end
       end
 
       def test_insert_id_value_returned
-        sql = "INSERT INTO items (number) VALUES (10)"
-        idval = 'vuvuzela'
-        id = @conn.insert_sql sql, nil, nil, idval
-        assert_equal idval, id
+        with_example_table do
+          sql = "INSERT INTO ex (number) VALUES (10)"
+          idval = 'vuvuzela'
+          id = @conn.insert_sql sql, nil, nil, idval
+          assert_equal idval, id
+        end
       end
 
       def test_select_rows
-        2.times do |i|
-          @conn.create "INSERT INTO items (number) VALUES (#{i})"
+        with_example_table do
+          2.times do |i|
+            @conn.create "INSERT INTO ex (number) VALUES (#{i})"
+          end
+          rows = @conn.select_rows 'select number, id from ex'
+          assert_equal [[0, 1], [1, 2]], rows
         end
-        rows = @conn.select_rows 'select number, id from items'
-        assert_equal [[0, 1], [1, 2]], rows
       end
 
       def test_select_rows_logged
-        sql = "select * from items"
-        name = "foo"
-
-        assert_logged([[sql, name, []]]) do
-          @conn.select_rows sql, name
+        with_example_table do
+          sql = "select * from ex"
+          name = "foo"
+          assert_logged [[sql, name, []]] do
+            @conn.select_rows sql, name
+          end
         end
       end
 
       def test_transaction
-        count_sql = 'select count(*) from items'
+        with_example_table do
+          count_sql = 'select count(*) from ex'
 
-        @conn.begin_db_transaction
-        @conn.create "INSERT INTO items (number) VALUES (10)"
+          @conn.begin_db_transaction
+          @conn.create "INSERT INTO ex (number) VALUES (10)"
 
-        assert_equal 1, @conn.select_rows(count_sql).first.first
-        @conn.rollback_db_transaction
-        assert_equal 0, @conn.select_rows(count_sql).first.first
+          assert_equal 1, @conn.select_rows(count_sql).first.first
+          @conn.rollback_db_transaction
+          assert_equal 0, @conn.select_rows(count_sql).first.first
+        end
       end
 
       def test_tables
-        assert_equal %w{ items }, @conn.tables
-
-        @conn.execute <<-eosql
-          CREATE TABLE people (
-            id integer PRIMARY KEY AUTOINCREMENT,
-            number integer
-          )
-        eosql
-        assert_equal %w{ items people }.sort, @conn.tables.sort
+        with_example_table do
+          assert_equal %w{ ex }, @conn.tables
+          with_example_table 'id integer PRIMARY KEY AUTOINCREMENT, number integer', 'people' do
+            assert_equal %w{ ex people }.sort, @conn.tables.sort
+          end
+        end
       end
 
       def test_tables_logs_name
-        assert_logged [['SCHEMA', []]] do
+        sql = <<-SQL
+          SELECT name FROM sqlite_master
+          WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+        SQL
+        assert_logged [[sql.squish, 'SCHEMA', []]] do
           @conn.tables('hello')
-          assert_not_nil @subscriber.logged.first.shift
         end
       end
 
       def test_indexes_logs_name
-        assert_logged [["PRAGMA index_list(\"items\")", 'SCHEMA', []]] do
-          @conn.indexes('items', 'hello')
+        with_example_table do
+          assert_logged [["PRAGMA index_list(\"ex\")", 'SCHEMA', []]] do
+            @conn.indexes('ex', 'hello')
+          end
         end
       end
 
       def test_table_exists_logs_name
-        assert @conn.table_exists?('items')
-        assert_equal 'SCHEMA', @subscriber.logged[0][1]
+        with_example_table do
+          sql = <<-SQL
+            SELECT name FROM sqlite_master
+            WHERE type = 'table'
+            AND NOT name = 'sqlite_sequence' AND name = \"ex\"
+          SQL
+          assert_logged [[sql.squish, 'SCHEMA', []]] do
+            assert @conn.table_exists?('ex')
+          end
+        end
       end
 
       def test_columns
-        columns = @conn.columns('items').sort_by { |x| x.name }
-        assert_equal 2, columns.length
-        assert_equal %w{ id number }.sort, columns.map { |x| x.name }
-        assert_equal [nil, nil], columns.map { |x| x.default }
-        assert_equal [true, true], columns.map { |x| x.null }
+        with_example_table do
+          columns = @conn.columns('ex').sort_by { |x| x.name }
+          assert_equal 2, columns.length
+          assert_equal %w{ id number }.sort, columns.map { |x| x.name }
+          assert_equal [nil, nil], columns.map { |x| x.default }
+          assert_equal [true, true], columns.map { |x| x.null }
+        end
       end
 
       def test_columns_with_default
-        @conn.execute <<-eosql
-          CREATE TABLE columns_with_default (
-            id integer PRIMARY KEY AUTOINCREMENT,
-            number integer default 10
-          )
-        eosql
-        column = @conn.columns('columns_with_default').find { |x|
-          x.name == 'number'
-        }
-        assert_equal 10, column.default
+        with_example_table 'id integer PRIMARY KEY AUTOINCREMENT, number integer default 10' do
+          column = @conn.columns('ex').find { |x|
+            x.name == 'number'
+          }
+          assert_equal 10, column.default
+        end
       end
 
       def test_columns_with_not_null
-        @conn.execute <<-eosql
-          CREATE TABLE columns_with_default (
-            id integer PRIMARY KEY AUTOINCREMENT,
-            number integer not null
-          )
-        eosql
-        column = @conn.columns('columns_with_default').find { |x|
-          x.name == 'number'
-        }
-        assert !column.null, "column should not be null"
+        with_example_table 'id integer PRIMARY KEY AUTOINCREMENT, number integer not null' do
+          column = @conn.columns('ex').find { |x| x.name == 'number' }
+          assert_not column.null, "column should not be null"
+        end
       end
 
       def test_indexes_logs
-        assert_difference('@subscriber.logged.length') do
-          @conn.indexes('items')
+        with_example_table do
+          assert_logged [["PRAGMA index_list(\"ex\")", "SCHEMA", []]] do
+            @conn.indexes('ex')
+          end
         end
-        assert_match(/items/, @subscriber.logged.last.first)
       end
 
       def test_no_indexes
@@ -347,41 +363,45 @@ module ActiveRecord
       end
 
       def test_index
-        @conn.add_index 'items', 'id', :unique => true, :name => 'fun'
-        index = @conn.indexes('items').find { |idx| idx.name == 'fun' }
+        with_example_table do
+          @conn.add_index 'ex', 'id', unique: true, name: 'fun'
+          index = @conn.indexes('ex').find { |idx| idx.name == 'fun' }
 
-        assert_equal 'items', index.table
-        assert index.unique, 'index is unique'
-        assert_equal ['id'], index.columns
+          assert_equal 'ex', index.table
+          assert index.unique, 'index is unique'
+          assert_equal ['id'], index.columns
+        end
       end
 
       def test_non_unique_index
-        @conn.add_index 'items', 'id', :name => 'fun'
-        index = @conn.indexes('items').find { |idx| idx.name == 'fun' }
-        assert !index.unique, 'index is not unique'
+        with_example_table do
+          @conn.add_index 'ex', 'id', name: 'fun'
+          index = @conn.indexes('ex').find { |idx| idx.name == 'fun' }
+          assert_not index.unique, 'index is not unique'
+        end
       end
 
       def test_compound_index
-        @conn.add_index 'items', %w{ id number }, :name => 'fun'
-        index = @conn.indexes('items').find { |idx| idx.name == 'fun' }
-        assert_equal %w{ id number }.sort, index.columns.sort
+        with_example_table do
+          @conn.add_index 'ex', %w{ id number }, name: 'fun'
+          index = @conn.indexes('ex').find { |idx| idx.name == 'fun' }
+          assert_equal %w{ id number }.sort, index.columns.sort
+        end
       end
 
       def test_primary_key
-        assert_equal 'id', @conn.primary_key('items')
-
-        @conn.execute <<-eosql
-          CREATE TABLE foos (
-            internet integer PRIMARY KEY AUTOINCREMENT,
-            number integer not null
-          )
-        eosql
-        assert_equal 'internet', @conn.primary_key('foos')
+        with_example_table do
+          assert_equal 'id', @conn.primary_key('ex')
+          with_example_table 'internet integer PRIMARY KEY AUTOINCREMENT, number integer not null', 'foos' do
+            assert_equal 'internet', @conn.primary_key('foos')
+          end
+        end
       end
 
       def test_no_primary_key
-        @conn.execute 'CREATE TABLE failboat (number integer not null)'
-        assert_nil @conn.primary_key('failboat')
+        with_example_table 'number integer not null' do
+          assert_nil @conn.primary_key('ex')
+        end
       end
 
       def test_supports_extensions
@@ -399,10 +419,21 @@ module ActiveRecord
       private
 
       def assert_logged logs
+        subscriber = SQLSubscriber.new
+        subscription = ActiveSupport::Notifications.subscribe('sql.active_record', subscriber)
         yield
-        assert_equal logs, @subscriber.logged
+        assert_equal logs, subscriber.logged
+      ensure
+        ActiveSupport::Notifications.unsubscribe(subscription)
       end
 
+      def with_example_table(definition = nil, table_name = 'ex', &block)
+        definition ||= <<-SQL
+          id integer PRIMARY KEY AUTOINCREMENT,
+          number integer
+        SQL
+        super(@conn, table_name, definition, &block)
+      end
     end
   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 56ac284331..27f6fa575d 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -16,6 +16,8 @@ require 'models/essay'
 require 'models/toy'
 require 'models/invoice'
 require 'models/line_item'
+require 'models/column'
+require 'models/record'
 
 class BelongsToAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :topics,
@@ -340,6 +342,17 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_queries(1) { line_item.touch }
   end
 
+  def test_belongs_to_with_touch_option_on_touch_without_updated_at_attributes
+    assert_not LineItem.column_names.include?("updated_at")
+
+    line_item = LineItem.create!
+    invoice = Invoice.create!(line_items: [line_item])
+    initial = invoice.updated_at
+    line_item.touch
+
+    assert_not_equal initial, invoice.reload.updated_at
+  end
+
   def test_belongs_to_with_touch_option_on_touch_and_removed_parent
     line_item = LineItem.create!
     Invoice.create!(line_items: [line_item])
@@ -874,4 +887,10 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
       end
     end
   end
+
+  test 'belongs_to works with model called Record' do
+    record = Record.create!
+    Column.create! record: record
+    assert_equal 1, Column.count
+  end
 end
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index e59161fc5b..8c9797861c 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -235,6 +235,17 @@ class EagerAssociationTest < ActiveRecord::TestCase
     end
   end
 
+  def test_finding_with_includes_on_empty_polymorphic_type_column
+    sponsor = sponsors(:moustache_club_sponsor_for_groucho)
+    sponsor.update!(sponsorable_type: '', sponsorable_id: nil) # sponsorable_type column might be declared NOT NULL
+    sponsor = assert_queries(1) do
+      assert_nothing_raised { Sponsor.all.merge!(:includes => :sponsorable).find(sponsor.id) }
+    end
+    assert_no_queries do
+      assert_equal nil, sponsor.sponsorable
+    end
+  end
+
   def test_loading_from_an_association
     posts = authors(:david).posts.merge(:includes => :comments, :order => "posts.id").to_a
     assert_equal 2, posts.first.comments.size
@@ -709,16 +720,16 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_invalid_association_reference
-    assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
+    assert_raise(ActiveRecord::AssociationNotFoundError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
       Post.all.merge!(:includes=> :monkeys ).find(6)
     }
-    assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
+    assert_raise(ActiveRecord::AssociationNotFoundError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
       Post.all.merge!(:includes=>[ :monkeys ]).find(6)
     }
-    assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
+    assert_raise(ActiveRecord::AssociationNotFoundError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
       Post.all.merge!(:includes=>[ 'monkeys' ]).find(6)
     }
-    assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys, :elephants") {
+    assert_raise(ActiveRecord::AssociationNotFoundError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys, :elephants") {
       Post.all.merge!(:includes=>[ :monkeys, :elephants ]).find(6)
     }
   end
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 49d3301044..c79c0c87c5 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -22,6 +22,10 @@ require 'models/engine'
 require 'models/categorization'
 require 'models/minivan'
 require 'models/speedometer'
+require 'models/reference'
+require 'models/job'
+require 'models/college'
+require 'models/student'
 
 class HasManyAssociationsTestForReorderWithJoinDependency < ActiveRecord::TestCase
   fixtures :authors, :posts, :comments
@@ -39,7 +43,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :categories, :companies, :developers, :projects,
            :developers_projects, :topics, :authors, :comments,
            :people, :posts, :readers, :taggings, :cars, :essays,
-           :categorizations
+           :categorizations, :jobs
 
   def setup
     Client.destroyed_client_ids.clear
@@ -63,6 +67,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
                  dev.developer_projects.map(&:project_id).sort
   end
 
+  def test_has_many_build_with_options
+    college = College.create(name: 'UFMT')
+    Student.create(active: true, college_id: college.id, name: 'Sarah')
+
+    assert_equal college.students, Student.where(active: true, college_id: college.id)
+  end
+
   def test_create_from_association_should_respect_default_scope
     car = Car.create(:name => 'honda')
     assert_equal 'honda', car.name
@@ -107,6 +118,19 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 0, Bulb.count, "bulbs should have been deleted using :delete_all strategy"
   end
 
+  def test_delete_all_on_association_is_the_same_as_not_loaded
+    author = authors :david
+    author.thinking_posts.create!(:body => "test")
+    author.reload
+    expected_sql = capture_sql { author.thinking_posts.delete_all }
+
+    author.thinking_posts.create!(:body => "test")
+    author.reload
+    author.thinking_posts.inspect
+    loaded_sql = capture_sql { author.thinking_posts.delete_all }
+    assert_equal(expected_sql, loaded_sql)
+  end
+
   def test_building_the_associated_object_with_implicit_sti_base_class
     firm = DependentFirm.new
     company = firm.companies.build
diff --git a/activerecord/test/cases/associations/inner_join_association_test.rb b/activerecord/test/cases/associations/inner_join_association_test.rb
index a9efa6d86a..b23517b2f9 100644
--- a/activerecord/test/cases/associations/inner_join_association_test.rb
+++ b/activerecord/test/cases/associations/inner_join_association_test.rb
@@ -117,4 +117,13 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
 
     assert_equal [author], Author.where(id: author).joins(:special_categorizations)
   end
+
+  test "the default scope of the target is correctly aliased when joining associations" do
+    author = Author.create! name: "Jon"
+    author.categories.create! name: 'Not Special'
+    author.special_categories.create! name: 'Special'
+
+    categories = author.categories.includes(:special_categorizations).references(:special_categorizations).to_a
+    assert_equal 2, categories.size
+  end
 end
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index 09892d50ba..f7584c3a51 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -683,23 +683,10 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
       end
     end
 
-    @ship.pirate.catchphrase = "Changed Catchphrase"
-
     assert_raise(RuntimeError) { assert !@pirate.save }
     assert_not_nil @pirate.reload.ship
   end
 
-  def test_should_save_changed_has_one_changed_object_if_child_is_saved
-    @pirate.ship.name = "NewName"
-    assert @pirate.save
-    assert_equal "NewName", @pirate.ship.reload.name
-  end
-
-  def test_should_not_save_changed_has_one_unchanged_object_if_child_is_saved
-    @pirate.ship.expects(:save).never
-    assert @pirate.save
-  end
-
   # belongs_to
   def test_should_destroy_a_parent_association_as_part_of_the_save_transaction_if_it_was_marked_for_destroyal
     assert !@ship.pirate.marked_for_destruction?
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 6acb342d0b..4969344763 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -533,6 +533,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_equality_of_new_records
     assert_not_equal Topic.new, Topic.new
+    assert_equal false, Topic.new == Topic.new
   end
 
   def test_equality_of_destroyed_records
@@ -544,6 +545,12 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal topic_2, topic_1
   end
 
+  def test_equality_with_blank_ids
+    one = Subscriber.new(:id => '')
+    two = Subscriber.new(:id => '')
+    assert_equal one, two
+  end
+
   def test_hashing
     assert_equal [ Topic.find(1) ], [ Topic.find(2).topic ] & [ Topic.find(1) ]
   end
@@ -578,12 +585,6 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal nil, Topic.find_by_id(topic.id)
   end
 
-  def test_blank_ids
-    one = Subscriber.new(:id => '')
-    two = Subscriber.new(:id => '')
-    assert_equal one, two
-  end
-
   def test_comparison_with_different_objects
     topic = Topic.create
     category = Category.create(:name => "comparison")
diff --git a/activerecord/test/cases/bind_parameter_test.rb b/activerecord/test/cases/bind_parameter_test.rb
index 24eb91bef9..40f73cd68c 100644
--- a/activerecord/test/cases/bind_parameter_test.rb
+++ b/activerecord/test/cases/bind_parameter_test.rb
@@ -20,13 +20,13 @@ module ActiveRecord
     def setup
       super
       @connection = ActiveRecord::Base.connection
-      @listener   = LogListener.new
+      @subscriber   = LogListener.new
       @pk         = Topic.columns.find { |c| c.primary }
-      ActiveSupport::Notifications.subscribe('sql.active_record', @listener)
+      @subscription = ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
     end
 
     teardown do
-      ActiveSupport::Notifications.unsubscribe(@listener)
+      ActiveSupport::Notifications.unsubscribe(@subscription)
     end
 
     if ActiveRecord::Base.connection.supports_statement_cache?
@@ -37,7 +37,7 @@ module ActiveRecord
 
         @connection.exec_query(sql, 'SQL', binds)
 
-        message = @listener.calls.find { |args| args[4][:sql] == sql }
+        message = @subscriber.calls.find { |args| args[4][:sql] == sql }
         assert_equal binds, message[4][:binds]
       end
 
@@ -48,14 +48,14 @@ module ActiveRecord
 
         @connection.exec_query(sql, 'SQL', binds)
 
-        message = @listener.calls.find { |args| args[4][:sql] == sql }
+        message = @subscriber.calls.find { |args| args[4][:sql] == sql }
         assert_equal [[@pk, 3]], message[4][:binds]
       end
 
       def test_find_one_uses_binds
         Topic.find(1)
         binds = [[@pk, 1]]
-        message = @listener.calls.find { |args| args[4][:binds] == binds }
+        message = @subscriber.calls.find { |args| args[4][:binds] == binds }
         assert message, 'expected a message with binds'
       end
 
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index db999f90ab..b8de78934e 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -387,6 +387,20 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_raise(ArgumentError) { Account.count(1, 2, 3) }
   end
 
+  def test_count_with_order
+    assert_equal 6, Account.order(:credit_limit).count
+  end
+
+  def test_count_with_reverse_order
+    assert_equal 6, Account.order(:credit_limit).reverse_order.count
+  end
+
+  def test_count_with_where_and_order
+    assert_equal 1, Account.where(firm_name: '37signals').count
+    assert_equal 1, Account.where(firm_name: '37signals').order(:firm_name).count
+    assert_equal 1, Account.where(firm_name: '37signals').order(:firm_name).reverse_order.count
+  end
+
   def test_should_sum_expression
     # Oracle adapter returns floating point value 636.0 after SUM
     if current_adapter?(:OracleAdapter)
diff --git a/activerecord/test/cases/column_definition_test.rb b/activerecord/test/cases/column_definition_test.rb
index c7b64f29c3..c1dd1f1c69 100644
--- a/activerecord/test/cases/column_definition_test.rb
+++ b/activerecord/test/cases/column_definition_test.rb
@@ -127,13 +127,13 @@ module ActiveRecord
 
       if current_adapter?(:PostgreSQLAdapter)
         def test_bigint_column_should_map_to_integer
-          oid = PostgreSQLAdapter::OID::Identity.new
+          oid = PostgreSQLAdapter::OID::Integer.new
           bigint_column = PostgreSQLColumn.new('number', nil, oid, "bigint")
           assert_equal :integer, bigint_column.type
         end
 
         def test_smallint_column_should_map_to_integer
-          oid = PostgreSQLAdapter::OID::Identity.new
+          oid = PostgreSQLAdapter::OID::Integer.new
           smallint_column = PostgreSQLColumn.new('number', nil, oid, "smallint")
           assert_equal :integer, smallint_column.type
         end
diff --git a/activerecord/test/cases/connection_adapters/connection_handler_test.rb b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
index 2992ceb211..e097449029 100644
--- a/activerecord/test/cases/connection_adapters/connection_handler_test.rb
+++ b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
@@ -17,6 +17,54 @@ module ActiveRecord
         ENV["DATABASE_URL"] = @previous_database_url
       end
 
+      def resolve(spec, config)
+        ConnectionSpecification::Resolver.new(klass.new(config).resolve).resolve(spec)
+      end
+
+      def spec(spec, config)
+        ConnectionSpecification::Resolver.new(klass.new(config).resolve).spec(spec)
+      end
+
+      def test_resolver_with_database_uri_and_known_key
+        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        config   = { "production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
+        actual   = resolve(:production, config)
+        expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
+        assert_equal expected, actual
+      end
+
+      def test_resolver_with_database_uri_and_known_string_key
+        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        config   = { "production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
+        actual   = assert_deprecated { resolve("production", config) }
+        expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
+        assert_equal expected, actual
+      end
+
+      def test_resolver_with_database_uri_and_unknown_symbol_key
+        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        config   = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
+        actual   = resolve(:production, config)
+        expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
+        assert_equal expected, actual
+      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_raises AdapterNotSpecified do
+          spec("production", config)
+        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" } }
+        actual   = resolve("postgres://localhost/foo", config)
+        expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
+        assert_equal expected, actual
+      end
+
       def test_jdbc_url
         config   = { "production" => { "url" => "jdbc:postgres://localhost/foo" } }
         actual   = klass.new(config).resolve
diff --git a/activerecord/test/cases/connection_specification/resolver_test.rb b/activerecord/test/cases/connection_specification/resolver_test.rb
index fdd1914cba..3c2f5d4219 100644
--- a/activerecord/test/cases/connection_specification/resolver_test.rb
+++ b/activerecord/test/cases/connection_specification/resolver_test.rb
@@ -82,15 +82,34 @@ module ActiveRecord
           assert_equal password, spec["password"]
         end
 
-        def test_url_host_db_for_sqlite3
-          spec = resolve 'sqlite3://foo:bar@dburl:9000/foo_test'
+        def test_url_with_authority_for_sqlite3
+          spec = resolve 'sqlite3:///foo_test'
           assert_equal('/foo_test', spec["database"])
         end
 
-        def test_url_host_memory_db_for_sqlite3
-          spec = resolve 'sqlite3://foo:bar@dburl:9000/:memory:'
+        def test_url_absolute_path_for_sqlite3
+          spec = resolve 'sqlite3:/foo_test'
+          assert_equal('/foo_test', spec["database"])
+        end
+
+        def test_url_relative_path_for_sqlite3
+          spec = resolve 'sqlite3:foo_test'
+          assert_equal('foo_test', spec["database"])
+        end
+
+        def test_url_memory_db_for_sqlite3
+          spec = resolve 'sqlite3::memory:'
           assert_equal(':memory:', spec["database"])
         end
+
+        def test_url_sub_key_for_sqlite3
+          spec = resolve :production, 'production' => {"url" => 'sqlite3:foo?encoding=utf8'}
+          assert_equal({
+            "adapter"  => "sqlite3",
+            "database" => "foo",
+            "encoding" => "utf8" }, spec)
+        end
+
       end
     end
   end
diff --git a/activerecord/test/cases/enum_test.rb b/activerecord/test/cases/enum_test.rb
index f8ebd7caee..5157c272ca 100644
--- a/activerecord/test/cases/enum_test.rb
+++ b/activerecord/test/cases/enum_test.rb
@@ -194,6 +194,7 @@ class EnumTest < ActiveRecord::TestCase
       :valid,    # generates #valid?, which conflicts with an AR method
       :save,     # generates #save!, which conflicts with an AR method
       :proposed, # same value as an existing enum
+      :public, :private, :protected, # generates a method that conflict with ruby words
     ]
 
     conflicts.each_with_index do |value, i|
@@ -249,4 +250,19 @@ class EnumTest < ActiveRecord::TestCase
     valid_book = klass.new(status: "written")
     assert valid_book.valid?
   end
+
+  test "enums are distinct per class" do
+    Plane = Class.new(ActiveRecord::Base) do
+      enum status: [:grounded, :operational]
+    end
+    assert_equal({ "proposed" => 0, "written" => 1, "published" => 2 }, Book.statuses)
+    assert_equal({ "grounded" => 0, "operational" => 1 }, Plane.statuses)
+  end
+
+  test "enums are inheritable" do
+    Encyclopedia = Class.new(Book) do
+      enum status: [:published, :reprinted]
+    end
+    assert_equal({ "published" => 0, "reprinted" => 1 }, Encyclopedia.statuses)
+  end
 end
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index 1147418815..cf0235b8c5 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -254,7 +254,7 @@ class FixturesTest < ActiveRecord::TestCase
 
   def test_fixtures_are_set_up_with_database_env_variable
     db_url_tmp = ENV['DATABASE_URL']
-    ENV['DATABASE_URL'] = "sqlite3:///:memory:"
+    ENV['DATABASE_URL'] = "sqlite3::memory:"
     ActiveRecord::Base.stubs(:configurations).returns({})
     test_case = Class.new(ActiveRecord::TestCase) do
       fixtures :accounts
diff --git a/activerecord/test/cases/helper.rb b/activerecord/test/cases/helper.rb
index 8a49dfbb44..5ed508a799 100644
--- a/activerecord/test/cases/helper.rb
+++ b/activerecord/test/cases/helper.rb
@@ -168,7 +168,7 @@ class SQLSubscriber
 
   def start(name, id, payload)
     @payloads << payload
-    @logged << [payload[:sql], payload[:name], payload[:binds]]
+    @logged << [payload[:sql].squish, payload[:name], payload[:binds]]
   end
 
   def finish(name, id, payload); end
diff --git a/activerecord/test/cases/migration/column_attributes_test.rb b/activerecord/test/cases/migration/column_attributes_test.rb
index ccf19fb4d0..6a02873cba 100644
--- a/activerecord/test/cases/migration/column_attributes_test.rb
+++ b/activerecord/test/cases/migration/column_attributes_test.rb
@@ -35,6 +35,14 @@ module ActiveRecord
         assert_no_column TestModel, :last_name
       end
 
+      def test_add_column_without_limit
+        # TODO: limit: nil should work with all adapters.
+        skip "MySQL wrongly enforces a limit of 255" if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+        add_column :test_models, :description, :string, limit: nil
+        TestModel.reset_column_information
+        assert_nil TestModel.columns_hash["description"].limit
+      end
+
       if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
         def test_unabstracted_database_dependent_types
           add_column :test_models, :intelligence_quotient, :tinyint
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index d7ad5ed29f..ad77472333 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -63,7 +63,7 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_column_string_type_and_limit
     assert_equal :string, @first.column_for_attribute("title").type
-    assert_equal 255, @first.column_for_attribute("title").limit
+    assert_equal 250, @first.column_for_attribute("title").limit
   end
 
   def test_column_null_not_null
diff --git a/activerecord/test/cases/relation/mutation_test.rb b/activerecord/test/cases/relation/mutation_test.rb
index 4fafa668fb..c81a3002d6 100644
--- a/activerecord/test/cases/relation/mutation_test.rb
+++ b/activerecord/test/cases/relation/mutation_test.rb
@@ -107,10 +107,18 @@ module ActiveRecord
     end
 
     test 'reverse_order!' do
-      assert relation.reverse_order!.equal?(relation)
-      assert relation.reverse_order_value
+      relation = Post.order('title ASC, comments_count DESC')
+
+      relation.reverse_order!
+
+      assert_equal 'title DESC', relation.order_values.first
+      assert_equal 'comments_count ASC', relation.order_values.last
+
+
       relation.reverse_order!
-      assert !relation.reverse_order_value
+
+      assert_equal 'title ASC', relation.order_values.first
+      assert_equal 'comments_count DESC', relation.order_values.last
     end
 
     test 'create_with!' do
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index e2b353ca73..662e374ddd 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -573,6 +573,12 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal expected, actual
   end
 
+  def test_to_sql_on_scoped_proxy
+    auth = Author.first
+    Post.where("1=1").written_by(auth)
+    assert_not auth.posts.to_sql.include?("1=1")
+  end
+
   def test_loading_with_one_association_with_non_preload
     posts = Post.eager_load(:last_comment).order('comments.id DESC')
     post = posts.find { |p| p.id == 1 }
@@ -1418,6 +1424,18 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal [], scope.references_values
   end
 
+  def test_order_with_reorder_nil_removes_the_order
+    relation = Post.order(:title).reorder(nil)
+
+    assert_nil relation.order_values.first
+  end
+
+  def test_reverse_order_with_reorder_nil_removes_the_order
+    relation = Post.order(:title).reverse_order.reorder(nil)
+
+    assert_nil relation.order_values.first
+  end
+
   def test_presence
     topics = Topic.all
 
diff --git a/activerecord/test/cases/scoping/named_scoping_test.rb b/activerecord/test/cases/scoping/named_scoping_test.rb
index f0ad9ebb8a..59ec2dd6a4 100644
--- a/activerecord/test/cases/scoping/named_scoping_test.rb
+++ b/activerecord/test/cases/scoping/named_scoping_test.rb
@@ -291,6 +291,9 @@ class NamedScopingTest < ActiveRecord::TestCase
       :relation,      # private class method on AR::Base
       :new,           # redefined class method on AR::Base
       :all,           # a default scope
+      :public,
+      :protected,
+      :private
     ]
 
     non_conflicts = [
diff --git a/activerecord/test/cases/test_case.rb b/activerecord/test/cases/test_case.rb
index 4476ce3410..803a054d7e 100644
--- a/activerecord/test/cases/test_case.rb
+++ b/activerecord/test/cases/test_case.rb
@@ -19,10 +19,14 @@ module ActiveRecord
       end
     end
 
-    def assert_sql(*patterns_to_match)
+    def capture_sql
       SQLCounter.clear_log
       yield
-      SQLCounter.log_all
+      SQLCounter.log_all.dup
+    end
+
+    def assert_sql(*patterns_to_match)
+      capture_sql { yield }
     ensure
       failed_patterns = []
       patterns_to_match.each do |pattern|
diff --git a/activerecord/test/cases/timestamp_test.rb b/activerecord/test/cases/timestamp_test.rb
index 5308fa8808..594b4fb07b 100644
--- a/activerecord/test/cases/timestamp_test.rb
+++ b/activerecord/test/cases/timestamp_test.rb
@@ -71,6 +71,24 @@ class TimestampTest < ActiveRecord::TestCase
     assert_equal @previously_updated_at, @developer.updated_at
   end
 
+  def test_saving_when_callback_sets_record_timestamps_to_false_doesnt_update_its_timestamp
+    klass = Class.new(Developer) do
+      before_update :cancel_record_timestamps
+      def cancel_record_timestamps
+        self.record_timestamps = false
+        return true
+      end
+    end
+
+    developer = klass.first
+    previously_updated_at = developer.updated_at
+
+    developer.name = "New Name"
+    developer.save!
+
+    assert_equal previously_updated_at, developer.updated_at
+  end
+
   def test_touching_an_attribute_updates_timestamp
     previously_created_at = @developer.created_at
     @developer.touch(:created_at)
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index 1664f1a096..e6ed85394b 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -5,6 +5,7 @@ require 'models/developer'
 require 'models/book'
 require 'models/author'
 require 'models/post'
+require 'models/movie'
 
 class TransactionTest < ActiveRecord::TestCase
   self.use_transactional_fixtures = false
@@ -14,6 +15,11 @@ class TransactionTest < ActiveRecord::TestCase
     @first, @second = Topic.find(1, 2).sort_by { |t| t.id }
   end
 
+  def test_persisted_in_a_model_with_custom_primary_key_after_failed_save
+    movie = Movie.create
+    assert !movie.persisted?
+  end
+
   def test_raise_after_destroy
     assert_not @first.frozen?
 
diff --git a/activerecord/test/cases/validations_test.rb b/activerecord/test/cases/validations_test.rb
index de618902aa..d80da06e27 100644
--- a/activerecord/test/cases/validations_test.rb
+++ b/activerecord/test/cases/validations_test.rb
@@ -52,6 +52,21 @@ class ValidationsTest < ActiveRecord::TestCase
     assert r.save(:context => :special_case)
   end
 
+  def test_validate
+    r = WrongReply.new
+
+    r.validate
+    assert_empty r.errors[:author_name]
+
+    r.validate(:special_case)
+    assert_not_empty r.errors[:author_name]
+
+    r.author_name = "secret"
+
+    r.validate(:special_case)
+    assert_empty r.errors[:author_name]
+  end
+
   def test_invalid_record_exception
     assert_raise(ActiveRecord::RecordInvalid) { WrongReply.create! }
     assert_raise(ActiveRecord::RecordInvalid) { WrongReply.new.save! }
diff --git a/activerecord/test/cases/xml_serialization_test.rb b/activerecord/test/cases/xml_serialization_test.rb
index 78fa2f935a..3cb617497d 100644
--- a/activerecord/test/cases/xml_serialization_test.rb
+++ b/activerecord/test/cases/xml_serialization_test.rb
@@ -1,4 +1,5 @@
 require "cases/helper"
+require "rexml/document"
 require 'models/contact'
 require 'models/post'
 require 'models/author'
diff --git a/activerecord/test/models/category.rb b/activerecord/test/models/category.rb
index 7da39a8e33..272223e1d8 100644
--- a/activerecord/test/models/category.rb
+++ b/activerecord/test/models/category.rb
@@ -22,6 +22,7 @@ class Category < ActiveRecord::Base
   end
 
   has_many :categorizations
+  has_many :special_categorizations
   has_many :post_comments, :through => :posts, :source => :comments
 
   has_many :authors, :through => :categorizations
diff --git a/activerecord/test/models/college.rb b/activerecord/test/models/college.rb
index c7495d7deb..501af4a8dd 100644
--- a/activerecord/test/models/college.rb
+++ b/activerecord/test/models/college.rb
@@ -1,5 +1,10 @@
 require_dependency 'models/arunit2_model'
+require 'active_support/core_ext/object/with_options'
 
 class College < ARUnit2Model
   has_many :courses
+
+  with_options dependent: :destroy do |assoc|
+    assoc.has_many :students, -> { where(active: true) }
+  end
 end
diff --git a/activerecord/test/models/column.rb b/activerecord/test/models/column.rb
new file mode 100644
index 0000000000..499358b4cf
--- /dev/null
+++ b/activerecord/test/models/column.rb
@@ -0,0 +1,3 @@
+class Column < ActiveRecord::Base
+  belongs_to :record
+end
diff --git a/activerecord/test/models/movie.rb b/activerecord/test/models/movie.rb
index c441be2bef..0302abad1e 100644
--- a/activerecord/test/models/movie.rb
+++ b/activerecord/test/models/movie.rb
@@ -1,3 +1,5 @@
 class Movie < ActiveRecord::Base
   self.primary_key = "movieid"
+
+  validates_presence_of :name
 end
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index faf539a562..099e039255 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -149,6 +149,10 @@ class Post < ActiveRecord::Base
     ranked_by_comments.limit_by(limit)
   end
 
+  def self.written_by(author)
+    where(id: author.posts.pluck(:id))
+  end
+
   def self.reset_log
     @log = []
   end
diff --git a/activerecord/test/models/record.rb b/activerecord/test/models/record.rb
new file mode 100644
index 0000000000..f77ac9fc03
--- /dev/null
+++ b/activerecord/test/models/record.rb
@@ -0,0 +1,2 @@
+class Record < ActiveRecord::Base
+end
diff --git a/activerecord/test/models/student.rb b/activerecord/test/models/student.rb
index f459f2a9a3..28a0b6c99b 100644
--- a/activerecord/test/models/student.rb
+++ b/activerecord/test/models/student.rb
@@ -1,3 +1,4 @@
 class Student < ActiveRecord::Base
   has_and_belongs_to_many :lessons
+  belongs_to :college
 end
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index b44e72a67c..d9e1745029 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -161,6 +161,10 @@ ActiveRecord::Schema.define do
     t.integer :references, null: false
   end
 
+  create_table :columns, force: true do |t|
+    t.references :record
+  end
+
   create_table :comments, force: true do |t|
     t.integer :post_id, null: false
     # use VARCHAR2(4000) instead of CLOB datatype as CLOB data type has many limitations in
@@ -638,6 +642,8 @@ ActiveRecord::Schema.define do
 
   create_table :students, force: true do |t|
     t.string :name
+    t.boolean :active
+    t.integer :college_id
   end
 
   create_table :subscribers, force: true, id: false do |t|
@@ -671,7 +677,7 @@ ActiveRecord::Schema.define do
   end
 
   create_table :topics, force: true do |t|
-    t.string   :title
+    t.string   :title, limit: 250
     t.string   :author_name
     t.string   :author_email_address
     if mysql_56?
@@ -817,6 +823,8 @@ ActiveRecord::Schema.define do
     t.integer :department_id
   end
 
+  create_table :records, force: true do |t|
+  end
 
   except 'SQLite' do
     # fk_test_has_fk should be before fk_test_has_pk
diff --git a/activerecord/test/support/connection_helper.rb b/activerecord/test/support/connection_helper.rb
new file mode 100644
index 0000000000..4a19e5df44
--- /dev/null
+++ b/activerecord/test/support/connection_helper.rb
@@ -0,0 +1,14 @@
+module ConnectionHelper
+  def run_without_connection
+    original_connection = ActiveRecord::Base.remove_connection
+    yield original_connection
+  ensure
+    ActiveRecord::Base.establish_connection(original_connection)
+  end
+
+  # Used to drop all cache query plans in tests.
+  def reset_connection
+    original_connection = ActiveRecord::Base.remove_connection
+    ActiveRecord::Base.establish_connection(original_connection)
+  end
+end