perf: Adjust TupleKey encoding to default to NULLS LAST, allowing Min/Max to be rewritten as TopK without filtering NULLs

Author: KKould

README.md

@@ -93,13 +93,13 @@ Run `make tpcc-dual` to mirror every TPCC statement to an in-memory SQLite datab
 All cases have been fully optimized.
 ```shell
 <90th Percentile RT (MaxRT)>
-   New-Order : 0.002  (0.006)
-     Payment : 0.001  (0.019)
-Order-Status : 0.001  (0.003)
-    Delivery : 0.022  (0.038)
- Stock-Level : 0.002  (0.005)
+   New-Order : 0.002  (0.005)
+     Payment : 0.001  (0.013)
+Order-Status : 0.002  (0.006)
+    Delivery : 0.010  (0.023)
+ Stock-Level : 0.002  (0.017)
 <TpmC>
-18432 Tpmc
+27226 Tpmc
 ```
 #### 👉[check more](tpcc/README.md)
 

src/binder/aggregate.rs

@@ -98,7 +98,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                 return_orderby.push(SortField::new(
                     expr,
                     asc.is_none_or(|asc| asc),
-                    nulls_first.unwrap_or(true),
+                    nulls_first.unwrap_or(false),
                 ));
             }
             Some(return_orderby)

src/optimizer/core/memo.rs

