ibm_db 5.6.1 → 5.7.0

data/test/cases/relation/select_test.rb

@@ -9,8 +9,117 @@ module ActiveRecord
     fixtures :posts, :comments
 
     def test_select_with_nil_argument
-      expected = Post.select(:title).to_sql
-      assert_equal expected, Post.select(nil).select(:title).to_sql
+      expected = %r/\ASELECT #{Regexp.escape(quote_table_name("posts.title"))} FROM/
+      assert_match expected, Post.select(nil).select(:title).to_sql
+    end
+
+    def test_select_with_non_field_values
+      expected = %r/\ASELECT 1, foo\(\), #{Regexp.escape(quote_table_name("bar"))} FROM/
+      assert_match expected, Post.select("1", "foo()", :bar).to_sql
+    end
+
+    def test_select_with_non_field_hash_values
+      q = -> name { Regexp.escape(quote_table_name(name)) }
+      expected = %r/\ASELECT 1 AS #{q["a"]}, foo\(\) AS #{q["b"]}, #{q["bar"]} AS #{q["c"]} FROM/
+      assert_match expected, Post.select("1" => :a, "foo()" => :b, :bar => :c).to_sql
+    end
+
+    def test_select_with_hash_argument
+      post = Post.select("UPPER(title)" => :title, posts: { title: :post_title }).first
+
+      assert_equal "WELCOME TO THE WEBLOG", post.title
+      assert_equal "Welcome to the weblog", post.post_title
+    end
+
+    def test_select_with_reserved_words_aliases
+      post = Post.select("UPPER(title)" => :from, title: :group).first
+
+      assert_equal "WELCOME TO THE WEBLOG", post.from
+      assert_equal "Welcome to the weblog", post.group
+    end
+
+    def test_select_with_one_level_hash_argument
+      post = Post.select("UPPER(title)" => :title, title: :post_title).first
+
+      assert_equal "WELCOME TO THE WEBLOG", post.title
+      assert_equal "Welcome to the weblog", post.post_title
+    end
+
+    def test_select_with_not_exists_field
+      q = -> name { Regexp.escape(quote_table_name(name)) }
+      expected = %r/\ASELECT #{q["foo"]} AS #{q["post_title"]} FROM/
+      assert_match expected, Post.select(foo: :post_title).to_sql
+
+      skip if sqlite3_adapter_strict_strings_disabled?
+      skip "DB2 does not raise for unresolved projection identifiers in SELECT list" if current_adapter?(:IBM_DBAdapter)
+
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Post.select(foo: :post_title).take
+      end
+    end
+
+    def test_select_with_hash_with_not_exists_field
+      q = -> name { Regexp.escape(quote_table_name(name)) }
+      expected = %r/\ASELECT #{q["posts.bar"]} AS #{q["post_title"]} FROM/
+      assert_match expected, Post.select(posts: { bar: :post_title }).to_sql
+
+      skip "DB2 does not raise for unresolved projection identifiers in SELECT list" if current_adapter?(:IBM_DBAdapter)
+
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Post.select(posts: { boo: :post_title }).take
+      end
+    end
+
+    def test_select_with_hash_array_value_with_not_exists_field
+      q = -> name { Regexp.escape(quote_table_name(name)) }
+      expected = %r/\ASELECT #{q["posts.bar"]}, #{q["posts.id"]} FROM/
+      assert_match expected, Post.select(posts: [:bar, :id]).to_sql
+
+      skip "DB2 does not raise for unresolved projection identifiers in SELECT list" if current_adapter?(:IBM_DBAdapter)
+
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Post.select(posts: [:bar, :id]).take
+      end
+    end
+
+    def test_select_with_hash_and_table_alias
+      post = Post.joins(:comments, :comments_with_extend)
+        .select(
+          :title,
+          posts: { title: :post_title },
+          comments: { body: :comment_body },
+          comments_with_extend: { body: :comment_body_2 }
+        )
+        .take
+
+      assert_equal post.title, post.post_title
+      assert_not_nil post.comment_body
+      assert_not_nil post.comment_body_2
+    end
+
+    def test_select_with_invalid_nested_field
+      skip "DB2 allows expression-like nested projection keys without raising" if current_adapter?(:IBM_DBAdapter)
+
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Post.select(posts: { "UPPER(title)" => :post_title }).take
+      end
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Post.select(posts: ["UPPER(title)"]).take
+      end
+    end
+
+    def test_select_with_hash_argument_without_aliases
+      post = Post.select(posts: [:title, "title as post_title"]).first
+      assert_equal "Welcome to the weblog", post.title
+      assert_equal "Welcome to the weblog", post.post_title
+    end
+
+    def test_select_with_hash_argument_with_few_tables
+      post = Post.joins(:comments).select(:title, posts: { title: :post_title }, comments: { body: :comment_body }).take
+
+      assert_equal post.title, post.post_title
+      assert_not_nil post.comment_body
+      assert_not_nil post.post_title
     end
 
     def test_reselect
