Add session context to evaluation (#446)

.github/workflows/ci_build_test.yml

@@ -92,7 +92,7 @@ jobs:
       - name: Rust Toolchain
         uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: nightly-2023-03-09
+          toolchain: nightly-2023-06-09
       - uses: actions/cache@v3
         id: restore-build
         with:
@@ -132,7 +132,7 @@ jobs:
       - name: Rust Toolchain
         uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: nightly-2023-03-09
+          toolchain: nightly-2023-06-09
       - uses: actions/cache@v3
         id: restore-build-and-conformance
         with:

CHANGELOG.md

@@ -8,9 +8,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 ### Changed
 - Adds quotes to the attributes of PartiQL tuple's debug output so it can be read and transformed using Kotlin `partiql-cli`
+- [breaking] Changes the interface to `EvalPlan` to accept an `EvalContext`
 
 ### Added
 - Add `partiql-extension-visualize` for visualizing AST and logical plan
+- Add a `SessionContext` containing both a system-level and a user-level context object usable by expression evaluation 
 
 ### Fixed
 - Fixed `ORDER BY`'s ability to see into projection aliases

Cargo.toml

@@ -4,9 +4,9 @@ homepage = "https://github.com/partiql/partiql-lang-rust"
 repository = "https://github.com/partiql/partiql-lang-rust"
 version = "0.6.0"
 edition = "2021"
-resolver = 2
 
 [workspace]
+resolver = "2"
 
 members = [
   "partiql",

extension/partiql-extension-ion-functions/src/lib.rs

@@ -11,6 +11,7 @@ use partiql_logical as logical;
 use partiql_value::Value;
 use std::borrow::Cow;
 
+use partiql_catalog::context::SessionContext;
 use std::error::Error;
 use std::fmt::Debug;
 use std::fs::File;
@@ -98,7 +99,11 @@ impl BaseTableFunctionInfo for ReadIonFunction {
 pub(crate) struct EvalFnReadIon {}
 
 impl BaseTableExpr for EvalFnReadIon {
-    fn evaluate(&self, args: &[Cow<Value>]) -> BaseTableExprResult {
+    fn evaluate<'c>(
+        &self,
+        args: &[Cow<Value>],
+        _ctx: &'c dyn SessionContext<'c>,
+    ) -> BaseTableExprResult<'c> {
         if let Some(arg1) = args.first() {
             match arg1.as_ref() {
                 Value::String(path) => parse_ion_file(path),
@@ -155,11 +160,13 @@ fn parse_ion_buff<'a, I: 'a + ToIonDataSource>(input: I) -> BaseTableExprResult<
 mod tests {
     use super::*;
 
+    use partiql_catalog::context::SystemContext;
     use partiql_catalog::{Catalog, Extension, PartiqlCatalog};
     use partiql_eval::env::basic::MapBindings;
+    use partiql_eval::eval::BasicContext;
     use partiql_eval::plan::EvaluationMode;
     use partiql_parser::{Parsed, ParserResult};
-    use partiql_value::{bag, tuple, Value};
+    use partiql_value::{bag, tuple, DateTime, Value};
 
     #[track_caller]
     #[inline]
@@ -189,7 +196,11 @@ mod tests {
 
         let mut plan = planner.compile(&logical).expect("Expect no plan error");
 
-        if let Ok(out) = plan.execute_mut(bindings) {
+        let sys = SystemContext {
+            now: DateTime::from_system_now_utc(),
+        };
+        let ctx = BasicContext::new(bindings, sys);
+        if let Ok(out) = plan.execute_mut(&ctx) {
             out.result
         } else {
             Value::Missing

partiql-catalog/src/context.rs

@@ -0,0 +1,27 @@
+use partiql_value::{BindingsName, DateTime, Tuple, Value};
+use std::any::Any;
+use std::fmt::Debug;
+
+pub trait Bindings<T>: Debug {
+    fn get(&self, name: &BindingsName) -> Option<&T>;
+}
+
+impl Bindings<Value> for Tuple {
+    fn get(&self, name: &BindingsName) -> Option<&Value> {
+        self.get(name)
+    }
+}
+
+#[derive(Debug)]
+pub struct SystemContext {
+    pub now: DateTime,
+}
+
+/// Represents a session context that is used during evaluation of a plan.
+pub trait SessionContext<'a>: Debug {
+    fn bindings(&self) -> &dyn Bindings<Value>;
+
+    fn system_context(&self) -> &SystemContext;
+
+    fn user_context(&self, name: &str) -> Option<&(dyn Any)>;
+}

partiql-catalog/src/lib.rs

@@ -4,6 +4,7 @@ use partiql_types::PartiqlType;
 use partiql_value::Value;
 use std::borrow::Cow;
 
+use crate::context::SessionContext;
 use std::collections::HashMap;
 use std::error::Error;
 use std::fmt::Debug;
@@ -13,6 +14,8 @@ use unicase::UniCase;
 
 pub mod call_defs;
 
+pub mod context;
+
 pub trait Extension: Debug {
     fn name(&self) -> String;
     fn load(&self, catalog: &mut dyn Catalog) -> Result<(), Box<dyn Error>>;
@@ -49,7 +52,11 @@ pub type BaseTableExprResult<'a> =
     Result<BaseTableExprResultValueIter<'a>, BaseTableExprResultError>;
 
 pub trait BaseTableExpr: Debug {
-    fn evaluate(&self, args: &[Cow<Value>]) -> BaseTableExprResult;
+    fn evaluate<'c>(
+        &self,
+        args: &[Cow<Value>],
+        ctx: &'c dyn SessionContext<'c>,
+    ) -> BaseTableExprResult<'c>;
 }
 
 pub trait BaseTableFunctionInfo: Debug {

partiql-conformance-tests/tests/mod.rs

@@ -1,13 +1,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::{EvalErr, PlanErr};
-use partiql_eval::eval::{EvalPlan, EvalResult, Evaluated};
+use partiql_eval::eval::{BasicContext, EvalContext, EvalPlan, EvalResult, Evaluated};
 use partiql_logical as logical;
 use partiql_parser::{Parsed, ParserError, ParserResult};
-use partiql_value::Value;
+use partiql_value::DateTime;
 
+use partiql_catalog::context::SystemContext;
 use thiserror::Error;
 
 mod test_value;
@@ -58,8 +59,8 @@ pub(crate) fn compile(
 
 #[track_caller]
 #[inline]
-pub(crate) fn evaluate(mut plan: EvalPlan, bindings: MapBindings<Value>) -> EvalResult {
-    plan.execute_mut(bindings)
+pub(crate) fn evaluate<'c>(mut plan: EvalPlan, ctx: &'c dyn EvalContext<'c>) -> EvalResult {
+    plan.execute_mut(ctx)
 }
 
 #[track_caller]
@@ -161,9 +162,15 @@ pub(crate) fn eval<'a>(
 
     let parsed = parse(statement)?;
     let lowered = lower(&catalog, &parsed)?;
+
     let bindings = env.as_ref().map(|e| (&e.value).into()).unwrap_or_default();
+    let sys = SystemContext {
+        now: DateTime::from_system_now_utc(),
+    };
+    let ctx = BasicContext::new(bindings, sys);
     let plan = compile(mode, &catalog, lowered)?;
-    Ok(evaluate(plan, bindings)?)
+
+    Ok(evaluate(plan, &ctx)?)
 }
 
 #[track_caller]

partiql-eval/Cargo.toml

@@ -36,6 +36,7 @@ assert_matches = "1.5.*"
 regex = "1.7"
 regex-syntax = "0.6"
 rustc-hash = "1"
+delegate = "0.12"
 
 [dev-dependencies]
 criterion = "0.4"

partiql-eval/benches/bench_eval.rs

@@ -2,18 +2,19 @@ use std::borrow::Cow;
 use std::time::Duration;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use partiql_catalog::context::SystemContext;
 use partiql_catalog::PartiqlCatalog;
 
 use partiql_eval::env::basic::MapBindings;
-use partiql_eval::eval::EvalPlan;
+use partiql_eval::eval::{BasicContext, EvalPlan};
 use partiql_eval::plan;
 use partiql_eval::plan::EvaluationMode;
 use partiql_logical as logical;
 use partiql_logical::BindingsOp::{Project, ProjectAll};
 use partiql_logical::{
     BinaryOp, BindingsOp, JoinKind, LogicalPlan, PathComponent, ValueExpr, VarRefType,
 };
-use partiql_value::{bag, list, tuple, BindingsName, Value};
+use partiql_value::{bag, list, tuple, BindingsName, DateTime, Value};
 
 fn data() -> MapBindings<Value> {
     let hr = tuple![(
@@ -134,7 +135,11 @@ fn eval_plan(logical: &LogicalPlan<BindingsOp>) -> EvalPlan {
 }
 
 fn evaluate(mut plan: EvalPlan, bindings: MapBindings<Value>) -> Value {
-    if let Ok(out) = plan.execute_mut(bindings) {
+    let sys = SystemContext {
+        now: DateTime::from_system_now_utc(),
+    };
+    let ctx = BasicContext::new(bindings, sys);
+    if let Ok(out) = plan.execute_mut(&ctx) {
         out.result
     } else {
         Value::Missing

partiql-eval/src/env.rs

@@ -1,17 +1,8 @@
+use partiql_catalog::context::Bindings;
 use partiql_value::{BindingsName, Tuple, Value};
 use std::fmt::Debug;
 use unicase::UniCase;
 
-pub trait Bindings<T>: Debug {
-    fn get(&self, name: &BindingsName) -> Option<&T>;
-}
-
-impl Bindings<Value> for Tuple {
-    fn get(&self, name: &BindingsName) -> Option<&Value> {
-        self.get(name)
-    }
-}
-
 pub mod basic {
     use super::*;
     use std::collections::HashMap;

partiql-eval/src/error.rs

@@ -56,7 +56,7 @@ impl ErrorNode {
 }
 
 impl Evaluable for ErrorNode {
-    fn evaluate(&mut self, _ctx: &dyn EvalContext) -> Value {
+    fn evaluate<'a, 'c>(&mut self, _ctx: &'c dyn EvalContext<'c>) -> Value {
         panic!("ErrorNode will not be evaluated")
     }
 
@@ -66,7 +66,14 @@ impl Evaluable for ErrorNode {
 }
 
 impl EvalExpr for ErrorNode {
-    fn evaluate<'a>(&'a self, _bindings: &'a Tuple, _ctx: &'a dyn EvalContext) -> Cow<'a, Value> {
+    fn evaluate<'a, 'c>(
+        &'a self,
+        _bindings: &'a Tuple,
+        _ctx: &'c dyn EvalContext<'c>,
+    ) -> Cow<'a, Value>
+    where
+        'c: 'a,
+    {
         panic!("ErrorNode will not be evaluated")
     }
 }