cleaning up

src/data/op/arithmetic.rs

@@ -318,7 +318,7 @@ impl Op for OpMinus {
         false
     }
     fn name(&self) -> &str {
-        "--"
+        NAME_OP_MINUS
     }
     fn non_null_args(&self) -> bool {
         true

src/data/op/control.rs

@@ -7,8 +7,6 @@ use std::sync::Arc;
 
 type Result<T> = result::Result<T, EvalError>;
 
-pub(crate) struct OpCond;
-
 pub(crate) struct OpCoalesce;
 
 pub(crate) const NAME_OP_COALESCE: &str = "~~";

src/data/tuple.rs

@@ -115,8 +115,6 @@ pub enum DataKind {
 // In storage, key layout is `[0, name, stack_depth]` where stack_depth is a non-positive number as zigzag
 // Also has inverted index `[0, stack_depth, name]` for easy popping of stacks
 
-pub const EMPTY_DATA: [u8; 4] = u32::MAX.to_be_bytes();
-
 impl<T: AsRef<[u8]>> Tuple<T> {
     pub fn data_kind(&self) -> Result<DataKind> {
         use DataKind::*;

src/ddl/reify.rs

@@ -889,11 +889,11 @@ impl<'a> DdlContext for MainDbContext<'a> {
 
         if let Some(existing_key) = self
             .txn
-            .get_for_update_owned(&default_read_options(), &name_key)?
+            .get_for_update_owned(&self.sess.r_opts_main, &name_key)?
         {
             if let Some(existing) = self
                 .txn
-                .get_for_update_owned(&default_read_options(), existing_key)?
+                .get_for_update_owned(&self.sess.r_opts_main, existing_key)?
             {
                 if let Ok(mut existing_info) = TableInfo::try_from(Tuple::new(existing)) {
                     existing_info.set_table_id(info.table_id());
@@ -912,14 +912,14 @@ impl<'a> DdlContext for MainDbContext<'a> {
         info.set_table_id(table_id);
         idx_key.push_int(tid as i64);
 
-        let read_opts = default_read_options();
+        let read_opts = &self.sess.r_opts_main;
 
         match &info {
             TableInfo::Edge(info) => {
                 let mut key = OwnTuple::with_prefix(0);
                 key.push_int(info.src_id.id as i64);
                 key.push_int(DataKind::Edge as i64);
-                let mut current = match self.txn.get_for_update_owned(&read_opts, &key)? {
+                let mut current = match self.txn.get_for_update_owned(read_opts, &key)? {
                     Some(v) => OwnTuple::new(v.as_ref().to_vec()),
                     None => OwnTuple::with_prefix(0),
                 };
@@ -929,7 +929,7 @@ impl<'a> DdlContext for MainDbContext<'a> {
                 key.truncate_all();
                 key.push_int(info.dst_id.id as i64);
                 key.push_int(DataKind::EdgeBwd as i64);
-                let mut current = match self.txn.get_for_update_owned(&read_opts, &key)? {
+                let mut current = match self.txn.get_for_update_owned(read_opts, &key)? {
                     Some(v) => OwnTuple::new(v.as_ref().to_vec()),
                     None => OwnTuple::with_prefix(0),
                 };
@@ -940,7 +940,7 @@ impl<'a> DdlContext for MainDbContext<'a> {
                 let mut key = OwnTuple::with_prefix(0);
                 key.push_int(info.src_id.id as i64);
                 key.push_int(DataKind::Assoc as i64);
-                let mut current = match self.txn.get_for_update_owned(&read_opts, &key)? {
+                let mut current = match self.txn.get_for_update_owned(read_opts, &key)? {
                     Some(v) => OwnTuple::new(v.as_ref().to_vec()),
                     None => OwnTuple::with_prefix(0),
                 };
@@ -951,7 +951,7 @@ impl<'a> DdlContext for MainDbContext<'a> {
                 let mut key = OwnTuple::with_prefix(0);
                 key.push_int(info.src_id.id as i64);
                 key.push_int(DataKind::Index as i64);
-                let mut current = match self.txn.get_for_update_owned(&read_opts, &key)? {
+                let mut current = match self.txn.get_for_update_owned(read_opts, &key)? {
                     Some(v) => OwnTuple::new(v.as_ref().to_vec()),
                     None => OwnTuple::with_prefix(0),
                 };

src/grammar.pest

@@ -184,7 +184,8 @@ seq_def = { "sequence" ~ name_in_def ~ ";" }
 
 definition = _{ node_def | assoc_def | edge_def | index_def | seq_def }
 definition_all = _{SOI ~ definition ~ EOI}
-statement = _{ definition | persist_block }
+statement = _{ scope | definition }
+scope = {"{" ~ statement* ~ "}"}
 
 persist_block = {"persist!" ~ "{" ~ definition* ~ "}" }
 

src/parser/text_identifier.rs

@@ -114,16 +114,4 @@ pub(crate) fn build_name_in_def(pair: Pair, forbid_underscore: bool) -> Result<S
     } else {
         Ok(name)
     }
-}
+}
-
-pub(crate) fn parse_col_name(pair: Pair) -> Result<(String, bool)> {
-    let mut pairs = pair.into_inner();
-    let mut is_key = false;
-    let mut nxt_pair = pairs.next().unwrap();
-    if nxt_pair.as_rule() == Rule::key_marker {
-        is_key = true;
-        nxt_pair = pairs.next().unwrap();
-    }
-
-    Ok((build_name_in_def(nxt_pair, true)?, is_key))
-}

src/runtime/instance.rs

@@ -7,7 +7,7 @@ use crate::runtime::options::*;
 use crate::runtime::session::Session;
 use cozorocks::*;
 use log::error;
-use std::sync::{Arc, Mutex, RwLock};
+use std::sync::{Arc, Mutex};
 use std::{mem, result};
 
 #[derive(thiserror::Error, Debug)]
@@ -65,17 +65,14 @@ pub(crate) struct SessionHandle {
     pub(crate) status: SessionStatus,
 }
 
-pub(crate) type TableLock = Arc<RwLock<()>>;
-
 pub struct DbInstance {
     pub(crate) main: DbPtr,
     options: OptionsPtrShared,
-    tdb_options: TDbOptions,
+    _tdb_options: TDbOptions,
     path: String,
     session_handles: Mutex<Vec<Arc<Mutex<SessionHandle>>>>,
     optimistic: bool,
     destroy_on_close: bool,
-    table_locks: TableLock,
 }
 
 impl DbInstance {
@@ -85,13 +82,12 @@ impl DbInstance {
         let main = DbPtr::open(&options, &tdb_options, path)?;
         Ok(Self {
             options,
-            tdb_options,
+            _tdb_options: tdb_options,
             main,
             optimistic,
             path: path.to_string(),
             session_handles: vec![].into(),
             destroy_on_close: false,
-            table_locks: Default::default(),
         })
     }
 }
@@ -149,7 +145,6 @@ impl DbInstance {
             stack: vec![],
             cur_table_id: 0.into(),
             params: Default::default(),
-            table_locks: self.table_locks.clone(),
             tables: Default::default(),
             table_assocs: Default::default(),
         })

src/runtime/options.rs

@@ -1,6 +1,6 @@
 use crate::data::tuple::PREFIX_LEN;
 use cozorocks::{
-    FlushOptionsPtr, OTxnDbOptionsPtr, OTxnOptionsPtr, OptionsPtr, PTxnDbOptionsPtr,
+    OTxnDbOptionsPtr, OTxnOptionsPtr, OptionsPtr, PTxnDbOptionsPtr,
     PTxnOptionsPtr, ReadOptionsPtr, RustComparatorPtr, TDbOptions, TransactOptions,
     WriteOptionsPtr,
 };
@@ -32,9 +32,9 @@ pub fn default_write_options() -> WriteOptionsPtr {
     WriteOptionsPtr::default()
 }
 
-pub fn default_flush_options() -> FlushOptionsPtr {
+// pub fn default_flush_options() -> FlushOptionsPtr {
-    FlushOptionsPtr::default()
+//     FlushOptionsPtr::default()
-}
+// }
 
 pub fn default_txn_db_options(optimistic: bool) -> TDbOptions {
     if optimistic {

src/runtime/session.rs

@@ -6,7 +6,7 @@ use crate::data::value::{StaticValue, Value};
 use crate::ddl::parser::DdlSchema;
 use crate::ddl::reify::{DdlContext, DdlReifyError, TableInfo};
 use crate::parser::{CozoParser, Pair, Rule};
-use crate::runtime::instance::{DbInstanceError, SessionHandle, SessionStatus, TableLock};
+use crate::runtime::instance::{DbInstanceError, SessionHandle, SessionStatus};
 use crate::runtime::options::{default_txn_options, default_write_options};
 use cozorocks::{DbPtr, ReadOptionsPtr, TransactionPtr, WriteOptionsPtr};
 use lazy_static::lazy_static;
@@ -41,7 +41,6 @@ pub struct Session {
     pub(crate) stack: Vec<SessionStackFrame>,
     pub(crate) params: BTreeMap<String, StaticValue>,
     pub(crate) session_handle: Arc<Mutex<SessionHandle>>,
-    pub(crate) table_locks: TableLock,
     pub(crate) tables: BTreeMap<u32, TableInfo>,
     pub(crate) table_assocs: TableAssocMap,
 }
@@ -198,7 +197,9 @@ impl Drop for Session {
 
 #[cfg(test)]
 pub(crate) mod tests {
+    use crate::data::tuple::Tuple;
     use crate::DbInstance;
+    use crate::runtime::options::default_read_options;
 
     const HR_TEST_SCRIPT: &str = include_str!("../../test_data/hr.cozo");
 
@@ -215,5 +216,14 @@ pub(crate) mod tests {
         sess.run_script(persist_hr_test()).unwrap();
         sess.run_script(persist_hr_test()).unwrap();
         dbg!(&sess.tables);
+        let mut opts = default_read_options();
+        opts.set_total_order_seek(true);
+        let it = sess.main.iterator(&opts);
+        it.to_first();
+        while it.is_valid() {
+            let (k, v) = it.pair().unwrap();
+            dbg!((Tuple::new(k), Tuple::new(v)));
+            it.next();
+        }
     }
 }