Merge branch 'master' into activestorage-guide

77 files changed, 947 insertions, 1747 deletions

diff --git a/activerecord/CHANGELOG.md b/activerecord/CHANGELOG.md
index e6a41ec281..217eada1d7 100644
--- a/activerecord/CHANGELOG.md
+++ b/activerecord/CHANGELOG.md
@@ -1,3 +1,49 @@
+*   Add `#up_only` to database migrations for code that is only relevant when
+    migrating up, e.g. populating a new column.
+
+    *Rich Daley*
+
+*   Require raw SQL fragments to be explicitly marked when used in
+    relation query methods.
+
+    Before:
+    ```
+    Article.order("LENGTH(title)")
+    ```
+
+    After:
+    ```
+    Article.order(Arel.sql("LENGTH(title)"))
+    ```
+
+    This prevents SQL injection if applications use the [strongly
+    discouraged] form `Article.order(params[:my_order])`, under the
+    mistaken belief that only column names will be accepted.
+
+    Raw SQL strings will now cause a deprecation warning, which will
+    become an UnknownAttributeReference error in Rails 6.0. Applications
+    can opt in to the future behavior by setting `allow_unsafe_raw_sql`
+    to `:disabled`.
+
+    Common and judged-safe string values (such as simple column
+    references) are unaffected:
+    ```
+    Article.order("title DESC")
+    ```
+
+    *Ben Toews*
+
+*   `update_all` will now pass its values to `Type#cast` before passing them to
+    `Type#serialize`. This means that `update_all(foo: 'true')` will properly
+    persist a boolean.
+
+    *Sean Griffin*
+
+*   Add new error class `StatementTimeout` which will be raised
+    when statement timeout exceeded.
+
+    *Ryuta Kamizono*
+
 *   Fix `bin/rails db:migrate` with specified `VERSION`.
     `bin/rails db:migrate` with empty VERSION behaves as without `VERSION`.
     Check a format of `VERSION`: Allow a migration version number
@@ -144,8 +190,8 @@
 
     *Jeremy Green*
 
-*   Add new error class `TransactionTimeout` for MySQL adapter which will be raised
-    when lock wait time expires.
+*   Add new error class `TransactionTimeout` which will be raised
+    when lock wait timeout exceeded.
 
     *Gabriel Courtemanche*
 
diff --git a/activerecord/activerecord.gemspec b/activerecord/activerecord.gemspec
index 7ad06fe840..8e42a11df4 100644
--- a/activerecord/activerecord.gemspec
+++ b/activerecord/activerecord.gemspec
@@ -31,5 +31,5 @@ Gem::Specification.new do |s|
   s.add_dependency "activesupport", version
   s.add_dependency "activemodel",   version
 
-  s.add_dependency "arel", "9.0.0.alpha"
+  s.add_dependency "arel", ">= 9.0"
 end
diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb
index bf6dfd46e1..5de6503144 100644
--- a/activerecord/lib/active_record.rb
+++ b/activerecord/lib/active_record.rb
@@ -27,14 +27,14 @@ require "active_support"
 require "active_support/rails"
 require "active_model"
 require "arel"
+require "yaml"
 
 require "active_record/version"
-require "active_record/attribute_set"
+require "active_model/attribute_set"
 
 module ActiveRecord
   extend ActiveSupport::Autoload
 
-  autoload :Attribute
   autoload :Base
   autoload :Callbacks
   autoload :Core
@@ -104,6 +104,7 @@ module ActiveRecord
 
     autoload :Result
     autoload :TableMetadata
+    autoload :Type
   end
 
   module Coders
@@ -181,3 +182,7 @@ end
 ActiveSupport.on_load(:i18n) do
   I18n.load_path << File.expand_path("active_record/locale/en.yml", __dir__)
 end
+
+YAML.load_tags["!ruby/object:ActiveRecord::AttributeSet"] = "ActiveModel::AttributeSet"
+YAML.load_tags["!ruby/object:ActiveRecord::Attribute::FromDatabase"] = "ActiveModel::Attribute::FromDatabase"
+YAML.load_tags["!ruby/object:ActiveRecord::LazyAttributeHash"] = "ActiveModel::LazyAttributeHash"
diff --git a/activerecord/lib/active_record/associations/collection_proxy.rb b/activerecord/lib/active_record/associations/collection_proxy.rb
index 07f7303f8d..8b4a48a38c 100644
--- a/activerecord/lib/active_record/associations/collection_proxy.rb
+++ b/activerecord/lib/active_record/associations/collection_proxy.rb
@@ -988,6 +988,12 @@ module ActiveRecord
         load_target == other
       end
 
+      ##
+      # :method: to_ary
+      #
+      # :call-seq:
+      #   to_ary()
+      #
       # Returns a new array of objects from the collection. If the collection
       # hasn't been loaded, it fetches the records from the database.
       #
@@ -1021,10 +1027,6 @@ module ActiveRecord
       #   #       #<Pet id: 5, name: "Brain", person_id: 1>,
       #   #       #<Pet id: 6, name: "Boss",  person_id: 1>
       #   #    ]
-      def to_ary
-        load_target.dup
-      end
-      alias_method :to_a, :to_ary
 
       def records # :nodoc:
         load_target
diff --git a/activerecord/lib/active_record/associations/preloader.rb b/activerecord/lib/active_record/associations/preloader.rb
index 5a93a89d0a..e1087be9b3 100644
--- a/activerecord/lib/active_record/associations/preloader.rb
+++ b/activerecord/lib/active_record/associations/preloader.rb
@@ -44,16 +44,8 @@ module ActiveRecord
       extend ActiveSupport::Autoload
 
       eager_autoload do
-        autoload :Association,           "active_record/associations/preloader/association"
-        autoload :SingularAssociation,   "active_record/associations/preloader/singular_association"
-        autoload :CollectionAssociation, "active_record/associations/preloader/collection_association"
-        autoload :ThroughAssociation,    "active_record/associations/preloader/through_association"
-
-        autoload :HasMany,             "active_record/associations/preloader/has_many"
-        autoload :HasManyThrough,      "active_record/associations/preloader/has_many_through"
-        autoload :HasOne,              "active_record/associations/preloader/has_one"
-        autoload :HasOneThrough,       "active_record/associations/preloader/has_one_through"
-        autoload :BelongsTo,           "active_record/associations/preloader/belongs_to"
+        autoload :Association,        "active_record/associations/preloader/association"
+        autoload :ThroughAssociation, "active_record/associations/preloader/through_association"
       end
 
       # Eager loads the named associations for the given Active Record record(s).
@@ -182,8 +174,7 @@ module ActiveRecord
         end
 
         # Returns a class containing the logic needed to load preload the data
-        # and attach it to a relation. For example +Preloader::Association+ or
-        # +Preloader::HasManyThrough+. The class returned implements a `run` method
+        # and attach it to a relation. The class returned implements a `run` method
         # that accepts a preloader.
         def preloader_for(reflection, owners)
           if owners.first.association(reflection.name).loaded?
@@ -191,13 +182,10 @@ module ActiveRecord
           end
           reflection.check_preloadable!
 
-          case reflection.macro
-          when :has_many
-            reflection.options[:through] ? HasManyThrough : HasMany
-          when :has_one
-            reflection.options[:through] ? HasOneThrough : HasOne
-          when :belongs_to
-            BelongsTo
+          if reflection.options[:through]
+            ThroughAssociation
+          else
+            Association
           end
         end
     end
diff --git a/activerecord/lib/active_record/associations/preloader/association.rb b/activerecord/lib/active_record/associations/preloader/association.rb
index 19c337dc39..735da152b7 100644
--- a/activerecord/lib/active_record/associations/preloader/association.rb
+++ b/activerecord/lib/active_record/associations/preloader/association.rb
@@ -42,7 +42,13 @@ module ActiveRecord
           end
 
           def associate_records_to_owner(owner, records)
-            raise NotImplementedError
+            association = owner.association(reflection.name)
+            if reflection.collection?
+              association.loaded!
+              association.target.concat(records)
+            else
+              association.target = records.first
+            end
           end
 
           def owner_keys
diff --git a/activerecord/lib/active_record/associations/preloader/belongs_to.rb b/activerecord/lib/active_record/associations/preloader/belongs_to.rb
deleted file mode 100644
index a8e3340b23..0000000000
--- a/activerecord/lib/active_record/associations/preloader/belongs_to.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module Associations
-    class Preloader
-      class BelongsTo < SingularAssociation #:nodoc:
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/collection_association.rb b/activerecord/lib/active_record/associations/preloader/collection_association.rb
deleted file mode 100644
index fc2029f54a..0000000000
--- a/activerecord/lib/active_record/associations/preloader/collection_association.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module Associations
-    class Preloader
-      class CollectionAssociation < Association #:nodoc:
-        private
-          def associate_records_to_owner(owner, records)
-            association = owner.association(reflection.name)
-            association.loaded!
-            association.target.concat(records)
-          end
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/has_many.rb b/activerecord/lib/active_record/associations/preloader/has_many.rb
deleted file mode 100644
index 72f55bc43f..0000000000
--- a/activerecord/lib/active_record/associations/preloader/has_many.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasMany < CollectionAssociation #:nodoc:
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/has_many_through.rb b/activerecord/lib/active_record/associations/preloader/has_many_through.rb
deleted file mode 100644
index 3e17d07a33..0000000000
--- a/activerecord/lib/active_record/associations/preloader/has_many_through.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasManyThrough < CollectionAssociation #:nodoc:
-        include ThroughAssociation
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/has_one.rb b/activerecord/lib/active_record/associations/preloader/has_one.rb
deleted file mode 100644
index e339b65fb5..0000000000
--- a/activerecord/lib/active_record/associations/preloader/has_one.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasOne < SingularAssociation #:nodoc:
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/has_one_through.rb b/activerecord/lib/active_record/associations/preloader/has_one_through.rb
deleted file mode 100644
index 17734d0257..0000000000
--- a/activerecord/lib/active_record/associations/preloader/has_one_through.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasOneThrough < SingularAssociation #:nodoc:
-        include ThroughAssociation
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/singular_association.rb b/activerecord/lib/active_record/associations/preloader/singular_association.rb
deleted file mode 100644
index 30a92411e3..0000000000
--- a/activerecord/lib/active_record/associations/preloader/singular_association.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module Associations
-    class Preloader
-      class SingularAssociation < Association #:nodoc:
-        private
-          def associate_records_to_owner(owner, records)
-            association = owner.association(reflection.name)
-            association.target = records.first
-          end
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/through_association.rb b/activerecord/lib/active_record/associations/preloader/through_association.rb
index 762275fbad..a6b7ab80a2 100644
--- a/activerecord/lib/active_record/associations/preloader/through_association.rb
+++ b/activerecord/lib/active_record/associations/preloader/through_association.rb
@@ -3,7 +3,7 @@
 module ActiveRecord
   module Associations
     class Preloader
-      module ThroughAssociation #:nodoc:
+      class ThroughAssociation < Association # :nodoc:
         def run(preloader)
           already_loaded     = owners.first.association(through_reflection.name).loaded?
           through_scope      = through_scope()
diff --git a/activerecord/lib/active_record/attribute.rb b/activerecord/lib/active_record/attribute.rb
deleted file mode 100644
index fc474edc15..0000000000
--- a/activerecord/lib/active_record/attribute.rb
+++ /dev/null
@@ -1,242 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class Attribute # :nodoc:
-    class << self
-      def from_database(name, value, type)
-        FromDatabase.new(name, value, type)
-      end
-
-      def from_user(name, value, type, original_attribute = nil)
-        FromUser.new(name, value, type, original_attribute)
-      end
-
-      def with_cast_value(name, value, type)
-        WithCastValue.new(name, value, type)
-      end
-
-      def null(name)
-        Null.new(name)
-      end
-
-      def uninitialized(name, type)
-        Uninitialized.new(name, type)
-      end
-    end
-
-    attr_reader :name, :value_before_type_cast, :type
-
-    # This method should not be called directly.
-    # Use #from_database or #from_user
-    def initialize(name, value_before_type_cast, type, original_attribute = nil)
-      @name = name
-      @value_before_type_cast = value_before_type_cast
-      @type = type
-      @original_attribute = original_attribute
-    end
-
-    def value
-      # `defined?` is cheaper than `||=` when we get back falsy values
-      @value = type_cast(value_before_type_cast) unless defined?(@value)
-      @value
-    end
-
-    def original_value
-      if assigned?
-        original_attribute.original_value
-      else
-        type_cast(value_before_type_cast)
-      end
-    end
-
-    def value_for_database
-      type.serialize(value)
-    end
-
-    def changed?
-      changed_from_assignment? || changed_in_place?
-    end
-
-    def changed_in_place?
-      has_been_read? && type.changed_in_place?(original_value_for_database, value)
-    end
-
-    def forgetting_assignment
-      with_value_from_database(value_for_database)
-    end
-
-    def with_value_from_user(value)
-      type.assert_valid_value(value)
-      self.class.from_user(name, value, type, original_attribute || self)
-    end
-
-    def with_value_from_database(value)
-      self.class.from_database(name, value, type)
-    end
-
-    def with_cast_value(value)
-      self.class.with_cast_value(name, value, type)
-    end
-
-    def with_type(type)
-      if changed_in_place?
-        with_value_from_user(value).with_type(type)
-      else
-        self.class.new(name, value_before_type_cast, type, original_attribute)
-      end
-    end
-
-    def type_cast(*)
-      raise NotImplementedError
-    end
-
-    def initialized?
-      true
-    end
-
-    def came_from_user?
-      false
-    end
-
-    def has_been_read?
-      defined?(@value)
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        name == other.name &&
-        value_before_type_cast == other.value_before_type_cast &&
-        type == other.type
-    end
-    alias eql? ==
-
-    def hash
-      [self.class, name, value_before_type_cast, type].hash
-    end
-
-    def init_with(coder)
-      @name = coder["name"]
-      @value_before_type_cast = coder["value_before_type_cast"]
-      @type = coder["type"]
-      @original_attribute = coder["original_attribute"]
-      @value = coder["value"] if coder.map.key?("value")
-    end
-
-    def encode_with(coder)
-      coder["name"] = name
-      coder["value_before_type_cast"] = value_before_type_cast unless value_before_type_cast.nil?
-      coder["type"] = type if type
-      coder["original_attribute"] = original_attribute if original_attribute
-      coder["value"] = value if defined?(@value)
-    end
-
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
-      attr_reader :original_attribute
-      alias_method :assigned?, :original_attribute
-
-      def original_value_for_database
-        if assigned?
-          original_attribute.original_value_for_database
-        else
-          _original_value_for_database
-        end
-      end
-
-    private
-      def initialize_dup(other)
-        if defined?(@value) && @value.duplicable?
-          @value = @value.dup
-        end
-      end
-
-      def changed_from_assignment?
-        assigned? && type.changed?(original_value, value, value_before_type_cast)
-      end
-
-      def _original_value_for_database
-        type.serialize(original_value)
-      end
-
-      class FromDatabase < Attribute # :nodoc:
-        def type_cast(value)
-          type.deserialize(value)
-        end
-
-        def _original_value_for_database
-          value_before_type_cast
-        end
-      end
-
-      class FromUser < Attribute # :nodoc:
-        def type_cast(value)
-          type.cast(value)
-        end
-
-        def came_from_user?
-          !type.value_constructed_by_mass_assignment?(value_before_type_cast)
-        end
-      end
-
-      class WithCastValue < Attribute # :nodoc:
-        def type_cast(value)
-          value
-        end
-
-        def changed_in_place?
-          false
-        end
-      end
-
-      class Null < Attribute # :nodoc:
-        def initialize(name)
-          super(name, nil, Type.default_value)
-        end
-
-        def type_cast(*)
-          nil
-        end
-
-        def with_type(type)
-          self.class.with_cast_value(name, nil, type)
-        end
-
-        def with_value_from_database(value)
-          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
-        end
-        alias_method :with_value_from_user, :with_value_from_database
-      end
-
-      class Uninitialized < Attribute # :nodoc:
-        UNINITIALIZED_ORIGINAL_VALUE = Object.new
-
-        def initialize(name, type)
-          super(name, nil, type)
-        end
-
-        def value
-          if block_given?
-            yield name
-          end
-        end
-
-        def original_value
-          UNINITIALIZED_ORIGINAL_VALUE
-        end
-
-        def value_for_database
-        end
-
-        def initialized?
-          false
-        end
-
-        def with_type(type)
-          self.class.new(name, type)
-        end
-      end
-      private_constant :FromDatabase, :FromUser, :Null, :Uninitialized, :WithCastValue
-  end
-end
diff --git a/activerecord/lib/active_record/attribute/user_provided_default.rb b/activerecord/lib/active_record/attribute/user_provided_default.rb
deleted file mode 100644
index f746960fac..0000000000
--- a/activerecord/lib/active_record/attribute/user_provided_default.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record/attribute"
-
-module ActiveRecord
-  class Attribute # :nodoc:
-    class UserProvidedDefault < FromUser # :nodoc:
-      def initialize(name, value, type, database_default)
-        @user_provided_value = value
-        super(name, value, type, database_default)
-      end
-
-      def value_before_type_cast
-        if user_provided_value.is_a?(Proc)
-          @memoized_value_before_type_cast ||= user_provided_value.call
-        else
-          @user_provided_value
-        end
-      end
-
-      def with_type(type)
-        self.class.new(name, user_provided_value, type, original_attribute)
-      end
-
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :user_provided_value
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb
index 23d2aef214..64f81ca582 100644
--- a/activerecord/lib/active_record/attribute_methods.rb
+++ b/activerecord/lib/active_record/attribute_methods.rb
@@ -167,6 +167,46 @@ module ActiveRecord
         end
       end
 
