chore: fix null_first in sort

Author: KKould

Makefile

@@ -0,0 +1,25 @@
+# Helper variables (override on invocation if needed).
+CARGO ?= cargo
+WASM_PACK ?= wasm-pack
+SQLLOGIC_PATH ?= tests/slt/**/*.slt
+
+.PHONY: test test-wasm test-slt test-all wasm-build
+
+## Run default Rust tests in the current environment (non-WASM).
+test:
+	$(CARGO) test
+
+## Build the WebAssembly package (artifact goes to ./pkg).
+wasm-build:
+	$(WASM_PACK) build --release --target nodejs
+
+## Execute wasm-bindgen tests under Node.js (wasm32 target).
+test-wasm:
+	$(WASM_PACK) test --node --release
+
+## Run the sqllogictest harness against the configured .slt suite.
+test-slt:
+	$(CARGO) run -p sqllogictest-test -- --path $(SQLLOGIC_PATH)
+
+## Convenience target to run every suite in sequence.
+test-all: test test-wasm test-slt

src/execution/dql/sort.rs

@@ -183,13 +183,13 @@ impl SortBy {
                         let mut key = BumpBytes::new_in(arena);
 
                         expr.eval(Some((tuple, schema)))?
-                            .memcomparable_encode(&mut key)?;
-                        if !asc {
-                            for byte in key.iter_mut() {
+                            .memcomparable_encode_with_null_order(&mut key, *nulls_first)?;
+
+                        if !asc && key.len() > 1 {
+                            for byte in key.iter_mut().skip(1) {
                                 *byte ^= 0xFF;
                             }
                         }
-                        key.push(if *nulls_first { u8::MIN } else { u8::MAX });
                         full_key.extend(key);
                     }
                     sort_keys.put((i, full_key))

src/execution/dql/top_k.rs

@@ -48,13 +48,12 @@ fn top_sort<'a>(
     {
         let mut key = BumpBytes::new_in(arena);
         expr.eval(Some((&tuple, &**schema)))?
-            .memcomparable_encode(&mut key)?;
-        if !asc {
-            for byte in key.iter_mut() {
+            .memcomparable_encode_with_null_order(&mut key, *nulls_first)?;
+        if !asc && key.len() > 1 {
+            for byte in key.iter_mut().skip(1) {
                 *byte ^= 0xFF;
             }
         }
-        key.push(if *nulls_first { u8::MIN } else { u8::MAX });
         full_key.extend(key);
     }
 

src/storage/memory.rs

@@ -218,6 +218,7 @@ mod wasm_tests {
                 max: Bound::Included(DataValue::Int32(2)),
             }],
             true,
+            None,
         )?;
 
         let mut result = Vec::new();

src/types/value.rs

@@ -657,13 +657,22 @@ impl DataValue {
         }
     }
 
-    #[inline]
-    pub fn memcomparable_encode(&self, b: &mut BumpBytes) -> Result<(), DatabaseError> {
+    #[inline(always)]
+    pub fn memcomparable_encode_with_null_order(
+        &self,
+        b: &mut BumpBytes,
+        nulls_first: bool,
+    ) -> Result<(), DatabaseError> {
+        let (null_tag, not_null_tag) = if nulls_first {
+            (NULL_TAG, NOTNULL_TAG)
+        } else {
+            (NOTNULL_TAG, NULL_TAG)
+        };
         if let DataValue::Null = self {
-            b.push(NULL_TAG);
+            b.push(null_tag);
             return Ok(());
         }
-        b.push(NOTNULL_TAG);
+        b.push(not_null_tag);
 
         match self {
             DataValue::Null => (),
@@ -719,6 +728,11 @@ impl DataValue {
         Ok(())
     }
 
+    #[inline]
+    pub fn memcomparable_encode(&self, b: &mut BumpBytes) -> Result<(), DatabaseError> {
+        self.memcomparable_encode_with_null_order(b, true)
+    }
+
     pub fn memcomparable_decode<R: Read>(
         reader: &mut R,
         ty: &LogicalType,