remove 'reverse' nonsense

Cargo.lock

@@ -339,6 +339,7 @@ version = "0.1.0"
 dependencies = [
  "approx",
  "base64",
+ "byteorder",
  "casey",
  "chrono",
  "chrono-tz",

Cargo.toml

@@ -34,6 +34,7 @@ chrono = "0.4.19"
 chrono-tz = "0.6.3"
 priority-queue = "1.2.3"
 ordered-float = "3.0.0"
+byteorder = "1.4.3"
 num-traits = "0.2.15"
 itertools = "0.10.3"
 regex = "1.6.0"

src/data/functions.rs

@@ -43,7 +43,6 @@ fn ensure_same_value_type(a: &DataValue, b: &DataValue) -> Result<()> {
             | (Regex(_), Regex(_))
             | (List(_), List(_))
             | (Set(_), Set(_))
-            | (Rev(_), Rev(_))
             | (Guard, Guard)
             | (Bot, Bot)
     ) {

src/data/json.rs

@@ -84,7 +84,6 @@ impl From<DataValue> for JsonValue {
             DataValue::List(l) => {
                 JsonValue::Array(l.iter().map(|v| JsonValue::from(v.clone())).collect())
             }
-            DataValue::Rev(v) => JsonValue::from(*v.0),
             DataValue::Bot => panic!("found bottom"),
             DataValue::Guard => panic!("found guard"),
             DataValue::Set(l) => {

src/data/mod.rs

@@ -11,6 +11,7 @@ pub(crate) mod program;
 pub(crate) mod aggr;
 pub(crate) mod functions;
 pub(crate) mod relation;
+pub(crate) mod memcmp;
 
 #[cfg(test)]
 mod tests;

src/data/value.rs

@@ -2,7 +2,7 @@
  * Copyright 2022, The Cozo Project Authors. Licensed under AGPL-3 or later.
  */
 
-use std::cmp::{Ordering, Reverse};
+use std::cmp::Ordering;
 use std::collections::BTreeSet;
 use std::fmt::{Debug, Display, Formatter};
 use std::hash::{Hash, Hasher};
@@ -102,8 +102,6 @@ pub(crate) enum DataValue {
     List(Vec<DataValue>),
     #[serde(rename = "H", alias = "Set")]
     Set(BTreeSet<DataValue>),
-    #[serde(rename = "R", alias = "Rev")]
-    Rev(Reverse<Box<DataValue>>),
     #[serde(rename = "G", alias = "Guard")]
     Guard,
     #[serde(rename = "_", alias = "Bot")]
@@ -181,11 +179,10 @@ impl Display for Num {
                     } else {
                         write!(f, r#"to_float("INF")"#)
                     }
-                }
+                } else {
-                else {
                     write!(f, "{}", n)
                 }
-            },
+            }
         }
     }
 }
@@ -256,9 +253,6 @@ impl Display for DataValue {
             }
             DataValue::List(ls) => f.debug_list().entries(ls).finish(),
             DataValue::Set(s) => f.debug_list().entries(s).finish(),
-            DataValue::Rev(rev) => {
-                write!(f, "{}", rev.0)
-            }
             DataValue::Guard => {
                 write!(f, "null")
             }
@@ -355,7 +349,6 @@ mod tests {
         dbg!(s);
     }
 
