special value type for reverse sorting

src/db/cnf_transform.rs

@@ -1,6 +1,7 @@
+use std::cmp::Reverse;
 use crate::db::table::TableId;
 use crate::relation::value;
-use crate::relation::value::Value;
+use crate::relation::value::{Value};
 use std::collections::BTreeSet;
 
 pub fn extract_tables(val: &Value) -> BTreeSet<TableId> {
@@ -39,6 +40,7 @@ fn do_extract_tables(val: &Value, coll: &mut BTreeSet<TableId>) {
         Value::FieldAccess(_, _) => {}
         Value::IdxAccess(_, _) => {}
         Value::EndSentinel => {}
+        Value::DescSort(Reverse(v)) => do_extract_tables(v, coll)
     }
 }
 

src/db/eval.rs

@@ -141,6 +141,9 @@ pub fn tuple_eval<'a>(value: &'a Value<'a>, tuples: &'a MegaTuple) -> Result<Val
         Value::EndSentinel => {
             return Err(LogicError("Encountered end sentinel".to_string()));
         }
+        Value::DescSort(_) => {
+            return Err(LogicError("Encountered desc sort value".to_string()));
+        }
     };
     Ok(res)
 }
@@ -655,6 +658,9 @@ impl<'s> Session<'s> {
                     todo!()
                 }
             }),
+            Value::DescSort(_) => {
+                return Err(LogicError("Cannot process desc value".to_string()));
+            }
         }
     }
 }
@@ -1127,6 +1133,9 @@ impl<'s> Session<'s> {
                                     Value::TupleRef(_, _) => {
                                         todo!()
                                     }
+                                    Value::DescSort(_) => {
+                                        return Err(Err(LogicError("Cannot process desc value".to_string())));
+                                    }
                                 }
                             }
                         }
@@ -1294,6 +1303,9 @@ impl<'s> Session<'s> {
                                     Value::TupleRef(_, _) => {
                                         todo!()
                                     }
+                                    Value::DescSort(_) => {
+                                        Err(Err(LogicError("Cannot process desc value".to_string())))
+                                    }
                                 }
                             }
                         }

src/relation/tuple.rs

@@ -4,7 +4,7 @@ use crate::relation::value::{Tag, Value};
 use cozorocks::SlicePtr;
 use std::borrow::Cow;
 use std::cell::RefCell;
-use std::cmp::Ordering;
+use std::cmp::{Ordering, Reverse};
 use std::collections::BTreeMap;
 use std::fmt::{Debug, Formatter};
 use std::hash::{Hash, Hasher};
@@ -159,26 +159,34 @@ impl<T: AsRef<[u8]>> Tuple<T> {
     fn skip_and_cache(&self) {
         let data = self.data.as_ref();
         let tag_start = *self.idx_cache.borrow().last().unwrap_or(&PREFIX_LEN);
-        let start = tag_start + 1;
-        let nxt = match Tag::try_from(data[tag_start]).unwrap() {
-            Tag::Null | Tag::BoolTrue | Tag::BoolFalse => start,
-            Tag::Int => start + self.parse_varint(start).1,
-            Tag::Float => start + 8,
-            Tag::Uuid => start + 16,
-            Tag::Text | Tag::Variable => {
-                let (slen, offset) = self.parse_varint(start);
-                let slen = slen as usize;
-                start + slen + offset
-            }
-            Tag::List | Tag::Apply | Tag::Dict | Tag::IdxAccess | Tag::FieldAccess => {
-                start + u32::from_be_bytes(data[start..start + 4].try_into().unwrap()) as usize
-            }
-            Tag::TupleRef => {
-                let temp = start + 1 + self.parse_varint(start + 1).1 + 1;
-                temp + self.parse_varint(temp).1
-            }
-            Tag::MaxTag => panic!(),
-        };
+        let mut start = tag_start + 1;
+        let nxt;
+        loop {
+            nxt = match Tag::try_from(data[tag_start]).unwrap() {
+                Tag::Null | Tag::BoolTrue | Tag::BoolFalse => start,
+                Tag::Int => start + self.parse_varint(start).1,
+                Tag::Float => start + 8,
+                Tag::Uuid => start + 16,
+                Tag::Text | Tag::Variable => {
+                    let (slen, offset) = self.parse_varint(start);
+                    let slen = slen as usize;
+                    start + slen + offset
+                }
+                Tag::List | Tag::Apply | Tag::Dict | Tag::IdxAccess | Tag::FieldAccess => {
+                    start + u32::from_be_bytes(data[start..start + 4].try_into().unwrap()) as usize
+                }
+                Tag::TupleRef => {
+                    let temp = start + 1 + self.parse_varint(start + 1).1 + 1;
+                    temp + self.parse_varint(temp).1
+                }
+                Tag::DescVal => {
+                    start += 1;
+                    continue;
+                },
+                Tag::MaxTag => panic!(),
+            };
+            break;
+        }
         self.idx_cache.borrow_mut().push(nxt);
     }
 
@@ -433,6 +441,10 @@ impl<T: AsRef<[u8]>> Tuple<T> {
                     ),
                 )
             }
