ibm_db 5.6.1 → 5.7.0

data/test/cases/relation/where_test.rb

@@ -16,6 +16,7 @@ require "models/price_estimate"
 require "models/topic"
 require "models/treasure"
 require "models/vertex"
+require "models/cpk"
 require "support/stubs/strong_parameters"
 
 module ActiveRecord
@@ -33,10 +34,6 @@ module ActiveRecord
       assert_equal [authors(:bob)], Author.joins(:categories).where(categories: categories(:technology))
     end
 
-    def test_where_with_aliased_association
-      assert_equal [comments(:does_it_hurt)], Comment.where(entry: posts(:thinking))
-    end
-
     def test_type_cast_is_not_evaluated_at_relation_build_time
       posts = nil
 
@@ -95,6 +92,74 @@ module ActiveRecord
       assert_equal posts(:welcome), Post.rewhere(title: "Welcome to the weblog").first
     end
 
+    def test_where_with_tuple_syntax
+      first_topic = topics(:first)
+      third_topic = topics(:third)
+
+      key = [:title, :author_name]
+
+      conditions = [
+        [first_topic.title, first_topic.author_name],
+        [third_topic.title, third_topic.author_name],
+      ]
+
+      assert_equal [first_topic], Topic.where([:id] => [[first_topic.id]])
+      assert_equal [first_topic, third_topic].sort, Topic.where(key => conditions).sort
+    end
+
+    def test_where_with_tuple_syntax_on_composite_models
+      book_one = Cpk::Book.create!(id: [1, 2])
+      book_two = Cpk::Book.create!(id: [3, 4])
+
+      assert_equal [book_one], Cpk::Book.where([:author_id, :id] => [[1, 2]])
+      assert_equal [book_one, book_two].sort, Cpk::Book.where(Cpk::Book.primary_key => [[1, 2], [3, 4]]).sort
+      assert_empty Cpk::Book.where([:author_id, :id] => [[1, 4], [3, 2]])
+    end
+
+    def test_where_with_tuple_syntax_with_incorrect_arity
+      error = assert_raise ArgumentError do
+        Cpk::Book.where([:one, :two, :three] => [1, 2, 3])
+      end
+
+      assert_match(/Expected corresponding value for.*to be an Array/, error.message)
+
+      error = assert_raise ArgumentError do
+        Cpk::Book.where([:one, :two] => 1)
+      end
+
+      assert_match(/Expected corresponding value for.*to be an Array/, error.message)
+    end
+
+    def test_where_with_tuple_syntax_and_regular_syntax_combined
+      book_one = Cpk::Book.create!(id: [1, 2], title: "The Alchemist")
+      book_two = Cpk::Book.create!(id: [3, 4], title: "The Alchemist")
+
+      assert_equal [book_one, book_two].sort, Cpk::Book.where(title: "The Alchemist").sort
+      assert_equal [book_one, book_two].sort, Cpk::Book.where(title: "The Alchemist", [:author_id, :id] => [[1, 2], [3, 4]]).sort
+      assert_equal [book_two], Cpk::Book.where(title: "The Alchemist", [:author_id, :id] => [[3, 4]])
+    end
+
+    def test_with_tuple_syntax_and_large_values_list
+      # sqlite3 raises "Expression tree is too large (maximum depth 1000)"
+      skip if current_adapter?(:SQLite3Adapter)
+
+      assert_nothing_raised do
+        ids = [[1, 2]] * 1500
+        Cpk::Book.where([:author_id, :id] => ids).to_sql
+      end
+    end
+
+    def test_where_with_nil_cpk_association
+      skip "DB2 CPK association nil predicate expansion is not supported in this environment" if current_adapter?(:IBM_DBAdapter)
+
+      order = Cpk::Order.create!(id: [1, 2])
+      book = order.books.create!(id: [3, 4])
+      assert_includes Cpk::Book.where(order: order), book
+
+      book.update!(order: nil)
+      assert_includes Cpk::Book.where(order: nil), book
+    end
+
     def test_belongs_to_shallow_where
       author = Author.new
       author.id = 1
@@ -265,8 +330,8 @@ module ActiveRecord
           model.is_a?(klass)
         end
 
-        def method_missing(method, *args, &block)
-          model.send(method, *args, &block)
+        def method_missing(...)
+          model.send(...)
         end
       end
 
@@ -336,6 +401,11 @@ module ActiveRecord
       assert_equal 0, count
     end
 
