silence it

Cargo.toml

@@ -18,4 +18,5 @@ thiserror = "1.0.30"
 log = "0.4.16"
 env_logger = "0.9.0"
 actix-web = "4.0.1"
+extsort = "0.4.2"
 cozorocks = { path = "cozorocks" }

src/algebra/op/from.rs

@@ -157,6 +157,7 @@ pub(crate) enum ChainPartEdgeDir {
 pub(crate) enum JoinType {
     Inner,
     Left,
+    #[allow(dead_code)]
     Right,
     // FullOuter,
 }
@@ -180,8 +181,6 @@ pub(crate) struct ChainEl {
 
 #[derive(thiserror::Error, Debug)]
 pub(crate) enum JoinError {
-    #[error("Cannot have both left and right join marker in a chain segment")]
-    NoFullOuterInChain,
     #[error("Must specify edge direction")]
     BidiEdge,
 }

src/algebra/op/group.rs

@@ -203,7 +203,7 @@ impl<'b> RelationalAlgebra for GroupOp<'b> {
                     )
                 })
                 .collect::<BTreeMap<_, _>>(),
-            ex => return Err(SelectOpError::NeedsDict.into()),
+            _ex => return Err(SelectOpError::NeedsDict.into()),
         };
 
         for (i, (k, _)) in extract_map.iter().enumerate() {
@@ -255,7 +255,7 @@ impl<'b> RelationalAlgebra for GroupOp<'b> {
                 .values()
                 .map(|v| Expr::Const(v.clone()))
                 .collect::<Vec<_>>(),
-            ex => return Err(SelectOpError::NeedsDict.into()),
+            _ex => return Err(SelectOpError::NeedsDict.into()),
         };
 
         for ex in extraction_vec {

src/algebra/op/merge.rs

@@ -100,7 +100,7 @@ impl<'a> MergeJoin<'a> {
                     }
                     join_keys.push((left_condition, right_condition))
                 }
-                ex => return Err(JoinError::JoinCondition.into()),
+                _ex => return Err(JoinError::JoinCondition.into()),
             }
         }
 

src/algebra/op/nested_loop.rs

@@ -80,7 +80,7 @@ impl<'b> RelationalAlgebra for NestedLoopLeft<'b> {
             })
             .collect::<Result<Vec<_>>>()?;
         let table_id = self.right.table_id();
-        let mut key_tuple = OwnTuple::with_prefix(table_id.id);
+        let key_tuple = OwnTuple::with_prefix(table_id.id);
         let txn = self.ctx.txn.clone();
         let temp_db = self.ctx.sess.temp.clone();
         let w_opts = default_write_options();

src/algebra/op/select.rs

@@ -116,7 +116,7 @@ impl<'b> RelationalAlgebra for SelectOp<'b> {
                     )
                 })
                 .collect::<BTreeMap<_, _>>(),
