Merge branch 'master' into set_binds

* master: (2794 commits)
  doc, API example on how to use `Model#exists?` with multiple IDs. [ci skip]
  Restore DATABASE_URL even if it's nil in connection_handler test
  [ci skip] - error_messages_for has been deprecated since 2.3.8 - lets reduce any confusion for users
  Ensure Active Record connection consistency
  Revert "ask the fixture set for the sql statements"
  Check `respond_to` before delegation due to: https://github.com/ruby/ruby/commit/d781caaf313b8649948c107bba277e5ad7307314
  Adding Hash#compact and Hash#compact! methods
  MySQL version 4.1 was EOL on December 31, 2009 We should at least recommend modern versions of MySQL to users.
  clear cache on body close so that cache remains during rendering
  add a more restricted codepath for templates fixes #13390
  refactor generator tests to use block form of Tempfile
  Fix typo [ci skip]
  Move finish_template as the last public method in the generator
  Minor typos fix [ci skip]
  make `change_column_null` reversible. Closes #13576.
  create/drop test and development databases only if RAILS_ENV is nil
  Revert "Speedup String#to"
  typo fix in test name. [ci skip].
  `core_ext/string/access.rb` test what we are documenting.
  Fix typo in image_tag documentation
  ...

Conflicts:
	activerecord/lib/active_record/associations/join_dependency/join_association.rb
	activerecord/lib/active_record/relation/query_methods.rb

10 files changed, 505 insertions, 313 deletions

diff --git a/activerecord/lib/active_record/relation/batches.rb b/activerecord/lib/active_record/relation/batches.rb
index b921f2eddb..49b01909c6 100644
--- a/activerecord/lib/active_record/relation/batches.rb
+++ b/activerecord/lib/active_record/relation/batches.rb
@@ -11,7 +11,7 @@ module ActiveRecord
     # The #find_each method uses #find_in_batches with a batch size of 1000 (or as
     # specified by the +:batch_size+ option).
     #
-    #   Person.all.find_each do |person|
+    #   Person.find_each do |person|
     #     person.do_awesome_stuff
     #   end
     #
@@ -19,47 +19,78 @@ module ActiveRecord
     #     person.party_all_night!
     #   end
     #
-    #  You can also pass the +:start+ option to specify
-    #  an offset to control the starting point.
-    def find_each(options = {})
-      find_in_batches(options) do |records|
-        records.each { |record| yield record }
-      end
-    end
-
-    # Yields each batch of records that was found by the find +options+ as
-    # an array. The size of each batch is set by the +:batch_size+
-    # option; the default is 1000.
+    # If you do not provide a block to #find_each, it will return an Enumerator
+    # for chaining with other methods:
+    #
+    #   Person.find_each.with_index do |person, index|
+    #     person.award_trophy(index + 1)
+    #   end
+    #
+    # ==== Options
+    # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
+    # * <tt>:start</tt> - Specifies the starting point for the batch processing.
+    # This is especially useful if you want multiple workers dealing with
+    # the same processing queue. You can make worker 1 handle all the records
+    # between id 0 and 10,000 and worker 2 handle from 10,000 and beyond
+    # (by setting the +:start+ option on that worker).
     #
-    # You can control the starting point for the batch processing by
-    # supplying the +:start+ option. This is especially useful if you
-    # want multiple workers dealing with the same processing queue. You can
-    # make worker 1 handle all the records between id 0 and 10,000 and
-    # worker 2 handle from 10,000 and beyond (by setting the +:start+
-    # option on that worker).
+    #   # Let's process for a batch of 2000 records, skipping the first 2000 rows
+    #   Person.find_each(start: 2000, batch_size: 2000) do |person|
+    #     person.party_all_night!
+    #   end
     #
-    # It's not possible to set the order. That is automatically set to
+    # NOTE: It's not possible to set the order. That is automatically set to
     # ascending on the primary key ("id ASC") to make the batch ordering
     # work. This also means that this method only works with integer-based
-    # primary keys. You can't set the limit either, that's used to control
+    # primary keys.
+    #
+    # NOTE: You can't set the limit either, that's used to control
     # the batch sizes.
+    def find_each(options = {})
+      if block_given?
+        find_in_batches(options) do |records|
+          records.each { |record| yield record }
+        end
+      else
+        enum_for :find_each, options
+      end
+    end
+
+    # Yields each batch of records that was found by the find +options+ as
+    # an array.
     #
     #   Person.where("age > 21").find_in_batches do |group|
     #     sleep(50) # Make sure it doesn't get too crowded in there!
     #     group.each { |person| person.party_all_night! }
     #   end
     #
+    # ==== Options
+    # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
+    # * <tt>:start</tt> - Specifies the starting point for the batch processing.
+    # This is especially useful if you want multiple workers dealing with
+    # the same processing queue. You can make worker 1 handle all the records
+    # between id 0 and 10,000 and worker 2 handle from 10,000 and beyond
+    # (by setting the +:start+ option on that worker).
+    #
     #   # Let's process the next 2000 records
-    #   Person.all.find_in_batches(start: 2000, batch_size: 2000) do |group|
+    #   Person.find_in_batches(start: 2000, batch_size: 2000) do |group|
     #     group.each { |person| person.party_all_night! }
     #   end
+    #
+    # NOTE: It's not possible to set the order. That is automatically set to
+    # ascending on the primary key ("id ASC") to make the batch ordering
+    # work. This also means that this method only works with integer-based
+    # primary keys.
+    #
+    # NOTE: You can't set the limit either, that's used to control
+    # the batch sizes.
     def find_in_batches(options = {})
       options.assert_valid_keys(:start, :batch_size)
 
       relation = self
 
-      unless arel.orders.blank? && arel.taken.blank?
-        ActiveRecord::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
+      if logger && (arel.orders.present? || arel.taken.present?)
+        logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
       end
 
       start = options.delete(:start)
diff --git a/activerecord/lib/active_record/relation/calculations.rb b/activerecord/lib/active_record/relation/calculations.rb
index 7239270c4d..45ffb99868 100644
--- a/activerecord/lib/active_record/relation/calculations.rb
+++ b/activerecord/lib/active_record/relation/calculations.rb
@@ -20,6 +20,8 @@ module ActiveRecord
     #   Person.group(:city).count
     #   # => { 'Rome' => 5, 'Paris' => 3 }
     def count(column_name = nil, options = {})
+      # TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
       column_name, options = nil, column_name if column_name.is_a?(Hash)
       calculate(:count, column_name, options)
     end
@@ -29,6 +31,8 @@ module ActiveRecord
     #
     #   Person.average(:age) # => 35.8
     def average(column_name, options = {})
+      # TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
       calculate(:average, column_name, options)
     end
 
@@ -38,6 +42,8 @@ module ActiveRecord
     #
     #   Person.minimum(:age) # => 7
     def minimum(column_name, options = {})
+      # TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
       calculate(:minimum, column_name, options)
     end
 
@@ -47,6 +53,8 @@ module ActiveRecord
     #
     #   Person.maximum(:age) # => 93
     def maximum(column_name, options = {})