@@ -25,6 +134,18 @@ module ActiveRecord
       assert_equal expected, actual
     end
 
+    def test_reselect_with_hash_argument
+      expected = Post.select(:title, posts: { title: :post_title }).to_sql
+      actual = Post.select(:title, :body).reselect(:title, posts: { title: :post_title }).to_sql
+      assert_equal expected, actual
+    end
+
+    def test_reselect_with_one_level_hash_argument
+      expected = Post.select(:title, title: :post_title).to_sql
+      actual = Post.select(:title, :body).reselect(:title, title: :post_title).to_sql
+      assert_equal expected, actual
+    end
+
     def test_non_select_columns_wont_be_loaded
       posts = Post.select("UPPER(title) AS title")
 
@@ -35,12 +156,26 @@ module ActiveRecord
 
     def assert_non_select_columns_wont_be_loaded(post)
       assert_equal "WELCOME TO THE WEBLOG", post.title
-      assert_raise(ActiveModel::MissingAttributeError) do
+      assert_raise(ActiveModel::MissingAttributeError, match: /attribute 'body' for Post/) do
         post.body
       end
     end
     private :assert_non_select_columns_wont_be_loaded
 
+    def test_merging_select_from_different_model
+      posts = Post.select(:id, :title).joins(:comments)
+      comments = Comment.where(body: "Thank you for the welcome")
+
+      [
+        posts.merge(comments.select(:body)).first,
+        posts.merge(comments.select("comments.body")).first,
+      ].each do |post|
+        assert_equal 1, post.id
+        assert_equal "Welcome to the weblog", post.title
+        assert_equal "Thank you for the welcome", post.body
+      end
+    end
+
     def test_type_casted_extra_select_with_eager_loading
       posts = Post.select("posts.id * 1.1 AS foo").eager_load(:comments)
       assert_equal 1.1, posts.first.foo
@@ -63,5 +198,29 @@ module ActiveRecord
         tags_count indestructible_tags_count tags_with_destroy_count tags_with_nullify_count
       ), posts.first.attributes.keys
     end
+
+    def test_enumerate_columns_in_select_statements
+      original_value = Post.enumerate_columns_in_select_statements
+      Post.enumerate_columns_in_select_statements = true
+      sql = Post.all.to_sql
+      Post.column_names.each do |column_name|
+        assert_includes sql, column_name
+      end
+    ensure
+      Post.enumerate_columns_in_select_statements = original_value
+    end
+
+    def test_select_without_any_arguments
+      error = assert_raises(ArgumentError) { Post.select }
+      assert_equal "Call `select' with at least one field.", error.message
+    end
+
+    def test_select_with_block_without_any_arguments
+      error = assert_raises(ArgumentError) do
+        Post.select("invalid_argument") { }
+      end
+
+      assert_equal "`select' with block doesn't take arguments.", error.message
+    end
   end
 end

data/test/cases/relation/structural_compatibility_test.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+module ActiveRecord
+  class StructuralCompatibilityTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    def test_compatible_values
+      left = Post.where(id: 1)
+      right = Post.where(id: 2)
+
+      assert left.structurally_compatible?(right)
+    end
+
+    def test_incompatible_single_value_relations
+      left = Post.distinct.where("id = 1")
+      right = Post.where(id: [2, 3])
+
+      assert_not left.structurally_compatible?(right)
+    end
+
+    def test_incompatible_multi_value_relations
+      left = Post.order("body asc").where("id = 1")
+      right = Post.order("id desc").where(id: [2, 3])
+
+      assert_not left.structurally_compatible?(right)
+    end
+
+    def test_incompatible_unscope
+      left = Post.order("body asc").where("id = 1").unscope(:order)
+      right = Post.order("body asc").where("id = 2")
+
+      assert_not left.structurally_compatible?(right)
+    end
+  end
+end

data/test/cases/relation/update_all_test.rb

@@ -14,9 +14,11 @@ require "models/topic"
 require "models/tag"
 require "models/tagging"
 require "models/warehouse_thing"
