ibm_db 5.6.1 → 5.7.0

data/test/cases/relation/merging_test.rb

@@ -24,29 +24,23 @@ class RelationMergingTest < ActiveRecord::TestCase
 
     assert_equal [mary], david_and_mary.merge(Author.where(id: mary))
     assert_equal [mary], david_and_mary.merge(Author.rewhere(id: mary))
-    assert_equal [mary], david_and_mary.merge(Author.where(id: mary), rewhere: true)
 
     assert_equal [bob],  david_and_mary.merge(Author.where(id: bob))
     assert_equal [bob],  david_and_mary.merge(Author.rewhere(id: bob))
-    assert_equal [bob],  david_and_mary.merge(Author.where(id: bob), rewhere: true)
 
     assert_equal [david, bob], mary_and_bob.merge(Author.where(id: [david, bob]))
-    assert_equal [david, bob], mary_and_bob.merge(Author.where(id: [david, bob]), rewhere: true)
 
     assert_equal [mary, bob], david_and_mary.merge(mary_and_bob)
-    assert_equal [mary, bob], david_and_mary.merge(mary_and_bob, rewhere: true)
     assert_equal [mary], david_and_mary.and(mary_and_bob)
     assert_equal authors, david_and_mary.or(mary_and_bob)
 
     assert_equal [david, mary], mary_and_bob.merge(david_and_mary)
-    assert_equal [david, mary], mary_and_bob.merge(david_and_mary, rewhere: true)
     assert_equal [mary], david_and_mary.and(mary_and_bob)
     assert_equal authors, david_and_mary.or(mary_and_bob)
 
     david_and_bob = Author.where(id: david).or(Author.where(name: "Bob"))
 
     assert_equal [david], david_and_mary.merge(david_and_bob)
-    assert_equal [david], david_and_mary.merge(david_and_bob, rewhere: true)
     assert_equal [david], david_and_mary.and(david_and_bob)
     assert_equal authors, david_and_mary.or(david_and_bob)
   end
@@ -60,46 +54,25 @@ class RelationMergingTest < ActiveRecord::TestCase
     assert_equal [david, mary], david_and_mary
     assert_equal [mary, bob],   mary_and_bob
 