+      # TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
       calculate(:maximum, column_name, options)
     end
 
@@ -56,15 +64,7 @@ module ActiveRecord
     #
     #   Person.sum(:age) # => 4562
     def sum(*args)
-      if block_given?
-        ActiveSupport::Deprecation.warn(
-          "Calling #sum with a block is deprecated and will be removed in Rails 4.1. " \
-          "If you want to perform sum calculation over the array of elements, use `to_a.sum(&block)`."
-        )
-        self.to_a.sum(*args) {|*block_args| yield(*block_args)}
-      else
-        calculate(:sum, *args)
-      end
+      calculate(:sum, *args)
     end
 
     # This calculates aggregate values in the given column. Methods for count, sum, average,
@@ -99,23 +99,17 @@ module ActiveRecord
     #
     #   Person.sum("2 * age")
     def calculate(operation, column_name, options = {})
-      relation = with_default_scope
-
-      if column_name.is_a?(Symbol) && attribute_aliases.key?(column_name.to_s)
-        column_name = attribute_aliases[column_name.to_s].to_sym
+      # TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
+      if column_name.is_a?(Symbol) && attribute_alias?(column_name)
+        column_name = attribute_alias(column_name)
       end
 
-      if relation.equal?(self)
-        if has_include?(column_name)
-          construct_relation_for_association_calculations.calculate(operation, column_name, options)
-        else
-          perform_calculation(operation, column_name, options)
-        end
+      if has_include?(column_name)
+        construct_relation_for_association_calculations.calculate(operation, column_name, options)
       else
-        relation.calculate(operation, column_name, options)
+        perform_calculation(operation, column_name, options)
       end
-    rescue ThrowResult
-      0
     end
 
     # Use <tt>pluck</tt> as a shortcut to select one or more attributes without
@@ -153,39 +147,31 @@ module ActiveRecord
     #
     def pluck(*column_names)
       column_names.map! do |column_name|
-        if column_name.is_a?(Symbol)
-          if attribute_aliases.key?(column_name.to_s)
-            column_name = attribute_aliases[column_name.to_s].to_sym
-          end
-
-          if self.columns_hash.key?(column_name.to_s)
-            column_name = "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(column_name)}"
-          end
+        if column_name.is_a?(Symbol) && attribute_alias?(column_name)
+          attribute_alias(column_name)
+        else
+          column_name.to_s
         end
-
-        column_name
       end
 
       if has_include?(column_names.first)
         construct_relation_for_association_calculations.pluck(*column_names)
       else
         relation = spawn
-        relation.select_values = column_names
+        relation.select_values = column_names.map { |cn|
+          columns_hash.key?(cn) ? arel_table[cn] : cn
+        }
         result = klass.connection.select_all(relation.arel, nil, bind_values)
         columns = result.columns.map do |key|
           klass.column_types.fetch(key) {
-            result.column_types.fetch(key) {
-              Class.new { def type_cast(v); v; end }.new
-            }
+            result.column_types.fetch(key) { result.identity_type }
           }
         end
 
         result = result.map do |attributes|
           values = klass.initialize_attributes(attributes).values
 
-          columns.zip(values).map do |column, value|
-            column.type_cast(value)
-          end
+          columns.zip(values).map { |column, value| column.type_cast value }
         end
         columns.one? ? result.map!(&:first) : result
       end
@@ -206,26 +192,22 @@ module ActiveRecord
     end
 
     def perform_calculation(operation, column_name, options = {})
+      # TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
       operation = operation.to_s.downcase
 
       # If #count is used with #distinct / #uniq it is considered distinct. (eg. relation.distinct.count)
       distinct = self.distinct_value
-      if options.has_key?(:distinct)
-        ActiveSupport::Deprecation.warn "The :distinct option for `Relation#count` is deprecated. " \
-          "Please use `Relation#distinct` instead. (eg. `relation.distinct.count`)"
-        distinct = options[:distinct]
-      end
 
       if operation == "count"
-        column_name ||= (select_for_count || :all)
+        column_name ||= select_for_count
 
         unless arel.ast.grep(Arel::Nodes::OuterJoin).empty?
           distinct = true
         end
 
         column_name = primary_key if column_name == :all && distinct
-
-        distinct = nil if column_name =~ /\s*DISTINCT\s+/i
+        distinct = nil if column_name =~ /\s*DISTINCT[\s(]+/i
       end
 
       if group_values.any?
@@ -342,7 +324,9 @@ module ActiveRecord
         }
         key = key.first if key.size == 1
         key = key_records[key] if associated
-        [key, type_cast_calculated_value(row[aggregate_alias], column_for(column_name), operation)]
+
+        column_type = calculated_data.column_types.fetch(aggregate_alias) { column_for(column_name) }
+        [key, type_cast_calculated_value(row[aggregate_alias], column_type, operation)]
       end]
     end
 
@@ -386,10 +370,12 @@ module ActiveRecord
       column ? column.type_cast(value) : value
     end
 
+    # TODO: refactor to allow non-string `select_values` (eg. Arel nodes).
     def select_for_count
       if select_values.present?
-        select = select_values.join(", ")
-        select if select !~ /[,*]/
+        select_values.join(", ")
+      else
+        :all
       end
     end
 
diff --git a/activerecord/lib/active_record/relation/delegation.rb b/activerecord/lib/active_record/relation/delegation.rb
index 8d6740246c..21beed332f 100644
--- a/activerecord/lib/active_record/relation/delegation.rb
+++ b/activerecord/lib/active_record/relation/delegation.rb
@@ -1,8 +1,35 @@
-require 'thread'
-require 'thread_safe'
+require 'set'
+require 'active_support/concern'
+require 'active_support/deprecation'
 
 module ActiveRecord
   module Delegation # :nodoc:
+    module DelegateCache
+      def relation_delegate_class(klass) # :nodoc:
+        @relation_delegate_cache[klass]
+      end
+
+      def initialize_relation_delegate_cache # :nodoc:
+        @relation_delegate_cache = cache = {}
+        [
+          ActiveRecord::Relation,
+          ActiveRecord::Associations::CollectionProxy,
+          ActiveRecord::AssociationRelation
+        ].each do |klass|
+          delegate = Class.new(klass) {
+            include ClassSpecificRelation
+          }
+          const_set klass.name.gsub('::', '_'), delegate
+          cache[klass] = delegate
+        end
+      end
+
+      def inherited(child_class)
+        child_class.initialize_relation_delegate_cache
+        super
+      end
+    end
+
     extend ActiveSupport::Concern
 
     # This module creates compiled delegation methods dynamically at runtime, which makes
@@ -10,7 +37,14 @@ 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, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, :to => :to_a
+    BLACKLISTED_ARRAY_METHODS = [
+      :compact!, :flatten!, :reject!, :reverse!, :rotate!, :map!,
+      :shuffle!, :slice!, :sort!, :sort_by!, :delete_if,
+      :keep_if, :pop, :shift, :delete_at, :compact
+    ].to_set # :nodoc:
+
+    delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, to: :to_a
+
     delegate :table_name, :quoted_table_name, :primary_key, :quoted_primary_key,
              :connection, :columns_hash, :to => :klass
 
