6 files changed, 217 insertions, 77 deletions

diff --git a/activerecord/test/cases/relation/delegation_test.rb b/activerecord/test/cases/relation/delegation_test.rb
index 9b2bfed039..29c9d0e2af 100644
--- a/activerecord/test/cases/relation/delegation_test.rb
+++ b/activerecord/test/cases/relation/delegation_test.rb
@@ -32,7 +32,7 @@ module ActiveRecord
       :exclude?, :find_all, :flat_map, :group_by, :include?, :length,
       :map, :none?, :one?, :partition, :reject, :reverse,
       :sample, :second, :sort, :sort_by, :third,
-      :to_ary, :to_set, :to_xml, :to_yaml
+      :to_ary, :to_set, :to_xml, :to_yaml, :join
     ]
 
     ARRAY_DELEGATES.each do |method|
diff --git a/activerecord/test/cases/relation/merging_test.rb b/activerecord/test/cases/relation/merging_test.rb
index 23500bf5d8..eb76ef6328 100644
--- a/activerecord/test/cases/relation/merging_test.rb
+++ b/activerecord/test/cases/relation/merging_test.rb
@@ -2,8 +2,10 @@ require 'cases/helper'
 require 'models/author'
 require 'models/comment'
 require 'models/developer'
+require 'models/computer'
 require 'models/post'
 require 'models/project'
+require 'models/rating'
 
 class RelationMergingTest < ActiveRecord::TestCase
   fixtures :developers, :comments, :authors, :posts
@@ -17,10 +19,9 @@ class RelationMergingTest < ActiveRecord::TestCase
   end
 
   def test_relation_to_sql