+      # Regexp whitelist. Matches the following:
+      #   "#{table_name}.#{column_name}"
+      #   "#{column_name}"
+      COLUMN_NAME_WHITELIST = /\A(?:\w+\.)?\w+\z/i
+
+      # Regexp whitelist. Matches the following:
+      #   "#{table_name}.#{column_name}"
+      #   "#{table_name}.#{column_name} #{direction}"
+      #   "#{column_name}"
+      #   "#{column_name} #{direction}"
+      COLUMN_NAME_ORDER_WHITELIST = /\A(?:\w+\.)?\w+(?:\s+asc|\s+desc)?\z/i
+
+      def enforce_raw_sql_whitelist(args, whitelist: COLUMN_NAME_WHITELIST) # :nodoc:
+        unexpected = args.reject do |arg|
+          arg.kind_of?(Arel::Node) ||
+            arg.is_a?(Arel::Nodes::SqlLiteral) ||
+            arg.is_a?(Arel::Attributes::Attribute) ||
+            arg.to_s.split(/\s*,\s*/).all? { |part| whitelist.match?(part) }
+        end
+
+        return if unexpected.none?
+
+        if allow_unsafe_raw_sql == :deprecated
+          ActiveSupport::Deprecation.warn(
+            "Dangerous query method (method whose arguments are used as raw " \
+            "SQL) called with non-attribute argument(s): " \
+            "#{unexpected.map(&:inspect).join(", ")}. Non-attribute " \
+            "arguments will be disallowed in Rails 6.0. This method should " \
+            "not be called with user-provided values, such as request " \
+            "parameters or model attributes. Known-safe values can be passed " \
+            "by wrapping them in Arel.sql()."
+          )
+        else
+          raise(ActiveRecord::UnknownAttributeReference,
+            "Query method called with non-attribute argument(s): " +
+            unexpected.map(&:inspect).join(", ")
+          )
+        end
+      end
+
       # Returns true if the given attribute exists, otherwise false.
       #
       #   class Person < ActiveRecord::Base
diff --git a/activerecord/lib/active_record/attribute_methods/dirty.rb b/activerecord/lib/active_record/attribute_methods/dirty.rb
index 79110d04f4..3de6fe566d 100644
--- a/activerecord/lib/active_record/attribute_methods/dirty.rb
+++ b/activerecord/lib/active_record/attribute_methods/dirty.rb
@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/module/attribute_accessors"
-require "active_record/attribute_mutation_tracker"
 
 module ActiveRecord
   module AttributeMethods
@@ -33,65 +32,13 @@ module ActiveRecord
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
+          @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
           @mutations_before_last_save = nil
+          @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
           @mutations_from_database = nil
-          @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
         end
       end
 
-      def initialize_dup(other) # :nodoc:
-        super
-        @attributes = self.class._default_attributes.map do |attr|
-          attr.with_value_from_user(@attributes.fetch_value(attr.name))
-        end
-        @mutations_from_database = nil
-      end
-
-      def changes_applied # :nodoc:
-        @mutations_before_last_save = mutations_from_database
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-        forget_attribute_assignments
-        @mutations_from_database = nil
-      end
-
-      def clear_changes_information # :nodoc:
-        @mutations_before_last_save = nil
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-        forget_attribute_assignments
-        @mutations_from_database = nil
-      end
-
-      def clear_attribute_changes(attr_names) # :nodoc:
-        super
-        attr_names.each do |attr_name|
-          clear_attribute_change(attr_name)
-        end
-      end
-
-      def changed_attributes # :nodoc:
-        # This should only be set by methods which will call changed_attributes
-        # multiple times when it is known that the computed value cannot change.
-        if defined?(@cached_changed_attributes)
-          @cached_changed_attributes
-        else
-          super.reverse_merge(mutations_from_database.changed_values).freeze
-        end
-      end
-
-      def changes # :nodoc:
-        cache_changed_attributes do
-          super
-        end
-      end
-
-      def previous_changes # :nodoc:
-        mutations_before_last_save.changes
-      end
-
-      def attribute_changed_in_place?(attr_name) # :nodoc:
-        mutations_from_database.changed_in_place?(attr_name)
-      end
-
       # Did this attribute change when we last saved? This method can be invoked
       # as +saved_change_to_name?+ instead of <tt>saved_change_to_attribute?("name")</tt>.
       # Behaves similarly to +attribute_changed?+. This method is useful in
@@ -182,26 +129,6 @@ module ActiveRecord
           result
         end
 
-        def mutations_from_database
-          unless defined?(@mutations_from_database)
-            @mutations_from_database = nil
-          end
-          @mutations_from_database ||= AttributeMutationTracker.new(@attributes)
-        end
-
-        def changes_include?(attr_name)
-          super || mutations_from_database.changed?(attr_name)
-        end
-
-        def clear_attribute_change(attr_name)
-          mutations_from_database.forget_change(attr_name)
-        end
-
-        def attribute_will_change!(attr_name)
-          super
-          mutations_from_database.force_change(attr_name)
-        end
-
         def _update_record(*)
           partial_writes? ? super(keys_for_partial_write) : super
         end
@@ -213,25 +140,6 @@ module ActiveRecord
         def keys_for_partial_write
           changed_attribute_names_to_save & self.class.column_names
         end
-
-        def forget_attribute_assignments
-          @attributes = @attributes.map(&:forgetting_assignment)
-        end
-
-        def mutations_before_last_save
-          @mutations_before_last_save ||= NullMutationTracker.instance
-        end
-
-        def cache_changed_attributes
-          @cached_changed_attributes = changed_attributes
-          yield
-        ensure
-          clear_changed_attributes_cache
-        end
-
-        def clear_changed_attributes_cache
-          remove_instance_variable(:@cached_changed_attributes) if defined?(@cached_changed_attributes)
-        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/attribute_mutation_tracker.rb b/activerecord/lib/active_record/attribute_mutation_tracker.rb
deleted file mode 100644
index 94bf641a5d..0000000000
--- a/activerecord/lib/active_record/attribute_mutation_tracker.rb
+++ /dev/null
@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class AttributeMutationTracker # :nodoc:
-    OPTION_NOT_GIVEN = Object.new
-
-    def initialize(attributes)
-      @attributes = attributes
-      @forced_changes = Set.new
-    end
-
-    def changed_values
-      attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
-        if changed?(attr_name)
-          result[attr_name] = attributes[attr_name].original_value
-        end
-      end
-    end
-
-    def changes
-      attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
-        change = change_to_attribute(attr_name)
-        if change
-          result[attr_name] = change
-        end
-      end
-    end
-
-    def change_to_attribute(attr_name)
-      attr_name = attr_name.to_s
-      if changed?(attr_name)
-        [attributes[attr_name].original_value, attributes.fetch_value(attr_name)]
-      end
-    end
-
-    def any_changes?
-      attr_names.any? { |attr| changed?(attr) }
-    end
-
-    def changed?(attr_name, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
-      attr_name = attr_name.to_s
-      forced_changes.include?(attr_name) ||
-        attributes[attr_name].changed? &&
-        (OPTION_NOT_GIVEN == from || attributes[attr_name].original_value == from) &&
-        (OPTION_NOT_GIVEN == to || attributes[attr_name].value == to)
-    end
-
-    def changed_in_place?(attr_name)
-      attributes[attr_name.to_s].changed_in_place?
-    end
-
-    def forget_change(attr_name)
-      attr_name = attr_name.to_s
-      attributes[attr_name] = attributes[attr_name].forgetting_assignment
-      forced_changes.delete(attr_name)
-    end
-
-    def original_value(attr_name)
-      attributes[attr_name.to_s].original_value
-    end
-
-    def force_change(attr_name)
-      forced_changes << attr_name.to_s
-    end
-
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
-      attr_reader :attributes, :forced_changes
-
-    private
-
-      def attr_names
-        attributes.keys
-      end
-  end
-
-  class NullMutationTracker # :nodoc:
-    include Singleton
-
-    def changed_values(*)
-      {}
-    end
-
-    def changes(*)
-      {}
-    end
-
-    def change_to_attribute(attr_name)
-    end
-
-    def any_changes?(*)
-      false
-    end
-
-    def changed?(*)
-      false
-    end
-
-    def changed_in_place?(*)
-      false
-    end
-
-    def forget_change(*)
-    end
-
-    def original_value(*)
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_set.rb b/activerecord/lib/active_record/attribute_set.rb
deleted file mode 100644
index 9785666e77..0000000000
--- a/activerecord/lib/active_record/attribute_set.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record/attribute_set/builder"
-require "active_record/attribute_set/yaml_encoder"
-
-module ActiveRecord
-  class AttributeSet # :nodoc:
-    delegate :each_value, :fetch, to: :attributes
-
-    def initialize(attributes)
-      @attributes = attributes
-    end
-
-    def [](name)
-      attributes[name] || Attribute.null(name)
-    end
-
-    def []=(name, value)
-      attributes[name] = value
-    end
-
-    def values_before_type_cast
-      attributes.transform_values(&:value_before_type_cast)
-    end
-
-    def to_hash
-      initialized_attributes.transform_values(&:value)
-    end
-    alias_method :to_h, :to_hash
-
-    def key?(name)
-      attributes.key?(name) && self[name].initialized?
-    end
-
-    def keys
-      attributes.each_key.select { |name| self[name].initialized? }
-    end
-
-    if defined?(JRUBY_VERSION)
-      # This form is significantly faster on JRuby, and this is one of our biggest hotspots.
-      # https://github.com/jruby/jruby/pull/2562
-      def fetch_value(name, &block)
-        self[name].value(&block)
-      end
-    else
-      def fetch_value(name)
-        self[name].value { |n| yield n if block_given? }
-      end
-    end
-
-    def write_from_database(name, value)
-      attributes[name] = self[name].with_value_from_database(value)
-    end
-
-    def write_from_user(name, value)
-      attributes[name] = self[name].with_value_from_user(value)
-    end
-
-    def write_cast_value(name, value)
-      attributes[name] = self[name].with_cast_value(value)
-    end
-
-    def freeze
-      @attributes.freeze
-      super
-    end
-
-    def deep_dup
-      self.class.allocate.tap do |copy|
-        copy.instance_variable_set(:@attributes, attributes.deep_dup)
-      end
-    end
-
-    def initialize_dup(_)
-      @attributes = attributes.dup
-      super
-    end
-
-    def initialize_clone(_)
-      @attributes = attributes.clone
-      super
-    end
-
-    def reset(key)
-      if key?(key)
-        write_from_database(key, nil)
-      end
-    end
-
-    def accessed
-      attributes.select { |_, attr| attr.has_been_read? }.keys
-    end
-
-    def map(&block)
-      new_attributes = attributes.transform_values(&block)
-      AttributeSet.new(new_attributes)
-    end
-
-    def ==(other)
-      attributes == other.attributes
-    end
-
-    protected
-
-      attr_reader :attributes
-
-    private
-
-      def initialized_attributes
-        attributes.select { |_, attr| attr.initialized? }
-      end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_set/builder.rb b/activerecord/lib/active_record/attribute_set/builder.rb
deleted file mode 100644
index 349cc7e403..0000000000
--- a/activerecord/lib/active_record/attribute_set/builder.rb
+++ /dev/null
@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record/attribute"
-
-module ActiveRecord
-  class AttributeSet # :nodoc:
-    class Builder # :nodoc:
-      attr_reader :types, :always_initialized, :default
-
-      def initialize(types, always_initialized = nil, &default)
-        @types = types
-        @always_initialized = always_initialized
-        @default = default
-      end
-
-      def build_from_database(values = {}, additional_types = {})
-        if always_initialized && !values.key?(always_initialized)
-          values[always_initialized] = nil
-        end
-
-        attributes = LazyAttributeHash.new(types, values, additional_types, &default)
-        AttributeSet.new(attributes)
-      end
-    end
-  end
-
-  class LazyAttributeHash # :nodoc:
-    delegate :transform_values, :each_key, :each_value, :fetch, to: :materialize
-
-    def initialize(types, values, additional_types, &default)
-      @types = types
-      @values = values
-      @additional_types = additional_types
-      @materialized = false
-      @delegate_hash = {}
-      @default = default || proc {}
-    end
-
-    def key?(key)
-      delegate_hash.key?(key) || values.key?(key) || types.key?(key)
-    end
-
-    def [](key)
-      delegate_hash[key] || assign_default_value(key)
-    end
-
-    def []=(key, value)
-      if frozen?
-        raise RuntimeError, "Can't modify frozen hash"
-      end
-      delegate_hash[key] = value
-    end
-
-    def deep_dup
-      dup.tap do |copy|
-        copy.instance_variable_set(:@delegate_hash, delegate_hash.transform_values(&:dup))
-      end
-    end
-
-    def initialize_dup(_)
-      @delegate_hash = Hash[delegate_hash]
-      super
-    end
-
-    def select
-      keys = types.keys | values.keys | delegate_hash.keys
-      keys.each_with_object({}) do |key, hash|
-        attribute = self[key]
-        if yield(key, attribute)
-          hash[key] = attribute
-        end
-      end
-    end
-
-    def ==(other)
-      if other.is_a?(LazyAttributeHash)
-        materialize == other.materialize
-      else
-        materialize == other
-      end
-    end
-
-    def marshal_dump
-      materialize
-    end
-
-    def marshal_load(delegate_hash)
-      @delegate_hash = delegate_hash
-      @types = {}
-      @values = {}
-      @additional_types = {}
-      @materialized = true
-    end
-
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
-      attr_reader :types, :values, :additional_types, :delegate_hash, :default
-
-      def materialize
-        unless @materialized
-          values.each_key { |key| self[key] }
-          types.each_key { |key| self[key] }
-          unless frozen?
-            @materialized = true
-          end
-        end
-        delegate_hash
-      end
-
-    private
-
-      def assign_default_value(name)
-        type = additional_types.fetch(name, types[name])
-        value_present = true
-        value = values.fetch(name) { value_present = false }
-
-        if value_present
-          delegate_hash[name] = Attribute.from_database(name, value, type)
-        elsif types.key?(name)
-          delegate_hash[name] = default.call(name) || Attribute.uninitialized(name, type)
-        end
-      end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_set/yaml_encoder.rb b/activerecord/lib/active_record/attribute_set/yaml_encoder.rb
deleted file mode 100644
index 9254ce16ab..0000000000
--- a/activerecord/lib/active_record/attribute_set/yaml_encoder.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class AttributeSet
-    # Attempts to do more intelligent YAML dumping of an
-    # ActiveRecord::AttributeSet to reduce the size of the resulting string
-    class YAMLEncoder # :nodoc:
-      def initialize(default_types)
-        @default_types = default_types
-      end
-
-      def encode(attribute_set, coder)
-        coder["concise_attributes"] = attribute_set.each_value.map do |attr|
-          if attr.type.equal?(default_types[attr.name])
-            attr.with_type(nil)
-          else
-            attr
-          end
-        end
-      end
-
-      def decode(coder)
-        if coder["attributes"]
-          coder["attributes"]
-        else
-          attributes_hash = Hash[coder["concise_attributes"].map do |attr|
-            if attr.type.nil?
-              attr = attr.with_type(default_types[attr.name])
-            end
-            [attr.name, attr]
-          end]
-          AttributeSet.new(attributes_hash)
-        end
-      end
-
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :default_types
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/attributes.rb b/activerecord/lib/active_record/attributes.rb
index 9224d58928..0b7c9398a8 100644
--- a/activerecord/lib/active_record/attributes.rb
+++ b/activerecord/lib/active_record/attributes.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_record/attribute/user_provided_default"
+require "active_model/attribute/user_provided_default"
 
 module ActiveRecord
   # See ActiveRecord::Attributes::ClassMethods for documentation
@@ -250,14 +250,14 @@ module ActiveRecord
           if value == NO_DEFAULT_PROVIDED
             default_attribute = _default_attributes[name].with_type(type)
           elsif from_user
-            default_attribute = Attribute::UserProvidedDefault.new(
+            default_attribute = ActiveModel::Attribute::UserProvidedDefault.new(
               name,
               value,
               type,
               _default_attributes.fetch(name.to_s) { nil },
             )
           else
-            default_attribute = Attribute.from_database(name, value, type)
+            default_attribute = ActiveModel::Attribute.from_database(name, value, type)
           end
           _default_attributes[name] = default_attribute
         end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
index 0759f4d2b3..6c06f67239 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
@@ -82,11 +82,8 @@ module ActiveRecord
     # * private methods that require being called in a +synchronize+ blocks
     #   are now explicitly documented
     class ConnectionPool
-      # Threadsafe, fair, FIFO queue.  Meant to be used by ConnectionPool
-      # with which it shares a Monitor.  But could be a generic Queue.
-      #
-      # The Queue in stdlib's 'thread' could replace this class except
-      # stdlib's doesn't support waiting with a timeout.
+      # Threadsafe, fair, LIFO queue.  Meant to be used by ConnectionPool
+      # with which it shares a Monitor.
       class Queue
         def initialize(lock = Monitor.new)
           @lock = lock
@@ -175,7 +172,7 @@ module ActiveRecord
 
           # Removes and returns the head of the queue if possible, or +nil+.
           def remove
-            @queue.shift
+            @queue.pop
           end
 
           # Remove and return the head the queue if the number of
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index e3aab8dad8..7e6db860dd 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "active_record/type"
 require "active_record/connection_adapters/determine_if_preparable_visitor"
 require "active_record/connection_adapters/schema_cache"
 require "active_record/connection_adapters/sql_type_metadata"
 require "active_record/connection_adapters/abstract/schema_dumper"
 require "active_record/connection_adapters/abstract/schema_creation"
+require "active_support/concurrency/load_interlock_aware_monitor"
 require "arel/collectors/bind"
 require "arel/collectors/composite"
 require "arel/collectors/sql_string"
@@ -108,7 +108,7 @@ module ActiveRecord
         @schema_cache        = SchemaCache.new self
         @quoted_column_names, @quoted_table_names = {}, {}
         @visitor = arel_visitor
-        @lock = Monitor.new
+        @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
 
         if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true })
           @prepared_statements = true
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 bfec6fb784..ca651ef390 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
@@ -635,6 +635,7 @@ module ActiveRecord
         ER_CANNOT_ADD_FOREIGN   = 1215
         ER_CANNOT_CREATE_TABLE  = 1005
         ER_LOCK_WAIT_TIMEOUT    = 1205
