ibm_db 5.6.1 → 5.7.0

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

@@ -22,12 +22,12 @@ module Arel
 
       describe "equality" do
         it "is equal with equal ivars" do
-          array = [Or.new("foo", "bar"), Or.new("foo", "bar")]
+          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")]
+          array = [Or.new(["foo", "bar"]), Or.new(["foo", "baz"])]
           assert_equal 2, array.uniq.size
         end
       end

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

@@ -7,7 +7,7 @@ module Arel
   module Nodes
     class SqlLiteralTest < Arel::Spec
       before do
-        @visitor = Visitors::ToSql.new Table.engine.connection
+        @visitor = Visitors::ToSql.new Table.engine.lease_connection
       end
 
       def compile(node)
@@ -70,6 +70,23 @@ module Arel
           assert_equal("foo", YAML.load(yaml_literal))
         end
       end
+
+      describe "addition" do
+        it "generates a Fragments node" do
+          sql1 = Arel.sql "SELECT *"
+          sql2 = Arel.sql "FROM users"
+          fragments = sql1 + sql2
+          _(fragments).must_be_kind_of Arel::Nodes::Fragments
+          assert_equal([sql1, sql2], fragments.values)
+        end
+
+        it "fails if joined with something that is not an Arel node" do
+          sql = Arel.sql "SELECT *"
+          assert_raises ArgumentError do
+            sql + "Not a node"
+          end
+        end
+      end
     end
   end
 end

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

@@ -24,6 +24,18 @@ module Arel
           assert_equal 2, array.uniq.size
         end
       end
+
+      describe "#to_cte" do
+        it "returns a Cte node using the TableAlias's name and relation" do
+          relation = Table.new(:users).project(Arel.star)
+          table_alias = TableAlias.new(relation, :foo)
+          cte = table_alias.to_cte
+
+          assert_kind_of Arel::Nodes::Cte, cte
+          assert_equal :foo, cte.name
+          assert_equal relation, cte.relation
+        end
+      end
     end
   end
 end

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

@@ -24,7 +24,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/update_statement_test.rb

@@ -27,6 +27,8 @@ describe Arel::Nodes::UpdateStatement do
       statement1.orders   = %w[x y z]
       statement1.limit    = 42
       statement1.key      = "zomg"
+      statement1.groups   = ["foo"]
+      statement1.havings  = []
       statement2 = Arel::Nodes::UpdateStatement.new
       statement2.relation = "zomg"
       statement2.wheres   = 2
@@ -34,6 +36,8 @@ describe Arel::Nodes::UpdateStatement do
       statement2.orders   = %w[x y z]
       statement2.limit    = 42
       statement2.key      = "zomg"
+      statement2.groups   = ["foo"]
+      statement2.havings  = []
       array = [statement1, statement2]
       assert_equal 1, array.uniq.size
     end

data/test/cases/arel/nodes_test.rb

@@ -16,11 +16,12 @@ module Arel
         node_descendants.delete(Arel::Nodes::NodeExpression)
 
         bad_node_descendants = node_descendants.reject do |subnode|
-          eqeq_owner = subnode.instance_method(:==).owner
+          eqeq_method = subnode.instance_method(:==)
+          eqeq_owner = eqeq_method.owner
           eql_owner = subnode.instance_method(:eql?).owner
           hash_owner = subnode.instance_method(:hash).owner
 
-          eqeq_owner < Arel::Nodes::Node &&
+          eqeq_method.super_method && # Not using the ruby default #== method
               eqeq_owner == eql_owner &&
               eqeq_owner == hash_owner
         end

data/test/cases/arel/select_manager_test.rb

@@ -338,13 +338,13 @@ module Arel
         replies            = Table.new(:replies)
         replies_id         = replies[:id]
 
-        recursive_term = Arel::SelectManager.new
-        recursive_term.from(comments).project(comments_id, comments_parent_id).where(comments_id.eq 42)
-
         non_recursive_term = Arel::SelectManager.new
-        non_recursive_term.from(comments).project(comments_id, comments_parent_id).join(replies).on(comments_parent_id.eq replies_id)
+        non_recursive_term.from(comments).project(comments_id, comments_parent_id).where(comments_id.eq 42)
+
+        recursive_term = Arel::SelectManager.new
+        recursive_term.from(comments).project(comments_id, comments_parent_id).join(replies).on(comments_parent_id.eq replies_id)
 