-    sql = Post.connection.unprepared_statement do
-      Post.first.comments.to_sql
-    end
-    assert_no_match(/\?/, sql)
+    post = Post.first
+    sql = post.comments.to_sql
+    assert_match(/.?post_id.? = #{post.id}\Z/i, sql)
   end
 
   def test_relation_merging_with_arel_equalities_keeps_last_equality
@@ -81,31 +82,20 @@ class RelationMergingTest < ActiveRecord::TestCase
     left  = Post.where(title: "omg").where(comments_count: 1)
     right = Post.where(title: "wtf").where(title: "bbq")
 
-    expected = [left.where_values[1]] + right.where_values
+    expected = [left.bind_values[1]] + right.bind_values
     merged   = left.merge(right)
 
-    assert_equal expected, merged.where_values
+    assert_equal expected, merged.bind_values
     assert !merged.to_sql.include?("omg")
     assert merged.to_sql.include?("wtf")
     assert merged.to_sql.include?("bbq")
   end
 
-  def test_merging_removes_rhs_bind_parameters
-    left  = Post.where(id: Arel::Nodes::BindParam.new('?'))
-    column = Post.columns_hash['id']
-    left.bind_values += [[column, 20]]
-    right   = Post.where(id: 10)
-
-    merged = left.merge(right)
-    assert_equal [], merged.bind_values
-  end
-
   def test_merging_keeps_lhs_bind_parameters
     column = Post.columns_hash['id']
     binds = [[column, 20]]
 
-    right  = Post.where(id: Arel::Nodes::BindParam.new('?'))
-    right.bind_values += binds
+    right  = Post.where(id: 20)
     left   = Post.where(id: 10)
 
     merged = left.merge(right)
@@ -113,25 +103,22 @@ class RelationMergingTest < ActiveRecord::TestCase
   end
 
   def test_merging_reorders_bind_params
-    post         = Post.first
-    id_column    = Post.columns_hash['id']
-    title_column = Post.columns_hash['title']
-
-    bv = Post.connection.substitute_at id_column, 0
-
-    right  = Post.where(id: bv)
-    right.bind_values += [[id_column, post.id]]
-
-    left   = Post.where(title: bv)
-    left.bind_values += [[title_column, post.title]]
+    post  = Post.first
+    right = Post.where(id: 1)
+    left  = Post.where(title: post.title)
 
     merged = left.merge(right)
     assert_equal post, merged.first
   end
+
+  def test_merging_compares_symbols_and_strings_as_equal
+    post = PostThatLoadsCommentsInAnAfterSaveHook.create!(title: "First Post", body: "Blah blah blah.")
+    assert_equal "First comment!", post.comments.where(body: "First comment!").first_or_create.body
+  end
 end
 
 class MergingDifferentRelationsTest < ActiveRecord::TestCase
-  fixtures :posts, :authors
+  fixtures :posts, :authors, :developers
 
   test "merging where relations" do
     hello_by_bob = Post.where(body: "hello").joins(:author).
@@ -159,4 +146,16 @@ class MergingDifferentRelationsTest < ActiveRecord::TestCase
 
     assert_equal ["Mary", "Mary", "Mary", "David"], posts_by_author_name
   end
+
+  test "relation merging (using a proc  argument)" do
+    dev = Developer.where(name: "Jamis").first
+
+    comment_1 = dev.comments.create!(body: "I'm Jamis", post: Post.first)
+    rating_1 = comment_1.ratings.create!
+
+    comment_2 = dev.comments.create!(body: "I'm John", post: Post.first)
+    comment_2.ratings.create!
+
+    assert_equal dev.ratings, [rating_1]
+  end
 end
diff --git a/activerecord/test/cases/relation/mutation_test.rb b/activerecord/test/cases/relation/mutation_test.rb
index 7cb2a19bee..2443f10269 100644
--- a/activerecord/test/cases/relation/mutation_test.rb
+++ b/activerecord/test/cases/relation/mutation_test.rb
@@ -14,19 +14,32 @@ module ActiveRecord
       def relation_delegate_class(klass)
         self.class.relation_delegate_class(klass)
       end
+
+      def attribute_alias?(name)
+        false
+      end
+
+      def sanitize_sql(sql)
+        sql
+      end
     end
 
     def relation
-      @relation ||= Relation.new FakeKlass.new('posts'), Post.arel_table
+      @relation ||= Relation.new FakeKlass.new('posts'), Post.arel_table, Post.predicate_builder
     end
 
-    (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope]).each do |method|
+    (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal [:foo], relation.public_send("#{method}_values")
       end
     end
 
+    test "#_select!" do
+      assert relation.public_send("_select!", :foo).equal?(relation)
+      assert_equal [:foo], relation.public_send("select_values")
+    end
+
     test '#order!' do
       assert relation.order!('name ASC').equal?(relation)
       assert_equal ['name ASC'], relation.order_values
@@ -86,7 +99,7 @@ module ActiveRecord
     end
 
     test '#reorder!' do
-      relation = self.relation.order('foo')
+      @relation = self.relation.order('foo')
 
       assert relation.reorder!('bar').equal?(relation)
       assert_equal ['bar'], relation.order_values
@@ -103,10 +116,18 @@ module ActiveRecord
     end
 
     test 'reverse_order!' do
-      assert relation.reverse_order!.equal?(relation)
-      assert relation.reverse_order_value
+      @relation = Post.order('title ASC, comments_count DESC')
+
+      relation.reverse_order!
+
+      assert_equal 'title DESC', relation.order_values.first
+      assert_equal 'comments_count ASC', relation.order_values.last
+
+
       relation.reverse_order!
-      assert !relation.reverse_order_value
+
+      assert_equal 'title ASC', relation.order_values.first
+      assert_equal 'comments_count DESC', relation.order_values.last
     end
 
     test 'create_with!' do
diff --git a/activerecord/test/cases/relation/predicate_builder_test.rb b/activerecord/test/cases/relation/predicate_builder_test.rb
index 14a8d97d36..0cc081fced 100644
--- a/activerecord/test/cases/relation/predicate_builder_test.rb
+++ b/activerecord/test/cases/relation/predicate_builder_test.rb
@@ -4,11 +4,13 @@ require 'models/topic'
 module ActiveRecord
   class PredicateBuilderTest < ActiveRecord::TestCase
     def test_registering_new_handlers
-      PredicateBuilder.register_handler(Regexp, proc do |column, value|
-        Arel::Nodes::InfixOperation.new('~', column, value.source)
+      Topic.predicate_builder.register_handler(Regexp, proc do |column, value|
+        Arel::Nodes::InfixOperation.new('~', column, Arel.sql(value.source))
       end)
 
-      assert_match %r{["`]topics["`].["`]title["`] ~ 'rails'}i, Topic.where(title: /rails/).to_sql
+      assert_match %r{["`]topics["`].["`]title["`] ~ rails}i, Topic.where(title: /rails/).to_sql
+    ensure
+      Topic.reset_column_information
     end
   end
 end
diff --git a/activerecord/test/cases/relation/where_chain_test.rb b/activerecord/test/cases/relation/where_chain_test.rb
index fd2420cb88..619055f1e7 100644
--- a/activerecord/test/cases/relation/where_chain_test.rb
+++ b/activerecord/test/cases/relation/where_chain_test.rb
@@ -12,13 +12,19 @@ module ActiveRecord
     end
 
     def test_not_eq
-      expected = Arel::Nodes::NotEqual.new(Post.arel_table[@name], 'hello')
       relation = Post.where.not(title: 'hello')
-      assert_equal([expected], relation.where_values)
+
+      assert_equal 1, relation.where_values.length
+
+      value = relation.where_values.first
+      bind  = relation.bind_values.first
+
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
+      assert_equal 'hello', bind.last
     end
 
     def test_not_null
-      expected = Arel::Nodes::NotEqual.new(Post.arel_table[@name], nil)
+      expected = Post.arel_table[@name].not_eq(nil)
       relation = Post.where.not(title: nil)
       assert_equal([expected], relation.where_values)
     end
@@ -30,13 +36,13 @@ module ActiveRecord
     end
 
     def test_not_in
-      expected = Arel::Nodes::NotIn.new(Post.arel_table[@name], %w[hello goodbye])
+      expected = Post.arel_table[@name].not_in(%w[hello goodbye])
       relation = Post.where.not(title: %w[hello goodbye])
       assert_equal([expected], relation.where_values)
     end
 
     def test_association_not_eq
-      expected = Arel::Nodes::NotEqual.new(Comment.arel_table[@name], 'hello')
+      expected = Comment.arel_table[@name].not_eq('hello')
       relation = Post.joins(:comments).where.not(comments: {title: 'hello'})
       assert_equal(expected.to_sql, relation.where_values.first.to_sql)
     end
@@ -44,21 +50,29 @@ module ActiveRecord
     def test_not_eq_with_preceding_where
       relation = Post.where(title: 'hello').where.not(title: 'world')
 
-      expected = Arel::Nodes::Equality.new(Post.arel_table[@name], 'hello')
-      assert_equal(expected, relation.where_values.first)
+      value = relation.where_values.first
+      bind  = relation.bind_values.first
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
+      assert_equal 'hello', bind.last
 
-      expected = Arel::Nodes::NotEqual.new(Post.arel_table[@name], 'world')
-      assert_equal(expected, relation.where_values.last)
+      value = relation.where_values.last
+      bind  = relation.bind_values.last
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
+      assert_equal 'world', bind.last
     end
 
     def test_not_eq_with_succeeding_where
       relation = Post.where.not(title: 'hello').where(title: 'world')
 
-      expected = Arel::Nodes::NotEqual.new(Post.arel_table[@name], 'hello')
-      assert_equal(expected, relation.where_values.first)
+      value = relation.where_values.first
+      bind  = relation.bind_values.first
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
+      assert_equal 'hello', bind.last
 
-      expected = Arel::Nodes::Equality.new(Post.arel_table[@name], 'world')
-      assert_equal(expected, relation.where_values.last)
+      value = relation.where_values.last
+      bind  = relation.bind_values.last
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
+      assert_equal 'world', bind.last
     end
 
     def test_not_eq_with_string_parameter
@@ -76,41 +90,92 @@ module ActiveRecord
     def test_chaining_multiple
       relation = Post.where.not(author_id: [1, 2]).where.not(title: 'ruby on rails')
 
-      expected = Arel::Nodes::NotIn.new(Post.arel_table['author_id'], [1, 2])
+      expected = Post.arel_table['author_id'].not_in([1, 2])
       assert_equal(expected, relation.where_values[0])
 
-      expected = Arel::Nodes::NotEqual.new(Post.arel_table[@name], 'ruby on rails')
-      assert_equal(expected, relation.where_values[1])
+      value = relation.where_values[1]
+      bind  = relation.bind_values.first
+
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
+      assert_equal 'ruby on rails', bind.last
     end
-    
+
     def test_rewhere_with_one_condition
       relation = Post.where(title: 'hello').where(title: 'world').rewhere(title: 'alone')
 
-      expected = Arel::Nodes::Equality.new(Post.arel_table[@name], 'alone')
       assert_equal 1, relation.where_values.size
-      assert_equal expected, relation.where_values.first
+      value = relation.where_values.first
+      bind = relation.bind_values.first
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
+      assert_equal 'alone', bind.last
     end
 
     def test_rewhere_with_multiple_overwriting_conditions
       relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone', body: 'again')
 
-      title_expected = Arel::Nodes::Equality.new(Post.arel_table['title'], 'alone')
-      body_expected  = Arel::Nodes::Equality.new(Post.arel_table['body'], 'again')
-
       assert_equal 2, relation.where_values.size
-      assert_equal title_expected, relation.where_values.first
-      assert_equal body_expected, relation.where_values.second
+
+      value = relation.where_values.first
+      bind = relation.bind_values.first
+      assert_bound_ast value, Post.arel_table['title'], Arel::Nodes::Equality
+      assert_equal 'alone', bind.last
+
+      value = relation.where_values[1]
+      bind = relation.bind_values[1]
+      assert_bound_ast value, Post.arel_table['body'], Arel::Nodes::Equality
+      assert_equal 'again', bind.last
+    end
+
+    def assert_bound_ast value, table, type
+      assert_equal table, value.left
+      assert_kind_of type, value
+      assert_kind_of Arel::Nodes::BindParam, value.right
     end
 
     def test_rewhere_with_one_overwriting_condition_and_one_unrelated
       relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone')
 
-      title_expected = Arel::Nodes::Equality.new(Post.arel_table['title'], 'alone')
-      body_expected  = Arel::Nodes::Equality.new(Post.arel_table['body'], 'world')
-
       assert_equal 2, relation.where_values.size
-      assert_equal body_expected, relation.where_values.first
-      assert_equal title_expected, relation.where_values.second
+
+      value = relation.where_values.first
+      bind  = relation.bind_values.first
+
+      assert_bound_ast value, Post.arel_table['body'], Arel::Nodes::Equality
+      assert_equal 'world', bind.last
+
+      value = relation.where_values.second
+      bind  = relation.bind_values.second
+
+      assert_bound_ast value, Post.arel_table['title'], Arel::Nodes::Equality
+      assert_equal 'alone', bind.last
+    end
+
+    def test_rewhere_with_range
+      relation = Post.where(comments_count: 1..3).rewhere(comments_count: 3..5)
+
+      assert_equal 1, relation.where_values.size
+      assert_equal Post.where(comments_count: 3..5), relation
+    end
+
+    def test_rewhere_with_infinite_upper_bound_range
+      relation = Post.where(comments_count: 1..Float::INFINITY).rewhere(comments_count: 3..5)
+
+      assert_equal 1, relation.where_values.size
+      assert_equal Post.where(comments_count: 3..5), relation
+    end
+
+    def test_rewhere_with_infinite_lower_bound_range
+      relation = Post.where(comments_count: -Float::INFINITY..1).rewhere(comments_count: 3..5)
+
+      assert_equal 1, relation.where_values.size
+      assert_equal Post.where(comments_count: 3..5), relation
+    end
+
+    def test_rewhere_with_infinite_range
+      relation = Post.where(comments_count: -Float::INFINITY..Float::INFINITY).rewhere(comments_count: 3..5)
+
+      assert_equal 1, relation.where_values.size
+      assert_equal Post.where(comments_count: 3..5), relation
     end
   end
 end
diff --git a/activerecord/test/cases/relation/where_test.rb b/activerecord/test/cases/relation/where_test.rb
index 937f226b1d..b0573579da 100644
--- a/activerecord/test/cases/relation/where_test.rb
+++ b/activerecord/test/cases/relation/where_test.rb
@@ -1,15 +1,19 @@
 require "cases/helper"
-require 'models/author'
-require 'models/price_estimate'
-require 'models/treasure'
-require 'models/post'
-require 'models/comment'
-require 'models/edge'
-require 'models/topic'
+require "models/author"
+require "models/binary"
+require "models/cake_designer"
+require "models/chef"
+require "models/comment"
+require "models/edge"
+require "models/post"
+require "models/price_estimate"
+require "models/topic"
+require "models/treasure"
+require "models/vertex"
 
 module ActiveRecord
   class WhereTest < ActiveRecord::TestCase
-    fixtures :posts, :edges, :authors
+    fixtures :posts, :edges, :authors, :binaries
 
     def test_where_copies_bind_params
       author = authors(:david)
@@ -24,6 +28,16 @@ module ActiveRecord
       }
     end
 
+    def test_where_copies_arel_bind_params
+      chef = Chef.create!
+      CakeDesigner.create!(chef: chef)
+
+      cake_designers = CakeDesigner.joins(:chef).where(chefs: { id: chef.id })
+      chefs = Chef.where(employable: cake_designers)
+
+      assert_equal [chef], chefs.to_a
+    end
+
     def test_rewhere_on_root
       assert_equal posts(:welcome), Post.rewhere(title: 'Welcome to the weblog').first
     end
@@ -60,6 +74,15 @@ module ActiveRecord
       assert_equal expected.to_sql, actual.to_sql
     end
 
+    def test_belongs_to_nested_where_with_relation
+      author = authors(:david)
+
+      expected = Author.where(id: author ).joins(:posts)
+      actual   = Author.where(posts: { author_id: Author.where(id: author.id) }).joins(:posts)
+
+      assert_equal expected.to_a, actual.to_a
+    end
+
     def test_polymorphic_shallow_where
       treasure = Treasure.new
       treasure.id = 1
@@ -179,5 +202,35 @@ module ActiveRecord
         assert_equal 4, Edge.where(blank).order("sink_id").to_a.size
       end
     end
+
+    def test_where_with_integer_for_string_column
+      count = Post.where(:title => 0).count
+      assert_equal 0, count
+    end
+
+    def test_where_with_float_for_string_column
+      count = Post.where(:title => 0.0).count
+      assert_equal 0, count
+    end
+
+    def test_where_with_boolean_for_string_column
+      count = Post.where(:title => false).count
+      assert_equal 0, count
+    end
+
+    def test_where_with_decimal_for_string_column
+      count = Post.where(:title => BigDecimal.new(0)).count
+      assert_equal 0, count
+    end
+
+    def test_where_with_duration_for_string_column
+      count = Post.where(:title => 0.seconds).count
+      assert_equal 0, count
+    end
+
+    def test_where_with_integer_for_binary_column
+      count = Binary.where(:data => 0).count
+      assert_equal 0, count
+    end
   end
 end