From a5145f538082ad7d149ea5f8bc7e3f918b4d4556 Mon Sep 17 00:00:00 2001 From: John Ed Quinn Date: Fri, 12 Apr 2024 13:17:38 -0700 Subject: [PATCH 01/12] Adds compilation/evaluation support for UNION/INTERSECT/EXCEPT ALL/DISTINCT --- .../org/partiql/eval/internal/Compiler.kt | 19 + .../eval/internal/helpers/IteratorChain.kt | 29 + .../internal/operator/rel/RelExceptAll.kt | 56 + .../{RelExcept.kt => RelExceptDistinct.kt} | 2 +- .../internal/operator/rel/RelIntersectAll.kt | 56 + ...elIntersect.kt => RelIntersectDistinct.kt} | 11 +- .../rel/{RelUnion.kt => RelUnionAll.kt} | 2 +- .../internal/operator/rel/RelUnionDistinct.kt | 39 + .../src/main/resources/partiql_plan.ion | 22 +- .../org/partiql/planner/internal/ir/Nodes.kt | 60 +- .../internal/transforms/PlanTransform.kt | 20 +- .../internal/transforms/RelConverter.kt | 22 +- .../internal/transforms/RexConverter.kt | 42 + .../planner/internal/typer/PlanTyper.kt | 14 +- .../main/resources/partiql_plan_internal.ion | 22 +- test/partiql-tests-runner/comp_report.md | 2649 +++++++++++++++++ 16 files changed, 2960 insertions(+), 105 deletions(-) create mode 100644 partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorChain.kt create mode 100644 partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt rename partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/{RelExcept.kt => RelExceptDistinct.kt} (97%) create mode 100644 partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectAll.kt rename partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/{RelIntersect.kt => RelIntersectDistinct.kt} (81%) rename partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/{RelUnion.kt => RelUnionAll.kt} (96%) create mode 100644 partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt create mode 100644 test/partiql-tests-runner/comp_report.md diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/Compiler.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/Compiler.kt index 6df4eaf590..eb1601bc56 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/Compiler.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/Compiler.kt @@ -4,8 +4,12 @@ import org.partiql.eval.PartiQLEngine import org.partiql.eval.internal.operator.Operator import org.partiql.eval.internal.operator.rel.RelAggregate import org.partiql.eval.internal.operator.rel.RelDistinct +import org.partiql.eval.internal.operator.rel.RelExceptAll +import org.partiql.eval.internal.operator.rel.RelExceptDistinct import org.partiql.eval.internal.operator.rel.RelExclude import org.partiql.eval.internal.operator.rel.RelFilter +import org.partiql.eval.internal.operator.rel.RelIntersectAll +import org.partiql.eval.internal.operator.rel.RelIntersectDistinct import org.partiql.eval.internal.operator.rel.RelJoinInner import org.partiql.eval.internal.operator.rel.RelJoinLeft import org.partiql.eval.internal.operator.rel.RelJoinOuterFull @@ -18,6 +22,8 @@ import org.partiql.eval.internal.operator.rel.RelScanIndexed import org.partiql.eval.internal.operator.rel.RelScanIndexedPermissive import org.partiql.eval.internal.operator.rel.RelScanPermissive import org.partiql.eval.internal.operator.rel.RelSort +import org.partiql.eval.internal.operator.rel.RelUnionAll +import org.partiql.eval.internal.operator.rel.RelUnionDistinct import org.partiql.eval.internal.operator.rel.RelUnpivot import org.partiql.eval.internal.operator.rex.ExprCallDynamic import org.partiql.eval.internal.operator.rex.ExprCallStatic @@ -308,6 +314,19 @@ internal class Compiler( } } + override fun visitRelOpSet(node: Rel.Op.Set, ctx: StaticType?): Operator { + val lhs = visitRel(node.lhs, ctx) + val rhs = visitRel(node.rhs, ctx) + return when (node.type) { + Rel.Op.Set.Type.UNION_ALL -> RelUnionAll(lhs, rhs) + Rel.Op.Set.Type.UNION_DISTINCT -> RelUnionDistinct(lhs, rhs) + Rel.Op.Set.Type.INTERSECT_ALL -> RelIntersectAll(lhs, rhs) + Rel.Op.Set.Type.INTERSECT_DISTINCT -> RelIntersectDistinct(lhs, rhs) + Rel.Op.Set.Type.EXCEPT_ALL -> RelExceptAll(lhs, rhs) + Rel.Op.Set.Type.EXCEPT_DISTINCT -> RelExceptDistinct(lhs, rhs) + } + } + override fun visitRelOpLimit(node: Rel.Op.Limit, ctx: StaticType?): Operator { val input = visitRel(node.input, ctx) val limit = visitRex(node.limit, ctx) diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorChain.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorChain.kt new file mode 100644 index 0000000000..72b10d53e4 --- /dev/null +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorChain.kt @@ -0,0 +1,29 @@ +package org.partiql.eval.internal.helpers + +/** + * WARNING: You must invoke [hasNext] before calling [next]. + */ +internal class IteratorChain( + iterators: Iterable> +) : Iterator { + + private var iterator = iterators.iterator() + private var current = iterator.next() + + override fun hasNext(): Boolean { + return when (current.hasNext()) { + true -> true + false -> { + if (!iterator.hasNext()) { + return false + } + current = iterator.next() + current.hasNext() + } + } + } + + override fun next(): T { + return current.next() + } +} diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt new file mode 100644 index 0000000000..d585881401 --- /dev/null +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt @@ -0,0 +1,56 @@ +package org.partiql.eval.internal.operator.rel + +import org.partiql.eval.internal.Environment +import org.partiql.eval.internal.Record +import org.partiql.eval.internal.operator.Operator + +internal class RelExceptAll( + private val lhs: Operator.Relation, + private val rhs: Operator.Relation, +) : RelPeeking() { + + private val seen: MutableMap = mutableMapOf() + private var init: Boolean = false + + override fun open(env: Environment) { + lhs.open(env) + rhs.open(env) + init = false + seen.clear() + super.open(env) + } + + override fun peek(): Record? { + if (!init) { + seed() + } + for (row in lhs) { + seen.computeIfPresent(row) { _, y -> + when (y) { + 0 -> null + else -> y - 1 + } + } ?: return row + } + return null + } + + override fun close() { + lhs.close() + rhs.close() + seen.clear() + super.close() + } + + /** + * Read the entire left-hand-side into our search structure. + */ + private fun seed() { + init = true + for (row in rhs) { + seen.computeIfPresent(row) { _, y -> + y + 1 + } ?: seen.put(row, 1) + } + } +} diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExcept.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptDistinct.kt similarity index 97% rename from partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExcept.kt rename to partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptDistinct.kt index 93ac2eb581..c5d153bb39 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExcept.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptDistinct.kt @@ -10,7 +10,7 @@ import org.partiql.eval.internal.operator.Operator * @property lhs * @property rhs */ -internal class RelExcept( +internal class RelExceptDistinct( private val lhs: Operator.Relation, private val rhs: Operator.Relation, ) : RelPeeking() { diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectAll.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectAll.kt new file mode 100644 index 0000000000..77ca4dfa6e --- /dev/null +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectAll.kt @@ -0,0 +1,56 @@ +package org.partiql.eval.internal.operator.rel + +import org.partiql.eval.internal.Environment +import org.partiql.eval.internal.Record +import org.partiql.eval.internal.operator.Operator + +internal class RelIntersectAll( + private val lhs: Operator.Relation, + private val rhs: Operator.Relation, +) : RelPeeking() { + + private val seen: MutableMap = mutableMapOf() + private var init: Boolean = false + + override fun open(env: Environment) { + lhs.open(env) + rhs.open(env) + init = false + seen.clear() + super.open(env) + } + + override fun peek(): Record? { + if (!init) { + seed() + } + for (row in rhs) { + seen.computeIfPresent(row) { _, y -> + when (y) { + 0 -> null + else -> y - 1 + } + }?.let { return row } + } + return null + } + + override fun close() { + lhs.close() + rhs.close() + seen.clear() + super.close() + } + + /** + * Read the entire left-hand-side into our search structure. + */ + private fun seed() { + init = true + for (row in lhs) { + seen.computeIfPresent(row) { _, y -> + y + 1 + } ?: seen.put(row, 1) + } + } +} diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersect.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectDistinct.kt similarity index 81% rename from partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersect.kt rename to partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectDistinct.kt index 67c83b9e9a..e32575395c 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersect.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectDistinct.kt @@ -4,19 +4,19 @@ import org.partiql.eval.internal.Environment import org.partiql.eval.internal.Record import org.partiql.eval.internal.operator.Operator -internal class RelIntersect( +internal class RelIntersectDistinct( private val lhs: Operator.Relation, private val rhs: Operator.Relation, ) : RelPeeking() { - private var seen: MutableSet = mutableSetOf() + private val seen: MutableSet = mutableSetOf() private var init: Boolean = false override fun open(env: Environment) { lhs.open(env) rhs.open(env) init = false - seen = mutableSetOf() + seen.clear() super.open(env) } @@ -25,7 +25,7 @@ internal class RelIntersect( seed() } for (row in rhs) { - if (seen.contains(row)) { + if (seen.remove(row)) { return row } } @@ -44,8 +44,7 @@ internal class RelIntersect( */ private fun seed() { init = true - while (true) { - val row = lhs.next() ?: break + for (row in lhs) { seen.add(row) } } diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnion.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionAll.kt similarity index 96% rename from partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnion.kt rename to partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionAll.kt index 58d66709a3..663abadd23 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnion.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionAll.kt @@ -4,7 +4,7 @@ import org.partiql.eval.internal.Environment import org.partiql.eval.internal.Record import org.partiql.eval.internal.operator.Operator -internal class RelUnion( +internal class RelUnionAll( private val lhs: Operator.Relation, private val rhs: Operator.Relation, ) : Operator.Relation { diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt new file mode 100644 index 0000000000..a4847f8c7b --- /dev/null +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt @@ -0,0 +1,39 @@ +package org.partiql.eval.internal.operator.rel + +import org.partiql.eval.internal.Environment +import org.partiql.eval.internal.Record +import org.partiql.eval.internal.helpers.IteratorChain +import org.partiql.eval.internal.operator.Operator + +internal class RelUnionDistinct( + private val lhs: Operator.Relation, + private val rhs: Operator.Relation, +) : RelPeeking() { + + private val seen: MutableSet = mutableSetOf() + private val input = IteratorChain(listOf(lhs, rhs)) + + override fun open(env: Environment) { + lhs.open(env) + rhs.open(env) + seen.clear() + super.open(env) + } + + override fun peek(): Record? { + for (record in input) { + if (!seen.contains(record)) { + seen.add(record) + return record + } + } + return null + } + + override fun close() { + lhs.close() + rhs.close() + seen.clear() + super.close() + } +} diff --git a/partiql-plan/src/main/resources/partiql_plan.ion b/partiql-plan/src/main/resources/partiql_plan.ion index 0c272060b8..2218a08a07 100644 --- a/partiql-plan/src/main/resources/partiql_plan.ion +++ b/partiql-plan/src/main/resources/partiql_plan.ion @@ -261,19 +261,19 @@ rel::{ ], }, - union::{ - lhs: rel, - rhs: rel, - }, - - intersect::{ - lhs: rel, - rhs: rel, - }, - - except::{ + // From Substrait: "The set operation encompasses several set-level operations that support combining datasets, ... + // possibly excluding records based on various types of record level matching." + set::{ lhs: rel, rhs: rel, + type: [ + UNION_ALL, + UNION_DISTINCT, + INTERSECT_ALL, + INTERSECT_DISTINCT, + EXCEPT_ALL, + EXCEPT_DISTINCT + ] }, limit::{ diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/ir/Nodes.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/ir/Nodes.kt index dc09b1f705..68aaafb8f8 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/ir/Nodes.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/ir/Nodes.kt @@ -20,7 +20,6 @@ import org.partiql.planner.internal.ir.builder.RelOpAggregateCallResolvedBuilder import org.partiql.planner.internal.ir.builder.RelOpAggregateCallUnresolvedBuilder import org.partiql.planner.internal.ir.builder.RelOpDistinctBuilder import org.partiql.planner.internal.ir.builder.RelOpErrBuilder -import org.partiql.planner.internal.ir.builder.RelOpExceptBuilder import org.partiql.planner.internal.ir.builder.RelOpExcludeBuilder import org.partiql.planner.internal.ir.builder.RelOpExcludePathBuilder import org.partiql.planner.internal.ir.builder.RelOpExcludeStepBuilder @@ -30,16 +29,15 @@ import org.partiql.planner.internal.ir.builder.RelOpExcludeTypeStructKeyBuilder import org.partiql.planner.internal.ir.builder.RelOpExcludeTypeStructSymbolBuilder import org.partiql.planner.internal.ir.builder.RelOpExcludeTypeStructWildcardBuilder import org.partiql.planner.internal.ir.builder.RelOpFilterBuilder -import org.partiql.planner.internal.ir.builder.RelOpIntersectBuilder import org.partiql.planner.internal.ir.builder.RelOpJoinBuilder import org.partiql.planner.internal.ir.builder.RelOpLimitBuilder import org.partiql.planner.internal.ir.builder.RelOpOffsetBuilder import org.partiql.planner.internal.ir.builder.RelOpProjectBuilder import org.partiql.planner.internal.ir.builder.RelOpScanBuilder import org.partiql.planner.internal.ir.builder.RelOpScanIndexedBuilder +import org.partiql.planner.internal.ir.builder.RelOpSetBuilder import org.partiql.planner.internal.ir.builder.RelOpSortBuilder import org.partiql.planner.internal.ir.builder.RelOpSortSpecBuilder -import org.partiql.planner.internal.ir.builder.RelOpUnionBuilder import org.partiql.planner.internal.ir.builder.RelOpUnpivotBuilder import org.partiql.planner.internal.ir.builder.RelTypeBuilder import org.partiql.planner.internal.ir.builder.RexBuilder @@ -876,9 +874,7 @@ internal data class Rel( is Distinct -> visitor.visitRelOpDistinct(this, ctx) is Filter -> visitor.visitRelOpFilter(this, ctx) is Sort -> visitor.visitRelOpSort(this, ctx) - is Union -> visitor.visitRelOpUnion(this, ctx) - is Intersect -> visitor.visitRelOpIntersect(this, ctx) - is Except -> visitor.visitRelOpExcept(this, ctx) + is Set -> visitor.visitRelOpSet(this, ctx) is Limit -> visitor.visitRelOpLimit(this, ctx) is Offset -> visitor.visitRelOpOffset(this, ctx) is Project -> visitor.visitRelOpProject(this, ctx) @@ -1021,29 +1017,10 @@ internal data class Rel( } } - internal data class Union( - @JvmField internal val lhs: Rel, - @JvmField internal val rhs: Rel, - ) : Op() { - public override val children: List by lazy { - val kids = mutableListOf() - kids.add(lhs) - kids.add(rhs) - kids.filterNotNull() - } - - public override fun accept(visitor: PlanVisitor, ctx: C): R = - visitor.visitRelOpUnion(this, ctx) - - internal companion object { - @JvmStatic - internal fun builder(): RelOpUnionBuilder = RelOpUnionBuilder() - } - } - - internal data class Intersect( + internal data class Set( @JvmField internal val lhs: Rel, @JvmField internal val rhs: Rel, + @JvmField internal val type: Type, ) : Op() { public override val children: List by lazy { val kids = mutableListOf() @@ -1053,31 +1030,20 @@ internal data class Rel( } public override fun accept(visitor: PlanVisitor, ctx: C): R = - visitor.visitRelOpIntersect(this, ctx) + visitor.visitRelOpSet(this, ctx) internal companion object { @JvmStatic - internal fun builder(): RelOpIntersectBuilder = RelOpIntersectBuilder() + internal fun builder(): RelOpSetBuilder = RelOpSetBuilder() } - } - internal data class Except( - @JvmField internal val lhs: Rel, - @JvmField internal val rhs: Rel, - ) : Op() { - public override val children: List by lazy { - val kids = mutableListOf() - kids.add(lhs) - kids.add(rhs) - kids.filterNotNull() - } - - public override fun accept(visitor: PlanVisitor, ctx: C): R = - visitor.visitRelOpExcept(this, ctx) - - internal companion object { - @JvmStatic - internal fun builder(): RelOpExceptBuilder = RelOpExceptBuilder() + internal enum class Type { + UNION_ALL, + UNION_DISTINCT, + INTERSECT_ALL, + INTERSECT_DISTINCT, + EXCEPT_ALL, + EXCEPT_DISTINCT } } diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/PlanTransform.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/PlanTransform.kt index 7fdcc25c29..442014214b 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/PlanTransform.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/PlanTransform.kt @@ -328,19 +328,17 @@ internal class PlanTransform( } ) - override fun visitRelOpUnion(node: Rel.Op.Union, ctx: Unit) = org.partiql.plan.Rel.Op.Union( - lhs = visitRel(node.lhs, ctx), - rhs = visitRel(node.rhs, ctx), - ) - - override fun visitRelOpIntersect(node: Rel.Op.Intersect, ctx: Unit) = org.partiql.plan.Rel.Op.Intersect( - lhs = visitRel(node.lhs, ctx), - rhs = visitRel(node.rhs, ctx), - ) - - override fun visitRelOpExcept(node: Rel.Op.Except, ctx: Unit) = org.partiql.plan.Rel.Op.Except( + override fun visitRelOpSet(node: Rel.Op.Set, ctx: Unit) = org.partiql.plan.Rel.Op.Set( lhs = visitRel(node.lhs, ctx), rhs = visitRel(node.rhs, ctx), + type = when (node.type) { + Rel.Op.Set.Type.UNION_ALL -> org.partiql.plan.Rel.Op.Set.Type.UNION_ALL + Rel.Op.Set.Type.UNION_DISTINCT -> org.partiql.plan.Rel.Op.Set.Type.UNION_DISTINCT + Rel.Op.Set.Type.EXCEPT_ALL -> org.partiql.plan.Rel.Op.Set.Type.EXCEPT_ALL + Rel.Op.Set.Type.EXCEPT_DISTINCT -> org.partiql.plan.Rel.Op.Set.Type.EXCEPT_DISTINCT + Rel.Op.Set.Type.INTERSECT_ALL -> org.partiql.plan.Rel.Op.Set.Type.INTERSECT_ALL + Rel.Op.Set.Type.INTERSECT_DISTINCT -> org.partiql.plan.Rel.Op.Set.Type.INTERSECT_DISTINCT + } ) override fun visitRelOpLimit(node: Rel.Op.Limit, ctx: Unit) = org.partiql.plan.Rel.Op.Limit( diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RelConverter.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RelConverter.kt index 5abdb2bbde..7d111b2e4e 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RelConverter.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RelConverter.kt @@ -42,7 +42,6 @@ import org.partiql.planner.internal.ir.relOpAggregate import org.partiql.planner.internal.ir.relOpAggregateCallUnresolved import org.partiql.planner.internal.ir.relOpDistinct import org.partiql.planner.internal.ir.relOpErr -import org.partiql.planner.internal.ir.relOpExcept import org.partiql.planner.internal.ir.relOpExclude import org.partiql.planner.internal.ir.relOpExcludePath import org.partiql.planner.internal.ir.relOpExcludeStep @@ -52,7 +51,6 @@ import org.partiql.planner.internal.ir.relOpExcludeTypeStructKey import org.partiql.planner.internal.ir.relOpExcludeTypeStructSymbol import org.partiql.planner.internal.ir.relOpExcludeTypeStructWildcard import org.partiql.planner.internal.ir.relOpFilter -import org.partiql.planner.internal.ir.relOpIntersect import org.partiql.planner.internal.ir.relOpJoin import org.partiql.planner.internal.ir.relOpLimit import org.partiql.planner.internal.ir.relOpOffset @@ -61,7 +59,6 @@ import org.partiql.planner.internal.ir.relOpScan import org.partiql.planner.internal.ir.relOpScanIndexed import org.partiql.planner.internal.ir.relOpSort import org.partiql.planner.internal.ir.relOpSortSpec -import org.partiql.planner.internal.ir.relOpUnion import org.partiql.planner.internal.ir.relOpUnpivot import org.partiql.planner.internal.ir.relType import org.partiql.planner.internal.ir.rex @@ -446,11 +443,22 @@ internal object RelConverter { val type = input.type.copy(props = emptySet()) val lhs = input val rhs = visitExprSFW(setOp.operand, nil) - val op = when (setOp.type.type) { - SetOp.Type.UNION -> relOpUnion(lhs, rhs) - SetOp.Type.INTERSECT -> relOpIntersect(lhs, rhs) - SetOp.Type.EXCEPT -> relOpExcept(lhs, rhs) + + val setType = when (setOp.type.type) { + SetOp.Type.UNION -> when (setOp.type.setq) { + SetQuantifier.ALL -> Rel.Op.Set.Type.UNION_ALL + null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.UNION_DISTINCT + } + SetOp.Type.EXCEPT -> when (setOp.type.setq) { + SetQuantifier.ALL -> Rel.Op.Set.Type.EXCEPT_ALL + null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.EXCEPT_DISTINCT + } + SetOp.Type.INTERSECT -> when (setOp.type.setq) { + SetQuantifier.ALL -> Rel.Op.Set.Type.INTERSECT_ALL + null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.INTERSECT_DISTINCT + } } + val op = Rel.Op.Set(lhs, rhs, setType) return rel(type, op) } diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt index 11db9199b2..c29f563012 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt @@ -20,6 +20,8 @@ import org.partiql.ast.AstNode import org.partiql.ast.DatetimeField import org.partiql.ast.Expr import org.partiql.ast.Select +import org.partiql.ast.SetOp +import org.partiql.ast.SetQuantifier import org.partiql.ast.Type import org.partiql.ast.visitor.AstBaseVisitor import org.partiql.planner.internal.Env @@ -821,6 +823,46 @@ internal object RexConverter { override fun visitExprSFW(node: Expr.SFW, context: Env): Rex = RelConverter.apply(node, context) + override fun visitExprBagOp(node: Expr.BagOp, ctx: Env): Rex { + val lhs = Rel( + type = Rel.Type(listOf(Rel.Binding("_0", StaticType.ANY)), props = emptySet()), + op = Rel.Op.Scan(visitExprCoerce(node.lhs, ctx)) + ) + val rhs = Rel( + type = Rel.Type(listOf(Rel.Binding("_1", StaticType.ANY)), props = emptySet()), + op = Rel.Op.Scan(visitExprCoerce(node.rhs, ctx)) + ) + val type = when (node.type.type) { + SetOp.Type.UNION -> when (node.type.setq) { + SetQuantifier.ALL -> Rel.Op.Set.Type.UNION_ALL + null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.UNION_DISTINCT + } + SetOp.Type.EXCEPT -> when (node.type.setq) { + SetQuantifier.ALL -> Rel.Op.Set.Type.EXCEPT_ALL + null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.EXCEPT_DISTINCT + } + SetOp.Type.INTERSECT -> when (node.type.setq) { + SetQuantifier.ALL -> Rel.Op.Set.Type.INTERSECT_ALL + null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.INTERSECT_DISTINCT + } + } + val op = Rel.Op.Set(lhs, rhs, type) + val rel = Rel( + type = Rel.Type(listOf(Rel.Binding("_0", StaticType.ANY)), props = emptySet()), + op = op + ) + return Rex( + type = StaticType.ANY, + op = Rex.Op.Select( + constructor = Rex( + StaticType.ANY, + Rex.Op.Var.Unresolved(Identifier.Symbol("_0", Identifier.CaseSensitivity.SENSITIVE), Rex.Op.Var.Scope.LOCAL) + ), + rel = rel + ) + ) + } + // Helpers private fun negate(call: Rex.Op.Call): Rex.Op.Call { diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt index 0c1018972f..0e0a161d72 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt @@ -218,16 +218,10 @@ internal class PlanTyper(private val env: Env) { return rel(type, op) } - override fun visitRelOpUnion(node: Rel.Op.Union, ctx: Rel.Type?): Rel { - TODO("Type RelOp Union") - } - - override fun visitRelOpIntersect(node: Rel.Op.Intersect, ctx: Rel.Type?): Rel { - TODO("Type RelOp Intersect") - } - - override fun visitRelOpExcept(node: Rel.Op.Except, ctx: Rel.Type?): Rel { - TODO("Type RelOp Except") + // TODO: Add better typing logic + override fun visitRelOpSet(node: Rel.Op.Set, ctx: Rel.Type?): PlanNode { + val schema = ctx!! + return Rel(schema, node) } override fun visitRelOpLimit(node: Rel.Op.Limit, ctx: Rel.Type?): Rel { diff --git a/partiql-planner/src/main/resources/partiql_plan_internal.ion b/partiql-planner/src/main/resources/partiql_plan_internal.ion index a8f5479817..9b01c7898d 100644 --- a/partiql-planner/src/main/resources/partiql_plan_internal.ion +++ b/partiql-planner/src/main/resources/partiql_plan_internal.ion @@ -296,19 +296,19 @@ rel::{ ], }, - union::{ - lhs: rel, - rhs: rel, - }, - - intersect::{ - lhs: rel, - rhs: rel, - }, - - except::{ + // From Substrait: "The set operation encompasses several set-level operations that support combining datasets, ... + // possibly excluding records based on various types of record level matching." + set::{ lhs: rel, rhs: rel, + type: [ + UNION_ALL, + UNION_DISTINCT, + INTERSECT_ALL, + INTERSECT_DISTINCT, + EXCEPT_ALL, + EXCEPT_DISTINCT + ] }, limit::{ diff --git a/test/partiql-tests-runner/comp_report.md b/test/partiql-tests-runner/comp_report.md new file mode 100644 index 0000000000..cab30e43fe --- /dev/null +++ b/test/partiql-tests-runner/comp_report.md @@ -0,0 +1,2649 @@ +### Conformance comparison report-Cross Engine +| | Base (legacy) | eval | +/- | +| --- | ---: | ---: | ---: | +| % Passing | 92.47% | 82.37% | -10.11% | +| :white_check_mark: Passing | 5380 | 4792 | -588 | +| :x: Failing | 438 | 1026 | 588 | +| :large_orange_diamond: Ignored | 0 | 0 | 0 | +| Total Tests | 5818 | 5818 | 0 | +Number passing in both: 4614 + +Number failing in both: 260 + +Number passing in legacy engine but fail in eval engine: 766 + +Number failing in legacy engine but pass in eval engine: 178 +:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) are passing in legacy but fail in eval: +
Click here to see + + +- equiv wildcard steps struct, compileOption: PERMISSIVE +- equiv wildcard steps struct, compileOption: LEGACY +- equiv path expression with wildcard steps, compileOption: PERMISSIVE +- equiv path expression with wildcard steps, compileOption: LEGACY +- equiv path collection expression with wildcard steps, compileOption: PERMISSIVE +- equiv path collection expression with wildcard steps, compileOption: LEGACY +- equiv attribute value pair unpivot missing, compileOption: PERMISSIVE +- equiv left join, compileOption: PERMISSIVE +- equiv left join, compileOption: LEGACY +- Example 6 — Value Coercion, compileOption: PERMISSIVE +- Example 6 — Value Coercion, compileOption: LEGACY +- path on string, compileOption: PERMISSIVE +- tuple navigation missing attribute dot notation, compileOption: PERMISSIVE +- tuple navigation missing attribute array notation, compileOption: PERMISSIVE +- array navigation with wrongly typed array index, compileOption: PERMISSIVE +- single source FROM with scalar, compileOption: LEGACY +- single source FROM with tuple, compileOption: LEGACY +- single source FROM with absent value null, compileOption: LEGACY +- single source FROM with absent value missing, compileOption: LEGACY +- tuple constructor and mistyped attribute name, compileOption: PERMISSIVE +- attribute value evaluates to MISSING, compileOption: LEGACY +- array element evaluates to MISSING, compileOption: LEGACY +- bag element evaluates to MISSING, compileOption: LEGACY +- bag element evaluates to MISSING in bag constructor, compileOption: LEGACY +- pivot into a tuple with invalid attribute name, compileOption: LEGACY +- missing value in arithmetic expression, compileOption: PERMISSIVE +- data type mismatch in comparison expression, compileOption: PERMISSIVE +- data type mismatch in logical expression, compileOption: PERMISSIVE +- equality of scalar missing, compileOption: PERMISSIVE +- equality of same element bags, compileOption: PERMISSIVE +- equality of same element bags, compileOption: LEGACY +- WHERE clause eliminating absent values, compileOption: PERMISSIVE +- WHERE clause eliminating absent values, compileOption: LEGACY +- group by with absent values, compileOption: LEGACY +- group by with differenciated absent values, compileOption: LEGACY +- Right with variables, compileOption: PERMISSIVE +- Right with variables, compileOption: LEGACY +- Right with spots, compileOption: PERMISSIVE +- Right with spots, compileOption: LEGACY +- Right shorthand, compileOption: PERMISSIVE +- Right shorthand, compileOption: LEGACY +- Left with variables, compileOption: PERMISSIVE +- Left with variables, compileOption: LEGACY +- Left with spots, compileOption: PERMISSIVE +- Left with spots, compileOption: LEGACY +- Left shorthand, compileOption: PERMISSIVE +- Left shorthand, compileOption: LEGACY +- Left+right with variables, compileOption: PERMISSIVE +- Left+right with variables, compileOption: LEGACY +- Left+right with spots, compileOption: PERMISSIVE +- Left+right with spots, compileOption: LEGACY +- Left+right shorthand, compileOption: PERMISSIVE +- Left+right shorthand, compileOption: LEGACY +- Left+right with variables and label, compileOption: PERMISSIVE +- Left+right with variables and label, compileOption: LEGACY +- Undirected with variables, compileOption: PERMISSIVE +- Undirected with variables, compileOption: LEGACY +- Undirected with spots, compileOption: PERMISSIVE +- Undirected with spots, compileOption: LEGACY +- Undirected shorthand, compileOption: PERMISSIVE +- Undirected shorthand, compileOption: LEGACY +- Undirected with variables and label, compileOption: PERMISSIVE +- Undirected with variables and label, compileOption: LEGACY +- Right+undirected with variables, compileOption: PERMISSIVE +- Right+undirected with variables, compileOption: LEGACY +- Right+undirected with spots, compileOption: PERMISSIVE +- Right+undirected with spots, compileOption: LEGACY +- Right+undirected shorthand, compileOption: PERMISSIVE +- Right+undirected shorthand, compileOption: LEGACY +- Right+undirected with variables and labels, compileOption: PERMISSIVE +- Right+undirected with variables and labels, compileOption: LEGACY +- Left+undirected with variables, compileOption: PERMISSIVE +- Left+undirected with variables, compileOption: LEGACY +- Left+undirected with spots, compileOption: PERMISSIVE +- Left+undirected with spots, compileOption: LEGACY +- Left+undirected shorthand, compileOption: PERMISSIVE +- Left+undirected shorthand, compileOption: LEGACY +- Left+undirected with variables and label, compileOption: PERMISSIVE +- Left+undirected with variables and label, compileOption: LEGACY +- Left+right+undirected with variables, compileOption: PERMISSIVE +- Left+right+undirected with variables, compileOption: LEGACY +- Left+right+undirected with spots, compileOption: PERMISSIVE +- Left+right+undirected with spots, compileOption: LEGACY +- Left+right+undirected shorthand, compileOption: PERMISSIVE +- Left+right+undirected shorthand, compileOption: LEGACY +- (N0E0 MATCH (x)), compileOption: PERMISSIVE +- (N0E0 MATCH (x)), compileOption: LEGACY +- (N0E0 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N0E0 MATCH -[y]-> ), compileOption: LEGACY +- (N0E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N0E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N1E0 MATCH (x)), compileOption: PERMISSIVE +- (N1E0 MATCH (x)), compileOption: LEGACY +- (N1E0 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N1E0 MATCH -[y]-> ), compileOption: LEGACY +- (N1E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N1E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N1E0 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE +- (N1E0 MATCH (x)-[y]->(x) ), compileOption: LEGACY +- (N1U1 MATCH (x)), compileOption: PERMISSIVE +- (N1U1 MATCH (x)), compileOption: LEGACY +- (N1U1 MATCH ~[y]~ ), compileOption: PERMISSIVE +- (N1U1 MATCH ~[y]~ ), compileOption: LEGACY +- (N1U1 MATCH (x)~[y]~(z) ), compileOption: PERMISSIVE +- (N1U1 MATCH (x)~[y]~(z) ), compileOption: LEGACY +- (N1U1 MATCH (x)~[y]~(x) ), compileOption: PERMISSIVE +- (N1U1 MATCH (x)~[y]~(x) ), compileOption: LEGACY +- (N1U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: PERMISSIVE +- (N1U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: LEGACY +- (N1D2 MATCH (x)), compileOption: PERMISSIVE +- (N1D2 MATCH (x)), compileOption: LEGACY +- (N1D2 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N1D2 MATCH -[y]-> ), compileOption: LEGACY +- (N1D2 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N1D2 MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N1D2 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE +- (N1D2 MATCH (x)-[y]->(x) ), compileOption: LEGACY +- (N1D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N1D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2E0 MATCH (x)), compileOption: PERMISSIVE +- (N2E0 MATCH (x)), compileOption: LEGACY +- (N2E0 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N2E0 MATCH -[y]-> ), compileOption: LEGACY +- (N2E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N2E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N2E0 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE +- (N2E0 MATCH (x)-[y]->(x) ), compileOption: LEGACY +- (N2D1 MATCH (x)), compileOption: PERMISSIVE +- (N2D1 MATCH (x)), compileOption: LEGACY +- (N2D1 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N2D1 MATCH -[y]-> ), compileOption: LEGACY +- (N2D1 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N2D1 MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N2D1 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE +- (N2D1 MATCH (x)-[y]->(x) ), compileOption: LEGACY +- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2U1 MATCH (x)), compileOption: PERMISSIVE +- (N2U1 MATCH (x)), compileOption: LEGACY +- (N2U1 MATCH ~[y]~ ), compileOption: PERMISSIVE +- (N2U1 MATCH ~[y]~ ), compileOption: LEGACY +- (N2U1 MATCH (x)~[y]~(z) ), compileOption: PERMISSIVE +- (N2U1 MATCH (x)~[y]~(z) ), compileOption: LEGACY +- (N2U1 MATCH (x)~[y]~(x) ), compileOption: PERMISSIVE +- (N2U1 MATCH (x)~[y]~(x) ), compileOption: LEGACY +- (N2U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: PERMISSIVE +- (N2U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: LEGACY +- (N2U1 MATCH (x1)~[y1]~(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2U1 MATCH (x1)~[y1]~(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2U1 MATCH (x1)-[y1]-(x2)~[y2]~(x3) ), compileOption: PERMISSIVE +- (N2U1 MATCH (x1)-[y1]-(x2)~[y2]~(x3) ), compileOption: LEGACY +- (N2U1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2U1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2D2 MATCH (x)), compileOption: PERMISSIVE +- (N2D2 MATCH (x)), compileOption: LEGACY +- (N2D2 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N2D2 MATCH -[y]-> ), compileOption: LEGACY +- (N2D2 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N2D2 MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N2D2 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE +- (N2D2 MATCH (x)-[y]->(x) ), compileOption: LEGACY +- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2D2c MATCH (x)), compileOption: PERMISSIVE +- (N2D2c MATCH (x)), compileOption: LEGACY +- (N2D2c MATCH -[y]-> ), compileOption: PERMISSIVE +- (N2D2c MATCH -[y]-> ), compileOption: LEGACY +- (N2D2c MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N2D2c MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x)-[y]->(x) ), compileOption: LEGACY +- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x1) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x1) ), compileOption: LEGACY +- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2U2 MATCH (x)), compileOption: PERMISSIVE +- (N2U2 MATCH (x)), compileOption: LEGACY +- (N2U2 MATCH ~[y]~ ), compileOption: PERMISSIVE +- (N2U2 MATCH ~[y]~ ), compileOption: LEGACY +- (N2U2 MATCH (x)~[y]~(z) ), compileOption: PERMISSIVE +- (N2U2 MATCH (x)~[y]~(z) ), compileOption: LEGACY +- (N2U2 MATCH (x)~[y]~(x) ), compileOption: PERMISSIVE +- (N2U2 MATCH (x)~[y]~(x) ), compileOption: LEGACY +- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: PERMISSIVE +- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: LEGACY +- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x1) ), compileOption: PERMISSIVE +- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x1) ), compileOption: LEGACY +- cast to MISSING valid cases{value:"NULL"}, compileOption: PERMISSIVE +- cast to MISSING valid cases{value:"NULL"}, compileOption: LEGACY +- cast to MISSING valid cases{value:"MISSING"}, compileOption: PERMISSIVE +- cast to MISSING valid cases{value:"MISSING"}, compileOption: LEGACY +- cast to NULL valid cases{value:"MISSING"}, compileOption: PERMISSIVE +- cast to NULL valid cases{value:"MISSING"}, compileOption: LEGACY +- cast to int invalid target type{value:"`2017T`",target:"TIMESTAMP"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:" `{{\"\"}}` ",target:"CLOB"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:" `{{\"1\"}}` ",target:"CLOB"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"`{{}}`",target:"BLOB"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"[1, 2]",target:"LIST"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"[1]",target:"LIST"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"[]",target:"LIST"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"`(1 2)`",target:"SEXP"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"`(1)`",target:"SEXP"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"`()`",target:"SEXP"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"{'a': 1}",target:"STRUCT"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"{'a': '12'}",target:"STRUCT"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"{}",target:"STRUCT"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"<<1, 2>>",target:"BAG"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"<<1>>",target:"BAG"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"<<>>",target:"BAG"}, compileOption: PERMISSIVE +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE null "}, compileOption: PERMISSIVE +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE null "}, compileOption: LEGACY +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE '[' "}, compileOption: PERMISSIVE +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE '[' "}, compileOption: LEGACY +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE 'S1' ESCAPE null "}, compileOption: PERMISSIVE +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE 'S1' ESCAPE null "}, compileOption: LEGACY +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null "}, compileOption: PERMISSIVE +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null "}, compileOption: LEGACY +- MISSING LIKE 'some pattern', compileOption: PERMISSIVE +- 'some value' LIKE MISSING, compileOption: PERMISSIVE +- MISSING LIKE MISSING, compileOption: PERMISSIVE +- NULL LIKE MISSING, compileOption: PERMISSIVE +- MISSING LIKE NULL, compileOption: PERMISSIVE +- MISSING LIKE 'some pattern' ESCAPE '/', compileOption: PERMISSIVE +- 'some value' LIKE MISSING ESCAPE '/', compileOption: PERMISSIVE +- 'some value' LIKE 'some pattern' ESCAPE MISSING, compileOption: PERMISSIVE +- NULL LIKE 'some pattern' ESCAPE MISSING, compileOption: PERMISSIVE +- 'some value' LIKE NULL ESCAPE MISSING, compileOption: PERMISSIVE +- outerUnionCoerceScalar, compileOption: PERMISSIVE +- outerUnionCoerceScalar, compileOption: LEGACY +- outerUnionCoerceStruct, compileOption: PERMISSIVE +- outerUnionCoerceStruct, compileOption: LEGACY +- outerUnionCoerceNullMissing, compileOption: PERMISSIVE +- outerUnionCoerceNullMissing, compileOption: LEGACY +- inPredicate, compileOption: PERMISSIVE +- inPredicate, compileOption: LEGACY +- inPredicateSingleItem, compileOption: PERMISSIVE +- inPredicateSingleItem, compileOption: LEGACY +- inPredicateSingleExpr, compileOption: PERMISSIVE +- inPredicateSingleExpr, compileOption: LEGACY +- inPredicateSingleItemListVar, compileOption: PERMISSIVE +- inPredicateSingleItemListVar, compileOption: LEGACY +- inPredicateSingleListVar, compileOption: PERMISSIVE +- inPredicateSingleListVar, compileOption: LEGACY +- inPredicateSubQuerySelectValue, compileOption: PERMISSIVE +- inPredicateSubQuerySelectValue, compileOption: LEGACY +- notInPredicate, compileOption: PERMISSIVE +- notInPredicate, compileOption: LEGACY +- notInPredicateSingleItem, compileOption: PERMISSIVE +- notInPredicateSingleItem, compileOption: LEGACY +- notInPredicateSingleExpr, compileOption: PERMISSIVE +- notInPredicateSingleItemListVar, compileOption: PERMISSIVE +- notInPredicateSingleItemListVar, compileOption: LEGACY +- notInPredicateSingleListVar, compileOption: PERMISSIVE +- notInPredicateSingleListVar, compileOption: LEGACY +- notInPredicateSubQuerySelectValue, compileOption: PERMISSIVE +- notInPredicateSubQuerySelectValue, compileOption: LEGACY +- inPredicateWithTableConstructor, compileOption: PERMISSIVE +- inPredicateWithTableConstructor, compileOption: LEGACY +- notInPredicateWithTableConstructor, compileOption: PERMISSIVE +- notInPredicateWithTableConstructor, compileOption: LEGACY +- inPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE +- inPredicateWithExpressionOnRightSide, compileOption: LEGACY +- notInPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE +- notInPredicateWithExpressionOnRightSide, compileOption: LEGACY +- || valid cases{lparam:"null",rparam:"missing",result:missing::null}, compileOption: PERMISSIVE +- || valid cases{lparam:"missing",rparam:"null",result:missing::null}, compileOption: PERMISSIVE +- || valid cases{lparam:"missing",rparam:"'b'",result:missing::null}, compileOption: PERMISSIVE +- || valid cases{lparam:"'a'",rparam:"missing",result:missing::null}, compileOption: PERMISSIVE +- || valid cases{lparam:"missing",rparam:"missing",result:missing::null}, compileOption: PERMISSIVE +- repeatingDecimal, compileOption: PERMISSIVE +- repeatingDecimal, compileOption: LEGACY +- repeatingDecimalHigherPrecision, compileOption: PERMISSIVE +- repeatingDecimalHigherPrecision, compileOption: LEGACY +- divDecimalInt, compileOption: PERMISSIVE +- divDecimalInt, compileOption: LEGACY +- subtractionOutOfAllowedPrecision, compileOption: PERMISSIVE +- subtractionOutOfAllowedPrecision, compileOption: LEGACY +- equalListDifferentTypesTrue, compileOption: PERMISSIVE +- equalListDifferentTypesTrue, compileOption: LEGACY +- simpleCase, compileOption: PERMISSIVE +- simpleCase, compileOption: LEGACY +- simpleCaseNoElse, compileOption: PERMISSIVE +- simpleCaseNoElse, compileOption: LEGACY +- searchedCase, compileOption: PERMISSIVE +- searchedCase, compileOption: LEGACY +- searchedCaseNoElse, compileOption: PERMISSIVE +- searchedCaseNoElse, compileOption: LEGACY +- dateTimePartsAsVariableNames, compileOption: LEGACY +- pathDotMissingAttribute, compileOption: LEGACY +- pathMissingDotName, compileOption: PERMISSIVE +- pathMissingDotName, compileOption: LEGACY +- pathNullDotName, compileOption: PERMISSIVE +- pathNullDotName, compileOption: LEGACY +- pathIndexBagLiteral, compileOption: PERMISSIVE +- pathIndexBagLiteral, compileOption: LEGACY +- pathIndexStructLiteral, compileOption: PERMISSIVE +- pathIndexStructLiteral, compileOption: LEGACY +- pathIndexStructOutOfBoundsLowLiteral, compileOption: PERMISSIVE +- pathIndexStructOutOfBoundsLowLiteral, compileOption: LEGACY +- pathIndexStructOutOfBoundsHighLiteral, compileOption: PERMISSIVE +- pathIndexStructOutOfBoundsHighLiteral, compileOption: LEGACY +- pathDoubleWildCard, compileOption: PERMISSIVE +- pathDoubleWildCard, compileOption: LEGACY +- pathWildCardOverScalar, compileOption: LEGACY +- pathUnpivotWildCardOverScalar, compileOption: LEGACY +- pathWildCardOverScalarMultiple, compileOption: LEGACY +- pathUnpivotWildCardOverScalarMultiple, compileOption: LEGACY +- pathWildCardOverStructMultiple, compileOption: LEGACY +- unpivotMissing, compileOption: PERMISSIVE +- unpivotMissing, compileOption: LEGACY +- unpivotEmptyStruct, compileOption: PERMISSIVE +- unpivotEmptyStruct, compileOption: LEGACY +- unpivotStructWithMissingField, compileOption: PERMISSIVE +- unpivotStructWithMissingField, compileOption: LEGACY +- unpivotMissingWithAsAndAt, compileOption: LEGACY +- unpivotMissingCrossJoinWithAsAndAt, compileOption: LEGACY +- pathUnpivotEmptyStruct1, compileOption: PERMISSIVE +- pathUnpivotEmptyStruct1, compileOption: LEGACY +- pathUnpivotEmptyStruct2, compileOption: PERMISSIVE +- pathUnpivotEmptyStruct2, compileOption: LEGACY +- pathUnpivotEmptyStruct3, compileOption: PERMISSIVE +- pathUnpivotEmptyStruct3, compileOption: LEGACY +- dotted path expression with quoted field name accesses field UNAMBIGUOUS_FIELD (uppercase), compileOption: LEGACY +- subscript with variable in lowercase, compileOption: PERMISSIVE +- subscript with variable in lowercase, compileOption: LEGACY +- subscript with variable in uppercase, compileOption: PERMISSIVE +- subscript with variable in uppercase, compileOption: LEGACY +- subscript with variable in mixed case, compileOption: PERMISSIVE +- subscript with variable in mixed case, compileOption: LEGACY +- subscript with non-existent variable in lowercase, compileOption: PERMISSIVE +- subscript with non-existent variable in uppercase, compileOption: PERMISSIVE +- null comparison{sql:"MISSING IS NULL",result:true}, compileOption: PERMISSIVE +- null comparison{sql:"MISSING IS NULL",result:true}, compileOption: LEGACY +- null comparison{sql:"MISSING = NULL",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"NULL = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.sexp` = NULL",result:null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.sexp` = NULL",result:null}, compileOption: LEGACY +- null comparison{sql:"`null.null` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.bool` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.int` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.decimal` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.string` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.symbol` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.clob` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.blob` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.list` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.struct` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.sexp` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- concatenation with null values{left:"MISSING",right:"MISSING"}, compileOption: PERMISSIVE +- concatenation with null values{left:"''",right:"MISSING"}, compileOption: PERMISSIVE +- concatenation with null values{left:"MISSING",right:"''"}, compileOption: PERMISSIVE +- concatenation with null values{left:"'a'",right:"MISSING"}, compileOption: PERMISSIVE +- concatenation with null values{left:"MISSING",right:"'b'"}, compileOption: PERMISSIVE +- char_length null and missing propagation{in:"missing",result:(success missing::null)}, compileOption: PERMISSIVE +- character_length null and missing propagation{in:"missing",result:(success missing::null)}, compileOption: PERMISSIVE +- CHARACTER_LENGTH invalid type, compileOption: PERMISSIVE +- upper null and missing propagation{param:"missing"}, compileOption: PERMISSIVE +- cardinality null and missing propagation{param:"missing"}, compileOption: PERMISSIVE +- CARDINALITY('foo') type mismatch, compileOption: PERMISSIVE +- EXTRACT(YEAR FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(MONTH FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(DAY FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(HOUR FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(MINUTE FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(SECOND FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(TIMEZONE_HOUR FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(TIMEZONE_MINUTE FROM MISSING), compileOption: PERMISSIVE +- invalid extract year from time, compileOption: PERMISSIVE +- invalid extract month from time, compileOption: PERMISSIVE +- invalid extract day from time, compileOption: PERMISSIVE +- invalid extract month from time with time zone, compileOption: PERMISSIVE +- invalid extract day from time with time zone, compileOption: PERMISSIVE +- POSITION MISSING in string, compileOption: PERMISSIVE +- POSITION string in MISSING, compileOption: PERMISSIVE +- POSITION NULL in MISSING, compileOption: PERMISSIVE +- POSITION MISSING in NULL, compileOption: PERMISSIVE +- POSITION MISSING in MISSING, compileOption: PERMISSIVE +- POSITION invalid type in string, compileOption: PERMISSIVE +- POSITION string in invalid type, compileOption: PERMISSIVE +- substring null and missing propagation 2 arguments{target:"missing",start_pos:"1"}, compileOption: PERMISSIVE +- substring null and missing propagation 2 arguments{target:"''",start_pos:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 2 arguments{target:"missing",start_pos:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 2 arguments{target:"null",start_pos:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 2 arguments{target:"missing",start_pos:"null"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"null",start_pos:"1",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"null",start_pos:"null",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"null",start_pos:"missing",quantity:"1"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"null",start_pos:"missing",quantity:"null"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"null",start_pos:"missing",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"1",quantity:"1"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"1",quantity:"null"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"1",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"null",quantity:"1"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"null",quantity:"null"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"null",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"missing",quantity:"1"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"missing",quantity:"null"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"missing",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"''",start_pos:"1",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"''",start_pos:"null",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"''",start_pos:"missing",quantity:"1"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"''",start_pos:"missing",quantity:"null"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"''",start_pos:"missing",quantity:"missing"}, compileOption: PERMISSIVE +- lower null and missing propagation{param:"missing"}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"1",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"1",result:null}, compileOption: LEGACY +- nullif valid cases{first:"1.0",second:"1",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"1.0",second:"1",result:null}, compileOption: LEGACY +- nullif valid cases{first:"1",second:"2",result:1}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"2",result:1}, compileOption: LEGACY +- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: PERMISSIVE +- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: LEGACY +- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: LEGACY +- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: LEGACY +- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: PERMISSIVE +- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: LEGACY +- nullif valid cases{first:"1",second:"null",result:1}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"null",result:1}, compileOption: LEGACY +- nullif valid cases{first:"null",second:"1",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"null",second:"1",result:null}, compileOption: LEGACY +- nullif valid cases{first:"null",second:"null",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"null",second:"null",result:null}, compileOption: LEGACY +- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: LEGACY +- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: PERMISSIVE +- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: LEGACY +- ABS(MISSING) null propogation, compileOption: PERMISSIVE +- ABS('foo'), compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(leading from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(trailing from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(both from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(leading '' from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(trailing '' from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(both '' from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(leading missing from '')"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(trailing missing from '')"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(both missing from '')"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(leading null from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(trailing null from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(both null from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(leading missing from null)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(trailing missing from null)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(both missing from null)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(leading missing from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(trailing missing from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(both missing from missing)"}, compileOption: PERMISSIVE +- MOD(MISSING, 3), compileOption: PERMISSIVE +- MOD(3, MISSING), compileOption: PERMISSIVE +- MOD(MISSING, NULL), compileOption: PERMISSIVE +- MOD(NULL, MISSING), compileOption: PERMISSIVE +- MOD(MISSING, 'some string'), compileOption: PERMISSIVE +- MOD('some string', MISSING), compileOption: PERMISSIVE +- MOD(3, 'some string'), compileOption: PERMISSIVE +- MOD('some string', 3), compileOption: PERMISSIVE +- BIT_LENGTH MISSING, compileOption: PERMISSIVE +- BIT_LENGTH invalid type, compileOption: PERMISSIVE +- OCTET_LENGTH MISSING, compileOption: PERMISSIVE +- OCTET_LENGTH invalid type, compileOption: PERMISSIVE +- OVERLAY MISSING, compileOption: PERMISSIVE +- OVERLAY PLACING MISSING, compileOption: PERMISSIVE +- OVERLAY FROM MISSING, compileOption: PERMISSIVE +- OVERLAY FOR MISSING, compileOption: PERMISSIVE +- OVERLAY mismatched type, compileOption: PERMISSIVE +- OVERLAY PLACING mismatched type, compileOption: PERMISSIVE +- OVERLAY FROM mismatched type, compileOption: PERMISSIVE +- OVERLAY FOR mismatched type, compileOption: PERMISSIVE +- coalesce valid cases{args:"1",result:(success 1)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"1",result:(success 1)}, compileOption: LEGACY +- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: LEGACY +- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: LEGACY +- coalesce valid cases{args:"missing, 3",result:(success 3)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"missing, 3",result:(success 3)}, compileOption: LEGACY +- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: LEGACY +- coalesce valid cases{args:"null, missing, 3",result:(success 3)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"null, missing, 3",result:(success 3)}, compileOption: LEGACY +- coalesce valid cases{args:"null, missing, null, null, missing, 9, 4, 5, 6",result:(success 9)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"null, missing, null, null, missing, 9, 4, 5, 6",result:(success 9)}, compileOption: LEGACY +- Empty Symbol in table, compileOption: LEGACY +- Empty Symbol in globals, compileOption: LEGACY +- Empty Symbol in alias, compileOption: LEGACY +- functionCall, compileOption: PERMISSIVE +- functionCall, compileOption: LEGACY +- division with mixed StaticType, compileOption: PERMISSIVE +- division with mixed StaticType, compileOption: LEGACY +- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: PERMISSIVE +- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: LEGACY +- Example 3 — Outer union of Heterogenous Relations, compileOption: PERMISSIVE +- Example 3 — Outer union of Heterogenous Relations, compileOption: LEGACY +- Example 6 — Value Coercion; Coercion of single value, compileOption: PERMISSIVE +- Example 6 — Value Coercion; Coercion of single value, compileOption: LEGACY +- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: PERMISSIVE +- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: LEGACY +- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: PERMISSIVE +- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: LEGACY +- Example 7 — result is the empty bag, compileOption: PERMISSIVE +- Example 7 — result is the empty bag, compileOption: LEGACY +- undefinedUnqualifiedVariableWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE +- undefinedUnqualifiedVariableIsNullExprWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE +- undefinedUnqualifiedVariableIsMissingExprWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE +- undefinedUnqualifiedVariableInSelectWithUndefinedVariableBehaviorMissing, compileOption: LEGACY +- join on column - all column values non-null, compileOption: PERMISSIVE +- join on column - all column values non-null, compileOption: LEGACY +- join on column - some column values are null, compileOption: PERMISSIVE +- join on column - some column values are null, compileOption: LEGACY +- join on column - 1 table contains 1 row with the value null, compileOption: PERMISSIVE +- join on column - 1 table contains 1 row with the value null, compileOption: LEGACY +- join on column - ON condition = false, compileOption: PERMISSIVE +- join on column - ON condition = false, compileOption: LEGACY +- PG_JOIN_01, compileOption: PERMISSIVE +- PG_JOIN_01, compileOption: LEGACY +- PG_JOIN_02, compileOption: PERMISSIVE +- PG_JOIN_02, compileOption: LEGACY +- PG_JOIN_03, compileOption: PERMISSIVE +- PG_JOIN_03, compileOption: LEGACY +- PG_JOIN_06, compileOption: PERMISSIVE +- PG_JOIN_06, compileOption: LEGACY +- PG_JOIN_07, compileOption: PERMISSIVE +- PG_JOIN_07, compileOption: LEGACY +- PG_JOIN_08, compileOption: PERMISSIVE +- PG_JOIN_08, compileOption: LEGACY +- PG_JOIN_09, compileOption: PERMISSIVE +- PG_JOIN_09, compileOption: LEGACY +- PG_JOIN_10, compileOption: PERMISSIVE +- PG_JOIN_10, compileOption: LEGACY +- offset 0, compileOption: PERMISSIVE +- offset 0, compileOption: LEGACY +- offset 1, compileOption: PERMISSIVE +- offset 1, compileOption: LEGACY +- offset 2, compileOption: PERMISSIVE +- offset 2, compileOption: LEGACY +- limit 1 offset 1, compileOption: PERMISSIVE +- limit 1 offset 1, compileOption: LEGACY +- limit 10 offset 1, compileOption: PERMISSIVE +- limit 10 offset 1, compileOption: LEGACY +- limit 2 offset 2, compileOption: PERMISSIVE +- limit 2 offset 2, compileOption: LEGACY +- limit offset after group by, compileOption: PERMISSIVE +- limit offset after group by, compileOption: LEGACY +- offset 2-1, compileOption: PERMISSIVE +- offset 2-1, compileOption: LEGACY +- offset 2+1, compileOption: PERMISSIVE +- offset 2+1, compileOption: LEGACY +- offset 2*1, compileOption: PERMISSIVE +- offset 2*1, compileOption: LEGACY +- offset 2/1, compileOption: PERMISSIVE +- offset 2/1, compileOption: LEGACY +- offset group by having, compileOption: PERMISSIVE +- offset group by having, compileOption: LEGACY +- offset with pivot, compileOption: PERMISSIVE +- offset with pivot, compileOption: LEGACY +- pivotBadFieldType, compileOption: LEGACY +- col1 asc, compileOption: PERMISSIVE +- col1 asc, compileOption: LEGACY +- col1 desc, compileOption: PERMISSIVE +- col1 desc, compileOption: LEGACY +- col1 asc, col2 asc, compileOption: PERMISSIVE +- col1 asc, col2 asc, compileOption: LEGACY +- price desc, productId asc, compileOption: PERMISSIVE +- price desc, productId asc, compileOption: LEGACY +- supplierId_nulls nulls last, compileOption: PERMISSIVE +- supplierId_nulls nulls last, compileOption: LEGACY +- supplierId_nulls nulls first, compileOption: PERMISSIVE +- supplierId_nulls nulls first, compileOption: LEGACY +- supplierId_nulls asc nulls last, productId asc, compileOption: PERMISSIVE +- supplierId_nulls asc nulls last, productId asc, compileOption: LEGACY +- nulls first as default for supplierId_nulls desc, compileOption: PERMISSIVE +- nulls first as default for supplierId_nulls desc, compileOption: LEGACY +- group and order by asc sellerId, compileOption: PERMISSIVE +- group and order by asc sellerId, compileOption: LEGACY +- group and order by desc sellerId, compileOption: PERMISSIVE +- group and order by desc sellerId, compileOption: LEGACY +- group and order by DESC (NULLS FIRST as default), compileOption: PERMISSIVE +- group and order by DESC (NULLS FIRST as default), compileOption: LEGACY +- group and order by ASC (NULLS LAST as default), compileOption: PERMISSIVE +- group and order by ASC (NULLS LAST as default), compileOption: LEGACY +- group and place nulls first (asc as default), compileOption: PERMISSIVE +- group and place nulls first (asc as default), compileOption: LEGACY +- group and place nulls last (asc as default), compileOption: PERMISSIVE +- group and place nulls last (asc as default), compileOption: LEGACY +- group and order by asc and place nulls first, compileOption: PERMISSIVE +- group and order by asc and place nulls first, compileOption: LEGACY +- false before true (ASC), compileOption: PERMISSIVE +- false before true (ASC), compileOption: LEGACY +- true before false (DESC), compileOption: PERMISSIVE +- true before false (DESC), compileOption: LEGACY +- nan before -inf, then numeric values then +inf (ASC), compileOption: PERMISSIVE +- nan before -inf, then numeric values then +inf (ASC), compileOption: LEGACY +- +inf before numeric values then -inf then nan (DESC), compileOption: PERMISSIVE +- +inf before numeric values then -inf then nan (DESC), compileOption: LEGACY +- LOB types follow their lexicographical ordering by octet (ASC), compileOption: PERMISSIVE +- LOB types follow their lexicographical ordering by octet (ASC), compileOption: LEGACY +- LOB types should ordered (DESC), compileOption: PERMISSIVE +- LOB types should ordered (DESC), compileOption: LEGACY +- shorter array comes first (ASC), compileOption: PERMISSIVE +- shorter array comes first (ASC), compileOption: LEGACY +- longer array comes first (DESC), compileOption: PERMISSIVE +- longer array comes first (DESC), compileOption: LEGACY +- lists compared lexicographically based on comparison of elements (ASC), compileOption: PERMISSIVE +- lists compared lexicographically based on comparison of elements (ASC), compileOption: LEGACY +- lists compared lexicographically based on comparison of elements (DESC), compileOption: PERMISSIVE +- lists compared lexicographically based on comparison of elements (DESC), compileOption: LEGACY +- lists items should be ordered by data types (ASC) (nulls last as default for asc), compileOption: PERMISSIVE +- lists items should be ordered by data types (ASC) (nulls last as default for asc), compileOption: LEGACY +- lists items should be ordered by data types (DESC) (nulls first as default for desc), compileOption: PERMISSIVE +- lists items should be ordered by data types (DESC) (nulls first as default for desc), compileOption: LEGACY +- structs compared lexicographically first by key then by value (ASC), compileOption: PERMISSIVE +- structs compared lexicographically first by key then by value (ASC), compileOption: LEGACY +- structs compared lexicographically first by key then by value (DESC), compileOption: PERMISSIVE +- structs compared lexicographically first by key then by value (DESC), compileOption: LEGACY +- structs should be ordered by data types (ASC) (nulls last as default for asc), compileOption: PERMISSIVE +- structs should be ordered by data types (ASC) (nulls last as default for asc), compileOption: LEGACY +- structs should be ordered by data types (DESC) (nulls first as default for desc), compileOption: PERMISSIVE +- structs should be ordered by data types (DESC) (nulls first as default for desc), compileOption: LEGACY +- bags compared as sorted lists (ASC), compileOption: PERMISSIVE +- bags compared as sorted lists (ASC), compileOption: LEGACY +- bags compared as sorted lists (DESC), compileOption: PERMISSIVE +- bags compared as sorted lists (DESC), compileOption: LEGACY +- testing alias support, compileOption: PERMISSIVE +- testing alias support, compileOption: LEGACY +- testing nested alias support, compileOption: PERMISSIVE +- testing nested alias support, compileOption: LEGACY +- Empty Output (ordered), compileOption: PERMISSIVE +- Empty Output (ordered), compileOption: LEGACY +- GROUP BY binding referenced in FROM clause, compileOption: PERMISSIVE +- GROUP BY binding referenced in WHERE clause, compileOption: PERMISSIVE +- GROUP AS binding referenced in FROM clause, compileOption: PERMISSIVE +- GROUP AS binding referenced in WHERE clause, compileOption: PERMISSIVE +- SELECT COUNT(1) AS the_count, COUNT(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, SUM(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, MIN(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, MAX(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, AVG(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, COUNT(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, SUM(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, MIN(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, MAX(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, AVG(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, COUNT(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, SUM(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, MIN(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, MAX(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, AVG(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, COUNT(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, SUM(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, MIN(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, MAX(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, AVG(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, COUNT(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, SUM(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, MIN(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, MAX(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, AVG(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, COUNT(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, SUM(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, MIN(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, MAX(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, AVG(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- Expression with multiple subqueriees containing aggregates : CAST((SELECT COUNT(1) FROM products) AS LIST)[0]._1 / CAST((SELECT COUNT(1) FROM suppliers) AS LIST)[0]._1, compileOption: PERMISSIVE +- Expression with multiple subqueriees containing aggregates : CAST((SELECT COUNT(1) FROM products) AS LIST)[0]._1 / CAST((SELECT COUNT(1) FROM suppliers) AS LIST)[0]._1, compileOption: LEGACY +- Aggregates with subquery containing another aggregate : SELECT COUNT(1) + CAST((SELECT SUM(numInStock) FROM products) AS LIST)[0]._1 as a_number FROM products, compileOption: PERMISSIVE +- Aggregates with subquery containing another aggregate : SELECT COUNT(1) + CAST((SELECT SUM(numInStock) FROM products) AS LIST)[0]._1 as a_number FROM products, compileOption: LEGACY +- GROUP BY with JOIN : SELECT supplierName, COUNT(*) as the_count FROM suppliers AS s INNER JOIN products AS p ON s.supplierId = p.supplierId GROUP BY supplierName, compileOption: PERMISSIVE +- GROUP BY with JOIN : SELECT supplierName, COUNT(*) as the_count FROM suppliers AS s INNER JOIN products AS p ON s.supplierId = p.supplierId GROUP BY supplierName, compileOption: LEGACY +- SELECT VALUE with nested aggregates : SELECT VALUE (SELECT SUM(outerFromSource.col1) AS the_sum FROM <<1>>) FROM simple_1_col_1_group as outerFromSource, compileOption: PERMISSIVE +- SELECT VALUE with nested aggregates : SELECT VALUE (SELECT SUM(outerFromSource.col1) AS the_sum FROM <<1>>) FROM simple_1_col_1_group as outerFromSource, compileOption: LEGACY +- SELECT col1, g FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE +- SELECT col1, g FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: LEGACY +- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE +- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: LEGACY +- SELECT col1, g FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE +- SELECT col1, g FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: LEGACY +- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE +- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: LEGACY +- MYSQL_SELECT_20, compileOption: PERMISSIVE +- MYSQL_SELECT_20, compileOption: LEGACY +- MYSQL_SELECT_21, compileOption: PERMISSIVE +- MYSQL_SELECT_21, compileOption: LEGACY +- MYSQL_SELECT_26, compileOption: PERMISSIVE +- MYSQL_SELECT_26, compileOption: LEGACY +- selectFromScalarAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE +- selectFromScalarAndAtUnpivotWildCardOverScalar, compileOption: LEGACY +- selectFromListAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE +- selectFromListAndAtUnpivotWildCardOverScalar, compileOption: LEGACY +- selectFromBagAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE +- selectFromBagAndAtUnpivotWildCardOverScalar, compileOption: LEGACY +- selectPathUnpivotWildCardOverStructMultiple, compileOption: PERMISSIVE +- selectPathUnpivotWildCardOverStructMultiple, compileOption: LEGACY +- selectStarSingleSourceHoisted, compileOption: PERMISSIVE +- selectStarSingleSourceHoisted, compileOption: LEGACY +- ordinalAccessWithNegativeIndex, compileOption: LEGACY +- ordinalAccessWithNegativeIndexAndBindings, compileOption: LEGACY +- rangeOverScalar, compileOption: LEGACY +- rangeTwiceOverScalar, compileOption: LEGACY +- rangeOverSexp, compileOption: PERMISSIVE +- rangeOverSexp, compileOption: LEGACY +- rangeOverStruct, compileOption: LEGACY +- rangeOverBagWithAt, compileOption: LEGACY +- rangeOverNestedWithAt, compileOption: LEGACY +- avg group by{agg:'AVG(t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: PERMISSIVE +- avg group by{agg:'AVG(t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: LEGACY +- avg group by{agg:'AVG(ALL t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: PERMISSIVE +- avg group by{agg:'AVG(ALL t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: LEGACY +- avg group by{agg:'AVG(DISTINCT t.b)',expectedF1:1.5,expectedF2:3.}, compileOption: PERMISSIVE +- avg group by{agg:'AVG(DISTINCT t.b)',expectedF1:1.5,expectedF2:3.}, compileOption: LEGACY +- ANY with GROUP BY, compileOption: LEGACY +- ANY DISTINCT with GROUP BY, compileOption: LEGACY +- SOME with GROUP BY, compileOption: LEGACY +- SOME DISTINCT with GROUP BY, compileOption: LEGACY +- EVERY with GROUP BY, compileOption: LEGACY +- EVERY DISTINCT with GROUP BY, compileOption: LEGACY +- selectListMultipleAggregatesNestedQuery, compileOption: PERMISSIVE +- selectListMultipleAggregatesNestedQuery, compileOption: LEGACY +- undefinedUnqualifiedVariable_inSelect_withProjectionOption, compileOption: LEGACY +- projectionIterationBehaviorUnfiltered_select_star, compileOption: PERMISSIVE +- projectionIterationBehaviorUnfiltered_select_star, compileOption: LEGACY +- projectOfSexp, compileOption: PERMISSIVE +- projectOfSexp, compileOption: LEGACY +- projectOfUnpivotPath, compileOption: LEGACY +- alias1.alias2.*, compileOption: LEGACY +- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: PERMISSIVE +- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: LEGACY +- selectListWithMissing, compileOption: LEGACY +- selectCorrelatedJoin, compileOption: PERMISSIVE +- selectCorrelatedJoin, compileOption: LEGACY +- selectCorrelatedLeftJoin, compileOption: PERMISSIVE +- selectCorrelatedLeftJoin, compileOption: LEGACY +- selectCorrelatedLeftJoinOnClause, compileOption: PERMISSIVE +- selectCorrelatedLeftJoinOnClause, compileOption: LEGACY +- selectJoinOnClauseScoping, compileOption: PERMISSIVE +- selectJoinOnClauseScoping, compileOption: LEGACY +- selectNonCorrelatedJoin, compileOption: LEGACY +- correlatedJoinWithShadowedAttributes, compileOption: LEGACY +- correlatedJoinWithoutLexicalScope, compileOption: LEGACY +- joinWithShadowedGlobal, compileOption: LEGACY +- selectDistinctStarBags, compileOption: PERMISSIVE +- selectDistinctStarBags, compileOption: LEGACY +- variableShadow, compileOption: LEGACY +- selectValueStructConstructorWithMissing, compileOption: LEGACY +- selectIndexStruct, compileOption: PERMISSIVE +- selectIndexStruct, compileOption: LEGACY +- emptySymbol, compileOption: LEGACY +- emptySymbolInGlobals, compileOption: LEGACY +
+The following test(s) are failing in legacy but pass in eval. Before merging, confirm they are intended to pass: +
Click here to see + + +- equiv group by with aggregates, compileOption: PERMISSIVE + +- equiv group by with aggregates, compileOption: LEGACY + +- missing and true, compileOption: PERMISSIVE + +- coll_count with result of subquery, compileOption: PERMISSIVE + +- coll_count with result of subquery, compileOption: LEGACY + +- outerUnionAll, compileOption: PERMISSIVE + +- outerUnionAll, compileOption: LEGACY + +- outerExceptDistinct, compileOption: PERMISSIVE + +- outerExceptDistinct, compileOption: LEGACY + +- outerUnionCoerceList, compileOption: PERMISSIVE + +- outerUnionCoerceList, compileOption: LEGACY + +- max top level{agg:'COLL_MAX(data)',result:(success 2)}, compileOption: PERMISSIVE + +- max top level{agg:'COLL_MAX(data)',result:(success 2)}, compileOption: LEGACY + +- topLevelCollMax, compileOption: PERMISSIVE + +- topLevelCollMax, compileOption: LEGACY + +- COLL_MAX empty collection, compileOption: PERMISSIVE + +- COLL_MAX empty collection, compileOption: LEGACY + +- COLL_MAX null, compileOption: PERMISSIVE + +- COLL_MAX null, compileOption: LEGACY + +- COLL_MAX list of missing element, compileOption: PERMISSIVE + +- COLL_MAX list of missing element, compileOption: LEGACY + +- COLL_MAX bag of missing elements, compileOption: PERMISSIVE + +- COLL_MAX bag of missing elements, compileOption: LEGACY + +- COLL_MAX bag of heterogeneous element types, compileOption: PERMISSIVE + +- COLL_MAX bag of heterogeneous element types, compileOption: LEGACY + +- coll_avg top level{agg:'COLL_AVG(data)',result:(success 1.25)}, compileOption: PERMISSIVE + +- coll_avg top level{agg:'COLL_AVG(data)',result:(success 1.25)}, compileOption: LEGACY + +- topLevelCollAvg, compileOption: PERMISSIVE + +- topLevelCollAvg, compileOption: LEGACY + +- topLevelCollAvgOnlyInt, compileOption: PERMISSIVE + +- topLevelCollAvgOnlyInt, compileOption: LEGACY + +- COLL_AVG empty collection, compileOption: PERMISSIVE + +- COLL_AVG empty collection, compileOption: LEGACY + +- COLL_AVG null, compileOption: PERMISSIVE + +- COLL_AVG null, compileOption: LEGACY + +- COLL_AVG list of missing element, compileOption: PERMISSIVE + +- COLL_AVG list of missing element, compileOption: LEGACY + +- COLL_AVG bag of missing elements, compileOption: PERMISSIVE + +- COLL_AVG bag of missing elements, compileOption: LEGACY + +- COLL_AVG mistyped element, compileOption: PERMISSIVE + +- coll_count top level{agg:'COLL_COUNT(data)',result:(success 4)}, compileOption: PERMISSIVE + +- coll_count top level{agg:'COLL_COUNT(data)',result:(success 4)}, compileOption: LEGACY + +- topLevelCollCount, compileOption: PERMISSIVE + +- topLevelCollCount, compileOption: LEGACY + +- COLL_COUNT empty collection, compileOption: PERMISSIVE + +- COLL_COUNT empty collection, compileOption: LEGACY + +- COLL_COUNT null, compileOption: PERMISSIVE + +- COLL_COUNT null, compileOption: LEGACY + +- COLL_COUNT list of missing element, compileOption: PERMISSIVE + +- COLL_COUNT list of missing element, compileOption: LEGACY + +- COLL_COUNT bag of missing elements, compileOption: PERMISSIVE + +- COLL_COUNT bag of missing elements, compileOption: LEGACY + +- COLL_COUNT bag of heterogeneous element types, compileOption: PERMISSIVE + +- COLL_COUNT bag of heterogeneous element types, compileOption: LEGACY + +- coll_sum top level{agg:'COLL_SUM(data)',result:(success 5)}, compileOption: PERMISSIVE + +- coll_sum top level{agg:'COLL_SUM(data)',result:(success 5)}, compileOption: LEGACY + +- topLevelCollSum, compileOption: PERMISSIVE + +- topLevelCollSum, compileOption: LEGACY + +- COLL_SUM empty collection, compileOption: PERMISSIVE + +- COLL_SUM empty collection, compileOption: LEGACY + +- COLL_SUM null, compileOption: PERMISSIVE + +- COLL_SUM null, compileOption: LEGACY + +- COLL_SUM list of missing element, compileOption: PERMISSIVE + +- COLL_SUM list of missing element, compileOption: LEGACY + +- COLL_SUM bag of missing elements, compileOption: PERMISSIVE + +- COLL_SUM bag of missing elements, compileOption: LEGACY + +- COLL_SUM mistyped element, compileOption: PERMISSIVE + +- coll_min top level{agg:'COLL_MIN(data)',result:(success 1)}, compileOption: PERMISSIVE + +- coll_min top level{agg:'COLL_MIN(data)',result:(success 1)}, compileOption: LEGACY + +- topLevelCollMin, compileOption: PERMISSIVE + +- topLevelCollMin, compileOption: LEGACY + +- COLL_MIN empty collection, compileOption: PERMISSIVE + +- COLL_MIN empty collection, compileOption: LEGACY + +- COLL_MIN null, compileOption: PERMISSIVE + +- COLL_MIN null, compileOption: LEGACY + +- COLL_MIN list of missing element, compileOption: PERMISSIVE + +- COLL_MIN list of missing element, compileOption: LEGACY + +- COLL_MIN bag of missing elements, compileOption: PERMISSIVE + +- COLL_MIN bag of missing elements, compileOption: LEGACY + +- COLL_MIN bag of heterogeneous element types, compileOption: PERMISSIVE + +- COLL_MIN bag of heterogeneous element types, compileOption: LEGACY + +- COLL_ANY bag literals, compileOption: PERMISSIVE + +- COLL_ANY bag literals, compileOption: LEGACY + +- COLL_ANY list expressions, compileOption: PERMISSIVE + +- COLL_ANY list expressions, compileOption: LEGACY + +- COLL_ANY single true, compileOption: PERMISSIVE + +- COLL_ANY single true, compileOption: LEGACY + +- COLL_ANY single false, compileOption: PERMISSIVE + +- COLL_ANY single false, compileOption: LEGACY + +- COLL_ANY nulls with true, compileOption: PERMISSIVE + +- COLL_ANY nulls with true, compileOption: LEGACY + +- COLL_ANY nulls with false, compileOption: PERMISSIVE + +- COLL_ANY nulls with false, compileOption: LEGACY + +- COLL_ANY nulls only, compileOption: PERMISSIVE + +- COLL_ANY nulls only, compileOption: LEGACY + +- COLL_ANY null, compileOption: PERMISSIVE + +- COLL_ANY null, compileOption: LEGACY + +- COLL_ANY list of missing element, compileOption: PERMISSIVE + +- COLL_ANY list of missing element, compileOption: LEGACY + +- COLL_ANY bag of missing elements, compileOption: PERMISSIVE + +- COLL_ANY bag of missing elements, compileOption: LEGACY + +- COLL_ANY some empty, compileOption: PERMISSIVE + +- COLL_ANY some empty, compileOption: LEGACY + +- COLL_ANY one non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_ANY all non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_ANY nested collection, compileOption: PERMISSIVE + +- COLL_SOME bag literals, compileOption: PERMISSIVE + +- COLL_SOME bag literals, compileOption: LEGACY + +- COLL_SOME list expressions, compileOption: PERMISSIVE + +- COLL_SOME list expressions, compileOption: LEGACY + +- COLL_SOME single true, compileOption: PERMISSIVE + +- COLL_SOME single true, compileOption: LEGACY + +- COLL_SOME single false, compileOption: PERMISSIVE + +- COLL_SOME single false, compileOption: LEGACY + +- COLL_SOME nulls with true, compileOption: PERMISSIVE + +- COLL_SOME nulls with true, compileOption: LEGACY + +- COLL_SOME nulls with false, compileOption: PERMISSIVE + +- COLL_SOME nulls with false, compileOption: LEGACY + +- COLL_SOME nulls only, compileOption: PERMISSIVE + +- COLL_SOME nulls only, compileOption: LEGACY + +- COLL_SOME null, compileOption: PERMISSIVE + +- COLL_SOME null, compileOption: LEGACY + +- COLL_SOME list of missing element, compileOption: PERMISSIVE + +- COLL_SOME list of missing element, compileOption: LEGACY + +- COLL_SOME bag of missing elements, compileOption: PERMISSIVE + +- COLL_SOME bag of missing elements, compileOption: LEGACY + +- COLL_SOME some empty, compileOption: PERMISSIVE + +- COLL_SOME some empty, compileOption: LEGACY + +- COLL_SOME one non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_SOME all non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_SOME nested collection, compileOption: PERMISSIVE + +- COLL_EVERY bag literals, compileOption: PERMISSIVE + +- COLL_EVERY bag literals, compileOption: LEGACY + +- COLL_EVERY list expressions, compileOption: PERMISSIVE + +- COLL_EVERY list expressions, compileOption: LEGACY + +- COLL_EVERY single true, compileOption: PERMISSIVE + +- COLL_EVERY single true, compileOption: LEGACY + +- COLL_EVERY single false, compileOption: PERMISSIVE + +- COLL_EVERY single false, compileOption: LEGACY + +- COLL_EVERY null and missing with true, compileOption: PERMISSIVE + +- COLL_EVERY null and missing with true, compileOption: LEGACY + +- COLL_EVERY null with false, compileOption: PERMISSIVE + +- COLL_EVERY null with false, compileOption: LEGACY + +- COLL_EVERY null and missing only, compileOption: PERMISSIVE + +- COLL_EVERY null and missing only, compileOption: LEGACY + +- COLL_EVERY null, compileOption: PERMISSIVE + +- COLL_EVERY null, compileOption: LEGACY + +- COLL_EVERY list of missing element, compileOption: PERMISSIVE + +- COLL_EVERY list of missing element, compileOption: LEGACY + +- COLL_EVERY bag of missing elements, compileOption: PERMISSIVE + +- COLL_EVERY bag of missing elements, compileOption: LEGACY + +- COLL_EVERY empty collection, compileOption: PERMISSIVE + +- COLL_EVERY empty collection, compileOption: LEGACY + +- COLL_EVERY one non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_EVERY all non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_EVERY nested collection, compileOption: PERMISSIVE + +- selectValueCollAggregate, compileOption: PERMISSIVE + +- selectValueCollAggregate, compileOption: LEGACY + +- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67Z`), compileOption: PERMISSIVE + +- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67Z`), compileOption: LEGACY + +- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: PERMISSIVE + +- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: LEGACY + +- offset 2^63, compileOption: PERMISSIVE + +- offset 2^63, compileOption: LEGACY + +- SELECT supplierId_missings FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE + +- SELECT p.supplierId_missings FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE + +- SELECT VALUE { 'supplierId_missings' : p.supplierId_missings } FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE + +- SELECT supplierId_mixed FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE + +- SELECT p.supplierId_mixed FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE + +- SELECT VALUE { 'supplierId_mixed' : p.supplierId_mixed } FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE + +- SELECT regionId, supplierId_missings FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE + +- SELECT p.regionId, p.supplierId_missings FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE + +- SELECT VALUE { 'regionId': p.regionId, 'supplierId_missings': p.supplierId_missings } FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE + +- SELECT regionId, supplierId_mixed FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE + +- SELECT regionId, p.supplierId_mixed FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE + +- SELECT VALUE { 'regionId': p.regionId, 'supplierId_mixed': p.supplierId_mixed } FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE + +- SELECT with nested aggregates (complex) 2, compileOption: PERMISSIVE + +- SELECT with nested aggregates (complex) 2, compileOption: LEGACY + +
+ +### Conformance comparison report-Cross Commit-LEGACY +| | Base (HEAD) | HEAD | +/- | +| --- | ---: | ---: | ---: | +| % Passing | 92.47% | 92.47% | 0.00% | +| :white_check_mark: Passing | 5380 | 5380 | 0 | +| :x: Failing | 438 | 438 | 0 | +| :large_orange_diamond: Ignored | 0 | 0 | 0 | +| Total Tests | 5818 | 5818 | 0 | +Number passing in both: 5380 + +Number failing in both: 438 + +Number passing in Base (HEAD) but now fail: 0 + +Number failing in Base (HEAD) but now pass: 0 + +### Conformance comparison report-Cross Commit-EVAL +| | Base (HEAD) | HEAD | +/- | +| --- | ---: | ---: | ---: | +| % Passing | 82.37% | 82.37% | 0.00% | +| :white_check_mark: Passing | 4792 | 4792 | 0 | +| :x: Failing | 1026 | 1026 | 0 | +| :large_orange_diamond: Ignored | 0 | 0 | 0 | +| Total Tests | 5818 | 5818 | 0 | +Number passing in both: 4792 + +Number failing in both: 1026 + +Number passing in Base (HEAD) but now fail: 0 + +Number failing in Base (HEAD) but now pass: 0 + +### Conformance comparison report-Cross Engine +| | Base (legacy) | eval | +/- | +| --- | ---: | ---: | ---: | +| % Passing | 92.47% | 82.37% | -10.11% | +| :white_check_mark: Passing | 5380 | 4792 | -588 | +| :x: Failing | 438 | 1026 | 588 | +| :large_orange_diamond: Ignored | 0 | 0 | 0 | +| Total Tests | 5818 | 5818 | 0 | +Number passing in both: 4614 + +Number failing in both: 260 + +Number passing in legacy engine but fail in eval engine: 766 + +Number failing in legacy engine but pass in eval engine: 178 +:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) are passing in legacy but fail in eval: +
Click here to see + + +- equiv wildcard steps struct, compileOption: PERMISSIVE +- equiv wildcard steps struct, compileOption: LEGACY +- equiv path expression with wildcard steps, compileOption: PERMISSIVE +- equiv path expression with wildcard steps, compileOption: LEGACY +- equiv path collection expression with wildcard steps, compileOption: PERMISSIVE +- equiv path collection expression with wildcard steps, compileOption: LEGACY +- equiv attribute value pair unpivot missing, compileOption: PERMISSIVE +- equiv left join, compileOption: PERMISSIVE +- equiv left join, compileOption: LEGACY +- Example 6 — Value Coercion, compileOption: PERMISSIVE +- Example 6 — Value Coercion, compileOption: LEGACY +- path on string, compileOption: PERMISSIVE +- tuple navigation missing attribute dot notation, compileOption: PERMISSIVE +- tuple navigation missing attribute array notation, compileOption: PERMISSIVE +- array navigation with wrongly typed array index, compileOption: PERMISSIVE +- single source FROM with scalar, compileOption: LEGACY +- single source FROM with tuple, compileOption: LEGACY +- single source FROM with absent value null, compileOption: LEGACY +- single source FROM with absent value missing, compileOption: LEGACY +- tuple constructor and mistyped attribute name, compileOption: PERMISSIVE +- attribute value evaluates to MISSING, compileOption: LEGACY +- array element evaluates to MISSING, compileOption: LEGACY +- bag element evaluates to MISSING, compileOption: LEGACY +- bag element evaluates to MISSING in bag constructor, compileOption: LEGACY +- pivot into a tuple with invalid attribute name, compileOption: LEGACY +- missing value in arithmetic expression, compileOption: PERMISSIVE +- data type mismatch in comparison expression, compileOption: PERMISSIVE +- data type mismatch in logical expression, compileOption: PERMISSIVE +- equality of scalar missing, compileOption: PERMISSIVE +- equality of same element bags, compileOption: PERMISSIVE +- equality of same element bags, compileOption: LEGACY +- WHERE clause eliminating absent values, compileOption: PERMISSIVE +- WHERE clause eliminating absent values, compileOption: LEGACY +- group by with absent values, compileOption: LEGACY +- group by with differenciated absent values, compileOption: LEGACY +- Right with variables, compileOption: PERMISSIVE +- Right with variables, compileOption: LEGACY +- Right with spots, compileOption: PERMISSIVE +- Right with spots, compileOption: LEGACY +- Right shorthand, compileOption: PERMISSIVE +- Right shorthand, compileOption: LEGACY +- Left with variables, compileOption: PERMISSIVE +- Left with variables, compileOption: LEGACY +- Left with spots, compileOption: PERMISSIVE +- Left with spots, compileOption: LEGACY +- Left shorthand, compileOption: PERMISSIVE +- Left shorthand, compileOption: LEGACY +- Left+right with variables, compileOption: PERMISSIVE +- Left+right with variables, compileOption: LEGACY +- Left+right with spots, compileOption: PERMISSIVE +- Left+right with spots, compileOption: LEGACY +- Left+right shorthand, compileOption: PERMISSIVE +- Left+right shorthand, compileOption: LEGACY +- Left+right with variables and label, compileOption: PERMISSIVE +- Left+right with variables and label, compileOption: LEGACY +- Undirected with variables, compileOption: PERMISSIVE +- Undirected with variables, compileOption: LEGACY +- Undirected with spots, compileOption: PERMISSIVE +- Undirected with spots, compileOption: LEGACY +- Undirected shorthand, compileOption: PERMISSIVE +- Undirected shorthand, compileOption: LEGACY +- Undirected with variables and label, compileOption: PERMISSIVE +- Undirected with variables and label, compileOption: LEGACY +- Right+undirected with variables, compileOption: PERMISSIVE +- Right+undirected with variables, compileOption: LEGACY +- Right+undirected with spots, compileOption: PERMISSIVE +- Right+undirected with spots, compileOption: LEGACY +- Right+undirected shorthand, compileOption: PERMISSIVE +- Right+undirected shorthand, compileOption: LEGACY +- Right+undirected with variables and labels, compileOption: PERMISSIVE +- Right+undirected with variables and labels, compileOption: LEGACY +- Left+undirected with variables, compileOption: PERMISSIVE +- Left+undirected with variables, compileOption: LEGACY +- Left+undirected with spots, compileOption: PERMISSIVE +- Left+undirected with spots, compileOption: LEGACY +- Left+undirected shorthand, compileOption: PERMISSIVE +- Left+undirected shorthand, compileOption: LEGACY +- Left+undirected with variables and label, compileOption: PERMISSIVE +- Left+undirected with variables and label, compileOption: LEGACY +- Left+right+undirected with variables, compileOption: PERMISSIVE +- Left+right+undirected with variables, compileOption: LEGACY +- Left+right+undirected with spots, compileOption: PERMISSIVE +- Left+right+undirected with spots, compileOption: LEGACY +- Left+right+undirected shorthand, compileOption: PERMISSIVE +- Left+right+undirected shorthand, compileOption: LEGACY +- (N0E0 MATCH (x)), compileOption: PERMISSIVE +- (N0E0 MATCH (x)), compileOption: LEGACY +- (N0E0 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N0E0 MATCH -[y]-> ), compileOption: LEGACY +- (N0E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N0E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N1E0 MATCH (x)), compileOption: PERMISSIVE +- (N1E0 MATCH (x)), compileOption: LEGACY +- (N1E0 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N1E0 MATCH -[y]-> ), compileOption: LEGACY +- (N1E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N1E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N1E0 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE +- (N1E0 MATCH (x)-[y]->(x) ), compileOption: LEGACY +- (N1U1 MATCH (x)), compileOption: PERMISSIVE +- (N1U1 MATCH (x)), compileOption: LEGACY +- (N1U1 MATCH ~[y]~ ), compileOption: PERMISSIVE +- (N1U1 MATCH ~[y]~ ), compileOption: LEGACY +- (N1U1 MATCH (x)~[y]~(z) ), compileOption: PERMISSIVE +- (N1U1 MATCH (x)~[y]~(z) ), compileOption: LEGACY +- (N1U1 MATCH (x)~[y]~(x) ), compileOption: PERMISSIVE +- (N1U1 MATCH (x)~[y]~(x) ), compileOption: LEGACY +- (N1U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: PERMISSIVE +- (N1U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: LEGACY +- (N1D2 MATCH (x)), compileOption: PERMISSIVE +- (N1D2 MATCH (x)), compileOption: LEGACY +- (N1D2 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N1D2 MATCH -[y]-> ), compileOption: LEGACY +- (N1D2 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N1D2 MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N1D2 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE +- (N1D2 MATCH (x)-[y]->(x) ), compileOption: LEGACY +- (N1D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N1D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2E0 MATCH (x)), compileOption: PERMISSIVE +- (N2E0 MATCH (x)), compileOption: LEGACY +- (N2E0 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N2E0 MATCH -[y]-> ), compileOption: LEGACY +- (N2E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N2E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N2E0 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE +- (N2E0 MATCH (x)-[y]->(x) ), compileOption: LEGACY +- (N2D1 MATCH (x)), compileOption: PERMISSIVE +- (N2D1 MATCH (x)), compileOption: LEGACY +- (N2D1 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N2D1 MATCH -[y]-> ), compileOption: LEGACY +- (N2D1 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N2D1 MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N2D1 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE +- (N2D1 MATCH (x)-[y]->(x) ), compileOption: LEGACY +- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2U1 MATCH (x)), compileOption: PERMISSIVE +- (N2U1 MATCH (x)), compileOption: LEGACY +- (N2U1 MATCH ~[y]~ ), compileOption: PERMISSIVE +- (N2U1 MATCH ~[y]~ ), compileOption: LEGACY +- (N2U1 MATCH (x)~[y]~(z) ), compileOption: PERMISSIVE +- (N2U1 MATCH (x)~[y]~(z) ), compileOption: LEGACY +- (N2U1 MATCH (x)~[y]~(x) ), compileOption: PERMISSIVE +- (N2U1 MATCH (x)~[y]~(x) ), compileOption: LEGACY +- (N2U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: PERMISSIVE +- (N2U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: LEGACY +- (N2U1 MATCH (x1)~[y1]~(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2U1 MATCH (x1)~[y1]~(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2U1 MATCH (x1)-[y1]-(x2)~[y2]~(x3) ), compileOption: PERMISSIVE +- (N2U1 MATCH (x1)-[y1]-(x2)~[y2]~(x3) ), compileOption: LEGACY +- (N2U1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2U1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2D2 MATCH (x)), compileOption: PERMISSIVE +- (N2D2 MATCH (x)), compileOption: LEGACY +- (N2D2 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N2D2 MATCH -[y]-> ), compileOption: LEGACY +- (N2D2 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N2D2 MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N2D2 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE +- (N2D2 MATCH (x)-[y]->(x) ), compileOption: LEGACY +- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2D2c MATCH (x)), compileOption: PERMISSIVE +- (N2D2c MATCH (x)), compileOption: LEGACY +- (N2D2c MATCH -[y]-> ), compileOption: PERMISSIVE +- (N2D2c MATCH -[y]-> ), compileOption: LEGACY +- (N2D2c MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x)-[y]->(z) ), compileOption: LEGACY +- (N2D2c MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x)-[y]->(x) ), compileOption: LEGACY +- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x1) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x1) ), compileOption: LEGACY +- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: LEGACY +- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE +- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY +- (N2U2 MATCH (x)), compileOption: PERMISSIVE +- (N2U2 MATCH (x)), compileOption: LEGACY +- (N2U2 MATCH ~[y]~ ), compileOption: PERMISSIVE +- (N2U2 MATCH ~[y]~ ), compileOption: LEGACY +- (N2U2 MATCH (x)~[y]~(z) ), compileOption: PERMISSIVE +- (N2U2 MATCH (x)~[y]~(z) ), compileOption: LEGACY +- (N2U2 MATCH (x)~[y]~(x) ), compileOption: PERMISSIVE +- (N2U2 MATCH (x)~[y]~(x) ), compileOption: LEGACY +- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: PERMISSIVE +- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: LEGACY +- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x1) ), compileOption: PERMISSIVE +- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x1) ), compileOption: LEGACY +- cast to MISSING valid cases{value:"NULL"}, compileOption: PERMISSIVE +- cast to MISSING valid cases{value:"NULL"}, compileOption: LEGACY +- cast to MISSING valid cases{value:"MISSING"}, compileOption: PERMISSIVE +- cast to MISSING valid cases{value:"MISSING"}, compileOption: LEGACY +- cast to NULL valid cases{value:"MISSING"}, compileOption: PERMISSIVE +- cast to NULL valid cases{value:"MISSING"}, compileOption: LEGACY +- cast to int invalid target type{value:"`2017T`",target:"TIMESTAMP"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:" `{{\"\"}}` ",target:"CLOB"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:" `{{\"1\"}}` ",target:"CLOB"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"`{{}}`",target:"BLOB"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"[1, 2]",target:"LIST"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"[1]",target:"LIST"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"[]",target:"LIST"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"`(1 2)`",target:"SEXP"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"`(1)`",target:"SEXP"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"`()`",target:"SEXP"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"{'a': 1}",target:"STRUCT"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"{'a': '12'}",target:"STRUCT"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"{}",target:"STRUCT"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"<<1, 2>>",target:"BAG"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"<<1>>",target:"BAG"}, compileOption: PERMISSIVE +- cast to int invalid target type{value:"<<>>",target:"BAG"}, compileOption: PERMISSIVE +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE null "}, compileOption: PERMISSIVE +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE null "}, compileOption: LEGACY +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE '[' "}, compileOption: PERMISSIVE +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE '[' "}, compileOption: LEGACY +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE 'S1' ESCAPE null "}, compileOption: PERMISSIVE +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE 'S1' ESCAPE null "}, compileOption: LEGACY +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null "}, compileOption: PERMISSIVE +- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null "}, compileOption: LEGACY +- MISSING LIKE 'some pattern', compileOption: PERMISSIVE +- 'some value' LIKE MISSING, compileOption: PERMISSIVE +- MISSING LIKE MISSING, compileOption: PERMISSIVE +- NULL LIKE MISSING, compileOption: PERMISSIVE +- MISSING LIKE NULL, compileOption: PERMISSIVE +- MISSING LIKE 'some pattern' ESCAPE '/', compileOption: PERMISSIVE +- 'some value' LIKE MISSING ESCAPE '/', compileOption: PERMISSIVE +- 'some value' LIKE 'some pattern' ESCAPE MISSING, compileOption: PERMISSIVE +- NULL LIKE 'some pattern' ESCAPE MISSING, compileOption: PERMISSIVE +- 'some value' LIKE NULL ESCAPE MISSING, compileOption: PERMISSIVE +- outerUnionCoerceScalar, compileOption: PERMISSIVE +- outerUnionCoerceScalar, compileOption: LEGACY +- outerUnionCoerceStruct, compileOption: PERMISSIVE +- outerUnionCoerceStruct, compileOption: LEGACY +- outerUnionCoerceNullMissing, compileOption: PERMISSIVE +- outerUnionCoerceNullMissing, compileOption: LEGACY +- inPredicate, compileOption: PERMISSIVE +- inPredicate, compileOption: LEGACY +- inPredicateSingleItem, compileOption: PERMISSIVE +- inPredicateSingleItem, compileOption: LEGACY +- inPredicateSingleExpr, compileOption: PERMISSIVE +- inPredicateSingleExpr, compileOption: LEGACY +- inPredicateSingleItemListVar, compileOption: PERMISSIVE +- inPredicateSingleItemListVar, compileOption: LEGACY +- inPredicateSingleListVar, compileOption: PERMISSIVE +- inPredicateSingleListVar, compileOption: LEGACY +- inPredicateSubQuerySelectValue, compileOption: PERMISSIVE +- inPredicateSubQuerySelectValue, compileOption: LEGACY +- notInPredicate, compileOption: PERMISSIVE +- notInPredicate, compileOption: LEGACY +- notInPredicateSingleItem, compileOption: PERMISSIVE +- notInPredicateSingleItem, compileOption: LEGACY +- notInPredicateSingleExpr, compileOption: PERMISSIVE +- notInPredicateSingleItemListVar, compileOption: PERMISSIVE +- notInPredicateSingleItemListVar, compileOption: LEGACY +- notInPredicateSingleListVar, compileOption: PERMISSIVE +- notInPredicateSingleListVar, compileOption: LEGACY +- notInPredicateSubQuerySelectValue, compileOption: PERMISSIVE +- notInPredicateSubQuerySelectValue, compileOption: LEGACY +- inPredicateWithTableConstructor, compileOption: PERMISSIVE +- inPredicateWithTableConstructor, compileOption: LEGACY +- notInPredicateWithTableConstructor, compileOption: PERMISSIVE +- notInPredicateWithTableConstructor, compileOption: LEGACY +- inPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE +- inPredicateWithExpressionOnRightSide, compileOption: LEGACY +- notInPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE +- notInPredicateWithExpressionOnRightSide, compileOption: LEGACY +- || valid cases{lparam:"null",rparam:"missing",result:missing::null}, compileOption: PERMISSIVE +- || valid cases{lparam:"missing",rparam:"null",result:missing::null}, compileOption: PERMISSIVE +- || valid cases{lparam:"missing",rparam:"'b'",result:missing::null}, compileOption: PERMISSIVE +- || valid cases{lparam:"'a'",rparam:"missing",result:missing::null}, compileOption: PERMISSIVE +- || valid cases{lparam:"missing",rparam:"missing",result:missing::null}, compileOption: PERMISSIVE +- repeatingDecimal, compileOption: PERMISSIVE +- repeatingDecimal, compileOption: LEGACY +- repeatingDecimalHigherPrecision, compileOption: PERMISSIVE +- repeatingDecimalHigherPrecision, compileOption: LEGACY +- divDecimalInt, compileOption: PERMISSIVE +- divDecimalInt, compileOption: LEGACY +- subtractionOutOfAllowedPrecision, compileOption: PERMISSIVE +- subtractionOutOfAllowedPrecision, compileOption: LEGACY +- equalListDifferentTypesTrue, compileOption: PERMISSIVE +- equalListDifferentTypesTrue, compileOption: LEGACY +- simpleCase, compileOption: PERMISSIVE +- simpleCase, compileOption: LEGACY +- simpleCaseNoElse, compileOption: PERMISSIVE +- simpleCaseNoElse, compileOption: LEGACY +- searchedCase, compileOption: PERMISSIVE +- searchedCase, compileOption: LEGACY +- searchedCaseNoElse, compileOption: PERMISSIVE +- searchedCaseNoElse, compileOption: LEGACY +- dateTimePartsAsVariableNames, compileOption: LEGACY +- pathDotMissingAttribute, compileOption: LEGACY +- pathMissingDotName, compileOption: PERMISSIVE +- pathMissingDotName, compileOption: LEGACY +- pathNullDotName, compileOption: PERMISSIVE +- pathNullDotName, compileOption: LEGACY +- pathIndexBagLiteral, compileOption: PERMISSIVE +- pathIndexBagLiteral, compileOption: LEGACY +- pathIndexStructLiteral, compileOption: PERMISSIVE +- pathIndexStructLiteral, compileOption: LEGACY +- pathIndexStructOutOfBoundsLowLiteral, compileOption: PERMISSIVE +- pathIndexStructOutOfBoundsLowLiteral, compileOption: LEGACY +- pathIndexStructOutOfBoundsHighLiteral, compileOption: PERMISSIVE +- pathIndexStructOutOfBoundsHighLiteral, compileOption: LEGACY +- pathDoubleWildCard, compileOption: PERMISSIVE +- pathDoubleWildCard, compileOption: LEGACY +- pathWildCardOverScalar, compileOption: LEGACY +- pathUnpivotWildCardOverScalar, compileOption: LEGACY +- pathWildCardOverScalarMultiple, compileOption: LEGACY +- pathUnpivotWildCardOverScalarMultiple, compileOption: LEGACY +- pathWildCardOverStructMultiple, compileOption: LEGACY +- unpivotMissing, compileOption: PERMISSIVE +- unpivotMissing, compileOption: LEGACY +- unpivotEmptyStruct, compileOption: PERMISSIVE +- unpivotEmptyStruct, compileOption: LEGACY +- unpivotStructWithMissingField, compileOption: PERMISSIVE +- unpivotStructWithMissingField, compileOption: LEGACY +- unpivotMissingWithAsAndAt, compileOption: LEGACY +- unpivotMissingCrossJoinWithAsAndAt, compileOption: LEGACY +- pathUnpivotEmptyStruct1, compileOption: PERMISSIVE +- pathUnpivotEmptyStruct1, compileOption: LEGACY +- pathUnpivotEmptyStruct2, compileOption: PERMISSIVE +- pathUnpivotEmptyStruct2, compileOption: LEGACY +- pathUnpivotEmptyStruct3, compileOption: PERMISSIVE +- pathUnpivotEmptyStruct3, compileOption: LEGACY +- dotted path expression with quoted field name accesses field UNAMBIGUOUS_FIELD (uppercase), compileOption: LEGACY +- subscript with variable in lowercase, compileOption: PERMISSIVE +- subscript with variable in lowercase, compileOption: LEGACY +- subscript with variable in uppercase, compileOption: PERMISSIVE +- subscript with variable in uppercase, compileOption: LEGACY +- subscript with variable in mixed case, compileOption: PERMISSIVE +- subscript with variable in mixed case, compileOption: LEGACY +- subscript with non-existent variable in lowercase, compileOption: PERMISSIVE +- subscript with non-existent variable in uppercase, compileOption: PERMISSIVE +- null comparison{sql:"MISSING IS NULL",result:true}, compileOption: PERMISSIVE +- null comparison{sql:"MISSING IS NULL",result:true}, compileOption: LEGACY +- null comparison{sql:"MISSING = NULL",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"NULL = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.sexp` = NULL",result:null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.sexp` = NULL",result:null}, compileOption: LEGACY +- null comparison{sql:"`null.null` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.bool` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.int` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.decimal` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.string` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.symbol` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.clob` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.blob` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.list` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.struct` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- null comparison{sql:"`null.sexp` = MISSING",result:missing::null}, compileOption: PERMISSIVE +- concatenation with null values{left:"MISSING",right:"MISSING"}, compileOption: PERMISSIVE +- concatenation with null values{left:"''",right:"MISSING"}, compileOption: PERMISSIVE +- concatenation with null values{left:"MISSING",right:"''"}, compileOption: PERMISSIVE +- concatenation with null values{left:"'a'",right:"MISSING"}, compileOption: PERMISSIVE +- concatenation with null values{left:"MISSING",right:"'b'"}, compileOption: PERMISSIVE +- char_length null and missing propagation{in:"missing",result:(success missing::null)}, compileOption: PERMISSIVE +- character_length null and missing propagation{in:"missing",result:(success missing::null)}, compileOption: PERMISSIVE +- CHARACTER_LENGTH invalid type, compileOption: PERMISSIVE +- upper null and missing propagation{param:"missing"}, compileOption: PERMISSIVE +- cardinality null and missing propagation{param:"missing"}, compileOption: PERMISSIVE +- CARDINALITY('foo') type mismatch, compileOption: PERMISSIVE +- EXTRACT(YEAR FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(MONTH FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(DAY FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(HOUR FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(MINUTE FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(SECOND FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(TIMEZONE_HOUR FROM MISSING), compileOption: PERMISSIVE +- EXTRACT(TIMEZONE_MINUTE FROM MISSING), compileOption: PERMISSIVE +- invalid extract year from time, compileOption: PERMISSIVE +- invalid extract month from time, compileOption: PERMISSIVE +- invalid extract day from time, compileOption: PERMISSIVE +- invalid extract month from time with time zone, compileOption: PERMISSIVE +- invalid extract day from time with time zone, compileOption: PERMISSIVE +- POSITION MISSING in string, compileOption: PERMISSIVE +- POSITION string in MISSING, compileOption: PERMISSIVE +- POSITION NULL in MISSING, compileOption: PERMISSIVE +- POSITION MISSING in NULL, compileOption: PERMISSIVE +- POSITION MISSING in MISSING, compileOption: PERMISSIVE +- POSITION invalid type in string, compileOption: PERMISSIVE +- POSITION string in invalid type, compileOption: PERMISSIVE +- substring null and missing propagation 2 arguments{target:"missing",start_pos:"1"}, compileOption: PERMISSIVE +- substring null and missing propagation 2 arguments{target:"''",start_pos:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 2 arguments{target:"missing",start_pos:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 2 arguments{target:"null",start_pos:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 2 arguments{target:"missing",start_pos:"null"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"null",start_pos:"1",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"null",start_pos:"null",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"null",start_pos:"missing",quantity:"1"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"null",start_pos:"missing",quantity:"null"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"null",start_pos:"missing",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"1",quantity:"1"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"1",quantity:"null"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"1",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"null",quantity:"1"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"null",quantity:"null"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"null",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"missing",quantity:"1"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"missing",quantity:"null"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"missing",start_pos:"missing",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"''",start_pos:"1",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"''",start_pos:"null",quantity:"missing"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"''",start_pos:"missing",quantity:"1"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"''",start_pos:"missing",quantity:"null"}, compileOption: PERMISSIVE +- substring null and missing propagation 3 arguments{target:"''",start_pos:"missing",quantity:"missing"}, compileOption: PERMISSIVE +- lower null and missing propagation{param:"missing"}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"1",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"1",result:null}, compileOption: LEGACY +- nullif valid cases{first:"1.0",second:"1",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"1.0",second:"1",result:null}, compileOption: LEGACY +- nullif valid cases{first:"1",second:"2",result:1}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"2",result:1}, compileOption: LEGACY +- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: PERMISSIVE +- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: LEGACY +- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: LEGACY +- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: LEGACY +- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: PERMISSIVE +- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: LEGACY +- nullif valid cases{first:"1",second:"null",result:1}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"null",result:1}, compileOption: LEGACY +- nullif valid cases{first:"null",second:"1",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"null",second:"1",result:null}, compileOption: LEGACY +- nullif valid cases{first:"null",second:"null",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"null",second:"null",result:null}, compileOption: LEGACY +- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: LEGACY +- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: PERMISSIVE +- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: LEGACY +- ABS(MISSING) null propogation, compileOption: PERMISSIVE +- ABS('foo'), compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(leading from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(trailing from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(both from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(leading '' from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(trailing '' from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(both '' from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(leading missing from '')"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(trailing missing from '')"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(both missing from '')"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(leading null from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(trailing null from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(both null from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(leading missing from null)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(trailing missing from null)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(both missing from null)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(leading missing from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(trailing missing from missing)"}, compileOption: PERMISSIVE +- trim null and missing propagation{sql:"trim(both missing from missing)"}, compileOption: PERMISSIVE +- MOD(MISSING, 3), compileOption: PERMISSIVE +- MOD(3, MISSING), compileOption: PERMISSIVE +- MOD(MISSING, NULL), compileOption: PERMISSIVE +- MOD(NULL, MISSING), compileOption: PERMISSIVE +- MOD(MISSING, 'some string'), compileOption: PERMISSIVE +- MOD('some string', MISSING), compileOption: PERMISSIVE +- MOD(3, 'some string'), compileOption: PERMISSIVE +- MOD('some string', 3), compileOption: PERMISSIVE +- BIT_LENGTH MISSING, compileOption: PERMISSIVE +- BIT_LENGTH invalid type, compileOption: PERMISSIVE +- OCTET_LENGTH MISSING, compileOption: PERMISSIVE +- OCTET_LENGTH invalid type, compileOption: PERMISSIVE +- OVERLAY MISSING, compileOption: PERMISSIVE +- OVERLAY PLACING MISSING, compileOption: PERMISSIVE +- OVERLAY FROM MISSING, compileOption: PERMISSIVE +- OVERLAY FOR MISSING, compileOption: PERMISSIVE +- OVERLAY mismatched type, compileOption: PERMISSIVE +- OVERLAY PLACING mismatched type, compileOption: PERMISSIVE +- OVERLAY FROM mismatched type, compileOption: PERMISSIVE +- OVERLAY FOR mismatched type, compileOption: PERMISSIVE +- coalesce valid cases{args:"1",result:(success 1)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"1",result:(success 1)}, compileOption: LEGACY +- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: LEGACY +- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: LEGACY +- coalesce valid cases{args:"missing, 3",result:(success 3)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"missing, 3",result:(success 3)}, compileOption: LEGACY +- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: LEGACY +- coalesce valid cases{args:"null, missing, 3",result:(success 3)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"null, missing, 3",result:(success 3)}, compileOption: LEGACY +- coalesce valid cases{args:"null, missing, null, null, missing, 9, 4, 5, 6",result:(success 9)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"null, missing, null, null, missing, 9, 4, 5, 6",result:(success 9)}, compileOption: LEGACY +- Empty Symbol in table, compileOption: LEGACY +- Empty Symbol in globals, compileOption: LEGACY +- Empty Symbol in alias, compileOption: LEGACY +- functionCall, compileOption: PERMISSIVE +- functionCall, compileOption: LEGACY +- division with mixed StaticType, compileOption: PERMISSIVE +- division with mixed StaticType, compileOption: LEGACY +- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: PERMISSIVE +- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: LEGACY +- Example 3 — Outer union of Heterogenous Relations, compileOption: PERMISSIVE +- Example 3 — Outer union of Heterogenous Relations, compileOption: LEGACY +- Example 6 — Value Coercion; Coercion of single value, compileOption: PERMISSIVE +- Example 6 — Value Coercion; Coercion of single value, compileOption: LEGACY +- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: PERMISSIVE +- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: LEGACY +- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: PERMISSIVE +- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: LEGACY +- Example 7 — result is the empty bag, compileOption: PERMISSIVE +- Example 7 — result is the empty bag, compileOption: LEGACY +- undefinedUnqualifiedVariableWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE +- undefinedUnqualifiedVariableIsNullExprWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE +- undefinedUnqualifiedVariableIsMissingExprWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE +- undefinedUnqualifiedVariableInSelectWithUndefinedVariableBehaviorMissing, compileOption: LEGACY +- join on column - all column values non-null, compileOption: PERMISSIVE +- join on column - all column values non-null, compileOption: LEGACY +- join on column - some column values are null, compileOption: PERMISSIVE +- join on column - some column values are null, compileOption: LEGACY +- join on column - 1 table contains 1 row with the value null, compileOption: PERMISSIVE +- join on column - 1 table contains 1 row with the value null, compileOption: LEGACY +- join on column - ON condition = false, compileOption: PERMISSIVE +- join on column - ON condition = false, compileOption: LEGACY +- PG_JOIN_01, compileOption: PERMISSIVE +- PG_JOIN_01, compileOption: LEGACY +- PG_JOIN_02, compileOption: PERMISSIVE +- PG_JOIN_02, compileOption: LEGACY +- PG_JOIN_03, compileOption: PERMISSIVE +- PG_JOIN_03, compileOption: LEGACY +- PG_JOIN_06, compileOption: PERMISSIVE +- PG_JOIN_06, compileOption: LEGACY +- PG_JOIN_07, compileOption: PERMISSIVE +- PG_JOIN_07, compileOption: LEGACY +- PG_JOIN_08, compileOption: PERMISSIVE +- PG_JOIN_08, compileOption: LEGACY +- PG_JOIN_09, compileOption: PERMISSIVE +- PG_JOIN_09, compileOption: LEGACY +- PG_JOIN_10, compileOption: PERMISSIVE +- PG_JOIN_10, compileOption: LEGACY +- offset 0, compileOption: PERMISSIVE +- offset 0, compileOption: LEGACY +- offset 1, compileOption: PERMISSIVE +- offset 1, compileOption: LEGACY +- offset 2, compileOption: PERMISSIVE +- offset 2, compileOption: LEGACY +- limit 1 offset 1, compileOption: PERMISSIVE +- limit 1 offset 1, compileOption: LEGACY +- limit 10 offset 1, compileOption: PERMISSIVE +- limit 10 offset 1, compileOption: LEGACY +- limit 2 offset 2, compileOption: PERMISSIVE +- limit 2 offset 2, compileOption: LEGACY +- limit offset after group by, compileOption: PERMISSIVE +- limit offset after group by, compileOption: LEGACY +- offset 2-1, compileOption: PERMISSIVE +- offset 2-1, compileOption: LEGACY +- offset 2+1, compileOption: PERMISSIVE +- offset 2+1, compileOption: LEGACY +- offset 2*1, compileOption: PERMISSIVE +- offset 2*1, compileOption: LEGACY +- offset 2/1, compileOption: PERMISSIVE +- offset 2/1, compileOption: LEGACY +- offset group by having, compileOption: PERMISSIVE +- offset group by having, compileOption: LEGACY +- offset with pivot, compileOption: PERMISSIVE +- offset with pivot, compileOption: LEGACY +- pivotBadFieldType, compileOption: LEGACY +- col1 asc, compileOption: PERMISSIVE +- col1 asc, compileOption: LEGACY +- col1 desc, compileOption: PERMISSIVE +- col1 desc, compileOption: LEGACY +- col1 asc, col2 asc, compileOption: PERMISSIVE +- col1 asc, col2 asc, compileOption: LEGACY +- price desc, productId asc, compileOption: PERMISSIVE +- price desc, productId asc, compileOption: LEGACY +- supplierId_nulls nulls last, compileOption: PERMISSIVE +- supplierId_nulls nulls last, compileOption: LEGACY +- supplierId_nulls nulls first, compileOption: PERMISSIVE +- supplierId_nulls nulls first, compileOption: LEGACY +- supplierId_nulls asc nulls last, productId asc, compileOption: PERMISSIVE +- supplierId_nulls asc nulls last, productId asc, compileOption: LEGACY +- nulls first as default for supplierId_nulls desc, compileOption: PERMISSIVE +- nulls first as default for supplierId_nulls desc, compileOption: LEGACY +- group and order by asc sellerId, compileOption: PERMISSIVE +- group and order by asc sellerId, compileOption: LEGACY +- group and order by desc sellerId, compileOption: PERMISSIVE +- group and order by desc sellerId, compileOption: LEGACY +- group and order by DESC (NULLS FIRST as default), compileOption: PERMISSIVE +- group and order by DESC (NULLS FIRST as default), compileOption: LEGACY +- group and order by ASC (NULLS LAST as default), compileOption: PERMISSIVE +- group and order by ASC (NULLS LAST as default), compileOption: LEGACY +- group and place nulls first (asc as default), compileOption: PERMISSIVE +- group and place nulls first (asc as default), compileOption: LEGACY +- group and place nulls last (asc as default), compileOption: PERMISSIVE +- group and place nulls last (asc as default), compileOption: LEGACY +- group and order by asc and place nulls first, compileOption: PERMISSIVE +- group and order by asc and place nulls first, compileOption: LEGACY +- false before true (ASC), compileOption: PERMISSIVE +- false before true (ASC), compileOption: LEGACY +- true before false (DESC), compileOption: PERMISSIVE +- true before false (DESC), compileOption: LEGACY +- nan before -inf, then numeric values then +inf (ASC), compileOption: PERMISSIVE +- nan before -inf, then numeric values then +inf (ASC), compileOption: LEGACY +- +inf before numeric values then -inf then nan (DESC), compileOption: PERMISSIVE +- +inf before numeric values then -inf then nan (DESC), compileOption: LEGACY +- LOB types follow their lexicographical ordering by octet (ASC), compileOption: PERMISSIVE +- LOB types follow their lexicographical ordering by octet (ASC), compileOption: LEGACY +- LOB types should ordered (DESC), compileOption: PERMISSIVE +- LOB types should ordered (DESC), compileOption: LEGACY +- shorter array comes first (ASC), compileOption: PERMISSIVE +- shorter array comes first (ASC), compileOption: LEGACY +- longer array comes first (DESC), compileOption: PERMISSIVE +- longer array comes first (DESC), compileOption: LEGACY +- lists compared lexicographically based on comparison of elements (ASC), compileOption: PERMISSIVE +- lists compared lexicographically based on comparison of elements (ASC), compileOption: LEGACY +- lists compared lexicographically based on comparison of elements (DESC), compileOption: PERMISSIVE +- lists compared lexicographically based on comparison of elements (DESC), compileOption: LEGACY +- lists items should be ordered by data types (ASC) (nulls last as default for asc), compileOption: PERMISSIVE +- lists items should be ordered by data types (ASC) (nulls last as default for asc), compileOption: LEGACY +- lists items should be ordered by data types (DESC) (nulls first as default for desc), compileOption: PERMISSIVE +- lists items should be ordered by data types (DESC) (nulls first as default for desc), compileOption: LEGACY +- structs compared lexicographically first by key then by value (ASC), compileOption: PERMISSIVE +- structs compared lexicographically first by key then by value (ASC), compileOption: LEGACY +- structs compared lexicographically first by key then by value (DESC), compileOption: PERMISSIVE +- structs compared lexicographically first by key then by value (DESC), compileOption: LEGACY +- structs should be ordered by data types (ASC) (nulls last as default for asc), compileOption: PERMISSIVE +- structs should be ordered by data types (ASC) (nulls last as default for asc), compileOption: LEGACY +- structs should be ordered by data types (DESC) (nulls first as default for desc), compileOption: PERMISSIVE +- structs should be ordered by data types (DESC) (nulls first as default for desc), compileOption: LEGACY +- bags compared as sorted lists (ASC), compileOption: PERMISSIVE +- bags compared as sorted lists (ASC), compileOption: LEGACY +- bags compared as sorted lists (DESC), compileOption: PERMISSIVE +- bags compared as sorted lists (DESC), compileOption: LEGACY +- testing alias support, compileOption: PERMISSIVE +- testing alias support, compileOption: LEGACY +- testing nested alias support, compileOption: PERMISSIVE +- testing nested alias support, compileOption: LEGACY +- Empty Output (ordered), compileOption: PERMISSIVE +- Empty Output (ordered), compileOption: LEGACY +- GROUP BY binding referenced in FROM clause, compileOption: PERMISSIVE +- GROUP BY binding referenced in WHERE clause, compileOption: PERMISSIVE +- GROUP AS binding referenced in FROM clause, compileOption: PERMISSIVE +- GROUP AS binding referenced in WHERE clause, compileOption: PERMISSIVE +- SELECT COUNT(1) AS the_count, COUNT(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, SUM(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, MIN(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, MAX(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, AVG(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, COUNT(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, SUM(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, MIN(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, MAX(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT COUNT(1) AS the_count, AVG(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, COUNT(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, SUM(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, MIN(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, MAX(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, AVG(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, COUNT(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, SUM(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, MIN(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, MAX(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT categoryId, COUNT(1) AS the_count, AVG(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, COUNT(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, SUM(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, MIN(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, MAX(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, AVG(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, COUNT(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, SUM(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, MIN(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, MAX(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- SELECT p.categoryId, COUNT(1) AS the_count, AVG(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY +- Expression with multiple subqueriees containing aggregates : CAST((SELECT COUNT(1) FROM products) AS LIST)[0]._1 / CAST((SELECT COUNT(1) FROM suppliers) AS LIST)[0]._1, compileOption: PERMISSIVE +- Expression with multiple subqueriees containing aggregates : CAST((SELECT COUNT(1) FROM products) AS LIST)[0]._1 / CAST((SELECT COUNT(1) FROM suppliers) AS LIST)[0]._1, compileOption: LEGACY +- Aggregates with subquery containing another aggregate : SELECT COUNT(1) + CAST((SELECT SUM(numInStock) FROM products) AS LIST)[0]._1 as a_number FROM products, compileOption: PERMISSIVE +- Aggregates with subquery containing another aggregate : SELECT COUNT(1) + CAST((SELECT SUM(numInStock) FROM products) AS LIST)[0]._1 as a_number FROM products, compileOption: LEGACY +- GROUP BY with JOIN : SELECT supplierName, COUNT(*) as the_count FROM suppliers AS s INNER JOIN products AS p ON s.supplierId = p.supplierId GROUP BY supplierName, compileOption: PERMISSIVE +- GROUP BY with JOIN : SELECT supplierName, COUNT(*) as the_count FROM suppliers AS s INNER JOIN products AS p ON s.supplierId = p.supplierId GROUP BY supplierName, compileOption: LEGACY +- SELECT VALUE with nested aggregates : SELECT VALUE (SELECT SUM(outerFromSource.col1) AS the_sum FROM <<1>>) FROM simple_1_col_1_group as outerFromSource, compileOption: PERMISSIVE +- SELECT VALUE with nested aggregates : SELECT VALUE (SELECT SUM(outerFromSource.col1) AS the_sum FROM <<1>>) FROM simple_1_col_1_group as outerFromSource, compileOption: LEGACY +- SELECT col1, g FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE +- SELECT col1, g FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: LEGACY +- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE +- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: LEGACY +- SELECT col1, g FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE +- SELECT col1, g FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: LEGACY +- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE +- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: LEGACY +- MYSQL_SELECT_20, compileOption: PERMISSIVE +- MYSQL_SELECT_20, compileOption: LEGACY +- MYSQL_SELECT_21, compileOption: PERMISSIVE +- MYSQL_SELECT_21, compileOption: LEGACY +- MYSQL_SELECT_26, compileOption: PERMISSIVE +- MYSQL_SELECT_26, compileOption: LEGACY +- selectFromScalarAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE +- selectFromScalarAndAtUnpivotWildCardOverScalar, compileOption: LEGACY +- selectFromListAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE +- selectFromListAndAtUnpivotWildCardOverScalar, compileOption: LEGACY +- selectFromBagAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE +- selectFromBagAndAtUnpivotWildCardOverScalar, compileOption: LEGACY +- selectPathUnpivotWildCardOverStructMultiple, compileOption: PERMISSIVE +- selectPathUnpivotWildCardOverStructMultiple, compileOption: LEGACY +- selectStarSingleSourceHoisted, compileOption: PERMISSIVE +- selectStarSingleSourceHoisted, compileOption: LEGACY +- ordinalAccessWithNegativeIndex, compileOption: LEGACY +- ordinalAccessWithNegativeIndexAndBindings, compileOption: LEGACY +- rangeOverScalar, compileOption: LEGACY +- rangeTwiceOverScalar, compileOption: LEGACY +- rangeOverSexp, compileOption: PERMISSIVE +- rangeOverSexp, compileOption: LEGACY +- rangeOverStruct, compileOption: LEGACY +- rangeOverBagWithAt, compileOption: LEGACY +- rangeOverNestedWithAt, compileOption: LEGACY +- avg group by{agg:'AVG(t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: PERMISSIVE +- avg group by{agg:'AVG(t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: LEGACY +- avg group by{agg:'AVG(ALL t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: PERMISSIVE +- avg group by{agg:'AVG(ALL t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: LEGACY +- avg group by{agg:'AVG(DISTINCT t.b)',expectedF1:1.5,expectedF2:3.}, compileOption: PERMISSIVE +- avg group by{agg:'AVG(DISTINCT t.b)',expectedF1:1.5,expectedF2:3.}, compileOption: LEGACY +- ANY with GROUP BY, compileOption: LEGACY +- ANY DISTINCT with GROUP BY, compileOption: LEGACY +- SOME with GROUP BY, compileOption: LEGACY +- SOME DISTINCT with GROUP BY, compileOption: LEGACY +- EVERY with GROUP BY, compileOption: LEGACY +- EVERY DISTINCT with GROUP BY, compileOption: LEGACY +- selectListMultipleAggregatesNestedQuery, compileOption: PERMISSIVE +- selectListMultipleAggregatesNestedQuery, compileOption: LEGACY +- undefinedUnqualifiedVariable_inSelect_withProjectionOption, compileOption: LEGACY +- projectionIterationBehaviorUnfiltered_select_star, compileOption: PERMISSIVE +- projectionIterationBehaviorUnfiltered_select_star, compileOption: LEGACY +- projectOfSexp, compileOption: PERMISSIVE +- projectOfSexp, compileOption: LEGACY +- projectOfUnpivotPath, compileOption: LEGACY +- alias1.alias2.*, compileOption: LEGACY +- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: PERMISSIVE +- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: LEGACY +- selectListWithMissing, compileOption: LEGACY +- selectCorrelatedJoin, compileOption: PERMISSIVE +- selectCorrelatedJoin, compileOption: LEGACY +- selectCorrelatedLeftJoin, compileOption: PERMISSIVE +- selectCorrelatedLeftJoin, compileOption: LEGACY +- selectCorrelatedLeftJoinOnClause, compileOption: PERMISSIVE +- selectCorrelatedLeftJoinOnClause, compileOption: LEGACY +- selectJoinOnClauseScoping, compileOption: PERMISSIVE +- selectJoinOnClauseScoping, compileOption: LEGACY +- selectNonCorrelatedJoin, compileOption: LEGACY +- correlatedJoinWithShadowedAttributes, compileOption: LEGACY +- correlatedJoinWithoutLexicalScope, compileOption: LEGACY +- joinWithShadowedGlobal, compileOption: LEGACY +- selectDistinctStarBags, compileOption: PERMISSIVE +- selectDistinctStarBags, compileOption: LEGACY +- variableShadow, compileOption: LEGACY +- selectValueStructConstructorWithMissing, compileOption: LEGACY +- selectIndexStruct, compileOption: PERMISSIVE +- selectIndexStruct, compileOption: LEGACY +- emptySymbol, compileOption: LEGACY +- emptySymbolInGlobals, compileOption: LEGACY +
+The following test(s) are failing in legacy but pass in eval. Before merging, confirm they are intended to pass: +
Click here to see + + +- equiv group by with aggregates, compileOption: PERMISSIVE + +- equiv group by with aggregates, compileOption: LEGACY + +- missing and true, compileOption: PERMISSIVE + +- coll_count with result of subquery, compileOption: PERMISSIVE + +- coll_count with result of subquery, compileOption: LEGACY + +- outerUnionAll, compileOption: PERMISSIVE + +- outerUnionAll, compileOption: LEGACY + +- outerExceptDistinct, compileOption: PERMISSIVE + +- outerExceptDistinct, compileOption: LEGACY + +- outerUnionCoerceList, compileOption: PERMISSIVE + +- outerUnionCoerceList, compileOption: LEGACY + +- max top level{agg:'COLL_MAX(data)',result:(success 2)}, compileOption: PERMISSIVE + +- max top level{agg:'COLL_MAX(data)',result:(success 2)}, compileOption: LEGACY + +- topLevelCollMax, compileOption: PERMISSIVE + +- topLevelCollMax, compileOption: LEGACY + +- COLL_MAX empty collection, compileOption: PERMISSIVE + +- COLL_MAX empty collection, compileOption: LEGACY + +- COLL_MAX null, compileOption: PERMISSIVE + +- COLL_MAX null, compileOption: LEGACY + +- COLL_MAX list of missing element, compileOption: PERMISSIVE + +- COLL_MAX list of missing element, compileOption: LEGACY + +- COLL_MAX bag of missing elements, compileOption: PERMISSIVE + +- COLL_MAX bag of missing elements, compileOption: LEGACY + +- COLL_MAX bag of heterogeneous element types, compileOption: PERMISSIVE + +- COLL_MAX bag of heterogeneous element types, compileOption: LEGACY + +- coll_avg top level{agg:'COLL_AVG(data)',result:(success 1.25)}, compileOption: PERMISSIVE + +- coll_avg top level{agg:'COLL_AVG(data)',result:(success 1.25)}, compileOption: LEGACY + +- topLevelCollAvg, compileOption: PERMISSIVE + +- topLevelCollAvg, compileOption: LEGACY + +- topLevelCollAvgOnlyInt, compileOption: PERMISSIVE + +- topLevelCollAvgOnlyInt, compileOption: LEGACY + +- COLL_AVG empty collection, compileOption: PERMISSIVE + +- COLL_AVG empty collection, compileOption: LEGACY + +- COLL_AVG null, compileOption: PERMISSIVE + +- COLL_AVG null, compileOption: LEGACY + +- COLL_AVG list of missing element, compileOption: PERMISSIVE + +- COLL_AVG list of missing element, compileOption: LEGACY + +- COLL_AVG bag of missing elements, compileOption: PERMISSIVE + +- COLL_AVG bag of missing elements, compileOption: LEGACY + +- COLL_AVG mistyped element, compileOption: PERMISSIVE + +- coll_count top level{agg:'COLL_COUNT(data)',result:(success 4)}, compileOption: PERMISSIVE + +- coll_count top level{agg:'COLL_COUNT(data)',result:(success 4)}, compileOption: LEGACY + +- topLevelCollCount, compileOption: PERMISSIVE + +- topLevelCollCount, compileOption: LEGACY + +- COLL_COUNT empty collection, compileOption: PERMISSIVE + +- COLL_COUNT empty collection, compileOption: LEGACY + +- COLL_COUNT null, compileOption: PERMISSIVE + +- COLL_COUNT null, compileOption: LEGACY + +- COLL_COUNT list of missing element, compileOption: PERMISSIVE + +- COLL_COUNT list of missing element, compileOption: LEGACY + +- COLL_COUNT bag of missing elements, compileOption: PERMISSIVE + +- COLL_COUNT bag of missing elements, compileOption: LEGACY + +- COLL_COUNT bag of heterogeneous element types, compileOption: PERMISSIVE + +- COLL_COUNT bag of heterogeneous element types, compileOption: LEGACY + +- coll_sum top level{agg:'COLL_SUM(data)',result:(success 5)}, compileOption: PERMISSIVE + +- coll_sum top level{agg:'COLL_SUM(data)',result:(success 5)}, compileOption: LEGACY + +- topLevelCollSum, compileOption: PERMISSIVE + +- topLevelCollSum, compileOption: LEGACY + +- COLL_SUM empty collection, compileOption: PERMISSIVE + +- COLL_SUM empty collection, compileOption: LEGACY + +- COLL_SUM null, compileOption: PERMISSIVE + +- COLL_SUM null, compileOption: LEGACY + +- COLL_SUM list of missing element, compileOption: PERMISSIVE + +- COLL_SUM list of missing element, compileOption: LEGACY + +- COLL_SUM bag of missing elements, compileOption: PERMISSIVE + +- COLL_SUM bag of missing elements, compileOption: LEGACY + +- COLL_SUM mistyped element, compileOption: PERMISSIVE + +- coll_min top level{agg:'COLL_MIN(data)',result:(success 1)}, compileOption: PERMISSIVE + +- coll_min top level{agg:'COLL_MIN(data)',result:(success 1)}, compileOption: LEGACY + +- topLevelCollMin, compileOption: PERMISSIVE + +- topLevelCollMin, compileOption: LEGACY + +- COLL_MIN empty collection, compileOption: PERMISSIVE + +- COLL_MIN empty collection, compileOption: LEGACY + +- COLL_MIN null, compileOption: PERMISSIVE + +- COLL_MIN null, compileOption: LEGACY + +- COLL_MIN list of missing element, compileOption: PERMISSIVE + +- COLL_MIN list of missing element, compileOption: LEGACY + +- COLL_MIN bag of missing elements, compileOption: PERMISSIVE + +- COLL_MIN bag of missing elements, compileOption: LEGACY + +- COLL_MIN bag of heterogeneous element types, compileOption: PERMISSIVE + +- COLL_MIN bag of heterogeneous element types, compileOption: LEGACY + +- COLL_ANY bag literals, compileOption: PERMISSIVE + +- COLL_ANY bag literals, compileOption: LEGACY + +- COLL_ANY list expressions, compileOption: PERMISSIVE + +- COLL_ANY list expressions, compileOption: LEGACY + +- COLL_ANY single true, compileOption: PERMISSIVE + +- COLL_ANY single true, compileOption: LEGACY + +- COLL_ANY single false, compileOption: PERMISSIVE + +- COLL_ANY single false, compileOption: LEGACY + +- COLL_ANY nulls with true, compileOption: PERMISSIVE + +- COLL_ANY nulls with true, compileOption: LEGACY + +- COLL_ANY nulls with false, compileOption: PERMISSIVE + +- COLL_ANY nulls with false, compileOption: LEGACY + +- COLL_ANY nulls only, compileOption: PERMISSIVE + +- COLL_ANY nulls only, compileOption: LEGACY + +- COLL_ANY null, compileOption: PERMISSIVE + +- COLL_ANY null, compileOption: LEGACY + +- COLL_ANY list of missing element, compileOption: PERMISSIVE + +- COLL_ANY list of missing element, compileOption: LEGACY + +- COLL_ANY bag of missing elements, compileOption: PERMISSIVE + +- COLL_ANY bag of missing elements, compileOption: LEGACY + +- COLL_ANY some empty, compileOption: PERMISSIVE + +- COLL_ANY some empty, compileOption: LEGACY + +- COLL_ANY one non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_ANY all non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_ANY nested collection, compileOption: PERMISSIVE + +- COLL_SOME bag literals, compileOption: PERMISSIVE + +- COLL_SOME bag literals, compileOption: LEGACY + +- COLL_SOME list expressions, compileOption: PERMISSIVE + +- COLL_SOME list expressions, compileOption: LEGACY + +- COLL_SOME single true, compileOption: PERMISSIVE + +- COLL_SOME single true, compileOption: LEGACY + +- COLL_SOME single false, compileOption: PERMISSIVE + +- COLL_SOME single false, compileOption: LEGACY + +- COLL_SOME nulls with true, compileOption: PERMISSIVE + +- COLL_SOME nulls with true, compileOption: LEGACY + +- COLL_SOME nulls with false, compileOption: PERMISSIVE + +- COLL_SOME nulls with false, compileOption: LEGACY + +- COLL_SOME nulls only, compileOption: PERMISSIVE + +- COLL_SOME nulls only, compileOption: LEGACY + +- COLL_SOME null, compileOption: PERMISSIVE + +- COLL_SOME null, compileOption: LEGACY + +- COLL_SOME list of missing element, compileOption: PERMISSIVE + +- COLL_SOME list of missing element, compileOption: LEGACY + +- COLL_SOME bag of missing elements, compileOption: PERMISSIVE + +- COLL_SOME bag of missing elements, compileOption: LEGACY + +- COLL_SOME some empty, compileOption: PERMISSIVE + +- COLL_SOME some empty, compileOption: LEGACY + +- COLL_SOME one non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_SOME all non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_SOME nested collection, compileOption: PERMISSIVE + +- COLL_EVERY bag literals, compileOption: PERMISSIVE + +- COLL_EVERY bag literals, compileOption: LEGACY + +- COLL_EVERY list expressions, compileOption: PERMISSIVE + +- COLL_EVERY list expressions, compileOption: LEGACY + +- COLL_EVERY single true, compileOption: PERMISSIVE + +- COLL_EVERY single true, compileOption: LEGACY + +- COLL_EVERY single false, compileOption: PERMISSIVE + +- COLL_EVERY single false, compileOption: LEGACY + +- COLL_EVERY null and missing with true, compileOption: PERMISSIVE + +- COLL_EVERY null and missing with true, compileOption: LEGACY + +- COLL_EVERY null with false, compileOption: PERMISSIVE + +- COLL_EVERY null with false, compileOption: LEGACY + +- COLL_EVERY null and missing only, compileOption: PERMISSIVE + +- COLL_EVERY null and missing only, compileOption: LEGACY + +- COLL_EVERY null, compileOption: PERMISSIVE + +- COLL_EVERY null, compileOption: LEGACY + +- COLL_EVERY list of missing element, compileOption: PERMISSIVE + +- COLL_EVERY list of missing element, compileOption: LEGACY + +- COLL_EVERY bag of missing elements, compileOption: PERMISSIVE + +- COLL_EVERY bag of missing elements, compileOption: LEGACY + +- COLL_EVERY empty collection, compileOption: PERMISSIVE + +- COLL_EVERY empty collection, compileOption: LEGACY + +- COLL_EVERY one non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_EVERY all non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_EVERY nested collection, compileOption: PERMISSIVE + +- selectValueCollAggregate, compileOption: PERMISSIVE + +- selectValueCollAggregate, compileOption: LEGACY + +- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67Z`), compileOption: PERMISSIVE + +- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67Z`), compileOption: LEGACY + +- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: PERMISSIVE + +- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: LEGACY + +- offset 2^63, compileOption: PERMISSIVE + +- offset 2^63, compileOption: LEGACY + +- SELECT supplierId_missings FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE + +- SELECT p.supplierId_missings FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE + +- SELECT VALUE { 'supplierId_missings' : p.supplierId_missings } FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE + +- SELECT supplierId_mixed FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE + +- SELECT p.supplierId_mixed FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE + +- SELECT VALUE { 'supplierId_mixed' : p.supplierId_mixed } FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE + +- SELECT regionId, supplierId_missings FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE + +- SELECT p.regionId, p.supplierId_missings FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE + +- SELECT VALUE { 'regionId': p.regionId, 'supplierId_missings': p.supplierId_missings } FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE + +- SELECT regionId, supplierId_mixed FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE + +- SELECT regionId, p.supplierId_mixed FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE + +- SELECT VALUE { 'regionId': p.regionId, 'supplierId_mixed': p.supplierId_mixed } FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE + +- SELECT with nested aggregates (complex) 2, compileOption: PERMISSIVE + +- SELECT with nested aggregates (complex) 2, compileOption: LEGACY + +
+ +### Conformance comparison report-Cross Commit-LEGACY +| | Base (HEAD) | HEAD | +/- | +| --- | ---: | ---: | ---: | +| % Passing | 92.51% | 92.47% | -0.03% | +| :white_check_mark: Passing | 5382 | 5380 | -2 | +| :x: Failing | 436 | 438 | 2 | +| :large_orange_diamond: Ignored | 0 | 0 | 0 | +| Total Tests | 5818 | 5818 | 0 | +Number passing in both: 5380 + +Number failing in both: 436 + +Number passing in Base (HEAD) but now fail: 2 + +Number failing in Base (HEAD) but now pass: 0 +:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) were previously passing but now fail: +
Click here to see + + +- outerExceptDistinct, compileOption: PERMISSIVE +- outerExceptDistinct, compileOption: LEGACY +
+ +### Conformance comparison report-Cross Commit-EVAL +| | Base (HEAD) | HEAD | +/- | +| --- | ---: | ---: | ---: | +| % Passing | 82.81% | 82.37% | -0.45% | +| :white_check_mark: Passing | 4819 | 4792 | -27 | +| :x: Failing | 1000 | 1026 | 26 | +| :large_orange_diamond: Ignored | 0 | 0 | 0 | +| Total Tests | 5819 | 5818 | -1 | +Number passing in both: 4711 + +Number failing in both: 918 + +Number passing in Base (HEAD) but now fail: 108 + +Number failing in Base (HEAD) but now pass: 82 +:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) were previously passing but now fail: +
Click here to see + + +- inPredicate, compileOption: PERMISSIVE +- inPredicate, compileOption: LEGACY +- inPredicateSingleItem, compileOption: PERMISSIVE +- inPredicateSingleItem, compileOption: LEGACY +- inPredicateSingleItemListVar, compileOption: PERMISSIVE +- inPredicateSubQuerySelectValue, compileOption: PERMISSIVE +- inPredicateSubQuerySelectValue, compileOption: LEGACY +- notInPredicate, compileOption: PERMISSIVE +- notInPredicate, compileOption: LEGACY +- notInPredicateSingleItem, compileOption: PERMISSIVE +- notInPredicateSingleItem, compileOption: LEGACY +- notInPredicateSingleItemListVar, compileOption: PERMISSIVE +- notInPredicateSubQuerySelectValue, compileOption: PERMISSIVE +- notInPredicateSubQuerySelectValue, compileOption: LEGACY +- inPredicateWithTableConstructor, compileOption: PERMISSIVE +- inPredicateWithTableConstructor, compileOption: LEGACY +- notInPredicateWithTableConstructor, compileOption: PERMISSIVE +- notInPredicateWithTableConstructor, compileOption: LEGACY +- inPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE +- inPredicateWithExpressionOnRightSide, compileOption: LEGACY +- notInPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE +- notInPredicateWithExpressionOnRightSide, compileOption: LEGACY +- pathDoubleWildCard, compileOption: PERMISSIVE +- pathDoubleWildCard, compileOption: LEGACY +- nullif valid cases{first:"1",second:"1",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"1",result:null}, compileOption: LEGACY +- nullif valid cases{first:"1",second:"2",result:1}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"2",result:1}, compileOption: LEGACY +- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: PERMISSIVE +- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: LEGACY +- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: LEGACY +- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: LEGACY +- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: PERMISSIVE +- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: LEGACY +- nullif valid cases{first:"1",second:"null",result:1}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"null",result:1}, compileOption: LEGACY +- nullif valid cases{first:"null",second:"1",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"null",second:"1",result:null}, compileOption: LEGACY +- nullif valid cases{first:"null",second:"null",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"null",second:"null",result:null}, compileOption: LEGACY +- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: LEGACY +- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: PERMISSIVE +- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: LEGACY +- nullif valid cases{first:"missing",second:"missing",result:missing}, compileOption: PERMISSIVE +- nullif valid cases{first:"missing",second:"missing",result:missing}, compileOption: LEGACY +- coalesce valid cases{args:"1",result:(success 1)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"1",result:(success 1)}, compileOption: LEGACY +- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: LEGACY +- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: LEGACY +- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: LEGACY +- join on column - all column values non-null, compileOption: PERMISSIVE +- join on column - all column values non-null, compileOption: LEGACY +- join on column - some column values are null, compileOption: PERMISSIVE +- join on column - some column values are null, compileOption: LEGACY +- join on column - 1 table contains 1 row with the value null, compileOption: PERMISSIVE +- join on column - ON condition = false, compileOption: PERMISSIVE +- join on column - ON condition = false, compileOption: LEGACY +- PG_JOIN_01, compileOption: PERMISSIVE +- PG_JOIN_01, compileOption: LEGACY +- PG_JOIN_02, compileOption: PERMISSIVE +- PG_JOIN_02, compileOption: LEGACY +- PG_JOIN_03, compileOption: PERMISSIVE +- PG_JOIN_03, compileOption: LEGACY +- PG_JOIN_06, compileOption: PERMISSIVE +- PG_JOIN_06, compileOption: LEGACY +- PG_JOIN_08, compileOption: PERMISSIVE +- PG_JOIN_08, compileOption: LEGACY +- PG_JOIN_10, compileOption: PERMISSIVE +- PG_JOIN_10, compileOption: LEGACY +- offset 0, compileOption: PERMISSIVE +- offset 0, compileOption: LEGACY +- offset 1, compileOption: PERMISSIVE +- offset 1, compileOption: LEGACY +- offset 2, compileOption: PERMISSIVE +- offset 2, compileOption: LEGACY +- limit 1 offset 1, compileOption: PERMISSIVE +- limit 1 offset 1, compileOption: LEGACY +- limit 10 offset 1, compileOption: PERMISSIVE +- limit 10 offset 1, compileOption: LEGACY +- limit 2 offset 2, compileOption: PERMISSIVE +- limit 2 offset 2, compileOption: LEGACY +- limit offset after group by, compileOption: PERMISSIVE +- limit offset after group by, compileOption: LEGACY +- offset 2-1, compileOption: PERMISSIVE +- offset 2-1, compileOption: LEGACY +- offset 2+1, compileOption: PERMISSIVE +- offset 2+1, compileOption: LEGACY +- offset 2*1, compileOption: PERMISSIVE +- offset 2*1, compileOption: LEGACY +- offset 2/1, compileOption: PERMISSIVE +- offset 2/1, compileOption: LEGACY +- offset group by having, compileOption: PERMISSIVE +- offset group by having, compileOption: LEGACY +- offset with pivot, compileOption: PERMISSIVE +- offset with pivot, compileOption: LEGACY +- offset 1-2, compileOption: PERMISSIVE +- selectStarSingleSourceHoisted, compileOption: PERMISSIVE +- selectStarSingleSourceHoisted, compileOption: LEGACY +- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: PERMISSIVE +- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: LEGACY +- selectCorrelatedJoin, compileOption: PERMISSIVE +- selectCorrelatedJoin, compileOption: LEGACY +
+The following test(s) were previously failing but now pass. Before merging, confirm they are intended to pass: +
Click here to see + + +- equiv attribute value pair unpivot missing, compileOption: LEGACY + +- tuple navigation with array notation without explicit CAST to string, compileOption: LEGACY + +- path on string, compileOption: LEGACY + +- tuple navigation missing attribute dot notation, compileOption: LEGACY + +- tuple navigation missing attribute array notation, compileOption: LEGACY + +- array navigation with wrongly typed array index, compileOption: LEGACY + +- data type mismatch in comparison expression, compileOption: LEGACY + +- data type mismatch in logical expression, compileOption: LEGACY + +- LIKE bad value type, compileOption: LEGACY + +- LIKE bad pattern type, compileOption: LEGACY + +- LIKE bad escape type, compileOption: LEGACY + +- outerUnionDistinct, compileOption: PERMISSIVE + +- outerUnionDistinct, compileOption: LEGACY + +- outerUnionAll, compileOption: PERMISSIVE + +- outerUnionAll, compileOption: LEGACY + +- outerIntersectDistinct, compileOption: PERMISSIVE + +- outerIntersectDistinct, compileOption: LEGACY + +- outerIntersectAll, compileOption: PERMISSIVE + +- outerIntersectAll, compileOption: LEGACY + +- outerExceptDistinct, compileOption: PERMISSIVE + +- outerExceptDistinct, compileOption: LEGACY + +- outerExceptAll, compileOption: PERMISSIVE + +- outerExceptAll, compileOption: LEGACY + +- outerUnionCoerceList, compileOption: PERMISSIVE + +- outerUnionCoerceList, compileOption: LEGACY + +- notInPredicateSingleExpr, compileOption: LEGACY + +- betweenPredicate, compileOption: PERMISSIVE + +- betweenPredicate, compileOption: LEGACY + +- notBetweenPredicate, compileOption: PERMISSIVE + +- notBetweenPredicate, compileOption: LEGACY + +- pathUnpivotWildcardFieldsAfter, compileOption: PERMISSIVE + +- pathUnpivotWildcardFieldsAfter, compileOption: LEGACY + +- pathDoubleUnpivotWildCard, compileOption: PERMISSIVE + +- pathDoubleUnpivotWildCard, compileOption: LEGACY + +- subscript with non-existent variable in lowercase, compileOption: LEGACY + +- subscript with non-existent variable in uppercase, compileOption: LEGACY + +- path expression with ambiguous table alias (lowercase), compileOption: LEGACY + +- COLL_MAX non-collection, compileOption: LEGACY + +- COLL_AVG non-collection, compileOption: LEGACY + +- COLL_COUNT non-collection, compileOption: LEGACY + +- COLL_SUM non-collection, compileOption: LEGACY + +- COLL_MIN non-collection, compileOption: LEGACY + +- COLL_ANY non-collection, compileOption: LEGACY + +- COLL_SOME non-collection, compileOption: LEGACY + +- COLL_EVERY non-collection, compileOption: LEGACY + +- selectValueCollAggregate, compileOption: PERMISSIVE + +- selectValueCollAggregate, compileOption: LEGACY + +- CHARACTER_LENGTH invalid type, compileOption: LEGACY + +- CARDINALITY('foo') type mismatch, compileOption: LEGACY + +- invalid extract year from time, compileOption: LEGACY + +- invalid extract month from time, compileOption: LEGACY + +- invalid extract day from time, compileOption: LEGACY + +- invalid extract month from time with time zone, compileOption: LEGACY + +- invalid extract day from time with time zone, compileOption: LEGACY + +- POSITION invalid type in string, compileOption: LEGACY + +- POSITION string in invalid type, compileOption: LEGACY + +- ABS('foo'), compileOption: LEGACY + +- MOD(3, 'some string'), compileOption: LEGACY + +- MOD('some string', 3), compileOption: LEGACY + +- BIT_LENGTH invalid type, compileOption: LEGACY + +- OCTET_LENGTH invalid type, compileOption: LEGACY + +- OVERLAY mismatched type, compileOption: LEGACY + +- OVERLAY PLACING mismatched type, compileOption: LEGACY + +- OVERLAY FROM mismatched type, compileOption: LEGACY + +- OVERLAY FOR mismatched type, compileOption: LEGACY + +- undefinedUnqualifiedVariableWithUndefinedVariableBehaviorMissing, compileOption: LEGACY + +- undefinedUnqualifiedVariableIsNullExprWithUndefinedVariableBehaviorMissing, compileOption: LEGACY + +- undefinedUnqualifiedVariableIsMissingExprWithUndefinedVariableBehaviorMissing, compileOption: LEGACY + +- offset , compileOption: LEGACY + +- offset >, compileOption: LEGACY + +- GROUP BY binding referenced in FROM clause, compileOption: LEGACY + +- GROUP BY binding referenced in WHERE clause, compileOption: LEGACY + +- GROUP AS binding referenced in FROM clause, compileOption: LEGACY + +- GROUP AS binding referenced in WHERE clause, compileOption: LEGACY + +- SELECT COUNT( numInStock) + 2 AS agg FROM products, compileOption: PERMISSIVE + +- SELECT COUNT( numInStock) + 2 AS agg FROM products, compileOption: LEGACY + +- SELECT COUNT(p.numInStock) + 2 AS agg FROM products as p, compileOption: PERMISSIVE + +- SELECT COUNT(p.numInStock) + 2 AS agg FROM products as p, compileOption: LEGACY + +- MYSQL_SELECT_23, compileOption: PERMISSIVE + +- MYSQL_SELECT_23, compileOption: LEGACY + +- projectionIterationBehaviorUnfiltered_select_list, compileOption: PERMISSIVE + +- projectionIterationBehaviorUnfiltered_select_list, compileOption: LEGACY + +
+ From f0b754fa2d0b64fe1919d443671c977ea61e0108 Mon Sep 17 00:00:00 2001 From: John Ed Quinn Date: Tue, 16 Apr 2024 14:56:59 -0700 Subject: [PATCH 02/12] Adds typing support for UNION --- .../internal/operator/rel/RelUnionDistinct.kt | 3 +- .../eval/internal/PartiQLEngineDefaultTest.kt | 7 +- .../internal/transforms/RexConverter.kt | 4 +- .../planner/internal/typer/PlanTyper.kt | 21 +- test/partiql-tests-runner/comp_report.md | 1336 +++++++++-------- 5 files changed, 753 insertions(+), 618 deletions(-) diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt index a4847f8c7b..6321955d43 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt @@ -11,12 +11,13 @@ internal class RelUnionDistinct( ) : RelPeeking() { private val seen: MutableSet = mutableSetOf() - private val input = IteratorChain(listOf(lhs, rhs)) + private lateinit var input: Iterator override fun open(env: Environment) { lhs.open(env) rhs.open(env) seen.clear() + input = IteratorChain(listOf(lhs, rhs)) super.open(env) } diff --git a/partiql-eval/src/test/kotlin/org/partiql/eval/internal/PartiQLEngineDefaultTest.kt b/partiql-eval/src/test/kotlin/org/partiql/eval/internal/PartiQLEngineDefaultTest.kt index 6de65d6937..24ea9d7c9f 100644 --- a/partiql-eval/src/test/kotlin/org/partiql/eval/internal/PartiQLEngineDefaultTest.kt +++ b/partiql-eval/src/test/kotlin/org/partiql/eval/internal/PartiQLEngineDefaultTest.kt @@ -74,9 +74,7 @@ class PartiQLEngineDefaultTest { fun singleTest() { val tc = SuccessTestCase( input = """ - SELECT o.name AS orderName, - (SELECT c.name FROM customers c WHERE c.id=o.custId) AS customerName - FROM orders o + SELECT * FROM << 1 >> OUTER UNION << 'A' >> """.trimIndent(), expected = bagValue( structValue( @@ -105,7 +103,8 @@ class PartiQLEngineDefaultTest { ] """ ), - ) + ), + mode = PartiQLEngine.Mode.STRICT ) tc.assert() } diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt index c29f563012..2eacc59b9f 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt @@ -826,11 +826,11 @@ internal object RexConverter { override fun visitExprBagOp(node: Expr.BagOp, ctx: Env): Rex { val lhs = Rel( type = Rel.Type(listOf(Rel.Binding("_0", StaticType.ANY)), props = emptySet()), - op = Rel.Op.Scan(visitExprCoerce(node.lhs, ctx)) + op = Rel.Op.Scan(visitExpr(node.lhs, ctx)) ) val rhs = Rel( type = Rel.Type(listOf(Rel.Binding("_1", StaticType.ANY)), props = emptySet()), - op = Rel.Op.Scan(visitExprCoerce(node.rhs, ctx)) + op = Rel.Op.Scan(visitExpr(node.rhs, ctx)) ) val type = when (node.type.type) { SetOp.Type.UNION -> when (node.type.setq) { diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt index 0e0a161d72..05cc422f5e 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt @@ -91,6 +91,7 @@ import org.partiql.value.PartiQLValueExperimental import org.partiql.value.TextValue import org.partiql.value.boolValue import org.partiql.value.stringValue +import kotlin.math.max /** * Rewrites an untyped algebraic translation of the query to be both typed and have resolved variables. @@ -218,10 +219,24 @@ internal class PlanTyper(private val env: Env) { return rel(type, op) } - // TODO: Add better typing logic override fun visitRelOpSet(node: Rel.Op.Set, ctx: Rel.Type?): PlanNode { - val schema = ctx!! - return Rel(schema, node) + val lhs = visitRel(node.lhs, node.lhs.type) + val rhs = visitRel(node.rhs, node.rhs.type) + val set = node.copy(lhs = lhs, rhs = rhs) + + // Compute Schema + val size = max(lhs.type.schema.size, rhs.type.schema.size) + val schema = List(size) { + val lhsBinding = lhs.type.schema.getOrNull(it) ?: Rel.Binding("_$it", MISSING) + val rhsBinding = rhs.type.schema.getOrNull(it) ?: Rel.Binding("_$it", MISSING) + val bindingName = when (lhsBinding.name == rhsBinding.name) { + true -> lhsBinding.name + false -> "_$it" + } + Rel.Binding(bindingName, unionOf(lhsBinding.type, rhsBinding.type)) + } + val type = Rel.Type(schema, props = emptySet()) + return Rel(type, set) } override fun visitRelOpLimit(node: Rel.Op.Limit, ctx: Rel.Type?): Rel { diff --git a/test/partiql-tests-runner/comp_report.md b/test/partiql-tests-runner/comp_report.md index cab30e43fe..36de776d5c 100644 --- a/test/partiql-tests-runner/comp_report.md +++ b/test/partiql-tests-runner/comp_report.md @@ -1,18 +1,18 @@ ### Conformance comparison report-Cross Engine | | Base (legacy) | eval | +/- | | --- | ---: | ---: | ---: | -| % Passing | 92.47% | 82.37% | -10.11% | -| :white_check_mark: Passing | 5380 | 4792 | -588 | -| :x: Failing | 438 | 1026 | 588 | +| % Passing | 92.47% | 82.68% | -9.79% | +| :white_check_mark: Passing | 5380 | 4811 | -569 | +| :x: Failing | 438 | 1008 | 570 | | :large_orange_diamond: Ignored | 0 | 0 | 0 | -| Total Tests | 5818 | 5818 | 0 | -Number passing in both: 4614 +| Total Tests | 5818 | 5819 | 1 | +Number passing in both: 4627 -Number failing in both: 260 +Number failing in both: 254 -Number passing in legacy engine but fail in eval engine: 766 +Number passing in legacy engine but fail in eval engine: 754 -Number failing in legacy engine but pass in eval engine: 178 +Number failing in legacy engine but pass in eval engine: 184 :interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) are passing in legacy but fail in eval:
Click here to see @@ -26,7 +26,6 @@ Number failing in legacy engine but pass in eval engine: 178 - equiv attribute value pair unpivot missing, compileOption: PERMISSIVE - equiv left join, compileOption: PERMISSIVE - equiv left join, compileOption: LEGACY -- Example 6 — Value Coercion, compileOption: PERMISSIVE - Example 6 — Value Coercion, compileOption: LEGACY - path on string, compileOption: PERMISSIVE - tuple navigation missing attribute dot notation, compileOption: PERMISSIVE @@ -262,9 +261,7 @@ Number failing in legacy engine but pass in eval engine: 178 - 'some value' LIKE 'some pattern' ESCAPE MISSING, compileOption: PERMISSIVE - NULL LIKE 'some pattern' ESCAPE MISSING, compileOption: PERMISSIVE - 'some value' LIKE NULL ESCAPE MISSING, compileOption: PERMISSIVE -- outerUnionCoerceScalar, compileOption: PERMISSIVE - outerUnionCoerceScalar, compileOption: LEGACY -- outerUnionCoerceStruct, compileOption: PERMISSIVE - outerUnionCoerceStruct, compileOption: LEGACY - outerUnionCoerceNullMissing, compileOption: PERMISSIVE - outerUnionCoerceNullMissing, compileOption: LEGACY @@ -525,18 +522,7 @@ Number failing in legacy engine but pass in eval engine: 178 - functionCall, compileOption: LEGACY - division with mixed StaticType, compileOption: PERMISSIVE - division with mixed StaticType, compileOption: LEGACY -- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: PERMISSIVE -- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: LEGACY -- Example 3 — Outer union of Heterogenous Relations, compileOption: PERMISSIVE -- Example 3 — Outer union of Heterogenous Relations, compileOption: LEGACY -- Example 6 — Value Coercion; Coercion of single value, compileOption: PERMISSIVE - Example 6 — Value Coercion; Coercion of single value, compileOption: LEGACY -- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: PERMISSIVE -- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: LEGACY -- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: PERMISSIVE -- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: LEGACY -- Example 7 — result is the empty bag, compileOption: PERMISSIVE -- Example 7 — result is the empty bag, compileOption: LEGACY - undefinedUnqualifiedVariableWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE - undefinedUnqualifiedVariableIsNullExprWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE - undefinedUnqualifiedVariableIsMissingExprWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE @@ -718,6 +704,8 @@ Number failing in legacy engine but pass in eval engine: 178 - MYSQL_SELECT_20, compileOption: LEGACY - MYSQL_SELECT_21, compileOption: PERMISSIVE - MYSQL_SELECT_21, compileOption: LEGACY +- MYSQL_SELECT_23, compileOption: PERMISSIVE +- MYSQL_SELECT_23, compileOption: LEGACY - MYSQL_SELECT_26, compileOption: PERMISSIVE - MYSQL_SELECT_26, compileOption: LEGACY - selectFromScalarAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE @@ -1112,6 +1100,18 @@ The following test(s) are failing in legacy but pass in eval. Before merging, co - EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: LEGACY +- Example 1 — Union of Compatible Relations, compileOption: PERMISSIVE + +- Example 1 — Union of Compatible Relations, compileOption: LEGACY + +- Example 4 — Intersection of Compatible Relations, compileOption: PERMISSIVE + +- Example 4 — Intersection of Compatible Relations, compileOption: LEGACY + +- Example 5 — Difference of Compatible Relations, compileOption: PERMISSIVE + +- Example 5 — Difference of Compatible Relations, compileOption: LEGACY + - offset 2^63, compileOption: PERMISSIVE - offset 2^63, compileOption: LEGACY @@ -1149,144 +1149,470 @@ The following test(s) are failing in legacy but pass in eval. Before merging, co ### Conformance comparison report-Cross Commit-LEGACY | | Base (HEAD) | HEAD | +/- | | --- | ---: | ---: | ---: | -| % Passing | 92.47% | 92.47% | 0.00% | -| :white_check_mark: Passing | 5380 | 5380 | 0 | -| :x: Failing | 438 | 438 | 0 | +| % Passing | 92.51% | 92.47% | -0.03% | +| :white_check_mark: Passing | 5382 | 5380 | -2 | +| :x: Failing | 436 | 438 | 2 | | :large_orange_diamond: Ignored | 0 | 0 | 0 | | Total Tests | 5818 | 5818 | 0 | Number passing in both: 5380 -Number failing in both: 438 +Number failing in both: 436 -Number passing in Base (HEAD) but now fail: 0 +Number passing in Base (HEAD) but now fail: 2 Number failing in Base (HEAD) but now pass: 0 +:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) were previously passing but now fail: +
Click here to see + + +- outerExceptDistinct, compileOption: PERMISSIVE +- outerExceptDistinct, compileOption: LEGACY +
### Conformance comparison report-Cross Commit-EVAL | | Base (HEAD) | HEAD | +/- | | --- | ---: | ---: | ---: | -| % Passing | 82.37% | 82.37% | 0.00% | -| :white_check_mark: Passing | 4792 | 4792 | 0 | -| :x: Failing | 1026 | 1026 | 0 | +| % Passing | 82.81% | 82.68% | -0.14% | +| :white_check_mark: Passing | 4819 | 4811 | -8 | +| :x: Failing | 1000 | 1008 | 8 | | :large_orange_diamond: Ignored | 0 | 0 | 0 | -| Total Tests | 5818 | 5818 | 0 | -Number passing in both: 4792 - -Number failing in both: 1026 - -Number passing in Base (HEAD) but now fail: 0 +| Total Tests | 5819 | 5819 | 0 | +Number passing in both: 4711 -Number failing in Base (HEAD) but now pass: 0 +Number failing in both: 900 -### Conformance comparison report-Cross Engine -| | Base (legacy) | eval | +/- | -| --- | ---: | ---: | ---: | -| % Passing | 92.47% | 82.37% | -10.11% | -| :white_check_mark: Passing | 5380 | 4792 | -588 | -| :x: Failing | 438 | 1026 | 588 | -| :large_orange_diamond: Ignored | 0 | 0 | 0 | -| Total Tests | 5818 | 5818 | 0 | -Number passing in both: 4614 +Number passing in Base (HEAD) but now fail: 108 -Number failing in both: 260 +Number failing in Base (HEAD) but now pass: 101 +:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) were previously passing but now fail: +
Click here to see -Number passing in legacy engine but fail in eval engine: 766 -Number failing in legacy engine but pass in eval engine: 178 -:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) are passing in legacy but fail in eval: +- inPredicate, compileOption: PERMISSIVE +- inPredicate, compileOption: LEGACY +- inPredicateSingleItem, compileOption: PERMISSIVE +- inPredicateSingleItem, compileOption: LEGACY +- inPredicateSingleItemListVar, compileOption: PERMISSIVE +- inPredicateSubQuerySelectValue, compileOption: PERMISSIVE +- inPredicateSubQuerySelectValue, compileOption: LEGACY +- notInPredicate, compileOption: PERMISSIVE +- notInPredicate, compileOption: LEGACY +- notInPredicateSingleItem, compileOption: PERMISSIVE +- notInPredicateSingleItem, compileOption: LEGACY +- notInPredicateSingleItemListVar, compileOption: PERMISSIVE +- notInPredicateSubQuerySelectValue, compileOption: PERMISSIVE +- notInPredicateSubQuerySelectValue, compileOption: LEGACY +- inPredicateWithTableConstructor, compileOption: PERMISSIVE +- inPredicateWithTableConstructor, compileOption: LEGACY +- notInPredicateWithTableConstructor, compileOption: PERMISSIVE +- notInPredicateWithTableConstructor, compileOption: LEGACY +- inPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE +- inPredicateWithExpressionOnRightSide, compileOption: LEGACY +- notInPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE +- notInPredicateWithExpressionOnRightSide, compileOption: LEGACY +- pathDoubleWildCard, compileOption: PERMISSIVE +- pathDoubleWildCard, compileOption: LEGACY +- nullif valid cases{first:"1",second:"1",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"1",result:null}, compileOption: LEGACY +- nullif valid cases{first:"1",second:"2",result:1}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"2",result:1}, compileOption: LEGACY +- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: PERMISSIVE +- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: LEGACY +- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: LEGACY +- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: LEGACY +- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: PERMISSIVE +- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: LEGACY +- nullif valid cases{first:"1",second:"null",result:1}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"null",result:1}, compileOption: LEGACY +- nullif valid cases{first:"null",second:"1",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"null",second:"1",result:null}, compileOption: LEGACY +- nullif valid cases{first:"null",second:"null",result:null}, compileOption: PERMISSIVE +- nullif valid cases{first:"null",second:"null",result:null}, compileOption: LEGACY +- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: PERMISSIVE +- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: LEGACY +- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: PERMISSIVE +- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: LEGACY +- nullif valid cases{first:"missing",second:"missing",result:missing}, compileOption: PERMISSIVE +- nullif valid cases{first:"missing",second:"missing",result:missing}, compileOption: LEGACY +- coalesce valid cases{args:"1",result:(success 1)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"1",result:(success 1)}, compileOption: LEGACY +- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: LEGACY +- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: LEGACY +- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: PERMISSIVE +- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: LEGACY +- join on column - all column values non-null, compileOption: PERMISSIVE +- join on column - all column values non-null, compileOption: LEGACY +- join on column - some column values are null, compileOption: PERMISSIVE +- join on column - some column values are null, compileOption: LEGACY +- join on column - 1 table contains 1 row with the value null, compileOption: PERMISSIVE +- join on column - ON condition = false, compileOption: PERMISSIVE +- join on column - ON condition = false, compileOption: LEGACY +- PG_JOIN_01, compileOption: PERMISSIVE +- PG_JOIN_01, compileOption: LEGACY +- PG_JOIN_02, compileOption: PERMISSIVE +- PG_JOIN_02, compileOption: LEGACY +- PG_JOIN_03, compileOption: PERMISSIVE +- PG_JOIN_03, compileOption: LEGACY +- PG_JOIN_06, compileOption: PERMISSIVE +- PG_JOIN_06, compileOption: LEGACY +- PG_JOIN_08, compileOption: PERMISSIVE +- PG_JOIN_08, compileOption: LEGACY +- PG_JOIN_10, compileOption: PERMISSIVE +- PG_JOIN_10, compileOption: LEGACY +- offset 0, compileOption: PERMISSIVE +- offset 0, compileOption: LEGACY +- offset 1, compileOption: PERMISSIVE +- offset 1, compileOption: LEGACY +- offset 2, compileOption: PERMISSIVE +- offset 2, compileOption: LEGACY +- limit 1 offset 1, compileOption: PERMISSIVE +- limit 1 offset 1, compileOption: LEGACY +- limit 10 offset 1, compileOption: PERMISSIVE +- limit 10 offset 1, compileOption: LEGACY +- limit 2 offset 2, compileOption: PERMISSIVE +- limit 2 offset 2, compileOption: LEGACY +- limit offset after group by, compileOption: PERMISSIVE +- limit offset after group by, compileOption: LEGACY +- offset 2-1, compileOption: PERMISSIVE +- offset 2-1, compileOption: LEGACY +- offset 2+1, compileOption: PERMISSIVE +- offset 2+1, compileOption: LEGACY +- offset 2*1, compileOption: PERMISSIVE +- offset 2*1, compileOption: LEGACY +- offset 2/1, compileOption: PERMISSIVE +- offset 2/1, compileOption: LEGACY +- offset group by having, compileOption: PERMISSIVE +- offset group by having, compileOption: LEGACY +- offset with pivot, compileOption: PERMISSIVE +- offset with pivot, compileOption: LEGACY +- offset 1-2, compileOption: PERMISSIVE +- selectStarSingleSourceHoisted, compileOption: PERMISSIVE +- selectStarSingleSourceHoisted, compileOption: LEGACY +- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: PERMISSIVE +- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: LEGACY +- selectCorrelatedJoin, compileOption: PERMISSIVE +- selectCorrelatedJoin, compileOption: LEGACY +
+The following test(s) were previously failing but now pass. Before merging, confirm they are intended to pass:
Click here to see -- equiv wildcard steps struct, compileOption: PERMISSIVE -- equiv wildcard steps struct, compileOption: LEGACY -- equiv path expression with wildcard steps, compileOption: PERMISSIVE -- equiv path expression with wildcard steps, compileOption: LEGACY -- equiv path collection expression with wildcard steps, compileOption: PERMISSIVE -- equiv path collection expression with wildcard steps, compileOption: LEGACY -- equiv attribute value pair unpivot missing, compileOption: PERMISSIVE -- equiv left join, compileOption: PERMISSIVE -- equiv left join, compileOption: LEGACY +- equiv attribute value pair unpivot missing, compileOption: LEGACY + - Example 6 — Value Coercion, compileOption: PERMISSIVE + - Example 6 — Value Coercion, compileOption: LEGACY -- path on string, compileOption: PERMISSIVE -- tuple navigation missing attribute dot notation, compileOption: PERMISSIVE -- tuple navigation missing attribute array notation, compileOption: PERMISSIVE -- array navigation with wrongly typed array index, compileOption: PERMISSIVE -- single source FROM with scalar, compileOption: LEGACY -- single source FROM with tuple, compileOption: LEGACY -- single source FROM with absent value null, compileOption: LEGACY -- single source FROM with absent value missing, compileOption: LEGACY -- tuple constructor and mistyped attribute name, compileOption: PERMISSIVE -- attribute value evaluates to MISSING, compileOption: LEGACY -- array element evaluates to MISSING, compileOption: LEGACY -- bag element evaluates to MISSING, compileOption: LEGACY -- bag element evaluates to MISSING in bag constructor, compileOption: LEGACY -- pivot into a tuple with invalid attribute name, compileOption: LEGACY -- missing value in arithmetic expression, compileOption: PERMISSIVE -- data type mismatch in comparison expression, compileOption: PERMISSIVE -- data type mismatch in logical expression, compileOption: PERMISSIVE -- equality of scalar missing, compileOption: PERMISSIVE -- equality of same element bags, compileOption: PERMISSIVE -- equality of same element bags, compileOption: LEGACY -- WHERE clause eliminating absent values, compileOption: PERMISSIVE -- WHERE clause eliminating absent values, compileOption: LEGACY -- group by with absent values, compileOption: LEGACY -- group by with differenciated absent values, compileOption: LEGACY -- Right with variables, compileOption: PERMISSIVE -- Right with variables, compileOption: LEGACY -- Right with spots, compileOption: PERMISSIVE -- Right with spots, compileOption: LEGACY -- Right shorthand, compileOption: PERMISSIVE -- Right shorthand, compileOption: LEGACY -- Left with variables, compileOption: PERMISSIVE -- Left with variables, compileOption: LEGACY -- Left with spots, compileOption: PERMISSIVE -- Left with spots, compileOption: LEGACY -- Left shorthand, compileOption: PERMISSIVE -- Left shorthand, compileOption: LEGACY -- Left+right with variables, compileOption: PERMISSIVE -- Left+right with variables, compileOption: LEGACY -- Left+right with spots, compileOption: PERMISSIVE -- Left+right with spots, compileOption: LEGACY -- Left+right shorthand, compileOption: PERMISSIVE -- Left+right shorthand, compileOption: LEGACY -- Left+right with variables and label, compileOption: PERMISSIVE -- Left+right with variables and label, compileOption: LEGACY -- Undirected with variables, compileOption: PERMISSIVE -- Undirected with variables, compileOption: LEGACY -- Undirected with spots, compileOption: PERMISSIVE -- Undirected with spots, compileOption: LEGACY -- Undirected shorthand, compileOption: PERMISSIVE -- Undirected shorthand, compileOption: LEGACY -- Undirected with variables and label, compileOption: PERMISSIVE -- Undirected with variables and label, compileOption: LEGACY -- Right+undirected with variables, compileOption: PERMISSIVE -- Right+undirected with variables, compileOption: LEGACY -- Right+undirected with spots, compileOption: PERMISSIVE -- Right+undirected with spots, compileOption: LEGACY -- Right+undirected shorthand, compileOption: PERMISSIVE -- Right+undirected shorthand, compileOption: LEGACY -- Right+undirected with variables and labels, compileOption: PERMISSIVE -- Right+undirected with variables and labels, compileOption: LEGACY -- Left+undirected with variables, compileOption: PERMISSIVE -- Left+undirected with variables, compileOption: LEGACY -- Left+undirected with spots, compileOption: PERMISSIVE -- Left+undirected with spots, compileOption: LEGACY -- Left+undirected shorthand, compileOption: PERMISSIVE -- Left+undirected shorthand, compileOption: LEGACY -- Left+undirected with variables and label, compileOption: PERMISSIVE -- Left+undirected with variables and label, compileOption: LEGACY -- Left+right+undirected with variables, compileOption: PERMISSIVE -- Left+right+undirected with variables, compileOption: LEGACY -- Left+right+undirected with spots, compileOption: PERMISSIVE -- Left+right+undirected with spots, compileOption: LEGACY -- Left+right+undirected shorthand, compileOption: PERMISSIVE -- Left+right+undirected shorthand, compileOption: LEGACY -- (N0E0 MATCH (x)), compileOption: PERMISSIVE -- (N0E0 MATCH (x)), compileOption: LEGACY -- (N0E0 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N0E0 MATCH -[y]-> ), compileOption: LEGACY -- (N0E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE + +- tuple navigation with array notation without explicit CAST to string, compileOption: LEGACY + +- path on string, compileOption: LEGACY + +- tuple navigation missing attribute dot notation, compileOption: LEGACY + +- tuple navigation missing attribute array notation, compileOption: LEGACY + +- array navigation with wrongly typed array index, compileOption: LEGACY + +- data type mismatch in comparison expression, compileOption: LEGACY + +- data type mismatch in logical expression, compileOption: LEGACY + +- LIKE bad value type, compileOption: LEGACY + +- LIKE bad pattern type, compileOption: LEGACY + +- LIKE bad escape type, compileOption: LEGACY + +- outerUnionDistinct, compileOption: PERMISSIVE + +- outerUnionDistinct, compileOption: LEGACY + +- outerUnionAll, compileOption: PERMISSIVE + +- outerUnionAll, compileOption: LEGACY + +- outerIntersectDistinct, compileOption: PERMISSIVE + +- outerIntersectDistinct, compileOption: LEGACY + +- outerIntersectAll, compileOption: PERMISSIVE + +- outerIntersectAll, compileOption: LEGACY + +- outerExceptDistinct, compileOption: PERMISSIVE + +- outerExceptDistinct, compileOption: LEGACY + +- outerExceptAll, compileOption: PERMISSIVE + +- outerExceptAll, compileOption: LEGACY + +- outerUnionCoerceScalar, compileOption: PERMISSIVE + +- outerUnionCoerceStruct, compileOption: PERMISSIVE + +- outerUnionCoerceList, compileOption: PERMISSIVE + +- outerUnionCoerceList, compileOption: LEGACY + +- notInPredicateSingleExpr, compileOption: LEGACY + +- betweenPredicate, compileOption: PERMISSIVE + +- betweenPredicate, compileOption: LEGACY + +- notBetweenPredicate, compileOption: PERMISSIVE + +- notBetweenPredicate, compileOption: LEGACY + +- pathUnpivotWildcardFieldsAfter, compileOption: PERMISSIVE + +- pathUnpivotWildcardFieldsAfter, compileOption: LEGACY + +- pathDoubleUnpivotWildCard, compileOption: PERMISSIVE + +- pathDoubleUnpivotWildCard, compileOption: LEGACY + +- subscript with non-existent variable in lowercase, compileOption: LEGACY + +- subscript with non-existent variable in uppercase, compileOption: LEGACY + +- path expression with ambiguous table alias (lowercase), compileOption: LEGACY + +- COLL_MAX non-collection, compileOption: LEGACY + +- COLL_AVG non-collection, compileOption: LEGACY + +- COLL_COUNT non-collection, compileOption: LEGACY + +- COLL_SUM non-collection, compileOption: LEGACY + +- COLL_MIN non-collection, compileOption: LEGACY + +- COLL_ANY non-collection, compileOption: LEGACY + +- COLL_SOME non-collection, compileOption: LEGACY + +- COLL_EVERY non-collection, compileOption: LEGACY + +- selectValueCollAggregate, compileOption: PERMISSIVE + +- selectValueCollAggregate, compileOption: LEGACY + +- CHARACTER_LENGTH invalid type, compileOption: LEGACY + +- CARDINALITY('foo') type mismatch, compileOption: LEGACY + +- invalid extract year from time, compileOption: LEGACY + +- invalid extract month from time, compileOption: LEGACY + +- invalid extract day from time, compileOption: LEGACY + +- invalid extract month from time with time zone, compileOption: LEGACY + +- invalid extract day from time with time zone, compileOption: LEGACY + +- POSITION invalid type in string, compileOption: LEGACY + +- POSITION string in invalid type, compileOption: LEGACY + +- ABS('foo'), compileOption: LEGACY + +- MOD(3, 'some string'), compileOption: LEGACY + +- MOD('some string', 3), compileOption: LEGACY + +- BIT_LENGTH invalid type, compileOption: LEGACY + +- OCTET_LENGTH invalid type, compileOption: LEGACY + +- OVERLAY mismatched type, compileOption: LEGACY + +- OVERLAY PLACING mismatched type, compileOption: LEGACY + +- OVERLAY FROM mismatched type, compileOption: LEGACY + +- OVERLAY FOR mismatched type, compileOption: LEGACY + +- Example 1 — Union of Compatible Relations, compileOption: PERMISSIVE + +- Example 1 — Union of Compatible Relations, compileOption: LEGACY + +- Example 4 — Intersection of Compatible Relations, compileOption: PERMISSIVE + +- Example 4 — Intersection of Compatible Relations, compileOption: LEGACY + +- Example 5 — Difference of Compatible Relations, compileOption: PERMISSIVE + +- Example 5 — Difference of Compatible Relations, compileOption: LEGACY + +- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: PERMISSIVE + +- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: LEGACY + +- Example 3 — Outer union of Heterogenous Relations, compileOption: PERMISSIVE + +- Example 3 — Outer union of Heterogenous Relations, compileOption: LEGACY + +- Example 6 — Value Coercion; Coercion of single value, compileOption: PERMISSIVE + +- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: PERMISSIVE + +- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: LEGACY + +- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: PERMISSIVE + +- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: LEGACY + +- Example 7 — result is the empty bag, compileOption: PERMISSIVE + +- Example 7 — result is the empty bag, compileOption: LEGACY + +- undefinedUnqualifiedVariableWithUndefinedVariableBehaviorMissing, compileOption: LEGACY + +- undefinedUnqualifiedVariableIsNullExprWithUndefinedVariableBehaviorMissing, compileOption: LEGACY + +- undefinedUnqualifiedVariableIsMissingExprWithUndefinedVariableBehaviorMissing, compileOption: LEGACY + +- offset , compileOption: LEGACY + +- offset >, compileOption: LEGACY + +- GROUP BY binding referenced in FROM clause, compileOption: LEGACY + +- GROUP BY binding referenced in WHERE clause, compileOption: LEGACY + +- GROUP AS binding referenced in FROM clause, compileOption: LEGACY + +- GROUP AS binding referenced in WHERE clause, compileOption: LEGACY + +- SELECT COUNT( numInStock) + 2 AS agg FROM products, compileOption: PERMISSIVE + +- SELECT COUNT( numInStock) + 2 AS agg FROM products, compileOption: LEGACY + +- SELECT COUNT(p.numInStock) + 2 AS agg FROM products as p, compileOption: PERMISSIVE + +- SELECT COUNT(p.numInStock) + 2 AS agg FROM products as p, compileOption: LEGACY + +- projectionIterationBehaviorUnfiltered_select_list, compileOption: PERMISSIVE + +- projectionIterationBehaviorUnfiltered_select_list, compileOption: LEGACY + +
+ +### Conformance comparison report-Cross Engine +| | Base (legacy) | eval | +/- | +| --- | ---: | ---: | ---: | +| % Passing | 92.47% | 82.68% | -9.79% | +| :white_check_mark: Passing | 5380 | 4811 | -569 | +| :x: Failing | 438 | 1008 | 570 | +| :large_orange_diamond: Ignored | 0 | 0 | 0 | +| Total Tests | 5818 | 5819 | 1 | +Number passing in both: 4627 + +Number failing in both: 254 + +Number passing in legacy engine but fail in eval engine: 754 + +Number failing in legacy engine but pass in eval engine: 184 +:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) are passing in legacy but fail in eval: +
Click here to see + + +- equiv wildcard steps struct, compileOption: PERMISSIVE +- equiv wildcard steps struct, compileOption: LEGACY +- equiv path expression with wildcard steps, compileOption: PERMISSIVE +- equiv path expression with wildcard steps, compileOption: LEGACY +- equiv path collection expression with wildcard steps, compileOption: PERMISSIVE +- equiv path collection expression with wildcard steps, compileOption: LEGACY +- equiv attribute value pair unpivot missing, compileOption: PERMISSIVE +- equiv left join, compileOption: PERMISSIVE +- equiv left join, compileOption: LEGACY +- Example 6 — Value Coercion, compileOption: LEGACY +- path on string, compileOption: PERMISSIVE +- tuple navigation missing attribute dot notation, compileOption: PERMISSIVE +- tuple navigation missing attribute array notation, compileOption: PERMISSIVE +- array navigation with wrongly typed array index, compileOption: PERMISSIVE +- single source FROM with scalar, compileOption: LEGACY +- single source FROM with tuple, compileOption: LEGACY +- single source FROM with absent value null, compileOption: LEGACY +- single source FROM with absent value missing, compileOption: LEGACY +- tuple constructor and mistyped attribute name, compileOption: PERMISSIVE +- attribute value evaluates to MISSING, compileOption: LEGACY +- array element evaluates to MISSING, compileOption: LEGACY +- bag element evaluates to MISSING, compileOption: LEGACY +- bag element evaluates to MISSING in bag constructor, compileOption: LEGACY +- pivot into a tuple with invalid attribute name, compileOption: LEGACY +- missing value in arithmetic expression, compileOption: PERMISSIVE +- data type mismatch in comparison expression, compileOption: PERMISSIVE +- data type mismatch in logical expression, compileOption: PERMISSIVE +- equality of scalar missing, compileOption: PERMISSIVE +- equality of same element bags, compileOption: PERMISSIVE +- equality of same element bags, compileOption: LEGACY +- WHERE clause eliminating absent values, compileOption: PERMISSIVE +- WHERE clause eliminating absent values, compileOption: LEGACY +- group by with absent values, compileOption: LEGACY +- group by with differenciated absent values, compileOption: LEGACY +- Right with variables, compileOption: PERMISSIVE +- Right with variables, compileOption: LEGACY +- Right with spots, compileOption: PERMISSIVE +- Right with spots, compileOption: LEGACY +- Right shorthand, compileOption: PERMISSIVE +- Right shorthand, compileOption: LEGACY +- Left with variables, compileOption: PERMISSIVE +- Left with variables, compileOption: LEGACY +- Left with spots, compileOption: PERMISSIVE +- Left with spots, compileOption: LEGACY +- Left shorthand, compileOption: PERMISSIVE +- Left shorthand, compileOption: LEGACY +- Left+right with variables, compileOption: PERMISSIVE +- Left+right with variables, compileOption: LEGACY +- Left+right with spots, compileOption: PERMISSIVE +- Left+right with spots, compileOption: LEGACY +- Left+right shorthand, compileOption: PERMISSIVE +- Left+right shorthand, compileOption: LEGACY +- Left+right with variables and label, compileOption: PERMISSIVE +- Left+right with variables and label, compileOption: LEGACY +- Undirected with variables, compileOption: PERMISSIVE +- Undirected with variables, compileOption: LEGACY +- Undirected with spots, compileOption: PERMISSIVE +- Undirected with spots, compileOption: LEGACY +- Undirected shorthand, compileOption: PERMISSIVE +- Undirected shorthand, compileOption: LEGACY +- Undirected with variables and label, compileOption: PERMISSIVE +- Undirected with variables and label, compileOption: LEGACY +- Right+undirected with variables, compileOption: PERMISSIVE +- Right+undirected with variables, compileOption: LEGACY +- Right+undirected with spots, compileOption: PERMISSIVE +- Right+undirected with spots, compileOption: LEGACY +- Right+undirected shorthand, compileOption: PERMISSIVE +- Right+undirected shorthand, compileOption: LEGACY +- Right+undirected with variables and labels, compileOption: PERMISSIVE +- Right+undirected with variables and labels, compileOption: LEGACY +- Left+undirected with variables, compileOption: PERMISSIVE +- Left+undirected with variables, compileOption: LEGACY +- Left+undirected with spots, compileOption: PERMISSIVE +- Left+undirected with spots, compileOption: LEGACY +- Left+undirected shorthand, compileOption: PERMISSIVE +- Left+undirected shorthand, compileOption: LEGACY +- Left+undirected with variables and label, compileOption: PERMISSIVE +- Left+undirected with variables and label, compileOption: LEGACY +- Left+right+undirected with variables, compileOption: PERMISSIVE +- Left+right+undirected with variables, compileOption: LEGACY +- Left+right+undirected with spots, compileOption: PERMISSIVE +- Left+right+undirected with spots, compileOption: LEGACY +- Left+right+undirected shorthand, compileOption: PERMISSIVE +- Left+right+undirected shorthand, compileOption: LEGACY +- (N0E0 MATCH (x)), compileOption: PERMISSIVE +- (N0E0 MATCH (x)), compileOption: LEGACY +- (N0E0 MATCH -[y]-> ), compileOption: PERMISSIVE +- (N0E0 MATCH -[y]-> ), compileOption: LEGACY +- (N0E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE - (N0E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY - (N1E0 MATCH (x)), compileOption: PERMISSIVE - (N1E0 MATCH (x)), compileOption: LEGACY @@ -1442,9 +1768,7 @@ Number failing in legacy engine but pass in eval engine: 178 - 'some value' LIKE 'some pattern' ESCAPE MISSING, compileOption: PERMISSIVE - NULL LIKE 'some pattern' ESCAPE MISSING, compileOption: PERMISSIVE - 'some value' LIKE NULL ESCAPE MISSING, compileOption: PERMISSIVE -- outerUnionCoerceScalar, compileOption: PERMISSIVE - outerUnionCoerceScalar, compileOption: LEGACY -- outerUnionCoerceStruct, compileOption: PERMISSIVE - outerUnionCoerceStruct, compileOption: LEGACY - outerUnionCoerceNullMissing, compileOption: PERMISSIVE - outerUnionCoerceNullMissing, compileOption: LEGACY @@ -1705,18 +2029,7 @@ Number failing in legacy engine but pass in eval engine: 178 - functionCall, compileOption: LEGACY - division with mixed StaticType, compileOption: PERMISSIVE - division with mixed StaticType, compileOption: LEGACY -- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: PERMISSIVE -- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: LEGACY -- Example 3 — Outer union of Heterogenous Relations, compileOption: PERMISSIVE -- Example 3 — Outer union of Heterogenous Relations, compileOption: LEGACY -- Example 6 — Value Coercion; Coercion of single value, compileOption: PERMISSIVE - Example 6 — Value Coercion; Coercion of single value, compileOption: LEGACY -- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: PERMISSIVE -- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: LEGACY -- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: PERMISSIVE -- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: LEGACY -- Example 7 — result is the empty bag, compileOption: PERMISSIVE -- Example 7 — result is the empty bag, compileOption: LEGACY - undefinedUnqualifiedVariableWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE - undefinedUnqualifiedVariableIsNullExprWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE - undefinedUnqualifiedVariableIsMissingExprWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE @@ -1898,6 +2211,8 @@ Number failing in legacy engine but pass in eval engine: 178 - MYSQL_SELECT_20, compileOption: LEGACY - MYSQL_SELECT_21, compileOption: PERMISSIVE - MYSQL_SELECT_21, compileOption: LEGACY +- MYSQL_SELECT_23, compileOption: PERMISSIVE +- MYSQL_SELECT_23, compileOption: LEGACY - MYSQL_SELECT_26, compileOption: PERMISSIVE - MYSQL_SELECT_26, compileOption: LEGACY - selectFromScalarAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE @@ -2036,614 +2351,419 @@ The following test(s) are failing in legacy but pass in eval. Before merging, co - COLL_AVG null, compileOption: PERMISSIVE -- COLL_AVG null, compileOption: LEGACY - -- COLL_AVG list of missing element, compileOption: PERMISSIVE - -- COLL_AVG list of missing element, compileOption: LEGACY - -- COLL_AVG bag of missing elements, compileOption: PERMISSIVE - -- COLL_AVG bag of missing elements, compileOption: LEGACY - -- COLL_AVG mistyped element, compileOption: PERMISSIVE - -- coll_count top level{agg:'COLL_COUNT(data)',result:(success 4)}, compileOption: PERMISSIVE - -- coll_count top level{agg:'COLL_COUNT(data)',result:(success 4)}, compileOption: LEGACY - -- topLevelCollCount, compileOption: PERMISSIVE - -- topLevelCollCount, compileOption: LEGACY - -- COLL_COUNT empty collection, compileOption: PERMISSIVE - -- COLL_COUNT empty collection, compileOption: LEGACY - -- COLL_COUNT null, compileOption: PERMISSIVE - -- COLL_COUNT null, compileOption: LEGACY - -- COLL_COUNT list of missing element, compileOption: PERMISSIVE - -- COLL_COUNT list of missing element, compileOption: LEGACY - -- COLL_COUNT bag of missing elements, compileOption: PERMISSIVE - -- COLL_COUNT bag of missing elements, compileOption: LEGACY - -- COLL_COUNT bag of heterogeneous element types, compileOption: PERMISSIVE - -- COLL_COUNT bag of heterogeneous element types, compileOption: LEGACY - -- coll_sum top level{agg:'COLL_SUM(data)',result:(success 5)}, compileOption: PERMISSIVE - -- coll_sum top level{agg:'COLL_SUM(data)',result:(success 5)}, compileOption: LEGACY - -- topLevelCollSum, compileOption: PERMISSIVE - -- topLevelCollSum, compileOption: LEGACY - -- COLL_SUM empty collection, compileOption: PERMISSIVE - -- COLL_SUM empty collection, compileOption: LEGACY - -- COLL_SUM null, compileOption: PERMISSIVE - -- COLL_SUM null, compileOption: LEGACY - -- COLL_SUM list of missing element, compileOption: PERMISSIVE - -- COLL_SUM list of missing element, compileOption: LEGACY - -- COLL_SUM bag of missing elements, compileOption: PERMISSIVE - -- COLL_SUM bag of missing elements, compileOption: LEGACY - -- COLL_SUM mistyped element, compileOption: PERMISSIVE - -- coll_min top level{agg:'COLL_MIN(data)',result:(success 1)}, compileOption: PERMISSIVE - -- coll_min top level{agg:'COLL_MIN(data)',result:(success 1)}, compileOption: LEGACY - -- topLevelCollMin, compileOption: PERMISSIVE - -- topLevelCollMin, compileOption: LEGACY - -- COLL_MIN empty collection, compileOption: PERMISSIVE - -- COLL_MIN empty collection, compileOption: LEGACY - -- COLL_MIN null, compileOption: PERMISSIVE - -- COLL_MIN null, compileOption: LEGACY - -- COLL_MIN list of missing element, compileOption: PERMISSIVE - -- COLL_MIN list of missing element, compileOption: LEGACY - -- COLL_MIN bag of missing elements, compileOption: PERMISSIVE - -- COLL_MIN bag of missing elements, compileOption: LEGACY - -- COLL_MIN bag of heterogeneous element types, compileOption: PERMISSIVE - -- COLL_MIN bag of heterogeneous element types, compileOption: LEGACY - -- COLL_ANY bag literals, compileOption: PERMISSIVE - -- COLL_ANY bag literals, compileOption: LEGACY - -- COLL_ANY list expressions, compileOption: PERMISSIVE - -- COLL_ANY list expressions, compileOption: LEGACY - -- COLL_ANY single true, compileOption: PERMISSIVE - -- COLL_ANY single true, compileOption: LEGACY - -- COLL_ANY single false, compileOption: PERMISSIVE - -- COLL_ANY single false, compileOption: LEGACY - -- COLL_ANY nulls with true, compileOption: PERMISSIVE - -- COLL_ANY nulls with true, compileOption: LEGACY - -- COLL_ANY nulls with false, compileOption: PERMISSIVE - -- COLL_ANY nulls with false, compileOption: LEGACY - -- COLL_ANY nulls only, compileOption: PERMISSIVE - -- COLL_ANY nulls only, compileOption: LEGACY - -- COLL_ANY null, compileOption: PERMISSIVE - -- COLL_ANY null, compileOption: LEGACY - -- COLL_ANY list of missing element, compileOption: PERMISSIVE - -- COLL_ANY list of missing element, compileOption: LEGACY - -- COLL_ANY bag of missing elements, compileOption: PERMISSIVE - -- COLL_ANY bag of missing elements, compileOption: LEGACY - -- COLL_ANY some empty, compileOption: PERMISSIVE - -- COLL_ANY some empty, compileOption: LEGACY - -- COLL_ANY one non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_ANY all non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_ANY nested collection, compileOption: PERMISSIVE - -- COLL_SOME bag literals, compileOption: PERMISSIVE - -- COLL_SOME bag literals, compileOption: LEGACY - -- COLL_SOME list expressions, compileOption: PERMISSIVE - -- COLL_SOME list expressions, compileOption: LEGACY - -- COLL_SOME single true, compileOption: PERMISSIVE - -- COLL_SOME single true, compileOption: LEGACY - -- COLL_SOME single false, compileOption: PERMISSIVE - -- COLL_SOME single false, compileOption: LEGACY - -- COLL_SOME nulls with true, compileOption: PERMISSIVE - -- COLL_SOME nulls with true, compileOption: LEGACY - -- COLL_SOME nulls with false, compileOption: PERMISSIVE - -- COLL_SOME nulls with false, compileOption: LEGACY - -- COLL_SOME nulls only, compileOption: PERMISSIVE - -- COLL_SOME nulls only, compileOption: LEGACY - -- COLL_SOME null, compileOption: PERMISSIVE - -- COLL_SOME null, compileOption: LEGACY - -- COLL_SOME list of missing element, compileOption: PERMISSIVE - -- COLL_SOME list of missing element, compileOption: LEGACY - -- COLL_SOME bag of missing elements, compileOption: PERMISSIVE - -- COLL_SOME bag of missing elements, compileOption: LEGACY +- COLL_AVG null, compileOption: LEGACY -- COLL_SOME some empty, compileOption: PERMISSIVE +- COLL_AVG list of missing element, compileOption: PERMISSIVE -- COLL_SOME some empty, compileOption: LEGACY +- COLL_AVG list of missing element, compileOption: LEGACY -- COLL_SOME one non-bool, non-unknown, compileOption: PERMISSIVE +- COLL_AVG bag of missing elements, compileOption: PERMISSIVE -- COLL_SOME all non-bool, non-unknown, compileOption: PERMISSIVE +- COLL_AVG bag of missing elements, compileOption: LEGACY -- COLL_SOME nested collection, compileOption: PERMISSIVE +- COLL_AVG mistyped element, compileOption: PERMISSIVE -- COLL_EVERY bag literals, compileOption: PERMISSIVE +- coll_count top level{agg:'COLL_COUNT(data)',result:(success 4)}, compileOption: PERMISSIVE -- COLL_EVERY bag literals, compileOption: LEGACY +- coll_count top level{agg:'COLL_COUNT(data)',result:(success 4)}, compileOption: LEGACY -- COLL_EVERY list expressions, compileOption: PERMISSIVE +- topLevelCollCount, compileOption: PERMISSIVE -- COLL_EVERY list expressions, compileOption: LEGACY +- topLevelCollCount, compileOption: LEGACY -- COLL_EVERY single true, compileOption: PERMISSIVE +- COLL_COUNT empty collection, compileOption: PERMISSIVE -- COLL_EVERY single true, compileOption: LEGACY +- COLL_COUNT empty collection, compileOption: LEGACY -- COLL_EVERY single false, compileOption: PERMISSIVE +- COLL_COUNT null, compileOption: PERMISSIVE -- COLL_EVERY single false, compileOption: LEGACY +- COLL_COUNT null, compileOption: LEGACY -- COLL_EVERY null and missing with true, compileOption: PERMISSIVE +- COLL_COUNT list of missing element, compileOption: PERMISSIVE -- COLL_EVERY null and missing with true, compileOption: LEGACY +- COLL_COUNT list of missing element, compileOption: LEGACY -- COLL_EVERY null with false, compileOption: PERMISSIVE +- COLL_COUNT bag of missing elements, compileOption: PERMISSIVE -- COLL_EVERY null with false, compileOption: LEGACY +- COLL_COUNT bag of missing elements, compileOption: LEGACY -- COLL_EVERY null and missing only, compileOption: PERMISSIVE +- COLL_COUNT bag of heterogeneous element types, compileOption: PERMISSIVE -- COLL_EVERY null and missing only, compileOption: LEGACY +- COLL_COUNT bag of heterogeneous element types, compileOption: LEGACY -- COLL_EVERY null, compileOption: PERMISSIVE +- coll_sum top level{agg:'COLL_SUM(data)',result:(success 5)}, compileOption: PERMISSIVE -- COLL_EVERY null, compileOption: LEGACY +- coll_sum top level{agg:'COLL_SUM(data)',result:(success 5)}, compileOption: LEGACY -- COLL_EVERY list of missing element, compileOption: PERMISSIVE +- topLevelCollSum, compileOption: PERMISSIVE -- COLL_EVERY list of missing element, compileOption: LEGACY +- topLevelCollSum, compileOption: LEGACY -- COLL_EVERY bag of missing elements, compileOption: PERMISSIVE +- COLL_SUM empty collection, compileOption: PERMISSIVE -- COLL_EVERY bag of missing elements, compileOption: LEGACY +- COLL_SUM empty collection, compileOption: LEGACY -- COLL_EVERY empty collection, compileOption: PERMISSIVE +- COLL_SUM null, compileOption: PERMISSIVE -- COLL_EVERY empty collection, compileOption: LEGACY +- COLL_SUM null, compileOption: LEGACY -- COLL_EVERY one non-bool, non-unknown, compileOption: PERMISSIVE +- COLL_SUM list of missing element, compileOption: PERMISSIVE -- COLL_EVERY all non-bool, non-unknown, compileOption: PERMISSIVE +- COLL_SUM list of missing element, compileOption: LEGACY -- COLL_EVERY nested collection, compileOption: PERMISSIVE +- COLL_SUM bag of missing elements, compileOption: PERMISSIVE -- selectValueCollAggregate, compileOption: PERMISSIVE +- COLL_SUM bag of missing elements, compileOption: LEGACY -- selectValueCollAggregate, compileOption: LEGACY +- COLL_SUM mistyped element, compileOption: PERMISSIVE -- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67Z`), compileOption: PERMISSIVE +- coll_min top level{agg:'COLL_MIN(data)',result:(success 1)}, compileOption: PERMISSIVE -- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67Z`), compileOption: LEGACY +- coll_min top level{agg:'COLL_MIN(data)',result:(success 1)}, compileOption: LEGACY -- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: PERMISSIVE +- topLevelCollMin, compileOption: PERMISSIVE -- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: LEGACY +- topLevelCollMin, compileOption: LEGACY -- offset 2^63, compileOption: PERMISSIVE +- COLL_MIN empty collection, compileOption: PERMISSIVE -- offset 2^63, compileOption: LEGACY +- COLL_MIN empty collection, compileOption: LEGACY -- SELECT supplierId_missings FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE +- COLL_MIN null, compileOption: PERMISSIVE -- SELECT p.supplierId_missings FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE +- COLL_MIN null, compileOption: LEGACY -- SELECT VALUE { 'supplierId_missings' : p.supplierId_missings } FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE +- COLL_MIN list of missing element, compileOption: PERMISSIVE -- SELECT supplierId_mixed FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE +- COLL_MIN list of missing element, compileOption: LEGACY -- SELECT p.supplierId_mixed FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE +- COLL_MIN bag of missing elements, compileOption: PERMISSIVE -- SELECT VALUE { 'supplierId_mixed' : p.supplierId_mixed } FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE +- COLL_MIN bag of missing elements, compileOption: LEGACY -- SELECT regionId, supplierId_missings FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE +- COLL_MIN bag of heterogeneous element types, compileOption: PERMISSIVE -- SELECT p.regionId, p.supplierId_missings FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE +- COLL_MIN bag of heterogeneous element types, compileOption: LEGACY -- SELECT VALUE { 'regionId': p.regionId, 'supplierId_missings': p.supplierId_missings } FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE +- COLL_ANY bag literals, compileOption: PERMISSIVE -- SELECT regionId, supplierId_mixed FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE +- COLL_ANY bag literals, compileOption: LEGACY -- SELECT regionId, p.supplierId_mixed FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE +- COLL_ANY list expressions, compileOption: PERMISSIVE -- SELECT VALUE { 'regionId': p.regionId, 'supplierId_mixed': p.supplierId_mixed } FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE +- COLL_ANY list expressions, compileOption: LEGACY -- SELECT with nested aggregates (complex) 2, compileOption: PERMISSIVE +- COLL_ANY single true, compileOption: PERMISSIVE -- SELECT with nested aggregates (complex) 2, compileOption: LEGACY +- COLL_ANY single true, compileOption: LEGACY -
+- COLL_ANY single false, compileOption: PERMISSIVE -### Conformance comparison report-Cross Commit-LEGACY -| | Base (HEAD) | HEAD | +/- | -| --- | ---: | ---: | ---: | -| % Passing | 92.51% | 92.47% | -0.03% | -| :white_check_mark: Passing | 5382 | 5380 | -2 | -| :x: Failing | 436 | 438 | 2 | -| :large_orange_diamond: Ignored | 0 | 0 | 0 | -| Total Tests | 5818 | 5818 | 0 | -Number passing in both: 5380 +- COLL_ANY single false, compileOption: LEGACY -Number failing in both: 436 +- COLL_ANY nulls with true, compileOption: PERMISSIVE -Number passing in Base (HEAD) but now fail: 2 +- COLL_ANY nulls with true, compileOption: LEGACY -Number failing in Base (HEAD) but now pass: 0 -:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) were previously passing but now fail: -
Click here to see +- COLL_ANY nulls with false, compileOption: PERMISSIVE +- COLL_ANY nulls with false, compileOption: LEGACY -- outerExceptDistinct, compileOption: PERMISSIVE -- outerExceptDistinct, compileOption: LEGACY -
+- COLL_ANY nulls only, compileOption: PERMISSIVE -### Conformance comparison report-Cross Commit-EVAL -| | Base (HEAD) | HEAD | +/- | -| --- | ---: | ---: | ---: | -| % Passing | 82.81% | 82.37% | -0.45% | -| :white_check_mark: Passing | 4819 | 4792 | -27 | -| :x: Failing | 1000 | 1026 | 26 | -| :large_orange_diamond: Ignored | 0 | 0 | 0 | -| Total Tests | 5819 | 5818 | -1 | -Number passing in both: 4711 +- COLL_ANY nulls only, compileOption: LEGACY -Number failing in both: 918 +- COLL_ANY null, compileOption: PERMISSIVE -Number passing in Base (HEAD) but now fail: 108 +- COLL_ANY null, compileOption: LEGACY -Number failing in Base (HEAD) but now pass: 82 -:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) were previously passing but now fail: -
Click here to see +- COLL_ANY list of missing element, compileOption: PERMISSIVE +- COLL_ANY list of missing element, compileOption: LEGACY -- inPredicate, compileOption: PERMISSIVE -- inPredicate, compileOption: LEGACY -- inPredicateSingleItem, compileOption: PERMISSIVE -- inPredicateSingleItem, compileOption: LEGACY -- inPredicateSingleItemListVar, compileOption: PERMISSIVE -- inPredicateSubQuerySelectValue, compileOption: PERMISSIVE -- inPredicateSubQuerySelectValue, compileOption: LEGACY -- notInPredicate, compileOption: PERMISSIVE -- notInPredicate, compileOption: LEGACY -- notInPredicateSingleItem, compileOption: PERMISSIVE -- notInPredicateSingleItem, compileOption: LEGACY -- notInPredicateSingleItemListVar, compileOption: PERMISSIVE -- notInPredicateSubQuerySelectValue, compileOption: PERMISSIVE -- notInPredicateSubQuerySelectValue, compileOption: LEGACY -- inPredicateWithTableConstructor, compileOption: PERMISSIVE -- inPredicateWithTableConstructor, compileOption: LEGACY -- notInPredicateWithTableConstructor, compileOption: PERMISSIVE -- notInPredicateWithTableConstructor, compileOption: LEGACY -- inPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE -- inPredicateWithExpressionOnRightSide, compileOption: LEGACY -- notInPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE -- notInPredicateWithExpressionOnRightSide, compileOption: LEGACY -- pathDoubleWildCard, compileOption: PERMISSIVE -- pathDoubleWildCard, compileOption: LEGACY -- nullif valid cases{first:"1",second:"1",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"1",result:null}, compileOption: LEGACY -- nullif valid cases{first:"1",second:"2",result:1}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"2",result:1}, compileOption: LEGACY -- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: PERMISSIVE -- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: LEGACY -- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: LEGACY -- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: LEGACY -- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: PERMISSIVE -- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: LEGACY -- nullif valid cases{first:"1",second:"null",result:1}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"null",result:1}, compileOption: LEGACY -- nullif valid cases{first:"null",second:"1",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"null",second:"1",result:null}, compileOption: LEGACY -- nullif valid cases{first:"null",second:"null",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"null",second:"null",result:null}, compileOption: LEGACY -- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: LEGACY -- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: PERMISSIVE -- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: LEGACY -- nullif valid cases{first:"missing",second:"missing",result:missing}, compileOption: PERMISSIVE -- nullif valid cases{first:"missing",second:"missing",result:missing}, compileOption: LEGACY -- coalesce valid cases{args:"1",result:(success 1)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"1",result:(success 1)}, compileOption: LEGACY -- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: LEGACY -- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: LEGACY -- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: LEGACY -- join on column - all column values non-null, compileOption: PERMISSIVE -- join on column - all column values non-null, compileOption: LEGACY -- join on column - some column values are null, compileOption: PERMISSIVE -- join on column - some column values are null, compileOption: LEGACY -- join on column - 1 table contains 1 row with the value null, compileOption: PERMISSIVE -- join on column - ON condition = false, compileOption: PERMISSIVE -- join on column - ON condition = false, compileOption: LEGACY -- PG_JOIN_01, compileOption: PERMISSIVE -- PG_JOIN_01, compileOption: LEGACY -- PG_JOIN_02, compileOption: PERMISSIVE -- PG_JOIN_02, compileOption: LEGACY -- PG_JOIN_03, compileOption: PERMISSIVE -- PG_JOIN_03, compileOption: LEGACY -- PG_JOIN_06, compileOption: PERMISSIVE -- PG_JOIN_06, compileOption: LEGACY -- PG_JOIN_08, compileOption: PERMISSIVE -- PG_JOIN_08, compileOption: LEGACY -- PG_JOIN_10, compileOption: PERMISSIVE -- PG_JOIN_10, compileOption: LEGACY -- offset 0, compileOption: PERMISSIVE -- offset 0, compileOption: LEGACY -- offset 1, compileOption: PERMISSIVE -- offset 1, compileOption: LEGACY -- offset 2, compileOption: PERMISSIVE -- offset 2, compileOption: LEGACY -- limit 1 offset 1, compileOption: PERMISSIVE -- limit 1 offset 1, compileOption: LEGACY -- limit 10 offset 1, compileOption: PERMISSIVE -- limit 10 offset 1, compileOption: LEGACY -- limit 2 offset 2, compileOption: PERMISSIVE -- limit 2 offset 2, compileOption: LEGACY -- limit offset after group by, compileOption: PERMISSIVE -- limit offset after group by, compileOption: LEGACY -- offset 2-1, compileOption: PERMISSIVE -- offset 2-1, compileOption: LEGACY -- offset 2+1, compileOption: PERMISSIVE -- offset 2+1, compileOption: LEGACY -- offset 2*1, compileOption: PERMISSIVE -- offset 2*1, compileOption: LEGACY -- offset 2/1, compileOption: PERMISSIVE -- offset 2/1, compileOption: LEGACY -- offset group by having, compileOption: PERMISSIVE -- offset group by having, compileOption: LEGACY -- offset with pivot, compileOption: PERMISSIVE -- offset with pivot, compileOption: LEGACY -- offset 1-2, compileOption: PERMISSIVE -- selectStarSingleSourceHoisted, compileOption: PERMISSIVE -- selectStarSingleSourceHoisted, compileOption: LEGACY -- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: PERMISSIVE -- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: LEGACY -- selectCorrelatedJoin, compileOption: PERMISSIVE -- selectCorrelatedJoin, compileOption: LEGACY -
-The following test(s) were previously failing but now pass. Before merging, confirm they are intended to pass: -
Click here to see +- COLL_ANY bag of missing elements, compileOption: PERMISSIVE +- COLL_ANY bag of missing elements, compileOption: LEGACY -- equiv attribute value pair unpivot missing, compileOption: LEGACY +- COLL_ANY some empty, compileOption: PERMISSIVE -- tuple navigation with array notation without explicit CAST to string, compileOption: LEGACY +- COLL_ANY some empty, compileOption: LEGACY -- path on string, compileOption: LEGACY +- COLL_ANY one non-bool, non-unknown, compileOption: PERMISSIVE -- tuple navigation missing attribute dot notation, compileOption: LEGACY +- COLL_ANY all non-bool, non-unknown, compileOption: PERMISSIVE -- tuple navigation missing attribute array notation, compileOption: LEGACY +- COLL_ANY nested collection, compileOption: PERMISSIVE -- array navigation with wrongly typed array index, compileOption: LEGACY +- COLL_SOME bag literals, compileOption: PERMISSIVE -- data type mismatch in comparison expression, compileOption: LEGACY +- COLL_SOME bag literals, compileOption: LEGACY -- data type mismatch in logical expression, compileOption: LEGACY +- COLL_SOME list expressions, compileOption: PERMISSIVE -- LIKE bad value type, compileOption: LEGACY +- COLL_SOME list expressions, compileOption: LEGACY -- LIKE bad pattern type, compileOption: LEGACY +- COLL_SOME single true, compileOption: PERMISSIVE -- LIKE bad escape type, compileOption: LEGACY +- COLL_SOME single true, compileOption: LEGACY -- outerUnionDistinct, compileOption: PERMISSIVE +- COLL_SOME single false, compileOption: PERMISSIVE -- outerUnionDistinct, compileOption: LEGACY +- COLL_SOME single false, compileOption: LEGACY -- outerUnionAll, compileOption: PERMISSIVE +- COLL_SOME nulls with true, compileOption: PERMISSIVE -- outerUnionAll, compileOption: LEGACY +- COLL_SOME nulls with true, compileOption: LEGACY -- outerIntersectDistinct, compileOption: PERMISSIVE +- COLL_SOME nulls with false, compileOption: PERMISSIVE -- outerIntersectDistinct, compileOption: LEGACY +- COLL_SOME nulls with false, compileOption: LEGACY -- outerIntersectAll, compileOption: PERMISSIVE +- COLL_SOME nulls only, compileOption: PERMISSIVE -- outerIntersectAll, compileOption: LEGACY +- COLL_SOME nulls only, compileOption: LEGACY -- outerExceptDistinct, compileOption: PERMISSIVE +- COLL_SOME null, compileOption: PERMISSIVE -- outerExceptDistinct, compileOption: LEGACY +- COLL_SOME null, compileOption: LEGACY -- outerExceptAll, compileOption: PERMISSIVE +- COLL_SOME list of missing element, compileOption: PERMISSIVE -- outerExceptAll, compileOption: LEGACY +- COLL_SOME list of missing element, compileOption: LEGACY -- outerUnionCoerceList, compileOption: PERMISSIVE +- COLL_SOME bag of missing elements, compileOption: PERMISSIVE -- outerUnionCoerceList, compileOption: LEGACY +- COLL_SOME bag of missing elements, compileOption: LEGACY -- notInPredicateSingleExpr, compileOption: LEGACY +- COLL_SOME some empty, compileOption: PERMISSIVE -- betweenPredicate, compileOption: PERMISSIVE +- COLL_SOME some empty, compileOption: LEGACY -- betweenPredicate, compileOption: LEGACY +- COLL_SOME one non-bool, non-unknown, compileOption: PERMISSIVE -- notBetweenPredicate, compileOption: PERMISSIVE +- COLL_SOME all non-bool, non-unknown, compileOption: PERMISSIVE -- notBetweenPredicate, compileOption: LEGACY +- COLL_SOME nested collection, compileOption: PERMISSIVE -- pathUnpivotWildcardFieldsAfter, compileOption: PERMISSIVE +- COLL_EVERY bag literals, compileOption: PERMISSIVE -- pathUnpivotWildcardFieldsAfter, compileOption: LEGACY +- COLL_EVERY bag literals, compileOption: LEGACY -- pathDoubleUnpivotWildCard, compileOption: PERMISSIVE +- COLL_EVERY list expressions, compileOption: PERMISSIVE -- pathDoubleUnpivotWildCard, compileOption: LEGACY +- COLL_EVERY list expressions, compileOption: LEGACY -- subscript with non-existent variable in lowercase, compileOption: LEGACY +- COLL_EVERY single true, compileOption: PERMISSIVE -- subscript with non-existent variable in uppercase, compileOption: LEGACY +- COLL_EVERY single true, compileOption: LEGACY -- path expression with ambiguous table alias (lowercase), compileOption: LEGACY +- COLL_EVERY single false, compileOption: PERMISSIVE -- COLL_MAX non-collection, compileOption: LEGACY +- COLL_EVERY single false, compileOption: LEGACY -- COLL_AVG non-collection, compileOption: LEGACY +- COLL_EVERY null and missing with true, compileOption: PERMISSIVE -- COLL_COUNT non-collection, compileOption: LEGACY +- COLL_EVERY null and missing with true, compileOption: LEGACY -- COLL_SUM non-collection, compileOption: LEGACY +- COLL_EVERY null with false, compileOption: PERMISSIVE -- COLL_MIN non-collection, compileOption: LEGACY +- COLL_EVERY null with false, compileOption: LEGACY -- COLL_ANY non-collection, compileOption: LEGACY +- COLL_EVERY null and missing only, compileOption: PERMISSIVE -- COLL_SOME non-collection, compileOption: LEGACY +- COLL_EVERY null and missing only, compileOption: LEGACY -- COLL_EVERY non-collection, compileOption: LEGACY +- COLL_EVERY null, compileOption: PERMISSIVE + +- COLL_EVERY null, compileOption: LEGACY + +- COLL_EVERY list of missing element, compileOption: PERMISSIVE + +- COLL_EVERY list of missing element, compileOption: LEGACY + +- COLL_EVERY bag of missing elements, compileOption: PERMISSIVE + +- COLL_EVERY bag of missing elements, compileOption: LEGACY + +- COLL_EVERY empty collection, compileOption: PERMISSIVE + +- COLL_EVERY empty collection, compileOption: LEGACY + +- COLL_EVERY one non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_EVERY all non-bool, non-unknown, compileOption: PERMISSIVE + +- COLL_EVERY nested collection, compileOption: PERMISSIVE - selectValueCollAggregate, compileOption: PERMISSIVE - selectValueCollAggregate, compileOption: LEGACY -- CHARACTER_LENGTH invalid type, compileOption: LEGACY +- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67Z`), compileOption: PERMISSIVE -- CARDINALITY('foo') type mismatch, compileOption: LEGACY +- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67Z`), compileOption: LEGACY -- invalid extract year from time, compileOption: LEGACY +- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: PERMISSIVE -- invalid extract month from time, compileOption: LEGACY +- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: LEGACY -- invalid extract day from time, compileOption: LEGACY +- Example 1 — Union of Compatible Relations, compileOption: PERMISSIVE -- invalid extract month from time with time zone, compileOption: LEGACY +- Example 1 — Union of Compatible Relations, compileOption: LEGACY -- invalid extract day from time with time zone, compileOption: LEGACY +- Example 4 — Intersection of Compatible Relations, compileOption: PERMISSIVE -- POSITION invalid type in string, compileOption: LEGACY +- Example 4 — Intersection of Compatible Relations, compileOption: LEGACY -- POSITION string in invalid type, compileOption: LEGACY +- Example 5 — Difference of Compatible Relations, compileOption: PERMISSIVE -- ABS('foo'), compileOption: LEGACY +- Example 5 — Difference of Compatible Relations, compileOption: LEGACY -- MOD(3, 'some string'), compileOption: LEGACY +- offset 2^63, compileOption: PERMISSIVE -- MOD('some string', 3), compileOption: LEGACY +- offset 2^63, compileOption: LEGACY -- BIT_LENGTH invalid type, compileOption: LEGACY +- SELECT supplierId_missings FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE -- OCTET_LENGTH invalid type, compileOption: LEGACY +- SELECT p.supplierId_missings FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE -- OVERLAY mismatched type, compileOption: LEGACY +- SELECT VALUE { 'supplierId_missings' : p.supplierId_missings } FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE -- OVERLAY PLACING mismatched type, compileOption: LEGACY +- SELECT supplierId_mixed FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE -- OVERLAY FROM mismatched type, compileOption: LEGACY +- SELECT p.supplierId_mixed FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE -- OVERLAY FOR mismatched type, compileOption: LEGACY +- SELECT VALUE { 'supplierId_mixed' : p.supplierId_mixed } FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE -- undefinedUnqualifiedVariableWithUndefinedVariableBehaviorMissing, compileOption: LEGACY +- SELECT regionId, supplierId_missings FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE -- undefinedUnqualifiedVariableIsNullExprWithUndefinedVariableBehaviorMissing, compileOption: LEGACY +- SELECT p.regionId, p.supplierId_missings FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE -- undefinedUnqualifiedVariableIsMissingExprWithUndefinedVariableBehaviorMissing, compileOption: LEGACY +- SELECT VALUE { 'regionId': p.regionId, 'supplierId_missings': p.supplierId_missings } FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE -- offset , compileOption: LEGACY +- SELECT regionId, supplierId_mixed FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE -- offset >, compileOption: LEGACY +- SELECT regionId, p.supplierId_mixed FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE -- GROUP BY binding referenced in FROM clause, compileOption: LEGACY +- SELECT VALUE { 'regionId': p.regionId, 'supplierId_mixed': p.supplierId_mixed } FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE -- GROUP BY binding referenced in WHERE clause, compileOption: LEGACY +- SELECT with nested aggregates (complex) 2, compileOption: PERMISSIVE -- GROUP AS binding referenced in FROM clause, compileOption: LEGACY +- SELECT with nested aggregates (complex) 2, compileOption: LEGACY -- GROUP AS binding referenced in WHERE clause, compileOption: LEGACY +
-- SELECT COUNT( numInStock) + 2 AS agg FROM products, compileOption: PERMISSIVE +### Conformance comparison report-Cross Commit-LEGACY +| | Base (HEAD) | HEAD | +/- | +| --- | ---: | ---: | ---: | +| % Passing | 92.47% | 92.47% | 0.00% | +| :white_check_mark: Passing | 5380 | 5380 | 0 | +| :x: Failing | 438 | 438 | 0 | +| :large_orange_diamond: Ignored | 0 | 0 | 0 | +| Total Tests | 5818 | 5818 | 0 | +Number passing in both: 5380 -- SELECT COUNT( numInStock) + 2 AS agg FROM products, compileOption: LEGACY +Number failing in both: 438 -- SELECT COUNT(p.numInStock) + 2 AS agg FROM products as p, compileOption: PERMISSIVE +Number passing in Base (HEAD) but now fail: 0 -- SELECT COUNT(p.numInStock) + 2 AS agg FROM products as p, compileOption: LEGACY +Number failing in Base (HEAD) but now pass: 0 -- MYSQL_SELECT_23, compileOption: PERMISSIVE +### Conformance comparison report-Cross Commit-EVAL +| | Base (HEAD) | HEAD | +/- | +| --- | ---: | ---: | ---: | +| % Passing | 82.12% | 82.68% | 0.55% | +| :white_check_mark: Passing | 4778 | 4811 | 33 | +| :x: Failing | 1040 | 1008 | -32 | +| :large_orange_diamond: Ignored | 0 | 0 | 0 | +| Total Tests | 5818 | 5819 | 1 | +Number passing in both: 4776 + +Number failing in both: 1006 + +Number passing in Base (HEAD) but now fail: 2 + +Number failing in Base (HEAD) but now pass: 35 +:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) were previously passing but now fail: +
Click here to see + +- MYSQL_SELECT_23, compileOption: PERMISSIVE - MYSQL_SELECT_23, compileOption: LEGACY +
+The following test(s) were previously failing but now pass. Before merging, confirm they are intended to pass: +
Click here to see -- projectionIterationBehaviorUnfiltered_select_list, compileOption: PERMISSIVE -- projectionIterationBehaviorUnfiltered_select_list, compileOption: LEGACY +- Example 6 — Value Coercion, compileOption: PERMISSIVE + +- Example 6 — Value Coercion, compileOption: LEGACY + +- outerUnionDistinct, compileOption: PERMISSIVE + +- outerUnionDistinct, compileOption: LEGACY + +- outerUnionAll, compileOption: PERMISSIVE + +- outerUnionAll, compileOption: LEGACY + +- outerIntersectDistinct, compileOption: PERMISSIVE + +- outerIntersectDistinct, compileOption: LEGACY + +- outerIntersectAll, compileOption: PERMISSIVE + +- outerIntersectAll, compileOption: LEGACY + +- outerExceptDistinct, compileOption: PERMISSIVE + +- outerExceptDistinct, compileOption: LEGACY + +- outerExceptAll, compileOption: PERMISSIVE + +- outerExceptAll, compileOption: LEGACY + +- outerUnionCoerceScalar, compileOption: PERMISSIVE + +- outerUnionCoerceStruct, compileOption: PERMISSIVE + +- outerUnionCoerceList, compileOption: PERMISSIVE + +- outerUnionCoerceList, compileOption: LEGACY + +- Example 1 — Union of Compatible Relations, compileOption: PERMISSIVE + +- Example 1 — Union of Compatible Relations, compileOption: LEGACY + +- Example 4 — Intersection of Compatible Relations, compileOption: PERMISSIVE + +- Example 4 — Intersection of Compatible Relations, compileOption: LEGACY + +- Example 5 — Difference of Compatible Relations, compileOption: PERMISSIVE + +- Example 5 — Difference of Compatible Relations, compileOption: LEGACY + +- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: PERMISSIVE + +- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: LEGACY + +- Example 3 — Outer union of Heterogenous Relations, compileOption: PERMISSIVE + +- Example 3 — Outer union of Heterogenous Relations, compileOption: LEGACY + +- Example 6 — Value Coercion; Coercion of single value, compileOption: PERMISSIVE + +- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: PERMISSIVE + +- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: LEGACY + +- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: PERMISSIVE + +- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: LEGACY + +- Example 7 — result is the empty bag, compileOption: PERMISSIVE + +- Example 7 — result is the empty bag, compileOption: LEGACY
From 367287ea6e7e9ddf92be92ce9f81cbf1cd659d38 Mon Sep 17 00:00:00 2001 From: John Ed Quinn Date: Mon, 15 Apr 2024 17:23:31 -0700 Subject: [PATCH 03/12] Adds enforcement of non-OUTER typing --- .../org/partiql/planner/internal/ir/Nodes.kt | 1 + .../internal/transforms/RelConverter.kt | 2 +- .../internal/transforms/RexConverter.kt | 2 +- .../planner/internal/typer/PlanTyper.kt | 43 ++++++++++++++----- .../main/resources/partiql_plan_internal.ion | 8 +++- 5 files changed, 43 insertions(+), 13 deletions(-) diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/ir/Nodes.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/ir/Nodes.kt index 68aaafb8f8..686a6ddec3 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/ir/Nodes.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/ir/Nodes.kt @@ -1021,6 +1021,7 @@ internal data class Rel( @JvmField internal val lhs: Rel, @JvmField internal val rhs: Rel, @JvmField internal val type: Type, + @JvmField internal val isOuter: Boolean ) : Op() { public override val children: List by lazy { val kids = mutableListOf() diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RelConverter.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RelConverter.kt index 7d111b2e4e..987ab02698 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RelConverter.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RelConverter.kt @@ -458,7 +458,7 @@ internal object RelConverter { null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.INTERSECT_DISTINCT } } - val op = Rel.Op.Set(lhs, rhs, setType) + val op = Rel.Op.Set(lhs, rhs, setType, isOuter = false) return rel(type, op) } diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt index 2eacc59b9f..f115d02199 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt @@ -846,7 +846,7 @@ internal object RexConverter { null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.INTERSECT_DISTINCT } } - val op = Rel.Op.Set(lhs, rhs, type) + val op = Rel.Op.Set(lhs, rhs, type, isOuter = node.outer == true) val rel = Rel( type = Rel.Type(listOf(Rel.Binding("_0", StaticType.ANY)), props = emptySet()), op = op diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt index 05cc422f5e..290b1e0e42 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt @@ -219,23 +219,46 @@ internal class PlanTyper(private val env: Env) { return rel(type, op) } - override fun visitRelOpSet(node: Rel.Op.Set, ctx: Rel.Type?): PlanNode { + override fun visitRelOpSet(node: Rel.Op.Set, ctx: Rel.Type?): Rel { val lhs = visitRel(node.lhs, node.lhs.type) val rhs = visitRel(node.rhs, node.rhs.type) val set = node.copy(lhs = lhs, rhs = rhs) - // Compute Schema + // Check that types are comparable + if (!node.isOuter) { + if (lhs.type.schema.size != rhs.type.schema.size) { + return Rel(Rel.Type(emptyList(), emptySet()), Rel.Op.Err("LHS and RHS of SET OP do not have the same number of bindings.")) + } + for (i in 0..lhs.type.schema.lastIndex) { + val lhsBindingType = lhs.type.schema[i].type + val rhsBindingType = rhs.type.schema[i].type + // TODO: [RFC-0007](https://github.com/partiql/partiql-lang/blob/main/RFCs/0007-rfc-bag-operators.md) + // states that the types must be "comparable". The below code ONLY makes sure that types need to be + // the same. In the future, we need to add support for checking comparable types. + if (lhsBindingType != rhsBindingType) { + return Rel(Rel.Type(emptyList(), emptySet()), Rel.Op.Err("LHS and RHS of SET OP do not have the same type.")) + } + } + } + + // Compute Output Schema val size = max(lhs.type.schema.size, rhs.type.schema.size) - val schema = List(size) { - val lhsBinding = lhs.type.schema.getOrNull(it) ?: Rel.Binding("_$it", MISSING) - val rhsBinding = rhs.type.schema.getOrNull(it) ?: Rel.Binding("_$it", MISSING) - val bindingName = when (lhsBinding.name == rhsBinding.name) { - true -> lhsBinding.name - false -> "_$it" + val type = when (node.type) { + Rel.Op.Set.Type.EXCEPT_DISTINCT, Rel.Op.Set.Type.EXCEPT_ALL -> lhs.type + Rel.Op.Set.Type.INTERSECT_ALL, Rel.Op.Set.Type.INTERSECT_DISTINCT, + Rel.Op.Set.Type.UNION_ALL, Rel.Op.Set.Type.UNION_DISTINCT -> { + val schema = List(size) { + val lhsBinding = lhs.type.schema.getOrNull(it) ?: Rel.Binding("_$it", MISSING) + val rhsBinding = rhs.type.schema.getOrNull(it) ?: Rel.Binding("_$it", MISSING) + val bindingName = when (lhsBinding.name == rhsBinding.name) { + true -> lhsBinding.name + false -> "_$it" + } + Rel.Binding(bindingName, unionOf(lhsBinding.type, rhsBinding.type)) + } + Rel.Type(schema, props = emptySet()) } - Rel.Binding(bindingName, unionOf(lhsBinding.type, rhsBinding.type)) } - val type = Rel.Type(schema, props = emptySet()) return Rel(type, set) } diff --git a/partiql-planner/src/main/resources/partiql_plan_internal.ion b/partiql-planner/src/main/resources/partiql_plan_internal.ion index 9b01c7898d..bf5fdcc2fe 100644 --- a/partiql-planner/src/main/resources/partiql_plan_internal.ion +++ b/partiql-planner/src/main/resources/partiql_plan_internal.ion @@ -308,7 +308,13 @@ rel::{ INTERSECT_DISTINCT, EXCEPT_ALL, EXCEPT_DISTINCT - ] + ], + // This is an internal-only field. It is specifically used to aid in typing the plan and throwing potential errors. + // For example, if a user were to write: `<< { 'a': 1 } >>` UNION << { 'b': 'hello' } >>, then this would FAIL + // due to [RFC-0007](https://github.com/partiql/partiql-lang/blob/main/RFCs/0007-rfc-bag-operators.md). However, + // if a user were to use OUTER UNION, then it would work. Under the hood at execution, the operator is the same -- + // however, at planning time, with static type analysis, we can fail queries prior to their execution. + is_outer: bool }, limit::{ From 3039d381d7f5eea62d38607619eda43cf37670cf Mon Sep 17 00:00:00 2001 From: John Ed Quinn Date: Tue, 16 Apr 2024 09:53:21 -0700 Subject: [PATCH 04/12] Removes development test --- .../eval/internal/PartiQLEngineDefaultTest.kt | 39 ------------------- .../planner/internal/typer/PlanTyper.kt | 6 +-- 2 files changed, 3 insertions(+), 42 deletions(-) diff --git a/partiql-eval/src/test/kotlin/org/partiql/eval/internal/PartiQLEngineDefaultTest.kt b/partiql-eval/src/test/kotlin/org/partiql/eval/internal/PartiQLEngineDefaultTest.kt index 24ea9d7c9f..c294c4b255 100644 --- a/partiql-eval/src/test/kotlin/org/partiql/eval/internal/PartiQLEngineDefaultTest.kt +++ b/partiql-eval/src/test/kotlin/org/partiql/eval/internal/PartiQLEngineDefaultTest.kt @@ -70,45 +70,6 @@ class PartiQLEngineDefaultTest { @Execution(ExecutionMode.CONCURRENT) fun globalsTests(tc: SuccessTestCase) = tc.assert() - @Test - fun singleTest() { - val tc = SuccessTestCase( - input = """ - SELECT * FROM << 1 >> OUTER UNION << 'A' >> - """.trimIndent(), - expected = bagValue( - structValue( - "orderName" to stringValue("foo") - ), - structValue( - "orderName" to stringValue("bar"), - "customerName" to stringValue("Helen") - ), - ), - globals = listOf( - SuccessTestCase.Global( - name = "customers", - value = """ - [{id:1, name: "Mary"}, - {id:2, name: "Helen"}, - {id:1, name: "John"} - ] - """ - ), - SuccessTestCase.Global( - name = "orders", - value = """ - [{custId:1, name: "foo"}, - {custId:2, name: "bar"} - ] - """ - ), - ), - mode = PartiQLEngine.Mode.STRICT - ) - tc.assert() - } - companion object { @JvmStatic diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt index 290b1e0e42..98d5dc2eab 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt @@ -219,6 +219,9 @@ internal class PlanTyper(private val env: Env) { return rel(type, op) } + // TODO: [RFC-0007](https://github.com/partiql/partiql-lang/blob/main/RFCs/0007-rfc-bag-operators.md) + // states that the types must be "comparable". The below code ONLY makes sure that types need to be + // the same. In the future, we need to add support for checking comparable types. override fun visitRelOpSet(node: Rel.Op.Set, ctx: Rel.Type?): Rel { val lhs = visitRel(node.lhs, node.lhs.type) val rhs = visitRel(node.rhs, node.rhs.type) @@ -232,9 +235,6 @@ internal class PlanTyper(private val env: Env) { for (i in 0..lhs.type.schema.lastIndex) { val lhsBindingType = lhs.type.schema[i].type val rhsBindingType = rhs.type.schema[i].type - // TODO: [RFC-0007](https://github.com/partiql/partiql-lang/blob/main/RFCs/0007-rfc-bag-operators.md) - // states that the types must be "comparable". The below code ONLY makes sure that types need to be - // the same. In the future, we need to add support for checking comparable types. if (lhsBindingType != rhsBindingType) { return Rel(Rel.Type(emptyList(), emptySet()), Rel.Op.Err("LHS and RHS of SET OP do not have the same type.")) } From 43cadd79f392330f1356c5c44be041d8a297e8fe Mon Sep 17 00:00:00 2001 From: John Ed Quinn Date: Tue, 16 Apr 2024 14:56:01 -0700 Subject: [PATCH 05/12] Removes comparison report --- test/partiql-tests-runner/comp_report.md | 2769 ---------------------- 1 file changed, 2769 deletions(-) delete mode 100644 test/partiql-tests-runner/comp_report.md diff --git a/test/partiql-tests-runner/comp_report.md b/test/partiql-tests-runner/comp_report.md deleted file mode 100644 index 36de776d5c..0000000000 --- a/test/partiql-tests-runner/comp_report.md +++ /dev/null @@ -1,2769 +0,0 @@ -### Conformance comparison report-Cross Engine -| | Base (legacy) | eval | +/- | -| --- | ---: | ---: | ---: | -| % Passing | 92.47% | 82.68% | -9.79% | -| :white_check_mark: Passing | 5380 | 4811 | -569 | -| :x: Failing | 438 | 1008 | 570 | -| :large_orange_diamond: Ignored | 0 | 0 | 0 | -| Total Tests | 5818 | 5819 | 1 | -Number passing in both: 4627 - -Number failing in both: 254 - -Number passing in legacy engine but fail in eval engine: 754 - -Number failing in legacy engine but pass in eval engine: 184 -:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) are passing in legacy but fail in eval: -
Click here to see - - -- equiv wildcard steps struct, compileOption: PERMISSIVE -- equiv wildcard steps struct, compileOption: LEGACY -- equiv path expression with wildcard steps, compileOption: PERMISSIVE -- equiv path expression with wildcard steps, compileOption: LEGACY -- equiv path collection expression with wildcard steps, compileOption: PERMISSIVE -- equiv path collection expression with wildcard steps, compileOption: LEGACY -- equiv attribute value pair unpivot missing, compileOption: PERMISSIVE -- equiv left join, compileOption: PERMISSIVE -- equiv left join, compileOption: LEGACY -- Example 6 — Value Coercion, compileOption: LEGACY -- path on string, compileOption: PERMISSIVE -- tuple navigation missing attribute dot notation, compileOption: PERMISSIVE -- tuple navigation missing attribute array notation, compileOption: PERMISSIVE -- array navigation with wrongly typed array index, compileOption: PERMISSIVE -- single source FROM with scalar, compileOption: LEGACY -- single source FROM with tuple, compileOption: LEGACY -- single source FROM with absent value null, compileOption: LEGACY -- single source FROM with absent value missing, compileOption: LEGACY -- tuple constructor and mistyped attribute name, compileOption: PERMISSIVE -- attribute value evaluates to MISSING, compileOption: LEGACY -- array element evaluates to MISSING, compileOption: LEGACY -- bag element evaluates to MISSING, compileOption: LEGACY -- bag element evaluates to MISSING in bag constructor, compileOption: LEGACY -- pivot into a tuple with invalid attribute name, compileOption: LEGACY -- missing value in arithmetic expression, compileOption: PERMISSIVE -- data type mismatch in comparison expression, compileOption: PERMISSIVE -- data type mismatch in logical expression, compileOption: PERMISSIVE -- equality of scalar missing, compileOption: PERMISSIVE -- equality of same element bags, compileOption: PERMISSIVE -- equality of same element bags, compileOption: LEGACY -- WHERE clause eliminating absent values, compileOption: PERMISSIVE -- WHERE clause eliminating absent values, compileOption: LEGACY -- group by with absent values, compileOption: LEGACY -- group by with differenciated absent values, compileOption: LEGACY -- Right with variables, compileOption: PERMISSIVE -- Right with variables, compileOption: LEGACY -- Right with spots, compileOption: PERMISSIVE -- Right with spots, compileOption: LEGACY -- Right shorthand, compileOption: PERMISSIVE -- Right shorthand, compileOption: LEGACY -- Left with variables, compileOption: PERMISSIVE -- Left with variables, compileOption: LEGACY -- Left with spots, compileOption: PERMISSIVE -- Left with spots, compileOption: LEGACY -- Left shorthand, compileOption: PERMISSIVE -- Left shorthand, compileOption: LEGACY -- Left+right with variables, compileOption: PERMISSIVE -- Left+right with variables, compileOption: LEGACY -- Left+right with spots, compileOption: PERMISSIVE -- Left+right with spots, compileOption: LEGACY -- Left+right shorthand, compileOption: PERMISSIVE -- Left+right shorthand, compileOption: LEGACY -- Left+right with variables and label, compileOption: PERMISSIVE -- Left+right with variables and label, compileOption: LEGACY -- Undirected with variables, compileOption: PERMISSIVE -- Undirected with variables, compileOption: LEGACY -- Undirected with spots, compileOption: PERMISSIVE -- Undirected with spots, compileOption: LEGACY -- Undirected shorthand, compileOption: PERMISSIVE -- Undirected shorthand, compileOption: LEGACY -- Undirected with variables and label, compileOption: PERMISSIVE -- Undirected with variables and label, compileOption: LEGACY -- Right+undirected with variables, compileOption: PERMISSIVE -- Right+undirected with variables, compileOption: LEGACY -- Right+undirected with spots, compileOption: PERMISSIVE -- Right+undirected with spots, compileOption: LEGACY -- Right+undirected shorthand, compileOption: PERMISSIVE -- Right+undirected shorthand, compileOption: LEGACY -- Right+undirected with variables and labels, compileOption: PERMISSIVE -- Right+undirected with variables and labels, compileOption: LEGACY -- Left+undirected with variables, compileOption: PERMISSIVE -- Left+undirected with variables, compileOption: LEGACY -- Left+undirected with spots, compileOption: PERMISSIVE -- Left+undirected with spots, compileOption: LEGACY -- Left+undirected shorthand, compileOption: PERMISSIVE -- Left+undirected shorthand, compileOption: LEGACY -- Left+undirected with variables and label, compileOption: PERMISSIVE -- Left+undirected with variables and label, compileOption: LEGACY -- Left+right+undirected with variables, compileOption: PERMISSIVE -- Left+right+undirected with variables, compileOption: LEGACY -- Left+right+undirected with spots, compileOption: PERMISSIVE -- Left+right+undirected with spots, compileOption: LEGACY -- Left+right+undirected shorthand, compileOption: PERMISSIVE -- Left+right+undirected shorthand, compileOption: LEGACY -- (N0E0 MATCH (x)), compileOption: PERMISSIVE -- (N0E0 MATCH (x)), compileOption: LEGACY -- (N0E0 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N0E0 MATCH -[y]-> ), compileOption: LEGACY -- (N0E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N0E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N1E0 MATCH (x)), compileOption: PERMISSIVE -- (N1E0 MATCH (x)), compileOption: LEGACY -- (N1E0 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N1E0 MATCH -[y]-> ), compileOption: LEGACY -- (N1E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N1E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N1E0 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE -- (N1E0 MATCH (x)-[y]->(x) ), compileOption: LEGACY -- (N1U1 MATCH (x)), compileOption: PERMISSIVE -- (N1U1 MATCH (x)), compileOption: LEGACY -- (N1U1 MATCH ~[y]~ ), compileOption: PERMISSIVE -- (N1U1 MATCH ~[y]~ ), compileOption: LEGACY -- (N1U1 MATCH (x)~[y]~(z) ), compileOption: PERMISSIVE -- (N1U1 MATCH (x)~[y]~(z) ), compileOption: LEGACY -- (N1U1 MATCH (x)~[y]~(x) ), compileOption: PERMISSIVE -- (N1U1 MATCH (x)~[y]~(x) ), compileOption: LEGACY -- (N1U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: PERMISSIVE -- (N1U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: LEGACY -- (N1D2 MATCH (x)), compileOption: PERMISSIVE -- (N1D2 MATCH (x)), compileOption: LEGACY -- (N1D2 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N1D2 MATCH -[y]-> ), compileOption: LEGACY -- (N1D2 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N1D2 MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N1D2 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE -- (N1D2 MATCH (x)-[y]->(x) ), compileOption: LEGACY -- (N1D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N1D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2E0 MATCH (x)), compileOption: PERMISSIVE -- (N2E0 MATCH (x)), compileOption: LEGACY -- (N2E0 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N2E0 MATCH -[y]-> ), compileOption: LEGACY -- (N2E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N2E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N2E0 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE -- (N2E0 MATCH (x)-[y]->(x) ), compileOption: LEGACY -- (N2D1 MATCH (x)), compileOption: PERMISSIVE -- (N2D1 MATCH (x)), compileOption: LEGACY -- (N2D1 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N2D1 MATCH -[y]-> ), compileOption: LEGACY -- (N2D1 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N2D1 MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N2D1 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE -- (N2D1 MATCH (x)-[y]->(x) ), compileOption: LEGACY -- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2U1 MATCH (x)), compileOption: PERMISSIVE -- (N2U1 MATCH (x)), compileOption: LEGACY -- (N2U1 MATCH ~[y]~ ), compileOption: PERMISSIVE -- (N2U1 MATCH ~[y]~ ), compileOption: LEGACY -- (N2U1 MATCH (x)~[y]~(z) ), compileOption: PERMISSIVE -- (N2U1 MATCH (x)~[y]~(z) ), compileOption: LEGACY -- (N2U1 MATCH (x)~[y]~(x) ), compileOption: PERMISSIVE -- (N2U1 MATCH (x)~[y]~(x) ), compileOption: LEGACY -- (N2U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: PERMISSIVE -- (N2U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: LEGACY -- (N2U1 MATCH (x1)~[y1]~(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2U1 MATCH (x1)~[y1]~(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2U1 MATCH (x1)-[y1]-(x2)~[y2]~(x3) ), compileOption: PERMISSIVE -- (N2U1 MATCH (x1)-[y1]-(x2)~[y2]~(x3) ), compileOption: LEGACY -- (N2U1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2U1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2D2 MATCH (x)), compileOption: PERMISSIVE -- (N2D2 MATCH (x)), compileOption: LEGACY -- (N2D2 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N2D2 MATCH -[y]-> ), compileOption: LEGACY -- (N2D2 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N2D2 MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N2D2 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE -- (N2D2 MATCH (x)-[y]->(x) ), compileOption: LEGACY -- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2D2c MATCH (x)), compileOption: PERMISSIVE -- (N2D2c MATCH (x)), compileOption: LEGACY -- (N2D2c MATCH -[y]-> ), compileOption: PERMISSIVE -- (N2D2c MATCH -[y]-> ), compileOption: LEGACY -- (N2D2c MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N2D2c MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x)-[y]->(x) ), compileOption: LEGACY -- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x1) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x1) ), compileOption: LEGACY -- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2U2 MATCH (x)), compileOption: PERMISSIVE -- (N2U2 MATCH (x)), compileOption: LEGACY -- (N2U2 MATCH ~[y]~ ), compileOption: PERMISSIVE -- (N2U2 MATCH ~[y]~ ), compileOption: LEGACY -- (N2U2 MATCH (x)~[y]~(z) ), compileOption: PERMISSIVE -- (N2U2 MATCH (x)~[y]~(z) ), compileOption: LEGACY -- (N2U2 MATCH (x)~[y]~(x) ), compileOption: PERMISSIVE -- (N2U2 MATCH (x)~[y]~(x) ), compileOption: LEGACY -- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: PERMISSIVE -- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: LEGACY -- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x1) ), compileOption: PERMISSIVE -- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x1) ), compileOption: LEGACY -- cast to MISSING valid cases{value:"NULL"}, compileOption: PERMISSIVE -- cast to MISSING valid cases{value:"NULL"}, compileOption: LEGACY -- cast to MISSING valid cases{value:"MISSING"}, compileOption: PERMISSIVE -- cast to MISSING valid cases{value:"MISSING"}, compileOption: LEGACY -- cast to NULL valid cases{value:"MISSING"}, compileOption: PERMISSIVE -- cast to NULL valid cases{value:"MISSING"}, compileOption: LEGACY -- cast to int invalid target type{value:"`2017T`",target:"TIMESTAMP"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:" `{{\"\"}}` ",target:"CLOB"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:" `{{\"1\"}}` ",target:"CLOB"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"`{{}}`",target:"BLOB"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"[1, 2]",target:"LIST"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"[1]",target:"LIST"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"[]",target:"LIST"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"`(1 2)`",target:"SEXP"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"`(1)`",target:"SEXP"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"`()`",target:"SEXP"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"{'a': 1}",target:"STRUCT"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"{'a': '12'}",target:"STRUCT"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"{}",target:"STRUCT"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"<<1, 2>>",target:"BAG"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"<<1>>",target:"BAG"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"<<>>",target:"BAG"}, compileOption: PERMISSIVE -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE null "}, compileOption: PERMISSIVE -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE null "}, compileOption: LEGACY -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE '[' "}, compileOption: PERMISSIVE -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE '[' "}, compileOption: LEGACY -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE 'S1' ESCAPE null "}, compileOption: PERMISSIVE -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE 'S1' ESCAPE null "}, compileOption: LEGACY -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null "}, compileOption: PERMISSIVE -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null "}, compileOption: LEGACY -- MISSING LIKE 'some pattern', compileOption: PERMISSIVE -- 'some value' LIKE MISSING, compileOption: PERMISSIVE -- MISSING LIKE MISSING, compileOption: PERMISSIVE -- NULL LIKE MISSING, compileOption: PERMISSIVE -- MISSING LIKE NULL, compileOption: PERMISSIVE -- MISSING LIKE 'some pattern' ESCAPE '/', compileOption: PERMISSIVE -- 'some value' LIKE MISSING ESCAPE '/', compileOption: PERMISSIVE -- 'some value' LIKE 'some pattern' ESCAPE MISSING, compileOption: PERMISSIVE -- NULL LIKE 'some pattern' ESCAPE MISSING, compileOption: PERMISSIVE -- 'some value' LIKE NULL ESCAPE MISSING, compileOption: PERMISSIVE -- outerUnionCoerceScalar, compileOption: LEGACY -- outerUnionCoerceStruct, compileOption: LEGACY -- outerUnionCoerceNullMissing, compileOption: PERMISSIVE -- outerUnionCoerceNullMissing, compileOption: LEGACY -- inPredicate, compileOption: PERMISSIVE -- inPredicate, compileOption: LEGACY -- inPredicateSingleItem, compileOption: PERMISSIVE -- inPredicateSingleItem, compileOption: LEGACY -- inPredicateSingleExpr, compileOption: PERMISSIVE -- inPredicateSingleExpr, compileOption: LEGACY -- inPredicateSingleItemListVar, compileOption: PERMISSIVE -- inPredicateSingleItemListVar, compileOption: LEGACY -- inPredicateSingleListVar, compileOption: PERMISSIVE -- inPredicateSingleListVar, compileOption: LEGACY -- inPredicateSubQuerySelectValue, compileOption: PERMISSIVE -- inPredicateSubQuerySelectValue, compileOption: LEGACY -- notInPredicate, compileOption: PERMISSIVE -- notInPredicate, compileOption: LEGACY -- notInPredicateSingleItem, compileOption: PERMISSIVE -- notInPredicateSingleItem, compileOption: LEGACY -- notInPredicateSingleExpr, compileOption: PERMISSIVE -- notInPredicateSingleItemListVar, compileOption: PERMISSIVE -- notInPredicateSingleItemListVar, compileOption: LEGACY -- notInPredicateSingleListVar, compileOption: PERMISSIVE -- notInPredicateSingleListVar, compileOption: LEGACY -- notInPredicateSubQuerySelectValue, compileOption: PERMISSIVE -- notInPredicateSubQuerySelectValue, compileOption: LEGACY -- inPredicateWithTableConstructor, compileOption: PERMISSIVE -- inPredicateWithTableConstructor, compileOption: LEGACY -- notInPredicateWithTableConstructor, compileOption: PERMISSIVE -- notInPredicateWithTableConstructor, compileOption: LEGACY -- inPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE -- inPredicateWithExpressionOnRightSide, compileOption: LEGACY -- notInPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE -- notInPredicateWithExpressionOnRightSide, compileOption: LEGACY -- || valid cases{lparam:"null",rparam:"missing",result:missing::null}, compileOption: PERMISSIVE -- || valid cases{lparam:"missing",rparam:"null",result:missing::null}, compileOption: PERMISSIVE -- || valid cases{lparam:"missing",rparam:"'b'",result:missing::null}, compileOption: PERMISSIVE -- || valid cases{lparam:"'a'",rparam:"missing",result:missing::null}, compileOption: PERMISSIVE -- || valid cases{lparam:"missing",rparam:"missing",result:missing::null}, compileOption: PERMISSIVE -- repeatingDecimal, compileOption: PERMISSIVE -- repeatingDecimal, compileOption: LEGACY -- repeatingDecimalHigherPrecision, compileOption: PERMISSIVE -- repeatingDecimalHigherPrecision, compileOption: LEGACY -- divDecimalInt, compileOption: PERMISSIVE -- divDecimalInt, compileOption: LEGACY -- subtractionOutOfAllowedPrecision, compileOption: PERMISSIVE -- subtractionOutOfAllowedPrecision, compileOption: LEGACY -- equalListDifferentTypesTrue, compileOption: PERMISSIVE -- equalListDifferentTypesTrue, compileOption: LEGACY -- simpleCase, compileOption: PERMISSIVE -- simpleCase, compileOption: LEGACY -- simpleCaseNoElse, compileOption: PERMISSIVE -- simpleCaseNoElse, compileOption: LEGACY -- searchedCase, compileOption: PERMISSIVE -- searchedCase, compileOption: LEGACY -- searchedCaseNoElse, compileOption: PERMISSIVE -- searchedCaseNoElse, compileOption: LEGACY -- dateTimePartsAsVariableNames, compileOption: LEGACY -- pathDotMissingAttribute, compileOption: LEGACY -- pathMissingDotName, compileOption: PERMISSIVE -- pathMissingDotName, compileOption: LEGACY -- pathNullDotName, compileOption: PERMISSIVE -- pathNullDotName, compileOption: LEGACY -- pathIndexBagLiteral, compileOption: PERMISSIVE -- pathIndexBagLiteral, compileOption: LEGACY -- pathIndexStructLiteral, compileOption: PERMISSIVE -- pathIndexStructLiteral, compileOption: LEGACY -- pathIndexStructOutOfBoundsLowLiteral, compileOption: PERMISSIVE -- pathIndexStructOutOfBoundsLowLiteral, compileOption: LEGACY -- pathIndexStructOutOfBoundsHighLiteral, compileOption: PERMISSIVE -- pathIndexStructOutOfBoundsHighLiteral, compileOption: LEGACY -- pathDoubleWildCard, compileOption: PERMISSIVE -- pathDoubleWildCard, compileOption: LEGACY -- pathWildCardOverScalar, compileOption: LEGACY -- pathUnpivotWildCardOverScalar, compileOption: LEGACY -- pathWildCardOverScalarMultiple, compileOption: LEGACY -- pathUnpivotWildCardOverScalarMultiple, compileOption: LEGACY -- pathWildCardOverStructMultiple, compileOption: LEGACY -- unpivotMissing, compileOption: PERMISSIVE -- unpivotMissing, compileOption: LEGACY -- unpivotEmptyStruct, compileOption: PERMISSIVE -- unpivotEmptyStruct, compileOption: LEGACY -- unpivotStructWithMissingField, compileOption: PERMISSIVE -- unpivotStructWithMissingField, compileOption: LEGACY -- unpivotMissingWithAsAndAt, compileOption: LEGACY -- unpivotMissingCrossJoinWithAsAndAt, compileOption: LEGACY -- pathUnpivotEmptyStruct1, compileOption: PERMISSIVE -- pathUnpivotEmptyStruct1, compileOption: LEGACY -- pathUnpivotEmptyStruct2, compileOption: PERMISSIVE -- pathUnpivotEmptyStruct2, compileOption: LEGACY -- pathUnpivotEmptyStruct3, compileOption: PERMISSIVE -- pathUnpivotEmptyStruct3, compileOption: LEGACY -- dotted path expression with quoted field name accesses field UNAMBIGUOUS_FIELD (uppercase), compileOption: LEGACY -- subscript with variable in lowercase, compileOption: PERMISSIVE -- subscript with variable in lowercase, compileOption: LEGACY -- subscript with variable in uppercase, compileOption: PERMISSIVE -- subscript with variable in uppercase, compileOption: LEGACY -- subscript with variable in mixed case, compileOption: PERMISSIVE -- subscript with variable in mixed case, compileOption: LEGACY -- subscript with non-existent variable in lowercase, compileOption: PERMISSIVE -- subscript with non-existent variable in uppercase, compileOption: PERMISSIVE -- null comparison{sql:"MISSING IS NULL",result:true}, compileOption: PERMISSIVE -- null comparison{sql:"MISSING IS NULL",result:true}, compileOption: LEGACY -- null comparison{sql:"MISSING = NULL",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"NULL = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.sexp` = NULL",result:null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.sexp` = NULL",result:null}, compileOption: LEGACY -- null comparison{sql:"`null.null` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.bool` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.int` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.decimal` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.string` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.symbol` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.clob` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.blob` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.list` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.struct` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.sexp` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- concatenation with null values{left:"MISSING",right:"MISSING"}, compileOption: PERMISSIVE -- concatenation with null values{left:"''",right:"MISSING"}, compileOption: PERMISSIVE -- concatenation with null values{left:"MISSING",right:"''"}, compileOption: PERMISSIVE -- concatenation with null values{left:"'a'",right:"MISSING"}, compileOption: PERMISSIVE -- concatenation with null values{left:"MISSING",right:"'b'"}, compileOption: PERMISSIVE -- char_length null and missing propagation{in:"missing",result:(success missing::null)}, compileOption: PERMISSIVE -- character_length null and missing propagation{in:"missing",result:(success missing::null)}, compileOption: PERMISSIVE -- CHARACTER_LENGTH invalid type, compileOption: PERMISSIVE -- upper null and missing propagation{param:"missing"}, compileOption: PERMISSIVE -- cardinality null and missing propagation{param:"missing"}, compileOption: PERMISSIVE -- CARDINALITY('foo') type mismatch, compileOption: PERMISSIVE -- EXTRACT(YEAR FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(MONTH FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(DAY FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(HOUR FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(MINUTE FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(SECOND FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(TIMEZONE_HOUR FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(TIMEZONE_MINUTE FROM MISSING), compileOption: PERMISSIVE -- invalid extract year from time, compileOption: PERMISSIVE -- invalid extract month from time, compileOption: PERMISSIVE -- invalid extract day from time, compileOption: PERMISSIVE -- invalid extract month from time with time zone, compileOption: PERMISSIVE -- invalid extract day from time with time zone, compileOption: PERMISSIVE -- POSITION MISSING in string, compileOption: PERMISSIVE -- POSITION string in MISSING, compileOption: PERMISSIVE -- POSITION NULL in MISSING, compileOption: PERMISSIVE -- POSITION MISSING in NULL, compileOption: PERMISSIVE -- POSITION MISSING in MISSING, compileOption: PERMISSIVE -- POSITION invalid type in string, compileOption: PERMISSIVE -- POSITION string in invalid type, compileOption: PERMISSIVE -- substring null and missing propagation 2 arguments{target:"missing",start_pos:"1"}, compileOption: PERMISSIVE -- substring null and missing propagation 2 arguments{target:"''",start_pos:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 2 arguments{target:"missing",start_pos:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 2 arguments{target:"null",start_pos:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 2 arguments{target:"missing",start_pos:"null"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"null",start_pos:"1",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"null",start_pos:"null",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"null",start_pos:"missing",quantity:"1"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"null",start_pos:"missing",quantity:"null"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"null",start_pos:"missing",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"1",quantity:"1"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"1",quantity:"null"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"1",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"null",quantity:"1"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"null",quantity:"null"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"null",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"missing",quantity:"1"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"missing",quantity:"null"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"missing",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"''",start_pos:"1",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"''",start_pos:"null",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"''",start_pos:"missing",quantity:"1"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"''",start_pos:"missing",quantity:"null"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"''",start_pos:"missing",quantity:"missing"}, compileOption: PERMISSIVE -- lower null and missing propagation{param:"missing"}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"1",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"1",result:null}, compileOption: LEGACY -- nullif valid cases{first:"1.0",second:"1",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"1.0",second:"1",result:null}, compileOption: LEGACY -- nullif valid cases{first:"1",second:"2",result:1}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"2",result:1}, compileOption: LEGACY -- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: PERMISSIVE -- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: LEGACY -- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: LEGACY -- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: LEGACY -- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: PERMISSIVE -- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: LEGACY -- nullif valid cases{first:"1",second:"null",result:1}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"null",result:1}, compileOption: LEGACY -- nullif valid cases{first:"null",second:"1",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"null",second:"1",result:null}, compileOption: LEGACY -- nullif valid cases{first:"null",second:"null",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"null",second:"null",result:null}, compileOption: LEGACY -- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: LEGACY -- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: PERMISSIVE -- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: LEGACY -- ABS(MISSING) null propogation, compileOption: PERMISSIVE -- ABS('foo'), compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(leading from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(trailing from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(both from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(leading '' from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(trailing '' from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(both '' from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(leading missing from '')"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(trailing missing from '')"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(both missing from '')"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(leading null from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(trailing null from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(both null from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(leading missing from null)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(trailing missing from null)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(both missing from null)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(leading missing from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(trailing missing from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(both missing from missing)"}, compileOption: PERMISSIVE -- MOD(MISSING, 3), compileOption: PERMISSIVE -- MOD(3, MISSING), compileOption: PERMISSIVE -- MOD(MISSING, NULL), compileOption: PERMISSIVE -- MOD(NULL, MISSING), compileOption: PERMISSIVE -- MOD(MISSING, 'some string'), compileOption: PERMISSIVE -- MOD('some string', MISSING), compileOption: PERMISSIVE -- MOD(3, 'some string'), compileOption: PERMISSIVE -- MOD('some string', 3), compileOption: PERMISSIVE -- BIT_LENGTH MISSING, compileOption: PERMISSIVE -- BIT_LENGTH invalid type, compileOption: PERMISSIVE -- OCTET_LENGTH MISSING, compileOption: PERMISSIVE -- OCTET_LENGTH invalid type, compileOption: PERMISSIVE -- OVERLAY MISSING, compileOption: PERMISSIVE -- OVERLAY PLACING MISSING, compileOption: PERMISSIVE -- OVERLAY FROM MISSING, compileOption: PERMISSIVE -- OVERLAY FOR MISSING, compileOption: PERMISSIVE -- OVERLAY mismatched type, compileOption: PERMISSIVE -- OVERLAY PLACING mismatched type, compileOption: PERMISSIVE -- OVERLAY FROM mismatched type, compileOption: PERMISSIVE -- OVERLAY FOR mismatched type, compileOption: PERMISSIVE -- coalesce valid cases{args:"1",result:(success 1)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"1",result:(success 1)}, compileOption: LEGACY -- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: LEGACY -- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: LEGACY -- coalesce valid cases{args:"missing, 3",result:(success 3)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"missing, 3",result:(success 3)}, compileOption: LEGACY -- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: LEGACY -- coalesce valid cases{args:"null, missing, 3",result:(success 3)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"null, missing, 3",result:(success 3)}, compileOption: LEGACY -- coalesce valid cases{args:"null, missing, null, null, missing, 9, 4, 5, 6",result:(success 9)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"null, missing, null, null, missing, 9, 4, 5, 6",result:(success 9)}, compileOption: LEGACY -- Empty Symbol in table, compileOption: LEGACY -- Empty Symbol in globals, compileOption: LEGACY -- Empty Symbol in alias, compileOption: LEGACY -- functionCall, compileOption: PERMISSIVE -- functionCall, compileOption: LEGACY -- division with mixed StaticType, compileOption: PERMISSIVE -- division with mixed StaticType, compileOption: LEGACY -- Example 6 — Value Coercion; Coercion of single value, compileOption: LEGACY -- undefinedUnqualifiedVariableWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE -- undefinedUnqualifiedVariableIsNullExprWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE -- undefinedUnqualifiedVariableIsMissingExprWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE -- undefinedUnqualifiedVariableInSelectWithUndefinedVariableBehaviorMissing, compileOption: LEGACY -- join on column - all column values non-null, compileOption: PERMISSIVE -- join on column - all column values non-null, compileOption: LEGACY -- join on column - some column values are null, compileOption: PERMISSIVE -- join on column - some column values are null, compileOption: LEGACY -- join on column - 1 table contains 1 row with the value null, compileOption: PERMISSIVE -- join on column - 1 table contains 1 row with the value null, compileOption: LEGACY -- join on column - ON condition = false, compileOption: PERMISSIVE -- join on column - ON condition = false, compileOption: LEGACY -- PG_JOIN_01, compileOption: PERMISSIVE -- PG_JOIN_01, compileOption: LEGACY -- PG_JOIN_02, compileOption: PERMISSIVE -- PG_JOIN_02, compileOption: LEGACY -- PG_JOIN_03, compileOption: PERMISSIVE -- PG_JOIN_03, compileOption: LEGACY -- PG_JOIN_06, compileOption: PERMISSIVE -- PG_JOIN_06, compileOption: LEGACY -- PG_JOIN_07, compileOption: PERMISSIVE -- PG_JOIN_07, compileOption: LEGACY -- PG_JOIN_08, compileOption: PERMISSIVE -- PG_JOIN_08, compileOption: LEGACY -- PG_JOIN_09, compileOption: PERMISSIVE -- PG_JOIN_09, compileOption: LEGACY -- PG_JOIN_10, compileOption: PERMISSIVE -- PG_JOIN_10, compileOption: LEGACY -- offset 0, compileOption: PERMISSIVE -- offset 0, compileOption: LEGACY -- offset 1, compileOption: PERMISSIVE -- offset 1, compileOption: LEGACY -- offset 2, compileOption: PERMISSIVE -- offset 2, compileOption: LEGACY -- limit 1 offset 1, compileOption: PERMISSIVE -- limit 1 offset 1, compileOption: LEGACY -- limit 10 offset 1, compileOption: PERMISSIVE -- limit 10 offset 1, compileOption: LEGACY -- limit 2 offset 2, compileOption: PERMISSIVE -- limit 2 offset 2, compileOption: LEGACY -- limit offset after group by, compileOption: PERMISSIVE -- limit offset after group by, compileOption: LEGACY -- offset 2-1, compileOption: PERMISSIVE -- offset 2-1, compileOption: LEGACY -- offset 2+1, compileOption: PERMISSIVE -- offset 2+1, compileOption: LEGACY -- offset 2*1, compileOption: PERMISSIVE -- offset 2*1, compileOption: LEGACY -- offset 2/1, compileOption: PERMISSIVE -- offset 2/1, compileOption: LEGACY -- offset group by having, compileOption: PERMISSIVE -- offset group by having, compileOption: LEGACY -- offset with pivot, compileOption: PERMISSIVE -- offset with pivot, compileOption: LEGACY -- pivotBadFieldType, compileOption: LEGACY -- col1 asc, compileOption: PERMISSIVE -- col1 asc, compileOption: LEGACY -- col1 desc, compileOption: PERMISSIVE -- col1 desc, compileOption: LEGACY -- col1 asc, col2 asc, compileOption: PERMISSIVE -- col1 asc, col2 asc, compileOption: LEGACY -- price desc, productId asc, compileOption: PERMISSIVE -- price desc, productId asc, compileOption: LEGACY -- supplierId_nulls nulls last, compileOption: PERMISSIVE -- supplierId_nulls nulls last, compileOption: LEGACY -- supplierId_nulls nulls first, compileOption: PERMISSIVE -- supplierId_nulls nulls first, compileOption: LEGACY -- supplierId_nulls asc nulls last, productId asc, compileOption: PERMISSIVE -- supplierId_nulls asc nulls last, productId asc, compileOption: LEGACY -- nulls first as default for supplierId_nulls desc, compileOption: PERMISSIVE -- nulls first as default for supplierId_nulls desc, compileOption: LEGACY -- group and order by asc sellerId, compileOption: PERMISSIVE -- group and order by asc sellerId, compileOption: LEGACY -- group and order by desc sellerId, compileOption: PERMISSIVE -- group and order by desc sellerId, compileOption: LEGACY -- group and order by DESC (NULLS FIRST as default), compileOption: PERMISSIVE -- group and order by DESC (NULLS FIRST as default), compileOption: LEGACY -- group and order by ASC (NULLS LAST as default), compileOption: PERMISSIVE -- group and order by ASC (NULLS LAST as default), compileOption: LEGACY -- group and place nulls first (asc as default), compileOption: PERMISSIVE -- group and place nulls first (asc as default), compileOption: LEGACY -- group and place nulls last (asc as default), compileOption: PERMISSIVE -- group and place nulls last (asc as default), compileOption: LEGACY -- group and order by asc and place nulls first, compileOption: PERMISSIVE -- group and order by asc and place nulls first, compileOption: LEGACY -- false before true (ASC), compileOption: PERMISSIVE -- false before true (ASC), compileOption: LEGACY -- true before false (DESC), compileOption: PERMISSIVE -- true before false (DESC), compileOption: LEGACY -- nan before -inf, then numeric values then +inf (ASC), compileOption: PERMISSIVE -- nan before -inf, then numeric values then +inf (ASC), compileOption: LEGACY -- +inf before numeric values then -inf then nan (DESC), compileOption: PERMISSIVE -- +inf before numeric values then -inf then nan (DESC), compileOption: LEGACY -- LOB types follow their lexicographical ordering by octet (ASC), compileOption: PERMISSIVE -- LOB types follow their lexicographical ordering by octet (ASC), compileOption: LEGACY -- LOB types should ordered (DESC), compileOption: PERMISSIVE -- LOB types should ordered (DESC), compileOption: LEGACY -- shorter array comes first (ASC), compileOption: PERMISSIVE -- shorter array comes first (ASC), compileOption: LEGACY -- longer array comes first (DESC), compileOption: PERMISSIVE -- longer array comes first (DESC), compileOption: LEGACY -- lists compared lexicographically based on comparison of elements (ASC), compileOption: PERMISSIVE -- lists compared lexicographically based on comparison of elements (ASC), compileOption: LEGACY -- lists compared lexicographically based on comparison of elements (DESC), compileOption: PERMISSIVE -- lists compared lexicographically based on comparison of elements (DESC), compileOption: LEGACY -- lists items should be ordered by data types (ASC) (nulls last as default for asc), compileOption: PERMISSIVE -- lists items should be ordered by data types (ASC) (nulls last as default for asc), compileOption: LEGACY -- lists items should be ordered by data types (DESC) (nulls first as default for desc), compileOption: PERMISSIVE -- lists items should be ordered by data types (DESC) (nulls first as default for desc), compileOption: LEGACY -- structs compared lexicographically first by key then by value (ASC), compileOption: PERMISSIVE -- structs compared lexicographically first by key then by value (ASC), compileOption: LEGACY -- structs compared lexicographically first by key then by value (DESC), compileOption: PERMISSIVE -- structs compared lexicographically first by key then by value (DESC), compileOption: LEGACY -- structs should be ordered by data types (ASC) (nulls last as default for asc), compileOption: PERMISSIVE -- structs should be ordered by data types (ASC) (nulls last as default for asc), compileOption: LEGACY -- structs should be ordered by data types (DESC) (nulls first as default for desc), compileOption: PERMISSIVE -- structs should be ordered by data types (DESC) (nulls first as default for desc), compileOption: LEGACY -- bags compared as sorted lists (ASC), compileOption: PERMISSIVE -- bags compared as sorted lists (ASC), compileOption: LEGACY -- bags compared as sorted lists (DESC), compileOption: PERMISSIVE -- bags compared as sorted lists (DESC), compileOption: LEGACY -- testing alias support, compileOption: PERMISSIVE -- testing alias support, compileOption: LEGACY -- testing nested alias support, compileOption: PERMISSIVE -- testing nested alias support, compileOption: LEGACY -- Empty Output (ordered), compileOption: PERMISSIVE -- Empty Output (ordered), compileOption: LEGACY -- GROUP BY binding referenced in FROM clause, compileOption: PERMISSIVE -- GROUP BY binding referenced in WHERE clause, compileOption: PERMISSIVE -- GROUP AS binding referenced in FROM clause, compileOption: PERMISSIVE -- GROUP AS binding referenced in WHERE clause, compileOption: PERMISSIVE -- SELECT COUNT(1) AS the_count, COUNT(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, SUM(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, MIN(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, MAX(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, AVG(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, COUNT(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, SUM(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, MIN(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, MAX(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, AVG(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, COUNT(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, SUM(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, MIN(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, MAX(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, AVG(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, COUNT(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, SUM(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, MIN(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, MAX(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, AVG(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, COUNT(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, SUM(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, MIN(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, MAX(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, AVG(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, COUNT(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, SUM(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, MIN(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, MAX(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, AVG(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- Expression with multiple subqueriees containing aggregates : CAST((SELECT COUNT(1) FROM products) AS LIST)[0]._1 / CAST((SELECT COUNT(1) FROM suppliers) AS LIST)[0]._1, compileOption: PERMISSIVE -- Expression with multiple subqueriees containing aggregates : CAST((SELECT COUNT(1) FROM products) AS LIST)[0]._1 / CAST((SELECT COUNT(1) FROM suppliers) AS LIST)[0]._1, compileOption: LEGACY -- Aggregates with subquery containing another aggregate : SELECT COUNT(1) + CAST((SELECT SUM(numInStock) FROM products) AS LIST)[0]._1 as a_number FROM products, compileOption: PERMISSIVE -- Aggregates with subquery containing another aggregate : SELECT COUNT(1) + CAST((SELECT SUM(numInStock) FROM products) AS LIST)[0]._1 as a_number FROM products, compileOption: LEGACY -- GROUP BY with JOIN : SELECT supplierName, COUNT(*) as the_count FROM suppliers AS s INNER JOIN products AS p ON s.supplierId = p.supplierId GROUP BY supplierName, compileOption: PERMISSIVE -- GROUP BY with JOIN : SELECT supplierName, COUNT(*) as the_count FROM suppliers AS s INNER JOIN products AS p ON s.supplierId = p.supplierId GROUP BY supplierName, compileOption: LEGACY -- SELECT VALUE with nested aggregates : SELECT VALUE (SELECT SUM(outerFromSource.col1) AS the_sum FROM <<1>>) FROM simple_1_col_1_group as outerFromSource, compileOption: PERMISSIVE -- SELECT VALUE with nested aggregates : SELECT VALUE (SELECT SUM(outerFromSource.col1) AS the_sum FROM <<1>>) FROM simple_1_col_1_group as outerFromSource, compileOption: LEGACY -- SELECT col1, g FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE -- SELECT col1, g FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: LEGACY -- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE -- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: LEGACY -- SELECT col1, g FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE -- SELECT col1, g FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: LEGACY -- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE -- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: LEGACY -- MYSQL_SELECT_20, compileOption: PERMISSIVE -- MYSQL_SELECT_20, compileOption: LEGACY -- MYSQL_SELECT_21, compileOption: PERMISSIVE -- MYSQL_SELECT_21, compileOption: LEGACY -- MYSQL_SELECT_23, compileOption: PERMISSIVE -- MYSQL_SELECT_23, compileOption: LEGACY -- MYSQL_SELECT_26, compileOption: PERMISSIVE -- MYSQL_SELECT_26, compileOption: LEGACY -- selectFromScalarAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE -- selectFromScalarAndAtUnpivotWildCardOverScalar, compileOption: LEGACY -- selectFromListAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE -- selectFromListAndAtUnpivotWildCardOverScalar, compileOption: LEGACY -- selectFromBagAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE -- selectFromBagAndAtUnpivotWildCardOverScalar, compileOption: LEGACY -- selectPathUnpivotWildCardOverStructMultiple, compileOption: PERMISSIVE -- selectPathUnpivotWildCardOverStructMultiple, compileOption: LEGACY -- selectStarSingleSourceHoisted, compileOption: PERMISSIVE -- selectStarSingleSourceHoisted, compileOption: LEGACY -- ordinalAccessWithNegativeIndex, compileOption: LEGACY -- ordinalAccessWithNegativeIndexAndBindings, compileOption: LEGACY -- rangeOverScalar, compileOption: LEGACY -- rangeTwiceOverScalar, compileOption: LEGACY -- rangeOverSexp, compileOption: PERMISSIVE -- rangeOverSexp, compileOption: LEGACY -- rangeOverStruct, compileOption: LEGACY -- rangeOverBagWithAt, compileOption: LEGACY -- rangeOverNestedWithAt, compileOption: LEGACY -- avg group by{agg:'AVG(t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: PERMISSIVE -- avg group by{agg:'AVG(t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: LEGACY -- avg group by{agg:'AVG(ALL t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: PERMISSIVE -- avg group by{agg:'AVG(ALL t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: LEGACY -- avg group by{agg:'AVG(DISTINCT t.b)',expectedF1:1.5,expectedF2:3.}, compileOption: PERMISSIVE -- avg group by{agg:'AVG(DISTINCT t.b)',expectedF1:1.5,expectedF2:3.}, compileOption: LEGACY -- ANY with GROUP BY, compileOption: LEGACY -- ANY DISTINCT with GROUP BY, compileOption: LEGACY -- SOME with GROUP BY, compileOption: LEGACY -- SOME DISTINCT with GROUP BY, compileOption: LEGACY -- EVERY with GROUP BY, compileOption: LEGACY -- EVERY DISTINCT with GROUP BY, compileOption: LEGACY -- selectListMultipleAggregatesNestedQuery, compileOption: PERMISSIVE -- selectListMultipleAggregatesNestedQuery, compileOption: LEGACY -- undefinedUnqualifiedVariable_inSelect_withProjectionOption, compileOption: LEGACY -- projectionIterationBehaviorUnfiltered_select_star, compileOption: PERMISSIVE -- projectionIterationBehaviorUnfiltered_select_star, compileOption: LEGACY -- projectOfSexp, compileOption: PERMISSIVE -- projectOfSexp, compileOption: LEGACY -- projectOfUnpivotPath, compileOption: LEGACY -- alias1.alias2.*, compileOption: LEGACY -- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: PERMISSIVE -- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: LEGACY -- selectListWithMissing, compileOption: LEGACY -- selectCorrelatedJoin, compileOption: PERMISSIVE -- selectCorrelatedJoin, compileOption: LEGACY -- selectCorrelatedLeftJoin, compileOption: PERMISSIVE -- selectCorrelatedLeftJoin, compileOption: LEGACY -- selectCorrelatedLeftJoinOnClause, compileOption: PERMISSIVE -- selectCorrelatedLeftJoinOnClause, compileOption: LEGACY -- selectJoinOnClauseScoping, compileOption: PERMISSIVE -- selectJoinOnClauseScoping, compileOption: LEGACY -- selectNonCorrelatedJoin, compileOption: LEGACY -- correlatedJoinWithShadowedAttributes, compileOption: LEGACY -- correlatedJoinWithoutLexicalScope, compileOption: LEGACY -- joinWithShadowedGlobal, compileOption: LEGACY -- selectDistinctStarBags, compileOption: PERMISSIVE -- selectDistinctStarBags, compileOption: LEGACY -- variableShadow, compileOption: LEGACY -- selectValueStructConstructorWithMissing, compileOption: LEGACY -- selectIndexStruct, compileOption: PERMISSIVE -- selectIndexStruct, compileOption: LEGACY -- emptySymbol, compileOption: LEGACY -- emptySymbolInGlobals, compileOption: LEGACY -
-The following test(s) are failing in legacy but pass in eval. Before merging, confirm they are intended to pass: -
Click here to see - - -- equiv group by with aggregates, compileOption: PERMISSIVE - -- equiv group by with aggregates, compileOption: LEGACY - -- missing and true, compileOption: PERMISSIVE - -- coll_count with result of subquery, compileOption: PERMISSIVE - -- coll_count with result of subquery, compileOption: LEGACY - -- outerUnionAll, compileOption: PERMISSIVE - -- outerUnionAll, compileOption: LEGACY - -- outerExceptDistinct, compileOption: PERMISSIVE - -- outerExceptDistinct, compileOption: LEGACY - -- outerUnionCoerceList, compileOption: PERMISSIVE - -- outerUnionCoerceList, compileOption: LEGACY - -- max top level{agg:'COLL_MAX(data)',result:(success 2)}, compileOption: PERMISSIVE - -- max top level{agg:'COLL_MAX(data)',result:(success 2)}, compileOption: LEGACY - -- topLevelCollMax, compileOption: PERMISSIVE - -- topLevelCollMax, compileOption: LEGACY - -- COLL_MAX empty collection, compileOption: PERMISSIVE - -- COLL_MAX empty collection, compileOption: LEGACY - -- COLL_MAX null, compileOption: PERMISSIVE - -- COLL_MAX null, compileOption: LEGACY - -- COLL_MAX list of missing element, compileOption: PERMISSIVE - -- COLL_MAX list of missing element, compileOption: LEGACY - -- COLL_MAX bag of missing elements, compileOption: PERMISSIVE - -- COLL_MAX bag of missing elements, compileOption: LEGACY - -- COLL_MAX bag of heterogeneous element types, compileOption: PERMISSIVE - -- COLL_MAX bag of heterogeneous element types, compileOption: LEGACY - -- coll_avg top level{agg:'COLL_AVG(data)',result:(success 1.25)}, compileOption: PERMISSIVE - -- coll_avg top level{agg:'COLL_AVG(data)',result:(success 1.25)}, compileOption: LEGACY - -- topLevelCollAvg, compileOption: PERMISSIVE - -- topLevelCollAvg, compileOption: LEGACY - -- topLevelCollAvgOnlyInt, compileOption: PERMISSIVE - -- topLevelCollAvgOnlyInt, compileOption: LEGACY - -- COLL_AVG empty collection, compileOption: PERMISSIVE - -- COLL_AVG empty collection, compileOption: LEGACY - -- COLL_AVG null, compileOption: PERMISSIVE - -- COLL_AVG null, compileOption: LEGACY - -- COLL_AVG list of missing element, compileOption: PERMISSIVE - -- COLL_AVG list of missing element, compileOption: LEGACY - -- COLL_AVG bag of missing elements, compileOption: PERMISSIVE - -- COLL_AVG bag of missing elements, compileOption: LEGACY - -- COLL_AVG mistyped element, compileOption: PERMISSIVE - -- coll_count top level{agg:'COLL_COUNT(data)',result:(success 4)}, compileOption: PERMISSIVE - -- coll_count top level{agg:'COLL_COUNT(data)',result:(success 4)}, compileOption: LEGACY - -- topLevelCollCount, compileOption: PERMISSIVE - -- topLevelCollCount, compileOption: LEGACY - -- COLL_COUNT empty collection, compileOption: PERMISSIVE - -- COLL_COUNT empty collection, compileOption: LEGACY - -- COLL_COUNT null, compileOption: PERMISSIVE - -- COLL_COUNT null, compileOption: LEGACY - -- COLL_COUNT list of missing element, compileOption: PERMISSIVE - -- COLL_COUNT list of missing element, compileOption: LEGACY - -- COLL_COUNT bag of missing elements, compileOption: PERMISSIVE - -- COLL_COUNT bag of missing elements, compileOption: LEGACY - -- COLL_COUNT bag of heterogeneous element types, compileOption: PERMISSIVE - -- COLL_COUNT bag of heterogeneous element types, compileOption: LEGACY - -- coll_sum top level{agg:'COLL_SUM(data)',result:(success 5)}, compileOption: PERMISSIVE - -- coll_sum top level{agg:'COLL_SUM(data)',result:(success 5)}, compileOption: LEGACY - -- topLevelCollSum, compileOption: PERMISSIVE - -- topLevelCollSum, compileOption: LEGACY - -- COLL_SUM empty collection, compileOption: PERMISSIVE - -- COLL_SUM empty collection, compileOption: LEGACY - -- COLL_SUM null, compileOption: PERMISSIVE - -- COLL_SUM null, compileOption: LEGACY - -- COLL_SUM list of missing element, compileOption: PERMISSIVE - -- COLL_SUM list of missing element, compileOption: LEGACY - -- COLL_SUM bag of missing elements, compileOption: PERMISSIVE - -- COLL_SUM bag of missing elements, compileOption: LEGACY - -- COLL_SUM mistyped element, compileOption: PERMISSIVE - -- coll_min top level{agg:'COLL_MIN(data)',result:(success 1)}, compileOption: PERMISSIVE - -- coll_min top level{agg:'COLL_MIN(data)',result:(success 1)}, compileOption: LEGACY - -- topLevelCollMin, compileOption: PERMISSIVE - -- topLevelCollMin, compileOption: LEGACY - -- COLL_MIN empty collection, compileOption: PERMISSIVE - -- COLL_MIN empty collection, compileOption: LEGACY - -- COLL_MIN null, compileOption: PERMISSIVE - -- COLL_MIN null, compileOption: LEGACY - -- COLL_MIN list of missing element, compileOption: PERMISSIVE - -- COLL_MIN list of missing element, compileOption: LEGACY - -- COLL_MIN bag of missing elements, compileOption: PERMISSIVE - -- COLL_MIN bag of missing elements, compileOption: LEGACY - -- COLL_MIN bag of heterogeneous element types, compileOption: PERMISSIVE - -- COLL_MIN bag of heterogeneous element types, compileOption: LEGACY - -- COLL_ANY bag literals, compileOption: PERMISSIVE - -- COLL_ANY bag literals, compileOption: LEGACY - -- COLL_ANY list expressions, compileOption: PERMISSIVE - -- COLL_ANY list expressions, compileOption: LEGACY - -- COLL_ANY single true, compileOption: PERMISSIVE - -- COLL_ANY single true, compileOption: LEGACY - -- COLL_ANY single false, compileOption: PERMISSIVE - -- COLL_ANY single false, compileOption: LEGACY - -- COLL_ANY nulls with true, compileOption: PERMISSIVE - -- COLL_ANY nulls with true, compileOption: LEGACY - -- COLL_ANY nulls with false, compileOption: PERMISSIVE - -- COLL_ANY nulls with false, compileOption: LEGACY - -- COLL_ANY nulls only, compileOption: PERMISSIVE - -- COLL_ANY nulls only, compileOption: LEGACY - -- COLL_ANY null, compileOption: PERMISSIVE - -- COLL_ANY null, compileOption: LEGACY - -- COLL_ANY list of missing element, compileOption: PERMISSIVE - -- COLL_ANY list of missing element, compileOption: LEGACY - -- COLL_ANY bag of missing elements, compileOption: PERMISSIVE - -- COLL_ANY bag of missing elements, compileOption: LEGACY - -- COLL_ANY some empty, compileOption: PERMISSIVE - -- COLL_ANY some empty, compileOption: LEGACY - -- COLL_ANY one non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_ANY all non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_ANY nested collection, compileOption: PERMISSIVE - -- COLL_SOME bag literals, compileOption: PERMISSIVE - -- COLL_SOME bag literals, compileOption: LEGACY - -- COLL_SOME list expressions, compileOption: PERMISSIVE - -- COLL_SOME list expressions, compileOption: LEGACY - -- COLL_SOME single true, compileOption: PERMISSIVE - -- COLL_SOME single true, compileOption: LEGACY - -- COLL_SOME single false, compileOption: PERMISSIVE - -- COLL_SOME single false, compileOption: LEGACY - -- COLL_SOME nulls with true, compileOption: PERMISSIVE - -- COLL_SOME nulls with true, compileOption: LEGACY - -- COLL_SOME nulls with false, compileOption: PERMISSIVE - -- COLL_SOME nulls with false, compileOption: LEGACY - -- COLL_SOME nulls only, compileOption: PERMISSIVE - -- COLL_SOME nulls only, compileOption: LEGACY - -- COLL_SOME null, compileOption: PERMISSIVE - -- COLL_SOME null, compileOption: LEGACY - -- COLL_SOME list of missing element, compileOption: PERMISSIVE - -- COLL_SOME list of missing element, compileOption: LEGACY - -- COLL_SOME bag of missing elements, compileOption: PERMISSIVE - -- COLL_SOME bag of missing elements, compileOption: LEGACY - -- COLL_SOME some empty, compileOption: PERMISSIVE - -- COLL_SOME some empty, compileOption: LEGACY - -- COLL_SOME one non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_SOME all non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_SOME nested collection, compileOption: PERMISSIVE - -- COLL_EVERY bag literals, compileOption: PERMISSIVE - -- COLL_EVERY bag literals, compileOption: LEGACY - -- COLL_EVERY list expressions, compileOption: PERMISSIVE - -- COLL_EVERY list expressions, compileOption: LEGACY - -- COLL_EVERY single true, compileOption: PERMISSIVE - -- COLL_EVERY single true, compileOption: LEGACY - -- COLL_EVERY single false, compileOption: PERMISSIVE - -- COLL_EVERY single false, compileOption: LEGACY - -- COLL_EVERY null and missing with true, compileOption: PERMISSIVE - -- COLL_EVERY null and missing with true, compileOption: LEGACY - -- COLL_EVERY null with false, compileOption: PERMISSIVE - -- COLL_EVERY null with false, compileOption: LEGACY - -- COLL_EVERY null and missing only, compileOption: PERMISSIVE - -- COLL_EVERY null and missing only, compileOption: LEGACY - -- COLL_EVERY null, compileOption: PERMISSIVE - -- COLL_EVERY null, compileOption: LEGACY - -- COLL_EVERY list of missing element, compileOption: PERMISSIVE - -- COLL_EVERY list of missing element, compileOption: LEGACY - -- COLL_EVERY bag of missing elements, compileOption: PERMISSIVE - -- COLL_EVERY bag of missing elements, compileOption: LEGACY - -- COLL_EVERY empty collection, compileOption: PERMISSIVE - -- COLL_EVERY empty collection, compileOption: LEGACY - -- COLL_EVERY one non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_EVERY all non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_EVERY nested collection, compileOption: PERMISSIVE - -- selectValueCollAggregate, compileOption: PERMISSIVE - -- selectValueCollAggregate, compileOption: LEGACY - -- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67Z`), compileOption: PERMISSIVE - -- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67Z`), compileOption: LEGACY - -- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: PERMISSIVE - -- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: LEGACY - -- Example 1 — Union of Compatible Relations, compileOption: PERMISSIVE - -- Example 1 — Union of Compatible Relations, compileOption: LEGACY - -- Example 4 — Intersection of Compatible Relations, compileOption: PERMISSIVE - -- Example 4 — Intersection of Compatible Relations, compileOption: LEGACY - -- Example 5 — Difference of Compatible Relations, compileOption: PERMISSIVE - -- Example 5 — Difference of Compatible Relations, compileOption: LEGACY - -- offset 2^63, compileOption: PERMISSIVE - -- offset 2^63, compileOption: LEGACY - -- SELECT supplierId_missings FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE - -- SELECT p.supplierId_missings FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE - -- SELECT VALUE { 'supplierId_missings' : p.supplierId_missings } FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE - -- SELECT supplierId_mixed FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE - -- SELECT p.supplierId_mixed FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE - -- SELECT VALUE { 'supplierId_mixed' : p.supplierId_mixed } FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE - -- SELECT regionId, supplierId_missings FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE - -- SELECT p.regionId, p.supplierId_missings FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE - -- SELECT VALUE { 'regionId': p.regionId, 'supplierId_missings': p.supplierId_missings } FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE - -- SELECT regionId, supplierId_mixed FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE - -- SELECT regionId, p.supplierId_mixed FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE - -- SELECT VALUE { 'regionId': p.regionId, 'supplierId_mixed': p.supplierId_mixed } FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE - -- SELECT with nested aggregates (complex) 2, compileOption: PERMISSIVE - -- SELECT with nested aggregates (complex) 2, compileOption: LEGACY - -
- -### Conformance comparison report-Cross Commit-LEGACY -| | Base (HEAD) | HEAD | +/- | -| --- | ---: | ---: | ---: | -| % Passing | 92.51% | 92.47% | -0.03% | -| :white_check_mark: Passing | 5382 | 5380 | -2 | -| :x: Failing | 436 | 438 | 2 | -| :large_orange_diamond: Ignored | 0 | 0 | 0 | -| Total Tests | 5818 | 5818 | 0 | -Number passing in both: 5380 - -Number failing in both: 436 - -Number passing in Base (HEAD) but now fail: 2 - -Number failing in Base (HEAD) but now pass: 0 -:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) were previously passing but now fail: -
Click here to see - - -- outerExceptDistinct, compileOption: PERMISSIVE -- outerExceptDistinct, compileOption: LEGACY -
- -### Conformance comparison report-Cross Commit-EVAL -| | Base (HEAD) | HEAD | +/- | -| --- | ---: | ---: | ---: | -| % Passing | 82.81% | 82.68% | -0.14% | -| :white_check_mark: Passing | 4819 | 4811 | -8 | -| :x: Failing | 1000 | 1008 | 8 | -| :large_orange_diamond: Ignored | 0 | 0 | 0 | -| Total Tests | 5819 | 5819 | 0 | -Number passing in both: 4711 - -Number failing in both: 900 - -Number passing in Base (HEAD) but now fail: 108 - -Number failing in Base (HEAD) but now pass: 101 -:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) were previously passing but now fail: -
Click here to see - - -- inPredicate, compileOption: PERMISSIVE -- inPredicate, compileOption: LEGACY -- inPredicateSingleItem, compileOption: PERMISSIVE -- inPredicateSingleItem, compileOption: LEGACY -- inPredicateSingleItemListVar, compileOption: PERMISSIVE -- inPredicateSubQuerySelectValue, compileOption: PERMISSIVE -- inPredicateSubQuerySelectValue, compileOption: LEGACY -- notInPredicate, compileOption: PERMISSIVE -- notInPredicate, compileOption: LEGACY -- notInPredicateSingleItem, compileOption: PERMISSIVE -- notInPredicateSingleItem, compileOption: LEGACY -- notInPredicateSingleItemListVar, compileOption: PERMISSIVE -- notInPredicateSubQuerySelectValue, compileOption: PERMISSIVE -- notInPredicateSubQuerySelectValue, compileOption: LEGACY -- inPredicateWithTableConstructor, compileOption: PERMISSIVE -- inPredicateWithTableConstructor, compileOption: LEGACY -- notInPredicateWithTableConstructor, compileOption: PERMISSIVE -- notInPredicateWithTableConstructor, compileOption: LEGACY -- inPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE -- inPredicateWithExpressionOnRightSide, compileOption: LEGACY -- notInPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE -- notInPredicateWithExpressionOnRightSide, compileOption: LEGACY -- pathDoubleWildCard, compileOption: PERMISSIVE -- pathDoubleWildCard, compileOption: LEGACY -- nullif valid cases{first:"1",second:"1",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"1",result:null}, compileOption: LEGACY -- nullif valid cases{first:"1",second:"2",result:1}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"2",result:1}, compileOption: LEGACY -- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: PERMISSIVE -- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: LEGACY -- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: LEGACY -- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: LEGACY -- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: PERMISSIVE -- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: LEGACY -- nullif valid cases{first:"1",second:"null",result:1}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"null",result:1}, compileOption: LEGACY -- nullif valid cases{first:"null",second:"1",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"null",second:"1",result:null}, compileOption: LEGACY -- nullif valid cases{first:"null",second:"null",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"null",second:"null",result:null}, compileOption: LEGACY -- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: LEGACY -- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: PERMISSIVE -- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: LEGACY -- nullif valid cases{first:"missing",second:"missing",result:missing}, compileOption: PERMISSIVE -- nullif valid cases{first:"missing",second:"missing",result:missing}, compileOption: LEGACY -- coalesce valid cases{args:"1",result:(success 1)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"1",result:(success 1)}, compileOption: LEGACY -- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: LEGACY -- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: LEGACY -- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: LEGACY -- join on column - all column values non-null, compileOption: PERMISSIVE -- join on column - all column values non-null, compileOption: LEGACY -- join on column - some column values are null, compileOption: PERMISSIVE -- join on column - some column values are null, compileOption: LEGACY -- join on column - 1 table contains 1 row with the value null, compileOption: PERMISSIVE -- join on column - ON condition = false, compileOption: PERMISSIVE -- join on column - ON condition = false, compileOption: LEGACY -- PG_JOIN_01, compileOption: PERMISSIVE -- PG_JOIN_01, compileOption: LEGACY -- PG_JOIN_02, compileOption: PERMISSIVE -- PG_JOIN_02, compileOption: LEGACY -- PG_JOIN_03, compileOption: PERMISSIVE -- PG_JOIN_03, compileOption: LEGACY -- PG_JOIN_06, compileOption: PERMISSIVE -- PG_JOIN_06, compileOption: LEGACY -- PG_JOIN_08, compileOption: PERMISSIVE -- PG_JOIN_08, compileOption: LEGACY -- PG_JOIN_10, compileOption: PERMISSIVE -- PG_JOIN_10, compileOption: LEGACY -- offset 0, compileOption: PERMISSIVE -- offset 0, compileOption: LEGACY -- offset 1, compileOption: PERMISSIVE -- offset 1, compileOption: LEGACY -- offset 2, compileOption: PERMISSIVE -- offset 2, compileOption: LEGACY -- limit 1 offset 1, compileOption: PERMISSIVE -- limit 1 offset 1, compileOption: LEGACY -- limit 10 offset 1, compileOption: PERMISSIVE -- limit 10 offset 1, compileOption: LEGACY -- limit 2 offset 2, compileOption: PERMISSIVE -- limit 2 offset 2, compileOption: LEGACY -- limit offset after group by, compileOption: PERMISSIVE -- limit offset after group by, compileOption: LEGACY -- offset 2-1, compileOption: PERMISSIVE -- offset 2-1, compileOption: LEGACY -- offset 2+1, compileOption: PERMISSIVE -- offset 2+1, compileOption: LEGACY -- offset 2*1, compileOption: PERMISSIVE -- offset 2*1, compileOption: LEGACY -- offset 2/1, compileOption: PERMISSIVE -- offset 2/1, compileOption: LEGACY -- offset group by having, compileOption: PERMISSIVE -- offset group by having, compileOption: LEGACY -- offset with pivot, compileOption: PERMISSIVE -- offset with pivot, compileOption: LEGACY -- offset 1-2, compileOption: PERMISSIVE -- selectStarSingleSourceHoisted, compileOption: PERMISSIVE -- selectStarSingleSourceHoisted, compileOption: LEGACY -- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: PERMISSIVE -- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: LEGACY -- selectCorrelatedJoin, compileOption: PERMISSIVE -- selectCorrelatedJoin, compileOption: LEGACY -
-The following test(s) were previously failing but now pass. Before merging, confirm they are intended to pass: -
Click here to see - - -- equiv attribute value pair unpivot missing, compileOption: LEGACY - -- Example 6 — Value Coercion, compileOption: PERMISSIVE - -- Example 6 — Value Coercion, compileOption: LEGACY - -- tuple navigation with array notation without explicit CAST to string, compileOption: LEGACY - -- path on string, compileOption: LEGACY - -- tuple navigation missing attribute dot notation, compileOption: LEGACY - -- tuple navigation missing attribute array notation, compileOption: LEGACY - -- array navigation with wrongly typed array index, compileOption: LEGACY - -- data type mismatch in comparison expression, compileOption: LEGACY - -- data type mismatch in logical expression, compileOption: LEGACY - -- LIKE bad value type, compileOption: LEGACY - -- LIKE bad pattern type, compileOption: LEGACY - -- LIKE bad escape type, compileOption: LEGACY - -- outerUnionDistinct, compileOption: PERMISSIVE - -- outerUnionDistinct, compileOption: LEGACY - -- outerUnionAll, compileOption: PERMISSIVE - -- outerUnionAll, compileOption: LEGACY - -- outerIntersectDistinct, compileOption: PERMISSIVE - -- outerIntersectDistinct, compileOption: LEGACY - -- outerIntersectAll, compileOption: PERMISSIVE - -- outerIntersectAll, compileOption: LEGACY - -- outerExceptDistinct, compileOption: PERMISSIVE - -- outerExceptDistinct, compileOption: LEGACY - -- outerExceptAll, compileOption: PERMISSIVE - -- outerExceptAll, compileOption: LEGACY - -- outerUnionCoerceScalar, compileOption: PERMISSIVE - -- outerUnionCoerceStruct, compileOption: PERMISSIVE - -- outerUnionCoerceList, compileOption: PERMISSIVE - -- outerUnionCoerceList, compileOption: LEGACY - -- notInPredicateSingleExpr, compileOption: LEGACY - -- betweenPredicate, compileOption: PERMISSIVE - -- betweenPredicate, compileOption: LEGACY - -- notBetweenPredicate, compileOption: PERMISSIVE - -- notBetweenPredicate, compileOption: LEGACY - -- pathUnpivotWildcardFieldsAfter, compileOption: PERMISSIVE - -- pathUnpivotWildcardFieldsAfter, compileOption: LEGACY - -- pathDoubleUnpivotWildCard, compileOption: PERMISSIVE - -- pathDoubleUnpivotWildCard, compileOption: LEGACY - -- subscript with non-existent variable in lowercase, compileOption: LEGACY - -- subscript with non-existent variable in uppercase, compileOption: LEGACY - -- path expression with ambiguous table alias (lowercase), compileOption: LEGACY - -- COLL_MAX non-collection, compileOption: LEGACY - -- COLL_AVG non-collection, compileOption: LEGACY - -- COLL_COUNT non-collection, compileOption: LEGACY - -- COLL_SUM non-collection, compileOption: LEGACY - -- COLL_MIN non-collection, compileOption: LEGACY - -- COLL_ANY non-collection, compileOption: LEGACY - -- COLL_SOME non-collection, compileOption: LEGACY - -- COLL_EVERY non-collection, compileOption: LEGACY - -- selectValueCollAggregate, compileOption: PERMISSIVE - -- selectValueCollAggregate, compileOption: LEGACY - -- CHARACTER_LENGTH invalid type, compileOption: LEGACY - -- CARDINALITY('foo') type mismatch, compileOption: LEGACY - -- invalid extract year from time, compileOption: LEGACY - -- invalid extract month from time, compileOption: LEGACY - -- invalid extract day from time, compileOption: LEGACY - -- invalid extract month from time with time zone, compileOption: LEGACY - -- invalid extract day from time with time zone, compileOption: LEGACY - -- POSITION invalid type in string, compileOption: LEGACY - -- POSITION string in invalid type, compileOption: LEGACY - -- ABS('foo'), compileOption: LEGACY - -- MOD(3, 'some string'), compileOption: LEGACY - -- MOD('some string', 3), compileOption: LEGACY - -- BIT_LENGTH invalid type, compileOption: LEGACY - -- OCTET_LENGTH invalid type, compileOption: LEGACY - -- OVERLAY mismatched type, compileOption: LEGACY - -- OVERLAY PLACING mismatched type, compileOption: LEGACY - -- OVERLAY FROM mismatched type, compileOption: LEGACY - -- OVERLAY FOR mismatched type, compileOption: LEGACY - -- Example 1 — Union of Compatible Relations, compileOption: PERMISSIVE - -- Example 1 — Union of Compatible Relations, compileOption: LEGACY - -- Example 4 — Intersection of Compatible Relations, compileOption: PERMISSIVE - -- Example 4 — Intersection of Compatible Relations, compileOption: LEGACY - -- Example 5 — Difference of Compatible Relations, compileOption: PERMISSIVE - -- Example 5 — Difference of Compatible Relations, compileOption: LEGACY - -- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: PERMISSIVE - -- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: LEGACY - -- Example 3 — Outer union of Heterogenous Relations, compileOption: PERMISSIVE - -- Example 3 — Outer union of Heterogenous Relations, compileOption: LEGACY - -- Example 6 — Value Coercion; Coercion of single value, compileOption: PERMISSIVE - -- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: PERMISSIVE - -- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: LEGACY - -- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: PERMISSIVE - -- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: LEGACY - -- Example 7 — result is the empty bag, compileOption: PERMISSIVE - -- Example 7 — result is the empty bag, compileOption: LEGACY - -- undefinedUnqualifiedVariableWithUndefinedVariableBehaviorMissing, compileOption: LEGACY - -- undefinedUnqualifiedVariableIsNullExprWithUndefinedVariableBehaviorMissing, compileOption: LEGACY - -- undefinedUnqualifiedVariableIsMissingExprWithUndefinedVariableBehaviorMissing, compileOption: LEGACY - -- offset , compileOption: LEGACY - -- offset >, compileOption: LEGACY - -- GROUP BY binding referenced in FROM clause, compileOption: LEGACY - -- GROUP BY binding referenced in WHERE clause, compileOption: LEGACY - -- GROUP AS binding referenced in FROM clause, compileOption: LEGACY - -- GROUP AS binding referenced in WHERE clause, compileOption: LEGACY - -- SELECT COUNT( numInStock) + 2 AS agg FROM products, compileOption: PERMISSIVE - -- SELECT COUNT( numInStock) + 2 AS agg FROM products, compileOption: LEGACY - -- SELECT COUNT(p.numInStock) + 2 AS agg FROM products as p, compileOption: PERMISSIVE - -- SELECT COUNT(p.numInStock) + 2 AS agg FROM products as p, compileOption: LEGACY - -- projectionIterationBehaviorUnfiltered_select_list, compileOption: PERMISSIVE - -- projectionIterationBehaviorUnfiltered_select_list, compileOption: LEGACY - -
- -### Conformance comparison report-Cross Engine -| | Base (legacy) | eval | +/- | -| --- | ---: | ---: | ---: | -| % Passing | 92.47% | 82.68% | -9.79% | -| :white_check_mark: Passing | 5380 | 4811 | -569 | -| :x: Failing | 438 | 1008 | 570 | -| :large_orange_diamond: Ignored | 0 | 0 | 0 | -| Total Tests | 5818 | 5819 | 1 | -Number passing in both: 4627 - -Number failing in both: 254 - -Number passing in legacy engine but fail in eval engine: 754 - -Number failing in legacy engine but pass in eval engine: 184 -:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) are passing in legacy but fail in eval: -
Click here to see - - -- equiv wildcard steps struct, compileOption: PERMISSIVE -- equiv wildcard steps struct, compileOption: LEGACY -- equiv path expression with wildcard steps, compileOption: PERMISSIVE -- equiv path expression with wildcard steps, compileOption: LEGACY -- equiv path collection expression with wildcard steps, compileOption: PERMISSIVE -- equiv path collection expression with wildcard steps, compileOption: LEGACY -- equiv attribute value pair unpivot missing, compileOption: PERMISSIVE -- equiv left join, compileOption: PERMISSIVE -- equiv left join, compileOption: LEGACY -- Example 6 — Value Coercion, compileOption: LEGACY -- path on string, compileOption: PERMISSIVE -- tuple navigation missing attribute dot notation, compileOption: PERMISSIVE -- tuple navigation missing attribute array notation, compileOption: PERMISSIVE -- array navigation with wrongly typed array index, compileOption: PERMISSIVE -- single source FROM with scalar, compileOption: LEGACY -- single source FROM with tuple, compileOption: LEGACY -- single source FROM with absent value null, compileOption: LEGACY -- single source FROM with absent value missing, compileOption: LEGACY -- tuple constructor and mistyped attribute name, compileOption: PERMISSIVE -- attribute value evaluates to MISSING, compileOption: LEGACY -- array element evaluates to MISSING, compileOption: LEGACY -- bag element evaluates to MISSING, compileOption: LEGACY -- bag element evaluates to MISSING in bag constructor, compileOption: LEGACY -- pivot into a tuple with invalid attribute name, compileOption: LEGACY -- missing value in arithmetic expression, compileOption: PERMISSIVE -- data type mismatch in comparison expression, compileOption: PERMISSIVE -- data type mismatch in logical expression, compileOption: PERMISSIVE -- equality of scalar missing, compileOption: PERMISSIVE -- equality of same element bags, compileOption: PERMISSIVE -- equality of same element bags, compileOption: LEGACY -- WHERE clause eliminating absent values, compileOption: PERMISSIVE -- WHERE clause eliminating absent values, compileOption: LEGACY -- group by with absent values, compileOption: LEGACY -- group by with differenciated absent values, compileOption: LEGACY -- Right with variables, compileOption: PERMISSIVE -- Right with variables, compileOption: LEGACY -- Right with spots, compileOption: PERMISSIVE -- Right with spots, compileOption: LEGACY -- Right shorthand, compileOption: PERMISSIVE -- Right shorthand, compileOption: LEGACY -- Left with variables, compileOption: PERMISSIVE -- Left with variables, compileOption: LEGACY -- Left with spots, compileOption: PERMISSIVE -- Left with spots, compileOption: LEGACY -- Left shorthand, compileOption: PERMISSIVE -- Left shorthand, compileOption: LEGACY -- Left+right with variables, compileOption: PERMISSIVE -- Left+right with variables, compileOption: LEGACY -- Left+right with spots, compileOption: PERMISSIVE -- Left+right with spots, compileOption: LEGACY -- Left+right shorthand, compileOption: PERMISSIVE -- Left+right shorthand, compileOption: LEGACY -- Left+right with variables and label, compileOption: PERMISSIVE -- Left+right with variables and label, compileOption: LEGACY -- Undirected with variables, compileOption: PERMISSIVE -- Undirected with variables, compileOption: LEGACY -- Undirected with spots, compileOption: PERMISSIVE -- Undirected with spots, compileOption: LEGACY -- Undirected shorthand, compileOption: PERMISSIVE -- Undirected shorthand, compileOption: LEGACY -- Undirected with variables and label, compileOption: PERMISSIVE -- Undirected with variables and label, compileOption: LEGACY -- Right+undirected with variables, compileOption: PERMISSIVE -- Right+undirected with variables, compileOption: LEGACY -- Right+undirected with spots, compileOption: PERMISSIVE -- Right+undirected with spots, compileOption: LEGACY -- Right+undirected shorthand, compileOption: PERMISSIVE -- Right+undirected shorthand, compileOption: LEGACY -- Right+undirected with variables and labels, compileOption: PERMISSIVE -- Right+undirected with variables and labels, compileOption: LEGACY -- Left+undirected with variables, compileOption: PERMISSIVE -- Left+undirected with variables, compileOption: LEGACY -- Left+undirected with spots, compileOption: PERMISSIVE -- Left+undirected with spots, compileOption: LEGACY -- Left+undirected shorthand, compileOption: PERMISSIVE -- Left+undirected shorthand, compileOption: LEGACY -- Left+undirected with variables and label, compileOption: PERMISSIVE -- Left+undirected with variables and label, compileOption: LEGACY -- Left+right+undirected with variables, compileOption: PERMISSIVE -- Left+right+undirected with variables, compileOption: LEGACY -- Left+right+undirected with spots, compileOption: PERMISSIVE -- Left+right+undirected with spots, compileOption: LEGACY -- Left+right+undirected shorthand, compileOption: PERMISSIVE -- Left+right+undirected shorthand, compileOption: LEGACY -- (N0E0 MATCH (x)), compileOption: PERMISSIVE -- (N0E0 MATCH (x)), compileOption: LEGACY -- (N0E0 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N0E0 MATCH -[y]-> ), compileOption: LEGACY -- (N0E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N0E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N1E0 MATCH (x)), compileOption: PERMISSIVE -- (N1E0 MATCH (x)), compileOption: LEGACY -- (N1E0 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N1E0 MATCH -[y]-> ), compileOption: LEGACY -- (N1E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N1E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N1E0 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE -- (N1E0 MATCH (x)-[y]->(x) ), compileOption: LEGACY -- (N1U1 MATCH (x)), compileOption: PERMISSIVE -- (N1U1 MATCH (x)), compileOption: LEGACY -- (N1U1 MATCH ~[y]~ ), compileOption: PERMISSIVE -- (N1U1 MATCH ~[y]~ ), compileOption: LEGACY -- (N1U1 MATCH (x)~[y]~(z) ), compileOption: PERMISSIVE -- (N1U1 MATCH (x)~[y]~(z) ), compileOption: LEGACY -- (N1U1 MATCH (x)~[y]~(x) ), compileOption: PERMISSIVE -- (N1U1 MATCH (x)~[y]~(x) ), compileOption: LEGACY -- (N1U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: PERMISSIVE -- (N1U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: LEGACY -- (N1D2 MATCH (x)), compileOption: PERMISSIVE -- (N1D2 MATCH (x)), compileOption: LEGACY -- (N1D2 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N1D2 MATCH -[y]-> ), compileOption: LEGACY -- (N1D2 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N1D2 MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N1D2 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE -- (N1D2 MATCH (x)-[y]->(x) ), compileOption: LEGACY -- (N1D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N1D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2E0 MATCH (x)), compileOption: PERMISSIVE -- (N2E0 MATCH (x)), compileOption: LEGACY -- (N2E0 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N2E0 MATCH -[y]-> ), compileOption: LEGACY -- (N2E0 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N2E0 MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N2E0 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE -- (N2E0 MATCH (x)-[y]->(x) ), compileOption: LEGACY -- (N2D1 MATCH (x)), compileOption: PERMISSIVE -- (N2D1 MATCH (x)), compileOption: LEGACY -- (N2D1 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N2D1 MATCH -[y]-> ), compileOption: LEGACY -- (N2D1 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N2D1 MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N2D1 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE -- (N2D1 MATCH (x)-[y]->(x) ), compileOption: LEGACY -- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2D1 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2D1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2U1 MATCH (x)), compileOption: PERMISSIVE -- (N2U1 MATCH (x)), compileOption: LEGACY -- (N2U1 MATCH ~[y]~ ), compileOption: PERMISSIVE -- (N2U1 MATCH ~[y]~ ), compileOption: LEGACY -- (N2U1 MATCH (x)~[y]~(z) ), compileOption: PERMISSIVE -- (N2U1 MATCH (x)~[y]~(z) ), compileOption: LEGACY -- (N2U1 MATCH (x)~[y]~(x) ), compileOption: PERMISSIVE -- (N2U1 MATCH (x)~[y]~(x) ), compileOption: LEGACY -- (N2U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: PERMISSIVE -- (N2U1 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: LEGACY -- (N2U1 MATCH (x1)~[y1]~(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2U1 MATCH (x1)~[y1]~(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2U1 MATCH (x1)-[y1]-(x2)~[y2]~(x3) ), compileOption: PERMISSIVE -- (N2U1 MATCH (x1)-[y1]-(x2)~[y2]~(x3) ), compileOption: LEGACY -- (N2U1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2U1 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2D2 MATCH (x)), compileOption: PERMISSIVE -- (N2D2 MATCH (x)), compileOption: LEGACY -- (N2D2 MATCH -[y]-> ), compileOption: PERMISSIVE -- (N2D2 MATCH -[y]-> ), compileOption: LEGACY -- (N2D2 MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N2D2 MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N2D2 MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE -- (N2D2 MATCH (x)-[y]->(x) ), compileOption: LEGACY -- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2D2 MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2D2 MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2D2c MATCH (x)), compileOption: PERMISSIVE -- (N2D2c MATCH (x)), compileOption: LEGACY -- (N2D2c MATCH -[y]-> ), compileOption: PERMISSIVE -- (N2D2c MATCH -[y]-> ), compileOption: LEGACY -- (N2D2c MATCH (x)-[y]->(z) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x)-[y]->(z) ), compileOption: LEGACY -- (N2D2c MATCH (x)-[y]->(x) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x)-[y]->(x) ), compileOption: LEGACY -- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x1) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]->(x1) ), compileOption: LEGACY -- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x1)-[y1]->(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]->(x3) ), compileOption: LEGACY -- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: PERMISSIVE -- (N2D2c MATCH (x1)-[y1]-(x2)-[y2]-(x3) ), compileOption: LEGACY -- (N2U2 MATCH (x)), compileOption: PERMISSIVE -- (N2U2 MATCH (x)), compileOption: LEGACY -- (N2U2 MATCH ~[y]~ ), compileOption: PERMISSIVE -- (N2U2 MATCH ~[y]~ ), compileOption: LEGACY -- (N2U2 MATCH (x)~[y]~(z) ), compileOption: PERMISSIVE -- (N2U2 MATCH (x)~[y]~(z) ), compileOption: LEGACY -- (N2U2 MATCH (x)~[y]~(x) ), compileOption: PERMISSIVE -- (N2U2 MATCH (x)~[y]~(x) ), compileOption: LEGACY -- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: PERMISSIVE -- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x3) ), compileOption: LEGACY -- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x1) ), compileOption: PERMISSIVE -- (N2U2 MATCH (x1)~[y1]~(x2)~[y2]~(x1) ), compileOption: LEGACY -- cast to MISSING valid cases{value:"NULL"}, compileOption: PERMISSIVE -- cast to MISSING valid cases{value:"NULL"}, compileOption: LEGACY -- cast to MISSING valid cases{value:"MISSING"}, compileOption: PERMISSIVE -- cast to MISSING valid cases{value:"MISSING"}, compileOption: LEGACY -- cast to NULL valid cases{value:"MISSING"}, compileOption: PERMISSIVE -- cast to NULL valid cases{value:"MISSING"}, compileOption: LEGACY -- cast to int invalid target type{value:"`2017T`",target:"TIMESTAMP"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:" `{{\"\"}}` ",target:"CLOB"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:" `{{\"1\"}}` ",target:"CLOB"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"`{{}}`",target:"BLOB"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"[1, 2]",target:"LIST"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"[1]",target:"LIST"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"[]",target:"LIST"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"`(1 2)`",target:"SEXP"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"`(1)`",target:"SEXP"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"`()`",target:"SEXP"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"{'a': 1}",target:"STRUCT"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"{'a': '12'}",target:"STRUCT"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"{}",target:"STRUCT"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"<<1, 2>>",target:"BAG"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"<<1>>",target:"BAG"}, compileOption: PERMISSIVE -- cast to int invalid target type{value:"<<>>",target:"BAG"}, compileOption: PERMISSIVE -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE null "}, compileOption: PERMISSIVE -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE null "}, compileOption: LEGACY -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE '[' "}, compileOption: PERMISSIVE -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null ESCAPE '[' "}, compileOption: LEGACY -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE 'S1' ESCAPE null "}, compileOption: PERMISSIVE -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE 'S1' ESCAPE null "}, compileOption: LEGACY -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null "}, compileOption: PERMISSIVE -- null value on any of the 3 inputs returns false{likeExpr:" d.sid LIKE null "}, compileOption: LEGACY -- MISSING LIKE 'some pattern', compileOption: PERMISSIVE -- 'some value' LIKE MISSING, compileOption: PERMISSIVE -- MISSING LIKE MISSING, compileOption: PERMISSIVE -- NULL LIKE MISSING, compileOption: PERMISSIVE -- MISSING LIKE NULL, compileOption: PERMISSIVE -- MISSING LIKE 'some pattern' ESCAPE '/', compileOption: PERMISSIVE -- 'some value' LIKE MISSING ESCAPE '/', compileOption: PERMISSIVE -- 'some value' LIKE 'some pattern' ESCAPE MISSING, compileOption: PERMISSIVE -- NULL LIKE 'some pattern' ESCAPE MISSING, compileOption: PERMISSIVE -- 'some value' LIKE NULL ESCAPE MISSING, compileOption: PERMISSIVE -- outerUnionCoerceScalar, compileOption: LEGACY -- outerUnionCoerceStruct, compileOption: LEGACY -- outerUnionCoerceNullMissing, compileOption: PERMISSIVE -- outerUnionCoerceNullMissing, compileOption: LEGACY -- inPredicate, compileOption: PERMISSIVE -- inPredicate, compileOption: LEGACY -- inPredicateSingleItem, compileOption: PERMISSIVE -- inPredicateSingleItem, compileOption: LEGACY -- inPredicateSingleExpr, compileOption: PERMISSIVE -- inPredicateSingleExpr, compileOption: LEGACY -- inPredicateSingleItemListVar, compileOption: PERMISSIVE -- inPredicateSingleItemListVar, compileOption: LEGACY -- inPredicateSingleListVar, compileOption: PERMISSIVE -- inPredicateSingleListVar, compileOption: LEGACY -- inPredicateSubQuerySelectValue, compileOption: PERMISSIVE -- inPredicateSubQuerySelectValue, compileOption: LEGACY -- notInPredicate, compileOption: PERMISSIVE -- notInPredicate, compileOption: LEGACY -- notInPredicateSingleItem, compileOption: PERMISSIVE -- notInPredicateSingleItem, compileOption: LEGACY -- notInPredicateSingleExpr, compileOption: PERMISSIVE -- notInPredicateSingleItemListVar, compileOption: PERMISSIVE -- notInPredicateSingleItemListVar, compileOption: LEGACY -- notInPredicateSingleListVar, compileOption: PERMISSIVE -- notInPredicateSingleListVar, compileOption: LEGACY -- notInPredicateSubQuerySelectValue, compileOption: PERMISSIVE -- notInPredicateSubQuerySelectValue, compileOption: LEGACY -- inPredicateWithTableConstructor, compileOption: PERMISSIVE -- inPredicateWithTableConstructor, compileOption: LEGACY -- notInPredicateWithTableConstructor, compileOption: PERMISSIVE -- notInPredicateWithTableConstructor, compileOption: LEGACY -- inPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE -- inPredicateWithExpressionOnRightSide, compileOption: LEGACY -- notInPredicateWithExpressionOnRightSide, compileOption: PERMISSIVE -- notInPredicateWithExpressionOnRightSide, compileOption: LEGACY -- || valid cases{lparam:"null",rparam:"missing",result:missing::null}, compileOption: PERMISSIVE -- || valid cases{lparam:"missing",rparam:"null",result:missing::null}, compileOption: PERMISSIVE -- || valid cases{lparam:"missing",rparam:"'b'",result:missing::null}, compileOption: PERMISSIVE -- || valid cases{lparam:"'a'",rparam:"missing",result:missing::null}, compileOption: PERMISSIVE -- || valid cases{lparam:"missing",rparam:"missing",result:missing::null}, compileOption: PERMISSIVE -- repeatingDecimal, compileOption: PERMISSIVE -- repeatingDecimal, compileOption: LEGACY -- repeatingDecimalHigherPrecision, compileOption: PERMISSIVE -- repeatingDecimalHigherPrecision, compileOption: LEGACY -- divDecimalInt, compileOption: PERMISSIVE -- divDecimalInt, compileOption: LEGACY -- subtractionOutOfAllowedPrecision, compileOption: PERMISSIVE -- subtractionOutOfAllowedPrecision, compileOption: LEGACY -- equalListDifferentTypesTrue, compileOption: PERMISSIVE -- equalListDifferentTypesTrue, compileOption: LEGACY -- simpleCase, compileOption: PERMISSIVE -- simpleCase, compileOption: LEGACY -- simpleCaseNoElse, compileOption: PERMISSIVE -- simpleCaseNoElse, compileOption: LEGACY -- searchedCase, compileOption: PERMISSIVE -- searchedCase, compileOption: LEGACY -- searchedCaseNoElse, compileOption: PERMISSIVE -- searchedCaseNoElse, compileOption: LEGACY -- dateTimePartsAsVariableNames, compileOption: LEGACY -- pathDotMissingAttribute, compileOption: LEGACY -- pathMissingDotName, compileOption: PERMISSIVE -- pathMissingDotName, compileOption: LEGACY -- pathNullDotName, compileOption: PERMISSIVE -- pathNullDotName, compileOption: LEGACY -- pathIndexBagLiteral, compileOption: PERMISSIVE -- pathIndexBagLiteral, compileOption: LEGACY -- pathIndexStructLiteral, compileOption: PERMISSIVE -- pathIndexStructLiteral, compileOption: LEGACY -- pathIndexStructOutOfBoundsLowLiteral, compileOption: PERMISSIVE -- pathIndexStructOutOfBoundsLowLiteral, compileOption: LEGACY -- pathIndexStructOutOfBoundsHighLiteral, compileOption: PERMISSIVE -- pathIndexStructOutOfBoundsHighLiteral, compileOption: LEGACY -- pathDoubleWildCard, compileOption: PERMISSIVE -- pathDoubleWildCard, compileOption: LEGACY -- pathWildCardOverScalar, compileOption: LEGACY -- pathUnpivotWildCardOverScalar, compileOption: LEGACY -- pathWildCardOverScalarMultiple, compileOption: LEGACY -- pathUnpivotWildCardOverScalarMultiple, compileOption: LEGACY -- pathWildCardOverStructMultiple, compileOption: LEGACY -- unpivotMissing, compileOption: PERMISSIVE -- unpivotMissing, compileOption: LEGACY -- unpivotEmptyStruct, compileOption: PERMISSIVE -- unpivotEmptyStruct, compileOption: LEGACY -- unpivotStructWithMissingField, compileOption: PERMISSIVE -- unpivotStructWithMissingField, compileOption: LEGACY -- unpivotMissingWithAsAndAt, compileOption: LEGACY -- unpivotMissingCrossJoinWithAsAndAt, compileOption: LEGACY -- pathUnpivotEmptyStruct1, compileOption: PERMISSIVE -- pathUnpivotEmptyStruct1, compileOption: LEGACY -- pathUnpivotEmptyStruct2, compileOption: PERMISSIVE -- pathUnpivotEmptyStruct2, compileOption: LEGACY -- pathUnpivotEmptyStruct3, compileOption: PERMISSIVE -- pathUnpivotEmptyStruct3, compileOption: LEGACY -- dotted path expression with quoted field name accesses field UNAMBIGUOUS_FIELD (uppercase), compileOption: LEGACY -- subscript with variable in lowercase, compileOption: PERMISSIVE -- subscript with variable in lowercase, compileOption: LEGACY -- subscript with variable in uppercase, compileOption: PERMISSIVE -- subscript with variable in uppercase, compileOption: LEGACY -- subscript with variable in mixed case, compileOption: PERMISSIVE -- subscript with variable in mixed case, compileOption: LEGACY -- subscript with non-existent variable in lowercase, compileOption: PERMISSIVE -- subscript with non-existent variable in uppercase, compileOption: PERMISSIVE -- null comparison{sql:"MISSING IS NULL",result:true}, compileOption: PERMISSIVE -- null comparison{sql:"MISSING IS NULL",result:true}, compileOption: LEGACY -- null comparison{sql:"MISSING = NULL",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"NULL = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.sexp` = NULL",result:null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.sexp` = NULL",result:null}, compileOption: LEGACY -- null comparison{sql:"`null.null` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.bool` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.int` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.decimal` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.string` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.symbol` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.clob` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.blob` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.list` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.struct` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- null comparison{sql:"`null.sexp` = MISSING",result:missing::null}, compileOption: PERMISSIVE -- concatenation with null values{left:"MISSING",right:"MISSING"}, compileOption: PERMISSIVE -- concatenation with null values{left:"''",right:"MISSING"}, compileOption: PERMISSIVE -- concatenation with null values{left:"MISSING",right:"''"}, compileOption: PERMISSIVE -- concatenation with null values{left:"'a'",right:"MISSING"}, compileOption: PERMISSIVE -- concatenation with null values{left:"MISSING",right:"'b'"}, compileOption: PERMISSIVE -- char_length null and missing propagation{in:"missing",result:(success missing::null)}, compileOption: PERMISSIVE -- character_length null and missing propagation{in:"missing",result:(success missing::null)}, compileOption: PERMISSIVE -- CHARACTER_LENGTH invalid type, compileOption: PERMISSIVE -- upper null and missing propagation{param:"missing"}, compileOption: PERMISSIVE -- cardinality null and missing propagation{param:"missing"}, compileOption: PERMISSIVE -- CARDINALITY('foo') type mismatch, compileOption: PERMISSIVE -- EXTRACT(YEAR FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(MONTH FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(DAY FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(HOUR FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(MINUTE FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(SECOND FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(TIMEZONE_HOUR FROM MISSING), compileOption: PERMISSIVE -- EXTRACT(TIMEZONE_MINUTE FROM MISSING), compileOption: PERMISSIVE -- invalid extract year from time, compileOption: PERMISSIVE -- invalid extract month from time, compileOption: PERMISSIVE -- invalid extract day from time, compileOption: PERMISSIVE -- invalid extract month from time with time zone, compileOption: PERMISSIVE -- invalid extract day from time with time zone, compileOption: PERMISSIVE -- POSITION MISSING in string, compileOption: PERMISSIVE -- POSITION string in MISSING, compileOption: PERMISSIVE -- POSITION NULL in MISSING, compileOption: PERMISSIVE -- POSITION MISSING in NULL, compileOption: PERMISSIVE -- POSITION MISSING in MISSING, compileOption: PERMISSIVE -- POSITION invalid type in string, compileOption: PERMISSIVE -- POSITION string in invalid type, compileOption: PERMISSIVE -- substring null and missing propagation 2 arguments{target:"missing",start_pos:"1"}, compileOption: PERMISSIVE -- substring null and missing propagation 2 arguments{target:"''",start_pos:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 2 arguments{target:"missing",start_pos:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 2 arguments{target:"null",start_pos:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 2 arguments{target:"missing",start_pos:"null"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"null",start_pos:"1",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"null",start_pos:"null",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"null",start_pos:"missing",quantity:"1"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"null",start_pos:"missing",quantity:"null"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"null",start_pos:"missing",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"1",quantity:"1"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"1",quantity:"null"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"1",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"null",quantity:"1"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"null",quantity:"null"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"null",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"missing",quantity:"1"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"missing",quantity:"null"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"missing",start_pos:"missing",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"''",start_pos:"1",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"''",start_pos:"null",quantity:"missing"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"''",start_pos:"missing",quantity:"1"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"''",start_pos:"missing",quantity:"null"}, compileOption: PERMISSIVE -- substring null and missing propagation 3 arguments{target:"''",start_pos:"missing",quantity:"missing"}, compileOption: PERMISSIVE -- lower null and missing propagation{param:"missing"}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"1",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"1",result:null}, compileOption: LEGACY -- nullif valid cases{first:"1.0",second:"1",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"1.0",second:"1",result:null}, compileOption: LEGACY -- nullif valid cases{first:"1",second:"2",result:1}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"2",result:1}, compileOption: LEGACY -- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: PERMISSIVE -- nullif valid cases{first:"2",second:"'2'",result:2}, compileOption: LEGACY -- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"{}",second:"{}",result:null}, compileOption: LEGACY -- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"[]",second:"[]",result:null}, compileOption: LEGACY -- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: PERMISSIVE -- nullif valid cases{first:"{}",second:"[]",result:{}}, compileOption: LEGACY -- nullif valid cases{first:"1",second:"null",result:1}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"null",result:1}, compileOption: LEGACY -- nullif valid cases{first:"null",second:"1",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"null",second:"1",result:null}, compileOption: LEGACY -- nullif valid cases{first:"null",second:"null",result:null}, compileOption: PERMISSIVE -- nullif valid cases{first:"null",second:"null",result:null}, compileOption: LEGACY -- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: PERMISSIVE -- nullif valid cases{first:"1",second:"missing",result:1}, compileOption: LEGACY -- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: PERMISSIVE -- nullif valid cases{first:"missing",second:"1",result:missing::null}, compileOption: LEGACY -- ABS(MISSING) null propogation, compileOption: PERMISSIVE -- ABS('foo'), compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(leading from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(trailing from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(both from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(leading '' from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(trailing '' from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(both '' from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(leading missing from '')"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(trailing missing from '')"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(both missing from '')"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(leading null from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(trailing null from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(both null from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(leading missing from null)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(trailing missing from null)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(both missing from null)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(leading missing from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(trailing missing from missing)"}, compileOption: PERMISSIVE -- trim null and missing propagation{sql:"trim(both missing from missing)"}, compileOption: PERMISSIVE -- MOD(MISSING, 3), compileOption: PERMISSIVE -- MOD(3, MISSING), compileOption: PERMISSIVE -- MOD(MISSING, NULL), compileOption: PERMISSIVE -- MOD(NULL, MISSING), compileOption: PERMISSIVE -- MOD(MISSING, 'some string'), compileOption: PERMISSIVE -- MOD('some string', MISSING), compileOption: PERMISSIVE -- MOD(3, 'some string'), compileOption: PERMISSIVE -- MOD('some string', 3), compileOption: PERMISSIVE -- BIT_LENGTH MISSING, compileOption: PERMISSIVE -- BIT_LENGTH invalid type, compileOption: PERMISSIVE -- OCTET_LENGTH MISSING, compileOption: PERMISSIVE -- OCTET_LENGTH invalid type, compileOption: PERMISSIVE -- OVERLAY MISSING, compileOption: PERMISSIVE -- OVERLAY PLACING MISSING, compileOption: PERMISSIVE -- OVERLAY FROM MISSING, compileOption: PERMISSIVE -- OVERLAY FOR MISSING, compileOption: PERMISSIVE -- OVERLAY mismatched type, compileOption: PERMISSIVE -- OVERLAY PLACING mismatched type, compileOption: PERMISSIVE -- OVERLAY FROM mismatched type, compileOption: PERMISSIVE -- OVERLAY FOR mismatched type, compileOption: PERMISSIVE -- coalesce valid cases{args:"1",result:(success 1)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"1",result:(success 1)}, compileOption: LEGACY -- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"1, 2",result:(success 1)}, compileOption: LEGACY -- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"null, 2",result:(success 2)}, compileOption: LEGACY -- coalesce valid cases{args:"missing, 3",result:(success 3)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"missing, 3",result:(success 3)}, compileOption: LEGACY -- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"null, null, 3",result:(success 3)}, compileOption: LEGACY -- coalesce valid cases{args:"null, missing, 3",result:(success 3)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"null, missing, 3",result:(success 3)}, compileOption: LEGACY -- coalesce valid cases{args:"null, missing, null, null, missing, 9, 4, 5, 6",result:(success 9)}, compileOption: PERMISSIVE -- coalesce valid cases{args:"null, missing, null, null, missing, 9, 4, 5, 6",result:(success 9)}, compileOption: LEGACY -- Empty Symbol in table, compileOption: LEGACY -- Empty Symbol in globals, compileOption: LEGACY -- Empty Symbol in alias, compileOption: LEGACY -- functionCall, compileOption: PERMISSIVE -- functionCall, compileOption: LEGACY -- division with mixed StaticType, compileOption: PERMISSIVE -- division with mixed StaticType, compileOption: LEGACY -- Example 6 — Value Coercion; Coercion of single value, compileOption: LEGACY -- undefinedUnqualifiedVariableWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE -- undefinedUnqualifiedVariableIsNullExprWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE -- undefinedUnqualifiedVariableIsMissingExprWithUndefinedVariableBehaviorMissing, compileOption: PERMISSIVE -- undefinedUnqualifiedVariableInSelectWithUndefinedVariableBehaviorMissing, compileOption: LEGACY -- join on column - all column values non-null, compileOption: PERMISSIVE -- join on column - all column values non-null, compileOption: LEGACY -- join on column - some column values are null, compileOption: PERMISSIVE -- join on column - some column values are null, compileOption: LEGACY -- join on column - 1 table contains 1 row with the value null, compileOption: PERMISSIVE -- join on column - 1 table contains 1 row with the value null, compileOption: LEGACY -- join on column - ON condition = false, compileOption: PERMISSIVE -- join on column - ON condition = false, compileOption: LEGACY -- PG_JOIN_01, compileOption: PERMISSIVE -- PG_JOIN_01, compileOption: LEGACY -- PG_JOIN_02, compileOption: PERMISSIVE -- PG_JOIN_02, compileOption: LEGACY -- PG_JOIN_03, compileOption: PERMISSIVE -- PG_JOIN_03, compileOption: LEGACY -- PG_JOIN_06, compileOption: PERMISSIVE -- PG_JOIN_06, compileOption: LEGACY -- PG_JOIN_07, compileOption: PERMISSIVE -- PG_JOIN_07, compileOption: LEGACY -- PG_JOIN_08, compileOption: PERMISSIVE -- PG_JOIN_08, compileOption: LEGACY -- PG_JOIN_09, compileOption: PERMISSIVE -- PG_JOIN_09, compileOption: LEGACY -- PG_JOIN_10, compileOption: PERMISSIVE -- PG_JOIN_10, compileOption: LEGACY -- offset 0, compileOption: PERMISSIVE -- offset 0, compileOption: LEGACY -- offset 1, compileOption: PERMISSIVE -- offset 1, compileOption: LEGACY -- offset 2, compileOption: PERMISSIVE -- offset 2, compileOption: LEGACY -- limit 1 offset 1, compileOption: PERMISSIVE -- limit 1 offset 1, compileOption: LEGACY -- limit 10 offset 1, compileOption: PERMISSIVE -- limit 10 offset 1, compileOption: LEGACY -- limit 2 offset 2, compileOption: PERMISSIVE -- limit 2 offset 2, compileOption: LEGACY -- limit offset after group by, compileOption: PERMISSIVE -- limit offset after group by, compileOption: LEGACY -- offset 2-1, compileOption: PERMISSIVE -- offset 2-1, compileOption: LEGACY -- offset 2+1, compileOption: PERMISSIVE -- offset 2+1, compileOption: LEGACY -- offset 2*1, compileOption: PERMISSIVE -- offset 2*1, compileOption: LEGACY -- offset 2/1, compileOption: PERMISSIVE -- offset 2/1, compileOption: LEGACY -- offset group by having, compileOption: PERMISSIVE -- offset group by having, compileOption: LEGACY -- offset with pivot, compileOption: PERMISSIVE -- offset with pivot, compileOption: LEGACY -- pivotBadFieldType, compileOption: LEGACY -- col1 asc, compileOption: PERMISSIVE -- col1 asc, compileOption: LEGACY -- col1 desc, compileOption: PERMISSIVE -- col1 desc, compileOption: LEGACY -- col1 asc, col2 asc, compileOption: PERMISSIVE -- col1 asc, col2 asc, compileOption: LEGACY -- price desc, productId asc, compileOption: PERMISSIVE -- price desc, productId asc, compileOption: LEGACY -- supplierId_nulls nulls last, compileOption: PERMISSIVE -- supplierId_nulls nulls last, compileOption: LEGACY -- supplierId_nulls nulls first, compileOption: PERMISSIVE -- supplierId_nulls nulls first, compileOption: LEGACY -- supplierId_nulls asc nulls last, productId asc, compileOption: PERMISSIVE -- supplierId_nulls asc nulls last, productId asc, compileOption: LEGACY -- nulls first as default for supplierId_nulls desc, compileOption: PERMISSIVE -- nulls first as default for supplierId_nulls desc, compileOption: LEGACY -- group and order by asc sellerId, compileOption: PERMISSIVE -- group and order by asc sellerId, compileOption: LEGACY -- group and order by desc sellerId, compileOption: PERMISSIVE -- group and order by desc sellerId, compileOption: LEGACY -- group and order by DESC (NULLS FIRST as default), compileOption: PERMISSIVE -- group and order by DESC (NULLS FIRST as default), compileOption: LEGACY -- group and order by ASC (NULLS LAST as default), compileOption: PERMISSIVE -- group and order by ASC (NULLS LAST as default), compileOption: LEGACY -- group and place nulls first (asc as default), compileOption: PERMISSIVE -- group and place nulls first (asc as default), compileOption: LEGACY -- group and place nulls last (asc as default), compileOption: PERMISSIVE -- group and place nulls last (asc as default), compileOption: LEGACY -- group and order by asc and place nulls first, compileOption: PERMISSIVE -- group and order by asc and place nulls first, compileOption: LEGACY -- false before true (ASC), compileOption: PERMISSIVE -- false before true (ASC), compileOption: LEGACY -- true before false (DESC), compileOption: PERMISSIVE -- true before false (DESC), compileOption: LEGACY -- nan before -inf, then numeric values then +inf (ASC), compileOption: PERMISSIVE -- nan before -inf, then numeric values then +inf (ASC), compileOption: LEGACY -- +inf before numeric values then -inf then nan (DESC), compileOption: PERMISSIVE -- +inf before numeric values then -inf then nan (DESC), compileOption: LEGACY -- LOB types follow their lexicographical ordering by octet (ASC), compileOption: PERMISSIVE -- LOB types follow their lexicographical ordering by octet (ASC), compileOption: LEGACY -- LOB types should ordered (DESC), compileOption: PERMISSIVE -- LOB types should ordered (DESC), compileOption: LEGACY -- shorter array comes first (ASC), compileOption: PERMISSIVE -- shorter array comes first (ASC), compileOption: LEGACY -- longer array comes first (DESC), compileOption: PERMISSIVE -- longer array comes first (DESC), compileOption: LEGACY -- lists compared lexicographically based on comparison of elements (ASC), compileOption: PERMISSIVE -- lists compared lexicographically based on comparison of elements (ASC), compileOption: LEGACY -- lists compared lexicographically based on comparison of elements (DESC), compileOption: PERMISSIVE -- lists compared lexicographically based on comparison of elements (DESC), compileOption: LEGACY -- lists items should be ordered by data types (ASC) (nulls last as default for asc), compileOption: PERMISSIVE -- lists items should be ordered by data types (ASC) (nulls last as default for asc), compileOption: LEGACY -- lists items should be ordered by data types (DESC) (nulls first as default for desc), compileOption: PERMISSIVE -- lists items should be ordered by data types (DESC) (nulls first as default for desc), compileOption: LEGACY -- structs compared lexicographically first by key then by value (ASC), compileOption: PERMISSIVE -- structs compared lexicographically first by key then by value (ASC), compileOption: LEGACY -- structs compared lexicographically first by key then by value (DESC), compileOption: PERMISSIVE -- structs compared lexicographically first by key then by value (DESC), compileOption: LEGACY -- structs should be ordered by data types (ASC) (nulls last as default for asc), compileOption: PERMISSIVE -- structs should be ordered by data types (ASC) (nulls last as default for asc), compileOption: LEGACY -- structs should be ordered by data types (DESC) (nulls first as default for desc), compileOption: PERMISSIVE -- structs should be ordered by data types (DESC) (nulls first as default for desc), compileOption: LEGACY -- bags compared as sorted lists (ASC), compileOption: PERMISSIVE -- bags compared as sorted lists (ASC), compileOption: LEGACY -- bags compared as sorted lists (DESC), compileOption: PERMISSIVE -- bags compared as sorted lists (DESC), compileOption: LEGACY -- testing alias support, compileOption: PERMISSIVE -- testing alias support, compileOption: LEGACY -- testing nested alias support, compileOption: PERMISSIVE -- testing nested alias support, compileOption: LEGACY -- Empty Output (ordered), compileOption: PERMISSIVE -- Empty Output (ordered), compileOption: LEGACY -- GROUP BY binding referenced in FROM clause, compileOption: PERMISSIVE -- GROUP BY binding referenced in WHERE clause, compileOption: PERMISSIVE -- GROUP AS binding referenced in FROM clause, compileOption: PERMISSIVE -- GROUP AS binding referenced in WHERE clause, compileOption: PERMISSIVE -- SELECT COUNT(1) AS the_count, COUNT(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, SUM(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, MIN(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, MAX(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, AVG(p.price_missings) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, COUNT(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, SUM(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, MIN(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, MAX(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT COUNT(1) AS the_count, AVG(p.price_mixed) AS the_agg FROM products_sparse AS p, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, COUNT(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, SUM(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, MIN(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, MAX(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, AVG(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, COUNT(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, SUM(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, MIN(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, MAX(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT categoryId, COUNT(1) AS the_count, AVG(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, COUNT(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, SUM(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, MIN(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, MAX(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, AVG(p.price_missings) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, COUNT(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, SUM(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, MIN(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, MAX(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- SELECT p.categoryId, COUNT(1) AS the_count, AVG(p.price_mixed) AS the_agg FROM products_sparse AS p GROUP BY p.categoryId, compileOption: LEGACY -- Expression with multiple subqueriees containing aggregates : CAST((SELECT COUNT(1) FROM products) AS LIST)[0]._1 / CAST((SELECT COUNT(1) FROM suppliers) AS LIST)[0]._1, compileOption: PERMISSIVE -- Expression with multiple subqueriees containing aggregates : CAST((SELECT COUNT(1) FROM products) AS LIST)[0]._1 / CAST((SELECT COUNT(1) FROM suppliers) AS LIST)[0]._1, compileOption: LEGACY -- Aggregates with subquery containing another aggregate : SELECT COUNT(1) + CAST((SELECT SUM(numInStock) FROM products) AS LIST)[0]._1 as a_number FROM products, compileOption: PERMISSIVE -- Aggregates with subquery containing another aggregate : SELECT COUNT(1) + CAST((SELECT SUM(numInStock) FROM products) AS LIST)[0]._1 as a_number FROM products, compileOption: LEGACY -- GROUP BY with JOIN : SELECT supplierName, COUNT(*) as the_count FROM suppliers AS s INNER JOIN products AS p ON s.supplierId = p.supplierId GROUP BY supplierName, compileOption: PERMISSIVE -- GROUP BY with JOIN : SELECT supplierName, COUNT(*) as the_count FROM suppliers AS s INNER JOIN products AS p ON s.supplierId = p.supplierId GROUP BY supplierName, compileOption: LEGACY -- SELECT VALUE with nested aggregates : SELECT VALUE (SELECT SUM(outerFromSource.col1) AS the_sum FROM <<1>>) FROM simple_1_col_1_group as outerFromSource, compileOption: PERMISSIVE -- SELECT VALUE with nested aggregates : SELECT VALUE (SELECT SUM(outerFromSource.col1) AS the_sum FROM <<1>>) FROM simple_1_col_1_group as outerFromSource, compileOption: LEGACY -- SELECT col1, g FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE -- SELECT col1, g FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: LEGACY -- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE -- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, join_me GROUP BY col1 GROUP AS g, compileOption: LEGACY -- SELECT col1, g FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE -- SELECT col1, g FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: LEGACY -- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: PERMISSIVE -- SELECT VALUE { 'col1': col1, 'g': g } FROM simple_1_col_1_group, different_types_per_row GROUP BY col1 GROUP AS g, compileOption: LEGACY -- MYSQL_SELECT_20, compileOption: PERMISSIVE -- MYSQL_SELECT_20, compileOption: LEGACY -- MYSQL_SELECT_21, compileOption: PERMISSIVE -- MYSQL_SELECT_21, compileOption: LEGACY -- MYSQL_SELECT_23, compileOption: PERMISSIVE -- MYSQL_SELECT_23, compileOption: LEGACY -- MYSQL_SELECT_26, compileOption: PERMISSIVE -- MYSQL_SELECT_26, compileOption: LEGACY -- selectFromScalarAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE -- selectFromScalarAndAtUnpivotWildCardOverScalar, compileOption: LEGACY -- selectFromListAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE -- selectFromListAndAtUnpivotWildCardOverScalar, compileOption: LEGACY -- selectFromBagAndAtUnpivotWildCardOverScalar, compileOption: PERMISSIVE -- selectFromBagAndAtUnpivotWildCardOverScalar, compileOption: LEGACY -- selectPathUnpivotWildCardOverStructMultiple, compileOption: PERMISSIVE -- selectPathUnpivotWildCardOverStructMultiple, compileOption: LEGACY -- selectStarSingleSourceHoisted, compileOption: PERMISSIVE -- selectStarSingleSourceHoisted, compileOption: LEGACY -- ordinalAccessWithNegativeIndex, compileOption: LEGACY -- ordinalAccessWithNegativeIndexAndBindings, compileOption: LEGACY -- rangeOverScalar, compileOption: LEGACY -- rangeTwiceOverScalar, compileOption: LEGACY -- rangeOverSexp, compileOption: PERMISSIVE -- rangeOverSexp, compileOption: LEGACY -- rangeOverStruct, compileOption: LEGACY -- rangeOverBagWithAt, compileOption: LEGACY -- rangeOverNestedWithAt, compileOption: LEGACY -- avg group by{agg:'AVG(t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: PERMISSIVE -- avg group by{agg:'AVG(t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: LEGACY -- avg group by{agg:'AVG(ALL t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: PERMISSIVE -- avg group by{agg:'AVG(ALL t.b)',expectedF1:1.25,expectedF2:3.}, compileOption: LEGACY -- avg group by{agg:'AVG(DISTINCT t.b)',expectedF1:1.5,expectedF2:3.}, compileOption: PERMISSIVE -- avg group by{agg:'AVG(DISTINCT t.b)',expectedF1:1.5,expectedF2:3.}, compileOption: LEGACY -- ANY with GROUP BY, compileOption: LEGACY -- ANY DISTINCT with GROUP BY, compileOption: LEGACY -- SOME with GROUP BY, compileOption: LEGACY -- SOME DISTINCT with GROUP BY, compileOption: LEGACY -- EVERY with GROUP BY, compileOption: LEGACY -- EVERY DISTINCT with GROUP BY, compileOption: LEGACY -- selectListMultipleAggregatesNestedQuery, compileOption: PERMISSIVE -- selectListMultipleAggregatesNestedQuery, compileOption: LEGACY -- undefinedUnqualifiedVariable_inSelect_withProjectionOption, compileOption: LEGACY -- projectionIterationBehaviorUnfiltered_select_star, compileOption: PERMISSIVE -- projectionIterationBehaviorUnfiltered_select_star, compileOption: LEGACY -- projectOfSexp, compileOption: PERMISSIVE -- projectOfSexp, compileOption: LEGACY -- projectOfUnpivotPath, compileOption: LEGACY -- alias1.alias2.*, compileOption: LEGACY -- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: PERMISSIVE -- selectImplicitAndExplicitAliasSingleSourceHoisted, compileOption: LEGACY -- selectListWithMissing, compileOption: LEGACY -- selectCorrelatedJoin, compileOption: PERMISSIVE -- selectCorrelatedJoin, compileOption: LEGACY -- selectCorrelatedLeftJoin, compileOption: PERMISSIVE -- selectCorrelatedLeftJoin, compileOption: LEGACY -- selectCorrelatedLeftJoinOnClause, compileOption: PERMISSIVE -- selectCorrelatedLeftJoinOnClause, compileOption: LEGACY -- selectJoinOnClauseScoping, compileOption: PERMISSIVE -- selectJoinOnClauseScoping, compileOption: LEGACY -- selectNonCorrelatedJoin, compileOption: LEGACY -- correlatedJoinWithShadowedAttributes, compileOption: LEGACY -- correlatedJoinWithoutLexicalScope, compileOption: LEGACY -- joinWithShadowedGlobal, compileOption: LEGACY -- selectDistinctStarBags, compileOption: PERMISSIVE -- selectDistinctStarBags, compileOption: LEGACY -- variableShadow, compileOption: LEGACY -- selectValueStructConstructorWithMissing, compileOption: LEGACY -- selectIndexStruct, compileOption: PERMISSIVE -- selectIndexStruct, compileOption: LEGACY -- emptySymbol, compileOption: LEGACY -- emptySymbolInGlobals, compileOption: LEGACY -
-The following test(s) are failing in legacy but pass in eval. Before merging, confirm they are intended to pass: -
Click here to see - - -- equiv group by with aggregates, compileOption: PERMISSIVE - -- equiv group by with aggregates, compileOption: LEGACY - -- missing and true, compileOption: PERMISSIVE - -- coll_count with result of subquery, compileOption: PERMISSIVE - -- coll_count with result of subquery, compileOption: LEGACY - -- outerUnionAll, compileOption: PERMISSIVE - -- outerUnionAll, compileOption: LEGACY - -- outerExceptDistinct, compileOption: PERMISSIVE - -- outerExceptDistinct, compileOption: LEGACY - -- outerUnionCoerceList, compileOption: PERMISSIVE - -- outerUnionCoerceList, compileOption: LEGACY - -- max top level{agg:'COLL_MAX(data)',result:(success 2)}, compileOption: PERMISSIVE - -- max top level{agg:'COLL_MAX(data)',result:(success 2)}, compileOption: LEGACY - -- topLevelCollMax, compileOption: PERMISSIVE - -- topLevelCollMax, compileOption: LEGACY - -- COLL_MAX empty collection, compileOption: PERMISSIVE - -- COLL_MAX empty collection, compileOption: LEGACY - -- COLL_MAX null, compileOption: PERMISSIVE - -- COLL_MAX null, compileOption: LEGACY - -- COLL_MAX list of missing element, compileOption: PERMISSIVE - -- COLL_MAX list of missing element, compileOption: LEGACY - -- COLL_MAX bag of missing elements, compileOption: PERMISSIVE - -- COLL_MAX bag of missing elements, compileOption: LEGACY - -- COLL_MAX bag of heterogeneous element types, compileOption: PERMISSIVE - -- COLL_MAX bag of heterogeneous element types, compileOption: LEGACY - -- coll_avg top level{agg:'COLL_AVG(data)',result:(success 1.25)}, compileOption: PERMISSIVE - -- coll_avg top level{agg:'COLL_AVG(data)',result:(success 1.25)}, compileOption: LEGACY - -- topLevelCollAvg, compileOption: PERMISSIVE - -- topLevelCollAvg, compileOption: LEGACY - -- topLevelCollAvgOnlyInt, compileOption: PERMISSIVE - -- topLevelCollAvgOnlyInt, compileOption: LEGACY - -- COLL_AVG empty collection, compileOption: PERMISSIVE - -- COLL_AVG empty collection, compileOption: LEGACY - -- COLL_AVG null, compileOption: PERMISSIVE - -- COLL_AVG null, compileOption: LEGACY - -- COLL_AVG list of missing element, compileOption: PERMISSIVE - -- COLL_AVG list of missing element, compileOption: LEGACY - -- COLL_AVG bag of missing elements, compileOption: PERMISSIVE - -- COLL_AVG bag of missing elements, compileOption: LEGACY - -- COLL_AVG mistyped element, compileOption: PERMISSIVE - -- coll_count top level{agg:'COLL_COUNT(data)',result:(success 4)}, compileOption: PERMISSIVE - -- coll_count top level{agg:'COLL_COUNT(data)',result:(success 4)}, compileOption: LEGACY - -- topLevelCollCount, compileOption: PERMISSIVE - -- topLevelCollCount, compileOption: LEGACY - -- COLL_COUNT empty collection, compileOption: PERMISSIVE - -- COLL_COUNT empty collection, compileOption: LEGACY - -- COLL_COUNT null, compileOption: PERMISSIVE - -- COLL_COUNT null, compileOption: LEGACY - -- COLL_COUNT list of missing element, compileOption: PERMISSIVE - -- COLL_COUNT list of missing element, compileOption: LEGACY - -- COLL_COUNT bag of missing elements, compileOption: PERMISSIVE - -- COLL_COUNT bag of missing elements, compileOption: LEGACY - -- COLL_COUNT bag of heterogeneous element types, compileOption: PERMISSIVE - -- COLL_COUNT bag of heterogeneous element types, compileOption: LEGACY - -- coll_sum top level{agg:'COLL_SUM(data)',result:(success 5)}, compileOption: PERMISSIVE - -- coll_sum top level{agg:'COLL_SUM(data)',result:(success 5)}, compileOption: LEGACY - -- topLevelCollSum, compileOption: PERMISSIVE - -- topLevelCollSum, compileOption: LEGACY - -- COLL_SUM empty collection, compileOption: PERMISSIVE - -- COLL_SUM empty collection, compileOption: LEGACY - -- COLL_SUM null, compileOption: PERMISSIVE - -- COLL_SUM null, compileOption: LEGACY - -- COLL_SUM list of missing element, compileOption: PERMISSIVE - -- COLL_SUM list of missing element, compileOption: LEGACY - -- COLL_SUM bag of missing elements, compileOption: PERMISSIVE - -- COLL_SUM bag of missing elements, compileOption: LEGACY - -- COLL_SUM mistyped element, compileOption: PERMISSIVE - -- coll_min top level{agg:'COLL_MIN(data)',result:(success 1)}, compileOption: PERMISSIVE - -- coll_min top level{agg:'COLL_MIN(data)',result:(success 1)}, compileOption: LEGACY - -- topLevelCollMin, compileOption: PERMISSIVE - -- topLevelCollMin, compileOption: LEGACY - -- COLL_MIN empty collection, compileOption: PERMISSIVE - -- COLL_MIN empty collection, compileOption: LEGACY - -- COLL_MIN null, compileOption: PERMISSIVE - -- COLL_MIN null, compileOption: LEGACY - -- COLL_MIN list of missing element, compileOption: PERMISSIVE - -- COLL_MIN list of missing element, compileOption: LEGACY - -- COLL_MIN bag of missing elements, compileOption: PERMISSIVE - -- COLL_MIN bag of missing elements, compileOption: LEGACY - -- COLL_MIN bag of heterogeneous element types, compileOption: PERMISSIVE - -- COLL_MIN bag of heterogeneous element types, compileOption: LEGACY - -- COLL_ANY bag literals, compileOption: PERMISSIVE - -- COLL_ANY bag literals, compileOption: LEGACY - -- COLL_ANY list expressions, compileOption: PERMISSIVE - -- COLL_ANY list expressions, compileOption: LEGACY - -- COLL_ANY single true, compileOption: PERMISSIVE - -- COLL_ANY single true, compileOption: LEGACY - -- COLL_ANY single false, compileOption: PERMISSIVE - -- COLL_ANY single false, compileOption: LEGACY - -- COLL_ANY nulls with true, compileOption: PERMISSIVE - -- COLL_ANY nulls with true, compileOption: LEGACY - -- COLL_ANY nulls with false, compileOption: PERMISSIVE - -- COLL_ANY nulls with false, compileOption: LEGACY - -- COLL_ANY nulls only, compileOption: PERMISSIVE - -- COLL_ANY nulls only, compileOption: LEGACY - -- COLL_ANY null, compileOption: PERMISSIVE - -- COLL_ANY null, compileOption: LEGACY - -- COLL_ANY list of missing element, compileOption: PERMISSIVE - -- COLL_ANY list of missing element, compileOption: LEGACY - -- COLL_ANY bag of missing elements, compileOption: PERMISSIVE - -- COLL_ANY bag of missing elements, compileOption: LEGACY - -- COLL_ANY some empty, compileOption: PERMISSIVE - -- COLL_ANY some empty, compileOption: LEGACY - -- COLL_ANY one non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_ANY all non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_ANY nested collection, compileOption: PERMISSIVE - -- COLL_SOME bag literals, compileOption: PERMISSIVE - -- COLL_SOME bag literals, compileOption: LEGACY - -- COLL_SOME list expressions, compileOption: PERMISSIVE - -- COLL_SOME list expressions, compileOption: LEGACY - -- COLL_SOME single true, compileOption: PERMISSIVE - -- COLL_SOME single true, compileOption: LEGACY - -- COLL_SOME single false, compileOption: PERMISSIVE - -- COLL_SOME single false, compileOption: LEGACY - -- COLL_SOME nulls with true, compileOption: PERMISSIVE - -- COLL_SOME nulls with true, compileOption: LEGACY - -- COLL_SOME nulls with false, compileOption: PERMISSIVE - -- COLL_SOME nulls with false, compileOption: LEGACY - -- COLL_SOME nulls only, compileOption: PERMISSIVE - -- COLL_SOME nulls only, compileOption: LEGACY - -- COLL_SOME null, compileOption: PERMISSIVE - -- COLL_SOME null, compileOption: LEGACY - -- COLL_SOME list of missing element, compileOption: PERMISSIVE - -- COLL_SOME list of missing element, compileOption: LEGACY - -- COLL_SOME bag of missing elements, compileOption: PERMISSIVE - -- COLL_SOME bag of missing elements, compileOption: LEGACY - -- COLL_SOME some empty, compileOption: PERMISSIVE - -- COLL_SOME some empty, compileOption: LEGACY - -- COLL_SOME one non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_SOME all non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_SOME nested collection, compileOption: PERMISSIVE - -- COLL_EVERY bag literals, compileOption: PERMISSIVE - -- COLL_EVERY bag literals, compileOption: LEGACY - -- COLL_EVERY list expressions, compileOption: PERMISSIVE - -- COLL_EVERY list expressions, compileOption: LEGACY - -- COLL_EVERY single true, compileOption: PERMISSIVE - -- COLL_EVERY single true, compileOption: LEGACY - -- COLL_EVERY single false, compileOption: PERMISSIVE - -- COLL_EVERY single false, compileOption: LEGACY - -- COLL_EVERY null and missing with true, compileOption: PERMISSIVE - -- COLL_EVERY null and missing with true, compileOption: LEGACY - -- COLL_EVERY null with false, compileOption: PERMISSIVE - -- COLL_EVERY null with false, compileOption: LEGACY - -- COLL_EVERY null and missing only, compileOption: PERMISSIVE - -- COLL_EVERY null and missing only, compileOption: LEGACY - -- COLL_EVERY null, compileOption: PERMISSIVE - -- COLL_EVERY null, compileOption: LEGACY - -- COLL_EVERY list of missing element, compileOption: PERMISSIVE - -- COLL_EVERY list of missing element, compileOption: LEGACY - -- COLL_EVERY bag of missing elements, compileOption: PERMISSIVE - -- COLL_EVERY bag of missing elements, compileOption: LEGACY - -- COLL_EVERY empty collection, compileOption: PERMISSIVE - -- COLL_EVERY empty collection, compileOption: LEGACY - -- COLL_EVERY one non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_EVERY all non-bool, non-unknown, compileOption: PERMISSIVE - -- COLL_EVERY nested collection, compileOption: PERMISSIVE - -- selectValueCollAggregate, compileOption: PERMISSIVE - -- selectValueCollAggregate, compileOption: LEGACY - -- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67Z`), compileOption: PERMISSIVE - -- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67Z`), compileOption: LEGACY - -- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: PERMISSIVE - -- EXTRACT(SECOND FROM `2000-01-02T03:04:05.67+08:09`), compileOption: LEGACY - -- Example 1 — Union of Compatible Relations, compileOption: PERMISSIVE - -- Example 1 — Union of Compatible Relations, compileOption: LEGACY - -- Example 4 — Intersection of Compatible Relations, compileOption: PERMISSIVE - -- Example 4 — Intersection of Compatible Relations, compileOption: LEGACY - -- Example 5 — Difference of Compatible Relations, compileOption: PERMISSIVE - -- Example 5 — Difference of Compatible Relations, compileOption: LEGACY - -- offset 2^63, compileOption: PERMISSIVE - -- offset 2^63, compileOption: LEGACY - -- SELECT supplierId_missings FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE - -- SELECT p.supplierId_missings FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE - -- SELECT VALUE { 'supplierId_missings' : p.supplierId_missings } FROM products_sparse p GROUP BY p.supplierId_missings, compileOption: PERMISSIVE - -- SELECT supplierId_mixed FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE - -- SELECT p.supplierId_mixed FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE - -- SELECT VALUE { 'supplierId_mixed' : p.supplierId_mixed } FROM products_sparse p GROUP BY p.supplierId_mixed, compileOption: PERMISSIVE - -- SELECT regionId, supplierId_missings FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE - -- SELECT p.regionId, p.supplierId_missings FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE - -- SELECT VALUE { 'regionId': p.regionId, 'supplierId_missings': p.supplierId_missings } FROM products_sparse p GROUP BY p.regionId, p.supplierId_missings, compileOption: PERMISSIVE - -- SELECT regionId, supplierId_mixed FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE - -- SELECT regionId, p.supplierId_mixed FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE - -- SELECT VALUE { 'regionId': p.regionId, 'supplierId_mixed': p.supplierId_mixed } FROM products_sparse p GROUP BY p.regionId, p.supplierId_mixed, compileOption: PERMISSIVE - -- SELECT with nested aggregates (complex) 2, compileOption: PERMISSIVE - -- SELECT with nested aggregates (complex) 2, compileOption: LEGACY - -
- -### Conformance comparison report-Cross Commit-LEGACY -| | Base (HEAD) | HEAD | +/- | -| --- | ---: | ---: | ---: | -| % Passing | 92.47% | 92.47% | 0.00% | -| :white_check_mark: Passing | 5380 | 5380 | 0 | -| :x: Failing | 438 | 438 | 0 | -| :large_orange_diamond: Ignored | 0 | 0 | 0 | -| Total Tests | 5818 | 5818 | 0 | -Number passing in both: 5380 - -Number failing in both: 438 - -Number passing in Base (HEAD) but now fail: 0 - -Number failing in Base (HEAD) but now pass: 0 - -### Conformance comparison report-Cross Commit-EVAL -| | Base (HEAD) | HEAD | +/- | -| --- | ---: | ---: | ---: | -| % Passing | 82.12% | 82.68% | 0.55% | -| :white_check_mark: Passing | 4778 | 4811 | 33 | -| :x: Failing | 1040 | 1008 | -32 | -| :large_orange_diamond: Ignored | 0 | 0 | 0 | -| Total Tests | 5818 | 5819 | 1 | -Number passing in both: 4776 - -Number failing in both: 1006 - -Number passing in Base (HEAD) but now fail: 2 - -Number failing in Base (HEAD) but now pass: 35 -:interrobang: CONFORMANCE REPORT REGRESSION DETECTED :interrobang:. The following test(s) were previously passing but now fail: -
Click here to see - - -- MYSQL_SELECT_23, compileOption: PERMISSIVE -- MYSQL_SELECT_23, compileOption: LEGACY -
-The following test(s) were previously failing but now pass. Before merging, confirm they are intended to pass: -
Click here to see - - -- Example 6 — Value Coercion, compileOption: PERMISSIVE - -- Example 6 — Value Coercion, compileOption: LEGACY - -- outerUnionDistinct, compileOption: PERMISSIVE - -- outerUnionDistinct, compileOption: LEGACY - -- outerUnionAll, compileOption: PERMISSIVE - -- outerUnionAll, compileOption: LEGACY - -- outerIntersectDistinct, compileOption: PERMISSIVE - -- outerIntersectDistinct, compileOption: LEGACY - -- outerIntersectAll, compileOption: PERMISSIVE - -- outerIntersectAll, compileOption: LEGACY - -- outerExceptDistinct, compileOption: PERMISSIVE - -- outerExceptDistinct, compileOption: LEGACY - -- outerExceptAll, compileOption: PERMISSIVE - -- outerExceptAll, compileOption: LEGACY - -- outerUnionCoerceScalar, compileOption: PERMISSIVE - -- outerUnionCoerceStruct, compileOption: PERMISSIVE - -- outerUnionCoerceList, compileOption: PERMISSIVE - -- outerUnionCoerceList, compileOption: LEGACY - -- Example 1 — Union of Compatible Relations, compileOption: PERMISSIVE - -- Example 1 — Union of Compatible Relations, compileOption: LEGACY - -- Example 4 — Intersection of Compatible Relations, compileOption: PERMISSIVE - -- Example 4 — Intersection of Compatible Relations, compileOption: LEGACY - -- Example 5 — Difference of Compatible Relations, compileOption: PERMISSIVE - -- Example 5 — Difference of Compatible Relations, compileOption: LEGACY - -- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: PERMISSIVE - -- Example 2.3 — Union of Compatible Relations; Mismatch Column Names; Using OUTER UNION, compileOption: LEGACY - -- Example 3 — Outer union of Heterogenous Relations, compileOption: PERMISSIVE - -- Example 3 — Outer union of Heterogenous Relations, compileOption: LEGACY - -- Example 6 — Value Coercion; Coercion of single value, compileOption: PERMISSIVE - -- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: PERMISSIVE - -- Example 7 — `SELECT * FROM engineering.employees OUTER EXCEPT << >>`, compileOption: LEGACY - -- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: PERMISSIVE - -- Example 7 — `engineering.employees OUTER UNION << MISSING >>`, compileOption: LEGACY - -- Example 7 — result is the empty bag, compileOption: PERMISSIVE - -- Example 7 — result is the empty bag, compileOption: LEGACY - -
- From 48747fff992bdca6f5dae1cf8a3ff98ec68bedf1 Mon Sep 17 00:00:00 2001 From: John Ed Quinn <40360967+johnedquinn@users.noreply.github.com> Date: Thu, 18 Apr 2024 11:40:57 -0700 Subject: [PATCH 06/12] Simplify loading of data Co-authored-by: R. C. Howell --- .../org/partiql/eval/internal/operator/rel/RelExceptAll.kt | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt index d585881401..5e7d8d0fce 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt @@ -48,9 +48,8 @@ internal class RelExceptAll( private fun seed() { init = true for (row in rhs) { - seen.computeIfPresent(row) { _, y -> - y + 1 - } ?: seen.put(row, 1) + val n = seen[row] ?: 0; + seen[row] = n + 1; } } } From e85ec70664c9aea0428e2839a9c6a0da0f13323f Mon Sep 17 00:00:00 2001 From: John Ed Quinn Date: Thu, 18 Apr 2024 11:51:57 -0700 Subject: [PATCH 07/12] Simplifies data comparison logic --- .../eval/internal/operator/rel/RelExceptAll.kt | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt index 5e7d8d0fce..793899e6ef 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt @@ -25,12 +25,12 @@ internal class RelExceptAll( seed() } for (row in lhs) { - seen.computeIfPresent(row) { _, y -> - when (y) { - 0 -> null - else -> y - 1 - } - } ?: return row + val remaining = seen[row] ?: 0 + if (remaining > 0) { + seen[row] = remaining - 1 + continue + } + return row } return null } @@ -43,7 +43,7 @@ internal class RelExceptAll( } /** - * Read the entire left-hand-side into our search structure. + * Read the entire right-hand-side into our search structure. */ private fun seed() { init = true From 7589aaefd2a8fbde5a5ca89130c3a4fbe0335c11 Mon Sep 17 00:00:00 2001 From: John Ed Quinn Date: Thu, 18 Apr 2024 12:15:45 -0700 Subject: [PATCH 08/12] Consolidates logic by extracting IteratorPeeking out of RelPeeking --- .../eval/internal/helpers/IteratorChain.kt | 32 ++++++++--------- .../eval/internal/helpers/IteratorPeeking.kt | 36 +++++++++++++++++++ .../internal/operator/rel/RelExceptAll.kt | 4 +-- .../eval/internal/operator/rel/RelPeeking.kt | 26 ++------------ .../internal/operator/rel/RelUnionDistinct.kt | 2 +- 5 files changed, 56 insertions(+), 44 deletions(-) create mode 100644 partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorChain.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorChain.kt index 72b10d53e4..55a2c832e8 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorChain.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorChain.kt @@ -1,29 +1,27 @@ package org.partiql.eval.internal.helpers -/** - * WARNING: You must invoke [hasNext] before calling [next]. - */ internal class IteratorChain( - iterators: Iterable> -) : Iterator { + iterators: Array> +) : IteratorPeeking() { - private var iterator = iterators.iterator() - private var current = iterator.next() + private var iterator: Iterator> = when (iterators.isEmpty()) { + true -> listOf(emptyList().iterator()).iterator() + false -> iterators.iterator() + } + private var current: Iterator = iterator.next() - override fun hasNext(): Boolean { + override fun peek(): T? { return when (current.hasNext()) { - true -> true + true -> current.next() false -> { - if (!iterator.hasNext()) { - return false + while (iterator.hasNext()) { + current = iterator.next() + if (current.hasNext()) { + return current.next() + } } - current = iterator.next() - current.hasNext() + return null } } } - - override fun next(): T { - return current.next() - } } diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt new file mode 100644 index 0000000000..034a698e04 --- /dev/null +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt @@ -0,0 +1,36 @@ +package org.partiql.eval.internal.helpers + +/** + * For [Iterator]s that MUST materialize data in order to execute [hasNext], this abstract class caches the + * result of [peek] to implement both [hasNext] and [next]. + * + * With this implementation, invoking hasNext() multiple times will not iterate unnecessarily. Invoking next() without + * invoking hasNext() is allowed -- however, it is highly recommended to avoid doing so. + */ +abstract class IteratorPeeking : Iterator { + + private var _next: T? = null + + /** + * @return NULL when there is not another [T] to be produced. Returns a [T] when able to. + * + * @see IteratorPeeking + */ + abstract fun peek(): T? + + override fun hasNext(): Boolean { + if (_next != null) { + return true + } + this._next = peek() + return this._next != null + } + + override fun next(): T { + val next = _next + ?: peek() + ?: error("There was no more elements, however, next() was called. Please use hasNext() beforehand.") + this._next = null + return next + } +} diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt index 793899e6ef..5920a8ea61 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt @@ -48,8 +48,8 @@ internal class RelExceptAll( private fun seed() { init = true for (row in rhs) { - val n = seen[row] ?: 0; - seen[row] = n + 1; + val n = seen[row] ?: 0 + seen[row] = n + 1 } } } diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelPeeking.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelPeeking.kt index b8fd37685b..f78eaa96c7 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelPeeking.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelPeeking.kt @@ -2,43 +2,21 @@ package org.partiql.eval.internal.operator.rel import org.partiql.eval.internal.Environment import org.partiql.eval.internal.Record +import org.partiql.eval.internal.helpers.IteratorPeeking import org.partiql.eval.internal.operator.Operator /** * For [Operator.Relation]'s that MUST materialize data in order to execute [hasNext], this abstract class caches the * result of [peek] to implement both [hasNext] and [next]. */ -internal abstract class RelPeeking : Operator.Relation { +internal abstract class RelPeeking : Operator.Relation, IteratorPeeking() { private var _next: Record? = null - /** - * @return Null when there is not another record to be produced. Returns a [Record] when able to. - * - * @see RelPeeking - */ - abstract fun peek(): Record? - override fun open(env: Environment) { _next = null } - override fun hasNext(): Boolean { - if (_next != null) { - return true - } - this._next = peek() - return this._next != null - } - - override fun next(): Record { - val next = _next - ?: peek() - ?: error("There was not a record to be produced, however, next() was called. Please use hasNext() beforehand.") - this._next = null - return next - } - override fun close() { _next = null } diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt index 6321955d43..ca4f8366d0 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt @@ -17,7 +17,7 @@ internal class RelUnionDistinct( lhs.open(env) rhs.open(env) seen.clear() - input = IteratorChain(listOf(lhs, rhs)) + input = IteratorChain(arrayOf(lhs, rhs)) super.open(env) } From 7de7f44cf8a20276c129c7a01c0bd1b9d104420f Mon Sep 17 00:00:00 2001 From: John Ed Quinn Date: Thu, 18 Apr 2024 14:41:10 -0700 Subject: [PATCH 09/12] Updates modeling of set operations in plan --- .../org/partiql/eval/internal/Compiler.kt | 30 +++-- .../src/main/resources/partiql_plan.ion | 35 ++++-- .../org/partiql/planner/internal/ir/Nodes.kt | 97 +++++++++++---- .../internal/transforms/PlanTransform.kt | 28 +++-- .../internal/transforms/RelConverter.kt | 26 ++-- .../internal/transforms/RexConverter.kt | 23 ++-- .../planner/internal/typer/PlanTyper.kt | 114 +++++++++++++----- .../main/resources/partiql_plan_internal.ion | 52 +++++--- 8 files changed, 266 insertions(+), 139 deletions(-) diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/Compiler.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/Compiler.kt index eb1601bc56..ae2950342a 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/Compiler.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/Compiler.kt @@ -314,16 +314,30 @@ internal class Compiler( } } - override fun visitRelOpSet(node: Rel.Op.Set, ctx: StaticType?): Operator { + override fun visitRelOpSetExcept(node: Rel.Op.Set.Except, ctx: StaticType?): Operator { val lhs = visitRel(node.lhs, ctx) val rhs = visitRel(node.rhs, ctx) - return when (node.type) { - Rel.Op.Set.Type.UNION_ALL -> RelUnionAll(lhs, rhs) - Rel.Op.Set.Type.UNION_DISTINCT -> RelUnionDistinct(lhs, rhs) - Rel.Op.Set.Type.INTERSECT_ALL -> RelIntersectAll(lhs, rhs) - Rel.Op.Set.Type.INTERSECT_DISTINCT -> RelIntersectDistinct(lhs, rhs) - Rel.Op.Set.Type.EXCEPT_ALL -> RelExceptAll(lhs, rhs) - Rel.Op.Set.Type.EXCEPT_DISTINCT -> RelExceptDistinct(lhs, rhs) + return when (node.quantifier) { + Rel.Op.Set.Quantifier.ALL -> RelExceptAll(lhs, rhs) + Rel.Op.Set.Quantifier.DISTINCT -> RelExceptDistinct(lhs, rhs) + } + } + + override fun visitRelOpSetIntersect(node: Rel.Op.Set.Intersect, ctx: StaticType?): Operator { + val lhs = visitRel(node.lhs, ctx) + val rhs = visitRel(node.rhs, ctx) + return when (node.quantifier) { + Rel.Op.Set.Quantifier.ALL -> RelIntersectAll(lhs, rhs) + Rel.Op.Set.Quantifier.DISTINCT -> RelIntersectDistinct(lhs, rhs) + } + } + + override fun visitRelOpSetUnion(node: Rel.Op.Set.Union, ctx: StaticType?): Operator { + val lhs = visitRel(node.lhs, ctx) + val rhs = visitRel(node.rhs, ctx) + return when (node.quantifier) { + Rel.Op.Set.Quantifier.ALL -> RelUnionAll(lhs, rhs) + Rel.Op.Set.Quantifier.DISTINCT -> RelUnionDistinct(lhs, rhs) } } diff --git a/partiql-plan/src/main/resources/partiql_plan.ion b/partiql-plan/src/main/resources/partiql_plan.ion index 2218a08a07..cf723fce0b 100644 --- a/partiql-plan/src/main/resources/partiql_plan.ion +++ b/partiql-plan/src/main/resources/partiql_plan.ion @@ -261,20 +261,29 @@ rel::{ ], }, - // From Substrait: "The set operation encompasses several set-level operations that support combining datasets, ... - // possibly excluding records based on various types of record level matching." - set::{ - lhs: rel, - rhs: rel, - type: [ - UNION_ALL, - UNION_DISTINCT, - INTERSECT_ALL, - INTERSECT_DISTINCT, - EXCEPT_ALL, - EXCEPT_DISTINCT + set::[ + union::{ + quantifier: quantifier, + lhs: rel, + rhs: rel, + }, + + intersect::{ + quantifier: quantifier, + lhs: rel, + rhs: rel, + }, + + except::{ + quantifier: quantifier, + lhs: rel, + rhs: rel, + }, + + _::[ + quantifier::[ ALL, DISTINCT ], ] - }, + ], limit::{ input: rel, diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/ir/Nodes.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/ir/Nodes.kt index 686a6ddec3..370ad08e8f 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/ir/Nodes.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/ir/Nodes.kt @@ -35,7 +35,9 @@ import org.partiql.planner.internal.ir.builder.RelOpOffsetBuilder import org.partiql.planner.internal.ir.builder.RelOpProjectBuilder import org.partiql.planner.internal.ir.builder.RelOpScanBuilder import org.partiql.planner.internal.ir.builder.RelOpScanIndexedBuilder -import org.partiql.planner.internal.ir.builder.RelOpSetBuilder +import org.partiql.planner.internal.ir.builder.RelOpSetExceptBuilder +import org.partiql.planner.internal.ir.builder.RelOpSetIntersectBuilder +import org.partiql.planner.internal.ir.builder.RelOpSetUnionBuilder import org.partiql.planner.internal.ir.builder.RelOpSortBuilder import org.partiql.planner.internal.ir.builder.RelOpSortSpecBuilder import org.partiql.planner.internal.ir.builder.RelOpUnpivotBuilder @@ -1016,35 +1018,82 @@ internal data class Rel( internal fun builder(): RelOpSortBuilder = RelOpSortBuilder() } } + internal sealed class Set : Op() { - internal data class Set( - @JvmField internal val lhs: Rel, - @JvmField internal val rhs: Rel, - @JvmField internal val type: Type, - @JvmField internal val isOuter: Boolean - ) : Op() { - public override val children: List by lazy { - val kids = mutableListOf() - kids.add(lhs) - kids.add(rhs) - kids.filterNotNull() + public override fun accept(visitor: PlanVisitor, ctx: C): R = when (this) { + is Union -> visitor.visitRelOpSetUnion(this, ctx) + is Intersect -> visitor.visitRelOpSetIntersect(this, ctx) + is Except -> visitor.visitRelOpSetExcept(this, ctx) } - public override fun accept(visitor: PlanVisitor, ctx: C): R = - visitor.visitRelOpSet(this, ctx) + internal data class Union( + @JvmField internal val quantifier: Quantifier, + @JvmField internal val lhs: Rel, + @JvmField internal val rhs: Rel, + @JvmField internal val isOuter: Boolean, + ) : Set() { + public override val children: List by lazy { + val kids = mutableListOf() + kids.add(lhs) + kids.add(rhs) + kids.filterNotNull() + } - internal companion object { - @JvmStatic - internal fun builder(): RelOpSetBuilder = RelOpSetBuilder() + public override fun accept(visitor: PlanVisitor, ctx: C): R = + visitor.visitRelOpSetUnion(this, ctx) + + internal companion object { + @JvmStatic + internal fun builder(): RelOpSetUnionBuilder = RelOpSetUnionBuilder() + } } - internal enum class Type { - UNION_ALL, - UNION_DISTINCT, - INTERSECT_ALL, - INTERSECT_DISTINCT, - EXCEPT_ALL, - EXCEPT_DISTINCT + internal data class Intersect( + @JvmField internal val quantifier: Quantifier, + @JvmField internal val lhs: Rel, + @JvmField internal val rhs: Rel, + @JvmField internal val isOuter: Boolean, + ) : Set() { + public override val children: List by lazy { + val kids = mutableListOf() + kids.add(lhs) + kids.add(rhs) + kids.filterNotNull() + } + + public override fun accept(visitor: PlanVisitor, ctx: C): R = + visitor.visitRelOpSetIntersect(this, ctx) + + internal companion object { + @JvmStatic + internal fun builder(): RelOpSetIntersectBuilder = RelOpSetIntersectBuilder() + } + } + + internal data class Except( + @JvmField internal val quantifier: Quantifier, + @JvmField internal val lhs: Rel, + @JvmField internal val rhs: Rel, + @JvmField internal val isOuter: Boolean, + ) : Set() { + public override val children: List by lazy { + val kids = mutableListOf() + kids.add(lhs) + kids.add(rhs) + kids.filterNotNull() + } + + public override fun accept(visitor: PlanVisitor, ctx: C): R = + visitor.visitRelOpSetExcept(this, ctx) + + internal companion object { + @JvmStatic + internal fun builder(): RelOpSetExceptBuilder = RelOpSetExceptBuilder() + } + } + + internal enum class Quantifier { + ALL, DISTINCT } } diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/PlanTransform.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/PlanTransform.kt index 442014214b..0d0c7de206 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/PlanTransform.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/PlanTransform.kt @@ -328,19 +328,29 @@ internal class PlanTransform( } ) - override fun visitRelOpSet(node: Rel.Op.Set, ctx: Unit) = org.partiql.plan.Rel.Op.Set( + override fun visitRelOpSetExcept(node: Rel.Op.Set.Except, ctx: Unit) = org.partiql.plan.Rel.Op.Set.Except( lhs = visitRel(node.lhs, ctx), rhs = visitRel(node.rhs, ctx), - type = when (node.type) { - Rel.Op.Set.Type.UNION_ALL -> org.partiql.plan.Rel.Op.Set.Type.UNION_ALL - Rel.Op.Set.Type.UNION_DISTINCT -> org.partiql.plan.Rel.Op.Set.Type.UNION_DISTINCT - Rel.Op.Set.Type.EXCEPT_ALL -> org.partiql.plan.Rel.Op.Set.Type.EXCEPT_ALL - Rel.Op.Set.Type.EXCEPT_DISTINCT -> org.partiql.plan.Rel.Op.Set.Type.EXCEPT_DISTINCT - Rel.Op.Set.Type.INTERSECT_ALL -> org.partiql.plan.Rel.Op.Set.Type.INTERSECT_ALL - Rel.Op.Set.Type.INTERSECT_DISTINCT -> org.partiql.plan.Rel.Op.Set.Type.INTERSECT_DISTINCT - } + quantifier = visitRelOpSetQuantifier(node.quantifier) + ) + + override fun visitRelOpSetIntersect(node: Rel.Op.Set.Intersect, ctx: Unit) = org.partiql.plan.Rel.Op.Set.Intersect( + lhs = visitRel(node.lhs, ctx), + rhs = visitRel(node.rhs, ctx), + quantifier = visitRelOpSetQuantifier(node.quantifier) ) + override fun visitRelOpSetUnion(node: Rel.Op.Set.Union, ctx: Unit) = org.partiql.plan.Rel.Op.Set.Union( + lhs = visitRel(node.lhs, ctx), + rhs = visitRel(node.rhs, ctx), + quantifier = visitRelOpSetQuantifier(node.quantifier) + ) + + private fun visitRelOpSetQuantifier(node: Rel.Op.Set.Quantifier) = when (node) { + Rel.Op.Set.Quantifier.ALL -> org.partiql.plan.Rel.Op.Set.Quantifier.ALL + Rel.Op.Set.Quantifier.DISTINCT -> org.partiql.plan.Rel.Op.Set.Quantifier.DISTINCT + } + override fun visitRelOpLimit(node: Rel.Op.Limit, ctx: Unit) = org.partiql.plan.Rel.Op.Limit( input = visitRel(node.input, ctx), limit = visitRex(node.limit, ctx), diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RelConverter.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RelConverter.kt index 987ab02698..21259c3bed 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RelConverter.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RelConverter.kt @@ -432,9 +432,6 @@ internal object RelConverter { /** * Append SQL set operator if present - * - * TODO combine/compare schemas - * TODO set quantifier */ private fun convertSetOp(input: Rel, setOp: Expr.SFW.SetOp?): Rel { if (setOp == null) { @@ -443,22 +440,15 @@ internal object RelConverter { val type = input.type.copy(props = emptySet()) val lhs = input val rhs = visitExprSFW(setOp.operand, nil) - - val setType = when (setOp.type.type) { - SetOp.Type.UNION -> when (setOp.type.setq) { - SetQuantifier.ALL -> Rel.Op.Set.Type.UNION_ALL - null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.UNION_DISTINCT - } - SetOp.Type.EXCEPT -> when (setOp.type.setq) { - SetQuantifier.ALL -> Rel.Op.Set.Type.EXCEPT_ALL - null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.EXCEPT_DISTINCT - } - SetOp.Type.INTERSECT -> when (setOp.type.setq) { - SetQuantifier.ALL -> Rel.Op.Set.Type.INTERSECT_ALL - null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.INTERSECT_DISTINCT - } + val quantifier = when (setOp.type.setq) { + SetQuantifier.ALL -> Rel.Op.Set.Quantifier.ALL + null, SetQuantifier.DISTINCT -> Rel.Op.Set.Quantifier.DISTINCT + } + val op = when (setOp.type.type) { + SetOp.Type.UNION -> Rel.Op.Set.Union(quantifier, lhs, rhs, false) + SetOp.Type.EXCEPT -> Rel.Op.Set.Except(quantifier, lhs, rhs, false) + SetOp.Type.INTERSECT -> Rel.Op.Set.Intersect(quantifier, lhs, rhs, false) } - val op = Rel.Op.Set(lhs, rhs, setType, isOuter = false) return rel(type, op) } diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt index f115d02199..e4ab533d53 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt @@ -832,21 +832,16 @@ internal object RexConverter { type = Rel.Type(listOf(Rel.Binding("_1", StaticType.ANY)), props = emptySet()), op = Rel.Op.Scan(visitExpr(node.rhs, ctx)) ) - val type = when (node.type.type) { - SetOp.Type.UNION -> when (node.type.setq) { - SetQuantifier.ALL -> Rel.Op.Set.Type.UNION_ALL - null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.UNION_DISTINCT - } - SetOp.Type.EXCEPT -> when (node.type.setq) { - SetQuantifier.ALL -> Rel.Op.Set.Type.EXCEPT_ALL - null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.EXCEPT_DISTINCT - } - SetOp.Type.INTERSECT -> when (node.type.setq) { - SetQuantifier.ALL -> Rel.Op.Set.Type.INTERSECT_ALL - null, SetQuantifier.DISTINCT -> Rel.Op.Set.Type.INTERSECT_DISTINCT - } + val quantifier = when (node.type.setq) { + SetQuantifier.ALL -> Rel.Op.Set.Quantifier.ALL + null, SetQuantifier.DISTINCT -> Rel.Op.Set.Quantifier.DISTINCT + } + val isOuter = node.outer == true + val op = when (node.type.type) { + SetOp.Type.UNION -> Rel.Op.Set.Union(quantifier, lhs, rhs, isOuter) + SetOp.Type.EXCEPT -> Rel.Op.Set.Except(quantifier, lhs, rhs, isOuter) + SetOp.Type.INTERSECT -> Rel.Op.Set.Intersect(quantifier, lhs, rhs, isOuter) } - val op = Rel.Op.Set(lhs, rhs, type, isOuter = node.outer == true) val rel = Rel( type = Rel.Type(listOf(Rel.Binding("_0", StaticType.ANY)), props = emptySet()), op = op diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt index 98d5dc2eab..5bab5333fe 100644 --- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt +++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/PlanTyper.kt @@ -219,47 +219,95 @@ internal class PlanTyper(private val env: Env) { return rel(type, op) } - // TODO: [RFC-0007](https://github.com/partiql/partiql-lang/blob/main/RFCs/0007-rfc-bag-operators.md) - // states that the types must be "comparable". The below code ONLY makes sure that types need to be - // the same. In the future, we need to add support for checking comparable types. - override fun visitRelOpSet(node: Rel.Op.Set, ctx: Rel.Type?): Rel { + override fun visitRelOpSetExcept(node: Rel.Op.Set.Except, ctx: Rel.Type?): Rel { val lhs = visitRel(node.lhs, node.lhs.type) val rhs = visitRel(node.rhs, node.rhs.type) - val set = node.copy(lhs = lhs, rhs = rhs) + // Check for Compatibility + if (!setOpSchemaSizesMatch(lhs, rhs)) { + return createRelErrForSetOpMismatchSizes() + } + if (!node.isOuter && !setOpSchemaTypesMatch(lhs, rhs)) { + return createRelErrForSetOpMismatchTypes() + } + // Compute Schema + val type = Rel.Type(lhs.type.schema, props = emptySet()) + return Rel(type, node.copy(lhs = lhs, rhs = rhs)) + } - // Check that types are comparable - if (!node.isOuter) { - if (lhs.type.schema.size != rhs.type.schema.size) { - return Rel(Rel.Type(emptyList(), emptySet()), Rel.Op.Err("LHS and RHS of SET OP do not have the same number of bindings.")) - } - for (i in 0..lhs.type.schema.lastIndex) { - val lhsBindingType = lhs.type.schema[i].type - val rhsBindingType = rhs.type.schema[i].type - if (lhsBindingType != rhsBindingType) { - return Rel(Rel.Type(emptyList(), emptySet()), Rel.Op.Err("LHS and RHS of SET OP do not have the same type.")) - } - } + override fun visitRelOpSetIntersect(node: Rel.Op.Set.Intersect, ctx: Rel.Type?): Rel { + val lhs = visitRel(node.lhs, node.lhs.type) + val rhs = visitRel(node.rhs, node.rhs.type) + // Check for Compatibility + if (!setOpSchemaSizesMatch(lhs, rhs)) { + return createRelErrForSetOpMismatchSizes() } + if (!node.isOuter && !setOpSchemaTypesMatch(lhs, rhs)) { + return createRelErrForSetOpMismatchTypes() + } + // Compute Schema + val type = Rel.Type(lhs.type.schema, props = emptySet()) + return Rel(type, node.copy(lhs = lhs, rhs = rhs)) + } - // Compute Output Schema + override fun visitRelOpSetUnion(node: Rel.Op.Set.Union, ctx: Rel.Type?): Rel { + val lhs = visitRel(node.lhs, node.lhs.type) + val rhs = visitRel(node.rhs, node.rhs.type) + // Check for Compatibility + if (!setOpSchemaSizesMatch(lhs, rhs)) { + return createRelErrForSetOpMismatchSizes() + } + if (!node.isOuter && !setOpSchemaTypesMatch(lhs, rhs)) { + return createRelErrForSetOpMismatchTypes() + } + // Compute Schema val size = max(lhs.type.schema.size, rhs.type.schema.size) - val type = when (node.type) { - Rel.Op.Set.Type.EXCEPT_DISTINCT, Rel.Op.Set.Type.EXCEPT_ALL -> lhs.type - Rel.Op.Set.Type.INTERSECT_ALL, Rel.Op.Set.Type.INTERSECT_DISTINCT, - Rel.Op.Set.Type.UNION_ALL, Rel.Op.Set.Type.UNION_DISTINCT -> { - val schema = List(size) { - val lhsBinding = lhs.type.schema.getOrNull(it) ?: Rel.Binding("_$it", MISSING) - val rhsBinding = rhs.type.schema.getOrNull(it) ?: Rel.Binding("_$it", MISSING) - val bindingName = when (lhsBinding.name == rhsBinding.name) { - true -> lhsBinding.name - false -> "_$it" - } - Rel.Binding(bindingName, unionOf(lhsBinding.type, rhsBinding.type)) - } - Rel.Type(schema, props = emptySet()) + val schema = List(size) { + val lhsBinding = lhs.type.schema.getOrNull(it) ?: Rel.Binding("_$it", MISSING) + val rhsBinding = rhs.type.schema.getOrNull(it) ?: Rel.Binding("_$it", MISSING) + val bindingName = when (lhsBinding.name == rhsBinding.name) { + true -> lhsBinding.name + false -> "_$it" + } + Rel.Binding(bindingName, unionOf(lhsBinding.type, rhsBinding.type)) + } + val type = Rel.Type(schema, props = emptySet()) + return Rel(type, node.copy(lhs = lhs, rhs = rhs)) + } + + /** + * @return whether each type of the [lhs] is equal to its counterpart on the [rhs] + * @param lhs should be typed already + * @param rhs should be typed already + */ + private fun setOpSchemaTypesMatch(lhs: Rel, rhs: Rel): Boolean { + // TODO: [RFC-0007](https://github.com/partiql/partiql-lang/blob/main/RFCs/0007-rfc-bag-operators.md) + // states that the types must be "comparable". The below code ONLY makes sure that types need to be + // the same. In the future, we need to add support for checking comparable types. + for (i in 0..lhs.type.schema.lastIndex) { + val lhsBindingType = lhs.type.schema[i].type + val rhsBindingType = rhs.type.schema[i].type + if (lhsBindingType != rhsBindingType) { + return false } } - return Rel(type, set) + return true + } + + /** + * @return whether the [lhs] and [rhs] schemas are of equal size + * @param lhs should be typed already + * @param rhs should be typed already + */ + private fun setOpSchemaSizesMatch(lhs: Rel, rhs: Rel): Boolean { + return lhs.type.schema.size == rhs.type.schema.size + } + + private fun createRelErrForSetOpMismatchSizes(): Rel { + return Rel(Rel.Type(emptyList(), emptySet()), Rel.Op.Err("LHS and RHS of SET OP do not have the same number of bindings.")) + } + + private fun createRelErrForSetOpMismatchTypes(): Rel { + return Rel(Rel.Type(emptyList(), emptySet()), Rel.Op.Err("LHS and RHS of SET OP do not have the same type.")) } override fun visitRelOpLimit(node: Rel.Op.Limit, ctx: Rel.Type?): Rel { diff --git a/partiql-planner/src/main/resources/partiql_plan_internal.ion b/partiql-planner/src/main/resources/partiql_plan_internal.ion index bf5fdcc2fe..590134f693 100644 --- a/partiql-planner/src/main/resources/partiql_plan_internal.ion +++ b/partiql-planner/src/main/resources/partiql_plan_internal.ion @@ -296,26 +296,38 @@ rel::{ ], }, - // From Substrait: "The set operation encompasses several set-level operations that support combining datasets, ... - // possibly excluding records based on various types of record level matching." - set::{ - lhs: rel, - rhs: rel, - type: [ - UNION_ALL, - UNION_DISTINCT, - INTERSECT_ALL, - INTERSECT_DISTINCT, - EXCEPT_ALL, - EXCEPT_DISTINCT - ], - // This is an internal-only field. It is specifically used to aid in typing the plan and throwing potential errors. - // For example, if a user were to write: `<< { 'a': 1 } >>` UNION << { 'b': 'hello' } >>, then this would FAIL - // due to [RFC-0007](https://github.com/partiql/partiql-lang/blob/main/RFCs/0007-rfc-bag-operators.md). However, - // if a user were to use OUTER UNION, then it would work. Under the hood at execution, the operator is the same -- - // however, at planning time, with static type analysis, we can fail queries prior to their execution. - is_outer: bool - }, + + // In each variant, is_outer is an internal-only field. It is specifically used to aid in typing the plan and throwing potential errors. + // For example, if a user were to write: `<< { 'a': 1 } >>` UNION << { 'b': 'hello' } >>, then this would FAIL + // due to [RFC-0007](https://github.com/partiql/partiql-lang/blob/main/RFCs/0007-rfc-bag-operators.md). However, + // if a user were to use OUTER UNION, then it would work. Under the hood at execution, the operator is the same -- + // however, at planning time, with static type analysis, we can fail queries prior to their execution. + set::[ + union::{ + quantifier: quantifier, + lhs: rel, + rhs: rel, + is_outer: bool + }, + + intersect::{ + quantifier: quantifier, + lhs: rel, + rhs: rel, + is_outer: bool + }, + + except::{ + quantifier: quantifier, + lhs: rel, + rhs: rel, + is_outer: bool + }, + + _::[ + quantifier::[ ALL, DISTINCT ], + ] + ], limit::{ input: rel, From b983f0925515e64e49eb6bd2604bb32cc21ff6bb Mon Sep 17 00:00:00 2001 From: John Ed Quinn Date: Tue, 23 Apr 2024 15:12:42 -0700 Subject: [PATCH 10/12] Make IteratorPeeking internal and internalize property --- .../eval/internal/helpers/IteratorPeeking.kt | 14 +++++++------- .../eval/internal/operator/rel/RelPeeking.kt | 6 ++---- 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt index 034a698e04..655d020d2c 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt @@ -7,9 +7,9 @@ package org.partiql.eval.internal.helpers * With this implementation, invoking hasNext() multiple times will not iterate unnecessarily. Invoking next() without * invoking hasNext() is allowed -- however, it is highly recommended to avoid doing so. */ -abstract class IteratorPeeking : Iterator { +internal abstract class IteratorPeeking : Iterator { - private var _next: T? = null + internal var next: T? = null /** * @return NULL when there is not another [T] to be produced. Returns a [T] when able to. @@ -19,18 +19,18 @@ abstract class IteratorPeeking : Iterator { abstract fun peek(): T? override fun hasNext(): Boolean { - if (_next != null) { + if (next != null) { return true } - this._next = peek() - return this._next != null + this.next = peek() + return this.next != null } override fun next(): T { - val next = _next + val next = next ?: peek() ?: error("There was no more elements, however, next() was called. Please use hasNext() beforehand.") - this._next = null + this.next = null return next } } diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelPeeking.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelPeeking.kt index f78eaa96c7..be2cf203b8 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelPeeking.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelPeeking.kt @@ -11,13 +11,11 @@ import org.partiql.eval.internal.operator.Operator */ internal abstract class RelPeeking : Operator.Relation, IteratorPeeking() { - private var _next: Record? = null - override fun open(env: Environment) { - _next = null + next = null } override fun close() { - _next = null + next = null } } From b57bc378e9dbe83ed636a2e33ca65a484fe81010 Mon Sep 17 00:00:00 2001 From: John Ed Quinn <40360967+johnedquinn@users.noreply.github.com> Date: Wed, 24 Apr 2024 09:30:34 -0700 Subject: [PATCH 11/12] Add suggested change Co-authored-by: R. C. Howell --- .../kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt index 655d020d2c..55f6c8fd2b 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/helpers/IteratorPeeking.kt @@ -29,7 +29,7 @@ internal abstract class IteratorPeeking : Iterator { override fun next(): T { val next = next ?: peek() - ?: error("There was no more elements, however, next() was called. Please use hasNext() beforehand.") + ?: error("There were no more elements, however, next() was called. Please use hasNext() beforehand.") this.next = null return next } From 0962bcf58d8978311225d8553672747ac269519e Mon Sep 17 00:00:00 2001 From: John Ed Quinn Date: Wed, 24 Apr 2024 09:48:48 -0700 Subject: [PATCH 12/12] Adds closePeeking and openPeeking to RelPeeking --- .../eval/internal/operator/rel/RelDistinct.kt | 6 ++---- .../eval/internal/operator/rel/RelExceptAll.kt | 6 ++---- .../internal/operator/rel/RelExceptDistinct.kt | 6 ++---- .../eval/internal/operator/rel/RelFilter.kt | 6 ++---- .../internal/operator/rel/RelIntersectAll.kt | 6 ++---- .../operator/rel/RelIntersectDistinct.kt | 6 ++---- .../internal/operator/rel/RelJoinNestedLoop.kt | 6 ++---- .../eval/internal/operator/rel/RelPeeking.kt | 18 ++++++++++++++++++ .../internal/operator/rel/RelUnionDistinct.kt | 6 ++---- 9 files changed, 34 insertions(+), 32 deletions(-) diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelDistinct.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelDistinct.kt index b4d041ccf7..15dcc1ba5a 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelDistinct.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelDistinct.kt @@ -10,9 +10,8 @@ internal class RelDistinct( private val seen = mutableSetOf() - override fun open(env: Environment) { + override fun openPeeking(env: Environment) { input.open(env) - super.open(env) } override fun peek(): Record? { @@ -25,9 +24,8 @@ internal class RelDistinct( return null } - override fun close() { + override fun closePeeking() { seen.clear() input.close() - super.close() } } diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt index 5920a8ea61..f62a433b32 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptAll.kt @@ -12,12 +12,11 @@ internal class RelExceptAll( private val seen: MutableMap = mutableMapOf() private var init: Boolean = false - override fun open(env: Environment) { + override fun openPeeking(env: Environment) { lhs.open(env) rhs.open(env) init = false seen.clear() - super.open(env) } override fun peek(): Record? { @@ -35,11 +34,10 @@ internal class RelExceptAll( return null } - override fun close() { + override fun closePeeking() { lhs.close() rhs.close() seen.clear() - super.close() } /** diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptDistinct.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptDistinct.kt index c5d153bb39..9874aabaea 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptDistinct.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelExceptDistinct.kt @@ -18,12 +18,11 @@ internal class RelExceptDistinct( private var seen: MutableSet = mutableSetOf() private var init: Boolean = false - override fun open(env: Environment) { + override fun openPeeking(env: Environment) { lhs.open(env) rhs.open(env) init = false seen = mutableSetOf() - super.open(env) } override fun peek(): Record? { @@ -38,11 +37,10 @@ internal class RelExceptDistinct( return null } - override fun close() { + override fun closePeeking() { lhs.close() rhs.close() seen.clear() - super.close() } /** diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelFilter.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelFilter.kt index 5c8b38949d..2081f14d58 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelFilter.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelFilter.kt @@ -13,10 +13,9 @@ internal class RelFilter( private lateinit var env: Environment - override fun open(env: Environment) { + override fun openPeeking(env: Environment) { this.env = env input.open(env) - super.open(env) } override fun peek(): Record? { @@ -28,9 +27,8 @@ internal class RelFilter( return null } - override fun close() { + override fun closePeeking() { input.close() - super.close() } @OptIn(PartiQLValueExperimental::class) diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectAll.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectAll.kt index 77ca4dfa6e..33f2ba869a 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectAll.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectAll.kt @@ -12,12 +12,11 @@ internal class RelIntersectAll( private val seen: MutableMap = mutableMapOf() private var init: Boolean = false - override fun open(env: Environment) { + override fun openPeeking(env: Environment) { lhs.open(env) rhs.open(env) init = false seen.clear() - super.open(env) } override fun peek(): Record? { @@ -35,11 +34,10 @@ internal class RelIntersectAll( return null } - override fun close() { + override fun closePeeking() { lhs.close() rhs.close() seen.clear() - super.close() } /** diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectDistinct.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectDistinct.kt index e32575395c..2700924104 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectDistinct.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelIntersectDistinct.kt @@ -12,12 +12,11 @@ internal class RelIntersectDistinct( private val seen: MutableSet = mutableSetOf() private var init: Boolean = false - override fun open(env: Environment) { + override fun openPeeking(env: Environment) { lhs.open(env) rhs.open(env) init = false seen.clear() - super.open(env) } override fun peek(): Record? { @@ -32,11 +31,10 @@ internal class RelIntersectDistinct( return null } - override fun close() { + override fun closePeeking() { lhs.close() rhs.close() seen.clear() - super.close() } /** diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelJoinNestedLoop.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelJoinNestedLoop.kt index ed761c10d2..cb39e48188 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelJoinNestedLoop.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelJoinNestedLoop.kt @@ -19,7 +19,7 @@ internal abstract class RelJoinNestedLoop : RelPeeking() { private var lhsRecord: Record? = null private lateinit var env: Environment - override fun open(env: Environment) { + override fun openPeeking(env: Environment) { this.env = env lhs.open(env) if (lhs.hasNext().not()) { @@ -27,7 +27,6 @@ internal abstract class RelJoinNestedLoop : RelPeeking() { } lhsRecord = lhs.next() rhs.open(env.push(lhsRecord!!)) - super.open(env) } abstract fun join(condition: Boolean, lhs: Record, rhs: Record): Record? @@ -69,10 +68,9 @@ internal abstract class RelJoinNestedLoop : RelPeeking() { return toReturn } - override fun close() { + override fun closePeeking() { lhs.close() rhs.close() - super.close() } @OptIn(PartiQLValueExperimental::class) diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelPeeking.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelPeeking.kt index be2cf203b8..6206b783bf 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelPeeking.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelPeeking.kt @@ -11,11 +11,29 @@ import org.partiql.eval.internal.operator.Operator */ internal abstract class RelPeeking : Operator.Relation, IteratorPeeking() { + /** + * This shall have the same functionality as [open]. Implementers of [RelPeeking] shall not override [open]. + */ + abstract fun openPeeking(env: Environment) + + /** + * This shall have the same functionality as [close]. Implementers of [RelPeeking] shall not override [close]. + */ + abstract fun closePeeking() + + /** + * Implementers shall not override this method. + */ override fun open(env: Environment) { next = null + openPeeking(env) } + /** + * Implementers shall not override this method. + */ override fun close() { next = null + closePeeking() } } diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt index ca4f8366d0..bafa6cb28e 100644 --- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt +++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rel/RelUnionDistinct.kt @@ -13,12 +13,11 @@ internal class RelUnionDistinct( private val seen: MutableSet = mutableSetOf() private lateinit var input: Iterator - override fun open(env: Environment) { + override fun openPeeking(env: Environment) { lhs.open(env) rhs.open(env) seen.clear() input = IteratorChain(arrayOf(lhs, rhs)) - super.open(env) } override fun peek(): Record? { @@ -31,10 +30,9 @@ internal class RelUnionDistinct( return null } - override fun close() { + override fun closePeeking() { lhs.close() rhs.close() seen.clear() - super.close() } }