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

1 files changed, 108 insertions, 53 deletions

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