ibm_db 5.6.1 → 5.7.0

data/test/cases/arel/attributes/attribute_test.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "../helper"
-require "ostruct"
 
 module Arel
   module Attributes
@@ -638,28 +637,34 @@ module Arel
           )
         end
 
-        if RUBY_VERSION >= "2.7"
-          it "can be constructed with a range implicitly starting at Infinity" do
-            attribute = Attribute.new nil, nil
-            node = attribute.between(eval("..0")) # eval for backwards compatibility
+        it "can be constructed with a range implicitly starting at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(..0)
 
-            _(node).must_equal Nodes::LessThanOrEqual.new(
-              attribute,
-              Nodes::Casted.new(0, attribute)
-            )
-          end
+          _(node).must_equal Nodes::LessThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
         end
 
-        if RUBY_VERSION >= "2.6"
-          it "can be constructed with a range implicitly ending at Infinity" do
-            attribute = Attribute.new nil, nil
-            node = attribute.between(eval("0..")) # Use eval for compatibility with Ruby < 2.6 parser
+        it "can be constructed with a range implicitly ending at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(0..)
 
-            _(node).must_equal Nodes::GreaterThanOrEqual.new(
-              attribute,
-              Nodes::Casted.new(0, attribute)
-            )
-          end
+          _(node).must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
+        end
+
+        it "can be constructed with an exclusive range implicitly ending at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(0...)
+
+          _(node).must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
         end
 
         it "can be constructed with a quoted range ending at Infinity" do
@@ -672,6 +677,20 @@ module Arel
           )
         end
 
+        it "can be constructed with an endless range starting from Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(::Float::INFINITY..)
+
+          _(node).must_equal Nodes::In.new(attribute, [])
+        end
+
+        it "can be constructed with a beginless range ending in -Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(..-::Float::INFINITY)
+
+          _(node).must_equal Nodes::In.new(attribute, [])
+        end
+
         it "can be constructed with an exclusive range" do
           attribute = Attribute.new nil, nil
           node = attribute.between(0...3)
@@ -687,6 +706,16 @@ module Arel
             )
           ])
         end
+
+        it "can be constructed with a range where the begin and end are equal" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(1..1)
+
+          _(node).must_equal Nodes::Equality.new(
+            attribute,
+            Nodes::Casted.new(1, attribute)
+          )
+        end
       end
 
       describe "#in" do
@@ -774,7 +803,7 @@ module Arel
           node = attribute.not_between(1..3)
 
           _(node).must_equal Nodes::Grouping.new(
-            Nodes::Or.new(
+            Nodes::Or.new([
               Nodes::LessThan.new(
                 attribute,
                 Nodes::Casted.new(1, attribute)
@@ -783,7 +812,7 @@ module Arel
                 attribute,
                 Nodes::Casted.new(3, attribute)
               )
-            )
+            ])
           )
         end
 
@@ -851,28 +880,24 @@ module Arel
           )
         end
 
-        if RUBY_VERSION >= "2.7"
-          it "can be constructed with a range implicitly starting at Infinity" do
-            attribute = Attribute.new nil, nil
-            node = attribute.not_between(eval("..0")) # eval for backwards compatibility
+        it "can be constructed with a range implicitly starting at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(..0)
 
-            _(node).must_equal Nodes::GreaterThan.new(
-              attribute,
-              Nodes::Casted.new(0, attribute)
-            )
-          end
+          _(node).must_equal Nodes::GreaterThan.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
         end
 
-        if RUBY_VERSION >= "2.6"
-          it "can be constructed with a range implicitly ending at Infinity" do
-            attribute = Attribute.new nil, nil
-            node = attribute.not_between(eval("0..")) # Use eval for compatibility with Ruby < 2.6 parser
+        it "can be constructed with a range implicitly ending at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(0..)
 
-            _(node).must_equal Nodes::LessThan.new(
-              attribute,
-              Nodes::Casted.new(0, attribute)
-            )
-          end
+          _(node).must_equal Nodes::LessThan.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
         end
 
         it "can be constructed with a quoted range ending at Infinity" do
