fix: topK sorted nulls first while full sort path sorted nulls last

The topK heap comparator treated null as "less than" everything (null
sorted first), but rowComparator used by the full sort path sorts nulls
last. This caused ORDER BY + LIMIT queries to produce different null
ordering depending on whether the limit was small enough to trigger the
topK path. Fixed topK to treat nulls as "greatest" (nulls-last),
matching rowComparator and SQL standard NULLS LAST default.

Author: teamchong

src/decode.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { decodePage, assembleRows, canSkipPage, canSkipFragment, matchesFilter, bigIntReplacer } from "./decode.js";
+import { decodePage, assembleRows, applySortAndLimit, canSkipPage, canSkipFragment, matchesFilter, bigIntReplacer } from "./decode.js";
 import type { ColumnMeta, PageInfo } from "./types.js";
 import type { QueryDescriptor } from "./client.js";
 import type { WasmEngine } from "./wasm-engine.js";
@@ -442,6 +442,56 @@ describe("assembleRows", () => {
   });
 });
 
+describe("applySortAndLimit (topK null ordering)", () => {
+  it("sorts nulls last in ascending topK", () => {
+    const rows = [
+      { v: null }, { v: 3 }, { v: 1 }, { v: null }, { v: 2 }, { v: 5 }, { v: 4 },
+    ];
+    const query: QueryDescriptor = {
+      table: "t", filters: [], projections: ["v"],
+      sortColumn: "v", sortDirection: "asc", limit: 3,
+    };
+    const result = applySortAndLimit(rows, query);
+    expect(result.map(r => r.v)).toEqual([1, 2, 3]);
+  });
+
+  it("sorts nulls last in descending topK", () => {
+    const rows = [
+      { v: null }, { v: 3 }, { v: 1 }, { v: null }, { v: 2 }, { v: 5 }, { v: 4 },
+    ];
+    const query: QueryDescriptor = {
+      table: "t", filters: [], projections: ["v"],
+      sortColumn: "v", sortDirection: "desc", limit: 3,
+    };
+    const result = applySortAndLimit(rows, query);
+    expect(result.map(r => r.v)).toEqual([5, 4, 3]);
+  });
+
+  it("nulls appear at end when limit exceeds non-null count", () => {
+    const rows = [
+      { v: null }, { v: 2 }, { v: 1 },
+    ];
+    const query: QueryDescriptor = {
+      table: "t", filters: [], projections: ["v"],
+      sortColumn: "v", sortDirection: "asc", limit: 3,
+    };
+    const result = applySortAndLimit(rows, query);
+    expect(result.map(r => r.v)).toEqual([1, 2, null]);
+  });
+
+  it("full sort path also puts nulls last", () => {
+    const rows = [
+      { v: null }, { v: 3 }, { v: 1 }, { v: null }, { v: 2 },
+    ];
+    const query: QueryDescriptor = {
+      table: "t", filters: [], projections: ["v"],
+      sortColumn: "v", sortDirection: "asc",
+    };
+    const result = applySortAndLimit(rows, query);
+    expect(result.map(r => r.v)).toEqual([1, 2, 3, null, null]);
+  });
+});
+
 describe("matchesFilter", () => {
   it("matches eq", () => {
     expect(matchesFilter(42, { column: "x", op: "eq", value: 42 })).toBe(true);

src/decode.ts

@@ -359,17 +359,18 @@ function topK(rows: Row[], k: number, col: string, desc: boolean): Row[] {
 
   const cmp = (a: Row, b: Row): number => {
     const av = a[col], bv = b[col];
-    if (av === null && bv === null) return 0;
-    if (av === null) return -1;
-    if (bv === null) return 1;
+    // Nulls-last: null is "greatest" so it sits at the heap root and gets replaced first
+    if ((av === null || av === undefined) && (bv === null || bv === undefined)) return 0;
+    if (av === null || av === undefined) return 1;
+    if (bv === null || bv === undefined) return -1;
     const c = av < bv ? -1 : av > bv ? 1 : 0;
     return desc ? -c : c;
   };
 
   const shouldReplace = (row: Row): boolean => {
     const nv = row[col], rv = heap[0][col];
-    if (nv === null) return false;
-    if (rv === null) return true;
+    if (nv === null || nv === undefined) return false;
+    if (rv === null || rv === undefined) return true;
     return desc ? nv > rv : nv < rv;
   };