ibm_db 5.6.1 → 5.7.0

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

@@ -6,7 +6,7 @@ module Arel
   module Visitors
     class MysqlTest < Arel::Spec
       before do
-        @visitor = MySQL.new Table.engine.connection
+        @visitor = MySQL.new Table.engine.lease_connection
       end
 
       def compile(node)
@@ -152,6 +152,54 @@ module Arel
           }
         end
       end
+
+      describe "Nodes::Ordering" do
+        it "should handle nulls first" do
+          test = Table.new(:users)[:first_name].asc.nulls_first
+          _(compile(test)).must_be_like %{
+            "users"."first_name" IS NOT NULL, "users"."first_name" ASC
+          }
+        end
+
+        it "should handle nulls last" do
+          test = Table.new(:users)[:first_name].asc.nulls_last
+          _(compile(test)).must_be_like %{
+            "users"."first_name" IS NULL, "users"."first_name" ASC
+          }
+        end
+
+        it "should handle nulls first reversed" do
+          test = Table.new(:users)[:first_name].asc.nulls_first.reverse
+          _(compile(test)).must_be_like %{
+            "users"."first_name" IS NULL, "users"."first_name" DESC
+          }
+        end
+
+        it "should handle nulls last reversed" do
+          test = Table.new(:users)[:first_name].asc.nulls_last.reverse
+          _(compile(test)).must_be_like %{
+            "users"."first_name" IS NOT NULL, "users"."first_name" DESC
+          }
+        end
+      end
+
+      describe "Nodes::Cte" do
+        it "ignores MATERIALIZED modifiers" do
+          cte = Nodes::Cte.new("foo", Table.new(:bar).project(Arel.star), materialized: true)
+
+          _(compile(cte)).must_be_like %{
+            "foo" AS (SELECT * FROM "bar")
+          }
+        end
+
+        it "ignores NOT MATERIALIZED modifiers" do
+          cte = Nodes::Cte.new("foo", Table.new(:bar).project(Arel.star), materialized: false)
+
+          _(compile(cte)).must_be_like %{
+            "foo" AS (SELECT * FROM "bar")
+          }
+        end
+      end
     end
   end
 end

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

@@ -6,7 +6,7 @@ module Arel
   module Visitors
     class PostgresTest < Arel::Spec
       before do
-        @visitor = PostgreSQL.new Table.engine.connection
+        @visitor = PostgreSQL.new Table.engine.lease_connection
         @table = Table.new(:users)
         @attr = @table[:id]
       end
@@ -316,36 +316,6 @@ module Arel
         end
       end
 
-      describe "Nodes::Ordering" do
-        it "should handle nulls first" do
-          test = Table.new(:users)[:first_name].desc.nulls_first
-          _(compile(test)).must_be_like %{
-            "users"."first_name" DESC NULLS FIRST
-          }
-        end
-
-        it "should handle nulls last" do
-          test = Table.new(:users)[:first_name].desc.nulls_last
-          _(compile(test)).must_be_like %{
-            "users"."first_name" DESC NULLS LAST
-          }
-        end
-
-        it "should handle nulls first reversed" do
-          test = Table.new(:users)[:first_name].desc.nulls_first.reverse
-          _(compile(test)).must_be_like %{
-            "users"."first_name" ASC NULLS LAST
-          }
-        end
-
-        it "should handle nulls last reversed" do
-          test = Table.new(:users)[:first_name].desc.nulls_last.reverse
-          _(compile(test)).must_be_like %{
-            "users"."first_name" ASC NULLS FIRST
-          }
-        end
-      end
-
       describe "Nodes::InfixOperation" do
         it "should handle Contains" do
           inner = Nodes.build_quoted('{"foo":"bar"}')

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

@@ -6,7 +6,7 @@ module Arel
   module Visitors
     class SqliteTest < Arel::Spec
       before do
-        @visitor = SQLite.new Table.engine.connection
+        @visitor = SQLite.new Table.engine.lease_connection
       end
 
       def compile(node)

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

@@ -8,7 +8,7 @@ module Arel
     describe "the to_sql visitor" do
       before do
         @conn = FakeRecord::Base.new
-        @visitor = ToSql.new @conn.connection
+        @visitor = ToSql.new @conn.lease_connection
         @table = Table.new(:users)
         @attr = @table[:id]
       end
@@ -69,6 +69,81 @@ module Arel
         _(sql).must_be_like %{ omg(*) IS NULL }
       end
 
