@rex0220/kintone-sql-tools 3.65.0 → 3.66.1

package/dist-cli/ksql.js

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/cli/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CLI_HELP_TEXT: () => CLI_HELP_TEXT,
   CLI_IMPORT_SOURCE_REQUIRED_MESSAGE: () => CLI_IMPORT_SOURCE_REQUIRED_MESSAGE,
   HELP_TEXT: () => HELP_TEXT,
   buildBatchDmlConfirmMessage: () => buildBatchDmlConfirmMessage,
@@ -1085,6 +1086,12 @@ var Parser = class {
     this.tempTableRefs = [];
     /** GROUP BY を読む前に作る B124 候補 leaf の診断位置。AST 公開型へ位置情報を足さない。 */
     this.aggregateGroupKeyTokens = /* @__PURE__ */ new WeakMap();
+    // ----------------------------------------------------------
+    // WITH 句（CTE）
+    // ----------------------------------------------------------
+    /** B53 parser-private state. Kept here so earlier diagnostic source locations remain stable. */
+    this.activeCteDefinition = null;
+    this.provisionalRecursiveCte = null;
     this.allowSelectArithVariable = false;
   }
   // ----------------------------------------------------------
@@ -1919,34 +1926,172 @@ var Parser = class {
       offset
     };
   }
