@rex0220/kintone-sql-tools 3.58.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) => {
@@ -17767,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"]);
@@ -18083,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);
@@ -18099,18 +18378,18 @@ function tieBreakAdvice(context, kind) {
   }
   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")
     );
@@ -20041,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);
     }
@@ -20048,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(
@@ -20061,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);
@@ -20167,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();
@@ -23840,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) => {
@@ -25133,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") {
@@ -26083,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.`
       );
     }
@@ -26103,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.`
       );
     }
@@ -26130,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.`);
       }
     }
   }
@@ -26174,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 {
@@ -26184,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;
     },
@@ -26196,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>.`
         );
       }