ibm_db 5.2.0 → 5.3.1

data/test/cases/arel/insert_manager_test.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+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
+        values  = manager.create_values_list([%w{ a b }, %w{ c d }])
+
+        assert_kind_of Arel::Nodes::ValuesList, values
+        assert_equal [%w{ a b }, %w{ c d }], values.rows
+      end
+
+      it "allows sql literals" do
+        manager = Arel::InsertManager.new
+        manager.into Table.new(:users)
+        manager.values = manager.create_values([Arel.sql("*")])
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO \"users\" VALUES (*)
+        }
+      end
+
+      it "works with multiple values" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.columns << table[:id]
+        manager.columns << table[:name]
+
+        manager.values = manager.create_values_list([
+          %w{1 david},
+          %w{2 kir},
+          ["3", Arel.sql("DEFAULT")],
+        ])
+
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO \"users\" (\"id\", \"name\") VALUES ('1', 'david'), ('2', 'kir'), ('3', DEFAULT)
+        }
+      end
+
+      it "literals in multiple values are not escaped" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.columns << table[:name]
+
+        manager.values = manager.create_values_list([
+          [Arel.sql("*")],
+          [Arel.sql("DEFAULT")],
+        ])
+
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO \"users\" (\"name\") VALUES (*), (DEFAULT)
+        }
+      end
+
+      it "works with multiple single values" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.columns << table[:name]
+
+        manager.values = manager.create_values_list([
+          %w{david},
+          %w{kir},
+          [Arel.sql("DEFAULT")],
+        ])
+
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO \"users\" (\"name\") VALUES ('david'), ('kir'), (DEFAULT)
+        }
+      end
+
+      it "inserts false" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+
+        manager.insert [[table[:bool], false]]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("bool") VALUES ('f')
+        }
+      end
+
+      it "inserts null" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.insert [[table[:id], nil]]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id") VALUES (NULL)
+        }
+      end
+
+      it "inserts time" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+
+        time = Time.now
+        attribute = table[:created_at]
+
+        manager.insert [[attribute, time]]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("created_at") VALUES (#{Table.engine.connection.quote time})
+        }
+      end
+
+      it "takes a list of lists" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.into table
+        manager.insert [[table[:id], 1], [table[:name], "aaron"]]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
+        }
+      end
+
+      it "defaults the table" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.insert [[table[:id], 1], [table[:name], "aaron"]]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
+        }
+      end
+
+      it "noop for empty list" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.insert [[table[:id], 1]]
+        manager.insert []
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id") VALUES (1)
+        }
+      end
+
+      it "is chainable" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        insert_result = manager.insert [[table[:id], 1]]
+        assert_equal manager, insert_result
+      end
+    end
+
+    describe "into" do
+      it "takes a Table and chains" do
+        manager = Arel::InsertManager.new
+        _(manager.into(Table.new(:users))).must_equal manager
+      end
+
+      it "converts to sql" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users"
+        }
+      end
+    end
+
+    describe "columns" do
+      it "converts to sql" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+        manager.columns << table[:id]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id")
+        }
+      end
+    end
+
+    describe "values" do
+      it "converts to sql" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.values = Nodes::ValuesList.new([[1], [2]])
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" VALUES (1), (2)
+        }
+      end
+
+      it "accepts sql literals" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.values = Arel.sql("DEFAULT VALUES")
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" DEFAULT VALUES
+        }
+      end
+    end
+
+    describe "combo" do
+      it "combines columns and values list in order" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.values = Nodes::ValuesList.new([[1, "aaron"], [2, "david"]])
+        manager.columns << table[:id]
+        manager.columns << table[:name]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id", "name") VALUES (1, 'aaron'), (2, 'david')
+        }
+      end
+    end
+
+    describe "select" do
+      it "accepts a select query in place of a VALUES clause" do
+        table   = Table.new :users
+
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        select = Arel::SelectManager.new
+        select.project Arel.sql("1")
+        select.project Arel.sql('"aaron"')
+
+        manager.select select
+        manager.columns << table[:id]
+        manager.columns << table[:name]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id", "name") (SELECT 1, "aaron")
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    describe "And" do
+      describe "equality" do
+        it "is equal with equal ivars" do
+          array = [And.new(["foo", "bar"]), And.new(["foo", "bar"])]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          array = [And.new(["foo", "bar"]), And.new(["foo", "baz"])]
+          assert_equal 2, array.uniq.size
+        end
+      end
+
+      describe "functions as node expression" do
+        it "allows aliasing" do
+          aliased = And.new(["foo", "bar"]).as("baz")
+
+          assert_kind_of As, aliased
+          assert_kind_of SqlLiteral, aliased.right
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    describe "As" do
+      describe "#as" do
+        it "makes an AS node" do
+          attr = Table.new(:users)[:id]
+          as = attr.as(Arel.sql("foo"))
+          assert_equal attr, as.left
+          assert_equal "foo", as.right
+        end
+
+        it "converts right to SqlLiteral if a string" do
+          attr = Table.new(:users)[:id]
+          as = attr.as("foo")
+          assert_kind_of Arel::Nodes::SqlLiteral, as.right
+        end
+      end
+
+      describe "equality" do
+        it "is equal with equal ivars" do
+          array = [As.new("foo", "bar"), As.new("foo", "bar")]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          array = [As.new("foo", "bar"), As.new("foo", "baz")]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestAscending < Arel::Test
+      def test_construct
+        ascending = Ascending.new "zomg"
+        assert_equal "zomg", ascending.expr
+      end
+
+      def test_reverse
+        ascending = Ascending.new "zomg"
+        descending = ascending.reverse
+        assert_kind_of Descending, descending
+        assert_equal ascending.expr, descending.expr
+      end
+
+      def test_direction
+        ascending = Ascending.new "zomg"
+        assert_equal :asc, ascending.direction
+      end
+
+      def test_ascending?
+        ascending = Ascending.new "zomg"
+        assert ascending.ascending?
+      end
+
+      def test_descending?
+        ascending = Ascending.new "zomg"
+        assert_not ascending.descending?
+      end
+
+      def test_equality_with_same_ivars
+        array = [Ascending.new("zomg"), Ascending.new("zomg")]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [Ascending.new("zomg"), Ascending.new("zomg!")]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestBin < Arel::Test
+      def test_new
+        assert Arel::Nodes::Bin.new("zomg")
+      end
+
+      def test_default_to_sql
+        viz  = Arel::Visitors::ToSql.new Table.engine.connection_pool
+        node = Arel::Nodes::Bin.new(Arel.sql("zomg"))
+        assert_equal "zomg", viz.accept(node, Collectors::SQLString.new).value
+      end
+
+      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
+      end
+
+      def test_equality_with_same_ivars
+        array = [Bin.new("zomg"), Bin.new("zomg")]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [Bin.new("zomg"), Bin.new("zomg!")]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class NodesTest < Arel::Spec
+      describe "Binary" do
+        describe "#hash" do
+          it "generates a hash based on its value" do
+            eq = Equality.new("foo", "bar")
+            eq2 = Equality.new("foo", "bar")
+            eq3 = Equality.new("bar", "baz")
+
+            assert_equal eq.hash, eq2.hash
+            assert_not_equal eq.hash, eq3.hash
+          end
+
+          it "generates a hash specific to its class" do
+            eq = Equality.new("foo", "bar")
+            neq = NotEqual.new("foo", "bar")
+
+            assert_not_equal eq.hash, neq.hash
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    describe "BindParam" do
+      it "is equal to other bind params with the same value" do
+        _(BindParam.new(1)).must_equal(BindParam.new(1))
+        _(BindParam.new("foo")).must_equal(BindParam.new("foo"))
+      end
+
+      it "is not equal to other nodes" do
+        _(BindParam.new(nil)).wont_equal(Node.new)
+      end
+
+      it "is not equal to bind params with different values" do
+        _(BindParam.new(1)).wont_equal(BindParam.new(2))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class NodesTest < Arel::Spec
+      describe "Case" do
+        describe "#initialize" do
+          it "sets case expression from first argument" do
+            node = Case.new "foo"
+
+            assert_equal "foo", node.case
+          end
+
+          it "sets default case from second argument" do
+            node = Case.new nil, "bar"
+
+            assert_equal "bar", node.default
+          end
+        end
+
+        describe "#clone" do
+          it "clones case, conditions and default" do
+            foo = Nodes.build_quoted "foo"
+
+            node = Case.new
+            node.case = foo
+            node.conditions = [When.new(foo, foo)]
+            node.default = foo
+
+            dolly = node.clone
+
+            assert_equal dolly.case, node.case
+            assert_not_same dolly.case, node.case
+
+            assert_equal dolly.conditions, node.conditions
+            assert_not_same dolly.conditions, node.conditions
+
+            assert_equal dolly.default, node.default
+            assert_not_same dolly.default, node.default
+          end
+        end
+
+        describe "equality" do
+          it "is equal with equal ivars" do
+            foo = Nodes.build_quoted "foo"
+            one = Nodes.build_quoted 1
+            zero = Nodes.build_quoted 0
+
+            case1 = Case.new foo
+            case1.conditions = [When.new(foo, one)]
+            case1.default = Else.new zero
+
+            case2 = Case.new foo
+            case2.conditions = [When.new(foo, one)]
+            case2.default = Else.new zero
+
+            array = [case1, case2]
+
+            assert_equal 1, array.uniq.size
+          end
+
+          it "is not equal with different ivars" do
+            foo = Nodes.build_quoted "foo"
+            bar = Nodes.build_quoted "bar"
+            one = Nodes.build_quoted 1
+            zero = Nodes.build_quoted 0
+
+            case1 = Case.new foo
+            case1.conditions = [When.new(foo, one)]
+            case1.default = Else.new zero
+
+            case2 = Case.new foo
+            case2.conditions = [When.new(bar, one)]
+            case2.default = Else.new zero
+
+            array = [case1, case2]
+
+            assert_equal 2, array.uniq.size
+          end
+        end
+
+        describe "#as" do
+          it "allows aliasing" do
+            node = Case.new "foo"
+            as = node.as("bar")
+
+            assert_equal node, as.left
+            assert_kind_of Arel::Nodes::SqlLiteral, as.right
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    describe Casted do
+      describe "#hash" do
+        it "is equal when eql? returns true" do
+          one = Casted.new 1, 2
+          also_one = Casted.new 1, 2
+
+          assert_equal one.hash, also_one.hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "yaml"
+
+module Arel
+  module Nodes
+    class CommentTest < Arel::Spec
+      describe "equality" do
+        it "is equal with equal contents" do
+          array = [Comment.new(["foo"]), Comment.new(["foo"])]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different contents" do
+          array = [Comment.new(["foo"]), Comment.new(["bar"])]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+class Arel::Nodes::CountTest < Arel::Spec
+  describe "as" do
+    it "should alias the count" do
+      table = Arel::Table.new :users
+      _(table[:id].count.as("foo").to_sql).must_be_like %{
+        COUNT("users"."id") AS foo
+      }
+    end
+  end
+
+  describe "eq" do
+    it "should compare the count" do
+      table = Arel::Table.new :users
+      _(table[:id].count.eq(2).to_sql).must_be_like %{
+        COUNT("users"."id") = 2
+      }
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      array = [Arel::Nodes::Count.new("foo"), Arel::Nodes::Count.new("foo")]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      array = [Arel::Nodes::Count.new("foo"), Arel::Nodes::Count.new("foo!")]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+describe Arel::Nodes::DeleteStatement do
+  describe "#clone" do
+    it "clones wheres" do
+      statement = Arel::Nodes::DeleteStatement.new
+      statement.wheres = %w[a b c]
+
+      dolly = statement.clone
+      _(dolly.wheres).must_equal statement.wheres
+      _(dolly.wheres).wont_be_same_as statement.wheres
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      statement1 = Arel::Nodes::DeleteStatement.new
+      statement1.wheres = %w[a b c]
+      statement2 = Arel::Nodes::DeleteStatement.new
+      statement2.wheres = %w[a b c]
+      array = [statement1, statement2]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      statement1 = Arel::Nodes::DeleteStatement.new
+      statement1.wheres = %w[a b c]
+      statement2 = Arel::Nodes::DeleteStatement.new
+      statement2.wheres = %w[1 2 3]
+      array = [statement1, statement2]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestDescending < Arel::Test
+      def test_construct
+        descending = Descending.new "zomg"
+        assert_equal "zomg", descending.expr
+      end
+
+      def test_reverse
+        descending = Descending.new "zomg"
+        ascending = descending.reverse
+        assert_kind_of Ascending, ascending
+        assert_equal descending.expr, ascending.expr
+      end
+
+      def test_direction
+        descending = Descending.new "zomg"
+        assert_equal :desc, descending.direction
+      end
+
+      def test_ascending?
+        descending = Descending.new "zomg"
+        assert_not descending.ascending?
+      end
+
+      def test_descending?
+        descending = Descending.new "zomg"
+        assert descending.descending?
+      end
+
+      def test_equality_with_same_ivars
+        array = [Descending.new("zomg"), Descending.new("zomg")]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [Descending.new("zomg"), Descending.new("zomg!")]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end