+require "models/cpk"
 
 class UpdateAllTest < ActiveRecord::TestCase
-  fixtures :authors, :author_addresses, :comments, :developers, :posts, :people, :pets, :toys, :tags, :taggings, "warehouse_things"
+  fixtures :authors, :author_addresses, :comments, :developers, :posts, :people, :pets, :toys, :tags,
+    :taggings, :warehouse_things, :cpk_orders, :cpk_order_agreements
 
   class TopicWithCallbacks < ActiveRecord::Base
     self.table_name = :topics
@@ -39,7 +41,23 @@ class UpdateAllTest < ActiveRecord::TestCase
   end
 
   def test_update_all_with_blank_argument
-    assert_raises(ArgumentError) { Comment.update_all({}) }
+    error = assert_raises(ArgumentError) { Comment.update_all({}) }
+
+    assert_equal "Empty list of attributes to change", error.message
+  end
+
+  def test_update_all_with_group_by
+    minimum_comments_count = 2
+
+    Post.most_commented(minimum_comments_count).update_all(title: "ig")
+    posts = Post.most_commented(minimum_comments_count).all.to_a
+
+    assert_operator posts.length, :>, 0
+    assert posts.all? { |post| post.comments.length >= minimum_comments_count }
+    assert posts.all? { |post| "ig" == post.title }
+
+    post = Post.joins(:comments).group("posts.id", "posts.author_id", "posts.title", "posts.body", "posts.type", "posts.legacy_comments_count", "posts.taggings_with_delete_all_count", "posts.taggings_with_destroy_count", "posts.tags_count", "posts.indestructible_tags_count", "posts.tags_with_destroy_count", "posts.tags_with_nullify_count").having("count(comments.id) < #{minimum_comments_count}").first
+    assert_not_equal "ig", post.title
   end
 
   def test_update_all_with_joins
@@ -50,10 +68,10 @@ class UpdateAllTest < ActiveRecord::TestCase
       assert_equal pets.count, pets.update_all(name: "Bob")
     end
 
-    if current_adapter?(:Mysql2Adapter)
-      assert_no_match %r/SELECT DISTINCT #{Regexp.escape(Pet.connection.quote_table_name("pets.pet_id"))}/, sqls.last
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_no_match %r/SELECT DISTINCT #{Regexp.escape(quote_table_name("pets.pet_id"))}/, sqls.last
     else
-      assert_match %r/SELECT #{Regexp.escape(Pet.connection.quote_table_name("pets.pet_id"))}/, sqls.last
+      assert_match %r/SELECT #{Regexp.escape(quote_table_name("pets.pet_id"))}/, sqls.last
     end
   end
 
@@ -117,6 +135,19 @@ class UpdateAllTest < ActiveRecord::TestCase
     assert_not_equal previously_updated_at, developer.updated_at
   end
 
+  def test_touch_all_with_aliased_for_update_timestamp
+    assert Developer.attribute_aliases.key?("updated_at")
+
+    developer = developers(:david)
+    previously_created_at = developer.created_at
+    previously_updated_at = developer.updated_at
+    Developer.where(name: "David").touch_all(:updated_at)
+    developer.reload
+
+    assert_equal previously_created_at, developer.created_at
+    assert_not_equal previously_updated_at, developer.updated_at
+  end
+
   def test_touch_all_with_given_time
     developer = developers(:david)
     previously_created_at = developer.created_at
@@ -171,6 +202,24 @@ class UpdateAllTest < ActiveRecord::TestCase
     end
   end
 
+  def test_update_bang_on_relation
+    topic1 = TopicWithCallbacks.create! title: "arel", author_name: nil
+    topic2 = TopicWithCallbacks.create! title: "activerecord", author_name: nil
+    topic3 = TopicWithCallbacks.create! title: "ar", author_name: nil
+    topics = TopicWithCallbacks.where(id: [topic1.id, topic2.id])
+    topics.update!(title: "adequaterecord")
+
+    assert_equal TopicWithCallbacks.count, TopicWithCallbacks.topic_count
+
+    assert_equal "adequaterecord", topic1.reload.title
+    assert_equal "adequaterecord", topic2.reload.title
+    assert_equal "ar", topic3.reload.title
+    # Testing that the before_update callbacks have run
+    assert_equal "David", topic1.reload.author_name
+    assert_equal "David", topic2.reload.author_name
+    assert_nil topic3.reload.author_name
+  end
+
   def test_update_all_cares_about_optimistic_locking
     david = people(:david)
 