@@ -38,7 +72,7 @@ module ActiveRecord
               RUBY
             else
               define_method method do |*args, &block|
-                scoping { @klass.send(method, *args, &block) }
+                scoping { @klass.public_send(method, *args, &block) }
               end
             end
           end
@@ -57,13 +91,10 @@ module ActiveRecord
       def method_missing(method, *args, &block)
         if @klass.respond_to?(method)
           self.class.delegate_to_scoped_klass(method)
-          scoping { @klass.send(method, *args, &block) }
-        elsif Array.method_defined?(method)
-          self.class.delegate method, :to => :to_a
-          to_a.send(method, *args, &block)
+          scoping { @klass.public_send(method, *args, &block) }
         elsif arel.respond_to?(method)
           self.class.delegate method, :to => :arel
-          arel.send(method, *args, &block)
+          arel.public_send(method, *args, &block)
         else
           super
         end
@@ -71,52 +102,36 @@ module ActiveRecord
     end
 
     module ClassMethods # :nodoc:
-      @@subclasses = ThreadSafe::Cache.new(:initial_capacity => 2)
-
-      def new(klass, *args)
-        relation = relation_class_for(klass).allocate
-        relation.__send__(:initialize, klass, *args)
-        relation
-      end
-
-      # This doesn't have to be thread-safe. relation_class_for guarantees that this will only be
-      # called exactly once for a given const name.
-      def const_missing(name)
-        const_set(name, Class.new(self) { include ClassSpecificRelation })
+      def create(klass, *args)
+        relation_class_for(klass).new(klass, *args)
       end
 
       private
-      # Cache the constants in @@subclasses because looking them up via const_get
-      # make instantiation significantly slower.
+
       def relation_class_for(klass)
-        if klass && (klass_name = klass.name)
-          my_cache = @@subclasses.compute_if_absent(self) { ThreadSafe::Cache.new }
-          # This hash is keyed by klass.name to avoid memory leaks in development mode
-          my_cache.compute_if_absent(klass_name) do
-            # Cache#compute_if_absent guarantees that the block will only executed once for the given klass_name
-            const_get("#{name.gsub('::', '_')}_#{klass_name.gsub('::', '_')}", false)
-          end
-        else
-          ActiveRecord::Relation
-        end
+        klass.relation_delegate_class(self)
       end
     end
 
     def respond_to?(method, include_private = false)
-      super || Array.method_defined?(method) ||
-        @klass.respond_to?(method, include_private) ||
+      super || @klass.respond_to?(method, include_private) ||
+        array_delegable?(method) ||
         arel.respond_to?(method, include_private)
     end
 
     protected
 
+    def array_delegable?(method)
+      Array.method_defined?(method) && BLACKLISTED_ARRAY_METHODS.exclude?(method)
+    end
+
     def method_missing(method, *args, &block)
       if @klass.respond_to?(method)
-        scoping { @klass.send(method, *args, &block) }
-      elsif Array.method_defined?(method)
-        to_a.send(method, *args, &block)
+        scoping { @klass.public_send(method, *args, &block) }
+      elsif array_delegable?(method)
+        to_a.public_send(method, *args, &block)
       elsif arel.respond_to?(method)
-        arel.send(method, *args, &block)
+        arel.public_send(method, *args, &block)
       else
         super
       end
diff --git a/activerecord/lib/active_record/relation/finder_methods.rb b/activerecord/lib/active_record/relation/finder_methods.rb
index ba222aac93..4984dbd277 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -1,19 +1,24 @@
 module ActiveRecord
   module FinderMethods
+    ONE_AS_ONE = '1 AS one'
+
     # Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
     # If no record can be found for all of the listed ids, then RecordNotFound will be raised. If the primary key
     # is an integer, find by id coerces its arguments using +to_i+.
     #
-    #   Person.find(1)       # returns the object for ID = 1
-    #   Person.find("1")     # returns the object for ID = 1
-    #   Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6)
-    #   Person.find([7, 17]) # returns an array for objects with IDs in (7, 17)
-    #   Person.find([1])     # returns an array for the object with ID = 1
+    #   Person.find(1)          # returns the object for ID = 1
+    #   Person.find("1")        # returns the object for ID = 1
+    #   Person.find("31-sarah") # returns the object for ID = 31
+    #   Person.find(1, 2, 6)    # returns an array for objects with IDs in (1, 2, 6)
+    #   Person.find([7, 17])    # returns an array for objects with IDs in (7, 17)
+    #   Person.find([1])        # returns an array for the object with ID = 1
     #   Person.where("administrator = 1").order("created_on DESC").find(1)
     #
-    # Note that returned records may not be in the same order as the ids you
-    # provide since database rows are unordered. Give an explicit <tt>order</tt>
-    # to ensure the results are sorted.
+    # <tt>ActiveRecord::RecordNotFound</tt> will be raised if one or more ids are not found.
+    #
+    # NOTE: The returned records may not be in the same order as the ids you
+    # provide since database rows are unordered. You'd need to provide an explicit <tt>order</tt>
+    # option if you want the results are sorted.
     #
     # ==== Find with lock
     #
@@ -28,6 +33,34 @@ module ActiveRecord
     #     person.visits += 1
     #     person.save!
     #   end
+    #
+    # ==== Variations of +find+
+    #
+    #   Person.where(name: 'Spartacus', rating: 4)
+    #   # returns a chainable list (which can be empty).
+    #
+    #   Person.find_by(name: 'Spartacus', rating: 4)
+    #   # returns the first item or nil.
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).first_or_initialize
+    #   # returns the first item or returns a new instance (requires you call .save to persist against the database).
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).first_or_create
+    #   # returns the first item or creates it and returns it, available since Rails 3.2.1.
+    #
+    # ==== Alternatives for +find+
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).exists?(conditions = :none)
+    #   # returns a boolean indicating if any record with the given conditions exist.
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).select("field1, field2, field3")
+    #   # returns a chainable list of instances with only the mentioned fields.
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).ids
+    #   # returns an Array of ids, available since Rails 3.2.1.
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).pluck(:field1, :field2)
+    #   # returns an Array of the required fields, available since Rails 3.1.
     def find(*args)
       if block_given?
         to_a.find { |*block_args| yield(*block_args) }
@@ -79,13 +112,22 @@ module ActiveRecord
     #   Person.where(["user_name = :u", { u: user_name }]).first
     #   Person.order("created_on DESC").offset(5).first
     #   Person.first(3) # returns the first three objects fetched by SELECT * FROM people LIMIT 3
+    #
+    # ==== Rails 3
+    #
+    #   Person.first # SELECT "people".* FROM "people" LIMIT 1
+    #
+    # NOTE: Rails 3 may not order this query by the primary key and the order
+    # will depend on the database implementation. In order to ensure that behavior,
+    # use <tt>User.order(:id).first</tt> instead.
+    #
+    # ==== Rails 4
+    #
+    #   Person.first # SELECT "people".* FROM "people" ORDER BY "people"."id" ASC LIMIT 1
+    #
     def first(limit = nil)
       if limit
