@minnowdb/core 0.7.0 → 0.7.2

package/dist/engine/memory.js

@@ -1,120 +1,118 @@
-/** Finite default for every public engine execution path. */
-export const DEFAULT_QUERY_MEMORY_BUDGET_BYTES = 64 * 1024 * 1024;
-export class QueryMemoryBudgetError extends Error {
-    label;
-    requestedBytes;
-    usedBytes;
-    budgetBytes;
-    name = "QueryMemoryBudgetError";
-    constructor(label, requestedBytes, usedBytes, budgetBytes) {
-        super(`${label} requested ${String(requestedBytes)} accounted bytes with ${String(usedBytes)} of ${String(budgetBytes)} bytes already reserved`);
-        this.label = label;
-        this.requestedBytes = requestedBytes;
-        this.usedBytes = usedBytes;
-        this.budgetBytes = budgetBytes;
-    }
+const DEFAULT_QUERY_MEMORY_BUDGET_BYTES = 64 * 1024 * 1024;
+class QueryMemoryBudgetError extends Error {
+  label;
+  requestedBytes;
+  usedBytes;
+  budgetBytes;
+  name = "QueryMemoryBudgetError";
+  constructor(label, requestedBytes, usedBytes, budgetBytes) {
+    super(`${label} requested ${String(requestedBytes)} accounted bytes with ${String(usedBytes)} of ${String(budgetBytes)} bytes already reserved`);
+    this.label = label;
+    this.requestedBytes = requestedBytes;
+    this.usedBytes = usedBytes;
+    this.budgetBytes = budgetBytes;
+  }
 }
-export class QueryMemoryContext {
-    #state;
-    #parent;
-    #children = new Set();
-    #reservations = new Set();
-    #talliedBytes = 0;
-    #closed = false;
-    constructor(budgetBytes = DEFAULT_QUERY_MEMORY_BUDGET_BYTES, parent) {
-        if (!Number.isSafeInteger(budgetBytes) || budgetBytes < 0) {
-            throw new RangeError("Query memory budget must be a non-negative safe integer");
-        }
-        this.#parent = parent;
-        if (parent === undefined)
-            this.#state = { budgetBytes, usedBytes: 0, peakBytes: 0 };
-        else {
-            this.#state = parent.#state;
-            parent.#children.add(this);
-        }
-    }
-    get usage() {
-        return { ...this.#state };
-    }
-    createChild() {
-        this.#assertOpen();
-        return new QueryMemoryContext(this.#state.budgetBytes, this);
-    }
-    reserve(bytes, label) {
-        this.#assertOpen();
-        validateMemoryBytes(bytes, "Query memory reservation");
-        const nextUsed = this.#state.usedBytes + bytes;
-        if (!Number.isSafeInteger(nextUsed) || nextUsed > this.#state.budgetBytes) {
-            throw new QueryMemoryBudgetError(label, bytes, this.#state.usedBytes, this.#state.budgetBytes);
-        }
-        this.#state.usedBytes = nextUsed;
-        this.#state.peakBytes = Math.max(this.#state.peakBytes, nextUsed);
-        const reservation = new QueryMemoryReservation(this, bytes);
-        this.#reservations.add(reservation);
-        return reservation;
+class QueryMemoryContext {
+  #state;
+  #parent;
+  #children = /* @__PURE__ */ new Set();
+  #reservations = /* @__PURE__ */ new Set();
+  #talliedBytes = 0;
+  #closed = false;
+  constructor(budgetBytes = DEFAULT_QUERY_MEMORY_BUDGET_BYTES, parent) {
+    if (!Number.isSafeInteger(budgetBytes) || budgetBytes < 0) {
+      throw new RangeError("Query memory budget must be a non-negative safe integer");
     }
-    /**
-     * Reserves bytes that live until this context closes, without a per-call reservation object.
-     * The hot accumulation paths (result rows, spill pages) reserve once per row; tracking each
-     * row as a retained `QueryMemoryReservation` in a Set costs O(result rows) live objects on
-     * top of the rows themselves. Tallied bytes share the same budget and error semantics as
-     * `reserve` and are released together when the context closes.
-     */
-    tally(bytes, label) {
-        this.#assertOpen();
-        validateMemoryBytes(bytes, "Query memory reservation");
-        const nextUsed = this.#state.usedBytes + bytes;
-        if (!Number.isSafeInteger(nextUsed) || nextUsed > this.#state.budgetBytes) {
-            throw new QueryMemoryBudgetError(label, bytes, this.#state.usedBytes, this.#state.budgetBytes);
-        }
-        this.#state.usedBytes = nextUsed;
-        this.#state.peakBytes = Math.max(this.#state.peakBytes, nextUsed);
-        this.#talliedBytes += bytes;
+    this.#parent = parent;
+    if (parent === void 0)
+      this.#state = { budgetBytes, usedBytes: 0, peakBytes: 0 };
+    else {
+      this.#state = parent.#state;
+      parent.#children.add(this);
     }
-    close() {
-        if (this.#closed)
-            return;
-        this.#closed = true;
-        for (const child of [...this.#children])
-            child.close();
-        for (const reservation of [...this.#reservations])
-            reservation.release();
-        this.#state.usedBytes -= this.#talliedBytes;
-        this.#talliedBytes = 0;
-        if (this.#state.usedBytes < 0)
-            throw new Error("Query memory accounting underflow");
-        if (this.#parent !== undefined)
-            this.#parent.#children.delete(this);
+  }
+  get usage() {
+    return { ...this.#state };
+  }
+  createChild() {
+    this.#assertOpen();
+    return new QueryMemoryContext(this.#state.budgetBytes, this);
+  }
+  reserve(bytes, label) {
+    this.#assertOpen();
+    validateMemoryBytes(bytes, "Query memory reservation");
+    const nextUsed = this.#state.usedBytes + bytes;
+    if (!Number.isSafeInteger(nextUsed) || nextUsed > this.#state.budgetBytes) {
+      throw new QueryMemoryBudgetError(label, bytes, this.#state.usedBytes, this.#state.budgetBytes);
     }
-    release(reservation, bytes) {
-        if (!this.#reservations.delete(reservation))
-            return;
-        this.#state.usedBytes -= bytes;
-        if (this.#state.usedBytes < 0)
-            throw new Error("Query memory accounting underflow");
-    }
-    #assertOpen() {
-        if (this.#closed)
-            throw new Error("Query memory context is closed");
+    this.#state.usedBytes = nextUsed;
+    this.#state.peakBytes = Math.max(this.#state.peakBytes, nextUsed);
+    const reservation = new QueryMemoryReservation(this, bytes);
+    this.#reservations.add(reservation);
+    return reservation;
+  }
+  tally(bytes, label) {
+    this.#assertOpen();
+    validateMemoryBytes(bytes, "Query memory reservation");
+    const nextUsed = this.#state.usedBytes + bytes;
+    if (!Number.isSafeInteger(nextUsed) || nextUsed > this.#state.budgetBytes) {
+      throw new QueryMemoryBudgetError(label, bytes, this.#state.usedBytes, this.#state.budgetBytes);
     }
+    this.#state.usedBytes = nextUsed;
+    this.#state.peakBytes = Math.max(this.#state.peakBytes, nextUsed);
+    this.#talliedBytes += bytes;
+  }
+  close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    for (const child of [...this.#children])
+      child.close();
+    for (const reservation of [...this.#reservations])
+      reservation.release();
+    this.#state.usedBytes -= this.#talliedBytes;
+    this.#talliedBytes = 0;
+    if (this.#state.usedBytes < 0)
+      throw new Error("Query memory accounting underflow");
+    if (this.#parent !== void 0)
+      this.#parent.#children.delete(this);
+  }
+  release(reservation, bytes) {
+    if (!this.#reservations.delete(reservation))
+      return;
+    this.#state.usedBytes -= bytes;
+    if (this.#state.usedBytes < 0)
+      throw new Error("Query memory accounting underflow");
+  }
+  #assertOpen() {
+    if (this.#closed)
+      throw new Error("Query memory context is closed");
+  }
 }
-export class QueryMemoryReservation {
-    #context;
-    bytes;
-    #released = false;
-    constructor(context, bytes) {
-        this.#context = context;
-        this.bytes = bytes;
-    }
-    release() {
-        if (this.#released)
-            return;
-        this.#released = true;
-        this.#context.release(this, this.bytes);
-    }
+class QueryMemoryReservation {
+  #context;
+  bytes;
+  #released = false;
+  constructor(context, bytes) {
+    this.#context = context;
+    this.bytes = bytes;
+  }
+  release() {
+    if (this.#released)
+      return;
+    this.#released = true;
+    this.#context.release(this, this.bytes);
+  }
 }
 function validateMemoryBytes(bytes, label) {
-    if (!Number.isSafeInteger(bytes) || bytes < 0) {
-        throw new RangeError(`${label} must be a non-negative safe integer`);
-    }
+  if (!Number.isSafeInteger(bytes) || bytes < 0) {
+    throw new RangeError(`${label} must be a non-negative safe integer`);
+  }
 }
+export {
+  DEFAULT_QUERY_MEMORY_BUDGET_BYTES,
+  QueryMemoryBudgetError,
+  QueryMemoryContext,
+  QueryMemoryReservation
+};

package/dist/engine/optimizer.d.ts

@@ -5,7 +5,25 @@ import { type CompiledQuery } from "./query.js";
  * The optimizer runs before subquery resolution, so subquery blocks optimize recursively and
  * predicates containing subqueries stay self-contained when they move.
  */
-export declare function optimizePlan(plan: CompiledQuery): CompiledQuery;
+export declare function optimizePlan(plan: CompiledQuery, options?: OptimizeOptions): CompiledQuery;
+export interface OptimizeOptions {
+    /**
+     * Every unqualified column name in every subquery has been resolved against its scopes, so
+     * one that remains is local to its block. Compilation has no catalog and cannot know whether
+     * `WHERE region = home_region` inside a subquery reads the subquery's table or the enclosing
+     * query's, so it holds back the rewrites that would move such a name into a derived block —
+     * an uncorrelated `IN (SELECT …)` becoming a join, an unqualified outer predicate entering a
+     * correlation probe. The database applies them after `qualifyCorrelatedReferences`.
+     */
+    readonly resolvedNames?: boolean;
+}
+/**
+ * The bind-time half of the calendar rewrite. Compilation runs before parameters exist, so
+ * `DATE_TRUNC('day', col) = ?` reaches execution as a per-row call over the whole scan; once
+ * the placeholder is a Date literal the same range rewrite applies. Walks every block the
+ * optimizer would have — nested sources and subquery blocks included.
+ */
+export declare function rewriteBoundCalendarEqualities(plan: CompiledQuery): void;
 /**
  * Resolves an unqualified column in a nested block against the nearest enclosing query scope
  * when that name does not exist in the nested block itself. Compilation has no catalog, so this