@@ -266,31 +315,36 @@ class UpdateAllTest < ActiveRecord::TestCase
     end
   end
 
-  # Oracle UPDATE does not support ORDER BY
-  unless current_adapter?(:OracleAdapter)
-    def test_update_all_ignores_order_without_limit_from_association
-      author = authors(:david)
-      assert_nothing_raised do
-        assert_equal author.posts_with_comments_and_categories.length, author.posts_with_comments_and_categories.update_all([ "body = ?", "bulk update!" ])
-      end
+  def test_update_all_composite_model_with_join_subquery
+    agreement = cpk_order_agreements(:order_agreement_three)
+    join_scope = Cpk::Order.joins(:order_agreements).where(order_agreements: { signature: agreement.signature })
+    assert_equal 1, join_scope.update_all(status: "shipped")
+  end
+
+  def test_update_all_ignores_order_without_limit_from_association
+    author = authors(:david)
+    assert_nothing_raised do
+      assert_equal author.posts_with_comments_and_categories.length, author.posts_with_comments_and_categories.update_all([ "body = ?", "bulk update!" ])
     end
+  end
 
-    def test_update_all_doesnt_ignore_order
-      assert_equal authors(:david).id + 1, authors(:mary).id # make sure there is going to be a duplicate PK error
-      test_update_with_order_succeeds = lambda do |order|
-        Author.order(order).update_all("id = id + 1")
-      rescue ActiveRecord::ActiveRecordError
-        false
-      end
+  def test_update_all_doesnt_ignore_order
+    skip "DB2 enforces unique constraints at statement end, so ORDER effect is not observable" if current_adapter?(:IBM_DBAdapter)
+
+    assert_equal authors(:david).id + 1, authors(:mary).id # make sure there is going to be a duplicate PK error
+    test_update_with_order_succeeds = lambda do |order|
+      Author.order(order).update_all("id = id + 1")
+    rescue ActiveRecord::ActiveRecordError
+      false
+    end
 
-      if test_update_with_order_succeeds.call("id DESC")
-        # test that this wasn't a fluke and using an incorrect order results in an exception
-        assert_not test_update_with_order_succeeds.call("id ASC")
-      else
-        # test that we're failing because the current Arel's engine doesn't support UPDATE ORDER BY queries is using subselects instead
-        assert_sql(/\AUPDATE .+ \(SELECT .* ORDER BY id DESC\)\z/i) do
-          test_update_with_order_succeeds.call("id DESC")
-        end
+    if test_update_with_order_succeeds.call("id DESC")
+      # test that this wasn't a fluke and using an incorrect order results in an exception
+      assert_not test_update_with_order_succeeds.call("id ASC")
+    else
+      # test that we're failing because the current Arel's engine doesn't support UPDATE ORDER BY queries is using subselects instead
+      assert_queries_match(/\AUPDATE .+ \(SELECT .* ORDER BY id DESC\)\z/i) do
+        test_update_with_order_succeeds.call("id DESC")
       end
     end
 

data/test/cases/relation/where_chain_test.rb

@@ -7,21 +7,201 @@ require "models/human"
 require "models/essay"
 require "models/comment"
 require "models/categorization"
+require "models/book"
+require "models/cpk"
 
 module ActiveRecord
   class WhereChainTest < ActiveRecord::TestCase
