@minnowdb/core 0.7.10 → 0.9.0

package/dist/engine/result-state.d.ts

@@ -0,0 +1,7 @@
+import type { QueryResult } from "../plan/model.js";
+/** Shared boundary state; result copies must not need the SQL compiler or evaluators. */
+export declare const alreadyExternalResults: WeakSet<QueryResult>;
+/** Internal ownership boundary for results assembled entirely from already-public row values. */
+export declare function markQueryResultExternal(result: QueryResult): QueryResult;
+/** Carries the internal no-conversion proof across a defensive result copy. */
+export declare function copyQueryResultExternalization(source: QueryResult, copy: QueryResult): QueryResult;

package/dist/engine/result-state.js

@@ -0,0 +1,15 @@
+const alreadyExternalResults = /* @__PURE__ */ new WeakSet();
+function markQueryResultExternal(result) {
+  alreadyExternalResults.add(result);
+  return result;
+}
+function copyQueryResultExternalization(source, copy) {
+  if (alreadyExternalResults.has(source))
+    alreadyExternalResults.add(copy);
+  return copy;
+}
+export {
+  alreadyExternalResults,
+  copyQueryResultExternalization,
+  markQueryResultExternal
+};

package/dist/engine/sql-domains.js

@@ -722,6 +722,125 @@ function intervalDomainCompare(left, right) {
 function isSqlDomainValue(value) {
   return typeof value === "string" && value.startsWith(PREFIX);
 }
+function temporalDomainPart(field, value) {
+  if (typeof value !== "string")
+    return void 0;
+  let months = 0;
+  let days = 0;
+  let usecs;
+  const interval = value.startsWith(INTERVAL_VALUE);
+  if (interval) {
+    [months, days, usecs] = JSON.parse(value.slice(INTERVAL_VALUE.length));
+  } else if (value.startsWith(TIME_VALUE)) {
+    const [hour = "0", minute = "0", second = "0"] = value.slice(TIME_VALUE.length).split(":");
+    usecs = Number(hour) * 36e8 + Number(minute) * 6e7 + Math.round(Number(second) * 1e6);
+  } else
+    return void 0;
+  switch (field) {
+    case "hour":
+      return Math.trunc(usecs / 36e8);
+    case "minute":
+      return Math.trunc(usecs / 6e7) % 60;
+    case "second":
+      return usecs % 6e7 / 1e6;
+    case "milliseconds":
+      return usecs % 6e7 / 1e3;
+    case "microseconds":
+      return usecs % 6e7;
+    case "epoch":
+      return interval ? (Math.trunc(months / 12) * 365.25 + months % 12 * 30 + days) * 86400 + usecs / 1e6 : usecs / 1e6;
+  }
+  if (interval) {
+    const years = Math.trunc(months / 12);
+    switch (field) {
+      case "year":
+        return years;
+      case "month":
+        return months % 12;
+      case "day":
+        return days;
+      case "quarter":
+        return Math.trunc(months % 12 / 3) + 1;
+      case "decade":
+        return Math.trunc(years / 10);
+      case "century":
+        return Math.trunc(years / 100);
+      case "millennium":
+        return Math.trunc(years / 1e3);
+    }
+  }
+  throw new TypeError(`Cannot extract ${field} from ${interval ? "INTERVAL" : "TIME"}`);
+}
+function structuredDomainCompare(left, right) {
+  if (typeof left !== "string" || typeof right !== "string")
+    return void 0;
+  const array = left.startsWith(ARRAY_VALUE) && right.startsWith(ARRAY_VALUE);
+  const jsonb = left.startsWith(JSONB_VALUE) && right.startsWith(JSONB_VALUE);
+  if (!array && !jsonb)
+    return void 0;
+  if (left === right)
+    return 0;
+  const prefix = array ? ARRAY_VALUE : JSONB_VALUE;
+  const a = JSON.parse(left.slice(prefix.length));
+  const b = JSON.parse(right.slice(prefix.length));
+  if (array && Array.isArray(a) && Array.isArray(b)) {
+    for (let index = 0; index < Math.min(a.length, b.length); index += 1) {
+      const x = a[index];
+      const y = b[index];
+      const order = x === null || y === null ? x === y ? 0 : x === null ? 1 : -1 : compareJsonStructure(x, y);
+      if (order !== 0)
+        return order;
+    }
+    return a.length - b.length;
+  }
+  if (Array.isArray(a) && a.length === 0)
+    return Array.isArray(b) && b.length === 0 ? 0 : -1;
+  if (Array.isArray(b) && b.length === 0)
+    return 1;
+  return compareJsonStructure(a, b);
+}
+function compareJsonStructure(left, right) {
+  if (left === right)
+    return 0;
+  const rank = (value) => value === null ? 0 : typeof value === "string" ? 1 : typeof value === "number" ? 2 : typeof value === "boolean" ? 3 : Array.isArray(value) ? 4 : 5;
+  const difference = rank(left) - rank(right);
+  if (difference !== 0)
+    return difference;
+  if (typeof left === "number" && typeof right === "number")
+    return left - right;
+  if (typeof left === "string" && typeof right === "string")
+    return left < right ? -1 : 1;
+  if (typeof left === "boolean" && typeof right === "boolean")
+    return Number(left) - Number(right);
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length)
+      return left.length - right.length;
+    for (let index = 0; index < left.length; index += 1) {
+      const order = compareJsonStructure(left[index], right[index]);
+      if (order !== 0)
+        return order;
+    }
+    return 0;
+  }
+  const a = left;
+  const b = right;
+  const encoder = new TextEncoder();
+  const keyOrder = (x, y) => encoder.encode(x).length - encoder.encode(y).length || (x === y ? 0 : x < y ? -1 : 1);
+  const keysA = Object.keys(a).sort(keyOrder);
+  const keysB = Object.keys(b).sort(keyOrder);
+  if (keysA.length !== keysB.length)
+    return keysA.length - keysB.length;
+  for (let index = 0; index < keysA.length; index += 1) {
+    const x = keysA[index] ?? "";
+    const y = keysB[index] ?? "";
+    if (x !== y)
+      return x < y ? -1 : 1;
+    const order = compareJsonStructure(a[x], b[y]);
+    if (order !== 0)
+      return order;
+  }
+  return 0;
+}
 export {
   arrayDomainValue,
   boundedJsonText,
@@ -751,6 +870,8 @@ export {
   normalizeSqlDomainValue,
   preservedJsonDomainValue,
   protectedSqlTextValue,
+  structuredDomainCompare,
+  temporalDomainPart,
   timeDomainValue,
   uuidDomainValue
 };

package/dist/engine/sql-semantics.js

@@ -1,7 +1,7 @@
 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, intervalDomainCompare, isDateDomainValue, isSqlDomainValue } from "./sql-domains.js";
