row eval context

src/algebra/parser.rs

@@ -3,7 +3,9 @@ use crate::data::eval::PartialEvalContext;
 use crate::data::expr::{Expr, StaticExpr};
 use crate::data::parser::parse_scoped_dict;
 use crate::data::tuple::{DataKind, OwnTuple};
-use crate::data::tuple_set::{BindingMap, BindingMapEvalContext, TableId, TupleSet, TupleSetIdx};
+use crate::data::tuple_set::{
+    BindingMap, BindingMapEvalContext, TableId, TupleSet, TupleSetEvalContext, TupleSetIdx,
+};
 use crate::data::typing::Typing;
 use crate::data::value::{StaticValue, Value};
 use crate::ddl::parser::ColExtractor;
@@ -107,7 +109,7 @@ impl<'a> InterpretContext for TempDbContext<'a> {
 pub(crate) trait RelationalAlgebra {
     fn name(&self) -> &str;
     fn binding_map(&self) -> Result<BindingMap>;
-    fn iter<'a>(&'a self) -> Result<Box<dyn Iterator<Item=Result<TupleSet>> + 'a>>;
+    fn iter<'a>(&'a self) -> Result<Box<dyn Iterator<Item = Result<TupleSet>> + 'a>>;
 }
 
 const NAME_RELATION_FROM_VALUES: &str = "Values";
@@ -127,7 +129,7 @@ fn assert_rule(pair: &Pair, rule: Rule, name: &str, u: usize) -> Result<()> {
             u,
             format!("{:?}", pair.as_rule()),
         )
-            .into())
+        .into())
     }
 }
 