@@ -885,12 +910,26 @@ module Arel
           )
         end
 
+        it "can be constructed with an endless range starting from Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(::Float::INFINITY..)
+
+          _(node).must_equal Nodes::NotIn.new(attribute, [])
+        end
+
+        it "can be constructed with a beginless range ending in -Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(..-::Float::INFINITY)
+
+          _(node).must_equal Nodes::NotIn.new(attribute, [])
+        end
+
         it "can be constructed with an exclusive range" do
           attribute = Attribute.new nil, nil
           node = attribute.not_between(0...3)
 
           _(node).must_equal Nodes::Grouping.new(
-            Nodes::Or.new(
+            Nodes::Or.new([
               Nodes::LessThan.new(
                 attribute,
                 Nodes::Casted.new(0, attribute)
@@ -899,7 +938,7 @@ module Arel
                 attribute,
                 Nodes::Casted.new(3, attribute)
               )
-            )
+            ])
           )
         end
       end
@@ -1102,7 +1141,7 @@ module Arel
           table = Table.new(:foo, type_caster: fake_caster)
           condition = table["id"].eq("1").and(table["other_id"].eq("2"))
 
-          assert table.able_to_type_cast?
+          assert_predicate table, :able_to_type_cast?
           _(condition.to_sql).must_equal %("foo"."id" = 1 AND "foo"."other_id" = '2')
         end
 
@@ -1114,17 +1153,17 @@ module Arel
           table = Table.new(:foo, type_caster: fake_caster)
           condition = table["id"].eq(Arel.sql("(select 1)"))
 
-          assert table.able_to_type_cast?
+          assert_predicate table, :able_to_type_cast?
           _(condition.to_sql).must_equal %("foo"."id" = (select 1))
         end
       end
 
       private
         def quoted_range(begin_val, end_val, exclude)