+        ER_QUERY_TIMEOUT        = 3024
 
         def translate_exception(exception, message)
           case error_number(exception)
@@ -660,6 +661,8 @@ module ActiveRecord
             Deadlocked.new(message)
           when ER_LOCK_WAIT_TIMEOUT
             TransactionTimeout.new(message)
+          when ER_QUERY_TIMEOUT
+            StatementTimeout.new(message)
           else
             super
           end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 2c3c1df2a9..5ce6765dd8 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -391,6 +391,8 @@ module ActiveRecord
         UNIQUE_VIOLATION      = "23505"
         SERIALIZATION_FAILURE = "40001"
         DEADLOCK_DETECTED     = "40P01"
+        LOCK_NOT_AVAILABLE    = "55P03"
+        QUERY_CANCELED        = "57014"
 
         def translate_exception(exception, message)
           return exception unless exception.respond_to?(:result)
@@ -410,6 +412,10 @@ module ActiveRecord
             SerializationFailure.new(message)
           when DEADLOCK_DETECTED
             Deadlocked.new(message)
+          when LOCK_NOT_AVAILABLE
+            TransactionTimeout.new(message)
+          when QUERY_CANCELED
+            StatementTimeout.new(message)
           else
             super
           end
diff --git a/activerecord/lib/active_record/core.rb b/activerecord/lib/active_record/core.rb
index 0f7a503c90..481159e501 100644
--- a/activerecord/lib/active_record/core.rb
+++ b/activerecord/lib/active_record/core.rb
@@ -76,6 +76,14 @@ module ActiveRecord
       # scope being ignored is error-worthy, rather than a warning.
       mattr_accessor :error_on_ignored_order, instance_writer: false, default: false
 
+      # :singleton-method:
+      # Specify the behavior for unsafe raw query methods. Values are as follows
+      #   deprecated - Warnings are logged when unsafe raw SQL is passed to
+      #                query methods.
+      #   disabled   - Unsafe raw SQL passed to query methods results in
+      #                UnknownAttributeReference exception.
+      mattr_accessor :allow_unsafe_raw_sql, instance_writer: false, default: :deprecated
+
       ##
       # :singleton-method:
       # Specify whether or not to use timestamps for migration versions
@@ -269,7 +277,8 @@ module ActiveRecord
           relation = Relation.create(self, arel_table, predicate_builder)
 
           if finder_needs_type_condition? && !ignore_default_scope?
-            relation.where(type_condition).create_with(inheritance_column.to_s => sti_name)
+            relation.where!(type_condition)
+            relation.create_with!(inheritance_column.to_s => sti_name)
           else
             relation
           end
diff --git a/activerecord/lib/active_record/errors.rb b/activerecord/lib/active_record/errors.rb
index 9ef3316393..7382879fce 100644
--- a/activerecord/lib/active_record/errors.rb
+++ b/activerecord/lib/active_record/errors.rb
@@ -335,8 +335,36 @@ module ActiveRecord
   class IrreversibleOrderError < ActiveRecordError
   end
 
-  # TransactionTimeout will be raised when lock wait timeout expires.
-  # Wait time value is set by innodb_lock_wait_timeout.
+  # TransactionTimeout will be raised when lock wait timeout exceeded.
   class TransactionTimeout < StatementInvalid
   end
+
+  # StatementTimeout will be raised when statement timeout exceeded.
+  class StatementTimeout < StatementInvalid
+  end
+
+  # UnknownAttributeReference is raised when an unknown and potentially unsafe
+  # value is passed to a query method when allow_unsafe_raw_sql is set to
+  # :disabled. For example, passing a non column name value to a relation's
+  # #order method might cause this exception.
+  #
+  # When working around this exception, caution should be taken to avoid SQL
+  # injection vulnerabilities when passing user-provided values to query
+  # methods. Known-safe values can be passed to query methods by wrapping them
+  # in Arel.sql.
+  #
+  # For example, with allow_unsafe_raw_sql set to :disabled, the following
+  # code would raise this exception:
+  #
+  #   Post.order("length(title)").first
+  #
+  # The desired result can be accomplished by wrapping the known-safe string
+  # in Arel.sql:
+  #
+  #   Post.order(Arel.sql("length(title)")).first
+  #
+  # Again, such a workaround should *not* be used when passing user-provided
+  # values, such as request parameters or model attributes to query methods.
+  class UnknownAttributeReference < ActiveRecordError
+  end
 end
diff --git a/activerecord/lib/active_record/legacy_yaml_adapter.rb b/activerecord/lib/active_record/legacy_yaml_adapter.rb
index 23644aab8f..ffa095dd94 100644
--- a/activerecord/lib/active_record/legacy_yaml_adapter.rb
+++ b/activerecord/lib/active_record/legacy_yaml_adapter.rb
@@ -8,7 +8,7 @@ module ActiveRecord
       case coder["active_record_yaml_version"]
       when 1, 2 then coder
       else
-        if coder["attributes"].is_a?(AttributeSet)
+        if coder["attributes"].is_a?(ActiveModel::AttributeSet)
           Rails420.convert(klass, coder)
         else
           Rails41.convert(klass, coder)
diff --git a/activerecord/lib/active_record/migration.rb b/activerecord/lib/active_record/migration.rb
index d12a979a7f..360bf25a8c 100644
--- a/activerecord/lib/active_record/migration.rb
+++ b/activerecord/lib/active_record/migration.rb
@@ -581,7 +581,8 @@ module ActiveRecord
       def load_schema_if_pending!
         if ActiveRecord::Migrator.needs_migration? || !ActiveRecord::Migrator.any_migrations?
           # Roundtrip to Rake to allow plugins to hook into database initialization.
-          FileUtils.cd Rails.root do
+          root = defined?(ENGINE_ROOT) ? ENGINE_ROOT : Rails.root
+          FileUtils.cd(root) do
             current_config = Base.connection_config
             Base.clear_all_connections!
             system("bin/rails db:test:prepare")
@@ -733,6 +734,24 @@ module ActiveRecord
       execute_block { yield helper }
     end
 
+    # Used to specify an operation that is only run when migrating up
+    # (for example, populating a new column with its initial values).
+    #
+    # In the following example, the new column `published` will be given
+    # the value `true` for all existing records.
+    #
+    #    class AddPublishedToPosts < ActiveRecord::Migration[5.2]
+    #      def change
+    #        add_column :posts, :published, :boolean, default: false
+    #        up_only do
+    #          execute "update posts set published = 'true'"
+    #        end
+    #      end
+    #    end
+    def up_only
+      execute_block { yield } unless reverting?
+    end
+
     # Runs the given migration classes.
     # Last argument can specify options:
     # - :direction (default is :up)
diff --git a/activerecord/lib/active_record/model_schema.rb b/activerecord/lib/active_record/model_schema.rb
index bed9400f51..12ee4a4137 100644
--- a/activerecord/lib/active_record/model_schema.rb
+++ b/activerecord/lib/active_record/model_schema.rb
@@ -323,7 +323,7 @@ module ActiveRecord
       end
 
       def attributes_builder # :nodoc:
-        @attributes_builder ||= AttributeSet::Builder.new(attribute_types, primary_key) do |name|
+        @attributes_builder ||= ActiveModel::AttributeSet::Builder.new(attribute_types, primary_key) do |name|
           unless columns_hash.key?(name)
             _default_attributes[name].dup
           end
@@ -346,7 +346,7 @@ module ActiveRecord
       end
 
       def yaml_encoder # :nodoc:
-        @yaml_encoder ||= AttributeSet::YAMLEncoder.new(attribute_types)
+        @yaml_encoder ||= ActiveModel::AttributeSet::YAMLEncoder.new(attribute_types)
       end
 
       # Returns the type of the attribute with the given name, after applying
@@ -376,7 +376,7 @@ module ActiveRecord
       end
 
       def _default_attributes # :nodoc:
-        @default_attributes ||= AttributeSet.new({})
+        @default_attributes ||= ActiveModel::AttributeSet.new({})
       end
 
       # Returns an array of column names as strings.
diff --git a/activerecord/lib/active_record/nested_attributes.rb b/activerecord/lib/active_record/nested_attributes.rb
index 435c81c153..fa20bce3a9 100644
--- a/activerecord/lib/active_record/nested_attributes.rb
+++ b/activerecord/lib/active_record/nested_attributes.rb
@@ -63,6 +63,18 @@ module ActiveRecord
     #   member.update params[:member]
     #   member.avatar.icon # => 'sad'
     #
+    # If you want to update the current avatar without providing the id, you must add <tt>:update_only</tt> option.
+    #
+    #   class Member < ActiveRecord::Base
+    #     has_one :avatar
+    #     accepts_nested_attributes_for :avatar, update_only: true
+    #   end
+    #
+    #   params = { member: { avatar_attributes: { icon: 'sad' } } }
+    #   member.update params[:member]
+    #   member.avatar.id # => 2
+    #   member.avatar.icon # => 'sad'
+    #
     # By default you will only be able to set and update attributes on the
     # associated model. If you want to destroy the associated model through the
     # attributes hash, you have to enable it first using the
diff --git a/activerecord/lib/active_record/persistence.rb b/activerecord/lib/active_record/persistence.rb
index a57c60ffac..4e1b05dbf6 100644
--- a/activerecord/lib/active_record/persistence.rb
+++ b/activerecord/lib/active_record/persistence.rb
@@ -165,6 +165,38 @@ module ActiveRecord
         where(primary_key => id_or_array).delete_all
       end
 
+      def _insert_record(values) # :nodoc:
+        primary_key_value = nil
+
+        if primary_key && Hash === values
+          arel_primary_key = arel_attribute(primary_key)
+          primary_key_value = values[arel_primary_key]
+
+          if !primary_key_value && prefetch_primary_key?
+            primary_key_value = next_sequence_value
+            values[arel_primary_key] = primary_key_value
+          end
+        end
+
+        if values.empty?
+          im = arel_table.compile_insert(connection.empty_insert_statement_value)
+          im.into arel_table
+        else
+          im = arel_table.compile_insert(_substitute_values(values))
+        end
+
+        connection.insert(im, "#{self} Create", primary_key || false, primary_key_value)
+      end
+
+      def _update_record(values, id, id_was) # :nodoc:
+        bind = predicate_builder.build_bind_attribute(primary_key, id_was || id)
+        um = arel_table.where(
+          arel_attribute(primary_key).eq(bind)
+        ).compile_update(_substitute_values(values), primary_key)
+
+        connection.update(um, "#{self} Update")
+      end
+
       private
         # Called by +instantiate+ to decide which class to use for a new
         # record instance.
@@ -174,6 +206,13 @@ module ActiveRecord
         def discriminate_class_for_record(record)
           self
         end
+
+        def _substitute_values(values)
+          values.map do |attr, value|
+            bind = predicate_builder.build_bind_attribute(attr.name, value)
+            [attr, bind]
+          end
+        end
     end
 
     # Returns true if this object hasn't been saved yet -- that is, a record
@@ -671,7 +710,7 @@ module ActiveRecord
         rows_affected = 0
         @_trigger_update_callback = true
       else
-        rows_affected = self.class.unscoped._update_record attributes_values, id, id_in_database
+        rows_affected = self.class._update_record(attributes_values, id, id_in_database)
         @_trigger_update_callback = rows_affected > 0
       end
 
@@ -685,7 +724,7 @@ module ActiveRecord
     def _create_record(attribute_names = self.attribute_names)
       attributes_values = arel_attributes_with_values_for_create(attribute_names)
 
-      new_id = self.class.unscoped.insert attributes_values
+      new_id = self.class._insert_record(attributes_values)
       self.id ||= new_id if self.class.primary_key
 
       @new_record = false
diff --git a/activerecord/lib/active_record/query_cache.rb b/activerecord/lib/active_record/query_cache.rb
index 3d5babb8b7..8e23128333 100644
--- a/activerecord/lib/active_record/query_cache.rb
+++ b/activerecord/lib/active_record/query_cache.rb
@@ -26,16 +26,19 @@ module ActiveRecord
     end
 
     def self.run
-      caching_pool = ActiveRecord::Base.connection_pool
-      caching_was_enabled = caching_pool.query_cache_enabled
+      ActiveRecord::Base.connection_handler.connection_pool_list.map do |pool|
+        caching_was_enabled = pool.query_cache_enabled
 
-      caching_pool.enable_query_cache!
+        pool.enable_query_cache!
 
-      [caching_pool, caching_was_enabled]
+        [pool, caching_was_enabled]
+      end
     end
 
-    def self.complete((caching_pool, caching_was_enabled))
-      caching_pool.disable_query_cache! unless caching_was_enabled
+    def self.complete(caching_pools)
+      caching_pools.each do |pool, caching_was_enabled|
+        pool.disable_query_cache! unless caching_was_enabled
+      end
 
       ActiveRecord::Base.connection_handler.connection_pool_list.each do |pool|
         pool.release_connection if pool.active_connection? && !pool.connection.transaction_open?
diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index 3bca2982e0..fce3e1c5cf 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -4,16 +4,16 @@ require "active_record"
 
 db_namespace = namespace :db do
   desc "Set the environment value for the database"
-  task "environment:set" => [:environment, :load_config] do
+  task "environment:set" => :load_config do
     ActiveRecord::InternalMetadata.create_table
     ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
   end
 
-  task check_protected_environments: [:environment, :load_config] do
+  task check_protected_environments: :load_config do
     ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
   end
 
-  task :load_config do
+  task load_config: :environment do
     ActiveRecord::Base.configurations       = ActiveRecord::Tasks::DatabaseTasks.database_configuration || {}
     ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
   end
@@ -56,7 +56,7 @@ db_namespace = namespace :db do
   end
 
   desc "Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)."
-  task migrate: [:environment, :load_config] do
+  task migrate: :load_config do
     ActiveRecord::Tasks::DatabaseTasks.migrate
     db_namespace["_dump"].invoke
   end
@@ -78,7 +78,7 @@ db_namespace = namespace :db do
 
   namespace :migrate do
     # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
-    task redo: [:environment, :load_config] do
+    task redo: :load_config do
       raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
 
       if ENV["VERSION"]
@@ -94,7 +94,7 @@ db_namespace = namespace :db do
     task reset: ["db:drop", "db:create", "db:migrate"]
 
     # desc 'Runs the "up" for a given migration VERSION.'
-    task up: [:environment, :load_config] do
+    task up: :load_config do
       raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
 
       ActiveRecord::Tasks::DatabaseTasks.check_target_version
@@ -108,7 +108,7 @@ db_namespace = namespace :db do
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
-    task down: [:environment, :load_config] do
+    task down: :load_config do
       raise "VERSION is required - To go down one migration, use db:rollback" if !ENV["VERSION"] || ENV["VERSION"].empty?
 
       ActiveRecord::Tasks::DatabaseTasks.check_target_version
@@ -122,7 +122,7 @@ db_namespace = namespace :db do
     end
 
     desc "Display status of migrations"
-    task status: [:environment, :load_config] do
+    task status: :load_config do
       unless ActiveRecord::SchemaMigration.table_exists?
         abort "Schema migrations table does not exist yet."
       end