@@ -138,7 +140,9 @@ impl RelationFromValues {
         mut args: Pairs,
     ) -> Result<Self> {
         if !matches!(prev, None) {
-            return Err(AlgebraParseError::Unchainable(NAME_RELATION_FROM_VALUES.to_string()).into());
+            return Err(
+                AlgebraParseError::Unchainable(NAME_RELATION_FROM_VALUES.to_string()).into(),
+            );
         }
         let not_enough_args =
             || AlgebraParseError::NotEnoughArguments(NAME_RELATION_FROM_VALUES.to_string());
@@ -206,7 +210,7 @@ impl RelationalAlgebra for RelationFromValues {
         Ok(self.binding_map.clone())
     }
 
-    fn iter<'a>(&'a self) -> Result<Box<dyn Iterator<Item=Result<TupleSet>> + 'a>> {
+    fn iter<'a>(&'a self) -> Result<Box<dyn Iterator<Item = Result<TupleSet>> + 'a>> {
         let it = self.values.iter().map(|vs| {
             let mut tuple = OwnTuple::with_data_prefix(DataKind::Data);
             for v in vs {
@@ -376,7 +380,7 @@ impl<'a> RelationalAlgebra for Insertion<'a> {
         Ok(BTreeMap::from([(self.binding.clone(), inner)]))
     }
 
-    fn iter<'b>(&'b self) -> Result<Box<dyn Iterator<Item=Result<TupleSet>> + 'b>> {
+    fn iter<'b>(&'b self) -> Result<Box<dyn Iterator<Item = Result<TupleSet>> + 'b>> {
         let source_map = self.source.binding_map()?;
         let binding_ctx = BindingMapEvalContext {
             map: &source_map,
@@ -403,37 +407,42 @@ impl<'a> RelationalAlgebra for Insertion<'a> {
             .collect::<Vec<_>>();
         let target_key = self.target_info.table_id();
 
-        let txn = self.ctx.txn.clone();
-        let temp_db = self.ctx.sess.temp.clone();
-        let write_opts = default_write_options();
+        let mut eval_ctx = TupleSetEvalContext {
+            tuple_set: Default::default(),
+            txn: self.ctx.txn.clone(),
+            temp_db: self.ctx.sess.temp.clone(),
+            write_options: default_write_options(),
+        };
 
         Ok(Box::new(self.source.iter()?.map(
             move |tset| -> Result<TupleSet> {
-                let tset = tset?;
-                let mut key = tset.eval_to_tuple(target_key.id, &key_builder)?;
-                let val = tset.eval_to_tuple(DataKind::Data as u32, &val_builder)?;
+                eval_ctx.set_tuple_set(tset?);
+                let mut key = eval_ctx.eval_to_tuple(target_key.id, &key_builder)?;
+                let val = eval_ctx.eval_to_tuple(DataKind::Data as u32, &val_builder)?;
                 if target_key.in_root {
-                    txn.put(&key, &val)?;
+                    eval_ctx.txn.put(&key, &val)?;
                 } else {
-                    temp_db.put(&write_opts, &key, &val)?;
+                    eval_ctx.temp_db.put(&eval_ctx.write_options, &key, &val)?;
                 }
                 if let Some(builder) = &inv_key_builder {
-                    let inv_key = tset.eval_to_tuple(target_key.id, builder)?;
+                    let inv_key = eval_ctx.eval_to_tuple(target_key.id, builder)?;
                     if target_key.in_root {
-                        txn.put(&inv_key, &key)?;
+                        eval_ctx.txn.put(&inv_key, &key)?;
                     } else {
-                        temp_db.put(&write_opts, &inv_key, &key)?;
+                        eval_ctx
+                            .temp_db
+                            .put(&eval_ctx.write_options, &inv_key, &key)?;
                     }
                 }
                 let assoc_vals = assoc_val_builders
                     .iter()
                     .map(|(tid, builder)| -> Result<OwnTuple> {
-                        let ret = tset.eval_to_tuple(DataKind::Data as u32, builder)?;
+                        let ret = eval_ctx.eval_to_tuple(DataKind::Data as u32, builder)?;
                         key.overwrite_prefix(tid.id);
                         if tid.in_root {
-                            txn.put(&key, &ret)?;
+                            eval_ctx.txn.put(&key, &ret)?;
                         } else {
-                            temp_db.put(&write_opts, &key, &ret)?;
+                            eval_ctx.temp_db.put(&eval_ctx.write_options, &key, &ret)?;
                         }
                         Ok(ret)
                     })

src/data/eval.rs

@@ -3,6 +3,7 @@ use crate::data::op::*;
 use crate::data::tuple_set::TupleSetIdx;
 use crate::data::value::{StaticValue, Value};
 use anyhow::Result;
+use cozorocks::{DbPtr, TransactionPtr, WriteOptionsPtr};
 use std::borrow::Cow;
 use std::collections::BTreeMap;
 
@@ -43,12 +44,27 @@ pub enum EvalContextError {
 
 pub(crate) trait RowEvalContext {
     fn resolve(&self, idx: &TupleSetIdx) -> Result<Value>;
+    fn get_temp_db(&self) -> Result<&DbPtr>;
+    fn get_txn(&self) -> Result<&TransactionPtr>;
+    fn get_write_options(&self) -> Result<&WriteOptionsPtr>;
 }
 
 impl RowEvalContext for () {
     fn resolve(&self, _idx: &TupleSetIdx) -> Result<Value> {
         Err(EvalContextError::NullContext.into())
     }
+
+    fn get_temp_db(&self) -> Result<&DbPtr> {
+        Err(EvalContextError::NullContext.into())
+    }
+
+    fn get_txn(&self) -> Result<&TransactionPtr> {
+        Err(EvalContextError::NullContext.into())
+    }
+
+    fn get_write_options(&self) -> Result<&WriteOptionsPtr> {
+        Err(EvalContextError::NullContext.into())
+    }
 }
 
 pub(crate) trait PartialEvalContext {

src/data/tuple_set.rs

@@ -4,6 +4,7 @@ use crate::data::tuple::{OwnTuple, ReifiedTuple};
 use crate::data::typing::Typing;
 use crate::data::value::{StaticValue, Value};
 use anyhow::Result;
+use cozorocks::{DbPtr, TransactionPtr, WriteOptionsPtr};
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
 use std::fmt::{Debug, Formatter};
@@ -201,16 +202,38 @@ where
     }
 }
 
-impl RowEvalContext for TupleSet {
+pub(crate) struct TupleSetEvalContext {
+    pub(crate) tuple_set: TupleSet,
+    pub(crate) txn: TransactionPtr,
+    pub(crate) temp_db: DbPtr,
+    pub(crate) write_options: WriteOptionsPtr,
+}
+
+impl RowEvalContext for TupleSetEvalContext {
     fn resolve(&self, idx: &TupleSetIdx) -> Result<Value> {
-        let val = self.get_value(idx)?;
+        let val = self.tuple_set.get_value(idx)?;
         Ok(val)
     }
+
+    fn get_temp_db(&self) -> Result<&DbPtr> {
+        Ok(&self.temp_db)
+    }
+
+    fn get_txn(&self) -> Result<&TransactionPtr> {
+        Ok(&self.txn)
+    }
+
+    fn get_write_options(&self) -> Result<&WriteOptionsPtr> {
+        Ok(&self.write_options)
+    }
 }
 
 pub(crate) type TupleBuilder<'a> = Vec<(Expr<'a>, Typing)>;
 
-impl TupleSet {
+impl TupleSetEvalContext {
+    pub(crate) fn set_tuple_set(&mut self, tuple_set: TupleSet) {
+        self.tuple_set = tuple_set;
+    }
     pub(crate) fn eval_to_tuple(&self, prefix: u32, builder: &TupleBuilder) -> Result<OwnTuple> {
         let mut target = OwnTuple::with_prefix(prefix);
         for (expr, typing) in builder {

src/grammar.pest

@@ -211,6 +211,9 @@ ra_call = {"." ~ query_ident ~ "(" ~ (ra_arg ~ ",")* ~ ra_arg? ~ ")"}
 ra_expr = { ra_call_expr ~ ra_call* }
 ra_expr_all = _{SOI ~ ra_expr ~ EOI}
 
+insert_values = { "InsertValues" ~ "(" ~ expr ~ ")" ~ ";" }
+insert_values_all = _{SOI ~ insert_values ~ EOI}
+
 scoped_list = { ident ~ ":" ~ "[" ~ (ident ~ ",")* ~ ident? ~ "]"}
 table_with_assocs = { name_in_def ~ ("+" ~ name_in_def)*}
 table_with_assocs_all = _{SOI ~ table_with_assocs ~ EOI}