ibm_db 3.0.4 → 5.0.4

data/test/cases/relation/predicate_builder_test.rb

@@ -4,11 +4,13 @@ require 'models/topic'
 module ActiveRecord
   class PredicateBuilderTest < ActiveRecord::TestCase
     def test_registering_new_handlers
-      PredicateBuilder.register_handler(Regexp, proc do |column, value|
+      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
+      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

@@ -11,22 +11,11 @@ module ActiveRecord
       @name = 'title'
     end
 
-    def test_not_eq
+    def test_not_inverts_where_clause
       relation = Post.where.not(title: 'hello')
+      expected_where_clause = Post.where(title: 'hello').where_clause.invert
 
-      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)
+      assert_equal expected_where_clause, relation.where_clause
     end
 
     def test_not_with_nil
@@ -35,146 +24,81 @@ module ActiveRecord
       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')
+      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_values.first.to_sql)
+      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
 
-      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
+      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
 
-      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)
+      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
 
-      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
+      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 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
+      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 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
+      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 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
+      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 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

data/test/cases/relation/where_clause_test.rb

@@ -0,0 +1,182 @@
+require "cases/helper"
+
+class ActiveRecord::Relation
+  class WhereClauseTest < ActiveRecord::TestCase
+    test "+ combines two where clauses" do
+      first_clause = WhereClause.new([table["id"].eq(bind_param)], [["id", 1]])
+      second_clause = WhereClause.new([table["name"].eq(bind_param)], [["name", "Sean"]])
+      combined = WhereClause.new(
+        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
+        [["id", 1], ["name", "Sean"]],
+      )
+
+      assert_equal combined, first_clause + second_clause
+    end
+
+    test "+ is associative, but not commutative" do
+      a = WhereClause.new(["a"], ["bind a"])
+      b = WhereClause.new(["b"], ["bind b"])
+      c = WhereClause.new(["c"], ["bind c"])
+
+      assert_equal a + (b + c), (a + b) + c
+      assert_not_equal a + b, b + a
+    end
+
+    test "an empty where clause is the identity value for +" do
+      clause = WhereClause.new([table["id"].eq(bind_param)], [["id", 1]])
+
+      assert_equal clause, clause + WhereClause.empty
+    end
+
+    test "merge combines two where clauses" do
+      a = WhereClause.new([table["id"].eq(1)], [])
+      b = WhereClause.new([table["name"].eq("Sean")], [])
+      expected = WhereClause.new([table["id"].eq(1), table["name"].eq("Sean")], [])
+
+      assert_equal expected, a.merge(b)
+    end
+
+    test "merge keeps the right side, when two equality clauses reference the same column" do
+      a = WhereClause.new([table["id"].eq(1), table["name"].eq("Sean")], [])
+      b = WhereClause.new([table["name"].eq("Jim")], [])
+      expected = WhereClause.new([table["id"].eq(1), table["name"].eq("Jim")], [])
+
+      assert_equal expected, a.merge(b)
+    end
+
+    test "merge removes bind parameters matching overlapping equality clauses" do
+      a = WhereClause.new(
+        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
+        [attribute("id", 1), attribute("name", "Sean")],
+      )
+      b = WhereClause.new(
+        [table["name"].eq(bind_param)],
+        [attribute("name", "Jim")]
+      )
+      expected = WhereClause.new(
+        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
+        [attribute("id", 1), attribute("name", "Jim")],
+      )
+
+      assert_equal expected, a.merge(b)
+    end
+
+    test "merge allows for columns with the same name from different tables" do
+      skip "This is not possible as of 4.2, and the binds do not yet contain sufficient information for this to happen"
+      # We might be able to change the implementation to remove conflicts by index, rather than column name
+    end
+
+    test "a clause knows if it is empty" do
+      assert WhereClause.empty.empty?
+      assert_not WhereClause.new(["anything"], []).empty?
+    end
+
+    test "invert cannot handle nil" do
+      where_clause = WhereClause.new([nil], [])
+
+      assert_raises ArgumentError do
+        where_clause.invert
+      end
+    end
+
+    test "invert replaces each part of the predicate with its inverse" do
+      random_object = Object.new
+      original = WhereClause.new([
+        table["id"].in([1, 2, 3]),
+        table["id"].eq(1),
+        "sql literal",
+        random_object
+      ], [])
+      expected = WhereClause.new([
+        table["id"].not_in([1, 2, 3]),
+        table["id"].not_eq(1),
+        Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new("sql literal")),
+        Arel::Nodes::Not.new(random_object)
+      ], [])
+
+      assert_equal expected, original.invert
+    end
+
+    test "accept removes binary predicates referencing a given column" do
+      where_clause = WhereClause.new([
+        table["id"].in([1, 2, 3]),
+        table["name"].eq(bind_param),
+        table["age"].gteq(bind_param),
+      ], [
+        attribute("name", "Sean"),
+        attribute("age", 30),
+      ])
+      expected = WhereClause.new([table["age"].gteq(bind_param)], [attribute("age", 30)])
+
+      assert_equal expected, where_clause.except("id", "name")
+    end
+
+    test "ast groups its predicates with AND" do
+      predicates = [
+        table["id"].in([1, 2, 3]),
+        table["name"].eq(bind_param),
+      ]
+      where_clause = WhereClause.new(predicates, [])
+      expected = Arel::Nodes::And.new(predicates)
+
+      assert_equal expected, where_clause.ast
+    end
+
+    test "ast wraps any SQL literals in parenthesis" do
+      random_object = Object.new
+      where_clause = WhereClause.new([
+        table["id"].in([1, 2, 3]),
+        "foo = bar",
+        random_object,
+      ], [])
+      expected = Arel::Nodes::And.new([
+        table["id"].in([1, 2, 3]),
+        Arel::Nodes::Grouping.new(Arel.sql("foo = bar")),
+        Arel::Nodes::Grouping.new(random_object),
+      ])
+
+      assert_equal expected, where_clause.ast
+    end
+
+    test "ast removes any empty strings" do
+      where_clause = WhereClause.new([table["id"].in([1, 2, 3])], [])
+      where_clause_with_empty = WhereClause.new([table["id"].in([1, 2, 3]), ''], [])
+
+      assert_equal where_clause.ast, where_clause_with_empty.ast
+    end
+
+    test "or joins the two clauses using OR" do
+      where_clause = WhereClause.new([table["id"].eq(bind_param)], [attribute("id", 1)])
+      other_clause = WhereClause.new([table["name"].eq(bind_param)], [attribute("name", "Sean")])
+      expected_ast =
+        Arel::Nodes::Grouping.new(
+          Arel::Nodes::Or.new(table["id"].eq(bind_param), table["name"].eq(bind_param))
+        )
+      expected_binds = where_clause.binds + other_clause.binds
+
+      assert_equal expected_ast.to_sql, where_clause.or(other_clause).ast.to_sql
+      assert_equal expected_binds, where_clause.or(other_clause).binds
+    end
+
+    test "or returns an empty where clause when either side is empty" do
+      where_clause = WhereClause.new([table["id"].eq(bind_param)], [attribute("id", 1)])
+
+      assert_equal WhereClause.empty, where_clause.or(WhereClause.empty)
+      assert_equal WhereClause.empty, WhereClause.empty.or(where_clause)
+    end
+
+    private
+
+    def table
+      Arel::Table.new("table")
+    end
+
+    def bind_param
+      Arel::Nodes::BindParam.new
+    end
+
+    def attribute(name, value)
+      ActiveRecord::Attribute.with_cast_value(name, value, ActiveRecord::Type::Value.new)
+    end
+  end
+end