@@ -140,14 +140,14 @@ db_namespace = namespace :db do
   end
 
   desc "Rolls the schema back to the previous version (specify steps w/ STEP=n)."
-  task rollback: [:environment, :load_config] do
+  task rollback: :load_config do
     step = ENV["STEP"] ? ENV["STEP"].to_i : 1
     ActiveRecord::Migrator.rollback(ActiveRecord::Tasks::DatabaseTasks.migrations_paths, step)
     db_namespace["_dump"].invoke
   end
 
   # desc 'Pushes the schema to the next version (specify steps w/ STEP=n).'
-  task forward: [:environment, :load_config] do
+  task forward: :load_config do
     step = ENV["STEP"] ? ENV["STEP"].to_i : 1
     ActiveRecord::Migrator.forward(ActiveRecord::Tasks::DatabaseTasks.migrations_paths, step)
     db_namespace["_dump"].invoke
@@ -157,12 +157,12 @@ db_namespace = namespace :db do
   task reset: [ "db:drop", "db:setup" ]
 
   # desc "Retrieves the charset for the current environment's database"
-  task charset: [:environment, :load_config] do
+  task charset: :load_config do
     puts ActiveRecord::Tasks::DatabaseTasks.charset_current
   end
 
   # desc "Retrieves the collation for the current environment's database"
-  task collation: [:environment, :load_config] do
+  task collation: :load_config do
     begin
       puts ActiveRecord::Tasks::DatabaseTasks.collation_current
     rescue NoMethodError
@@ -171,12 +171,12 @@ db_namespace = namespace :db do
   end
 
   desc "Retrieves the current schema version number"
-  task version: [:environment, :load_config] do
+  task version: :load_config do
     puts "Current version: #{ActiveRecord::Migrator.current_version}"
   end
 
   # desc "Raises an error if there are pending migrations"
-  task abort_if_pending_migrations: [:environment, :load_config] do
+  task abort_if_pending_migrations: :load_config do
     pending_migrations = ActiveRecord::Migrator.open(ActiveRecord::Tasks::DatabaseTasks.migrations_paths).pending_migrations
 
     if pending_migrations.any?
@@ -199,7 +199,7 @@ db_namespace = namespace :db do
 
   namespace :fixtures do
     desc "Loads fixtures into the current environment's database. Load specific fixtures using FIXTURES=x,y. Load from subdirectory in test/fixtures using FIXTURES_DIR=z. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
-    task load: [:environment, :load_config] do
+    task load: :load_config do
       require "active_record/fixtures"
 
       base_dir = ActiveRecord::Tasks::DatabaseTasks.fixtures_path
@@ -221,7 +221,7 @@ db_namespace = namespace :db do
     end
 
     # desc "Search for a fixture given a LABEL or ID. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
-    task identify: [:environment, :load_config] do
+    task identify: :load_config do
       require "active_record/fixtures"
 
       label, id = ENV["LABEL"], ENV["ID"]
@@ -247,7 +247,7 @@ db_namespace = namespace :db do
 
   namespace :schema do
     desc "Creates a db/schema.rb file that is portable against any DB supported by Active Record"
-    task dump: [:environment, :load_config] do
+    task dump: :load_config do
       require "active_record/schema_dumper"
       filename = ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema.rb")
       File.open(filename, "w:utf-8") do |file|
@@ -257,7 +257,7 @@ db_namespace = namespace :db do
     end
 
     desc "Loads a schema.rb file into the database"
-    task load: [:environment, :load_config, :check_protected_environments] do
+    task load: [:load_config, :check_protected_environments] do
       ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:ruby, ENV["SCHEMA"])
     end
 
@@ -267,14 +267,14 @@ db_namespace = namespace :db do
 
     namespace :cache do
       desc "Creates a db/schema_cache.yml file."
-      task dump: [:environment, :load_config] do
+      task dump: :load_config do
         conn = ActiveRecord::Base.connection
         filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.yml")
         ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(conn, filename)
       end
 
       desc "Clears a db/schema_cache.yml file."
-      task clear: [:environment, :load_config] do
+      task clear: :load_config do
         filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.yml")
         rm_f filename, verbose: false
       end
@@ -284,7 +284,7 @@ db_namespace = namespace :db do
 
   namespace :structure do
     desc "Dumps the database structure to db/structure.sql. Specify another file with SCHEMA=db/my_structure.sql"
-    task dump: [:environment, :load_config] do
+    task dump: :load_config do
       filename = ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure.sql")
       current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
       ActiveRecord::Tasks::DatabaseTasks.structure_dump(current_config, filename)
@@ -299,7 +299,7 @@ db_namespace = namespace :db do
     end
 
     desc "Recreates the databases from the structure.sql file"
-    task load: [:environment, :load_config, :check_protected_environments] do
+    task load: [:load_config, :check_protected_environments] do
       ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:sql, ENV["SCHEMA"])
     end
 
@@ -338,12 +338,12 @@ db_namespace = namespace :db do
     end
 
     # desc "Empty the test database"
-    task purge: %w(environment load_config check_protected_environments) do
+    task purge: %w(load_config check_protected_environments) do
       ActiveRecord::Tasks::DatabaseTasks.purge ActiveRecord::Base.configurations["test"]
     end
 
     # desc 'Load the test schema'
-    task prepare: %w(environment load_config) do
+    task prepare: :load_config do
       unless ActiveRecord::Base.configurations.blank?
         db_namespace["test:load"].invoke
       end
diff --git a/activerecord/lib/active_record/railties/jdbcmysql_error.rb b/activerecord/lib/active_record/railties/jdbcmysql_error.rb
deleted file mode 100644
index 72c75ddd52..0000000000
--- a/activerecord/lib/active_record/railties/jdbcmysql_error.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-#FIXME Remove if ArJdbcMysql will give.
-module ArJdbcMySQL #:nodoc:
-  class Error < StandardError #:nodoc:
-    attr_accessor :error_number, :sql_state
-
-    def initialize(msg)
-      super
-      @error_number = nil
-      @sql_state    = nil
-    end
-
-    # Mysql gem compatibility
-    alias_method :errno, :error_number
-    alias_method :error, :message
-  end
-end
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index 7615fb6ee9..081ef5771f 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -36,67 +36,6 @@ module ActiveRecord
       reset
     end
 
-    def insert(values) # :nodoc:
-      primary_key_value = nil
-
-      if primary_key && Hash === values
-        primary_key_value = values[values.keys.find { |k|
-          k.name == primary_key
-        }]
-
-        if !primary_key_value && klass.prefetch_primary_key?
-          primary_key_value = klass.next_sequence_value
-          values[arel_attribute(klass.primary_key)] = primary_key_value
-        end
-      end
-
-      im = arel.create_insert
-      im.into @table
-
-      substitutes = substitute_values values
-
-      if values.empty? # empty insert
-        im.values = Arel.sql(connection.empty_insert_statement_value)
-      else
-        im.insert substitutes
-      end
-
-      @klass.connection.insert(
-        im,
-        "#{@klass} Create",
-        primary_key || false,
-        primary_key_value,
-        nil,
-      )
-    end
-
-    def _update_record(values, id, id_was) # :nodoc:
-      substitutes = substitute_values values
-
-      scope = @klass.unscoped
-
-      if @klass.finder_needs_type_condition?
-        scope.unscope!(where: @klass.inheritance_column)
-      end
-
-      relation = scope.where(@klass.primary_key => (id_was || id))
-      um = relation
-        .arel
-        .compile_update(substitutes, @klass.primary_key)
-
-      @klass.connection.update(
-        um,
-        "#{@klass} Update",
-      )
-    end
-
-    def substitute_values(values) # :nodoc:
-      values.map do |arel_attr, value|
-        bind = predicate_builder.build_bind_attribute(arel_attr.name, value)
-        [arel_attr, bind]
-      end
-    end
-
     def arel_attribute(name) # :nodoc:
       klass.arel_attribute(name, table)
     end
@@ -243,9 +182,10 @@ module ActiveRecord
     end
 
     # Converts relation objects to Array.
-    def to_a
+    def to_ary
       records.dup
     end
+    alias to_a to_ary
 
     def records # :nodoc:
       load
diff --git a/activerecord/lib/active_record/relation/calculations.rb b/activerecord/lib/active_record/relation/calculations.rb
index 11256ab3d9..d49472fc70 100644
--- a/activerecord/lib/active_record/relation/calculations.rb
+++ b/activerecord/lib/active_record/relation/calculations.rb
@@ -183,6 +183,7 @@ module ActiveRecord
         relation = apply_join_dependency
         relation.pluck(*column_names)
       else