-        if order_values.empty? && primary_key
-          order(arel_table[primary_key].asc).limit(limit).to_a
-        else
-          limit(limit).to_a
-        end
+        find_first_with_limit(limit)
       else
         find_first
       end
@@ -130,21 +172,21 @@ module ActiveRecord
       last or raise RecordNotFound
     end
 
-    # Returns truthy if a record exists in the table that matches the +id+ or
-    # conditions given, or falsy otherwise. The argument can take six forms:
+    # Returns +true+ if a record exists in the table that matches the +id+ or
+    # conditions given, or +false+ otherwise. The argument can take six forms:
     #
     # * Integer - Finds the record with this primary key.
     # * String - Finds the record with a primary key corresponding to this
     #   string (such as <tt>'5'</tt>).
     # * Array - Finds the record that matches these +find+-style conditions
-    #   (such as <tt>['color = ?', 'red']</tt>).
+    #   (such as <tt>['name LIKE ?', "%#{query}%"]</tt>).
     # * Hash - Finds the record that matches these +find+-style conditions
-    #   (such as <tt>{color: 'red'}</tt>).
+    #   (such as <tt>{name: 'David'}</tt>).
     # * +false+ - Returns always +false+.
     # * No args - Returns +false+ if the table 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.
+    # For more information about specifying conditions as a hash or array,
+    # see the Conditions section in the introduction to <tt>ActiveRecord::Base</tt>.
     #
     # Note: You can't pass in a condition as a string (like <tt>name =
     # 'Jamie'</tt>), since it would be sanitized and then queried against
@@ -153,6 +195,7 @@ module ActiveRecord
     #   Person.exists?(5)
     #   Person.exists?('5')
     #   Person.exists?(['name LIKE ?', "%#{query}%"])
+    #   Person.exists?(id: [1, 4, 8])
     #   Person.exists?(name: 'David')
     #   Person.exists?(false)
     #   Person.exists?
@@ -160,9 +203,10 @@ module ActiveRecord
       conditions = conditions.id if Base === conditions
       return false if !conditions
 
-      join_dependency = construct_join_dependency
-      relation = construct_relation_for_association_find(join_dependency)
-      relation = relation.except(:select, :order).select("1 AS one").limit(1)
+      relation = apply_join_dependency(self, construct_join_dependency)
+      return false if ActiveRecord::NullRelation === relation
+
+      relation = relation.except(:select, :order).select(ONE_AS_ONE).limit(1)
 
       case conditions
       when Array, Hash
@@ -171,9 +215,7 @@ module ActiveRecord
         relation = relation.where(table[primary_key].eq(conditions)) if conditions != :none
       end
 
-      connection.select_value(relation, "#{name} Exists", relation.bind_values)
-    rescue ThrowResult
-      false
+      connection.select_value(relation, "#{name} Exists", relation.bind_values) ? true : false
     end
 
     # This method is called whenever no records are found with either a single
@@ -198,19 +240,29 @@ module ActiveRecord
       raise RecordNotFound, error
     end
 
-    protected
+    private
 
     def find_with_associations
       join_dependency = construct_join_dependency
-      relation = construct_relation_for_association_find(join_dependency)
-      rows = connection.select_all(relation, 'SQL', relation.bind_values.dup)
-      join_dependency.instantiate(rows)
-    rescue ThrowResult
-      []
+
+      aliases  = join_dependency.aliases
+      relation = select aliases.columns
+      relation = apply_join_dependency(relation, join_dependency)
+
+      if block_given?
+        yield relation
+      else
+        if ActiveRecord::NullRelation === relation
+          []
+        else
+          rows = connection.select_all(relation.arel, 'SQL', relation.bind_values.dup)
+          join_dependency.instantiate(rows, aliases)
+        end
+      end
     end
 
     def construct_join_dependency(joins = [])
-      including = (eager_load_values + includes_values).uniq
+      including = eager_load_values + includes_values
       ActiveRecord::Associations::JoinDependency.new(@klass, including, joins)
     end
 
@@ -218,36 +270,40 @@ module ActiveRecord
       apply_join_dependency(self, construct_join_dependency(arel.froms.first))
     end
 
-    def construct_relation_for_association_find(join_dependency)
-      relation = except(:select).select(join_dependency.columns)
-      apply_join_dependency(relation, join_dependency)
-    end
-
     def apply_join_dependency(relation, join_dependency)
       relation = relation.except(:includes, :eager_load, :preload)
-      relation = join_dependency.join_relation(relation)
+      relation = relation.joins join_dependency
 
       if using_limitable_reflections?(join_dependency.reflections)
         relation
       else
-        relation.where!(construct_limited_ids_condition(relation)) if relation.limit_value
+        if relation.limit_value
+          limited_ids = limited_ids_for(relation)
+          limited_ids.empty? ? relation.none! : relation.where!(table[primary_key].in(limited_ids))
+        end
         relation.except(:limit, :offset)
       end
     end
 
-    def construct_limited_ids_condition(relation)
+    def limited_ids_for(relation)
       values = @klass.connection.columns_for_distinct(
         "#{quoted_table_name}.#{quoted_primary_key}", relation.order_values)
 
       relation = relation.except(:select).select(values).distinct!
 
       id_rows = @klass.connection.select_all(relation.arel, 'SQL', relation.bind_values)
-      ids_array = id_rows.map {|row| row[primary_key]}
+      id_rows.map {|row| row[primary_key]}
+    end
 
-      ids_array.empty? ? raise(ThrowResult) : table[primary_key].in(ids_array)
+    def using_limitable_reflections?(reflections)
+      reflections.none? { |r| r.collection? }
     end
 
+    protected
+
     def find_with_ids(*ids)
+      raise UnknownPrimaryKey.new(@klass) if primary_key.nil?
+
       expects_array = ids.first.kind_of?(Array)
       return ids.first if expects_array && ids.first.empty?
 
@@ -312,12 +368,15 @@ module ActiveRecord
       if loaded?
         @records.first
       else
-        @first ||=
-          if with_default_scope.order_values.empty? && primary_key
-            order(arel_table[primary_key].asc).limit(1).to_a.first
-          else
-            limit(1).to_a.first
-          end
+        @first ||= find_first_with_limit(1).first
+      end
+    end
+
+    def find_first_with_limit(limit)
+      if order_values.empty? && primary_key
+        order(arel_table[primary_key].asc).limit(limit).to_a
+      else
+        limit(limit).to_a
       end
     end
 
@@ -326,16 +385,12 @@ module ActiveRecord
         @records.last
       else
         @last ||=
-          if offset_value || limit_value
+          if limit_value
             to_a.last
           else
             reverse_order.limit(1).to_a.first
           end
       end
     end
-
-    def using_limitable_reflections?(reflections)
-      reflections.none? { |r| r.collection? }
-    end
   end
 end
