Separate binding from evaluation of expression & implement strict eval (

#413)

* Add interface for strict mode evaluation.
* Separate binding from evaluation of expression & implement strict eval
* Update conformance test data
* Better conformance test reporting
* Refactor to better categorize expressions
* Remove `is_null_or_missing`

CHANGELOG.md

@@ -7,7 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 ### Changed
-- *BREAKING:* partiql-eval: `EvaluatorPlanner` construction now takes an `EvaluationMode` parameter. 
+- *BREAKING:* partiql-eval: Construction of expression evaluators changed to separate binding from evaluation of expression. & implement strict eval
+- *BREAKING:* partiql-value: `Value` trait's `is_null_or_missing` renamed to `is_absent`
+- *BREAKING:* partiql-eval: `EvaluatorPlanner` construction now takes an `EvaluationMode` parameter.
+- *BREAKING:* partiql-eval: `like_to_re_pattern` is no longer public.
 - *BREAKING:* partiql-value: Box Decimals in `Value` to assure `Value` fits in 16 bytes.
 - *BREAKING:* partiql-logical-planner: moves `NameResolver` to `partiql-ast-passes`
 - *BREAKING:* partiql-value: removes `partiql` from value macro_rules; e.g. `partiql_bag` renames to `bag`.
@@ -20,6 +23,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - *BREAKING:* partiql-logical: changed modeling of `Project` `exprs` to be a `Vec<(String, ValueExpr)>` rather than a `HashMap<String, ValueExpr>` to support multiple project items with the same alias
 
 ### Added
+- Strict mode evaluation partial support added.
 - Add interface for `STRICT` mode evalution to `EvaluatorPlanner`.
 - Add ability for partiql-extension-ion extension encoding/decoding of `Value` to/from Ion `Element`
 - Add `partiql-types` crate that includes data models for PartiQL Types.

partiql-conformance-tests/Cargo.toml

@@ -49,6 +49,8 @@ once_cell = "1"
 
 rust_decimal = "1.27"
 
+thiserror = "1.0"
+
 serde = { version = "1.*", features = ["derive"], optional = true }
 serde_json = { version = "1.*", optional = true }
 

partiql-conformance-tests/tests/mod.rs

@@ -2,12 +2,14 @@ use partiql_ast_passes::error::AstTransformationError;
 use partiql_catalog::{Catalog, PartiqlCatalog};
 use partiql_eval as eval;
 use partiql_eval::env::basic::MapBindings;
-use partiql_eval::error::PlanErr;
-use partiql_eval::eval::{EvalPlan, EvalResult};
+use partiql_eval::error::{EvalErr, PlanErr};
+use partiql_eval::eval::{EvalPlan, EvalResult, Evaluated};
 use partiql_logical as logical;
-use partiql_parser::{Parsed, ParserResult};
+use partiql_parser::{Parsed, ParserError, ParserResult};
 use partiql_value::Value;
 
+use thiserror::Error;
+
 mod test_value;
 pub(crate) use test_value::TestValue;
 
@@ -111,31 +113,73 @@ pub(crate) fn pass_semantics(statement: &str) {
     );
 }
 
+#[derive(Error, Debug)]
+enum TestError<'a> {
+    #[error("Parse error: {0:?}")]
+    Parse(ParserError<'a>),
+    #[error("Lower error: {0:?}")]
+    Lower(AstTransformationError),
+    #[error("Plan error: {0:?}")]
+    Plan(PlanErr),
+    #[error("Evaluation error: {0:?}")]
+    Eval(EvalErr),
+}
+
+impl<'a> From<ParserError<'a>> for TestError<'a> {
+    fn from(err: ParserError<'a>) -> Self {
+        TestError::Parse(err)
+    }
+}
+
+impl From<AstTransformationError> for TestError<'_> {
+    fn from(err: AstTransformationError) -> Self {
+        TestError::Lower(err)
+    }
+}
+
+impl From<PlanErr> for TestError<'_> {
+    fn from(err: PlanErr) -> Self {
+        TestError::Plan(err)
+    }
+}
+
+impl From<EvalErr> for TestError<'_> {
+    fn from(err: EvalErr) -> Self {
+        TestError::Eval(err)
+    }
+}
+
 #[track_caller]
 #[inline]
 #[allow(dead_code)]