@@ -191,7 +191,7 @@ mod tests {
         let sort_fields = vec![SortField::new(
             ScalarExpression::column_expr(c1_column.clone()),
             true,
-            true,
+            false,
         )];
         let scala_functions = Default::default();
         let table_functions = Default::default();

src/optimizer/rule/normalization/agg_elimination.rs

@@ -179,7 +179,7 @@ fn distinct_sort_fields(groupby_exprs: &[ScalarExpression]) -> Vec<SortField> {
     groupby_exprs
         .iter()
         .cloned()
-        .map(|expr| SortField::new(expr, true, true))
+        .map(|expr| SortField::new(expr, true, false))
         .collect()
 }
 
@@ -349,7 +349,7 @@ mod tests {
 
     fn make_sort_field(name: &str) -> SortField {
         let column = ColumnRef::from(ColumnCatalog::new_dummy(name.to_string()));
-        SortField::new(ScalarExpression::column_expr(column), true, true)
+        SortField::new(ScalarExpression::column_expr(column), true, false)
     }
 
     fn build_plan(
@@ -427,7 +427,7 @@ mod tests {
         let sort_fields = vec![SortField::new(
             ScalarExpression::column_expr(c1.clone()),
             true,
-            true,
+            false,
         )];
         let sort_option = SortOption::OrderBy {
             fields: sort_fields.clone(),
@@ -523,7 +523,7 @@ mod tests {
     #[test]
     fn annotate_sets_sort_hint_on_table_scan() -> Result<(), DatabaseError> {
         let column = ColumnRef::from(ColumnCatalog::new_dummy("c1".to_string()));
-        let sort_field = SortField::new(ScalarExpression::column_expr(column.clone()), true, true);
+        let sort_field = SortField::new(ScalarExpression::column_expr(column.clone()), true, false);
         let (index_info, _) = build_index_info(vec![sort_field.clone()], 0);
 
         let mut columns = BTreeMap::new();
@@ -625,7 +625,7 @@ mod tests {
     #[test]
     fn promote_index_to_remove_sort() -> Result<(), DatabaseError> {
         let column = ColumnRef::from(ColumnCatalog::new_dummy("c_first".to_string()));
-        let sort_field = SortField::new(ScalarExpression::column_expr(column.clone()), true, true);
+        let sort_field = SortField::new(ScalarExpression::column_expr(column.clone()), true, false);
         let (mut index_info, _) = build_index_info(vec![sort_field.clone()], 0);
         index_info.range = Some(Range::Scope {
             min: Bound::Unbounded,

src/optimizer/rule/normalization/min_max_top_k.rs

@@ -18,7 +18,6 @@ use crate::expression::ScalarExpression;
 use crate::optimizer::core::pattern::{Pattern, PatternChildrenPredicate};
 use crate::optimizer::core::rule::{MatchPattern, NormalizationRule};
 use crate::optimizer::plan_utils::{only_child, wrap_child_with};
-use crate::planner::operator::filter::FilterOperator;
 use crate::planner::operator::sort::SortField;
 use crate::planner::operator::top_k::TopKOperator;
 use crate::planner::operator::Operator;
@@ -60,7 +59,7 @@ impl NormalizationRule for MinMaxToTopK {
             _ => return Ok(false),
         };
 
-        let sort_field = SortField::new(args[0].clone(), asc, true);
+        let sort_field = SortField::new(args[0].clone(), asc, false);
         let already_topk = match only_child(plan) {
             Some(child) => match &child.operator {
                 Operator::TopK(topk) => {
@@ -77,23 +76,6 @@ impl NormalizationRule for MinMaxToTopK {
             return Ok(false);
         }
 
-        // IndexScan prioritizes indexed columns as null first.
-        // Therefore, to ensure Top K is eliminated when an index exists,
-        // we set it to null first and filter null rows.
-        let predicate = ScalarExpression::IsNull {
-            negated: true,
-            expr: Box::new(args[0].clone()),
-        };
-        let filter = Operator::Filter(FilterOperator {
-            predicate,
-            is_optimized: false,
-            having: false,
-        });
-
-        if !wrap_child_with(plan, 0, filter) {
-            return Ok(false);
-        }
-
         // Agg do not remove, because when the table is empty, MIN/MAX should return a NULL row.
         Ok(wrap_child_with(
             plan,
@@ -167,28 +149,13 @@ mod tests {
         assert!(topk.offset.is_none());
         assert_eq!(topk.sort_fields.len(), 1);
         assert!(topk.sort_fields[0].asc);
-        assert!(topk.sort_fields[0].nulls_first);
+        assert!(!topk.sort_fields[0].nulls_first);
         let args = match &op.agg_calls[0] {
             crate::expression::ScalarExpression::AggCall { args, .. } => args,
             _ => unreachable!("Aggregate should use AggCall"),
         };
         assert_eq!(topk.sort_fields[0].expr, args[0]);
 
-        let filter_plan = match topk_plan.childrens.as_ref() {
-            Childrens::Only(child) => child.as_ref(),
-            _ => unreachable!("TopK should have one child"),
-        };
-        match &filter_plan.operator {
-            Operator::Filter(filter_op) => match &filter_op.predicate {
-                crate::expression::ScalarExpression::IsNull { negated, expr } => {
-                    assert!(*negated);
-                    assert_eq!(**expr, args[0]);
-                }
-                _ => unreachable!("Expected IS NOT NULL filter under TopK"),
-            },
-            _ => unreachable!("Expected Filter under TopK"),
-        }
-
         Ok(())
     }
 
@@ -216,21 +183,7 @@ mod tests {
         assert!(topk.offset.is_none());
         assert_eq!(topk.sort_fields.len(), 1);
         assert!(!topk.sort_fields[0].asc);
-        assert!(topk.sort_fields[0].nulls_first);
-
-        let filter_plan = match topk_plan.childrens.as_ref() {
-            Childrens::Only(child) => child.as_ref(),
-            _ => unreachable!("TopK should have one child"),
-        };
-        match &filter_plan.operator {
-            Operator::Filter(filter_op) => match &filter_op.predicate {
-                crate::expression::ScalarExpression::IsNull { negated, .. } => {
-                    assert!(*negated);
-                }
-                _ => unreachable!("Expected IS NOT NULL filter under TopK"),
-            },
-            _ => unreachable!("Expected Filter under TopK"),
-        }
+        assert!(!topk.sort_fields[0].nulls_first);
 
         Ok(())
     }

src/planner/operator/table_scan.rs

@@ -70,7 +70,7 @@ impl TableScanOperator {
                 sort_fields.push(SortField {
                     expr: ScalarExpression::column_expr(column.clone()),
                     asc: true,
-                    nulls_first: true,
+                    nulls_first: false,
                 })
             }
 

src/storage/table_codec.rs

@@ -30,8 +30,9 @@ use std::sync::LazyLock;
 
 pub(crate) const BOUND_MIN_TAG: u8 = u8::MIN;
 pub(crate) const BOUND_MAX_TAG: u8 = u8::MAX;
-pub(crate) const NULL_TAG: u8 = 0u8;
-pub(crate) const NOTNULL_TAG: u8 = 1u8;
+// Nulls Last default
+pub(crate) const NULL_TAG: u8 = 1u8;
+pub(crate) const NOTNULL_TAG: u8 = 0u8;
 const TABLE_NAME_HASH_LEN: usize = 8;
 const KEY_TYPE_TAG_LEN: usize = 1;
 const KEY_BOUND_LEN: usize = 1;

src/types/value.rs

@@ -756,9 +756,9 @@ impl DataValue {
         nulls_first: bool,
     ) -> Result<(), DatabaseError> {
         let (null_tag, not_null_tag) = if nulls_first {
-            (NULL_TAG, NOTNULL_TAG)
-        } else {
             (NOTNULL_TAG, NULL_TAG)
+        } else {
+            (NULL_TAG, NOTNULL_TAG)
         };
         if let DataValue::Null = self {
             b.push(null_tag);
@@ -822,7 +822,7 @@ impl DataValue {
 
     #[inline]
     pub fn memcomparable_encode(&self, b: &mut BumpBytes) -> Result<(), DatabaseError> {
-        self.memcomparable_encode_with_null_order(b, true)
+        self.memcomparable_encode_with_null_order(b, false)
     }
 
     pub fn memcomparable_decode<R: Read>(
@@ -839,7 +839,7 @@ impl DataValue {
         // for index cover mapping reduce one layer of conversion
         tuple_mapping: Option<TupleMappingRef<'_>>,
     ) -> Result<DataValue, DatabaseError> {
-        if reader.read_u8()? == 0u8 {
+        if reader.read_u8()? == NULL_TAG {
             return Ok(DataValue::Null);
         }
         match ty {
@@ -2273,9 +2273,9 @@ mod test {
         println!("{key_i8_0:?} < {key_i8_1:?}");
         println!("{key_i8_1:?} < {key_i8_2:?}");
         println!("{key_i8_2:?} < {key_i8_3:?}");
-        assert!(key_i8_0 < key_i8_1);
         assert!(key_i8_1 < key_i8_2);
         assert!(key_i8_2 < key_i8_3);
+        assert!(key_i8_3 < key_i8_0);
 
         assert_eq!(
             value_0,
@@ -2329,9 +2329,9 @@ mod test {
         v_i8_2.memcomparable_encode(&mut key_i8_2)?;
         v_i8_3.memcomparable_encode(&mut key_i8_3)?;
 
-        assert!(key_i8_0 < key_i8_1);
         assert!(key_i8_1 < key_i8_2);
         assert!(key_i8_2 < key_i8_3);
+        assert!(key_i8_3 < key_i8_0);
 
         assert_eq!(
             v_i8_0,
@@ -2378,9 +2378,9 @@ mod test {
         v_i16_2.memcomparable_encode(&mut key_i16_2)?;
         v_i16_3.memcomparable_encode(&mut key_i16_3)?;
 
-        assert!(key_i16_0 < key_i16_1);
         assert!(key_i16_1 < key_i16_2);
         assert!(key_i16_2 < key_i16_3);
+        assert!(key_i16_3 < key_i16_0);
 
         assert_eq!(
             v_i16_0,
@@ -2427,9 +2427,9 @@ mod test {
         v_i32_2.memcomparable_encode(&mut key_i32_2)?;
         v_i32_3.memcomparable_encode(&mut key_i32_3)?;
 
-        assert!(key_i32_0 < key_i32_1);
         assert!(key_i32_1 < key_i32_2);
         assert!(key_i32_2 < key_i32_3);
+        assert!(key_i32_3 < key_i32_0);
 
         assert_eq!(
             v_i32_0,
@@ -2476,9 +2476,9 @@ mod test {
         v_i64_2.memcomparable_encode(&mut key_i64_2)?;
         v_i64_3.memcomparable_encode(&mut key_i64_3)?;
 
-        assert!(key_i64_0 < key_i64_1);
         assert!(key_i64_1 < key_i64_2);
         assert!(key_i64_2 < key_i64_3);
+        assert!(key_i64_3 < key_i64_0);
 
         assert_eq!(
             v_i64_0,
@@ -2532,9 +2532,9 @@ mod test {
         v_f32_2.memcomparable_encode(&mut key_f32_2)?;
         v_f32_3.memcomparable_encode(&mut key_f32_3)?;
 
-        assert!(key_f32_0 < key_f32_1);
         assert!(key_f32_1 < key_f32_2);
         assert!(key_f32_2 < key_f32_3);
+        assert!(key_f32_3 < key_f32_0);
 
         assert_eq!(
             v_f32_0,
@@ -2569,9 +2569,9 @@ mod test {
         v_f64_2.memcomparable_encode(&mut key_f64_2)?;
         v_f64_3.memcomparable_encode(&mut key_f64_3)?;
 
-        assert!(key_f64_0 < key_f64_1);
         assert!(key_f64_1 < key_f64_2);
         assert!(key_f64_2 < key_f64_3);
+        assert!(key_f64_3 < key_f64_0);
 
         assert_eq!(
             v_f64_0,
@@ -2628,9 +2628,9 @@ mod test {
         println!("{key_decimal_1:?} < {key_decimal_2:?}");
         println!("{key_decimal_2:?} < {key_decimal_3:?}");
 
-        assert!(key_decimal_0 < key_decimal_1);
         assert!(key_decimal_1 < key_decimal_2);
         assert!(key_decimal_2 < key_decimal_3);
+        assert!(key_decimal_3 < key_decimal_0);
 
         assert_eq!(
             v_decimal_0,
@@ -2694,8 +2694,8 @@ mod test {
         println!("{key_tuple_1:?} < {key_tuple_2:?}");
         println!("{key_tuple_2:?} < {key_tuple_3:?}");
 
-        assert!(key_tuple_1 < key_tuple_2);
         assert!(key_tuple_2 < key_tuple_3);
+        assert!(key_tuple_3 < key_tuple_1);
 
         assert_eq!(
             v_tuple_1,
@@ -2766,8 +2766,8 @@ mod test {
         v_tuple_2.memcomparable_encode(&mut key_tuple_2)?;
         v_tuple_3.memcomparable_encode(&mut key_tuple_3)?;
 
-        assert!(key_tuple_1 < key_tuple_2);
         assert!(key_tuple_2 < key_tuple_3);
+        assert!(key_tuple_3 < key_tuple_1);
 
         let ty = LogicalType::Tuple(vec![
             LogicalType::Tinyint,
@@ -2865,10 +2865,10 @@ mod test {
         v_zh.memcomparable_encode(&mut key_zh)?;
 
         // ordering
-        assert!(key_null < key_a);
         assert!(key_a < key_ab);
         assert!(key_ab < key_b);
         assert!(key_b < key_zh);
+        assert!(key_zh < key_null);
 
         // decode check
         assert_eq!(