ibm_db 3.0.3 → 5.0.3

data/test/cases/relation_test.rb

@@ -6,7 +6,7 @@ require 'models/rating'
 
 module ActiveRecord
   class RelationTest < ActiveRecord::TestCase
-    fixtures :posts, :comments, :authors, :author_addresses
+    fixtures :posts, :comments, :authors
 
     class FakeKlass < Struct.new(:table_name, :name)
       extend ActiveRecord::Delegation::DelegateCache
@@ -20,62 +20,67 @@ module ActiveRecord
       def self.table_name
         'fake_table'
       end
+
+      def self.sanitize_sql_for_order(sql)
+        sql
+      end
     end
 
     def test_construction
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert_equal FakeKlass, relation.klass
       assert_equal :b, relation.table
       assert !relation.loaded, 'relation is not loaded'
     end
 
     def test_responds_to_model_and_returns_klass
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert_equal FakeKlass, relation.model
     end
 
     def test_initialize_single_values
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       (Relation::SINGLE_VALUE_METHODS - [:create_with]).each do |method|
         assert_nil relation.send("#{method}_value"), method.to_s
       end
-      assert_equal({}, relation.create_with_value)
+      value = relation.create_with_value
+      assert_equal({}, value)
+      assert_predicate value, :frozen?
     end
 
     def test_multi_value_initialize
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       Relation::MULTI_VALUE_METHODS.each do |method|
-        assert_equal [], relation.send("#{method}_values"), method.to_s
+        values = relation.send("#{method}_values")
+        assert_equal [], values, method.to_s
+        assert_predicate values, :frozen?, method.to_s
       end
     end
 
     def test_extensions
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert_equal [], relation.extensions
     end
 
     def test_empty_where_values_hash
-      relation = Relation.new FakeKlass, :b
-      assert_equal({}, relation.where_values_hash)
-
-      relation.where! :hello
+      relation = Relation.new(FakeKlass, :b, nil)
       assert_equal({}, relation.where_values_hash)
     end
 
     def test_has_values
-      relation = Relation.new Post, Post.arel_table
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       relation.where! relation.table[:id].eq(10)
       assert_equal({:id => 10}, relation.where_values_hash)
     end
 
     def test_values_wrong_table
-      relation = Relation.new Post, Post.arel_table
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       relation.where! Comment.arel_table[:id].eq(10)
       assert_equal({}, relation.where_values_hash)
     end
 
     def test_tree_is_not_traversed
-      relation = Relation.new Post, Post.arel_table
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       left     = relation.table[:id].eq(10)
       right    = relation.table[:id].eq(10)
       combine  = left.and right
@@ -84,24 +89,24 @@ module ActiveRecord
     end
 
     def test_table_name_delegates_to_klass
-      relation = Relation.new FakeKlass.new('posts'), :b
+      relation = Relation.new(FakeKlass.new('posts'), :b, Post.predicate_builder)
       assert_equal 'posts', relation.table_name
     end
 
     def test_scope_for_create
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert_equal({}, relation.scope_for_create)
     end
 
     def test_create_with_value
-      relation = Relation.new Post, Post.arel_table
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       hash = { :hello => 'world' }
       relation.create_with_value = hash
       assert_equal hash, relation.scope_for_create
     end
 
     def test_create_with_value_with_wheres
-      relation = Relation.new Post, Post.arel_table
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       relation.where! relation.table[:id].eq(10)
       relation.create_with_value = {:hello => 'world'}
       assert_equal({:hello => 'world', :id => 10}, relation.scope_for_create)
@@ -109,7 +114,7 @@ module ActiveRecord
 
     # FIXME: is this really wanted or expected behavior?
     def test_scope_for_create_is_cached
-      relation = Relation.new Post, Post.arel_table
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       assert_equal({}, relation.scope_for_create)
 
       relation.where! relation.table[:id].eq(10)