+      it "should mark collector as non-retryable when visiting named function" do
+        function = Nodes::NamedFunction.new("ABS", [@table])
+        collector = Collectors::SQLString.new
+        collector.retryable = true
+        @visitor.accept(function, collector)
+
+        assert_equal false, collector.retryable
+      end
+
+      it "should mark collector as non-retryable when visiting SQL literal" do
+        node = Nodes::SqlLiteral.new("COUNT(*)")
+        collector = Collectors::SQLString.new
+        collector.retryable = true
+        @visitor.accept(node, collector)
+
+        assert_equal false, collector.retryable
+      end
+
+      it "should not change retryable if SQL literal is marked as retryable" do
+        node = Nodes::SqlLiteral.new("COUNT(*)", retryable: true)
+        collector = Collectors::SQLString.new
+        collector.retryable = true
+        @visitor.accept(node, collector)
+
+        assert_predicate collector, :retryable
+      end
+
+      it "should mark collector as non-retryable if SQL literal is not retryable" do
+        node = Nodes::As.new(
+          Nodes::SqlLiteral.new("`product.id`"),
+          Nodes::SqlLiteral.new("`product.id`", retryable: true)
+        )
+        collector = Collectors::SQLString.new
+        collector.retryable = true
+        @visitor.accept(node, collector)
+
+        assert_equal false, collector.retryable
+      end
+
+      it "should mark collector as non-retryable when visiting bound SQL literal" do
+        node = Nodes::BoundSqlLiteral.new("id IN (?)", [[1, 2, 3]], {})
+        collector = Collectors::SQLString.new
+        collector.retryable = true
+        @visitor.accept(node, collector)
+
+        assert_equal false, collector.retryable
+      end
+
+      it "should mark collector as non-retryable when visiting insert statement node" do
+        statement = Arel::Nodes::InsertStatement.new(@table)
+        collector = Collectors::SQLString.new
+        collector.retryable = true
+        @visitor.accept(statement, collector)
+
+        assert_equal false, collector.retryable
+      end
+
+      it "should mark collector as non-retryable when visiting update statement node" do
+        statement = Arel::Nodes::UpdateStatement.new(@table)
+        collector = Collectors::SQLString.new
+        collector.retryable = true
+        @visitor.accept(statement, collector)
+
+        assert_equal false, collector.retryable
+      end
+
+      it "should mark collector as non-retryable when visiting delete statement node" do
+        statement = Arel::Nodes::DeleteStatement.new(@table)
+        collector = Collectors::SQLString.new
+        collector.retryable = true
+        @visitor.accept(statement, collector)
+
+        assert_equal false, collector.retryable
+      end
+
       it "should visit built-in functions" do
         function = Nodes::Count.new([Arel.star])
         assert_equal "COUNT(*)", compile(function)
@@ -305,7 +380,7 @@ module Arel
       end
 
       it "should visit_Arel_Nodes_Or" do
-        node = Nodes::Or.new @attr.eq(10), @attr.eq(11)
+        node = Nodes::Or.new [@attr.eq(10), @attr.eq(11)]
         _(compile(node)).must_be_like %{
           "users"."id" = 10 OR "users"."id" = 11
         }
@@ -322,11 +397,6 @@ module Arel
         }
       end
 
-      it "should visit visit_Arel_Attributes_Time" do
-        attr = Attributes::Time.new(@attr.relation, @attr.name)
-        compile attr
-      end
-
       it "should visit_TrueClass" do
         test = Table.new(:users)[:bool].eq(true)
         _(compile(test)).must_be_like %{ "users"."bool" = 't' }
@@ -387,6 +457,34 @@ module Arel
             "users"."id" DESC
           }
         end
+
+        it "should handle nulls first" do
+          node = @attr.desc.nulls_first
+          _(compile(node)).must_be_like %{
+            "users"."id" DESC NULLS FIRST
+          }
+        end
+
+        it "should handle nulls last" do
+          node = @attr.desc.nulls_last
+          _(compile(node)).must_be_like %{
+            "users"."id" DESC NULLS LAST
+          }
+        end
+
+        it "should handle nulls first reversed" do
+          node = @attr.desc.nulls_first.reverse
+          _(compile(node)).must_be_like %{
+            "users"."id" ASC NULLS LAST
+          }
+        end
+
+        it "should handle nulls last reversed" do
+          node = @attr.desc.nulls_last.reverse
+          _(compile(node)).must_be_like %{
+            "users"."id" ASC NULLS FIRST
+          }
+        end
       end
 
       describe "Nodes::In" do
