ibm_db 5.2.0 → 5.3.1

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Attributes
+    class MathTest < Arel::Spec
+      %i[* /].each do |math_operator|
+        it "average should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].average.public_send(math_operator, 2).to_sql).must_be_like %{
+            AVG("users"."id") #{math_operator} 2
+          }
+        end
+
+        it "count should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].count.public_send(math_operator, 2).to_sql).must_be_like %{
+            COUNT("users"."id") #{math_operator} 2
+          }
+        end
+
+        it "maximum should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].maximum.public_send(math_operator, 2).to_sql).must_be_like %{
+            MAX("users"."id") #{math_operator} 2
+          }
+        end
+
+        it "minimum should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].minimum.public_send(math_operator, 2).to_sql).must_be_like %{
+            MIN("users"."id") #{math_operator} 2
+          }
+        end
+
+        it "attribute node should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].public_send(math_operator, 2).to_sql).must_be_like %{
+            "users"."id" #{math_operator} 2
+          }
+        end
+      end
+
+      %i[+ - & | ^ << >>].each do |math_operator|
+        it "average should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].average.public_send(math_operator, 2).to_sql).must_be_like %{
+            (AVG("users"."id") #{math_operator} 2)
+          }
+        end
+
+        it "count should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].count.public_send(math_operator, 2).to_sql).must_be_like %{
+            (COUNT("users"."id") #{math_operator} 2)
+          }
+        end
+
+        it "maximum should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].maximum.public_send(math_operator, 2).to_sql).must_be_like %{
+            (MAX("users"."id") #{math_operator} 2)
+          }
+        end
+
+        it "minimum should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].minimum.public_send(math_operator, 2).to_sql).must_be_like %{
+            (MIN("users"."id") #{math_operator} 2)
+          }
+        end
+
+        it "attribute node should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].public_send(math_operator, 2).to_sql).must_be_like %{
+            ("users"."id" #{math_operator} 2)
+          }
+        end
+      end
+    end
+  end
+end

