Removes unnecessary evaluation session properties

partiql-eval/src/main/kotlin/org/partiql/eval/PartiQLEngine.kt

@@ -36,40 +36,11 @@ public interface PartiQLEngine {
 
     public class Session(
         val catalogs: Map<String, Connector> = mapOf(),
-        val mode: Mode = Mode.PERMISSIVE,
-        val errorHandling: CompilationErrorHandling = CompilationErrorHandling.SIGNALING
+        val mode: Mode = Mode.PERMISSIVE
     )
 
-    /**
-     * This determines the behavior when the evaluator encounters scenarios in which a type check exception occurs.
-     */
     public enum class Mode {
-        /**
-         * Returns MISSING when a type check exception occurs.
-         */
         PERMISSIVE,
-
-        /**
-         * Propagates the type check exception.
-         */
         STRICT // AKA, Type Checking Mode in the PartiQL Specification
     }
-
-    /**
-     * When the PartiQL Plan has determined that a function call or variable reference will always error, the
-     * [CompilationErrorHandling] will determine how the internal compiler will treat the error. Note that this is subtly
-     * different than [Mode]. [CompilationErrorHandling] is specifically used when nodes are known to ALWAYS return
-     * MISSING. The difference can be understood as compile-time ([CompilationErrorHandling]) vs run-time ([Mode]).
-     */
-    public enum class CompilationErrorHandling {
-        /**
-         * Returns a literal MISSING.
-         */
-        QUIET,
-
-        /**
-         * Errors out.
-         */
-        SIGNALING
-    }
 }

partiql-eval/src/main/kotlin/org/partiql/eval/internal/Compiler.kt

@@ -45,14 +45,12 @@ import org.partiql.plan.Ref
 import org.partiql.plan.Rel
 import org.partiql.plan.Rex
 import org.partiql.plan.Statement
-import org.partiql.plan.debug.PlanPrinter
 import org.partiql.plan.visitor.PlanBaseVisitor
 import org.partiql.spi.fn.Agg
 import org.partiql.spi.fn.FnExperimental
 import org.partiql.types.StaticType
 import org.partiql.value.PartiQLValueExperimental
 import org.partiql.value.PartiQLValueType
-import org.partiql.value.missingValue
 import java.lang.IllegalStateException
 
 internal class Compiler(
@@ -70,20 +68,16 @@ internal class Compiler(
     }
 
     /**
-     * [Rex.Op.Err] comes from the inability for the planner to resolve a variable/function/etc. Depending on the
-     * configuration, this will either return MISSING or throw an error.
+     * Realistically, this should never execute -- since the problems of severity ERROR are sent to the problem handler
+     * at planning time. Implementors SHOULD fail compilation, however, if they decide not to, we will allow its execution
+     * and will treat this identically to [visitRexOpMissing].
      */
     override fun visitRexOpErr(node: Rex.Op.Err, ctx: StaticType?): Operator {
-        return when (session.errorHandling) {
-            PartiQLEngine.CompilationErrorHandling.QUIET -> ExprError()
-            PartiQLEngine.CompilationErrorHandling.SIGNALING -> {
-                val message = buildString {
-                    this.appendLine(node.message)
-                    PlanPrinter.append(this, plan)
-                }
-                throw IllegalStateException(message)
-            }
-        }
+        return ExprError(node.message)
+    }
+
+    override fun visitRexOpMissing(node: Rex.Op.Missing, ctx: StaticType?): Operator {
+        return ExprError(node.message)
     }
 
     override fun visitRelOpErr(node: Rel.Op.Err, ctx: StaticType?): Operator {
@@ -117,11 +111,6 @@ internal class Compiler(
         return ExprStruct(fields)
     }
 
-    @OptIn(PartiQLValueExperimental::class)
-    override fun visitRexOpMissing(node: Rex.Op.Missing, ctx: StaticType?): Operator {
-        return ExprLiteral(missingValue())
-    }
-
     override fun visitRexOpSelect(node: Rex.Op.Select, ctx: StaticType?): Operator {
         val rel = visitRel(node.rel, ctx)
         val ordered = node.rel.type.props.contains(Rel.Prop.ORDERED)

partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rex/ExprError.kt

@@ -6,9 +6,12 @@ import org.partiql.eval.internal.operator.Operator
 import org.partiql.value.PartiQLValue
 import org.partiql.value.PartiQLValueExperimental
 
-internal class ExprError : Operator.Expr {
+internal class ExprError(
+    private val message: String,
+) : Operator.Expr {
+
     @OptIn(PartiQLValueExperimental::class)
     override fun eval(env: Environment): PartiQLValue {
-        throw TypeCheckException()
+        throw TypeCheckException(message)
     }
 }