-        union = recursive_term.union(non_recursive_term)
+        union = non_recursive_term.union(recursive_term)
 
         as_statement = Arel::Nodes::As.new replies, union
 
@@ -963,16 +963,16 @@ module Arel
         _(manager.where_sql).must_be_like %{ WHERE "users"."id" = 10 AND "users"."id" = 11}
       end
 
-      it "handles database specific statements" do
-        old_visitor = Table.engine.connection.visitor
-        Table.engine.connection.visitor = Visitors::PostgreSQL.new Table.engine.connection
+      it "handles database-specific statements" do
+        old_visitor = Table.engine.lease_connection.visitor
+        Table.engine.lease_connection.visitor = Visitors::PostgreSQL.new Table.engine.lease_connection
         table   = Table.new :users
         manager = Arel::SelectManager.new
         manager.from table
         manager.where table[:id].eq 10
         manager.where table[:name].matches "foo%"
         _(manager.where_sql).must_be_like %{ WHERE "users"."id" = 10 AND "users"."name" ILIKE 'foo%' }
-        Table.engine.connection.visitor = old_visitor
+        Table.engine.lease_connection.visitor = old_visitor
       end
 
       it "returns nil when there are no wheres" do
@@ -1014,7 +1014,7 @@ module Arel
 
         _(stmt.to_sql).must_be_like %{
           UPDATE "users" SET foo = bar
-          WHERE "users"."id" IN (SELECT "users"."id" FROM "users" LIMIT 1)
+          WHERE ("users"."id") IN (SELECT "users"."id" FROM "users" LIMIT 1)
         }
       end
 
@@ -1028,7 +1028,7 @@ module Arel
 
         _(stmt.to_sql).must_be_like %{
           UPDATE "users" SET foo = bar
-          WHERE "users"."id" IN (SELECT "users"."id" FROM "users" ORDER BY foo)
+          WHERE ("users"."id") IN (SELECT "users"."id" FROM "users" ORDER BY foo)
         }
       end
 
@@ -1053,7 +1053,7 @@ module Arel
         stmt = manager.compile_update({ table[:id] => 1 }, Arel::Attributes::Attribute.new(table, "id"))
 
         _(stmt.to_sql).must_be_like %{
-          UPDATE "users" SET "id" = 1 WHERE "users"."id" IN (SELECT "users"."id" FROM "users" WHERE "users"."foo" = 10 LIMIT 42)
+          UPDATE "users" SET "id" = 1 WHERE ("users"."id") IN (SELECT "users"."id" FROM "users" WHERE "users"."foo" = 10 LIMIT 42)
         }
       end
     end

data/test/cases/arel/support/fake_record.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/enumerable"
-
 require "date"
+
 module FakeRecord
   class Column < Struct.new(:name, :type)
   end
@@ -11,7 +11,7 @@ module FakeRecord
     attr_reader :tables
     attr_accessor :visitor
 