data/test/cases/arel/attributes_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Arel
+  describe "Attributes" do
+    it "responds to lower" do
+      relation  = Table.new(:users)
+      attribute = relation[:foo]
+      node      = attribute.lower
+      assert_equal "LOWER", node.name
+      assert_equal [attribute], node.expressions
+    end
+
+    describe "equality" do
+      it "is equal with equal ivars" do
+        array = [Attribute.new("foo", "bar"), Attribute.new("foo", "bar")]
+        assert_equal 1, array.uniq.size
+      end
+
+      it "is not equal with different ivars" do
+        array = [Attribute.new("foo", "bar"), Attribute.new("foo", "baz")]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "arel/collectors/bind"
+
+module Arel
+  module Collectors
+    class TestBind < Arel::Test
+      def setup
+        @conn = FakeRecord::Base.new
+        @visitor = Visitors::ToSql.new @conn.connection
+        super
+      end
+
+      def collect(node)
+        @visitor.accept(node, Collectors::Bind.new)
+      end
+
+      def compile(node)
+        collect(node).value
+      end
+
+      def ast_with_binds(bvs)
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.where(table[:age].eq(Nodes::BindParam.new(bvs.shift)))
+        manager.where(table[:name].eq(Nodes::BindParam.new(bvs.shift)))
+        manager.ast
+      end
+
+      def test_compile_gathers_all_bind_params
+        binds = compile(ast_with_binds(["hello", "world"]))
+        assert_equal ["hello", "world"], binds
+
+        binds = compile(ast_with_binds(["hello2", "world3"]))
+        assert_equal ["hello2", "world3"], binds
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+require "arel/collectors/bind"
+require "arel/collectors/composite"
+
+module Arel
+  module Collectors
+    class TestComposite < Arel::Test
+      def setup
+        @conn = FakeRecord::Base.new
+        @visitor = Visitors::ToSql.new @conn.connection
+        super
+      end
+
+      def collect(node)
+        sql_collector = Collectors::SQLString.new
+        bind_collector = Collectors::Bind.new
+        collector = Collectors::Composite.new(sql_collector, bind_collector)
+        @visitor.accept(node, collector)
+      end
+
+      def compile(node)
+        collect(node).value
+      end
+
+      def ast_with_binds(bvs)
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.where(table[:age].eq(Nodes::BindParam.new(bvs.shift)))
+        manager.where(table[:name].eq(Nodes::BindParam.new(bvs.shift)))
+        manager.ast
+      end
+
+      def test_composite_collector_performs_multiple_collections_at_once
+        sql, binds = compile(ast_with_binds(["hello", "world"]))
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = ? AND "users"."name" = ?', sql
+        assert_equal ["hello", "world"], binds
+
+        sql, binds = compile(ast_with_binds(["hello2", "world3"]))
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = ? AND "users"."name" = ?', sql
+        assert_equal ["hello2", "world3"], binds
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Collectors
+    class TestSqlString < Arel::Test
+      def setup
+        @conn = FakeRecord::Base.new
+        @visitor = Visitors::ToSql.new @conn.connection
+        super
+      end
+
+      def collect(node)
+        @visitor.accept(node, Collectors::SQLString.new)
+      end
+
+      def compile(node)
+        collect(node).value
+      end
+
+      def ast_with_binds
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.where(table[:age].eq(Nodes::BindParam.new("hello")))
+        manager.where(table[:name].eq(Nodes::BindParam.new("world")))
+        manager.ast
+      end
+
+      def test_compile
+        sql = compile(ast_with_binds)
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = ? AND "users"."name" = ?', sql
+      end
+
+      def test_returned_sql_uses_utf8_encoding
+        sql = compile(ast_with_binds)
+        assert_equal sql.encoding, Encoding::UTF_8
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "arel/collectors/substitute_binds"
+require "arel/collectors/sql_string"
+
+module Arel
+  module Collectors
+    class TestSubstituteBindCollector < Arel::Test
+      def setup
+        @conn = FakeRecord::Base.new
+        @visitor = Visitors::ToSql.new @conn.connection
+        super
+      end
+
+      def ast_with_binds
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.where(table[:age].eq(Nodes::BindParam.new("hello")))
+        manager.where(table[:name].eq(Nodes::BindParam.new("world")))
+        manager.ast
+      end
+
+      def compile(node, quoter)
+        collector = Collectors::SubstituteBinds.new(quoter, Collectors::SQLString.new)
+        @visitor.accept(node, collector).value
+      end
+
+      def test_compile
+        quoter = Object.new
+        def quoter.quote(val)
+          val.to_s
+        end
+        sql = compile(ast_with_binds, quoter)
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = hello AND "users"."name" = world', sql
+      end
+
+      def test_quoting_is_delegated_to_quoter
+        quoter = Object.new
+        def quoter.quote(val)
+          val.inspect
+        end
+        sql = compile(ast_with_binds, quoter)
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = "hello" AND "users"."name" = "world"', sql
+      end
+    end
+  end
+end

data/test/cases/arel/crud_test.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Arel
+  class FakeCrudder < SelectManager
+    class FakeEngine
+      attr_reader :calls, :connection_pool, :spec, :config
+
+      def initialize
+        @calls = []
+        @connection_pool = self
+        @spec = self
+        @config = { adapter: "sqlite3" }
+      end
+
+      def connection; self end
+
+      def method_missing(name, *args)
+        @calls << [name, args]
+      end
+    end
+
+    include Crud
+
+    attr_reader :engine
+    attr_accessor :ctx
+
+    def initialize(engine = FakeEngine.new)
+      super
+    end
+  end
+
+  describe "crud" do
+    describe "insert" do
+      it "should call insert on the connection" do
+        table = Table.new :users
+        fc = FakeCrudder.new
+        fc.from table
+        im = fc.compile_insert [[table[:id], "foo"]]
+        assert_instance_of Arel::InsertManager, im
+      end
+    end
+
+    describe "update" do
+      it "should call update on the connection" do
+        table = Table.new :users
+        fc = FakeCrudder.new
+        fc.from table
+        stmt = fc.compile_update [[table[:id], "foo"]], Arel::Attributes::Attribute.new(table, "id")
+        assert_instance_of Arel::UpdateManager, stmt
+      end
+    end
+
+    describe "delete" do
+      it "should call delete on the connection" do
+        table = Table.new :users
+        fc = FakeCrudder.new
+        fc.from table
+        stmt = fc.compile_delete
+        assert_instance_of Arel::DeleteManager, stmt
+      end
+    end
+  end
+end