+            Tag::DescVal => {
+                let (val, offset) = self.parse_value_at(pos + 1);
+                (offset, Value::DescSort(Reverse(val.into())))
+            }
         };
         (val, nxt)
     }
@@ -678,6 +690,14 @@ impl OwnTuple {
                 cache.push(self.data.len());
             }
             Value::EndSentinel => panic!("Cannot push sentinel value"),
+            Value::DescSort(Reverse(v)) => {
+                self.push_tag(Tag::DescVal);
+                let start_len = self.idx_cache.borrow().len();
+                self.push_value(v);
+                let mut cache = self.idx_cache.borrow_mut();
+                cache.truncate(start_len);
+                cache.push(self.data.len());
+            }
         }
     }
 

src/relation/value.rs

@@ -10,6 +10,7 @@ use pest::iterators::Pair;
 use pest::prec_climber::{Assoc, Operator, PrecClimber};
 use pest::Parser as PestParser;
 use std::borrow::Cow;
+use std::cmp::Reverse;
 use std::collections::BTreeMap;
 use std::fmt::{Debug, Display, Formatter, Write};
 use uuid::Uuid;
@@ -28,6 +29,8 @@ pub enum Tag {
     List = 128,
     Dict = 129,
 
+    DescVal = 192,
+
     TupleRef = 250,
     IdxAccess = 251,
     FieldAccess = 252,
@@ -53,6 +56,8 @@ impl TryFrom<u8> for Tag {
             128 => List,
             129 => Dict,
 
+            192 => DescVal,
+
             250 => TupleRef,
             251 => IdxAccess,
             252 => FieldAccess,
@@ -105,13 +110,19 @@ pub enum Value<'a> {
     // not evaluated
     Variable(Cow<'a, str>),
     TupleRef(TableId, ColId),
-    Apply(Cow<'a, str>, Vec<Value<'a>>), // TODO optimization: special case for small number of args (esp. 0, 1, 2)
+    Apply(Cow<'a, str>, Vec<Value<'a>>),
+    // TODO optimization: special case for small number of args (esp. 0, 1, 2)
     FieldAccess(Cow<'a, str>, Box<Value<'a>>),
     IdxAccess(usize, Box<Value<'a>>),
+    DescSort(DescVal<'a>),
     // cannot exist
     EndSentinel,
 }
 
+// #[derive(Clone, PartialEq, Ord, PartialOrd, Eq)]
+// pub struct DescVal<'a>(pub Box<Value<'a>>);
+pub type DescVal<'a> = Reverse<Box<Value<'a>>>;
+
 pub type StaticValue = Value<'static>;
 
 impl<'a> Debug for Value<'a> {
@@ -153,6 +164,7 @@ impl<'a> Value<'a> {
             }
             Value::IdxAccess(idx, value) => Value::IdxAccess(idx, value.to_static().into()),
             Value::TupleRef(tid, cid) => Value::TupleRef(tid, cid),
+            Value::DescSort(Reverse(val)) => Value::DescSort(Reverse(val.to_static().into()))
         }
     }
     #[inline]
@@ -172,6 +184,7 @@ impl<'a> Value<'a> {
             Value::FieldAccess(_, _) => false,
             Value::IdxAccess(_, _) => false,
             Value::TupleRef(_, _) => false,
+            Value::DescSort(Reverse(v)) => v.is_evaluated()
         }
     }
     #[inline]
@@ -186,7 +199,7 @@ impl<'a> Value<'a> {
         Value::from_pair(pair)
     }
 
-    pub fn extract_relevant_tables<T: Iterator<Item = Self>>(
+    pub fn extract_relevant_tables<T: Iterator<Item=Self>>(
         data: T,
     ) -> Result<(Vec<Self>, Vec<TableId>)> {
         let mut coll = vec![];
@@ -239,6 +252,9 @@ impl<'a> Value<'a> {
             Value::EndSentinel => {
                 return Err(LogicError("Encountered end sentinel".to_string()));
             }
+            Value::DescSort(Reverse(v)) => {
+                return v.do_extract_relevant_tables(coll);
+            }
         })
     }
 }
@@ -428,6 +444,9 @@ impl<'a> Display for Value<'a> {
                     cid.id
                 )?;
             }
+            Value::DescSort(Reverse(v)) => {
+                write!(f, "~{}", v)?;
+            }
         }
         Ok(())
     }