-          OpenStruct.new(
-            begin: Nodes::Quoted.new(begin_val),
-            end: Nodes::Quoted.new(end_val),
-            exclude_end?: exclude,
+          Struct.new(:begin, :end, :exclude_end?).new(
+            Nodes::Quoted.new(begin_val),
+            Nodes::Quoted.new(end_val),
+            exclude,
           )
         end
 

data/test/cases/arel/collectors/bind_test.rb

@@ -8,7 +8,7 @@ module Arel
     class TestBind < Arel::Test
       def setup
         @conn = FakeRecord::Base.new
-        @visitor = Visitors::ToSql.new @conn.connection
+        @visitor = Visitors::ToSql.new @conn.lease_connection
         super
       end
 

data/test/cases/arel/collectors/composite_test.rb

@@ -10,7 +10,7 @@ module Arel
     class TestComposite < Arel::Test
       def setup
         @conn = FakeRecord::Base.new
-        @visitor = Visitors::ToSql.new @conn.connection
+        @visitor = Visitors::ToSql.new @conn.lease_connection
         super
       end
 
@@ -42,6 +42,16 @@ module Arel
         assert_equal 'SELECT FROM "users" WHERE "users"."age" = ? AND "users"."name" = ?', sql
         assert_equal ["hello2", "world3"], binds
       end
+
+      def test_retryable_on_composite_collector_propagates
+        sql_collector = Collectors::SQLString.new
+        bind_collector = Collectors::Bind.new
+        collector = Collectors::Composite.new(sql_collector, bind_collector)
+        collector.retryable = true
+
+        assert sql_collector.retryable
+        assert bind_collector.retryable
+      end
     end
   end
 end

data/test/cases/arel/collectors/sql_string_test.rb

@@ -7,7 +7,7 @@ module Arel
     class TestSqlString < Arel::Test
       def setup
         @conn = FakeRecord::Base.new
-        @visitor = Visitors::ToSql.new @conn.connection
+        @visitor = Visitors::ToSql.new @conn.lease_connection
         super
       end
 

data/test/cases/arel/collectors/substitute_bind_collector_test.rb

@@ -9,7 +9,7 @@ module Arel
     class TestSubstituteBindCollector < Arel::Test
       def setup
         @conn = FakeRecord::Base.new
-        @visitor = Visitors::ToSql.new @conn.connection
+        @visitor = Visitors::ToSql.new @conn.lease_connection
         super
       end
 

data/test/cases/arel/delete_manager_test.rb

@@ -4,12 +4,6 @@ require_relative "helper"
 
 module Arel
   class DeleteManagerTest < Arel::Spec
-    describe "new" do
-      it "takes an engine" do
-        Arel::DeleteManager.new
-      end
-    end
-
     it "handles limit properly" do
       table = Table.new(:users)
       dm = Arel::DeleteManager.new

data/test/cases/arel/factory_methods_test.rb

@@ -19,6 +19,30 @@ module Arel
         assert_equal :two, join.right
       end
 
+      def test_create_table_alias
+        table_alias = @factory.create_table_alias :one, :two
+        assert_kind_of Nodes::TableAlias, table_alias
+        assert_equal :two, table_alias.right
+      end
+
+      def test_create_and
+        and_node = @factory.create_and ["foo", "bar"]
+        assert_instance_of Nodes::And, and_node
+        assert_equal ["foo", "bar"], and_node.children
+      end
+
+      def test_create_string_join
+        join = @factory.create_string_join "foo"
+        assert_kind_of Arel::Nodes::StringJoin, join
+        assert_equal "foo", join.left
+      end
+
+      def test_grouping
+        grouping = @factory.grouping :one
+        assert_instance_of Nodes::Grouping, grouping
+        assert_equal :one, grouping.expr
+      end
+
       def test_create_on
         on = @factory.create_on :one
         assert_instance_of Nodes::On, on
@@ -41,6 +65,27 @@ module Arel
         assert_equal "LOWER", lower.name
         assert_equal [:one], lower.expressions.map(&:expr)
       end
+
+      def test_coalesce
+        relation = Table.new(:users)
+        field_node = relation[:active]
+        coalesce = @factory.coalesce field_node, 0
+        assert_instance_of Nodes::NamedFunction, coalesce
+        assert_equal "COALESCE", coalesce.name
+        assert_equal [field_node, 0], coalesce.expressions
+      end
+
+      def test_cast
+        relation = Table.new(:users)
+        field_node = relation[:active]
+        cast = @factory.cast field_node, "boolean"
+        assert_instance_of Nodes::NamedFunction, cast
+        assert_equal "CAST", cast.name
+        as_node = cast.expressions.first
+        assert_instance_of Nodes::As, as_node
+        assert_equal field_node, as_node.left
+        assert_equal "boolean", as_node.right
+      end
     end
   end
 end

data/test/cases/arel/insert_manager_test.rb

@@ -4,12 +4,6 @@ require_relative "helper"
 
 module Arel
   class InsertManagerTest < Arel::Spec
-    describe "new" do
-      it "takes an engine" do
-        Arel::InsertManager.new
-      end
-    end
-
     describe "insert" do
       it "can create a ValuesList node" do
         manager = Arel::InsertManager.new
@@ -110,7 +104,7 @@ module Arel
 
         manager.insert [[attribute, time]]
         _(manager.to_sql).must_be_like %{
-          INSERT INTO "users" ("created_at") VALUES (#{Table.engine.connection.quote time})
+          INSERT INTO "users" ("created_at") VALUES (#{Table.engine.lease_connection.quote time})
         }
       end
 

data/test/cases/arel/nodes/as_test.rb

@@ -31,6 +31,18 @@ module Arel
           assert_equal 2, array.uniq.size
         end
       end
+
+      describe "#to_cte" do
+        it "returns a Cte node using the LHS's name and the RHS as the relation" do
+          table = Table.new(:users)
+          as_node = As.new(table, "foo")
+          cte_node = as_node.to_cte
+
+          assert_kind_of Arel::Nodes::Cte, cte_node
+          assert_equal as_node.left.name, cte_node.name
+          assert_equal as_node.right, cte_node.relation
+        end
+      end
     end
   end
 end

data/test/cases/arel/nodes/ascending_test.rb

@@ -24,7 +24,7 @@ module Arel
 
       def test_ascending?
         ascending = Ascending.new "zomg"
-        assert ascending.ascending?
+        assert_predicate ascending, :ascending?
       end
 
       def test_descending?

data/test/cases/arel/nodes/bin_test.rb

@@ -18,7 +18,7 @@ module Arel
       def test_mysql_to_sql
         viz  = Arel::Visitors::MySQL.new Table.engine.connection_pool
         node = Arel::Nodes::Bin.new(Arel.sql("zomg"))
-        assert_equal "BINARY zomg", viz.accept(node, Collectors::SQLString.new).value
+        assert_equal "CAST(zomg AS BINARY)", viz.accept(node, Collectors::SQLString.new).value
       end
 
       def test_equality_with_same_ivars

data/test/cases/arel/nodes/bound_sql_literal_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "yaml"
+
+module Arel
+  module Nodes
+    class BoundSqlLiteralTest < Arel::Spec
+      describe "equality" do
+        it "is equal with equal components" do
+          node1 = BoundSqlLiteral.new("foo + ?", [2], {})
+          node2 = BoundSqlLiteral.new("foo + ?", [2], {})
+
+          array = [node1, node2]
+
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different components" do
+          node1 = BoundSqlLiteral.new("foo + ?", [2], {})
+          node2 = BoundSqlLiteral.new("foo + ?", [3], {})
+          node3 = BoundSqlLiteral.new("foo + :bar", [], { bar: 2 })
+
+          array = [node1, node2, node3]
+
+          assert_equal 3, array.uniq.size
+        end
+      end
+    end
+  end
+end

data/test/cases/arel/nodes/cte_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    describe "Cte" do
+      describe "equality" do
+        it "is equal with equal ivars" do
+          array = [
+            Cte.new("foo", "bar", materialized: true),
+            Cte.new("foo", "bar", materialized: true)
+          ]
+
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with unequal ivars" do
+          array = [
+            Cte.new("foo", "bar", materialized: true),
+            Cte.new("foo", "bar")
+          ]
+
+          assert_equal 2, array.uniq.size
+        end
+      end
+
+      describe "#to_cte" do
+        it "returns self" do
+          cte = Cte.new("foo", "bar")
+
+          assert_equal cte.to_cte, cte
+        end
+      end
+
+      describe "#to_table" do
+        it "returns an Arel::Table using the Cte's name" do
+          table = Cte.new("foo", "bar").to_table
+
+          assert_kind_of Arel::Table, table
+          assert_equal "foo", table.name
+        end
+      end
+    end
+  end
+end

data/test/cases/arel/nodes/descending_test.rb

@@ -29,7 +29,7 @@ module Arel
 
       def test_descending?
         descending = Descending.new "zomg"
-        assert descending.descending?
+        assert_predicate descending, :descending?
       end
 
       def test_equality_with_same_ivars

data/test/cases/arel/nodes/equality_test.rb

@@ -10,18 +10,18 @@ module Arel
         describe "to_sql" do
           it "takes an engine" do
             engine = FakeRecord::Base.new
-            engine.connection.extend Module.new {
+            engine.lease_connection.extend Module.new {
               attr_accessor :quote_count
               def quote(*args) @quote_count += 1; super; end
               def quote_column_name(*args) @quote_count += 1; super; end
               def quote_table_name(*args) @quote_count += 1; super; end
             }
-            engine.connection.quote_count = 0
+            engine.lease_connection.quote_count = 0
 
             attr = Table.new(:users)[:id]
             test = attr.eq(10)
             test.to_sql engine
-            _(engine.connection.quote_count).must_equal 3
+            _(engine.lease_connection.quote_count).must_equal 3
           end
         end
       end

data/test/cases/arel/nodes/filter_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class ::FilterTest < Arel::Spec
+      describe "Filter" do
+        it "should add filter to expression" do
+          table = Arel::Table.new :users
+          _(table[:id].count.filter(table[:income].gteq(40_000)).to_sql).must_be_like %{
+              COUNT("users"."id") FILTER (WHERE "users"."income" >= 40000)
+            }
+        end
+
+        describe "as" do
+          it "should alias the expression" do
+            table = Arel::Table.new :users
+            _(table[:id].count.filter(table[:income].gteq(40_000)).as("rich_users_count").to_sql).must_be_like %{
+              COUNT("users"."id") FILTER (WHERE "users"."income" >= 40000) AS rich_users_count
+            }
+          end
+        end
+
+        describe "over" do
+          it "should reference the window definition by name" do
+            table = Arel::Table.new :users
+            window = Arel::Nodes::Window.new.partition(table[:year])
+            _(table[:id].count.filter(table[:income].gteq(40_000)).over(window).to_sql).must_be_like %{
+              COUNT("users"."id") FILTER (WHERE "users"."income" >= 40000) OVER (PARTITION BY "users"."year")
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/test/cases/arel/nodes/fragments_test.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "yaml"
+
+module Arel
+  module Nodes
+    class FragmentsTest < Arel::Spec
+      describe "equality" do
+        it "is equal with equal values" do
+          array = [Fragments.new(["foo", "bar"]), Fragments.new(["foo", "bar"])]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different values" do
+          array = [Fragments.new(["foo"]), Fragments.new(["bar"])]
+          assert_equal 2, array.uniq.size
+        end
+
+        it "can be joined with other nodes" do
+          fragments = Fragments.new(["foo", "bar"])
+          sql = Arel.sql("SELECT")
+          joined_fragments = fragments + sql
+
+          assert_equal ["foo", "bar"], fragments.values
+          assert_equal ["foo", "bar", sql], joined_fragments.values
+        end
+
+        it "fails if joined with something that is not an Arel node" do
+          fragments = Fragments.new
+          assert_raises ArgumentError do
+            fragments + "Not a node"
+          end
+        end
+      end
+    end
+  end
+end

data/test/cases/arel/nodes/homogeneous_in_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "active_record/type_caster/map"
+require "active_model"
+class Arel::Nodes::HomogeneousInTest < Arel::Spec
+  def test_in
+    table = Arel::Table.new :users, type_caster: fake_pg_caster
+
+    expr = Arel::Nodes::HomogeneousIn.new(["Bobby", "Robert"], table[:name], :in)
+
+    _(expr.to_sql).must_be_like %{
+      "users"."name" IN (?, ?)
+    }
+  end
+
+  def test_custom_attribute_node
+    table = Arel::Table.new :users, type_caster: fake_pg_caster
+
+    node = TypedNode.new("COALESCE",
+                         [table[:nickname], table[:name]],
+                         STRING_TYPE
+                        )
+    expr = Arel::Nodes::HomogeneousIn.new(["Bobby", "Robert"], node, :in)
+
+    _(expr.to_sql).must_be_like %{
+      COALESCE("users"."nickname", "users"."name") IN (?, ?)
+    }
+  end
+
+  private
+    STRING_TYPE = ActiveModel::Type::String.new.freeze
+
+    # this is a named function that also has a data type
+    class TypedNode < Arel::Nodes::NamedFunction
+      attr_reader :type_caster
+
+      def initialize(name, expr, type)
+        super(name, expr, nil)
+        @type_caster = type
+      end
+    end
+
+    # map that converts attribute names to a caster
+    def fake_pg_caster
+      Object.new.tap do |caster|
+        def caster.type_for_attribute(attr_name)
+          STRING_TYPE
+        end
+      end
+    end
+end

data/test/cases/arel/nodes/infix_operation_test.rb

@@ -25,7 +25,7 @@ module Arel
         ordering = operation.desc
         assert_kind_of Descending, ordering
         assert_equal operation, ordering.expr
-        assert ordering.descending?
+        assert_predicate ordering, :descending?
       end
 
       def test_equality_with_same_ivars

data/test/cases/arel/nodes/node_test.rb

@@ -15,7 +15,7 @@ module Arel
         next if Nodes::SqlLiteral == klass
         next if Nodes::BindParam == klass
         next if /^Arel::Nodes::(?:Test|.*Test$)/.match?(klass.name)
-        assert klass.ancestors.include?(Nodes::Node), klass.name
+        assert_includes klass.ancestors, Nodes::Node
       end
     end
   end