some cleanup

cozorocks/src/lib.rs

@@ -2,7 +2,7 @@ mod bridge;
 
 use bridge::*;
 
-use std::fmt::{Display, Formatter, write};
+use std::fmt::{Display, Formatter};
 use std::fmt::Debug;
 use std::ops::{Deref, DerefMut};
 use cxx::{let_cxx_string};
@@ -536,7 +536,7 @@ impl TransactionPtr {
         match res {
             Ok(r) => Ok(Some(r)),
             Err(e)  if e.status.code == StatusCode::kNotFound => Ok(None),
-            res => res.map(|v| None)
+            res => res.map(|_| None)
         }
     }
     #[inline]

src/db/engine.rs

@@ -12,7 +12,6 @@ use rand::Rng;
 use crate::error::{CozoError, Result};
 use crate::error::CozoError::{Poisoned, SessionErr};
 use crate::relation::tuple::Tuple;
-use crate::relation::value::{StaticValue, Value};
 
 pub struct EngineOptions {
     cmp: RustComparatorPtr,
@@ -109,7 +108,7 @@ impl Engine {
             perm_cf: SharedPtr::null(),
             temp_cf: SharedPtr::null(),
             handle,
-            params: BTreeMap::default()
+            params: BTreeMap::default(),
         };
         sess.start()?;
         Ok(sess)

src/db/eval.rs

@@ -1,15 +1,12 @@
 use std::borrow::Cow;
 use std::collections::{BTreeMap, HashSet};
-use std::path::is_separator;
-use std::process::id;
 use pest::Parser as PestParser;
 use pest::iterators::{Pair, Pairs};
-use cozorocks::{SlicePtr, StatusCode};
+use cozorocks::{SlicePtr};
 use crate::db::engine::{Session};
-use crate::relation::table::{Table};
 use crate::relation::tuple::{OwnTuple, Tuple};
 use crate::relation::typing::Typing;
-use crate::relation::value::{StaticValue, Value};
+use crate::relation::value::{Value};
 use crate::error::{CozoError, Result};
 use crate::relation::data::DataKind;
 use crate::parser::{Parser, Rule};
@@ -27,9 +24,6 @@ pub trait Environment<'t, T: AsRef<[u8]>> where Self: Sized {
         data.push_value(val);
         self.define_data(name, data, in_root)
     }
-    fn define_table(&mut self, table: &Table, in_root: bool) -> Result<()> {
-        todo!()
-    }
     fn resolve(&self, name: &str) -> Result<Option<Tuple<T>>>;
     fn resolve_param(&self, name: &str) -> Result<Value>;
     fn resolve_value(&self, name: &str) -> Result<Option<Value>> {
@@ -813,25 +807,31 @@ mod tests {
                 email: Text
             }
         "#;
-        // let mut env = MemoryEnv::default();
-        // let mut parsed = Parser::parse(Rule::file, s).unwrap();
-        //
-        // let t = parsed.next().unwrap();
-        // env.run_definition(t).unwrap();
-        // println!("{:?}", env.resolve("Person"));
-        //
-        // let t = parsed.next().unwrap();
-        // env.run_definition(t).unwrap();
-        // println!("{:?}", env.resolve("Friend"));
-        //
-        // let t = parsed.next().unwrap();
-        // env.run_definition(t).unwrap();
-        // println!("{:?}", env.resolve("XXY"));
-        //
-        // let t = parsed.next().unwrap();
-        // env.run_definition(t).unwrap();
-        // println!("{:?}", env.resolve("WorkInfo"));
-        // println!("{:?}", env.resolve("Person"));
+        let db_path = "_test_node";
+        {
+            let engine = Engine::new(db_path.to_string(), true).unwrap();
+            let mut env = engine.session().unwrap();
+
+            let mut parsed = Parser::parse(Rule::file, s).unwrap();
+
+            let t = parsed.next().unwrap();
+            env.run_definition(t).unwrap();
+            println!("{:?}", env.resolve("Person"));
+
+            let t = parsed.next().unwrap();
+            env.run_definition(t).unwrap();
+            println!("{:?}", env.resolve("Friend"));
+
+            let t = parsed.next().unwrap();
+            env.run_definition(t).unwrap();
+            println!("{:?}", env.resolve("XXY"));
+
+            let t = parsed.next().unwrap();
+            env.run_definition(t).unwrap();
+            println!("{:?}", env.resolve("WorkInfo"));
+            println!("{:?}", env.resolve("Person"));
+        }
+        fs::remove_dir_all(db_path).unwrap();
     }
 
     #[test]

src/db/mutation.rs

