@minnowdb/core 0.7.1 → 0.7.5

package/dist/engine/query.js

@@ -6,12 +6,12 @@ import { SqlCompileError } from "./errors.js";
 import { cachedQueryTerms, ftsBm25Row, FtsStatsAccumulator, ftsMatchTruth, renderDocumentValue, tokenize as ftsTokenize, validateFtsQuery } from "./fts.js";
 import { QueryMemoryContext } from "./memory.js";
 import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
-import { coerceComparisonOperands, coercedComparable, parseSqlTimestampText, stringArgument } from "./sql-semantics.js";
+import { coerceComparisonOperands, coercedComparable, parseSqlTimestampText, stringArgument, readUntypedText } from "./sql-semantics.js";
 import { simpleScalarFunctions } from "./sql-functions.js";
-import { jsonArrowStep, jsonAtPath, jsonConstructor, jsonIsValid, parseJsonPath } from "./sql-json.js";
+import { jsonArrowStep, jsonAtPath, jsonConstructor, jsonIsValid, parseJsonPath, jsonDocumentOf } from "./sql-json.js";
 import { optimizePlan, rewriteBoundCalendarEqualities } from "./optimizer.js";
 import { compareSqlValues as compareValues, compileLikePattern, compileSimilarPattern, encodeSqlEqualityValue, roundSqlNumber } from "./sql-semantics.js";