diff --git a/activerecord/lib/active_record/relation/merger.rb b/activerecord/lib/active_record/relation/merger.rb
index c114ea0c0d..182b9ed89c 100644
--- a/activerecord/lib/active_record/relation/merger.rb
+++ b/activerecord/lib/active_record/relation/merger.rb
@@ -22,7 +22,7 @@ module ActiveRecord
       # build a relation to merge in rather than directly merging
       # the values.
       def other
-        other = Relation.new(relation.klass, relation.table)
+        other = Relation.create(relation.klass, relation.table)
         hash.each { |k, v|
           if k == :joins
             if Hash === v
@@ -42,10 +42,6 @@ module ActiveRecord
       attr_reader :relation, :values, :other
 
       def initialize(relation, other)
-        if other.default_scoped? && other.klass != relation.klass
-          other = other.with_default_scope
-        end
-
         @relation = relation
         @values   = other.values
         @other    = other
@@ -62,7 +58,11 @@ module ActiveRecord
       def merge
         normal_values.each do |name|
           value = values[name]
-          relation.send("#{name}!", *value) unless value.blank?
+          # The unless clause is here mostly for performance reasons (since the `send` call might be moderately
+          # expensive), most of the time the value is going to be `nil` or `.blank?`, the only catch is that
+          # `false.blank?` returns `true`, so there needs to be an extra check so that explicit `false` values
+          # don't fall through the cracks.
+          relation.send("#{name}!", *value) unless value.nil? || (value.blank? && false != value)
         end
 
         merge_multi_values
@@ -94,26 +94,42 @@ module ActiveRecord
                                                                            [])
           relation.joins! rest
 
-          @relation = join_dependency.join_relation(relation)
+          @relation = relation.joins join_dependency
         end
       end
 
       def merge_multi_values
         lhs_wheres = relation.where_values
         rhs_wheres = values[:where] || []
+
         lhs_binds  = relation.bind_values
         rhs_binds  = values[:bind] || []
 
         removed, kept = partition_overwrites(lhs_wheres, rhs_wheres)
 
-        relation.where_values = kept + rhs_wheres
-        relation.bind_values  = filter_binds(lhs_binds, removed) + rhs_binds
+        where_values = kept + rhs_wheres
+        bind_values  = filter_binds(lhs_binds, removed) + rhs_binds
+
+        conn = relation.klass.connection
+        bv_index = 0
+        where_values.map! do |node|
+          if Arel::Nodes::Equality === node && Arel::Nodes::BindParam === node.right
+            substitute = conn.substitute_at(bind_values[bv_index].first, bv_index)
+            bv_index += 1
+            Arel::Nodes::Equality.new(node.left, substitute)
+          else
+            node
+          end
+        end
+
+        relation.where_values = where_values
+        relation.bind_values  = bind_values
 
         if values[:reordering]
           # override any order specified in the original relation
           relation.reorder! values[:order]
         elsif values[:order]
-          # merge in order_values from r
+          # merge in order_values from relation
           relation.order! values[:order]
         end
 
diff --git a/activerecord/lib/active_record/relation/predicate_builder.rb b/activerecord/lib/active_record/relation/predicate_builder.rb
index b7609c97b5..1252af7635 100644
--- a/activerecord/lib/active_record/relation/predicate_builder.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder.rb
@@ -1,15 +1,26 @@
 module ActiveRecord
   class PredicateBuilder # :nodoc:
+    @handlers = []
+
+    autoload :RelationHandler, 'active_record/relation/predicate_builder/relation_handler'
+    autoload :ArrayHandler, 'active_record/relation/predicate_builder/array_handler'
+
+    def self.resolve_column_aliases(klass, hash)
+      hash = hash.dup
+      hash.keys.grep(Symbol) do |key|
+        if klass.attribute_alias? key
+          hash[klass.attribute_alias(key)] = hash.delete key
+        end
+      end
+      hash
+    end
+
     def self.build_from_hash(klass, attributes, default_table)
       queries = []
 
       attributes.each do |column, value|
         table = default_table
 
-        if column.is_a?(Symbol) && klass.attribute_aliases.key?(column.to_s)
-          column = klass.attribute_aliases[column.to_s]
-        end
-
         if value.is_a?(Hash)
           if value.empty?
             queries << '1=0'
@@ -44,9 +55,9 @@ module ActiveRecord
       #
       # For polymorphic relationships, find the foreign key and type:
       # PriceEstimate.where(estimate_of: treasure)
-      if klass && value.class < Base && reflection = klass.reflect_on_association(column.to_sym)
-        if reflection.polymorphic?
-          queries << build(table[reflection.foreign_type], value.class.base_class)
+      if klass && reflection = klass.reflect_on_association(column.to_sym)
+        if reflection.polymorphic? && base_class = polymorphic_base_class_from_value(value)
+          queries << build(table[reflection.foreign_type], base_class)
         end
 
         column = reflection.foreign_key
@@ -56,6 +67,18 @@ module ActiveRecord
       queries
     end
 
+    def self.polymorphic_base_class_from_value(value)
+      case value
+      when Relation
+        value.klass.base_class
+      when Array
+        val = value.compact.first
+        val.class.base_class if val.is_a?(Base)
+      when Base
+        value.class.base_class
+      end
+    end
+
     def self.references(attributes)
       attributes.map do |key, value|
         if value.is_a?(Hash)
@@ -67,44 +90,36 @@ module ActiveRecord
       end.compact
     end
 
+    # Define how a class is converted to Arel nodes when passed to +where+.
+    # The handler can be any object that responds to +call+, and will be used
+    # for any value that +===+ the class given. For example:
+    #
+    #     MyCustomDateRange = Struct.new(:start, :end)
+    #     handler = proc do |column, range|
+    #       Arel::Nodes::Between.new(column,
+    #         Arel::Nodes::And.new([range.start, range.end])
+    #       )
+    #     end
+    #     ActiveRecord::PredicateBuilder.register_handler(MyCustomDateRange, handler)
+    def self.register_handler(klass, handler)
+      @handlers.unshift([klass, handler])
+    end
+
+    register_handler(BasicObject, ->(attribute, value) { attribute.eq(value) })
+    # FIXME: I think we need to deprecate this behavior
+    register_handler(Class, ->(attribute, value) { attribute.eq(value.name) })
+    register_handler(Base, ->(attribute, value) { attribute.eq(value.id) })
+    register_handler(Range, ->(attribute, value) { attribute.in(value) })
+    register_handler(Relation, RelationHandler.new)
+    register_handler(Array, ArrayHandler.new)
+
     private
       def self.build(attribute, value)
-        case value
-        when Array
-          values = value.to_a.map {|x| x.is_a?(Base) ? x.id : x}
-          ranges, values = values.partition {|v| v.is_a?(Range)}
-
-          values_predicate = if values.include?(nil)
-            values = values.compact
-
-            case values.length
-            when 0
-              attribute.eq(nil)
-            when 1
-              attribute.eq(values.first).or(attribute.eq(nil))
-            else
-              attribute.in(values).or(attribute.eq(nil))
-            end
-          else
-            attribute.in(values)
-          end
+        handler_for(value).call(attribute, value)
+      end
 