@@ -75,7 +75,7 @@ impl<'a, 'b, 't> MutationManager<'a, 'b, 't> {
             None => {
                 self.cache.insert(tbl_name.to_string(), ());
             }
-            Some(t) => {},
+            Some(_t) => {}
         }
         Ok(())
     }
@@ -124,7 +124,7 @@ mod tests {
                 insert [{id: 1, name: "Jack"}, {id: 2, name: "Joe", habits: ["Balls"]}] as Person;
             "#;
             let p = Parser::parse(Rule::file, s).unwrap().next().unwrap();
-            sess.run_mutation(p);
+            sess.run_mutation(p).unwrap();
         }
 
         drop(engine);

src/db/plan.rs

@@ -1,36 +1,36 @@
-struct Filter;
-
-enum QueryPlan {
-    Union {
-        args: Vec<QueryPlan>
-    },
-    Intersection {
-        args: Vec<QueryPlan>
-    },
-    Difference {
-        left: Box<QueryPlan>,
-        right: Box<QueryPlan>,
-    },
-    Selection {
-        arg: Box<QueryPlan>,
-        filter: (),
-    },
-    Projection {
-        arg: Box<QueryPlan>,
-        keys: (),
-        fields: (),
-    },
-    Product {
-        args: Vec<QueryPlan>
-    },
-    Join {
-        args: Vec<QueryPlan>
-    },
-    LeftJoin {
-        left: Box<QueryPlan>,
-        right: Box<QueryPlan>
-    },
-    BaseRelation {
-        relation: ()
-    },
-}
+// struct Filter;
+//
+// enum QueryPlan {
+//     Union {
+//         args: Vec<QueryPlan>
+//     },
+//     Intersection {
+//         args: Vec<QueryPlan>
+//     },
+//     Difference {
+//         left: Box<QueryPlan>,
+//         right: Box<QueryPlan>,
+//     },
+//     Selection {
+//         arg: Box<QueryPlan>,
+//         filter: (),
+//     },
+//     Projection {
+//         arg: Box<QueryPlan>,
+//         keys: (),
+//         fields: (),
+//     },
+//     Product {
+//         args: Vec<QueryPlan>
+//     },
+//     Join {
+//         args: Vec<QueryPlan>
+//     },
+//     LeftJoin {
+//         left: Box<QueryPlan>,
+//         right: Box<QueryPlan>
+//     },
+//     BaseRelation {
+//         relation: ()
+//     },
+// }

src/error.rs

@@ -82,8 +82,9 @@ pub enum CozoError {
     //     #[error(transparent)]
 //     Storage(#[from] cozo_rocks::BridgeStatus),
 //
-//     #[error(transparent)]
-//     Io(#[from] std::io::Error),
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+
     #[error("Session error")]
     SessionErr,
 

src/parser/text_identifier.rs

@@ -1,5 +1,4 @@
 use pest::iterators::Pair;
-use crate::parser::Parser;
 use crate::parser::Rule;
 use crate::error::{CozoError, Result};
 use crate::parser::number::parse_int;

src/relation/tuple.rs

@@ -1,10 +1,8 @@
 use std::borrow::{Cow};
 use std::cell::RefCell;
 use std::collections::BTreeMap;
-use std::convert::Infallible;
 use std::fmt::{Debug, Formatter};
 use std::hash::{Hash, Hasher};
-use std::ptr::write;
 use uuid::Uuid;
 use crate::relation::data::DataKind;
 use crate::relation::value::{Tag, Value};

src/relation/typing.rs

@@ -1,5 +1,4 @@
-use std::collections::BTreeMap;
-use std::fmt::{Display, Formatter, write};
+use std::fmt::{Display, Formatter};
 use pest::iterators::Pair;
 use crate::error::{Result, CozoError};
 use crate::relation::value::Value;

src/relation/value.rs

@@ -376,7 +376,7 @@ fn build_expr_primary(pair: Pair<Rule>) -> Result<Value> {
         Rule::boolean => Ok(Value::Bool(pair.as_str() == "true")),
         Rule::quoted_string | Rule::s_quoted_string | Rule::raw_string => Ok(
             Value::Text(Cow::Owned(parse_string(pair)?))),
-        Rule::list => Ok(pair.into_inner().map(|v| build_expr_primary(v)).collect::<Result<Vec<Value>>>()?.into()),
+        Rule::list => Ok(pair.into_inner().map(build_expr_primary).collect::<Result<Vec<Value>>>()?.into()),
         Rule::dict => {
             Ok(pair.into_inner().map(|p| {
                 match p.as_rule() {