@minnowdb/core 0.5.0 → 0.6.1

package/dist/engine/vector.js

@@ -1,14 +1,15 @@
 import { dateMilliseconds } from "../date-value.js";
 import { MAX_TEMP_RUN_BATCH_BYTES, MAX_TEMP_RUN_PAGE_BYTES, MAX_TEMP_RUN_PAGES_PER_BATCH, } from "../storage/types.js";
+import { throwIfAborted } from "./cancellation.js";
 import { cachedListMembership, childExpressions, distinctFromComparison, nullOrder, isScalarFunctionName, likeMatches, orderOutputName, parseQuantified, quantifiedComparison, scalarFunctionValue, unknownColumnDomains, } from "./query.js";
-import { jsonValueOf } from "./sql-json.js";
+import { jsonConstructor } from "./sql-json.js";
 import { bm25DocumentScore, cachedQueryTerms, FtsStatsAccumulator, fullTermsMask, renderDocumentValue, termFrequencies, termsMask, tokenize, } from "./fts.js";
 import { ByteGroupIndex } from "./group-index.js";
 import { ByteJoinIndex } from "./join-index.js";
 import { UnknownTableError } from "./errors.js";
 import { QueryMemoryBudgetError, QueryMemoryContext, } from "./memory.js";
 import { compareSqlValues, compileSimilarPattern, defineSqlResultProperty, } from "./sql-semantics.js";
-import { exactNumericBinary, externalSqlDomainValue, isDateDomainValue, isExactNumeric, protectedSqlTextValue, } from "./sql-domains.js";
+import { exactNumericBinary, externalSqlDomainValue, isDateDomainValue, isExactNumeric, preservedJsonDomainValue, protectedSqlTextValue, } from "./sql-domains.js";
 import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
 const DEFAULT_BATCH_ROWS = 2_048;
 /** Above this, locating each IN member separately costs more than scanning between them. */
@@ -42,11 +43,14 @@ function boundedSpillPageRows(value) {
     return Math.min(rows, DEFAULT_BATCH_ROWS);
 }
 /** Writes already-materialized pages through the batch method when the store offers one. */
-async function writeSpillPages(store, pages) {
+async function writeSpillPages(store, pages, signal) {
+    throwIfAborted(signal);
     const batched = store.putPages?.bind(store);
     if (batched === undefined) {
         for (const page of pages) {
+            throwIfAborted(signal);
             await store.putPage(page.ownerId, page.runId, page.pageIndex, page.bytes);
+            throwIfAborted(signal);
         }
         return;
     }
@@ -60,24 +64,28 @@ async function writeSpillPages(store, pages) {
             (batch.length === SPILL_WRITE_BATCH_PAGES ||
                 batchBytes + page.bytes.byteLength > MAX_TEMP_RUN_BATCH_BYTES)) {
             await batched(batch);
+            throwIfAborted(signal);
             batch = [];
             batchBytes = 0;
         }
         batch.push(page);
         batchBytes += page.bytes.byteLength;
     }
-    if (batch.length > 0)
+    if (batch.length > 0) {
         await batched(batch);
+        throwIfAborted(signal);
+    }
 }