+import { structuredDomainCompare, collatedDomainCompare, enumDomainCompare, exactNumericCompare, externalSqlDomainValue, externalSqlTextValue, intervalDomainCompare, isDateDomainValue, isSqlDomainValue } from "./sql-domains.js";
 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})?$/;
 function parseSqlTimestampText(text) {
   const match = SQL_TIMESTAMP_TEXT.exec(text.trim());
@@ -33,9 +33,9 @@ function readUntypedText(type, text) {
   }
   if (type === "boolean") {
     const lowered = text.trim().toLowerCase();
-    if (lowered === "t" || lowered === "true" || lowered === "1")
+    if (/^(?:t(?:r(?:u(?:e)?)?)?|y(?:e(?:s)?)?|on|1)$/.test(lowered))
       return true;
-    if (lowered === "f" || lowered === "false" || lowered === "0")
+    if (/^(?:f(?:a(?:l(?:s(?:e)?)?)?)?|n(?:o)?|of(?:f)?|0)$/.test(lowered))
       return false;
   }
   return text;
@@ -72,6 +72,9 @@ function compareSqlValues(left, right) {
     }
     return compareSqlStrings(plainLeft, plainRight);
   }
+  const structured = structuredDomainCompare(left, right);
+  if (structured !== void 0)
+    return structured;
   const collated = collatedDomainCompare(left, right);
   if (collated !== void 0)
     return collated;