-  // ----------------------------------------------------------
-  // WITH 句（CTE）
-  // ----------------------------------------------------------
   parseWith() {
     this.expect("WITH" /* WITH */);
+    const recursive = this.isSoftKeyword("RECURSIVE") && this.peekAt(1).kind !== "AS" /* AS */ && this.peekAt(1).kind !== "(" /* LPAREN */;
+    if (recursive) this.advance();
     const ctes = [];
-    do {
-      const name = this.parseIdentifier();
-      this.expect("AS" /* AS */);
-      this.expect("(" /* LPAREN */);
-      let query2;
-      const inner = this.peek().kind;
-      if (inner === "SHOW" /* SHOW */) {
-        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());
+    let recursiveCount = 0;
+    try {
+      do {
+        const name = this.parseIdentifier();
+        const columnAliases = this.parseOptionalCteColumnAliases();
+        this.expect("AS" /* AS */);
+        this.expect("(" /* LPAREN */);
+        this.activeCteDefinition = { name, recursiveWith: recursive, phase: "SEED" };
+        let query2;
+        let recursiveSpec;
+        const inner = this.peek().kind;
+        if (inner === "SHOW" /* SHOW */) {
+          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 if (recursive) {
+          const parsed = this.parseRecursiveCteCandidate(name);
+          query2 = parsed.query;
+          recursiveSpec = parsed.recursiveSpec;
+        } else {
+          query2 = this.tryParseUnionChain(this.parseSelect());
+        }
+        this.expect(")" /* RPAREN */);
+        const cycle = recursive && this.isSoftKeyword("CYCLE") ? this.parseRecursiveCycleClause() : null;
+        if (cycle && !recursiveSpec) {
+          throw new ParseError("CYCLE \u53E5\u306F\u81EA\u5DF1\u53C2\u7167\u3059\u308B\u518D\u5E30 CTE \u306B\u3060\u3051\u6307\u5B9A\u3067\u304D\u307E\u3059", this.prev());
+        }
+        if (recursiveSpec) {
+          recursiveSpec = { ...recursiveSpec, cycle };
+          this.validateRecursiveCte(name, columnAliases, recursiveSpec);
+          recursiveCount++;
+          if (recursiveCount > 1) {
+            throw new ParseError("WITH RECURSIVE \u3067\u5B9A\u7FA9\u3067\u304D\u308B\u518D\u5E30 CTE \u306F1\u500B\u307E\u3067\u3067\u3059", this.prev());
+          }
+        }
+        if (columnAliases && !recursiveSpec) {
+          throw new ParseError("CTE \u306E\u5217\u540D\u30EA\u30B9\u30C8\u306F WITH RECURSIVE \u306E\u518D\u5E30 CTE \u306B\u3060\u3051\u6307\u5B9A\u3067\u304D\u307E\u3059", this.prev());
+        }
+        const definition = { name, query: query2 };
+        if (columnAliases) definition.columnAliases = columnAliases;
+        if (recursiveSpec) definition.recursiveSpec = recursiveSpec;
+        ctes.push(definition);
+        this.activeCteDefinition = null;
+        this.provisionalRecursiveCte = null;
+        this.cteNames.add(name);
+      } while (this.consume("," /* COMMA */));
+      const query = this.tryParseUnionChain(this.parseSelect());
+      return recursive ? { type: "WITH", ctes, query, recursive: true } : { type: "WITH", ctes, query };
+    } finally {
+      this.activeCteDefinition = null;
+      this.provisionalRecursiveCte = null;
+      this.cteNames.clear();
+    }
+  }
+  parseOptionalCteColumnAliases() {
+    if (!this.consume("(" /* LPAREN */)) return void 0;
+    const aliases = [];
+    if (this.peek().kind === ")" /* RPAREN */) {
+      throw new ParseError("CTE \u306E\u5217\u540D\u30EA\u30B9\u30C8\u306B\u306F1\u500B\u4EE5\u4E0A\u306E\u5217\u540D\u304C\u5FC5\u8981\u3067\u3059", this.peek());
+    }
+    do
+      aliases.push(this.parseIdentifier());
+    while (this.consume("," /* COMMA */));
+    this.expect(")" /* RPAREN */);
+    if (new Set(aliases).size !== aliases.length) {
+      throw new ParseError("CTE \u306E\u5217\u540D\u30EA\u30B9\u30C8\u306B\u540C\u3058\u5217\u540D\u3092\u91CD\u8907\u3057\u3066\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093", this.prev());
+    }
+    return aliases;
+  }
+  parseRecursiveCteCandidate(name) {
+    const seed = this.parseSelect();
+    if (this.peek().kind !== "UNION" /* UNION */) return { query: seed };
+    this.advance();
+    const all = this.consume("ALL" /* ALL */);
+    this.activeCteDefinition = { name, recursiveWith: true, phase: "RECURSIVE_TERM" };
+    this.provisionalRecursiveCte = { name, references: 0 };
+    const recursiveTerm = this.parseSelect();
+    const references = this.provisionalRecursiveCte.references;
+    this.provisionalRecursiveCte = null;
+    let query = { type: "UNION", all, left: seed, right: recursiveTerm };
+    query = this.tryParseUnionChain(query);
+    this.activeCteDefinition = { name, recursiveWith: true, phase: "SEED" };
+    if (references === 0) return { query };
+    if (!all || query.type !== "UNION" || query.left !== seed || query.right !== recursiveTerm) {
+      throw new ParseError("\u518D\u5E30 CTE \u306F seed SELECT UNION ALL recursive SELECT \u306E2\u5206\u5C90\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044", this.prev());
+    }
+    if (references !== 1) {
+      throw new ParseError("\u518D\u5E30\u9805\u304B\u3089\u306E\u81EA\u5DF1\u53C2\u7167\u306F\u3061\u3087\u3046\u30691\u56DE\u306B\u3057\u3066\u304F\u3060\u3055\u3044", this.prev());
+    }
+    return {
+      query,
+      recursiveSpec: { seed, recursiveTerm, unionAll: true, cycle: null }
+    };
+  }
+  parseRecursiveCycleClause() {
+    this.advance();
+    const column = this.parseIdentifier();
+    this.expect("SET" /* SET */, "CYCLE \u306E\u5217\u540D\u306E\u5F8C\u306B\u306F SET \u304C\u5FC5\u8981\u3067\u3059");
+    const markColumn = this.parseIdentifier();
+    if (!this.isSoftKeyword("TO")) throw new ParseError("CYCLE \u306E mark \u5217\u306E\u5F8C\u306B\u306F TO \u304C\u5FC5\u8981\u3067\u3059", this.peek());
+    this.advance();
+    const mark = this.expect("STRING" /* STRING */, "CYCLE TO \u306B\u306F\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u304C\u5FC5\u8981\u3067\u3059");
+    if (!this.isSoftKeyword("DEFAULT")) throw new ParseError("CYCLE TO \u306E\u5024\u306E\u5F8C\u306B\u306F DEFAULT \u304C\u5FC5\u8981\u3067\u3059", this.peek());
+    this.advance();
+    const normal = this.expect("STRING" /* STRING */, "CYCLE DEFAULT \u306B\u306F\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u304C\u5FC5\u8981\u3067\u3059");
+    if (mark.value === normal.value) {
+      throw new ParseError("CYCLE \u306E TO \u3068 DEFAULT \u306B\u306F\u7570\u306A\u308B\u6587\u5B57\u5217\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044", normal);
+    }
+    return { column, markColumn, markValue: mark.value, defaultValue: normal.value, exposePath: false };
+  }
+  validateRecursiveCte(name, columnAliases, spec) {
+    const token = this.prev();
+    const seed = spec.seed;
+    const term = spec.recursiveTerm;
+    const { groupBy } = term;
+    if (seed.columns.length !== term.columns.length) {
+      throw new ParseError("\u518D\u5E30 CTE \u306E seed \u3068\u518D\u5E30\u9805\u306E\u5217\u6570\u3092\u4E00\u81F4\u3055\u305B\u3066\u304F\u3060\u3055\u3044", token);
+    }
+    if (columnAliases && columnAliases.length !== seed.columns.length) {
+      throw new ParseError("CTE \u306E\u5217\u540D\u30EA\u30B9\u30C8\u3068 SELECT \u306E\u5217\u6570\u3092\u4E00\u81F4\u3055\u305B\u3066\u304F\u3060\u3055\u3044", token);
+    }
+    if (seed.columns.some((column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD") || term.columns.some((column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD")) {
+      throw new ParseError("\u518D\u5E30 CTE \u306E seed \u3068\u518D\u5E30\u9805\u3067\u306F\u5217\u3092\u660E\u793A\u7684\u306B\u5C04\u5F71\u3057\u3066\u304F\u3060\u3055\u3044", token);
+    }
+    if (term.distinct || groupBy.length > 0 || term.grouping !== void 0 || term.having !== null || term.orderBy.length > 0 || term.orderMode !== "CANONICAL" || term.limit !== null || term.offset !== null) {
+      throw new ParseError("\u518D\u5E30\u9805\u3067\u306F DISTINCT\u3001\u96C6\u8A08\u3001window\u3001GROUP BY\u3001HAVING\u3001ORDER BY\u3001LIMIT\u3001OFFSET \u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", token);
+    }
+    if (term.joins.length !== 1 || term.joins[0].type !== "INNER") {
+      throw new ParseError("\u518D\u5E30\u9805\u306F\u81EA\u5DF1\u53C2\u7167\u3068\u7269\u7406 source \u307E\u305F\u306F\u5148\u884C CTE \u306E INNER JOIN 1\u500B\u3067\u69CB\u6210\u3057\u3066\u304F\u3060\u3055\u3044", token);
+    }
+    const relationNames = [term.from.cteName, term.joins[0].table.cteName];
+    if (relationNames.filter((value) => value === name).length !== 1) {
+      throw new ParseError("\u518D\u5E30\u9805\u306E INNER JOIN \u306B\u306F\u81EA\u5DF1\u53C2\u7167\u3092\u3061\u3087\u3046\u30691\u56DE\u542B\u3081\u3066\u304F\u3060\u3055\u3044", token);
+    }
+    if (this.containsRecursiveForbiddenNode(term.columns) || this.containsRecursiveForbiddenNode(term.where)) {
+      throw new ParseError("\u518D\u5E30\u9805\u3067\u306F\u96C6\u8A08\u3001window\u3001DISTINCT\u3001subquery \u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", token);
+    }
+    const outputNames = columnAliases ?? seed.columns.map((column) => this.selectColumnOutputName(column));
+    if (spec.cycle) {
+      const cycleMatches = outputNames.filter((value) => value === spec.cycle.column).length;
+      if (cycleMatches !== 1) {
+        throw new ParseError("CYCLE \u5217\u306F\u518D\u5E30 CTE \u306E\u51FA\u529B\u52171\u500B\u3078\u4E00\u610F\u306B\u89E3\u6C7A\u3067\u304D\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059", token);
       }
-      this.expect(")" /* RPAREN */);
-      ctes.push({ name, query: query2 });
-      this.cteNames.add(name);
-    } while (this.consume("," /* COMMA */));
-    const query = this.tryParseUnionChain(this.parseSelect());
-    this.cteNames.clear();
-    return { type: "WITH", ctes, query };
+      if (outputNames.includes(spec.cycle.markColumn)) {
+        throw new ParseError("CYCLE \u306E mark \u5217\u306F\u518D\u5E30 CTE \u306E\u65E2\u5B58\u51FA\u529B\u5217\u3068\u540C\u540D\u306B\u3067\u304D\u307E\u305B\u3093", token);
+      }
+    }
+  }
+  containsRecursiveForbiddenNode(value) {
+    if (Array.isArray(value)) return value.some((item) => this.containsRecursiveForbiddenNode(item));
+    if (value === null || typeof value !== "object") return false;
+    const node = value;
+    if (node.type === "AGGREGATE" || node.type === "AGG_REF" || node.type === "ARITH_AGG_COL" || node.type === "WINDOW_COL" || node.type === "SCALAR_SUBQUERY" || node.type === "SCALAR_SUBQUERY_COL" || node.type === "SUBQUERY_IN_LIST" || node.type === "EXISTS") return true;
+    return Object.values(node).some((item) => this.containsRecursiveForbiddenNode(item));
+  }
+  selectColumnOutputName(column) {
+    if ("alias" in column && typeof column.alias === "string") return column.alias;
+    if (column.type === "FIELD") return column.field;
+    return null;
   }
   parseGenerateSeries() {
     const name = this.advance();
@@ -2985,6 +3130,15 @@ var Parser = class {
       const alias2 = this.consume("AS" /* AS */) ? this.parseTableAliasName() : this.tryParseImplicitAlias();
       return { appId: 0, alias: alias2, cteName: name };
     }
+    if (this.activeCteDefinition?.name === name) {
+      if (this.activeCteDefinition.recursiveWith && this.activeCteDefinition.phase === "RECURSIVE_TERM" && this.provisionalRecursiveCte?.name === name) {
+        this.provisionalRecursiveCte.references++;
+        const alias2 = this.consume("AS" /* AS */) ? this.parseTableAliasName() : this.tryParseImplicitAlias();
+        return { appId: 0, alias: alias2, cteName: name };
+      }
+      const message = this.activeCteDefinition.recursiveWith ? this.activeCteDefinition.phase === "RECURSIVE_TERM" ? "\u518D\u5E30 CTE \u306F seed SELECT UNION ALL recursive SELECT \u306E2\u5206\u5C90\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044" : "\u518D\u5E30 CTE \u306E seed \u304B\u3089\u81EA\u5206\u81EA\u8EAB\u3092\u53C2\u7167\u3067\u304D\u307E\u305B\u3093" : "CTE \u306E\u5B9A\u7FA9\u5185\u304B\u3089\u81EA\u5206\u81EA\u8EAB\u3092\u53C2\u7167\u3057\u3066\u3044\u307E\u3059\u3002\u81EA\u5DF1\u53C2\u7167\u306B\u306F `WITH RECURSIVE` \u304C\u5FC5\u8981\u3067\u3059";
+      throw new ParseError(message, nameTok);
+    }
     const { appId, subtableCode } = extractTableRef(name, this.prev());
     if (subtableCode) {
       const alias2 = this.consume("AS" /* AS */) ? this.parseTableAliasName() : this.tryParseImplicitAlias();
@@ -12804,6 +12958,71 @@ function isOuterJoinNonPreservedTable(statement, table, isMainTable) {
   return false;
 }
 
+// src/core/recursiveCte.ts
+var RECURSIVE_CTE_MAX_DEPTH = 100;
+var RECURSIVE_CTE_MAX_ROWS = 1e4;
+var RECURSIVE_CTE_MAX_EXPANSIONS = 1e5;
+function resolveRecursiveCteLimits(options) {
+  const entries = [
+    ["recursiveCteMaxDepth", options.recursiveCteMaxDepth, RECURSIVE_CTE_MAX_DEPTH],
+    ["recursiveCteMaxRows", options.recursiveCteMaxRows, RECURSIVE_CTE_MAX_ROWS],
+    ["recursiveCteMaxExpansions", options.recursiveCteMaxExpansions, RECURSIVE_CTE_MAX_EXPANSIONS]
+  ];
+  for (const [name, value] of entries) {
+    if (value !== void 0 && (!Number.isSafeInteger(value) || value <= 0)) {
+      throw new RangeError(`${name} must be a positive safe integer`);
+    }
+  }
+  return {
+    depth: options.recursiveCteMaxDepth ?? RECURSIVE_CTE_MAX_DEPTH,
+    rows: options.recursiveCteMaxRows ?? RECURSIVE_CTE_MAX_ROWS,
+    expansions: options.recursiveCteMaxExpansions ?? RECURSIVE_CTE_MAX_EXPANSIONS
+  };
+}
+var RecursiveCteLimitError = class extends Error {
+  constructor(kind, limit, detected, cteName) {
+    const label = kind === "DEPTH" ? "\u6DF1\u3055" : kind === "ROWS" ? "\u7D50\u679C\u884C\u6570" : "\u4E2D\u9593\u5C55\u958B\u6570";
+    const unit = kind === "DEPTH" ? "" : " \u4EF6";
+    super(`\u518D\u5E30 CTE\u300C${cteName}\u300D\u306E${label}\u304C\u4E0A\u9650 ${limit}${unit}\u3092\u8D85\u3048\u307E\u3057\u305F\uFF08\u691C\u51FA\u5024: ${detected}${unit}\uFF09\u3002`);
+    this.name = "RecursiveCteLimitError";
+    this.kind = kind;
+    this.limit = limit;
+    this.detected = detected;
+    this.cteName = cteName;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var RecursiveCteLimitCounter = class {
+  constructor(cteName, limits = resolveRecursiveCteLimits({})) {
+    this.cteName = cteName;
+    this.limits = limits;
+    this.rows = 0;
+    this.expansions = 0;
+  }
+  observeDepth(detected) {
+    if (detected > this.limits.depth) {
+      throw new RecursiveCteLimitError("DEPTH", this.limits.depth, detected, this.cteName);
+    }
+  }
+  addRow() {
+    this.rows++;
+    if (this.rows > this.limits.rows) {
+      throw new RecursiveCteLimitError("ROWS", this.limits.rows, this.rows, this.cteName);
+    }
+  }
+  addExpansion() {
+    this.expansions++;
+    if (this.expansions > this.limits.expansions) {
+      throw new RecursiveCteLimitError(
+        "EXPANSIONS",
+        this.limits.expansions,
+        this.expansions,
+        this.cteName
+      );
+    }
+  }
+};
+
 // src/core/optimization/joinKeyPrefilter.ts
 var JOIN_KEY_IN_CHUNK_SIZE = 50;
 function buildJoinKeyPrefilterQueries(plan, field, quoteValue) {
@@ -14245,8 +14464,15 @@ function applyJoin(leftRows, rightRows, join2, columns = {}) {
     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;
+  const normalizedOn = normalizeJoinConditionSides(
+    on,
+    leftRows,
+    rightRows,
+    columns.leftColumns,
+    columns.rightColumns
+  );
+  const leftKey = joinFieldKey(normalizedOn.left);
+  const rightKey = joinFieldKey(normalizedOn.right);
   assertJoinKeyAvailable(leftRows, leftKey, columns.leftColumns);
   assertJoinKeyAvailable(rightRows, rightKey, columns.rightColumns);
   if (joinType === "RIGHT") {
@@ -14294,6 +14520,37 @@ function applyJoin(leftRows, rightRows, join2, columns = {}) {
   }
   return result;
 }
+function joinFieldKey(ref) {
+  return ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
+}
+function normalizeJoinConditionSides(on, leftRows, rightRows, leftColumns, rightColumns) {
+  const leftSchema = leftColumns ?? Object.keys(leftRows[0] ?? {});
+  const rightSchema = rightColumns ?? Object.keys(rightRows[0] ?? {});
+  const leftAliases = qualifiedAliases(leftSchema);
+  const rightAliases = qualifiedAliases(rightSchema);
+  const sideFor = (ref) => {
+    if (ref.tableAlias) {
+      const inLeft2 = leftAliases.has(ref.tableAlias);
+      const inRight2 = rightAliases.has(ref.tableAlias);
+      if (inLeft2 !== inRight2) return inLeft2 ? "LEFT" : "RIGHT";
+    }
+    const key = joinFieldKey(ref);
+    const inLeft = leftSchema.includes(key);
+    const inRight = rightSchema.includes(key);
+    return inLeft !== inRight ? inLeft ? "LEFT" : "RIGHT" : "UNKNOWN";
+  };
+  const leftSide = sideFor(on.left);
+  const rightSide = sideFor(on.right);
+  return leftSide === "RIGHT" && rightSide === "LEFT" ? { left: on.right, right: on.left } : on;
+}
+function qualifiedAliases(columns) {
+  const aliases = /* @__PURE__ */ new Set();
+  for (const column of columns) {
+    const separator = column.indexOf(".");
+    if (separator > 0) aliases.add(column.slice(0, separator));
+  }
+  return aliases;
+}
 function assertJoinKeyAvailable(rows, key, savedColumns) {
   const missing = rows.length > 0 ? rows.some((row) => !Object.prototype.hasOwnProperty.call(row, key)) : savedColumns !== void 0 && !savedColumns.includes(key);
   if (missing) {
@@ -17331,6 +17588,7 @@ function createInvocationCacheContext(cacheContext) {
   return `${cacheContext}\0inv:${nextCacheInvocationId++}`;
 }
 async function execute(sql, client, options = {}) {
+  resolveRecursiveCteLimits(options);
   const startedAt = Date.now();
   const cacheContext = createInvocationCacheContext(
     resolveCacheContext(client, options.cacheContext)
@@ -17642,7 +17900,10 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
         options.cursorMaxActive ?? 2,
         stmt.query.type === "UPDATE" && stmt.query.applyBlocks?.length ? resolveApplyGuardLimit(options.dmlMaxRows, "dmlMaxRows", DEFAULT_APPLY_MAX_ROWS) : DEFAULT_APPLY_MAX_ROWS,
         stmt.query.type === "UPDATE" && stmt.query.applyBlocks?.length ? resolveApplyGuardLimit(options.dmlMaxSubtableRows, "dmlMaxSubtableRows", DEFAULT_APPLY_MAX_SUBTABLE_ROWS) : DEFAULT_APPLY_MAX_SUBTABLE_ROWS,
-        relativeDatePlan
+        relativeDatePlan,
+        options.recursiveCteMaxDepth,
+        options.recursiveCteMaxRows,
+        options.recursiveCteMaxExpansions
       );
     // 一時テーブルはバッチスコープのため単文実行では拒否する（executeBatch を使う）
     case "CREATE_TEMP_TABLE":
@@ -17914,6 +18175,7 @@ var BatchTimeoutError = class extends Error {
   }
 };
 async function executeBatch(sql, client, options = {}) {
+  resolveRecursiveCteLimits(options);
   const statements = parseSqlBatch(sql, options.enableImport === true);
   const analysis = analyzeBatch(statements);
   statements.forEach((statement) => assertApplyExecutionScope("phase15b", statement));
@@ -18740,7 +19002,7 @@ function canProveTotalWindowOrder(stmt, orderBy, resolveField2, context, generat
 }
 function tieBreakAdvice(context, kind) {
   if (context !== "DIRECT") {
-    return "\u305D\u306E\u8868\u306E\u4E2D\u3067\u4E00\u610F\u306B\u306A\u308B\u5217\uFF08\u5143\u306E\u96C6\u7D04\u306E\u30AD\u30FC\u306A\u3069\uFF09\u3092 ORDER BY \u306B\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002\u96C6\u7D04\u7D50\u679C\u306E\u5217\u306F\u4E00\u610F\u3067\u3082\u8A3C\u660E\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u3059\u3067\u306B\u4E00\u610F\u306A\u5834\u5408\u3082\u3053\u306E\u8B66\u544A\u304C\u51FA\u307E\u3059\u3002\u5143\u306E\u96C6\u7D04\u306E\u30AD\u30FC\u3092\u3059\u3079\u3066 ORDER BY \u306B\u542B\u3081\u3066\u3044\u308B\u306A\u3089\u3001\u3053\u306E\u8B66\u544A\u306F\u7121\u8996\u3057\u3066\u69CB\u3044\u307E\u305B\u3093\u3002";
+    return "\u30A6\u30A3\u30F3\u30C9\u30A6\u306E\u5404\u30D1\u30FC\u30C6\u30A3\u30B7\u30E7\u30F3\u5185\u3067\u3001ORDER BY \u306E\u5024\u306E\u7D44\u304C\u5165\u529B\u884C\u3092\u4E00\u610F\u306B\u8B58\u5225\u3059\u308B\u3068\u30AF\u30A8\u30EA\u69CB\u9020\u307E\u305F\u306F\u4FDD\u8A3C\u6E08\u307F\u306E\u30C7\u30FC\u30BF\u5236\u7D04\u304B\u3089\u78BA\u8A8D\u3067\u304D\u308B\u5834\u5408\u306B\u9650\u308A\u3001\u3053\u306E\u8B66\u544A\u306F\u7121\u8996\u3067\u304D\u307E\u3059\u3002\u5143\u306E\u96C6\u7D04\u30AD\u30FC\u3092\u3059\u3079\u3066 ORDER BY \u306B\u542B\u3080\u5F62\u3084\u3001JOIN \u5F8C\u3082\u540C\u3058\u7CFB\u5217\u5024\u304C\u5404\u30D1\u30FC\u30C6\u30A3\u30B7\u30E7\u30F3\u5185\u3067\u9AD8\u30051\u884C\u3068\u4FDD\u8A3C\u3067\u304D\u308B\u5F62\u304C\u8A72\u5F53\u3057\u307E\u3059\u3002\u751F\u6210\u5217\u3001\u518D\u5E30\u306E\u6DF1\u3055\u5217\u3001\u307E\u305F\u306F $id \u306B\u7531\u6765\u3059\u308B\u5217\u3067\u3042\u308B\u3068\u3044\u3046\u7406\u7531\u3060\u3051\u3067\u306F\u7121\u8996\u3067\u304D\u307E\u305B\u3093\u3002";
   }
   return kind === "RANGE" ? "ORDER BY \u306B\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u306A\u3069\u306E\u30BF\u30A4\u30D6\u30EC\u30FC\u30AF\u30AD\u30FC\u3092\u8DB3\u3057\u3066\u304F\u3060\u3055\u3044\u3002" : "\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u7B49\u3092 ORDER BY \u306B\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
 }
@@ -20629,6 +20891,53 @@ function assertUnionColumnCount(leftColumns, rightColumns) {
 UNION \u306F\u5217\u3092\u4F4D\u7F6E\u3067\u5BFE\u5FDC\u3055\u305B\u308B\u305F\u3081\u3001\u4E21\u8FBA\u306E\u5217\u6570\u3092\u63C3\u3048\u3066\u304F\u3060\u3055\u3044`
   );
 }
+function alignSelectResultByPosition(result, targetColumns, targetMeta) {
+  assertUnionColumnCount(targetColumns, result.columns);
+  const rows = result.rows.map((row) => {
+    const mapped = {};
+    targetColumns.forEach((column, index) => {
+      mapped[column] = row[result.columns[index] ?? column] ?? "";
+    });
+    return mapped;
+  });
+  const aligned = {
+    ...result,
+    rows,
+    columns: [...targetColumns],
+    rowCount: rows.length
+  };
+  const sourceMeta = materializedMetaBySelectResult.get(result);
+  if (targetMeta || sourceMeta) {
+    const meta = /* @__PURE__ */ new Map();
+    targetColumns.forEach((column, index) => {
+      const sourceColumn = result.columns[index];
+      const inferred = targetMeta?.get(column) ?? (sourceColumn === void 0 ? void 0 : sourceMeta?.get(sourceColumn));
+      if (inferred) meta.set(column, { ...inferred, displayName: column });
+    });
+    materializedMetaBySelectResult.set(aligned, meta);
+  }
+  return aligned;
+}
+function combineUnionResults(leftResult, rightResult, all, captureColumnMeta) {
+  const alignedRight = alignSelectResultByPosition(rightResult, leftResult.columns);
+  const combined = [...leftResult.rows, ...alignedRight.rows];
+  const rows = all ? combined : deduplicateRows(combined, leftResult.columns);
+  const warnings = [.../* @__PURE__ */ new Set([
+    ...leftResult.warnings ?? [],
+    ...rightResult.warnings ?? []
+  ])];
+  const result = {
+    type: "SELECT",
+    rows,
+    columns: [...leftResult.columns],
+    rowCount: rows.length,
+    warnings
+  };
+  if (captureColumnMeta) {
+    materializedMetaBySelectResult.set(result, mergeUnionColumnMeta(leftResult, rightResult));
+  }
+  return result;
+}
 async function executeUnion(stmt, client, options, cacheContext, captureColumnMeta = false, forLibraryCapture = false) {
   const completePolicy = buildCompleteInputPolicy(stmt, options, null);
   return withCompleteInputPolicy(completePolicy, async () => {
@@ -20662,33 +20971,7 @@ async function executeUnion(stmt, client, options, cacheContext, captureColumnMe
         "DERIVED"
       )
     ]);
-    const leftCols = leftResult.columns;
-    const rightCols = rightResult.columns;
-    assertUnionColumnCount(leftCols, rightCols);
-    const remappedRight = rightResult.rows.map((row) => {
-      const mapped = {};
-      leftCols.forEach((col, i) => {
-        mapped[col] = row[rightCols[i] ?? col] ?? "";
-      });
-      return mapped;
-    });
-    const combined = [...leftResult.rows, ...remappedRight];
-    const rows = stmt.all ? combined : deduplicateRows(combined, leftCols);
-    const warnings = [.../* @__PURE__ */ new Set([
-      ...leftResult.warnings ?? [],
-      ...rightResult.warnings ?? []
-    ])];
-    const result = {
-      type: "SELECT",
-      rows,
-      columns: leftCols,
-      rowCount: rows.length,
-      warnings
-    };
-    if (captureColumnMeta) {
-      materializedMetaBySelectResult.set(result, mergeUnionColumnMeta(leftResult, rightResult));
-    }
-    return result;
+    return combineUnionResults(leftResult, rightResult, stmt.all, captureColumnMeta);
   });
 }
 function deduplicateRows(rows, columns) {
@@ -20700,6 +20983,442 @@ function deduplicateRows(rows, columns) {
     return true;
   });
 }
+function recursiveSelectOutputName(column) {
+  if ("alias" in column && typeof column.alias === "string") return column.alias;
+  if (column.type === "FIELD") return column.field;
+  return null;
+}
+function recursiveOutputColumns(cte) {
+  const spec = cte.recursiveSpec;
+  if (cte.columnAliases) return [...cte.columnAliases];
+  const names = spec.seed.columns.map(recursiveSelectOutputName);
+  if (names.some((name) => name === null)) {
+    throw new Error(
+      `PlanningError: \u518D\u5E30 CTE\u300C${cte.name}\u300D\u3067\u5217\u540D\u30EA\u30B9\u30C8\u3092\u7701\u7565\u3059\u308B\u5834\u5408\u3001seed \u306E\u5F0F\u306B\u306F AS \u5225\u540D\u304C\u5FC5\u8981\u3067\u3059`
+    );
+  }
+  const columns = names;
+  if (new Set(columns).size !== columns.length) {
+    throw new Error(
+      `PlanningError: \u518D\u5E30 CTE\u300C${cte.name}\u300D\u3067\u5217\u540D\u30EA\u30B9\u30C8\u3092\u7701\u7565\u3059\u308B\u5834\u5408\u3001seed \u306E\u51FA\u529B\u5217\u540D\u3092\u91CD\u8907\u3055\u305B\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093`
+    );
+  }
+  return columns;
+}
+function recursivePlanningColumnNames(stmt) {
+  return stmt.columns.map((column, index) => recursiveSelectOutputName(column) ?? `__b53_column_${index}`);
+}
+function recursiveMetaCompatible(left, right) {
+  const a = left.semantics;
+  const b = right.semantics;
+  if (!a || !b || a.compareMode === "unsupported" || b.compareMode === "unsupported") return false;
+  if (a.compareMode !== b.compareMode) return false;
+  if (left.sortKind && right.sortKind && left.sortKind !== right.sortKind) return false;
+  if (a.inSubtable !== b.inSubtable || a.requiresCollectionOperators !== b.requiresCollectionOperators) return false;
+  const synthetic = (fieldType) => fieldType === void 0 || fieldType.startsWith("KSQL_");
+  if (!synthetic(left.fieldType) && !synthetic(right.fieldType) && left.fieldType !== right.fieldType) return false;
+  return true;
+}
+async function buildRecursiveFieldResolver(stmt, client, cacheContext, materializedTables) {
+  const tables = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  const physical = /* @__PURE__ */ new Map();
+  await Promise.all(tables.filter((table) => table.cteName === null).map(async (table) => {
+    if (physical.has(table.appId)) return;
+    const infos = await getFieldsCached(table.appId, client, cacheContext);
+    physical.set(table.appId, new Map(infos.map((info) => [info.code, info])));
+  }));
+  const resolveInTable = (table, field) => {
+    if (table.cteName !== null) return materializedTables.get(table.cteName)?.columnMeta?.get(field);
+    const info = physical.get(table.appId)?.get(fieldCodeForTypeLookup(table, field));
+    return info ? materializedMetaFromFieldInfo(info, table.appId) : systemColumnMeta(field);
+  };
+  return (ref) => {
+    if (ref.tableAlias !== null) {
+      const table = tables.find((candidate) => effectiveTableAlias(candidate) === ref.tableAlias);
+      return table ? resolveInTable(table, ref.field) : void 0;
+    }
+    if (tables.length === 1) return resolveInTable(tables[0], ref.field);
+    const matches = tables.map((table) => resolveInTable(table, ref.field)).filter(
+      (meta) => meta !== void 0
+    );
+    return matches.length === 1 ? matches[0] : void 0;
+  };
+}
+function validateRecursiveProjectionNode(value, resolveField2, numeric = false) {
+  if (value === null || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    value.forEach((item) => validateRecursiveProjectionNode(item, resolveField2, numeric));
+    return;
+  }
+  const node = value;
+  if (node.type === "FIELD") {
+    const ref = typeof node.tableAlias === "string" || node.tableAlias === null ? node : aggregateFieldRef(String(node.field ?? ""));
+    const meta = resolveField2(ref);
+    if (!meta?.semantics || meta.semantics.compareMode === "unsupported") {
+      throw new Error(`PlanningError: \u518D\u5E30 CTE \u306E\u5C04\u5F71\u5217 ${ref.tableAlias ? `${ref.tableAlias}.` : ""}${ref.field} \u306E\u578B\u3092\u8A3C\u660E\u3067\u304D\u307E\u305B\u3093`);
+    }
+    if (numeric && meta.semantics.compareMode !== "number" && meta.semantics.compareMode !== "recordNumber") {
+      throw new Error(`PlanningError: \u518D\u5E30 CTE \u306E\u6570\u5024\u6F14\u7B97\u306B\u6570\u5024\u3067\u306A\u3044\u5217 ${ref.field} \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093`);
+    }
+    return;
+  }
+  if (node.type === "FIELD_REF" && typeof node.field === "string") {
+    const ref = aggregateFieldRef(node.field);
+    const meta = resolveField2(ref);
+    if (!meta?.semantics || meta.semantics.compareMode === "unsupported") {
+      throw new Error(`PlanningError: \u518D\u5E30 CTE \u306E\u5C04\u5F71\u5217 ${node.field} \u306E\u578B\u3092\u8A3C\u660E\u3067\u304D\u307E\u305B\u3093`);
+    }
+    if (numeric && meta.semantics.compareMode !== "number" && meta.semantics.compareMode !== "recordNumber") {
+      throw new Error(`PlanningError: \u518D\u5E30 CTE \u306E\u6570\u5024\u6F14\u7B97\u306B\u6570\u5024\u3067\u306A\u3044\u5217 ${node.field} \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093`);
+    }
+    return;
+  }
+  if (node.type === "ARITH" || node.type === "SCALAR_ARITH") {
+    validateRecursiveProjectionNode(node.left, resolveField2, true);
+    validateRecursiveProjectionNode(node.right, resolveField2, true);
+    return;
+  }
+  for (const child of Object.values(node)) validateRecursiveProjectionNode(child, resolveField2, numeric);
+}
+async function inferRecursiveProjectionMeta(stmt, outputColumns, client, cacheContext, materializedTables) {
+  const resolveField2 = await buildRecursiveFieldResolver(stmt, client, cacheContext, materializedTables);
+  stmt.columns.forEach((column) => validateRecursiveProjectionNode(column, resolveField2));
+  const inferred = await inferSelectColumnMeta(
+    stmt,
+    recursivePlanningColumnNames(stmt),
+    client,
+    cacheContext,
+    materializedTables
+  );
+  const sourceNames = recursivePlanningColumnNames(stmt);
+  const aligned = /* @__PURE__ */ new Map();
+  outputColumns.forEach((column, index) => {
+    const meta = inferred.get(sourceNames[index]);
+    if (!meta?.semantics || meta.semantics.fieldType === "KSQL_UNKNOWN" || meta.semantics.compareMode === "unsupported") {
+      throw new Error(`PlanningError: \u518D\u5E30 CTE \u306E\u7B2C ${index + 1} \u5217\u306E\u578B\u3092\u9759\u7684\u306B\u8A3C\u660E\u3067\u304D\u307E\u305B\u3093`);
+    }
+    aligned.set(column, { ...meta, displayName: column });
+  });
+  return aligned;
+}
+function recursivePhysicalSourceKey(table) {
+  return `${table.appId}:${table.subtableCode ?? ""}`;
+}
+function recursivePhysicalTables(...queries) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const query of queries) {
+    for (const table of [query.from, ...query.joins.map((join2) => join2.table)]) {
+      if (table.cteName === null && !byKey.has(recursivePhysicalSourceKey(table))) {
+        byKey.set(recursivePhysicalSourceKey(table), table);
+      }
+    }
+  }
+  return [...byKey.values()];
+}
+function splitRecursiveFieldRef(field) {
+  const dot = field.indexOf(".");
+  return dot < 0 ? { alias: null, field } : { alias: field.slice(0, dot), field: field.slice(dot + 1) };
+}
+function collectRecursivePhysicalSourceFields(queries) {
+  const result = /* @__PURE__ */ new Map();
+  const markAll = (tables) => {
+    for (const table of tables) result.set(recursivePhysicalSourceKey(table), null);
+  };
+  for (const query of queries) {
+    const physical = physicalSelectTables(query);
+    for (const table of physical) {
+      const key = recursivePhysicalSourceKey(table);
+      if (!result.has(key)) result.set(key, /* @__PURE__ */ new Set());
+    }
+    const addRef = (rawAlias, field) => {
+      const table = rawAlias === null ? physical.length === 1 ? physical[0] : void 0 : [query.from, ...query.joins.map((join2) => join2.table)].find((candidate) => effectiveTableAlias(candidate)?.toLowerCase() === rawAlias.toLowerCase());
+      if (!table) {
+        markAll(physical);
+        return;
+      }
+      if (table.cteName !== null) return;
+      const current = result.get(recursivePhysicalSourceKey(table));
+      if (current !== null) current?.add(field);
+    };
+    const visit = (node) => {
+      if (node === null || node === void 0 || typeof node !== "object") return;
+      if (Array.isArray(node)) {
+        node.forEach(visit);
+        return;
+      }
+      const value = node;
+      if (value.type === "WILDCARD" || value.type === "PARENT_WILDCARD") {
+        markAll(physical);
+        return;
+      }
+      if ((value.type === "FIELD" || value.type === "FIELD_REF") && typeof value.field === "string") {
+        const encoded = splitRecursiveFieldRef(value.field);
+        const alias = typeof value.tableAlias === "string" ? value.tableAlias : value.tableAlias === null ? null : encoded.alias;
+        addRef(alias, encoded.field);
+        return;
+      }
+      if ((value.type === "FIELD_NAME" || value.type === "GROUPING_REF") && typeof value.name === "string") {
+        markAll(physical);
+        return;
+      }
+      Object.values(value).forEach(visit);
+    };
+    visit(query.columns);
+    visit(query.where);
+    visit(normalizeGroupingSpec(query));
+    visit(query.having);
+    visit(query.orderBy);
+    for (const join2 of query.joins) {
+      if (join2.on === null) {
+        markAll(physical);
+        continue;
+      }
+      addRef(join2.on.left.tableAlias, join2.on.left.field);
+      addRef(join2.on.right.tableAlias, join2.on.right.field);
+    }
+  }
+  return result;
+}
+function recursiveSourceSelect(table, fields) {
+  const columns = fields !== null && fields.size > 0 ? [...fields].map((field) => ({ type: "FIELD", field, alias: null })) : [{ type: "WILDCARD" }];
+  return {
+    type: "SELECT",
+    distinct: false,
+    columns,
+    from: { ...table, alias: null },
+    joins: [],
+    where: null,
+    groupBy: [],
+    having: null,
+    orderMode: "CANONICAL",
+    orderBy: [],
+    limit: null,
+    offset: null
+  };
+}
+async function materializeRecursivePhysicalSources(queries, client, options, cacheContext) {
+  const fieldsBySource = collectRecursivePhysicalSourceFields(queries);
+  const entries = await Promise.all(recursivePhysicalTables(...queries).map(async (table, index) => {
+    const result = await executeSelect(
+      recursiveSourceSelect(table, fieldsBySource.get(recursivePhysicalSourceKey(table)) ?? null),
+      client,
+      { ...options, onLimitReached: "error" },
+      cacheContext,
+      void 0,
+      true,
+      false,
+      "DERIVED"
+    );
+    const name = `__b53_source_${index}`;
+    return [recursivePhysicalSourceKey(table), {
+      name,
+      warnings: result.warnings ?? [],
+      table: {
+        rows: result.rows,
+        columns: result.columns,
+        columnMeta: materializedMetaBySelectResult.get(result)
+      }
+    }];
+  }));
+  return new Map(entries);
+}
+function rewriteRecursivePhysicalSources(stmt, sources) {
+  const rewrite = (table) => {
+    if (table.cteName !== null) return table;
+    const source = sources.get(recursivePhysicalSourceKey(table));
+    if (!source) throw new Error("PlanningError: \u518D\u5E30 CTE \u306E\u5B8C\u5168\u5B9F\u4F53\u5316 source \u3092\u89E3\u6C7A\u3067\u304D\u307E\u305B\u3093");
+    return { appId: 0, alias: table.alias, cteName: source.name, subtableCode: null };
+  };
+  return {
+    ...stmt,
+    from: rewrite(stmt.from),
+    joins: stmt.joins.map((join2) => ({ ...join2, table: rewrite(join2.table) }))
+  };
+}
+function tableMetaForJoinKey(table, field, cache) {
+  return table.cteName === null ? void 0 : cache.get(table.cteName)?.columnMeta?.get(field);
+}
+function recursiveJoinKey(value, semantics) {
+  if (semantics.compareMode !== "number" && semantics.compareMode !== "recordNumber") return value;
+  const decimal = parseExactDecimal(value);
+  return decimal === null ? `invalid:${value}` : `${decimal.sign}:${decimal.coefficient}:${decimal.scale}`;
+}
+function recursiveJoinSides(cteName, term) {
+  const join2 = term.joins[0];
+  if (!join2 || join2.type !== "INNER") throw new Error("PlanningError: \u518D\u5E30\u9805\u306E INNER JOIN \u3092\u89E3\u6C7A\u3067\u304D\u307E\u305B\u3093");
+  const self = term.from.cteName === cteName ? term.from : join2.table;
+  const source = self === term.from ? join2.table : term.from;
+  const selfAlias = effectiveTableAlias(self);
+  const leftIsSelf = join2.on.left.tableAlias === selfAlias;
+  const rightIsSelf = join2.on.right.tableAlias === selfAlias;
+  if (leftIsSelf === rightIsSelf) throw new Error("PlanningError: \u518D\u5E30\u9805\u306E\u81EA\u5DF1\u53C2\u7167 JOIN \u30AD\u30FC\u3092\u4E00\u610F\u306B\u89E3\u6C7A\u3067\u304D\u307E\u305B\u3093");
+  return {
+    self,
+    source,
+    selfField: leftIsSelf ? join2.on.left.field : join2.on.right.field,
+    sourceField: leftIsSelf ? join2.on.right.field : join2.on.left.field
+  };
+}
+async function executeRecursiveCte(cte, client, options, cteCache, cacheContext) {
+  const spec = cte.recursiveSpec;
+  const outputColumns = recursiveOutputColumns(cte);
+  const seedMeta = await inferRecursiveProjectionMeta(
+    spec.seed,
+    outputColumns,
+    client,
+    cacheContext,
+    cteCache
+  );
+  const planningCache = new Map(cteCache);
+  planningCache.set(cte.name, { rows: [], columns: outputColumns, columnMeta: seedMeta });
+  const termMeta = await inferRecursiveProjectionMeta(
+    spec.recursiveTerm,
+    outputColumns,
+    client,
+    cacheContext,
+    planningCache
+  );
+  outputColumns.forEach((column, index) => {
+    const left = seedMeta.get(column);
+    const right = termMeta.get(column);
+    if (!left || !right || !recursiveMetaCompatible(left, right)) {
+      throw new Error(`PlanningError: \u518D\u5E30 CTE\u300C${cte.name}\u300D\u306E\u7B2C ${index + 1} \u5217\u3067 seed \u3068\u518D\u5E30\u9805\u306E\u578B\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093`);
+    }
+  });
+  const planningSides = recursiveJoinSides(cte.name, spec.recursiveTerm);
+  const termFieldResolver = await buildRecursiveFieldResolver(
+    spec.recursiveTerm,
+    client,
+    cacheContext,
+    planningCache
+  );
+  const selfJoinMeta = termFieldResolver({
+    type: "FIELD",
+    tableAlias: effectiveTableAlias(planningSides.self),
+    field: planningSides.selfField
+  });
+  const sourceJoinMeta = termFieldResolver({
+    type: "FIELD",
+    tableAlias: effectiveTableAlias(planningSides.source),
+    field: planningSides.sourceField
+  });
+  if (!selfJoinMeta || !sourceJoinMeta || !recursiveMetaCompatible(selfJoinMeta, sourceJoinMeta)) {
+    throw new Error(`PlanningError: \u518D\u5E30 CTE\u300C${cte.name}\u300D\u306E\u81EA\u5DF1\u53C2\u7167 JOIN \u30AD\u30FC\u306E\u578B\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093`);
+  }
+  const sources = await materializeRecursivePhysicalSources(
+    [spec.seed, spec.recursiveTerm],
+    client,
+    options,
+    cacheContext
+  );
+  const runtimeCache = new Map(cteCache);
+  for (const source of sources.values()) runtimeCache.set(source.name, source.table);
+  const seedQuery = rewriteRecursivePhysicalSources(spec.seed, sources);
+  const termQuery = rewriteRecursivePhysicalSources(spec.recursiveTerm, sources);
+  const rawSeed = await executeQueryWithCte(seedQuery, client, options, runtimeCache, cacheContext, true, true);
+  const seed = alignSelectResultByPosition(rawSeed, outputColumns, seedMeta);
+  const cycle = spec.cycle;
+  const cycleMeta = cycle ? seedMeta.get(cycle.column) : void 0;
+  const resultMeta = new Map(seedMeta);
+  if (cycle) resultMeta.set(cycle.markColumn, { ...syntheticColumnMeta("string"), displayName: cycle.markColumn });
+  const resultColumns = cycle ? [...outputColumns, cycle.markColumn] : [...outputColumns];
+  const rows = [];
+  let frontier = [];
+  const warnings = /* @__PURE__ */ new Set([
+    ...seed.warnings ?? [],
+    ...[...sources.values()].flatMap((source) => source.warnings)
+  ]);
+  const limits = new RecursiveCteLimitCounter(cte.name, resolveRecursiveCteLimits(options));
+  const append = (row) => {
+    limits.addRow();
+    rows.push(row);
+  };
+  for (const row of seed.rows) {
+    const value = cycle ? String(row[cycle.column] ?? "") : "";
+    const emitted = cycle ? { ...row, [cycle.markColumn]: cycle.defaultValue } : row;
+    append(emitted);
+    frontier.push({ row, path: cycle ? [value] : [] });
+  }
+  const sides = recursiveJoinSides(cte.name, termQuery);
+  const sourceTable = sides.source.cteName === null ? void 0 : runtimeCache.get(sides.source.cteName);
+  if (!sourceTable) throw new Error("PlanningError: \u518D\u5E30\u9805\u306E\u5B8C\u5168\u5B9F\u4F53\u5316 source \u304C\u3042\u308A\u307E\u305B\u3093");
+  const joinMeta = tableMetaForJoinKey(sides.self, sides.selfField, planningCache) ?? tableMetaForJoinKey(sides.source, sides.sourceField, runtimeCache);
+  if (!joinMeta?.semantics || joinMeta.semantics.compareMode === "unsupported") {
+    throw new Error(`PlanningError: \u518D\u5E30\u9805\u306E JOIN \u30AD\u30FC ${sides.selfField} \u306E\u578B\u3092\u8A3C\u660E\u3067\u304D\u307E\u305B\u3093`);
+  }
+  const sourceRowsByKey = /* @__PURE__ */ new Map();
+  for (const sourceRow of sourceTable.rows) {
+    const value = String(sourceRow[sides.sourceField] ?? "");
+    const key = recursiveJoinKey(value, joinMeta.semantics);
+    const bucket = sourceRowsByKey.get(key);
+    if (bucket) bucket.push(sourceRow);
+    else sourceRowsByKey.set(key, [sourceRow]);
+  }
+  const sourceHasEmptyKey = sourceRowsByKey.has(recursiveJoinKey("", joinMeta.semantics));
+  let depth = 0;
+  let emptyKeyWarned = false;
+  while (frontier.length > 0) {
+    depth++;
+    const next = [];
+    for (const parent of frontier) {
+      const parentKey = String(parent.row[sides.selfField] ?? "");
+      if (!emptyKeyWarned && parentKey === "" && sourceHasEmptyKey) {
+        warnings.add(
+          `\u518D\u5E30 CTE\u300C${cte.name}\u300D\u306E JOIN ${sides.selfField} = ${sides.sourceField} \u3067\u7B2C ${depth} \u53CD\u5FA9\u306B\u4E21\u5074\u306E\u7A7A\u30AD\u30FC\u3092\u691C\u51FA\u3057\u307E\u3057\u305F\u3002\u7A7A\u30AD\u30FC\u3069\u3046\u3057\u306F\u4E00\u81F4\u3057\u3001\u30EB\u30FC\u30C8\u7FA4\u3092\u518D\u5C55\u958B\u3057\u5F97\u307E\u3059\u3002`
+        );
+        emptyKeyWarned = true;
+      }
+      const matchingSourceRows = sourceRowsByKey.get(recursiveJoinKey(parentKey, joinMeta.semantics)) ?? [];
+      for (const sourceRow of matchingSourceRows) {
+        const sourceKey = String(sourceRow[sides.sourceField] ?? "");
+        if (!compareScalarValues("=", parentKey, sourceKey, joinMeta.semantics)) continue;
+        limits.addExpansion();
+      }
+      if (matchingSourceRows.length === 0) continue;
+      const iterationCache = new Map(runtimeCache);
+      iterationCache.set(cte.name, {
+        rows: [parent.row],
+        columns: outputColumns,
+        columnMeta: seedMeta
+      });
+      const rawCandidates = await executeQueryWithCte(
+        termQuery,
+        client,
+        options,
+        iterationCache,
+        cacheContext,
+        true,
+        true
+      );
+      for (const warning of rawCandidates.warnings ?? []) warnings.add(warning);
+      const candidates = alignSelectResultByPosition(rawCandidates, outputColumns, seedMeta);
+      if (candidates.rows.length > 0) limits.observeDepth(depth);
+      for (const candidate of candidates.rows) {
+        if (!cycle) {
+          append(candidate);
+          next.push({ row: candidate, path: [] });
+          continue;
+        }
+        const value = String(candidate[cycle.column] ?? "");
+        const isCycle = parent.path.some(
+          (seen) => compareScalarValues("=", seen, value, cycleMeta.semantics)
+        );
+        append({ ...candidate, [cycle.markColumn]: isCycle ? cycle.markValue : cycle.defaultValue });
+        if (!isCycle) next.push({ row: candidate, path: [...parent.path, value] });
+      }
+    }
+    frontier = next;
+  }
+  const result = {
+    type: "SELECT",
+    rows,
+    columns: resultColumns,
+    rowCount: rows.length,
+    warnings: [...warnings]
+  };
+  materializedMetaBySelectResult.set(result, resultMeta);
+  return result;
+}
 async function executeWith(stmt, client, options, cacheContext, seed, captureColumnMeta = false) {
   if ((seed == null || seed.size === 0) && canInlineSingleCte(stmt)) {
     return executeSelect(
@@ -20717,7 +21436,9 @@ async function executeWith(stmt, client, options, cacheContext, seed, captureCol
   const warnings = /* @__PURE__ */ new Set();
   for (const cte of stmt.ctes) {
     let result2;
-    if (cte.query.type === "SHOW_APPS") {
+    if (cte.recursiveSpec) {
+      result2 = await executeRecursiveCte(cte, client, options, cteCache, cacheContext);
+    } else if (cte.query.type === "SHOW_APPS") {
       result2 = await executeShowApps(client);
     } else if (cte.query.type === "DESCRIBE") {
       result2 = await executeDescribe(cte.query, client, cacheContext);
@@ -20774,33 +21495,7 @@ async function executeQueryWithCte(query, client, options, cteCache, cacheContex
       executeQueryWithCte(query.left, client, options, cteCache, cacheContext, captureColumnMeta, true),
       executeQueryWithCte(query.right, client, options, cteCache, cacheContext, captureColumnMeta, true)
     ]);
-    const leftCols = leftResult.columns;
-    const rightCols = rightResult.columns;
-    assertUnionColumnCount(leftCols, rightCols);
-    const remapped = rightResult.rows.map((row) => {
-      const mapped = {};
-      leftCols.forEach((col, i) => {
-        mapped[col] = row[rightCols[i] ?? col] ?? "";
-      });
-      return mapped;
-    });
-    const combined = [...leftResult.rows, ...remapped];
-    const rows = query.all ? combined : deduplicateRows(combined, leftCols);
-    const warnings = [.../* @__PURE__ */ new Set([
-      ...leftResult.warnings ?? [],
-      ...rightResult.warnings ?? []
-    ])];
-    const result2 = {
-      type: "SELECT",
-      rows,
-      columns: leftCols,
-      rowCount: rows.length,
-      warnings
-    };
-    if (captureColumnMeta) {
-      materializedMetaBySelectResult.set(result2, mergeUnionColumnMeta(leftResult, rightResult));
-    }
-    return result2;
+    return combineUnionResults(leftResult, rightResult, query.all, captureColumnMeta);
   }
   const hasCteRef = query.from.cteName != null && query.from.cteName !== NO_FROM_CTE_NAME || query.joins.some((j) => j.table.cteName != null);
   if (!hasCteRef) {
@@ -24766,9 +25461,13 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         const joinField = leftAlias === joinAlias ? join2.on.left.field : join2.on.right.field;
         if (!sourceAlias) continue;
         const sourceTable = [select.from, ...select.joins.map((candidate) => candidate.table)].find((table) => effectiveTableAlias(table) === sourceAlias);
-        const targetInfos = await getFieldsCached(join2.table.appId, tracedClient, cacheContext);
-        const targetInfo = targetInfos.find((info) => info.code === fieldCodeForTypeLookup(join2.table, joinField));
-        const targetMeta = targetInfo ? materializedMetaFromFieldInfo(targetInfo, join2.table.appId) : systemColumnMeta(joinField);
+        let targetMeta;
+        if (join2.table.cteName !== null) {
+          targetMeta = explainRelations.get(join2.table.cteName)?.columnMeta?.get(joinField);
+        } else {
+          const targetInfo = (await getFieldsCached(join2.table.appId, tracedClient, cacheContext)).find((info) => info.code === fieldCodeForTypeLookup(join2.table, joinField));
+          targetMeta = targetInfo ? materializedMetaFromFieldInfo(targetInfo, join2.table.appId) : systemColumnMeta(joinField);
+        }
         let sourceMeta;
         let values;
         let sourceRowCount;
@@ -25337,7 +26036,12 @@ var EXPLAIN_FETCH_PLAN = /* @__PURE__ */ Symbol("ksql.explainFetchPlan");
 function setExplainFetchPlan(result, plan) {
   result[EXPLAIN_FETCH_PLAN] = plan;
 }
-async function buildBatchExplainPlans(sql, client, injectedVariables, cacheContext = "batch-explain", maxRecords = 1e4, cursorMaxActive = 2, enableImport = false, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, resolveMetadata = true) {
+async function buildBatchExplainPlans(sql, client, injectedVariables, cacheContext = "batch-explain", maxRecords = 1e4, cursorMaxActive = 2, enableImport = false, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, resolveMetadata = true, recursiveCteMaxDepth, recursiveCteMaxRows, recursiveCteMaxExpansions) {
+  const recursiveLimits = resolveRecursiveCteLimits({
+    recursiveCteMaxDepth,
+    recursiveCteMaxRows,
+    recursiveCteMaxExpansions
+  });
   const invocationCacheContext = createInvocationCacheContext(cacheContext);
   try {
     const statements = parseSqlBatch(sql, enableImport);
@@ -25416,7 +26120,8 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
           dmlMaxSubtableRows,
           fetchCollector,
           tempSchemaLedger,
-          createdSchema
+          createdSchema,
+          { maxRecords, recursiveLimits }
         ), cursorMaxActive)
       ];
       const metadataPlan = explainMetadataLines(whereAnalysis);
@@ -25448,7 +26153,7 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
     releaseMetadataCacheScope(invocationCacheContext);
   }
 }
-function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, plainGroupByPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, collector = { sources: [] }, tempSchemaLedger = /* @__PURE__ */ new Map(), createdSchema) {
+function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, plainGroupByPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, collector = { sources: [] }, tempSchemaLedger = /* @__PURE__ */ new Map(), createdSchema, explainContext = defaultRecursiveExplainContext()) {
   if (stmt.type === "CREATE_TEMP_TABLE") {
     return [
       `CREATE TEMP TABLE ${stmt.name}`,
@@ -25469,7 +26174,8 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, plainGrou
         plainGroupByPlans,
         collector,
         "main",
-        tempSchemaLedger
+        tempSchemaLedger,
+        explainContext
       ).map((l) => `  ${l}`)
     ];
   }
@@ -25494,7 +26200,8 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, plainGrou
           plainGroupByPlans,
           collector,
           "main",
-          tempSchemaLedger
+          tempSchemaLedger,
+          explainContext
         ).map((l) => `  ${l}`)
       ];
     }
@@ -25526,7 +26233,8 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, plainGrou
       plainGroupByPlans,
       collector,
       "main",
-      tempSchemaLedger
+      tempSchemaLedger,
+      explainContext
     );
   }
   if (stmt.type === "ASSERT") {
@@ -25548,7 +26256,8 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, plainGrou
         plainGroupByPlans,
         collector,
         "main",
-        tempSchemaLedger
+        tempSchemaLedger,
+        explainContext
       ).map((l) => `  ${l}`));
     });
     return lines;
@@ -25573,7 +26282,8 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, plainGrou
     plainGroupByPlans,
     collector,
     "main",
-    tempSchemaLedger
+    tempSchemaLedger,
+    explainContext
   );
 }
 function hasTempTableRef(node) {
@@ -25586,7 +26296,7 @@ function hasTempTableRef(node) {
   }
   return false;
 }
-function buildPlanForBatchQuery(query, info, capabilities, orderPlans, plainGroupByPlans, collector = { sources: [] }, sourceRole = "main", tempSchemaLedger = /* @__PURE__ */ new Map()) {
+function buildPlanForBatchQuery(query, info, capabilities, orderPlans, plainGroupByPlans, collector = { sources: [] }, sourceRole = "main", tempSchemaLedger = /* @__PURE__ */ new Map(), explainContext = defaultRecursiveExplainContext()) {
   if (info.tempTablesReferenced.length === 0) {
     return buildExplainPlan(
       query,
@@ -25595,11 +26305,12 @@ function buildPlanForBatchQuery(query, info, capabilities, orderPlans, plainGrou
       orderPlans,
       100,
       DEFAULT_APPLY_MAX_SUBTABLE_ROWS,
-      1e4,
+      explainContext.maxRecords,
       plainGroupByPlans,
       true,
       collector,
-      sourceRole
+      sourceRole,
+      explainContext.recursiveLimits
     );
   }
   const lines = [];
@@ -25646,7 +26357,15 @@ function buildPlanForBatchQuery(query, info, capabilities, orderPlans, plainGrou
   return lines;
 }
 var explainMaterializedTables = /* @__PURE__ */ new WeakMap();
-async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxActive, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, relativeDatePlan) {
+function defaultRecursiveExplainContext() {
+  return { maxRecords: 1e4, recursiveLimits: resolveRecursiveCteLimits({}) };
+}
+async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxActive, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, relativeDatePlan, recursiveCteMaxDepth, recursiveCteMaxRows, recursiveCteMaxExpansions) {
+  const recursiveLimits = resolveRecursiveCteLimits({
+    recursiveCteMaxDepth,
+    recursiveCteMaxRows,
+    recursiveCteMaxExpansions
+  });
   const sharedPlan = relativeDatePlan ?? await resolveRelativeDateExecutionPlan(stmt.query, client, cacheContext);
   const analysis = await buildExplainWhereAnalysis(
     stmt.query,
@@ -25672,7 +26391,9 @@ async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxA
         maxRecords,
         analysis.plainGroupByPlans,
         true,
-        fetchCollector
+        fetchCollector,
+        "main",
+        recursiveLimits
       ),
       cursorMaxActive
     )
@@ -25704,7 +26425,7 @@ function addCursorConcurrency(lines, cursorMaxActive) {
   }
   return result;
 }
-function buildExplainPlan(query, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, maxRecords = 1e4, plainGroupByPlans, includeFetchSummary = true, collector, sourceRole = "main") {
+function buildExplainPlan(query, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, maxRecords = 1e4, plainGroupByPlans, includeFetchSummary = true, collector, sourceRole = "main", recursiveLimits = resolveRecursiveCteLimits({})) {
   const fetchCollector = collector ?? { sources: [] };
   if (query.type === "UNION") {
     const lines2 = buildUnionPlan(
@@ -25722,7 +26443,9 @@ function buildExplainPlan(query, label, capabilities, orderPlans, dmlMaxRows = 1
       capabilities,
       orderPlans,
       plainGroupByPlans,
-      fetchCollector
+      fetchCollector,
+      maxRecords,
+      recursiveLimits
     );
     return includeFetchSummary ? addFetchSummary(lines2, fetchCollector.sources) : lines2;
   }
@@ -26319,11 +27042,30 @@ function populateWithCrossJoinExplain(stmt) {
   }
   analyzeQuery(stmt.query);
 }
-function buildWithPlan(stmt, capabilities, orderPlans, plainGroupByPlans, collector = { sources: [] }) {
+function buildWithPlan(stmt, capabilities, orderPlans, plainGroupByPlans, collector = { sources: [] }, maxRecords = 1e4, recursiveLimits = resolveRecursiveCteLimits({})) {
   populateWithCrossJoinExplain(stmt);
   const lines = [];
   for (const cte of stmt.ctes) {
-    if (cte.query.type === "SELECT") {
+    if (cte.recursiveSpec) {
+      const cycle = cte.recursiveSpec.cycle;
+      lines.push(
+        `recursive cte: ${cte.name}`,
+        "  strategy: B (materialize each source once, iterate in memory)",
+        "  union: UNION ALL",
+        "  self reference: once",
+        cycle ? `  cycle: path-scoped on ${cycle.column}, mark ${cycle.markColumn} ('${cycle.markValue}'/'${cycle.defaultValue}'), cycle row emitted, expansion stopped` : "  cycle: none (absolute limits still enforced)",
+        `  limits: depth=${recursiveLimits.depth}, rows=${recursiveLimits.rows}, expansions=${recursiveLimits.expansions} (always fail-closed)`,
+        "  complete input: required (onLimit=truncate disabled)",
+        "  empty-key recursive join: runtime checked"
+      );
+      for (const source of recursivePhysicalTables(cte.recursiveSpec.seed, cte.recursiveSpec.recursiveTerm)) {
+        const sourceName = `APP${source.appId}${source.subtableCode ? `$${source.subtableCode}` : ""}`;
+        lines.push(
+          `  source ${sourceName}: R unknown, pageSize=500, estimated calls=ceil(R/500), maxRecords=${maxRecords}`
+        );
+      }
+      lines.push("  iteration rows: unknown until execution", "  records API: none", "");
+    } else if (cte.query.type === "SELECT") {
       lines.push(...buildSelectPlan(
         cte.query,
         `[cte: ${cte.name}]`,
@@ -26389,10 +27131,12 @@ function buildWithPlan(stmt, capabilities, orderPlans, plainGroupByPlans, collec
       orderPlans,
       100,
       DEFAULT_APPLY_MAX_SUBTABLE_ROWS,
-      1e4,
+      maxRecords,
       plainGroupByPlans,
       false,
-      collector
+      collector,
+      "main",
+      recursiveLimits
     ));
   }
   if (canInlineSingleCte(stmt)) {
@@ -28744,6 +29488,16 @@ Options:
   -h, --help                 Show help
   -v, --version              Show version
 `;
+var RECURSIVE_CTE_HELP_LINES = [
+  "  --recursive-cte-max-depth <n> Max recursive CTE depth (default: 100)",
+  "  --recursive-cte-max-rows <n> Max accumulated recursive CTE rows (default: 10000)",
+  "  --recursive-cte-max-expansions <n> Max recursive CTE candidate expansions (default: 100000)"
+].join("\n");
+var CLI_HELP_TEXT = HELP_TEXT.replace(
+  "  --max-records <n>          Max records to fetch (default: 500)",
+  `  --max-records <n>          Max records to fetch (default: 500)
+${RECURSIVE_CTE_HELP_LINES}`
+);
 var CLI_IMPORT_SOURCE_REQUIRED_MESSAGE = "IMPORT \u306B\u306F\u30BD\u30FC\u30B9\u304C\u5FC5\u8981\u3067\u3059\u3002--import-csv <name=path> \u307E\u305F\u306F --import-json <name=path> \u3067\u30D5\u30A1\u30A4\u30EB\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
 function toCliImportError(error, importEnabled) {
   if (importEnabled || !isImportCapabilityGateError(error)) return error;
@@ -28763,6 +29517,9 @@ function parseArgs(argv) {
     dryRun: false,
     format: null,
     maxRecords: null,
+    recursiveCteMaxDepth: null,
+    recursiveCteMaxRows: null,
+    recursiveCteMaxExpansions: null,
     fetchParallel: null,
     onLimit: null,
     tempTableMaxRows: null,
@@ -29029,6 +29786,17 @@ function parseArgs(argv) {
       i++;
       continue;
     }
+    if (a === "--recursive-cte-max-depth" || a === "--recursive-cte-max-rows" || a === "--recursive-cte-max-expansions") {
+      const n = Number(v);
+      if (!Number.isSafeInteger(n) || n <= 0) {
+        throw new Error(`ArgumentError: ${a} must be a positive safe integer.`);
+      }
+      if (a === "--recursive-cte-max-depth") out.recursiveCteMaxDepth = n;
+      else if (a === "--recursive-cte-max-rows") out.recursiveCteMaxRows = n;
+      else out.recursiveCteMaxExpansions = n;
+      i++;
+      continue;
+    }
     if (a === "--temp-table-max-rows") {
       const n = Number(v);
       if (!Number.isInteger(n) || n <= 0) throw new Error("ArgumentError: --temp-table-max-rows must be a positive integer.");
@@ -29657,6 +30425,9 @@ function buildReplExecArgv(base, sql, dryRun, format) {
   pushOpt(argv, "--token-file", base.tokenFile);
   pushOpt(argv, "--app", base.app);
   pushOpt(argv, "--max-records", base.maxRecords);
+  pushOpt(argv, "--recursive-cte-max-depth", base.recursiveCteMaxDepth);
+  pushOpt(argv, "--recursive-cte-max-rows", base.recursiveCteMaxRows);
+  pushOpt(argv, "--recursive-cte-max-expansions", base.recursiveCteMaxExpansions);
   pushOpt(argv, "--fetch-parallel", base.fetchParallel);
   pushOpt(argv, "--on-limit", base.onLimit);
   pushOpt(argv, "--temp-table-max-rows", base.tempTableMaxRows);
@@ -30137,7 +30908,7 @@ async function run() {
     return 2;
   }
   if (args.help) {
-    process.stdout.write(`${HELP_TEXT}
+    process.stdout.write(`${CLI_HELP_TEXT}
 `);
     return 0;
   }
@@ -30255,6 +31026,20 @@ async function run() {
     }
   }
   const maxRecords = args.maxRecords ?? envInt2("KSQL_MAX_RECORDS") ?? profile.query?.maxRecords ?? 500;
+  const recursiveCteMaxDepth = args.recursiveCteMaxDepth ?? envInt2("KSQL_RECURSIVE_CTE_MAX_DEPTH") ?? profile.query?.recursiveCteMaxDepth ?? 100;
+  const recursiveCteMaxRows = args.recursiveCteMaxRows ?? envInt2("KSQL_RECURSIVE_CTE_MAX_ROWS") ?? profile.query?.recursiveCteMaxRows ?? 1e4;
+  const recursiveCteMaxExpansions = args.recursiveCteMaxExpansions ?? envInt2("KSQL_RECURSIVE_CTE_MAX_EXPANSIONS") ?? profile.query?.recursiveCteMaxExpansions ?? 1e5;
+  for (const [name, value] of [
+    ["recursiveCteMaxDepth", recursiveCteMaxDepth],
+    ["recursiveCteMaxRows", recursiveCteMaxRows],
+    ["recursiveCteMaxExpansions", recursiveCteMaxExpansions]
+  ]) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      process.stderr.write(`ArgumentError: ${name} must be a positive safe integer.
+`);
+      return 2;
+    }
+  }
   const fetchParallel = args.fetchParallel ?? envInt2("KSQL_FETCH_PARALLEL") ?? profile.query?.fetchParallel ?? 3;
   const onLimit = args.onLimit ?? envOnLimit2("KSQL_ON_LIMIT") ?? profile.query?.onLimit ?? "error";
   const timeout = args.timeout ?? envInt2("KSQL_TIMEOUT") ?? profile.query?.timeout ?? 3e4;
@@ -30611,7 +31396,10 @@ async function run() {
         Object.keys(args.importCsv).length > 0 || Object.keys(args.importJson).length > 0,
         dmlMaxRows,
         dmlMaxSubtableRows,
-        !dryRunUsesStaticTypedPlan
+        !dryRunUsesStaticTypedPlan,
+        recursiveCteMaxDepth,
+        recursiveCteMaxRows,
+        recursiveCteMaxExpansions
       );
       const out = [];
       const restoredStatements = sqlDiagnosticContext ? restoreSqlDiagnosticValue(plans.statements, sqlDiagnosticContext.appBindingByMappedApp) : plans.statements;
@@ -30701,6 +31489,9 @@ query=${label}`);
         tempTableMaxRows,
         timeoutMs: timeout,
         cursorMaxActive,
+        recursiveCteMaxDepth,
+        recursiveCteMaxRows,
+        recursiveCteMaxExpansions,
         variables: args.variables,
         enableImport: importEnabled,
         importSource,
@@ -30752,7 +31543,10 @@ query=${label}`);
       enableImport: importEnabled,
       importSource,
       dmlMaxRows,
-      dmlMaxSubtableRows
+      dmlMaxSubtableRows,
+      recursiveCteMaxDepth,
+      recursiveCteMaxRows,
+      recursiveCteMaxExpansions
     }) : await execute(sql, client, {
       maxRecords,
       fetchParallel,
@@ -30760,6 +31554,9 @@ query=${label}`);
       confirm: isDmlStatement ? confirm : void 0,
       cacheContext,
       cursorMaxActive,
+      recursiveCteMaxDepth,
+      recursiveCteMaxRows,
+      recursiveCteMaxExpansions,
       enableImport: importEnabled,
       importSource,
       supportsImportConfirmDetail: true,
@@ -30843,6 +31640,7 @@ if (isDirectCliRun()) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CLI_HELP_TEXT,
   CLI_IMPORT_SOURCE_REQUIRED_MESSAGE,
   HELP_TEXT,
   buildBatchDmlConfirmMessage,