@minnowdb/core 0.7.2 → 0.7.7

package/dist/engine/optimizer.js

@@ -1,6 +1,6 @@
 import { dateIsoString, dateMilliseconds } from "../date-value.js";
 import { crossJoinPlan } from "../plan/model.js";
-import { blockHasSubqueries, childExpressions, DUAL_TABLE, expressionAliases, forEachBlockExpression, forEachNestedBlock, hasAggregate, isAggregateCall, isScalarFunctionName, mapBlockExpressions, mapChildExpressions, parseQuantified, scalarFunctionNames, scalarFunctionValue, splitCondition, statementDatetimeNames, volatileScalarFunctionNames, transparentProjectionSource, dateTruncValue } from "./query.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";
 import { concatenatedSqlValue, isSqlDomainValue } from "./sql-domains.js";
 import { simpleScalarFunctions } from "./sql-functions.js";
 function optimizePlan(plan, options = {}) {
@@ -199,7 +199,7 @@ function decorrelateLateralSources(block) {
     const keyAliases = keys.map((_, index) => `\0lateral_key_${String(index + 1)}`);
     const grouped = inner.groupBy.length > 0;
     const globalAggregate = !grouped && inner.select.some((item) => containsAggregateCall(item.expression)) && inner.having.length === 0;
-    const ranked = inner.limit !== void 0 || inner.limitParameter !== void 0 || inner.offset !== void 0 || inner.offsetParameter !== void 0;
+    const ranked = blockHasRowWindow(inner);
     const cross = join.on?.kind === "condition" && join.on.operator === "=" && join.on.left.kind === "literal" && join.on.left.value === 1 && join.on.right.kind === "literal" && join.on.right.value === 1 || join.on?.kind === "literal" && join.on.value === true;
     if (grouped || globalAggregate || ranked || inner.having.length > 0) {
       if (!keys.every((key) => key.operator === "=")) {
@@ -1409,7 +1409,7 @@ function decorrelateScalarSubquery(block, subquery, scope, nextAlias) {
   if (passthrough !== void 0)
     return passthrough;
   const item = inner.select[0];
-  if (inner.select.length !== 1 || item === void 0 || !isAggregateCall(item.expression) || inner.groupBy.length > 0 || inner.having.length > 0 || inner.orderBy.length > 0 || inner.limit !== void 0 || inner.offset !== void 0 || !canExtractCorrelation(inner, scope, "scalar", true)) {
+  if (inner.select.length !== 1 || item === void 0 || !isAggregateCall(item.expression) || inner.groupBy.length > 0 || inner.having.length > 0 || inner.orderBy.length > 0 || blockHasRowWindow(inner) || !canExtractCorrelation(inner, scope, "scalar", true)) {
     return decorrelateGeneralScalar(block, inner, scope, nextAlias);
   }
   const previewKeys = extractCorrelation(structuredClone(inner), scope, "scalar", true);
@@ -1432,7 +1432,10 @@ function decorrelateScalarSubquery(block, subquery, scope, nextAlias) {
       })),
       { expression: item.expression, alias: correlationValueAlias }
     ],
-    predicates: inner.predicates,
+    predicates: [
+      ...inner.predicates,
+      ...mirrorPredicatesThroughKeys(outerProbePredicates(block, keys.map((key) => key.outer), nextAlias.resolvedNames), keys)
+    ],
     groupBy: keys.map((key) => key.inner),
     having: [],
     orderBy: []
@@ -1449,7 +1452,7 @@ function decorrelateScalarSubquery(block, subquery, scope, nextAlias) {
 }
 function scalarPassthrough(inner) {
   const item = inner.select[0];
-  if (inner.base.table !== DUAL_TABLE || inner.base.derived !== void 0 || inner.joins.length > 0 || inner.select.length !== 1 || item === void 0 || inner.predicates.length > 0 || inner.groupBy.length > 0 || inner.having.length > 0 || inner.orderBy.length > 0 || inner.offset !== void 0 || inner.limit !== void 0 && inner.limit < 1) {
+  if (inner.base.table !== DUAL_TABLE || inner.base.derived !== void 0 || inner.joins.length > 0 || inner.select.length !== 1 || item === void 0 || inner.predicates.length > 0 || inner.groupBy.length > 0 || inner.having.length > 0 || inner.orderBy.length > 0 || inner.offset !== void 0 || inner.offsetParameter !== void 0 || inner.limitParameter !== void 0 || inner.limit !== void 0 && inner.limit < 1) {
     return void 0;
   }
   return structuredClone(item.expression);
@@ -1463,7 +1466,7 @@ function scalarShape(inner) {
   let expression = structuredClone(item.expression);
   for (; ; ) {
     const derived = rows.base.derived;
-    if (derived === void 0 || rows.joins.length > 0 || rows.predicates.length > 0 || rows.groupBy.length > 0 || rows.having.length > 0 || rows.orderBy.length > 0 || rows.limit !== void 0 || rows.limitParameter !== void 0 || rows.offset !== void 0 || rows.offsetParameter !== void 0 || rows.distinctWildcard === true) {
+    if (derived === void 0 || rows.joins.length > 0 || rows.predicates.length > 0 || rows.groupBy.length > 0 || rows.having.length > 0 || rows.orderBy.length > 0 || blockHasRowWindow(rows) || rows.distinctWildcard === true) {
       break;
     }
     expression = inlineDerivedProjection(expression, rows.base.alias, derived);
@@ -1656,7 +1659,7 @@ function decorrelateGeneralScalar(block, inner, scope, nextAlias) {
     orderBy: []
   };
   let finalRows = matched;
-  if (rows.limit !== void 0 || rows.limitParameter !== void 0 || rows.offset !== void 0 || rows.offsetParameter !== void 0) {
+  if (blockHasRowWindow(rows)) {
     const rankedAlias = nextAlias();
     const rankedTable = nextAlias();
     const ranked = {
@@ -2022,6 +2025,34 @@ function outerProbeBlock(block, keys, resolvedNames) {
   return outerProbeBlockForExpressions(block, keys.map((key) => key.outer), resolvedNames);
 }
 function outerProbeBlockForExpressions(block, outerExpressions, resolvedNames) {
+  const prefix = outerProbePrefix(block, outerExpressions, resolvedNames);
+  const expressions = outerExpressions.map((expression) => structuredClone(expression));
+  return {
+    sql: "(correlation probes)",
+    base: structuredClone(block.base),
+    joins: structuredClone(block.joins.slice(0, prefix.lastSource)),
+    select: expressions.map((expression, index) => ({
+      expression,
+      alias: correlationProbeAlias(index)
+    })),
+    predicates: probePredicates(block, prefix.retained, prefix.retainsAll),
+    groupBy: expressions,
+    having: [],
+    orderBy: []
+  };
+}
+function outerProbePredicates(block, outerExpressions, resolvedNames) {
+  const sources = /* @__PURE__ */ new Set([block.base.alias, ...block.joins.map((join) => join.alias)]);
+  for (const expression of outerExpressions) {
+    for (const alias of expressionAliases(expression)) {
+      if (!sources.has(alias))
+        return [];
+    }
+  }
+  const prefix = outerProbePrefix(block, outerExpressions, resolvedNames);
+  return probePredicates(block, prefix.retained, prefix.retainsAll);
+}
+function outerProbePrefix(block, outerExpressions, resolvedNames) {
   const sources = [block.base, ...block.joins];
   const sourceIndexes = outerExpressions.flatMap((expression) => {
     const aliases = [...expressionAliases(expression)];
@@ -2035,22 +2066,9 @@ function outerProbeBlockForExpressions(block, outerExpressions, resolvedNames) {
     });
   });
   const lastSource = Math.max(...sourceIndexes);
-  const expressions = outerExpressions.map((expression) => structuredClone(expression));
   const retained = new Set(sources.slice(0, lastSource + 1).map((source) => source.alias));
   const retainsAll = resolvedNames && lastSource === sources.length - 1;
-  return {
-    sql: "(correlation probes)",
-    base: structuredClone(block.base),
-    joins: structuredClone(block.joins.slice(0, lastSource)),
-    select: expressions.map((expression, index) => ({
-      expression,
-      alias: correlationProbeAlias(index)
-    })),
-    predicates: probePredicates(block, retained, retainsAll),
-    groupBy: expressions,
-    having: [],
-    orderBy: []
-  };
+  return { lastSource, retained, retainsAll };
 }
 function probePredicates(block, retained, retainsAll) {
   return block.predicates.filter((predicate) => probeSafeExpression(predicate.left, retained, retainsAll) && probeSafeExpression(predicate.right, retained, retainsAll)).map((predicate) => structuredClone(predicate));
@@ -2387,14 +2405,15 @@ function foldExpression(expression) {
     const left = foldExpression(expression.left);
     const right = foldExpression(expression.right);
     if (left.kind === "literal" && right.kind === "literal") {
-      const folded = foldBinary(expression.operator, left.value, right.value);
+      const folded = foldBinary(expression.operator, left.value, right.value, expression.integer === true);
       if (folded !== void 0) {
         const domain = left.sqlDomain?.kind === "numeric" || right.sqlDomain?.kind === "numeric" ? { kind: "numeric" } : void 0;
         return {
           kind: "literal",
           value: folded,
           ...isSqlDomainValue(folded) ? { internalSqlValue: true } : {},
-          ...domain === void 0 ? {} : { sqlDomain: domain }
+          ...domain === void 0 ? {} : { sqlDomain: domain },
+          ...left.decimal === true || right.decimal === true ? { decimal: true } : {}
         };
       }
     }
@@ -2466,7 +2485,7 @@ function foldExpression(expression) {
   }
   return expression;
 }
-function foldBinary(operator, leftValue, rightValue) {
+function foldBinary(operator, leftValue, rightValue, integer = false) {
   if (leftValue === null || rightValue === null)
     return null;
   if (operator === "||") {
@@ -2487,6 +2506,9 @@ function foldBinary(operator, leftValue, rightValue) {
   const right = rightValue instanceof Date ? dateMilliseconds(rightValue) : rightValue;
   if ((operator === "/" || operator === "%") && right === 0)
     return null;
+  if (operator === "/" && integer && typeof left === "number" && typeof right === "number") {
+    return integerQuotient(left, right);
+  }
   const result = operator === "+" ? left + right : operator === "-" ? left - right : operator === "*" ? left * right : operator === "%" ? left % right : left / right;
   return Number.isFinite(result) ? result : void 0;
 }
@@ -2508,7 +2530,7 @@ function pushPredicatesIntoDerived(block) {
 function pushdownTarget(predicate, sources, singleSource) {
   for (const source of sources) {
     const derived = source.derived;
-    if (derived === void 0 || derived.limit !== void 0)
+    if (derived === void 0 || blockHasRowWindow(derived))
       continue;
     const left = rewriteForInner(predicate.left, source, derived, singleSource);
     if (left === void 0)
@@ -2740,7 +2762,7 @@ function referencedOutputAliases(block, source, singleSource) {
 }
 function combineDerivedLimit(block) {
   const derived = block.base.derived;
-  if (derived === void 0 || block.joins.length > 0 || block.predicates.length > 0 || block.groupBy.length > 0 || block.having.length > 0 || block.orderBy.length > 0 || block.limit === void 0 || block.offset !== void 0 || derived.offset !== void 0) {
+  if (derived === void 0 || block.joins.length > 0 || block.predicates.length > 0 || block.groupBy.length > 0 || block.having.length > 0 || block.orderBy.length > 0 || block.limit === void 0 || block.offset !== void 0 || block.offsetParameter !== void 0 || derived.offset !== void 0 || derived.offsetParameter !== void 0 || derived.limitParameter !== void 0) {
     return;
   }
   derived.limit = Math.min(derived.limit ?? Number.MAX_SAFE_INTEGER, block.limit);

package/dist/engine/query.d.ts

@@ -135,6 +135,13 @@ export type InsertValue = QueryValue | DefaultInsertValue | DeferredInsertExpres
 };
 export declare function isDefaultInsertValue(value: InsertValue): value is DefaultInsertValue;
 export declare function isDeferredInsertExpression(value: InsertValue): value is DeferredInsertExpression;
+/** The FROM / USING sources of an UPDATE or DELETE, joined to the target as a cross product. */
+export interface MutationSources {
+    base: TableSource;
+    joins: JoinPlan[];
+    /** ON conditions of parenthesized join groups, which filter the product like WHERE. */
+    predicates: Predicate[];
+}
 export type CompiledStatement = {
     kind: "select";
     sql: string;
@@ -189,6 +196,12 @@ export type CompiledStatement = {
         operator: PredicateOperator;
         right: Expression;
     }>;
+    /**
+     * `UPDATE t SET … FROM sources WHERE …`: the extra sources the assignments and predicates
+     * may read, joined to the target as PostgreSQL joins them. A target row matched by several
+     * source rows is updated once, from the first match.
+     */
+    from?: MutationSources;
     returning?: string[] | "*";
     /** RETURNING items that are not plain columns, evaluated over the affected rows. */
     returningItems?: ReturningItem[];
@@ -202,6 +215,8 @@ export type CompiledStatement = {
         operator: PredicateOperator;
         right: Expression;
     }>;
+    /** `DELETE FROM t USING sources WHERE …`: the extra sources the predicates may read. */
+    from?: MutationSources;
     returning?: string[] | "*";
     /** RETURNING items that are not plain columns, evaluated over the affected rows. */
     returningItems?: ReturningItem[];
@@ -303,6 +318,19 @@ export type CompiledStatement = {
     view: string;
     ifExists?: boolean;
     parameterCount?: number;
+}
+/** A session setting, accepted and ignored: `SET name TO value`, `RESET name`. */
+ | {
+    kind: "set";
+    action: "set" | "reset";
+    name: string;
+    parameterCount?: number;
+}
+/** `SHOW name`: the engine's value for a PostgreSQL setting, as one row. */
+ | {
+    kind: "show";
+    name: string;
+    parameterCount?: number;
 } | {
     kind: "transaction";
     action: "begin" | "commit" | "rollback" | "savepoint" | "rollback-to" | "release";
@@ -487,6 +515,64 @@ export declare function mapChildExpressions(expression: Expression, map: (child:
 export declare function forEachBlockExpression(block: CompiledQuery, visit: (expression: Expression) => void): void;
 /** Visits every nested block of one block's sources (derived, union, windowed, recursive). */
 export declare function forEachNestedBlock(block: CompiledQuery, visit: (nested: CompiledQuery) => void): void;
+/**
+ * Whether an expression is integer-typed the way PostgreSQL types it: an INTEGER, BIGINT, or
+ * SMALLINT column, an integer constant, COUNT, an integer CAST, SUM/MIN/MAX/ABS over an
+ * integer, MOD over integers, a CASE/COALESCE/NULLIF/GREATEST/LEAST whose every branch is an
+ * integer, or `+ - * / %` over two integers. A bound parameter takes the type of its integer
+ * partner, as PostgreSQL infers `qty / $1`. A column the caller cannot type is not an integer,
+ * so the compiler's static answer only ever widens once the catalog is known.
+ */
+export declare function integerTypedExpression(expression: Expression, columnInteger?: (reference: string) => boolean, tableIntegerColumns?: (table: string) => IntegerColumns | undefined): boolean;
+/** A table's integer columns, or `true` when every column may be one (the bind-time probe). */
+export type IntegerColumns = ReadonlySet<string> | true;
+/** PostgreSQL's integer `/`: truncation toward zero, NULL for a zero divisor. */
+export declare function integerQuotient(left: number, right: number): number | null;
+/**
+ * Marks every `/` in one expression whose operands are integers, subquery blocks included, so
+ * that every evaluator truncates it the way PostgreSQL does. Children are marked first: the
+ * parent's typing reads the children, and `(a / b) / c` is integer only once `a / b` is.
+ */
+export declare function annotateIntegerDivision(expression: Expression, columnInteger?: (reference: string) => boolean, tableIntegerColumns?: (table: string) => IntegerColumns | undefined): void;
+/**
+ * Marks integer division throughout a plan, nested blocks first. Without a catalog only
+ * constants, COUNT, and integer CASTs type as integers; with one, INTEGER columns do too, and
+ * a derived source's outputs follow from its own select list.
+ */
+export declare function annotatePlanIntegerDivision(plan: CompiledQuery, tableIntegerColumns?: (table: string) => IntegerColumns | undefined): void;
+/**
+ * Whether catalog binding could still mark a division in this plan: a `/` not yet marked whose
+ * operands would be integers if every column were one. Plans without such a node — the common
+ * case — need no clone at bind time.
+ */
+export declare function planMayHaveIntegerDivision(plan: CompiledQuery): boolean;
+/**
+ * PostgreSQL folds an unquoted identifier to lower case, so `SELECT ID FROM USERS` reads the
+ * table `users` and its column `id`. Minnow keeps the written spelling and resolves it exactly,
+ * which is what a catalog created through the typed API (where `Orders` is a legal name)
+ * relies on. This pass gives both: a table or column name that resolves exactly is left alone,
+ * and one that does not is read as the unique catalog name that matches it case-insensitively.
+ * Only plain tables and their columns are folded; derived sources expose their aliases as
+ * written. Returns the same plan when nothing needed folding, so cached plans stay untouched.
+ */
+export declare function foldIdentifierCase(plan: CompiledQuery, tables: ReadonlyMap<string, readonly string[]>): CompiledQuery;
+/**
+ * A table alias used as a value — `json_agg(agg)`, `to_json(obj)`, `row_to_json(u)` — is the
+ * row as a JSON object in PostgreSQL. The reference is expanded here, once the catalog is
+ * known, into JSON_OBJECT over the source's columns in declaration order, so the aggregate and
+ * constructor paths see a scalar document. Only an alias of the same block that names no column
+ * expands; a bare name that is also a column stays that column.
+ */
+export declare function expandRowReferences(plan: CompiledQuery, tableColumns: (table: string) => readonly string[] | undefined): CompiledQuery;
+/**
+ * PostgreSQL's functional-dependency rule (SQL:2003 T301): once a table's whole primary key is
+ * in GROUP BY, any other column of that table may appear ungrouped, because the key determines
+ * the row. Minnow's executors group by the listed expressions only, so such a column is added
+ * to GROUP BY here — the groups are unchanged, since the key already separates every row — and
+ * the containment check then accepts it. Only plain table sources with a declared key
+ * qualify; a derived table exposes no key. Returns the same plan when nothing needed adding.
+ */
+export declare function extendGroupByWithKeyDependents(plan: CompiledQuery, keyColumns: (table: string) => readonly string[] | undefined, tableColumns?: (table: string) => readonly string[] | undefined): CompiledQuery;
 /**
  * Rewrites every expression slot of one block in place, the writing counterpart to
  * `forEachBlockExpression`. The mapper receives each root expression and returns its
@@ -650,6 +736,11 @@ interface SelectBlockParts {
     /** GROUP BY GROUPING SETS/ROLLUP/CUBE: the grouping lists to union; groupBy is then unused. */
     groupingSets?: Expression[][];
 }
+/**
+ * The execution-time half of unifyGroupedReferences for a block over several sources: an
+ * unqualified name is the column of the one source that has it, which only the schemas know.
+ */
+export declare function unifyPlanGroupedReferences(plan: CompiledQuery, columnsOf: (tableName: string) => readonly string[] | undefined): CompiledQuery;
 export declare function assembleSelectBlock(parts: SelectBlockParts, nextSequence: () => number): CompiledQuery;
 /**
  * Turns every source carrying a column alias list into a derived projection that renames the
@@ -688,6 +779,13 @@ export declare function expandNaturalJoins(plan: CompiledQuery, columnsOf: (tabl
 export declare function expandSourceColumnAliases(plan: CompiledQuery, columnsOf: (tableName: string) => readonly string[] | undefined): CompiledQuery;
 /** Wraps compound members into the set-operation source the executor folds left to right. */
 export declare function compoundSelectBlock(sql: string, blocks: CompiledQuery[], ops: SetOperator[], tail: SelectTail, nextSequence: () => number): CompiledQuery;
+/**
+ * True when a block trims its rows with LIMIT, OFFSET, or a placeholder for either. A rewrite
+ * that moves a filter or a limit across such a block changes which rows the window sees, so every
+ * "does this block page its rows" guard goes through here: reading only the literal fields lets
+ * `LIMIT ?`, `OFFSET ?`, and a bare `OFFSET n` slip past and the predicate run before the window.
+ */
+export declare function blockHasRowWindow(block: CompiledQuery): boolean;
 /**
  * Detects a pure projection wrapper over one derived block — the shape the ORDER-BY-expression
  * desugar emits: no joins, filters, grouping, ordering, or paging of its own, and every select