ibm_db 5.2.0-x86-mingw32 → 5.4.0-x86-mingw32

data/test/cases/relation/mutation_test.rb

@@ -1,42 +1,11 @@
-require 'cases/helper'
-require 'models/post'
+# frozen_string_literal: true
 
-module ActiveRecord
-  class RelationMutationTest < ActiveSupport::TestCase
-    class FakeKlass < Struct.new(:table_name, :name)
-      extend ActiveRecord::Delegation::DelegateCache
-      inherited self
-
-      def connection
-        Post.connection
-      end
-
-      def relation_delegate_class(klass)
-        self.class.relation_delegate_class(klass)
-      end
-
-      def attribute_alias?(name)
-        false
-      end
-
-      def sanitize_sql(sql)
-        sql
-      end
-
-      def sanitize_sql_for_order(sql)
-        sql
-      end
-
-      def arel_attribute(name, table)
-        table[name]
-      end
-    end
+require "cases/helper"
+require "models/post"
 
-    def relation
-      @relation ||= Relation.new FakeKlass.new('posts'), Post.arel_table, Post.predicate_builder
-    end
-
-    (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select, :left_joins]).each do |method|
+module ActiveRecord
+  class RelationMutationTest < ActiveRecord::TestCase
+    (Relation::MULTI_VALUE_METHODS - [:extending, :order, :unscope, :select]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal [:foo], relation.public_send("#{method}_values")
@@ -44,24 +13,24 @@ module ActiveRecord
     end
 
     test "#_select!" do
-      assert relation.public_send("_select!", :foo).equal?(relation)
-      assert_equal [:foo], relation.public_send("select_values")
+      assert relation._select!(:foo).equal?(relation)
+      assert_equal [:foo], relation.select_values
     end
 
-    test '#order!' do
-      assert relation.order!('name ASC').equal?(relation)
-      assert_equal ['name ASC'], relation.order_values
+    test "#order!" do
+      assert relation.order!("name ASC").equal?(relation)
+      assert_equal ["name ASC"], relation.order_values
     end
 
-    test '#order! with symbol prepends the table name' do
+    test "#order! with symbol prepends the table name" do
       assert relation.order!(:name).equal?(relation)
       node = relation.order_values.first
-      assert node.ascending?
-      assert_equal :name, node.expr.name
+      assert_predicate node, :ascending?
+      assert_equal "name", node.expr.name
       assert_equal "posts", node.expr.relation.name
     end
 
-    test '#order! on non-string does not attempt regexp match for references' do
+    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)
@@ -69,12 +38,7 @@ module ActiveRecord
       end
     end
 
-    test '#references!' do
-      assert relation.references!(:foo).equal?(relation)
-      assert relation.references_values.include?('foo')
-    end
-
-    test 'extending!' do
+    test "extending!" do
       mod, mod2 = Module.new, Module.new
 
       assert relation.extending!(mod).equal?(relation)
@@ -85,99 +49,97 @@ module ActiveRecord
       assert_equal [mod, mod2], relation.extending_values
     end
 
-    test 'extending! with empty args' do
+    test "extending! with empty args" do
       relation.extending!
       assert_equal [], relation.extending_values
     end
 
