@minnowdb/core 0.2.1 → 0.4.0

package/dist/engine/sort-keys.d.ts

@@ -21,9 +21,10 @@
  */
 export interface SortKeyColumn {
     /**
-     * Ascending comparison with NULL smallest — the engine's default placement, which matches
-     * SQLite. Direction and an explicit NULLS FIRST/LAST stay with the caller: a placement is
-     * absolute, while direction negates the value comparison.
+     * Ascending comparison with NULL smallest. This is the column's raw comparison, not SQL's
+     * default placement: the sorter applies PostgreSQL's NULLS LAST for ASC and NULLS FIRST for
+     * DESC. Direction and an explicit NULLS FIRST/LAST stay with the caller because a placement is
+     * absolute, while direction negates only the non-null value comparison.
      *
      * Specialized when the column is built, so a comparison that runs millions of times is a
      * closure over one representation rather than a branch on which representation it holds.
@@ -71,4 +72,3 @@ export declare function buildSortKeyColumn(count: number, valueAt: (index: numbe
  * is already in order before doing anything else, since a scan often arrives sorted.
  */
 export declare function sortKeyIndexes(count: number, terms: readonly SortKeyTerm[]): Uint32Array;
-//# sourceMappingURL=sort-keys.d.ts.map

package/dist/engine/sort-keys.js

@@ -1,7 +1,8 @@
+import { dateMilliseconds } from "../date-value.js";
 import { compareSqlStrings, compareSqlValues } from "./sql-semantics.js";
 /** Unwraps a datetime to the number the comparisons use; every other value passes through. */
 export function comparableSortValue(value) {
-    return value instanceof Date ? value.getTime() : value;
+    return value instanceof Date ? dateMilliseconds(value) : value;
 }
 /**
  * Extracts one term's values into a comparison-ready column. `valueAt` is called once per row,
@@ -33,7 +34,14 @@ export function buildSortKeyColumn(count, valueAt) {
             kind = "boolean";
             numbers[index] = value ? 1 : 0;
         }
-        else if (typeof value === "string" && kind !== "number" && kind !== "boolean") {
+        else if (typeof value === "string" &&
+            // NUL-prefixed strings are the engine's lossless internal SQL-domain values
+            // (NUMERIC, ENUM, COLLATE, and friends). Their physical encoding is deliberately
+            // stable, not lexicographically ordered, so ranking the encoded strings would make
+            // ORDER BY disagree with the SQL comparator. Keep those terms on the generic path.
+            value.charCodeAt(0) !== 0 &&
+            kind !== "number" &&
+            kind !== "boolean") {
             kind = "string";
             ranks ??= new Map();
             let rank = ranks.get(value);
@@ -312,9 +320,8 @@ class KeySorter {
      * for a term without unboxed keys. A float's bits already order like the float once the sign
      * is folded (flip every bit of a negative, the sign bit of a positive); NaN is pinned just
      * past +Infinity and signed zero collapses to +0, which is where compareSqlValues puts them.
-     * DESC inverts the non-null keys, and NULL takes the end its placement names — the low end
-     * by default, which the inversion moves to the high end for DESC, or the end an explicit
-     * NULLS FIRST/LAST asks for regardless of direction.
+     * DESC inverts the non-null keys, and NULL takes the end its placement names. When omitted,
+     * PostgreSQL's default supplies NULLS LAST for ASC and NULLS FIRST for DESC.
      */
     #encodedKeys(term) {
         const cached = this.#encoded[term];
@@ -329,34 +336,45 @@ class KeySorter {
         const buffer = new ArrayBuffer(count * 8);
         const floats = new Float64Array(buffer);
         const words = new Uint32Array(buffer);
-        const nullWord = (spec.nulls === undefined ? !spec.descending : spec.nulls === "first")
-            ? 0
-            : UINT32_MAX;
+        const nullsFirst = (spec.nulls ?? (spec.descending ? "first" : "last")) === "first";
         const flip = spec.descending ? UINT32_MAX : 0;
+        // Keep the sentinel's low word aligned with the direction's transformed values. A sentinel
+        // that differs in an otherwise constant low digit makes radix sorting run a whole extra pass.
+        // The non-null domains are bounded away from these keys: ascending runs from encoded
+        // -Infinity through pinned NaN (fff80000:00000000), and descending is its bitwise inverse.
+        const nullHi = spec.descending
+            ? nullsFirst
+                ? 0x0007fffe
+                : UINT32_MAX
+            : nullsFirst
+                ? 0
+                : 0xfff80001;
+        const nullLo = spec.descending ? UINT32_MAX : 0;
         for (let index = 0; index < count; index += 1) {
             const lo = index * 2 + LO;
             const hi = index * 2 + HI;
             if (nulls[index] === 1) {
-                words[lo] = nullWord;
-                words[hi] = nullWord;
+                words[lo] = nullLo;
+                words[hi] = nullHi;
                 continue;
             }
             const value = numbers[index] ?? 0;
             if (value !== value) {
                 words[lo] = flip;
                 words[hi] = (0xfff80000 ^ flip) >>> 0;
-                continue;
-            }
-            // Adding +0 turns -0 into +0 and leaves every other value alone.
-            floats[index] = value + 0;
-            const rawHi = words[hi] ?? 0;
-            if ((rawHi & 0x80000000) !== 0) {
-                words[lo] = (~(words[lo] ?? 0) ^ flip) >>> 0;
-                words[hi] = (~rawHi ^ flip) >>> 0;
             }
             else {
-                words[lo] = ((words[lo] ?? 0) ^ flip) >>> 0;
-                words[hi] = ((rawHi | 0x80000000) ^ flip) >>> 0;
+                // Adding +0 turns -0 into +0 and leaves every other value alone.
+                floats[index] = value + 0;
+                const rawHi = words[hi] ?? 0;
+                if ((rawHi & 0x80000000) !== 0) {
+                    words[lo] = (~(words[lo] ?? 0) ^ flip) >>> 0;
+                    words[hi] = (~rawHi ^ flip) >>> 0;
+                }
+                else {
+                    words[lo] = ((words[lo] ?? 0) ^ flip) >>> 0;
+                    words[hi] = ((rawHi | 0x80000000) ^ flip) >>> 0;
+                }
             }
         }
         this.#encoded[term] = words;
@@ -385,15 +403,13 @@ class KeySorter {
         }
         else {
             const { column, descending } = spec;
-            const nullPlacement = spec.nulls === undefined ? 0 : spec.nulls === "first" ? 1 : -1;
+            const nulls = spec.nulls ?? (spec.descending ? "first" : "last");
             compare = (left, right) => {
-                if (nullPlacement !== 0) {
-                    // An explicit placement is absolute: direction must not negate it.
-                    const leftNull = column.isNull(left);
-                    const rightNull = column.isNull(right);
-                    if (leftNull || rightNull) {
-                        return leftNull && rightNull ? 0 : (leftNull ? -1 : 1) * nullPlacement;
-                    }
+                // NULL placement is absolute: direction must not negate it.
+                const leftNull = column.isNull(left);
+                const rightNull = column.isNull(right);
+                if (leftNull || rightNull) {
+                    return leftNull && rightNull ? 0 : (leftNull ? -1 : 1) * (nulls === "first" ? 1 : -1);
                 }
                 const comparison = column.compare(left, right);
                 return descending ? -comparison : comparison;
@@ -403,4 +419,3 @@ class KeySorter {
         return compare;
     }
 }
-//# sourceMappingURL=sort-keys.js.map

package/dist/engine/sql-domains.d.ts

@@ -0,0 +1,31 @@
+import type { SqlDomain } from "../storage/types.js";
+/**
+ * Protects an ordinary SQL string that happens to use the internal domain namespace. Physical
+ * TEXT remains unchanged on disk; this wrapper is applied at execution boundaries so a user
+ * value can never be mistaken for NUMERIC, INTERVAL, enum, or another tagged logical value.
+ */
+export declare function protectedSqlTextValue(value: string): string;
+/** Removes only the ordinary-TEXT wrapper, leaving real domain values tagged. */
+export declare function externalSqlTextValue(value: unknown): unknown;
+export declare function isExactNumeric(value: unknown): value is string;
+export declare function exactNumericValue(value: unknown, precision?: number, scale?: number): string | null;
+export declare function exactNumericBinary(operator: "+" | "-" | "*" | "/" | "%", left: unknown, right: unknown): string | null | undefined;
+export declare function exactNumericCompare(left: unknown, right: unknown): number | undefined;
+/**
+ * Serializes a JSON value while bounding traversal, nesting, and output before concatenation.
+ * Canonical mode sorts object names directly in the wire text (including integer-looking names,
+ * which JavaScript object enumeration would otherwise silently reorder).
+ */
+export declare function boundedJsonText(value: unknown, canonical: boolean, label?: string): string;
+export declare function jsonDomainValue(value: unknown, binary: boolean): string | null;
+export declare function uuidDomainValue(value: unknown): string | null;
+export declare function timeDomainValue(value: unknown): string | null;
+export declare function intervalDomainValue(value: unknown): string | null;
+export declare function arrayDomainValue(values: readonly unknown[]): string;
+export declare function enumDomainValue(value: unknown, name: string, values: readonly string[]): string | null;
+export declare function enumDomainCompare(left: unknown, right: unknown): number | undefined;
+export declare function normalizeSqlDomainValue(domain: SqlDomain, value: unknown): string | null;
+export declare function collatedDomainValue(value: unknown, collation: unknown): string | null;
+export declare function collatedDomainCompare(left: unknown, right: unknown): number | undefined;
+export declare function externalSqlDomainValue(value: unknown): unknown;
+export declare function isSqlDomainValue(value: unknown): value is string;