-    def initialize(visitor = nil)
+    def initialize
       @tables = %w{ users photos developers products}
       @columns = {
         "users" => [
@@ -33,7 +33,7 @@ module FakeRecord
         "users" => "id",
         "products" => "id"
       }
-      @visitor = visitor
+      @visitor = Arel::Visitors::ToSql.new(self)
     end
 
     def columns_hash(table_name)
@@ -86,38 +86,39 @@ module FakeRecord
         "'#{thing.to_s.gsub("'", "\\\\'")}'"
       end
     end
-  end
 
-  class ConnectionPool
-    class Spec < Struct.new(:adapter, keyword_init: true)
+    def cast_bound_value(thing)
+      thing
     end
+  end
 
-    attr_reader :spec, :connection
-
+  class ConnectionPool
     def initialize
-      @spec = Spec.new(adapter: "america")
       @connection = Connection.new
-      @connection.visitor = Arel::Visitors::ToSql.new(connection)
+    end
+
+    def lease_connection
+      @connection
     end
 
     def with_connection
-      yield connection
+      yield @connection
     end
 
     def table_exists?(name)
-      connection.tables.include? name.to_s
+      @connection.tables.include? name.to_s
     end
 
     def columns_hash
-      connection.columns_hash
+      @connection.columns_hash
     end
 
     def schema_cache
-      connection
+      @connection
     end
 
     def quote(thing)
-      connection.quote thing
+      @connection.quote thing
     end
   end
 
@@ -128,8 +129,12 @@ module FakeRecord
       @connection_pool = ConnectionPool.new
     end
 
-    def connection
-      connection_pool.connection
+    def with_connection(...)
+      connection_pool.with_connection(...)
+    end
+
+    def lease_connection
+      connection_pool.lease_connection
     end
   end
 end

data/test/cases/arel/table_test.rb

@@ -8,12 +8,6 @@ module Arel
       @relation = Table.new(:users)
     end
 
-    it "should create join nodes" do
-      join = @relation.create_string_join "foo"
-      assert_kind_of Arel::Nodes::StringJoin, join
-      assert_equal "foo", join.left
-    end
-
     it "should create join nodes" do
       join = @relation.create_join "foo", "bar"
       assert_kind_of Arel::Nodes::InnerJoin, join
@@ -42,13 +36,6 @@ module Arel
       assert_equal "bar", join.right
     end
 
-    it "should return an insert manager" do
-      im = @relation.compile_insert "VALUES(NULL)"
-      assert_kind_of Arel::InsertManager, im
-      im.into Table.new(:users)
-      assert_equal "INSERT INTO \"users\" VALUES(NULL)", im.to_sql
-    end
-
     describe "skip" do
       it "should add an offset" do
         sm = @relation.skip 2
@@ -134,6 +121,17 @@ module Arel
         rel = Table.new :users, as: "users"
         _(rel.table_alias).must_be_nil
       end
+
+      it "should accept literal SQL"  do
+        rel = Table.new Arel.sql("generate_series(4, 2)")
+        assert_equal Arel.sql("generate_series(4, 2)"), rel.name
+      end
+
+      it "should accept Arel nodes"  do
+        node = Arel::Nodes::NamedFunction.new("generate_series", [4, 2])
+        rel = Table.new node
+        assert_equal node, rel.name
+      end
     end
 
     describe "order" do
@@ -180,10 +178,6 @@ module Arel
       _(@relation.name).must_equal "users"
     end
 
-    it "should have a table name" do
-      _(@relation.table_name).must_equal "users"
-    end
-
     describe "[]" do
       describe "when given a Symbol" do
         it "manufactures an attribute if the symbol names an attribute within the relation" do
@@ -195,19 +189,15 @@ module Arel
 
     describe "equality" do
       it "is equal with equal ivars" do
-        relation1 = Table.new(:users)
-        relation1.table_alias = "zomg"
-        relation2 = Table.new(:users)
-        relation2.table_alias = "zomg"
+        relation1 = Table.new(:users, as: "zomg")
+        relation2 = Table.new(:users, as: "zomg")
         array = [relation1, relation2]
         assert_equal 1, array.uniq.size
       end
 
       it "is not equal with different ivars" do
-        relation1 = Table.new(:users)
-        relation1.table_alias = "zomg"
-        relation2 = Table.new(:users)
-        relation2.table_alias = "zomg2"
+        relation1 = Table.new(:users, as: "zomg")
+        relation2 = Table.new(:users, as: "zomg2")
         array = [relation1, relation2]
         assert_equal 2, array.uniq.size
       end

data/test/cases/arel/update_manager_test.rb

@@ -4,12 +4,6 @@ require_relative "helper"
 
 module Arel
   class UpdateManagerTest < Arel::Spec
-    describe "new" do
-      it "takes an engine" do
-        Arel::UpdateManager.new
-      end
-    end
-
     it "should not quote sql literals" do
       table = Table.new(:users)
       um = Arel::UpdateManager.new
@@ -28,6 +22,57 @@ module Arel
       assert_match(/LIMIT 10/, um.to_sql)
     end
 
+    describe "having" do
+      it "sets having" do
+        users_table = Table.new(:users)
+        posts_table = Table.new(:posts)
+        join_source = Arel::Nodes::InnerJoin.new(users_table, posts_table)
+
+        update_manager = Arel::UpdateManager.new
+        update_manager.table(join_source)
+        update_manager.group(["posts.id"])
+        update_manager.having("count(posts.id) >= 2")
+
+        assert_equal(["count(posts.id) >= 2"], update_manager.ast.havings)
+      end
+    end
+
+    describe "group" do
+      it "adds columns to the AST when group value is a String" do
+        users_table = Table.new(:users)
+        posts_table = Table.new(:posts)
+        join_source = Arel::Nodes::InnerJoin.new(users_table, posts_table)
+
+        update_manager = Arel::UpdateManager.new
+        update_manager.table(join_source)
+        update_manager.group(["posts.id"])
+        update_manager.having("count(posts.id) >= 2")
+
+        assert_equal(1, update_manager.ast.groups.count)
+        group_ast = update_manager.ast.groups.first
+        _(group_ast).must_be_kind_of Nodes::Group
+        assert_equal("posts.id", group_ast.expr)
+        assert_equal(["count(posts.id) >= 2"], update_manager.ast.havings)
+      end
+
+      it "adds columns to the AST when group value is a Symbol" do
+        users_table = Table.new(:users)
+        posts_table = Table.new(:posts)
+        join_source = Arel::Nodes::InnerJoin.new(users_table, posts_table)
+
+        update_manager = Arel::UpdateManager.new
+        update_manager.table(join_source)
+        update_manager.group([:"posts.id"])
+        update_manager.having("count(posts.id) >= 2")
+
+        assert_equal(1, update_manager.ast.groups.count)
+        group_ast = update_manager.ast.groups.first
+        _(group_ast).must_be_kind_of Nodes::Group
+        assert_equal("posts.id", group_ast.expr)
+        assert_equal(["count(posts.id) >= 2"], update_manager.ast.havings)
+      end
+    end
+
     describe "set" do
       it "updates with null" do
         table = Table.new(:users)

data/test/cases/arel/visitors/dispatch_contamination_test.rb

@@ -40,7 +40,7 @@ module Arel
 
     class DispatchContaminationTest < Arel::Spec
       before do
-        @connection = Table.engine.connection
+        @connection = Table.engine.lease_connection
         @table = Table.new(:users)
       end
 

data/test/cases/arel/visitors/dot_test.rb

@@ -10,6 +10,10 @@ module Arel
         @visitor = Visitors::Dot.new
       end
 
+      def assert_edge(edge_name, dot_string)
+        assert_match(/->.*label="#{edge_name}"/, dot_string)
+      end
+
       # functions
       [
         Nodes::Sum,
@@ -21,12 +25,14 @@ module Arel
         define_method("test_#{klass.name.gsub('::', '_')}") do
           op = klass.new(:a, "z")
           @visitor.accept op, Collectors::PlainString.new
+          pass
         end
       end
 
       def test_named_function
         func = Nodes::NamedFunction.new "omg", "omg"
         @visitor.accept func, Collectors::PlainString.new
+        pass
       end
 
       # unary ops
@@ -44,6 +50,7 @@ module Arel
         define_method("test_#{klass.name.gsub('::', '_')}") do
           op = klass.new(:a)
           @visitor.accept op, Collectors::PlainString.new
+          pass
         end
       end
 
@@ -61,16 +68,27 @@ module Arel
         Arel::Nodes::Matches,
         Arel::Nodes::NotEqual,
         Arel::Nodes::NotIn,
-        Arel::Nodes::Or,
         Arel::Nodes::TableAlias,
         Arel::Nodes::As,
-        Arel::Nodes::DeleteStatement,
         Arel::Nodes::JoinSource,
         Arel::Nodes::Casted,
       ].each do |klass|
         define_method("test_#{klass.name.gsub('::', '_')}") do
           binary = klass.new(:a, :b)
           @visitor.accept binary, Collectors::PlainString.new
+          pass
+        end
+      end
+
+      # nary ops
+      [
+        Arel::Nodes::And,
+        Arel::Nodes::Or,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          binary = klass.new([:a, :b])
+          @visitor.accept binary, Collectors::PlainString.new
+          pass
         end
       end
 
@@ -85,6 +103,163 @@ module Arel
         collector = Collectors::PlainString.new
         assert_match '[label="<f0>ActiveModel::Attribute::WithCastValue"]', @visitor.accept(node, collector).value
       end
+
+      def test_Arel_Nodes_CurrentRow
+        node = Arel::Nodes::CurrentRow.new
+        collector = Collectors::PlainString.new
+        assert_match '[label="<f0>Arel::Nodes::CurrentRow"]', @visitor.accept(node, collector).value
+      end
+
+      def test_Arel_Nodes_Distinct
+        node = Arel::Nodes::Distinct.new
+        collector = Collectors::PlainString.new
+        assert_match '[label="<f0>Arel::Nodes::Distinct"]', @visitor.accept(node, collector).value
+      end
+
+      def test_Arel_Nodes_Case_and_friends
+        foo = Arel::Nodes.build_quoted("foo")
+        node = Arel::Nodes::Case.new(foo)
+        node.conditions = [Arel::Nodes::When.new(foo, Arel::Nodes.build_quoted(1))]
+        node.default = Arel::Nodes::Else.new(Arel::Nodes.build_quoted(0))
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::Case"]', dot
+        assert_edge("case", dot)
+        assert_edge("conditions", dot)
+        assert_edge("default", dot)
+        assert_match '[label="<f0>Arel::Nodes::When"]', dot
+        assert_match '[label="<f0>Arel::Nodes::Else"]', dot
+        assert_match '[label="<f0>Arel::Nodes::Else"]', dot
+      end
+
+      def test_Arel_Nodes_InfixOperation
+        node = Arel::Nodes::InfixOperation.new("&&", Arel::Nodes.build_quoted(1), Arel::Nodes.build_quoted(2))
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::InfixOperation"]', dot
+        assert_edge("operator", dot)
+        assert_edge("left", dot)
+        assert_edge("right", dot)
+      end
+
+      def test_Arel_Nodes_RegExp
+        table = Table.new(:users)
+        node = Arel::Nodes::Regexp.new(table[:name], Nodes.build_quoted("foo%"))
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::Regexp"]', dot
+        assert_edge("left", dot)
+        assert_edge("right", dot)
+        assert_edge("case_sensitive", dot)
+      end
+
+      def test_Arel_Nodes_NotRegExp
+        table = Table.new(:users)
+        node = Arel::Nodes::NotRegexp.new(table[:name], Nodes.build_quoted("foo%"))
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::NotRegexp"]', dot
+        assert_edge("left", dot)
+        assert_edge("right", dot)
+        assert_edge("case_sensitive", dot)
+      end
+
+      def test_Arel_Nodes_UnaryOperation
+        node = Arel::Nodes::UnaryOperation.new(:-, 1)
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::UnaryOperation"]', dot
+        assert_edge("operator", dot)
+        assert_edge("expr", dot)
+      end
+
+      def test_Arel_Nodes_With
+        node = Arel::Nodes::With.new(["query1", "query2", "query3"])
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::With"]', dot
+        assert_edge("0", dot)
+        assert_edge("1", dot)
+        assert_edge("2", dot)
+      end
+
+      def test_Arel_Nodes_SelectCore
+        node = Arel::Nodes::SelectCore.new
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::SelectCore"]', dot
+        assert_edge("source", dot)
+        assert_edge("projections", dot)
+        assert_edge("wheres", dot)
+        assert_edge("windows", dot)
+        assert_edge("groups", dot)
+        assert_edge("comment", dot)
+        assert_edge("havings", dot)
+        assert_edge("set_quantifier", dot)
+        assert_edge("optimizer_hints", dot)
+      end
+
+      def test_Arel_Nodes_SelectStatement
+        node = Arel::Nodes::SelectStatement.new
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::SelectStatement"]', dot
+        assert_edge("cores", dot)
+        assert_edge("limit", dot)
+        assert_edge("orders", dot)
+        assert_edge("offset", dot)
+        assert_edge("lock", dot)
+        assert_edge("with", dot)
+      end
+
+      def test_Arel_Nodes_InsertStatement
+        node = Arel::Nodes::InsertStatement.new
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::InsertStatement"]', dot
+        assert_edge("relation", dot)
+        assert_edge("columns", dot)
+        assert_edge("values", dot)
+        assert_edge("select", dot)
+      end
+
+      def test_Arel_Nodes_UpdateStatement
+        node = Arel::Nodes::UpdateStatement.new
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::UpdateStatement"]', dot
+        assert_edge("relation", dot)
+        assert_edge("wheres", dot)
+        assert_edge("values", dot)
+        assert_edge("orders", dot)
+        assert_edge("limit", dot)
+        assert_edge("offset", dot)
+        assert_edge("key", dot)
+      end
+
+      def test_Arel_Nodes_DeleteStatement
+        node = Arel::Nodes::DeleteStatement.new
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::DeleteStatement"]', dot
+        assert_edge("relation", dot)
+        assert_edge("wheres", dot)
+        assert_edge("orders", dot)
+        assert_edge("limit", dot)
+        assert_edge("offset", dot)
+        assert_edge("key", dot)
+      end
     end
   end
 end