-    (Relation::SINGLE_VALUE_METHODS - [:lock, :reordering, :reverse_order, :create_with, :uniq]).each do |method|
+    (Relation::SINGLE_VALUE_METHODS - [:lock, :reordering, :reverse_order, :create_with, :skip_query_cache, :strict_loading]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal :foo, relation.public_send("#{method}_value")
       end
     end
 
-    test '#from!' do
-      assert relation.from!('foo').equal?(relation)
-      assert_equal 'foo', relation.from_clause.value
+    test "#from!" do
+      assert relation.from!("foo").equal?(relation)
+      assert_equal "foo", relation.from_clause.value
     end
 
-    test '#lock!' do
-      assert relation.lock!('foo').equal?(relation)
-      assert_equal 'foo', relation.lock_value
+    test "#lock!" do
+      assert relation.lock!("foo").equal?(relation)
+      assert_equal "foo", relation.lock_value
     end
 
-    test '#reorder!' do
-      @relation = self.relation.order('foo')
+    test "#reorder!" do
+      @relation = relation.order("foo")
 
-      assert relation.reorder!('bar').equal?(relation)
-      assert_equal ['bar'], relation.order_values
+      assert relation.reorder!("bar").equal?(relation)
+      assert_equal ["bar"], relation.order_values
       assert relation.reordering_value
     end
 
-    test '#reorder! with symbol prepends the table name' do
+    test "#reorder! with symbol prepends the table name" do
       assert relation.reorder!(:name).equal?(relation)
       node = relation.order_values.first
 
-      assert node.ascending?
-      assert_equal :name, node.expr.name
+      assert_predicate node, :ascending?
+      assert_equal "name", node.expr.name
       assert_equal "posts", node.expr.relation.name
     end
 
-    test 'reverse_order!' do
-      @relation = Post.order('title ASC, comments_count DESC')
+    test "reverse_order!" do
+      @relation = Post.order("title ASC, comments_count DESC")
 
       relation.reverse_order!
 
-      assert_equal 'title DESC', relation.order_values.first
-      assert_equal 'comments_count ASC', relation.order_values.last
-
+      assert_equal "title DESC", relation.order_values.first
+      assert_equal "comments_count ASC", relation.order_values.last
 
       relation.reverse_order!
 
-      assert_equal 'title ASC', relation.order_values.first
-      assert_equal 'comments_count DESC', relation.order_values.last
+      assert_equal "title ASC", relation.order_values.first
+      assert_equal "comments_count DESC", relation.order_values.last
     end
 
-    test 'create_with!' do
-      assert relation.create_with!(foo: 'bar').equal?(relation)
-      assert_equal({foo: 'bar'}, relation.create_with_value)
+    test "create_with!" do
+      assert relation.create_with!(foo: "bar").equal?(relation)
+      assert_equal({ foo: "bar" }, relation.create_with_value)
     end
 
-    test 'test_merge!' do
+    test "merge!" do
       assert relation.merge!(select: :foo).equal?(relation)
       assert_equal [:foo], relation.select_values
     end
 
-    test 'merge with a proc' do
+    test "merge with a proc" do
       assert_equal [:foo], relation.merge(-> { select(:foo) }).select_values
     end
 
-    test 'none!' do
+    test "none!" do
       assert relation.none!.equal?(relation)
       assert_equal [NullRelation], relation.extending_values
       assert relation.is_a?(NullRelation)
     end
 
-    test 'distinct!' do
+    test "distinct!" do
       relation.distinct! :foo
       assert_equal :foo, relation.distinct_value
+    end
 
-      assert_deprecated do
-        assert_equal :foo, relation.uniq_value # deprecated access
-      end
+    test "skip_query_cache!" do
+      relation.skip_query_cache!
+      assert relation.skip_query_cache_value
     end
 
-    test 'uniq! was replaced by distinct!' do
-      assert_deprecated(/use distinct! instead/) do
-        relation.uniq! :foo
-      end
+    test "skip_preloading!" do
+      relation.skip_preloading!
+      assert relation.skip_preloading_value
+    end
 
-      assert_deprecated(/use distinct_value instead/) do
-        assert_equal :foo, relation.uniq_value # deprecated access
+    private
+      def relation
+        @relation ||= Relation.new(FakeKlass)
       end
-
-      assert_equal :foo, relation.distinct_value
-    end
   end
 end

data/test/cases/relation/or_test.rb

@@ -1,32 +1,42 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/post'
+require "models/author"
+require "models/categorization"
+require "models/post"
+require "models/citation"
 
 module ActiveRecord
   class OrTest < ActiveRecord::TestCase
-    fixtures :posts
+    fixtures :posts, :authors, :author_addresses
 
     def test_or_with_relation
-      expected = Post.where('id = 1 or id = 2').to_a
-      assert_equal expected, Post.where('id = 1').or(Post.where('id = 2')).to_a
+      expected = Post.where("id = 1 or id = 2").to_a
+      assert_equal expected, Post.where("id = 1").or(Post.where("id = 2")).to_a
     end
 
     def test_or_identity
-      expected = Post.where('id = 1').to_a
-      assert_equal expected, Post.where('id = 1').or(Post.where('id = 1')).to_a
+      expected = Post.where("id = 1").to_a
+      assert_equal expected, Post.where("id = 1").or(Post.where("id = 1")).to_a
     end
 
     def test_or_with_null_left
-      expected = Post.where('id = 1').to_a
-      assert_equal expected, Post.none.or(Post.where('id = 1')).to_a
+      expected = Post.where("id = 1").to_a
+      assert_equal expected, Post.none.or(Post.where("id = 1")).to_a
     end
 
     def test_or_with_null_right
-      expected = Post.where('id = 1').to_a
-      assert_equal expected, Post.where('id = 1').or(Post.none).to_a
+      expected = Post.where("id = 1").to_a
+      assert_equal expected, Post.where("id = 1").or(Post.none).to_a
+    end
+
+    def test_or_with_large_number
+      expected = Post.where("id = 1 or id = 9223372036854775808").to_a
+      assert_equal expected, Post.where(id: 1).or(Post.where(id: 9223372036854775808)).to_a
     end
 
     def test_or_with_bind_params
-      assert_equal Post.find([1, 2]), Post.where(id: 1).or(Post.where(id: 2)).to_a
+      assert_equal Post.find([1, 2]).sort_by(&:id), Post.where(id: 1).or(Post.where(id: 2)).sort_by(&:id)
     end
 
     def test_or_with_null_both
@@ -36,56 +46,146 @@ module ActiveRecord
 
     def test_or_without_left_where
       expected = Post.all
-      assert_equal expected, Post.or(Post.where('id = 1')).to_a
+      assert_equal expected, Post.or(Post.where("id = 1")).to_a
     end
 
     def test_or_without_right_where
       expected = Post.all
-      assert_equal expected, Post.where('id = 1').or(Post.all).to_a
+      assert_equal expected, Post.where("id = 1").or(Post.all).to_a
     end
 
     def test_or_preserves_other_querying_methods
-      expected = Post.where('id = 1 or id = 2 or id = 3').order('body asc').to_a
-      partial = Post.order('body asc')
-      assert_equal expected, partial.where('id = 1').or(partial.where(:id => [2, 3])).to_a
-      assert_equal expected, Post.order('body asc').where('id = 1').or(Post.order('body asc').where(:id => [2, 3])).to_a
+      expected = Post.where("id = 1 or id = 2 or id = 3").order("body asc").to_a
+      partial = Post.order("body asc")
+      assert_equal expected, partial.where("id = 1").or(partial.where(id: [2, 3])).to_a
+      assert_equal expected, Post.order("body asc").where("id = 1").or(Post.order("body asc").where(id: [2, 3])).to_a
+    end
+
+    def test_or_with_incompatible_single_value_relations
+      error = assert_raises ArgumentError do
+        Post.distinct.where("id = 1").or(Post.where(id: [2, 3])).to_a
+      end
+
+      assert_equal "Relation passed to #or must be structurally compatible. Incompatible values: [:distinct]", error.message
+    end
+
+    def test_or_with_incompatible_multi_value_relations
+      error = assert_raises ArgumentError do
+        Post.order("body asc").where("id = 1").or(Post.order("id desc").where(id: [2, 3])).to_a
+      end
+
+      assert_equal "Relation passed to #or must be structurally compatible. Incompatible values: [:order]", error.message
+    end
+
+    def test_or_with_unscope_where
+      expected = Post.where("id = 1 or id = 2")
+      partial = Post.where("id = 1 and id != 2")
+      assert_equal expected, partial.or(partial.unscope(:where).where("id = 2")).to_a
+    end
+
+    def test_or_with_unscope_where_column
+      expected = Post.where("id = 1 or id = 2")
+      partial = Post.where(id: 1).where.not(id: 2)
+      assert_equal expected, partial.or(partial.unscope(where: :id).where("id = 2")).to_a
+    end
+
+    def test_or_with_unscope_order
+      expected = Post.where("id = 1 or id = 2").sort_by(&:id)
+      assert_equal expected, Post.order("body asc").where("id = 1").unscope(:order).or(Post.where("id = 2")).sort_by(&:id)
+      assert_equal expected, Post.order(:id).where("id = 1").or(Post.order(:id).where("id = 2").unscope(:order)).sort_by(&:id)
     end
 
-    def test_or_with_incompatible_relations
+    def test_or_with_incompatible_unscope
       error = assert_raises ArgumentError do
-        Post.order('body asc').where('id = 1').or(Post.order('id desc').where(:id => [2, 3])).to_a
+        Post.order("body asc").where("id = 1").unscope(:order).or(Post.order("body asc").where("id = 2")).to_a
       end
 
       assert_equal "Relation passed to #or must be structurally compatible. Incompatible values: [:order]", error.message
     end
 
     def test_or_when_grouping
-      groups = Post.where('id < 10').group('body').select('body, COUNT(*) AS c')
-      expected = groups.having("COUNT(*) > 1 OR body like 'Such%'").to_a.map {|o| [o.body, o.c] }
-      assert_equal expected, groups.having('COUNT(*) > 1').or(groups.having("body like 'Such%'")).to_a.map {|o| [o.body, o.c] }
+      groups = Post.where("id < 10").group("body")
+      expected = groups.having("COUNT(*) > 1 OR body like 'Such%'").count
+      assert_equal expected, groups.having("COUNT(*) > 1").or(groups.having("body like 'Such%'")).count
     end
 
     def test_or_with_named_scope
       expected = Post.where("id = 1 or body LIKE '\%a\%'").to_a
-      assert_equal expected, Post.where('id = 1').or(Post.containing_the_letter_a)
+      assert_equal expected, Post.where("id = 1").or(Post.containing_the_letter_a)
     end
 
     def test_or_inside_named_scope
-      expected = Post.where("body LIKE '\%a\%' OR title LIKE ?", "%'%").order('id DESC').to_a
+      expected = Post.where("body LIKE '\%a\%' OR title LIKE ?", "%'%").order("id DESC").to_a
       assert_equal expected, Post.order(id: :desc).typographically_interesting
     end
 
+    def test_or_with_sti_relation
+      expected = Post.where("id = 1 or id = 2").sort_by(&:id)
+      assert_equal expected, Post.where(id: 1).or(SpecialPost.all).sort_by(&:id)
+    end
+
     def test_or_on_loaded_relation
-      expected = Post.where('id = 1 or id = 2').to_a
-      p = Post.where('id = 1')
+      expected = Post.where("id = 1 or id = 2").to_a
+      p = Post.where("id = 1")
       p.load
-      assert_equal p.loaded?, true
-      assert_equal expected, p.or(Post.where('id = 2')).to_a
+      assert_equal true, p.loaded?
+      assert_equal expected, p.or(Post.where("id = 2")).to_a
     end
 
     def test_or_with_non_relation_object_raises_error
       assert_raises ArgumentError do
-        Post.where(id: [1, 2, 3]).or(title: 'Rails')
+        Post.where(id: [1, 2, 3]).or(title: "Rails")
+      end
+    end
+
+    def test_or_with_references_inequality
+      joined = Post.includes(:author)
+      actual = joined.where(authors: { id: 1 })
+        .or(joined.where(title: "I don't have any comments"))
+      expected = Author.find(1).posts + Post.where(title: "I don't have any comments")
+      assert_equal expected.sort_by(&:id), actual.sort_by(&:id)
+    end
+
+    def test_or_with_scope_on_association
+      author = Author.first
+      assert_nothing_raised do
+        author.top_posts.or(author.other_top_posts)
+      end
+    end
+
+    def test_or_with_annotate
+      quoted_posts = Regexp.escape(Post.quoted_table_name)
+      assert_match %r{#{quoted_posts} /\* foo \*/\z}, Post.annotate("foo").or(Post.all).to_sql
+      assert_match %r{#{quoted_posts} /\* foo \*/\z}, Post.annotate("foo").or(Post.annotate("foo")).to_sql
+      assert_match %r{#{quoted_posts} /\* foo \*/\z}, Post.annotate("foo").or(Post.annotate("bar")).to_sql
+      assert_match %r{#{quoted_posts} /\* foo \*/ /\* bar \*/\z}, Post.annotate("foo", "bar").or(Post.annotate("foo")).to_sql
+    end
+
+    def test_structurally_incompatible_values
+      assert_nothing_raised do
+        Post.includes(:author).includes(:author).or(Post.includes(:author))
+        Post.eager_load(:author).eager_load(:author).or(Post.eager_load(:author))
+        Post.preload(:author).preload(:author).or(Post.preload(:author))
+        Post.group(:author_id).group(:author_id).or(Post.group(:author_id))
+        Post.joins(:author).joins(:author).or(Post.joins(:author))
+        Post.left_outer_joins(:author).left_outer_joins(:author).or(Post.left_outer_joins(:author))
+        Post.from("posts").or(Post.from("posts"))
+      end
+    end
+  end
+
+  # 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
+
+      def test_too_many_or
+        citations = 6000.times.map do |i|
+          Citation.where(id: i, book2_id: i * i)
+        end
+
+        assert_equal 6000, citations.inject(&:or).count
       end
     end
   end

data/test/cases/relation/predicate_builder_test.rb

@@ -1,16 +1,31 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/topic'
+require "models/reply"
 
 module ActiveRecord
   class PredicateBuilderTest < ActiveRecord::TestCase
-    def test_registering_new_handlers
+    def setup
       Topic.predicate_builder.register_handler(Regexp, proc do |column, value|
-        Arel::Nodes::InfixOperation.new('~', column, Arel.sql(value.source))
+        Arel::Nodes::InfixOperation.new("~", column, Arel::Nodes.build_quoted(value.source))
       end)
+    end
 
-      assert_match %r{["`]topics["`]\.["`]title["`] ~ rails}i, Topic.where(title: /rails/).to_sql
-    ensure
-      Topic.reset_column_information
+    def teardown
+      Topic.class_eval { @predicate_builder = nil }
     end
+
+    def test_registering_new_handlers
+      assert_match %r{#{Regexp.escape(topic_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
+    end
+
+    private
+      def topic_title
+        Topic.connection.quote_table_name("topics.title")
+      end
   end
 end

data/test/cases/relation/record_fetch_warning_test.rb

@@ -1,6 +1,8 @@
-require 'cases/helper'
-require 'models/post'
-require 'active_record/relation/record_fetch_warning'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "active_record/relation/record_fetch_warning"
 
 module ActiveRecord
   class RecordFetchWarningTest < ActiveRecord::TestCase

data/test/cases/relation/select_test.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/comment"
+
+module ActiveRecord
+  class SelectTest < ActiveRecord::TestCase
+    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
+    end
+
+    def test_reselect
+      expected = Post.select(:title).to_sql
+      assert_equal expected, Post.select(:title, :body).reselect(:title).to_sql
+    end
+
+    def test_reselect_with_default_scope_select
+      expected = Post.select(:title).to_sql
+      actual   = PostWithDefaultSelect.reselect(:title).to_sql
+
+      assert_equal expected, actual
+    end
+
+    def test_non_select_columns_wont_be_loaded
+      posts = Post.select("UPPER(title) AS title")
+
+      assert_non_select_columns_wont_be_loaded(posts.first)
+      assert_non_select_columns_wont_be_loaded(posts.preload(:comments).first)
+      assert_non_select_columns_wont_be_loaded(posts.eager_load(:comments).first)
+    end
+
+    def assert_non_select_columns_wont_be_loaded(post)
+      assert_equal "WELCOME TO THE WEBLOG", post.title
+      assert_raise(ActiveModel::MissingAttributeError) do
+        post.body
+      end
+    end
+    private :assert_non_select_columns_wont_be_loaded
+
+    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
+    end
+
+    def test_aliased_select_using_as_with_joins_and_includes
+      posts = Post.select("posts.id AS field_alias").joins(:comments).includes(:comments)
+      assert_equal %w(id field_alias), posts.first.attributes.keys
+    end
+
+    def test_aliased_select_not_using_as_with_joins_and_includes
+      posts = Post.select("posts.id field_alias").joins(:comments).includes(:comments)
+      assert_equal %w(id field_alias), posts.first.attributes.keys
+    end
+
+    def test_star_select_with_joins_and_includes
+      posts = Post.select("posts.*").joins(:comments).includes(:comments)
+      assert_equal %w(
+        id author_id title body type legacy_comments_count taggings_with_delete_all_count taggings_with_destroy_count
+        tags_count indestructible_tags_count tags_with_destroy_count tags_with_nullify_count
+      ), posts.first.attributes.keys
+    end
+  end
+end