-async function writeSpillRowPages(store, ownerId, runId, startPageIndex, columns, rows, pageRows) {
+async function writeSpillRowPages(store, ownerId, runId, startPageIndex, columns, rows, pageRows, signal) {
     let pending = [];
     let pendingBytes = 0;
     let pageCount = 0;
     for (const bytes of encodeSpillRowPages(columns, rows, pageRows)) {
+        throwIfAborted(signal);
         if (pending.length > 0 &&
             (pending.length === SPILL_WRITE_BATCH_PAGES ||
                 pendingBytes + bytes.byteLength > MAX_TEMP_RUN_BATCH_BYTES)) {
-            await writeSpillPages(store, pending);
+            await writeSpillPages(store, pending, signal);
             pending = [];
             pendingBytes = 0;
         }
@@ -85,7 +93,7 @@ async function writeSpillRowPages(store, ownerId, runId, startPageIndex, columns
         pendingBytes += bytes.byteLength;
         pageCount += 1;
     }
-    await writeSpillPages(store, pending);
+    await writeSpillPages(store, pending, signal);
     return pageCount;
 }
 export function createColumnarTable(name, columns, uniqueKey) {
@@ -157,13 +165,17 @@ export function prepareVectorQuery(plan, inputTables, options = {}) {
             async executeAsync(executionOptions = {}) {
                 if (closed)
                     throw new Error("Prepared vector query is closed");
+                throwIfAborted(executionOptions.signal);
                 const canSpillSort = bound.orderBy.length > 0 && !bound.grouped && !bound.sourceOrdered;
                 // An unordered grouped plan spills too: the empty ordering makes the pairwise merge a
                 // stable concatenation, and partition-wise accumulation bounds peak group state.
                 const canSpillHash = bound.grouped && bound.groupBy.length > 0;
                 if (executionOptions.spillStore === undefined || (!canSpillSort && !canSpillHash)) {
-                    if (executionOptions.loadScanWindow === undefined)
-                        return this.execute();
+                    if (executionOptions.loadScanWindow === undefined) {
+                        const result = this.execute();
+                        throwIfAborted(executionOptions.signal);
+                        return result;
+                    }
                     const executionMemory = retainedMemory.createChild();
                     try {
                         return await executeBoundPlanAsync(bound, executionMemory, executionOptions);
@@ -589,6 +601,9 @@ function bindPlan(plan, tables, memory, ftsStats) {
         const dictionaryLike = detectDictionaryLike(bound);
         if (dictionaryLike !== undefined)
             return { ...bound, dictionaryLike };
+        const dictionaryNumeric = detectDictionaryNumericComparison(bound);
+        if (dictionaryNumeric !== undefined)
+            return { ...bound, dictionaryNumeric };
         const primitive = detectPrimitiveComparison(bound);
         if (primitive !== undefined)
             return { ...bound, primitive };
@@ -599,8 +614,11 @@ function bindPlan(plan, tables, memory, ftsStats) {
         const bound = bindPredicate(predicate);
         if (bound.primitive !== undefined || bound.primitiveIn !== undefined)
             return bound;
-        if (bound.dictionaryEquality !== undefined || bound.dictionaryLike !== undefined)
+        if (bound.dictionaryEquality !== undefined ||
+            bound.dictionaryLike !== undefined ||
+            bound.dictionaryNumeric !== undefined) {
             return bound;
+        }
         const branches = disjunctiveNormalForm(predicate);
         if (branches === undefined)
             return bound;
@@ -652,10 +670,10 @@ function bindPlan(plan, tables, memory, ftsStats) {
     });
     // A wildcard select projects the materialized columns of each source, so ORDER BY resolves
     // against those same names.
-    const orderSources = sources.map((source, index) => ({
-        alias: source.alias,
-        columns: [...(sourceTables[index]?.columns.keys() ?? [])],
-    }));
+    const orderSources = sources.flatMap((source, index) => {
+        const columns = [...(sourceTables[index]?.columns.keys() ?? [])].filter((name) => !name.startsWith("\0"));
+        return columns.length === 0 ? [] : [{ alias: source.alias, columns }];
+    });
     const orderBy = plan.orderBy.map(({ expression, direction, nulls }) => ({
         outputName: orderOutputName(expression, plan.select, orderSources),
         direction,
@@ -846,8 +864,11 @@ function bindExpression(expression, sources, aggregateSpecs, aggregateIndexes, m
             argument.vector.kind === "datetime"
             ? { source: argument.source, vector: argument.vector }
             : undefined;
-        const rawNumber = expression.name !== "JSON_ARRAYAGG" &&
-            expression.name !== "STRING_AGG" &&
+        const rawNumber = (expression.name === "COUNT" ||
+            expression.name === "SUM" ||
+            expression.name === "AVG" ||
+            expression.name === "MIN" ||
+            expression.name === "MAX") &&
             argument.kind === "column" &&
             argument.vector.kind === "number"
             ? { source: argument.source, vector: argument.vector }
@@ -1217,6 +1238,7 @@ function executeBoundPlan(plan, memory) {
     return finishResult(plan, rows, memory);
 }
 async function executeBoundPlanAsync(plan, memory, options) {
+    throwIfAborted(options.signal);
     const metadataCount = executeMetadataCount(plan, memory);
     if (metadataCount !== undefined)
         return metadataCount;
@@ -1224,11 +1246,13 @@ async function executeBoundPlanAsync(plan, memory, options) {
     const output = new ResultSink(plan, memory, options.loadScanWindow === undefined);
     const scanRows = plan.sourceTables[plan.scanSource]?.rowCount ?? 0;
     for (let start = 0; start < scanRows;) {
+        throwIfAborted(options.signal);
         let length = Math.min(DEFAULT_BATCH_ROWS, scanRows - start);
         // The loader answers synchronously when the batch is already resident — the common case,
         // every batch but the first per block — so the scan loop only pays await on real slides.
         const loaded = options.loadScanWindow?.(start, length);
         const residentEnd = typeof loaded === "number" || loaded === undefined ? loaded : await loaded;
+        throwIfAborted(options.signal);
         if (typeof residentEnd === "number" && residentEnd > start) {
             length = Math.min(length, residentEnd - start);
         }
@@ -1250,6 +1274,7 @@ async function executeBoundPlanAsync(plan, memory, options) {
         const ranges = narrowed.ranges ?? [{ begin: narrowed.begin, end: narrowed.end }];
         for (const range of ranges) {
             for (let row = range.begin; row < range.end; row += DEFAULT_BATCH_ROWS) {
+                throwIfAborted(options.signal);
                 const rows = Math.min(DEFAULT_BATCH_ROWS, range.end - row);
                 if (runScanBatch(plan, row, rows, groups, output, memory)) {
                     stopped = true;
@@ -1263,6 +1288,7 @@ async function executeBoundPlanAsync(plan, memory, options) {
             break;
         start = windowEnd;
     }
+    throwIfAborted(options.signal);
     const rows = plan.grouped ? finishGroups(plan, groups.values(), memory) : output.finish();
     return finishResult(plan, rows, memory);
 }
@@ -1275,24 +1301,44 @@ async function executeBoundPlanBatches(plan, memory, options, consume) {
     const columns = plan.wildcard ? wildcardColumnNames(plan) : plan.select.map((item) => item.alias);
     const { limit, offset, ...unbounded } = plan;
     const scanPlan = unbounded;
+    const consumeFirstColumn = options.consumeFirstColumn;
+    const firstExpression = consumeFirstColumn === undefined ? undefined : scanPlan.select[0]?.expression;
     let skipped = 0;
     let emitted = 0;
     const scanRows = scanPlan.sourceTables[scanPlan.scanSource]?.rowCount ?? 0;
     const step = Math.min(DEFAULT_BATCH_ROWS, options.batchRows);
     for (let start = 0; start < scanRows && (limit === undefined || emitted < limit);) {
-        options.signal?.throwIfAborted();
+        throwIfAborted(options.signal);
         let length = Math.min(step, scanRows - start);
         const loaded = options.loadScanWindow?.(start, length);
         const residentEnd = typeof loaded === "number" || loaded === undefined ? loaded : await loaded;
-        options.signal?.throwIfAborted();
+        throwIfAborted(options.signal);
         if (typeof residentEnd === "number" && residentEnd > start) {
             length = Math.min(length, residentEnd - start);
         }
         const pageMemory = memory.createChild();
         try {
             const groups = new GroupAccumulator(scanPlan, pageMemory);
-            const output = new ResultSink(scanPlan, pageMemory, options.loadScanWindow === undefined);
+            const values = [];
+            const output = firstExpression === undefined
+                ? new ResultSink(scanPlan, pageMemory, options.loadScanWindow === undefined)
+                : {
+                    get size() {
+                        return values.length;
+                    },
+                    tryAddBatch: () => false,
+                    add: (batch, row) => {
+                        values.push(asQueryValue(evaluateBatchExpression(scanPlan, firstExpression, batch, row)));
+                    },
+                    finish: () => [],
+                };
             runScanBatch(scanPlan, start, length, groups, output, pageMemory);
+            if (firstExpression !== undefined && consumeFirstColumn !== undefined) {
+                if (values.length > 0)
+                    await consumeFirstColumn(values);
+                start += length;
+                continue;
+            }
             let rows = output.finish();
             const remainingOffset = Math.max(0, (offset ?? 0) - skipped);
             if (remainingOffset > 0) {
@@ -1323,6 +1369,7 @@ function createSpillOwnerId() {
     return `query-${globalThis.crypto.randomUUID()}`;
 }
 async function executeBoundPlanWithSortSpill(plan, memory, options) {
+    throwIfAborted(options.signal);
     const store = required(options.spillStore, "Query spill store is missing");
     const pageRows = boundedSpillPageRows(options.spillPageRows);
     const columns = plan.wildcard ? wildcardColumnNames(plan) : plan.select.map((item) => item.alias);
@@ -1333,9 +1380,11 @@ async function executeBoundPlanWithSortSpill(plan, memory, options) {
         const scanRows = plan.sourceTables[plan.scanSource]?.rowCount ?? 0;
         const scanBatchRows = Math.min(DEFAULT_BATCH_ROWS, pageRows);
         for (let start = 0; start < scanRows;) {
+            throwIfAborted(options.signal);
             let length = Math.min(scanBatchRows, scanRows - start);
             const loadedSort = options.loadScanWindow?.(start, length);
             const residentEnd = typeof loadedSort === "number" || loadedSort === undefined ? loadedSort : await loadedSort;
+            throwIfAborted(options.signal);
             if (typeof residentEnd === "number" && residentEnd > start) {
                 length = Math.min(length, residentEnd - start);
             }
@@ -1351,6 +1400,7 @@ async function executeBoundPlanWithSortSpill(plan, memory, options) {
                 for (let index = 0; index < length; index += 1)
                     scan[index] = start + index;
                 await spillJoinedBatches(plan, { length, rowsBySource: sourceRows, memory: batchMemory }, 0, memory, async (batch) => {
+                    throwIfAborted(options.signal);
                     const outputMemory = memory.createChild();
                     try {
                         const rows = [];
@@ -1365,13 +1415,13 @@ async function executeBoundPlanWithSortSpill(plan, memory, options) {
                             ordering.release();
                         }
                         const runId = `run-${String(runSequence++)}`;
-                        const pageCount = await writeSpillRowPages(store, ownerId, runId, 0, columns, rows, pageRows);
+                        const pageCount = await writeSpillRowPages(store, ownerId, runId, 0, columns, rows, pageRows, options.signal);
                         runs.push({ id: runId, pageCount });
                     }
                     finally {
                         outputMemory.close();
                     }
-                });
+                }, options.signal);
             }
             finally {
                 batchMemory.close();
@@ -1382,8 +1432,10 @@ async function executeBoundPlanWithSortSpill(plan, memory, options) {
             return { columns, columnDomains: unknownColumnDomains(columns), rows: [] };
         let active = runs;
         while (active.length > 1) {
+            throwIfAborted(options.signal);
             const merged = [];
             for (let index = 0; index < active.length; index += 2) {
+                throwIfAborted(options.signal);
                 const left = required(active[index], "Left spill run is missing");
                 const right = active[index + 1];
                 if (right === undefined) {
@@ -1391,9 +1443,10 @@ async function executeBoundPlanWithSortSpill(plan, memory, options) {
                     continue;
                 }
                 const outputId = `merge-${String(runSequence++)}`;
-                merged.push(await mergeSpillRuns(store, ownerId, left, right, outputId, columns, plan.orderBy, pageRows, memory));
+                merged.push(await mergeSpillRuns(store, ownerId, left, right, outputId, columns, plan.orderBy, pageRows, memory, options.signal));
                 await store.removeRun(ownerId, left.id);
                 await store.removeRun(ownerId, right.id);
+                throwIfAborted(options.signal);
             }
             active = merged;
         }
@@ -1402,7 +1455,9 @@ async function executeBoundPlanWithSortSpill(plan, memory, options) {
         const offset = plan.offset ?? 0;
         const limit = plan.limit === undefined ? Number.MAX_SAFE_INTEGER : plan.limit + offset;
         for (let pageIndex = 0; pageIndex < finalRun.pageCount && rows.length < limit; pageIndex += 1) {
+            throwIfAborted(options.signal);
             const bytes = await store.getPage(ownerId, finalRun.id, pageIndex);
+            throwIfAborted(options.signal);
             if (bytes === undefined)
                 throw new Error("Query spill page is missing");
             for (const row of decodeSpillRows(columns, bytes)) {
@@ -1420,6 +1475,7 @@ async function executeBoundPlanWithSortSpill(plan, memory, options) {
     }
 }
 async function executeBoundPlanWithHashSpill(plan, memory, options) {
+    throwIfAborted(options.signal);
     const store = required(options.spillStore, "Query spill store is missing");
     const pageRows = boundedSpillPageRows(options.spillPageRows);
     const partitionCount = 64;
@@ -1436,9 +1492,11 @@ async function executeBoundPlanWithHashSpill(plan, memory, options) {
         // page size while staying coarse enough to amortize partition-page write transactions.
         const scanChunkRows = Math.min(DEFAULT_BATCH_ROWS, HASH_SPILL_SCAN_CHUNK_ROWS);
         for (let start = 0; start < scanRows;) {
+            throwIfAborted(options.signal);
             let length = Math.min(scanChunkRows, scanRows - start);
             const loadedHash = options.loadScanWindow?.(start, length);
             const residentEnd = typeof loadedHash === "number" || loadedHash === undefined ? loadedHash : await loadedHash;
+            throwIfAborted(options.signal);
             if (typeof residentEnd === "number" && residentEnd > start) {
                 length = Math.min(length, residentEnd - start);
             }
@@ -1458,6 +1516,7 @@ async function executeBoundPlanWithHashSpill(plan, memory, options) {
                 // Each surviving row spills its evaluated group keys and aggregate arguments, so the
                 // partition phase never re-reads source vectors and the scan source may be windowed.
                 async (batch) => {
+                    throwIfAborted(options.signal);
                     for (let row = 0; row < batch.length; row += 1) {
                         if (!plan.predicates.every((predicate) => evaluateBatchPredicate(plan, predicate, batch, row))) {
                             continue;
@@ -1480,6 +1539,12 @@ async function executeBoundPlanWithHashSpill(plan, memory, options) {
                                     (spec.orderBy ?? []).map((order) => encodeSpillValue(asQueryValue(evaluateBatchExpression(plan, order.expression, batch, row)))),
                                 ]);
                             }
+                            else if (spec.name === "JSON_ARRAYAGG" && (spec.orderBy?.length ?? 0) > 0) {
+                                spillRow[`a${String(index)}`] = JSON.stringify([
+                                    encodeSpillValue(asQueryValue(raw ?? null)),
+                                    (spec.orderBy ?? []).map((order) => encodeSpillValue(asQueryValue(evaluateBatchExpression(plan, order.expression, batch, row)))),
+                                ]);
+                            }
                             else {
                                 spillRow[`a${String(index)}`] =
                                     raw === null || raw === undefined ? null : asQueryValue(raw);
@@ -1491,7 +1556,7 @@ async function executeBoundPlanWithHashSpill(plan, memory, options) {
                         rows.push(spillRow);
                         partitionBuffers.set(partition, rows);
                     }
-                });
+                }, options.signal);
                 const flush = [];
                 let flushBytes = 0;
                 for (const [partition, rows] of partitionBuffers) {
@@ -1499,7 +1564,7 @@ async function executeBoundPlanWithHashSpill(plan, memory, options) {
                         if (flush.length > 0 &&
                             (flush.length === SPILL_WRITE_BATCH_PAGES ||
                                 flushBytes + bytes.byteLength > MAX_TEMP_RUN_BATCH_BYTES)) {
-                            await writeSpillPages(store, flush);
+                            await writeSpillPages(store, flush, options.signal);
                             flush.length = 0;
                             flushBytes = 0;
                         }
@@ -1514,7 +1579,7 @@ async function executeBoundPlanWithHashSpill(plan, memory, options) {
                         partitionPages[partition] = pageIndex + 1;
                     }
                 }
-                await writeSpillPages(store, flush);
+                await writeSpillPages(store, flush, options.signal);
             }
             finally {
                 batchMemory.close();
@@ -1523,6 +1588,7 @@ async function executeBoundPlanWithHashSpill(plan, memory, options) {
         }
         const runs = [];
         for (let partition = 0; partition < partitionCount; partition += 1) {
+            throwIfAborted(options.signal);
             const sourcePageCount = partitionPages[partition] ?? 0;
             if (sourcePageCount === 0)
                 continue;
@@ -1530,7 +1596,9 @@ async function executeBoundPlanWithHashSpill(plan, memory, options) {
             try {
                 const groups = new ByteGroupIndex(partitionMemory);
                 for (let pageIndex = 0; pageIndex < sourcePageCount; pageIndex += 1) {
+                    throwIfAborted(options.signal);
                     const bytes = await store.getPage(ownerId, `partition-${String(partition)}`, pageIndex);
+                    throwIfAborted(options.signal);
                     if (bytes === undefined)
                         throw new Error("Query hash spill page is missing");
                     const pageMemory = partitionMemory.createChild();
@@ -1559,7 +1627,7 @@ async function executeBoundPlanWithHashSpill(plan, memory, options) {
                     }
                 }
                 const runId = `group-${String(runSequence++)}`;
-                const pageCount = await writeSpillRowPages(store, ownerId, runId, 0, columns, rows, pageRows);
+                const pageCount = await writeSpillRowPages(store, ownerId, runId, 0, columns, rows, pageRows, options.signal);
                 runs.push({ id: runId, pageCount });
             }
             finally {
@@ -1569,9 +1637,9 @@ async function executeBoundPlanWithHashSpill(plan, memory, options) {
         }
         if (runs.length === 0)
             return { columns, columnDomains: unknownColumnDomains(columns), rows: [] };
-        const finalRun = await mergeAllSpillRuns(store, ownerId, runs, columns, plan.orderBy, pageRows, () => `merge-${String(runSequence++)}`, memory);
+        const finalRun = await mergeAllSpillRuns(store, ownerId, runs, columns, plan.orderBy, pageRows, () => `merge-${String(runSequence++)}`, memory, options.signal);
         const spillOffset = plan.offset ?? 0;
-        const result = await readFinalSpillRun(store, ownerId, finalRun, columns, plan.limit === undefined ? undefined : plan.limit + spillOffset);
+        const result = await readFinalSpillRun(store, ownerId, finalRun, columns, plan.limit === undefined ? undefined : plan.limit + spillOffset, options.signal);
         if (spillOffset > 0)
             result.rows.splice(0, Math.min(spillOffset, result.rows.length));
         return result;
@@ -1580,11 +1648,13 @@ async function executeBoundPlanWithHashSpill(plan, memory, options) {
         await store.removeOwner(ownerId);
     }
 }
-async function mergeAllSpillRuns(store, ownerId, runs, columns, orderBy, pageRows, nextRunId, memory) {
+async function mergeAllSpillRuns(store, ownerId, runs, columns, orderBy, pageRows, nextRunId, memory, signal) {
     let active = [...runs];
     while (active.length > 1) {
+        throwIfAborted(signal);
         const merged = [];
         for (let index = 0; index < active.length; index += 2) {
+            throwIfAborted(signal);
             const left = required(active[index], "Left spill run is missing");
             const right = active[index + 1];
             if (right === undefined) {
@@ -1592,19 +1662,22 @@ async function mergeAllSpillRuns(store, ownerId, runs, columns, orderBy, pageRow
                 continue;
             }
             const outputId = nextRunId();
-            merged.push(await mergeSpillRuns(store, ownerId, left, right, outputId, columns, orderBy, pageRows, memory));
+            merged.push(await mergeSpillRuns(store, ownerId, left, right, outputId, columns, orderBy, pageRows, memory, signal));
             await store.removeRun(ownerId, left.id);
             await store.removeRun(ownerId, right.id);
+            throwIfAborted(signal);
         }
         active = merged;
     }
     return required(active[0], "Final spill run is missing");
 }
-async function readFinalSpillRun(store, ownerId, run, columns, requestedLimit) {
+async function readFinalSpillRun(store, ownerId, run, columns, requestedLimit, signal) {
     const rows = [];
     const limit = requestedLimit ?? Number.MAX_SAFE_INTEGER;
     for (let pageIndex = 0; pageIndex < run.pageCount && rows.length < limit; pageIndex += 1) {
+        throwIfAborted(signal);
         const bytes = await store.getPage(ownerId, run.id, pageIndex);
+        throwIfAborted(signal);
         if (bytes === undefined) {
             throw new Error(`Query spill page is missing: ${run.id}/${String(pageIndex)}`);
         }
@@ -1651,15 +1724,17 @@ function hashQueryValues(values) {
     }
     return hash;
 }
-async function spillJoinedBatches(plan, batch, joinIndex, memory, consume) {
+async function spillJoinedBatches(plan, batch, joinIndex, memory, consume, signal) {
+    throwIfAborted(signal);
     const join = plan.joins[joinIndex];
     if (join === undefined) {
         await consume(batch);
         return;
     }
     for (const joined of joinBatches(plan, batch, join, memory)) {
+        throwIfAborted(signal);
         try {
-            await spillJoinedBatches(plan, joined, joinIndex + 1, memory, consume);
+            await spillJoinedBatches(plan, joined, joinIndex + 1, memory, consume, signal);
         }
         finally {
             joined.memory?.close();
@@ -1686,25 +1761,27 @@ function passesPredicates(plan, batch, row) {
     }
     return true;
 }
-async function mergeSpillRuns(store, ownerId, left, right, outputId, columns, orderBy, pageRows, memory) {
+async function mergeSpillRuns(store, ownerId, left, right, outputId, columns, orderBy, pageRows, memory, signal) {
     const mergeMemory = memory.createChild();
-    const leftReader = createSpillRunReader(store, ownerId, left, columns, mergeMemory);
-    const rightReader = createSpillRunReader(store, ownerId, right, columns, mergeMemory);
+    const leftReader = createSpillRunReader(store, ownerId, left, columns, mergeMemory, signal);
+    const rightReader = createSpillRunReader(store, ownerId, right, columns, mergeMemory, signal);
     let outputPage = [];
     let outputMemory = mergeMemory.createChild();
     let pageIndex = 0;
     const flush = async () => {
         if (outputPage.length === 0)
             return;
-        pageIndex += await writeSpillRowPages(store, ownerId, outputId, pageIndex, columns, outputPage, pageRows);
+        pageIndex += await writeSpillRowPages(store, ownerId, outputId, pageIndex, columns, outputPage, pageRows, signal);
         outputPage = [];
         outputMemory.close();
         outputMemory = mergeMemory.createChild();
     };
     try {
+        throwIfAborted(signal);
         let leftRow = await leftReader.next();
         let rightRow = await rightReader.next();
         while (leftRow !== undefined || rightRow !== undefined) {
+            throwIfAborted(signal);
             if (rightRow === undefined ||
                 (leftRow !== undefined && compareOrderedRows(leftRow, rightRow, orderBy) <= 0)) {
                 const row = required(leftRow, "Left spill row is missing");
@@ -1730,17 +1807,19 @@ async function mergeSpillRuns(store, ownerId, left, right, outputId, columns, or
         mergeMemory.close();
     }
 }
-function createSpillRunReader(store, ownerId, run, columns, memory) {
+function createSpillRunReader(store, ownerId, run, columns, memory, signal) {
     let pageIndex = 0;
     let rows = [];
     let rowIndex = 0;
     let pageReservation;
     return {
         async next() {
+            throwIfAborted(signal);
             while (rowIndex >= rows.length) {
                 if (pageIndex >= run.pageCount)
                     return undefined;
                 const bytes = await store.getPage(ownerId, run.id, pageIndex);
+                throwIfAborted(signal);
                 if (bytes === undefined)
                     throw new Error("Query spill page is missing");
                 pageReservation?.release();
@@ -2269,6 +2348,43 @@ function filterDictionaryLike(fast, batch, selection, survivors) {
     }
     return kept;
 }
+/** Compacts the selection using a match table computed once per exact-NUMERIC dictionary. */
+function filterDictionaryNumeric(fast, batch, selection, survivors) {
+    const vector = fast.expression.vector;
+    if (fast.cache.dictionary !== vector.dictionary) {
+        const matches = dictionaryNumericMatches(fast, vector.dictionary);
+        if (matches === undefined)
+            return undefined;
+        fast.cache.dictionary = vector.dictionary;
+        fast.cache.matches = matches;
+    }
+    const matches = fast.cache.matches;
+    const rows = batch.rowsBySource[fast.expression.source];
+    const codes = vector.codes;
+    const validity = vector.validity;
+    const windowStart = vector.window?.start ?? 0;
+    const slots = codes.length;
+    const vectorLength = vector.length;
+    let kept = 0;
+    for (let index = 0; index < survivors; index += 1) {
+        const row = selection[index] ?? 0;
+        const sourceRow = rows?.[row] ?? -1;
+        if (sourceRow < 0 || sourceRow >= vectorLength)
+            continue;
+        const slot = sourceRow - windowStart;
+        if (slot < 0 || slot >= slots) {
+            throw new RangeError("Streamed vector row is outside the resident window");
+        }
+        if (((validity[slot >>> 3] ?? 0) & (1 << (slot & 7))) === 0)
+            continue;
+        const code = codes[slot] ?? NULL_STRING_CODE;
+        if (code === NULL_STRING_CODE || matches[code] !== 1)
+            continue;
+        selection[kept] = row;
+        kept += 1;
+    }
+    return kept;
+}
 // The per-batch selection scratch: batches are bounded by DEFAULT_BATCH_ROWS, spills may use
 // larger pages, so the scratch grows to the largest batch seen and is trivially small.
 let selectionScratch = new Uint32Array(DEFAULT_BATCH_ROWS);
@@ -2289,6 +2405,9 @@ function applyPredicateKernel(plan, predicate, batch, selection, survivors) {
     if (predicate.dictionaryLike !== undefined) {
         return filterDictionaryLike(predicate.dictionaryLike, batch, selection, survivors);
     }
+    if (predicate.dictionaryNumeric !== undefined) {
+        return filterDictionaryNumeric(predicate.dictionaryNumeric, batch, selection, survivors);
+    }
     if (predicate.disjunction !== undefined) {
         return filterDisjunction(plan, predicate.disjunction, batch, selection, survivors);
     }
@@ -3653,12 +3772,30 @@ function updateAggregatesFromValues(plan, state, values, memory) {
                 throw new Error("Spilled STRING_AGG order is invalid");
             applyAggregateValue(spec, state, index, decoded[0], memory, decoded[1], encodedOrder.map(decodeSpillValue));
         }
+        else if (spec.name === "JSON_ARRAYAGG" &&
+            (spec.orderBy?.length ?? 0) > 0 &&
+            typeof value === "string") {
+            const decoded = JSON.parse(value);
+            if (!Array.isArray(decoded) || decoded.length !== 2 || !Array.isArray(decoded[1])) {
+                throw new Error("Spilled JSON_ARRAYAGG input is invalid");
+            }
+            applyAggregateValue(spec, state, index, decodeSpillValue(decoded[0]), memory, undefined, decoded[1].map(decodeSpillValue));
+        }
         else {
             applyAggregateValue(spec, state, index, value, memory);
         }
     }
 }
 function applyAggregateValue(spec, state, index, value, memory, delimiter, orderValues = []) {
+    if (spec.name === "MINNOW_SINGLE_VALUE") {
+        const count = (state.counts[index] ?? 0) + 1;
+        state.counts[index] = count;
+        if (count > 1) {
+            throw new TypeError(`A scalar subquery returned ${String(count)} rows`);
+        }
+        replaceAggregateValue(state, index, asQueryValue(value ?? null), "Scalar subquery value", memory);
+        return;
+    }
     if (spec.name === "JSON_ARRAYAGG") {
         const member = asQueryValue(value ?? null);
         if (spec.distinct === true && !firstOfItsKind(state, index, member, memory))
@@ -3670,8 +3807,14 @@ function applyAggregateValue(spec, state, index, value, memory, delimiter, order
             list = [];
             lists[index] = list;
         }
-        list.push(member);
-        memory.tally(safeMemorySum(QUERY_REFERENCE_BYTES, queryValuePayloadBytes(member), "JSON_ARRAYAGG member"), "JSON_ARRAYAGG member");
+        const retained = (spec.orderBy?.length ?? 0) === 0
+            ? member
+            : JSON.stringify([
+                encodeSpillValue(member),
+                orderValues.map((orderValue) => encodeSpillValue(orderValue)),
+            ]);
+        list.push(retained);
+        memory.tally(safeMemorySum(QUERY_REFERENCE_BYTES, queryValuePayloadBytes(retained), "JSON_ARRAYAGG member"), "JSON_ARRAYAGG member");
         return;
     }
     if (spec.name === "STRING_AGG") {
@@ -3811,7 +3954,38 @@ function evaluateFinalExpression(plan, expression, group) {
     if (count === 0)
         return null;
     if (expression.name === "JSON_ARRAYAGG") {
-        return JSON.stringify((required(group.lists, "JSON aggregate list state is missing")[aggregateIndex] ?? []).map(jsonValueOf));
+        const retained = required(group.lists, "JSON aggregate list state is missing")[aggregateIndex] ?? [];
+        const orderBy = plan.aggregates[aggregateIndex]?.orderBy ?? [];
+        const members = retained.map((encoded) => {
+            if (orderBy.length === 0)
+                return { value: encoded, order: [] };
+            if (typeof encoded !== "string")
+                throw new Error("JSON_ARRAYAGG member is invalid");
+            const pair = JSON.parse(encoded);
+            if (!Array.isArray(pair) || pair.length !== 2 || !Array.isArray(pair[1])) {
+                throw new Error("JSON_ARRAYAGG member is invalid");
+            }
+            return {
+                value: decodeSpillValue(pair[0]),
+                order: pair[1].map(decodeSpillValue),
+            };
+        });
+        if (orderBy.length > 0) {
+            members.sort((left, right) => {
+                for (const [index, order] of orderBy.entries()) {
+                    const a = left.order[index];
+                    const b = right.order[index];
+                    const placed = nullOrder(a, b, order.nulls, order.direction);
+                    if (placed !== undefined && placed !== 0)
+                        return placed;
+                    const compared = compareValues(a, b);
+                    if (compared !== 0)
+                        return order.direction === "desc" ? -compared : compared;
+                }
+                return 0;
+            });
+        }
+        return preservedJsonDomainValue(jsonConstructor("JSON_ARRAY", members.map(({ value }) => value)));
     }
     if (expression.name === "STRING_AGG") {
         const members = required(group.lists, "STRING_AGG list state is missing")[aggregateIndex] ?? [];
@@ -3882,7 +4056,7 @@ function projectBatchRow(plan, batch, row) {
         }
         return result;
     }
-    const multiple = plan.sourceTables.length > 1;
+    const multiple = plan.sourceTables.filter((table) => [...table.columns.keys()].some((name) => !name.startsWith("\0"))).length > 1;
     for (let source = 0; source < plan.sourceTables.length; source += 1) {
         const table = required(plan.sourceTables[source], "Wildcard source table is missing");
         const rowIndex = batch.rowsBySource[source]?.[row] ?? -1;
@@ -3901,7 +4075,7 @@ function projectBatchRow(plan, batch, row) {
     return result;
 }
 function wildcardColumnNames(plan) {
-    const multiple = plan.sourceTables.length > 1;
+    const multiple = plan.sourceTables.filter((table) => [...table.columns.keys()].some((name) => !name.startsWith("\0"))).length > 1;
     return plan.sourceTables.flatMap((table, source) => [...table.columns.keys()]
         .filter((name) => !name.startsWith("\0"))
         .map((name) => (multiple ? `${plan.sourceAliases[source] ?? ""}.${name}` : name)));
@@ -4116,6 +4290,143 @@ function dictionaryLikeMatches(dictionary, pattern, caseInsensitive, escape) {
     }
     return matches;
 }
+const exactNumericDictionaryCache = new WeakMap();
+const dictionaryNumericCache = new WeakMap();
+function isExactNumericDictionary(dictionary) {
+    const cached = exactNumericDictionaryCache.get(dictionary);
+    if (cached !== undefined)
+        return cached;
+    const exact = dictionary.every((value) => isExactNumeric(value));
+    exactNumericDictionaryCache.set(dictionary, exact);
+    return exact;
+}
+function dictionaryNumericMatches(comparison, dictionary) {
+    // An ordinary TEXT dictionary must retain the generic evaluator, including its error and
+    // coercion behavior. Physical NUMERIC dictionaries contain only validated internal tags.
+    if (!isExactNumericDictionary(dictionary))
+        return undefined;
+    let comparisons = dictionaryNumericCache.get(dictionary);
+    if (comparisons === undefined) {
+        comparisons = new Map();
+        dictionaryNumericCache.set(dictionary, comparisons);
+    }
+    let matches = comparisons.get(comparison.signature);
+    if (matches === undefined) {
+        matches = new Uint8Array(dictionary.length);
+        for (let code = 0; code < dictionary.length; code += 1) {
+            matches[code] = comparisonValue(comparison.operator, comparison.expression.evaluate(dictionary[code] ?? ""), comparison.target)
+                ? 1
+                : 0;
+        }
+        // The dictionary owns this cache weakly. Bound the number of query shapes retained by one
+        // high-cardinality NUMERIC column, matching the dictionary LIKE cache above.
+        if (comparisons.size >= 32)
+            comparisons.clear();
+        comparisons.set(comparison.signature, matches);
+    }
+    return matches;
+}
+function constantBoundExpressionValue(expression) {
+    if (expression.kind === "literal")
+        return { value: expression.value };
+    if (expression.kind === "binary") {
+        const left = constantBoundExpressionValue(expression.left);
+        const right = constantBoundExpressionValue(expression.right);
+        if (left === undefined || right === undefined)
+            return undefined;
+        try {
+            return { value: binaryValue(expression.operator, left.value, right.value) };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // CAST is the only scalar wrapper needed by exact-NUMERIC arithmetic. Keeping the constant
+    // folder deliberately narrow avoids changing error timing for general scalar expressions.
+    if (expression.kind !== "call" || expression.name !== "CAST")
+        return undefined;
+    const values = [];
+    for (const argument of expression.arguments) {
+        const constant = constantBoundExpressionValue(argument);
+        if (constant === undefined)
+            return undefined;
+        values.push(constant.value);
+    }
+    try {
+        return { value: scalarFunctionValue(expression.name, values) };
+    }
+    catch {
+        return undefined;
+    }
+}
+function numericComparisonConstant(expression) {
+    const constant = constantBoundExpressionValue(expression)?.value;
+    if (typeof constant === "number" && Number.isFinite(constant))
+        return constant;
+    return isExactNumeric(constant) ? constant : undefined;
+}
+function dictionaryNumericExpression(expression) {
+    if (expression.kind === "column" && expression.vector.kind === "string") {
+        return {
+            source: expression.source,
+            vector: expression.vector,
+            signature: expression.signature,
+            evaluate: (value) => value,
+        };
+    }
+    if (expression.kind !== "binary")
+        return undefined;
+    const sides = [
+        { column: expression.left, constant: expression.right, columnFirst: true },
+        { column: expression.right, constant: expression.left, columnFirst: false },
+    ];
+    for (const { column, constant, columnFirst } of sides) {
+        if (column.kind !== "column" || column.vector.kind !== "string")
+            continue;
+        const value = numericComparisonConstant(constant);
+        if (value === undefined)
+            continue;
+        return {
+            source: column.source,
+            vector: column.vector,
+            signature: expression.signature,
+            evaluate: columnFirst
+                ? (dictionaryValue) => binaryValue(expression.operator, dictionaryValue, value)
+                : (dictionaryValue) => binaryValue(expression.operator, value, dictionaryValue),
+        };
+    }
+    return undefined;
+}
+/** Detects exact-NUMERIC dictionary arithmetic compared with a constant. */
+function detectDictionaryNumericComparison(predicate) {
+    if (!primitiveOperators.has(predicate.operator))
+        return undefined;
+    const comparison = predicate.operator;
+    const sides = [
+        { expression: predicate.left, target: predicate.right, operator: comparison },
+        {
+            expression: predicate.right,
+            target: predicate.left,
+            operator: reverseComparisonOperator(comparison),
+        },
+    ];
+    for (const { expression, target, operator } of sides) {
+        const numeric = dictionaryNumericExpression(expression);
+        if (numeric === undefined)
+            continue;
+        const value = numericComparisonConstant(target);
+        if (value === undefined)
+            continue;
+        return {
+            expression: numeric,
+            operator,
+            target: value,
+            signature: `${numeric.signature}\u0001${operator}\u0001${target.signature}`,
+            cache: { dictionary: undefined, matches: new Uint8Array(0) },
+        };
+    }
+    return undefined;
+}
 function stringCodeAt(vector, rowIndex) {
     if (rowIndex < 0 || rowIndex >= vector.length)
         return undefined;
@@ -4299,6 +4610,21 @@ function evaluateBatchPredicate(plan, predicate, batch, row) {
         const matched = like.cache.matches[code] === 1;
         return like.negated ? !matched : matched;
     }
+    const dictionaryNumeric = predicate.dictionaryNumeric;
+    if (dictionaryNumeric !== undefined) {
+        const vector = dictionaryNumeric.expression.vector;
+        if (dictionaryNumeric.cache.dictionary !== vector.dictionary) {
+            const matches = dictionaryNumericMatches(dictionaryNumeric, vector.dictionary);
+            if (matches !== undefined) {
+                dictionaryNumeric.cache.dictionary = vector.dictionary;
+                dictionaryNumeric.cache.matches = matches;
+            }
+        }
+        if (dictionaryNumeric.cache.dictionary === vector.dictionary) {
+            const code = stringCodeAt(vector, batch.rowsBySource[dictionaryNumeric.expression.source]?.[row] ?? -1);
+            return code !== undefined && dictionaryNumeric.cache.matches[code] === 1;
+        }
+    }
     if (predicate.operator === "IS TRUE" ||
         predicate.operator === "LIKE" ||
         predicate.operator === "NOT LIKE" ||