-
     #[test]
     fn display_datavalues() {
         println!("{}", DataValue::Null);

src/query/sort.rs

@@ -2,7 +2,7 @@
  * Copyright 2022, The Cozo Project Authors. Licensed under AGPL-3 or later.
  */
 
-use std::cmp::Reverse;
+use std::cmp::{Ordering};
 use std::collections::BTreeMap;
 
 use itertools::Itertools;
@@ -11,7 +11,6 @@ use miette::Result;
 use crate::data::program::SortDir;
 use crate::data::symb::Symbol;
 use crate::data::tuple::Tuple;
-use crate::data::value::DataValue;
 use crate::runtime::in_mem::InMemRelation;
 use crate::runtime::transact::SessionTx;
 
@@ -21,29 +20,29 @@ impl SessionTx {
         original: InMemRelation,
         sorters: &[(Symbol, SortDir)],
         head: &[Symbol],
-    ) -> Result<InMemRelation> {
+    ) -> Result<Vec<Tuple>> {
         let head_indices: BTreeMap<_, _> = head.iter().enumerate().map(|(i, k)| (k, i)).collect();
         let idx_sorters = sorters
             .iter()
             .map(|(k, dir)| (head_indices[k], *dir))
             .collect_vec();
-        let ret = self.new_temp_store(original.rule_name.symbol().span);
+
-        for (idx, tuple) in original.scan_all().enumerate() {
+        let mut all_data: Vec<_> = original.scan_all().try_collect()?;
-            let tuple = tuple?;
+        all_data.sort_by(|a, b| {
-            let mut key = idx_sorters
+            for (idx, dir) in &idx_sorters {
-                .iter()
+                match a.0[*idx].cmp(&b.0[*idx]) {
-                .map(|(idx, dir)| {
+                    Ordering::Equal => {}
-                    let mut val = tuple.0[*idx].clone();
+                    o => {
-                    if *dir == SortDir::Dsc {
+                        return match dir {
-                        val = DataValue::Rev(Reverse(Box::new(val)));
+                            SortDir::Asc => o,
+                            SortDir::Dsc => o.reverse(),
+                        }
                     }
-                    val
+                }
-                })
+            }
-                .collect_vec();
+            Ordering::Equal
-            key.push(DataValue::from(idx as i64));
+        });
-            let key = Tuple(key);
+
-            ret.put_kv(key, tuple, 0);
+        Ok(all_data)
-        }
-        Ok(ret)
     }
 }

src/runtime/db.rs

@@ -603,15 +603,16 @@ impl Db {
             let sorted_result =
                 tx.sort_and_collect(result, &input_program.out_opts.sorters, &entry_head)?;
             let sorted_iter = if let Some(offset) = input_program.out_opts.offset {
-                Left(sorted_result.scan_sorted().skip(offset))
+                Left(sorted_result.into_iter().skip(offset))
             } else {
-                Right(sorted_result.scan_sorted())
+                Right(sorted_result.into_iter())
             };
             let sorted_iter = if let Some(limit) = input_program.out_opts.limit {
                 Left(sorted_iter.take(limit))
             } else {
                 Right(sorted_iter)
             };
+            let sorted_iter = sorted_iter.map(|t| Ok(t));
             if let Some((meta, relation_op)) = &input_program.out_opts.store_relation {
                 let to_clear = tx
                     .execute_relation(

src/runtime/in_mem.rs

@@ -141,12 +141,6 @@ impl InMemRelation {
         let mut target = db.get(epoch as usize).unwrap().try_write().unwrap();
         target.insert(tuple, Tuple::default());
     }
-    pub(crate) fn put_kv(&self, tuple: Tuple, val: Tuple, epoch: u32) {
-        self.ensure_mem_db_for_epoch(epoch);
-        let db = self.mem_db.try_read().unwrap();
-        let mut target = db.get(epoch as usize).unwrap().try_write().unwrap();
-        target.insert(tuple, val);
-    }
     pub(crate) fn normal_aggr_put(
         &self,
         tuple: &Tuple,
@@ -315,12 +309,6 @@ impl InMemRelation {
     pub(crate) fn scan_all(&self) -> impl Iterator<Item=Result<Tuple>> {
         self.scan_all_for_epoch(0)
     }
-    pub(crate) fn scan_sorted(&self) -> impl Iterator<Item=Result<Tuple>> {
-        self.ensure_mem_db_for_epoch(0);
-        let target = self.mem_db.try_read().unwrap();
-        let target = target.get(0).unwrap().try_read().unwrap();
-        target.clone().into_iter().map(|(_k, v)| Ok(v))
-    }
     pub(crate) fn scan_prefix(&self, prefix: &Tuple) -> impl Iterator<Item=Result<Tuple>> {
         self.scan_prefix_for_epoch(prefix, 0)
     }