@@ -126,62 +131,72 @@ module ActiveRecord
     end
 
     def test_empty_eager_loading?
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert !relation.eager_loading?
     end
 
     def test_eager_load_values
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       relation.eager_load! :b
       assert relation.eager_loading?
     end
 
     def test_references_values
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert_equal [], relation.references_values
       relation = relation.references(:foo).references(:omg, :lol)
       assert_equal ['foo', 'omg', 'lol'], relation.references_values
     end
 
     def test_references_values_dont_duplicate
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       relation = relation.references(:foo).references(:foo)
       assert_equal ['foo'], relation.references_values
     end
 
     test 'merging a hash into a relation' do
-      relation = Relation.new FakeKlass, :b
-      relation = relation.merge where: :lol, readonly: true
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
+      relation = relation.merge where: {name: :lol}, readonly: true
 
-      assert_equal [:lol], relation.where_values
+      assert_equal({"name"=>:lol}, relation.where_clause.to_h)
       assert_equal true, relation.readonly_value
     end
 
     test 'merging an empty hash into a relation' do
-      assert_equal [], Relation.new(FakeKlass, :b).merge({}).where_values
+      assert_equal Relation::WhereClause.empty, Relation.new(FakeKlass, :b, nil).merge({}).where_clause
     end
 
     test 'merging a hash with unknown keys raises' do
       assert_raises(ArgumentError) { Relation::HashMerger.new(nil, omg: 'lol') }
     end
 
+    test 'merging nil or false raises' do
+      relation = Relation.new(FakeKlass, :b, nil)
+
+      e = assert_raises(ArgumentError) do
+        relation = relation.merge nil
+      end
+
+      assert_equal 'invalid argument: nil.', e.message
+
+      e = assert_raises(ArgumentError) do
+        relation = relation.merge false
+      end
+
+      assert_equal 'invalid argument: false.', e.message
+    end
+
     test '#values returns a dup of the values' do
-      relation = Relation.new(FakeKlass, :b).where! :foo
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder).where!(name: :foo)
       values   = relation.values
 
       values[:where] = nil
-      assert_not_nil relation.where_values
+      assert_not_nil relation.where_clause
     end
 
     test 'relations can be created with a values hash' do
-      relation = Relation.new(FakeKlass, :b, where: [:foo])
-      assert_equal [:foo], relation.where_values
-    end
-
-    test 'merging a single where value' do
-      relation = Relation.new(FakeKlass, :b)
-      relation.merge!(where: :foo)
-      assert_equal [:foo], relation.where_values
+      relation = Relation.new(FakeKlass, :b, nil, select: [:foo])
+      assert_equal [:foo], relation.select_values
     end
 
     test 'merging a hash interpolates conditions' do
@@ -192,13 +207,13 @@ module ActiveRecord
         end
       end
 
-      relation = Relation.new(klass, :b)
+      relation = Relation.new(klass, :b, nil)
       relation.merge!(where: ['foo = ?', 'bar'])
-      assert_equal ['foo = bar'], relation.where_values
+      assert_equal Relation::WhereClause.new(['foo = bar'], []), relation.where_clause
     end
 
     def test_merging_readonly_false
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       readonly_false_relation = relation.readonly(false)
       # test merging in both directions
       assert_equal false, relation.merge(readonly_false_relation).readonly_value
@@ -208,13 +223,7 @@ module ActiveRecord
     def test_relation_merging_with_merged_joins_as_symbols
       special_comments_with_ratings = SpecialComment.joins(:ratings)
       posts_with_special_comments_with_ratings = Post.group("posts.id").joins(:special_comments).merge(special_comments_with_ratings)
-      assert_equal 3, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count.length
-    end
-
-    def test_conflicting_bind_values
-      assert_nothing_raised do
-        CommentWithConflictingDefaultScope.joins(:post_with_conflicting_default_scope).delete_all
-      end
+      assert_equal({ 2=>1, 4=>3, 5=>1 }, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count)
     end
 
     def test_relation_merging_with_joins_as_join_dependency_pick_proper_parent
@@ -227,6 +236,13 @@ module ActiveRecord
       assert_equal 3, relation.where(id: post.id).pluck(:id).size
     end
 
+    def test_merge_raises_with_invalid_argument
+      assert_raises ArgumentError do
+        relation = Relation.new(FakeKlass, :b, nil)
+        relation.merge(true)
+      end
+    end
+
     def test_respond_to_for_non_selected_element
       post = Post.select(:title).first
       assert_equal false, post.respond_to?(:body), "post should not respond_to?(:body) since invoking it raises exception"
