Introduce Datum, an interface to introspecting Values (#533)

* Introduce `Datum`, an interface to introspecting `Value`s

* Use `Datum` and `DatumCategory` in evaluator

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

@@ -171,6 +171,7 @@ mod tests {
     use partiql_eval::eval::BasicContext;
     use partiql_eval::plan::EvaluationMode;
     use partiql_parser::{Parsed, ParserResult};
+    use partiql_value::datum::Datum;
     use partiql_value::{bag, tuple, DateTime, Value};
 
     #[track_caller]
@@ -229,7 +230,7 @@ mod tests {
             .unwrap_or_default();
         let out = evaluate(&catalog, lowered, bindings);
 
-        assert!(out.is_bag());
+        assert!(out.is_sequence());
         assert_eq!(&out, expected);
     }
 

partiql-eval/src/eval/evaluable.rs

@@ -15,6 +15,7 @@ use std::collections::hash_map::Entry;
 use std::collections::HashSet;
 use std::fmt::{Debug, Formatter};
 
+use partiql_value::datum::Datum;
 use std::rc::Rc;
 
 #[macro_export]
@@ -110,17 +111,16 @@ impl Evaluable for EvalScan {
             Value::Tuple(t) => bag![*t],
             _ => bag![tuple![]],
         };
-
         let mut value = bag![];
         bindings.iter().for_each(|binding| {
             let binding_tuple = binding.as_tuple_ref();
             let v = self.expr.evaluate(&binding_tuple, ctx).into_owned();
-            let ordered = &v.is_ordered();
             let mut at_index_counter: i64 = 0;
             if let Some(at_key) = &self.at_key {
+                let ordered = v.is_ordered();
                 for t in v {
                     let mut out = Tuple::from([(self.as_key.as_str(), t)]);
-                    let at_id = if *ordered {
+                    let at_id = if ordered {
                         at_index_counter.into()
                     } else {
                         Missing
@@ -1233,7 +1233,6 @@ impl EvalExprQuery {
 impl Evaluable for EvalExprQuery {
     fn evaluate<'a, 'c>(&mut self, ctx: &'c dyn EvalContext<'c>) -> Value {
         let input_value = self.input.take().unwrap_or(Value::Null).coerce_into_tuple();
-
         self.expr.evaluate(&input_value, ctx).into_owned()
     }
 

partiql-eval/src/eval/expr/coll.rs

@@ -14,6 +14,7 @@ use std::fmt::Debug;
 use std::hash::Hash;
 
 use crate::eval::eval_expr_wrapper::UnaryValueExpr;
+use partiql_value::datum::Datum;
 use std::ops::ControlFlow;
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]

partiql-eval/src/eval/expr/mod.rs

@@ -21,6 +21,7 @@ pub(crate) use operators::*;
 
 use crate::eval::EvalContext;
 
+use partiql_value::datum::DatumLowerError;
 use partiql_value::{Tuple, Value};
 use std::borrow::Cow;
 use std::fmt::Debug;
@@ -37,7 +38,7 @@ pub trait EvalExpr: Debug {
         'c: 'a;
 }
 
-#[derive(Error, Debug, Clone, PartialEq)]
+#[derive(Error, Debug)]
 #[non_exhaustive]
 /// An error in binding an expression for evaluation
 pub enum BindError {
@@ -52,6 +53,9 @@ pub enum BindError {
     #[error("Not yet implemented: {0}")]
     NotYetImplemented(String),
 
+    #[error("Error lowering literal value: {0}")]
+    LiteralValue(#[from] DatumLowerError),
+
     /// Any other error.
     #[error("Bind error: unknown error")]
     Unknown,

partiql-eval/src/eval/expr/operators.rs

@@ -19,17 +19,30 @@ use std::fmt::{Debug, Formatter};
 
 use std::marker::PhantomData;
 
+use partiql_value::datum::{
+    DatumCategory, DatumCategoryRef, DatumLowerResult, DatumValue, SequenceDatum, TupleDatum,
+};
 use std::ops::ControlFlow;
 
 /// Represents a literal in (sub)query, e.g. `1` in `a + 1`.
 #[derive(Clone)]
 pub(crate) struct EvalLitExpr {
-    pub(crate) lit: Value,
+    pub(crate) val: Value,
+}
+
+impl EvalLitExpr {
+    pub(crate) fn new(val: Value) -> Self {
+        Self { val }
+    }
+
+    fn lower(&self) -> DatumLowerResult<EvalLitExpr> {
+        self.val.clone().into_lower().map(Self::new)
+    }
 }
 
 impl Debug for EvalLitExpr {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        self.lit.fmt(f)
+        self.val.fmt(f)
     }
 }
 
@@ -38,7 +51,7 @@ impl BindEvalExpr for EvalLitExpr {
         self,
         _args: Vec<Box<dyn EvalExpr>>,
     ) -> Result<Box<dyn EvalExpr>, BindError> {
-        Ok(Box::new(self.clone()))
+        Ok(Box::new(self.lower()?))
     }
 }
 
@@ -51,7 +64,7 @@ impl EvalExpr for EvalLitExpr {
     where
         'c: 'a,
     {
-        Cow::Borrowed(&self.lit)
+        Cow::Borrowed(&self.val)
     }
 }
 
@@ -379,10 +392,9 @@ impl BindEvalExpr for EvalFnExists {
         args: Vec<Box<dyn EvalExpr>>,
     ) -> Result<Box<dyn EvalExpr>, BindError> {
         UnaryValueExpr::create_with_any::<{ STRICT }, _>(args, |v| {
-            Value::from(match v {
-                Value::Bag(b) => !b.is_empty(),
-                Value::List(l) => !l.is_empty(),
-                Value::Tuple(t) => !t.is_empty(),
+            Value::from(match v.category() {
+                DatumCategoryRef::Tuple(tuple) => !tuple.is_empty(),
+                DatumCategoryRef::Sequence(seq) => !seq.is_empty(),
                 _ => false,
             })
         })
@@ -430,10 +442,9 @@ impl BindEvalExpr for EvalFnCardinality {
         ]
         .into_any_of(&mut bld);
 
-        UnaryValueExpr::create_typed::<{ STRICT }, _>([collections], args, |v| match v {
-            Value::List(l) => Value::from(l.len()),
-            Value::Bag(b) => Value::from(b.len()),
-            Value::Tuple(t) => Value::from(t.len()),
+        UnaryValueExpr::create_typed::<{ STRICT }, _>([collections], args, |v| match v.category() {
+            DatumCategoryRef::Tuple(tuple) => Value::from(tuple.len()),
+            DatumCategoryRef::Sequence(seq) => Value::from(seq.len()),
             _ => Missing,
         })
     }

partiql-eval/src/eval/expr/path.rs

@@ -7,6 +7,10 @@ use partiql_value::Value::Missing;
 use partiql_value::{BindingsName, Tuple, Value};
 
 use partiql_catalog::context::Bindings;
+use partiql_value::datum::{
+    DatumCategory, DatumCategoryOwned, DatumCategoryRef, OwnedSequenceView, OwnedTupleView,
+    RefSequenceView, RefTupleView,
+};
 use std::borrow::Cow;
 use std::fmt::{Debug, Formatter};
 
@@ -84,38 +88,43 @@ impl EvalPathComponent {
         value: &'a Value,
         bindings: &'a Tuple,
         ctx: &'c dyn EvalContext<'c>,
-    ) -> Option<&'a Value> {
-        match (self, value) {
-            (EvalPathComponent::Key(k), Value::Tuple(tuple)) => tuple.get(k),
-            (EvalPathComponent::Index(idx), Value::List(list)) => list.get(*idx),
-            (EvalPathComponent::KeyExpr(ke), Value::Tuple(tuple)) => {
-                as_name(ke.evaluate(bindings, ctx).borrow()).and_then(|key| tuple.get(&key))
+    ) -> Option<Cow<'a, Value>> {
+        let category = value.category();
+        match (self, category) {
+            (EvalPathComponent::Key(k), DatumCategoryRef::Tuple(tuple)) => tuple.get_val(k),
+            (EvalPathComponent::Index(idx), DatumCategoryRef::Sequence(seq)) => seq.get_val(*idx),
+            (EvalPathComponent::KeyExpr(ke), DatumCategoryRef::Tuple(tuple)) => {
+                as_name(ke.evaluate(bindings, ctx).borrow()).and_then(|key| tuple.get_val(&key))
             }
-            (EvalPathComponent::IndexExpr(ie), Value::List(list)) => {
-                as_int(ie.evaluate(bindings, ctx).borrow()).and_then(|i| list.get(i))
+            (EvalPathComponent::IndexExpr(ie), DatumCategoryRef::Sequence(seq)) => {
+                as_int(ie.evaluate(bindings, ctx).borrow()).and_then(|i| seq.get_val(i))
             }
             _ => None,
         }
     }
 
     #[inline]
-    fn take_val<'c>(
+    fn take_val<'a, 'c>(
         &self,
         value: Value,
         bindings: &Tuple,
         ctx: &'c dyn EvalContext<'c>,
-    ) -> Option<Value> {
-        match (self, value) {
-            (EvalPathComponent::Key(k), Value::Tuple(tuple)) => tuple.take_val(k),
-            (EvalPathComponent::Index(idx), Value::List(list)) => list.take_val(*idx),
-            (EvalPathComponent::KeyExpr(ke), Value::Tuple(tuple)) => {
+    ) -> Option<Cow<'a, Value>> {
+        let category = value.into_category();
+        match (self, category) {
+            (EvalPathComponent::Key(k), DatumCategoryOwned::Tuple(tuple)) => tuple.take_val(k),
+            (EvalPathComponent::Index(idx), DatumCategoryOwned::Sequence(seq)) => {
+                seq.take_val(*idx)
+            }
+            (EvalPathComponent::KeyExpr(ke), DatumCategoryOwned::Tuple(tuple)) => {
                 as_name(ke.evaluate(bindings, ctx).borrow()).and_then(|key| tuple.take_val(&key))
             }
-            (EvalPathComponent::IndexExpr(ie), Value::List(list)) => {
-                as_int(ie.evaluate(bindings, ctx).borrow()).and_then(|i| list.take_val(i))
+            (EvalPathComponent::IndexExpr(ie), DatumCategoryOwned::Sequence(seq)) => {
+                as_int(ie.evaluate(bindings, ctx).borrow()).and_then(|i| seq.take_val(i))
             }
             _ => None,
         }
+        .map(Cow::Owned)
     }
 }
 
@@ -128,17 +137,15 @@ impl EvalExpr for EvalPath {
     where
         'c: 'a,
     {
-        let value = self.expr.evaluate(bindings, ctx);
+        let evaluated = self.expr.evaluate(bindings, ctx);
         let mut path_componenents = self.components.iter();
-        match value {
-            Cow::Borrowed(borrowed) => path_componenents
-                .try_fold(borrowed, |v, path| path.get_val(v, bindings, ctx))
-                .map(Cow::Borrowed),
-            Cow::Owned(owned) => path_componenents
-                .try_fold(owned, |v, path| path.take_val(v, bindings, ctx))
-                .map(Cow::Owned),
-        }
-        .unwrap_or(Cow::Owned(Value::Missing))
+
+        path_componenents
+            .try_fold(evaluated, |value, path| match value {
+                Cow::Borrowed(borrowed) => path.get_val(borrowed, bindings, ctx),
+                Cow::Owned(owned) => path.take_val(owned, bindings, ctx),
+            })
+            .unwrap_or(Cow::Owned(Value::Missing))
     }
 }
 

partiql-eval/src/plan.rs

@@ -25,7 +25,6 @@ use crate::eval::expr::{
 use crate::eval::EvalPlan;
 use partiql_catalog::catalog::{Catalog, FunctionEntryFunction};
 use partiql_value::Value;
-use partiql_value::Value::Null;
 
 #[macro_export]
 macro_rules! correct_num_args_or_err {
@@ -361,6 +360,9 @@ impl<'c> EvaluatorPlanner<'c> {
                     }
                     BindError::NotYetImplemented(name) => PlanningError::NotYetImplemented(name),
                     BindError::ArgumentConstraint(msg) => PlanningError::IllegalState(msg),
+                    BindError::LiteralValue(err) => {
+                        PlanningError::IllegalState(format!("Literal error: {}", err))
+                    }
                 };
 
                 self.err(err)
@@ -392,10 +394,7 @@ impl<'c> EvaluatorPlanner<'c> {
             ),
             ValueExpr::Lit(lit) => (
                 "literal",
-                EvalLitExpr {
-                    lit: Value::from(lit.as_ref().clone()),
-                }
-                .bind::<{ STRICT }>(vec![]),
+                EvalLitExpr::new(Value::from(lit.as_ref().clone())).bind::<{ STRICT }>(vec![]),
             ),
             ValueExpr::Path(expr, components) => (
                 "path",
@@ -515,7 +514,7 @@ impl<'c> EvaluatorPlanner<'c> {
                     // If no `ELSE` clause is specified, use implicit `ELSE NULL` (see section 6.9, pg 142 of SQL-92 spec)
                     None => self.unwrap_bind(
                         "simple case default",
-                        EvalLitExpr { lit: Null }.bind::<{ STRICT }>(vec![]),
+                        EvalLitExpr::new(Value::Null).bind::<{ STRICT }>(vec![]),
                     ),
                     Some(def) => self.plan_value::<{ STRICT }>(def),
                 };
@@ -540,7 +539,7 @@ impl<'c> EvaluatorPlanner<'c> {
                     // If no `ELSE` clause is specified, use implicit `ELSE NULL` (see section 6.9, pg 142 of SQL-92 spec)
                     None => self.unwrap_bind(
                         "searched case default",
-                        EvalLitExpr { lit: Null }.bind::<{ STRICT }>(vec![]),
+                        EvalLitExpr::new(Value::Null).bind::<{ STRICT }>(vec![]),
                     ),
                     Some(def) => self.plan_value::<{ STRICT }>(def.as_ref()),
                 };