@minnowdb/core 0.7.8 → 0.8.0

package/dist/engine/optimizer.js

@@ -1,3 +1,4 @@
+import { encodeQueryIdentity } from "./query-identity.js";
 import { dateIsoString, dateMilliseconds } from "../date-value.js";
 import { crossJoinPlan } from "../plan/model.js";
 import { blockHasRowWindow, blockHasSubqueries, childExpressions, DUAL_TABLE, expressionAliases, forEachBlockExpression, forEachNestedBlock, hasAggregate, isAggregateCall, isScalarFunctionName, mapBlockExpressions, mapChildExpressions, parseQuantified, scalarFunctionNames, scalarFunctionValue, splitCondition, statementDatetimeNames, volatileScalarFunctionNames, transparentProjectionSource, dateTruncValue, integerQuotient } from "./query.js";
@@ -557,7 +558,7 @@ function propagateJoinKeyConstants(block) {
   }
   if (pairs.length === 0)
     return;
-  const signature = (predicate) => JSON.stringify(predicate);
+  const signature = (predicate) => encodeQueryIdentity(predicate);
   const present = new Set(block.predicates.map(signature));
   const implied = [];
   const constantSide = (predicate) => {
@@ -785,9 +786,9 @@ function decorrelateBlock(block, nextAlias) {
     if (!expressionHasCorrelatedSubquery(item.expression))
       continue;
     if (grouped) {
-      const groupedExpressions = new Set(block.groupBy.map((group) => JSON.stringify(group)));
+      const groupedExpressions = new Set(block.groupBy.map((group) => encodeQueryIdentity(group)));
       const outerReferences = correlatedOuterReferences(item.expression);
-      if (containsAggregateCall(item.expression) || outerReferences.some((reference) => !groupedExpressions.has(JSON.stringify({ kind: "column", reference })))) {
+      if (containsAggregateCall(item.expression) || outerReferences.some((reference) => !groupedExpressions.has(encodeQueryIdentity({ kind: "column", reference })))) {
         throw new TypeError("A grouped correlated select-list subquery must reference only GROUP BY columns and cannot be nested inside an aggregate");
       }
     }
@@ -2428,7 +2429,11 @@ function foldExpression(expression) {
         if (folded === null || typeof folded === "string" || typeof folded === "boolean" || folded instanceof Date || typeof folded === "number" && Number.isFinite(folded)) {
           const target = foldedArguments[1];
           const targetWord = expression.name === "CAST" && target?.kind === "literal" && typeof target.value === "string" ? target.value : void 0;
-          const sqlDomain = targetWord?.startsWith("numeric:") === true ? (() => {
+          const first = literalValues[0];
+          const sqlDomain = expression.name === "ARRAY" ? {
+            kind: "array",
+            element: typeof first === "number" ? "DOUBLE" : typeof first === "boolean" ? "BOOLEAN" : first instanceof Date ? "TIMESTAMP" : "TEXT"
+          } : targetWord?.startsWith("numeric:") === true ? (() => {
             const [, precisionWord = "", scaleWord = ""] = targetWord.split(":");
             return {
               kind: "numeric",
@@ -2565,8 +2570,8 @@ function rewriteForInner(expression, source, derived, singleSource) {
     if (containsAggregateOrWindow(item.expression))
       return void 0;
     if (derived.groupBy.length > 0) {
-      const signature = JSON.stringify(item.expression);
-      if (!derived.groupBy.some((group) => JSON.stringify(group) === signature)) {
+      const signature = encodeQueryIdentity(item.expression);
+      if (!derived.groupBy.some((group) => encodeQueryIdentity(group) === signature)) {
         return void 0;
       }
     }

package/dist/engine/query-cache.js

@@ -1,3 +1,4 @@
+import { encodeQueryIdentity } from "./query-identity.js";
 import { copyDate, dateMilliseconds } from "../date-value.js";
 import { estimateValuesBytes } from "./byte-estimates.js";
 import { copyQueryResultExternalization } from "./query.js";
@@ -7,19 +8,7 @@ function queryResultMemoKey(sql, params) {
   return JSON.stringify([sql, params.map(encodeParameter)]);
 }
 function planMemoKey(plan) {
-  return JSON.stringify(plan, (_key, value) => {
-    if (value instanceof Date)
-      return { $date: dateMilliseconds(value) };
-    if (typeof value === "bigint")
-      return { $bigint: value.toString() };
-    if (typeof value === "number") {
-      if (Object.is(value, -0))
-        return { $number: "-0" };
-      if (!Number.isFinite(value))
-        return { $number: String(value) };
-    }
-    return value;
-  });
+  return encodeQueryIdentity(plan);
 }
 function copyQueryResult(result) {
   const columns = result.columns;

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

@@ -0,0 +1,8 @@
+import type { Manifest, StoragePage } from "../storage/types.js";
+/** Bounded, process-local table generations proved by a contiguous durable commit history. */
+export declare class QueryGenerations {
+    #private;
+    readonly page: (after: number | null, limit: number) => Promise<StoragePage<Manifest, number>>;
+    constructor(page: (after: number | null, limit: number) => Promise<StoragePage<Manifest, number>>);
+    key(tableIds: readonly string[], version: number | null): Promise<string>;
+}

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;