@@ -236,23 +252,28 @@ module ActiveRecord
     end
 
     def test_select_quotes_when_using_from_clause
-      if sqlite3_version_includes_quoting_bug?
-        skip <<-ERROR.squish
-          You are using an outdated version of SQLite3 which has a bug in
-          quoted column names. Please update SQLite3 and rebuild the sqlite3
-          ruby gem
-        ERROR
-      end
+      skip_if_sqlite3_version_includes_quoting_bug
       quoted_join = ActiveRecord::Base.connection.quote_table_name("join")
       selected = Post.select(:join).from(Post.select("id as #{quoted_join}")).map(&:join)
       assert_equal Post.pluck(:id), selected
     end
 
+    def test_selecting_aliased_attribute_quotes_column_name_when_from_is_used
+      skip_if_sqlite3_version_includes_quoting_bug
+      klass = Class.new(ActiveRecord::Base) do
+        self.table_name = :test_with_keyword_column_name
+        alias_attribute :description, :desc
+      end
+      klass.create!(description: "foo")
+
+      assert_equal ["foo"], klass.select(:description).from(klass.all).map(&:desc)
+    end
+
     def test_relation_merging_with_merged_joins_as_strings
       join_string = "LEFT OUTER JOIN #{Rating.quoted_table_name} ON #{SpecialComment.quoted_table_name}.id = #{Rating.quoted_table_name}.comment_id"
       special_comments_with_ratings = SpecialComment.joins join_string
       posts_with_special_comments_with_ratings = Post.group("posts.id").joins(:special_comments).merge(special_comments_with_ratings)
-      assert_equal 3, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count.length
+      assert_equal({ 2=>1, 4=>3, 5=>1 }, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count)
     end
 
     class EnsureRoundTripTypeCasting < ActiveRecord::Type::Value
@@ -260,12 +281,12 @@ module ActiveRecord
         :string
       end
 
-      def type_cast_from_database(value)
+      def deserialize(value)
         raise value unless value == "type cast for database"
         "type cast from database"
       end
 
-      def type_cast_for_database(value)
+      def serialize(value)
         raise value unless value == "value from user"
         "type cast for database"
       end
@@ -285,6 +306,16 @@ module ActiveRecord
 
     private
 
