@minnowdb/core 0.6.9 → 0.7.0

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

@@ -1,9 +1,23 @@
 /**
- * SQL value semantics shared by the row and vector executors.
- *
- * Keep comparison, equality-key, scalar, and pattern behavior here so an execution-path
- * optimization cannot silently change query results.
+ * The standard's datetime text — `2026-01-02`, `2026-01-02 03:04:05`, `2026-01-02T03:04:05.250Z`,
+ * an optional zone offset — read as an instant. A zoneless spelling is UTC, the reading every
+ * datetime in a Minnow database has; `undefined` for text in any other shape.
  */
+export declare function parseSqlTimestampText(text: string): Date | undefined;
+/**
+ * PostgreSQL reads an untyped string constant beside a typed value in that value's type:
+ * `joined >= '2026-01-01'`, `id = '5'`, `active = 't'`. Catalog-backed plans coerce such literals
+ * before execution; this runtime reading covers the schema-less row executor and anything the
+ * plan rewrite could not see. Text that does not parse in the other side's type keeps the
+ * comparable-types error below, so a genuine mismatch still fails.
+ */
+export declare function coercedComparable(text: string, other: unknown): unknown;
+/**
+ * Applies the untyped-literal reading to a comparison's two operands: a plain string beside a
+ * typed value (datetime, DATE, number, boolean) is read in that value's type when it parses.
+ * Both executors call this before their own comparisons, so the reading is one decision.
+ */
+export declare function coerceComparisonOperands(left: unknown, right: unknown): [unknown, unknown];
 /**
  * Deterministic SQL ordering. Strings use Unicode codepoint order rather than host locale data,
  * and signed zero compares equal because SQL numeric equality does not distinguish it.
@@ -24,6 +38,13 @@ interface SqlPatternMatcher {
 }
 /** Compiles SQL LIKE without exposing input to the host regular-expression engine. */
 export declare function compileLikePattern(pattern: string, caseInsensitive?: boolean, escape?: string): SqlPatternMatcher;
+/**
+ * PostgreSQL's ~ / ~* / !~ / !~* operators and REGEXP_REPLACE, compiled as JavaScript regular
+ * expressions. Advanced regular expressions and JavaScript agree on the everyday syntax; the
+ * `n` flag makes `.` and anchors newline-sensitive, `i` is case-insensitive, and `g` replaces
+ * every match. Patterns are bounded like every other SQL pattern.
+ */
+export declare function compileRegexPattern(pattern: string, flags?: string): RegExp;
 /** PostgreSQL SIMILAR TO compiled to a Thompson NFA with bounded deterministic work. */
 export declare function compileSimilarPattern(pattern: string, escape?: string): SqlPatternMatcher;
 /** Defines an own enumerable result-column property, including the special name `__proto__`. */

package/dist/engine/sql-semantics.js

@@ -1,18 +1,95 @@
 import { dateMilliseconds } from "../date-value.js";
 import { assertWellFormedString } from "../block-format/unicode.js";
 import { MAX_SQL_NESTING_DEPTH, MAX_SQL_PATTERN_CHARACTERS, MAX_SQL_PATTERN_MATCH_STEPS, } from "./cache-limits.js";
-import { collatedDomainCompare, enumDomainCompare, exactNumericCompare, externalSqlDomainValue, externalSqlTextValue, isDateDomainValue, } from "./sql-domains.js";
+import { collatedDomainCompare, enumDomainCompare, exactNumericCompare, externalSqlDomainValue, externalSqlTextValue, intervalDomainCompare, isDateDomainValue, isSqlDomainValue, } from "./sql-domains.js";
 /**
  * SQL value semantics shared by the row and vector executors.
  *
  * Keep comparison, equality-key, scalar, and pattern behavior here so an execution-path
  * optimization cannot silently change query results.
  */