+        enforce_raw_sql_whitelist(column_names)
         relation = spawn
         relation.select_values = column_names.map { |cn|
           @klass.has_attribute?(cn) || @klass.attribute_alias?(cn) ? arel_attribute(cn) : cn
diff --git a/activerecord/lib/active_record/relation/delegation.rb b/activerecord/lib/active_record/relation/delegation.rb
index 48af777b69..4863befec8 100644
--- a/activerecord/lib/active_record/relation/delegation.rb
+++ b/activerecord/lib/active_record/relation/delegation.rb
@@ -38,7 +38,7 @@ module ActiveRecord
     # may vary depending on the klass of a relation, so we create a subclass of Relation
     # for each different klass, and the delegations are compiled into that subclass only.
 
-    delegate :to_xml, :encode_with, :length, :each, :uniq, :to_ary, :join,
+    delegate :to_xml, :encode_with, :length, :each, :uniq, :join,
              :[], :&, :|, :+, :-, :sample, :reverse, :rotate, :compact, :in_groups, :in_groups_of,
              :to_sentence, :to_formatted_s, :as_json,
              :shuffle, :split, :slice, :index, :rindex, to: :records
diff --git a/activerecord/lib/active_record/relation/finder_methods.rb b/activerecord/lib/active_record/relation/finder_methods.rb
index 18566b5662..706fd57704 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -284,7 +284,7 @@ module ActiveRecord
     # * Hash - Finds the record that matches these +find+-style conditions
     #   (such as <tt>{name: 'David'}</tt>).
     # * +false+ - Returns always +false+.
-    # * No args - Returns +false+ if the table is empty, +true+ otherwise.
+    # * No args - Returns +false+ if the relation is empty, +true+ otherwise.
     #
     # For more information about specifying conditions as a hash or array,
     # see the Conditions section in the introduction to ActiveRecord::Base.
@@ -300,6 +300,7 @@ module ActiveRecord
     #   Person.exists?(name: 'David')
     #   Person.exists?(false)
     #   Person.exists?
+    #   Person.where(name: 'Spartacus', rating: 4).exists?
     def exists?(conditions = :none)
       if Base === conditions
         raise ArgumentError, <<-MSG.squish
diff --git a/activerecord/lib/active_record/relation/merger.rb b/activerecord/lib/active_record/relation/merger.rb
index ebc72d28fd..b736b21525 100644
--- a/activerecord/lib/active_record/relation/merger.rb
+++ b/activerecord/lib/active_record/relation/merger.rb
@@ -112,22 +112,20 @@ module ActiveRecord
           if other.klass == relation.klass
             relation.joins!(*other.joins_values)
           else
-            joins_dependency, rest = other.joins_values.partition do |join|
+            alias_tracker = nil
+            joins_dependency = other.joins_values.map do |join|
               case join
               when Hash, Symbol, Array
-                true
+                alias_tracker ||= other.alias_tracker
+                ActiveRecord::Associations::JoinDependency.new(
+                  other.klass, other.table, join, alias_tracker
+                )
               else
-                false
+                join
               end
             end
 
-            join_dependency = ActiveRecord::Associations::JoinDependency.new(
-              other.klass, other.table, joins_dependency, other.alias_tracker
-            )
-
-            relation.joins! rest
-
-            @relation = relation.joins join_dependency
+            relation.joins!(*joins_dependency)
           end
         end
 
diff --git a/activerecord/lib/active_record/relation/predicate_builder/relation_handler.rb b/activerecord/lib/active_record/relation/predicate_builder/relation_handler.rb
index f51ea4fde0..c8bbfa5051 100644
--- a/activerecord/lib/active_record/relation/predicate_builder/relation_handler.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder/relation_handler.rb
@@ -4,6 +4,10 @@ module ActiveRecord
   class PredicateBuilder
     class RelationHandler # :nodoc:
       def call(attribute, value)
+        if value.eager_loading?
+          value = value.send(:apply_join_dependency)
+        end
+
         if value.select_values.empty?
           value = value.select(value.arel_attribute(value.klass.primary_key))
         end
diff --git a/activerecord/lib/active_record/relation/query_attribute.rb b/activerecord/lib/active_record/relation/query_attribute.rb
index fad08e2613..3532f28858 100644
--- a/activerecord/lib/active_record/relation/query_attribute.rb
+++ b/activerecord/lib/active_record/relation/query_attribute.rb
@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require "active_record/attribute"
+require "active_model/attribute"
 
 module ActiveRecord
   class Relation
-    class QueryAttribute < Attribute # :nodoc:
+    class QueryAttribute < ActiveModel::Attribute # :nodoc:
       def type_cast(value)
         value
       end
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
index 897ff5c8af..749223422f 100644
--- a/activerecord/lib/active_record/relation/query_methods.rb
+++ b/activerecord/lib/active_record/relation/query_methods.rb
@@ -295,6 +295,7 @@ module ActiveRecord
       spawn.order!(*args)
     end
 
+    # Same as #order but operates on relation in-place instead of copying.
     def order!(*args) # :nodoc:
       preprocess_order_args(args)
 
@@ -316,6 +317,7 @@ module ActiveRecord
       spawn.reorder!(*args)
     end
 
+    # Same as #reorder but operates on relation in-place instead of copying.
     def reorder!(*args) # :nodoc:
       preprocess_order_args(args)
 
@@ -930,7 +932,7 @@ module ActiveRecord
         arel.where(where_clause.ast) unless where_clause.empty?
         arel.having(having_clause.ast) unless having_clause.empty?
         if limit_value
-          limit_attribute = Attribute.with_cast_value(
+          limit_attribute = ActiveModel::Attribute.with_cast_value(
             "LIMIT".freeze,
             connection.sanitize_limit(limit_value),
             Type.default_value,
@@ -938,7 +940,7 @@ module ActiveRecord
           arel.take(Arel::Nodes::BindParam.new(limit_attribute))
         end
         if offset_value
-          offset_attribute = Attribute.with_cast_value(
+          offset_attribute = ActiveModel::Attribute.with_cast_value(
             "OFFSET".freeze,
             offset_value.to_i,
             Type.default_value,
@@ -963,6 +965,9 @@ module ActiveRecord
         name = from_clause.name
         case opts
         when Relation
+          if opts.eager_loading?
+            opts = opts.send(:apply_join_dependency)
+          end
           name ||= "subquery"
           opts.arel.as(name.to_s)
         else
@@ -1035,6 +1040,8 @@ module ActiveRecord
       def build_select(arel)
         if select_values.any?
           arel.project(*arel_columns(select_values.uniq))
+        elsif @klass.ignored_columns.any?
+          arel.project(*arel_columns(@klass.column_names))
         else
           arel.project(table[Arel.star])
         end
@@ -1071,7 +1078,7 @@ module ActiveRecord
             end
             o.split(",").map! do |s|
               s.strip!
-              s.gsub!(/\sasc\Z/i, " DESC") || s.gsub!(/\sdesc\Z/i, " ASC") || s.concat(" DESC")
+              s.gsub!(/\sasc\Z/i, " DESC") || s.gsub!(/\sdesc\Z/i, " ASC") || (s << " DESC")
             end
           else
             o
@@ -1080,6 +1087,10 @@ module ActiveRecord
       end
 
       def does_not_support_reverse?(order)
+        # Account for String subclasses like Arel::Nodes::SqlLiteral that
+        # override methods like #count.
+        order = String.new(order) unless order.instance_of?(String)
+
         # Uses SQL function with multiple arguments.
         (order.include?(",") && order.split(",").find { |section| section.count("(") != section.count(")") }) ||
           # Uses "nulls first" like construction.
@@ -1113,6 +1124,12 @@ module ActiveRecord
           klass.send(:sanitize_sql_for_order, arg)
         end
         order_args.flatten!
+
+        @klass.enforce_raw_sql_whitelist(
+          order_args.flat_map { |a| a.is_a?(Hash) ? a.keys : a },
+          whitelist: AttributeMethods::ClassMethods::COLUMN_NAME_ORDER_WHITELIST
+        )
+
         validate_order_args(order_args)
 
         references = order_args.grep(String)
diff --git a/activerecord/lib/active_record/sanitization.rb b/activerecord/lib/active_record/sanitization.rb
index 1c3099f55c..21f8bc7cb2 100644
--- a/activerecord/lib/active_record/sanitization.rb
+++ b/activerecord/lib/active_record/sanitization.rb
@@ -63,7 +63,17 @@ module ActiveRecord
         #   # => "id ASC"
         def sanitize_sql_for_order(condition) # :doc:
           if condition.is_a?(Array) && condition.first.to_s.include?("?")
-            sanitize_sql_array(condition)
+            enforce_raw_sql_whitelist([condition.first],
+              whitelist: AttributeMethods::ClassMethods::COLUMN_NAME_ORDER_WHITELIST
+            )
+
+            # Ensure we aren't dealing with a subclass of String that might
+            # override methods we use (eg. Arel::Nodes::SqlLiteral).
+            if condition.first.kind_of?(String) && !condition.first.instance_of?(String)
+              condition = [String.new(condition.first), *condition[1..-1]]
+            end
+
+            Arel.sql(sanitize_sql_array(condition))
           else
             condition
           end
@@ -110,7 +120,8 @@ module ActiveRecord
         def sanitize_sql_hash_for_assignment(attrs, table) # :doc:
           c = connection
           attrs.map do |attr, value|
-            value = type_for_attribute(attr.to_s).serialize(value)
+            type = type_for_attribute(attr.to_s)
+            value = type.serialize(type.cast(value))
             "#{c.quote_table_name_for_assignment(table, attr)} = #{c.quote(value)}"
           end.join(", ")
         end
diff --git a/activerecord/lib/active_record/scoping/default.rb b/activerecord/lib/active_record/scoping/default.rb
index 86ae374318..8c612df27a 100644
--- a/activerecord/lib/active_record/scoping/default.rb
+++ b/activerecord/lib/active_record/scoping/default.rb
@@ -111,7 +111,7 @@ module ActiveRecord
               # The user has defined their own default scope method, so call that
               evaluate_default_scope do
                 if scope = default_scope
-                  (base_rel ||= relation).merge(scope)
+                  (base_rel ||= relation).merge!(scope)
                 end
               end
             elsif default_scopes.any?
@@ -119,7 +119,7 @@ module ActiveRecord
               evaluate_default_scope do
                 default_scopes.inject(base_rel) do |default_scope, scope|
                   scope = scope.respond_to?(:to_proc) ? scope : scope.method(:call)
-                  default_scope.merge(base_rel.instance_exec(&scope))
+                  default_scope.merge!(base_rel.instance_exec(&scope))
                 end
               end
             end
diff --git a/activerecord/lib/active_record/tasks/mysql_database_tasks.rb b/activerecord/lib/active_record/tasks/mysql_database_tasks.rb
index 2f91884f59..e697fa6def 100644
--- a/activerecord/lib/active_record/tasks/mysql_database_tasks.rb
+++ b/activerecord/lib/active_record/tasks/mysql_database_tasks.rb
@@ -3,8 +3,6 @@
 module ActiveRecord
   module Tasks # :nodoc:
     class MySQLDatabaseTasks # :nodoc:
-      ACCESS_DENIED_ERROR = 1045
-
       delegate :connection, :establish_connection, to: ActiveRecord::Base
 
       def initialize(configuration)
@@ -21,20 +19,6 @@ module ActiveRecord
         else
           raise
         end
-      rescue error_class => error
-        if error.respond_to?(:errno) && error.errno == ACCESS_DENIED_ERROR
-          $stdout.print error.message
-          establish_connection root_configuration_without_database
-          connection.create_database configuration["database"], creation_options
-          if configuration["username"] != "root"
-            connection.execute grant_statement.gsub(/\s+/, " ").strip
-          end
-          establish_connection configuration
-        else
-          $stderr.puts error.inspect
-          $stderr.puts "Couldn't create database for #{configuration.inspect}, #{creation_options.inspect}"
-          $stderr.puts "(If you set the charset manually, make sure you have a matching collation)" if configuration["encoding"]
-        end
       end
 
       def drop
@@ -99,37 +83,6 @@ module ActiveRecord
           end
         end
 
-        def error_class
-          if configuration["adapter"].include?("jdbc")
-            require "active_record/railties/jdbcmysql_error"
-            ArJdbcMySQL::Error
-          elsif defined?(Mysql2)
-            Mysql2::Error
-          else
-            StandardError
-          end
-        end
-
-        def grant_statement
-          <<-SQL
-GRANT ALL PRIVILEGES ON `#{configuration['database']}`.*
-  TO '#{configuration['username']}'@'localhost'
-IDENTIFIED BY '#{configuration['password']}' WITH GRANT OPTION;
-          SQL
-        end
-
-        def root_configuration_without_database
-          configuration_without_database.merge(
-            "username" => "root",
-            "password" => root_password
-          )
-        end
-
-        def root_password
-          $stdout.print "Please provide the root password for your MySQL installation\n>"
-          $stdin.gets.strip
-        end
-
         def prepare_command_options
           args = {
             "host"      => "--host",
diff --git a/activerecord/lib/rails/generators/active_record/application_record/templates/application_record.rb b/activerecord/lib/rails/generators/active_record/application_record/templates/application_record.rb.tt
index 60050e0bf8..60050e0bf8 100644
--- a/activerecord/lib/rails/generators/active_record/application_record/templates/application_record.rb
+++ b/activerecord/lib/rails/generators/active_record/application_record/templates/application_record.rb.tt
diff --git a/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb b/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb.tt
index 5f7201cfe1..5f7201cfe1 100644
--- a/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb
+++ b/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb.tt
diff --git a/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb b/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb.tt
index 481c70201b..481c70201b 100644
--- a/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb
+++ b/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb.tt
diff --git a/activerecord/lib/rails/generators/active_record/model/templates/model.rb b/activerecord/lib/rails/generators/active_record/model/templates/model.rb.tt
index 55dc65c8ad..55dc65c8ad 100644
--- a/activerecord/lib/rails/generators/active_record/model/templates/model.rb
+++ b/activerecord/lib/rails/generators/active_record/model/templates/model.rb.tt
diff --git a/activerecord/lib/rails/generators/active_record/model/templates/module.rb b/activerecord/lib/rails/generators/active_record/model/templates/module.rb.tt
index a3bf1c37b6..a3bf1c37b6 100644
--- a/activerecord/lib/rails/generators/active_record/model/templates/module.rb
+++ b/activerecord/lib/rails/generators/active_record/model/templates/module.rb.tt
diff --git a/activerecord/test/cases/adapters/mysql2/explain_test.rb b/activerecord/test/cases/adapters/mysql2/explain_test.rb
index 2736f7cf0e..b8e778f0b0 100644
--- a/activerecord/test/cases/adapters/mysql2/explain_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/explain_test.rb
@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
 require "cases/helper"
-require "models/developer"
-require "models/computer"
+require "models/author"
+require "models/post"
 
 class Mysql2ExplainTest < ActiveRecord::Mysql2TestCase
-  fixtures :developers
+  fixtures :authors
 
   def test_explain_for_one_query
-    explain = Developer.where(id: 1).explain
-    assert_match %(EXPLAIN for: SELECT `developers`.* FROM `developers` WHERE `developers`.`id` = 1), explain
-    assert_match %r(developers |.* const), explain
+    explain = Author.where(id: 1).explain
+    assert_match %(EXPLAIN for: SELECT `authors`.* FROM `authors` WHERE `authors`.`id` = 1), explain
+    assert_match %r(authors |.* const), explain
   end
 
   def test_explain_with_eager_loading
-    explain = Developer.where(id: 1).includes(:audit_logs).explain
-    assert_match %(EXPLAIN for: SELECT `developers`.* FROM `developers` WHERE `developers`.`id` = 1), explain
-    assert_match %r(developers |.* const), explain
-    assert_match %(EXPLAIN for: SELECT `audit_logs`.* FROM `audit_logs` WHERE `audit_logs`.`developer_id` = 1), explain
-    assert_match %r(audit_logs |.* ALL), explain
+    explain = Author.where(id: 1).includes(:posts).explain
+    assert_match %(EXPLAIN for: SELECT `authors`.* FROM `authors` WHERE `authors`.`id` = 1), explain
+    assert_match %r(authors |.* const), explain
+    assert_match %(EXPLAIN for: SELECT `posts`.* FROM `posts` WHERE `posts`.`author_id` = 1), explain
+    assert_match %r(posts |.* ALL), explain
   end
 end
diff --git a/activerecord/test/cases/adapters/mysql2/transaction_test.rb b/activerecord/test/cases/adapters/mysql2/transaction_test.rb
index 25d9f69a89..4a3a4503de 100644
--- a/activerecord/test/cases/adapters/mysql2/transaction_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/transaction_test.rb
@@ -60,9 +60,60 @@ module ActiveRecord
       end
     end
 
-    test "raises TransactionTimeout when mysql raises ER_LOCK_WAIT_TIMEOUT" do
+    test "raises TransactionTimeout when lock wait timeout exceeded" do
       assert_raises(ActiveRecord::TransactionTimeout) do
-        ActiveRecord::Base.connection.execute("SIGNAL SQLSTATE 'HY000' SET MESSAGE_TEXT = 'Testing error', MYSQL_ERRNO = 1205;")
+        s = Sample.create!(value: 1)
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch1.count_down
+            latch2.wait
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch1.wait
+            Sample.connection.execute("SET innodb_lock_wait_timeout = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.connection.execute("SET innodb_lock_wait_timeout = DEFAULT")
+          latch2.count_down
+          thread.join
+        end
+      end
+    end
+
+    test "raises StatementTimeout when statement timeout exceeded" do
+      skip unless ActiveRecord::Base.connection.show_variable("max_execution_time")
+      assert_raises(ActiveRecord::StatementTimeout) do
+        s = Sample.create!(value: 1)
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch1.count_down
+            latch2.wait
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch1.wait
+            Sample.connection.execute("SET max_execution_time = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.connection.execute("SET max_execution_time = DEFAULT")
+          latch2.count_down
+          thread.join
+        end
       end
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/explain_test.rb b/activerecord/test/cases/adapters/postgresql/explain_test.rb
index 16fec94ede..be525383e9 100644
--- a/activerecord/test/cases/adapters/postgresql/explain_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/explain_test.rb
@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
 require "cases/helper"
-require "models/developer"
-require "models/computer"
+require "models/author"
+require "models/post"
 
 class PostgreSQLExplainTest < ActiveRecord::PostgreSQLTestCase
-  fixtures :developers
+  fixtures :authors
 
   def test_explain_for_one_query
-    explain = Developer.where(id: 1).explain
-    assert_match %r(EXPLAIN for: SELECT "developers"\.\* FROM "developers" WHERE "developers"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    explain = Author.where(id: 1).explain
+    assert_match %r(EXPLAIN for: SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
     assert_match %(QUERY PLAN), explain
   end
 
   def test_explain_with_eager_loading
-    explain = Developer.where(id: 1).includes(:audit_logs).explain
+    explain = Author.where(id: 1).includes(:posts).explain
     assert_match %(QUERY PLAN), explain
-    assert_match %r(EXPLAIN for: SELECT "developers"\.\* FROM "developers" WHERE "developers"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
-    assert_match %r(EXPLAIN for: SELECT "audit_logs"\.\* FROM "audit_logs" WHERE "audit_logs"\."developer_id" = (?:\$1 \[\["developer_id", 1\]\]|1)), explain
+    assert_match %r(EXPLAIN for: SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    assert_match %r(EXPLAIN for: SELECT "posts"\.\* FROM "posts" WHERE "posts"\."author_id" = (?:\$1 \[\["author_id", 1\]\]|1)), explain
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/transaction_test.rb b/activerecord/test/cases/adapters/postgresql/transaction_test.rb
index f56adf4a5e..4d63bbce59 100644
--- a/activerecord/test/cases/adapters/postgresql/transaction_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/transaction_test.rb
@@ -91,6 +91,63 @@ module ActiveRecord
       end
     end
 
+    test "raises TransactionTimeout when lock wait timeout exceeded" do
+      skip unless ActiveRecord::Base.connection.postgresql_version >= 90300
+      assert_raises(ActiveRecord::TransactionTimeout) do
+        s = Sample.create!(value: 1)
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch1.count_down
+            latch2.wait
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch1.wait
+            Sample.connection.execute("SET lock_timeout = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.connection.execute("SET lock_timeout = DEFAULT")
+          latch2.count_down
+          thread.join
+        end
+      end
+    end
+
+    test "raises StatementTimeout when statement timeout exceeded" do
+      assert_raises(ActiveRecord::StatementTimeout) do
+        s = Sample.create!(value: 1)
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch1.count_down
+            latch2.wait
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch1.wait
+            Sample.connection.execute("SET statement_timeout = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.connection.execute("SET statement_timeout = DEFAULT")
+          latch2.count_down
+          thread.join
+        end
+      end
+    end
+
     private
 
       def with_warning_suppression
diff --git a/activerecord/test/cases/adapters/sqlite3/explain_test.rb b/activerecord/test/cases/adapters/sqlite3/explain_test.rb
index 3b081d34e1..b6d2ccdb53 100644
--- a/activerecord/test/cases/adapters/sqlite3/explain_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/explain_test.rb
@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
 require "cases/helper"
-require "models/developer"
-require "models/computer"
+require "models/author"
+require "models/post"
 
 class SQLite3ExplainTest < ActiveRecord::SQLite3TestCase
-  fixtures :developers
+  fixtures :authors
 
   def test_explain_for_one_query
-    explain = Developer.where(id: 1).explain
-    assert_match %r(EXPLAIN for: SELECT "developers"\.\* FROM "developers" WHERE "developers"\."id" = (?:\? \[\["id", 1\]\]|1)), explain
-    assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
+    explain = Author.where(id: 1).explain
+    assert_match %r(EXPLAIN for: SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\? \[\["id", 1\]\]|1)), explain
+    assert_match(/(SEARCH )?TABLE authors USING (INTEGER )?PRIMARY KEY/, explain)
   end
 
   def test_explain_with_eager_loading
-    explain = Developer.where(id: 1).includes(:audit_logs).explain
-    assert_match %r(EXPLAIN for: SELECT "developers"\.\* FROM "developers" WHERE "developers"\."id" = (?:\? \[\["id", 1\]\]|1)), explain
-    assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
-    assert_match %r(EXPLAIN for: SELECT "audit_logs"\.\* FROM "audit_logs" WHERE "audit_logs"\."developer_id" = (?:\? \[\["developer_id", 1\]\]|1)), explain
-    assert_match(/(SCAN )?TABLE audit_logs/, explain)
+    explain = Author.where(id: 1).includes(:posts).explain
+    assert_match %r(EXPLAIN for: SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\? \[\["id", 1\]\]|1)), explain
+    assert_match(/(SEARCH )?TABLE authors USING (INTEGER )?PRIMARY KEY/, explain)
+    assert_match %r(EXPLAIN for: SELECT "posts"\.\* FROM "posts" WHERE "posts"\."author_id" = (?:\? \[\["author_id", 1\]\]|1)), explain
+    assert_match(/(SCAN )?TABLE posts/, explain)
   end
 end
diff --git a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
index e69cfe5e52..829e12fbc8 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -37,7 +37,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
 
   def test_eager_association_loading_with_hmt_does_not_table_name_collide_when_joining_associations
     authors = Author.joins(:posts).eager_load(:comments).where(posts: { tags_count: 1 }).to_a
-    assert_equal 1, assert_no_queries { authors.size }
+    assert_equal 3, assert_no_queries { authors.size }
     assert_equal 10, assert_no_queries { authors[0].comments.size }
   end
 
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 9afe6a893c..9a042c74db 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -427,7 +427,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_association_loading_with_belongs_to_and_order_string_with_quoted_table_name
     quoted_posts_id = Comment.connection.quote_table_name("posts") + "." + Comment.connection.quote_column_name("id")
     assert_nothing_raised do
-      Comment.includes(:post).references(:posts).order(quoted_posts_id)
+      Comment.includes(:post).references(:posts).order(Arel.sql(quoted_posts_id))
     end
   end
 
@@ -874,14 +874,14 @@ class EagerAssociationTest < ActiveRecord::TestCase
       posts(:thinking, :sti_comments),
       Post.all.merge!(
         includes: [:author, :comments], where: { "authors.name" => "David" },
-        order: "UPPER(posts.title)", limit: 2, offset: 1
+        order: Arel.sql("UPPER(posts.title)"), limit: 2, offset: 1
       ).to_a
     )
     assert_equal(
       posts(:sti_post_and_comments, :sti_comments),
       Post.all.merge!(
         includes: [:author, :comments], where: { "authors.name" => "David" },
-        order: "UPPER(posts.title) DESC", limit: 2, offset: 1
+        order: Arel.sql("UPPER(posts.title) DESC"), limit: 2, offset: 1
       ).to_a
     )
   end
@@ -891,14 +891,14 @@ class EagerAssociationTest < ActiveRecord::TestCase
       posts(:thinking, :sti_comments),
       Post.all.merge!(
         includes: [:author, :comments], where: { "authors.name" => "David" },
-        order: ["UPPER(posts.title)", "posts.id"], limit: 2, offset: 1
+        order: [Arel.sql("UPPER(posts.title)"), "posts.id"], limit: 2, offset: 1
       ).to_a
     )
     assert_equal(
       posts(:sti_post_and_comments, :sti_comments),
       Post.all.merge!(
         includes: [:author, :comments], where: { "authors.name" => "David" },
-        order: ["UPPER(posts.title) DESC", "posts.id"], limit: 2, offset: 1
+        order: [Arel.sql("UPPER(posts.title) DESC"), "posts.id"], limit: 2, offset: 1
       ).to_a
     )
   end
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 6bd11a5d81..4ca11af791 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -831,7 +831,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_scoped_grouped_having
-    assert_equal 1, authors(:david).popular_grouped_posts.length
+    assert_equal 2, authors(:david).popular_grouped_posts.length
     assert_equal 0, authors(:mary).popular_grouped_posts.length
   end
 
diff --git a/activerecord/test/cases/attribute_set_test.rb b/activerecord/test/cases/attribute_set_test.rb
deleted file mode 100644
index 8be77ed88f..0000000000
--- a/activerecord/test/cases/attribute_set_test.rb
+++ /dev/null
@@ -1,255 +0,0 @@
-# frozen_string_literal: true
-
-require "cases/helper"
-
-module ActiveRecord
-  class AttributeSetTest < ActiveRecord::TestCase
-    test "building a new set from raw attributes" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
-
-      assert_equal 1, attributes[:foo].value
-      assert_equal 2.2, attributes[:bar].value
-      assert_equal :foo, attributes[:foo].name
-      assert_equal :bar, attributes[:bar].name
-    end
-
-    test "building with custom types" do
-      builder = AttributeSet::Builder.new(foo: Type::Float.new)
-      attributes = builder.build_from_database({ foo: "3.3", bar: "4.4" }, { bar: Type::Integer.new })
-
-      assert_equal 3.3, attributes[:foo].value
-      assert_equal 4, attributes[:bar].value
-    end
-
-    test "[] returns a null object" do
-      builder = AttributeSet::Builder.new(foo: Type::Float.new)
-      attributes = builder.build_from_database(foo: "3.3")
-
-      assert_equal "3.3", attributes[:foo].value_before_type_cast
-      assert_nil attributes[:bar].value_before_type_cast
-      assert_equal :bar, attributes[:bar].name
-    end
-
-    test "duping creates a new hash, but does not dup the attributes" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::String.new)
-      attributes = builder.build_from_database(foo: 1, bar: "foo")
-
-      # Ensure the type cast value is cached
-      attributes[:foo].value
-      attributes[:bar].value
-
-      duped = attributes.dup
-      duped.write_from_database(:foo, 2)
-      duped[:bar].value << "bar"
-
-      assert_equal 1, attributes[:foo].value
-      assert_equal 2, duped[:foo].value
-      assert_equal "foobar", attributes[:bar].value
-      assert_equal "foobar", duped[:bar].value
-    end
-
-    test "deep_duping creates a new hash and dups each attribute" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::String.new)
-      attributes = builder.build_from_database(foo: 1, bar: "foo")
-
-      # Ensure the type cast value is cached
-      attributes[:foo].value
-      attributes[:bar].value
-
-      duped = attributes.deep_dup
-      duped.write_from_database(:foo, 2)
-      duped[:bar].value << "bar"
-
-      assert_equal 1, attributes[:foo].value
-      assert_equal 2, duped[:foo].value
-      assert_equal "foo", attributes[:bar].value
-      assert_equal "foobar", duped[:bar].value
-    end
-
-    test "freezing cloned set does not freeze original" do
-      attributes = AttributeSet.new({})
-      clone = attributes.clone
-
-      clone.freeze
-
-      assert clone.frozen?
-      assert_not attributes.frozen?
-    end
-
-    test "to_hash returns a hash of the type cast values" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
-
-      assert_equal({ foo: 1, bar: 2.2 }, attributes.to_hash)
-      assert_equal({ foo: 1, bar: 2.2 }, attributes.to_h)
-    end
-
-    test "to_hash maintains order" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: "2.2", bar: "3.3")
-
-      attributes[:bar]
-      hash = attributes.to_h
-
-      assert_equal [[:foo, 2], [:bar, 3.3]], hash.to_a
-    end
-
-    test "values_before_type_cast" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
-      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
-
-      assert_equal({ foo: "1.1", bar: "2.2" }, attributes.values_before_type_cast)
-    end
-
-    test "known columns are built with uninitialized attributes" do
-      attributes = attributes_with_uninitialized_key
-      assert attributes[:foo].initialized?
-      assert_not attributes[:bar].initialized?
-    end
-
-    test "uninitialized attributes are not included in the attributes hash" do
-      attributes = attributes_with_uninitialized_key
-      assert_equal({ foo: 1 }, attributes.to_hash)
-    end
-
-    test "uninitialized attributes are not included in keys" do
-      attributes = attributes_with_uninitialized_key
-      assert_equal [:foo], attributes.keys
-    end
-
-    test "uninitialized attributes return false for key?" do
-      attributes = attributes_with_uninitialized_key
-      assert attributes.key?(:foo)
-      assert_not attributes.key?(:bar)
-    end
-
-    test "unknown attributes return false for key?" do
-      attributes = attributes_with_uninitialized_key
-      assert_not attributes.key?(:wibble)
-    end
-
-    test "fetch_value returns the value for the given initialized attribute" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
-
-      assert_equal 1, attributes.fetch_value(:foo)
-      assert_equal 2.2, attributes.fetch_value(:bar)
-    end
-
-    test "fetch_value returns nil for unknown attributes" do
-      attributes = attributes_with_uninitialized_key
-      assert_nil attributes.fetch_value(:wibble) { "hello" }
-    end
-
-    test "fetch_value returns nil for unknown attributes when types has a default" do
-      types = Hash.new(Type::Value.new)
-      builder = AttributeSet::Builder.new(types)
-      attributes = builder.build_from_database
-
-      assert_nil attributes.fetch_value(:wibble) { "hello" }
-    end
-
-    test "fetch_value uses the given block for uninitialized attributes" do
-      attributes = attributes_with_uninitialized_key
-      value = attributes.fetch_value(:bar) { |n| n.to_s + "!" }
-      assert_equal "bar!", value
-    end
-
-    test "fetch_value returns nil for uninitialized attributes if no block is given" do
-      attributes = attributes_with_uninitialized_key
-      assert_nil attributes.fetch_value(:bar)
-    end
-
-    test "the primary_key is always initialized" do
-      builder = AttributeSet::Builder.new({ foo: Type::Integer.new }, :foo)
-      attributes = builder.build_from_database
-
-      assert attributes.key?(:foo)
-      assert_equal [:foo], attributes.keys
-      assert attributes[:foo].initialized?
-    end
-
-    class MyType
-      def cast(value)
-        return if value.nil?
-        value + " from user"
-      end
-
-      def deserialize(value)
-        return if value.nil?
-        value + " from database"
-      end
-
-      def assert_valid_value(*)
-      end
-    end
-
-    test "write_from_database sets the attribute with database typecasting" do
-      builder = AttributeSet::Builder.new(foo: MyType.new)
-      attributes = builder.build_from_database
-
-      assert_nil attributes.fetch_value(:foo)
-
-      attributes.write_from_database(:foo, "value")
-
-      assert_equal "value from database", attributes.fetch_value(:foo)
-    end
-
-    test "write_from_user sets the attribute with user typecasting" do
-      builder = AttributeSet::Builder.new(foo: MyType.new)
-      attributes = builder.build_from_database
-
-      assert_nil attributes.fetch_value(:foo)
-
-      attributes.write_from_user(:foo, "value")
-
-      assert_equal "value from user", attributes.fetch_value(:foo)
-    end
-
-    def attributes_with_uninitialized_key
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      builder.build_from_database(foo: "1.1")
-    end
-
-    test "freezing doesn't prevent the set from materializing" do
-      builder = AttributeSet::Builder.new(foo: Type::String.new)
-      attributes = builder.build_from_database(foo: "1")
-
-      attributes.freeze
-      assert_equal({ foo: "1" }, attributes.to_hash)
-    end
-
-    test "#accessed_attributes returns only attributes which have been read" do
-      builder = AttributeSet::Builder.new(foo: Type::Value.new, bar: Type::Value.new)
-      attributes = builder.build_from_database(foo: "1", bar: "2")
-
-      assert_equal [], attributes.accessed
-
-      attributes.fetch_value(:foo)
-
-      assert_equal [:foo], attributes.accessed
-    end
-
-    test "#map returns a new attribute set with the changes applied" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
-      attributes = builder.build_from_database(foo: "1", bar: "2")
-      new_attributes = attributes.map do |attr|
-        attr.with_cast_value(attr.value + 1)
-      end
-
-      assert_equal 2, new_attributes.fetch_value(:foo)
-      assert_equal 3, new_attributes.fetch_value(:bar)
-    end
-
-    test "comparison for equality is correctly implemented" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
-      attributes = builder.build_from_database(foo: "1", bar: "2")
-      attributes2 = builder.build_from_database(foo: "1", bar: "2")
-      attributes3 = builder.build_from_database(foo: "2", bar: "2")
-
-      assert_equal attributes, attributes2
-      assert_not_equal attributes2, attributes3
-    end
-  end
-end
diff --git a/activerecord/test/cases/attribute_test.rb b/activerecord/test/cases/attribute_test.rb
deleted file mode 100644
index 1731e7926e..0000000000
--- a/activerecord/test/cases/attribute_test.rb
+++ /dev/null
@@ -1,255 +0,0 @@
-# frozen_string_literal: true
-
-require "cases/helper"
-
-module ActiveRecord
-  class AttributeTest < ActiveRecord::TestCase
-    setup do
-      @type = Minitest::Mock.new
-    end
-
-    teardown do
-      assert @type.verify
-    end
-
-    test "from_database + read type casts from database" do
-      @type.expect(:deserialize, "type cast from database", ["a value"])
-      attribute = Attribute.from_database(nil, "a value", @type)
-
-      type_cast_value = attribute.value
-
-      assert_equal "type cast from database", type_cast_value
-    end
-
-    test "from_user + read type casts from user" do
-      @type.expect(:cast, "type cast from user", ["a value"])
-      attribute = Attribute.from_user(nil, "a value", @type)
-
-      type_cast_value = attribute.value
-
-      assert_equal "type cast from user", type_cast_value
-    end
-
-    test "reading memoizes the value" do
-      @type.expect(:deserialize, "from the database", ["whatever"])
-      attribute = Attribute.from_database(nil, "whatever", @type)
-
-      type_cast_value = attribute.value
-      second_read = attribute.value
-
-      assert_equal "from the database", type_cast_value
-      assert_same type_cast_value, second_read
-    end
-
-    test "reading memoizes falsy values" do
-      @type.expect(:deserialize, false, ["whatever"])
-      attribute = Attribute.from_database(nil, "whatever", @type)
-
-      attribute.value
-      attribute.value
-    end
-
-    test "read_before_typecast returns the given value" do
-      attribute = Attribute.from_database(nil, "raw value", @type)
-
-      raw_value = attribute.value_before_type_cast
-
-      assert_equal "raw value", raw_value
-    end
-
-    test "from_database + read_for_database type casts to and from database" do
-      @type.expect(:deserialize, "read from database", ["whatever"])
-      @type.expect(:serialize, "ready for database", ["read from database"])
-      attribute = Attribute.from_database(nil, "whatever", @type)
-
-      serialize = attribute.value_for_database
-
-      assert_equal "ready for database", serialize
-    end
-
-    test "from_user + read_for_database type casts from the user to the database" do
-      @type.expect(:cast, "read from user", ["whatever"])
-      @type.expect(:serialize, "ready for database", ["read from user"])
-      attribute = Attribute.from_user(nil, "whatever", @type)
-
-      serialize = attribute.value_for_database
-
-      assert_equal "ready for database", serialize
-    end
-
-    test "duping dups the value" do
-      @type.expect(:deserialize, "type cast".dup, ["a value"])
-      attribute = Attribute.from_database(nil, "a value", @type)
-
-      value_from_orig = attribute.value
-      value_from_clone = attribute.dup.value
-      value_from_orig << " foo"
-
-      assert_equal "type cast foo", value_from_orig
-      assert_equal "type cast", value_from_clone
-    end
-
-    test "duping does not dup the value if it is not dupable" do
-      @type.expect(:deserialize, false, ["a value"])
-      attribute = Attribute.from_database(nil, "a value", @type)
-
-      assert_same attribute.value, attribute.dup.value
-    end
-
-    test "duping does not eagerly type cast if we have not yet type cast" do
-      attribute = Attribute.from_database(nil, "a value", @type)
-      attribute.dup
-    end
-
-    class MyType
-      def cast(value)
-        value + " from user"
-      end
-
-      def deserialize(value)
-        value + " from database"
-      end
-
-      def assert_valid_value(*)
-      end
-    end
-
-    test "with_value_from_user returns a new attribute with the value from the user" do
-      old = Attribute.from_database(nil, "old", MyType.new)
-      new = old.with_value_from_user("new")
-
-      assert_equal "old from database", old.value
-      assert_equal "new from user", new.value
-    end
-
-    test "with_value_from_database returns a new attribute with the value from the database" do
-      old = Attribute.from_user(nil, "old", MyType.new)
-      new = old.with_value_from_database("new")
-
-      assert_equal "old from user", old.value
-      assert_equal "new from database", new.value
-    end
-
-    test "uninitialized attributes yield their name if a block is given to value" do
-      block = proc { |name| name.to_s + "!" }
-      foo = Attribute.uninitialized(:foo, nil)
-      bar = Attribute.uninitialized(:bar, nil)
-
-      assert_equal "foo!", foo.value(&block)
-      assert_equal "bar!", bar.value(&block)
-    end
-
-    test "uninitialized attributes have no value" do
-      assert_nil Attribute.uninitialized(:foo, nil).value
-    end
-
-    test "attributes equal other attributes with the same constructor arguments" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_database(:foo, 1, Type::Integer.new)
-      assert_equal first, second
-    end
-
-    test "attributes do not equal attributes with different names" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_database(:bar, 1, Type::Integer.new)
-      assert_not_equal first, second
-    end
-
-    test "attributes do not equal attributes with different types" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_database(:foo, 1, Type::Float.new)
-      assert_not_equal first, second
-    end
-
-    test "attributes do not equal attributes with different values" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_database(:foo, 2, Type::Integer.new)
-      assert_not_equal first, second
-    end
-
-    test "attributes do not equal attributes of other classes" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_user(:foo, 1, Type::Integer.new)
-      assert_not_equal first, second
-    end
-
-    test "an attribute has not been read by default" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-      assert_not attribute.has_been_read?
-    end
-
-    test "an attribute has been read when its value is calculated" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-      attribute.value
-      assert attribute.has_been_read?
-    end
-
-    test "an attribute is not changed if it hasn't been assigned or mutated" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-
-      refute attribute.changed?
-    end
-
-    test "an attribute is changed if it's been assigned a new value" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-      changed = attribute.with_value_from_user(2)
-
-      assert changed.changed?
-    end
-
-    test "an attribute is not changed if it's assigned the same value" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-      unchanged = attribute.with_value_from_user(1)
-
-      refute unchanged.changed?
-    end
-
-    test "an attribute can not be mutated if it has not been read,
-      and skips expensive calculations" do
-      type_which_raises_from_all_methods = Object.new
-      attribute = Attribute.from_database(:foo, "bar", type_which_raises_from_all_methods)
-
-      assert_not attribute.changed_in_place?
-    end
-
-    test "an attribute is changed if it has been mutated" do
-      attribute = Attribute.from_database(:foo, "bar", Type::String.new)
-      attribute.value << "!"
-
-      assert attribute.changed_in_place?
-      assert attribute.changed?
-    end
-
-    test "an attribute can forget its changes" do
-      attribute = Attribute.from_database(:foo, "bar", Type::String.new)
-      changed = attribute.with_value_from_user("foo")
-      forgotten = changed.forgetting_assignment
-
-      assert changed.changed? # sanity check
-      refute forgotten.changed?
-    end
-
-    test "with_value_from_user validates the value" do
-      type = Type::Value.new
-      type.define_singleton_method(:assert_valid_value) do |value|
-        if value == 1
-          raise ArgumentError
-        end
-      end
-
-      attribute = Attribute.from_database(:foo, 1, type)
-      assert_equal 1, attribute.value
-      assert_equal 2, attribute.with_value_from_user(2).value
-      assert_raises ArgumentError do
-        attribute.with_value_from_user(1)
-      end
-    end
-
-    test "with_type preserves mutations" do
-      attribute = Attribute.from_database(:foo, "".dup, Type::Value.new)
-      attribute.value << "1"
-
-      assert_equal 1, attribute.with_type(Type::Integer.new).value
-    end
-  end
-end
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index f0ef522515..d79afa2ee9 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -1476,4 +1476,25 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal(%w(first_name last_name), Developer.ignored_columns)
     assert_equal(%w(first_name last_name), SymbolIgnoredDeveloper.ignored_columns)
   end
+
+  test "when #reload called, ignored columns' attribute methods are not defined" do
+    developer = Developer.create!(name: "Developer")
+    refute developer.respond_to?(:first_name)
+    refute developer.respond_to?(:first_name=)
+
+    developer.reload
+
+    refute developer.respond_to?(:first_name)
+    refute developer.respond_to?(:first_name=)
+  end
+
+  test "ignored columns not included in SELECT" do
+    query = Developer.all.to_sql.downcase
+
+    # ignored column
+    refute query.include?("first_name")
+
+    # regular column
+    assert query.include?("name")
+  end
 end
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index 66bc14b5ab..55b50e4f84 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -663,14 +663,14 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_pluck_with_selection_clause
-    assert_equal [50, 53, 55, 60], Account.pluck("DISTINCT credit_limit").sort
-    assert_equal [50, 53, 55, 60], Account.pluck("DISTINCT accounts.credit_limit").sort
-    assert_equal [50, 53, 55, 60], Account.pluck("DISTINCT(credit_limit)").sort
+    assert_equal [50, 53, 55, 60], Account.pluck(Arel.sql("DISTINCT credit_limit")).sort
+    assert_equal [50, 53, 55, 60], Account.pluck(Arel.sql("DISTINCT accounts.credit_limit")).sort
+    assert_equal [50, 53, 55, 60], Account.pluck(Arel.sql("DISTINCT(credit_limit)")).sort
 
     # MySQL returns "SUM(DISTINCT(credit_limit))" as the column name unless
     # an alias is provided.  Without the alias, the column cannot be found
     # and properly typecast.
-    assert_equal [50 + 53 + 55 + 60], Account.pluck("SUM(DISTINCT(credit_limit)) as credit_limit")
+    assert_equal [50 + 53 + 55 + 60], Account.pluck(Arel.sql("SUM(DISTINCT(credit_limit)) as credit_limit"))
   end
 
   def test_plucks_with_ids
@@ -772,7 +772,7 @@ class CalculationsTest < ActiveRecord::TestCase
     companies = Company.order(:name).limit(3).load
 
     assert_queries 1 do
-      assert_equal ["37signals", "Apex", "Ex Nihilo"], companies.pluck("DISTINCT name")
+      assert_equal ["37signals", "Apex", "Ex Nihilo"], companies.pluck(Arel.sql("DISTINCT name"))
     end
   end
 
diff --git a/activerecord/test/cases/connection_pool_test.rb b/activerecord/test/cases/connection_pool_test.rb
index 2bfe490602..cb2fefb4f6 100644
--- a/activerecord/test/cases/connection_pool_test.rb
+++ b/activerecord/test/cases/connection_pool_test.rb
@@ -205,6 +205,14 @@ module ActiveRecord
         end.join
       end
 
+      def test_checkout_order_is_lifo
+        conn1 = @pool.checkout
+        conn2 = @pool.checkout
+        @pool.checkin conn1
+        @pool.checkin conn2
+        assert_equal [conn2, conn1], 2.times.map { @pool.checkout }
+      end
+
       # The connection pool is "fair" if threads waiting for
       # connections receive them in the order in which they began
       # waiting.  This ensures that we don't timeout one HTTP request
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index d8bc917e7f..1268949ba9 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -239,7 +239,7 @@ class FinderTest < ActiveRecord::TestCase
 
   # Ensure +exists?+ runs without an error by excluding order value.
   def test_exists_with_order
-    assert_equal true, Topic.order("invalid sql here").exists?
+    assert_equal true, Topic.order(Arel.sql("invalid sql here")).exists?
   end
 
   def test_exists_with_joins
@@ -652,7 +652,7 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_last_with_irreversible_order
     assert_raises(ActiveRecord::IrreversibleOrderError) do
-      Topic.order("coalesce(author_name, title)").last
+      Topic.order(Arel.sql("coalesce(author_name, title)")).last
     end
   end
 
diff --git a/activerecord/test/cases/invertible_migration_test.rb b/activerecord/test/cases/invertible_migration_test.rb
index 60c628511f..ebe0b0aa87 100644
--- a/activerecord/test/cases/invertible_migration_test.rb
+++ b/activerecord/test/cases/invertible_migration_test.rb
@@ -161,6 +161,15 @@ module ActiveRecord
       end
     end
 
+    class UpOnlyMigration < SilentMigration
+      def change
+        add_column :horses, :oldie, :integer, default: 0
+        up_only { execute "update horses set oldie = 1" }
+      end
+    end
+
+    self.use_transactional_tests = false
+
     setup do
       @verbose_was, ActiveRecord::Migration.verbose = ActiveRecord::Migration.verbose, false
     end
@@ -378,5 +387,23 @@ module ActiveRecord
               "horses_index_named index should not exist"
       end
     end
+
+    def test_up_only
+      InvertibleMigration.new.migrate(:up)
+      horse1 = Horse.create
+      # populates existing horses with oldie = 1 but new ones have default 0
+      UpOnlyMigration.new.migrate(:up)
+      Horse.reset_column_information
+      horse1.reload
+      horse2 = Horse.create
+
+      assert 1, horse1.oldie # created before migration
+      assert 0, horse2.oldie # created after migration
+
+      UpOnlyMigration.new.migrate(:down) # should be no error
+      connection = ActiveRecord::Base.connection
+      assert !connection.column_exists?(:horses, :oldie)
+      Horse.reset_column_information
+    end
   end
 end
diff --git a/activerecord/test/cases/query_cache_test.rb b/activerecord/test/cases/query_cache_test.rb
index 5cb537b623..46f90b0bca 100644
--- a/activerecord/test/cases/query_cache_test.rb
+++ b/activerecord/test/cases/query_cache_test.rb
@@ -452,6 +452,15 @@ class QueryCacheTest < ActiveRecord::TestCase
     end
   end
 
+  def test_query_cache_is_enabled_on_all_connection_pools
+    middleware {
+      ActiveRecord::Base.connection_handler.connection_pool_list.each do |pool|
+        assert pool.query_cache_enabled
+        assert pool.connection.query_cache_enabled
+      end
+    }.call({})
+  end
+
   private
     def middleware(&app)
       executor = Class.new(ActiveSupport::Executor)
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index fd5985ffe7..a71d8de521 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -274,18 +274,32 @@ module ActiveRecord
       assert_equal({ 2 => 1, 4 => 3, 5 => 1 }, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count)
     end
 
+    def test_relation_merging_keeps_joining_order
+      authors  = Author.where(id: 1)
+      posts    = Post.joins(:author).merge(authors)
+      comments = Comment.joins(:post).merge(posts)
+      ratings  = Rating.joins(:comment).merge(comments)
+
+      assert_equal 3, ratings.count
+    end
+
     class EnsureRoundTripTypeCasting < ActiveRecord::Type::Value
       def type
         :string
       end
 
+      def cast(value)
+        raise value unless value == "value from user"
+        "cast value"
+      end
+
       def deserialize(value)
         raise value unless value == "type cast for database"
         "type cast from database"
       end
 
       def serialize(value)
-        raise value unless value == "value from user"
+        raise value unless value == "cast value"
         "type cast for database"
       end
     end
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 72433d1e8e..50ad1d5b26 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -195,6 +195,18 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal(relation.map(&:post_count).sort, subquery.values.sort)
   end
 
+  def test_finding_with_subquery_with_eager_loading_in_from
+    relation = Comment.includes(:post).where("posts.type": "Post")
+    assert_equal relation.to_a, Comment.select("*").from(relation).to_a
+    assert_equal relation.to_a, Comment.select("subquery.*").from(relation).to_a
+    assert_equal relation.to_a, Comment.select("a.*").from(relation, :a).to_a
+  end
+
+  def test_finding_with_subquery_with_eager_loading_in_where
+    relation = Comment.includes(:post).where("posts.type": "Post")
+    assert_equal relation.sort_by(&:id), Comment.where(id: relation).sort_by(&:id)
+  end
+
   def test_finding_with_conditions
     assert_equal ["David"], Author.where(name: "David").map(&:name)
     assert_equal ["Mary"],  Author.where(["name = ?", "Mary"]).map(&:name)
@@ -238,7 +250,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_reverse_order_with_function
-    topics = Topic.order("length(title)").reverse_order
+    topics = Topic.order(Arel.sql("length(title)")).reverse_order
     assert_equal topics(:second).title, topics.first.title
   end
 
@@ -248,24 +260,24 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_reverse_order_with_function_other_predicates
-    topics = Topic.order("author_name, length(title), id").reverse_order
+    topics = Topic.order(Arel.sql("author_name, length(title), id")).reverse_order
     assert_equal topics(:second).title, topics.first.title
-    topics = Topic.order("length(author_name), id, length(title)").reverse_order
+    topics = Topic.order(Arel.sql("length(author_name), id, length(title)")).reverse_order
     assert_equal topics(:fifth).title, topics.first.title
   end
 
   def test_reverse_order_with_multiargument_function
     assert_raises(ActiveRecord::IrreversibleOrderError) do
-      Topic.order("concat(author_name, title)").reverse_order
+      Topic.order(Arel.sql("concat(author_name, title)")).reverse_order
     end
     assert_raises(ActiveRecord::IrreversibleOrderError) do
-      Topic.order("concat(lower(author_name), title)").reverse_order
+      Topic.order(Arel.sql("concat(lower(author_name), title)")).reverse_order
     end
     assert_raises(ActiveRecord::IrreversibleOrderError) do
-      Topic.order("concat(author_name, lower(title))").reverse_order
+      Topic.order(Arel.sql("concat(author_name, lower(title))")).reverse_order
     end
     assert_raises(ActiveRecord::IrreversibleOrderError) do
-      Topic.order("concat(lower(author_name), title, length(title)").reverse_order
+      Topic.order(Arel.sql("concat(lower(author_name), title, length(title)")).reverse_order
     end
   end
 
@@ -277,10 +289,10 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_reverse_order_with_nulls_first_or_last
     assert_raises(ActiveRecord::IrreversibleOrderError) do
-      Topic.order("title NULLS FIRST").reverse_order
+      Topic.order(Arel.sql("title NULLS FIRST")).reverse_order
     end
     assert_raises(ActiveRecord::IrreversibleOrderError) do
-      Topic.order("title nulls last").reverse_order
+      Topic.order(Arel.sql("title nulls last")).reverse_order
     end
   end
 
@@ -373,29 +385,29 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_finding_with_cross_table_order_and_limit
     tags = Tag.includes(:taggings).
-              order("tags.name asc", "taggings.taggable_id asc", "REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").
+              order("tags.name asc", "taggings.taggable_id asc", Arel.sql("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)")).
               limit(1).to_a
     assert_equal 1, tags.length
   end
 
   def test_finding_with_complex_order_and_limit
-    tags = Tag.includes(:taggings).references(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").limit(1).to_a
+    tags = Tag.includes(:taggings).references(:taggings).order(Arel.sql("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)")).limit(1).to_a
     assert_equal 1, tags.length
   end
 
   def test_finding_with_complex_order
-    tags = Tag.includes(:taggings).references(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").to_a
+    tags = Tag.includes(:taggings).references(:taggings).order(Arel.sql("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)")).to_a
     assert_equal 3, tags.length
   end
 
   def test_finding_with_sanitized_order
-    query = Tag.order(["field(id, ?)", [1, 3, 2]]).to_sql
+    query = Tag.order([Arel.sql("field(id, ?)"), [1, 3, 2]]).to_sql
     assert_match(/field\(id, 1,3,2\)/, query)
 
-    query = Tag.order(["field(id, ?)", []]).to_sql
+    query = Tag.order([Arel.sql("field(id, ?)"), []]).to_sql
     assert_match(/field\(id, NULL\)/, query)
 
-    query = Tag.order(["field(id, ?)", nil]).to_sql
+    query = Tag.order([Arel.sql("field(id, ?)"), nil]).to_sql
     assert_match(/field\(id, NULL\)/, query)
   end
 
@@ -927,13 +939,13 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal 11, posts.count(:all)
     assert_equal 11, posts.count(:id)
 
-    assert_equal 1, posts.where("comments_count > 1").count
-    assert_equal 9, posts.where(comments_count: 0).count
+    assert_equal 3, posts.where("comments_count > 1").count
+    assert_equal 6, posts.where(comments_count: 0).count
   end
 
   def test_count_with_block
     posts = Post.all
-    assert_equal 10, posts.count { |p| p.comments_count.even? }
+    assert_equal 8, posts.count { |p| p.comments_count.even? }
   end
 
   def test_count_on_association_relation
@@ -950,10 +962,10 @@ class RelationTest < ActiveRecord::TestCase
   def test_count_with_distinct
     posts = Post.all
 
-    assert_equal 3, posts.distinct(true).count(:comments_count)
+    assert_equal 4, posts.distinct(true).count(:comments_count)
     assert_equal 11, posts.distinct(false).count(:comments_count)
 
-    assert_equal 3, posts.distinct(true).select(:comments_count).count
+    assert_equal 4, posts.distinct(true).select(:comments_count).count
     assert_equal 11, posts.distinct(false).select(:comments_count).count
   end
 
@@ -992,7 +1004,7 @@ class RelationTest < ActiveRecord::TestCase
 
     best_posts = posts.where(comments_count: 0)
     best_posts.load # force load
-    assert_no_queries { assert_equal 9, best_posts.size }
+    assert_no_queries { assert_equal 6, best_posts.size }
   end
 
   def test_size_with_limit
@@ -1003,7 +1015,7 @@ class RelationTest < ActiveRecord::TestCase
 
     best_posts = posts.where(comments_count: 0)
     best_posts.load # force load
-    assert_no_queries { assert_equal 9, best_posts.size }
+    assert_no_queries { assert_equal 6, best_posts.size }
   end
 
   def test_size_with_zero_limit
@@ -1026,7 +1038,7 @@ class RelationTest < ActiveRecord::TestCase
   def test_count_complex_chained_relations
     posts = Post.select("comments_count").where("id is not null").group("author_id").where("comments_count > 0")
 
-    expected = { 1 => 2 }
+    expected = { 1 => 4, 2 => 1 }
     assert_equal expected, posts.count
   end
 
@@ -1567,7 +1579,7 @@ class RelationTest < ActiveRecord::TestCase
     scope = Post.order("comments.body")
     assert_equal ["comments"], scope.references_values
 
-    scope = Post.order("#{Comment.quoted_table_name}.#{Comment.quoted_primary_key}")
+    scope = Post.order(Arel.sql("#{Comment.quoted_table_name}.#{Comment.quoted_primary_key}"))
     if current_adapter?(:OracleAdapter)
       assert_equal ["COMMENTS"], scope.references_values
     else
@@ -1584,7 +1596,7 @@ class RelationTest < ActiveRecord::TestCase
     scope = Post.order("comments.body asc")
     assert_equal ["comments"], scope.references_values
 
-    scope = Post.order("foo(comments.body)")
+    scope = Post.order(Arel.sql("foo(comments.body)"))
     assert_equal [], scope.references_values
   end
 
@@ -1592,7 +1604,7 @@ class RelationTest < ActiveRecord::TestCase
     scope = Post.reorder("comments.body")
     assert_equal %w(comments), scope.references_values
 
-    scope = Post.reorder("#{Comment.quoted_table_name}.#{Comment.quoted_primary_key}")
+    scope = Post.reorder(Arel.sql("#{Comment.quoted_table_name}.#{Comment.quoted_primary_key}"))
     if current_adapter?(:OracleAdapter)
       assert_equal ["COMMENTS"], scope.references_values
     else
@@ -1609,7 +1621,7 @@ class RelationTest < ActiveRecord::TestCase
     scope = Post.reorder("comments.body asc")
     assert_equal %w(comments), scope.references_values
 
-    scope = Post.reorder("foo(comments.body)")
+    scope = Post.reorder(Arel.sql("foo(comments.body)"))
     assert_equal [], scope.references_values
   end
 
@@ -1781,7 +1793,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   test "arel_attribute respects a custom table" do
-    assert_equal [posts(:welcome)], custom_post_relation.ranked_by_comments.limit_by(1).to_a
+    assert_equal [posts(:sti_comments)], custom_post_relation.ranked_by_comments.limit_by(1).to_a
   end
 
   test "alias_tracker respects a custom table" do
diff --git a/activerecord/test/cases/scoping/default_scoping_test.rb b/activerecord/test/cases/scoping/default_scoping_test.rb
index 716ca29eda..fdfeabaa3b 100644
--- a/activerecord/test/cases/scoping/default_scoping_test.rb
+++ b/activerecord/test/cases/scoping/default_scoping_test.rb
@@ -120,49 +120,49 @@ class DefaultScopingTest < ActiveRecord::TestCase
   def test_unscope_with_where_attributes
     expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.where(name: "David").unscope(where: :name).collect(&:name)
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
 
     expected_2 = Developer.order("salary DESC").collect(&:name)
     received_2 = DeveloperOrderedBySalary.select("id").where("name" => "Jamis").unscope({ where: :name }, :select).collect(&:name)
-    assert_equal expected_2, received_2
+    assert_equal expected_2.sort, received_2.sort
 
     expected_3 = Developer.order("salary DESC").collect(&:name)
     received_3 = DeveloperOrderedBySalary.select("id").where("name" => "Jamis").unscope(:select, :where).collect(&:name)
-    assert_equal expected_3, received_3
+    assert_equal expected_3.sort, received_3.sort
 
     expected_4 = Developer.order("salary DESC").collect(&:name)
     received_4 = DeveloperOrderedBySalary.where.not("name" => "Jamis").unscope(where: :name).collect(&:name)
-    assert_equal expected_4, received_4
+    assert_equal expected_4.sort, received_4.sort
 
     expected_5 = Developer.order("salary DESC").collect(&:name)
     received_5 = DeveloperOrderedBySalary.where.not("name" => ["Jamis", "David"]).unscope(where: :name).collect(&:name)
-    assert_equal expected_5, received_5
+    assert_equal expected_5.sort, received_5.sort
 
     expected_6 = Developer.order("salary DESC").collect(&:name)
     received_6 = DeveloperOrderedBySalary.where(Developer.arel_table["name"].eq("David")).unscope(where: :name).collect(&:name)
-    assert_equal expected_6, received_6
+    assert_equal expected_6.sort, received_6.sort
 
     expected_7 = Developer.order("salary DESC").collect(&:name)
     received_7 = DeveloperOrderedBySalary.where(Developer.arel_table[:name].eq("David")).unscope(where: :name).collect(&:name)
-    assert_equal expected_7, received_7
+    assert_equal expected_7.sort, received_7.sort
   end
 
   def test_unscope_comparison_where_clauses
     # unscoped for WHERE (`developers`.`id` <= 2)
     expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.where(id: -Float::INFINITY..2).unscope(where: :id).collect { |dev| dev.name }
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
 
     # unscoped for WHERE (`developers`.`id` < 2)
     expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.where(id: -Float::INFINITY...2).unscope(where: :id).collect { |dev| dev.name }
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
   end
 
   def test_unscope_multiple_where_clauses
     expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.where(name: "Jamis").where(id: 1).unscope(where: [:name, :id]).collect(&:name)
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
   end
 
   def test_unscope_string_where_clauses_involved
@@ -172,23 +172,23 @@ class DefaultScopingTest < ActiveRecord::TestCase
     dev_ordered_relation = DeveloperOrderedBySalary.where(name: "Jamis").where("created_at > ?", 1.year.ago)
     received = dev_ordered_relation.unscope(where: [:name]).collect(&:name)
 
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
   end
 
   def test_unscope_with_grouping_attributes
     expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.group(:name).unscope(:group).collect(&:name)
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
 
     expected_2 = Developer.order("salary DESC").collect(&:name)
     received_2 = DeveloperOrderedBySalary.group("name").unscope(:group).collect(&:name)
-    assert_equal expected_2, received_2
+    assert_equal expected_2.sort, received_2.sort
   end
 
   def test_unscope_with_limit_in_query
     expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.limit(1).unscope(:limit).collect(&:name)
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
   end
 
   def test_order_to_unscope_reordering
@@ -472,7 +472,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
   test "a scope can remove the condition from the default scope" do
     scope = DeveloperCalledJamis.david2
     assert_equal 1, scope.where_clause.ast.children.length
-    assert_equal Developer.where(name: "David"), scope
+    assert_equal Developer.where(name: "David").map(&:id), scope.map(&:id)
   end
 
   def test_with_abstract_class_where_clause_should_not_be_duplicated
diff --git a/activerecord/test/cases/tasks/mysql_rake_test.rb b/activerecord/test/cases/tasks/mysql_rake_test.rb
index 98fe24baa0..047153e7cc 100644
--- a/activerecord/test/cases/tasks/mysql_rake_test.rb
+++ b/activerecord/test/cases/tasks/mysql_rake_test.rb
@@ -75,7 +75,7 @@ if current_adapter?(:Mysql2Adapter)
       end
     end
 
-    class MysqlDBCreateAsRootTest < ActiveRecord::TestCase
+    class MysqlDBCreateWithInvalidPermissionsTest < ActiveRecord::TestCase
       def setup
         @connection    = stub("Connection", create_database: true)
         @error         = Mysql2::Error.new("Invalid permissions")
@@ -86,13 +86,8 @@ if current_adapter?(:Mysql2Adapter)
           "password" => "wossname"
         }
 
-        $stdin.stubs(:gets).returns("secret\n")
-        $stdout.stubs(:print).returns(nil)
-        @error.stubs(:errno).returns(1045)
         ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).
-          raises(@error).
-          then.returns(true)
+        ActiveRecord::Base.stubs(:establish_connection).raises(@error)
 
         $stdout, @original_stdout = StringIO.new, $stdout
         $stderr, @original_stderr = StringIO.new, $stderr
@@ -102,75 +97,11 @@ if current_adapter?(:Mysql2Adapter)
         $stdout, $stderr = @original_stdout, @original_stderr
       end
 
-      def test_root_password_is_requested
-        assert_permissions_granted_for("pat")
-        $stdin.expects(:gets).returns("secret\n")
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_connection_established_as_root
-        assert_permissions_granted_for("pat")
-        ActiveRecord::Base.expects(:establish_connection).with(
-          "adapter"  => "mysql2",
-          "database" => nil,
-          "username" => "root",
-          "password" => "secret"
-        )
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_database_created_by_root
-        assert_permissions_granted_for("pat")
-        @connection.expects(:create_database).
-          with("my-app-db", {})
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_grant_privileges_for_normal_user
-        assert_permissions_granted_for("pat")
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_do_not_grant_privileges_for_root_user
-        @configuration["username"] = "root"
-        @configuration["password"] = ""
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_connection_established_as_normal_user
-        assert_permissions_granted_for("pat")
-        ActiveRecord::Base.expects(:establish_connection).returns do
-          ActiveRecord::Base.expects(:establish_connection).with(
-            "adapter"  => "mysql2",
-            "database" => "my-app-db",
-            "username" => "pat",
-            "password" => "secret"
-          )
-
-          raise @error
+      def test_raises_error
+        assert_raises(Mysql2::Error) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
         end
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
       end
-
-      def test_sends_output_to_stderr_when_other_errors
-        @error.stubs(:errno).returns(42)
-
-        $stderr.expects(:puts).at_least_once.returns(nil)
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      private
-
-        def assert_permissions_granted_for(db_user)
-          db_name = @configuration["database"]
-          db_password = @configuration["password"]
-          @connection.expects(:execute).with("GRANT ALL PRIVILEGES ON `#{db_name}`.* TO '#{db_user}'@'localhost' IDENTIFIED BY '#{db_password}' WITH GRANT OPTION;")
-        end
     end
 
     class MySQLDBDropTest < ActiveRecord::TestCase
diff --git a/activerecord/test/cases/unsafe_raw_sql_test.rb b/activerecord/test/cases/unsafe_raw_sql_test.rb
new file mode 100644
index 0000000000..72d4997d0b
--- /dev/null
+++ b/activerecord/test/cases/unsafe_raw_sql_test.rb
@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/comment"
+
+class UnsafeRawSqlTest < ActiveRecord::TestCase
+  fixtures :posts, :comments
+
+  test "order: allows string column name" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order("title").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order("title").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows symbol column name" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order(:title).pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order(:title).pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows downcase symbol direction" do
+    ids_expected = Post.order(Arel.sql("title") => Arel.sql("asc")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order(title: :asc).pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order(title: :asc).pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows upcase symbol direction" do
+    ids_expected = Post.order(Arel.sql("title") => Arel.sql("ASC")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order(title: :ASC).pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order(title: :ASC).pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows string direction" do
+    ids_expected = Post.order(Arel.sql("title") => Arel.sql("asc")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order(title: "asc").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order(title: "asc").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows multiple columns" do
+    ids_expected = Post.order(Arel.sql("author_id"), Arel.sql("title")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order(:author_id, :title).pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order(:author_id, :title).pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows mixed" do
+    ids_expected = Post.order(Arel.sql("author_id"), Arel.sql("title") => Arel.sql("asc")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order(:author_id, title: :asc).pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order(:author_id, title: :asc).pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows table and column name" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order("posts.title").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order("posts.title").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows column name and direction in string" do
+    ids_expected = Post.order(Arel.sql("title desc")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order("title desc").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order("title desc").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows table name, column name and direction in string" do
+    ids_expected = Post.order(Arel.sql("title desc")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order("posts.title desc").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order("posts.title desc").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: disallows invalid column name" do
+    with_unsafe_raw_sql_disabled do
+      assert_raises(ActiveRecord::UnknownAttributeReference) do
+        Post.order("len(title) asc").pluck(:id)
+      end
+    end
+  end
+
+  test "order: disallows invalid direction" do
+    with_unsafe_raw_sql_disabled do
+      assert_raises(ArgumentError) do
+        Post.order(title: :foo).pluck(:id)
+      end
+    end
+  end
+
+  test "order: disallows invalid column with direction" do
+    with_unsafe_raw_sql_disabled do
+      assert_raises(ActiveRecord::UnknownAttributeReference) do
+        Post.order("len(title)" => :asc).pluck(:id)
+      end
+    end
+  end
+
+  test "order: always allows Arel" do
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order(Arel.sql("length(title)")).pluck(:title) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order(Arel.sql("length(title)")).pluck(:title) }
+
+    assert_equal ids_depr, ids_disabled
+  end
+
+  test "order: allows Arel.sql with binds" do
+    ids_expected = Post.order(Arel.sql("REPLACE(title, 'misc', 'zzzz'), id")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order([Arel.sql("REPLACE(title, ?, ?), id"), "misc", "zzzz"]).pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order([Arel.sql("REPLACE(title, ?, ?), id"), "misc", "zzzz"]).pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: disallows invalid bind statement" do
+    with_unsafe_raw_sql_disabled do
+      assert_raises(ActiveRecord::UnknownAttributeReference) do
+        Post.order(["REPLACE(title, ?, ?), id", "misc", "zzzz"]).pluck(:id)
+      end
+    end
+  end
+
+  test "order: disallows invalid Array arguments" do
+    with_unsafe_raw_sql_disabled do
+      assert_raises(ActiveRecord::UnknownAttributeReference) do
+        Post.order(["author_id", "length(title)"]).pluck(:id)
+      end
+    end
+  end
+
+  test "order: allows valid Array arguments" do
+    ids_expected = Post.order(Arel.sql("author_id, length(title)")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order(["author_id", Arel.sql("length(title)")]).pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order(["author_id", Arel.sql("length(title)")]).pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: logs deprecation warning for unrecognized column" do
+    with_unsafe_raw_sql_deprecated do
+      assert_deprecated(/Dangerous query method/) do
+        Post.order("length(title)")
+      end
+    end
+  end
+
+  test "pluck: allows string column name" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles_depr     = with_unsafe_raw_sql_deprecated { Post.pluck("title") }
+    titles_disabled = with_unsafe_raw_sql_disabled   { Post.pluck("title") }
+
+    assert_equal titles_expected, titles_depr
+    assert_equal titles_expected, titles_disabled
+  end
+
+  test "pluck: allows symbol column name" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles_depr     = with_unsafe_raw_sql_deprecated { Post.pluck(:title) }
+    titles_disabled = with_unsafe_raw_sql_disabled   { Post.pluck(:title) }
+
+    assert_equal titles_expected, titles_depr
+    assert_equal titles_expected, titles_disabled
+  end
+
+  test "pluck: allows multiple column names" do
+    values_expected = Post.pluck(Arel.sql("title"), Arel.sql("id"))
+
+    values_depr     = with_unsafe_raw_sql_deprecated { Post.pluck(:title, :id) }
+    values_disabled = with_unsafe_raw_sql_disabled   { Post.pluck(:title, :id) }
+
+    assert_equal values_expected, values_depr
+    assert_equal values_expected, values_disabled
+  end
+
+  test "pluck: allows column names with includes" do
+    values_expected = Post.includes(:comments).pluck(Arel.sql("title"), Arel.sql("id"))
+
+    values_depr     = with_unsafe_raw_sql_deprecated { Post.includes(:comments).pluck(:title, :id) }
+    values_disabled = with_unsafe_raw_sql_disabled   { Post.includes(:comments).pluck(:title, :id) }
+
+    assert_equal values_expected, values_depr
+    assert_equal values_expected, values_disabled
+  end
+
+  test "pluck: allows auto-generated attributes" do
+    values_expected = Post.pluck(Arel.sql("tags_count"))
+
+    values_depr     = with_unsafe_raw_sql_deprecated { Post.pluck(:tags_count) }
+    values_disabled = with_unsafe_raw_sql_disabled   { Post.pluck(:tags_count) }
+
+    assert_equal values_expected, values_depr
+    assert_equal values_expected, values_disabled
+  end
+
+  test "pluck: allows table and column names" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles_depr     = with_unsafe_raw_sql_deprecated { Post.pluck("posts.title") }
+    titles_disabled = with_unsafe_raw_sql_disabled   { Post.pluck("posts.title") }
+
+    assert_equal titles_expected, titles_depr
+    assert_equal titles_expected, titles_disabled
+  end
+
+  test "pluck: disallows invalid column name" do
+    with_unsafe_raw_sql_disabled do
+      assert_raises(ActiveRecord::UnknownAttributeReference) do
+        Post.pluck("length(title)")
+      end
+    end
+  end
+
+  test "pluck: disallows invalid column name amongst valid names" do
+    with_unsafe_raw_sql_disabled do
+      assert_raises(ActiveRecord::UnknownAttributeReference) do
+        Post.pluck(:title, "length(title)")
+      end
+    end
+  end
+
+  test "pluck: disallows invalid column names with includes" do
+    with_unsafe_raw_sql_disabled do
+      assert_raises(ActiveRecord::UnknownAttributeReference) do
+        Post.includes(:comments).pluck(:title, "length(title)")
+      end
+    end
+  end
+
+  test "pluck: always allows Arel" do
+    values_depr     = with_unsafe_raw_sql_deprecated { Post.includes(:comments).pluck(:title, Arel.sql("length(title)")) }
+    values_disabled = with_unsafe_raw_sql_disabled   { Post.includes(:comments).pluck(:title, Arel.sql("length(title)")) }
+
+    assert_equal values_depr, values_disabled
+  end
+
+  test "pluck: logs deprecation warning" do
+    with_unsafe_raw_sql_deprecated do
+      assert_deprecated(/Dangerous query method/) do
+        Post.includes(:comments).pluck(:title, "length(title)")
+      end
+    end
+  end
+
+  def with_unsafe_raw_sql_disabled(&blk)
+    with_config(:disabled, &blk)
+  end
+
+  def with_unsafe_raw_sql_deprecated(&blk)
+    with_config(:deprecated, &blk)
+  end
+
+  def with_config(new_value, &blk)
+    old_value = ActiveRecord::Base.allow_unsafe_raw_sql
+    ActiveRecord::Base.allow_unsafe_raw_sql = new_value
+    blk.call
+  ensure
+    ActiveRecord::Base.allow_unsafe_raw_sql = old_value
+  end
+end
diff --git a/activerecord/test/fixtures/other_posts.yml b/activerecord/test/fixtures/other_posts.yml
index 39ff763547..3e11a33802 100644
--- a/activerecord/test/fixtures/other_posts.yml
+++ b/activerecord/test/fixtures/other_posts.yml
@@ -5,3 +5,4 @@ second_welcome:
   author_id: 1
   title: Welcome to the another weblog
   body: It's really nice today
+  comments_count: 1
diff --git a/activerecord/test/fixtures/posts.yml b/activerecord/test/fixtures/posts.yml
index 86d46f753a..8d7e1e0ae7 100644
--- a/activerecord/test/fixtures/posts.yml
+++ b/activerecord/test/fixtures/posts.yml
@@ -28,6 +28,7 @@ sti_comments:
   author_id: 1
   title: sti comments
   body: hello
+  comments_count: 5
   type: Post
 
 sti_post_and_comments:
@@ -35,6 +36,7 @@ sti_post_and_comments:
   author_id: 1
   title: sti me
   body: hello
+  comments_count: 2
   type: StiPost
 
 sti_habtm:
@@ -50,6 +52,8 @@ eager_other:
   title: eager loading with OR'd conditions
   body: hello
   type: Post
+  comments_count: 1
+  tags_count: 3
 
 misc_by_bob:
   id: 8
@@ -57,6 +61,7 @@ misc_by_bob:
   title: misc post by bob
   body: hello
   type: Post
+  tags_count: 1
 
 misc_by_mary:
   id: 9
@@ -64,6 +69,7 @@ misc_by_mary:
   title: misc post by mary
   body: hello
   type: Post
+  tags_count: 1
 
 other_by_bob:
   id: 10
@@ -71,6 +77,7 @@ other_by_bob:
   title: other post by bob
   body: hello
   type: Post
+  tags_count: 1
 
 other_by_mary:
   id: 11
@@ -78,3 +85,4 @@ other_by_mary:
   title: other post by mary
   body: hello
   type: Post
+  tags_count: 1
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index 7f064bf3dd..780a2c17f5 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -319,5 +319,9 @@ class FakeKlass
     def arel_attribute(name, table)
       table[name]
     end
+
+    def enforce_raw_sql_whitelist(*args)
+      # noop
+    end
   end
 end