+    def skip_if_sqlite3_version_includes_quoting_bug
+      if sqlite3_version_includes_quoting_bug?
+        skip <<-ERROR.squish
+          You are using an outdated version of SQLite3 which has a bug in
+          quoted column names. Please update SQLite3 and rebuild the sqlite3
+          ruby gem
+        ERROR
+      end
+    end
+
     def sqlite3_version_includes_quoting_bug?
       if current_adapter?(:SQLite3Adapter)
         selected_quoted_column_names = ActiveRecord::Base.connection.exec_query(

data/test/cases/relations_test.rb

@@ -18,10 +18,17 @@ require 'models/minivan'
 require 'models/aircraft'
 require "models/possession"
 require "models/reader"
+require "models/categorization"
+require "models/edge"
 
 class RelationTest < ActiveRecord::TestCase
   fixtures :authors, :topics, :entrants, :developers, :companies, :developers_projects, :accounts, :categories, :categorizations, :posts, :comments,
-    :tags, :taggings, :cars, :minivans, :author_addresses
+    :tags, :taggings, :cars, :minivans
+
+  class TopicWithCallbacks < ActiveRecord::Base
+    self.table_name = :topics
+    before_update { |topic| topic.author_name = 'David' if topic.author_name.blank? }
+  end
 
   def test_do_not_double_quote_string_id
     van = Minivan.last
@@ -35,15 +42,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal van, Minivan.where(:minivan_id => [van]).to_a.first
   end
 
-  def test_bind_values
-    relation = Post.all
-    assert_equal [], relation.bind_values
-
-    relation2 = relation.bind 'foo'
-    assert_equal %w{ foo }, relation2.bind_values
-    assert_equal [], relation.bind_values
-  end
-
   def test_two_scopes_with_includes_should_not_drop_any_include
     # heat habtm cache
     car = Car.incl_engines.incl_tyres.first
@@ -114,15 +112,38 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_loaded_first
     topics = Topic.all.order('id ASC')
+    topics.to_a # force load
 
-    assert_queries(1) do
-      topics.to_a # force load
-      2.times { assert_equal "The First Topic", topics.first.title }
+    assert_no_queries do
+      assert_equal "The First Topic", topics.first.title
     end
 
     assert topics.loaded?
   end
 
+  def test_loaded_first_with_limit
+    topics = Topic.all.order('id ASC')
+    topics.to_a # force load
+
+    assert_no_queries do
+      assert_equal ["The First Topic",
+                    "The Second Topic of the day"], topics.first(2).map(&:title)
+    end
+
+    assert topics.loaded?
+  end
+
+  def test_first_get_more_than_available
+    topics = Topic.all.order('id ASC')
+    unloaded_first = topics.first(10)
+    topics.to_a # force load
+
+    assert_no_queries do
+      loaded_first = topics.first(10)
+      assert_equal unloaded_first, loaded_first
+    end
+  end
+
   def test_reload
     topics = Topic.all
 
@@ -203,6 +224,48 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal topics(:fifth).title, topics.first.title
   end
 
+  def test_reverse_order_with_function
+    topics = Topic.order("length(title)").reverse_order
+    assert_equal topics(:second).title, topics.first.title
+  end
+
+  def test_reverse_order_with_function_other_predicates
+    topics = Topic.order("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
+    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
+    end
+    assert_raises(ActiveRecord::IrreversibleOrderError) do
+      Topic.order("concat(lower(author_name), title)").reverse_order
+    end
+    assert_raises(ActiveRecord::IrreversibleOrderError) do
+      Topic.order("concat(author_name, lower(title))").reverse_order
+    end
+    assert_raises(ActiveRecord::IrreversibleOrderError) do
+      Topic.order("concat(lower(author_name), title, length(title)").reverse_order
+    end
+  end
+
+  def test_reverse_order_with_nulls_first_or_last
+    assert_raises(ActiveRecord::IrreversibleOrderError) do
+      Topic.order("title NULLS FIRST").reverse_order
+    end
+    assert_raises(ActiveRecord::IrreversibleOrderError) do
+      Topic.order("title nulls last").reverse_order
+    end
+  end
+
+  def test_default_reverse_order_on_table_without_primary_key
+    assert_raises(ActiveRecord::IrreversibleOrderError) do
+      Edge.all.reverse_order
+    end
+  end
+
   def test_order_with_hash_and_symbol_generates_the_same_sql
     assert_equal Topic.order(:id).to_sql, Topic.order(:id => :asc).to_sql
   end
@@ -261,7 +324,7 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_finding_with_reorder
     topics = Topic.order('author_name').order('title').reorder('id').to_a
-    topics_titles = topics.map{ |t| t.title }
+    topics_titles = topics.map(&:title)
     assert_equal ['The First Topic', 'The Second Topic of the day', 'The Third Topic of the day', 'The Fourth Topic of the day', 'The Fifth Topic of the day'], topics_titles
   end
 
@@ -301,6 +364,17 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal 3, tags.length
   end
 
+  def test_finding_with_sanitized_order
+    query = Tag.order(["field(id, ?)", [1,3,2]]).to_sql
+    assert_match(/field\(id, 1,3,2\)/, query)
+
+    query = Tag.order(["field(id, ?)", []]).to_sql
+    assert_match(/field\(id, NULL\)/, query)
+
+    query = Tag.order(["field(id, ?)", nil]).to_sql
+    assert_match(/field\(id, NULL\)/, query)
+  end
+
   def test_finding_with_order_limit_and_offset
     entrants = Entrant.order("id ASC").limit(2).offset(1)
 
@@ -357,7 +431,9 @@ class RelationTest < ActiveRecord::TestCase
       assert_equal 0,     Developer.none.size
       assert_equal 0,     Developer.none.count
       assert_equal true,  Developer.none.empty?
+      assert_equal true, Developer.none.none?
       assert_equal false, Developer.none.any?
+      assert_equal false, Developer.none.one?
       assert_equal false, Developer.none.many?
     end
   end
@@ -365,7 +441,7 @@ class RelationTest < ActiveRecord::TestCase
   def test_null_relation_calculations_methods
     assert_no_queries(ignore_none: false) do
       assert_equal 0, Developer.none.count
-      assert_equal 0, Developer.none.calculate(:count, nil, {})
+      assert_equal 0, Developer.none.calculate(:count, nil)
       assert_equal nil, Developer.none.calculate(:average, 'salary')
     end
   end
@@ -453,7 +529,7 @@ class RelationTest < ActiveRecord::TestCase
       where('project_id=1').to_a
 
     assert_equal 3, developers_on_project_one.length
-    developer_names = developers_on_project_one.map { |d| d.name }
+    developer_names = developers_on_project_one.map(&:name)
     assert developer_names.include?('David')
     assert developer_names.include?('Jamis')
   end
@@ -709,8 +785,8 @@ class RelationTest < ActiveRecord::TestCase
     expected_taggings = taggings(:welcome_general, :thinking_general)
 
     assert_no_queries do
-      assert_equal expected_taggings, author.taggings.distinct.sort_by { |t| t.id }
-      assert_equal expected_taggings, author.taggings.uniq.sort_by { |t| t.id }
+      assert_equal expected_taggings, author.taggings.distinct.sort_by(&:id)
+      assert_equal expected_taggings, author.taggings.uniq.sort_by(&:id)
     end
 
     authors = Author.all
@@ -769,7 +845,9 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_find_by_classname
     Author.create!(:name => Mary.name)
-    assert_equal 1, Author.where(:name => Mary).size
+    assert_deprecated do
+      assert_equal 1, Author.where(:name => Mary).size
+    end
   end
 
   def test_find_by_id_with_list_of_ar
@@ -913,6 +991,12 @@ class RelationTest < ActiveRecord::TestCase
     assert authors.exists?(authors(:david).id)
   end
 
+  def test_any_with_scope_on_hash_includes
+    post = authors(:david).posts.first
+    categories = Categorization.includes(author: :posts).where(posts: { id: post.id })
+    assert categories.exists?
+  end
+
   def test_last
     authors = Author.all
     assert_equal authors(:bob), authors.last
@@ -931,6 +1015,12 @@ class RelationTest < ActiveRecord::TestCase
     assert davids.loaded?
   end
 
+  def test_destroy_all_with_conditions_is_deprecated
+    assert_deprecated do
+      assert_difference('Author.count', -1) { Author.destroy_all(name: 'David') }
+    end
+  end
+
   def test_delete_all
     davids = Author.where(:name => 'David')
 
@@ -938,6 +1028,12 @@ class RelationTest < ActiveRecord::TestCase
     assert ! davids.loaded?
   end
 
+  def test_delete_all_with_conditions_is_deprecated
+    assert_deprecated do
+      assert_difference('Author.count', -1) { Author.delete_all(name: 'David') }
+    end
+  end
+
   def test_delete_all_loaded
     davids = Author.where(:name => 'David')
 
@@ -953,7 +1049,7 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_delete_all_with_unpermitted_relation_raises_error
     assert_raises(ActiveRecord::ActiveRecordError) { Author.limit(10).delete_all }
-    assert_raises(ActiveRecord::ActiveRecordError) { Author.uniq.delete_all }
+    assert_raises(ActiveRecord::ActiveRecordError) { Author.distinct.delete_all }
     assert_raises(ActiveRecord::ActiveRecordError) { Author.group(:name).delete_all }
     assert_raises(ActiveRecord::ActiveRecordError) { Author.having('SUM(id) < 3').delete_all }
     assert_raises(ActiveRecord::ActiveRecordError) { Author.offset(10).delete_all }
@@ -1160,6 +1256,48 @@ class RelationTest < ActiveRecord::TestCase
     assert ! posts.limit(1).many?
   end
 
+  def test_none?
+    posts = Post.all
+    assert_queries(1) do
+      assert ! posts.none? # Uses COUNT()
+    end
+
+    assert ! posts.loaded?
+
+    assert_queries(1) do
+      assert posts.none? {|p| p.id < 0 }
+      assert ! posts.none? {|p| p.id == 1 }
+    end
+
+    assert posts.loaded?
+  end
+
+  def test_one
+    posts = Post.all
+    assert_queries(1) do
+      assert ! posts.one? # Uses COUNT()
+    end
+
+    assert ! posts.loaded?
+
+    assert_queries(1) do
+      assert ! posts.one? {|p| p.id < 3 }
+      assert posts.one? {|p| p.id == 1 }
+    end
+
+    assert posts.loaded?
+  end
+
+  def test_to_a_should_dup_target
+    posts = Post.all
+
+    original_size = posts.size
+    removed = posts.to_a.pop
+
+    assert_equal original_size, posts.size
+    assert_includes posts.to_a, removed
+  end
+
   def test_build
     posts = Post.all
 
@@ -1438,12 +1576,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal "id", Post.all.primary_key
   end
 
-  def test_disable_implicit_join_references_is_deprecated
-    assert_deprecated do
-      ActiveRecord::Base.disable_implicit_join_references = true
-    end
-  end
-
   def test_ordering_with_extra_spaces
     assert_equal authors(:david), Author.order('id DESC , name DESC').last
   end
@@ -1472,8 +1604,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal posts(:welcome),  comments(:more_greetings).post
   end
 
-unless current_adapter?(:IBM_DBAdapter)
-  #IBM_DB does not support offset on subselect of the update statement
   def test_update_all_with_joins_and_offset
     all_comments = Comment.joins(:post).where('posts.id' => posts(:welcome).id)
     count        = all_comments.count
@@ -1491,7 +1621,26 @@ unless current_adapter?(:IBM_DBAdapter)
     assert_equal posts(:thinking), comments(:more_greetings).post
     assert_equal posts(:welcome),  comments(:greetings).post
   end
-end
+
+  def test_update_on_relation
+    topic1 = TopicWithCallbacks.create! title: 'arel', author_name: nil
+    topic2 = TopicWithCallbacks.create! title: 'activerecord', author_name: nil
+    topics = TopicWithCallbacks.where(id: [topic1.id, topic2.id])
+    topics.update(title: 'adequaterecord')
+
+    assert_equal 'adequaterecord', topic1.reload.title
+    assert_equal 'adequaterecord', topic2.reload.title
+    # Testing that the before_update callbacks have run
+    assert_equal 'David', topic1.reload.author_name
+    assert_equal 'David', topic2.reload.author_name
+  end
+
+  def test_update_on_relation_passing_active_record_object_is_deprecated
+    topic = Topic.create!(title: 'Foo', author_name: nil)
+    assert_deprecated(/update/) do
+      Topic.where(id: topic.id).update(topic, title: 'Bar')
+    end
+  end
 
   def test_distinct
     tag1 = Tag.create(:name => 'Foo')
@@ -1502,22 +1651,42 @@ end
     assert_equal ['Foo', 'Foo'], query.map(&:name)
     assert_sql(/DISTINCT/) do
       assert_equal ['Foo'], query.distinct.map(&:name)
-      assert_equal ['Foo'], query.uniq.map(&:name)
+      assert_deprecated { assert_equal ['Foo'], query.uniq.map(&:name) }
     end
     assert_sql(/DISTINCT/) do
       assert_equal ['Foo'], query.distinct(true).map(&:name)
-      assert_equal ['Foo'], query.uniq(true).map(&:name)
+      assert_deprecated { assert_equal ['Foo'], query.uniq(true).map(&:name) }
     end
     assert_equal ['Foo', 'Foo'], query.distinct(true).distinct(false).map(&:name)
-    assert_equal ['Foo', 'Foo'], query.uniq(true).uniq(false).map(&:name)
+
+    assert_deprecated do
+      assert_equal ['Foo', 'Foo'], query.uniq(true).uniq(false).map(&:name)
+    end
   end
 
   def test_doesnt_add_having_values_if_options_are_blank
     scope = Post.having('')
-    assert_equal [], scope.having_values
+    assert scope.having_clause.empty?
 
     scope = Post.having([])
-    assert_equal [], scope.having_values
+    assert scope.having_clause.empty?
+  end
+
+  def test_having_with_binds_for_both_where_and_having
+    post = Post.first
+    having_then_where = Post.having(id: post.id).where(title: post.title).group(:id)
+    where_then_having = Post.where(title: post.title).having(id: post.id).group(:id)
+
+    assert_equal [post], having_then_where
+    assert_equal [post], where_then_having
+  end
+
+  def test_multiple_where_and_having_clauses
+    post = Post.first
+    having_then_where = Post.having(id: post.id).where(title: post.title)
+      .having(id: post.id).where(title: post.title).group(:id)
+
+    assert_equal [post], having_then_where
   end
 
   def test_grouping_by_column_with_reserved_name
@@ -1649,6 +1818,10 @@ end
     assert_sql(/^((?!ORDER).)*$/) { Post.all.find_by(author_id: 2) }
   end
 
+  test "find_by requires at least one argument" do
+    assert_raises(ArgumentError) { Post.all.find_by }
+  end
+
   test "find_by! with hash conditions returns the first matching record" do
     assert_equal posts(:eager_other), Post.order(:id).find_by!(author_id: 2)
   end
@@ -1671,6 +1844,10 @@ end
     end
   end
 
+  test "find_by! requires at least one argument" do
+    assert_raises(ArgumentError) { Post.all.find_by! }
+  end
+
   test "loaded relations cannot be mutated by multi value methods" do
     relation = Post.all
     relation.to_a
@@ -1707,6 +1884,14 @@ end
     end
   end
 
+  test "relations with cached arel can't be mutated [internal API]" do
+    relation = Post.all
+    relation.count
+
+    assert_raises(ActiveRecord::ImmutableRelation) { relation.limit!(5) }
+    assert_raises(ActiveRecord::ImmutableRelation) { relation.where!("1 = 2") }
+  end
+
   test "relations show the records in #inspect" do
     relation = Post.limit(2)
     assert_equal "#<ActiveRecord::Relation [#{Post.limit(2).map(&:inspect).join(', ')}]>", relation.inspect
@@ -1731,7 +1916,9 @@ end
   test 'using a custom table affects the wheres' do
     table_alias = Post.arel_table.alias('omg_posts')
 
-    relation = ActiveRecord::Relation.new Post, table_alias
+    table_metadata = ActiveRecord::TableMetadata.new(Post, table_alias)
+    predicate_builder = ActiveRecord::PredicateBuilder.new(table_metadata)
+    relation = ActiveRecord::Relation.new(Post, table_alias, predicate_builder)
     relation.where!(:foo => "bar")
 
     node = relation.arel.constraints.first.grep(Arel::Attributes::Attribute).first
@@ -1790,14 +1977,13 @@ end
   end
 
   def test_merging_keeps_lhs_bind_parameters
-    column = Post.columns_hash['id']
-    binds = [[column, 20]]
+    binds = [ActiveRecord::Relation::QueryAttribute.new("id", 20, Post.type_for_attribute("id"))]
 
     right  = Post.where(id: 20)
     left   = Post.where(id: 10)
 
     merged = left.merge(right)
-    assert_equal binds, merged.bind_values
+    assert_equal binds, merged.bound_attributes
   end
 
   def test_merging_reorders_bind_params
@@ -1812,4 +1998,29 @@ end
   def test_relation_join_method
     assert_equal 'Thank you for the welcome,Thank you again for the welcome', Post.first.comments.join(",")
   end
+
+  def test_connection_adapters_can_reorder_binds
+    posts = Post.limit(1).offset(2)
+
+    stubbed_connection = Post.connection.dup
+    def stubbed_connection.combine_bind_parameters(**kwargs)
+      offset = kwargs[:offset]
+      kwargs[:offset] = kwargs[:limit]
+      kwargs[:limit] = offset
+      super(**kwargs)
+    end
+
+    posts.define_singleton_method(:connection) do
+      stubbed_connection
+    end
+
+    assert_equal 2, posts.to_a.length
+  end
+
+  def test_update_all_can_receive_active_record_objects
+    assert_deprecated do
+      Comment.update_all(post_id: Post.first)
+      assert(Comment.all.all? { |c| c.post_id == Post.first.id })
+    end
+  end
 end