data/test/cases/arel/delete_manager_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+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
+      dm.take 10
+      dm.from table
+      dm.key = table[:id]
+      assert_match(/LIMIT 10/, dm.to_sql)
+    end
+
+    describe "from" do
+      it "uses from" do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new
+        dm.from table
+        _(dm.to_sql).must_be_like %{ DELETE FROM "users" }
+      end
+
+      it "chains" do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new
+        _(dm.from(table)).must_equal dm
+      end
+    end
+
+    describe "where" do
+      it "uses where values" do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new
+        dm.from table
+        dm.where table[:id].eq(10)
+        _(dm.to_sql).must_be_like %{ DELETE FROM "users" WHERE "users"."id" = 10}
+      end
+
+      it "chains" do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new
+        _(dm.where(table[:id].eq(10))).must_equal dm
+      end
+    end
+  end
+end

data/test/cases/arel/factory_methods_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Arel
+  module FactoryMethods
+    class TestFactoryMethods < Arel::Test
+      class Factory
+        include Arel::FactoryMethods
+      end
+
+      def setup
+        @factory = Factory.new
+      end
+
+      def test_create_join
+        join = @factory.create_join :one, :two
+        assert_kind_of Nodes::Join, join
+        assert_equal :two, join.right
+      end
+
+      def test_create_on
+        on = @factory.create_on :one
+        assert_instance_of Nodes::On, on
+        assert_equal :one, on.expr
+      end
+
+      def test_create_true
+        true_node = @factory.create_true
+        assert_instance_of Nodes::True, true_node
+      end
+
+      def test_create_false
+        false_node = @factory.create_false
+        assert_instance_of Nodes::False, false_node
+      end
+
+      def test_lower
+        lower = @factory.lower :one
+        assert_instance_of Nodes::NamedFunction, lower
+        assert_equal "LOWER", lower.name
+        assert_equal [:one], lower.expressions.map(&:expr)
+      end
+    end
+  end
+end

data/test/cases/arel/helper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "minitest/autorun"
+require "arel"
+
+require_relative "support/fake_record"
+
+Minitest::Expectation.class_eval do
+  def must_be_like(other)
+    self.class.new(target.gsub(/\s+/, " ").strip, ctx).must_equal other.gsub(/\s+/, " ").strip
+  end
+end
+
+module Arel
+  class Test < ActiveSupport::TestCase
+    def setup
+      super
+      @arel_engine = Arel::Table.engine
+      Arel::Table.engine = FakeRecord::Base.new
+    end
+
+    def teardown
+      Arel::Table.engine = @arel_engine if defined? @arel_engine
+      super
+    end
+  end
+
+  class Spec < Minitest::Spec
+    before do
+      @arel_engine = Arel::Table.engine
+      Arel::Table.engine = FakeRecord::Base.new
+    end
+
+    after do
+      Arel::Table.engine = @arel_engine if defined? @arel_engine
+    end
+    include ActiveSupport::Testing::Assertions
+
+    # test/unit backwards compatibility methods
+    alias :assert_no_match :refute_match
+    alias :assert_not_equal :refute_equal
+    alias :assert_not_same :refute_same
+  end
+end