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

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    describe "Distinct" do
+      describe "equality" do
+        it "is equal to other distinct nodes" do
+          array = [Distinct.new, Distinct.new]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with other nodes" do
+          array = [Distinct.new, Node.new]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    describe "equality" do
+      # FIXME: backwards compat
+      describe "backwards compat" do
+        describe "to_sql" do
+          it "takes an engine" do
+            engine = FakeRecord::Base.new
+            engine.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
+
+            attr = Table.new(:users)[:id]
+            test = attr.eq(10)
+            test.to_sql engine
+            _(engine.connection.quote_count).must_equal 3
+          end
+        end
+      end
+
+      describe "or" do
+        it "makes an OR node" do
+          attr = Table.new(:users)[:id]
+          left  = attr.eq(10)
+          right = attr.eq(11)
+          node  = left.or right
+          _(node.expr.left).must_equal left
+          _(node.expr.right).must_equal right
+        end
+      end
+
+      describe "and" do
+        it "makes and AND node" do
+          attr = Table.new(:users)[:id]
+          left  = attr.eq(10)
+          right = attr.eq(11)
+          node  = left.and right
+          _(node.left).must_equal left
+          _(node.right).must_equal right
+        end
+      end
+
+      it "is equal with equal ivars" do
+        array = [Equality.new("foo", "bar"), Equality.new("foo", "bar")]
+        assert_equal 1, array.uniq.size
+      end
+
+      it "is not equal with different ivars" do
+        array = [Equality.new("foo", "bar"), Equality.new("foo", "baz")]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+class Arel::Nodes::ExtractTest < Arel::Spec
+  it "should extract field" do
+    table = Arel::Table.new :users
+    _(table[:timestamp].extract("date").to_sql).must_be_like %{
+      EXTRACT(DATE FROM "users"."timestamp")
+    }
+  end
+
+  describe "as" do
+    it "should alias the extract" do
+      table = Arel::Table.new :users
+      _(table[:timestamp].extract("date").as("foo").to_sql).must_be_like %{
+        EXTRACT(DATE FROM "users"."timestamp") AS foo
+      }
+    end
+
+    it "should not mutate the extract" do
+      table = Arel::Table.new :users
+      extract = table[:timestamp].extract("date")
+      before = extract.dup
+      extract.as("foo")
+      assert_equal extract, before
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      table = Arel::Table.new :users
+      array = [table[:attr].extract("foo"), table[:attr].extract("foo")]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      table = Arel::Table.new :users
+      array = [table[:attr].extract("foo"), table[:attr].extract("bar")]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    describe "False" do
+      describe "equality" do
+        it "is equal to other false nodes" do
+          array = [False.new, False.new]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with other nodes" do
+          array = [False.new, Node.new]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class GroupingTest < Arel::Spec
+      it "should create Equality nodes" do
+        grouping = Grouping.new(Nodes.build_quoted("foo"))
+        _(grouping.eq("foo").to_sql).must_be_like "('foo') = 'foo'"
+      end
+
+      describe "equality" do
+        it "is equal with equal ivars" do
+          array = [Grouping.new("foo"), Grouping.new("foo")]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          array = [Grouping.new("foo"), Grouping.new("bar")]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestInfixOperation < Arel::Test
+      def test_construct
+        operation = InfixOperation.new :+, 1, 2
+        assert_equal :+, operation.operator
+        assert_equal 1, operation.left
+        assert_equal 2, operation.right
+      end
+
+      def test_operation_alias
+        operation = InfixOperation.new :+, 1, 2
+        aliaz = operation.as("zomg")
+        assert_kind_of As, aliaz
+        assert_equal operation, aliaz.left
+        assert_equal "zomg", aliaz.right
+      end
+
+      def test_operation_ordering
+        operation = InfixOperation.new :+, 1, 2
+        ordering = operation.desc
+        assert_kind_of Descending, ordering
+        assert_equal operation, ordering.expr
+        assert ordering.descending?
+      end
+
+      def test_equality_with_same_ivars
+        array = [InfixOperation.new(:+, 1, 2), InfixOperation.new(:+, 1, 2)]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [InfixOperation.new(:+, 1, 2), InfixOperation.new(:+, 1, 3)]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestNamedFunction < Arel::Test
+      def test_construct
+        function = NamedFunction.new "omg", "zomg"
+        assert_equal "omg", function.name
+        assert_equal "zomg", function.expressions
+      end
+
+      def test_function_alias
+        function = NamedFunction.new "omg", "zomg"
+        function = function.as("wth")
+        assert_equal "omg", function.name
+        assert_equal "zomg", function.expressions
+        assert_kind_of SqlLiteral, function.alias
+        assert_equal "wth", function.alias
+      end
+
+      def test_construct_with_alias
+        function = NamedFunction.new "omg", "zomg", "wth"
+        assert_equal "omg", function.name
+        assert_equal "zomg", function.expressions
+        assert_kind_of SqlLiteral, function.alias
+        assert_equal "wth", function.alias
+      end
+
+      def test_equality_with_same_ivars
+        array = [
+          NamedFunction.new("omg", "zomg", "wth"),
+          NamedFunction.new("omg", "zomg", "wth")
+        ]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [
+          NamedFunction.new("omg", "zomg", "wth"),
+          NamedFunction.new("zomg", "zomg", "wth")
+        ]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  class TestNode < Arel::Test
+    def test_includes_factory_methods
+      assert Arel::Nodes::Node.new.respond_to?(:create_join)
+    end
+
+    def test_all_nodes_are_nodes
+      Nodes.constants.map { |k|
+        Nodes.const_get(k)
+      }.grep(Class).each do |klass|
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    describe "not" do
+      describe "#not" do
+        it "makes a NOT node" do
+          attr = Table.new(:users)[:id]
+          expr  = attr.eq(10)
+          node  = expr.not
+          _(node).must_be_kind_of Not
+          _(node.expr).must_equal expr
+        end
+      end
+
+      describe "equality" do
+        it "is equal with equal ivars" do
+          array = [Not.new("foo"), Not.new("foo")]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          array = [Not.new("foo"), Not.new("baz")]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    describe "or" do
+      describe "#or" do
+        it "makes an OR node" do
+          attr = Table.new(:users)[:id]
+          left  = attr.eq(10)
+          right = attr.eq(11)
+          node  = left.or right
+          _(node.expr.left).must_equal left
+          _(node.expr.right).must_equal right
+
+          oror = node.or(right)
+          _(oror.expr.left).must_equal node
+          _(oror.expr.right).must_equal right
+        end
+      end
+
+      describe "equality" do
+        it "is equal with equal ivars" do
+          array = [Or.new("foo", "bar"), Or.new("foo", "bar")]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          array = [Or.new("foo", "bar"), Or.new("foo", "baz")]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+class Arel::Nodes::OverTest < Arel::Spec
+  describe "as" do
+    it "should alias the expression" do
+      table = Arel::Table.new :users
+      _(table[:id].count.over.as("foo").to_sql).must_be_like %{
+        COUNT("users"."id") OVER () AS foo
+      }
+    end
+  end
+
+  describe "with literal" do
+    it "should reference the window definition by name" do
+      table = Arel::Table.new :users
+      _(table[:id].count.over("foo").to_sql).must_be_like %{
+        COUNT("users"."id") OVER "foo"
+      }
+    end
+  end
+
+  describe "with SQL literal" do
+    it "should reference the window definition by name" do
+      table = Arel::Table.new :users
+      _(table[:id].count.over(Arel.sql("foo")).to_sql).must_be_like %{
+        COUNT("users"."id") OVER foo
+      }
+    end
+  end
+
+  describe "with no expression" do
+    it "should use empty definition" do
+      table = Arel::Table.new :users
+      _(table[:id].count.over.to_sql).must_be_like %{
+        COUNT("users"."id") OVER ()
+      }
+    end
+  end
+
+  describe "with expression" do
+    it "should use definition in sub-expression" do
+      table = Arel::Table.new :users
+      window = Arel::Nodes::Window.new.order(table["foo"])
+      _(table[:id].count.over(window).to_sql).must_be_like %{
+        COUNT("users"."id") OVER (ORDER BY \"users\".\"foo\")
+      }
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      array = [
+        Arel::Nodes::Over.new("foo", "bar"),
+        Arel::Nodes::Over.new("foo", "bar")
+      ]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      array = [
+        Arel::Nodes::Over.new("foo", "bar"),
+        Arel::Nodes::Over.new("foo", "baz")
+      ]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestSelectCore < Arel::Test
+      def test_clone
+        core = Arel::Nodes::SelectCore.new
+        core.froms       = %w[a b c]
+        core.projections = %w[d e f]
+        core.wheres      = %w[g h i]
+
+        dolly = core.clone
+
+        assert_equal core.froms, dolly.froms
+        assert_equal core.projections, dolly.projections
+        assert_equal core.wheres, dolly.wheres
+
+        assert_not_same core.froms, dolly.froms
+        assert_not_same core.projections, dolly.projections
+        assert_not_same core.wheres, dolly.wheres
+      end
+
+      def test_set_quantifier
+        core = Arel::Nodes::SelectCore.new
+        core.set_quantifier = Arel::Nodes::Distinct.new
+        viz = Arel::Visitors::ToSql.new Table.engine.connection_pool
+        assert_match "DISTINCT", viz.accept(core, Collectors::SQLString.new).value
+      end
+
+      def test_equality_with_same_ivars
+        core1 = SelectCore.new
+        core1.froms       = %w[a b c]
+        core1.projections = %w[d e f]
+        core1.wheres      = %w[g h i]
+        core1.groups      = %w[j k l]
+        core1.windows     = %w[m n o]
+        core1.havings     = %w[p q r]
+        core1.comment     = Arel::Nodes::Comment.new(["comment"])
+        core2 = SelectCore.new
+        core2.froms       = %w[a b c]
+        core2.projections = %w[d e f]
+        core2.wheres      = %w[g h i]
+        core2.groups      = %w[j k l]
+        core2.windows     = %w[m n o]
+        core2.havings     = %w[p q r]
+        core2.comment     = Arel::Nodes::Comment.new(["comment"])
+        array = [core1, core2]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        core1 = SelectCore.new
+        core1.froms       = %w[a b c]
+        core1.projections = %w[d e f]
+        core1.wheres      = %w[g h i]
+        core1.groups      = %w[j k l]
+        core1.windows     = %w[m n o]
+        core1.havings     = %w[p q r]
+        core1.comment     = Arel::Nodes::Comment.new(["comment"])
+        core2 = SelectCore.new
+        core2.froms       = %w[a b c]
+        core2.projections = %w[d e f]
+        core2.wheres      = %w[g h i]
+        core2.groups      = %w[j k l]
+        core2.windows     = %w[m n o]
+        core2.havings     = %w[l o l]
+        core2.comment     = Arel::Nodes::Comment.new(["comment"])
+        array = [core1, core2]
+        assert_equal 2, array.uniq.size
+        core2.havings     = %w[p q r]
+        core2.comment     = Arel::Nodes::Comment.new(["other"])
+        array = [core1, core2]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+describe Arel::Nodes::SelectStatement do
+  describe "#clone" do
+    it "clones cores" do
+      statement = Arel::Nodes::SelectStatement.new %w[a b c]
+
+      dolly = statement.clone
+      _(dolly.cores).must_equal      statement.cores
+      _(dolly.cores).wont_be_same_as statement.cores
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      statement1 = Arel::Nodes::SelectStatement.new %w[a b c]
+      statement1.offset = 1
+      statement1.limit  = 2
+      statement1.lock   = false
+      statement1.orders = %w[x y z]
+      statement1.with   = "zomg"
+      statement2 = Arel::Nodes::SelectStatement.new %w[a b c]
+      statement2.offset = 1
+      statement2.limit  = 2
+      statement2.lock   = false
+      statement2.orders = %w[x y z]
+      statement2.with   = "zomg"
+      array = [statement1, statement2]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      statement1 = Arel::Nodes::SelectStatement.new %w[a b c]
+      statement1.offset = 1
+      statement1.limit  = 2
+      statement1.lock   = false
+      statement1.orders = %w[x y z]
+      statement1.with   = "zomg"
+      statement2 = Arel::Nodes::SelectStatement.new %w[a b c]
+      statement2.offset = 1
+      statement2.limit  = 2
+      statement2.lock   = false
+      statement2.orders = %w[x y z]
+      statement2.with   = "wth"
+      array = [statement1, statement2]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "yaml"
+
+module Arel
+  module Nodes
+    class SqlLiteralTest < Arel::Spec
+      before do
+        @visitor = Visitors::ToSql.new Table.engine.connection
+      end
+
+      def compile(node)
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      describe "sql" do
+        it "makes a sql literal node" do
+          sql = Arel.sql "foo"
+          _(sql).must_be_kind_of Arel::Nodes::SqlLiteral
+        end
+      end
+
+      describe "count" do
+        it "makes a count node" do
+          node = SqlLiteral.new("*").count
+          _(compile(node)).must_be_like %{ COUNT(*) }
+        end
+
+        it "makes a distinct node" do
+          node = SqlLiteral.new("*").count true
+          _(compile(node)).must_be_like %{ COUNT(DISTINCT *) }
+        end
+      end
+
+      describe "equality" do
+        it "makes an equality node" do
+          node = SqlLiteral.new("foo").eq(1)
+          _(compile(node)).must_be_like %{ foo = 1 }
+        end
+
+        it "is equal with equal contents" do
+          array = [SqlLiteral.new("foo"), SqlLiteral.new("foo")]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different contents" do
+          array = [SqlLiteral.new("foo"), SqlLiteral.new("bar")]
+          assert_equal 2, array.uniq.size
+        end
+      end
+
+      describe 'grouped "or" equality' do
+        it "makes a grouping node with an or node" do
+          node = SqlLiteral.new("foo").eq_any([1, 2])
+          _(compile(node)).must_be_like %{ (foo = 1 OR foo = 2) }
+        end
+      end
+
+      describe 'grouped "and" equality' do
+        it "makes a grouping node with an and node" do
+          node = SqlLiteral.new("foo").eq_all([1, 2])
+          _(compile(node)).must_be_like %{ (foo = 1 AND foo = 2) }
+        end
+      end
+
+      describe "serialization" do
+        it "serializes into YAML" do
+          yaml_literal = SqlLiteral.new("foo").to_yaml
+          assert_equal("foo", YAML.load(yaml_literal))
+        end
+      end
+    end
+  end
+end