-pub(crate) fn fail_eval(statement: &str, mode: EvaluationMode, env: &Option<TestValue>) {
+pub(crate) fn eval<'a>(
+    statement: &'a str,
+    mode: EvaluationMode,
+    env: &Option<TestValue>,
+) -> Result<Evaluated, TestError<'a>> {
     let catalog = PartiqlCatalog::default();
 
-    let parsed = parse(statement);
-    let lowered_result = lower(&catalog, &parsed.expect("parse"));
-    let lowered = lowered_result.expect("lower");
+    let parsed = parse(statement)?;
+    let lowered = lower(&catalog, &parsed)?;
     let bindings = env
         .as_ref()
         .map(|e| (&e.value).into())
         .unwrap_or_else(MapBindings::default);
+    let plan = compile(mode, &catalog, lowered)?;
+    Ok(evaluate(plan, bindings)?)
+}
 
-    let plan = compile(mode, &catalog, lowered);
-    match plan {
-        Ok(plan) => {
-            let out = evaluate(plan, bindings);
+#[track_caller]
+#[inline]
+#[allow(dead_code)]
+pub(crate) fn fail_eval(statement: &str, mode: EvaluationMode, env: &Option<TestValue>) {
+    let result = eval(statement, mode, env);
 
-            assert!(
-                out.is_err(),
-                "When evaluating (mode = {mode:#?}) `{statement}`, expected `Err(_)`, but was `{out:#?}`"
-            );
-        }
-        Err(_) => {}
+    match result {
+        Ok(result) => panic!("When evaluating (mode = {mode:#?}) `{statement}`, expected `Err(_)`, but was `{result:#?}`"),
+        Err(TestError::Parse(_)) => panic!("When evaluating (mode = {mode:#?}) `{statement}`, unexpected parse error"),
+        Err(TestError::Lower(err)) => panic!("When evaluating (mode = {mode:#?}) `{statement}`, unexpected lowering error `{err:?}`"),
+        Err(TestError::Plan(_)) | Err(TestError::Eval(_)) => {}
     }
 }
 
@@ -148,25 +192,16 @@ pub(crate) fn pass_eval(
     env: &Option<TestValue>,
     expected: &TestValue,
 ) {
-    let catalog = PartiqlCatalog::default();
-
-    let parsed = parse(statement);
-    let lowered_result = lower(&catalog, &parsed.expect("parse"));
-    let lowered = lowered_result.expect("lower");
-    let bindings = env
-        .as_ref()
-        .map(|e| (&e.value).into())
-        .unwrap_or_else(MapBindings::default);
-    let plan = compile(mode, &catalog, lowered).expect("compile");
-    let out = evaluate(plan, bindings);
-
-    match out {
+    match eval(statement, mode, env) {
         Ok(v) => assert_eq!(v.result, expected.value),
-        Err(err) => {
-            panic!(
-                "When evaluating (mode = {mode:#?}) `{statement}`, expected `Ok(_)`, but was `Err({err:#?})`"
-            )
+        Err(TestError::Parse(_)) => {
+            panic!("When evaluating (mode = {mode:#?}) `{statement}`, unexpected parse error")
         }
+        Err(TestError::Lower(err)) => panic!("When evaluating (mode = {mode:#?}) `{statement}`, unexpected lowering error `{err:?}`"),
+        Err(TestError::Plan(err)) => panic!("When evaluating (mode = {mode:#?}) `{statement}`, unexpected planning error `{err:?}`"),
+        Err(TestError::Eval(err)) => panic!(
+            "When evaluating (mode = {mode:#?}) `{statement}`, expected `Ok(_)`, but was `Err({err:#?})`"
+        )
     }
 }
 

partiql-eval/Cargo.toml

@@ -24,6 +24,7 @@ bench = false
 partiql-logical = { path = "../partiql-logical", version = "0.5.*" }
 partiql-value = { path = "../partiql-value", version = "0.5.*" }
 partiql-catalog = { path = "../partiql-catalog", version = "0.5.*" }
+partiql-types = { path = "../partiql-types", version = "0.5.*" }
 petgraph = "0.6.*"
 ordered-float = "3.*"
 itertools = "0.10.*"