ibm_db 3.0.5 → 4.0.0

data/test/cases/relation/or_test.rb

@@ -0,0 +1,92 @@
+require "cases/helper"
+require 'models/post'
+
+module ActiveRecord
+  class OrTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    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
+    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
+    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
+    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
+    end
+
+    def test_or_with_bind_params
+      assert_equal Post.find([1, 2]), Post.where(id: 1).or(Post.where(id: 2)).to_a
+    end
+
+    def test_or_with_null_both
+      expected = Post.none.to_a
+      assert_equal expected, Post.none.or(Post.none).to_a
+    end
+
+    def test_or_without_left_where
+      expected = Post.all
+      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
+    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
+    end
+
+    def test_or_with_incompatible_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_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] }
+    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)
+    end
+
+    def test_or_inside_named_scope
+      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_on_loaded_relation
+      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
+    end
+
+    def test_or_with_non_relation_object_raises_error
+      assert_raises ArgumentError do
+        Post.where(id: [1, 2, 3]).or(title: 'Rails')
+      end
+    end
+  end
+end

data/test/cases/relation/predicate_builder_test.rb

@@ -1,14 +1,16 @@
-require "cases/helper"
-require 'models/topic'
-
-module ActiveRecord
-  class PredicateBuilderTest < ActiveRecord::TestCase
-    def test_registering_new_handlers
-      PredicateBuilder.register_handler(Regexp, proc do |column, value|
-        Arel::Nodes::InfixOperation.new('~', column, Arel.sql(value.source))
-      end)
-
-      assert_match %r{["`]topics["`].["`]title["`] ~ rails}i, Topic.where(title: /rails/).to_sql
-    end
-  end
-end
+require "cases/helper"
+require 'models/topic'
+
+module ActiveRecord
+  class PredicateBuilderTest < ActiveRecord::TestCase
+    def test_registering_new_handlers
+      Topic.predicate_builder.register_handler(Regexp, proc do |column, value|
+        Arel::Nodes::InfixOperation.new('~', column, Arel.sql(value.source))
+      end)
+
+      assert_match %r{["`]topics["`]\.["`]title["`] ~ rails}i, Topic.where(title: /rails/).to_sql
+    ensure
+      Topic.reset_column_information
+    end
+  end
+end

data/test/cases/relation/record_fetch_warning_test.rb

@@ -0,0 +1,40 @@
+require 'cases/helper'
+require 'models/post'
+require 'active_record/relation/record_fetch_warning'
+
+module ActiveRecord
+  class RecordFetchWarningTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    def setup
+      @original_logger = ActiveRecord::Base.logger
+      @original_warn_on_records_fetched_greater_than = ActiveRecord::Base.warn_on_records_fetched_greater_than
+      @log = StringIO.new
+    end
+
+    def teardown
+      ActiveRecord::Base.logger = @original_logger
+      ActiveRecord::Base.warn_on_records_fetched_greater_than = @original_warn_on_records_fetched_greater_than
+    end
+
+    def test_warn_on_records_fetched_greater_than_allowed_limit
+      ActiveRecord::Base.logger = ActiveSupport::Logger.new(@log)
+      ActiveRecord::Base.logger.level = Logger::WARN
+      ActiveRecord::Base.warn_on_records_fetched_greater_than = 1
+
+      Post.all.to_a
+
+      assert_match(/Query fetched/, @log.string)
+    end
+
+    def test_does_not_warn_on_records_fetched_less_than_allowed_limit
+      ActiveRecord::Base.logger = ActiveSupport::Logger.new(@log)
+      ActiveRecord::Base.logger.level = Logger::WARN
+      ActiveRecord::Base.warn_on_records_fetched_greater_than = 100
+
+      Post.all.to_a
+
+      assert_no_match(/Query fetched/, @log.string)
+    end
+  end
+end

data/test/cases/relation/where_chain_test.rb

@@ -1,181 +1,105 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/comment'
-
-module ActiveRecord
-  class WhereChainTest < ActiveRecord::TestCase
-    fixtures :posts
-
-    def setup
-      super
-      @name = 'title'
-    end
-
-    def test_not_eq
-      relation = Post.where.not(title: 'hello')
-
-      assert_equal 1, relation.where_values.length
-
-      value = relation.where_values.first
-      bind  = relation.bind_values.first
-
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
-      assert_equal 'hello', bind.last
-    end
-
-    def test_not_null
-      expected = Post.arel_table[@name].not_eq(nil)
-      relation = Post.where.not(title: nil)
-      assert_equal([expected], relation.where_values)
-    end
-
-    def test_not_with_nil
-      assert_raise ArgumentError do
-        Post.where.not(nil)
-      end
-    end
-
-    def test_not_in
-      expected = Post.arel_table[@name].not_in(%w[hello goodbye])
-      relation = Post.where.not(title: %w[hello goodbye])
-      assert_equal([expected], relation.where_values)
-    end
-
-    def test_association_not_eq
-      expected = Comment.arel_table[@name].not_eq('hello')
-      relation = Post.joins(:comments).where.not(comments: {title: 'hello'})
-      assert_equal(expected.to_sql, relation.where_values.first.to_sql)
-    end
-
-    def test_not_eq_with_preceding_where
-      relation = Post.where(title: 'hello').where.not(title: 'world')
-
-      value = relation.where_values.first
-      bind  = relation.bind_values.first
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
-      assert_equal 'hello', bind.last
-
-      value = relation.where_values.last
-      bind  = relation.bind_values.last
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
-      assert_equal 'world', bind.last
-    end
-
-    def test_not_eq_with_succeeding_where
-      relation = Post.where.not(title: 'hello').where(title: 'world')
-
-      value = relation.where_values.first
-      bind  = relation.bind_values.first
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
-      assert_equal 'hello', bind.last
-
-      value = relation.where_values.last
-      bind  = relation.bind_values.last
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
-      assert_equal 'world', bind.last
-    end
-
-    def test_not_eq_with_string_parameter
-      expected = Arel::Nodes::Not.new("title = 'hello'")
-      relation = Post.where.not("title = 'hello'")
-      assert_equal([expected], relation.where_values)
-    end
-
-    def test_not_eq_with_array_parameter
-      expected = Arel::Nodes::Not.new("title = 'hello'")
-      relation = Post.where.not(['title = ?', 'hello'])
-      assert_equal([expected], relation.where_values)
-    end
-
-    def test_chaining_multiple
-      relation = Post.where.not(author_id: [1, 2]).where.not(title: 'ruby on rails')
-
-      expected = Post.arel_table['author_id'].not_in([1, 2])
-      assert_equal(expected, relation.where_values[0])
-
-      value = relation.where_values[1]
-      bind  = relation.bind_values.first
-
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
-      assert_equal 'ruby on rails', bind.last
-    end
-
-    def test_rewhere_with_one_condition
-      relation = Post.where(title: 'hello').where(title: 'world').rewhere(title: 'alone')
-
-      assert_equal 1, relation.where_values.size
-      value = relation.where_values.first
-      bind = relation.bind_values.first
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
-      assert_equal 'alone', bind.last
-    end
-
-    def test_rewhere_with_multiple_overwriting_conditions
-      relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone', body: 'again')
-
-      assert_equal 2, relation.where_values.size
-
-      value = relation.where_values.first
-      bind = relation.bind_values.first
-      assert_bound_ast value, Post.arel_table['title'], Arel::Nodes::Equality
-      assert_equal 'alone', bind.last
-
-      value = relation.where_values[1]
-      bind = relation.bind_values[1]
-      assert_bound_ast value, Post.arel_table['body'], Arel::Nodes::Equality
-      assert_equal 'again', bind.last
-    end
-
-    def assert_bound_ast value, table, type
-      assert_equal table, value.left
-      assert_kind_of type, value
-      assert_kind_of Arel::Nodes::BindParam, value.right
-    end
-
-    def test_rewhere_with_one_overwriting_condition_and_one_unrelated
-      relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone')
-
-      assert_equal 2, relation.where_values.size
-
-      value = relation.where_values.first
-      bind  = relation.bind_values.first
-
-      assert_bound_ast value, Post.arel_table['body'], Arel::Nodes::Equality
-      assert_equal 'world', bind.last
-
-      value = relation.where_values.second
-      bind  = relation.bind_values.second
-
-      assert_bound_ast value, Post.arel_table['title'], Arel::Nodes::Equality
-      assert_equal 'alone', bind.last
-    end
-
-    def test_rewhere_with_range
-      relation = Post.where(comments_count: 1..3).rewhere(comments_count: 3..5)
-
-      assert_equal 1, relation.where_values.size
-      assert_equal Post.where(comments_count: 3..5), relation
-    end
-
-    def test_rewhere_with_infinite_upper_bound_range
-      relation = Post.where(comments_count: 1..Float::INFINITY).rewhere(comments_count: 3..5)
-
-      assert_equal 1, relation.where_values.size
-      assert_equal Post.where(comments_count: 3..5), relation
-    end
-
-    def test_rewhere_with_infinite_lower_bound_range
-      relation = Post.where(comments_count: -Float::INFINITY..1).rewhere(comments_count: 3..5)
-
-      assert_equal 1, relation.where_values.size
-      assert_equal Post.where(comments_count: 3..5), relation
-    end
-
-    def test_rewhere_with_infinite_range
-      relation = Post.where(comments_count: -Float::INFINITY..Float::INFINITY).rewhere(comments_count: 3..5)
-
-      assert_equal 1, relation.where_values.size
-      assert_equal Post.where(comments_count: 3..5), relation
-    end
-  end
-end
+require 'cases/helper'
+require 'models/post'
+require 'models/comment'
+
+module ActiveRecord
+  class WhereChainTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    def setup
+      super
+      @name = 'title'
+    end
+
+    def test_not_inverts_where_clause
+      relation = Post.where.not(title: 'hello')
+      expected_where_clause = Post.where(title: 'hello').where_clause.invert
+
+      assert_equal expected_where_clause, relation.where_clause
+    end
+
+    def test_not_with_nil
+      assert_raise ArgumentError do
+        Post.where.not(nil)
+      end
+    end
+
+    def test_association_not_eq
+      expected = Arel::Nodes::Grouping.new(Comment.arel_table[@name].not_eq(Arel::Nodes::BindParam.new))
+      relation = Post.joins(:comments).where.not(comments: {title: 'hello'})
+      assert_equal(expected.to_sql, relation.where_clause.ast.to_sql)
+    end
+
+    def test_not_eq_with_preceding_where
+      relation = Post.where(title: 'hello').where.not(title: 'world')
+      expected_where_clause =
+        Post.where(title: 'hello').where_clause +
+        Post.where(title: 'world').where_clause.invert
+
+      assert_equal expected_where_clause, relation.where_clause
+    end
+
+    def test_not_eq_with_succeeding_where
+      relation = Post.where.not(title: 'hello').where(title: 'world')
+      expected_where_clause =
+        Post.where(title: 'hello').where_clause.invert +
+        Post.where(title: 'world').where_clause
+
+      assert_equal expected_where_clause, relation.where_clause
+    end
+
+    def test_chaining_multiple
+      relation = Post.where.not(author_id: [1, 2]).where.not(title: 'ruby on rails')
+      expected_where_clause =
+        Post.where(author_id: [1, 2]).where_clause.invert +
+        Post.where(title: 'ruby on rails').where_clause.invert
+
+      assert_equal expected_where_clause, relation.where_clause
+    end
+
+    def test_rewhere_with_one_condition
+      relation = Post.where(title: 'hello').where(title: 'world').rewhere(title: 'alone')
+      expected = Post.where(title: 'alone')
+
+      assert_equal expected.where_clause, relation.where_clause
+    end
+
+    def test_rewhere_with_multiple_overwriting_conditions
+      relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone', body: 'again')
+      expected = Post.where(title: 'alone', body: 'again')
+
+      assert_equal expected.where_clause, relation.where_clause
+    end
+
+    def test_rewhere_with_one_overwriting_condition_and_one_unrelated
+      relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone')
+      expected = Post.where(body: 'world', title: 'alone')
+
+      assert_equal expected.where_clause, relation.where_clause
+    end
+
+    def test_rewhere_with_range
+      relation = Post.where(comments_count: 1..3).rewhere(comments_count: 3..5)
+
+      assert_equal Post.where(comments_count: 3..5), relation
+    end
+
+    def test_rewhere_with_infinite_upper_bound_range
+      relation = Post.where(comments_count: 1..Float::INFINITY).rewhere(comments_count: 3..5)
+
+      assert_equal Post.where(comments_count: 3..5), relation
+    end
+
+    def test_rewhere_with_infinite_lower_bound_range
+      relation = Post.where(comments_count: -Float::INFINITY..1).rewhere(comments_count: 3..5)
+
+      assert_equal Post.where(comments_count: 3..5), relation
+    end
+
+    def test_rewhere_with_infinite_range
+      relation = Post.where(comments_count: -Float::INFINITY..Float::INFINITY).rewhere(comments_count: 3..5)
+
+      assert_equal Post.where(comments_count: 3..5), relation
+    end
+  end
+end