-            ex => return Err(SelectOpError::NeedsDict.into()),
+            _ex => return Err(SelectOpError::NeedsDict.into()),
         };
         Ok(BindingMap {
             inner_map: BTreeMap::from([(self.binding.clone(), extract_map)]),
@@ -137,7 +137,7 @@ impl<'b> RelationalAlgebra for SelectOp<'b> {
                 .values()
                 .map(|v| Expr::Const(v.clone()))
                 .collect::<Vec<_>>(),
-            ex => return Err(SelectOpError::NeedsDict.into()),
+            _ex => return Err(SelectOpError::NeedsDict.into()),
         };
 
         extraction_vec.iter().for_each(|ex| ex.aggr_reset());

src/algebra/op/walk.rs

@@ -18,8 +18,10 @@ use crate::parser::{Pair, Pairs, Rule};
 use crate::runtime::options::{default_read_options, default_write_options};
 use anyhow::Result;
 use cozorocks::RowIterator;
+use extsort::Sortable;
 use std::cmp::{Ordering, Reverse};
 use std::collections::{BTreeMap, BTreeSet};
+use std::io::{Read, Write};
 use std::mem;
 
 pub(crate) const NAME_WALK: &str = "Walk";
@@ -112,7 +114,7 @@ impl<'a> WalkOp<'a> {
                             },
                         )
                         .collect::<Result<Vec<_>>>()?;
-                    it = Box::new(in_mem_sort(it, sort_exprs)?)
+                    it = Box::new(maybe_in_mem_sort(it, sort_exprs)?)
                 }
                 WalkElOp::Filter(expr) => {
                     let expr = expr.clone().partial_eval(&first_binding_ctx)?;
@@ -400,6 +402,7 @@ impl<'a> WalkOp<'a> {
 #[derive(Debug)]
 pub(crate) struct StartingEl {
     node_info: NodeInfo,
+    #[allow(dead_code)]
     assocs: Vec<AssocInfo>,
     binding: String,
     pivot: bool,
@@ -409,9 +412,11 @@ pub(crate) struct StartingEl {
 #[derive(Debug)]
 pub(crate) struct HoppingEls {
     node_info: NodeInfo,
+    #[allow(dead_code)]
     node_assocs: Vec<AssocInfo>,
     node_binding: String,
     edge_info: EdgeInfo,
+    #[allow(dead_code)]
     edge_assocs: Vec<AssocInfo>,
     edge_binding: String,
     direction: ChainPartEdgeDir,
@@ -435,8 +440,6 @@ pub(crate) enum WalkError {
     UnboundFilter,
     #[error("No/multiple collectors")]
     CollectorNumberMismatch,
-    #[error("Starting el cannot have sorters")]
-    SorterOnStart,
     #[error("Unsupported operation {0} on walk element")]
     UnsupportedWalkOp(String),
     #[error("Wrong argument to walk op")]
@@ -909,7 +912,7 @@ fn clustered_in_mem_sort(
     Ok(it)
 }
 
-fn in_mem_sort(
+fn maybe_in_mem_sort(
     it: Box<dyn Iterator<Item = Result<TupleSet>>>,
     sort_exprs: Vec<(Expr, SortDirection)>,
 ) -> Result<impl Iterator<Item = Result<TupleSet>>> {
@@ -919,30 +922,138 @@ fn in_mem_sort(
         }
     }
 
-    let mut collected: Vec<(Vec<Value>, TupleSet)> = it
+    let collected_iter = it.map(move |v| match v {
-        .map(|v| match v {
+        Err(err) => {
-            Err(e) => Err(e),
+            dbg!(err);
-            Ok(v) => {
+            TupleSetSortEl {
-                match sort_exprs
+                is_ok: false,
-                    .iter()
+                keys: vec![],
-                    .map(|(ex, dir)| -> Result<Value> {
+                tset: Default::default(),
-                        let mut res = ex.row_eval(&v)?.into_static();
-                        if *dir == SortDirection::Dsc {
-                            res = Value::DescVal(Reverse(res.into()))
-                        }
-                        Ok(res)
-                    })
-                    .collect::<Result<Vec<_>>>()
-                {
-                    Err(e) => Err(e),
-                    Ok(sort_vals) => Ok((sort_vals, v.into_owned())),
-                }
             }
-        })
+        }
-        .collect::<Result<Vec<_>>>()?;
+        Ok(v) => {
+            match sort_exprs
+                .iter()
+                .map(|(ex, dir)| -> Result<Value> {
+                    let mut res = ex.row_eval(&v)?.into_static();
+                    if *dir == SortDirection::Dsc {
+                        res = Value::DescVal(Reverse(res.into()))
+                    }
+                    Ok(res)
+                })
+                .collect::<Result<Vec<_>>>()
+            {
+                Err(_) => TupleSetSortEl {
+                    is_ok: false,
+                    keys: vec![],
+                    tset: Default::default(),
+                },
+                Ok(sort_vals) => TupleSetSortEl {
+                    is_ok: true,
+                    keys: sort_vals,
+                    tset: v.into_owned(),
+                },
+            }
+        }
+    });
+    let sorter = extsort::ExternalSorter::new();
+    let ret = sorter.sort(collected_iter).unwrap();
+    Ok(ret.map(|st| {
+        if st.is_ok {
+            Ok(st.tset)
+        } else {
+            Err(AlgebraParseError::Sorting.into())
+        }
+    }))
+}
+
+#[derive(Eq, PartialEq)]
+struct TupleSetSortEl<'a> {
+    is_ok: bool,
+    keys: Vec<Value<'a>>,
+    tset: TupleSet,
+}
+
+impl<'a> PartialOrd for TupleSetSortEl<'a> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
 
-    collected.sort_by(sort_value_comparator);
+impl<'a> Ord for TupleSetSortEl<'a> {
-    Ok(collected.into_iter().map(|(_, v)| Ok(v)))
+    fn cmp(&self, other: &Self) -> Ordering {
+        match self.is_ok.cmp(&other.is_ok) {
+            Ordering::Equal => self.keys.cmp(&other.keys),
+            v => v,
+        }
+    }
+}
+
+impl<'a> Sortable for TupleSetSortEl<'a> {
+    fn encode<W: Write>(&self, writer: &mut W) {
+        let mut out = OwnTuple::with_null_prefix();
+        if !self.is_ok {
+            out.push_null();
+            writer.write_all(out.as_ref()).unwrap();
+        }
+
+        out.push_int(self.keys.len() as i64);
+        for val in &self.keys {
+            out.push_value(val);
+        }
+
+        out.push_int(self.tset.keys.len() as i64);
+        out.push_int(self.tset.vals.len() as i64);
+        for k in &self.tset.keys {
+            out.push_bytes(k.as_ref());
+        }
+        for v in &self.tset.vals {
+            out.push_bytes(v.as_ref());
+        }
+        writer.write_all(out.as_ref()).unwrap()
+    }
+
+    fn decode<R: Read>(reader: &mut R) -> Option<Self> {
+        let mut buf = vec![];
+        reader.read_to_end(&mut buf).ok()?;
+        let source = OwnTuple::new(buf);
+        let key_len = match source.get_int(0) {
+            Ok(len) => len as usize,
+            Err(err) => {
+                dbg!(err);
+                return Some(Self {
+                    is_ok: false,
+                    keys: vec![],
+                    tset: Default::default(),
+                });
+            }
+        };
+        let mut keys = Vec::with_capacity(key_len);
+        for i in 1..(key_len + 1) {
+            keys.push(source.get(i).ok()?.into_static());
+        }
+        let k_len = source.get_int(key_len + 1).ok()? as usize;
+        let v_len = source.get_int(key_len + 2).ok()? as usize;
+        let mut tset = TupleSet {
+            keys: Vec::with_capacity(k_len),
+            vals: Vec::with_capacity(v_len),
+        };
+        for i in 3 + key_len..3 + key_len + k_len {
+            let d = source.get(i).ok()?;
+            let d = d.get_bytes()?;
+            tset.keys.push(OwnTuple::new(d.to_vec()).into());
+        }
+        for i in 3 + key_len + k_len..3 + key_len + k_len + v_len {
+            let d = source.get(i).ok()?;
+            let d = d.get_bytes()?;
+            tset.vals.push(OwnTuple::new(d.to_vec()).into());
+        }
+        Some(Self {
+            is_ok: true,
+            keys,
+            tset,
+        })
+    }
 }
 
 fn sort_value_comparator(a: &(Vec<Value>, TupleSet), b: &(Vec<Value>, TupleSet)) -> Ordering {
@@ -1064,7 +1175,7 @@ pub(crate) fn parse_walk_conditions_and_collectors(
     ctx: &TempDbContext,
     args: Pairs,
     starting_el: &mut StartingEl,
-    hops: &mut Vec<HoppingEls>,
+    hops: &mut [HoppingEls],
     binding_map: &BindingMap,
 ) -> Result<(String, BTreeMap<String, Expr>)> {
     let mut collectors = vec![];
@@ -1139,13 +1250,13 @@ pub(crate) fn parse_walk_conditions_and_collectors(
         map: binding_map,
         parent: ctx,
     };
-    let extraction_map = match collector.clone().partial_eval(&binding_ctx)? {
+    let extraction_map = match collector.partial_eval(&binding_ctx)? {
         Expr::Dict(d) => d,
         Expr::Const(Value::Dict(d)) => d
             .into_iter()
             .map(|(k, v)| (k.to_string(), Expr::Const(v.clone())))
             .collect(),
-        ex => return Err(SelectOpError::NeedsDict.into()),
+        _ex => return Err(SelectOpError::NeedsDict.into()),
     };
     Ok((bindings.pop().unwrap(), extraction_map))
 }

src/algebra/parser.rs

@@ -52,6 +52,9 @@ pub(crate) enum AlgebraParseError {
 
     #[error("Scalar function in forbidden place")]
     ScalarFnNotAllowed,
+
+    #[error("sorting failed")]
+    Sorting,
 }
 
 pub(crate) fn assert_rule(pair: &Pair, rule: Rule, name: &str, u: usize) -> Result<()> {
@@ -648,7 +651,7 @@ pub(crate) mod tests {
             let s = r#"
              Walk(j:Job<-[:HasJob]-e:Employee-[:InDepartment]->d:Department,
                   j => Sort(j.id => desc),
-                  // e => Sort(e.id => desc).Skip(1).Where(e.id > 110),
+                  e => Sort(e.id => desc).Skip(1).Where(e.id > 110),
                   j: {
                     id_1_job: j.id,
                     id_2_emp: count_non_null[e.id],

src/bin/cozo_rest/main.rs

@@ -1,4 +1,4 @@
-use actix_web::{get, post, web, App, HttpResponse, HttpServer, Responder};
+use actix_web::{post, web, App, HttpResponse, HttpServer, Responder};
 use cozo::DbInstance;
 
 struct AppStateWithDb {
@@ -9,8 +9,10 @@ struct AppStateWithDb {
 async fn query(body: web::Bytes, data: web::Data<AppStateWithDb>) -> impl Responder {
     let text = String::from_utf8_lossy(body.as_ref());
     let mut sess = data.db.session().unwrap().start().unwrap();
-    let res = sess.run_script(text, true);
+    match sess.run_script(text, true) {
-    HttpResponse::Ok().body(format!("{:?}", res))
+        Ok(res) => HttpResponse::Ok().body(res.to_string()),
+        Err(e) => HttpResponse::BadRequest().body(format!("{:?}", e)),
+    }
 }
 
 #[actix_web::main]

src/context.rs

@@ -8,6 +8,7 @@ pub(crate) struct MainDbContext<'a> {
     pub(crate) txn: TransactionPtr,
 }
 
+#[allow(dead_code)]
 pub(crate) struct TempDbContext<'a> {
     pub(crate) sess: &'a mut Session,
     pub(crate) txn: TransactionPtr,

src/data/eval.rs

@@ -350,7 +350,7 @@ impl Expr {
                     | Expr::OpMerge(_)
                     | Expr::OpCoalesce(_)) => Expr::FieldAcc(f, v.into()),
                     Expr::Dict(mut d) => d.remove(&f as &str).unwrap_or(Expr::Const(Value::Null)),
-                    v => return Err(EvalError::FieldAccess(f).into()),
+                    _v => return Err(EvalError::FieldAccess(f).into()),
                 },
             },
             Expr::IdxAcc(i, arg) => {
@@ -383,7 +383,7 @@ impl Expr {
                         | Expr::FieldAcc(_, _)
                         | Expr::BuiltinFn(_, _)
                         | Expr::ApplyAgg(_, _, _)) => Expr::IdxAcc(i, v.into()),
-                        v => return Err(EvalError::IndexAccess(i).into()),
+                        _v => return Err(EvalError::IndexAccess(i).into()),
                     },
                 }
             }
@@ -509,7 +509,7 @@ impl Expr {
             Expr::FieldAcc(f, arg) => match arg.row_eval(ctx)? {
                 Value::Null => Value::Null,
                 Value::Dict(mut d) => d.remove(f as &str).unwrap_or(Value::Null),
-                v => {
+                _v => {
                     return Err(
                         EvalError::FieldAccess(f.clone()).into(),
                     );
@@ -524,7 +524,7 @@ impl Expr {
                         d.swap_remove(*idx)
                     }
                 }
-                v => return Err(EvalError::IndexAccess(*idx).into()),
+                _v => return Err(EvalError::IndexAccess(*idx).into()),
             },
             Expr::IfExpr(args) => {
                 let (cond, if_part, else_part) = args.as_ref();

src/data/expr.rs

@@ -275,34 +275,34 @@ impl TryFrom<StaticValue> for Expr {
                     }))
                 }
                 EXPR_TAG_APPLY => {
-                    let mut ll = extract_list_from_value(v, 2)?.into_iter();
+                    // let mut ll = extract_list_from_value(v, 2)?.into_iter();
-                    let name = match ll.next().unwrap() {
+                    // let name = match ll.next().unwrap() {
-                        Value::Text(t) => t,
+                    //     Value::Text(t) => t,
-                        v => return Err(ExprError::ConversionFailure(v.into_static()).into()),
+                    //     v => return Err(ExprError::ConversionFailure(v.into_static()).into()),
-                    };
+                    // };
-                    let l = extract_list_from_value(ll.next().unwrap(), 0)?;
+                    // let l = extract_list_from_value(ll.next().unwrap(), 0)?;
-                    let _args = l
+                    // let _args = l
-                        .into_iter()
+                    //     .into_iter()
-                        .map(Expr::try_from)
+                    //     .map(Expr::try_from)
-                        .collect::<Result<Vec<_>>>()?;
+                    //     .collect::<Result<Vec<_>>>()?;
                     todo!()
                 }
                 EXPR_TAG_APPLY_AGG => {
-                    let mut ll = extract_list_from_value(v, 3)?.into_iter();
+                    // let mut ll = extract_list_from_value(v, 3)?.into_iter();
-                    let name = match ll.next().unwrap() {
+                    // let name = match ll.next().unwrap() {
-                        Value::Text(t) => t,
+                    //     Value::Text(t) => t,
-                        v => return Err(ExprError::ConversionFailure(v.into_static()).into()),
+                    //     v => return Err(ExprError::ConversionFailure(v.into_static()).into()),
-                    };
+                    // };
-                    let l = extract_list_from_value(ll.next().unwrap(), 0)?;
+                    // let l = extract_list_from_value(ll.next().unwrap(), 0)?;
-                    let a_args = l
+                    // let a_args = l
-                        .into_iter()
+                    //     .into_iter()
-                        .map(Expr::try_from)
+                    //     .map(Expr::try_from)
-                        .collect::<Result<Vec<_>>>()?;
+                    //     .collect::<Result<Vec<_>>>()?;
-                    let l = extract_list_from_value(ll.next().unwrap(), 0)?;
+                    // let l = extract_list_from_value(ll.next().unwrap(), 0)?;
-                    let _args = l
+                    // let _args = l
-                        .into_iter()
+                    //     .into_iter()
-                        .map(Expr::try_from)
+                    //     .map(Expr::try_from)
-                        .collect::<Result<Vec<_>>>()?;
+                    //     .collect::<Result<Vec<_>>>()?;
                     todo!()
                 }
                 EXPR_TAG_FIELD_ACC => {
@@ -420,19 +420,23 @@ impl<'a> From<Expr> for Value<'a> {
             Expr::SwitchExpr(_) => {
                 todo!()
             }
-            Expr::ApplyAgg(op, a_args, args) => build_tagged_value(
+            Expr::ApplyAgg(_op, _a_args, _args) => {
-                EXPR_TAG_APPLY_AGG,
+                todo!()
-                vec![
+                // build_tagged_value(
-                    Value::from(todo!()),
+                //     // EXPR_TAG_APPLY_AGG,
-                    a_args
+                //     // vec![
-                        .into_iter()
+                //     //     Value::from(todo!()),
-                        .map(Value::from)
+                //     //     a_args
-                        .collect::<Vec<_>>()
+                //     //         .into_iter()
-                        .into(),
+                //     //         .map(Value::from)
-                    args.into_iter().map(Value::from).collect::<Vec<_>>().into(),
+                //     //         .collect::<Vec<_>>()
-                ]
+                //     //         .into(),
-                .into(),
+                //     //     args.into_iter().map(Value::from).collect::<Vec<_>>().into(),
-            ),
+                //     // ]
+                //     // .into(),
+                //     todo!()
+                // )
+            },
             Expr::FieldAcc(f, v) => {
                 build_tagged_value(EXPR_TAG_FIELD_ACC, vec![f.into(), Value::from(*v)].into())
             }

src/data/op_agg/collect.rs

@@ -39,7 +39,7 @@ impl OpAggT for OpCollectIf {
         self.buffer.borrow_mut().clear();
     }
 
-    fn initialize(&self, a_args: Vec<StaticValue>) -> Result<()> {
+    fn initialize(&self, _a_args: Vec<StaticValue>) -> Result<()> {
         Ok(())
     }
 

src/data/parser.rs

@@ -348,7 +348,7 @@ fn build_aggr_call(name: &str, a_args: Vec<Expr>, args: Vec<Expr>) -> Result<Exp
     })
 }
 
-fn build_expr_infix<'a>(lhs: Result<Expr>, op: Pair, rhs: Result<Expr>) -> Result<Expr> {
+fn build_expr_infix(lhs: Result<Expr>, op: Pair, rhs: Result<Expr>) -> Result<Expr> {
     let args = vec![lhs?, rhs?];
     Ok(match op.as_rule() {
         Rule::op_add => Expr::BuiltinFn(OP_ADD, args),

src/data/tuple.rs

@@ -190,6 +190,7 @@ impl<T: AsRef<[u8]>> Tuple<T> {
         }
     }
 
+    #[allow(dead_code)]
     #[inline]
     pub(crate) fn starts_with<T2: AsRef<[u8]>>(&self, other: &Tuple<T2>) -> bool {
         self.data.as_ref().starts_with(other.data.as_ref())
@@ -329,6 +330,7 @@ impl<T: AsRef<[u8]>> Tuple<T> {
         }
     }
 
+    #[allow(dead_code)]
     #[inline]
     pub(crate) fn get_null(&self, idx: usize) -> Result<()> {
         match self.get(idx)? {
@@ -345,6 +347,7 @@ impl<T: AsRef<[u8]>> Tuple<T> {
         }
     }
 
+    #[allow(dead_code)]
     #[inline]
     pub(crate) fn get_text(&self, idx: usize) -> Result<Cow<str>> {
         match self.get(idx)? {
@@ -353,6 +356,7 @@ impl<T: AsRef<[u8]>> Tuple<T> {
         }
     }
 
+    #[allow(dead_code)]
     #[inline]
     pub(crate) fn get_bool(&self, idx: usize) -> Result<bool> {
         match self.get(idx)? {
@@ -361,6 +365,7 @@ impl<T: AsRef<[u8]>> Tuple<T> {
         }
     }
 
+    #[allow(dead_code)]
     #[inline]
     pub(crate) fn get_float(&self, idx: usize) -> Result<f64> {
         match self.get(idx)? {
@@ -369,6 +374,7 @@ impl<T: AsRef<[u8]>> Tuple<T> {
         }
     }
 
+    #[allow(dead_code)]
     #[inline]
     pub(crate) fn get_uuid(&self, idx: usize) -> Result<Uuid> {
         match self.get(idx)? {
@@ -377,6 +383,7 @@ impl<T: AsRef<[u8]>> Tuple<T> {
         }
     }
 
+    #[allow(dead_code)]
     #[inline]
     pub(crate) fn get_list(&self, idx: usize) -> Result<Vec<Value>> {
         match self.get(idx)? {
@@ -385,6 +392,7 @@ impl<T: AsRef<[u8]>> Tuple<T> {
         }
     }
 
+    #[allow(dead_code)]
     #[inline]
     pub(crate) fn get_dict(&self, idx: usize) -> Result<BTreeMap<Cow<str>, Value>> {
         match self.get(idx)? {
@@ -723,12 +731,14 @@ impl OwnTuple {
         self.push_varint(u);
     }
 
+    #[allow(dead_code)]
     #[inline]
     pub(crate) fn concat_data<T: AsRef<[u8]>>(&mut self, other: &Tuple<T>) {
         let other_data_part = &other.as_ref()[4..];
         self.data.extend_from_slice(other_data_part);
     }
 
+    #[allow(dead_code)]
     #[inline]
     pub(crate) fn insert_values_at<'a, T: AsRef<[Value<'a>]>>(
         &self,

src/data/tuple_set.rs

@@ -68,6 +68,7 @@ impl Debug for TableId {
 }
 
 impl TableId {
+    #[allow(dead_code)]
     pub(crate) fn new(in_root: bool, id: u32) -> Result<Self> {
         if id <= MIN_TABLE_ID_BOUND {
             Err(TupleSetError::InvalidTableId(id).into())
@@ -75,6 +76,7 @@ impl TableId {
             Ok(TableId { in_root, id })
         }
     }
+    #[allow(dead_code)]
     pub(crate) fn is_valid(&self) -> bool {
         self.id > MIN_TABLE_ID_BOUND
     }
@@ -177,8 +179,8 @@ impl TupleSet {
 
     pub(crate) fn decode_from_tuple<T: AsRef<[u8]>>(source: &Tuple<T>) -> Result<Self> {
         let gen_err = || DecodeFailure(source.to_owned());
-        let k_len = source.get(0)?.get_int().ok_or_else(gen_err)? as usize;
+        let k_len = source.get_int(0)? as usize;
-        let v_len = source.get(1)?.get_int().ok_or_else(gen_err)? as usize;
+        let v_len = source.get_int(1)? as usize;
         let mut ret = TupleSet {
             keys: Vec::with_capacity(k_len),
             vals: Vec::with_capacity(v_len),
@@ -198,6 +200,7 @@ impl TupleSet {
 }
 
 impl TupleSet {
+    #[allow(dead_code)]
     pub(crate) fn last_key_is_empty(&self) -> bool {
         match self.keys.last() {
             None => false,
@@ -216,6 +219,7 @@ impl TupleSet {
         self.keys.extend(o.keys);
         self.vals.extend(o.vals);
     }
+    #[allow(dead_code)]
     pub(crate) fn extend_keys<I, T>(&mut self, keys: I)
     where
         I: IntoIterator<Item = T>,
@@ -223,6 +227,7 @@ impl TupleSet {
     {
         self.keys.extend(keys.into_iter().map(ReifiedTuple::from));
     }
+    #[allow(dead_code)]
     pub(crate) fn extend_vals<I, T>(&mut self, keys: I)
     where
         I: IntoIterator<Item = T>,
@@ -231,6 +236,7 @@ impl TupleSet {
         self.vals.extend(keys.into_iter().map(ReifiedTuple::from));
     }
 
+    #[allow(dead_code)]
     pub(crate) fn all_keys_eq(&self, other: &Self) -> bool {
         if self.keys.len() != other.keys.len() {
             return false;
@@ -253,6 +259,7 @@ impl TupleSet {
         }
         true
     }
+    #[allow(dead_code)]
     pub(crate) fn all_keys_cmp(&self, other: &Self) -> Ordering {
         for (l, r) in self.keys.iter().zip(&other.keys) {
             match l.key_part_cmp(r) {

src/data/typing.rs

@@ -20,6 +20,7 @@ pub enum TypingError {
     UndefinedType(String),
 }
 
+#[allow(dead_code)]
 #[derive(Ord, PartialOrd, Eq, PartialEq, Clone)]
 pub enum Typing {
     Any,
@@ -73,6 +74,7 @@ impl Debug for Typing {
 }
 
 impl Typing {
+    #[allow(dead_code)]
     pub(crate) fn representative_value(&self) -> StaticValue {
         match self {
             Typing::Any => Value::Bottom,
@@ -257,6 +259,7 @@ impl Typing {
 }
 
 impl<'a> Value<'a> {
+    #[allow(dead_code)]
     pub(crate) fn deduce_typing(&self) -> Typing {
         match self {
             Value::Null => Typing::Any,

src/data/value.rs

@@ -24,9 +24,11 @@ pub enum Value<'a> {
 }
 
 impl<'a> Value<'a> {
+    #[allow(dead_code)]
     pub(crate) fn is_null(&self) -> bool {
         *self == Value::Null
     }
+    #[allow(dead_code)]
     pub(crate) fn get_bool(&self) -> Option<bool> {
         match self {
             Value::Bool(b) => Some(*b),
@@ -39,6 +41,7 @@ impl<'a> Value<'a> {
             _ => None,
         }
     }
+    #[allow(dead_code)]
     pub(crate) fn get_float(&self) -> Option<f64> {
         match self {
             Value::Float(b) => Some(b.into_inner()),
@@ -75,6 +78,7 @@ impl<'a> Value<'a> {
             _ => None,
         }
     }
+    #[allow(dead_code)]
     pub(crate) fn into_map(self) -> Result<BTreeMap<Cow<'a, str>, Value<'a>>, Value<'a>> {
         match self {
             Value::Dict(m) => Ok(m),

src/ddl/reify.rs

@@ -84,6 +84,7 @@ impl TableInfo {
             _ => Err(DdlReifyError::WrongDataKind(self.table_id()).into()),
         }
     }
+    #[allow(dead_code)]
     pub(crate) fn as_index(&self) -> Result<&IndexInfo> {
         match self {
             TableInfo::Index(n) => Ok(n),
@@ -96,12 +97,14 @@ impl TableInfo {
             _ => Err(DdlReifyError::WrongDataKind(self.table_id()).into()),
         }
     }
+    #[allow(dead_code)]
     pub(crate) fn as_sequence(&self) -> Result<&SequenceInfo> {
         match self {
             TableInfo::Sequence(n) => Ok(n),
             _ => Err(DdlReifyError::WrongDataKind(self.table_id()).into()),
         }
     }
+    #[allow(dead_code)]
     pub(crate) fn into_sequence(self) -> Result<SequenceInfo> {
         match self {
             TableInfo::Sequence(n) => Ok(n),

src/runtime/session.rs

@@ -18,6 +18,7 @@ use std::collections::{BTreeMap, BTreeSet};
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::{Mutex, Arc};
 
+#[allow(dead_code)]
 pub(crate) enum Definable {
     Value(StaticValue),
     Expr(Expr),
@@ -32,6 +33,7 @@ pub struct Session {
     pub(crate) temp: DbPtr,
     pub(crate) r_opts_main: ReadOptionsPtr,
     pub(crate) r_opts_temp: ReadOptionsPtr,
+    #[allow(dead_code)]
     pub(crate) w_opts_main: WriteOptionsPtr,
     pub(crate) w_opts_temp: WriteOptionsPtr,
     pub(crate) optimistic: bool,
@@ -59,6 +61,7 @@ impl Session {
     pub(crate) fn push_env(&mut self) {
         self.stack.push(BTreeMap::new());
     }
+    #[allow(dead_code)]
     pub(crate) fn pop_env(&mut self) {
         if !self.stack.is_empty() {
             let popped_frame = self.stack.pop().unwrap();
@@ -72,6 +75,7 @@ impl Session {
             self.push_env()
         }
     }
+    #[allow(dead_code)]
     fn undefine_temp_table(&mut self, id: u32) {
         // remove table
         self.tables.remove(&id);