-    author_id = Regexp.escape(Author.connection.quote_table_name("authors.id"))
-    message = %r/Merging \(#{author_id} BETWEEN (\?|\W?\w?\d) AND \g<1>\) and \(#{author_id} (?:= \g<1>|IN \(\g<1>, \g<1>\))\) no longer maintain both conditions, and will be replaced by the latter in Rails 7\.0\./
-
-    assert_deprecated(message) do
-      assert_equal [mary], david_and_mary.merge(Author.where(id: mary))
-    end
+    assert_equal [mary], david_and_mary.merge(Author.where(id: mary))
     assert_equal [mary], david_and_mary.merge(Author.rewhere(id: mary))
-    assert_equal [mary], david_and_mary.merge(Author.where(id: mary), rewhere: true)
 
-    assert_deprecated(message) do
-      assert_equal [], david_and_mary.merge(Author.where(id: bob))
-    end
+    assert_equal [bob], david_and_mary.merge(Author.where(id: bob))
     assert_equal [bob],  david_and_mary.merge(Author.rewhere(id: bob))
-    assert_equal [bob],  david_and_mary.merge(Author.where(id: bob), rewhere: true)
 
-    assert_deprecated(message) do
-      assert_equal [bob], mary_and_bob.merge(Author.where(id: [david, bob]))
-    end
-    assert_equal [david, bob], mary_and_bob.merge(Author.where(id: [david, bob]), rewhere: true)
-
-    message = %r/Merging \(#{author_id} BETWEEN (\?|\W?\w?\d) AND \g<1>\) and \(#{author_id} BETWEEN \g<1> AND \g<1>\) no longer maintain both conditions, and will be replaced by the latter in Rails 7\.0\./
+    assert_equal [david, bob], mary_and_bob.merge(Author.where(id: [david, bob]))
 
-    assert_deprecated(message) do
-      assert_equal [mary], david_and_mary.merge(mary_and_bob)
-    end
-    assert_equal [mary, bob], david_and_mary.merge(mary_and_bob, rewhere: true)
+    assert_equal [mary, bob], david_and_mary.merge(mary_and_bob)
     assert_equal [mary], david_and_mary.and(mary_and_bob)
     assert_equal authors, david_and_mary.or(mary_and_bob)
 
-    assert_deprecated(message) do
-      assert_equal [mary], mary_and_bob.merge(david_and_mary)
-    end
-    assert_equal [david, mary], mary_and_bob.merge(david_and_mary, rewhere: true)
+    assert_equal [david, mary], mary_and_bob.merge(david_and_mary)
     assert_equal [mary], david_and_mary.and(mary_and_bob)
     assert_equal authors, david_and_mary.or(mary_and_bob)
 
     david_and_bob = Author.where(id: david).or(Author.where(name: "Bob"))
 
     assert_equal [david], david_and_mary.merge(david_and_bob)
-    assert_equal [david], david_and_mary.merge(david_and_bob, rewhere: true)
     assert_equal [david], david_and_mary.and(david_and_bob)
     assert_equal authors, david_and_mary.or(david_and_bob)
   end
@@ -113,46 +86,26 @@ class RelationMergingTest < ActiveRecord::TestCase
     assert_equal [david, mary], david_and_mary
     assert_equal [mary, bob],   mary_and_bob
 
-    author_id = Regexp.escape(Author.connection.quote_table_name("authors.id"))
-    message = %r/Merging \(\(#{author_id} = (\?|\W?\w?\d) OR #{author_id} = \g<1>\)\) and \(#{author_id} (?:= \g<1>|IN \(\g<1>, \g<1>\))\) no longer maintain both conditions, and will be replaced by the latter in Rails 7\.0\./
-
-    assert_deprecated(message) do
-      assert_equal [mary], david_and_mary.merge(Author.where(id: mary))
-    end
+    assert_equal [mary], david_and_mary.merge(Author.where(id: mary))
     assert_equal [mary], david_and_mary.merge(Author.rewhere(id: mary))
-    assert_equal [mary], david_and_mary.merge(Author.where(id: mary), rewhere: true)
 
-    assert_deprecated(message) do
-      assert_equal [], david_and_mary.merge(Author.where(id: bob))
-    end
+    assert_equal [bob], david_and_mary.merge(Author.where(id: bob))
     assert_equal [bob],  david_and_mary.merge(Author.rewhere(id: bob))
-    assert_equal [bob],  david_and_mary.merge(Author.where(id: bob), rewhere: true)
 
-    assert_deprecated(message) do
-      assert_equal [bob], mary_and_bob.merge(Author.where(id: [david, bob]))
-    end
-    assert_equal [david, bob], mary_and_bob.merge(Author.where(id: [david, bob]), rewhere: true)
+    assert_equal [david, bob], mary_and_bob.merge(Author.where(id: [david, bob]))
 
-    message = %r/Merging \(\(#{author_id} = (\?|\W?\w?\d) OR #{author_id} = \g<1>\)\) and \(\(#{author_id} = \g<1> OR #{author_id} = \g<1>\)\) no longer maintain both conditions, and will be replaced by the latter in Rails 7\.0\./
 
-    assert_deprecated(message) do
-      assert_equal [mary], david_and_mary.merge(mary_and_bob)
-    end
-    assert_equal [mary, bob], david_and_mary.merge(mary_and_bob, rewhere: true)
+    assert_equal [mary, bob], david_and_mary.merge(mary_and_bob)
     assert_equal [mary], david_and_mary.and(mary_and_bob)
     assert_equal authors, david_and_mary.or(mary_and_bob)
 
-    assert_deprecated(message) do
-      assert_equal [mary], mary_and_bob.merge(david_and_mary)
-    end
-    assert_equal [david, mary], mary_and_bob.merge(david_and_mary, rewhere: true)
+    assert_equal [david, mary], mary_and_bob.merge(david_and_mary)
     assert_equal [mary], david_and_mary.and(mary_and_bob)
     assert_equal authors, david_and_mary.or(mary_and_bob)
 
     david_and_bob = Author.where(id: david).or(Author.where(name: "Bob"))
 
     assert_equal [david], david_and_mary.merge(david_and_bob)
-    assert_equal [david], david_and_mary.merge(david_and_bob, rewhere: true)
     assert_equal [david], david_and_mary.and(david_and_bob)
     assert_equal authors, david_and_mary.or(david_and_bob)
   end
@@ -164,15 +117,9 @@ class RelationMergingTest < ActiveRecord::TestCase
 
     assert_equal [david], non_mary_and_bob
 
-    assert_deprecated do
-      assert_equal [david], Author.where(id: david).merge(non_mary_and_bob)
-    end
-    assert_equal [david], Author.where(id: david).merge(non_mary_and_bob, rewhere: true)
+    assert_equal [david], Author.where(id: david).merge(non_mary_and_bob)
 
-    assert_deprecated do
-      assert_equal [], Author.where(id: mary).merge(non_mary_and_bob)
-    end
-    assert_equal [david], Author.where(id: mary).merge(non_mary_and_bob, rewhere: true)
+    assert_equal [david], Author.where(id: mary).merge(non_mary_and_bob)
   end
 
   def test_merge_not_range_clause
@@ -182,15 +129,9 @@ class RelationMergingTest < ActiveRecord::TestCase
 
     assert_equal [david, mary], less_than_bob
 
-    assert_deprecated do
-      assert_equal [david], Author.where(id: david).merge(less_than_bob)
-    end
-    assert_equal [david, mary], Author.where(id: david).merge(less_than_bob, rewhere: true)
+    assert_equal [david, mary], Author.where(id: david).merge(less_than_bob)
 
-    assert_deprecated do
-      assert_equal [mary], Author.where(id: mary).merge(less_than_bob)
-    end
-    assert_equal [david, mary], Author.where(id: mary).merge(less_than_bob, rewhere: true)
+    assert_equal [david, mary], Author.where(id: mary).merge(less_than_bob)
   end
 
   def test_merge_doesnt_duplicate_same_clauses
@@ -198,19 +139,27 @@ class RelationMergingTest < ActiveRecord::TestCase
 
     non_mary_and_bob = Author.where.not(id: [mary, bob])
 
-    author_id = Author.connection.quote_table_name("authors.id")
-    assert_sql(/WHERE #{Regexp.escape(author_id)} NOT IN \((\?|\W?\w?\d), \g<1>\)\z/) do
+    author_id = quote_table_name("authors.id")
+    assert_queries_match(/WHERE #{Regexp.escape(author_id)} NOT IN \((\?|\W?\w?\d), \g<1>\)\z/) do
       assert_equal [david], non_mary_and_bob.merge(non_mary_and_bob)
     end
 
     only_david = Author.where("#{author_id} IN (?)", david)
 
-    assert_sql(/WHERE \(#{Regexp.escape(author_id)} IN \(1\)\)\z/) do
-      assert_equal [david], only_david.merge(only_david)
+    matcher = if Author.lease_connection.prepared_statements
+      if current_adapter?(:PostgreSQLAdapter)
+        /WHERE \(#{Regexp.escape(author_id)} IN \(\$1\)\)\z/
+      else
+        /WHERE \(#{Regexp.escape(author_id)} IN \(\?\)\)\z/
+      end
+    elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      /WHERE \(#{Regexp.escape(author_id)} IN \('1'\)\)\z/
+    else
+      /WHERE \(#{Regexp.escape(author_id)} IN \(1\)\)\z/
     end
 
-    assert_sql(/WHERE \(#{Regexp.escape(author_id)} IN \(1\)\)\z/) do
-      assert_equal [david], only_david.merge(only_david, rewhere: true)
+    assert_queries_match(matcher) do
+      assert_equal [david], only_david.merge(only_david)
     end
   end
 
@@ -234,9 +183,6 @@ class RelationMergingTest < ActiveRecord::TestCase
     devs = Developer.where(salary_attr.eq(80000)).merge(Developer.where(salary_attr.eq(9000)))
     assert_equal [developers(:poor_jamis)], devs.to_a
 
-    devs = Developer.where(salary_attr.eq(80000)).merge(Developer.where(salary_attr.eq(9000)), rewhere: true)
-    assert_equal [developers(:poor_jamis)], devs.to_a
-
     devs = Developer.where(salary_attr.eq(80000)).rewhere(salary_attr.eq(9000))
     assert_equal [developers(:poor_jamis)], devs.to_a
   end
@@ -248,9 +194,6 @@ class RelationMergingTest < ActiveRecord::TestCase
     devs = Developer.where(abs_salary.eq(80000)).merge(Developer.where(abs_salary.eq(9000)))
     assert_equal [developers(:poor_jamis)], devs.to_a
 
-    devs = Developer.where(abs_salary.eq(80000)).merge(Developer.where(abs_salary.eq(9000)), rewhere: true)
-    assert_equal [developers(:poor_jamis)], devs.to_a
-
     devs = Developer.where(abs_salary.eq(80000)).rewhere(abs_salary.eq(9000))
     assert_equal [developers(:poor_jamis)], devs.to_a
   end
@@ -273,7 +216,7 @@ class RelationMergingTest < ActiveRecord::TestCase
 
   def test_relation_merging_with_preload
     [Post.all.merge(Post.preload(:author)), Post.preload(:author).merge(Post.all)].each do |posts|
-      assert_queries(2) { assert posts.first.author }
+      assert_queries_count(2) { assert posts.first.author }
     end
   end
 
@@ -289,11 +232,11 @@ class RelationMergingTest < ActiveRecord::TestCase
   end
 
   def test_relation_merging_with_skip_query_cache
-    assert_equal Post.all.merge(Post.all.skip_query_cache!).skip_query_cache_value, true
+    assert_equal true, Post.all.merge(Post.all.skip_query_cache!).skip_query_cache_value
   end
 
   def test_relation_merging_with_association
-    assert_queries(2) do  # one for loading post, and another one merged query
+    assert_queries_count(2) do  # one for loading post, and another one merged query
       post = Post.where(body: "Such a lovely day").first
       comments = Comment.where(body: "Thank you for the welcome").merge(post.comments)
       assert_equal 1, comments.count
@@ -347,42 +290,31 @@ class RelationMergingTest < ActiveRecord::TestCase
   end
 
   def test_merging_annotations_respects_merge_order
-    assert_sql(%r{/\* foo \*/ /\* bar \*/}) do
+    assert_queries_match(%r{/\* foo \*/ /\* bar \*/}) do
       Post.annotate("foo").merge(Post.annotate("bar")).first
     end
-    assert_sql(%r{/\* bar \*/ /\* foo \*/}) do
+    assert_queries_match(%r{/\* bar \*/ /\* foo \*/}) do
       Post.annotate("bar").merge(Post.annotate("foo")).first
     end
-    assert_sql(%r{/\* foo \*/ /\* bar \*/ /\* baz \*/ /\* qux \*/}) do
+    assert_queries_match(%r{/\* foo \*/ /\* bar \*/ /\* baz \*/ /\* qux \*/}) do
       Post.annotate("foo").annotate("bar").merge(Post.annotate("baz").annotate("qux")).first
     end
   end
 
   def test_merging_duplicated_annotations
     posts = Post.annotate("foo")
-    assert_sql(%r{FROM #{Regexp.escape(Post.quoted_table_name)} /\* foo \*/\z}) do
+    assert_queries_match(%r{FROM #{Regexp.escape(Post.quoted_table_name)} /\* foo \*/\z}) do
       posts.merge(posts).uniq!(:annotate).to_a
     end
 
-    message = <<-MSG.squish
-      Duplicated query annotations are no longer shown in queries in Rails 7.0.
-      To migrate to Rails 7.0's behavior, use `uniq!(:annotate)` to deduplicate query annotations
-      (`posts.uniq!(:annotate)`).
-    MSG
-    assert_deprecated(message) do
-      assert_sql(%r{FROM #{Regexp.escape(Post.quoted_table_name)} /\* foo \*/ /\* foo \*/\z}) do
-        posts.merge(posts).to_a
-      end
+    assert_queries_match(%r{FROM #{Regexp.escape(Post.quoted_table_name)} /\* foo \*/\z}) do
+      posts.merge(posts).to_a
     end
-    assert_deprecated(message) do
-      assert_sql(%r{FROM #{Regexp.escape(Post.quoted_table_name)} /\* foo \*/ /\* bar \*/ /\* foo \*/\z}) do
-        Post.annotate("foo").merge(Post.annotate("bar")).merge(posts).to_a
-      end
+    assert_queries_match(%r{FROM #{Regexp.escape(Post.quoted_table_name)} /\* foo \*/ /\* bar \*/\z}) do
+      Post.annotate("foo").merge(Post.annotate("bar")).merge(posts).to_a
     end
-    assert_deprecated(message) do
-      assert_sql(%r{FROM #{Regexp.escape(Post.quoted_table_name)} /\* bar \*/ /\* foo \*/ /\* foo \*/\z}) do
-        Post.annotate("bar").merge(Post.annotate("foo")).merge(posts).to_a
-      end
+    assert_queries_match(%r{FROM #{Regexp.escape(Post.quoted_table_name)} /\* bar \*/ /\* foo \*/\z}) do
+      Post.annotate("bar").merge(Post.annotate("foo")).merge(posts).to_a
     end
   end
 end
@@ -431,4 +363,43 @@ class MergingDifferentRelationsTest < ActiveRecord::TestCase
 
     assert_equal dev.ratings, [rating_1]
   end
+
+  test "merging where relation having arel equality with null relation" do
+    skip "DB2 emits SQL literal predicates for this NULL equality shape, which ActiveRecord relation merge cannot de-duplicate" if current_adapter?(:IBM_DBAdapter)
+
+    arel_predicate = Arel::Nodes::NamedFunction.new("ABS", [Post.arel_table[:tags_count]]).eq(0)
+    arel_relation = Post.where(arel_predicate)
+    relation = arel_relation.merge(arel_relation.none)
+    sql = relation.to_sql
+    assert_match("AND", sql)
+  end
+
+  if ActiveRecord::Base.lease_connection.supports_common_table_expressions?
+    test "merging relation with common table expression" do
+      posts_with_tags = Post.with(posts_with_tags: Post.where("tags_count > 0")).from("posts_with_tags AS posts")
+      posts_with_comments = Post.where("legacy_comments_count > 0")
+      relation = posts_with_comments.merge(posts_with_tags).order("posts.id")
+
+      assert_equal [1, 2, 7], relation.pluck(:id)
+    end
+
+    test "merging multiple relations with common table expression" do
+      posts_with_tags = Post.with(posts_with_tags: Post.where("tags_count > 0"))
+      posts_with_comments = Post.with(posts_with_comments: Post.where("legacy_comments_count > 0"))
+      relation = posts_with_comments.merge(posts_with_tags)
+        .joins("JOIN posts_with_tags pwt ON pwt.id = posts.id JOIN posts_with_comments pwc ON pwc.id = posts.id").order("posts.id")
+
+      assert_equal [1, 2, 7], relation.pluck(:id)
+    end
+
+    test "relation merger leaves to database to decide what to do when multiple CTEs with same alias are passed" do
+      posts_with_tags = Post.with(popular_posts: Post.where("tags_count > 0"))
+      posts_with_comments = Post.with(popular_posts: Post.where("legacy_comments_count > 0"))
+      relation = posts_with_tags.merge(posts_with_comments).joins("JOIN popular_posts pp ON pp.id = posts.id")
+
+      assert_raises ActiveRecord::StatementInvalid do
+        relation.load
+      end
+    end
+  end
 end

data/test/cases/relation/mutation_test.rb

@@ -5,7 +5,7 @@ require "models/post"
 
 module ActiveRecord
   class RelationMutationTest < ActiveRecord::TestCase
-    (Relation::MULTI_VALUE_METHODS - [:extending, :order, :unscope, :select]).each do |method|
+    (Relation::MULTI_VALUE_METHODS - [:extending, :order, :unscope, :select, :with]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal [:foo], relation.public_send("#{method}_values")
@@ -32,10 +32,8 @@ module ActiveRecord
 
     test "#order! on non-string does not attempt regexp match for references" do
       obj = Object.new
-      assert_not_called(obj, :=~) do
-        assert relation.order!(obj)
-        assert_equal [obj], relation.order_values
-      end
+      assert relation.order!(obj)
+      assert_equal [obj], relation.order_values
     end
 
     test "extending!" do
@@ -118,8 +116,8 @@ module ActiveRecord
 
     test "none!" do
       assert relation.none!.equal?(relation)
-      assert_equal [NullRelation], relation.extending_values
-      assert relation.is_a?(NullRelation)
+      assert_predicate relation, :none?
+      assert_predicate relation, :null_relation?
     end
 
     test "distinct!" do
@@ -137,6 +135,13 @@ module ActiveRecord
       assert relation.skip_preloading_value
     end
 
+    test "#regroup!" do
+      @relation = relation.group("foo")
+
+      assert relation.regroup!("bar").equal?(relation)
+      assert_equal ["bar"], relation.group_values
+    end
+
     private
       def relation
         @relation ||= Relation.new(FakeKlass)

data/test/cases/relation/or_test.rb

@@ -4,7 +4,8 @@ require "cases/helper"
 require "models/author"
 require "models/categorization"
 require "models/post"
-require "models/citation"
+require "models/book"
+require "models/paragraph"
 
 module ActiveRecord
   class OrTest < ActiveRecord::TestCase
@@ -133,9 +134,11 @@ module ActiveRecord
     end
 
     def test_or_with_non_relation_object_raises_error
-      assert_raises ArgumentError do
+      error = assert_raises ArgumentError do
         Post.where(id: [1, 2, 3]).or(title: "Rails")
       end
+
+      assert_equal "You have passed Hash object to #or. Pass an ActiveRecord::Relation object instead.", error.message
     end
 
     def test_or_with_references_inequality
@@ -176,16 +179,16 @@ module ActiveRecord
 
   # The maximum expression tree depth is 1000 by default for SQLite3.
   # https://www.sqlite.org/limits.html#max_expr_depth
-  unless current_adapter?(:SQLite3Adapter)
-    class TooManyOrTest < ActiveRecord::TestCase
-      fixtures :citations
+  class TooManyOrTest < ActiveRecord::TestCase
+    unless current_adapter?(:SQLite3Adapter)
+      fixtures :paragraphs
 
       def test_too_many_or
-        citations = 6000.times.map do |i|
-          Citation.where(id: i, book2_id: i * i)
+        paragraphs = 1001.times.map do |i|
+          Paragraph.where(id: i, book_id: i * i)
         end
 
-        assert_equal 6000, citations.inject(&:or).count
+        assert_equal 1001, paragraphs.inject(&:or).count
       end
     end
   end

data/test/cases/relation/order_test.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/book"
+
+class OrderTest < ActiveRecord::TestCase
+  fixtures :authors, :author_addresses
+
+  def setup
+    Book.delete_all
+  end
+
+  def test_order_asc
+    z = Book.create!(name: "Zulu", author: authors(:david))
+    y = Book.create!(name: "Yankee", author: authors(:mary))
+    x = Book.create!(name: "X-Ray", author: authors(:david))
+
+    alphabetical = [x, y, z]
+
+    assert_equal(alphabetical, Book.order(name: :asc))
+    assert_equal(alphabetical, Book.order(name: :ASC))
+    assert_equal(alphabetical, Book.order(name: "asc"))
+    assert_equal(alphabetical, Book.order(:name))
+    assert_equal(alphabetical, Book.order("name"))
+    assert_equal(alphabetical, Book.order("books.name"))
+    assert_equal(alphabetical, Book.order(Book.arel_table["name"]))
+    assert_equal(alphabetical, Book.order(books: { name: :asc }))
+  end
+
+  def test_order_desc
+    z = Book.create!(name: "Zulu", author: authors(:david))
+    y = Book.create!(name: "Yankee", author: authors(:mary))
+    x = Book.create!(name: "X-Ray", author: authors(:david))
+
+    reverse_alphabetical = [z, y, x]
+
+    assert_equal(reverse_alphabetical, Book.order(name: :desc))
+    assert_equal(reverse_alphabetical, Book.order(name: :DESC))
+    assert_equal(reverse_alphabetical, Book.order(name: "desc"))
+    assert_equal(reverse_alphabetical, Book.order(:name).reverse_order)
+    assert_equal(reverse_alphabetical, Book.order("name desc"))
+    assert_equal(reverse_alphabetical, Book.order("books.name desc"))
+    assert_equal(reverse_alphabetical, Book.order(Book.arel_table["name"].desc))
+    assert_equal(reverse_alphabetical, Book.order(books: { name: :desc }))
+  end
+
+  def test_order_with_association
+    z = Book.create!(name: "Zulu", author: authors(:david))
+    y = Book.create!(name: "Yankee", author: authors(:mary))
+    x = Book.create!(name: "X-Ray", author: authors(:david))
+
+    author_then_book_name = [x, z, y]
+
+    assert_equal(author_then_book_name, Book.includes(:author).order(authors: { name: :asc }, books: { name: :asc }))
+    assert_equal(author_then_book_name, Book.includes(:author).order("authors.name", books: { name: :asc }))
+    assert_equal(author_then_book_name, Book.includes(:author).order("authors.name", "books.name"))
+    assert_equal(author_then_book_name, Book.includes(:author).order({ authors: { name: :asc } }, Book.arel_table[:name]))
+    assert_equal(author_then_book_name, Book.includes(:author).order(Author.arel_table[:name], Book.arel_table[:name]))
+
+    author_desc_then_book_name = [y, x, z]
+
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order(authors: { name: :desc }, books: { name: :asc }))
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order("authors.name desc", books: { name: :asc }))
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order(Author.arel_table[:name].desc, books: { name: :asc }))
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order({ authors: { name: :desc } }, :name))
+  end
+
+  def test_order_with_association_alias
+    z = Book.create!(name: "Zulu", author: authors(:david))
+    y = Book.create!(name: "Yankee", author: authors(:mary))
+    x = Book.create!(name: "X-Ray", author: authors(:david))
+
+    author_name = Author.arel_table.alias("author")[:name]
+
+    author_then_book_name = [x, z, y]
+
+    assert_equal(author_then_book_name, Book.includes(:author).order(author: { name: :asc }, books: { name: :asc }))
+    assert_equal(author_then_book_name, Book.includes(:author).order("author.name", books: { name: :asc }))
+    assert_equal(author_then_book_name, Book.includes(:author).order({ author: { name: :asc } }, :name))
+    assert_equal(author_then_book_name, Book.includes(:author).order(author_name, :name))
+
+    author_desc_then_book_name = [y, x, z]
+
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order(author: { name: :desc }, books: { name: :asc }))
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order("author.name desc", books: { name: :asc }))
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order({ author: { name: :desc } }, :name))
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order(author_name.desc, :name))
+  end
+end

data/test/cases/relation/predicate_builder_test.rb

@@ -16,16 +16,31 @@ module ActiveRecord
     end
 
     def test_registering_new_handlers
-      assert_match %r{#{Regexp.escape(topic_title)} ~ 'rails'}i, Topic.where(title: /rails/).to_sql
+      assert_match %r{#{Regexp.escape(quote_table_name("topics.title"))} ~ 'rails'}i, Topic.where(title: /rails/).to_sql
     end
 
     def test_registering_new_handlers_for_association
-      assert_match %r{#{Regexp.escape(topic_title)} ~ 'rails'}i, Reply.joins(:topic).where(topics: { title: /rails/ }).to_sql
+      assert_match %r{#{Regexp.escape(quote_table_name("topics.title"))} ~ 'rails'}i, Reply.joins(:topic).where(topics: { title: /rails/ }).to_sql
     end
 
-    private
-      def topic_title
-        Topic.connection.quote_table_name("topics.title")
-      end
+    def test_registering_new_handlers_for_joins
+      Reply.belongs_to :regexp_topic, -> { where(title: /rails/) }, class_name: "Topic", foreign_key: "parent_id"
+
+      assert_match %r{#{Regexp.escape(quote_table_name("regexp_topic.title"))} ~ 'rails'}i, Reply.joins(:regexp_topic).references(Arel.sql("regexp_topic")).to_sql
+    end
+
+    def test_references_with_schema
+      assert_equal %w{schema.table}, ActiveRecord::PredicateBuilder.references(%w{schema.table.column})
+    end
+
+    def test_build_from_hash_with_schema
+      assert_match %r{schema.+table.+column}i, Topic.predicate_builder.build_from_hash("schema.table.column" => "value").first.to_sql
+    end
+
+    def test_does_not_mutate
+      defaults = { topics: { title: "rails" }, "topics.approved" => true }
+      Topic.where(defaults).to_sql
+      assert_equal({ topics: { title: "rails" }, "topics.approved" => true }, defaults)
+    end
   end
 end