-          array_predicates = ranges.map { |range| attribute.in(range) }
-          array_predicates << values_predicate
-          array_predicates.inject { |composite, predicate| composite.or(predicate) }
-        when ActiveRecord::Relation
-          value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
-          attribute.in(value.arel.ast)
-        when Range
-          attribute.in(value)
-        when ActiveRecord::Base
-          attribute.eq(value.id)
-        when Class
-          # FIXME: I think we need to deprecate this behavior
-          attribute.eq(value.name)
-        else
-          attribute.eq(value)
-        end
+      def self.handler_for(object)
+        @handlers.detect { |klass, _| klass === object }.last
       end
   end
 end
diff --git a/activerecord/lib/active_record/relation/predicate_builder/array_handler.rb b/activerecord/lib/active_record/relation/predicate_builder/array_handler.rb
new file mode 100644
index 0000000000..2f6c34ac08
--- /dev/null
+++ b/activerecord/lib/active_record/relation/predicate_builder/array_handler.rb
@@ -0,0 +1,29 @@
+module ActiveRecord
+  class PredicateBuilder
+    class ArrayHandler # :nodoc:
+      def call(attribute, value)
+        values = value.map { |x| x.is_a?(Base) ? x.id : x }
+        ranges, values = values.partition { |v| v.is_a?(Range) }
+
+        values_predicate = if values.include?(nil)
+          values = values.compact
+
+          case values.length
+          when 0
+            attribute.eq(nil)
+          when 1
+            attribute.eq(values.first).or(attribute.eq(nil))
+          else
+            attribute.in(values).or(attribute.eq(nil))
+          end
+        else
+          attribute.in(values)
+        end
+
+        array_predicates = ranges.map { |range| attribute.in(range) }
+        array_predicates << values_predicate
+        array_predicates.inject { |composite, predicate| composite.or(predicate) }
+      end
+    end
+  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
new file mode 100644
index 0000000000..618fa3cdd9
--- /dev/null
+++ b/activerecord/lib/active_record/relation/predicate_builder/relation_handler.rb
@@ -0,0 +1,13 @@
+module ActiveRecord
+  class PredicateBuilder
+    class RelationHandler # :nodoc:
+      def call(attribute, value)
+        if value.select_values.empty?
+          value = value.select(value.klass.arel_table[value.klass.primary_key])
+        end
+
+        attribute.in(value.arel.ast)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
index c27afb512f..fc653f467c 100644
--- a/activerecord/lib/active_record/relation/query_methods.rb
+++ b/activerecord/lib/active_record/relation/query_methods.rb
@@ -37,6 +37,8 @@ module ActiveRecord
       def not(opts, *rest)
         where_value = @scope.send(:build_where, opts, rest).map do |rel|
           case rel
+          when NilClass
+            raise ArgumentError, 'Invalid argument for .where.not(), got nil.'
           when Arel::Nodes::In
             Arel::Nodes::NotIn.new(rel.left, rel.right)
           when Arel::Nodes::Equality
@@ -100,6 +102,14 @@ module ActiveRecord
     # firing an additional query. This will often result in a
     # performance improvement over a simple +join+.
     #
+    # You can also specify multiple relationships, like this:
+    #
+    #   users = User.includes(:address, :friends)
+    #
+    # Loading nested relationships is possible using a Hash:
+    #
+    #   users = User.includes(:address, friends: [:address, :followers])
+    #
     # === conditions
     #
     # If you want to add conditions to your included models you'll have
@@ -111,14 +121,15 @@ module ActiveRecord
     #
     #   User.includes(:posts).where('posts.name = ?', 'example').references(:posts)
     def includes(*args)
-      check_if_method_has_arguments!("includes", args)
+      check_if_method_has_arguments!(:includes, args)
       spawn.includes!(*args)
     end
 
     def includes!(*args) # :nodoc:
-      args.reject! {|a| a.blank? }
+      args.reject!(&:blank?)
+      args.flatten!
 
-      self.includes_values = (includes_values + args).flatten.uniq
+      self.includes_values |= args
       self
     end
 
@@ -129,7 +140,7 @@ module ActiveRecord
     #   FROM "users" LEFT OUTER JOIN "posts" ON "posts"."user_id" =
     #   "users"."id"
     def eager_load(*args)
-      check_if_method_has_arguments!("eager_load", args)
+      check_if_method_has_arguments!(:eager_load, args)
       spawn.eager_load!(*args)
     end
 
@@ -143,7 +154,7 @@ module ActiveRecord
     #   User.preload(:posts)
     #   => SELECT "posts".* FROM "posts" WHERE "posts"."user_id" IN (1, 2, 3)
     def preload(*args)
-      check_if_method_has_arguments!("preload", args)
+      check_if_method_has_arguments!(:preload, args)
       spawn.preload!(*args)
     end
 
@@ -161,14 +172,15 @@ module ActiveRecord
     #   User.includes(:posts).where("posts.name = 'foo'").references(:posts)
     #   # => Query now knows the string references posts, so adds a JOIN
     def references(*args)
-      check_if_method_has_arguments!("references", args)
+      check_if_method_has_arguments!(:references, args)
       spawn.references!(*args)
     end
 
     def references!(*args) # :nodoc:
       args.flatten!
+      args.map!(&:to_s)
 
-      self.references_values = (references_values + args.map!(&:to_s)).uniq
+      self.references_values |= args
       self
     end
 
@@ -221,7 +233,9 @@ module ActiveRecord
     end
 
     def select!(*fields) # :nodoc:
-      self.select_values += fields.flatten
+      fields.flatten!
+
+      self.select_values += fields
       self
     end
 
@@ -241,7 +255,7 @@ module ActiveRecord
     #   User.group('name AS grouped_name, age')
     #   => [#<User id: 3, name: "Foo", age: 21, ...>, #<User id: 2, name: "Oscar", age: 21, ...>, #<User id: 5, name: "Foo", age: 23, ...>]
     def group(*args)
-      check_if_method_has_arguments!("group", args)
+      check_if_method_has_arguments!(:group, args)
       spawn.group!(*args)
     end
 
@@ -272,24 +286,14 @@ module ActiveRecord
     #   User.order(:name, email: :desc)
     #   => SELECT "users".* FROM "users" ORDER BY "users"."name" ASC, "users"."email" DESC
     def order(*args)
-      check_if_method_has_arguments!("order", args)
+      check_if_method_has_arguments!(:order, args)
       spawn.order!(*args)
     end
 
     def order!(*args) # :nodoc:
-      args.flatten!
-      validate_order_args args
+      preprocess_order_args(args)
 