-    fixtures :posts, :comments, :authors, :humans, :essays, :author_addresses
+    fixtures :posts, :comments, :authors, :humans, :essays, :author_addresses, :books
+
+    def test_associated_with_association
+      Post.where.associated(:author).tap do |relation|
+        assert_includes     relation, posts(:welcome)
+        assert_includes     relation, posts(:sti_habtm)
+        assert_not_includes relation, posts(:authorless)
+      end
+    end
+
+    def test_associated_with_child_association
+      Comment.where.associated(:children).tap do |relation|
+        assert_includes     relation, comments(:greetings)
+        assert_not_includes relation, comments(:more_greetings)
+      end
+    end
+
+    def test_associated_with_multiple_associations
+      Post.where.associated(:author, :comments).tap do |relation|
+        assert_includes     relation, posts(:welcome)
+        assert_not_includes relation, posts(:sti_habtm)
+        assert_not_includes relation, posts(:authorless)
+      end
+    end
+
+    def test_associated_with_invalid_association_name
+      e = assert_raises(ArgumentError) do
+        Post.where.associated(:cars).to_a
+      end
+
+      assert_match(/An association named `:cars` does not exist on the model `Post`\./, e.message)
+    end
+
+    def test_associated_merged_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.where.associated(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_associated_unscoped_merged_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.unscope(:where).where.associated(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_associated_unscoped_merged_joined_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.joins(:author).unscope(:where).where.associated(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_associated_unscoped_merged_joined_extended_early_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.extending(Post::NamedExtension).joins(:author).unscope(:where).where.associated(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_associated_unscoped_merged_joined_extended_late_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.joins(:author).unscope(:where).where.associated(:author).merge(Author.where(id: 1)).extending(Post::NamedExtension).count
+    end
+
+    def test_associated_ordered_merged_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.order(created_at: :desc).where.associated(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_associated_ordered_merged_joined_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.joins(:author).order(created_at: :desc).where.associated(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_associated_with_enum
+      assert_equal Author.find(2), Author.joins(:reading_listing).where.associated(:reading_listing).first
+    end
+
+    def test_associated_with_enum_ordered
+      assert_equal Author.find(2), Author.order(id: :desc).joins(:reading_listing).where.associated(:reading_listing).first
+    end
+
+    def test_associated_with_enum_unscoped
+      assert_equal Author.find(2), Author.unscope(:where).joins(:reading_listing).where.associated(:reading_listing).first
+    end
+
+    def test_associated_with_enum_extended_early
+      assert_equal Author.find(2), Author.extending(Author::NamedExtension).order(id: :desc).joins(:reading_listing).where.associated(:reading_listing).first
+    end
+
+    def test_associated_with_enum_extended_late
+      assert_equal Author.find(2), Author.order(id: :desc).joins(:reading_listing).where.associated(:reading_listing).extending(Author::NamedExtension).first
+    end
+
+    def test_associated_with_add_joins_before
+      Comment.joins(:children).where.associated(:children).tap do |relation|
+        assert_includes     relation, comments(:greetings)
+        assert_not_includes relation, comments(:more_greetings)
+      end
+    end
+
+    def test_associated_with_add_left_joins_before
+      Comment.left_joins(:children).where.associated(:children).tap do |relation|
+        assert_includes     relation, comments(:greetings)
+        assert_not_includes relation, comments(:more_greetings)
+      end
+    end
+
+    def test_associated_with_add_left_outer_joins_before
+      Comment.left_outer_joins(:children).where.associated(:children).tap do |relation|
+        assert_includes     relation, comments(:greetings)
+        assert_not_includes relation, comments(:more_greetings)
+      end
+    end
+
+    def test_associated_with_composite_primary_key
+      author = Cpk::Author.create!(id: [1, 2])
+      Cpk::Book.create!(id: [author.id, 2])
+
+      assert_predicate Cpk::Author.where.associated(:books), :any?
+    end
 
     def test_missing_with_association
-      assert posts(:authorless).author.blank?
+      assert_predicate posts(:authorless).author, :blank?
       assert_equal [posts(:authorless)], Post.where.missing(:author).to_a
     end
 
+    def test_missing_with_child_association
+      Comment.where.missing(:children).tap do |relation|
+        assert_includes     relation, comments(:more_greetings)
+        assert_not_includes relation, comments(:greetings)
+      end
+    end
+
+    def test_missing_with_invalid_association_name
+      e = assert_raises(ArgumentError) do
+        Post.where.missing(:cars).to_a
+      end
+
+      assert_match(/An association named `:cars` does not exist on the model `Post`\./, e.message)
+    end
+
     def test_missing_with_multiple_association
-      assert posts(:authorless).comments.empty?
+      assert_predicate posts(:authorless).comments, :empty?
       assert_equal [posts(:authorless)], Post.where.missing(:author, :comments).to_a
     end
 
+    def test_missing_merged_with_scope_on_association
+      # This query does not make much logical sense, but it is testing
+      # that the generated SQL query is valid.
+      assert_equal Author.find(1).posts.count, Post.where.missing(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_missing_unscoped_merged_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.joins(:author).unscope(:where).where.missing(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_missing_unscoped_merged_joined_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.unscope(:where).where.missing(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_missing_ordered_merged_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.order(created_at: :desc).where.missing(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_missing_ordered_merged_joined_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.joins(:author).order(created_at: :desc).where.missing(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_missing_unscoped_merged_joined_extended_early_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.extending(Post::NamedExtension).joins(:author).unscope(:where).where.missing(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_missing_unscoped_merged_joined_extended_late_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.joins(:author).unscope(:where).where.missing(:author).merge(Author.where(id: 1)).extending(Post::NamedExtension).count
+    end
+
+    def test_missing_with_enum
+      assert_equal Author.find(2), Author.joins(:reading_listing).where.missing(:unread_listing).first
+    end
+
+    def test_missing_with_enum_ordered
+      assert_equal Author.find(2), Author.order(id: :desc).joins(:reading_listing).where.missing(:unread_listing).first
+    end
+
+    def test_missing_with_enum_unscoped
+      assert_equal Author.find(2), Author.unscope(:where).joins(:reading_listing).where.missing(:unread_listing).first
+    end
+
+    def test_missing_with_enum_extended_early
+      assert_equal Author.find(2), Author.extending(Author::NamedExtension).order(id: :desc).joins(:reading_listing).where.missing(:unread_listing).first
+    end
+
+    def test_missing_with_enum_extended_late
+      assert_equal Author.find(2), Author.order(id: :desc).joins(:reading_listing).where.missing(:unread_listing).extending(Author::NamedExtension).first
+    end
+
+    def test_missing_with_composite_primary_key
+      Cpk::Book.create!(id: [1, 2])
+
+      assert_predicate Cpk::Book.where.missing(:author), :any?
+    end
+
     def test_not_inverts_where_clause
       relation = Post.where.not(title: "hello")
       expected_where_clause = Post.where(title: "hello").where_clause.invert
@@ -137,5 +317,12 @@ module ActiveRecord
 
       assert_equal expected.to_a, relation.to_a
     end
+
+    def test_rewhere_with_nil
+      relation = Post.where(comments_count: 16).rewhere(nil)
+      expected = Post.all
+
+      assert_equal expected.to_a, relation.to_a
+    end
   end
 end

data/test/cases/relation/where_clause_test.rb

@@ -74,6 +74,35 @@ class ActiveRecord::Relation
       assert_equal expected, a.merge(b)
     end
 
+    test "merge with or/and correctly handles SQL literals and attributes" do
+      skip "DB2 wraps SQL literal predicates differently when merging OR/AND where clauses" if current_adapter?(:IBM_DBAdapter)
+
+      a = WhereClause.new([
+        table["id"].eq(1),
+        Arel::Nodes::Grouping.new(Arel.sql("foo = bar"))
+      ])
+      b = (a + WhereClause.new([table["attr_1"].eq("val_1")])).or(
+        WhereClause.new([table["attr_2"].eq("val_2")])
+      )
+
+      expected = WhereClause.new([
+        table["id"].eq(1),
+        Arel::Nodes::Grouping.new(Arel.sql("foo = bar")),
+        Arel::Nodes::Grouping.new(
+          Arel::Nodes::Or.new([
+            Arel::Nodes::And.new([
+              table["id"].eq(1),
+              Arel::Nodes::Grouping.new(Arel.sql("foo = bar")),
+              table["attr_1"].eq("val_1")
+            ]),
+            table["attr_2"].eq("val_2")
+          ])
+        )
+      ])
+
+      assert_equal expected, a.merge(b)
+    end
+
     test "a clause knows if it is empty" do
       assert_empty WhereClause.empty
       assert_not_empty WhereClause.new(["anything"])
@@ -185,7 +214,7 @@ class ActiveRecord::Relation
       other_clause = WhereClause.new([table["name"].eq(bind_param("Sean"))])
       expected_ast =
         Arel::Nodes::Grouping.new(
-          Arel::Nodes::Or.new(table["id"].eq(bind_param(1)), table["name"].eq(bind_param("Sean")))
+          Arel::Nodes::Or.new([table["id"].eq(bind_param(1)), table["name"].eq(bind_param("Sean"))])
         )
 
       assert_equal expected_ast.to_sql, where_clause.or(other_clause).ast.to_sql
@@ -245,6 +274,19 @@ class ActiveRecord::Relation
       assert_equal only_common, common_with_extra.or(only_common)
     end
 
+    test "supports hash equality" do
+      h = Hash.new(0)
+      h[WhereClause.new(["a"])] += 1
+      h[WhereClause.new(["a"])] += 1
+      h[WhereClause.new(["b"])] += 1
+
+      expected = {
+        WhereClause.new(["a"]) => 2,
+        WhereClause.new(["b"]) => 1
+      }
+      assert_equal expected, h
+    end
+
     private
       def table
         Arel::Table.new("table")