@@ -441,26 +539,44 @@ module Arel
             "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
           }
         end
+
+        it "is not preparable when an array" do
+          node = @attr.in [1, 2, 3]
+
+          collector = Collectors::SQLString.new.tap { |c| c.preparable = true }
+          @visitor.accept(node, collector)
+          _(collector.preparable).must_equal false
+        end
+
+        it "is preparable when a subselect" do
+          table = Table.new(:users)
+          subquery = table.project(table[:id]).where(table[:name].eq("Aaron"))
+          node = @attr.in subquery
+
+          collector = Collectors::SQLString.new.tap { |c| c.preparable = true }
+          @visitor.accept(node, collector)
+          _(collector.preparable).must_equal true
+        end
       end
 
       describe "Nodes::InfixOperation" do
         it "should handle Multiplication" do
-          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) * Arel::Attributes::Decimal.new(Table.new(:currency_rates), :rate)
+          node = Arel::Attribute.new(Table.new(:products), :price) * Arel::Attribute.new(Table.new(:currency_rates), :rate)
           _(compile(node)).must_equal %("products"."price" * "currency_rates"."rate")
         end
 
         it "should handle Division" do
-          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) / 5
+          node = Arel::Attribute.new(Table.new(:products), :price) / 5
           _(compile(node)).must_equal %("products"."price" / 5)
         end
 
         it "should handle Addition" do
-          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) + 6
+          node = Arel::Attribute.new(Table.new(:products), :price) + 6
           _(compile(node)).must_equal %(("products"."price" + 6))
         end
 
         it "should handle Subtraction" do
-          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) - 7
+          node = Arel::Attribute.new(Table.new(:products), :price) - 7
           _(compile(node)).must_equal %(("products"."price" - 7))
         end
 
@@ -483,35 +599,35 @@ module Arel
         end
 
         it "should handle BitwiseAnd" do
-          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) & 16
+          node = Arel::Attribute.new(Table.new(:products), :bitmap) & 16
           _(compile(node)).must_equal %(("products"."bitmap" & 16))
         end
 
         it "should handle BitwiseOr" do
-          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) | 16
+          node = Arel::Attribute.new(Table.new(:products), :bitmap) | 16
           _(compile(node)).must_equal %(("products"."bitmap" | 16))
         end
 
         it "should handle BitwiseXor" do
-          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) ^ 16
+          node = Arel::Attribute.new(Table.new(:products), :bitmap) ^ 16
           _(compile(node)).must_equal %(("products"."bitmap" ^ 16))
         end
 
         it "should handle BitwiseShiftLeft" do
-          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) << 4
+          node = Arel::Attribute.new(Table.new(:products), :bitmap) << 4
           _(compile(node)).must_equal %(("products"."bitmap" << 4))
         end
 
         it "should handle BitwiseShiftRight" do
-          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) >> 4
+          node = Arel::Attribute.new(Table.new(:products), :bitmap) >> 4
           _(compile(node)).must_equal %(("products"."bitmap" >> 4))
         end
 
         it "should handle arbitrary operators" do
           node = Arel::Nodes::InfixOperation.new(
             "&&",
-            Arel::Attributes::String.new(Table.new(:products), :name),
-            Arel::Attributes::String.new(Table.new(:products), :name)
+            Arel::Attribute.new(Table.new(:products), :name),
+            Arel::Attribute.new(Table.new(:products), :name)
           )
           _(compile(node)).must_equal %("products"."name" && "products"."name")
         end
@@ -519,12 +635,12 @@ module Arel
 
       describe "Nodes::UnaryOperation" do
         it "should handle BitwiseNot" do
-          node = ~ Arel::Attributes::Integer.new(Table.new(:products), :bitmap)
+          node = ~ Arel::Attribute.new(Table.new(:products), :bitmap)
           _(compile(node)).must_equal %( ~ "products"."bitmap")
         end
 
         it "should handle arbitrary operators" do
-          node = Arel::Nodes::UnaryOperation.new("!", Arel::Attributes::String.new(Table.new(:products), :active))
+          node = Arel::Nodes::UnaryOperation.new("!", Arel::Attribute.new(Table.new(:products), :active))
           _(compile(node)).must_equal %( ! "products"."active")
         end
       end
