@minnowdb/core 0.7.1 → 0.7.5

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);
@@ -1494,14 +1497,17 @@ function scalarOrderExpression(expression, rows) {
   const matches = rows.select.filter((item) => item.alias === expression.reference);
   return matches.length === 1 ? structuredClone(matches[0]?.expression ?? expression) : structuredClone(expression);
 }
-function emptyScalarExpression(expression) {
+function emptyScalarExpression(expression, preservedColumns = /* @__PURE__ */ new Set()) {
   if (isAggregateCall(expression)) {
     return { kind: "literal", value: expression.name === "COUNT" ? 0 : null };
   }
-  if (expression.kind === "column" || expression.kind === "wildcard") {
+  if (expression.kind === "column") {
+    return preservedColumns.has(expression.reference) ? structuredClone(expression) : { kind: "literal", value: null };
+  }
+  if (expression.kind === "wildcard") {
     return { kind: "literal", value: null };
   }
-  return mapChildExpressions(expression, emptyScalarExpression);
+  return mapChildExpressions(expression, (child) => emptyScalarExpression(child, preservedColumns));
 }
 function decorrelateGeneralScalar(block, inner, scope, nextAlias) {
   const shape = scalarShape(inner);
@@ -1512,14 +1518,44 @@ function decorrelateGeneralScalar(block, inner, scope, nextAlias) {
   if (rows.limitWithTies === true && rows.orderBy.length === 0) {
     throw new TypeError("A correlated scalar WITH TIES query requires ORDER BY");
   }
-  const keys = extractCorrelation(rows, scope, "scalar", true);
-  const outerExpressions = keys.map((key) => structuredClone(key.outer));
+  const expressionOutside = [];
+  collectExpressionOutsideReferences(shape.expression, /* @__PURE__ */ new Set([rows.base.alias, ...rows.joins.map((join) => join.alias)]), expressionOutside);
+  const probeLifted = expressionOutside.length > 0 || !canExtractCorrelation(rows, scope, "scalar", true);
+  const references = probeLifted ? probeOuterReferences(rows, expressionOutside, scope, "scalar") : [];
+  const keys = probeLifted ? takeCorrelationPredicates(rows, scope, true) : extractCorrelation(rows, scope, "scalar", true);
+  const outerExpressions = probeLifted ? references.map((reference) => ({ kind: "column", reference })) : keys.map((key) => structuredClone(key.outer));
+  const originalExpression = structuredClone(shape.expression);
   const probes = outerProbeBlockForExpressions(block, outerExpressions, nextAlias.resolvedNames);
   const probesAlias = nextAlias();
   const probeReferences = outerExpressions.map((_, index) => ({
     kind: "column",
     reference: `${probesAlias}.${correlationProbeAlias(index)}`
   }));
+  if (probeLifted) {
+    const replacements = new Map(references.map((reference, index) => [reference, probeReferences[index] ?? null]));
+    replacePlanReferences(rows, replacements);
+    shape.expression = replaceExpressionReferences(shape.expression, replacements);
+    const source = { table: probesAlias, alias: probesAlias, derived: probes };
+    const missingProbe = { kind: "literal", value: null };
+    const keyProbes = keys.map((key) => {
+      const reference = key.outer.kind === "column" ? key.outer.reference : "";
+      return probeReferences[references.indexOf(reference)] ?? missingProbe;
+    });
+    const keysReadBase = keys.every((key) => {
+      const parts = key.inner.kind === "column" ? key.inner.reference.split(".") : [];
+      return parts.length === 1 || parts[0] === rows.base.alias;
+    });
+    if (keys.length > 0 && keysReadBase) {
+      rows.joins.unshift(generalCorrelationJoin(probesAlias, probes, keys.map((key) => key.inner), keyProbes, keys.map((key) => key.operator)));
+    } else {
+      rows.joins.unshift(crossJoinPlan(source));
+      rows.predicates.push(...keys.map((key, index) => ({
+        left: key.inner,
+        operator: key.operator,
+        right: keyProbes[index] ?? missingProbe
+      })));
+    }
+  }
   const finalRowsAlias = nextAlias();
   const projected = [];
   const project = (expression, alias) => {
@@ -1556,6 +1592,15 @@ function decorrelateGeneralScalar(block, inner, scope, nextAlias) {
       return rewritten;
     }
     if (expression.kind === "column" || expression.kind === "wildcard") {
+      if (probeLifted && expression.kind === "column") {
+        const index = probeReferences.findIndex((reference) => reference.kind === "column" && reference.reference === expression.reference);
+        if (index >= 0) {
+          return {
+            kind: "column",
+            reference: `${finalRowsAlias}.${correlationKeyAlias(index)}`
+          };
+        }
+      }
       throw new TypeError("A correlated scalar aggregate cannot select an ungrouped inner column");
     }
     if (expression.kind === "subquery" || expression.kind === "exists") {
@@ -1575,18 +1620,21 @@ function decorrelateGeneralScalar(block, inner, scope, nextAlias) {
     base: rows.base,
     joins: rows.joins,
     select: [
-      ...keys.map((key, index) => ({
-        expression: key.inner,
+      ...(probeLifted ? probeReferences : keys.map((key) => key.inner)).map((expression, index) => ({
+        expression,
         alias: correlationKeyAlias(index)
       })),
       ...projected
     ],
-    predicates: [...rows.predicates, ...mirrorPredicatesThroughKeys(probes.predicates, keys)],
+    predicates: [
+      ...rows.predicates,
+      ...probeLifted ? [] : mirrorPredicatesThroughKeys(probes.predicates, keys)
+    ],
     groupBy: [],
     having: [],
     orderBy: []
   };
-  const matched = {
+  const matched = probeLifted ? rawRows : {
     sql: "(correlated scalar matched probes)",
     base: { table: probesAlias, alias: probesAlias, derived: probes },
     joins: [
@@ -1611,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 = {
@@ -1623,7 +1671,7 @@ function decorrelateGeneralScalar(block, inner, scope, nextAlias) {
           {
             alias: correlationRowNumberAlias,
             name: rows.limitWithTies === true ? "RANK" : "ROW_NUMBER",
-            partitionAliases: keys.map((_, index) => correlationKeyAlias(index)),
+            partitionAliases: outerExpressions.map((_, index) => correlationKeyAlias(index)),
             orderAliases: rows.orderBy.map((order, index) => ({
               alias: correlationOrderAlias(index),
               direction: order.direction,
@@ -1659,7 +1707,7 @@ function decorrelateGeneralScalar(block, inner, scope, nextAlias) {
       base: ranked,
       joins: [],
       select: [
-        ...keys.map((_, index) => ({
+        ...outerExpressions.map((_, index) => ({
           expression: {
             kind: "column",
             reference: `${rankedAlias}.${correlationKeyAlias(index)}`
@@ -1679,7 +1727,7 @@ function decorrelateGeneralScalar(block, inner, scope, nextAlias) {
       ...rows.offsetParameter === void 0 ? {} : { offsetValidationParameters: [rows.offsetParameter] }
     };
   }
-  const finalProbeReferences = keys.map((_, index) => ({
+  const finalProbeReferences = outerExpressions.map((_, index) => ({
     kind: "column",
     reference: `${finalRowsAlias}.${correlationKeyAlias(index)}`
   }));
@@ -1716,7 +1764,7 @@ function decorrelateGeneralScalar(block, inner, scope, nextAlias) {
           left: marker,
           right: { kind: "literal", value: null }
         },
-        then: grouped ? emptyScalarExpression(structuredClone(shape.expression)) : { kind: "literal", value: null }
+        then: grouped ? emptyScalarExpression(originalExpression, new Set(references)) : { kind: "literal", value: null }
       }
     ],
     otherwise: {
@@ -1880,19 +1928,7 @@ function decorrelateExistsExpression(block, exists, scope, nextAlias) {
 }
 function decorrelateExistsWithProbes(block, exists, scope, nextAlias) {
   const inner = exists.block;
-  const outside = [];
-  collectOutsideReferences(inner, /* @__PURE__ */ new Set(), outside);
-  const references = [...new Set(outside)];
-  if (references.length === 0) {
-    throw new TypeError("Correlated EXISTS subquery has no usable outer reference");
-  }
-  for (const reference of references) {
-    const parts = reference.split(".");
-    const alias = parts.length === 2 ? parts[0] : void 0;
-    if (alias === void 0 || !scope.has(alias)) {
-      throw new TypeError(`Correlated EXISTS references an unavailable outer source: ${reference}`);
-    }
-  }
+  const references = probeOuterReferences(inner, [], scope, "EXISTS");
   const outerExpressions = references.map((reference) => ({
     kind: "column",
     reference
@@ -1959,33 +1995,64 @@ function decorrelateExistsWithProbes(block, exists, scope, nextAlias) {
     right: { kind: "literal", value: null }
   };
 }
-function replacePlanReferences(block, replacements) {
-  const rewrite = (expression) => {
-    if (expression.kind === "column") {
-      const replacement = replacements.get(expression.reference);
-      return replacement == null ? expression : structuredClone(replacement);
+function replaceExpressionReferences(expression, replacements) {
+  const rewrite = (expression2) => {
+    if (expression2.kind === "column") {
+      const replacement = replacements.get(expression2.reference);
+      return replacement == null ? expression2 : structuredClone(replacement);
     }
-    if (expression.kind === "subquery" || expression.kind === "exists") {
-      replacePlanReferences(expression.block, replacements);
-      return expression;
+    if (expression2.kind === "subquery" || expression2.kind === "exists") {
+      replacePlanReferences(expression2.block, replacements);
+      return expression2;
     }
-    if (expression.kind === "window") {
-      expression.partitionBy = expression.partitionBy.map(rewrite);
-      for (const order of expression.orderBy)
+    if (expression2.kind === "window") {
+      expression2.partitionBy = expression2.partitionBy.map(rewrite);
+      for (const order of expression2.orderBy)
         order.expression = rewrite(order.expression);
-      if (expression.argument !== void 0)
-        expression.argument = rewrite(expression.argument);
-      return expression;
+      if (expression2.argument !== void 0)
+        expression2.argument = rewrite(expression2.argument);
+      return expression2;
     }
-    return mapChildExpressions(expression, rewrite);
+    return mapChildExpressions(expression2, rewrite);
   };
-  mapBlockExpressions(block, rewrite);
+  return rewrite(expression);
+}
+function replacePlanReferences(block, replacements) {
+  mapBlockExpressions(block, (expression) => replaceExpressionReferences(expression, replacements));
   forEachNestedBlock(block, (nested) => replacePlanReferences(nested, replacements));
 }
 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)];
@@ -1999,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));
@@ -2166,30 +2220,62 @@ function blockReferencesOutside(block) {
   collectOutsideReferences(block, /* @__PURE__ */ new Set(), refs);
   return refs.length > 0;
 }
-function collectOutsideReferences(block, outer, refs) {
-  const scope = /* @__PURE__ */ new Set([...outer, block.base.alias, ...block.joins.map((join) => join.alias)]);
-  const visit = (expression) => {
-    if (expression.kind === "column") {
-      const parts = expression.reference.split(".");
+function collectExpressionOutsideReferences(expression, scope, refs) {
+  const visit = (expression2) => {
+    if (expression2.kind === "column") {
+      const parts = expression2.reference.split(".");
       const alias = parts[0];
       if (parts.length === 2 && alias !== void 0 && !scope.has(alias)) {
-        refs.push(expression.reference);
+        refs.push(expression2.reference);
       }
       return;
     }
-    if (expression.kind === "subquery" || expression.kind === "exists") {
-      collectOutsideReferences(expression.block, scope, refs);
+    if (expression2.kind === "subquery" || expression2.kind === "exists") {
+      collectOutsideReferences(expression2.block, scope, refs);
       return;
     }
-    for (const child of childExpressions(expression))
+    for (const child of childExpressions(expression2))
       visit(child);
   };
-  forEachBlockExpression(block, visit);
+  visit(expression);
+}
+function collectOutsideReferences(block, outer, refs) {
+  const scope = /* @__PURE__ */ new Set([...outer, block.base.alias, ...block.joins.map((join) => join.alias)]);
+  forEachBlockExpression(block, (expression) => collectExpressionOutsideReferences(expression, scope, refs));
   forEachNestedBlock(block, (nested) => {
     collectOutsideReferences(nested, scope, refs);
   });
 }
+function probeOuterReferences(block, additional, scope, label) {
+  const outside = [];
+  collectOutsideReferences(block, /* @__PURE__ */ new Set(), outside);
+  const references = [.../* @__PURE__ */ new Set([...outside, ...additional])];
+  if (references.length === 0) {
+    throw new TypeError(`Correlated ${label} subquery has no usable outer reference`);
+  }
+  for (const reference of references) {
+    const parts = reference.split(".");
+    const alias = parts.length === 2 ? parts[0] : void 0;
+    if (alias === void 0 || !scope.has(alias)) {
+      throw new TypeError(`Correlated ${label} references an unavailable outer source: ${reference}`);
+    }
+  }
+  return references;
+}
 function extractCorrelation(inner, outerScope, label, comparisons = false) {
+  const keys = takeCorrelationPredicates(inner, outerScope, comparisons);
+  const leftover = [];
+  collectOutsideReferences(inner, /* @__PURE__ */ new Set(), leftover);
+  if (leftover.length > 0) {
+    const supported = comparisons ? "comparison" : "equality";
+    throw new TypeError(`Correlated ${label} subqueries support only ${supported} conditions between one inner and one outer qualified column (unsupported reference: ${leftover[0] ?? ""})`);
+  }
+  if (keys.length === 0) {
+    throw new TypeError(`Correlated ${label} subquery has no usable correlation condition`);
+  }
+  return keys;
+}
+function takeCorrelationPredicates(inner, outerScope, comparisons) {
   const innerScope = /* @__PURE__ */ new Set([inner.base.alias, ...inner.joins.map((join) => join.alias)]);
   const keys = [];
   const kept = [];
@@ -2201,15 +2287,6 @@ function extractCorrelation(inner, outerScope, label, comparisons = false) {
       keys.push(key);
   }
   inner.predicates = kept;
-  const leftover = [];
-  collectOutsideReferences(inner, /* @__PURE__ */ new Set(), leftover);
-  if (leftover.length > 0) {
-    const supported = comparisons ? "comparison" : "equality";
-    throw new TypeError(`Correlated ${label} subqueries support only ${supported} conditions between one inner and one outer qualified column (unsupported reference: ${leftover[0] ?? ""})`);
-  }
-  if (keys.length === 0) {
-    throw new TypeError(`Correlated ${label} subquery has no usable correlation condition`);
-  }
   return keys;
 }
 function canExtractCorrelation(inner, outerScope, label, comparisons) {
@@ -2328,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 } : {}
         };
       }
     }
@@ -2407,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 === "||") {
@@ -2428,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;
 }
@@ -2449,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)
@@ -2681,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