Upgrade to plk 0.14.6 + add UNION support

build.gradle.kts

@@ -25,7 +25,7 @@ object Versions {
     const val jline = "3.21.0"
     const val junit5 = "5.9.3"
     const val picoCli = "4.7.0"
-    const val partiql = "0.14.5"
+    const val partiql = "0.14.6"
 }
 
 object Deps {

src/main/kotlin/org/partiql/scribe/shell/ShellHighlighter.kt

@@ -13,18 +13,18 @@
  */
 package org.partiql.scribe.shell
 
-import org.antlr.v4.runtime.BaseErrorListener
-import org.antlr.v4.runtime.CharStreams
-import org.antlr.v4.runtime.CommonTokenStream
-import org.antlr.v4.runtime.RecognitionException
-import org.antlr.v4.runtime.Recognizer
 import org.jline.reader.Highlighter
 import org.jline.reader.LineReader
 import org.jline.utils.AttributedString
 import org.jline.utils.AttributedStringBuilder
 import org.jline.utils.AttributedStyle
 import org.partiql.parser.antlr.PartiQLParser
 import org.partiql.parser.antlr.PartiQLTokens
+import org.partiql.parser.thirdparty.antlr.v4.runtime.BaseErrorListener
+import org.partiql.parser.thirdparty.antlr.v4.runtime.CharStreams
+import org.partiql.parser.thirdparty.antlr.v4.runtime.CommonTokenStream
+import org.partiql.parser.thirdparty.antlr.v4.runtime.RecognitionException
+import org.partiql.parser.thirdparty.antlr.v4.runtime.Recognizer
 import java.nio.charset.StandardCharsets
 import java.util.regex.Pattern
 
@@ -127,12 +127,12 @@ internal class ShellHighlighter : Highlighter {
             msg: String?,
             e: RecognitionException?
         ) {
-            if (offendingSymbol != null && offendingSymbol is org.antlr.v4.runtime.Token && offendingSymbol.type != PartiQLParser.EOF) {
+            if (offendingSymbol != null && offendingSymbol is org.partiql.parser.thirdparty.antlr.v4.runtime.Token && offendingSymbol.type != PartiQLParser.EOF) {
                 throw OffendingSymbolException(offendingSymbol)
             }
         }
 
-        class OffendingSymbolException(val offendingSymbol: org.antlr.v4.runtime.Token) : Exception()
+        class OffendingSymbolException(val offendingSymbol: org.partiql.parser.thirdparty.antlr.v4.runtime.Token) : Exception()
     }
 
     private fun getTokenStream(input: String): CommonTokenStream {

src/main/kotlin/org/partiql/scribe/sql/RexConverter.kt

@@ -3,7 +3,9 @@ package org.partiql.scribe.sql
 import org.partiql.ast.Expr
 import org.partiql.ast.Identifier
 import org.partiql.ast.Select
+import org.partiql.ast.SetOp
 import org.partiql.ast.SetQuantifier
+import org.partiql.ast.exprBagOp
 import org.partiql.ast.exprCall
 import org.partiql.ast.exprCase
 import org.partiql.ast.exprCaseBranch
@@ -21,9 +23,11 @@ import org.partiql.ast.selectProject
 import org.partiql.ast.selectProjectItemAll
 import org.partiql.ast.selectProjectItemExpression
 import org.partiql.ast.selectValue
+import org.partiql.ast.setOp
 import org.partiql.plan.PlanNode
 import org.partiql.plan.Rel
 import org.partiql.plan.Rex
+import org.partiql.plan.rexOpSelect
 import org.partiql.plan.visitor.PlanBaseVisitor
 import org.partiql.types.BagType
 import org.partiql.types.ListType
@@ -206,19 +210,74 @@ public open class RexConverter(
         return transform.getFunction(name, args)
     }
 
+    private fun planToAstSetQ(setQuantifier: org.partiql.plan.SetQuantifier?): org.partiql.ast.SetQuantifier {
+        return when (setQuantifier) {
+            null, org.partiql.plan.SetQuantifier.DISTINCT -> SetQuantifier.DISTINCT
+            org.partiql.plan.SetQuantifier.ALL -> SetQuantifier.ALL
+        }
+    }
+
+    /**
+     * Create an ast [Expr.BagOp] from two plan [Rel] nodes (coming from a plan SQL set op).
+     */
+    private fun relSetOpToBagOp(lhs: Rel, rhs: Rel, setq: org.partiql.plan.SetQuantifier, opType: SetOp.Type, ctx: StaticType): Expr.BagOp {
+        // Since the args to a SQL set op are both SFW queries, re-create an [Expr.SFW]
+        val lhsRex = rexOpSelect(
+            constructor = Rex(
+                type = lhs.type.schema.first().type.asOrderedStruct(),
+                Rex.Op.Var(0)
+            ),
+            rel = lhs
+        )
+        val lhsExpr = visitRexOp(node = lhsRex, ctx = ctx)
+        val rhsRex = rexOpSelect(
+            constructor = Rex(
+                type = rhs.type.schema.first().type.asOrderedStruct(),
+                Rex.Op.Var(0)
+            ),
+            rel = rhs
+        )
+        val rhsExpr = visitRexOp(node = rhsRex, ctx = ctx)
+        return exprBagOp(
+            type = setOp(type = opType, setq = planToAstSetQ(setq)),
+            lhs = lhsExpr,
+            rhs = rhsExpr,
+            outer = false
+        )
+    }
+
+    // Adds the [TupleConstraint.Ordered] for [StructType]s
+    private fun StaticType.asOrderedStruct(): StaticType {
+        return when (this) {
+            is StructType -> this.copy(
+                constraints = this.constraints + setOf(TupleConstraint.Ordered)
+            )
+            else -> this
+        }
+    }
+
     override fun visitRexOpSelect(node: Rex.Op.Select, ctx: StaticType): Expr {
-        val relToSql = transform.getRelConverter()
-        val rexToSql = transform.getRexConverter(locals)
-        val sfw = relToSql.apply(node.rel)
-        assert(sfw.select != null) { "SELECT from RelConverter should never be null" }
-        val setq = getSetQuantifier(sfw.select!!)
-        val select = convertSelectValueToSqlSelect(sfw.select, node.constructor, node.rel, setq) ?: convertSelectValue(
-            node.constructor,
-            node.rel,
-            setq
-        ) ?: selectValue(rexToSql.apply(node.constructor), setq)
-        sfw.select = select
-        return sfw.build()
+        val rel = node.rel
+        return when (val op = rel.op) {
+            // SQL sets modeled as a Rel node taking in two Rels
+            is Rel.Op.Except -> relSetOpToBagOp(op.lhs, op.rhs, op.setq, SetOp.Type.EXCEPT, ctx)
+            is Rel.Op.Intersect -> relSetOpToBagOp(op.lhs, op.rhs, op.setq, SetOp.Type.INTERSECT, ctx)
+            is Rel.Op.Union -> relSetOpToBagOp(op.lhs, op.rhs, op.setq, SetOp.Type.UNION, ctx)
+            else -> {
+                val relToSql = transform.getRelConverter()
+                val rexToSql = transform.getRexConverter(locals)
+                val sfw = relToSql.apply(rel)
+                assert(sfw.select != null) { "SELECT from RelConverter should never be null" }
+                val setq = getSetQuantifier(sfw.select!!)
+                val select = convertSelectValueToSqlSelect(sfw.select, node.constructor, node.rel, setq) ?: convertSelectValue(
+                    node.constructor,
+                    node.rel,
+                    setq
+                ) ?: selectValue(rexToSql.apply(node.constructor), setq)
+                sfw.select = select
+                return sfw.build()
+            }
+        }
     }
 
     override fun visitRexOpSubquery(node: Rex.Op.Subquery, ctx: StaticType): Expr {

src/main/kotlin/org/partiql/scribe/sql/SqlDialect.kt

@@ -89,6 +89,13 @@ abstract class SqlDialect : AstBaseVisitor<SqlBlock, SqlBlock>() {
             t = t concat ")"
             t
         }
+        node is Expr.BagOp -> {
+            var t = tail
+            t = t concat "("
+            t = visitExprBagOp(node, t)
+            t = t concat ")"
+            t
+        }
         else -> visitExpr(node, tail)
     }
 

src/main/kotlin/org/partiql/scribe/targets/redshift/RedshiftFeatures.kt

@@ -24,6 +24,7 @@ public open class RedshiftFeatures : SqlFeatures.Defensive() {
         Rel.Op.Exclude::class.java,
         Rel.Op.Exclude.Item::class.java,
         Rel.Op.Exclude.Step.StructField::class.java,
+        Rel.Op.Union::class.java,
         // Do not support Rel.Op.Exclude.Step.CollWildcard -- currently, no efficient way to reconstruct SUPER ARRAYs
         //
         // Rex

src/main/kotlin/org/partiql/scribe/targets/spark/SparkFeatures.kt

@@ -22,6 +22,7 @@ public open class SparkFeatures : SqlFeatures.Defensive() {
         Rel.Op.Exclude.Item::class.java,
         Rel.Op.Exclude.Step.StructField::class.java,
         Rel.Op.Exclude.Step.CollWildcard::class.java,
+        Rel.Op.Union::class.java,
         //
         // Rex
         //

src/main/kotlin/org/partiql/scribe/targets/trino/TrinoFeatures.kt

@@ -27,6 +27,7 @@ public open class TrinoFeatures : SqlFeatures.Defensive() {
         Rel.Op.Exclude.Item::class.java,
         Rel.Op.Exclude.Step.StructField::class.java,
         Rel.Op.Exclude.Step.CollWildcard::class.java,
+        Rel.Op.Union::class.java,
         //
         // Rex
         //

src/test/resources/catalogs/default/SIMPLE_T.ion

@@ -0,0 +1,21 @@
+{
+  type: "bag",
+  items: {
+    type: "struct",
+    constraints: [ closed, ordered, unique ],
+    fields: [
+      {
+        name: "a",
+        type: "bool",
+      },
+      {
+        name: "b",
+        type: "int32",
+      },
+      {
+        name: "c",
+        type: "string",
+      }
+    ]
+  }
+}

src/test/resources/inputs/basics/setop.sql

@@ -0,0 +1,20 @@
+-- SQL set ops
+
+-- SQL UNION
+--#[setop-00]
+SELECT a FROM SIMPLE_T AS t1 UNION SELECT a FROM SIMPLE_T AS t2;
+
+--#[setop-01]
+SELECT a FROM SIMPLE_T AS t1 UNION ALL SELECT a FROM SIMPLE_T AS t2;
+
+--#[setop-02]
+SELECT a FROM SIMPLE_T AS t1 UNION ALL SELECT a FROM SIMPLE_T AS t2 UNION SELECT a FROM SIMPLE_T AS t3;
+
+--#[setop-03]
+SELECT a FROM SIMPLE_T AS t1 UNION ALL (SELECT a FROM SIMPLE_T AS t2 UNION SELECT a FROM SIMPLE_T AS t3);
+
+--#[setop-04]
+SELECT c, b, a FROM SIMPLE_T AS t1 UNION ALL (SELECT c, b, a FROM SIMPLE_T AS t2 UNION SELECT c, b, a FROM SIMPLE_T AS t3);
+
+--#[setop-05]
+SELECT * FROM SIMPLE_T AS t1 UNION ALL SELECT * FROM SIMPLE_T AS t2 UNION SELECT * FROM SIMPLE_T AS t3;

src/test/resources/outputs/partiql/basics/setop.sql

@@ -0,0 +1,20 @@
+-- SQL set ops
+
+-- SQL UNION
+--#[setop-00]
+(SELECT "t1"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION DISTINCT (SELECT "t2"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t2");
+
+--#[setop-01]
+(SELECT "t1"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION ALL (SELECT "t2"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t2");
+
+--#[setop-02]
+((SELECT "t1"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION ALL (SELECT "t2"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t2")) UNION DISTINCT (SELECT "t3"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t3");
+
+--#[setop-03]
+(SELECT "t1"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION ALL ((SELECT "t2"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t2") UNION DISTINCT (SELECT "t3"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t3"));
+
+--#[setop-04]
+(SELECT "t1"['c'] AS "c", "t1"['b'] AS "b", "t1"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION ALL ((SELECT "t2"['c'] AS "c", "t2"['b'] AS "b", "t2"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t2") UNION DISTINCT (SELECT "t3"['c'] AS "c", "t3"['b'] AS "b", "t3"['a'] AS "a" FROM "default"."SIMPLE_T" AS "t3"));
+
+--#[setop-05]
+((SELECT "t1".* FROM "default"."SIMPLE_T" AS "t1") UNION ALL (SELECT "t2".* FROM "default"."SIMPLE_T" AS "t2")) UNION DISTINCT (SELECT "t3".* FROM "default"."SIMPLE_T" AS "t3");

src/test/resources/outputs/redshift/basics/setop.sql

@@ -0,0 +1,20 @@
+-- SQL set ops
+
+-- SQL UNION
+--#[setop-00]
+(SELECT "t1"."a" AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION DISTINCT (SELECT "t2"."a" AS "a" FROM "default"."SIMPLE_T" AS "t2");
+
+--#[setop-01]
+(SELECT "t1"."a" AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION ALL (SELECT "t2"."a" AS "a" FROM "default"."SIMPLE_T" AS "t2");
+
+--#[setop-02]
+((SELECT "t1"."a" AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION ALL (SELECT "t2"."a" AS "a" FROM "default"."SIMPLE_T" AS "t2")) UNION DISTINCT (SELECT "t3"."a" AS "a" FROM "default"."SIMPLE_T" AS "t3");
+
+--#[setop-03]
+(SELECT "t1"."a" AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION ALL ((SELECT "t2"."a" AS "a" FROM "default"."SIMPLE_T" AS "t2") UNION DISTINCT (SELECT "t3"."a" AS "a" FROM "default"."SIMPLE_T" AS "t3"));
+
+--#[setop-04]
+(SELECT "t1"."c" AS "c", "t1"."b" AS "b", "t1"."a" AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION ALL ((SELECT "t2"."c" AS "c", "t2"."b" AS "b", "t2"."a" AS "a" FROM "default"."SIMPLE_T" AS "t2") UNION DISTINCT (SELECT "t3"."c" AS "c", "t3"."b" AS "b", "t3"."a" AS "a" FROM "default"."SIMPLE_T" AS "t3"));
+
+--#[setop-05]
+((SELECT "t1"."a" AS "a", "t1"."b" AS "b", "t1"."c" AS "c" FROM "default"."SIMPLE_T" AS "t1") UNION ALL (SELECT "t2"."a" AS "a", "t2"."b" AS "b", "t2"."c" AS "c" FROM "default"."SIMPLE_T" AS "t2")) UNION DISTINCT (SELECT "t3"."a" AS "a", "t3"."b" AS "b", "t3"."c" AS "c" FROM "default"."SIMPLE_T" AS "t3");

src/test/resources/outputs/redshift/operators/between.sql

@@ -1,23 +1,23 @@
 --#[between-00]
 -- between(decimal, int32, int32)
-SELECT "T_DECIMALS"."da" AS "da" FROM "default"."T_DECIMALS" AS "T_DECIMALS" WHERE "T_DECIMALS"."da" BETWEEN -1 AND 1;
+SELECT "T_DECIMALS"."da" AS "da" FROM "default"."T_DECIMALS" AS "T_DECIMALS" WHERE "T_DECIMALS"."da" BETWEEN CAST(-1 AS DECIMAL) AND CAST(1 AS DECIMAL);
 
 --#[between-01]
 -- between(decimal, int64, int64)
-SELECT "T_DECIMALS"."da" AS "da" FROM "default"."T_DECIMALS" AS "T_DECIMALS" WHERE "T_DECIMALS"."da" BETWEEN -2147483649 AND 2147483648;
+SELECT "T_DECIMALS"."da" AS "da" FROM "default"."T_DECIMALS" AS "T_DECIMALS" WHERE "T_DECIMALS"."da" BETWEEN CAST(-2147483649 AS DECIMAL) AND CAST(2147483648 AS DECIMAL);
 
 --#[between-02]
 -- between(decimal, decimal, decimal)
-SELECT "T_DECIMALS"."da" AS "da" FROM "default"."T_DECIMALS" AS "T_DECIMALS" WHERE "T_DECIMALS"."da" BETWEEN -9223372036854775809 AND 9223372036854775808;
+SELECT "T_DECIMALS"."da" AS "da" FROM "default"."T_DECIMALS" AS "T_DECIMALS" WHERE "T_DECIMALS"."da" BETWEEN CAST(-9223372036854775809 AS DECIMAL) AND CAST(9223372036854775808 AS DECIMAL);
 
 --#[between-04]
 -- between(decimal(p,s), int32, int32)
-SELECT "T_DECIMALS"."de" AS "de" FROM "default"."T_DECIMALS" AS "T_DECIMALS" WHERE "T_DECIMALS"."de" BETWEEN -1 AND 1;
+SELECT "T_DECIMALS"."de" AS "de" FROM "default"."T_DECIMALS" AS "T_DECIMALS" WHERE CAST("T_DECIMALS"."de" AS DECIMAL) BETWEEN CAST(-1 AS DECIMAL) AND CAST(1 AS DECIMAL);
 
 --#[between-05]
 -- between(decimal(p,s), int64, int64)
-SELECT "T_DECIMALS"."de" AS "de" FROM "default"."T_DECIMALS" AS "T_DECIMALS" WHERE "T_DECIMALS"."de" BETWEEN -2147483649 AND 2147483648;
+SELECT "T_DECIMALS"."de" AS "de" FROM "default"."T_DECIMALS" AS "T_DECIMALS" WHERE CAST("T_DECIMALS"."de" AS DECIMAL) BETWEEN CAST(-2147483649 AS DECIMAL) AND CAST(2147483648 AS DECIMAL);
 
 --#[between-06]
 -- between(decimal(p,s), decimal, decimal)
-SELECT "T_DECIMALS"."de" AS "de" FROM "default"."T_DECIMALS" AS "T_DECIMALS" WHERE "T_DECIMALS"."de" BETWEEN -9223372036854775809 AND 9223372036854775808;
+SELECT "T_DECIMALS"."de" AS "de" FROM "default"."T_DECIMALS" AS "T_DECIMALS" WHERE CAST("T_DECIMALS"."de" AS DECIMAL) BETWEEN CAST(-9223372036854775809 AS DECIMAL) AND CAST(9223372036854775808 AS DECIMAL);

src/test/resources/outputs/spark/basics/setop.sql

@@ -0,0 +1,20 @@
+-- SQL set ops
+
+-- SQL UNION
+--#[setop-00]
+(SELECT `t1`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t1`) UNION DISTINCT (SELECT `t2`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t2`);
+
+--#[setop-01]
+(SELECT `t1`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t1`) UNION ALL (SELECT `t2`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t2`);
+
+--#[setop-02]
+((SELECT `t1`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t1`) UNION ALL (SELECT `t2`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t2`)) UNION DISTINCT (SELECT `t3`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t3`);
+
+--#[setop-03]
+(SELECT `t1`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t1`) UNION ALL ((SELECT `t2`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t2`) UNION DISTINCT (SELECT `t3`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t3`));
+
+--#[setop-04]
+(SELECT `t1`.`c` AS `c`, `t1`.`b` AS `b`, `t1`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t1`) UNION ALL ((SELECT `t2`.`c` AS `c`, `t2`.`b` AS `b`, `t2`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t2`) UNION DISTINCT (SELECT `t3`.`c` AS `c`, `t3`.`b` AS `b`, `t3`.`a` AS `a` FROM `default`.`SIMPLE_T` AS `t3`));
+
+--#[setop-05]
+((SELECT `t1`.`a` AS `a`, `t1`.`b` AS `b`, `t1`.`c` AS `c` FROM `default`.`SIMPLE_T` AS `t1`) UNION ALL (SELECT `t2`.`a` AS `a`, `t2`.`b` AS `b`, `t2`.`c` AS `c` FROM `default`.`SIMPLE_T` AS `t2`)) UNION DISTINCT (SELECT `t3`.`a` AS `a`, `t3`.`b` AS `b`, `t3`.`c` AS `c` FROM `default`.`SIMPLE_T` AS `t3`);

src/test/resources/outputs/spark/operators/between.sql

@@ -1,23 +1,23 @@
 --#[between-00]
 -- between(decimal, int32, int32)
-SELECT `T_DECIMALS`.`da` AS `da` FROM `default`.`T_DECIMALS` AS `T_DECIMALS` WHERE `T_DECIMALS`.`da` BETWEEN -1 AND 1;
+SELECT `T_DECIMALS`.`da` AS `da` FROM `default`.`T_DECIMALS` AS `T_DECIMALS` WHERE `T_DECIMALS`.`da` BETWEEN CAST(-1 AS DECIMAL) AND CAST(1 AS DECIMAL);
 
 --#[between-01]
 -- between(decimal, int64, int64)
-SELECT `T_DECIMALS`.`da` AS `da` FROM `default`.`T_DECIMALS` AS `T_DECIMALS` WHERE `T_DECIMALS`.`da` BETWEEN -2147483649 AND 2147483648;
+SELECT `T_DECIMALS`.`da` AS `da` FROM `default`.`T_DECIMALS` AS `T_DECIMALS` WHERE `T_DECIMALS`.`da` BETWEEN CAST(-2147483649 AS DECIMAL) AND CAST(2147483648 AS DECIMAL);
 
 --#[between-02]
 -- between(decimal, decimal, decimal)
-SELECT `T_DECIMALS`.`da` AS `da` FROM `default`.`T_DECIMALS` AS `T_DECIMALS` WHERE `T_DECIMALS`.`da` BETWEEN -9223372036854775809 AND 9223372036854775808;
+SELECT `T_DECIMALS`.`da` AS `da` FROM `default`.`T_DECIMALS` AS `T_DECIMALS` WHERE `T_DECIMALS`.`da` BETWEEN CAST(-9223372036854775809 AS DECIMAL) AND CAST(9223372036854775808 AS DECIMAL);
 
 --#[between-04]
 -- between(decimal(p,s), int32, int32)
-SELECT `T_DECIMALS`.`de` AS `de` FROM `default`.`T_DECIMALS` AS `T_DECIMALS` WHERE `T_DECIMALS`.`de` BETWEEN -1 AND 1;
+SELECT `T_DECIMALS`.`de` AS `de` FROM `default`.`T_DECIMALS` AS `T_DECIMALS` WHERE CAST(`T_DECIMALS`.`de` AS DECIMAL) BETWEEN CAST(-1 AS DECIMAL) AND CAST(1 AS DECIMAL);
 
 --#[between-05]
 -- between(decimal(p,s), int64, int64)
-SELECT `T_DECIMALS`.`de` AS `de` FROM `default`.`T_DECIMALS` AS `T_DECIMALS` WHERE `T_DECIMALS`.`de` BETWEEN -2147483649 AND 2147483648;
+SELECT `T_DECIMALS`.`de` AS `de` FROM `default`.`T_DECIMALS` AS `T_DECIMALS` WHERE CAST(`T_DECIMALS`.`de` AS DECIMAL) BETWEEN CAST(-2147483649 AS DECIMAL) AND CAST(2147483648 AS DECIMAL);
 
 --#[between-06]
 -- between(decimal(p,s), decimal, decimal)
-SELECT `T_DECIMALS`.`de` AS `de` FROM `default`.`T_DECIMALS` AS `T_DECIMALS` WHERE `T_DECIMALS`.`de` BETWEEN -9223372036854775809 AND 9223372036854775808;
+SELECT `T_DECIMALS`.`de` AS `de` FROM `default`.`T_DECIMALS` AS `T_DECIMALS` WHERE CAST(`T_DECIMALS`.`de` AS DECIMAL) BETWEEN CAST(-9223372036854775809 AS DECIMAL) AND CAST(9223372036854775808 AS DECIMAL);

src/test/resources/outputs/trino/basics/setop.sql

@@ -0,0 +1,20 @@
+-- SQL set ops
+
+-- SQL UNION
+--#[setop-00]
+(SELECT "t1"."a" AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION DISTINCT (SELECT "t2"."a" AS "a" FROM "default"."SIMPLE_T" AS "t2");
+
+--#[setop-01]
+(SELECT "t1"."a" AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION ALL (SELECT "t2"."a" AS "a" FROM "default"."SIMPLE_T" AS "t2");
+
+--#[setop-02]
+((SELECT "t1"."a" AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION ALL (SELECT "t2"."a" AS "a" FROM "default"."SIMPLE_T" AS "t2")) UNION DISTINCT (SELECT "t3"."a" AS "a" FROM "default"."SIMPLE_T" AS "t3");
+
+--#[setop-03]
+(SELECT "t1"."a" AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION ALL ((SELECT "t2"."a" AS "a" FROM "default"."SIMPLE_T" AS "t2") UNION DISTINCT (SELECT "t3"."a" AS "a" FROM "default"."SIMPLE_T" AS "t3"));
+
+--#[setop-04]
+(SELECT "t1"."c" AS "c", "t1"."b" AS "b", "t1"."a" AS "a" FROM "default"."SIMPLE_T" AS "t1") UNION ALL ((SELECT "t2"."c" AS "c", "t2"."b" AS "b", "t2"."a" AS "a" FROM "default"."SIMPLE_T" AS "t2") UNION DISTINCT (SELECT "t3"."c" AS "c", "t3"."b" AS "b", "t3"."a" AS "a" FROM "default"."SIMPLE_T" AS "t3"));
+
+--#[setop-05]
+((SELECT "t1"."a" AS "a", "t1"."b" AS "b", "t1"."c" AS "c" FROM "default"."SIMPLE_T" AS "t1") UNION ALL (SELECT "t2"."a" AS "a", "t2"."b" AS "b", "t2"."c" AS "c" FROM "default"."SIMPLE_T" AS "t2")) UNION DISTINCT (SELECT "t3"."a" AS "a", "t3"."b" AS "b", "t3"."c" AS "c" FROM "default"."SIMPLE_T" AS "t3");