@rex0220/kintone-sql-tools 3.57.0 → 3.59.0

package/dist-cli/ksql.js

@@ -1169,6 +1169,12 @@ var Parser = class {
         if (upper === "DROP") return this.parseDropTempTable();
         if (upper === "DECLARE") return this.parseDeclareVariable();
         if (upper === "VALIDATE") return this.parseValidate();
+        if (upper === "GENERATE_SERIES") {
+          throw new ParseError(
+            "GENERATE_SERIES \u306F WITH \u306E CTE \u672C\u4F53\u306B\u66F8\u3044\u3066\u304F\u3060\u3055\u3044\u3002\u4F8B: WITH s AS (GENERATE_SERIES(1, 5)) SELECT generate_series FROM s",
+            tok
+          );
+        }
         if (upper === "IMPORT") {
           if (!this.capabilities.import) {
             throw new ParseError("IMPORT is not supported (capability is disabled).", tok);
@@ -1928,6 +1934,8 @@ var Parser = class {
         query2 = this.parseShow();
       } else if (inner === "DESCRIBE" /* DESCRIBE */ || inner === "DESC" /* DESC */) {
         query2 = this.parseDescribe();
+      } else if (inner === "IDENT" /* IDENT */ && this.peek().value.toUpperCase() === "GENERATE_SERIES") {
+        query2 = this.parseGenerateSeries();
       } else {
         query2 = this.tryParseUnionChain(this.parseSelect());
       }
@@ -1939,6 +1947,43 @@ var Parser = class {
     this.cteNames.clear();
     return { type: "WITH", ctes, query };
   }
+  parseGenerateSeries() {
+    const name = this.advance();
+    if (name.kind !== "IDENT" /* IDENT */ || name.value.toUpperCase() !== "GENERATE_SERIES") {
+      throw new ParseError("GENERATE_SERIES \u304C\u5FC5\u8981\u3067\u3059", name);
+    }
+    this.expect("(" /* LPAREN */);
+    const args = [];
+    if (this.peek().kind !== ")" /* RPAREN */) {
+      do {
+        const tok = this.peek();
+        if (tok.kind === "STRING" /* STRING */) {
+          this.advance();
+          args.push({ type: "STRING", value: tok.value });
+          continue;
+        }
+        if (tok.kind === "VARIABLE" /* VARIABLE */) {
+          this.advance();
+          args.push({ type: "VARIABLE", name: tok.value.slice(1).toLowerCase() });
+          continue;
+        }
+        let sign = "";
+        if (tok.kind === "+" /* PLUS */ || tok.kind === "-" /* MINUS */) {
+          sign = tok.kind === "-" /* MINUS */ ? "-" : "+";
+          this.advance();
+        }
+        const number = this.peek();
+        if (number.kind !== "NUMBER" /* NUMBER */) {
+          throw new ParseError("GENERATE_SERIES \u306E\u5F15\u6570\u306B\u306F\u6570\u5024\u3001\u6587\u5B57\u5217\u3001\u307E\u305F\u306F\u30D0\u30C3\u30C1\u5909\u6570\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044", number);
+        }
+        this.advance();
+        args.push(makeNumberLiteral(`${sign}${number.value}`));
+      } while (this.consume("," /* COMMA */));
+    }
+    this.expect(")" /* RPAREN */);
+    const columnAlias = this.consume("AS" /* AS */) ? this.parseIdentifier() : "generate_series";
+    return { type: "GENERATE_SERIES", args, columnAlias };
+  }
   // ----------------------------------------------------------
   // UNION / UNION ALL チェーン
   // ----------------------------------------------------------
@@ -2923,6 +2968,12 @@ var Parser = class {
   // ----------------------------------------------------------
   parseTableRef() {
     const nameTok = this.peek();
+    if (nameTok.kind === "IDENT" /* IDENT */ && nameTok.value.toUpperCase() === "GENERATE_SERIES" && this.peekAt(1).kind === "(" /* LPAREN */) {
+      throw new ParseError(
+        "GENERATE_SERIES \u306F WITH \u306E CTE \u672C\u4F53\u306B\u66F8\u3044\u3066\u304F\u3060\u3055\u3044\u3002\u4F8B: WITH s AS (GENERATE_SERIES(1, 5)) SELECT generate_series FROM s",
+        nameTok
+      );
+    }
     const name = this.parseTableName();
     if (nameTok.kind === "IDENT" /* IDENT */ && name.startsWith("#")) {
       this.tempTableRefs.push(this.prev());
@@ -4698,7 +4749,9 @@ function completeInputReasons(stmt) {
       break;
     case "WITH":
       for (const cte of stmt.ctes) {
-        addReasons(reasons, completeInputReasons(cte.query));
+        if (cte.query.type !== "GENERATE_SERIES") {
+          addReasons(reasons, completeInputReasons(cte.query));
+        }
       }
       addReasons(reasons, completeInputReasons(stmt.query));
       break;
@@ -7649,11 +7702,231 @@ function assertStringFunctionArity(func, args) {
   }
 }
 
+// src/core/generateSeries.ts
+var GENERATE_SERIES_MAX_ROWS = 1e4;
+var argumentError = (message) => new Error(`ArgumentError: ${message}`);
+var isVariable = (arg) => arg.type === "VARIABLE";
+var isResolvedVariable = (arg) => arg?.type === "STRING" && arg.fromVariable === true;
+function literalValue(arg) {
+  return arg.type === "NUMBER" ? Number(numberLiteralText(arg)) : arg.value;
+}
+function dateParts(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (year < 1 || year > 9999 || month < 1 || month > 12 || day < 1 || day > 31) return null;
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCHours(0, 0, 0, 0);
+  date.setUTCFullYear(year, month - 1, day);
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day ? { year, month, day } : null;
+}
+function dateOrdinal(value) {
+  const parts = dateParts(value);
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCHours(0, 0, 0, 0);
+  date.setUTCFullYear(parts.year, parts.month - 1, parts.day);
+  return Math.trunc(date.getTime() / 864e5);
+}
+function dateFromOrdinal(ordinal) {
+  const date = new Date(ordinal * 864e5);
+  const year = date.getUTCFullYear();
+  if (year < 1 || year > 9999) {
+    throw argumentError("GENERATE_SERIES \u306E\u65E5\u4ED8\u5F15\u6570\u306B\u306F\u5B9F\u5728\u3059\u308B YYYY-MM-DD \u5F62\u5F0F\u306E DATE \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+  }
+  return `${String(year).padStart(4, "0")}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}`;
+}
+function parseDateStep(value) {
+  const trimmed = value.trim();
+  const match = /^([+-]?\d+)\s+(day|days)$/i.exec(trimmed);
+  if (!match) {
+    if (/^[+-]?\d+\s+\S+$/i.test(trimmed)) {
+      throw argumentError("GENERATE_SERIES \u306E\u65E5\u4ED8 step \u306F day \u307E\u305F\u306F days \u306E\u307F\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u3059\u3002");
+    }
+    throw argumentError("GENERATE_SERIES \u306E step \u304C\u7CFB\u5217\u306E\u578B\u3068\u4E00\u81F4\u3057\u307E\u305B\u3093\u3002\u6574\u6570\u7CFB\u5217\u306B\u306F\u6574\u6570\u3001DATE \u7CFB\u5217\u306B\u306F day \u5358\u4F4D\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+  }
+  const step = Number(match[1]);
+  if (!Number.isSafeInteger(step)) {
+    throw argumentError("GENERATE_SERIES \u306E\u6570\u5024\u7CFB\u5217\u306F\u6574\u6570\u306E start\u3001stop\u3001step \u306E\u307F\u3092\u53D7\u3051\u4ED8\u3051\u307E\u3059\u3002");
+  }
+  if (step === 0) throw argumentError("GENERATE_SERIES \u306E\u65E5\u4ED8 step \u306B 0 day \u306F\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093\u3002");
+  return step;
+}
+function integerValue(value) {
+  if (typeof value === "number") return Number.isSafeInteger(value) ? value : null;
+  if (!/^[+-]?\d+$/.test(value)) return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function integerNumberLiteral(arg) {
+  const decimal = parseExactDecimal(arg.raw ?? String(arg.value));
+  if (decimal === null || decimal.scale > 0) return null;
+  if (decimal.sign === 0) return 0;
+  const digits = decimal.coefficient.length - decimal.scale;
+  if (digits > 16) return null;
+  const magnitude = `${decimal.coefficient}${"0".repeat(-decimal.scale)}`;
+  if (magnitude.length === 16 && magnitude > "9007199254740991") return null;
+  const value = Number(magnitude) * decimal.sign;
+  return Number.isSafeInteger(value) ? value : null;
+}
+function isUnsupportedTemporal(value) {
+  return typeof value === "string" && (/^\d{4}-\d{2}-\d{2}T/.test(value) || /^\d{2}:\d{2}(?::\d{2})?$/.test(value));
+}
+function countRows(start, stop, step) {
+  if (start === stop) return 1;
+  if (start < stop && step < 0 || start > stop && step > 0) return 0;
+  const distance = step > 0 ? BigInt(stop) - BigInt(start) : BigInt(start) - BigInt(stop);
+  return Number(distance / BigInt(Math.abs(step)) + 1n);
+}
+function planResolved(stmt) {
+  if (stmt.args.length < 2 || stmt.args.length > 3) {
+    throw argumentError("GENERATE_SERIES \u306F start\u3001stop \u3068\u7701\u7565\u53EF\u80FD\u306A step \u306E2\u500B\u307E\u305F\u306F3\u500B\u306E\u5F15\u6570\u3092\u53D7\u3051\u4ED8\u3051\u307E\u3059\u3002");
+  }
+  const values = stmt.args.map((arg) => literalValue(arg));
+  ["start", "stop", "step"].forEach((name, index) => {
+    if (values[index] === "") throw argumentError(`GENERATE_SERIES \u306E ${name} \u306B\u7A7A\u6587\u5B57\u306F\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093\u3002`);
+  });
+  const [startRaw, stopRaw, stepRaw] = values;
+  const [startArg, stopArg, stepArg] = stmt.args;
+  const startDate = typeof startRaw === "string" ? dateParts(startRaw) : null;
+  const stopDate = typeof stopRaw === "string" ? dateParts(stopRaw) : null;
+  const dateLikeStart = typeof startRaw === "string" && /^\d{4}-/.test(startRaw);
+  const dateLikeStop = typeof stopRaw === "string" && /^\d{4}-/.test(stopRaw);
+  if ([startRaw, stopRaw].some(isUnsupportedTemporal)) {
+    throw argumentError("GENERATE_SERIES \u306F Phase 1 \u3067\u306F\u6574\u6570\u3068 DATE \u306E\u307F\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u3059\u3002DATETIME \u3068 TIME \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002");
+  }
+  if (startDate || stopDate || dateLikeStart || dateLikeStop || typeof startRaw === "string" && typeof stopRaw === "string" && !(isResolvedVariable(startArg) && isResolvedVariable(stopArg) && integerValue(startRaw) !== null && integerValue(stopRaw) !== null)) {
+    if (!startDate || !stopDate) {
+      if (startDate && typeof stopRaw !== "string" || stopDate && typeof startRaw !== "string") {
+        throw argumentError("GENERATE_SERIES \u306E start \u3068 stop \u306F\u3001\u4E21\u65B9\u3092\u6574\u6570\u307E\u305F\u306F\u4E21\u65B9\u3092 DATE \u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+      }
+      throw argumentError("GENERATE_SERIES \u306E\u65E5\u4ED8\u5F15\u6570\u306B\u306F\u5B9F\u5728\u3059\u308B YYYY-MM-DD \u5F62\u5F0F\u306E DATE \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+    }
+    if (stepRaw !== void 0 && typeof stepRaw !== "string") {
+      throw argumentError("GENERATE_SERIES \u306E step \u304C\u7CFB\u5217\u306E\u578B\u3068\u4E00\u81F4\u3057\u307E\u305B\u3093\u3002\u6574\u6570\u7CFB\u5217\u306B\u306F\u6574\u6570\u3001DATE \u7CFB\u5217\u306B\u306F day \u5358\u4F4D\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+    }
+    const step2 = stepRaw === void 0 ? 1 : parseDateStep(stepRaw);
+    const start2 = startRaw;
+    const stop2 = stopRaw;
+    return { kind: "DATE", start: start2, stop: stop2, step: step2, rowCount: countRows(dateOrdinal(start2), dateOrdinal(stop2), step2) };
+  }
+  const startInteger = startArg.type === "NUMBER" ? integerNumberLiteral(startArg) : isResolvedVariable(startArg) ? integerValue(startRaw) : null;
+  const stopInteger = stopArg.type === "NUMBER" ? integerNumberLiteral(stopArg) : isResolvedVariable(stopArg) ? integerValue(stopRaw) : null;
+  if (startInteger === null || stopInteger === null) {
+    if ((startArg.type === "NUMBER" || isResolvedVariable(startArg)) && (stopArg.type === "NUMBER" || isResolvedVariable(stopArg))) {
+      throw argumentError("GENERATE_SERIES \u306E\u6570\u5024\u7CFB\u5217\u306F\u6574\u6570\u306E start\u3001stop\u3001step \u306E\u307F\u3092\u53D7\u3051\u4ED8\u3051\u307E\u3059\u3002");
+    }
+    throw argumentError("GENERATE_SERIES \u306E start \u3068 stop \u306F\u3001\u4E21\u65B9\u3092\u6574\u6570\u307E\u305F\u306F\u4E21\u65B9\u3092 DATE \u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+  }
+  const resolvedStep = stepRaw === void 0 ? 1 : stepArg?.type === "NUMBER" ? integerNumberLiteral(stepArg) : isResolvedVariable(stepArg) ? integerValue(stepRaw) : null;
+  if (resolvedStep === null) {
+    if (stepArg?.type === "NUMBER" || isResolvedVariable(stepArg)) {
+      throw argumentError("GENERATE_SERIES \u306E\u6570\u5024\u7CFB\u5217\u306F\u6574\u6570\u306E start\u3001stop\u3001step \u306E\u307F\u3092\u53D7\u3051\u4ED8\u3051\u307E\u3059\u3002");
+    }
+    throw argumentError("GENERATE_SERIES \u306E step \u304C\u7CFB\u5217\u306E\u578B\u3068\u4E00\u81F4\u3057\u307E\u305B\u3093\u3002\u6574\u6570\u7CFB\u5217\u306B\u306F\u6574\u6570\u3001DATE \u7CFB\u5217\u306B\u306F day \u5358\u4F4D\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+  }
+  const start = startInteger;
+  const stop = stopInteger;
+  const step = resolvedStep;
+  if (step === 0) throw argumentError("GENERATE_SERIES \u306E step \u306B 0 \u306F\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093\u3002");
+  return { kind: "INTEGER", start, stop, step, rowCount: countRows(start, stop, step) };
+}
+function validateGenerateSeriesStatement(stmt) {
+  if (stmt.args.length < 2 || stmt.args.length > 3) {
+    throw argumentError("GENERATE_SERIES \u306F start\u3001stop \u3068\u7701\u7565\u53EF\u80FD\u306A step \u306E2\u500B\u307E\u305F\u306F3\u500B\u306E\u5F15\u6570\u3092\u53D7\u3051\u4ED8\u3051\u307E\u3059\u3002");
+  }
+  if (stmt.args.some(isVariable)) {
+    ["start", "stop", "step"].forEach((name, index) => {
+      const arg = stmt.args[index];
+      if (arg?.type === "STRING" && arg.value === "") {
+        throw argumentError(`GENERATE_SERIES \u306E ${name} \u306B\u7A7A\u6587\u5B57\u306F\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093\u3002`);
+      }
+      if (arg?.type === "NUMBER" && integerNumberLiteral(arg) === null) {
+        throw argumentError("GENERATE_SERIES \u306E\u6570\u5024\u7CFB\u5217\u306F\u6574\u6570\u306E start\u3001stop\u3001step \u306E\u307F\u3092\u53D7\u3051\u4ED8\u3051\u307E\u3059\u3002");
+      }
+      if (index < 2 && arg?.type === "STRING") {
+        if (isUnsupportedTemporal(arg.value)) {
+          throw argumentError("GENERATE_SERIES \u306F Phase 1 \u3067\u306F\u6574\u6570\u3068 DATE \u306E\u307F\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u3059\u3002DATETIME \u3068 TIME \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002");
+        }
+        if (/^\d{4}-/.test(arg.value) && dateParts(arg.value) === null) {
+          throw argumentError("GENERATE_SERIES \u306E\u65E5\u4ED8\u5F15\u6570\u306B\u306F\u5B9F\u5728\u3059\u308B YYYY-MM-DD \u5F62\u5F0F\u306E DATE \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+        }
+      }
+    });
+    const step = stmt.args[2];
+    if (step?.type === "NUMBER") {
+      const value = integerNumberLiteral(step);
+      if (value === null) throw argumentError("GENERATE_SERIES \u306E\u6570\u5024\u7CFB\u5217\u306F\u6574\u6570\u306E start\u3001stop\u3001step \u306E\u307F\u3092\u53D7\u3051\u4ED8\u3051\u307E\u3059\u3002");
+      if (value === 0) throw argumentError("GENERATE_SERIES \u306E step \u306B 0 \u306F\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093\u3002");
+    } else if (step?.type === "STRING") {
+      parseDateStep(step.value);
+    }
+    return null;
+  }
+  const plan = planResolved(stmt);
+  if (plan.rowCount > GENERATE_SERIES_MAX_ROWS) {
+    throw argumentError(`GENERATE_SERIES \u306E\u751F\u6210\u4EF6\u6570 ${plan.rowCount} \u884C\u304C\u4E0A\u9650 ${GENERATE_SERIES_MAX_ROWS} \u884C\u3092\u8D85\u3048\u3066\u3044\u307E\u3059\u3002`);
+  }
+  return plan.rowCount;
+}
+function validateGenerateSeriesInStatement(node) {
+  const visit = (value) => {
+    if (value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    const obj = value;
+    if (obj.type === "WITH") {
+      let total = 0;
+      let complete = true;
+      for (const cte of obj.ctes) {
+        if (cte.query.type === "GENERATE_SERIES") {
+          const count = validateGenerateSeriesStatement(cte.query);
+          if (count === null) complete = false;
+          else total += count;
+        } else visit(cte.query);
+      }
+      if (complete && total > GENERATE_SERIES_MAX_ROWS) {
+        throw argumentError(`\u3053\u306E WITH \u6587\u306E GENERATE_SERIES \u751F\u6210\u4EF6\u6570\u5408\u8A08 ${total} \u884C\u304C\u4E0A\u9650 ${GENERATE_SERIES_MAX_ROWS} \u884C\u3092\u8D85\u3048\u3066\u3044\u307E\u3059\u3002`);
+      }
+      visit(obj.query);
+      return;
+    }
+    Object.values(obj).forEach(visit);
+  };
+  visit(node);
+}
+function resolveGenerateSeries(stmt) {
+  const plan = planResolved(stmt);
+  if (plan.rowCount > GENERATE_SERIES_MAX_ROWS) {
+    throw argumentError(`GENERATE_SERIES \u306E\u751F\u6210\u4EF6\u6570 ${plan.rowCount} \u884C\u304C\u4E0A\u9650 ${GENERATE_SERIES_MAX_ROWS} \u884C\u3092\u8D85\u3048\u3066\u3044\u307E\u3059\u3002`);
+  }
+  const values = [];
+  if (plan.kind === "INTEGER") {
+    let current = plan.start;
+    for (let index = 0; index < plan.rowCount; index++) {
+      values.push(String(current));
+      if (index + 1 < plan.rowCount) {
+        const next = current + plan.step;
+        if (!Number.isSafeInteger(next)) throw argumentError("GENERATE_SERIES \u306E\u6570\u5024\u7CFB\u5217\u306F\u6574\u6570\u306E start\u3001stop\u3001step \u306E\u307F\u3092\u53D7\u3051\u4ED8\u3051\u307E\u3059\u3002");
+        current = next;
+      }
+    }
+  } else {
+    const startOrdinal = dateOrdinal(plan.start);
+    for (let index = 0; index < plan.rowCount; index++) values.push(dateFromOrdinal(startOrdinal + index * plan.step));
+  }
+  return { ...plan, values };
+}
+
 // src/core/statementValidation.ts
 function validateStatementStatic(stmt) {
   validateStringFunctionArities(stmt);
   validatePrimaryOrganizationDmlStatement(stmt);
   validateKlikeStatement(stmt);
+  validateGenerateSeriesInStatement(stmt);
 }
 function validateStringFunctionArities(stmt) {
   const visit = (value) => {
@@ -10780,11 +11053,11 @@ function validatePostImage(record, fieldIndex, numberPrecision, statementNumber,
     else normalizedRecord[field.code] = { value: preserveCodeObjects(raw, field.fieldType, result.value) };
   }
   for (const [tableCode, children] of fieldIndex.subtables) {
-    const sourceRows = record[tableCode]?.value;
-    if (!Array.isArray(sourceRows)) continue;
+    const sourceRows2 = record[tableCode]?.value;
+    if (!Array.isArray(sourceRows2)) continue;
     const normalizedRows = normalizedRecord[tableCode]?.value;
-    for (let rowIndex = 0; rowIndex < sourceRows.length; rowIndex++) {
-      const sourceRow = sourceRows[rowIndex];
+    for (let rowIndex = 0; rowIndex < sourceRows2.length; rowIndex++) {
+      const sourceRow = sourceRows2[rowIndex];
       const normalizedRow = normalizedRows[rowIndex];
       for (const field of children) {
         const raw = sourceRow.value?.[field.code]?.value;
@@ -13539,6 +13812,65 @@ async function deriveEmptyWildcardColumns(fields, subtableCode, loadProcessStatu
 }
 
 // src/engine/process.ts
+var materializedSelectValues = /* @__PURE__ */ new WeakMap();
+var sourceRows = /* @__PURE__ */ new WeakMap();
+function asProcessingRow(source) {
+  if (sourceRows.has(source)) return source;
+  let row;
+  row = new Proxy(source, {
+    get(target, property, receiver) {
+      if (typeof property !== "string" || Object.prototype.hasOwnProperty.call(target, property)) {
+        return Reflect.get(target, property, receiver);
+      }
+      return getMaterializedLookupValue(row, property);
+    },
+    has(target, property) {
+      return Reflect.has(target, property) || typeof property === "string" && getMaterializedLookupValue(row, property) !== void 0;
+    },
+    getOwnPropertyDescriptor(target, property) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, property);
+      if (descriptor || typeof property !== "string") return descriptor;
+      const value = getMaterializedLookupValue(row, property);
+      return value === void 0 ? void 0 : { configurable: true, enumerable: false, writable: false, value };
+    }
+  });
+  sourceRows.set(row, source);
+  return row;
+}
+function sourceRowForEvaluation(row) {
+  return sourceRows.get(row) ?? row;
+}
+function materializedValuesFor(row) {
+  let values = materializedSelectValues.get(row);
+  if (!values) {
+    values = { byColumn: /* @__PURE__ */ new Map(), byLookupKey: /* @__PURE__ */ new Map() };
+    materializedSelectValues.set(row, values);
+  }
+  return values;
+}
+function setMaterializedSelectValue(row, columnIndex, value, lookupKeys = []) {
+  const values = materializedValuesFor(row);
+  values.byColumn.set(columnIndex, value);
+  for (const key of lookupKeys) values.byLookupKey.set(key, value);
+}
+function getMaterializedSelectValue(row, columnIndex) {
+  return materializedSelectValues.get(row)?.byColumn.get(columnIndex);
+}
+function getMaterializedLookupValue(row, key) {
+  return materializedSelectValues.get(row)?.byLookupKey.get(key);
+}
+function getLegacyMaterializedValue(row, key) {
+  return materializedSelectValues.has(row) ? void 0 : row[key];
+}
+function havingEvaluationRow(row) {
+  const lookups = materializedSelectValues.get(row)?.byLookupKey;
+  if (!lookups || lookups.size === 0) return row;
+  const evaluationRow = { ...row };
+  for (const [key, value] of lookups) evaluationRow[key] = value;
+  const groupingMeta = getGroupingRowMeta(row);
+  if (groupingMeta) attachGroupingRowMeta(evaluationRow, groupingMeta.includedCanonicalIds);
+  return evaluationRow;
+}
 function flatten(record, alias) {
   const row = {};
   for (const [field, fv] of Object.entries(record)) {
@@ -13643,7 +13975,7 @@ function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolution
   }
   const result = [];
   for (const groupRows of groups.values()) {
-    const outRow = { ...groupRows[0] };
+    const outRow = asProcessingRow({ ...groupRows[0] });
     for (const k of groupByKeys) {
       if (k.type === "ARITH_KEY") {
         outRow[arithColDefaultKey(k.expr)] = String(evalArithExpr(k.expr, groupRows[0]));
@@ -13695,7 +14027,7 @@ function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {})
     }
     const includedCanonicalIds = new Set(set.items.map((item) => item.canonicalId));
     for (const groupRows of buckets) {
-      const outRow = { ...groupRows[0] };
+      const outRow = asProcessingRow({ ...groupRows[0] });
       const includedValues = /* @__PURE__ */ new Map();
       for (const item of set.items) {
         if (!includedValues.has(item.canonicalId)) {
@@ -13725,32 +14057,52 @@ function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortK
     if (col.type === "AGGREGATE") {
       const syntheticKey = aggregateSyntheticName(col.func, col.distinct, col.arg);
       const value = String(evalAggregate(col.func, col.distinct, col.arg, col.separator, groupRows, resolveAggSortKind));
-      outRow[col.alias ?? syntheticKey] = value;
-      if (col.alias) outRow[syntheticKey] = value;
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        value,
+        col.alias ? [col.alias, syntheticKey] : [syntheticKey]
+      );
     } else if (col.type === "ARITH_AGG_COL") {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const outputKey = col.alias ?? aggArithDefaultKey(col.expr);
-      outRow[outputKey] = String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind));
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind)),
+        [outputKey]
+      );
     } else if (col.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(col.expr)) {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const outputKey = col.alias ?? stringFuncDefaultKey(col.expr);
       const resolvedExpr = resolveAggInStringFuncExpr(col.expr, groupRows, resolveAggSortKind);
-      outRow[outputKey] = evalStringFunc(resolvedExpr, outRow);
+      setMaterializedSelectValue(outRow, columnIndex, evalStringFunc(resolvedExpr, outRow), [outputKey]);
     } else if (col.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(col.expr)) {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const outputKey = col.alias ?? scalarValueDefaultKey(col.expr);
       const resolvedExpr = resolveAggInScalarValue(col.expr, groupRows, resolveAggSortKind);
-      outRow[outputKey] = String(evalScalarValueExpr(resolvedExpr, outRow));
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        String(evalScalarValueExpr(resolvedExpr, outRow)),
+        [outputKey]
+      );
     } else if (col.type === "CASE_COL" && containsAggregate2(col.expr)) {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const resolvedExpr = resolveAggInCaseExpr(col.expr, groupRows, resolveAggSortKind);
       const resolveAggregateSemantics = (field) => field.aggregateRef ? aggregateResultSemantics(field.aggregateRef, resolveAggSortKind) : void 0;
-      outRow[caseMaterializedKey(col.alias, columnIndex)] = evalCaseWhen(
+      const value = evalCaseWhen(
         resolvedExpr,
         outRow,
         void 0,
         resolveAggregateSemantics
       );
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        value,
+        [caseMaterializedKey(col.alias, columnIndex)]
+      );
     }
   }
 }
@@ -13776,8 +14128,8 @@ function materializeAggregateDependencies(outRow, rows, node, resolveAggSortKind
   collectAggregateRefs(node, refs);
   for (const ref of refs) {
     const key = aggregateSyntheticName(ref.func, ref.distinct, ref.arg);
-    if (outRow[key] !== void 0) continue;
-    outRow[key] = String(evalAggregate(
+    if (getMaterializedLookupValue(outRow, key) !== void 0) continue;
+    const value = String(evalAggregate(
       ref.func,
       ref.distinct,
       ref.arg,
@@ -13785,6 +14137,7 @@ function materializeAggregateDependencies(outRow, rows, node, resolveAggSortKind
       rows,
       resolveAggSortKind
     ));
+    materializedValuesFor(outRow).byLookupKey.set(key, value);
   }
 }
 function evalGroupByKey(key, row, resolution, columns, aliasEvaluationContext) {
@@ -13899,7 +14252,8 @@ function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind)
   }
 }
 function aggregateRowValues(func, arg, rows) {
-  return rows.map((row) => {
+  return rows.map((processingRow) => {
+    const row = sourceRowForEvaluation(processingRow);
     let strVal;
     if (arg.type === "FIELD_REF") {
       const raw = row[arg.field];
@@ -13980,7 +14334,13 @@ function aggregateResultSemantics(ref, resolver) {
 }
 function applyHaving(rows, having, resolveFieldType, resolveFieldSemantics2) {
   if (having === null) return rows;
-  return rows.filter((row) => evalWhere(having, row, resolveFieldType, void 0, resolveFieldSemantics2));
+  return rows.filter((row) => evalWhere(
+    having,
+    havingEvaluationRow(row),
+    resolveFieldType,
+    void 0,
+    resolveFieldSemantics2
+  ));
 }
 function applyDistinct(rows, columns, scalarCache, resolveFieldType, resolveFieldSemantics2) {
   if (rows.length === 0) return rows;
@@ -14092,13 +14452,14 @@ var NUMERIC_ORDER_FUNCTIONS = /* @__PURE__ */ new Set([
   "WEEK"
 ]);
 function evalOrderKey(key, row, aliasEvaluator) {
+  const sourceRow = sourceRowForEvaluation(row);
   switch (key.type) {
     case "FIELD_NAME":
-      return aliasEvaluator?.(key.name, row) ?? row[key.name] ?? "";
+      return aliasEvaluator?.(key.name, row) ?? getMaterializedLookupValue(row, key.name) ?? sourceRow[key.name] ?? "";
     case "ARITH_KEY":
-      return String(evalArithExpr(key.expr, row));
+      return String(evalArithExpr(key.expr, sourceRow));
     case "FUNC_KEY":
-      return evalStringFunc(key.expr, row);
+      return evalStringFunc(key.expr, sourceRow);
     case "GROUPING_KEY":
       return evalGroupingRef(key.ref, row);
   }
@@ -14110,38 +14471,41 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
     const alias = column.alias;
     switch (column.type) {
       case "FIELD":
-        evaluators.set(alias, (row) => resolveFieldRef(row, column.field));
+        evaluators.set(alias, (row) => resolveFieldRef(sourceRowForEvaluation(row), column.field));
         break;
       case "LITERAL_COL":
         evaluators.set(alias, () => column.value);
         break;
       case "AGGREGATE": {
-        const source = aggregateSyntheticName(column.func, column.distinct, column.arg);
-        evaluators.set(alias, (row) => row[alias] ?? row[source] ?? "0");
+        evaluators.set(alias, (row) => getMaterializedSelectValue(row, columnIndex) ?? "0");
         break;
       }
       case "ARITH_AGG_COL": {
-        const source = aggArithDefaultKey(column.expr);
-        evaluators.set(alias, (row) => row[alias] ?? row[source] ?? "0");
+        evaluators.set(alias, (row) => getMaterializedSelectValue(row, columnIndex) ?? "0");
         break;
       }
       case "WINDOW_COL":
-        evaluators.set(alias, (row) => row[alias] ?? "");
+        evaluators.set(alias, (row) => getMaterializedSelectValue(row, columnIndex) ?? "");
         break;
       case "ARITH_COL":
-        evaluators.set(alias, (row) => String(evalArithExpr(column.expr, row)));
+        evaluators.set(alias, (row) => String(evalArithExpr(column.expr, sourceRowForEvaluation(row))));
         break;
       case "STRFUNC_COL": {
         const source = stringFuncDefaultKey(column.expr);
-        evaluators.set(alias, (row) => hasAggregateInStringFuncExpr2(column.expr) ? row[alias] ?? row[source] ?? evalStringFunc(column.expr, row, resolveFieldType, resolveFieldSemantics2) : evalStringFunc(column.expr, row, resolveFieldType, resolveFieldSemantics2));
+        evaluators.set(alias, (row) => hasAggregateInStringFuncExpr2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? evalStringFunc(column.expr, sourceRowForEvaluation(row), resolveFieldType, resolveFieldSemantics2) : evalStringFunc(column.expr, sourceRowForEvaluation(row), resolveFieldType, resolveFieldSemantics2));
         break;
       }
       case "CASE_COL":
-        evaluators.set(alias, (row) => containsAggregate2(column.expr) ? row[alias] ?? "" : evalCaseWhen(column.expr, row, resolveFieldType, resolveFieldSemantics2));
+        evaluators.set(alias, (row) => containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? "" : evalCaseWhen(column.expr, sourceRowForEvaluation(row), resolveFieldType, resolveFieldSemantics2));
         break;
       case "SCALAR_VALUE_COL": {
         const source = scalarValueDefaultKey(column.expr);
-        evaluators.set(alias, (row) => scalarValueHasAggregate2(column.expr) ? row[alias] ?? row[source] ?? "" : String(evalScalarValueExpr(column.expr, row, resolveFieldType, resolveFieldSemantics2)));
+        evaluators.set(alias, (row) => scalarValueHasAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? "" : String(evalScalarValueExpr(
+          column.expr,
+          sourceRowForEvaluation(row),
+          resolveFieldType,
+          resolveFieldSemantics2
+        )));
         break;
       }
       case "SCALAR_SUBQUERY_COL":
@@ -14157,9 +14521,10 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
   return (name, row) => evaluators.get(name)?.(row);
 }
 function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, resolveAggSortKind) {
-  const windows = columns.filter((column) => column.type === "WINDOW_COL");
+  const windows = columns.map((column, columnIndex) => ({ column, columnIndex })).filter((item) => item.column.type === "WINDOW_COL");
   if (rows.length === 0 || windows.length === 0) return rows;
-  for (const window of windows) {
+  for (let index = 0; index < rows.length; index++) rows[index] = asProcessingRow(rows[index]);
+  for (const { column: window, columnIndex } of windows) {
     const partitions = /* @__PURE__ */ new Map();
     for (const row of rows) {
       const key = JSON.stringify(window.partitionBy.map((ref) => resolveWindowField(row, ref)));
@@ -14171,11 +14536,11 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, re
       const sortedResult = sortDecoratedRows(partition, window.orderBy, optionOrders, sortKinds, fieldSemantics2);
       const sorted = sortedResult.rows;
       if (isAggregateWindow(window)) {
-        applyAggregateWindow(window, sortedResult, resolveAggSortKind);
+        applyAggregateWindow(window, columnIndex, sortedResult, resolveAggSortKind);
         continue;
       }
       if (isValueWindow(window)) {
-        applyValueWindow(window, sorted);
+        applyValueWindow(window, columnIndex, sorted);
         continue;
       }
       if (!isRankingWindow(window)) {
@@ -14189,27 +14554,32 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, re
           denseRank++;
         }
         const value = window.func === "ROW_NUMBER" ? index + 1 : window.func === "RANK" ? rank : denseRank;
-        sorted[index].row[window.alias] = String(value);
+        setMaterializedSelectValue(sorted[index].row, columnIndex, String(value), [window.alias]);
       }
     }
   }
   return rows;
 }
 function evaluateValueWindowArg(arg, row) {
-  const value = evalScalarValueExprNullable(arg, row);
+  const value = evalScalarValueExprNullable(arg, sourceRowForEvaluation(row));
   if (value === null || value === void 0) return "";
   if (typeof value === "number" && !Number.isFinite(value)) return "";
   return String(value);
 }
-function applyValueWindow(window, sorted) {
+function applyValueWindow(window, columnIndex, sorted) {
   const values = sorted.map((item) => evaluateValueWindowArg(window.arg, item.row));
   const direction = window.valueFunc === "LAG" ? -1 : 1;
   for (let index = 0; index < sorted.length; index++) {
     const target = index + direction * window.offset;
-    sorted[index].row[window.alias] = target >= 0 && target < values.length ? values[target] : "";
+    setMaterializedSelectValue(
+      sorted[index].row,
+      columnIndex,
+      target >= 0 && target < values.length ? values[target] : "",
+      [window.alias]
+    );
   }
 }
-function applyAggregateWindow(window, sortedResult, resolveAggSortKind) {
+function applyAggregateWindow(window, columnIndex, sortedResult, resolveAggSortKind) {
   const sorted = sortedResult.rows;
   const values = window.arg.type === "WILDCARD" ? null : aggregateRowValues(window.aggFunc, window.arg, sorted.map((item) => item.row));
   const comparison = window.arg.type === "WILDCARD" ? void 0 : resolveAggregateArgSemantics(window.arg, resolveAggSortKind);
@@ -14242,23 +14612,29 @@ function applyAggregateWindow(window, sortedResult, resolveAggSortKind) {
   }
   if (window.frame === null) {
     const finalValue = output[output.length - 1];
-    for (const item of sorted) item.row[window.alias] = finalValue;
+    for (const item of sorted) {
+      setMaterializedSelectValue(item.row, columnIndex, finalValue, [window.alias]);
+    }
     return;
   }
   if (window.frame.unit === "RANGE") {
     for (let start = 0; start < sorted.length; ) {
       let end = start;
       while (end + 1 < sorted.length && sortedResult.compare(sorted[end], sorted[end + 1]) === 0) end++;
-      for (let index = start; index <= end; index++) sorted[index].row[window.alias] = output[end];
+      for (let index = start; index <= end; index++) {
+        setMaterializedSelectValue(sorted[index].row, columnIndex, output[end], [window.alias]);
+      }
       start = end + 1;
     }
     return;
   }
-  for (let index = 0; index < sorted.length; index++) sorted[index].row[window.alias] = output[index];
+  for (let index = 0; index < sorted.length; index++) {
+    setMaterializedSelectValue(sorted[index].row, columnIndex, output[index], [window.alias]);
+  }
 }
 function resolveWindowField(row, ref) {
   const name = ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
-  return resolveFieldRef(row, name);
+  return resolveFieldRef(sourceRowForEvaluation(row), name);
 }
 function applyLimit(rows, limit, offset) {
   const start = offset ?? 0;
@@ -14266,41 +14642,42 @@ function applyLimit(rows, limit, offset) {
   return rows.slice(start, start + limit);
 }
 function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
+  const sourceRow = sourceRowForEvaluation(row);
   switch (column.type) {
     case "VARIABLE_COL":
       throw new Error(`internal error: unresolved SELECT variable @${column.name}`);
     case "WILDCARD": {
-      const keys = context.wildcardKeys ?? Object.keys(row);
+      const keys = context.wildcardKeys ?? Object.keys(sourceRow);
       return {
         kind: "EXPANDED",
-        entries: keys.map((key) => [key, row[key] !== void 0 ? row[key] : null])
+        entries: keys.map((key) => [key, sourceRow[key] !== void 0 ? sourceRow[key] : null])
       };
     }
     case "PARENT_WILDCARD": {
-      const keys = context.parentWildcardKeys ?? Object.keys(row).filter((key) => key.startsWith("_p.")).sort();
+      const keys = context.parentWildcardKeys ?? Object.keys(sourceRow).filter((key) => key.startsWith("_p.")).sort();
       return {
         kind: "EXPANDED",
-        entries: keys.map((key) => [key, row[key] !== void 0 ? row[key] : null])
+        entries: keys.map((key) => [key, sourceRow[key] !== void 0 ? sourceRow[key] : null])
       };
     }
     case "FIELD":
-      return resolveFieldRef(row, column.field);
+      return resolveFieldRef(sourceRow, column.field);
     case "LITERAL_COL":
       return column.value;
     case "AGGREGATE": {
       const source = aggregateSyntheticName(column.func, column.distinct, column.arg);
-      return row[column.alias ?? source] ?? row[source] ?? "0";
+      return getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? source) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, column.alias ?? source) ?? getLegacyMaterializedValue(row, source) ?? "0";
     }
     case "ARITH_AGG_COL": {
       const source = column.alias ?? aggArithDefaultKey(column.expr);
-      return row[source] ?? "0";
+      return getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, source) ?? "0";
     }
     case "ARITH_COL":
-      return String(evalArithExpr(column.expr, row));
+      return String(evalArithExpr(column.expr, sourceRow));
     case "CASE_COL":
-      return containsAggregate2(column.expr) ? row[caseMaterializedKey(column.alias, columnIndex)] ?? "" : evalCaseWhen(
+      return containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? getLegacyMaterializedValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? "" : evalCaseWhen(
         column.expr,
-        row,
+        sourceRow,
         context.resolveFieldType,
         context.resolveFieldSemantics
       );
@@ -14308,23 +14685,23 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
       return evalGroupingRef(column.ref, row);
     case "STRFUNC_COL": {
       const source = stringFuncDefaultKey(column.expr);
-      return hasAggregateInStringFuncExpr2(column.expr) ? row[column.alias ?? source] ?? row[source] ?? evalStringFunc(
+      return hasAggregateInStringFuncExpr2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? source) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, column.alias ?? source) ?? getLegacyMaterializedValue(row, source) ?? evalStringFunc(
         column.expr,
-        row,
+        sourceRow,
         context.resolveFieldType,
         context.resolveFieldSemantics
       ) : evalStringFunc(
         column.expr,
-        row,
+        sourceRow,
         context.resolveFieldType,
         context.resolveFieldSemantics
       );
     }
     case "SCALAR_VALUE_COL": {
       const source = scalarValueDefaultKey(column.expr);
-      return scalarValueHasAggregate2(column.expr) ? row[column.alias ?? source] ?? row[source] ?? "" : String(evalScalarValueExpr(
+      return scalarValueHasAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? source) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, column.alias ?? source) ?? getLegacyMaterializedValue(row, source) ?? "" : String(evalScalarValueExpr(
         column.expr,
-        row,
+        sourceRow,
         context.resolveFieldType,
         context.resolveFieldSemantics
       ));
@@ -14332,7 +14709,7 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
     case "SCALAR_SUBQUERY_COL":
       return context.scalarCache?.get(columnIndex) ?? "";
     case "WINDOW_COL":
-      return row[column.alias] ?? "";
+      return getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias) ?? getLegacyMaterializedValue(row, column.alias) ?? "";
   }
 }
 function buildDistinctTuple(columns, row, context = {}) {
@@ -16426,9 +16803,9 @@ function render(value) {
 function buildImportRecordPayload(top, subtables, rowIdMode) {
   const record = {};
   for (const [code, value] of top) record[code] = { value };
-  for (const [tableCode, sourceRows] of subtables) {
+  for (const [tableCode, sourceRows2] of subtables) {
     record[tableCode] = {
-      value: sourceRows.map((sourceRow) => ({
+      value: sourceRows2.map((sourceRow) => ({
         ...rowIdMode === "PRESERVE" && sourceRow.rowId ? { id: sourceRow.rowId } : {},
         value: Object.fromEntries([...sourceRow.values].map(([childCode, value]) => [childCode, { value }]))
       }))
@@ -17663,7 +18040,7 @@ function resolveBatchVariableReferencesInternal(node, variables, numericArithmet
         type: "NUMBER",
         value: value.value,
         raw: numericArithmeticOperand === "AGG_ARITH" ? `@${obj["name"]}` : value.raw ?? String(value.value)
-      } : { type: "STRING", value: value.value };
+      } : { type: "STRING", value: value.value, fromVariable: true };
     }
     if (obj["type"] === "VARIABLE_COL" && typeof obj["name"] === "string" && typeof obj["alias"] === "string") {
       const value = variables.get(obj["name"]);
@@ -17979,10 +18356,16 @@ function hasDefaultRangeAggregateWindow(stmt) {
 function hasWindowNeedingOrderProof(stmt) {
   return hasDefaultRangeAggregateWindow(stmt) || stmt.columns.some((column) => column.type === "WINDOW_COL" && column.windowKind === "VALUE");
 }
-function canProveTotalWindowOrder(stmt, orderBy, resolveField2, context) {
-  if (context !== "DIRECT" || stmt.joins.length > 0 || stmt.from.cteName !== null || stmt.from.subtableCode != null) {
-    return false;
+function canProveTotalWindowOrder(stmt, orderBy, resolveField2, context, generatedColumn) {
+  if (generatedColumn !== void 0 && stmt.joins.length === 0 && stmt.from.cteName !== null) {
+    return orderBy.some((item) => {
+      if (item.key.type !== "FIELD_NAME") return false;
+      const ref = aggregateFieldRef(item.key.name);
+      if (ref.field !== generatedColumn) return false;
+      return ref.tableAlias === null || ref.tableAlias === effectiveTableAlias(stmt.from);
+    });
   }
+  if (context !== "DIRECT" || stmt.joins.length > 0 || stmt.from.cteName !== null || stmt.from.subtableCode != null) return false;
   return orderBy.some((item) => {
     if (item.key.type !== "FIELD_NAME") return false;
     const ref = aggregateFieldRef(item.key.name);
@@ -17991,22 +18374,22 @@ function canProveTotalWindowOrder(stmt, orderBy, resolveField2, context) {
 }
 function tieBreakAdvice(context, kind) {
   if (context !== "DIRECT") {
-    return "\u305D\u306E\u8868\u306E\u4E2D\u3067\u4E00\u610F\u306B\u306A\u308B\u5217\uFF08\u5143\u306E\u96C6\u7D04\u306E\u30AD\u30FC\u306A\u3069\uFF09\u3092 ORDER BY \u306B\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002\u96C6\u7D04\u7D50\u679C\u306E\u5217\u306F\u4E00\u610F\u3067\u3082\u8A3C\u660E\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u3059\u3067\u306B\u4E00\u610F\u306A\u5834\u5408\u3082\u3053\u306E\u8B66\u544A\u304C\u51FA\u307E\u3059\u3002";
+    return "\u305D\u306E\u8868\u306E\u4E2D\u3067\u4E00\u610F\u306B\u306A\u308B\u5217\uFF08\u5143\u306E\u96C6\u7D04\u306E\u30AD\u30FC\u306A\u3069\uFF09\u3092 ORDER BY \u306B\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002\u96C6\u7D04\u7D50\u679C\u306E\u5217\u306F\u4E00\u610F\u3067\u3082\u8A3C\u660E\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u3059\u3067\u306B\u4E00\u610F\u306A\u5834\u5408\u3082\u3053\u306E\u8B66\u544A\u304C\u51FA\u307E\u3059\u3002\u5143\u306E\u96C6\u7D04\u306E\u30AD\u30FC\u3092\u3059\u3079\u3066 ORDER BY \u306B\u542B\u3081\u3066\u3044\u308B\u306A\u3089\u3001\u3053\u306E\u8B66\u544A\u306F\u7121\u8996\u3057\u3066\u69CB\u3044\u307E\u305B\u3093\u3002";
   }
   return kind === "RANGE" ? "ORDER BY \u306B\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u306A\u3069\u306E\u30BF\u30A4\u30D6\u30EC\u30FC\u30AF\u30AD\u30FC\u3092\u8DB3\u3057\u3066\u304F\u3060\u3055\u3044\u3002" : "\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u7B49\u3092 ORDER BY \u306B\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
 }
-function collectDefaultRangeWindowWarnings(stmt, resolveField2, context) {
+function collectDefaultRangeWindowWarnings(stmt, resolveField2, context, generatedColumn) {
   const warnings = [];
   for (const column of stmt.columns) {
     if (column.type !== "WINDOW_COL" || column.windowKind !== "AGGREGATE" || column.orderBy.length === 0 || column.frame?.source !== "DEFAULT") continue;
-    if (canProveTotalWindowOrder(stmt, column.orderBy, resolveField2, context)) continue;
+    if (canProveTotalWindowOrder(stmt, column.orderBy, resolveField2, context, generatedColumn)) continue;
     warnings.push(
       `${column.alias} \u306F\u65E2\u5B9A\u30D5\u30EC\u30FC\u30E0\uFF08RANGE\uFF09\u3067\u8A55\u4FA1\u3055\u308C\u307E\u3059\u3002ORDER BY \u306E\u5024\u304C\u540C\u3058\u884C\u306F\u3059\u3079\u3066\u540C\u3058\u5024\u306B\u306A\u308A\u307E\u3059\u3002\u884C\u3054\u3068\u306E\u5024\u304C\u5FC5\u8981\u306A\u3089 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW \u3092\u660E\u793A\u3059\u308B\u304B\u3001` + tieBreakAdvice(context, "RANGE")
     );
   }
   for (const column of stmt.columns) {
     if (column.type !== "WINDOW_COL" || column.windowKind !== "VALUE") continue;
-    if (canProveTotalWindowOrder(stmt, column.orderBy, resolveField2, context)) continue;
+    if (canProveTotalWindowOrder(stmt, column.orderBy, resolveField2, context, generatedColumn)) continue;
     warnings.push(
       `${column.alias} \u306E ORDER BY \u306F\u5168\u9806\u5E8F\u3067\u306A\u3044\u305F\u3081\u3001\u540C\u9806\u5185\u306E\u524D\u5F8C\u95A2\u4FC2\u306F\u672A\u898F\u5B9A\u3067\u3059\u3002` + tieBreakAdvice(context, "VALUE")
     );
@@ -19937,6 +20320,8 @@ async function executeWith(stmt, client, options, cacheContext, seed, captureCol
       result2 = await executeShowApps(client);
     } else if (cte.query.type === "DESCRIBE") {
       result2 = await executeDescribe(cte.query, client, cacheContext);
+    } else if (cte.query.type === "GENERATE_SERIES") {
+      result2 = executeGenerateSeries(cte.query);
     } else {
       result2 = await executeQueryWithCte(cte.query, client, options, cteCache, cacheContext, true);
     }
@@ -19944,7 +20329,8 @@ async function executeWith(stmt, client, options, cacheContext, seed, captureCol
     cteCache.set(cte.name, {
       rows: result2.rows,
       columns: result2.columns,
-      columnMeta: materializedMetaBySelectResult.get(result2)
+      columnMeta: materializedMetaBySelectResult.get(result2),
+      ...cte.query.type === "GENERATE_SERIES" ? { uniqueGeneratedColumn: cte.query.columnAlias } : {}
     });
   }
   const result = await executeQueryWithCte(
@@ -19957,6 +20343,27 @@ async function executeWith(stmt, client, options, cacheContext, seed, captureCol
   );
   return mergeSelectWarnings(result, [...warnings]);
 }
+function executeGenerateSeries(stmt) {
+  const series = resolveGenerateSeries(stmt);
+  const result = {
+    type: "SELECT",
+    columns: [stmt.columnAlias],
+    rows: series.values.map((value) => ({ [stmt.columnAlias]: value })),
+    rowCount: series.rowCount,
+    warnings: []
+  };
+  const meta = series.kind === "INTEGER" ? {
+    sortKind: "number",
+    fieldType: "NUMBER",
+    semantics: resolveFieldSemantics({ fieldType: "NUMBER" })
+  } : {
+    sortKind: "string",
+    fieldType: "DATE",
+    semantics: resolveFieldSemantics({ fieldType: "DATE" })
+  };
+  materializedMetaBySelectResult.set(result, /* @__PURE__ */ new Map([[stmt.columnAlias, meta]]));
+  return result;
+}
 async function executeQueryWithCte(query, client, options, cteCache, cacheContext, captureColumnMeta = false, b86PreflightComplete = false) {
   if (!b86PreflightComplete) {
     await preflightB86QueryWithCte(query, client, cteCache, cacheContext);
@@ -20063,7 +20470,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   const defaultRangeWarnings = collectDefaultRangeWindowWarnings(
     stmt,
     choiceAndWindowResolver,
-    "DERIVED"
+    "DERIVED",
+    stmt.joins.length === 0 && stmt.from.cteName !== null ? cteCache.get(stmt.from.cteName)?.uniqueGeneratedColumn : void 0
   );
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
@@ -20370,10 +20778,10 @@ async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxR
   } else {
     return null;
   }
-  const sourceRows = tables.get(sourceAlias);
-  if (!sourceRows) return null;
+  const sourceRows2 = tables.get(sourceAlias);
+  if (!sourceRows2) return null;
   const keys = /* @__PURE__ */ new Set();
-  for (const row of sourceRows) {
+  for (const row of sourceRows2) {
     const raw = row[sourceField]?.value;
     const txt = toScalarText(raw).trim();
     if (txt.length > 0) keys.add(txt);
@@ -21283,7 +21691,7 @@ async function materializeValidationCandidates(stmt, operation, client, options,
     );
   }
   let rows;
-  let sourceRows;
+  let sourceRows2;
   let sourcePresence;
   let sourceRowErrors;
   let evaluationTypes;
@@ -21304,7 +21712,7 @@ async function materializeValidationCandidates(stmt, operation, client, options,
       throw customCheckParseError("CHECK \u4ED8\u304D DML \u30BD\u30FC\u30B9 SELECT \u306E\u51FA\u529B\u540D\u306F\u4E00\u610F\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059");
     }
     assertInsertCheckRefs(stmt, selectResult.columns);
-    sourceRows = selectResult.rows;
+    sourceRows2 = selectResult.rows;
     sourcePresence = selectResult.importPresence;
     sourceRowErrors = selectResult.importRowErrors;
     const meta = selectResult.columnMeta;
@@ -21325,7 +21733,7 @@ async function materializeValidationCandidates(stmt, operation, client, options,
     )),
     preErrors: [...sourceRowErrors?.[index] ?? []],
     record: {},
-    evaluationRow: sourceRows?.[index] ?? Object.fromEntries(
+    evaluationRow: sourceRows2?.[index] ?? Object.fromEntries(
       stmt.fields.map((field, i) => [field, renderValidationValue(values[i])])
     ),
     evaluationFieldTypes: evaluationTypes
@@ -21621,7 +22029,7 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
   const checkScope = await resolveUpdateFromCheckScope(stmt, from, client, cacheContext, tempTables);
   const sourceFields = [...new Set(stmt.assignments.filter((a) => a.value.type === "SOURCE_FIELD").map((a) => a.value.type === "SOURCE_FIELD" ? a.value.field : "").concat(checkScope.sourceFields))];
   const requiredSourceFields = [.../* @__PURE__ */ new Set([from.joinKeyField, ...sourceFields])];
-  const sourceRows = await loadUpdateFromSourceRows(
+  const sourceRows2 = await loadUpdateFromSourceRows(
     from,
     requiredSourceFields,
     sourceFields,
@@ -21632,7 +22040,7 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
   );
   const sourceByKey = /* @__PURE__ */ new Map();
   const sourceQueryByKey = /* @__PURE__ */ new Map();
-  for (const row of sourceRows) {
+  for (const row of sourceRows2) {
     if (!Object.prototype.hasOwnProperty.call(row, from.joinKeyField)) {
       throw new Error(`ArgumentError: UPDATE ... FROM source column ${from.joinKeyField} does not exist.`);
     }
@@ -23736,6 +24144,9 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     }
     if (typed["type"] === "SHOW_APPS") return [...SHOW_APPS_COLUMNS];
     if (typed["type"] === "DESCRIBE") return [...DESCRIBE_COLUMNS];
+    if (typed["type"] === "GENERATE_SERIES") {
+      return [node.columnAlias];
+    }
     throw new Error("ArgumentError: EXPLAIN could not determine the relation output schema.");
   };
   const preflightExplainRelations = async (node) => {
@@ -25029,6 +25440,22 @@ function buildWithPlan(stmt, capabilities, orderPlans, plainGroupByPlans, collec
         "cte"
       ));
       lines.push("");
+    } else if (cte.query.type === "GENERATE_SERIES") {
+      const series = resolveGenerateSeries(cte.query);
+      const step = series.kind === "DATE" ? `${series.step} ${Math.abs(series.step) === 1 ? "day" : "days"}` : String(series.step);
+      lines.push(
+        `[cte: ${cte.name}]`,
+        "  source:        GENERATE_SERIES",
+        `  column:        ${cte.query.columnAlias}`,
+        `  series type:   ${series.kind}`,
+        `  start:         ${series.start}`,
+        `  stop:          ${series.stop}`,
+        `  step:          ${step}`,
+        `  rows:          ${series.rowCount}`,
+        `  row guard:     ${series.rowCount} / ${GENERATE_SERIES_MAX_ROWS}`,
+        "  records API:   none",
+        ""
+      );
     }
   }
   if (stmt.query.type === "SELECT" || stmt.query.type === "UNION") {
@@ -25979,19 +26406,19 @@ function normalizeSqlAppProfiles(sql, defaultProfile = "dev", resolutionContext)
 var PHYSICAL_APP_KEY_RE = /^APP\d+$/i;
 var NUMERIC_APP_KEY_RE = /^\d+$/;
 var LOGICAL_SQL_KEY_RE = /^LAPP_/i;
-function argumentError(message) {
+function argumentError2(message) {
   return new Error(`ArgumentError: ${message}`);
 }
 function normalizeLogicalApps(profileName, value) {
   if (value === void 0) return void 0;
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw argumentError(`logicalApps for profile "${profileName}" must be an object.`);
+    throw argumentError2(`logicalApps for profile "${profileName}" must be an object.`);
   }
   const normalized = {};
   const physicalIdOwners = /* @__PURE__ */ new Map();
   for (const [rawName, rawAppId] of Object.entries(value)) {
     if (PHYSICAL_APP_KEY_RE.test(rawName) || NUMERIC_APP_KEY_RE.test(rawName) || LOGICAL_SQL_KEY_RE.test(rawName)) {
-      throw argumentError(
+      throw argumentError2(
         `logical app key "${rawName}" in profile "${profileName}" must be a logical name without APP, numeric, or LAPP_ syntax.`
       );
     }
@@ -25999,23 +26426,23 @@ function normalizeLogicalApps(profileName, value) {
     try {
       logicalName = canonicalizeLogicalAppName(rawName);
     } catch {
-      throw argumentError(
+      throw argumentError2(
         `logical app key "${rawName}" in profile "${profileName}" must match the logical app name rules.`
       );
     }
     if (Object.prototype.hasOwnProperty.call(normalized, logicalName)) {
-      throw argumentError(
+      throw argumentError2(
         `logical app name "${logicalName}" is duplicated after case normalization in profile "${profileName}".`
       );
     }
     if (typeof rawAppId !== "number" || !Number.isSafeInteger(rawAppId) || rawAppId <= 0) {
-      throw argumentError(
+      throw argumentError2(
         `physical app ID for logical app "${logicalName}" in profile "${profileName}" must be a positive safe integer.`
       );
     }
     const existingName = physicalIdOwners.get(rawAppId);
     if (existingName !== void 0) {
-      throw argumentError(
+      throw argumentError2(
         `logical apps "${existingName}" and "${logicalName}" in profile "${profileName}" map to the same physical app ID ${rawAppId}; physical app aliases are not supported yet.`
       );
     }
@@ -26026,31 +26453,31 @@ function normalizeLogicalApps(profileName, value) {
 }
 function validateKsqlConfig(config) {
   if (config === null || typeof config !== "object" || Array.isArray(config)) {
-    throw argumentError("config must be an object.");
+    throw argumentError2("config must be an object.");
   }
   if (config.profiles === void 0) return config;
   if (config.profiles === null || typeof config.profiles !== "object" || Array.isArray(config.profiles)) {
-    throw argumentError("profiles must be an object.");
+    throw argumentError2("profiles must be an object.");
   }
   for (const [profileName, profile] of Object.entries(config.profiles)) {
     if (profile === null || typeof profile !== "object" || Array.isArray(profile)) {
-      throw argumentError(`profile "${profileName}" must be an object.`);
+      throw argumentError2(`profile "${profileName}" must be an object.`);
     }
     if (profile.allowPhysicalAppRefs !== void 0 && typeof profile.allowPhysicalAppRefs !== "boolean") {
-      throw argumentError(`allowPhysicalAppRefs for profile "${profileName}" must be boolean.`);
+      throw argumentError2(`allowPhysicalAppRefs for profile "${profileName}" must be boolean.`);
     }
     const logicalApps = normalizeLogicalApps(profileName, profile.logicalApps);
     if (logicalApps !== void 0) profile.logicalApps = logicalApps;
     if (profile.query?.cursorMaxActive !== void 0) {
       const value = profile.query.cursorMaxActive;
       if (!Number.isSafeInteger(value) || value < 1 || value > 5) {
-        throw argumentError(`query.cursorMaxActive for profile "${profileName}" must be an integer from 1 to 5.`);
+        throw argumentError2(`query.cursorMaxActive for profile "${profileName}" must be an integer from 1 to 5.`);
       }
     }
     if (profile.query?.dmlMaxSubtableRows !== void 0) {
       const value = profile.query.dmlMaxSubtableRows;
       if (!Number.isSafeInteger(value) || value <= 0) {
-        throw argumentError(`query.dmlMaxSubtableRows for profile "${profileName}" must be a positive safe integer.`);
+        throw argumentError2(`query.dmlMaxSubtableRows for profile "${profileName}" must be a positive safe integer.`);
       }
     }
   }
@@ -26070,7 +26497,7 @@ function createAppResolutionContext(config, defaultProfile) {
   function requireProfile(profileName) {
     const profile = profiles[profileName];
     if (!profile && profileName === defaultProfile) return implicitDefaultProfile;
-    if (!profile) throw argumentError(`profile "${profileName}" is not defined.`);
+    if (!profile) throw argumentError2(`profile "${profileName}" is not defined.`);
     return profile;
   }
   return {
@@ -26080,11 +26507,11 @@ function createAppResolutionContext(config, defaultProfile) {
       try {
         logicalName = canonicalizeLogicalAppName(name);
       } catch {
-        throw argumentError(`logical app name "${name}" must match the logical app name rules.`);
+        throw argumentError2(`logical app name "${name}" must match the logical app name rules.`);
       }
       const appId = requireProfile(profileName).logicalApps?.[logicalName];
       if (appId === void 0) {
-        throw argumentError(`logical app LAPP_${logicalName}@${profileName} is not defined.`);
+        throw argumentError2(`logical app LAPP_${logicalName}@${profileName} is not defined.`);
       }
       return appId;
     },
@@ -26092,7 +26519,7 @@ function createAppResolutionContext(config, defaultProfile) {
       const profileName = profile || defaultProfile;
       if (!profiles[profileName]) return;
       if (requireProfile(profileName).allowPhysicalAppRefs === false) {
-        throw argumentError(
+        throw argumentError2(
           `physical app references are not allowed for profile "${profileName}"; use LAPP_<NAME>.`
         );
       }