-      references = args.reject { |arg| Arel::Node === arg }
-      references.map! { |arg| arg =~ /^([a-zA-Z]\w*)\.(\w+)/ && $1 }.compact!
-      references!(references) if references.any?
-
-      # if a symbol is given we prepend the quoted table name
-      args = args.map { |arg|
-        arg.is_a?(Symbol) ? "#{quoted_table_name}.#{arg} ASC" : arg
-      }
-
-      self.order_values = args + self.order_values
+      self.order_values += args
       self
     end
 
@@ -301,15 +305,14 @@ module ActiveRecord
     #
     #   User.order('email DESC').reorder('id ASC').order('name ASC')
     #
-    # generates a query with 'ORDER BY name ASC, id ASC'.
+    # generates a query with 'ORDER BY id ASC, name ASC'.
     def reorder(*args)
-      check_if_method_has_arguments!("reorder", args)
+      check_if_method_has_arguments!(:reorder, args)
       spawn.reorder!(*args)
     end
 
     def reorder!(*args) # :nodoc:
-      args.flatten!
-      validate_order_args args
+      preprocess_order_args(args)
 
       self.reordering_value = true
       self.order_values = args
@@ -340,23 +343,27 @@ module ActiveRecord
     #   User.where(name: "John", active: true).unscope(where: :name)
     #       == User.where(active: true)
     #
-    # This method is applied before the default_scope is applied. So the conditions
-    # specified in default_scope will not be removed.
+    # This method is similar to <tt>except</tt>, but unlike
+    # <tt>except</tt>, it persists across merges:
     #
-    # Note that this method is more generalized than ActiveRecord::SpawnMethods#except
-    # because #except will only affect a particular relation's values. It won't wipe
-    # the order, grouping, etc. when that relation is merged. For example:
+    #   User.order('email').merge(User.except(:order))
+    #       == User.order('email')
     #
-    #   Post.comments.except(:order)
+    #   User.order('email').merge(User.unscope(:order))
+    #       == User.all
+    #
+    # This means it can be used in association definitions:
+    #
+    #   has_many :comments, -> { unscope where: :trashed }
     #
-    # will still have an order if it comes from the default_scope on Comment.
     def unscope(*args)
-      check_if_method_has_arguments!("unscope", args)
+      check_if_method_has_arguments!(:unscope, args)
       spawn.unscope!(*args)
     end
 
     def unscope!(*args) # :nodoc:
       args.flatten!
+      self.unscope_values += args
 
       args.each do |scope|
         case scope
@@ -393,8 +400,12 @@ module ActiveRecord
     #   User.joins("LEFT JOIN bookmarks ON bookmarks.bookmarkable_type = 'Post' AND bookmarks.user_id = users.id")
     #   => SELECT "users".* FROM "users" LEFT JOIN bookmarks ON bookmarks.bookmarkable_type = 'Post' AND bookmarks.user_id = users.id
     def joins(*args)
-      check_if_method_has_arguments!("joins", args)
-      spawn.joins!(*args.compact.flatten)
+      check_if_method_has_arguments!(:joins, args)
+
+      args.compact!
+      args.flatten!
+
+      spawn.joins!(*args)
     end
 
     def joins!(*args) # :nodoc:
@@ -421,7 +432,7 @@ module ActiveRecord
     # === string
     #
     # A single string, without additional arguments, is passed to the query
-    # constructor as a SQL fragment, and used in the where clause of the query.
+    # constructor as an SQL fragment, and used in the where clause of the query.
     #
     #    Client.where("orders_count = '2'")
     #    # SELECT * from clients where orders_count = '2';
@@ -551,6 +562,18 @@ module ActiveRecord
       end
     end
 
+    # Allows you to change a previously set where condition for a given attribute, instead of appending to that condition.
+    #
+    #   Post.where(trashed: true).where(trashed: false)                       # => WHERE `trashed` = 1 AND `trashed` = 0
+    #   Post.where(trashed: true).rewhere(trashed: false)                     # => WHERE `trashed` = 0
+    #   Post.where(active: true).where(trashed: true).rewhere(trashed: false) # => WHERE `active` = 1 AND `trashed` = 0
+    #
+    # This is short-hand for unscope(where: conditions.keys).where(conditions). Note that unlike reorder, we're only unscoping
+    # the named conditions -- not the entire where statement.
+    def rewhere(conditions)
+      unscope(where: conditions.keys).where(conditions)
+    end
+
     # Allows to specify a HAVING clause. Note that you can't use HAVING
     # without also specifying a GROUP clause.
     #
@@ -613,12 +636,11 @@ module ActiveRecord
       self
     end
 
-    # Returns a chainable relation with zero records, specifically an
-    # instance of the <tt>ActiveRecord::NullRelation</tt> class.
+    # Returns a chainable relation with zero records.
     #
-    # The returned <tt>ActiveRecord::NullRelation</tt> inherits from Relation and implements the
-    # Null Object pattern. It is an object with defined null behavior and always returns an empty
-    # array of records without querying the database.
+    # The returned relation implements the Null Object pattern. It is an
+    # object with defined null behavior and always returns an empty array of
+    # records without querying the database.
     #
     # Any subsequent condition chained to the returned relation will continue
     # generating an empty relation and will not fire any query to the database.
@@ -638,7 +660,7 @@ module ActiveRecord
     #     when 'Reviewer'
     #       Post.published
     #     when 'Bad User'
-    #       Post.none # => returning [] instead breaks the previous code
+    #       Post.none # It can't be chained if [] is returned.
     #     end
     #   end
     #
@@ -690,7 +712,7 @@ module ActiveRecord
     # Specifies table from which the records will be fetched. For example:
     #
     #   Topic.select('title').from('posts')
-    #   #=> SELECT title FROM posts
+    #   # => SELECT title FROM posts
     #
     # Can accept other relation objects. For example:
     #
@@ -776,9 +798,10 @@ module ActiveRecord
     end
 
     def extending!(*modules, &block) # :nodoc:
-      modules << Module.new(&block) if block_given?
+      modules << Module.new(&block) if block
+      modules.flatten!
 
-      self.extending_values += modules.flatten
+      self.extending_values += modules
       extend(*extending_values) if extending_values.any?
 
       self
@@ -798,23 +821,23 @@ module ActiveRecord
 
     # Returns the Arel object associated with the relation.
     def arel
-      @arel ||= with_default_scope.build_arel
+      @arel ||= build_arel
     end
 
     # Like #arel, but ignores the default scope of the model.
     def build_arel
       arel = Arel::SelectManager.new(table.engine, table)
 
-      build_joins(arel, joins_values) unless joins_values.empty?
+      build_joins(arel, joins_values.flatten) unless joins_values.empty?
 
       collapse_wheres(arel, (where_values - [''])) #TODO: Add uniq with real value comparison / ignore uniqs that have binds
 
-      arel.having(*having_values.uniq.reject{|h| h.blank?}) unless having_values.empty?
+      arel.having(*having_values.uniq.reject(&:blank?)) unless having_values.empty?
 
       arel.take(connection.sanitize_limit(limit_value)) if limit_value
       arel.skip(offset_value.to_i) if offset_value
 