-import { arrayDomainValue, boundedJsonText, collatedDomainValue, concatenatedSqlValue, dateDomainValue, exactNumericAsNumber, exactNumericBinary, exactNumericLiteral, exactNumericValue, externalSqlDomainColumnValue, externalSqlDomainValue, intervalDomainValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, jsonDomainValue, normalizeSqlDomainValue, preservedJsonDomainValue, protectedSqlTextValue, timeDomainValue, uuidDomainValue } from "./sql-domains.js";
+import { arrayDomainValue, boundedJsonText, collatedDomainValue, concatenatedSqlValue, dateDomainValue, exactNumericAsNumber, exactNumericBinary, exactNumericLiteral, decimalScaleOfNumber, exactNumericRounded, exactNumericUnary, exactNumericValue, externalSqlDomainColumnValue, externalSqlDomainValue, intervalDomainValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, jsonDomainValue, normalizeSqlDomainValue, preservedJsonDomainValue, protectedSqlTextValue, timeDomainValue, uuidDomainValue } from "./sql-domains.js";
 import { columnarTableFromRows, prepareVectorQuery } from "./vector.js";
 function unknownColumnDomains(columns) {
   return columns.map(() => null);
@@ -61,6 +61,7 @@ const scalarFunctionNames = /* @__PURE__ */ new Set([
   "JSON_EXISTS",
   "JSON_OBJECT",
   "JSON_ARRAY",
+  "TO_JSON",
   "IS_JSON",
   "ARRAY",
   "MINNOW_JSON_GET",
@@ -87,13 +88,23 @@ const functionSpellings = /* @__PURE__ */ new Map([
   ["DATE_PART", "EXTRACT"],
   ["CEILING", "CEIL"],
   ["CHAR_LENGTH", "LENGTH"],
-  ["CHARACTER_LENGTH", "LENGTH"]
+  ["CHARACTER_LENGTH", "LENGTH"],
+  ["POW", "POWER"],
+  ["JSON_AGG", "JSON_ARRAYAGG"],
+  ["JSONB_AGG", "JSON_ARRAYAGG"],
+  ["JSON_BUILD_ARRAY", "JSON_ARRAY"],
+  ["JSONB_BUILD_ARRAY", "JSON_ARRAY"],
+  ["TO_JSONB", "TO_JSON"],
+  ["ROW_TO_JSON", "TO_JSON"]
 ]);
 const statementDatetimeAliases = /* @__PURE__ */ new Map([
   ["CURRENT_DATE", "CURRENT_DATE"],
   ["CURRENT_TIMESTAMP", "CURRENT_TIMESTAMP"],
   ["LOCALTIMESTAMP", "CURRENT_TIMESTAMP"],
   ["NOW", "CURRENT_TIMESTAMP"],
+  ["TRANSACTION_TIMESTAMP", "CURRENT_TIMESTAMP"],
+  ["STATEMENT_TIMESTAMP", "CURRENT_TIMESTAMP"],
+  ["CLOCK_TIMESTAMP", "CURRENT_TIMESTAMP"],
   ["CURRENT_TIME", "LOCALTIME"],
   ["LOCALTIME", "LOCALTIME"]
 ]);
@@ -256,17 +267,23 @@ function buildScalarFunctionEvaluator(name) {
         if (values.length > 1 && (values[1] === null || values[1] === void 0))
           return null;
         const digits = values.length > 1 ? numeric(values[1]) : 0;
-        if (isExactNumeric(first) && Number.isInteger(digits) && digits >= 0) {
-          return exactNumericValue(first, void 0, digits);
+        if (isExactNumeric(first) && Number.isInteger(digits)) {
+          return exactNumericRounded(first, digits, "round");
         }
         return roundSqlNumber(numeric(first), digits);
       };
     case "FLOOR":
-      return (values) => values[0] === null || values[0] === void 0 ? null : Math.floor(numeric(values[0]));
     case "CEIL":
-      return (values) => values[0] === null || values[0] === void 0 ? null : Math.ceil(numeric(values[0]));
     case "ABS":
-      return (values) => values[0] === null || values[0] === void 0 ? null : Math.abs(numeric(values[0]));
+      return (values) => {
+        const first = values[0];
+        if (first === null || first === void 0)
+          return null;
+        if (isExactNumeric(first))
+          return exactNumericUnary(name, first);
+        const operand = numeric(first);
+        return name === "FLOOR" ? Math.floor(operand) : name === "CEIL" ? Math.ceil(operand) : Math.abs(operand);
+      };
     case "UPPER":
       return (values) => {
         const first = values[0];
@@ -355,12 +372,15 @@ function scalarFunctionValueGeneric(name, values) {
       return comparable(first) === comparable(other) ? null : first;
     }
     case "FLOOR":
-      return Math.floor(numeric(first));
+      return isExactNumeric(first) ? exactNumericUnary("FLOOR", first) : Math.floor(numeric(first));
     case "CEIL":
-      return Math.ceil(numeric(first));
+      return isExactNumeric(first) ? exactNumericUnary("CEIL", first) : Math.ceil(numeric(first));
     case "MOD": {
       if (values[1] === null || values[1] === void 0)
         return null;
+      const exact = exactNumericBinary("%", first, values[1]);
+      if (exact !== void 0)
+        return exact;
       const divisor = numeric(values[1]);
       return divisor === 0 ? null : numeric(first) % divisor;
     }
@@ -412,13 +432,13 @@ function scalarFunctionValueGeneric(name, values) {
       if (values.length > 1 && (values[1] === null || values[1] === void 0))
         return null;
       const digits = values.length > 1 ? numeric(values[1]) : 0;
-      if (isExactNumeric(first) && Number.isInteger(digits) && digits >= 0) {
-        return exactNumericValue(first, void 0, digits);
+      if (isExactNumeric(first) && Number.isInteger(digits)) {
+        return exactNumericRounded(first, digits, "round");
       }
       return roundSqlNumber(numeric(first), digits);
     }
     case "ABS":
-      return Math.abs(numeric(first));
+      return isExactNumeric(first) ? exactNumericUnary("ABS", first) : Math.abs(numeric(first));
     case "UPPER": {
       const source = stringArgument("UPPER", first);
       assertScalarInputLength(source, "UPPER input");
@@ -458,6 +478,8 @@ function scalarFunctionValueGeneric(name, values) {
         return null;
       return preservedJsonDomainValue(JSON.stringify(found.value));
     }
+    case "TO_JSON":
+      return preservedJsonDomainValue(jsonDocumentOf(first));
     case "MINNOW_JSON_GET": {
       if (values[1] === null || values[1] === void 0)
         return null;
@@ -767,20 +789,36 @@ const createTableTypeNames = /* @__PURE__ */ new Map([
   ["BOOL", "boolean"],
   ["INTEGER", "number"],
   ["INT", "number"],
+  ["INT4", "number"],
   ["BIGINT", "number"],
+  ["INT8", "number"],
   ["SMALLINT", "number"],
+  ["INT2", "number"],
   ["REAL", "number"],
+  ["FLOAT4", "number"],
   ["FLOAT", "number"],
+  ["FLOAT8", "number"],
   ["TEXT", "string"],
   ["VARCHAR", "string"],
   ["CHAR", "string"],
+  ["CHARACTER", "string"],
   ["STRING", "string"],
   ["TIMESTAMP", "datetime"],
   ["TIMESTAMPTZ", "datetime"],
   ["DATETIME", "datetime"]
 ]);
+const integerTypeNames = /* @__PURE__ */ new Set([
+  "INTEGER",
+  "INT",
+  "INT4",
+  "BIGINT",
+  "INT8",
+  "SMALLINT",
+  "INT2"
+]);
 const clauseKeywords = /* @__PURE__ */ new Set([
   "WHERE",
+  "FOR",
   "NATURAL",
   "USING",
   "OUTER",
@@ -802,6 +840,72 @@ const clauseKeywords = /* @__PURE__ */ new Set([
   "UNION",
   "RETURNING"
 ]);
+const bareLabelStopWords = /* @__PURE__ */ new Set([
+  ...clauseKeywords,
+  "ALL",
+  "AND",
+  "ANY",
+  "ARRAY",
+  "AS",
+  "ASC",
+  "AT",
+  "BETWEEN",
+  "BOTH",
+  "CASE",
+  "CAST",
+  "CHECK",
+  "COLLATE",
+  "COLUMN",
+  "CONSTRAINT",
+  "CREATE",
+  "DEFAULT",
+  "DESC",
+  "DISTINCT",
+  "DO",
+  "ELSE",
+  "END",
+  "ESCAPE",
+  "FALSE",
+  "FILTER",
+  "FOR",
+  "FOREIGN",
+  "FROM",
+  "GRANT",
+  "ILIKE",
+  "IN",
+  "INTO",
+  "IS",
+  "ISNULL",
+  "LATERAL",
+  "LEADING",
+  "LIKE",
+  "NOT",
+  "NOTNULL",
+  "NULL",
+  "ON",
+  "ONLY",
+  "OR",
+  "OVER",
+  "OVERLAPS",
+  "PLACING",
+  "PRIMARY",
+  "REFERENCES",
+  "SELECT",
+  "SIMILAR",
+  "SOME",
+  "TABLE",
+  "THEN",
+  "TO",
+  "TRAILING",
+  "TRUE",
+  "UNIQUE",
+  "USER",
+  "VALUES",
+  "WHEN",
+  "WITH",
+  "WITHIN",
+  "WITHOUT"
+]);
 const aggregateNames = /* @__PURE__ */ new Set([
   "COUNT",
   "SUM",
@@ -830,20 +934,28 @@ function rejectSemicolons(tokens) {
 function normalizeSql(sql) {
   return { text: sql.trim().replace(/;$/, "").trim(), offset: sql.length - sql.trimStart().length };
 }
+function normalizeQuerySql(sql) {
+  const spelling = "SELECT * FROM ";
+  const table = /^\s*TABLE\s+(?=[A-Za-z_"])/i.exec(sql);
+  if (table === null)
+    return normalizeSql(sql);
+  const { text } = normalizeSql(spelling + sql.slice(table[0].length));
+  return { text, offset: table[0].length - spelling.length };
+}
 function throwLocated(error, offset, span) {
   if (error instanceof SqlCompileError) {
     if (offset === 0)
       throw error;
-    throw new SqlCompileError(error.message, error.offset + offset, error.length);
+    throw new SqlCompileError(error.message, Math.max(error.offset + offset, 0), error.length);
   }
   if (error instanceof TypeError) {
-    throw new SqlCompileError(error.message, offset + span.start, Math.max(span.end - span.start, 0));
+    throw new SqlCompileError(error.message, Math.max(offset + span.start, 0), Math.max(span.end - span.start, 0));
   }
   throw error;
 }
 function compileQuery(sql, options = {}) {
   validateSqlSource(sql);
-  const { text, offset } = normalizeSql(sql);
+  const { text, offset } = normalizeQuerySql(sql);
   if (text.length === 0)
     throw new SqlCompileError("Enter a SELECT query", offset, 0);
   let parser;
@@ -858,6 +970,8 @@ function compileQuery(sql, options = {}) {
   }
   let compiled;
   try {
+    plan = expandRowReferences(plan, () => void 0);
+    annotatePlanIntegerDivision(plan);
     resolvePlanExactNumericConstants(plan);
     if (options.optimize === false && planHasPendingSelectShapes(plan)) {
       plan.preserveUnoptimizedShape = true;
@@ -896,6 +1010,94 @@ function isDefaultInsertValue(value) {
 function isDeferredInsertExpression(value) {
   return typeof value === "object" && value !== null && !(value instanceof Date) && "expression" in value;
 }
+function parseSettingStatement(keyword, tokens) {
+  const words = tokens.filter((token) => token.kind !== "eof");
+  const upperAt = (at) => {
+    const word = words[at];
+    return word?.kind === "identifier" && word.quoted !== true ? word.text.toUpperCase() : void 0;
+  };
+  if (keyword === "RESET") {
+    const name2 = words[1];
+    if (name2 === void 0 || name2.kind !== "identifier" && name2.kind !== "string") {
+      throw new TypeError("RESET takes a setting name or ALL");
+    }
+    return { kind: "set", action: "reset", name: name2.text };
+  }
+  let index = 1;
+  if (upperAt(index) === "SESSION" || upperAt(index) === "LOCAL")
+    index += 1;
+  if (upperAt(index) === "TIME" && upperAt(index + 1) === "ZONE") {
+    const zone = words[index + 2];
+    const spelled = zone?.kind === "string" ? zone.text : zone?.text.toUpperCase();
+    const utc = spelled === void 0 || spelled.toUpperCase() === "UTC" || spelled.toUpperCase() === "DEFAULT" || spelled.toUpperCase() === "LOCAL" || spelled === "Etc/UTC" || spelled === "GMT";
+    if (!utc) {
+      throw new TypeError(`SET TIME ZONE ${zone?.text ?? ""} is not supported: every datetime is an instant in UTC`);
+    }
+    return { kind: "set", action: "set", name: "timezone" };
+  }
+  if (upperAt(index) === "TRANSACTION" || upperAt(index) === "CONSTRAINTS") {
+    if (words.some((word) => word.text.toUpperCase() === "SERIALIZABLE")) {
+      throw new TypeError("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE is not supported: the engine has one isolation level");
+    }
+    return { kind: "set", action: "set", name: (upperAt(index) ?? "").toLowerCase() };
+  }
+  const name = words[index];
+  if (name?.kind !== "identifier") {
+    throw new TypeError(`Expected a setting name, found ${name?.text ?? "end of input"}`);
+  }
+  let cursor = index + 1;
+  while (words[cursor]?.text === ".")
+    cursor += 2;
+  const settingName = words.slice(index, cursor).map((token) => token.text).join("");
+  const separator = words[cursor];
+  if (separator === void 0 || separator.text.toUpperCase() !== "TO" && separator.text !== "=") {
+    throw new TypeError(`SET ${settingName} takes TO or = and a value`);
+  }
+  if (words[cursor + 1] === void 0)
+    throw new TypeError(`SET ${settingName} needs a value`);
+  if (settingName.toLowerCase() === "timezone" || settingName.toLowerCase() === "time_zone") {
+    const zone = words[cursor + 1];
+    const spelled = zone?.kind === "string" ? zone.text : zone?.text ?? "";
+    if (!["utc", "default", "local", "etc/utc", "gmt"].includes(spelled.toLowerCase())) {
+      throw new TypeError(`SET ${settingName} = ${zone?.text ?? ""} is not supported: every datetime is an instant in UTC`);
+    }
+  }
+  return { kind: "set", action: "set", name: settingName };
+}
+function parseTruncateStatement(tokens) {
+  const words = tokens.filter((token) => token.kind !== "eof");
+  let index = 1;
+  const upperAt = (at) => {
+    const word = words[at];
+    return word?.kind === "identifier" ? word.text.toUpperCase() : void 0;
+  };
+  if (upperAt(index) === "TABLE")
+    index += 1;
+  if (upperAt(index) === "ONLY")
+    index += 1;
+  const table = words[index];
+  if (table?.kind !== "identifier") {
+    throw new TypeError(`Expected table name, found ${table?.text ?? "end of input"}`);
+  }
+  index += 1;
+  if (words[index]?.text === ",")
+    throw new TypeError("TRUNCATE takes one table at a time");
+  if (upperAt(index) === "RESTART" || upperAt(index) === "CONTINUE") {
+    if (upperAt(index + 1) !== "IDENTITY") {
+      throw new TypeError(`Expected IDENTITY, found ${words[index + 1]?.text ?? "end of input"}`);
+    }
+    index += 2;
+  }
+  if (upperAt(index) === "CASCADE") {
+    throw new TypeError("TRUNCATE CASCADE is not supported; truncate dependents explicitly");
+  }
+  if (upperAt(index) === "RESTRICT")
+    index += 1;
+  if (index !== words.length) {
+    throw new TypeError(`Unexpected input after TRUNCATE: ${words[index]?.text ?? ""}`);
+  }
+  return { kind: "delete", table: table.text, predicates: [] };
+}
 function parseTransactionStatement(keyword, tokens) {
   const identifierAt = (index) => {
     const token = tokens[index];
@@ -927,8 +1129,30 @@ function parseTransactionStatement(keyword, tokens) {
     return { kind: "transaction", action: "rollback-to", name };
   }
   const words = tokens.filter((token) => token.kind === "identifier").map((token) => token.text.toUpperCase());
-  const action = keyword === "START" || keyword === "BEGIN" ? "begin" : keyword.toLowerCase();
-  const allowed = /* @__PURE__ */ new Set(["BEGIN", "START", "COMMIT", "ROLLBACK", "WORK", "TRANSACTION"]);
+  const action = keyword === "START" || keyword === "BEGIN" ? "begin" : keyword === "END" ? "commit" : keyword === "ABORT" ? "rollback" : keyword.toLowerCase();
+  if (words.includes("SERIALIZABLE")) {
+    throw new TypeError("BEGIN ISOLATION LEVEL SERIALIZABLE is not supported: the engine has one isolation level");
+  }
+  const allowed = /* @__PURE__ */ new Set([
+    "BEGIN",
+    "START",
+    "COMMIT",
+    "END",
+    "ROLLBACK",
+    "ABORT",
+    "WORK",
+    "TRANSACTION",
+    "READ",
+    "ONLY",
+    "WRITE",
+    "NOT",
+    "DEFERRABLE",
+    "ISOLATION",
+    "LEVEL",
+    "COMMITTED",
+    "UNCOMMITTED",
+    "REPEATABLE"
+  ]);
   for (const word of words) {
     if (!allowed.has(word)) {
       throw new TypeError(`${keyword} takes no ${word}: this engine has one isolation level`);
@@ -1115,7 +1339,7 @@ function parseCreateTrigger(text, tokens) {
 }
 function compileStatement(sql) {
   validateSqlSource(sql);
-  const { text, offset } = normalizeSql(sql);
+  const { text, offset } = normalizeQuerySql(sql);
   if (text.length === 0)
     throw new SqlCompileError("Enter a SQL statement", offset, 0);
   let parser;
@@ -1123,13 +1347,25 @@ function compileStatement(sql) {
     const tokens = tokenize(text);
     const first = tokens[0];
     const keyword = first?.kind === "identifier" ? first.text.toUpperCase() : "";
-    const second = tokens[1];
+    let second = tokens[1];
     const isTriggerDdl = (keyword === "CREATE" || keyword === "DROP") && second?.kind === "identifier" && second.text.toUpperCase() === "TRIGGER";
     if (!isTriggerDdl)
       rejectSemicolons(tokens);
-    if (keyword === "BEGIN" || keyword === "START" || keyword === "COMMIT" || keyword === "ROLLBACK" || keyword === "SAVEPOINT" || keyword === "RELEASE") {
+    if (keyword === "BEGIN" || keyword === "START" || keyword === "COMMIT" || keyword === "END" || keyword === "ROLLBACK" || keyword === "ABORT" || keyword === "SAVEPOINT" || keyword === "RELEASE") {
       return parseTransactionStatement(keyword, tokens);
     }
+    if (keyword === "TRUNCATE")
+      return parseTruncateStatement(tokens);
+    if (keyword === "SET" || keyword === "RESET")
+      return parseSettingStatement(keyword, tokens);
+    if (keyword === "SHOW") {
+      const name = tokens[1];
+      if (name?.kind !== "identifier" || tokens[2]?.kind !== "eof" && tokens[2]?.text !== ".") {
+        throw new TypeError("SHOW takes one setting name");
+      }
+      const setting = tokens.slice(1).filter((token) => token.kind !== "eof").map((token) => token.text).join("");
+      return { kind: "show", name: setting };
+    }
     if (keyword === "MERGE") {
       parser = new Parser(tokens, text);
       const statement = parser.parseMerge();
@@ -1147,6 +1383,10 @@ function compileStatement(sql) {
     if (keyword === "CREATE") {
       if (isTriggerDdl)
         return parseCreateTrigger(text, tokens);
+      while (tokens[1]?.kind === "identifier" && ["TEMP", "TEMPORARY", "UNLOGGED", "GLOBAL", "LOCAL"].includes(tokens[1].text.toUpperCase())) {
+        tokens.splice(1, 1);
+      }
+      second = tokens[1];
       if (second?.kind === "identifier" && second.text.toUpperCase() === "TYPE") {
         const name = tokens[2];
         if (name?.kind !== "identifier")
@@ -1608,6 +1848,7 @@ function bindStatementParameters(statement, params) {
     if (clone.onConflict?.where !== void 0) {
       clone.onConflict.where = bindExpression(clone.onConflict.where, values);
     }
+    bindReturningItems(clone.returningItems, values);
     return clone;
   }
   if (clone.kind === "drop-table" || clone.kind === "create-view" || clone.kind === "drop-view" || clone.kind === "transaction") {
@@ -1643,8 +1884,15 @@ function bindStatementParameters(statement, params) {
     predicate.left = bindExpression(predicate.left, values);
     predicate.right = bindExpression(predicate.right, values);
   }
+  bindReturningItems(clone.returningItems, values);
   return clone;
 }
+function bindReturningItems(items, values) {
+  if (items === void 0)
+    return;
+  for (const item of items)
+    item.expression = bindExpression(item.expression, values);
+}
 function inferBlockSchema(plan, schemas) {
   const sources = [plan.base, ...plan.joins];
   const multipleSources = sources.filter((source) => {
@@ -1711,15 +1959,42 @@ function inferBlockSchema(plan, schemas) {
       return { kind: "interval" };
     return void 0;
   };
+  const operandScale = (expression, domain) => {
+    if (domain !== void 0)
+      return domain.kind === "numeric" ? domain.scale : void 0;
+    if (expression.kind === "literal") {
+      return typeof expression.value === "number" && Number.isFinite(expression.value) ? decimalScaleOfNumber(expression.value) : void 0;
+    }
+    return expression.kind === "column" ? 0 : void 0;
+  };
+  const numericResultDomain = (operator, sides) => {
+    const scales = sides.map(([expression, domain]) => operandScale(expression, domain));
+    if (scales.some((scale) => scale === void 0))
+      return { kind: "numeric" };
+    const known = scales;
+    return {
+      kind: "numeric",
+      scale: operator === "*" ? known.reduce((sum, scale) => sum + scale, 0) : Math.max(...known)
+    };
+  };
   const inferDomain = (expression) => {
     if (expression.kind === "literal")
       return expression.sqlDomain;
     if (expression.kind === "column")
       return resolveColumnDomain(expression.reference);
     if (expression.kind === "binary") {
+      if (expression.operator === "||")
+        return void 0;
       const left = inferDomain(expression.left);
       const right = inferDomain(expression.right);
-      return left?.kind === "numeric" || right?.kind === "numeric" ? { kind: "numeric" } : void 0;
+      if (left?.kind !== "numeric" && right?.kind !== "numeric")
+        return void 0;
+      if (expression.operator === "/")
+        return { kind: "numeric" };
+      return numericResultDomain(expression.operator, [
+        [expression.left, left],
+        [expression.right, right]
+      ]);
     }
     if (expression.kind === "case") {
       const outcomes = [
@@ -1741,11 +2016,30 @@ function inferBlockSchema(plan, schemas) {
       const target = expression.arguments[1];
       return target?.kind === "literal" && typeof target.value === "string" ? castDomain(target.value) : void 0;
     }
-    if (expression.name === "JSON_ARRAYAGG" || expression.name === "JSON_QUERY" || expression.name === "JSON_OBJECT" || expression.name === "JSON_ARRAY" || expression.name === "MINNOW_JSON_GET") {
+    if (expression.name === "JSON_ARRAYAGG" || expression.name === "JSON_QUERY" || expression.name === "JSON_OBJECT" || expression.name === "JSON_ARRAY" || expression.name === "TO_JSON" || expression.name === "MINNOW_JSON_GET") {
       return { kind: "json" };
     }
     if (expression.name === "GEN_RANDOM_UUID")
       return { kind: "uuid" };
+    if (expression.name === "ROUND" || expression.name === "TRUNC") {
+      const input = inferDomain(expression.arguments[0] ?? { kind: "literal", value: null });
+      if (input?.kind !== "numeric")
+        return void 0;
+      const digits = expression.arguments[1];
+      return digits?.kind === "literal" && typeof digits.value === "number" && Number.isInteger(digits.value) && digits.value > 0 ? { kind: "numeric", scale: digits.value } : { kind: "numeric" };
+    }
+    if (expression.name === "ABS") {
+      const input = inferDomain(expression.arguments[0] ?? { kind: "literal", value: null });
+      return input?.kind === "numeric" ? input : void 0;
+    }
+    if (expression.name === "FLOOR" || expression.name === "CEIL" || expression.name === "SIGN") {
+      const input = inferDomain(expression.arguments[0] ?? { kind: "literal", value: null });
+      return input?.kind === "numeric" ? { kind: "numeric" } : void 0;
+    }
+    if (expression.name === "MOD") {
+      const sides = expression.arguments.map((argument) => [argument, inferDomain(argument)]);
+      return sides.some(([, domain]) => domain?.kind === "numeric") ? numericResultDomain("%", sides) : void 0;
+    }
     if (expression.name === "DATE_ADD") {
       const input = inferDomain(expression.arguments[0] ?? { kind: "literal", value: null });
       const milliseconds = expression.arguments[2];
@@ -1756,6 +2050,7 @@ function inferBlockSchema(plan, schemas) {
     }
     return void 0;
   };
+  const exactNumericMix = (expression, left, right) => (left === "string" && right === "number" || left === "number" && right === "string") && inferDomain(expression)?.kind === "numeric";
   const infer = (expression) => {
     if (expression.kind === "subquery" || expression.kind === "list") {
       throw new TypeError("Subqueries must be resolved before schema inference");
@@ -1780,6 +2075,10 @@ function inferBlockSchema(plan, schemas) {
         if (type === "null")
           continue;
         if (resolved !== "null" && resolved !== type) {
+          if (exactNumericMix(expression, resolved, type)) {
+            resolved = "string";
+            continue;
+          }
           throw new TypeError("CASE branches must produce one value type");
         }
         resolved = type;
@@ -1838,10 +2137,13 @@ function inferBlockSchema(plan, schemas) {
     if (expression.name === "SUM" || expression.name === "AVG") {
       return inferDomain(expression)?.kind === "numeric" ? "string" : "number";
     }
-    if (expression.name === "ROUND" || expression.name === "LENGTH" || expression.name === "ABS" || expression.name === "FLOOR" || expression.name === "CEIL" || expression.name === "MOD" || expression.name === "POWER" || expression.name === "SQRT" || expression.name === "INSTR" || expression.name === "EXTRACT" || expression.name === "OCTET_LENGTH" || expression.name === "GROUPING" || expression.name === "NEXTVAL" || expression.name === "CURRVAL" || expression.name === "RANDOM") {
+    if (expression.name === "ROUND" || expression.name === "ABS" || expression.name === "FLOOR" || expression.name === "CEIL" || expression.name === "MOD") {
+      return inferDomain(expression)?.kind === "numeric" ? "string" : "number";
+    }
+    if (expression.name === "LENGTH" || expression.name === "POWER" || expression.name === "SQRT" || expression.name === "INSTR" || expression.name === "EXTRACT" || expression.name === "OCTET_LENGTH" || expression.name === "GROUPING" || expression.name === "NEXTVAL" || expression.name === "CURRVAL" || expression.name === "RANDOM") {
       return "number";
     }
-    if (expression.name === "JSON_ARRAYAGG" || expression.name === "STRING_AGG" || expression.name === "JSON_VALUE" || expression.name === "JSON_QUERY" || expression.name === "JSON_OBJECT" || expression.name === "JSON_ARRAY" || expression.name === "ARRAY" || expression.name === "MINNOW_JSON_GET" || expression.name === "MINNOW_JSON_GET_TEXT" || expression.name === "MINNOW_TUPLE_KEY" || expression.name === "MINNOW_COLLATE" || expression.name === "GEN_RANDOM_UUID") {
+    if (expression.name === "JSON_ARRAYAGG" || expression.name === "STRING_AGG" || expression.name === "JSON_VALUE" || expression.name === "JSON_QUERY" || expression.name === "JSON_OBJECT" || expression.name === "JSON_ARRAY" || expression.name === "TO_JSON" || expression.name === "ARRAY" || expression.name === "MINNOW_JSON_GET" || expression.name === "MINNOW_JSON_GET_TEXT" || expression.name === "MINNOW_TUPLE_KEY" || expression.name === "MINNOW_COLLATE" || expression.name === "GEN_RANDOM_UUID") {
       return "string";
     }
     if (expression.name === "JSON_EXISTS" || expression.name === "IS_JSON")
@@ -1852,6 +2154,9 @@ function inferBlockSchema(plan, schemas) {
         const argument2 = expression.arguments[0];
         return argument2 === void 0 ? "null" : infer(argument2);
       }
+      if (simple.returns === "number" && inferDomain(expression)?.kind === "numeric") {
+        return "string";
+      }
       return simple.returns === "date" || simple.returns === "interval" ? "string" : simple.returns;
     }
     if (expression.name === "DATE_TRUNC")
@@ -1872,6 +2177,10 @@ function inferBlockSchema(plan, schemas) {
         if (type === "null")
           continue;
         if (resolved !== "null" && resolved !== type) {
+          if (exactNumericMix(expression, resolved, type)) {
+            resolved = "string";
+            continue;
+          }
           throw new TypeError(`${expression.name} arguments must produce one value type`);
         }
         resolved = type;
@@ -1907,6 +2216,10 @@ function inferBlockSchema(plan, schemas) {
         if (type === "null")
           continue;
         if (resolved !== "null" && resolved !== type) {
+          if (exactNumericMix(expression, resolved, type)) {
+            resolved = "string";
+            continue;
+          }
           throw new TypeError("COALESCE arguments must produce one value type");
         }
         resolved = type;
@@ -1928,7 +2241,7 @@ function inferBlockSchema(plan, schemas) {
     if (type === "null") {
       throw new TypeError(`Cannot infer a column type for output ${item.alias}`);
     }
-    const integer = item.expression.kind === "column" && resolveColumnInteger(item.expression.reference) || item.expression.kind === "call" && item.expression.name === "CAST" && item.expression.arguments[1]?.kind === "literal" && item.expression.arguments[1].value === "number-integer" || item.expression.kind === "call" && item.expression.name === "COUNT";
+    const integer = integerTypedExpression(item.expression, resolveColumnInteger);
     const sqlDomain = inferDomain(item.expression);
     return [
       {
@@ -1980,6 +2293,7 @@ function referencedColumns(plan, schemas) {
   const sourceAliases = sources.map((source) => source.alias);
   if (new Set(sourceAliases).size !== sourceAliases.length)
     throw new TypeError("Table aliases must be unique");
+  plan = unifyPlanGroupedReferences(plan, (tableName) => schemas.get(tableName));
   validateGrouping(plan);
   const aliases = new Map(sources.map((source) => [source.alias, source.table]));
   const requested = new Map(sources.map((source) => [source.table, /* @__PURE__ */ new Set()]));
@@ -2100,6 +2414,7 @@ function createPreparedQuery(plan, tables, options = {}) {
   assertTailParametersBound(plan);
   plan = resolveStatementDatetimes(plan);
   plan = bindPendingSelectShapes(plan, wildcardRowColumns(tables));
+  plan = unifyPlanGroupedReferences(plan, wildcardRowColumns(tables));
   validateGrouping(plan);
   plan = expandSourceColumnAliases(plan, wildcardRowColumns(tables));
   plan = expandNaturalJoins(plan, wildcardRowColumns(tables));
@@ -2145,6 +2460,7 @@ function createPreparedColumnarQuery(plan, tables, memory = new QueryMemoryConte
   plan = expandNaturalJoins(plan, columnarColumns);
   plan = expandQualifiedWildcards(plan, columnarColumns);
   plan = expandDistinctWildcard(plan, columnarColumns);
+  plan = unifyPlanGroupedReferences(plan, columnarColumns);
   validateGrouping(plan);
   let closed = false;
   let prepared;
@@ -2487,6 +2803,485 @@ function forEachNestedBlock(block, visit) {
     }
   }
 }
+function integerTypedExpression(expression, columnInteger = () => false, tableIntegerColumns) {
+  const typed = (candidate) => integerTypedExpression(candidate, columnInteger, tableIntegerColumns);
+  switch (expression.kind) {
+    case "subquery": {
+      const item = expression.block.select[0];
+      return expression.block.select.length === 1 && item !== void 0 && integerTypedExpression(item.expression, blockColumnIntegerResolver(expression.block, tableIntegerColumns), tableIntegerColumns);
+    }
+    case "literal":
+      return typeof expression.value === "number" && expression.exactText === void 0 && expression.decimal !== true && expression.internalSqlValue !== true && Number.isSafeInteger(expression.value);
+    case "column":
+      return columnInteger(expression.reference);
+    case "binary": {
+      if (expression.operator === "||")
+        return false;
+      const left = typed(expression.left);
+      const right = typed(expression.right);
+      if (left && right)
+        return true;
+      const untyped = (candidate) => candidate.kind === "parameter" || candidate.kind === "literal" && typeof candidate.value === "string" && candidate.internalSqlValue !== true;
+      return left && untyped(expression.right) || right && untyped(expression.left);
+    }
+    case "call": {
+      const { name, arguments: args } = expression;
+      if (name === "COUNT")
+        return true;
+      if (name === "CAST") {
+        return args[1]?.kind === "literal" && args[1].value === "number-integer";
+      }
+      if (name === "SUM" || name === "MIN" || name === "MAX" || name === "ABS") {
+        return args.length === 1 && args[0] !== void 0 && typed(args[0]);
+      }
+      if (name === "MOD")
+        return args.length === 2 && args.every(typed);
+      if (name === "COALESCE" || name === "NULLIF" || name === "GREATEST" || name === "LEAST") {
+        return args.length > 0 && args.every(typed);
+      }
+      return false;
+    }
+    case "case":
+      return expression.branches.every((branch) => typed(branch.then)) && (expression.otherwise === void 0 || typed(expression.otherwise));
+    default:
+      return false;
+  }
+}
+function integerQuotient(left, right) {
+  if (right === 0)
+    return null;
+  if (!Number.isInteger(left) || !Number.isInteger(right))
+    return left / right;
+  const quotient = Math.trunc(left / right);
+  return quotient === 0 ? 0 : quotient;
+}
+function annotateIntegerDivision(expression, columnInteger = () => false, tableIntegerColumns) {
+  if (expression.kind === "subquery" || expression.kind === "exists") {
+    annotatePlanIntegerDivision(expression.block, tableIntegerColumns);
+    return;
+  }
+  for (const child of childExpressions(expression)) {
+    annotateIntegerDivision(child, columnInteger, tableIntegerColumns);
+  }
+  if (expression.kind === "binary" && expression.operator === "/" && expression.integer !== true && integerTypedExpression(expression, columnInteger, tableIntegerColumns)) {
+    expression.integer = true;
+  }
+}
+function blockIntegerOutputs(block, tableIntegerColumns, columnAliases) {
+  const resolver = blockColumnIntegerResolver(block, tableIntegerColumns);
+  const names = [];
+  for (const item of block.select) {
+    if (item.expression.kind === "wildcard") {
+      const table = item.expression.table;
+      for (const source of [block.base, ...block.joins]) {
+        if (table !== void 0 && source.alias !== table)
+          continue;
+        const columns = sourceIntegerColumns(source, tableIntegerColumns);
+        if (columns === true)
+          return true;
+        for (const name of columns)
+          if (resolver(name))
+            names.push(name);
+      }
+      continue;
+    }
+    if (integerTypedExpression(item.expression, resolver, tableIntegerColumns)) {
+      names.push(item.alias);
+    }
+  }
+  if (columnAliases === void 0)
+    return new Set(names);
+  const aliased = /* @__PURE__ */ new Set();
+  block.select.forEach((item, index) => {
+    const alias = columnAliases[index];
+    if (alias !== void 0 && item.expression.kind !== "wildcard" && names.includes(item.alias)) {
+      aliased.add(alias);
+    }
+  });
+  return aliased;
+}
+function sourceIntegerColumns(source, tableIntegerColumns) {
+  if (source.derived !== void 0) {
+    return blockIntegerOutputs(source.derived, tableIntegerColumns, source.columnAliases);
+  }
+  if (source.union !== void 0) {
+    const first = source.union.blocks[0];
+    return first === void 0 ? /* @__PURE__ */ new Set() : blockIntegerOutputs(first, tableIntegerColumns, source.columnAliases);
+  }
+  if (source.windowed !== void 0) {
+    return blockIntegerOutputs(source.windowed.block, tableIntegerColumns, source.columnAliases);
+  }
+  if (source.recursive !== void 0)
+    return /* @__PURE__ */ new Set();
+  return tableIntegerColumns?.(source.table) ?? /* @__PURE__ */ new Set();
+}
+function blockColumnIntegerResolver(block, tableIntegerColumns) {
+  const sources = [block.base, ...block.joins];
+  const cache = /* @__PURE__ */ new Map();
+  const has = (columns, name) => columns === true || columns.has(name);
+  const columnsOf = (source) => {
+    let columns = cache.get(source);
+    if (columns === void 0) {
+      columns = sourceIntegerColumns(source, tableIntegerColumns);
+      cache.set(source, columns);
+    }
+    return columns;
+  };
+  return (reference) => {
+    const separator = reference.indexOf(".");
+    if (separator !== -1) {
+      const alias = reference.slice(0, separator);
+      const name = reference.slice(separator + 1);
+      const source = sources.find((candidate) => candidate.alias === alias);
+      return source !== void 0 && has(columnsOf(source), name);
+    }
+    let found = 0;
+    for (const source of sources)
+      if (has(columnsOf(source), reference))
+        found += 1;
+    return found === 1;
+  };
+}
+function annotatePlanIntegerDivision(plan, tableIntegerColumns) {
+  forEachNestedBlock(plan, (nested) => annotatePlanIntegerDivision(nested, tableIntegerColumns));
+  const resolver = blockColumnIntegerResolver(plan, tableIntegerColumns);
+  forEachBlockExpression(plan, (expression) => annotateIntegerDivision(expression, resolver, tableIntegerColumns));
+}
+function planMayHaveIntegerDivision(plan) {
+  const state = { found: false };
+  const optimistic = () => true;
+  const everyColumn = () => true;
+  const probe = (expression) => {
+    if (state.found)
+      return;
+    if (expression.kind === "subquery" || expression.kind === "exists") {
+      if (planMayHaveIntegerDivision(expression.block))
+        state.found = true;
+      return;
+    }
+    if (expression.kind === "binary" && expression.operator === "/" && expression.integer !== true && integerTypedExpression(expression, optimistic, everyColumn)) {
+      state.found = true;
+      return;
+    }
+    childExpressions(expression).forEach(probe);
+  };
+  forEachNestedBlock(plan, (nested) => {
+    if (!state.found && planMayHaveIntegerDivision(nested))
+      state.found = true;
+  });
+  if (!state.found)
+    forEachBlockExpression(plan, probe);
+  return state.found;
+}
+function foldIdentifierCase(plan, tables) {
+  const lowerTables = /* @__PURE__ */ new Map();
+  for (const name of tables.keys()) {
+    const lowered = name.toLowerCase();
+    const bucket = lowerTables.get(lowered);
+    if (bucket === void 0)
+      lowerTables.set(lowered, [name]);
+    else
+      bucket.push(name);
+  }
+  const foldTable = (name) => {
+    if (tables.has(name))
+      return void 0;
+    const lowered = name.toLowerCase();
+    if (tables.has(lowered))
+      return lowered;
+    const candidates = lowerTables.get(lowered);
+    return candidates?.length === 1 ? candidates[0] : void 0;
+  };
+  const foldColumn = (columns, name) => {
+    if (columns.includes(name))
+      return void 0;
+    const lowered = name.toLowerCase();
+    if (columns.includes(lowered))
+      return lowered;
+    const matches = columns.filter((column) => column.toLowerCase() === lowered);
+    return matches.length === 1 ? matches[0] : void 0;
+  };
+  const pass = { probing: true, needed: false };
+  const sourceColumns = (source) => {
+    if (source.derived !== void 0) {
+      return source.columnAliases ?? source.derived.select.map((item) => item.alias);
+    }
+    if (source.union !== void 0) {
+      return source.columnAliases ?? source.union.blocks[0]?.select.map((item) => item.alias) ?? [];
+    }
+    if (source.windowed !== void 0) {
+      return source.columnAliases ?? source.windowed.block.select.map((item) => item.alias);
+    }
+    if (source.recursive !== void 0)
+      return source.columnAliases ?? [];
+    return source.columnAliases ?? tables.get(source.table) ?? [];
+  };
+  const rewriteBlock = (block) => {
+    if (pass.probing && pass.needed)
+      return;
+    forEachNestedBlock(block, rewriteBlock);
+    const sources = [block.base, ...block.joins];
+    for (const source of sources) {
+      const plain = source.derived === void 0 && source.union === void 0 && source.windowed === void 0 && source.recursive === void 0;
+      if (!plain)
+        continue;
+      const folded = foldTable(source.table);
+      if (folded === void 0)
+        continue;
+      if (pass.probing) {
+        pass.needed = true;
+        return;
+      }
+      const aliasWasTable = source.alias === source.table;
+      source.table = folded;
+      if (aliasWasTable)
+        source.alias = folded;
+    }
+    const foldReference = (reference) => {
+      const separator = reference.indexOf(".");
+      if (separator !== -1) {
+        const qualifier = reference.slice(0, separator);
+        const name = reference.slice(separator + 1);
+        let source = sources.find((candidate) => candidate.alias === qualifier);
+        let foldedQualifier;
+        if (source === void 0) {
+          const lowered = qualifier.toLowerCase();
+          const matches = sources.filter((candidate) => candidate.alias.toLowerCase() === lowered);
+          if (matches.length !== 1)
+            return void 0;
+          source = matches[0];
+          foldedQualifier = source?.alias;
+        }
+        if (source === void 0)
+          return void 0;
+        const columns = sourceColumns(source);
+        const foldedName = columns.includes(name) ? void 0 : foldColumn(columns, name);
+        if (foldedQualifier === void 0 && foldedName === void 0)
+          return void 0;
+        return `${foldedQualifier ?? qualifier}.${foldedName ?? name}`;
+      }
+      if (sources.some((source) => sourceColumns(source).includes(reference)))
+        return void 0;
+      const folded = sources.map((source) => foldColumn(sourceColumns(source), reference)).filter((name) => name !== void 0);
+      return folded.length === 1 ? folded[0] : void 0;
+    };
+    const aliases = new Set(block.select.map((item) => item.alias));
+    const orderByAliases = new Set(block.orderBy.map((order) => order.expression).filter((expression) => expression.kind === "column" && aliases.has(expression.reference)));
+    const writtenNames = block.select.map((item) => item.expression.kind === "column" ? bareColumnName(item.expression.reference) : void 0);
+    const rewrite = (expression) => {
+      if (expression.kind === "column") {
+        if (orderByAliases.has(expression))
+          return;
+        const folded = foldReference(expression.reference);
+        if (folded === void 0)
+          return;
+        if (pass.probing)
+          pass.needed = true;
+        else
+          expression.reference = folded;
+        return;
+      }
+      if (expression.kind === "wildcard") {
+        if (expression.table === void 0)
+          return;
+        const exact = sources.some((source) => source.alias === expression.table);
+        if (exact)
+          return;
+        const lowered = expression.table.toLowerCase();
+        const matches = sources.filter((source) => source.alias.toLowerCase() === lowered);
+        if (matches.length !== 1)
+          return;
+        if (pass.probing)
+          pass.needed = true;
+        else
+          expression.table = matches[0]?.alias ?? expression.table;
+        return;
+      }
+      if (expression.kind === "subquery" || expression.kind === "exists") {
+        rewriteBlock(expression.block);
+        return;
+      }
+      childExpressions(expression).forEach(rewrite);
+    };
+    forEachBlockExpression(block, rewrite);
+    if (!pass.probing) {
+      block.select.forEach((item, index) => {
+        if (item.expression.kind !== "column")
+          return;
+        const name = bareColumnName(item.expression.reference);
+        if (item.alias !== name && item.alias === writtenNames[index])
+          item.alias = name;
+      });
+    }
+  };
+  rewriteBlock(plan);
+  if (!pass.needed)
+    return plan;
+  const cloned = clonePlanTree(plan);
+  pass.probing = false;
+  rewriteBlock(cloned);
+  return cloned;
+}
+function expandRowReferences(plan, tableColumns) {
+  const pass = { probing: true, needed: false };
+  const sourceColumns = (source) => {
+    if (source.columnAliases !== void 0)
+      return source.columnAliases;
+    if (source.derived !== void 0)
+      return source.derived.select.map((item) => item.alias);
+    if (source.union !== void 0) {
+      return source.union.blocks[0]?.select.map((item) => item.alias) ?? [];
+    }
+    if (source.windowed !== void 0)
+      return source.windowed.block.select.map((item) => item.alias);
+    if (source.recursive !== void 0)
+      return [];
+    return tableColumns(source.table) ?? [];
+  };
+  const rewriteBlock = (block) => {
+    if (pass.probing && pass.needed)
+      return;
+    forEachNestedBlock(block, rewriteBlock);
+    const sources = [block.base, ...block.joins];
+    const rowObject = (reference) => {
+      if (reference.includes("."))
+        return void 0;
+      const source = sources.find((candidate) => candidate.alias === reference);
+      if (source === void 0)
+        return void 0;
+      if (sources.some((candidate) => sourceColumns(candidate).includes(reference))) {
+        return void 0;
+      }
+      const columns = sourceColumns(source);
+      if (columns.length === 0 || columns.some((name) => name.startsWith("\0")))
+        return void 0;
+      return {
+        kind: "call",
+        name: "JSON_OBJECT",
+        arguments: columns.flatMap((name) => [
+          { kind: "literal", value: name },
+          { kind: "column", reference: `${source.alias}.${name}` }
+        ])
+      };
+    };
+    if (pass.probing) {
+      const probe = (expression) => {
+        if (pass.needed)
+          return;
+        if (expression.kind === "column") {
+          if (rowObject(expression.reference) !== void 0)
+            pass.needed = true;
+          return;
+        }
+        if (expression.kind === "subquery" || expression.kind === "exists") {
+          rewriteBlock(expression.block);
+          return;
+        }
+        childExpressions(expression).forEach(probe);
+      };
+      forEachBlockExpression(block, probe);
+      return;
+    }
+    const rewrite = (expression) => {
+      if (expression.kind === "column") {
+        return rowObject(expression.reference) ?? expression;
+      }
+      if (expression.kind === "subquery" || expression.kind === "exists") {
+        rewriteBlock(expression.block);
+        return expression;
+      }
+      return mapChildExpressions(expression, rewrite);
+    };
+    mapBlockExpressions(block, rewrite);
+  };
+  rewriteBlock(plan);
+  if (!pass.needed)
+    return plan;
+  const cloned = clonePlanTree(plan);
+  pass.probing = false;
+  rewriteBlock(cloned);
+  return cloned;
+}
+function extendGroupByWithKeyDependents(plan, keyColumns, tableColumns = keyColumns) {
+  const pass = { probing: true, needed: false };
+  const rewriteBlock = (block) => {
+    if (pass.probing && pass.needed)
+      return;
+    forEachNestedBlock(block, rewriteBlock);
+    const visitSubqueries = (expression) => {
+      if (expression.kind === "subquery" || expression.kind === "exists") {
+        rewriteBlock(expression.block);
+        return;
+      }
+      childExpressions(expression).forEach(visitSubqueries);
+    };
+    forEachBlockExpression(block, visitSubqueries);
+    if (block.groupBy.length === 0)
+      return;
+    const sources = [block.base, ...block.joins];
+    const multipleSources = sources.length > 1;
+    const groupedColumns = new Set(block.groupBy.flatMap((expression) => expression.kind === "column" ? [expression.reference] : []));
+    const additions = [];
+    for (const source of sources) {
+      const plain = source.derived === void 0 && source.union === void 0 && source.windowed === void 0 && source.recursive === void 0 && source.columnAliases === void 0;
+      if (!plain)
+        continue;
+      const key = keyColumns(source.table);
+      if (key === void 0 || key.length === 0)
+        continue;
+      const columns = tableColumns(source.table) ?? key;
+      const namesFor = (column) => multipleSources ? [`${source.alias}.${column}`] : [column, `${source.alias}.${column}`];
+      const keyGrouped = key.every((column) => namesFor(column).some((name) => groupedColumns.has(name)));
+      if (!keyGrouped)
+        continue;
+      const referenced = /* @__PURE__ */ new Set();
+      const collect = (expression, insideAggregate) => {
+        if (expression.kind === "column") {
+          if (insideAggregate || groupedColumns.has(expression.reference))
+            return;
+          const separator = expression.reference.indexOf(".");
+          const qualifier = separator === -1 ? void 0 : expression.reference.slice(0, separator);
+          if (qualifier === void 0 ? multipleSources : qualifier !== source.alias)
+            return;
+          const name = separator === -1 ? expression.reference : expression.reference.slice(separator + 1);
+          if (!columns.includes(name))
+            return;
+          referenced.add(expression.reference);
+          return;
+        }
+        if (expression.kind === "subquery" || expression.kind === "exists")
+          return;
+        const aggregate = insideAggregate || expression.kind === "call" && aggregateNames.has(expression.name);
+        childExpressions(expression).forEach((child) => collect(child, aggregate));
+      };
+      for (const item of block.select)
+        collect(item.expression, false);
+      for (const predicate of block.having) {
+        collect(predicate.left, false);
+        collect(predicate.right, false);
+      }
+      for (const order of block.orderBy)
+        collect(order.expression, false);
+      for (const reference of referenced) {
+        if (pass.probing) {
+          pass.needed = true;
+          return;
+        }
+        groupedColumns.add(reference);
+        additions.push({ kind: "column", reference });
+      }
+    }
+    if (additions.length > 0)
+      block.groupBy = [...block.groupBy, ...additions];
+  };
+  rewriteBlock(plan);
+  if (!pass.needed)
+    return plan;
+  const cloned = clonePlanTree(plan);
+  pass.probing = false;
+  rewriteBlock(cloned);
+  return cloned;
+}
 function mapBlockExpressions(block, map) {
   for (const item of block.select)
     item.expression = map(item.expression);
@@ -2681,6 +3476,9 @@ function exactConstantFold(expression) {
   const seeded = left.seeded || right.seeded;
   if (left.value === null || right.value === null)
     return { value: null, seeded };
+  if (expression.integer === true && expression.operator === "/" && typeof left.value === "number" && typeof right.value === "number") {
+    return { value: integerQuotient(left.value, right.value), seeded };
+  }
   const folded = exactNumericBinary(expression.operator, left.value, right.value, 0, false);
   return folded === void 0 ? void 0 : { value: folded, seeded };
 }
@@ -2693,11 +3491,13 @@ function resolveExactNumericConstants(expression) {
   }
   if (folded?.seeded === true) {
     const value = folded.value;
-    if (value === null || typeof value === "number")
+    if (value === null)
       return { kind: "literal", value };
+    if (typeof value === "number")
+      return { kind: "literal", value, decimal: true };
     const fits = exactNumericAsNumber(value);
     if (fits !== void 0)
-      return { kind: "literal", value: fits };
+      return { kind: "literal", value: fits, decimal: true };
     return { kind: "literal", value, internalSqlValue: true, sqlDomain: { kind: "numeric" } };
   }
   if (expression.kind === "subquery" || expression.kind === "exists") {
@@ -2721,8 +3521,12 @@ function resolvePlanExactNumericConstants(plan) {
   mapBlockExpressions(plan, resolveExactNumericConstants);
   forEachNestedBlock(plan, resolvePlanExactNumericConstants);
 }
+function resolveStatementExpression(expression) {
+  annotateIntegerDivision(expression);
+  return resolveExactNumericConstants(expression);
+}
 function resolveStatementExactNumericConstants(statement) {
-  const resolve = resolveExactNumericConstants;
+  const resolve = resolveStatementExpression;
   if (statement.kind === "insert") {
     const conflict = statement.onConflict;
     if (conflict?.assignments !== void 0) {
@@ -2744,6 +3548,18 @@ function resolveStatementExactNumericConstants(statement) {
       predicate.left = resolve(predicate.left);
       predicate.right = resolve(predicate.right);
     }
+    if (statement.from !== void 0) {
+      for (const predicate of statement.from.predicates) {
+        predicate.left = resolve(predicate.left);
+        predicate.right = resolve(predicate.right);
+      }
+      for (const join of statement.from.joins) {
+        join.left = resolve(join.left);
+        join.right = resolve(join.right);
+        if (join.on !== void 0)
+          join.on = resolve(join.on);
+      }
+    }
     return;
   }
   if (statement.kind === "merge") {
@@ -3197,6 +4013,7 @@ function executeRowQueryInternal(plan, tables, memory) {
   assertTailParametersBound(plan);
   plan = resolveStatementDatetimes(plan);
   plan = bindPendingSelectShapes(plan, wildcardRowColumns(tables));
+  plan = unifyPlanGroupedReferences(plan, wildcardRowColumns(tables));
   validateGrouping(plan);
   plan = expandSourceColumnAliases(plan, wildcardRowColumns(tables));
   plan = expandNaturalJoins(plan, wildcardRowColumns(tables));
@@ -3460,11 +4277,16 @@ function evaluate(expression, context, group) {
         return null;
       if (expression.operator === "||")
         return concatenatedSqlValue(left, right);
-      const exact = exactNumericBinary(expression.operator, left, right);
+      const leftValue = typeof left === "string" && typeof right === "number" && !isSqlDomainValue(left) ? readUntypedText("number", left) : left;
+      const rightValue = typeof right === "string" && typeof left === "number" && !isSqlDomainValue(right) ? readUntypedText("number", right) : right;
+      if (expression.integer === true && expression.operator === "/" && typeof leftValue === "number" && typeof rightValue === "number") {
+        return integerQuotient(leftValue, rightValue);
+      }
+      const exact = exactNumericBinary(expression.operator, leftValue, rightValue);
       if (exact !== void 0)
         return exact;
-      const a = numeric(left);
-      const b = numeric(right);
+      const a = numeric(leftValue);
+      const b = numeric(rightValue);
       if (expression.operator === "+")
         return a + b;
       if (expression.operator === "-")
@@ -3904,10 +4726,12 @@ function evaluateBooleanExpression(expression, evaluateValue) {
       const distinct = distinctFromComparison(evaluateValue(expression.left), evaluateValue(expression.right));
       return operator === "IS DISTINCT FROM" ? distinct : !distinct;
     }
-    const left = evaluateValue(expression.left);
-    const right = evaluateValue(expression.right);
-    if (left === null || left === void 0 || right === null || right === void 0)
+    const evaluatedLeft = evaluateValue(expression.left);
+    const evaluatedRight = evaluateValue(expression.right);
+    if (evaluatedLeft === null || evaluatedLeft === void 0 || evaluatedRight === null || evaluatedRight === void 0) {
       return null;
+    }
+    const [left, right] = coerceComparisonOperands(evaluatedLeft, evaluatedRight);
     const a = comparable(left);
     const b = comparable(right);
     if (operator === "=")
@@ -4063,6 +4887,15 @@ function validateGrouping(plan) {
       throw new TypeError(`Selected column must appear in GROUP BY: ${item.alias}`);
     }
   }
+  for (const predicate of plan.having) {
+    for (const side of [predicate.left, predicate.right]) {
+      if (hasAggregate(side) || expressionColumns(side).length === 0)
+        continue;
+      if (!groupedExpression(side, groupExpressions)) {
+        throw new TypeError("HAVING conditions must use aggregates, literals, or GROUP BY expressions");
+      }
+    }
+  }
   const forbiddenAggregates = [
     ...plan.joins.flatMap((join) => [
       join.left,
@@ -4150,8 +4983,9 @@ function externalizeQueryResult(result) {
     for (let position = 0; position < result.columns.length; position += 1) {
       const name = result.columns[position] ?? "";
       const value = row[name];
-      if (value !== void 0 && !isSqlDomainValue(value))
+      if (value !== void 0 && !isSqlDomainValue(value) && !(typeof value === "number" && result.columnDomains[position]?.kind === "numeric")) {
         continue;
+      }
       const external = asQueryValue(externalSqlDomainColumnValue(value, result.columnDomains[position]));
       if (external === value)
         continue;
@@ -4234,6 +5068,12 @@ class Parser {
       }
       const columns = this.#cteColumnList();
       this.#keyword("AS");
+      if (this.#isKeyword("NOT")) {
+        this.#keyword("NOT");
+        this.#keyword("MATERIALIZED");
+      } else if (this.#isKeyword("MATERIALIZED")) {
+        this.#keyword("MATERIALIZED");
+      }
       this.#expectPunctuation("(");
       if (recursive) {
         this.#recursiveCte(name, columns);
@@ -4325,7 +5165,9 @@ class Parser {
     return plan;
   }
   #compoundTail() {
-    return { orderBy: this.#orderByClause(), ...this.#tailClauses() };
+    const tail = { orderBy: this.#orderByClause(), ...this.#tailClauses() };
+    this.#lockingClause();
+    return tail;
   }
   #setTerm(sql, member) {
     const first = this.#unionMember(sql, member);
@@ -4514,6 +5356,22 @@ class Parser {
           nullable = false;
           continue;
         }
+        if (this.#isKeyword("CONSTRAINT")) {
+          this.#keyword("CONSTRAINT");
+          const constraintName = this.#identifier();
+          if (this.#isKeyword("CHECK")) {
+            checks.push(this.#checkConstraint(constraintName));
+            continue;
+          }
+          if (this.#isKeyword("REFERENCES")) {
+            foreignKeys.push(this.#references(constraintName, [name]));
+            continue;
+          }
+          if (this.#isKeyword("PRIMARY") || this.#isKeyword("UNIQUE") || this.#isKeyword("NOT") || this.#isKeyword("NULL")) {
+            continue;
+          }
+          throw new TypeError(`Expected a constraint after CONSTRAINT ${constraintName}`);
+        }
         if (this.#isKeyword("CHECK")) {
           checks.push(this.#checkConstraint(`${table}_${name}_check`));
           continue;
@@ -4890,6 +5748,7 @@ class Parser {
       return `numeric:${precision === void 0 ? "" : String(precision)}:${scale === void 0 ? "" : String(scale)}`;
     }
     if (["JSON", "JSONB", "UUID", "DATE", "TIME", "INTERVAL"].includes(word)) {
+      this.#multiWordTypeTail(word);
       return word.toLowerCase();
     }
     if (word === "DOUBLE") {
@@ -4899,14 +5758,27 @@ class Parser {
     const mapped = createTableTypeNames.get(word);
     if (mapped === void 0)
       throw new TypeError(`Unsupported CAST target: ${word}`);
+    this.#multiWordTypeTail(word);
     if (this.#punctuation("(")) {
       this.#typeWidth();
       if (this.#punctuation(","))
         this.#typeWidth();
       this.#expectPunctuation(")");
     }
-    const integer = word === "INTEGER" || word === "INT" || word === "BIGINT" || word === "SMALLINT";
-    return integer ? "number-integer" : mapped;
+    return integerTypeNames.has(word) ? "number-integer" : mapped;
+  }
+  #multiWordTypeTail(word) {
+    if (word === "CHARACTER" && this.#isKeyword("VARYING")) {
+      this.#keyword("VARYING");
+      return true;
+    }
+    if ((word === "TIMESTAMP" || word === "TIME") && (this.#isKeyword("WITH") || this.#isKeyword("WITHOUT"))) {
+      this.#keyword(this.#isKeyword("WITH") ? "WITH" : "WITHOUT");
+      this.#keyword("TIME");
+      this.#keyword("ZONE");
+      return true;
+    }
+    return false;
   }
   #columnType() {
     const declared = this.#identifier();
@@ -4932,6 +5804,7 @@ class Parser {
       };
     }
     if (["JSON", "JSONB", "UUID", "DATE", "TIME", "INTERVAL"].includes(word)) {
+      this.#multiWordTypeTail(word);
       return { type: "string", sqlDomain: { kind: word.toLowerCase() } };
     }
     if (word === "DOUBLE") {
@@ -4942,6 +5815,7 @@ class Parser {
     if (mapped === void 0) {
       return { type: "string", sqlDomain: { kind: "enum", name: declared, values: [] } };
     }
+    const multiWord = this.#multiWordTypeTail(word);
     if (this.#punctuation("(")) {
       this.#typeWidth();
       if (this.#punctuation(",")) {
@@ -4949,12 +5823,11 @@ class Parser {
       }
       this.#expectPunctuation(")");
     }
-    if (this.#punctuation("[")) {
+    if (!multiWord && this.#punctuation("[")) {
       this.#expectPunctuation("]");
       return { type: "string", sqlDomain: { kind: "array", element: word } };
     }
-    const integer = word === "INTEGER" || word === "INT" || word === "BIGINT" || word === "SMALLINT";
-    return { type: mapped, ...integer ? { integer: true } : {} };
+    return { type: mapped, ...integerTypeNames.has(word) ? { integer: true } : {} };
   }
   parseMutation(keyword) {
     const statement = keyword === "INSERT" ? this.#insertStatement() : keyword === "UPDATE" ? this.#updateStatement() : this.#deleteStatement();
@@ -4993,6 +5866,7 @@ class Parser {
     }
     if (this.#isKeyword("SELECT") || this.#isKeyword("WITH") || this.#peek().text === "(") {
       const insertSource = this.#queryExpression("(insert select)");
+      annotatePlanIntegerDivision(insertSource);
       resolvePlanExactNumericConstants(insertSource);
       const query = planHasPendingSelectShapes(insertSource) ? insertSource : optimizePlan(insertSource);
       if (!planHasPendingSelectShapes(query) && !query.select.some((item) => item.expression.kind === "wildcard") && columns.length > 0 && query.select.length !== columns.length) {
@@ -5312,6 +6186,7 @@ class Parser {
     if (new Set(assignments.map(({ column }) => column)).size !== assignments.length) {
       throw new TypeError("UPDATE assignments must set each column once");
     }
+    const from = this.#mutationSources("FROM");
     const predicates = this.#mutationPredicates();
     return {
       kind: "update",
@@ -5319,20 +6194,31 @@ class Parser {
       ...alias === void 0 ? {} : { alias },
       assignments,
       predicates,
+      ...from === void 0 ? {} : { from },
       ...this.#returningClause(table, alias)
     };
   }
+  #mutationSources(keyword) {
+    if (!this.#isKeyword(keyword))
+      return void 0;
+    this.#keyword(keyword);
+    const groupConditions = [];
+    const { base, joins } = this.#joinedSources([], groupConditions);
+    return { base, joins, predicates: groupConditions.flatMap(splitCondition) };
+  }
   #deleteStatement() {
     this.#keyword("DELETE");
     this.#keyword("FROM");
     const table = this.#identifier();
-    const alias = this.#mutationAlias("WHERE", "RETURNING");
+    const alias = this.#mutationAlias("WHERE", "USING", "RETURNING");
+    const from = this.#mutationSources("USING");
     const predicates = this.#mutationPredicates();
     return {
       kind: "delete",
       table,
       ...alias === void 0 ? {} : { alias },
       predicates,
+      ...from === void 0 ? {} : { from },
       ...this.#returningClause(table, alias)
     };
   }
@@ -5386,9 +6272,9 @@ class Parser {
     }
     const needsExecution = (value) => value.kind === "subquery" || value.kind === "exists" || value.kind === "call" && (statementDatetimeNames.has(value.name) || value.name === "NEXTVAL" || value.name === "CURRVAL" || volatileScalarFunctionNames.has(value.name)) || childExpressions(value).some(needsExecution);
     if (needsExecution(expression)) {
-      return { expression: resolveExactNumericConstants(expression) };
+      return { expression: resolveStatementExpression(expression) };
     }
-    return asQueryValue(evaluate(resolveExactNumericConstants(expression), {}));
+    return asQueryValue(evaluate(resolveStatementExpression(expression), {}));
   }
   #unionMember(sql, member) {
     if (this.#punctuation("(")) {
@@ -5436,6 +6322,10 @@ class Parser {
   #limitClause() {
     if (this.#isKeyword("LIMIT")) {
       this.#keyword("LIMIT");
+      if (this.#isKeyword("ALL")) {
+        this.#keyword("ALL");
+        return {};
+      }
       if (this.#peek().kind === "parameter") {
         const parameter = this.#parameterExpression();
         return { limitParameter: parameter.index };
@@ -5488,6 +6378,37 @@ class Parser {
       this.#keyword("ROW");
     return result;
   }
+  #lockingClause() {
+    while (this.#isKeyword("FOR")) {
+      this.#keyword("FOR");
+      if (this.#isKeyword("UPDATE"))
+        this.#keyword("UPDATE");
+      else if (this.#isKeyword("SHARE"))
+        this.#keyword("SHARE");
+      else if (this.#isKeyword("NO")) {
+        this.#keyword("NO");
+        this.#keyword("KEY");
+        this.#keyword("UPDATE");
+      } else if (this.#isKeyword("KEY")) {
+        this.#keyword("KEY");
+        this.#keyword("SHARE");
+      } else {
+        throw new TypeError(`Expected UPDATE or SHARE after FOR, found ${this.#peek().text}`);
+      }
+      if (this.#isKeyword("OF")) {
+        this.#keyword("OF");
+        this.#identifier();
+        while (this.#punctuation(","))
+          this.#identifier();
+      }
+      if (this.#isKeyword("NOWAIT"))
+        this.#keyword("NOWAIT");
+      else if (this.#isKeyword("SKIP")) {
+        this.#keyword("SKIP");
+        this.#keyword("LOCKED");
+      }
+    }
+  }
   #tailClauses() {
     if (this.#isKeyword("LIMIT")) {
       return { ...this.#limitClause(), ...this.#offsetClause() };
@@ -5561,33 +6482,216 @@ class Parser {
     this.#compoundMember = false;
     this.#keyword("SELECT");
     let distinct = false;
+    let distinctOn;
     if (this.#isKeyword("DISTINCT")) {
       this.#keyword("DISTINCT");
-      distinct = true;
+      if (this.#isKeyword("ON")) {
+        this.#keyword("ON");
+        this.#expectPunctuation("(");
+        distinctOn = this.#expressionList();
+        this.#expectPunctuation(")");
+      } else {
+        distinct = true;
+      }
+    } else if (this.#isKeyword("ALL")) {
+      this.#keyword("ALL");
     }
     const select = this.#selectList();
     let base;
+    let joins = [];
+    const groupConditions = [];
     if (this.#isKeyword("FROM")) {
       this.#keyword("FROM");
-      base = this.#source();
+      ({ base, joins } = this.#joinedSources(select, groupConditions));
     } else {
       if (select.some((item) => item.expression.kind === "wildcard")) {
         throw new TypeError("SELECT * requires a FROM clause");
       }
       base = { table: DUAL_TABLE, alias: DUAL_TABLE };
     }
-    const joins = [];
-    let rightJoins = 0;
-    while (this.#peek().text === "," || this.#isKeyword("NATURAL") || this.#isKeyword("JOIN") || this.#isKeyword("INNER") || this.#isKeyword("LEFT") || this.#isKeyword("RIGHT") || this.#isKeyword("FULL") || this.#isKeyword("CROSS")) {
-      if (this.#punctuation(",")) {
-        joins.push(crossJoinPlan(this.#source()));
-        continue;
-      }
-      if (this.#isKeyword("CROSS")) {
-        this.#keyword("CROSS");
-        this.#keyword("JOIN");
-        joins.push(crossJoinPlan(this.#source()));
-        continue;
+    const predicates = groupConditions.flatMap(splitCondition);
+    if (this.#isKeyword("WHERE")) {
+      this.#keyword("WHERE");
+      predicates.push(...splitCondition(this.#expression()));
+    }
+    const groupBy = [];
+    let groupingSets;
+    if (this.#isKeyword("GROUP")) {
+      this.#keyword("GROUP");
+      this.#keyword("BY");
+      if (this.#isKeyword("GROUPING") || this.#isKeyword("ROLLUP") || this.#isKeyword("CUBE")) {
+        groupingSets = this.#groupingSets();
+      } else {
+        groupBy.push(...this.#expressionList());
+      }
+    }
+    const having = [];
+    if (this.#isKeyword("HAVING")) {
+      this.#keyword("HAVING");
+      having.push(...splitCondition(this.#expression()));
+    }
+    if (this.#isKeyword("WINDOW")) {
+      this.#keyword("WINDOW");
+      for (; ; ) {
+        this.#identifier();
+        this.#keyword("AS");
+        const definition = this.#namedWindows.get(this.tokens[this.#index - 2]?.text ?? "");
+        this.#index = definition?.end ?? this.#index;
+        if (!this.#punctuation(","))
+          break;
+      }
+    }
+    const orderBy = compoundMember ? [] : this.#orderByClause();
+    const tail = compoundMember ? {} : this.#tailClauses();
+    if (!compoundMember)
+      this.#lockingClause();
+    if (distinctOn !== void 0) {
+      return this.#distinctOnBlock(sql, distinctOn, { base, joins, select, predicates, groupBy, having, orderBy, groupingSets }, tail);
+    }
+    return assembleSelectBlock({
+      sql,
+      base,
+      joins,
+      select,
+      distinct,
+      predicates,
+      groupBy,
+      having,
+      orderBy,
+      ...tail,
+      ...groupingSets === void 0 ? {} : { groupingSets }
+    }, this.nextDerivedSequence);
+  }
+  #distinctOnBlock(sql, distinctOn, parts, tail) {
+    const rowNumberAlias = "\0distinct_on";
+    const innerSelect = [...parts.select];
+    const aliased = new Map(parts.select.filter((item) => item.expression.kind !== "wildcard").map((item) => [item.alias, item.expression]));
+    const windowExpression = (expression) => {
+      if (expression.kind === "column" && !expression.reference.includes(".")) {
+        const labelled = aliased.get(expression.reference);
+        if (labelled !== void 0)
+          return labelled;
+      }
+      return expression;
+    };
+    const outerOrderBy = [];
+    parts.orderBy.forEach((order, index) => {
+      const expression = order.expression;
+      const output = expression.kind === "column" && !expression.reference.includes(".") ? parts.select.find((item) => item.alias === expression.reference) : parts.select.find((item) => item.expression.kind !== "wildcard" && JSON.stringify(item.expression) === JSON.stringify(expression));
+      let alias = output?.alias;
+      if (alias === void 0) {
+        alias = `\0distinct_on_order_${String(index)}`;
+        innerSelect.push({ expression, alias });
+      }
+      outerOrderBy.push({ ...order, expression: { kind: "column", reference: alias } });
+    });
+    innerSelect.push({
+      expression: {
+        kind: "window",
+        name: "ROW_NUMBER",
+        partitionBy: distinctOn.map(windowExpression),
+        orderBy: parts.orderBy.map((order) => ({
+          ...order,
+          expression: windowExpression(order.expression)
+        }))
+      },
+      alias: rowNumberAlias
+    });
+    const inner = assembleSelectBlock({
+      sql: "(distinct on)",
+      base: parts.base,
+      joins: parts.joins,
+      select: innerSelect,
+      distinct: false,
+      predicates: parts.predicates,
+      groupBy: parts.groupBy,
+      having: parts.having,
+      orderBy: [],
+      ...parts.groupingSets === void 0 ? {} : { groupingSets: parts.groupingSets }
+    }, this.nextDerivedSequence);
+    const outerAlias = "(distinct on)";
+    const outerSelect = parts.select.map((item) => item.expression.kind === "wildcard" ? item : { expression: { kind: "column", reference: item.alias }, alias: item.alias });
+    return assembleSelectBlock({
+      sql,
+      base: this.#derivedSource(inner, outerAlias),
+      joins: [],
+      select: outerSelect,
+      distinct: false,
+      predicates: [
+        {
+          left: { kind: "column", reference: rowNumberAlias },
+          operator: "=",
+          right: { kind: "literal", value: 1 }
+        }
+      ],
+      groupBy: [],
+      having: [],
+      orderBy: outerOrderBy,
+      ...tail
+    }, this.nextDerivedSequence);
+  }
+  #groupingSets() {
+    if (this.#isKeyword("GROUPING")) {
+      this.#keyword("GROUPING");
+      this.#keyword("SETS");
+      this.#expectPunctuation("(");
+      const sets2 = [];
+      for (; ; ) {
+        this.#expectPunctuation("(");
+        const set = [];
+        if (!this.#punctuation(")")) {
+          set.push(...this.#expressionList());
+          this.#expectPunctuation(")");
+        }
+        sets2.push(set);
+        if (!this.#punctuation(","))
+          break;
+      }
+      this.#expectPunctuation(")");
+      return sets2;
+    }
+    const cube = this.#isKeyword("CUBE");
+    this.#keyword(cube ? "CUBE" : "ROLLUP");
+    this.#expectPunctuation("(");
+    const columns = this.#expressionList();
+    this.#expectPunctuation(")");
+    if (columns.length === 0)
+      throw new TypeError("ROLLUP/CUBE take at least one expression");
+    if (cube) {
+      if (columns.length > 5) {
+        throw new TypeError("CUBE supports at most 5 expressions (32 grouping sets)");
+      }
+      const sets2 = [];
+      for (let mask = (1 << columns.length) - 1; mask >= 0; mask -= 1) {
+        sets2.push(columns.filter((_, index) => (mask & 1 << index) !== 0));
+      }
+      return sets2;
+    }
+    const sets = [];
+    for (let length = columns.length; length >= 0; length -= 1) {
+      sets.push(columns.slice(0, length));
+    }
+    return sets;
+  }
+  #joinedSources(select, groupConditions) {
+    const first = this.#joinOperand(select, groupConditions);
+    let base = first.base;
+    const joins = [...first.joins];
+    let rightJoins = first.rightJoins;
+    while (this.#peek().text === "," || this.#isKeyword("NATURAL") || this.#isKeyword("JOIN") || this.#isKeyword("INNER") || this.#isKeyword("LEFT") || this.#isKeyword("RIGHT") || this.#isKeyword("FULL") || this.#isKeyword("CROSS")) {
+      if (this.#punctuation(",")) {
+        const operand2 = this.#joinOperand(select, groupConditions);
+        joins.push(crossJoinPlan(operand2.base), ...operand2.joins);
+        rightJoins += operand2.rightJoins;
+        continue;
+      }
+      if (this.#isKeyword("CROSS")) {
+        this.#keyword("CROSS");
+        this.#keyword("JOIN");
+        const operand2 = this.#joinOperand(select, groupConditions);
+        joins.push(crossJoinPlan(operand2.base), ...operand2.joins);
+        rightJoins += operand2.rightJoins;
+        continue;
       }
       let kind = "inner";
       let right = false;
@@ -5614,7 +6718,21 @@ class Parser {
       if (this.#isKeyword("OUTER"))
         this.#keyword("OUTER");
       this.#keyword("JOIN");
-      const source = this.#source();
+      const operand = this.#joinOperand(select, groupConditions);
+      if (operand.group) {
+        if (natural || right || full || kind === "left") {
+          throw new TypeError("A parenthesized join can only follow a comma, CROSS JOIN, or INNER JOIN");
+        }
+        if (this.#isKeyword("USING")) {
+          throw new TypeError("A parenthesized join takes an ON condition, not USING");
+        }
+        this.#keyword("ON");
+        groupConditions.push(this.#expression());
+        joins.push(crossJoinPlan(operand.base), ...operand.joins);
+        rightJoins += operand.rightJoins;
+        continue;
+      }
+      const source = operand.base;
       if (natural) {
         if (this.#isKeyword("ON") || this.#isKeyword("USING")) {
           throw new TypeError("A NATURAL join takes no ON or USING clause");
@@ -5674,95 +6792,58 @@ class Parser {
         }
       }
     }
-    const predicates = [];
-    if (this.#isKeyword("WHERE")) {
-      this.#keyword("WHERE");
-      predicates.push(...splitCondition(this.#expression()));
-    }
-    const groupBy = [];
-    let groupingSets;
-    if (this.#isKeyword("GROUP")) {
-      this.#keyword("GROUP");
-      this.#keyword("BY");
-      if (this.#isKeyword("GROUPING") || this.#isKeyword("ROLLUP") || this.#isKeyword("CUBE")) {
-        groupingSets = this.#groupingSets();
-      } else {
-        groupBy.push(...this.#expressionList());
-      }
-    }
-    const having = [];
-    if (this.#isKeyword("HAVING")) {
-      this.#keyword("HAVING");
-      having.push(...splitCondition(this.#expression()));
-    }
-    if (this.#isKeyword("WINDOW")) {
-      this.#keyword("WINDOW");
-      for (; ; ) {
-        this.#identifier();
-        this.#keyword("AS");
-        const definition = this.#namedWindows.get(this.tokens[this.#index - 2]?.text ?? "");
-        this.#index = definition?.end ?? this.#index;
-        if (!this.#punctuation(","))
-          break;
-      }
+    if (rightJoins > 0 && joins.length !== 1) {
+      throw new TypeError("RIGHT JOIN is only supported as the sole join");
     }
-    const orderBy = compoundMember ? [] : this.#orderByClause();
-    return assembleSelectBlock({
-      sql,
-      base,
-      joins,
-      select,
-      distinct,
-      predicates,
-      groupBy,
-      having,
-      orderBy,
-      ...compoundMember ? {} : this.#tailClauses(),
-      ...groupingSets === void 0 ? {} : { groupingSets }
-    }, this.nextDerivedSequence);
+    return { base, joins, rightJoins };
   }
-  #groupingSets() {
-    if (this.#isKeyword("GROUPING")) {
-      this.#keyword("GROUPING");
-      this.#keyword("SETS");
+  #joinOperand(select, groupConditions) {
+    const next = this.#peek();
+    if (next.kind === "punctuation" && next.text === "(" && this.#parenthesizedJoinAhead()) {
       this.#expectPunctuation("(");
-      const sets2 = [];
-      for (; ; ) {
-        this.#expectPunctuation("(");
-        const set = [];
-        if (!this.#punctuation(")")) {
-          set.push(...this.#expressionList());
-          this.#expectPunctuation(")");
-        }
-        sets2.push(set);
-        if (!this.#punctuation(","))
-          break;
-      }
+      const inner = this.#joinedSources(select, groupConditions);
       this.#expectPunctuation(")");
-      return sets2;
-    }
-    const cube = this.#isKeyword("CUBE");
-    this.#keyword(cube ? "CUBE" : "ROLLUP");
-    this.#expectPunctuation("(");
-    const columns = this.#expressionList();
-    this.#expectPunctuation(")");
-    if (columns.length === 0)
-      throw new TypeError("ROLLUP/CUBE take at least one expression");
-    if (cube) {
-      if (columns.length > 5) {
-        throw new TypeError("CUBE supports at most 5 expressions (32 grouping sets)");
+      if (this.#sourceAlias() !== void 0) {
+        throw new TypeError("A parenthesized join cannot take an alias");
       }
-      const sets2 = [];
-      for (let mask = (1 << columns.length) - 1; mask >= 0; mask -= 1) {
-        sets2.push(columns.filter((_, index) => (mask & 1 << index) !== 0));
-      }
-      return sets2;
+      return { ...inner, group: true };
     }
-    const sets = [];
-    for (let length = columns.length; length >= 0; length -= 1) {
-      sets.push(columns.slice(0, length));
+    return { base: this.#source(), joins: [], rightJoins: 0, group: false };
+  }
+  #parenthesizedJoinAhead() {
+    let cursor = this.#index;
+    let first = this.tokens[cursor];
+    while (first?.kind === "punctuation" && first.text === "(") {
+      cursor += 1;
+      first = this.tokens[cursor];
     }
-    return sets;
+    if (first?.kind !== "identifier")
+      return false;
+    const keyword = first.quoted === true ? "" : first.text.toUpperCase();
+    if (keyword !== "SELECT" && keyword !== "VALUES" && keyword !== "WITH")
+      return true;
+    if (cursor === this.#index + 1)
+      return false;
+    let depth = 0;
+    for (let index = this.#index; index < this.tokens.length; index += 1) {
+      const token = this.tokens[index];
+      if (token?.kind !== "punctuation")
+        continue;
+      if (token.text === "(")
+        depth += 1;
+      else if (token.text === ")") {
+        depth -= 1;
+        if (depth > 0)
+          continue;
+        const next = this.tokens[index + 1];
+        if (next?.kind !== "identifier")
+          return true;
+        if (next.quoted === true || next.text.toUpperCase() === "AS")
+          return false;
+        return clauseKeywords.has(next.text.toUpperCase()) || next.text.toUpperCase() === "ON";
+      }
+    }
+    return false;
   }
   #selectList() {
     const items = [];
@@ -5775,6 +6856,9 @@ class Parser {
         this.#keyword("AS");
         alias = this.#identifier();
         explicitAlias = true;
+      } else if (this.#bareLabelAhead()) {
+        alias = this.#identifier();
+        explicitAlias = true;
       }
       items.push({ expression, alias });
       explicitAliases.push(explicitAlias);
@@ -6060,6 +7144,12 @@ class Parser {
     }
     return { table, alias };
   }
+  #bareLabelAhead() {
+    const token = this.#peek();
+    if (token.kind !== "identifier")
+      return false;
+    return token.quoted === true || !bareLabelStopWords.has(token.text.toUpperCase());
+  }
   #sourceAlias() {
     if (this.#isKeyword("AS")) {
       this.#keyword("AS");
@@ -6324,6 +7414,14 @@ class Parser {
       }
       return { kind: "condition", operator, left, right: { kind: "list", items } };
     }
+    const likeSpelling = this.#peek();
+    if (likeSpelling.kind === "operator" && /^!?~~\*?$/.test(likeSpelling.text)) {
+      this.#index += 1;
+      const negatedSpelling = likeSpelling.text.startsWith("!") !== negated;
+      const insensitiveSpelling = likeSpelling.text.endsWith("*");
+      const operator = insensitiveSpelling ? negatedSpelling ? "NOT ILIKE" : "ILIKE" : negatedSpelling ? "NOT LIKE" : "LIKE";
+      return { kind: "condition", operator, left, right: this.#additive() };
+    }
     if (this.#isKeyword("LIKE") || this.#isKeyword("ILIKE")) {
       const insensitive = this.#isKeyword("ILIKE");
       this.#keyword(insensitive ? "ILIKE" : "LIKE");
@@ -6522,8 +7620,9 @@ class Parser {
         throw new SqlCompileError(error instanceof Error ? error.message : `Invalid number: ${token.text}`, token.start, token.end - token.start);
       }
       const fits = exactNumericAsNumber(tagged);
-      if (fits !== void 0)
-        return { kind: "literal", value: fits, exactText: token.text };
+      if (fits !== void 0) {
+        return { kind: "literal", value: fits, exactText: token.text, decimal: true };
+      }
       return {
         kind: "literal",
         value: tagged,
@@ -6688,6 +7787,10 @@ class Parser {
           args.push(this.#expression());
         }
         this.#expectPunctuation(")");
+        const pattern = args[1];
+        if (args.length === 2 && pattern?.kind === "literal" && typeof pattern.value === "string") {
+          return { kind: "call", name: "REGEXP_SUBSTR", arguments: args };
+        }
         return { kind: "call", name: "SUBSTR", arguments: args };
       }
       this.#index = restore;
@@ -6892,8 +7995,18 @@ class Parser {
           ...fallback === null ? {} : { fallback }
         };
       }
-      if (upper === "JSON_OBJECT")
+      if (upper === "JSON_OBJECT" || upper === "JSON_BUILD_OBJECT" || upper === "JSONB_BUILD_OBJECT") {
         return this.#jsonObject();
+      }
+      if (upper === "DATE") {
+        const operand = this.#expression();
+        this.#expectPunctuation(")");
+        return {
+          kind: "call",
+          name: "CAST",
+          arguments: [operand, { kind: "literal", value: "date" }]
+        };
+      }
       if (statisticalAggregates.has(upper))
         return this.#statisticalAggregate(upper);
       if (upper === "EVERY" || upper === "BOOL_AND" || upper === "BOOL_OR") {
@@ -7011,6 +8124,10 @@ class Parser {
       }
       if (name === "SUBSTR" && (args.length < 2 || args.length > 3))
         throw new TypeError("SUBSTR requires a string, a start, and an optional length");
+      const substringPattern = args[1];
+      if (upper === "SUBSTRING" && args.length === 2 && substringPattern?.kind === "literal" && typeof substringPattern.value === "string") {
+        return { kind: "call", name: "REGEXP_SUBSTR", arguments: args };
+      }
       if (name === "DATE_TRUNC") {
         if (args.length !== 2)
           throw new TypeError("DATE_TRUNC requires a unit and a datetime argument");
@@ -7491,6 +8608,105 @@ function resolveGroupByReferences(groupBy, select) {
     return structuredClone(item.expression);
   });
 }
+function unifyGroupedReferences(block, resolve) {
+  const groupingReferences = [...block.groupBy, ...(block.groupingSets ?? []).flat()].flatMap((expression) => expression.kind === "column" ? [expression.reference] : []);
+  if (groupingReferences.length === 0)
+    return block;
+  const spelled = new Set(groupingReferences);
+  const bareNames = new Set(groupingReferences.map(bareColumnName));
+  const candidate = (expression) => expressionColumns(expression).some((reference) => !spelled.has(reference) && bareNames.has(bareColumnName(reference)));
+  const aliases = new Set(block.select.map((item) => item.alias));
+  const orderCandidates = block.orderBy.filter((order) => !(order.expression.kind === "column" && aliases.has(order.expression.reference)));
+  if (!block.select.some((item) => candidate(item.expression)) && !block.having.some((predicate) => candidate(predicate.left) || candidate(predicate.right)) && !orderCandidates.some((order) => candidate(order.expression)) && !groupingReferences.some((reference) => !spelled.has(reference))) {
+    return block;
+  }
+  const spellings = /* @__PURE__ */ new Map();
+  for (const reference of groupingReferences) {
+    const column = resolve(reference);
+    if (column !== void 0 && !spellings.has(column))
+      spellings.set(column, reference);
+  }
+  if (spellings.size === 0)
+    return block;
+  let respelled = 0;
+  const respell = (expression) => {
+    if (expression.kind === "column") {
+      const column = resolve(expression.reference);
+      const spelling = column === void 0 ? void 0 : spellings.get(column);
+      if (spelling === void 0 || spelling === expression.reference)
+        return expression;
+      respelled += 1;
+      return { ...expression, reference: spelling };
+    }
+    if (expression.kind === "subquery" || expression.kind === "exists")
+      return expression;
+    if (expression.kind === "window") {
+      return {
+        ...expression,
+        partitionBy: expression.partitionBy.map(respell),
+        orderBy: expression.orderBy.map((order) => ({
+          ...order,
+          expression: respell(order.expression)
+        })),
+        ...expression.argument === void 0 ? {} : { argument: respell(expression.argument) }
+      };
+    }
+    return mapChildExpressions(expression, respell);
+  };
+  const unified = {
+    ...block,
+    select: block.select.map((item) => ({ ...item, expression: respell(item.expression) })),
+    groupBy: block.groupBy.map(respell),
+    having: block.having.map((predicate) => ({
+      ...predicate,
+      left: respell(predicate.left),
+      right: respell(predicate.right)
+    })),
+    orderBy: block.orderBy.map((order) => order.expression.kind === "column" && aliases.has(order.expression.reference) ? order : { ...order, expression: respell(order.expression) }),
+    ...block.groupingSets === void 0 ? {} : { groupingSets: block.groupingSets.map((set) => set.map(respell)) }
+  };
+  return respelled > 0 ? unified : block;
+}
+function bareColumnName(reference) {
+  const separator = reference.indexOf(".");
+  return separator === -1 ? reference : reference.slice(separator + 1);
+}
+function unifyBlockGroupedReferences(parts) {
+  if (parts.joins.length > 0 || parts.base.table === DUAL_TABLE)
+    return parts;
+  const alias = parts.base.alias;
+  return unifyGroupedReferences(parts, (reference) => {
+    const separator = reference.indexOf(".");
+    if (separator === -1)
+      return `${alias}.${reference}`;
+    return reference.slice(0, separator) === alias ? reference : void 0;
+  });
+}
+function unifyPlanGroupedReferences(plan, columnsOf) {
+  if (plan.joins.length === 0 || plan.groupBy.length === 0)
+    return plan;
+  const sources = [plan.base, ...plan.joins];
+  const aliases = new Set(sources.map((source) => source.alias));
+  let columnsBySource;
+  return unifyGroupedReferences(plan, (reference) => {
+    const separator = reference.indexOf(".");
+    if (separator !== -1)
+      return aliases.has(reference.slice(0, separator)) ? reference : void 0;
+    columnsBySource ??= new Map(sources.map((source) => [
+      source.alias,
+      new Set(sourceWildcardColumns(source, columnsOf) ?? [])
+    ]));
+    let owner;
+    for (const [alias, columns] of columnsBySource) {
+      if (!columns.has(reference))
+        continue;
+      if (owner !== void 0)
+        return void 0;
+      owner = alias;
+    }
+    return owner === void 0 ? void 0 : `${owner}.${reference}`;
+  });
+}
 function desugarFullJoin(parts, nextSequence) {
   const join = parts.joins[0];
   if (parts.joins.length !== 1 || join?.full !== true) {
@@ -7591,6 +8807,7 @@ function assembleSelectBlock(parts, nextSequence) {
       groupingSets: parts.groupingSets.map((set) => resolveGroupByReferences(set, parts.select))
     }
   };
+  parts = unifyBlockGroupedReferences(parts);
   if (parts.joins.some((join) => join.full === true)) {
     return desugarFullJoin(parts, nextSequence);
   }
@@ -7646,18 +8863,6 @@ function assembleSelectBlock(parts, nextSequence) {
     const grouped = parts.groupBy.length > 0 || select.some((item) => hasAggregate(item.expression));
     if (!grouped)
       throw new TypeError("HAVING requires GROUP BY or aggregate functions");
-    const groupExpressions = new Set(groupBy.map((expression) => JSON.stringify(expression)));
-    for (const predicate of having) {
-      for (const side of [predicate.left, predicate.right]) {
-        if (hasAggregate(side))
-          continue;
-        if (expressionColumns(side).length === 0)
-          continue;
-        if (groupExpressions.has(JSON.stringify(side)))
-          continue;
-        throw new TypeError("HAVING conditions must use aggregates, literals, or GROUP BY expressions");
-      }
-    }
   }
   const clauseExpressions = [
     ...predicates.flatMap((predicate) => [predicate.left, predicate.right]),
@@ -8263,8 +9468,11 @@ function assembleOrderByExpressionBlock(parts, nextSequence) {
     orderBy: []
   };
 }
+function blockHasRowWindow(block) {
+  return block.limit !== void 0 || block.offset !== void 0 || block.limitParameter !== void 0 || block.offsetParameter !== void 0;
+}
 function transparentProjectionSource(plan) {
-  if (plan.joins.length > 0 || plan.predicates.length > 0 || plan.groupBy.length > 0 || plan.having.length > 0 || plan.orderBy.length > 0 || plan.limit !== void 0 || plan.offset !== void 0) {
+  if (plan.joins.length > 0 || plan.predicates.length > 0 || plan.groupBy.length > 0 || plan.having.length > 0 || plan.orderBy.length > 0 || blockHasRowWindow(plan)) {
     return void 0;
   }
   const inner = plan.base.derived;
@@ -8560,6 +9768,59 @@ function tokenize(sql) {
       index += 1;
       continue;
     }
+    if ((character === "E" || character === "e") && sql[index + 1] === "'") {
+      const start = index;
+      index += 2;
+      let value = "";
+      let closed = false;
+      while (index < sql.length) {
+        const current = sql[index] ?? "";
+        if (current === "'" && sql[index + 1] === "'") {
+          value += "'";
+          index += 2;
+        } else if (current === "'") {
+          index += 1;
+          closed = true;
+          break;
+        } else if (current === "\\") {
+          const next = sql[index + 1] ?? "";
+          const simple = /* @__PURE__ */ new Map([
+            ["n", "\n"],
+            ["t", "	"],
+            ["r", "\r"],
+            ["b", "\b"],
+            ["f", "\f"]
+          ]);
+          const escaped = simple.get(next);
+          if (escaped !== void 0) {
+            value += escaped;
+            index += 2;
+          } else if (next === "x" && /[0-9A-Fa-f]/.test(sql[index + 2] ?? "")) {
+            const hex = /^[0-9A-Fa-f]{1,2}/.exec(sql.slice(index + 2, index + 4))?.[0] ?? "";
+            value += String.fromCharCode(Number.parseInt(hex, 16));
+            index += 2 + hex.length;
+          } else if (next === "u" && /^[0-9A-Fa-f]{4}/.test(sql.slice(index + 2, index + 6))) {
+            value += String.fromCharCode(Number.parseInt(sql.slice(index + 2, index + 6), 16));
+            index += 6;
+          } else if (/[0-7]/.test(next)) {
+            const octal = /^[0-7]{1,3}/.exec(sql.slice(index + 1, index + 4))?.[0] ?? "";
+            value += String.fromCharCode(Number.parseInt(octal, 8));
+            index += 1 + octal.length;
+          } else {
+            value += next;
+            index += 2;
+          }
+        } else {
+          value += current;
+          index += 1;
+        }
+      }
+      if (!closed) {
+        throw new SqlCompileError("Unterminated string literal", start, sql.length - start);
+      }
+      push({ kind: "string", text: value, start, end: index });
+      continue;
+    }
     if (/[A-Za-z_]/.test(character)) {
       const start = index++;
       while (index < sql.length && /[A-Za-z0-9_]/.test(sql[index] ?? ""))
@@ -8567,7 +9828,7 @@ function tokenize(sql) {
       push({ kind: "identifier", text: sql.slice(start, index), start, end: index });
       continue;
     }
-    if (/\d/.test(character)) {
+    if (/\d/.test(character) || character === "." && /\d/.test(sql[index + 1] ?? "")) {
       const start = index;
       const radix = { x: 16, o: 8, b: 2 }[(sql[index + 1] ?? "").toLowerCase()];
       if (character === "0" && radix !== void 0) {
@@ -8593,9 +9854,10 @@ function tokenize(sql) {
             index += 1;
         }
       }
-      const text = sql.slice(start, index);
+      const spelled = sql.slice(start, index);
+      const text = spelled.startsWith(".") ? `0${spelled}` : /^\d+\.(?:[eE][+-]?\d+)?$/.test(spelled) ? spelled.replace(".", ".0") : spelled;
       if (!validNumericLiteral(text, 10))
-        throw new SqlCompileError(`Invalid number: ${text}`, start, index - start);
+        throw new SqlCompileError(`Invalid number: ${spelled}`, start, index - start);
       push({ kind: "number", text: text.replaceAll("_", ""), start, end: index });
       continue;
     }
@@ -8650,6 +9912,18 @@ function tokenize(sql) {
     }
     if (character === "$") {
       const start = index++;
+      const tagMatch = /^\$([A-Za-z_][A-Za-z0-9_]*)?\$/.exec(sql.slice(start));
+      if (tagMatch !== null) {
+        const tag = tagMatch[0];
+        const bodyStart = start + tag.length;
+        const close = sql.indexOf(tag, bodyStart);
+        if (close === -1) {
+          throw new SqlCompileError("Unterminated dollar-quoted string", start, sql.length - start);
+        }
+        push({ kind: "string", text: sql.slice(bodyStart, close), start, end: close + tag.length });
+        index = close + tag.length;
+        continue;
+      }
       while (index < sql.length && /\d/.test(sql[index] ?? ""))
         index += 1;
       const digits = sql.slice(start + 1, index);
@@ -8683,6 +9957,17 @@ function tokenize(sql) {
       index += 3;
       continue;
     }
+    const likeOperator = /^!?~~\*?/.exec(sql.slice(index, index + 4))?.[0];
+    if (likeOperator !== void 0) {
+      push({
+        kind: "operator",
+        text: likeOperator,
+        start: index,
+        end: index + likeOperator.length
+      });
+      index += likeOperator.length;
+      continue;
+    }
     if ([">=", "<=", "!=", "<>", "||", "->"].includes(pair)) {
       push({ kind: "operator", text: pair, start: index, end: index + 2 });
       index += 2;
@@ -8732,11 +10017,14 @@ function validateSqlSource(sql) {
 export {
   DUAL_TABLE,
   annotateAvgArgumentScales,
+  annotateIntegerDivision,
+  annotatePlanIntegerDivision,
   applyWindowFunctions,
   assembleSelectBlock,
   bindPendingSelectShapes,
   bindPlanParameters,
   bindStatementParameters,
+  blockHasRowWindow,
   blockHasSubqueries,
   cachedListMembership,
   childExpressions,
@@ -8763,17 +10051,22 @@ export {
   executeRowQuery,
   expandFtsColumns,
   expandNaturalJoins,
+  expandRowReferences,
   expandSourceColumnAliases,
   expandViewSources,
   expressionAliases,
   expressionColumnNames,
   expressionColumns,
+  extendGroupByWithKeyDependents,
   externalizeQueryResult,
+  foldIdentifierCase,
   forEachBlockExpression,
   forEachNestedBlock,
   hasAggregate,
   inferBlockSchema,
   inferResultColumnDomains,
+  integerQuotient,
+  integerTypedExpression,
   isAggregateCall,
   isDefaultInsertValue,
   isDeferredInsertExpression,
@@ -8788,6 +10081,7 @@ export {
   planHasNaturalJoins,
   planHasPendingSelectShapes,
   planHasSourceColumnAliases,
+  planMayHaveIntegerDivision,
   planReadsBeyondSingleScan,
   planReadsTable,
   planReadsViews,
@@ -8804,6 +10098,7 @@ export {
   subqueryResolutionSteps,
   topLevelFtsMatchConjuncts,
   transparentProjectionSource,
+  unifyPlanGroupedReferences,
   unknownColumnDomains,
   validateDefaultExpression,
   validateLimit,