@minnowdb/core 0.6.8 → 0.7.0

package/dist/engine/vector.js

@@ -2,14 +2,14 @@ import { dateMilliseconds } from "../date-value.js";
 import { crossJoinPlan, isCrossJoinPlan } from "../plan/model.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 { cachedListMembership, childExpressions, distinctFromComparison, nullOrder, isScalarFunctionName, likeMatches, orderOutputName, parseQuantified, quantifiedComparison, scalarFunctionEvaluator, scalarFunctionValue, unknownColumnDomains, } from "./query.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 { coerceComparisonOperands, compareSqlValues, compileSimilarPattern, defineSqlResultProperty, } from "./sql-semantics.js";
 import { concatenatedSqlValue, exactNumericBinary, externalSqlDomainValue, isDateDomainValue, isExactNumeric, preservedJsonDomainValue, protectedSqlTextValue, } from "./sql-domains.js";
 import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
 const DEFAULT_BATCH_ROWS = 2_048;
@@ -97,6 +97,8 @@ async function writeSpillRowPages(store, ownerId, runId, startPageIndex, columns
     await writeSpillPages(store, pending, signal);
     return pageCount;
 }
+/** Distinct raw values a packed number key column may carry before the generic index takes over. */
+const NUMBER_KEY_CODE_CAP = 1 << 20;
 export function createColumnarTable(name, columns, uniqueKey) {
     const first = columns.values().next().value;
     const rowCount = first?.values.length ?? 0;
@@ -585,7 +587,10 @@ function bindPlan(plan, tables, memory, ftsStats) {
         if (primitive !== undefined)
             return { ...bound, primitive };
         const primitiveIn = detectPrimitiveInList(bound);
-        return primitiveIn === undefined ? bound : { ...bound, primitiveIn };
+        if (primitiveIn !== undefined)
+            return { ...bound, primitiveIn };
+        const dictionaryPredicate = detectDictionaryPredicate(bound);
+        return dictionaryPredicate === undefined ? bound : { ...bound, dictionaryPredicate };
     };
     const predicates = plan.predicates.map((predicate) => {
         const bound = bindPredicate(predicate);
@@ -593,7 +598,8 @@ function bindPlan(plan, tables, memory, ftsStats) {
             return bound;
         if (bound.dictionaryEquality !== undefined ||
             bound.dictionaryLike !== undefined ||
-            bound.dictionaryNumeric !== undefined) {
+            bound.dictionaryNumeric !== undefined ||
+            bound.dictionaryPredicate !== undefined) {
             return bound;
         }
         const branches = disjunctiveNormalForm(predicate);
@@ -663,7 +669,10 @@ function bindPlan(plan, tables, memory, ftsStats) {
     // vectors swap dictionaries per window; the accumulator remaps its slot table by value on
     // each swap, so windowed vectors qualify too.
     const groupColumn = groupBy.length === 1 ? groupBy[0] : undefined;
-    const codeGrouping = grouped && groupColumn?.kind === "column" && groupColumn.vector.kind === "string"
+    const codeGrouping = !grouped || groupColumn === undefined ? undefined : codeGroupingFor(groupColumn);
+    const numberGrouping = grouped &&
+        groupColumn?.kind === "column" &&
+        (groupColumn.vector.kind === "number" || groupColumn.vector.kind === "datetime")
         ? { source: groupColumn.source, vector: groupColumn.vector }
         : undefined;
     return {
@@ -682,11 +691,82 @@ function bindPlan(plan, tables, memory, ftsStats) {
         grouped,
         sourceOrdered,
         ...(codeGrouping === undefined ? {} : { codeGrouping }),
+        ...(numberGrouping === undefined ? {} : { numberGrouping }),
         wildcard: plan.select[0]?.expression.kind === "wildcard",
         ...(plan.limit === undefined ? {} : { limit: plan.limit }),
         ...(plan.offset === undefined ? {} : { offset: plan.offset }),
     };
 }
+/**
+ * A single GROUP BY key groups by dictionary code when it is a bare string column, or any
+ * expression whose only column is one string column: the value is then a function of the code.
+ */
+function codeGroupingFor(key) {
+    if (key.kind === "column") {
+        return key.vector.kind === "string" ? { source: key.source, vector: key.vector } : undefined;
+    }
+    const column = singleStringColumn(key);
+    return column === undefined ? undefined : { ...column, expression: key };
+}
+/**
+ * A CASE the batch aggregate kernel can decide per dictionary code: every WHEN reads exactly one
+ * string column (the same one), and every THEN/ELSE is a bare number column or a numeric literal.
+ */
+function conditionalAggregate(argument) {
+    if (argument.kind !== "case" || argument.branches.length === 0)
+        return undefined;
+    const whens = argument.branches.map((branch) => branch.when);
+    const first = whens[0];
+    if (first === undefined)
+        return undefined;
+    const conjunction = whens
+        .slice(1)
+        .reduce((left, right) => ({ kind: "logical", operator: "and", left, right, signature: "" }), first);
+    const column = singleStringColumn(conjunction);
+    if (column === undefined)
+        return undefined;
+    const branchValue = (expression) => {
+        if (expression === undefined)
+            return { kind: "literal", value: null };
+        if (expression.kind === "column" && expression.vector.kind === "number") {
+            return { kind: "column", source: expression.source, vector: expression.vector };
+        }
+        if (expression.kind === "literal" &&
+            (expression.value === null || typeof expression.value === "number")) {
+            return { kind: "literal", value: expression.value };
+        }
+        return undefined;
+    };
+    const branches = [];
+    for (const branch of argument.branches) {
+        const value = branchValue(branch.then);
+        if (value === undefined)
+            return undefined;
+        branches.push({ when: branch.when, value });
+    }
+    const otherwise = branchValue(argument.otherwise);
+    if (otherwise === undefined)
+        return undefined;
+    return {
+        ...column,
+        branches,
+        otherwise,
+        cache: { dictionary: undefined, branch: new Int32Array(0) },
+    };
+}
+/** The one string column an expression reads, when it reads exactly one column and no FTS. */
+function singleStringColumn(expression) {
+    if (boundContainsFts(expression))
+        return undefined;
+    const columns = boundColumnNodes(expression);
+    const first = columns[0];
+    if (first?.vector.kind !== "string")
+        return undefined;
+    if (columns.some((column) => column.source !== first.source || column.column !== first.column)) {
+        return undefined;
+    }
+    return { source: first.source, vector: first.vector };
+}
 function bindExpression(expression, sources, aggregateSpecs, aggregateIndexes, memory, ftsBySignature, ftsStats) {
     const signature = JSON.stringify(expression);
     if (expression.kind === "subquery") {
@@ -850,9 +930,14 @@ function bindExpression(expression, sources, aggregateSpecs, aggregateIndexes, m
             argument.vector.kind === "number"
             ? { source: argument.source, vector: argument.vector }
             : undefined;
+        const conditional = (expression.name === "COUNT" || expression.name === "SUM" || expression.name === "AVG") &&
+            expression.distinct !== true
+            ? conditionalAggregate(argument)
+            : undefined;
         aggregateSpecs.push({
             name: expression.name,
             argument,
+            ...(conditional === undefined ? {} : { conditional }),
             ...(expression.name === "STRING_AGG"
                 ? { delimiter: required(arguments_[1], "STRING_AGG delimiter is missing") }
                 : {}),
@@ -1225,7 +1310,10 @@ async function executeBoundPlanAsync(plan, memory, options) {
     const groups = new GroupAccumulator(plan, memory);
     const output = new ResultSink(plan, memory, options.loadScanWindow === undefined);
     const scanRows = plan.sourceTables[plan.scanSource]?.rowCount ?? 0;
-    for (let start = 0; start < scanRows;) {
+    if (options.scanRows !== undefined && options.loadScanWindow !== undefined) {
+        await scanSelectedRows(plan, options.scanRows, groups, output, memory, options);
+    }
+    for (let start = 0; start < scanRows && options.scanRows === undefined;) {
         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,
@@ -1272,6 +1360,49 @@ async function executeBoundPlanAsync(plan, memory, options) {
     const rows = plan.grouped ? finishGroups(plan, groups.values(), memory) : output.finish();
     return finishResult(plan, rows, memory);
 }
+/** Selected rows closer than this run in one batch; the predicates discard the rows between. */
+const SELECTED_ROW_COALESCE_GAP = 32;
+/**
+ * Visits only the rows of an index-provided selection. Rows are ascending, so each streamed
+ * window is loaded once; neighbouring selected rows inside a window run as one contiguous
+ * batch, so a clustered hit costs one batch and a scattered one costs a batch per row, never
+ * a batch per unselected row in between.
+ */
+async function scanSelectedRows(plan, selection, groups, output, memory, options) {
+    const scanRows = plan.sourceTables[plan.scanSource]?.rowCount ?? 0;
+    let index = 0;
+    while (index < selection.length) {
+        throwIfAborted(options.signal);
+        const first = selection[index] ?? 0;
+        if (first >= scanRows)
+            break;
+        const loaded = options.loadScanWindow?.(first, 1);
+        const residentEnd = typeof loaded === "number" || loaded === undefined ? loaded : await loaded;
+        throwIfAborted(options.signal);
+        const windowEnd = typeof residentEnd === "number" && residentEnd > first
+            ? Math.min(residentEnd, scanRows)
+            : first + 1;
+        while (index < selection.length) {
+            const begin = selection[index] ?? 0;
+            if (begin >= windowEnd)
+                break;
+            let end = begin + 1;
+            index += 1;
+            while (index < selection.length) {
+                const next = selection[index] ?? 0;
+                if (next >= windowEnd ||
+                    next - end > SELECTED_ROW_COALESCE_GAP ||
+                    next >= begin + DEFAULT_BATCH_ROWS) {
+                    break;
+                }
+                end = next + 1;
+                index += 1;
+            }
+            if (runScanBatch(plan, begin, end - begin, groups, output, memory))
+                return;
+        }
+    }
+}
 /**
  * Pull-driven scan execution for cursor-safe plans. A result page owns a child memory context
  * that closes after the consumer settles, so both modeled memory and live row objects are
@@ -1307,6 +1438,7 @@ async function executeBoundPlanBatches(plan, memory, options, consume) {
                         return values.length;
                     },
                     tryAddBatch: () => false,
+                    tryAddSelection: () => false,
                     add: (batch, row) => {
                         values.push(asQueryValue(evaluateBatchExpression(scanPlan, firstExpression, batch, row)));
                     },
@@ -2391,8 +2523,91 @@ function applyPredicateKernel(plan, predicate, batch, selection, survivors) {
     if (predicate.disjunction !== undefined) {
         return filterDisjunction(plan, predicate.disjunction, batch, selection, survivors);
     }
+    if (predicate.dictionaryPredicate !== undefined) {
+        return filterDictionaryPredicate(plan, predicate, predicate.dictionaryPredicate, batch, selection, survivors);
+    }
     return undefined;
 }
+/**
+ * Filters by a predicate that depends on one dictionary column only. The truth for a code is
+ * learned the first time a row carrying that code appears, by running the ordinary per-row
+ * evaluator on that row — so LOWER(status) = 'paid', a CASE over region, or STARTS_WITH on a
+ * category cost one generic evaluation per distinct value per dictionary, then one code read
+ * per row. A NULL code is never a match, exactly as the generic path treats an unknown result.
+ */
+function filterDictionaryPredicate(plan, predicate, fast, batch, selection, survivors) {
+    const vector = fast.vector;
+    if (fast.cache.dictionary !== vector.dictionary) {
+        fast.cache.dictionary = vector.dictionary;
+        fast.cache.truth = new Uint8Array(vector.dictionary.length + 1);
+    }
+    const truth = fast.cache.truth;
+    const nullSlot = vector.dictionary.length;
+    const rows = batch.rowsBySource[fast.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;
+        let code = nullSlot;
+        if (sourceRow >= 0 && sourceRow < vectorLength) {
+            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) {
+                const raw = codes[slot] ?? NULL_STRING_CODE;
+                if (raw !== NULL_STRING_CODE)
+                    code = raw;
+            }
+        }
+        let known = truth[code] ?? 0;
+        if (known === 0) {
+            known = evaluateBatchPredicate(plan, predicate, batch, row) ? 1 : 2;
+            truth[code] = known;
+        }
+        if (known !== 1)
+            continue;
+        selection[kept] = row;
+        kept += 1;
+    }
+    return kept;
+}
+/** Slots one packed key column occupies: dictionary size plus NULL, or the number-code cap. */
+function multiCodeSpan(column) {
+    return column.codes === undefined ? column.vector.dictionary.length + 1 : NUMBER_KEY_CODE_CAP;
+}
+/** Every column node under a bound expression. */
+function boundColumnNodes(expression, into = []) {
+    if (expression.kind === "column")
+        into.push(expression);
+    else if (expression.kind !== "fts") {
+        for (const child of boundChildren(expression))
+            boundColumnNodes(child, into);
+    }
+    return into;
+}
+function boundContainsFts(expression) {
+    if (expression.kind === "fts")
+        return true;
+    return boundChildren(expression).some(boundContainsFts);
+}
+function detectDictionaryPredicate(predicate) {
+    const column = singleStringColumn({
+        kind: "logical",
+        operator: "and",
+        left: predicate.left,
+        right: predicate.right,
+        signature: "",
+    });
+    return column === undefined
+        ? undefined
+        : { ...column, cache: { dictionary: undefined, truth: new Uint8Array(0) } };
+}
 // Scratch for the disjunction kernel. Branch predicates are always plain conditions, so a
 // branch never carries a disjunction of its own and these buffers are never reentered.
 let disjunctionCandidates = new Uint32Array(DEFAULT_BATCH_ROWS);
@@ -2938,6 +3153,12 @@ class ResultSink {
      * Returns false when the sink shape needs the per-row path.
      */
     tryAddBatch(batch) {
+        return this.#tryAddRows(batch, undefined, batch.length);
+    }
+    tryAddSelection(batch, selection, survivors) {
+        return this.#tryAddRows(batch, selection, survivors);
+    }
+    #tryAddRows(batch, selection, count) {
         const fast = this.#fastFirstKey;
         if (this.#capacity === undefined || fast === undefined)
             return false;
@@ -2950,7 +3171,19 @@ class ResultSink {
         const windowStart = window?.start ?? 0;
         const windowLength = window?.length ?? vector.length;
         const desc = fast.desc;
-        for (let row = 0; row < batch.length; row += 1) {
+        // A key that arrives sorted against the requested direction — `ORDER BY id DESC` over a
+        // table stored in key order, the newest-first page — would otherwise improve on the cut
+        // line on every row and rebuild the selection 200,000 times. Walking such a batch from
+        // its last row establishes the cut line within `capacity` rows and rejects the rest on the
+        // float comparison. Row order within a batch never affects the answer: ties keep the
+        // earlier `seq`, and seq numbers are assigned in scan order below either way.
+        const reversed = desc && this.#batchKeyIsAscending(rows, vector, selection, count);
+        const firstSeq = this.#seq;
+        for (let step = 0; step < count; step += 1) {
+            const position = reversed ? count - 1 - step : step;
+            const row = selection === undefined ? position : (selection[position] ?? 0);
+            if (reversed)
+                this.#seq = firstSeq + position;
             const threshold = this.#thresholdFirst;
             if (threshold === undefined || threshold === null) {
                 this.#addCandidate(batch, row);
@@ -2969,6 +3202,31 @@ class ResultSink {
             }
             this.#addCandidate(batch, row);
         }
+        if (reversed)
+            this.#seq = firstSeq + count;
+        return true;
+    }
+    /**
+     * Whether the rows to add read the first order key in ascending order, checked directly on
+     * the resident values: one unboxed pass, cheaper than a single candidate insertion.
+     */
+    #batchKeyIsAscending(rows, vector, selection, count) {
+        if (rows === undefined || count < 2)
+            return false;
+        const windowStart = vector.window?.start ?? 0;
+        const values = vector.values;
+        const validity = vector.validity;
+        let previous = Number.NEGATIVE_INFINITY;
+        for (let position = 0; position < count; position += 1) {
+            const row = selection === undefined ? position : (selection[position] ?? 0);
+            const slot = (rows[row] ?? -1) - windowStart;
+            if (slot < 0 || slot >= values.length || !isValid(validity, slot))
+                return false;
+            const value = values[slot] ?? 0;
+            if (!(value >= previous))
+                return false;
+            previous = value;
+        }
         return true;
     }
     add(batch, row) {
@@ -3198,7 +3456,13 @@ class GroupAccumulator {
     #codeColumns;
     #multiCodeColumns;
     #multiCodeStates;
+    /** The dictionaries the packed slot table was laid out for; any swap re-lays it. */
+    #multiCodeDictionaries = [];
+    #multiCodeSlotsReserved = 0;
     #multiCodeScratch = [];
+    /** Raw-number grouping: state per finite value, plus the NULL group. */
+    #numberStates;
+    #numberNullState;
     #keyScratch = [];
     // The miss factories live on the accumulator and read the pending row through these fields, so
     // the per-row lookup never allocates a capturing closure; execution is synchronous, so the
@@ -3229,42 +3493,93 @@ class GroupAccumulator {
         // are stable and value-unique within one execution, so the key encodes a fixed-width number
         // instead of re-encoding the string's UTF-8 on every row. Types are stable per position, so
         // a code can never collide with a genuine number from the same expression.
-        this.#codeColumns =
-            plan.groupBy.length > 1
-                ? plan.groupBy.map((expression) => expression.kind === "column" &&
-                    expression.vector.kind === "string" &&
-                    expression.vector.window === undefined
-                    ? { source: expression.source, vector: expression.vector }
-                    : undefined)
-                : [];
-        // When every compound key column is dictionary-coded and the combined code space is small,
-        // group lookup packs codes into one exact integer. Small domains use a direct array; large,
-        // sparse domains use a numeric Map instead of byte-encoding and hashing each compound key.
-        // Each column contributes (dictionary size + 1) slots, the extra one for NULL.
-        if (this.#codeColumns.length > 1 && this.#codeColumns.every((column) => column !== undefined)) {
-            const columns = this.#codeColumns;
-            let slots = 1;
-            for (const column of columns)
-                slots *= column.vector.dictionary.length + 1;
-            if (Number.isSafeInteger(slots) && slots <= MULTI_CODE_GROUP_SLOT_CAP) {
+        const codeColumns = plan.groupBy.length > 1
+            ? plan.groupBy.map((expression) => expression.kind === "column" && expression.vector.kind === "string"
+                ? { source: expression.source, vector: expression.vector }
+                : undefined)
+            : [];
+        // When every compound key column is a bare string, number, or datetime column, group lookup
+        // packs one code per column into one integer slot and byte-encodes a key only on the first
+        // row of each combination per window. The slot table is laid out lazily by
+        // #ensureMultiCodeStates, which re-lays it whenever a streamed window swaps a dictionary;
+        // the group states themselves live in the value-keyed index, so a combination seen in two
+        // windows is one group.
+        const packed = plan.groupBy.length > 1
+            ? plan.groupBy.map((expression) => {
+                if (expression.kind !== "column")
+                    return undefined;
+                if (expression.vector.kind === "string") {
+                    return { source: expression.source, vector: expression.vector };
+                }
+                if (expression.vector.kind === "number" || expression.vector.kind === "datetime") {
+                    return {
+                        source: expression.source,
+                        vector: expression.vector,
+                        codes: new Map(),
+                    };
+                }
+                return undefined;
+            })
+            : [];
+        if (packed.length > 1 && packed.every((column) => column !== undefined)) {
+            this.#multiCodeColumns = packed;
+            this.#codeColumns = [];
+            return;
+        }
+        // Otherwise the compound key substitutes the dictionary code for each bare unwindowed string
+        // column: codes are stable and value-unique within one execution, so the key encodes a
+        // fixed-width number instead of re-encoding the string's UTF-8 on every row. Types are
+        // stable per position, so a code can never collide with a genuine number from the same
+        // expression.
+        this.#codeColumns = codeColumns.map((column) => column?.vector.window === undefined ? column : undefined);
+        if (plan.numberGrouping !== undefined)
+            this.#numberStates = new Map();
+    }
+    /**
+     * Lays out the packed slot table for the current window dictionaries. Small combined domains
+     * use a direct array (reserved against the budget); large ones a numeric Map. Returns false
+     * when the budget refuses the array, which sends the query to the generic per-row index.
+     */
+    #ensureMultiCodeStates(columns) {
+        let current = true;
+        for (let index = 0; index < columns.length; index += 1) {
+            const column = columns[index];
+            if (column?.codes !== undefined)
+                continue;
+            if (this.#multiCodeDictionaries[index] !== column?.vector.dictionary) {
+                current = false;
+                break;
+            }
+        }
+        if (current && (this.#codeStates !== undefined || this.#multiCodeStates !== undefined)) {
+            return true;
+        }
+        let slots = 1;
+        for (const column of columns)
+            slots *= multiCodeSpan(column);
+        if (!Number.isSafeInteger(slots))
+            return false;
+        if (slots <= MULTI_CODE_GROUP_SLOT_CAP) {
+            if (slots > this.#multiCodeSlotsReserved) {
                 try {
-                    memory.reserve(safeMemoryProduct(slots, QUERY_REFERENCE_BYTES, "Group code slots"), "Group code slots");
+                    this.#memory.reserve(safeMemoryProduct(slots - this.#multiCodeSlotsReserved, QUERY_REFERENCE_BYTES, "Group code slots"), "Group code slots");
                 }
                 catch (error) {
                     if (!(error instanceof QueryMemoryBudgetError))
                         throw error;
-                    return;
+                    return false;
                 }
-                this.#multiCodeColumns = columns;
-                this.#codeStates = new Array(slots).fill(undefined);
-                this.#ordered = [];
-            }
-            else if (Number.isSafeInteger(slots)) {
-                this.#multiCodeColumns = columns;
-                this.#multiCodeStates = new Map();
-                this.#ordered = [];
+                this.#multiCodeSlotsReserved = slots;
             }
+            this.#codeStates = new Array(slots).fill(undefined);
+            this.#multiCodeStates = undefined;
         }
+        else {
+            this.#codeStates = undefined;
+            this.#multiCodeStates = new Map();
+        }
+        this.#multiCodeDictionaries = columns.map((column) => column.codes === undefined ? column.vector.dictionary : undefined);
+        return true;
     }
     /**
      * Fast aggregate specs for the batch kernel: every aggregate is COUNT(*) or a bare numeric
@@ -3286,6 +3601,10 @@ class GroupAccumulator {
                 specs.push({ kind: "column", sums: spec.name !== "COUNT" });
                 continue;
             }
+            if (spec.conditional !== undefined) {
+                specs.push({ kind: "conditional", sums: spec.name !== "COUNT" });
+                continue;
+            }
             return undefined;
         }
         return specs;
@@ -3299,7 +3618,10 @@ class GroupAccumulator {
         const plan = this.#plan;
         const codeGrouping = plan.codeGrouping;
         const globalGroup = plan.groupBy.length === 0;
-        if (!globalGroup && (codeGrouping === undefined || this.#codeStates === undefined)) {
+        const numberGrouped = plan.numberGrouping !== undefined && this.#numberStates !== undefined;
+        if (!globalGroup &&
+            !numberGrouped &&
+            (codeGrouping === undefined || this.#codeStates === undefined)) {
             return false;
         }
         const specs = this.#fastAggregatesCache;
@@ -3324,6 +3646,10 @@ class GroupAccumulator {
             : undefined;
         // Hoisted per-column reads: the row loop touches only local typed arrays and numbers.
         const columns = [];
+        // Conditional aggregates: the branch for a dictionary code is learned from the first row
+        // carrying it (the generic truth evaluator on that row), then every later row with the code
+        // reads its branch's number column or literal directly.
+        const conditionals = [];
         let stars = 0;
         for (let index = 0; index < specs.length; index += 1) {
             const spec = specs[index];
@@ -3331,6 +3657,26 @@ class GroupAccumulator {
                 stars += 1;
                 continue;
             }
+            if (spec.kind === "conditional") {
+                const conditional = plan.aggregates[index]?.conditional;
+                if (conditional === undefined)
+                    return false;
+                const vector = conditional.vector;
+                if (conditional.cache.dictionary !== vector.dictionary) {
+                    conditional.cache.dictionary = vector.dictionary;
+                    conditional.cache.branch = new Int32Array(vector.dictionary.length + 1).fill(-2);
+                }
+                conditionals.push({
+                    index,
+                    sums: spec.sums,
+                    spec: conditional,
+                    rows: batch.rowsBySource[conditional.source],
+                    branch: conditional.cache.branch,
+                    nullSlot: vector.dictionary.length,
+                    truths: conditional.branches.map((branch) => compiledTruth(plan, branch.when)),
+                });
+                continue;
+            }
             const raw = plan.aggregates[index]?.rawNumber;
             if (raw === undefined)
                 return false;
@@ -3371,14 +3717,10 @@ class GroupAccumulator {
                             code = rawCode;
                     }
                 }
-                state = states[code];
-                if (state === undefined) {
-                    const value = code === nullCode ? null : (grouping.dictionary[code] ?? null);
-                    state = createGroupState([value], plan, this.#memory);
-                    states[code] = state;
-                    this.#registerCodeState(value, state);
-                    this.#ordered?.push(state);
-                }
+                state = states[code] ?? this.#createCodeState(batch, row, code, grouping.dictionary);
+            }
+            else if (state === undefined && numberGrouped) {
+                state = this.stateFor(batch, row);
             }
             if (state === undefined)
                 return false;
@@ -3404,6 +3746,36 @@ class GroupAccumulator {
                     state.sums[column.index] = (state.sums[column.index] ?? 0) + (column.values[slot] ?? 0);
                 }
             }
+            for (const conditional of conditionals) {
+                const code = stringCodeAt(conditional.spec.vector, conditional.rows?.[row] ?? -1) ??
+                    conditional.nullSlot;
+                let chosen = conditional.branch[code] ?? -2;
+                if (chosen === -2) {
+                    chosen = -1;
+                    for (let index = 0; index < conditional.truths.length; index += 1) {
+                        if (conditional.truths[index]?.(batch, row) === true) {
+                            chosen = index;
+                            break;
+                        }
+                    }
+                    conditional.branch[code] = chosen;
+                }
+                const branchValue = chosen < 0 ? conditional.spec.otherwise : conditional.spec.branches[chosen]?.value;
+                if (branchValue === undefined)
+                    return false;
+                let value;
+                if (branchValue.kind === "literal")
+                    value = branchValue.value;
+                else {
+                    value = rawFloat64Value(branchValue.vector, batch.rowsBySource[branchValue.source]?.[row] ?? -1);
+                }
+                if (value === null)
+                    continue;
+                counts[conditional.index] = (counts[conditional.index] ?? 0) + 1;
+                if (conditional.sums) {
+                    state.sums[conditional.index] = (state.sums[conditional.index] ?? 0) + value;
+                }
+            }
         }
         return true;
     }
@@ -3425,12 +3797,14 @@ class GroupAccumulator {
             this.#codeSlotsReserved = slots;
         }
         const next = new Array(slots).fill(undefined);
-        for (let code = 0; code < dictionary.length; code += 1) {
-            const state = this.#codeStateByValue.get(dictionary[code] ?? "");
-            if (state !== undefined)
-                next[code] = state;
+        if (this.#plan.codeGrouping?.expression === undefined) {
+            for (let code = 0; code < dictionary.length; code += 1) {
+                const state = this.#codeStateByValue.get(dictionary[code] ?? "");
+                if (state !== undefined)
+                    next[code] = state;
+            }
+            next[dictionary.length] = this.#nullCodeState;
         }
-        next[dictionary.length] = this.#nullCodeState;
         this.#codeStates = next;
         this.#codeDictionary = dictionary;
     }
@@ -3441,6 +3815,33 @@ class GroupAccumulator {
         else
             this.#codeStateByValue.set(value, state);
     }
+    /**
+     * Fills the slot for a dictionary code seen for the first time. A bare column's slot is a new
+     * state keyed by the dictionary value; an expression key evaluates the expression on this row
+     * (the representative of its code) and shares the state of any earlier code that produced the
+     * same value, so UPPER('a') and UPPER('A') land in one group.
+     */
+    #createCodeState(batch, row, code, dictionary) {
+        const states = required(this.#codeStates, "Group code slots are missing");
+        const expression = this.#plan.codeGrouping?.expression;
+        let state;
+        if (expression === undefined) {
+            const value = code === dictionary.length ? null : (dictionary[code] ?? null);
+            state = createGroupState([value], this.#plan, this.#memory);
+            this.#registerCodeState(value, state);
+            this.#ordered?.push(state);
+        }
+        else {
+            const value = asQueryValue(evaluateBatchExpression(this.#plan, expression, batch, row));
+            this.#pendingSingleValue = value;
+            const before = this.#index.size;
+            state = this.#index.getOrInsertOne(groupKey(value), this.#createPendingSingle);
+            if (this.#index.size !== before)
+                this.#ordered?.push(state);
+        }
+        states[code] = state;
+        return state;
+    }
     /** Resolves the group state for one row, creating it on first touch. */
     stateFor(batch, row) {
         const plan = this.#plan;
@@ -3463,55 +3864,115 @@ class GroupAccumulator {
                         code = rawCode;
                 }
             }
-            let state = states[code];
-            if (state === undefined) {
-                const value = code === vector.dictionary.length ? null : (vector.dictionary[code] ?? null);
-                state = createGroupState([value], plan, this.#memory);
-                states[code] = state;
-                this.#registerCodeState(value, state);
-                this.#ordered?.push(state);
-            }
-            return state;
+            return states[code] ?? this.#createCodeState(batch, row, code, vector.dictionary);
         }
         if (plan.groupBy.length === 0) {
             return required(this.#index.getEmpty(), "Grouped query state is missing");
         }
         const multiCode = this.#multiCodeColumns;
-        if (multiCode !== undefined &&
-            (this.#codeStates !== undefined || this.#multiCodeStates !== undefined)) {
+        if (multiCode !== undefined) {
+            if (!this.#ensureMultiCodeStates(multiCode)) {
+                this.#multiCodeColumns = undefined;
+                this.#codeStates = undefined;
+                this.#multiCodeStates = undefined;
+                return this.stateFor(batch, row);
+            }
             let slot = 0;
             for (let index = 0; index < multiCode.length; index += 1) {
                 const column = required(multiCode[index], "Group code column is missing");
-                const vector = column.vector;
                 const sourceRow = batch.rowsBySource[column.source]?.[row] ?? -1;
-                let code = vector.dictionary.length;
-                if (sourceRow >= 0 && sourceRow < vector.length && isValid(vector.validity, sourceRow)) {
-                    const rawCode = vector.codes[sourceRow] ?? NULL_STRING_CODE;
-                    if (rawCode !== NULL_STRING_CODE)
-                        code = rawCode;
+                let code;
+                if (column.codes === undefined) {
+                    code = stringCodeAt(column.vector, sourceRow) ?? column.vector.dictionary.length;
+                }
+                else {
+                    // Code 0 is NULL and every other finite value gets the next dense code; a key column
+                    // with too many distinct values, or a non-finite one, hands the query to the index.
+                    const raw = rawFloat64Value(column.vector, sourceRow);
+                    if (raw === null)
+                        code = 0;
+                    else if (!Number.isFinite(raw))
+                        code = -1;
+                    else {
+                        const known = column.codes.get(raw);
+                        if (known !== undefined)
+                            code = known;
+                        else if (column.codes.size + 1 >= NUMBER_KEY_CODE_CAP)
+                            code = -1;
+                        else {
+                            code = column.codes.size + 1;
+                            this.#memory.tally(PACKED_GROUP_ENTRY_BYTES, "Packed group key code");
+                            column.codes.set(raw, code);
+                        }
+                    }
+                    if (code < 0) {
+                        this.#multiCodeColumns = undefined;
+                        this.#codeStates = undefined;
+                        this.#multiCodeStates = undefined;
+                        return this.stateFor(batch, row);
+                    }
                 }
                 this.#multiCodeScratch[index] = code;
-                slot = slot * (vector.dictionary.length + 1) + code;
+                slot = slot * multiCodeSpan(column) + code;
             }
             let state = this.#codeStates?.[slot] ?? this.#multiCodeStates?.get(slot);
             if (state === undefined) {
-                const groupValues = [];
                 for (let index = 0; index < multiCode.length; index += 1) {
-                    const vector = required(multiCode[index], "Group code column is missing").vector;
-                    const code = this.#multiCodeScratch[index] ?? vector.dictionary.length;
-                    groupValues.push(code === vector.dictionary.length ? null : (vector.dictionary[code] ?? null));
+                    const column = required(multiCode[index], "Group code column is missing");
+                    const code = this.#multiCodeScratch[index] ?? 0;
+                    if (column.codes === undefined) {
+                        const vector = column.vector;
+                        this.#keyScratch[index] =
+                            code === vector.dictionary.length ? null : (vector.dictionary[code] ?? null);
+                    }
+                    else {
+                        const raw = rawFloat64Value(column.vector, batch.rowsBySource[column.source]?.[row] ?? -1);
+                        this.#keyScratch[index] =
+                            raw === null
+                                ? null
+                                : groupKey(column.vector.kind === "datetime" ? new Date(raw) : raw);
+                    }
                 }
-                state = createGroupState(groupValues, plan, this.#memory);
+                this.#keyScratch.length = multiCode.length;
+                this.#pendingBatch = batch;
+                this.#pendingRow = row;
+                state = this.#index.getOrInsert(this.#keyScratch, this.#createPendingCompound);
                 if (this.#codeStates !== undefined)
                     this.#codeStates[slot] = state;
                 else {
                     this.#memory.tally(PACKED_GROUP_ENTRY_BYTES, "Packed group index entry");
                     this.#multiCodeStates?.set(slot, state);
                 }
-                this.#ordered?.push(state);
             }
             return state;
         }
+        const numberGrouping = plan.numberGrouping;
+        const numberStates = this.#numberStates;
+        if (numberGrouping !== undefined && numberStates !== undefined) {
+            const raw = rawFloat64Value(numberGrouping.vector, batch.rowsBySource[numberGrouping.source]?.[row] ?? -1);
+            if (raw === null) {
+                let state = this.#numberNullState;
+                if (state === undefined) {
+                    this.#pendingSingleValue = null;
+                    state = this.#index.getOrInsertOne(null, this.#createPendingSingle);
+                    this.#numberNullState = state;
+                }
+                return state;
+            }
+            // Non-finite values keep the generic key rules (they share the NULL key), so only finite
+            // values are cached by raw value.
+            if (Number.isFinite(raw)) {
+                let state = numberStates.get(raw);
+                if (state === undefined) {
+                    const value = numberGrouping.vector.kind === "datetime" ? new Date(raw) : raw;
+                    this.#pendingSingleValue = value;
+                    state = this.#index.getOrInsertOne(groupKey(value), this.#createPendingSingle);
+                    this.#memory.tally(PACKED_GROUP_ENTRY_BYTES, "Packed group index entry");
+                    numberStates.set(raw, state);
+                }
+                return state;
+            }
+        }
         if (plan.groupBy.length === 1) {
             const groupValue = asQueryValue(evaluateBatchExpression(plan, required(plan.groupBy[0], "Group expression is missing"), batch, row));
             this.#pendingSingleValue = groupValue;
@@ -3567,6 +4028,8 @@ function consumeBatch(plan, batch, groups, output, memory, prefiltered = false)
             }
             return;
         }
+        if (output.tryAddSelection(batch, selection, survivors))
+            return;
         for (let index = 0; index < survivors; index += 1) {
             output.add(batch, selection[index] ?? 0);
             if (reachedEarlyLimit(plan, output.size))
@@ -3680,7 +4143,21 @@ function updateAggregates(plan, state, batch, row, memory) {
         // the single surviving value.
         if (spec.rawDatetime !== undefined) {
             const sourceRow = batch.rowsBySource[spec.rawDatetime.source]?.[row] ?? -1;
-            applyAggregateValue(spec, state, index, rawFloat64Value(spec.rawDatetime.vector, sourceRow), memory);
+            const value = rawFloat64Value(spec.rawDatetime.vector, sourceRow);
+            if (value !== null &&
+                spec.distinct !== true &&
+                (spec.name === "MIN" || spec.name === "MAX")) {
+                // Epoch milliseconds compare as plain numbers; the generic comparator would classify
+                // both operands on every row of the scan.
+                state.counts[index] = (state.counts[index] ?? 0) + 1;
+                const current = state.values[index];
+                if (typeof current !== "number" ||
+                    (spec.name === "MIN" ? value < current : value > current)) {
+                    replaceAggregateValue(state, index, value, `${spec.name} aggregate value`, memory);
+                }
+                continue;
+            }
+            applyAggregateValue(spec, state, index, value, memory);
             continue;
         }
         // A bare number column reads its Float64Array slot directly and accumulates SUM/AVG into
@@ -3697,16 +4174,21 @@ function updateAggregates(plan, state, batch, row, memory) {
                 if (spec.name === "SUM" || spec.name === "AVG") {
                     state.sums[index] = (state.sums[index] ?? 0) + value;
                 }
-                else if (spec.name === "MIN") {
+                else if (spec.name === "MIN" || spec.name === "MAX") {
+                    // A raw number compares as a number. NaN keeps compareValues's place, after every
+                    // finite value: it is never the minimum and always the maximum once seen.
                     const current = state.values[index];
-                    if (current === undefined || compareValues(value, current) < 0) {
-                        replaceAggregateValue(state, index, value, "MIN aggregate value", memory);
-                    }
-                }
-                else if (spec.name === "MAX") {
-                    const current = state.values[index];
-                    if (current === undefined || compareValues(value, current) > 0) {
-                        replaceAggregateValue(state, index, value, "MAX aggregate value", memory);
+                    const better = typeof current !== "number"
+                        ? true
+                        : Number.isNaN(value)
+                            ? spec.name === "MAX" && !Number.isNaN(current)
+                            : Number.isNaN(current)
+                                ? spec.name === "MIN"
+                                : spec.name === "MIN"
+                                    ? value < current
+                                    : value > current;
+                    if (better) {
+                        replaceAggregateValue(state, index, value, `${spec.name} aggregate value`, memory);
                     }
                 }
             }
@@ -4648,50 +5130,134 @@ function inListHolds(operator, value, items) {
     }
     return operator === "NOT IN" && !hasNull;
 }
+const compiledBatchExpressions = new WeakMap();
+/**
+ * Compiles a bound expression to a closure once per plan, so a scan does not re-dispatch on the
+ * node kind, re-check the function name, or allocate an argument array on every row. The
+ * closures call the same value functions the interpreter does — binaryValue,
+ * scalarFunctionValue, booleanTruth — so semantics are shared, only the walk is hoisted.
+ */
+function compiledBatchExpression(plan, expression) {
+    const cached = compiledBatchExpressions.get(expression);
+    if (cached !== undefined)
+        return cached;
+    let compiled;
+    switch (expression.kind) {
+        case "literal": {
+            const value = expression.value;
+            compiled = () => value;
+            break;
+        }
+        case "wildcard":
+            compiled = () => 1;
+            break;
+        case "column": {
+            const vector = expression.vector;
+            const source = expression.source;
+            compiled = (batch, row) => vectorValue(vector, batch.rowsBySource[source]?.[row] ?? -1);
+            break;
+        }
+        case "binary": {
+            const operator = expression.operator;
+            const left = compiledBatchExpression(plan, expression.left);
+            const right = compiledBatchExpression(plan, expression.right);
+            compiled = (batch, row) => binaryValue(operator, left(batch, row), right(batch, row));
+            break;
+        }
+        case "case": {
+            const branches = expression.branches.map((branch) => ({
+                when: compiledTruth(plan, branch.when),
+                then: compiledBatchExpression(plan, branch.then),
+            }));
+            const otherwise = expression.otherwise === undefined
+                ? undefined
+                : compiledBatchExpression(plan, expression.otherwise);
+            compiled = (batch, row) => {
+                for (const branch of branches) {
+                    if (branch.when(batch, row) === true)
+                        return branch.then(batch, row);
+                }
+                return otherwise === undefined ? null : otherwise(batch, row);
+            };
+            break;
+        }
+        case "condition":
+        case "logical":
+        case "not": {
+            const truth = compiledTruth(plan, expression);
+            compiled = truth;
+            break;
+        }
+        case "fts":
+            compiled = (batch, row) => expression.op === "match"
+                ? ftsBatchTruth(expression, batch, null, row)
+                : ftsBm25BatchValue(expression, batch, null, row);
+            break;
+        case "list":
+            compiled = () => {
+                throw new TypeError("Value lists are only supported with IN");
+            };
+            break;
+        default: {
+            if (expression.name === "COALESCE") {
+                const parts = expression.arguments.map((argument) => compiledBatchExpression(plan, argument));
+                compiled = (batch, row) => {
+                    for (const part of parts) {
+                        const candidate = part(batch, row);
+                        if (candidate !== null && candidate !== undefined)
+                            return candidate;
+                    }
+                    return null;
+                };
+                break;
+            }
+            const name = expression.name;
+            if (!isScalarFunctionName(name)) {
+                compiled = () => {
+                    throw new TypeError(`${name} requires grouped execution`);
+                };
+                break;
+            }
+            const parts = expression.arguments.map((argument) => compiledBatchExpression(plan, argument));
+            // One argument array per call site, refilled per row: a function never re-enters its own
+            // evaluation, so the slots are free again before the next row reads them.
+            const values = new Array(parts.length);
+            const evaluate = scalarFunctionEvaluator(name);
+            compiled = (batch, row) => {
+                let index = 0;
+                for (const part of parts) {
+                    values[index] = part(batch, row);
+                    index += 1;
+                }
+                return evaluate(values);
+            };
+        }
+    }
+    compiledBatchExpressions.set(expression, compiled);
+    return compiled;
+}
+/** A boolean node compiled over its children, keeping booleanTruth's three-valued rules. */
+function compiledTruth(plan, expression) {
+    // booleanTruth reads operands through a callback; binding the current row into one closure
+    // per node avoids allocating that callback per row. A node is never re-entered while its
+    // own operands evaluate, so the shared slots are safe.
+    const state = { batch: undefined, row: 0 };
+    const evaluateValue = (nested) => compiledBatchExpression(plan, nested)(state.batch, state.row);
+    return (batch, row) => {
+        state.batch = batch;
+        state.row = row;
+        return booleanTruth(expression, evaluateValue);
+    };
+}
 function evaluateBatchExpression(plan, expression, batch, row) {
     if (expression.kind === "literal")
         return expression.value;
     if (expression.kind === "wildcard")
         return 1;
-    if (expression.kind === "list")
-        throw new TypeError("Value lists are only supported with IN");
-    if (expression.kind === "condition" ||
-        expression.kind === "logical" ||
-        expression.kind === "not") {
-        return booleanTruth(expression, (nested) => evaluateBatchExpression(plan, nested, batch, row));
-    }
-    if (expression.kind === "case") {
-        for (const branch of expression.branches) {
-            const matched = booleanTruth(branch.when, (nested) => evaluateBatchExpression(plan, nested, batch, row));
-            if (matched === true)
-                return evaluateBatchExpression(plan, branch.then, batch, row);
-        }
-        return expression.otherwise === undefined
-            ? null
-            : evaluateBatchExpression(plan, expression.otherwise, batch, row);
-    }
     if (expression.kind === "column") {
         return vectorValue(expression.vector, batch.rowsBySource[expression.source]?.[row] ?? -1);
     }
-    if (expression.kind === "fts") {
-        return expression.op === "match"
-            ? ftsBatchTruth(expression, batch, null, row)
-            : ftsBm25BatchValue(expression, batch, null, row);
-    }
-    if (expression.kind === "binary") {
-        return binaryValue(expression.operator, evaluateBatchExpression(plan, expression.left, batch, row), evaluateBatchExpression(plan, expression.right, batch, row));
-    }
-    if (expression.name === "COALESCE") {
-        for (const argument of expression.arguments) {
-            const candidate = evaluateBatchExpression(plan, argument, batch, row);
-            if (candidate !== null && candidate !== undefined)
-                return candidate;
-        }
-        return null;
-    }
-    if (!isScalarFunctionName(expression.name))
-        throw new TypeError(`${expression.name} requires grouped execution`);
-    return scalarFunctionValue(expression.name, expression.arguments.map((argument) => evaluateBatchExpression(plan, argument, batch, row)));
+    return compiledBatchExpression(plan, expression)(batch, row);
 }
 function evaluateExpression(expression, rowsBySource) {
     if (expression.kind === "literal")
@@ -4741,12 +5307,20 @@ function evaluateExpression(expression, rowsBySource) {
 function binaryValue(operator, left, right) {
     if (left === null || left === undefined || right === null || right === undefined)
         return null;
-    if (operator === "||") {
-        if (typeof left !== "string" || typeof right !== "string") {
-            throw new TypeError("|| requires string operands");
-        }
+    if (typeof left === "number" && typeof right === "number") {
+        if (operator === "+")
+            return left + right;
+        if (operator === "-")
+            return left - right;
+        if (operator === "*")
+            return left * right;
+        if (operator === "/")
+            return right === 0 ? null : left / right;
+        if (operator === "%")
+            return right === 0 ? null : left % right;
+    }
+    if (operator === "||")
         return concatenatedSqlValue(left, right);
-    }
     const exact = exactNumericBinary(operator, left, right);
     if (exact !== undefined)
         return exact;
@@ -4806,6 +5380,26 @@ function comparisonValue(operator, leftValue, rightValue) {
         rightValue === undefined) {
         return false;
     }
+    // NaN keeps the general path: SQL treats it as one value equal to itself.
+    if (typeof leftValue === "number" &&
+        typeof rightValue === "number" &&
+        leftValue === leftValue &&
+        rightValue === rightValue) {
+        if (operator === "=")
+            return leftValue === rightValue;
+        if (operator === "!=" || operator === "<>")
+            return leftValue !== rightValue;
+        if (operator === ">")
+            return leftValue > rightValue;
+        if (operator === ">=")
+            return leftValue >= rightValue;
+        if (operator === "<")
+            return leftValue < rightValue;
+        return leftValue <= rightValue;
+    }
+    // An untyped string beside a datetime, number, or boolean reads in that value's type, as
+    // PostgreSQL types an unknown-typed literal by its context; the row executor does the same.
+    [leftValue, rightValue] = coerceComparisonOperands(leftValue, rightValue);
     const left = comparable(leftValue);
     const right = comparable(rightValue);
     if (operator === "=")