-      arel.group(*group_values.uniq.reject{|g| g.blank?}) unless group_values.empty?
+      arel.group(*group_values.uniq.reject(&:blank?)) unless group_values.empty?
 
       build_order(arel)
 
@@ -853,7 +876,7 @@ module ActiveRecord
 
       where_values.reject! do |rel|
         case rel
-        when Arel::Nodes::In, Arel::Nodes::Equality
+        when Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual
           subrelation = (rel.left.kind_of?(Arel::Attributes::Attribute) ? rel.left : rel.right)
           subrelation.name.to_sym == target_value_sym
         else
@@ -863,13 +886,11 @@ module ActiveRecord
     end
 
     def custom_join_ast(table, joins)
-      joins = joins.reject { |join| join.blank? }
+      joins = joins.reject(&:blank?)
 
       return [] if joins.empty?
 
-      @implicit_readonly = true
-
-      joins.map do |join|
+      joins.map! do |join|
         case join
         when Array
           join = Arel.sql(join.join(' ')) if array_of_strings?(join)
@@ -881,22 +902,30 @@ module ActiveRecord
     end
 
     def collapse_wheres(arel, wheres)
-      equalities = wheres.grep(Arel::Nodes::Equality)
-
-      arel.where(Arel::Nodes::And.new(equalities)) unless equalities.empty?
-
-      (wheres - equalities).each do |where|
+      predicates = wheres.map do |where|
+        next where if ::Arel::Nodes::Equality === where
         where = Arel.sql(where) if String === where
-        arel.where(Arel::Nodes::Grouping.new(where))
+        Arel::Nodes::Grouping.new(where)
       end
+
+      arel.where(Arel::Nodes::And.new(predicates)) if predicates.present?
     end
 
     def build_where(opts, other = [])
       case opts
       when String, Array
+        #TODO: Remove duplication with: /activerecord/lib/active_record/sanitization.rb:113
+        values = Hash === other.first ? other.first.values : other
+
+        values.grep(ActiveRecord::Relation) do |rel|
+          self.bind_values += rel.bind_values
+        end
+
         [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
       when Hash
         temp_opts = opts.dup
+        opts = PredicateBuilder.resolve_column_aliases(klass, opts)
+        attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)
 
         create_binds(temp_opts)
         temp_opts = substitute_opts(temp_opts)
@@ -941,6 +970,7 @@ module ActiveRecord
       case opts
       when Relation
         name ||= 'subquery'
+        self.bind_values = opts.bind_values + self.bind_values
         opts.arel.as(name.to_s)
       else
         opts
@@ -954,7 +984,7 @@ module ActiveRecord
           :string_join
         when Hash, Symbol, Array
           :association_join
-        when ActiveRecord::Associations::JoinDependency::JoinAssociation
+        when ActiveRecord::Associations::JoinDependency
           :stashed_join
         when Arel::Nodes::Join
           :join_node
@@ -966,7 +996,7 @@ module ActiveRecord
       association_joins         = buckets[:association_join] || []
       stashed_association_joins = buckets[:stashed_join] || []
       join_nodes                = (buckets[:join_node] || []).uniq
-      string_joins              = (buckets[:string_join] || []).map { |x| x.strip }.uniq
+      string_joins              = (buckets[:string_join] || []).map(&:strip).uniq
 
       join_list = join_nodes + custom_join_ast(manager, string_joins)
 
@@ -976,24 +1006,20 @@ module ActiveRecord
         join_list
       )
 
-      join_dependency.graft(*stashed_association_joins)
+      joins = join_dependency.join_constraints stashed_association_joins
 
-      @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
+      joins.each { |join| manager.from(join) }
 
-      # FIXME: refactor this to build an AST
-      join_dependency.join_associations.each do |association|
-        association.join_to(manager, self)
-      end
-
-      manager.join_sources.concat join_list
+      manager.join_sources.concat(join_list)
 
       manager
     end
 
     def build_select(arel, selects)
-      unless selects.empty?
-        @implicit_readonly = false
+      if !selects.empty?
         arel.project(*selects)
+      elsif from_value
+        arel.project(Arel.star)
       else
         arel.project(@klass.arel_table[Arel.star])
       end
@@ -1007,16 +1033,10 @@ module ActiveRecord
         when Arel::Nodes::Ordering
           o.reverse
         when String
-          o.to_s.split(',').collect do |s|
+          o.to_s.split(',').map! do |s|
             s.strip!
             s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
           end
-        when Symbol
-          { o => :desc }
-        when Hash
-          o.each_with_object({}) do |(field, dir), memo|
-            memo[field] = (dir == :asc ? :desc : :asc )
-          end
         else
           o
         end
@@ -1024,35 +1044,48 @@ module ActiveRecord
     end
 
     def array_of_strings?(o)
-      o.is_a?(Array) && o.all?{|obj| obj.is_a?(String)}
+      o.is_a?(Array) && o.all? { |obj| obj.is_a?(String) }
     end
 
     def build_order(arel)
-      orders = order_values
+      orders = order_values.uniq
+      orders.reject!(&:blank?)
       orders = reverse_sql_order(orders) if reverse_order_value
 
-      orders = orders.uniq.reject(&:blank?).flat_map do |order|
-        case order
-        when Symbol
-          table[order].asc
-        when Hash
-          order.map { |field, dir| table[field].send(dir) }
-        else
-          order
-        end
-      end
-
       arel.order(*orders) unless orders.empty?
     end
 
     def validate_order_args(args)
-      args.select { |a| Hash === a  }.each do |h|
+      args.grep(Hash) do |h|
         unless (h.values - [:asc, :desc]).empty?
           raise ArgumentError, 'Direction should be :asc or :desc'
         end
       end
     end
 
+    def preprocess_order_args(order_args)
+      order_args.flatten!
+      validate_order_args(order_args)
+
+      references = order_args.grep(String)
+      references.map! { |arg| arg =~ /^([a-zA-Z]\w*)\.(\w+)/ && $1 }.compact!
+      references!(references) if references.any?
+
+      # if a symbol is given we prepend the quoted table name
+      order_args.map! do |arg|
+        case arg
+        when Symbol
+          table[arg].asc
+        when Hash
+          arg.map { |field, dir|
+            table[field].send(dir)
+          }
+        else
+          arg
+        end
+      end.flatten!
+    end
+
     # Checks to make sure that the arguments are not blank. Note that if some
     # blank-like object were initially passed into the query method, then this
     # method will not raise an error.
diff --git a/activerecord/lib/active_record/relation/spawn_methods.rb b/activerecord/lib/active_record/relation/spawn_methods.rb
index de784f9f57..2552cbd234 100644
--- a/activerecord/lib/active_record/relation/spawn_methods.rb
+++ b/activerecord/lib/active_record/relation/spawn_methods.rb
@@ -64,8 +64,7 @@ module ActiveRecord
     private
 
       def relation_with(values) # :nodoc:
-        result = Relation.new(klass, table, values)
-        result.default_scoped = default_scoped
+        result = Relation.create(klass, table, values)
         result.extend(*extending_values) if extending_values.any?
         result
       end