data/test/cases/relation/where_test.rb

@@ -2,7 +2,7 @@ require "cases/helper"
 require "models/author"
 require "models/binary"
 require "models/cake_designer"
-require "models/category"
+require "models/car"
 require "models/chef"
 require "models/comment"
 require "models/edge"
@@ -15,7 +15,7 @@ require "models/vertex"
 
 module ActiveRecord
   class WhereTest < ActiveRecord::TestCase
-    fixtures :posts, :edges, :authors, :binaries, :essays, :author_addresses
+    fixtures :posts, :edges, :authors, :binaries, :essays, :cars, :treasures, :price_estimates
 
     def test_where_copies_bind_params
       author = authors(:david)
@@ -30,6 +30,14 @@ module ActiveRecord
       }
     end
 
+    def test_where_copies_bind_params_in_the_right_order
+      author = authors(:david)
+      posts = author.posts.where.not(id: 1)
+      joined = Post.where(id: posts, title: posts.first.title)
+
+      assert_equal joined, [posts.first]
+    end
+
     def test_where_copies_arel_bind_params
       chef = Chef.create!
       CakeDesigner.create!(chef: chef)
@@ -107,16 +115,15 @@ module ActiveRecord
       assert_equal expected.to_sql, actual.to_sql
     end
 
-    def test_polymorphic_empty_array_where
-      treasure = Treasure.new
-      treasure.id = 1
-      hidden = HiddenTreasure.new
-      hidden.id = 2
+    def test_polymorphic_array_where_multiple_types
+      treasure_1 = treasures(:diamond)
+      treasure_2 = treasures(:sapphire)
+      car = cars(:honda)
 