@@ -538,6 +654,14 @@ module Arel
           node = Nodes::Union.new Arel.sql("topleft"), subnode
           assert_equal("( topleft UNION left UNION right )", compile(node))
         end
+
+        it "encloses SELECT statements with parentheses" do
+          table = Table.new(:users)
+          left = table.where(table[:name].eq(0)).take(1).ast
+          right = table.where(table[:name].eq(1)).take(1).ast
+          node = Nodes::Union.new left, right
+          assert_match(/LIMIT 1\) UNION \(/, compile(node))
+        end
       end
 
       describe "Nodes::UnionAll" do
@@ -549,6 +673,14 @@ module Arel
           node = Nodes::UnionAll.new Arel.sql("topleft"), subnode
           assert_equal("( topleft UNION ALL left UNION ALL right )", compile(node))
         end
+
+        it "encloses SELECT statements with parentheses" do
+          table = Table.new(:users)
+          left = table.where(table[:name].eq(0)).take(1).ast
+          right = table.where(table[:name].eq(1)).take(1).ast
+          node = Nodes::UnionAll.new left, right
+          assert_match(/LIMIT 1\) UNION ALL \(/, compile(node))
+        end
       end
 
       describe "Nodes::NotIn" do
@@ -603,6 +735,24 @@ module Arel
             "users"."id" NOT IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
           }
         end
+
+        it "is not preparable when an array" do
+          node = @attr.not_in [1, 2, 3]
+
+          collector = Collectors::SQLString.new.tap { |c| c.preparable = true }
+          @visitor.accept(node, collector)
+          _(collector.preparable).must_equal false
+        end
+
+        it "is preparable when a subselect" do
+          table = Table.new(:users)
+          subquery = table.project(table[:id]).where(table[:name].eq("Aaron"))
+          node = @attr.not_in subquery
+
+          collector = Collectors::SQLString.new.tap { |c| c.preparable = true }
+          @visitor.accept(node, collector)
+          _(collector.preparable).must_equal true
+        end
       end
 
       describe "Constants" do
@@ -621,6 +771,113 @@ module Arel
         end
       end
 
+      describe "Nodes::BoundSqlLiteral" do
+        it "works with positional binds" do
+          node = Nodes::BoundSqlLiteral.new("id = ?", [1], {})
+          _(compile(node)).must_be_like %{
+            id = ?
+          }
+        end
+
+        it "works with named binds" do
+          node = Nodes::BoundSqlLiteral.new("id = :id", [], { id: 1 })
+          _(compile(node)).must_be_like %{
+            id = ?
+          }
+        end
+
+        it "will only consider named binds starting with a letter" do
+          node = Nodes::BoundSqlLiteral.new("id = :0abc", [], { "0abc": 1 })
+          _(compile(node)).must_be_like %{
+            id = :0abc
+          }
+        end
+
+        it "works with array values" do
+          node = Nodes::BoundSqlLiteral.new("id IN (?)", [[1, 2, 3]], {})
+          _(compile(node)).must_be_like %{
+            id IN (?, ?, ?)
+          }
+        end
+
+        it "refuses mixed binds" do
+          assert_raises(Arel::BindError) do
+            Nodes::BoundSqlLiteral.new("id = ? AND name = :name", [1], { name: "Aaron" })
+          end
+        end
+
+        it "requires positional binds to match the placeholders" do
+          assert_raises(Arel::BindError) do
+            Nodes::BoundSqlLiteral.new("id IN (?, ?, ?)", [1, 2], {})
+          end
+
+          assert_raises(Arel::BindError) do
+            Nodes::BoundSqlLiteral.new("id IN (?, ?, ?)", [1, 2, 3, 4], {})
+          end
+        end
+
+        it "requires all named bind params to be supplied" do
+          assert_raises(Arel::BindError) do
+            Nodes::BoundSqlLiteral.new("id IN (:foo, :bar)", [], { foo: 1 })
+          end
+        end
+
+        it "ignores excess named parameters" do
+          node = Nodes::BoundSqlLiteral.new("id = :id", [], { foo: 2, id: 1, bar: 3 })
+          _(compile(node)).must_be_like %{
+            id = ?
+          }
+        end
+
+        it "quotes nested arrays" do
+          # Two cases to exercise all branches.
+          # For real adapters, quoting arrays may fail in adapter-specific ways.
+
+          inner_literal = Nodes::BoundSqlLiteral.new("? * 2", [4], {})
+          node = Nodes::BoundSqlLiteral.new("id IN (?)", [[1, [2, 3], inner_literal]], {})
+          _(compile(node)).must_be_like %{
+            id IN (?, ?, ? * 2)
+          }
+
+          node = Nodes::BoundSqlLiteral.new("id IN (?)", [[1, [2, 3]]], {})
+          _(compile(node)).must_be_like %{
+            id IN (?, ?)
+          }
+        end
+
+        it "supports other bound literals as binds" do
+          node = Arel.sql("?", [1, 2, Arel.sql("?", 3)])
+          _(compile(node)).must_be_like %{
+            ?, ?, ?
+          }
+        end
+      end
+
+      describe "Table" do
+        it "should compile node names" do
+          test = Table.new(:users).alias("zomgusers")[:id].eq "3"
+          _(compile(test)).must_be_like %{
+            "zomgusers"."id" = '3'
+          }
+        end
+
+        it "should compile literal SQL"  do
+          test = Table.new Arel.sql("generate_series(4, 2)")
+          _(compile(test)).must_be_like %{ generate_series(4, 2) }
+        end
+
+        it "should compile Arel nodes"  do
+          test = Arel::Nodes::NamedFunction.new("generate_series", [4, 2])
+          _(compile(test)).must_be_like %{ generate_series(4, 2) }
+        end
+
+        it "should compile nodes with bind params" do
+          bp = Nodes::BindParam.new(1)
+          test = Arel::Nodes::NamedFunction.new("generate_series", [4, bp])
+          _(compile(test)).must_be_like %{ generate_series(4, ?) }
+        end
+      end
+
       describe "TableAlias" do
         it "should use the underlying table for checking columns" do
           test = Table.new(:users).alias("zomgusers")[:id].eq "3"