+    def test_where_with_rational_for_string_column
+      count = Post.where(title: Rational(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
@@ -369,7 +439,7 @@ module ActiveRecord
     def test_where_on_association_with_relation_performs_subselect_not_two_queries
       author = authors(:david)
 
-      assert_queries(1) do
+      assert_queries_count(1) do
         Essay.where(writer: Author.where(id: author.id)).to_a
       end
     end
@@ -405,6 +475,11 @@ module ActiveRecord
       assert_equal essays(:david_modest_proposal), essay
     end
 
+    def test_where_on_association_with_collection_polymorphic_relation
+      treasures = Treasure.where(name: ["diamond", "emerald"], price_estimates: PriceEstimate.all)
+      assert_equal [treasures(:diamond)], treasures
+    end
+
     def test_where_with_strong_parameters
       author = authors(:david)
       params = ProtectedParams.new(name: author.name)
@@ -425,5 +500,18 @@ module ActiveRecord
     def test_where_with_unsupported_arguments
       assert_raises(ArgumentError) { Author.where(42) }
     end
+
+    def test_invert_where
+      author = authors(:david)
+      posts = author.posts.where.not(id: 1)
+
+      assert_equal 1, posts.invert_where.first.id
+    end
+
+    def test_nested_conditional_on_enum
+      post = Post.first
+      Comment.create!(label: :default, post: post, body: "Nice weather today")
+      assert_equal [post], Post.joins(:comments).where(comments: { label: :default, body: "Nice weather today" }).to_a
+    end
   end
 end

data/test/cases/relation/with_test.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/comment"
+require "models/post"
+require "models/company"
+
+module ActiveRecord
+  class WithTest < ActiveRecord::TestCase
+    fixtures :comments, :posts, :companies
+
+    SPECIAL_POSTS = [2].freeze
+    POSTS_WITH_TAGS = [1, 2, 7, 8, 9, 10, 11].freeze
+    POSTS_WITH_COMMENTS = [1, 2, 4, 5, 7].freeze
+    POSTS_WITH_MULTIPLE_COMMENTS = [1, 4, 5].freeze
+    POSTS_WITH_TAGS_AND_COMMENTS = (POSTS_WITH_COMMENTS & POSTS_WITH_TAGS).sort.freeze
+    POSTS_WITH_TAGS_AND_MULTIPLE_COMMENTS = (POSTS_WITH_MULTIPLE_COMMENTS & POSTS_WITH_TAGS).sort.freeze
+
+    if ActiveRecord::Base.lease_connection.supports_common_table_expressions?
+      def test_with_when_hash_is_passed_as_an_argument
+        relation = Post
+          .with(posts_with_comments: Post.where("legacy_comments_count > 0"))
+          .from("posts_with_comments AS posts")
+
+        assert_equal POSTS_WITH_COMMENTS, relation.order(:id).pluck(:id)
+      end
+
+      def test_with_when_hash_with_multiple_elements_of_different_type_is_passed_as_an_argument
+        skip "DB2 does not support BoundSqlLiteral values in WITH hash expressions" if current_adapter?(:IBM_DBAdapter)
+
+        cte_options = {
+          posts_with_tags: Post.arel_table.project(Arel.star).where(Post.arel_table[:tags_count].gt(0)),
+          posts_with_tags_and_truthy: Arel.sql("SELECT * FROM posts_with_tags WHERE 1=1"),
+          posts_with_tags_and_comments: Arel.sql("SELECT * FROM posts_with_tags_and_truthy WHERE tags_count > ?", 0),
+          "posts_with_tags_and_multiple_comments" => Post.where("legacy_comments_count > 1").from("posts_with_tags_and_comments AS posts")
+        }
+        relation = Post.with(cte_options).from("posts_with_tags_and_multiple_comments AS posts")
+
+        assert_equal POSTS_WITH_TAGS_AND_MULTIPLE_COMMENTS, relation.order(:id).pluck(:id)
+      end
+
+      def test_with_when_invalid_argument_is_passed
+        assert_raises ArgumentError, match: /\AUnsupported argument type: #<Post:0x[0-9a-f]+> Post\z/ do
+          Post.with(Post.where(type: "Post"))
+        end
+      end
+
+      def test_multiple_with_calls
+        relation = Post
+          .with(posts_with_tags: Post.where("tags_count > 0"))
+          .from("posts_with_tags_and_comments AS posts")
+          .with(posts_with_tags_and_comments: Arel.sql("SELECT * FROM posts_with_tags WHERE legacy_comments_count > 0"))
+
+        assert_equal POSTS_WITH_TAGS_AND_COMMENTS, relation.order(:id).pluck(:id)
+      end
+
+      def test_multiple_dupicate_with_calls
+        posts_with_tags = Post.where("tags_count > 0")
+        relation = Post
+          .with(posts_with_tags: posts_with_tags, one_more_posts_with_tags: posts_with_tags)
+          .with(posts_with_tags: posts_with_tags)
+          .from("posts_with_tags AS posts")
+
+        assert_equal POSTS_WITH_TAGS, relation.order(:id).pluck(:id)
+      end
+
+      def test_count_after_with_call
+        relation = Post.with(posts_with_comments: Post.where("legacy_comments_count > 0"))
+
+        assert_equal Post.count, relation.count
+        assert_equal POSTS_WITH_COMMENTS.size, relation.from("posts_with_comments AS posts").count
+        assert_equal POSTS_WITH_COMMENTS.size, relation.joins("JOIN posts_with_comments ON posts_with_comments.id = posts.id").count
+      end
+
+      def test_with_when_called_from_active_record_scope
+        assert_equal POSTS_WITH_TAGS, Post.with_tags_cte.order(:id).pluck(:id)
+      end
+
+      def test_with_when_invalid_params_are_passed
+        assert_raise(ArgumentError) { Post.with(posts_with_tags: nil).load }
+        assert_raise(ArgumentError) { Post.with(posts_with_tags: [Post.where("tags_count > 0"), 5]).load }
+      end
+
+      def test_with_when_passing_arrays
+        relation = Post
+          .with(posts_with_special_type_or_tags_or_comments: [
+            Post.where(type: "SpecialPost"),
+            Arel.sql("SELECT * FROM posts WHERE tags_count > 0"), # arel node on purpose
+            Post.where("legacy_comments_count > 0")
+          ])
+          .from("posts_with_special_type_or_tags_or_comments AS posts")
+
+        assert_equal (SPECIAL_POSTS + POSTS_WITH_TAGS + POSTS_WITH_COMMENTS).sort, relation.order(:id).pluck(:id)
+      end
+
+      def test_with_when_passing_single_item_array
+        relation = Post
+          .with(posts_with_special_type_or_tags_or_comments: [Post.where(type: "SpecialPost")])
+          .from("posts_with_special_type_or_tags_or_comments AS posts")
+
+        assert_equal SPECIAL_POSTS.sort, relation.order(:id).pluck(:id)
+      end
+
+      def test_with_recursive
+        skip "DB2 does not support this RECURSIVE CTE syntax form" if current_adapter?(:IBM_DBAdapter)
+
+        top_companies = Company.where(firm_id: nil).to_a
+        child_companies = Company.where(firm_id: top_companies).to_a
+        top_companies_and_children = (top_companies.map(&:id) + child_companies.map(&:id)).sort
+
+        relation = Company.with_recursive(
+          top_companies_and_children: [
+            Company.where(firm_id: nil),
+            Company.joins("JOIN top_companies_and_children ON companies.firm_id = top_companies_and_children.id"),
+          ]
+        ).from("top_companies_and_children AS companies")
+
+        assert_equal top_companies_and_children, relation.order(:id).pluck(:id)
+        assert_match "WITH RECURSIVE", relation.to_sql
+      end
+
+      def test_with_joins
+        relation = Post
+          .with(commented_posts: Comment.select(:post_id).distinct)
+          .joins(:commented_posts)
+
+        assert_equal POSTS_WITH_COMMENTS, relation.order(:id).pluck(:id)
+      end
+
+      def test_with_left_joins
+        relation = Post
+          .with(commented_posts: Comment.select(:post_id).distinct)
+          .left_outer_joins(:commented_posts)
+          .select("posts.*, commented_posts.post_id as has_comments")
+
+        records = relation.order(:id).to_a
+
+        # Make sure we load all records (thus, left outer join is used)
+        assert_equal Post.count, records.size
+        assert_equal POSTS_WITH_COMMENTS, records.filter_map { _1.id if _1.has_comments }
+      end
+
+      def test_raises_when_using_block
+        assert_raises(ArgumentError, match: "does not accept a block") do
+          Post.with(attributes_for_inspect: :id) { }
+        end
+      end
+
+      def test_unscoping
+        relation = Post.with(posts_with_comments: Post.where("legacy_comments_count > 0"))
+
+        assert_equal true, relation.values[:with].flat_map(&:keys).include?(:posts_with_comments)
+        relation = relation.unscope(:with)
+        assert_nil relation.values[:with]
+        assert_equal Post.count, relation.count
+      end
+    else
+      def test_common_table_expressions_are_unsupported
+        assert_raises ActiveRecord::StatementInvalid do
+          Post.with_tags_cte.order(:id).pluck(:id)
+        end
+      end
+    end
+  end
+end

data/test/cases/relation_test.rb

@@ -13,7 +13,7 @@ module ActiveRecord
 
     def test_construction
       relation = Relation.new(FakeKlass, table: :b)
-      assert_equal FakeKlass, relation.klass
+      assert_equal FakeKlass, relation.model
       assert_equal :b, relation.table
       assert_not relation.loaded, "relation is not loaded"
     end
@@ -204,7 +204,7 @@ module ActiveRecord
 
       relation = Relation.new(klass)
       relation.merge!(where: ["foo = ?", "bar"])
-      assert_equal Relation::WhereClause.new(["foo = bar"]), relation.where_clause
+      assert_equal Relation::WhereClause.new([Arel.sql("(foo = ?)", "bar")]), relation.where_clause
     end
 
     def test_merging_readonly_false
@@ -247,8 +247,13 @@ module ActiveRecord
       nb_inner_join = queries.sum { |sql| sql.scan(/INNER\s+JOIN/i).size }
       assert_equal 3, nb_inner_join, "Wrong amount of INNER JOIN in query"
 
-      # using `\W` as the column separator
-      assert queries.any? { |sql| %r[INNER\s+JOIN\s+#{Regexp.escape(Author.quoted_table_name)}\s+authors_categorizations]i.match?(sql) }, "Should be aliasing the child INNER JOINs in query"
+      alias_pattern = if current_adapter?(:IBM_DBAdapter)
+        %r[INNER\s+JOIN\s+#{Regexp.escape(Author.quoted_table_name)}\s+authors_categorizations\W]i
+      else
+        # using `\W` as the column separator
+        %r[INNER\s+JOIN\s+#{Regexp.escape(Author.quoted_table_name)}\s+\Wauthors_categorizations\W]i
+      end
+      assert queries.any? { |sql| alias_pattern.match?(sql) }, "Should be aliasing the child INNER JOINs in query"
     end
 
     def test_relation_with_merged_joins_aliased_works
@@ -256,9 +261,9 @@ module ActiveRecord
       posts_with_joins_and_merges = Post.joins(:author, :categorizations)
                                         .merge(Author.select(:id)).merge(categorizations_with_authors)
 
-      author_with_posts = Author.joins(:posts).ids
-      categorizations_with_author = Categorization.joins(:author).ids
-      posts_with_author_and_categorizations = Post.joins(:categorizations).where(author_id: author_with_posts, categorizations: { id: categorizations_with_author }).ids
+      author_with_posts = Author.joins(:posts).pluck(:id)
+      categorizations_with_author = Categorization.joins(:author).pluck(:id)
+      posts_with_author_and_categorizations = Post.joins(:categorizations).where(author_id: author_with_posts, categorizations: { id: categorizations_with_author }).pluck(:id)
 
       assert_equal posts_with_author_and_categorizations.size, posts_with_joins_and_merges.count
       assert_equal posts_with_author_and_categorizations.size, posts_with_joins_and_merges.to_a.size
@@ -291,9 +296,8 @@ module ActiveRecord
 
     def test_select_quotes_when_using_from_clause
       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
+      selected = Post.select(:join).from(Post.select("id as #{quote_table_name("join")}")).map(&:join)
+      assert_equal Post.pluck(:id).sort, selected.sort
     end
 
     def test_selecting_aliased_attribute_quotes_column_name_when_from_is_used
@@ -331,31 +335,47 @@ module ActiveRecord
 
     def test_relation_with_annotation_includes_comment_in_sql
       post_with_annotation = Post.where(id: 1).annotate("foo")
-      assert_sql(%r{/\* foo \*/}) do
+      assert_queries_match(%r{/\* foo \*/}) do
         assert post_with_annotation.first, "record should be found"
       end
     end
 
     def test_relation_with_annotation_chains_sql_comments
       post_with_annotation = Post.where(id: 1).annotate("foo").annotate("bar")
-      assert_sql(%r{/\* foo \*/ /\* bar \*/}) do
+      assert_queries_match(%r{/\* foo \*/ /\* bar \*/}) do
         assert post_with_annotation.first, "record should be found"
       end
     end
 
     def test_relation_with_annotation_filters_sql_comment_delimiters
       post_with_annotation = Post.where(id: 1).annotate("**//foo//**")
-      assert_match %r{= 1 /\* foo \*/}, post_with_annotation.to_sql
+      assert_includes post_with_annotation.to_sql, "= 1 /* ** //foo// ** */"
     end
 
     def test_relation_with_annotation_includes_comment_in_count_query
       post_with_annotation = Post.annotate("foo")
       all_count = Post.all.to_a.count
-      assert_sql(%r{/\* foo \*/}) do
+      assert_queries_match(%r{/\* foo \*/}) do
         assert_equal all_count, post_with_annotation.count
       end
     end
 
+    def test_relation_with_annotation_includes_comment_in_update_all_query
+      post_with_annotation = Post.annotate("foo")
+      all_count = Post.all.to_a.count
+      assert_queries_match(%r{/\* foo \*/}) do
+        assert_equal all_count, post_with_annotation.update_all(title: "Same title")
+      end
+    end
+
+    def test_relation_with_annotation_includes_comment_in_delete_all_query
+      post_with_annotation = Post.annotate("foo")
+      all_count = Post.all.to_a.count
+      assert_queries_match(%r{/\* foo \*/}) do
+        assert_equal all_count, post_with_annotation.delete_all
+      end
+    end
+
     def test_relation_without_annotation_does_not_include_an_empty_comment
       log = capture_sql do
         Post.where(id: 1).first
@@ -367,22 +387,15 @@ module ActiveRecord
 
     def test_relation_with_optimizer_hints_filters_sql_comment_delimiters
       post_with_hint = Post.where(id: 1).optimizer_hints("**//BADHINT//**")
-      assert_match %r{BADHINT}, post_with_hint.to_sql
-      assert_no_match %r{\*/BADHINT}, post_with_hint.to_sql
-      assert_no_match %r{\*//BADHINT}, post_with_hint.to_sql
-      assert_no_match %r{BADHINT/\*}, post_with_hint.to_sql
-      assert_no_match %r{BADHINT//\*}, post_with_hint.to_sql
+      assert_includes post_with_hint.to_sql, "/*+ ** //BADHINT// ** */"
       post_with_hint = Post.where(id: 1).optimizer_hints("/*+ BADHINT */")
-      assert_match %r{/\*\+ BADHINT \*/}, post_with_hint.to_sql
+      assert_includes post_with_hint.to_sql, "/*+ BADHINT */"
     end
 
     def test_does_not_duplicate_optimizer_hints_on_merge
-      puts "test_does_not_duplicate_optimizer_hints_on_merge"
-      escaped_table = Post.connection.quote_table_name("posts")
+      escaped_table = quote_table_name("posts")
       expected = "SELECT /*+ OMGHINT */ #{escaped_table}.* FROM #{escaped_table}"
       query = Post.optimizer_hints("OMGHINT").merge(Post.optimizer_hints("OMGHINT")).to_sql
-      puts "Expected = #{expected}"
-      puts "Query = #{query}"
       assert_equal expected, query
     end
 
@@ -427,34 +440,26 @@ module ActiveRecord
       end
     end
 
-    def test_marshal_load_legacy_relation
-      path = File.expand_path(
-        "support/marshal_compatibility_fixtures/legacy_relation.dump",
-        TEST_ROOT
-      )
-      assert_equal 11, Marshal.load(File.read(path)).size
-    end
-
     test "no queries on empty IN" do
-      assert_queries(0) do
+      assert_queries_count(0) do
         Post.where(id: []).load
       end
     end
 
     test "can unscope empty IN" do
-      assert_queries(1) do
+      assert_queries_count(1) do
         Post.where(id: []).unscope(where: :id).load
       end
     end
 
     test "no queries on empty relation exists?" do
-      assert_queries(0) do
+      assert_queries_count(0) do
         Post.where(id: []).exists?(123)
       end
     end
 
     test "no queries on empty condition exists?" do
-      assert_queries(0) do
+      assert_queries_count(0) do
         Post.all.exists?(id: [])
       end
     end
@@ -472,7 +477,7 @@ module ActiveRecord
 
       def sqlite3_version_includes_quoting_bug?
         if current_adapter?(:SQLite3Adapter)
-          selected_quoted_column_names = ActiveRecord::Base.connection.exec_query(
+          selected_quoted_column_names = ActiveRecord::Base.lease_connection.exec_query(
             'SELECT "join" FROM (SELECT id AS "join" FROM posts) subquery'
           ).columns
           ["join"] != selected_quoted_column_names