-      expected = PriceEstimate.where("1=0")
-      actual   = PriceEstimate.where(estimate_of: [])
+      expected = [price_estimates(:diamond), price_estimates(:sapphire_1), price_estimates(:sapphire_2), price_estimates(:honda)].sort
+      actual   = PriceEstimate.where(estimate_of: [treasure_1, treasure_2, car]).to_a.sort
 
-      assert_equal expected.to_a, actual.to_a
+      assert_equal expected, actual
     end
 
     def test_polymorphic_nested_relation_where
@@ -207,12 +214,6 @@ module ActiveRecord
       assert_equal 0, Post.where(:id => []).count
     end
 
-    def test_where_with_table_name_and_nested_empty_array
-      assert_deprecated do
-        assert_equal [], Post.where(:id => [[]]).to_a
-      end
-    end
-
     def test_where_with_empty_hash_and_no_foreign_key
       assert_equal 0, Edge.where(:sink => {}).count
     end
@@ -233,12 +234,10 @@ module ActiveRecord
       assert_equal 0, count
     end
 
-  unless current_adapter?(:IBM_DBAdapter)
     def test_where_with_boolean_for_string_column
       count = Post.where(:title => false).count
       assert_equal 0, count
     end
-  end
 
     def test_where_with_decimal_for_string_column
       count = Post.where(:title => BigDecimal.new(0)).count
@@ -249,12 +248,11 @@ module ActiveRecord
       count = Post.where(:title => 0.seconds).count
       assert_equal 0, count
     end
-  unless current_adapter?(:IBM_DBAdapter)
+
     def test_where_with_integer_for_binary_column
       count = Binary.where(:data => 0).count
       assert_equal 0, count
     end
-  end
 
     def test_where_on_association_with_custom_primary_key
       author = authors(:david)
@@ -291,10 +289,34 @@ module ActiveRecord
       assert_equal essays(:david_modest_proposal), essay
     end
 
-    def test_where_on_non_polymorphic_association_with_custom_primary_key
-      essay = Essay.where(category: [Category.new(name: "General")]).first
+    def test_where_with_strong_parameters
+      protected_params = Class.new do
+        attr_reader :permitted
+        alias :permitted? :permitted
 
-      assert_equal essays(:david_modest_proposal), essay
+        def initialize(parameters)
+          @parameters = parameters
+          @permitted = false
+        end
+
+        def to_h
+          @parameters
+        end
+
+        def permit!
+          @permitted = true
+          self
+        end
+      end
+
+      author = authors(:david)
+      params = protected_params.new(name: author.name)
+      assert_raises(ActiveModel::ForbiddenAttributesError) { Author.where(params) }
+      assert_equal author, Author.where(params.permit!).first
+    end
+
+    def test_where_with_unsupported_arguments
+      assert_raises(ArgumentError) { Author.where(42) }
     end
   end
 end