+const SQL_TIMESTAMP_TEXT = /^(\d{4}-\d{2}-\d{2})(?:[ T](\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?))?(Z|[+-]\d{2}:?\d{2})?$/;
+/**
+ * The standard's datetime text — `2026-01-02`, `2026-01-02 03:04:05`, `2026-01-02T03:04:05.250Z`,
+ * an optional zone offset — read as an instant. A zoneless spelling is UTC, the reading every
+ * datetime in a Minnow database has; `undefined` for text in any other shape.
+ */
+export function parseSqlTimestampText(text) {
+    const match = SQL_TIMESTAMP_TEXT.exec(text.trim());
+    if (match === null)
+        return undefined;
+    const [, day, time = "00:00:00", zone = "Z"] = match;
+    const seconds = time.length === 5 ? `${time}:00` : time;
+    const date = new Date(`${String(day)}T${seconds}${zone === "Z" ? "Z" : zone}`);
+    return Number.isFinite(dateMilliseconds(date)) ? date : undefined;
+}
+/**
+ * PostgreSQL reads an untyped string constant beside a typed value in that value's type:
+ * `joined >= '2026-01-01'`, `id = '5'`, `active = 't'`. Catalog-backed plans coerce such literals
+ * before execution; this runtime reading covers the schema-less row executor and anything the
+ * plan rewrite could not see. Text that does not parse in the other side's type keeps the
+ * comparable-types error below, so a genuine mismatch still fails.
+ */
+export function coercedComparable(text, other) {
+    if (other instanceof Date || isDateDomainValue(other))
+        return parseSqlTimestampText(text) ?? text;
+    if (typeof other === "number") {
+        const trimmed = text.trim();
+        if (trimmed === "")
+            return text;
+        const parsed = Number(trimmed);
+        return Number.isFinite(parsed) ? parsed : text;
+    }
+    if (typeof other === "boolean") {
+        const lowered = text.trim().toLowerCase();
+        if (lowered === "t" || lowered === "true" || lowered === "1")
+            return true;
+        if (lowered === "f" || lowered === "false" || lowered === "0")
+            return false;
+    }
+    return text;
+}
+/**
+ * Applies the untyped-literal reading to a comparison's two operands: a plain string beside a
+ * typed value (datetime, DATE, number, boolean) is read in that value's type when it parses.
+ * Both executors call this before their own comparisons, so the reading is one decision.
+ */
+export function coerceComparisonOperands(left, right) {
+    const plainText = (value) => typeof value === "string" && !isSqlDomainValue(value);
+    const typed = (value) => typeof value !== "string" || isDateDomainValue(value);
+    if (plainText(left) && typed(right))
+        return [coercedComparable(left, right), right];
+    if (plainText(right) && typed(left))
+        return [left, coercedComparable(right, left)];
+    return [left, right];
+}
 /**
  * Deterministic SQL ordering. Strings use Unicode codepoint order rather than host locale data,
  * and signed zero compares equal because SQL numeric equality does not distinguish it.
  */
 export function compareSqlValues(left, right) {
+    // Plain numbers and untagged strings are the bulk of every comparison; settle them before the
+    // domain checks. NaN falls through so its placement stays with the general ordering below, and
+    // a string starting with NUL may carry a domain tag, so only tag-free strings take the short path.
+    if (typeof left === "number" && typeof right === "number") {
+        if (left < right)
+            return -1;
+        if (left > right)
+            return 1;
+        if (left === right)
+            return 0;
+    }
+    else if (typeof left === "string" &&
+        typeof right === "string" &&
+        left.charCodeAt(0) !== 0 &&
+        right.charCodeAt(0) !== 0) {
+        return compareSqlStrings(left, right);
+    }
+    const [coercedLeft, coercedRight] = coerceComparisonOperands(left, right);
+    // Object.is, not !==: NaN would otherwise look changed on every pass and recurse forever.
+    if (!Object.is(coercedLeft, left) || !Object.is(coercedRight, right)) {
+        return compareSqlValues(coercedLeft, coercedRight);
+    }
     const plainLeft = externalSqlTextValue(left);
     const plainRight = externalSqlTextValue(right);
     if ((typeof left === "string" && plainLeft !== left) ||
@@ -25,6 +102,9 @@ export function compareSqlValues(left, right) {
     const collated = collatedDomainCompare(left, right);
     if (collated !== undefined)
         return collated;
+    const interval = intervalDomainCompare(left, right);
+    if (interval !== undefined)
+        return interval;
     const enumOrder = enumDomainCompare(left, right);
     if (enumOrder !== undefined)
         return enumOrder;
@@ -96,6 +176,17 @@ export function encodeSqlEqualityValue(value) {
  */
 export function roundSqlNumber(value, precision = 0) {
     const digits = Math.min(30, Math.max(0, Math.trunc(precision)));
+    // Whole-number rounding is arithmetic: toFixed(0) picks the integer nearest the exact binary
+    // value, ties toward larger magnitude. Below 2^52 the fractional part of a double is exact,
+    // so floor and compare reproduce it without formatting a string per row.
+    if (digits === 0 && Number.isFinite(value)) {
+        const magnitude = Math.abs(value);
+        if (magnitude >= 4_503_599_627_370_496)
+            return value === 0 ? 0 : value;
+        const whole = Math.floor(magnitude);
+        const rounded = magnitude - whole >= 0.5 ? whole + 1 : whole;
+        return rounded === 0 ? 0 : value < 0 ? -rounded : rounded;
+    }
     // SQLite formats with the requested decimal precision and parses the result back. toFixed
     // follows the same decimal path, avoiding multiplication overflow and binary scaling drift.
     const rounded = Number(value.toFixed(digits));
@@ -525,6 +616,48 @@ function nfaMatcher(pattern, escape) {
     // the cache instead of pretending their Uint32-sized indexes are the whole retained graph.
     return { test, retainedSize: states.length * 32 };
 }
+const regexCache = new Map();
+/**
+ * PostgreSQL's ~ / ~* / !~ / !~* operators and REGEXP_REPLACE, compiled as JavaScript regular
+ * expressions. Advanced regular expressions and JavaScript agree on the everyday syntax; the
+ * `n` flag makes `.` and anchors newline-sensitive, `i` is case-insensitive, and `g` replaces
+ * every match. Patterns are bounded like every other SQL pattern.
+ */
+export function compileRegexPattern(pattern, flags = "") {
+    assertBoundedPattern(pattern, "regular expression");
+    const normalized = [...new Set(flags)].sort().join("");
+    const key = `${normalized}\u0000${pattern}`;
+    const cached = regexCache.get(key);
+    if (cached !== undefined) {
+        cached.lastIndex = 0;
+        return cached;
+    }
+    let jsFlags = "u";
+    if (normalized.includes("i"))
+        jsFlags += "i";
+    if (normalized.includes("g"))
+        jsFlags += "g";
+    if (normalized.includes("n"))
+        jsFlags += "m";
+    else
+        jsFlags += "s";
+    let expression;
+    try {
+        expression = new RegExp(pattern, jsFlags);
+    }
+    catch {
+        try {
+            expression = new RegExp(pattern, jsFlags.replace("u", ""));
+        }
+        catch (error) {
+            throw new TypeError(`Invalid regular expression: ${error instanceof Error ? error.message : pattern}`, { cause: error });
+        }
+    }
+    if (regexCache.size >= 256)
+        regexCache.clear();
+    regexCache.set(key, expression);
+    return expression;
+}
 /** PostgreSQL SIMILAR TO compiled to a Thompson NFA with bounded deterministic work. */
 export function compileSimilarPattern(pattern, escape = "\\") {
     assertBoundedPattern(pattern, "SIMILAR TO pattern");

package/dist/engine/vector.d.ts

@@ -34,7 +34,7 @@ interface StringVector extends VectorBase {
     readonly dictionary: readonly string[];
 }
 export type ColumnVector = BooleanVector | NumberVector | DateTimeVector | StringVector;
-interface ColumnarColumnInput {
+export interface ColumnarColumnInput {
     readonly type: VectorType;
     readonly values: readonly QueryValue[];
 }
@@ -86,6 +86,12 @@ export interface AsyncQueryExecutionOptions {
      * reference instead of stitching copies.
      */
     readonly loadScanWindow?: (start: number, length: number) => number | Promise<number>;
+    /**
+     * Ascending scan row positions an index has already narrowed the plan to. The predicates
+     * still run on every visited row, so the selection is a pure skip list: rows outside it are
+     * never loaded or evaluated. Only the streamed scan honors it.
+     */
+    readonly scanRows?: readonly number[];
 }
 export interface QueryBatchExecutionOptions extends AsyncQueryExecutionOptions {
     /** Maximum result rows handed to the consumer at once. */