@minnowdb/core 0.7.10 → 0.8.0

package/dist/engine/query-generations.js

@@ -0,0 +1,61 @@
+class QueryGenerations {
+  page;
+  #version;
+  #base = null;
+  #tables = /* @__PURE__ */ new Map();
+  #pending = Promise.resolve();
+  constructor(page) {
+    this.page = page;
+  }
+  key(tableIds, version) {
+    const task = this.#pending.then(async () => {
+      if (this.#version !== void 0 && (version ?? -1) < (this.#version ?? -1))
+        return JSON.stringify(["snapshot", version, tableIds]);
+      if (this.#version === void 0)
+        this.#reset(version);
+      if (version !== this.#version) {
+        const tables = new Map(this.#tables);
+        let cursor = this.#version ?? null;
+        let complete = false;
+        for (let pageIndex = 0; pageIndex < 8 && !complete; pageIndex += 1) {
+          const page = await this.page(cursor, 64);
+          for (const manifest of page.records) {
+            if (manifest.previousVersion !== cursor || manifest.version > (version ?? -1))
+              break;
+            for (const id of manifest.changedTableIds)
+              tables.set(id, manifest.version);
+            cursor = manifest.version;
+            if (cursor === version) {
+              complete = true;
+              break;
+            }
+          }
+          if (page.nextCursor === null || tables.size > 4096)
+            break;
+        }
+        if (!complete || tables.size > 4096)
+          this.#reset(version);
+        else {
+          this.#tables.clear();
+          for (const [id, generation] of tables)
+            this.#tables.set(id, generation);
+          this.#version = version;
+        }
+      }
+      return JSON.stringify([
+        this.#base,
+        tableIds.map((id) => [id, this.#tables.get(id) ?? this.#base])
+      ]);
+    });
+    this.#pending = task.then(() => void 0, () => void 0);
+    return task;
+  }
+  #reset(version) {
+    this.#version = version;
+    this.#base = version;
+    this.#tables.clear();
+  }
+}
+export {
+  QueryGenerations
+};

package/dist/engine/query-identity.d.ts

@@ -0,0 +1,3 @@
+/** Type-tagged, length-delimited structural identity. Unlike JSON, it preserves Date vs string,
+ * -0, non-finite numbers, and undefined fields, so deduplication cannot merge distinct plans. */
+export declare function encodeQueryIdentity(value: unknown, ancestors?: Set<object>): string;

package/dist/engine/query-identity.js

@@ -0,0 +1,41 @@
+import { dateMilliseconds } from "../date-value.js";
+function encodeQueryIdentity(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null)
+    return "z";
+  if (typeof value === "undefined")
+    return "u";
+  if (typeof value === "boolean")
+    return value ? "b1" : "b0";
+  if (typeof value === "number") {
+    if (Number.isNaN(value))
+      return "nNaN;";
+    if (Object.is(value, -0))
+      return "n-0;";
+    return `n${String(value)};`;
+  }
+  if (typeof value === "bigint")
+    return `i${String(value)};`;
+  if (typeof value === "string")
+    return `s${String(value.length)}:${value}`;
+  if (value instanceof Date)
+    return `d${String(dateMilliseconds(value))};`;
+  if (typeof value !== "object") {
+    throw new TypeError(`Unsupported query identity value: ${typeof value}`);
+  }
+  if (ancestors.has(value))
+    throw new TypeError("Query identity contains a cycle");
+  ancestors.add(value);
+  let encoded;
+  if (Array.isArray(value)) {
+    encoded = `a${String(value.length)}[${Array.from(value, (item) => encodeQueryIdentity(item, ancestors)).join("")}]`;
+  } else {
+    const record = value;
+    const keys = Object.keys(record).sort();
+    encoded = `o${String(keys.length)}{${keys.map((key) => `${encodeQueryIdentity(key, ancestors)}${encodeQueryIdentity(record[key], ancestors)}`).join("")}}`;
+  }
+  ancestors.delete(value);
+  return encoded;
+}
+export {
+  encodeQueryIdentity
+};

package/dist/engine/query.d.ts

@@ -3,6 +3,7 @@ import type { ColumnDefault, ColumnGenerated, SqlDomain } from "../storage/types
 import type { AggregateName, ComparisonOperator, CompiledQuery, Expression, FtsStats, JoinPlan, Predicate, PredicateOperator, QueryResult, QueryRow, QueryValue, ScalarFunctionName, SelectItem, SelectTail, SetOperator, TableSource, WindowSpec } from "../plan/model.js";
 export type { AggregateName, BinaryOperator, ComparisonOperator, CompiledQuery, Expression, JoinPlan, Predicate, PredicateOperator, QueryResult, QueryRow, QueryValue, RecursiveCte, ScalarFunctionName, SelectItem, SelectTail, SetOperator, TableSource, WindowFrame, WindowFrameBound, WindowFrameExclusion, WindowFunctionName, WindowSpec, } from "../plan/model.js";
 import { QueryMemoryContext, type QueryMemoryUsage } from "./memory.js";
+export { applyWindowFunctions } from "./windows.js";
 import { type ColumnarTable, type AsyncQueryExecutionOptions, type QueryBatchExecutionOptions } from "./vector.js";
 /** Domain metadata for an execution path that has no catalog-backed type information. */
 export declare function unknownColumnDomains(columns: readonly string[]): null[];
@@ -451,6 +452,8 @@ export declare function bindStatementParameters(statement: CompiledStatement, pa
 export type SqlColumnType = "boolean" | "number" | "string" | "datetime";
 export interface SqlColumnSchema {
     name: string;
+    /** An all-NULL expression awaiting a surrounding common SQL type. */
+    unknown?: true;
     type: SqlColumnType;
     /** Exact SQL whole-number domain, physically stored as a safe JavaScript number. */
     integer?: true;
@@ -459,8 +462,8 @@ export interface SqlColumnSchema {
 }
 /**
  * Infers the typed output schema of one select block from typed source schemas. A column whose
- * type cannot be established (for example a bare NULL literal) is rejected explicitly, so a
- * derived table always has concrete column types even when its result is empty.
+ * type is still unknown (a bare NULL literal) carries that fact until a surrounding UNION or
+ * expression provides context. Its all-null physical vector uses string storage meanwhile.
  */
 export declare function inferBlockSchema(plan: CompiledQuery, schemas: ReadonlyMap<string, readonly SqlColumnSchema[]>): SqlColumnSchema[];
 /** Best-effort logical domains for a public result without making execution a new typecheck. */
@@ -631,17 +634,9 @@ export declare function expandFtsColumns(plan: CompiledQuery, searchableColumnsF
  * AVG pass through untouched, and the input is often the compile cache's own object.
  */
 export declare function annotateAvgArgumentScales(plan: CompiledQuery, schemas: ReadonlyMap<string, readonly SqlColumnSchema[]>): CompiledQuery;
-/**
- * Appends window-function columns to an executed inner-block result. Rows sort stably by the
- * hidden partition and ordering aliases with the same comparison semantics as ORDER BY;
- * ROW_NUMBER numbers rows per partition, RANK shares ranks across ordering ties with gaps, and
- * DENSE_RANK shares without gaps. Without OVER ordering every partition row is a peer.
- */
-export declare function applyWindowFunctions(result: QueryResult, windows: readonly WindowSpec[], options?: {
-    copyRows?: boolean;
-}): QueryResult;
 /** Correctness reference retained while the vector executor matures. */
 export declare function executeRowQuery(plan: CompiledQuery, tables: ReadonlyMap<string, DatabaseRow[]>): QueryResult;
+export declare function executeRowQueryInternal(plan: CompiledQuery, tables: ReadonlyMap<string, DatabaseRow[]>, memory?: QueryMemoryContext): QueryResult;
 /** One ORDER BY resolution source: an alias and the columns a wildcard select exposes from it. */
 interface OrderSourceShape {
     readonly alias: string;