@@ -732,6 +989,19 @@ module Arel
             WITH expr1 AS (SELECT * FROM "bar"), expr2 AS (SELECT * FROM "baz") SELECT * FROM expr2
           }
         end
+
+        it "handles Cte nodes" do
+          cte = Arel::Nodes::Cte.new("expr1", Table.new(:bar).project(Arel.star))
+          manager = Table.new(:foo).
+            project(Arel.star).
+            with(cte).
+            from(cte.to_table).
+            where(cte.to_table[:score].gt(5))
+
+          _(compile(manager.ast)).must_be_like %{
+            WITH "expr1" AS (SELECT * FROM "bar") SELECT * FROM "expr1" WHERE "expr1"."score" > 5
+          }
+        end
       end
 
       describe "Nodes::WithRecursive" do
@@ -745,6 +1015,46 @@ module Arel
           }
         end
       end
+
+      describe "Nodes::Cte" do
+        it "handles CTEs with no MATERIALIZED modifier" do
+          cte = Nodes::Cte.new("foo", Table.new(:bar).project(Arel.star))
+
+          _(compile(cte)).must_be_like %{
+            "foo" AS (SELECT * FROM "bar")
+          }
+        end
+
+        it "handles CTEs with a MATERIALIZED modifier" do
+          cte = Nodes::Cte.new("foo", Table.new(:bar).project(Arel.star), materialized: true)
+
+          _(compile(cte)).must_be_like %{
+            "foo" AS MATERIALIZED (SELECT * FROM "bar")
+          }
+        end
+
+        it "handles CTEs with a NOT MATERIALIZED modifier" do
+          cte = Nodes::Cte.new("foo", Table.new(:bar).project(Arel.star), materialized: false)
+
+          _(compile(cte)).must_be_like %{
+            "foo" AS NOT MATERIALIZED (SELECT * FROM "bar")
+          }
+        end
+      end
+
+      describe "Nodes::Fragments" do
+        it "joins subexpressions" do
+          sql = Arel.sql("SELECT foo, bar") + Arel.sql(" FROM customers")
+          _(compile(sql)).must_be_like "SELECT foo, bar FROM customers"
+        end
+
+        it "can be built by adding SQL fragments one at a time" do
+          sql = Arel.sql("SELECT foo, bar")
+          sql += Arel.sql("FROM customers")
+          sql += Arel.sql("GROUP BY foo")
+          _(compile(sql)).must_be_like "SELECT foo, bar FROM customers GROUP BY foo"
+        end
+      end
     end
   end
 end