@@ -347,7 +350,7 @@ function generalLikeMatcher(tokens, caseInsensitive) {
 }
 function compileLikePattern(pattern, caseInsensitive = false, escape) {
   assertBoundedPattern(pattern, "LIKE pattern");
-  const exactEscape = escape === void 0 ? void 0 : exactSingleCharacter(escape, "LIKE escape");
+  const exactEscape = escape === void 0 || escape === "" ? void 0 : exactSingleCharacter(escape, "LIKE escape");
   const key = JSON.stringify([caseInsensitive, exactEscape ?? null, pattern]);
   const cached = cachedPattern(likeCache, key);
   if (cached !== void 0)

package/dist/engine/typed-live.js

@@ -6,7 +6,7 @@ function reconcileRows(previous, next, retained) {
   for (let index = 0; index < next.length; index += 1) {
     const row = next[index];
     const was = provenance?.[index] ?? -1;
-    if (was >= 0 && was < previous.length) {
+    if (was >= 0 && was < previous.length && sameLiveValue(previous[was], row)) {
       rows[index] = previous[was];
       if (was !== index)
         changed = true;
@@ -38,6 +38,7 @@ class LiveQuery {
   #executionAbort;
   #invalidationSequence = 0;
   #closed = false;
+  #refreshLeases = 0;
   constructor(backend, source, onClose) {
     this.#backend = backend;
     this.#source = source;
@@ -57,32 +58,39 @@ class LiveQuery {
         return;
       subscribed = false;
       this.#listeners.delete(registered);
-      if (this.#listeners.size === 0)
+      if (this.#listeners.size === 0 && this.#refreshLeases === 0)
         this.#stopObservation();
     };
   };
   async refresh() {
     if (this.#closed)
       throw new Error("Live query is closed");
-    const sequence = this.#invalidationSequence;
-    if (this.#listeners.size > 0) {
-      if (this.#subscription === void 0)
-        this.#startObservation();
-      const opening = this.#subscription;
-      if (opening !== void 0)
-        await opening.catch(() => void 0);
-      await this.#backend.refresh();
-    }
-    if (this.#invalidationSequence === sequence) {
-      const version = this.#snapshot.status === "loading" ? null : this.#snapshot.version;
-      if (this.#decodes()) {
-        const last = this.#lastDelivered;
-        if (this.#snapshot.status === "error" && last !== void 0)
-          this.#schedule(last);
-      } else
-        this.#schedule({ manifestVersion: version, catalogEpoch: 0, initial: false });
+    this.#refreshLeases += 1;
+    try {
+      const sequence = this.#invalidationSequence;
+      if (this.#listeners.size > 0 || this.#decodes()) {
+        if (this.#subscription === void 0)
+          this.#startObservation();
+        const opening = this.#subscription;
+        if (opening !== void 0)
+          await opening.catch(() => void 0);
+        await this.#backend.refresh();
+      }
+      if (this.#invalidationSequence === sequence) {
+        const version = this.#snapshot.status === "loading" ? null : this.#snapshot.version;
+        if (this.#decodes()) {
+          const last = this.#lastDelivered;
+          if (this.#snapshot.status === "error" && last !== void 0)
+            this.#schedule(last);
+        } else
+          this.#schedule({ manifestVersion: version, catalogEpoch: 0, initial: false });
+      }
+      await this.#waitForIdle();
+    } finally {
+      this.#refreshLeases -= 1;
+      if (this.#refreshLeases === 0 && this.#listeners.size === 0)
+        this.#stopObservation();
     }
-    await this.#waitForIdle();
   }
   #decodes() {
     return this.#source.decode !== void 0 && this.#backend.subscribe !== void 0;

package/dist/engine/vector.d.ts

@@ -12,6 +12,8 @@ export interface VectorWindow {
     readonly length: number;
 }
 interface VectorBase {
+    /** Present on immutable block vectors, so keyed reads need no decoded-block lookup. */
+    readonly nullCount?: number;
     readonly validity: Uint8Array;
     readonly length: number;
     readonly window?: VectorWindow;
@@ -110,5 +112,7 @@ interface PrepareVectorQueryOptions {
 export declare function createColumnarTable(name: string, columns: ReadonlyMap<string, ColumnarColumnInput>, uniqueKey?: string): ColumnarTable;
 export declare function columnarTableFromRows(name: string, rows: readonly DatabaseRow[], projectedColumnNames?: readonly string[], protectText?: boolean): ColumnarTable;
 export declare function prepareVectorQuery(plan: CompiledQuery, inputTables: ReadonlyMap<string, ColumnarTable>, options?: PrepareVectorQueryOptions): PreparedVectorQuery;
+/** Builds directly from a row/column reader without retaining an intermediate value array. */
+export declare function createColumnVector(type: VectorType, length: number, valueAt: (index: number) => unknown): ColumnVector;
 export declare function vectorValue(vector: ColumnVector, rowIndex: number): QueryValue;
 export {};

package/dist/engine/vector.js

@@ -90,7 +90,7 @@ function createColumnarTable(name, columns, uniqueKey) {
     if (column.values.length !== rowCount) {
       throw new Error(`Column row count mismatch: ${name}.${columnName}`);
     }
-    vectors.set(columnName, createVector(column));
+    vectors.set(columnName, createColumnVector(column.type, rowCount, (index) => column.values[index]));
   }
   if (uniqueKey !== void 0 && !vectors.has(uniqueKey)) {
     throw new Error(`Unique-key vector is missing: ${name}.${uniqueKey}`);
@@ -205,21 +205,20 @@ function prepareVectorQuery(plan, inputTables, options = {}) {
     throw error;
   }
 }
-function createVector(input) {
-  validateVectorType(input.type);
-  const length = input.values.length;
+function createColumnVector(type, length, valueAt) {
+  validateVectorType(type);
   const validity = new Uint8Array(Math.ceil(length / 8));
-  if (input.type === "string") {
+  if (type === "string") {
     const dictionary = [];
     const dictionaryIndex = /* @__PURE__ */ new Map();
     const codes = new Uint32Array(length);
     codes.fill(NULL_STRING_CODE);
     for (let index = 0; index < length; index += 1) {
-      const value = input.values[index];
+      const value = valueAt(index);
       if (value === null)
         continue;
       if (typeof value !== "string")
-        throw vectorTypeError(input.type, value);
+        throw vectorTypeError(type, value);
       setValid(validity, index);
       let code = dictionaryIndex.get(value);
       if (code === void 0) {
@@ -231,14 +230,14 @@ function createVector(input) {
     }
     return { kind: "string", length, validity, codes, dictionary };
   }
-  if (input.type === "boolean") {
+  if (type === "boolean") {
     const values2 = new Uint8Array(length);
     for (let index = 0; index < length; index += 1) {
-      const value = input.values[index];
+      const value = valueAt(index);
       if (value === null)
         continue;
       if (typeof value !== "boolean")
-        throw vectorTypeError(input.type, value);
+        throw vectorTypeError(type, value);
       setValid(validity, index);
       values2[index] = value ? 1 : 0;
     }
@@ -246,16 +245,16 @@ function createVector(input) {
   }
   const values = new Float64Array(length);
   for (let index = 0; index < length; index += 1) {
-    const value = input.values[index];
+    const value = valueAt(index);
     if (value === null)
       continue;
-    const numericValue = input.type === "datetime" ? value instanceof Date ? dateMilliseconds(value) : Number.NaN : typeof value === "number" ? value : Number.NaN;
+    const numericValue = type === "datetime" ? value instanceof Date ? dateMilliseconds(value) : Number.NaN : typeof value === "number" ? value : Number.NaN;
     if (!Number.isFinite(numericValue))
-      throw vectorTypeError(input.type, value);
+      throw vectorTypeError(type, value);
     setValid(validity, index);
     values[index] = numericValue;
   }
-  return input.type === "datetime" ? { kind: "datetime", length, validity, values } : { kind: "number", length, validity, values };
+  return type === "datetime" ? { kind: "datetime", length, validity, values } : { kind: "number", length, validity, values };
 }
 function validateVectorType(type) {
   if (type !== "boolean" && type !== "number" && type !== "string" && type !== "datetime") {
@@ -4876,6 +4875,7 @@ function safeMemoryProduct(left, right, label) {
 }
 export {
   columnarTableFromRows,
+  createColumnVector,
   createColumnarTable,
   prepareVectorQuery,
   vectorValue

package/dist/engine/windows.d.ts

@@ -0,0 +1,12 @@
+import type { QueryResult, WindowSpec } from "../plan/model.js";
+import { QueryMemoryContext } from "./memory.js";
+interface WindowOptions {
+    copyRows?: boolean;
+    memoryContext?: QueryMemoryContext;
+    signal?: AbortSignal;
+}
+/** Synchronous executor used by standalone queries; shares every kernel with asynchronous reads. */
+export declare function applyWindowFunctions(result: QueryResult, windows: readonly WindowSpec[], options?: WindowOptions): QueryResult;
+/** Cooperatively runs window passes so cancellation can arrive while a large partition is active. */
+export declare function applyWindowFunctionsAsync(result: QueryResult, windows: readonly WindowSpec[], options?: WindowOptions): Promise<QueryResult>;
+export {};