@rex0220/kintone-sql-tools 3.62.0 → 3.64.0

package/dist-cli/ksql.js

@@ -76,6 +76,7 @@ var KEYWORDS = /* @__PURE__ */ new Map([
   ["INNER", "INNER" /* INNER */],
   ["LEFT", "LEFT" /* LEFT */],
   ["RIGHT", "RIGHT" /* RIGHT */],
+  ["CROSS", "CROSS" /* CROSS */],
   ["JOIN", "JOIN" /* JOIN */],
   ["ON", "ON" /* ON */],
   ["GROUP", "GROUP" /* GROUP */],
@@ -3016,6 +3017,13 @@ var Parser = class {
       const joinType = this.tryJoinType();
       if (joinType === null) break;
       const table = this.parseTableRef();
+      if (joinType === "CROSS") {
+        if (this.peek().kind === "ON" /* ON */) {
+          throw new ParseError("CROSS JOIN \u306B ON \u53E5\u306F\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093\u3002", this.peek());
+        }
+        joins.push({ type: "CROSS", table, on: null });
+        continue;
+      }
       this.expect("ON" /* ON */);
       const on = this.parseJoinCondition();
       joins.push({ type: joinType, table, on });
@@ -3024,17 +3032,30 @@ var Parser = class {
   }
   tryJoinType() {
     if (this.consume("INNER" /* INNER */)) {
+      if (this.peek().kind === "CROSS" /* CROSS */) {
+        throw new ParseError("CROSS JOIN \u306B INNER \u306F\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093\u3002", this.peek());
+      }
       this.expect("JOIN" /* JOIN */);
       return "INNER";
     }
     if (this.consume("LEFT" /* LEFT */)) {
+      if (this.peek().kind === "CROSS" /* CROSS */) {
+        throw new ParseError("CROSS JOIN \u306B LEFT / RIGHT \u306F\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093\u3002", this.peek());
+      }
       this.expect("JOIN" /* JOIN */);
       return "LEFT";
     }
     if (this.consume("RIGHT" /* RIGHT */)) {
+      if (this.peek().kind === "CROSS" /* CROSS */) {
+        throw new ParseError("CROSS JOIN \u306B LEFT / RIGHT \u306F\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093\u3002", this.peek());
+      }
       this.expect("JOIN" /* JOIN */);
       return "RIGHT";
     }
+    if (this.consume("CROSS" /* CROSS */)) {
+      this.expect("JOIN" /* JOIN */);
+      return "CROSS";
+    }
     if (this.consume("JOIN" /* JOIN */)) {
       return "INNER";
     }
@@ -4584,6 +4605,8 @@ var Parser = class {
       this.advance();
       return tok.value;
     }
+    const digitPrefixed = this.tryParseDigitPrefixedIdentifier();
+    if (digitPrefixed !== null) return digitPrefixed;
     throw new ParseError(
       "\u30D5\u30A3\u30FC\u30EB\u30C9\u540D\u307E\u305F\u306F\u30C6\u30FC\u30D6\u30EB\u540D\u304C\u5FC5\u8981\u3067\u3059",
       tok
@@ -4597,11 +4620,24 @@ var Parser = class {
       this.advance();
       return tok.value;
     }
+    const digitPrefixed = this.tryParseDigitPrefixedIdentifier();
+    if (digitPrefixed !== null) return digitPrefixed;
     throw new ParseError(
       "\u30D5\u30A3\u30FC\u30EB\u30C9\u540D\u307E\u305F\u306F\u30C6\u30FC\u30D6\u30EB\u540D\u304C\u5FC5\u8981\u3067\u3059",
       tok
     );
   }
+  /** `0埋め` のように数字から始まる日本語識別子を、空白なしの場合だけ読む。 */
+  tryParseDigitPrefixedIdentifier() {
+    const first = this.peek();
+    const second = this.peekAt(1);
+    if (first.kind !== "NUMBER" /* NUMBER */ || !/^\d+$/.test(first.value) || second.kind !== "IDENT" /* IDENT */ || second.pos !== first.pos + first.value.length) {
+      return null;
+    }
+    this.advance();
+    this.advance();
+    return first.value + second.value;
+  }
   // DML の対象テーブル位置に一時テーブルが指定されていたら拒否する
   rejectTempTableDml() {
     const tok = this.peek();
@@ -4781,6 +4817,7 @@ function unionCompleteInputReasons(stmt) {
 }
 function selectCompleteInputReasons(stmt) {
   const reasons = /* @__PURE__ */ new Set();
+  if (stmt.joins.some((join2) => join2.type === "CROSS")) reasons.add("CROSS_JOIN");
   const grouping = normalizeGroupingSpec(stmt);
   if (grouping.type === "GROUPING_SETS") reasons.add("GROUPING_SETS");
   if (grouping.type === "PLAIN") reasons.add("GROUP_BY");
@@ -6887,6 +6924,7 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
     }
   }
   for (const join2 of stmt.joins) {
+    if (join2.type === "CROSS") continue;
     addFieldRef(join2.on.left.field, join2.on.left.tableAlias, "where");
     addFieldRef(join2.on.right.field, join2.on.right.tableAlias, "where");
   }
@@ -7831,7 +7869,9 @@ function buildSingleTableKlikePushdownPlan(where, options = {}) {
   return { condition, relation, appliedKlikes, allKlikes: [...allKlikes] };
 }
 function buildKlikePushdownPlan(stmt, options = {}) {
-  const joinsAreSafeForKlike = stmt.joins.every((join2) => join2.type === "INNER");
+  const joinsAreSafeForKlike = stmt.joins.every(
+    (join2) => join2.type === "INNER" || join2.type === "CROSS"
+  );
   const common = {
     allowKlike: joinsAreSafeForKlike,
     allowUnresolvedKlikeVariables: options.allowUnresolvedVariables
@@ -7851,7 +7891,7 @@ function buildKlikePushdownPlan(stmt, options = {}) {
   const joinRelations = /* @__PURE__ */ new Map();
   if (stmt.where !== null) {
     for (const join2 of stmt.joins) {
-      if (join2.type !== "INNER" || !join2.table.alias || join2.table.subtableCode || join2.table.cteName !== null) continue;
+      if (join2.type !== "INNER" && join2.type !== "CROSS" || !join2.table.alias || join2.table.subtableCode || join2.table.cteName !== null) continue;
       const extracted = extractSafePushdownPlan(stmt.where, {
         ...common,
         tableAlias: join2.table.alias,
@@ -8198,7 +8238,7 @@ function validateSelect(stmt) {
   validateNestedSelects(stmt);
 }
 function canDeferJoinWholeWhereKlikeValidation(stmt) {
-  return stmt.where !== null && serverOnlyFunctionOccurrencesInWhere(stmt.where).length > 0 && stmt.joins.length > 0 && stmt.joins.every((join2) => join2.type === "INNER") && [stmt.from, ...stmt.joins.map((join2) => join2.table)].every(
+  return stmt.where !== null && serverOnlyFunctionOccurrencesInWhere(stmt.where).length > 0 && stmt.joins.length > 0 && stmt.joins.every((join2) => join2.type === "INNER" || join2.type === "CROSS") && [stmt.from, ...stmt.joins.map((join2) => join2.table)].every(
     (table) => table.alias !== null && table.cteName === null && !table.subtableCode
   );
 }
@@ -8417,7 +8457,8 @@ function assertStringFunctionArity(func, args) {
 }
 
 // src/core/generateSeries.ts
-var GENERATE_SERIES_MAX_ROWS = 1e4;
+var GENERATED_ROW_MAX_ROWS = 1e4;
+var GENERATE_SERIES_MAX_ROWS = GENERATED_ROW_MAX_ROWS;
 var argumentError = (message) => new Error(`ArgumentError: ${message}`);
 var isVariable = (arg) => arg.type === "VARIABLE";
 var isResolvedVariable = (arg) => arg?.type === "STRING" && arg.fromVariable === true;
@@ -8453,19 +8494,26 @@ function dateFromOrdinal(ordinal) {
 }
 function parseDateStep(value) {
   const trimmed = value.trim();
-  const match = /^([+-]?\d+)\s+(day|days)$/i.exec(trimmed);
+  const match = /^([+-]?\d+)\s+(day|days|month|months|year|years)$/i.exec(trimmed);
   if (!match) {
+    if (/^\S+\s+(?:day|days|month|months|year|years)$/i.test(trimmed)) {
+      throw argumentError("GENERATE_SERIES \u306E\u65E5\u4ED8 step \u306E\u4FC2\u6570\u306B\u306F\u5B89\u5168\u306A\u6574\u6570\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+    }
     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\u65E5\u4ED8 step \u306F day\u3001days\u3001month\u3001months\u3001year\u3001years \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");
+    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\u3001month\u3001year \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");
+  const coefficient = Number(match[1]);
+  if (!Number.isSafeInteger(coefficient)) {
+    throw argumentError("GENERATE_SERIES \u306E\u65E5\u4ED8 step \u306E\u4FC2\u6570\u306B\u306F\u5B89\u5168\u306A\u6574\u6570\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\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;
+  const rawUnit = match[2].toLowerCase();
+  const unit = rawUnit.startsWith("month") ? "MONTH" : rawUnit.startsWith("year") ? "YEAR" : "DAY";
+  if (coefficient === 0) {
+    throw argumentError(`GENERATE_SERIES \u306E\u65E5\u4ED8 step \u306B 0 ${unit.toLowerCase()} \u306F\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093\u3002`);
+  }
+  return { coefficient, unit };
 }
 function integerValue(value) {
   if (typeof value === "number") return Number.isSafeInteger(value) ? value : null;
@@ -8493,6 +8541,46 @@ function countRows(start, stop, step) {
   const distance = step > 0 ? BigInt(stop) - BigInt(start) : BigInt(start) - BigInt(stop);
   return Number(distance / BigInt(Math.abs(step)) + 1n);
 }
+function monthIndex(parts) {
+  return parts.year * 12 + parts.month - 1;
+}
+function validateDateAnchor(start, unit) {
+  if (unit === "MONTH" && start.day !== 1) {
+    throw argumentError("GENERATE_SERIES \u306E month step \u3067\u306F start \u306B\u6708\u521D\uFF08YYYY-MM-01\uFF09\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+  }
+  if (unit === "YEAR" && (start.month !== 1 || start.day !== 1)) {
+    throw argumentError("GENERATE_SERIES \u306E year step \u3067\u306F start \u306B\u5E74\u521D\uFF08YYYY-01-01\uFF09\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+  }
+}
+function countDateRows(start, stop, step) {
+  const startOrdinal = dateOrdinal(
+    `${String(start.year).padStart(4, "0")}-${String(start.month).padStart(2, "0")}-${String(start.day).padStart(2, "0")}`
+  );
+  const stopOrdinal = dateOrdinal(
+    `${String(stop.year).padStart(4, "0")}-${String(stop.month).padStart(2, "0")}-${String(stop.day).padStart(2, "0")}`
+  );
+  if (step.unit === "DAY") return countRows(startOrdinal, stopOrdinal, step.coefficient);
+  if (startOrdinal === stopOrdinal) return 1;
+  if (startOrdinal < stopOrdinal && step.coefficient < 0 || startOrdinal > stopOrdinal && step.coefficient > 0) return 0;
+  if (step.unit === "MONTH") {
+    const boundary2 = monthIndex(stop) + (step.coefficient < 0 && stop.day !== 1 ? 1 : 0);
+    return countRows(monthIndex(start), boundary2, step.coefficient);
+  }
+  const stopIsYearStart = stop.month === 1 && stop.day === 1;
+  const boundary = stop.year + (step.coefficient < 0 && !stopIsYearStart ? 1 : 0);
+  return countRows(start.year, boundary, step.coefficient);
+}
+function dateFromParts(year, month, day) {
+  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(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+function dateFromMonthIndex(index) {
+  const year = Math.floor(index / 12);
+  const month = index - year * 12 + 1;
+  return dateFromParts(year, month, 1);
+}
 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");
@@ -8518,12 +8606,20 @@ function planResolved(stmt) {
       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");
+      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\u3001month\u3001year \u5358\u4F4D\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
     }
-    const step2 = stepRaw === void 0 ? 1 : parseDateStep(stepRaw);
+    const dateStep = stepRaw === void 0 ? { coefficient: 1, unit: "DAY" } : parseDateStep(stepRaw);
+    validateDateAnchor(startDate, dateStep.unit);
     const start2 = startRaw;
     const stop2 = stopRaw;
-    return { kind: "DATE", start: start2, stop: stop2, step: step2, rowCount: countRows(dateOrdinal(start2), dateOrdinal(stop2), step2) };
+    return {
+      kind: "DATE",
+      start: start2,
+      stop: stop2,
+      step: dateStep.coefficient,
+      dateUnit: dateStep.unit,
+      rowCount: countDateRows(startDate, stopDate, dateStep)
+    };
   }
   const startInteger = startArg.type === "NUMBER" ? integerNumberLiteral(startArg) : isResolvedVariable(startArg) ? integerValue(startRaw) : null;
   const stopInteger = stopArg.type === "NUMBER" ? integerNumberLiteral(stopArg) : isResolvedVariable(stopArg) ? integerValue(stopRaw) : null;
@@ -8538,7 +8634,7 @@ function planResolved(stmt) {
     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");
+    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\u3001month\u3001year \u5358\u4F4D\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
   }
   const start = startInteger;
   const stop = stopInteger;
@@ -8574,7 +8670,12 @@ function validateGenerateSeriesStatement(stmt) {
       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);
+      const dateStep = parseDateStep(step.value);
+      const start = stmt.args[0];
+      if (start?.type === "STRING") {
+        const parts = dateParts(start.value);
+        if (parts) validateDateAnchor(parts, dateStep.unit);
+      }
     }
     return null;
   }
@@ -8629,8 +8730,22 @@ function resolveGenerateSeries(stmt) {
       }
     }
   } else {
-    const startOrdinal = dateOrdinal(plan.start);
-    for (let index = 0; index < plan.rowCount; index++) values.push(dateFromOrdinal(startOrdinal + index * plan.step));
+    const start = dateParts(plan.start);
+    if (plan.dateUnit === "MONTH") {
+      const anchor = monthIndex(start);
+      for (let index = 0; index < plan.rowCount; index++) {
+        values.push(dateFromMonthIndex(anchor + index * plan.step));
+      }
+    } else if (plan.dateUnit === "YEAR") {
+      for (let index = 0; index < plan.rowCount; index++) {
+        values.push(dateFromParts(start.year + index * plan.step, 1, 1));
+      }
+    } else {
+      const startOrdinal = dateOrdinal(plan.start);
+      for (let index = 0; index < plan.rowCount; index++) {
+        values.push(dateFromOrdinal(startOrdinal + index * plan.step));
+      }
+    }
   }
   return { ...plan, values };
 }
@@ -12774,6 +12889,19 @@ function planJoinKeyPrefilter(input) {
   return { kind: "RANGE", min, max, relation: "superset" };
 }
 
+// src/core/optimization/crossJoinRowPlan.ts
+var CROSS_JOIN_MAX_ROWS = GENERATED_ROW_MAX_ROWS;
+function planCrossJoinRows(leftRows, rightRows, limit = CROSS_JOIN_MAX_ROWS) {
+  const outputRows = leftRows === 0 || rightRows === 0 ? 0 : leftRows * rightRows;
+  return {
+    leftRows,
+    rightRows,
+    outputRows,
+    limit,
+    allowed: outputRows <= limit
+  };
+}
+
 // src/core/explainMetadata.ts
 function buildGroupingExplainMetadata(statement, canonicalItemCount) {
   const grouping = normalizeGroupingSpec(statement);
@@ -12814,11 +12942,30 @@ function valueNeedsFieldMetadata(value) {
 }
 function selectNeedsOwnMetadata(statement) {
   return whereNeedsFieldMetadata(statement.where) || statement.groupBy.length > 0 || normalizeGroupingSpec(statement).type === "GROUPING_SETS" || statement.orderBy.length > 0 || statement.joins.some(
-    (join2) => join2.table.appId > 0 && join2.table.cteName === null && (join2.on.left.field !== "$id" || join2.on.right.field !== "$id")
+    (join2) => join2.type !== "CROSS" && join2.table.appId > 0 && join2.table.cteName === null && (join2.on.left.field !== "$id" || join2.on.right.field !== "$id")
   ) || statement.columns.some(
     (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
   );
 }
+function cteQueriesContainPhysicalSelect(ctes) {
+  if (!Array.isArray(ctes)) return false;
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (node === null || typeof node !== "object") return false;
+    if (seen.has(node)) return false;
+    seen.add(node);
+    if (Array.isArray(node)) return node.some(visit);
+    const item = node;
+    if (item["type"] === "SELECT") {
+      const select = node;
+      if ([select.from, ...select.joins.map((join2) => join2.table)].some((table) => table.appId > 0 && table.cteName === null)) {
+        return true;
+      }
+    }
+    return Object.values(item).some(visit);
+  };
+  return ctes.some((cte) => visit(cte?.query));
+}
 function explainNeedsAppMetadata(statement) {
   const seen = /* @__PURE__ */ new Set();
   const visit = (node) => {
@@ -12828,6 +12975,9 @@ function explainNeedsAppMetadata(statement) {
     if (Array.isArray(node)) return node.some(visit);
     const item = node;
     if (item["type"] === "VALIDATE") return true;
+    if (item["type"] === "WITH" && cteQueriesContainPhysicalSelect(item["ctes"])) {
+      return true;
+    }
     if (item["type"] === "SELECT" && selectNeedsOwnMetadata(node)) {
       return true;
     }
@@ -14051,6 +14201,19 @@ function flatten(record, alias) {
   return row;
 }
 function applyJoin(leftRows, rightRows, join2, columns = {}) {
+  if (join2.type === "CROSS") {
+    const plan = planCrossJoinRows(leftRows.length, rightRows.length);
+    if (!plan.allowed) {
+      throw new Error(
+        `ArgumentError: CROSS JOIN \u306E\u751F\u6210\u4EF6\u6570 ${plan.outputRows} \u884C\uFF08\u5DE6 ${plan.leftRows} \u884C \xD7 \u53F3 ${plan.rightRows} \u884C\uFF09\u304C\u4E0A\u9650 ${plan.limit} \u884C\u3092\u8D85\u3048\u3066\u3044\u307E\u3059\u3002`
+      );
+    }
+    const result2 = [];
+    for (const lRow of leftRows) {
+      for (const rRow of rightRows) result2.push({ ...lRow, ...rRow });
+    }
+    return result2;
+  }
   const { on, type: joinType } = join2;
   const leftKey = on.left.tableAlias ? `${on.left.tableAlias}.${on.left.field}` : on.left.field;
   const rightKey = on.right.tableAlias ? `${on.right.tableAlias}.${on.right.field}` : on.right.field;
@@ -15741,7 +15904,7 @@ function allowRelativeDatePrefilterPlan(select, decomposition) {
   return decomposition.eligible === true && resolveSelectMode(select) === "FULL_SCAN" && select.orderMode !== "KINTONE_NATIVE" && select.from.cteName === null && !select.from.subtableCode && select.joins.length === 0;
 }
 function allowJoinServerFunctionPlan(select, plan) {
-  return select.where !== null && select.joins.length > 0 && select.joins.every((join2) => join2.type === "INNER") && [select.from, ...select.joins.map((join2) => join2.table)].every(
+  return select.where !== null && select.joins.length > 0 && select.joins.every((join2) => join2.type === "INNER" || join2.type === "CROSS") && [select.from, ...select.joins.map((join2) => join2.table)].every(
     (table) => table.alias !== null && table.cteName === null && !table.subtableCode
   ) && isJoinServerFunctionFetchPlan(plan);
 }
@@ -19056,7 +19219,7 @@ function completeInputErrorPrefix(reasons) {
   const hasAggregateReason = aggregateSubjects.some(([reason]) => reasons.has(reason));
   const hasOrderReason = reasons.has("LOCAL_ORDER") || reasons.has("WINDOW_ORDER");
   const legacySubject = reasons.size === 1 && reasons.has("STATISTICAL_AGGREGATE") ? "\u7D71\u8A08\u96C6\u7D04\u306E\u6B63\u3057\u3044\u7D50\u679C" : reasons.size === 1 && reasons.has("GROUPING_SETS") ? "\u5C0F\u8A08\u30FB\u7DCF\u8A08\u306E\u6B63\u3057\u3044\u7D50\u679C" : reasons.size === 1 && reasons.has("AGGREGATE") ? "\u96C6\u8A08\u306E\u6B63\u3057\u3044\u7D50\u679C" : reasons.size === 1 && reasons.has("GROUP_BY") ? "\u30B0\u30EB\u30FC\u30D7\u96C6\u8A08\u306E\u6B63\u3057\u3044\u7D50\u679C" : reasons.size === 1 && reasons.has("DISTINCT") ? "DISTINCT \u306E\u6B63\u3057\u3044\u7D50\u679C" : reasons.has("GROUPING_SETS") ? "\u30AF\u30A8\u30EA\u306E\u6B63\u3057\u3044\u7D50\u679C" : "ORDER BY\u306E\u6B63\u3057\u3044\u7D50\u679C";
-  const subject = reasons.has("DML") || reasons.has("VALIDATE") ? legacySubject : hasAggregateReason && hasOrderReason ? "\u30AF\u30A8\u30EA\u306E\u6B63\u3057\u3044\u7D50\u679C" : hasAggregateReason ? aggregateSubjects.find(([reason]) => reasons.has(reason))[1] : "ORDER BY\u306E\u6B63\u3057\u3044\u7D50\u679C";
+  const subject = reasons.size === 1 && reasons.has("CROSS_JOIN") ? "CROSS JOIN \u306E\u6B63\u3057\u3044\u7D50\u679C" : reasons.has("DML") || reasons.has("VALIDATE") ? legacySubject : hasAggregateReason && hasOrderReason ? "\u30AF\u30A8\u30EA\u306E\u6B63\u3057\u3044\u7D50\u679C" : hasAggregateReason ? aggregateSubjects.find(([reason]) => reasons.has(reason))[1] : "ORDER BY\u306E\u6B63\u3057\u3044\u7D50\u679C";
   return `${subject}\u306B\u306F\u5B8C\u5168\u306A\u5019\u88DC\u96C6\u5408\u304C\u5FC5\u8981\u3067\u3059\u3002complete input reason: ${reasonList}\u3002`;
 }
 function buildCompleteInputPolicy(stmt, options, orderPlan) {
@@ -19427,6 +19590,7 @@ async function validateB86SelectFieldCodes(stmt, client, cteCache, cacheContext)
     for (const alias of b86SourceAliases(schema.table)) sourceByAlias.set(alias, schema);
   }
   for (const join2 of stmt.joins) {
+    if (join2.type === "CROSS") continue;
     for (const ref of [join2.on.left, join2.on.right]) {
       if (!ref.tableAlias) continue;
       const schema = sourceByAlias.get(ref.tableAlias);
@@ -19497,7 +19661,7 @@ function hasPushdownPlaceholder(where) {
 }
 var boundJoinRuntimePlans = /* @__PURE__ */ new WeakMap();
 function buildRuntimeJoinPushdownPlan(stmt, metadata) {
-  if (stmt.joins.length === 0 || stmt.where === null || stmt.joins.some((join2) => join2.type !== "INNER")) {
+  if (stmt.joins.length === 0 || stmt.where === null || stmt.joins.some((join2) => join2.type !== "INNER" && join2.type !== "CROSS")) {
     return null;
   }
   const tables = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
@@ -19556,7 +19720,7 @@ async function loadTypedPushdownMeta(stmt, client, cacheContext) {
     else candidatesByApp.set(appId, [candidate]);
   };
   addCandidate(stmt.from.appId, extractMainTypedPushdownCandidate(stmt));
-  const directInnerJoin = stmt.joins.length > 0 && stmt.where !== null && stmt.joins.every((join2) => join2.type === "INNER") && [stmt.from, ...stmt.joins.map((join2) => join2.table)].every(
+  const directInnerJoin = stmt.joins.length > 0 && stmt.where !== null && stmt.joins.every((join2) => join2.type === "INNER" || join2.type === "CROSS") && [stmt.from, ...stmt.joins.map((join2) => join2.table)].every(
     (table) => table.alias !== null && table.cteName === null && !table.subtableCode
   );
   if (directInnerJoin) {
@@ -24273,6 +24437,7 @@ var explainJoinPushdownPlans = /* @__PURE__ */ new WeakMap();
 var explainPushdownPlans = /* @__PURE__ */ new WeakMap();
 var explainJoinKeyPrefilters = /* @__PURE__ */ new WeakMap();
 var explainChoiceEqualityRewrites = /* @__PURE__ */ new WeakMap();
+var explainCrossJoinSteps = /* @__PURE__ */ new WeakMap();
 var validateExplainInfo = /* @__PURE__ */ new WeakMap();
 var applyParentExplainPlan = /* @__PURE__ */ new WeakMap();
 async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords = 1e4, relativeDatePlan, initialRelations) {
@@ -24304,6 +24469,54 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
   );
   const explainRelations = new Map(initialRelations ?? []);
   const staticExplainRelations = new Set(initialRelations?.keys() ?? []);
+  const exactRelationRows = new Map(
+    [...initialRelations ?? /* @__PURE__ */ new Map()].map(([name, relation]) => [name, relation.rows.length])
+  );
+  const staticSelectRows = /* @__PURE__ */ new WeakMap();
+  const tableLabel = (table) => effectiveTableAlias(table) ?? (table.appId > 0 ? `APP${table.appId}` : "source");
+  const tableExactRows = (table) => {
+    if (table.cteName === NO_FROM_CTE_NAME) return 1;
+    if (table.cteName !== null) return exactRelationRows.get(table.cteName) ?? null;
+    return null;
+  };
+  const analyzeStaticSelectRows = (select) => {
+    let currentRows = tableExactRows(select.from);
+    let leftLabel = tableLabel(select.from);
+    const steps = [];
+    for (const join2 of select.joins) {
+      const rightRows = tableExactRows(join2.table);
+      const rightLabel = tableLabel(join2.table);
+      if (join2.type === "CROSS") {
+        const plan = currentRows !== null && rightRows !== null ? planCrossJoinRows(currentRows, rightRows) : null;
+        steps.push({
+          leftLabel,
+          rightLabel,
+          leftRows: currentRows,
+          rightRows,
+          plan,
+          rightRuntimeLabel: join2.table.cteName === null ? `APP${join2.table.appId} fetched rows` : `${rightLabel} materialized rows`
+        });
+        currentRows = plan?.outputRows ?? null;
+        leftLabel = `${leftLabel} \xD7 ${rightLabel}`;
+      } else {
+        currentRows = null;
+        leftLabel = `${leftLabel} ${join2.type} JOIN ${rightLabel}`;
+      }
+    }
+    if (steps.length > 0) explainCrossJoinSteps.set(select, steps);
+    if (isConstantFalseWhere(select.where)) currentRows = 0;
+    else if (select.where !== null) currentRows = null;
+    const grouping = normalizeGroupingSpec(select);
+    if (grouping.type !== "NONE" || select.distinct || select.having !== null || isAggregateQueryBlock(select) || select.columns.some((column) => column.type === "WINDOW_COL")) {
+      currentRows = null;
+    }
+    if (currentRows !== null) {
+      const offset = select.offset ?? 0;
+      currentRows = Math.max(0, currentRows - offset);
+      if (select.limit !== null) currentRows = Math.min(currentRows, select.limit);
+      staticSelectRows.set(select, currentRows);
+    }
+  };
   const explainSourceColumns = async (select) => {
     const tables = [select.from, ...select.joins.map((join2) => join2.table)];
     if (tables.length > 1 && select.columns.some(
@@ -24384,6 +24597,10 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       for (const cte of withStatement.ctes) {
         await preflightExplainRelations(cte.query);
         if (cte.query.type === "GENERATE_SERIES") {
+          if (cte.query.args.some((arg) => arg.type === "VARIABLE")) {
+            explainRelations.set(cte.name, { rows: [], columns: [cte.query.columnAlias] });
+            continue;
+          }
           const generated = executeGenerateSeries(cte.query);
           explainRelations.set(cte.name, {
             rows: generated.rows,
@@ -24392,10 +24609,15 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
             uniqueGeneratedColumn: cte.query.columnAlias
           });
           staticExplainRelations.add(cte.name);
+          exactRelationRows.set(cte.name, generated.rows.length);
           continue;
         }
         const columns = await inferExplainRelationColumns(cte.query);
         explainRelations.set(cte.name, { rows: [], columns });
+        if (cte.query.type === "SELECT") {
+          const rowCount = staticSelectRows.get(cte.query);
+          if (rowCount !== void 0) exactRelationRows.set(cte.name, rowCount);
+        }
       }
       await preflightExplainRelations(withStatement.query);
       return;
@@ -24407,6 +24629,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     }
     if (typed["type"] === "SELECT") {
       const select = node;
+      analyzeStaticSelectRows(select);
       for (const column of select.columns) {
         if (column.type === "SCALAR_SUBQUERY_COL") await preflightExplainRelations(column.query);
       }
@@ -24418,13 +24641,19 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         cacheContext,
         explainRelations
       );
-      const plainPlan = await buildRuntimePlainGroupByPlan(
-        select,
-        tracedClient,
-        cacheContext,
-        explainRelations
+      const sources = [select.from, ...select.joins.map((join2) => join2.table)];
+      const hasUnavailableMaterializedSource = sources.some(
+        (source) => source.cteName !== null && !explainRelations.has(source.cteName)
       );
-      if (plainPlan) plainGroupByPlans.set(select, plainPlan);
+      if (!hasUnavailableMaterializedSource) {
+        const plainPlan = await buildRuntimePlainGroupByPlan(
+          select,
+          tracedClient,
+          cacheContext,
+          explainRelations
+        );
+        if (plainPlan) plainGroupByPlans.set(select, plainPlan);
+      }
       return;
     }
     for (const child of Object.values(typed)) await preflightExplainRelations(child);
@@ -24953,6 +25182,106 @@ function serverFunctionClientEvaluationLabel(leaves) {
     (leaf) => leaf.right.type === "KINTONE_FUNC" && isRelativeDateFunctionName(leaf.right.name)
   ) ? "relative date client evaluations" : "kintone function client evaluations";
 }
+var explainSeriesBindings = /* @__PURE__ */ new WeakMap();
+function resolveExplainGenerateSeriesDefaults(node, literalDefaults) {
+  if (Array.isArray(node)) {
+    return node.map((value) => resolveExplainGenerateSeriesDefaults(value, literalDefaults));
+  }
+  if (node === null || typeof node !== "object") return node;
+  const object = node;
+  if (object["type"] === "GENERATE_SERIES") {
+    const variableNames = /* @__PURE__ */ new Map();
+    const defaultBoundIndexes = /* @__PURE__ */ new Set();
+    const args = object["args"].map((arg, index) => {
+      if (arg.type !== "STRING" || arg.fromVariable !== true || !arg.value.startsWith("@")) return arg;
+      const name = arg.value.slice(1);
+      variableNames.set(index, name);
+      const defaultValue = literalDefaults.get(name);
+      if (defaultValue === void 0) return { type: "VARIABLE", name };
+      defaultBoundIndexes.add(index);
+      return { type: "STRING", value: defaultValue, fromVariable: true };
+    });
+    const resolved = { ...object, args };
+    explainSeriesBindings.set(resolved, { variableNames, defaultBoundIndexes });
+    return resolved;
+  }
+  return Object.fromEntries(Object.entries(object).map(([key, value]) => [
+    key,
+    resolveExplainGenerateSeriesDefaults(value, literalDefaults)
+  ]));
+}
+function inferStaticExplainSchema(node, relations) {
+  if (node.type === "SHOW_APPS") return { status: "STATIC", columns: [...SHOW_APPS_COLUMNS] };
+  if (node.type === "DESCRIBE") return { status: "STATIC", columns: [...DESCRIBE_COLUMNS] };
+  if (node.type === "GENERATE_SERIES") {
+    return { status: "STATIC", columns: [node.columnAlias] };
+  }
+  if (node.type === "WITH") {
+    const local = new Map(relations);
+    for (const cte of node.ctes) {
+      const schema = inferStaticExplainSchema(cte.query, local);
+      local.set(cte.name, schema);
+    }
+    return inferStaticExplainSchema(node.query, local);
+  }
+  if (node.type === "UNION") {
+    const left = inferStaticExplainSchema(node.left, relations);
+    const right = inferStaticExplainSchema(node.right, relations);
+    return left.status === "STATIC" && right.status === "STATIC" ? { status: "STATIC", columns: left.columns } : { status: "DEFERRED" };
+  }
+  const sources = [node.from, ...node.joins.map((join2) => join2.table)];
+  const relationSources = sources.filter((source) => source.cteName !== null && source.cteName !== NO_FROM_CTE_NAME);
+  if (relationSources.some((source) => relations.get(source.cteName)?.status !== "STATIC")) {
+    return { status: "DEFERRED" };
+  }
+  const hasWildcard = node.columns.some(
+    (column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD"
+  );
+  if (hasWildcard) {
+    if (sources.length !== 1 || sources[0].cteName === null) return { status: "DEFERRED" };
+  }
+  const sourceColumns2 = relationSources.flatMap((source) => {
+    const schema = relations.get(source.cteName);
+    return schema?.status === "STATIC" ? [...schema.columns] : [];
+  });
+  const columns = [];
+  for (const column of node.columns) {
+    if (column.type === "WILDCARD") columns.push(...sourceColumns2);
+    else if (column.type === "PARENT_WILDCARD") {
+      columns.push(...sourceColumns2.filter((name) => name.startsWith("_p.")));
+    } else {
+      columns.push(...project([], [column]).columns);
+    }
+  }
+  return { status: "STATIC", columns };
+}
+function staticSchemaRelations(ledger) {
+  return new Map([...ledger].flatMap(
+    ([name, entry]) => entry.status === "STATIC" ? [[name, entry.relation]] : []
+  ));
+}
+async function buildStaticTempPlainGroupByPlans(node, client, cacheContext, relations) {
+  const plans = /* @__PURE__ */ new Map();
+  const visit = async (value) => {
+    if (value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (const child of value) await visit(child);
+      return;
+    }
+    const object = value;
+    if (object["type"] === "SELECT") {
+      const select = value;
+      const sources = [select.from, ...select.joins.map((join2) => join2.table)];
+      if (sources.some((source) => source.cteName !== null) && sources.every((source) => source.cteName === NO_FROM_CTE_NAME || source.cteName !== null && relations.has(source.cteName))) {
+        const plan = await buildRuntimePlainGroupByPlan(select, client, cacheContext, relations);
+        if (plan) plans.set(select, plan);
+      }
+    }
+    for (const child of Object.values(object)) await visit(child);
+  };
+  await visit(node);
+  return plans;
+}
 var EXPLAIN_FETCH_PLAN = /* @__PURE__ */ Symbol("ksql.explainFetchPlan");
 function setExplainFetchPlan(result, plan) {
   result[EXPLAIN_FETCH_PLAN] = plan;
@@ -24965,19 +25294,27 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
     const normalizedInjectedVariables = validateDeclaredBatchVariables(statements, injectedVariables);
     const relativeDateVariables = prepareRelativeDateVariables(statements, normalizedInjectedVariables);
     const variables = /* @__PURE__ */ new Map();
+    const literalDeclareDefaults = /* @__PURE__ */ new Map();
+    const tempSchemaLedger = /* @__PURE__ */ new Map();
     const plans = [];
     const fetchStatements = [];
     for (let i = 0; i < statements.length; i++) {
       const stmt = statements[i];
-      const planStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveBatchVariableReferences(stmt.expr, variables) } : stmt : resolveBatchVariableReferences(stmt, variables);
+      const placeholderResolvedStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveBatchVariableReferences(stmt.expr, variables) } : stmt : resolveBatchVariableReferences(stmt, variables);
+      const planStmt = resolveExplainGenerateSeriesDefaults(
+        placeholderResolvedStmt,
+        literalDeclareDefaults
+      );
       validateStatementStatic(planStmt);
       const relativeDatePlan = await resolveRelativeDateExecutionPlan(planStmt, client, invocationCacheContext);
+      const initialRelations = staticSchemaRelations(tempSchemaLedger);
       const whereAnalysis = resolveMetadata ? await buildExplainWhereAnalysis(
         planStmt,
         client,
         invocationCacheContext,
         maxRecords,
-        relativeDatePlan
+        relativeDatePlan,
+        initialRelations
       ) : {
         capabilities: /* @__PURE__ */ new Map(),
         orderPlans: /* @__PURE__ */ new Map(),
@@ -24987,6 +25324,34 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
         numberPrecisionApps: /* @__PURE__ */ new Set(),
         relativeDatePlan
       };
+      if (!resolveMetadata) {
+        const staticPlans = await buildStaticTempPlainGroupByPlans(
+          planStmt,
+          client,
+          invocationCacheContext,
+          initialRelations
+        );
+        for (const [select, plan] of staticPlans) whereAnalysis.plainGroupByPlans.set(select, plan);
+      }
+      let createdSchema;
+      if (planStmt.type === "CREATE_TEMP_TABLE") {
+        const relationSchemas = new Map([...tempSchemaLedger].map(([name, entry]) => [
+          name,
+          entry.status === "STATIC" ? { status: "STATIC", columns: entry.columns } : { status: "DEFERRED" }
+        ]));
+        const inferred = inferStaticExplainSchema(planStmt.query, relationSchemas);
+        createdSchema = inferred.status === "STATIC" ? {
+          status: "STATIC",
+          columns: inferred.columns,
+          relation: { rows: [], columns: [...inferred.columns] },
+          producerStatement: i + 1
+        } : {
+          status: "DEFERRED",
+          producerStatement: i + 1,
+          reason: "EXPLAIN_TEMP_SCHEMA_UNAVAILABLE"
+        };
+        tempSchemaLedger.set(planStmt.name, createdSchema);
+      }
       const fetchCollector = { sources: [] };
       const statementPlan = relativeDatePlan.hasServerOnlyWhereFunction && !relativeDatePlan.allowed ? relativeDateExplainLines(relativeDatePlan) : [
         ...relativeDateExplainLines(relativeDatePlan),
@@ -24995,9 +25360,12 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
           analysis.statements[i],
           whereAnalysis.capabilities,
           whereAnalysis.orderPlans,
+          whereAnalysis.plainGroupByPlans,
           dmlMaxRows,
           dmlMaxSubtableRows,
-          fetchCollector
+          fetchCollector,
+          tempSchemaLedger,
+          createdSchema
         ), cursorMaxActive)
       ];
       const metadataPlan = explainMetadataLines(whereAnalysis);
@@ -25011,8 +25379,15 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
         fetch: worstExplainFetch(fetchCollector.sources),
         sources: fetchCollector.sources
       });
+      if (planStmt.type === "DROP_TEMP_TABLE") tempSchemaLedger.delete(planStmt.name);
       if (stmt.type === "SET_VARIABLE" || stmt.type === "DECLARE_VARIABLE") {
         variables.set(stmt.name, stmt.type === "DECLARE_VARIABLE" && stmt.annotation === "RELATIVE_DATE" ? { type: "relative-date", value: relativeDateVariables.get(stmt.name) } : stmt.type === "SET_VARIABLE" && stmt.expr.type === "ARRAY" ? { type: "array", elements: stmt.expr.elements.map((element) => ({ type: "string", value: element.value })) } : { type: "string", value: `@${stmt.name}`, placeholder: true });
+        if (stmt.type === "DECLARE_VARIABLE" && stmt.annotation === void 0 && (stmt.default.type === "STRING" || stmt.default.type === "NUMBER")) {
+          literalDeclareDefaults.set(
+            stmt.name,
+            stmt.default.type === "STRING" ? stmt.default.value : numberLiteralText(stmt.default)
+          );
+        }
       }
     }
     const result = { statementCount: statements.length, statements: plans };
@@ -25022,19 +25397,28 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
     releaseMetadataCacheScope(invocationCacheContext);
   }
 }
-function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, collector = { sources: [] }) {
+function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, plainGroupByPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, collector = { sources: [] }, tempSchemaLedger = /* @__PURE__ */ new Map(), createdSchema) {
   if (stmt.type === "CREATE_TEMP_TABLE") {
     return [
       `CREATE TEMP TABLE ${stmt.name}`,
       `  scope:         batch\uFF08\u30D0\u30C3\u30C1\u7D42\u4E86\u6642\u306B\u81EA\u52D5\u7834\u68C4\uFF09`,
+      ...createdSchema?.status === "STATIC" ? [
+        `  schema:        ${createdSchema.columns.join(", ")}`,
+        `  schema source: SELECT output of statement ${createdSchema.producerStatement}`
+      ] : createdSchema ? [
+        "  schema:        deferred (could not be derived statically)",
+        `  plan status:   deferred (temp table schema; reason=${createdSchema.reason})`
+      ] : [],
       `  rows:          \u5B9F\u4F53\u5316\u524D\u306E\u305F\u3081\u4E0D\u660E\uFF08\u65E2\u5B9A\u4E0A\u9650 ${TEMP_TABLE_MAX_ROWS} \u884C\u3001tempTableMaxRows \u3067\u5909\u66F4\u53EF\u3001\u8D85\u904E\u306F\u30A8\u30E9\u30FC\uFF09`,
       ...buildPlanForBatchQuery(
         stmt.query,
         info,
         capabilities,
         orderPlans,
+        plainGroupByPlans,
         collector,
-        "main"
+        "main",
+        tempSchemaLedger
       ).map((l) => `  ${l}`)
     ];
   }
@@ -25056,7 +25440,10 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, dmlMaxRow
           subInfo,
           capabilities,
           orderPlans,
-          collector
+          plainGroupByPlans,
+          collector,
+          "main",
+          tempSchemaLedger
         ).map((l) => `  ${l}`)
       ];
     }
@@ -25085,7 +25472,10 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, dmlMaxRow
       info,
       capabilities,
       orderPlans,
-      collector
+      plainGroupByPlans,
+      collector,
+      "main",
+      tempSchemaLedger
     );
   }
   if (stmt.type === "ASSERT") {
@@ -25104,15 +25494,36 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, dmlMaxRow
         subInfo,
         capabilities,
         orderPlans,
-        collector
+        plainGroupByPlans,
+        collector,
+        "main",
+        tempSchemaLedger
       ).map((l) => `  ${l}`));
     });
     return lines;
   }
   if (stmt.type === "UPDATE" && (stmt.applyBlocks?.length ?? 0) > 0) {
-    return buildExplainPlan(stmt, void 0, capabilities, orderPlans, dmlMaxRows, dmlMaxSubtableRows);
+    return buildExplainPlan(
+      stmt,
+      void 0,
+      capabilities,
+      orderPlans,
+      dmlMaxRows,
+      dmlMaxSubtableRows,
+      1e4,
+      plainGroupByPlans
+    );
   }
-  return buildPlanForBatchQuery(stmt, info, capabilities, orderPlans, collector);
+  return buildPlanForBatchQuery(
+    stmt,
+    info,
+    capabilities,
+    orderPlans,
+    plainGroupByPlans,
+    collector,
+    "main",
+    tempSchemaLedger
+  );
 }
 function hasTempTableRef(node) {
   if (Array.isArray(node)) return node.some(hasTempTableRef);
@@ -25124,7 +25535,7 @@ function hasTempTableRef(node) {
   }
   return false;
 }
-function buildPlanForBatchQuery(query, info, capabilities, orderPlans, collector = { sources: [] }, sourceRole = "main") {
+function buildPlanForBatchQuery(query, info, capabilities, orderPlans, plainGroupByPlans, collector = { sources: [] }, sourceRole = "main", tempSchemaLedger = /* @__PURE__ */ new Map()) {
   if (info.tempTablesReferenced.length === 0) {
     return buildExplainPlan(
       query,
@@ -25134,7 +25545,7 @@ function buildPlanForBatchQuery(query, info, capabilities, orderPlans, collector
       100,
       DEFAULT_APPLY_MAX_SUBTABLE_ROWS,
       1e4,
-      void 0,
+      plainGroupByPlans,
       true,
       collector,
       sourceRole
@@ -25154,6 +25565,26 @@ function buildPlanForBatchQuery(query, info, capabilities, orderPlans, collector
   lines.push(
     `  temp:          ${info.tempTablesReferenced.join(", ")}\uFF08\u30A4\u30F3\u30E1\u30E2\u30EA\u8D70\u67FB\u3002\u5B9F\u4F53\u5316\u524D\u306E\u305F\u3081\u884C\u6570\u4E0D\u660E\uFF09`
   );
+  const entries = info.tempTablesReferenced.map((name) => [name, tempSchemaLedger.get(name)]);
+  for (const [name, entry] of entries) {
+    if (entry?.status === "STATIC") {
+      lines.push(`  source:        temp table ${name} (schema from statement ${entry.producerStatement})`);
+    } else {
+      lines.push(`  source:        temp table ${name}`);
+      lines.push("  schema:        deferred (could not be derived statically)");
+    }
+  }
+  lines.push("  rows:          runtime (not materialized by EXPLAIN)");
+  const directSelect = query.type === "SELECT" ? query : query.type === "EXPLAIN" && query.query.type === "SELECT" ? query.query : void 0;
+  if (directSelect) {
+    lines.push(...renderPlainGroupByExplainLines(
+      directSelect,
+      plainGroupByPlans?.get(directSelect),
+      entries.some(([, entry]) => entry?.status !== "STATIC")
+    ));
+  }
+  lines.push(entries.every(([, entry]) => entry?.status === "STATIC") ? "  plan status:   static schema / runtime rows" : "  plan status:   deferred (temp table schema)");
+  lines.push("  records API:   none");
   const apps = info.appIds.filter(
     (a) => query.type !== "INSERT_SELECT" && query.type !== "UPSERT_SELECT" || a !== query.appId
   );
@@ -25423,6 +25854,33 @@ function formatChoiceEqualityRewrite(rewrite) {
   const normalizedOperator = rewrite.normalizedOperator === "IN" ? "in" : "not in";
   return `  pushdown normalized: ${field} ${rewrite.originalOperator} '${originalValue}' -> ${field} ${normalizedOperator} ("${normalizedValue}")`;
 }
+function renderPlainGroupByExplainLines(stmt, plainGroupByPlan, schemaDeferred) {
+  const normalizedGrouping = normalizeGroupingSpec(stmt);
+  if (normalizedGrouping.type !== "PLAIN") return [];
+  const lines = [];
+  if (plainGroupByPlan) {
+    plainGroupByPlan.items.forEach((item, index) => {
+      const key = normalizedGrouping.allItems[index];
+      if (key?.type !== "FIELD_NAME") return;
+      if (item.kind === "PHYSICAL") {
+        lines.push(
+          `  group key ${key.name}: PHYSICAL (source=${item.sourceIndex}, field=${item.fieldCode})`
+        );
+      } else if (item.kind === "ALIAS_SAFE") {
+        lines.push(`  group key ${key.name}: ALIAS_SAFE (column=${item.columnIndex})`);
+      } else if (item.kind === "EXPRESSION") {
+        lines.push(`  group key ${key.name}: EXPRESSION`);
+      }
+    });
+  } else if (schemaDeferred) {
+    for (const key of normalizedGrouping.allItems) {
+      if (key.type === "FIELD_NAME") {
+        lines.push(`  group key ${key.name}: DEFERRED (temp table schema unavailable)`);
+      }
+    }
+  }
+  return lines;
+}
 function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlans, allowTotalCountPlan = true, emitFetch = true, collector = { sources: [] }, sourceRole = "main") {
   const whereCapability = capabilities?.get(stmt) ?? (capabilities ? [...capabilities].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
   const orderPlan = orderPlans?.get(stmt) ?? (orderPlans ? [...orderPlans].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
@@ -25440,6 +25898,23 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
   );
   if (label) lines.push(label);
   lines.push(`  mode:          ${mode}`);
+  for (const step of explainCrossJoinSteps.get(stmt) ?? []) {
+    lines.push(`  cross join:    ${step.leftLabel} \xD7 ${step.rightLabel}`);
+    lines.push(`  left rows:     ${step.leftRows ?? "runtime (left intermediate rows)"}`);
+    lines.push(`  right rows:    ${step.rightRows ?? `runtime (${step.rightRuntimeLabel})`}`);
+    if (step.plan) {
+      lines.push(`  rows:          ${step.plan.outputRows}`);
+      lines.push(`  row guard:     ${step.plan.outputRows} / ${step.plan.limit}`);
+      lines.push("  guard timing:  before row materialization");
+    } else {
+      const left = step.leftRows === null ? "left rows" : String(step.leftRows);
+      const right = step.rightRows === null ? "right rows" : String(step.rightRows);
+      lines.push(`  rows:          runtime (${left} \xD7 ${right})`);
+      lines.push(`  row guard:     runtime checked / ${CROSS_JOIN_MAX_ROWS}`);
+      lines.push("  guard timing:  after complete source fetch, before row materialization");
+    }
+    lines.push("  records API:   none");
+  }
   for (const rewrite of explainChoiceEqualityRewrites.get(stmt) ?? choiceEqualityRewritesBySelect.get(stmt) ?? []) {
     lines.push(formatChoiceEqualityRewrite(rewrite));
   }
@@ -25455,35 +25930,11 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
       `  grouping output rows: runtime checked (limit: ${groupingMetadata.outputRowLimit}, before HAVING/DISTINCT/LIMIT)`
     );
   }
-  const normalizedGrouping = normalizeGroupingSpec(stmt);
-  if (normalizedGrouping.type === "PLAIN") {
-    const groupBy = normalizedGrouping.allItems;
-    if (plainGroupByPlan) {
-      plainGroupByPlan.items.forEach((item, index) => {
-        const key = groupBy[index];
-        if (key?.type !== "FIELD_NAME") return;
-        if (item.kind === "PHYSICAL") {
-          lines.push(
-            `  group key ${key.name}: PHYSICAL (source=${item.sourceIndex}, field=${item.fieldCode})`
-          );
-        } else if (item.kind === "ALIAS_SAFE") {
-          lines.push(
-            `  group key ${key.name}: ALIAS_SAFE (column=${item.columnIndex})`
-          );
-        } else if (item.kind === "EXPRESSION") {
-          lines.push(`  group key ${key.name}: EXPRESSION`);
-        }
-      });
-    } else if ([stmt.from, ...stmt.joins.map((join2) => join2.table)].some((table) => table.cteName !== null)) {
-      for (const key of groupBy) {
-        if (key.type === "FIELD_NAME") {
-          lines.push(
-            `  group key ${key.name}: DEFERRED (materialized schema unavailable)`
-          );
-        }
-      }
-    }
-  }
+  lines.push(...renderPlainGroupByExplainLines(
+    stmt,
+    plainGroupByPlan,
+    [stmt.from, ...stmt.joins.map((join2) => join2.table)].some((table) => table.cteName !== null)
+  ));
   for (const column of stmt.columns) {
     if (column.type !== "WINDOW_COL" || column.windowKind === void 0 || column.windowKind === "RANKING") continue;
     const clauses = [];
@@ -25604,7 +26055,7 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
           }
         }
       } else {
-        const reason = stmt.joins.some((join2) => join2.type !== "INNER") ? "OUTER_JOIN" : [stmt.from, ...stmt.joins.map((join2) => join2.table)].some(
+        const reason = stmt.joins.some((join2) => join2.type !== "INNER" && join2.type !== "CROSS") ? "OUTER_JOIN" : [stmt.from, ...stmt.joins.map((join2) => join2.table)].some(
           (table) => table.cteName !== null || Boolean(table.subtableCode)
         ) ? "SOURCE_KIND" : "PLAN_NOT_APPLICABLE";
         lines.push("  join pushdown plan: not applied (join key/WHERE prefilters are reported per source below)");
@@ -25756,7 +26207,69 @@ function buildUnionPlan(stmt, capabilities, orderPlans, plainGroupByPlans, colle
   });
   return lines;
 }
+function populateWithCrossJoinExplain(stmt) {
+  const exactRows = /* @__PURE__ */ new Map();
+  const labelFor = (table) => effectiveTableAlias(table) ?? (table.appId > 0 ? `APP${table.appId}` : "source");
+  const rowsFor = (table) => {
+    if (table.cteName === NO_FROM_CTE_NAME) return 1;
+    return table.cteName === null ? null : exactRows.get(table.cteName) ?? null;
+  };
+  const analyze = (select) => {
+    let current = rowsFor(select.from);
+    let leftLabel = labelFor(select.from);
+    const steps = [];
+    for (const join2 of select.joins) {
+      const right = rowsFor(join2.table);
+      const rightLabel = labelFor(join2.table);
+      if (join2.type === "CROSS") {
+        const plan = current !== null && right !== null ? planCrossJoinRows(current, right) : null;
+        steps.push({
+          leftLabel,
+          rightLabel,
+          leftRows: current,
+          rightRows: right,
+          plan,
+          rightRuntimeLabel: join2.table.cteName === null ? `APP${join2.table.appId} fetched rows` : `${rightLabel} materialized rows`
+        });
+        current = plan?.outputRows ?? null;
+        leftLabel = `${leftLabel} \xD7 ${rightLabel}`;
+      } else {
+        current = null;
+        leftLabel = `${leftLabel} ${join2.type} JOIN ${rightLabel}`;
+      }
+    }
+    if (steps.length > 0) explainCrossJoinSteps.set(select, steps);
+    if (isConstantFalseWhere(select.where)) current = 0;
+    else if (select.where !== null) current = null;
+    if (normalizeGroupingSpec(select).type !== "NONE" || select.distinct || select.having !== null || isAggregateQueryBlock(select) || select.columns.some((column) => column.type === "WINDOW_COL")) return null;
+    if (current === null) return null;
+    current = Math.max(0, current - (select.offset ?? 0));
+    return select.limit === null ? current : Math.min(current, select.limit);
+  };
+  const analyzeQuery = (query) => {
+    if (query.type === "SELECT") {
+      analyze(query);
+      return;
+    }
+    analyzeQuery(query.left);
+    analyze(query.right);
+  };
+  for (const cte of stmt.ctes) {
+    if (cte.query.type === "GENERATE_SERIES") {
+      if (!cte.query.args.some((arg) => arg.type === "VARIABLE")) {
+        exactRows.set(cte.name, resolveGenerateSeries(cte.query).rowCount);
+      }
+    } else if (cte.query.type === "SELECT") {
+      const rows = analyze(cte.query);
+      if (rows !== null) exactRows.set(cte.name, rows);
+    } else if (cte.query.type === "UNION") {
+      analyzeQuery(cte.query);
+    }
+  }
+  analyzeQuery(stmt.query);
+}
 function buildWithPlan(stmt, capabilities, orderPlans, plainGroupByPlans, collector = { sources: [] }) {
+  populateWithCrossJoinExplain(stmt);
   const lines = [];
   for (const cte of stmt.ctes) {
     if (cte.query.type === "SELECT") {
@@ -25773,18 +26286,45 @@ function buildWithPlan(stmt, capabilities, orderPlans, plainGroupByPlans, collec
       ));
       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);
+      const seriesStatement = cte.query;
+      const binding = explainSeriesBindings.get(seriesStatement);
+      const unresolved = seriesStatement.args.some((arg) => arg.type === "VARIABLE");
+      if (unresolved) {
+        const argumentLabel = (index) => {
+          const arg = seriesStatement.args[index];
+          if (!arg) return index === 2 ? "runtime" : "deferred";
+          if (arg.type === "VARIABLE") return `@${arg.name} (runtime)`;
+          if (index < 2) return "literal";
+          return arg.type === "NUMBER" ? numberLiteralText(arg) : arg.value;
+        };
+        lines.push(
+          `[cte: ${cte.name}]`,
+          "  source:        GENERATE_SERIES",
+          `  column:        ${seriesStatement.columnAlias}`,
+          "  series type:   deferred (variable)",
+          `  start:         ${argumentLabel(0)}`,
+          `  stop:          ${argumentLabel(1)}`,
+          `  step:          ${argumentLabel(2)}`,
+          "  rows:          runtime",
+          `  row guard:     runtime / ${GENERATE_SERIES_MAX_ROWS}`,
+          "  records API:   none",
+          ""
+        );
+        continue;
+      }
+      const series = resolveGenerateSeries(seriesStatement);
+      const step = series.kind === "DATE" ? `${series.step} ${String(series.dateUnit ?? "DAY").toLowerCase()}${Math.abs(series.step) === 1 ? "" : "s"}` : 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}`,
+        `  column:        ${seriesStatement.columnAlias}`,
+        `  series type:   ${series.kind}${binding?.defaultBoundIndexes.size ? " (DECLARE default)" : ""}`,
+        `  start:         ${binding?.variableNames.has(0) ? `@${binding.variableNames.get(0)} (DECLARE default; value hidden)` : series.start}`,
+        `  stop:          ${binding?.variableNames.has(1) ? `@${binding.variableNames.get(1)} (DECLARE default; value hidden)` : series.stop}`,
         `  step:          ${step}`,
-        `  rows:          ${series.rowCount}`,
+        `  rows:          ${series.rowCount}${binding?.defaultBoundIndexes.size ? " (DECLARE default estimate)" : ""}`,
         `  row guard:     ${series.rowCount} / ${GENERATE_SERIES_MAX_ROWS}`,
+        ...binding?.defaultBoundIndexes.size ? ["  binding:       DECLARE defaults; runtime injection may change this plan"] : [],
         "  records API:   none",
         ""
       );
@@ -25825,7 +26365,9 @@ function collectFullScanReasons(stmt) {
   const r = [];
   if (stmt.from.subtableCode || stmt.joins.some((j) => j.table.subtableCode))
     r.push("\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB\u4EEE\u60F3\u30C6\u30FC\u30D6\u30EB");
-  if (stmt.joins.length > 0)
+  if (stmt.joins.some((join2) => join2.type === "CROSS"))
+    r.push("CROSS JOIN \u3042\u308A");
+  if (stmt.joins.some((join2) => join2.type !== "CROSS"))
     r.push("JOIN \u3042\u308A");
   const grouping = normalizeGroupingSpec(stmt);
   if (grouping.type === "PLAIN")
@@ -28906,14 +29448,42 @@ function createDryRunClient() {
 function hasStaticTypedPushdownCandidate(statement) {
   if (statement === null || typeof statement !== "object") return false;
   const node = statement;
-  if (node["type"] === "WITH") return hasStaticTypedPushdownCandidate(node["query"]);
+  if (node["type"] === "CREATE_TEMP_TABLE") {
+    return hasStaticTypedPushdownCandidate(node["query"]);
+  }
+  if (node["type"] === "WITH") {
+    const query = node["query"];
+    const containsCross = (value) => {
+      if (Array.isArray(value)) return value.some(containsCross);
+      if (value === null || typeof value !== "object") return false;
+      const item = value;
+      if (item["type"] === "SELECT") {
+        if (Array.isArray(item["joins"]) && item["joins"].some(
+          (join2) => typeof join2 === "object" && join2 !== null && join2["type"] === "CROSS"
+        )) return true;
+      }
+      return Object.values(item).some(containsCross);
+    };
+    const hasPhysicalCte = Array.isArray(node["ctes"]) && node["ctes"].some((cte) => {
+      if (typeof cte !== "object" || cte === null) return false;
+      const cteQuery = cte["query"];
+      if (typeof cteQuery !== "object" || cteQuery === null) return false;
+      const from = cteQuery["from"];
+      return cteQuery["type"] === "SELECT" && typeof from === "object" && from !== null && from["cteName"] === null;
+    });
+    return (containsCross(node["ctes"]) || containsCross(query)) && hasPhysicalCte || hasStaticTypedPushdownCandidate(query);
+  }
   if (node["type"] !== "SELECT") return false;
   const select = statement;
-  if (!select.where || !Array.isArray(select.joins) || select.joins.length === 0) return false;
+  if (!Array.isArray(select.joins) || select.joins.length === 0) return false;
   if (![select.from, ...select.joins.map((join2) => join2.table)].some((table) => table.cteName !== null)) return false;
+  if (select.joins.some((join2) => join2.type === "CROSS" && join2.table.cteName === null)) {
+    return true;
+  }
+  if (!select.where) return false;
   const where = select.where;
   return select.joins.some(
-    (join2) => join2.type === "INNER" && join2.table?.alias && join2.table?.cteName === null && !join2.table?.subtableCode && extractTypedPushdownCandidates(where, { tableAlias: join2.table.alias }) !== null
+    (join2) => (join2.type === "INNER" || join2.type === "CROSS") && join2.table?.alias && join2.table?.cteName === null && !join2.table?.subtableCode && extractTypedPushdownCandidates(where, { tableAlias: join2.table.alias }) !== null
   );
 }
 async function runDiagnosticRecordGet(params) {
@@ -29600,7 +30170,10 @@ async function run() {
         return false;
       });
       dryRunNeedsMetadata = statements.some(explainNeedsAppMetadata);
-      dryRunUsesStaticTypedPlan = statements.some(hasStaticTypedPushdownCandidate) && !statements.some(statementUsesRelativeDateResolution);
+      const staticEligible = statements.every(
+        (statement) => !explainNeedsAppMetadata(statement) || hasStaticTypedPushdownCandidate(statement)
+      );
+      dryRunUsesStaticTypedPlan = statements.some(hasStaticTypedPushdownCandidate) && staticEligible && !statements.some(statementUsesRelativeDateResolution);
       if (statements.length > 1) {
         batchAnalysis = analyzeBatch(statements);
         isBatchSql = true;
@@ -29987,7 +30560,7 @@ async function run() {
         Object.keys(args.importCsv).length > 0 || Object.keys(args.importJson).length > 0,
         dmlMaxRows,
         dmlMaxSubtableRows,
-        false
+        !dryRunUsesStaticTypedPlan
       );
       const out = [];
       const restoredStatements = sqlDiagnosticContext ? restoreSqlDiagnosticValue(plans.statements, sqlDiagnosticContext.appBindingByMappedApp) : plans.statements;