memory env implementation

src/db/eval.rs

@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 use cozorocks::{SlicePtr, StatusCode};
 use crate::db::engine::{Session};
 use crate::relation::table::{Table};
-use crate::relation::tuple::{Tuple};
+use crate::relation::tuple::{OwnTuple, Tuple};
 use crate::relation::typing::Typing;
 use crate::relation::value::Value;
 use crate::error::{CozoError, Result};
@@ -29,8 +29,8 @@ pub trait Environment<T: AsRef<[u8]>> {
     }
     fn resolve(&self, name: &str) -> Result<Option<Tuple<T>>>;
     fn delete_defined(&mut self, name: &str, in_root: bool) -> Result<()>;
-    fn define_data(&mut self, name: &str, data: Tuple<Vec<u8>>, in_root: bool) -> Result<()>;
-    fn encode_definable_key(&self, name: &str, in_root: bool) -> Tuple<Vec<u8>> {
+    fn define_data(&mut self, name: &str, data: OwnTuple, in_root: bool) -> Result<()>;
+    fn encode_definable_key(&self, name: &str, in_root: bool) -> OwnTuple {
         let depth_code = if in_root { 0 } else { self.get_stack_depth() as i64 };
         let mut tuple = Tuple::with_null_prefix();
         tuple.push_str(name);
@@ -40,8 +40,8 @@ pub trait Environment<T: AsRef<[u8]>> {
 }
 
 pub struct MemoryEnv {
-    root: BTreeMap<String, Tuple<Vec<u8>>>,
-    stack: Vec<BTreeMap<String, Tuple<Vec<u8>>>>,
+    root: BTreeMap<String, OwnTuple>,
+    stack: Vec<BTreeMap<String, OwnTuple>>,
 }
 
 impl Default for MemoryEnv {
@@ -50,7 +50,7 @@ impl Default for MemoryEnv {
     }
 }
 
-impl Environment<Tuple<Vec<u8>>> for MemoryEnv {
+impl Environment<Vec<u8>> for MemoryEnv {
     fn get_stack_depth(&self) -> i32 {
         -(self.stack.len() as i32)
     }
@@ -66,28 +66,36 @@ impl Environment<Tuple<Vec<u8>>> for MemoryEnv {
         Ok(())
     }
 
-    fn define_variable(&mut self, name: &str, val: &Value, in_root: bool) -> Result<()> {
-        todo!()
-    }
-
-    fn define_type_alias(&mut self, name: &str, typ: &Typing, in_root: bool) -> Result<()> {
-        todo!()
-    }
-
-    fn define_table(&mut self, table: &Table, in_root: bool) -> Result<()> {
-        todo!()
-    }
-
-    fn resolve(&self, name: &str) -> Result<Option<Tuple<Tuple<Vec<u8>>>>> {
-        todo!()
+    fn resolve(&self, name: &str) -> Result<Option<OwnTuple>> {
+        for layer in self.stack.iter() {
+            if let Some(res) = layer.get(name) {
+                return Ok(Some(res.clone()))
+            }
+        }
+        Ok(self.root.get(name).cloned())
     }
 
     fn delete_defined(&mut self, name: &str, in_root: bool) -> Result<()> {
-        todo!()
+        if in_root {
+            self.root.remove(name);
+        } else {
+            for layer in self.stack.iter_mut().rev() {
+                if let Some(_) = layer.remove(name) {
+                    return Ok(());
+                }
+            }
+        }
+        Ok(())
     }
 
-    fn define_data(&mut self, name: &str, data: Tuple<Vec<u8>>, in_root: bool) -> Result<()> {
-        todo!()
+    fn define_data(&mut self, name: &str, data: OwnTuple, in_root: bool) -> Result<()> {
+        if in_root {
+            self.root.insert(name.to_string(), data);
+        } else {
+            let last = self.stack.last_mut().unwrap();
+            last.insert(name.to_string(), data);
+        }
+        Ok(())
     }
 }
 
@@ -171,7 +179,7 @@ impl<'a> Environment<SlicePtr> for Session<'a> {
         Ok(())
     }
 
-    fn define_data(&mut self, name: &str, data: Tuple<Vec<u8>>, in_root: bool) -> Result<()> {
+    fn define_data(&mut self, name: &str, data: OwnTuple, in_root: bool) -> Result<()> {
         let key = self.encode_definable_key(name, in_root);
         if in_root {
             self.txn.put(true, &self.perm_cf, key, data)?;

src/db/table_def.rs

@@ -1,10 +1,10 @@
 use pest::iterators::Pair;
 use crate::db::engine::Session;
 use crate::parser::Rule;
-use crate::relation::tuple::Tuple;
+use crate::relation::tuple::{OwnTuple, Tuple};
 
 impl<'a> Session<'a> {
-    pub fn parse_table_def(&self, pair: Pair<Rule>) -> Tuple<Vec<u8>> {
+    pub fn parse_table_def(&self, pair: Pair<Rule>) -> OwnTuple {
         todo!()
     }
 }

src/relation/tuple.rs

@@ -21,6 +21,8 @@ impl<T> AsRef<[u8]> for Tuple<T> where T: AsRef<[u8]> {
     }
 }
 
+pub type OwnTuple = Tuple<Vec<u8>>;
+
 const PREFIX_LEN: usize = 4;
 
 impl<T: AsRef<[u8]>> Tuple<T> {
@@ -224,7 +226,7 @@ impl<'a, T: AsRef<[u8]>> Iterator for TupleIter<'a, T> {
     }
 }
 
-impl Tuple<Vec<u8>> {
+impl OwnTuple {
     #[inline]
     pub fn with_null_prefix() -> Self {
         Tuple::with_prefix(0)
@@ -372,7 +374,7 @@ impl Tuple<Vec<u8>> {
     }
 }
 
-impl<'a> Extend<Value<'a>> for Tuple<Vec<u8>> {
+impl<'a> Extend<Value<'a>> for OwnTuple {
     #[inline]
     fn extend<T: IntoIterator<Item=Value<'a>>>(&mut self, iter: T) {
         for v in iter {

src/relation/typing.rs

@@ -6,7 +6,7 @@ use crate::relation::value::Value;
 use pest::Parser as PestParser;
 use cozorocks::SlicePtr;
 use crate::db::engine::Session;
-use crate::db::eval::Environment;
+use crate::db::eval::{Environment, MemoryEnv};
 use crate::parser::Parser;
 use crate::parser::Rule;
 use crate::parser::text_identifier::build_name_in_def;
@@ -118,7 +118,7 @@ impl TryFrom<&str> for Typing {
 
     fn try_from(value: &str) -> Result<Self> {
         let pair = Parser::parse(Rule::typing, value)?.next().unwrap();
-        Typing::from_pair::<SlicePtr, Session>(pair, None)
+        Typing::from_pair::<Vec<u8>, MemoryEnv>(pair, None)
     }
 }