@rex0220/kintone-sql-tools 1.2.0 → 1.4.0

package/dist-cli/ksql.js

@@ -22,6 +22,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   HELP_TEXT: () => HELP_TEXT,
+  buildBatchDmlConfirmMessage: () => buildBatchDmlConfirmMessage,
+  buildBatchStatementSummary: () => buildBatchStatementSummary,
   buildOutput: () => buildOutput,
   extractAppIds: () => extractAppIds,
   normalizeAppKey: () => normalizeAppKey,
@@ -134,11 +136,12 @@ var KEYWORDS = /* @__PURE__ */ new Map([
 
 // src/lexer/lexer.ts
 var LexError = class extends Error {
-  constructor(message, pos, input) {
+  constructor(message, pos, input, unterminated = false) {
     const around = input.slice(Math.max(0, pos - 10), pos + 10);
     super(`${message}\uFF08\u4F4D\u7F6E ${pos}\u3001\u524D\u5F8C: \u300C${around}\u300D\uFF09`);
     this.pos = pos;
     this.input = input;
+    this.unterminated = unterminated;
     this.name = "LexError";
   }
 };
@@ -175,6 +178,7 @@ var Lexer = class {
     const opTok = this.tryReadOperator(start);
     if (opTok) return opTok;
     if (isIdentStart(ch)) return this.readIdentOrKeyword(start);
+    if (ch === "#") return this.readHashIdent(start);
     throw new LexError(
       `\u4E88\u671F\u3057\u306A\u3044\u6587\u5B57 \u300C${ch}\u300D \u3067\u3059`,
       this.pos,
@@ -203,7 +207,7 @@ var Lexer = class {
         this.pos++;
       }
     }
-    throw new LexError("\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u304C\u9589\u3058\u3089\u308C\u3066\u3044\u307E\u305B\u3093", start, this.input);
+    throw new LexError("\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u304C\u9589\u3058\u3089\u308C\u3066\u3044\u307E\u305B\u3093", start, this.input, true);
   }
   // ----------------------------------------------------------
   // バッククォート識別子: `field name`
@@ -223,7 +227,8 @@ var Lexer = class {
     throw new LexError(
       "\u30D0\u30C3\u30AF\u30AF\u30A9\u30FC\u30C8\u8B58\u5225\u5B50\u304C\u9589\u3058\u3089\u308C\u3066\u3044\u307E\u305B\u3093",
       start,
-      this.input
+      this.input,
+      true
     );
   }
   // ----------------------------------------------------------
@@ -330,6 +335,30 @@ var Lexer = class {
     return this.makeToken(kind, value, start);
   }
   // ----------------------------------------------------------
+  // 一時テーブル識別子: #temp
+  // # は先頭のみ有効。isIdentStart に # を加えると isIdentContinue 経由で
+  // 識別子の途中（APP#x 等）にも許容されてしまうため、専用分岐で読む。
+  // ----------------------------------------------------------
+  readHashIdent(start) {
+    this.pos++;
+    const next = this.input[this.pos] ?? "";
+    if (!isIdentStart(next)) {
+      throw new LexError("\u300C#\u300D \u306E\u76F4\u5F8C\u306B\u306F\u8B58\u5225\u5B50\u304C\u5FC5\u8981\u3067\u3059", start, this.input);
+    }
+    while (this.pos < this.input.length && isIdentContinue(this.input[this.pos])) {
+      this.pos++;
+    }
+    const value = this.input.slice(start, this.pos);
+    if (this.input[this.pos] === "@") {
+      throw new LexError(
+        `@profile is not allowed on temp table ${value}.`,
+        this.pos,
+        this.input
+      );
+    }
+    return this.makeToken("IDENT" /* IDENT */, value, start);
+  }
+  // ----------------------------------------------------------
   // 空白・コメントをスキップ
   // ----------------------------------------------------------
   skipWhitespaceAndComments() {
@@ -346,14 +375,25 @@ var Lexer = class {
         continue;
       }
       if (ch === "/" && this.input[this.pos + 1] === "*") {
+        const commentStart = this.pos;
         this.pos += 2;
+        let closed = false;
         while (this.pos < this.input.length) {
           if (this.input[this.pos] === "*" && this.input[this.pos + 1] === "/") {
             this.pos += 2;
+            closed = true;
             break;
           }
           this.pos++;
         }
+        if (!closed) {
+          throw new LexError(
+            "\u30D6\u30ED\u30C3\u30AF\u30B3\u30E1\u30F3\u30C8\u304C\u9589\u3058\u3089\u308C\u3066\u3044\u307E\u305B\u3093",
+            commentStart,
+            this.input,
+            true
+          );
+        }
         continue;
       }
       break;
@@ -387,6 +427,7 @@ function isJapanese(cp) {
 }
 
 // src/parser/parser.ts
+var MAX_BATCH_STATEMENTS = 20;
 var ParseError = class extends Error {
   constructor(message, token) {
     super(`${message}\uFF08\u4F4D\u7F6E ${token.pos}\u3001\u30C8\u30FC\u30AF\u30F3: \u300C${token.value}\u300D\uFF09`);
@@ -400,15 +441,54 @@ var Parser = class {
     this.pos = 0;
     /** WITH 句で定義された CTE 名のセット（parseTableRef で参照） */
     this.cteNames = /* @__PURE__ */ new Set();
+    /** パース中に出現した一時テーブル参照（#name）のトークン。単文 API での拒否に使う */
+    this.tempTableRefs = [];
   }
   // ----------------------------------------------------------
   // 公開 API
   // ----------------------------------------------------------
+  /** 単文をパースする（従来 API。複文が渡されたらエラー） */
   parse() {
-    const stmt = this.parseStatement();
-    if (this.peek().kind === ";" /* SEMICOLON */) this.advance();
+    const stmts = this.parseStatements();
+    if (stmts.length === 0) {
+      throw new ParseError("SQL \u6587\u304C\u3042\u308A\u307E\u305B\u3093", this.peek());
+    }
+    if (stmts.length > 1) {
+      throw new ParseError(
+        "\u3053\u306E API \u306F\u5358\u6587\u306E\u307F\u53D7\u3051\u4ED8\u3051\u307E\u3059\uFF08\u8907\u6587\u306F\u30D0\u30C3\u30C1\u5B9F\u884C API \u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\uFF09",
+        this.peek()
+      );
+    }
+    if (this.tempTableRefs.length > 0) {
+      const tok = this.tempTableRefs[0];
+      throw new ParseError(
+        `temp table ${tok.value} is not defined in this batch.`,
+        tok
+      );
+    }
+    return stmts[0];
+  }
+  /** 複文（`;` 区切り）をパースする。空文はスキップする */
+  parseStatements() {
+    const stmts = [];
+    while (true) {
+      while (this.peek().kind === ";" /* SEMICOLON */) this.advance();
+      if (this.peek().kind === "EOF" /* EOF */) break;
+      const startTok = this.peek();
+      stmts.push(this.parseStatement());
+      if (stmts.length > MAX_BATCH_STATEMENTS) {
+        throw new ParseError(
+          `batch exceeds ${MAX_BATCH_STATEMENTS} statements.`,
+          startTok
+        );
+      }
+      const after = this.peek();
+      if (after.kind !== ";" /* SEMICOLON */ && after.kind !== "EOF" /* EOF */) {
+        throw new ParseError("\u6587\u306E\u533A\u5207\u308A\u306B\u306F ; \u304C\u5FC5\u8981\u3067\u3059", after);
+      }
+    }
     this.expect("EOF" /* EOF */);
-    return stmt;
+    return stmts;
   }
   // ----------------------------------------------------------
   // Statement ディスパッチ
@@ -437,12 +517,63 @@ var Parser = class {
         return this.parseDescribe();
       case "EXPLAIN" /* EXPLAIN */:
         return this.parseExplain();
+      case "IDENT" /* IDENT */: {
+        const upper = tok.value.toUpperCase();
+        if (upper === "CREATE") return this.parseCreateTempTable();
+        if (upper === "DROP") return this.parseDropTempTable();
+        break;
+      }
       default:
-        throw new ParseError(
-          "SELECT / INSERT / UPDATE / DELETE / REORDER / WITH / SHOW / DESCRIBE / EXPLAIN \u306E\u3044\u305A\u308C\u304B\u3067\u59CB\u307E\u308B SQL \u6587\u304C\u5FC5\u8981\u3067\u3059",
-          tok
-        );
+        break;
+    }
+    throw new ParseError(
+      "SELECT / INSERT / UPDATE / DELETE / REORDER / WITH / SHOW / DESCRIBE / EXPLAIN / CREATE TEMP TABLE / DROP TEMP TABLE \u306E\u3044\u305A\u308C\u304B\u3067\u59CB\u307E\u308B SQL \u6587\u304C\u5FC5\u8981\u3067\u3059",
+      tok
+    );
+  }
+  // ----------------------------------------------------------
+  // CREATE TEMP TABLE / DROP TEMP TABLE（バッチ内一時テーブル）
+  // CREATE / DROP / TEMP / TABLE は予約語にしない（ソフトキーワード）
+  // ----------------------------------------------------------
+  parseCreateTempTable() {
+    this.advance();
+    this.expectSoftKeyword("TEMP", "CREATE \u306E\u5F8C\u306B\u306F TEMP TABLE \u304C\u5FC5\u8981\u3067\u3059\uFF08\u4F8B: CREATE TEMP TABLE #temp AS SELECT ...\uFF09");
+    this.expectSoftKeyword("TABLE", "CREATE TEMP \u306E\u5F8C\u306B\u306F TABLE \u304C\u5FC5\u8981\u3067\u3059");
+    const name = this.parseTempTableName();
+    this.expect("AS" /* AS */, "CREATE TEMP TABLE \u306B\u306F AS SELECT \u304C\u5FC5\u8981\u3067\u3059");
+    const tok = this.peek();
+    let query;
+    if (tok.kind === "WITH" /* WITH */) {
+      query = this.parseWith();
+    } else if (tok.kind === "SELECT" /* SELECT */) {
+      query = this.tryParseUnionChain(this.parseSelect());
+    } else {
+      throw new ParseError("CREATE TEMP TABLE ... AS \u306E\u5F8C\u306B\u306F SELECT / WITH \u304C\u5FC5\u8981\u3067\u3059", tok);
     }
+    return { type: "CREATE_TEMP_TABLE", name, query };
+  }
+  parseDropTempTable() {
+    this.advance();
+    this.expectSoftKeyword("TEMP", "DROP \u306E\u5F8C\u306B\u306F TEMP TABLE \u304C\u5FC5\u8981\u3067\u3059\uFF08\u4F8B: DROP TEMP TABLE #temp\uFF09");
+    this.expectSoftKeyword("TABLE", "DROP TEMP \u306E\u5F8C\u306B\u306F TABLE \u304C\u5FC5\u8981\u3067\u3059");
+    const name = this.parseTempTableName();
+    return { type: "DROP_TEMP_TABLE", name };
+  }
+  expectSoftKeyword(word, msg) {
+    const tok = this.peek();
+    if (tok.kind === "IDENT" /* IDENT */ && tok.value.toUpperCase() === word) {
+      this.advance();
+      return;
+    }
+    throw new ParseError(msg, tok);
+  }
+  parseTempTableName() {
+    const tok = this.peek();
+    if (tok.kind === "IDENT" /* IDENT */ && tok.value.startsWith("#")) {
+      this.advance();
+      return tok.value;
+    }
+    throw new ParseError("\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u540D\u306F # \u3067\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\uFF08\u4F8B: #temp\uFF09", tok);
   }
   parseShow() {
     this.advance();
@@ -999,24 +1130,38 @@ var Parser = class {
   // FROM / JOIN
   // ----------------------------------------------------------
   parseTableRef() {
-    const name = this.parseIdentifier();
+    const nameTok = this.peek();
+    const name = this.parseTableName();
+    if (nameTok.kind === "IDENT" /* IDENT */ && name.startsWith("#")) {
+      this.tempTableRefs.push(this.prev());
+      const alias2 = this.consume("AS" /* AS */) ? this.parseTableAliasName() : this.tryParseImplicitAlias();
+      return { appId: 0, alias: alias2, cteName: name };
+    }
     if (this.cteNames.has(name)) {
-      const alias2 = this.consume("AS" /* AS */) ? this.parseIdentifier() : this.tryParseImplicitAlias();
+      const alias2 = this.consume("AS" /* AS */) ? this.parseTableAliasName() : this.tryParseImplicitAlias();
       return { appId: 0, alias: alias2, cteName: name };
     }
     const { appId, subtableCode } = extractTableRef(name, this.prev());
     if (subtableCode) {
-      const alias2 = this.consume("AS" /* AS */) ? this.parseIdentifier() : this.tryParseImplicitAlias();
+      const alias2 = this.consume("AS" /* AS */) ? this.parseTableAliasName() : this.tryParseImplicitAlias();
       return { appId, alias: alias2, cteName: null, subtableCode };
     }
     const implicit = this.tryParseImplicitAlias();
-    const alias = this.consume("AS" /* AS */) ? this.parseIdentifier() : implicit ?? name;
+    const alias = this.consume("AS" /* AS */) ? this.parseTableAliasName() : implicit ?? name;
     return { appId, alias, cteName: null };
   }
+  // テーブル alias 名を読む（IDENT / BIDENT）。alias 位置の # は BIDENT でも拒否
+  parseTableAliasName() {
+    const tok = this.peek();
+    if ((tok.kind === "IDENT" /* IDENT */ || tok.kind === "BIDENT" /* BIDENT */) && tok.value.startsWith("#")) {
+      throw new ParseError("\u30A8\u30A4\u30EA\u30A2\u30B9\u540D\u306B # \u3067\u59CB\u307E\u308B\u540D\u524D\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+    }
+    return this.parseIdentifier();
+  }
   tryParseImplicitAlias() {
     const k = this.peek().kind;
     if (k === "IDENT" /* IDENT */ || k === "BIDENT" /* BIDENT */) {
-      return this.parseIdentifier();
+      return this.parseTableAliasName();
     }
     return null;
   }
@@ -1421,6 +1566,7 @@ var Parser = class {
   parseInsert() {
     this.expect("INSERT" /* INSERT */);
     this.expect("INTO" /* INTO */);
+    this.rejectTempTableDml();
     const name = this.parseIdentifier();
     const { appId, subtableCode } = extractTableRef(name, this.prev());
     this.expect("(" /* LPAREN */);
@@ -1446,6 +1592,7 @@ var Parser = class {
   parseUpsert() {
     this.expect("UPSERT" /* UPSERT */);
     this.expect("INTO" /* INTO */);
+    this.rejectTempTableDml();
     const name = this.parseIdentifier();
     const { appId, subtableCode } = extractTableRef(name, this.prev());
     if (subtableCode) {
@@ -1530,6 +1677,7 @@ var Parser = class {
   // ----------------------------------------------------------
   parseUpdate() {
     this.expect("UPDATE" /* UPDATE */);
+    this.rejectTempTableDml();
     const name = this.parseIdentifier();
     const { appId, subtableCode } = extractTableRef(name, this.prev());
     this.expect("SET" /* SET */);
@@ -1605,6 +1753,7 @@ var Parser = class {
   parseDelete() {
     this.expect("DELETE" /* DELETE */);
     this.expect("FROM" /* FROM */);
+    this.rejectTempTableDml();
     const name = this.parseIdentifier();
     const { appId, subtableCode } = extractTableRef(name, this.prev());
     const whereTok = this.peek();
@@ -1623,6 +1772,7 @@ var Parser = class {
   parseReorder() {
     this.expect("REORDER" /* REORDER */);
     const all = this.consume("ALL" /* ALL */);
+    this.rejectTempTableDml();
     const name = this.parseIdentifier();
     const { appId, subtableCode } = extractTableRef(name, this.prev());
     if (!subtableCode) {
@@ -1704,8 +1854,29 @@ var Parser = class {
     }
     return n;
   }
-  // 識別子（IDENT / BIDENT）を読む
+  // 識別子（IDENT / BIDENT）を読む。# 始まりの一時テーブル名は不可
+  //（temp マーカーはレキサが生成する IDENT のみ。`#field` のような
+  //  バッククォート識別子は # で始まる通常フィールド名として許容する）
   parseIdentifier() {
+    const tok = this.peek();
+    if (tok.kind === "IDENT" /* IDENT */ || tok.kind === "BIDENT" /* BIDENT */) {
+      if (tok.kind === "IDENT" /* IDENT */ && tok.value.startsWith("#")) {
+        throw new ParseError(
+          "\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u540D\uFF08# \u3067\u59CB\u307E\u308B\u540D\u524D\uFF09\u306F FROM / JOIN / CREATE / DROP TEMP TABLE \u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059",
+          tok
+        );
+      }
+      this.advance();
+      return tok.value;
+    }
+    throw new ParseError(
+      "\u30D5\u30A3\u30FC\u30EB\u30C9\u540D\u307E\u305F\u306F\u30C6\u30FC\u30D6\u30EB\u540D\u304C\u5FC5\u8981\u3067\u3059",
+      tok
+    );
+  }
+  // テーブル名（IDENT / BIDENT）を読む。# 始まりの一時テーブル名を許容する
+  //（一時テーブルを受理してよいのはテーブル参照位置のみ。他は parseIdentifier を使う）
+  parseTableName() {
     const tok = this.peek();
     if (tok.kind === "IDENT" /* IDENT */ || tok.kind === "BIDENT" /* BIDENT */) {
       this.advance();
@@ -1716,10 +1887,23 @@ var Parser = class {
       tok
     );
   }
+  // DML の対象テーブル位置に一時テーブルが指定されていたら拒否する
+  rejectTempTableDml() {
+    const tok = this.peek();
+    if (tok.kind === "IDENT" /* IDENT */ && tok.value.startsWith("#")) {
+      throw new ParseError(
+        `DML on temp table ${tok.value} is not supported.`,
+        tok
+      );
+    }
+  }
   // エイリアス名: IDENT / BIDENT に加え、キーワードも許容する
   // 例: SELECT SUM(金額) AS avg → "avg" は AVG キーワードだが alias として有効
   parseAliasName() {
     const tok = this.peek();
+    if (tok.value.startsWith("#")) {
+      throw new ParseError("\u30A8\u30A4\u30EA\u30A2\u30B9\u540D\u306B # \u3067\u59CB\u307E\u308B\u540D\u524D\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+    }
     if (tok.kind === "IDENT" /* IDENT */ || tok.kind === "BIDENT" /* BIDENT */ || KEYWORDS.has(tok.value.toUpperCase())) {
       this.advance();
       return tok.value.toLowerCase();
@@ -1776,6 +1960,171 @@ function extractTableRef(name, tok) {
   return { appId: Number(m[1]), subtableCode: m[2] ?? null };
 }
 
+// src/core/dmlGuard.ts
+function getStatementType(stmt) {
+  if (!stmt || typeof stmt !== "object") return "UNKNOWN";
+  const obj = stmt;
+  return typeof obj.type === "string" ? obj.type : "UNKNOWN";
+}
+function isDmlType(type) {
+  return type === "INSERT" || type === "INSERT_SELECT" || type === "UPDATE" || type === "DELETE" || type === "UPSERT" || type === "UPSERT_SELECT" || type === "REORDER";
+}
+function isReadOnlyType(type) {
+  return type === "SELECT" || type === "UNION" || type === "WITH" || type === "EXPLAIN" || type === "SHOW_APPS" || type === "DESCRIBE" || type === "CREATE_TEMP_TABLE" || type === "DROP_TEMP_TABLE";
+}
+function hasWhereClause(stmt) {
+  if (!stmt || typeof stmt !== "object") return false;
+  const obj = stmt;
+  return obj.where !== null && obj.where !== void 0;
+}
+function isNoFromSelectStatement(stmt) {
+  if (!stmt || typeof stmt !== "object") return false;
+  const obj = stmt;
+  return obj.type === "SELECT" && obj.from?.appId === 0 && obj.from?.cteName === "__NO_FROM__";
+}
+function getInsertValuesCount(stmt) {
+  if (!stmt || typeof stmt !== "object") return null;
+  const obj = stmt;
+  if (obj.type !== "INSERT") return null;
+  return Array.isArray(obj.values) ? obj.values.length : null;
+}
+function collectDmlTargetFields(stmt) {
+  if (!stmt || typeof stmt !== "object") return [];
+  const obj = stmt;
+  if (!obj.type) return [];
+  if (obj.type === "UPDATE") {
+    return (obj.assignments ?? []).map((a) => a.field).filter((f) => Boolean(f));
+  }
+  if (obj.type === "INSERT" || obj.type === "INSERT_SELECT" || obj.type === "UPSERT" || obj.type === "UPSERT_SELECT") {
+    return [...obj.fields ?? [], ...obj.keyFields ?? []];
+  }
+  return [];
+}
+
+// src/core/batch.ts
+var MAX_TEMP_TABLES = 16;
+var BatchAnalysisError = class extends Error {
+  constructor(message, statementIndex) {
+    super(message);
+    this.statementIndex = statementIndex;
+  }
+};
+function collectRefs(node, tempRefs, appIds) {
+  if (Array.isArray(node)) {
+    for (const v of node) collectRefs(v, tempRefs, appIds);
+    return;
+  }
+  if (node !== null && typeof node === "object") {
+    const obj = node;
+    const cte = obj["cteName"];
+    if (typeof cte === "string" && cte.startsWith("#")) tempRefs.add(cte);
+    const appId = obj["appId"];
+    if (typeof appId === "number" && appId > 0) appIds.add(appId);
+    for (const v of Object.values(obj)) collectRefs(v, tempRefs, appIds);
+  }
+}
+function analyzeBatch(statements) {
+  if (statements.length === 0) {
+    throw new BatchAnalysisError("ArgumentError: SQL is empty.", 0);
+  }
+  if (statements.length === 1) {
+    const t = statements[0].type;
+    if (t === "CREATE_TEMP_TABLE" || t === "DROP_TEMP_TABLE") {
+      const verb = t === "CREATE_TEMP_TABLE" ? "CREATE TEMP TABLE" : "DROP TEMP TABLE";
+      throw new BatchAnalysisError(
+        `ArgumentError: ${verb} requires a batch (temp tables are batch-scoped).`,
+        0
+      );
+    }
+  }
+  const defined = /* @__PURE__ */ new Map();
+  const createdOrder = [];
+  const results = [];
+  statements.forEach((stmt, index) => {
+    const statementType = getStatementType(stmt);
+    const created = [];
+    const dropped = [];
+    const refs = /* @__PURE__ */ new Set();
+    const stmtAppIds = /* @__PURE__ */ new Set();
+    const dependsOn = /* @__PURE__ */ new Set();
+    if (stmt.type === "CREATE_TEMP_TABLE") {
+      collectRefs(stmt.query, refs, stmtAppIds);
+    } else if (stmt.type === "DROP_TEMP_TABLE") {
+    } else {
+      collectRefs(stmt, refs, stmtAppIds);
+    }
+    let tempOnlySource = false;
+    if (stmt.type === "INSERT_SELECT" || stmt.type === "UPSERT_SELECT") {
+      const srcTemp = /* @__PURE__ */ new Set();
+      const srcApps = /* @__PURE__ */ new Set();
+      collectRefs(stmt.select, srcTemp, srcApps);
+      tempOnlySource = srcTemp.size > 0 && srcApps.size === 0;
+    }
+    for (const name of refs) {
+      const at = defined.get(name);
+      if (at === void 0) {
+        throw new BatchAnalysisError(
+          `ParseError: temp table ${name} is not defined in this batch.`,
+          index
+        );
+      }
+      dependsOn.add(at);
+    }
+    if (stmt.type === "CREATE_TEMP_TABLE") {
+      if (defined.has(stmt.name)) {
+        throw new BatchAnalysisError(
+          `ParseError: temp table ${stmt.name} is already defined.`,
+          index
+        );
+      }
+      defined.set(stmt.name, index);
+      createdOrder.push(stmt.name);
+      created.push(stmt.name);
+      if (defined.size > MAX_TEMP_TABLES) {
+        throw new BatchAnalysisError(
+          `ParseError: batch exceeds ${MAX_TEMP_TABLES} temp tables.`,
+          index
+        );
+      }
+    }
+    if (stmt.type === "DROP_TEMP_TABLE") {
+      const at = defined.get(stmt.name);
+      if (at === void 0) {
+        throw new BatchAnalysisError(
+          `ParseError: temp table ${stmt.name} is not defined in this batch.`,
+          index
+        );
+      }
+      dependsOn.add(at);
+      dropped.push(stmt.name);
+      defined.delete(stmt.name);
+    }
+    results.push({
+      index,
+      statementType,
+      isDml: isDmlType(statementType),
+      isReadOnly: isReadOnlyType(statementType),
+      hasWhere: hasWhereClause(stmt),
+      insertValuesCount: getInsertValuesCount(stmt),
+      appIds: [...stmtAppIds].sort((a, b) => a - b),
+      tempTablesCreated: created,
+      tempTablesReferenced: [...refs],
+      tempTablesDropped: dropped,
+      dependsOn: [...dependsOn].sort((a, b) => a - b),
+      tempOnlySource,
+      targetAppId: isDmlType(statementType) && typeof stmt.appId === "number" ? stmt.appId : null
+    });
+  });
+  const containsDml = results.some((r) => r.isDml);
+  return {
+    statementCount: statements.length,
+    isReadOnlyBatch: !containsDml && results.every((r) => r.isReadOnly),
+    containsDml,
+    tempTables: createdOrder,
+    statements: results
+  };
+}
+
 // src/engine/pushDownNot.ts
 function pushDownNot(expr) {
   switch (expr.type) {
@@ -2804,23 +3153,31 @@ function resolveKintoneFunc(name) {
       return "";
   }
 }
+var likeRegexCache = /* @__PURE__ */ new Map();
+var LIKE_REGEX_CACHE_MAX = 200;
 function matchLike(value, pattern) {
   if (!pattern.includes("%") && !pattern.includes("_")) {
     return value.includes(pattern);
   }
-  let regexStr = "^";
-  for (let i = 0; i < pattern.length; i++) {
-    const ch = pattern[i];
-    if (ch === "%") {
-      regexStr += ".*";
-    } else if (ch === "_") {
-      regexStr += ".";
-    } else {
-      regexStr += ch.replace(/[.+*?^${}()|[\]\\]/g, "\\$&");
+  let regex = likeRegexCache.get(pattern);
+  if (!regex) {
+    let regexStr = "^";
+    for (let i = 0; i < pattern.length; i++) {
+      const ch = pattern[i];
+      if (ch === "%") {
+        regexStr += ".*";
+      } else if (ch === "_") {
+        regexStr += ".";
+      } else {
+        regexStr += ch.replace(/[.+*?^${}()|[\]\\]/g, "\\$&");
+      }
     }
+    regexStr += "$";
+    regex = new RegExp(regexStr, "u");
+    if (likeRegexCache.size >= LIKE_REGEX_CACHE_MAX) likeRegexCache.clear();
+    likeRegexCache.set(pattern, regex);
   }
-  regexStr += "$";
-  return new RegExp(regexStr, "u").test(value);
+  return regex.test(value);
 }
 
 // src/converter/dmlToKintone.ts
@@ -3248,10 +3605,12 @@ async function fetchPage(fetcher, app, query, fields, pageSize, offset) {
   return fetcher({ app, query: pageQuery, fields });
 }
 function buildCursorQuery(baseQuery, cursorId) {
-  if (cursorId <= 0) return baseQuery.trimEnd();
-  const cursor = `$id > ${cursorId} order by $id asc`;
   const base = baseQuery.trimEnd();
-  return base ? `${base} and ${cursor}` : cursor;
+  if (cursorId <= 0) {
+    return base ? `${base} order by $id asc` : "order by $id asc";
+  }
+  const cursor = `$id > ${cursorId} order by $id asc`;
+  return base ? `(${base}) and ${cursor}` : cursor;
 }
 function buildPageQuery(query, pageSize, offset) {
   const base = query.trimEnd();
@@ -3404,6 +3763,8 @@ function applyJoin(leftRows, rightRows, join2) {
     else rightIndex.set(k, [rRow]);
   }
   const result = [];
+  const emptyRight = {};
+  for (const key of Object.keys(rightRows[0] ?? {})) emptyRight[key] = "";
   for (const lRow of leftRows) {
     const k = lRow[leftKey] ?? "";
     const matched = rightIndex.get(k) ?? [];
@@ -3412,8 +3773,6 @@ function applyJoin(leftRows, rightRows, join2) {
         result.push({ ...lRow, ...rRow });
       }
     } else if (joinType === "LEFT") {
-      const emptyRight = {};
-      for (const key of Object.keys(rightRows[0] ?? {})) emptyRight[key] = "";
       result.push({ ...lRow, ...emptyRight });
     }
   }
@@ -3443,8 +3802,10 @@ function applyGroupBy(rows, groupByKeys, columns) {
     }
     for (const col of columns) {
       if (col.type === "AGGREGATE") {
-        const outputKey = col.alias ?? aggregateSyntheticName2(col.func, col.distinct, col.arg);
-        outRow[outputKey] = String(evalAggregate(col.func, col.distinct, col.arg, groupRows));
+        const syntheticKey = aggregateSyntheticName2(col.func, col.distinct, col.arg);
+        const value = String(evalAggregate(col.func, col.distinct, col.arg, groupRows));
+        outRow[col.alias ?? syntheticKey] = value;
+        if (col.alias) outRow[syntheticKey] = value;
       } else if (col.type === "ARITH_AGG_COL") {
         const outputKey = col.alias ?? aggArithDefaultKey(col.expr);
         outRow[outputKey] = String(evalAggArithExpr(col.expr, groupRows));
@@ -3489,12 +3850,23 @@ function evalAggregate(func, distinct, arg, rows) {
       return nums.reduce((a, b) => a + b, 0);
     case "AVG":
       return nums.length === 0 ? 0 : nums.reduce((a, b) => a + b, 0) / nums.length;
+    // Math.max(...nums) は要素数が多いと RangeError になるためループで求める
     case "MAX":
-      return nums.length === 0 ? 0 : Math.max(...nums);
+      return nums.length === 0 ? 0 : maxOf(nums);
     case "MIN":
-      return nums.length === 0 ? 0 : Math.min(...nums);
+      return nums.length === 0 ? 0 : minOf(nums);
   }
 }
+function maxOf(nums) {
+  let m = nums[0];
+  for (const n of nums) if (n > m) m = n;
+  return m;
+}
+function minOf(nums) {
+  let m = nums[0];
+  for (const n of nums) if (n < m) m = n;
+  return m;
+}
 function evalAggArithExpr(node, rows) {
   if (node.type === "NUMBER") return node.value;
   if (node.type === "AGG_REF") return evalAggregate(node.func, node.distinct, node.arg, rows);
@@ -3531,43 +3903,89 @@ function applyHaving(rows, having) {
   return rows.filter((row) => evalWhere(having, row));
 }
 function applyDistinct(rows, columns) {
+  if (rows.length === 0) return rows;
+  const keyFor = buildDistinctKeyBuilder(rows, columns);
   const seen = /* @__PURE__ */ new Set();
   return rows.filter((row) => {
-    const key = buildDistinctKey(row, columns);
+    const key = keyFor(row);
     if (seen.has(key)) return false;
     seen.add(key);
     return true;
   });
 }
-function buildDistinctKey(row, columns) {
+function buildDistinctKeyBuilder(rows, columns) {
   if (columns.some((c) => c.type === "WILDCARD")) {
-    return JSON.stringify(Object.entries(row).sort());
-  }
-  const values = [];
-  for (const col of columns) {
-    if (col.type === "FIELD") {
-      values.push(row[col.field] ?? "");
-      continue;
-    }
-    if (col.type === "PARENT_WILDCARD") {
-      for (const key of Object.keys(row).filter((k) => k.startsWith("_p.")).sort()) {
-        values.push(row[key] ?? "");
+    const allKeys = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      for (const k of Object.keys(row)) allKeys.add(k);
+    }
+    const keys = [...allKeys].sort();
+    return (row) => JSON.stringify(keys.map((k) => row[k] !== void 0 ? row[k] : null));
+  }
+  let sortedParentKeys = [];
+  if (columns.some((c) => c.type === "PARENT_WILDCARD")) {
+    const parentKeys = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      for (const k of Object.keys(row)) {
+        if (k.startsWith("_p.")) parentKeys.add(k);
       }
     }
+    sortedParentKeys = [...parentKeys].sort();
   }
-  return values.join("\0");
+  return (row) => {
+    const values = [];
+    for (const col of columns) {
+      if (col.type === "FIELD") {
+        values.push(row[col.field] ?? "");
+        continue;
+      }
+      if (col.type === "PARENT_WILDCARD") {
+        for (const k of sortedParentKeys) {
+          values.push(row[k] !== void 0 ? row[k] : null);
+        }
+      }
+    }
+    return JSON.stringify(values);
+  };
 }
 function applyOrderBy(rows, orderBy, optionOrders, sortKinds) {
   if (orderBy.length === 0) return rows;
-  return [...rows].sort((a, b) => {
-    for (const { key, direction } of orderBy) {
-      const av = evalOrderKey(key, a);
-      const bv = evalOrderKey(key, b);
-      const cmp = compareOrderValues(av, bv, key, optionOrders, sortKinds);
-      if (cmp !== 0) return direction === "ASC" ? cmp : -cmp;
+  const keyMeta = orderBy.map(({ key }) => ({
+    orderMap: key.type === "FIELD_NAME" ? optionOrders?.get(key.name) : void 0,
+    sortKind: key.type === "FIELD_NAME" ? sortKinds?.get(key.name) : void 0
+  }));
+  const decorated = rows.map((row) => ({
+    row,
+    keys: orderBy.map(({ key }, i) => {
+      const s = evalOrderKey(key, row);
+      const n = Number(s);
+      const orderMap = keyMeta[i].orderMap;
+      return {
+        s,
+        n,
+        isNum: !Number.isNaN(n),
+        rank: orderMap ? minChoiceIndex(parseChoiceValues(s), orderMap) : 0
+      };
+    })
+  }));
+  decorated.sort((a, b) => {
+    for (let i = 0; i < orderBy.length; i++) {
+      const cmp = compareSortKeys(a.keys[i], b.keys[i], keyMeta[i]);
+      if (cmp !== 0) return orderBy[i].direction === "ASC" ? cmp : -cmp;
     }
     return 0;
   });
+  return decorated.map((d) => d.row);
+}
+function compareSortKeys(a, b, meta) {
+  if (meta.orderMap) {
+    if (a.rank !== b.rank) return a.rank - b.rank;
+    return a.s.localeCompare(b.s, "ja");
+  }
+  if (meta.sortKind === "string") {
+    return a.s.localeCompare(b.s, "ja");
+  }
+  return a.isNum && b.isNum ? a.n - b.n : a.s.localeCompare(b.s, "ja");
 }
 function evalOrderKey(key, row) {
   switch (key.type) {
@@ -3579,32 +3997,6 @@ function evalOrderKey(key, row) {
       return evalStringFunc(key.expr, row);
   }
 }
-function compareOrderValues(av, bv, key, optionOrders, sortKinds) {
-  if (key.type === "FIELD_NAME") {
-    const orderMap = optionOrders?.get(key.name);
-    if (orderMap) {
-      const ac = compareByChoiceOrder(av, bv, orderMap);
-      if (ac !== 0) return ac;
-      return av.localeCompare(bv, "ja");
-    }
-    const sortKind = sortKinds?.get(key.name);
-    if (sortKind === "number") {
-      return compareAsNumber(av, bv);
-    }
-    if (sortKind === "string") {
-      return av.localeCompare(bv, "ja");
-    }
-  }
-  return compareAuto(av, bv);
-}
-function compareByChoiceOrder(av, bv, orderMap) {
-  const aValues = parseChoiceValues(av);
-  const bValues = parseChoiceValues(bv);
-  const aRank = minChoiceIndex(aValues, orderMap);
-  const bRank = minChoiceIndex(bValues, orderMap);
-  if (aRank !== bRank) return aRank - bRank;
-  return 0;
-}
 function parseChoiceValues(raw) {
   const trimmed = raw.trim();
   if (trimmed === "") return [""];
@@ -3628,18 +4020,6 @@ function minChoiceIndex(values, orderMap) {
   }
   return min;
 }
-function compareAsNumber(av, bv) {
-  const an = Number(av);
-  const bn = Number(bv);
-  const numeric = !Number.isNaN(an) && !Number.isNaN(bn);
-  return numeric ? an - bn : av.localeCompare(bv, "ja");
-}
-function compareAuto(av, bv) {
-  const an = Number(av);
-  const bn = Number(bv);
-  const numeric = !Number.isNaN(an) && !Number.isNaN(bn);
-  return numeric ? an - bn : av.localeCompare(bv, "ja");
-}
 function applyLimit(rows, limit, offset) {
   const start = offset ?? 0;
   if (limit === null) return rows.slice(start);
@@ -3884,8 +4264,61 @@ function toFlatString(value) {
 
 // src/execute.ts
 async function execute(sql, client, options = {}) {
+  const metrics = createEmptyMetrics();
+  const countedClient = wrapClientWithMetrics(client, metrics);
+  const startedAt = Date.now();
+  const result = await executeStatement(sql, countedClient, options);
+  metrics.elapsedMs = Date.now() - startedAt;
+  return { ...result, metrics };
+}
+function createEmptyMetrics() {
+  return {
+    getCalls: 0,
+    postCalls: 0,
+    putCalls: 0,
+    deleteCalls: 0,
+    fieldCalls: 0,
+    appsCalls: 0,
+    fetchedRows: 0,
+    elapsedMs: 0
+  };
+}
+function wrapClientWithMetrics(client, metrics) {
+  return {
+    getRecords: async (params) => {
+      metrics.getCalls += 1;
+      const res = await client.getRecords(params);
+      metrics.fetchedRows += res.records.length;
+      return res;
+    },
+    postRecords: (params) => {
+      metrics.postCalls += 1;
+      return client.postRecords(params);
+    },
+    putRecords: (params) => {
+      metrics.putCalls += 1;
+      return client.putRecords(params);
+    },
+    deleteRecords: (params) => {
+      metrics.deleteCalls += 1;
+      return client.deleteRecords(params);
+    },
+    getApps: () => {
+      metrics.appsCalls += 1;
+      return client.getApps();
+    },
+    getFields: (appId) => {
+      metrics.fieldCalls += 1;
+      return client.getFields(appId);
+    }
+  };
+}
+async function executeStatement(sql, client, options) {
   const cacheContext = options.cacheContext ?? "default";
   const stmt = parseSql(sql);
+  return executeParsedStatement(stmt, client, options, cacheContext);
+}
+async function executeParsedStatement(stmt, client, options, cacheContext) {
   switch (stmt.type) {
     case "SELECT":
       return executeSelect(stmt, client, options, cacheContext);
@@ -3894,7 +4327,7 @@ async function execute(sql, client, options = {}) {
     case "WITH":
       return executeWith(stmt, client, options, cacheContext);
     case "INSERT":
-      return executeInsert(stmt, client, cacheContext);
+      return executeInsert(stmt, client, options, cacheContext);
     case "INSERT_SELECT":
       return executeInsertSelect(stmt, client, options, cacheContext);
     case "UPSERT":
@@ -3913,9 +4346,181 @@ async function execute(sql, client, options = {}) {
       return executeDescribe(stmt, client, cacheContext);
     case "EXPLAIN":
       return executeExplain(stmt);
+    // 一時テーブルはバッチスコープのため単文実行では拒否する（executeBatch を使う）
+    case "CREATE_TEMP_TABLE":
+      throw new Error("ArgumentError: CREATE TEMP TABLE requires a batch (temp tables are batch-scoped).");
+    case "DROP_TEMP_TABLE":
+      throw new Error("ArgumentError: DROP TEMP TABLE requires a batch (temp tables are batch-scoped).");
+  }
+}
+var TEMP_TABLE_MAX_ROWS = 1e4;
+var BatchTimeoutError = class extends Error {
+  constructor() {
+    super("TimeoutError: batch timeout exceeded.");
+  }
+};
+async function executeBatch(sql, client, options = {}) {
+  const statements = parseSqlBatch(sql);
+  const analysis = analyzeBatch(statements);
+  if (options.continueOnError && analysis.containsDml) {
+    throw new Error("ArgumentError: continueOnError is not allowed for batches containing DML.");
+  }
+  for (const s of analysis.statements) {
+    if (!s.isDml || s.tempTablesReferenced.length === 0) continue;
+    if (s.statementType === "INSERT_SELECT" && s.tempOnlySource) continue;
+    throw new BatchAnalysisError(
+      s.statementType === "INSERT_SELECT" ? `ArgumentError: INSERT_SELECT in a batch must select from temp tables only. (statement ${s.index})` : `ArgumentError: temp table references in ${s.statementType} are not supported yet.`,
+      s.index
+    );
+  }
+  const metrics = createEmptyMetrics();
+  const countedClient = wrapClientWithMetrics(client, metrics);
+  const startedAt = Date.now();
+  const deadline = options.timeoutMs != null ? startedAt + options.timeoutMs : null;
+  const cacheContext = options.cacheContext ?? "default";
+  const tempTables = /* @__PURE__ */ new Map();
+  const results = [];
+  const failed = /* @__PURE__ */ new Set();
+  let aborted = null;
+  for (let i = 0; i < statements.length; i++) {
+    const info = analysis.statements[i];
+    const base = { index: i, type: info.statementType };
+    if (aborted) {
+      results.push({ ...base, status: "skipped", skippedReason: aborted });
+      failed.add(i);
+      continue;
+    }
+    const brokenDep = info.dependsOn.find((d) => failed.has(d));
+    if (brokenDep !== void 0) {
+      const depName = analysis.statements[brokenDep].tempTablesCreated[0] ?? `statement ${brokenDep}`;
+      results.push({ ...base, status: "skipped", skippedReason: `dependency: ${depName}` });
+      failed.add(i);
+      continue;
+    }
+    if (deadline !== null && Date.now() >= deadline) {
+      results.push({ ...base, status: "skipped", skippedReason: "timeout" });
+      failed.add(i);
+      aborted = "timeout";
+      continue;
+    }
+    try {
+      const remaining = deadline !== null ? deadline - Date.now() : null;
+      const outcome = await runWithDeadline(
+        executeBatchStatement(statements[i], info, countedClient, options, cacheContext, tempTables),
+        remaining
+      );
+      results.push({ ...base, status: "success", ...outcome });
+    } catch (e) {
+      results.push({ ...base, status: "error", error: toBatchStatementError(e) });
+      failed.add(i);
+      if (e instanceof BatchTimeoutError) {
+        aborted = "timeout";
+      } else if (!options.continueOnError) {
+        aborted = "fail-fast";
+      }
+    }
+  }
+  metrics.elapsedMs = Date.now() - startedAt;
+  return {
+    ok: results.every((r) => r.status === "success"),
+    statementCount: statements.length,
+    statements: results,
+    analysis,
+    metrics
+  };
+}
+async function executeBatchStatement(stmt, info, client, options, cacheContext, tempTables) {
+  if (stmt.type === "CREATE_TEMP_TABLE") {
+    const materializeOptions = {
+      ...options,
+      maxRecords: options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
+      onLimitReached: "error"
+    };
+    const result = await runSelectLike(stmt.query, client, materializeOptions, cacheContext, tempTables);
+    tempTables.set(stmt.name, result.rows);
+    return { tempTable: stmt.name, rowCount: result.rows.length };
+  }
+  if (stmt.type === "DROP_TEMP_TABLE") {
+    tempTables.delete(stmt.name);
+    return { tempTable: stmt.name };
   }
+  if (stmt.type === "EXPLAIN") {
+    return { result: await executeParsedStatement(stmt, client, options, cacheContext) };
+  }
+  if (info.tempTablesReferenced.length > 0) {
+    if (stmt.type === "SELECT" || stmt.type === "UNION") {
+      return { result: await executeQueryWithCte(stmt, client, options, tempTables, cacheContext) };
+    }
+    if (stmt.type === "WITH") {
+      return { result: await executeWith(stmt, client, options, cacheContext, tempTables) };
+    }
+    if (stmt.type === "INSERT_SELECT") {
+      return { result: await executeInsertSelect(stmt, client, options, cacheContext, tempTables) };
+    }
+    throw new Error(`ArgumentError: temp table references in ${stmt.type} are not supported yet.`);
+  }
+  return { result: await executeParsedStatement(stmt, client, options, cacheContext) };
+}
+async function runSelectLike(query, client, options, cacheContext, tempTables) {
+  if (query.type === "WITH") {
+    return executeWith(query, client, options, cacheContext, tempTables);
+  }
+  return executeQueryWithCte(query, client, options, tempTables, cacheContext);
+}
+async function runWithDeadline(work, remainingMs) {
+  if (remainingMs === null) return work;
+  if (remainingMs <= 0) {
+    void work.catch(() => {
+    });
+    throw new BatchTimeoutError();
+  }
+  let timer;
+  try {
+    return await Promise.race([
+      work,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new BatchTimeoutError()), remainingMs);
+      })
+    ]);
+  } catch (e) {
+    if (e instanceof BatchTimeoutError) {
+      void work.catch(() => {
+      });
+    }
+    throw e;
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+function toBatchStatementError(e) {
+  if (e instanceof Error) {
+    const name = e.name !== "Error" ? e.name : null;
+    return { code: name ?? codeFromMessagePrefix(e.message), message: e.message };
+  }
+  if (e !== null && typeof e === "object") {
+    const obj = e;
+    const message2 = typeof obj.message === "string" && obj.message.length > 0 ? obj.message : safeJsonStringify(e);
+    const code = typeof obj.code === "string" && obj.code.length > 0 ? obj.code : codeFromMessagePrefix(message2);
+    return { code, message: message2 };
+  }
+  const message = String(e);
+  return { code: codeFromMessagePrefix(message), message };
+}
+function codeFromMessagePrefix(message) {
+  return message.match(/^([A-Za-z]+Error):/)?.[1] ?? "Error";
+}
+function safeJsonStringify(v) {
+  try {
+    return JSON.stringify(v) ?? String(v);
+  } catch {
+    return String(v);
+  }
+}
+function parseSqlBatch(sql) {
+  const tokens = new Lexer(sql).tokenize();
+  return new Parser(tokens).parseStatements();
 }
-async function executeSelect(stmt, client, options, cacheContext) {
+async function executeSelect(stmt, client, options, cacheContext, cteCache) {
   if (isNoFromSelect(stmt)) {
     return executeNoFromSelect(stmt);
   }
@@ -3924,7 +4529,7 @@ async function executeSelect(stmt, client, options, cacheContext) {
   if (mode === "SIMPLE") {
     return executeSimpleSelect(stmt, client, options, cacheContext);
   } else {
-    return executeFullScanSelect(stmt, client, options, cacheContext);
+    return executeFullScanSelect(stmt, client, options, cacheContext, cteCache);
   }
 }
 function isNoFromSelect(stmt) {
@@ -4009,8 +4614,7 @@ async function executeSimpleSelect(stmt, client, options, cacheContext) {
   }
   let rows = records.map((r) => flatten(r, null));
   if (!useSingleGet) {
-    const optionOrders = await buildOptionOrdersForSelect(stmt, client, cacheContext);
-    const sortKinds = await buildSortKindsForSelect(stmt, client, cacheContext);
+    const { optionOrders, sortKinds } = await buildOrderByMetaForSelect(stmt, client, cacheContext);
     rows = applyOrderBy(rows, stmt.orderBy, optionOrders, sortKinds);
     rows = applyLimit(rows, stmt.limit, stmt.offset);
   }
@@ -4038,22 +4642,25 @@ async function validateSelectFieldCodes(stmt, mode, client, cacheContext) {
     }
   }
   for (const [appId, fields] of appToFields.entries()) {
-    if (fields.size === 0) continue;
+    const userFields = [...fields].filter((f) => !isSystemLikeFieldCode(f));
+    if (userFields.length === 0) continue;
     const defs = await getFieldsCached(appId, client, cacheContext);
     if (defs.length === 0) continue;
     const validCodes = new Set(defs.map((d) => d.code));
-    const unknown = [...fields].filter((f) => !isSystemLikeFieldCode(f) && !validCodes.has(f));
+    const unknown = userFields.filter((f) => !validCodes.has(f));
     if (unknown.length > 0) {
       throw new Error(`ArgumentError: unknown field code(s): ${unknown.join(", ")} (APP${appId})`);
     }
   }
 }
-async function executeFullScanSelect(stmt, client, options, cacheContext) {
+async function executeFullScanSelect(stmt, client, options, cacheContext, cteCache) {
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
   const parallel = options.fetchParallel ?? 1;
-  await resolveSubqueries(stmt.where, client, options, cacheContext);
-  await resolveSubqueries(stmt.having, client, options, cacheContext);
+  await Promise.all([
+    resolveSubqueries(stmt.where, client, options, cacheContext, cteCache),
+    resolveSubqueries(stmt.having, client, options, cacheContext, cteCache)
+  ]);
   const tableConditions = /* @__PURE__ */ new Map();
   if (stmt.where !== null) {
     if (stmt.from.alias) {
@@ -4102,6 +4709,12 @@ async function executeFullScanSelect(stmt, client, options, cacheContext) {
       onOptJoins.push(join2);
     }
   }
+  const scalarCachePromise = resolveScalarColumns(stmt.columns, client, options, cacheContext, cteCache);
+  const orderByMetaPromise = buildOrderByMetaForSelect(stmt, client, cacheContext);
+  scalarCachePromise.catch(() => {
+  });
+  orderByMetaPromise.catch(() => {
+  });
   const mainRecords = await mainFetch;
   const tables = /* @__PURE__ */ new Map();
   tables.set(stmt.from.alias, mainRecords);
@@ -4133,15 +4746,16 @@ async function executeFullScanSelect(stmt, client, options, cacheContext) {
     );
     tables.set(join2.table.alias, joinRecords);
   }));
-  const scalarCache = await resolveScalarColumns(stmt.columns, client, options, cacheContext);
-  const optionOrders = await buildOptionOrdersForSelect(stmt, client, cacheContext);
-  const sortKinds = await buildSortKindsForSelect(stmt, client, cacheContext);
+  const scalarCache = await scalarCachePromise;
+  const { optionOrders, sortKinds } = await orderByMetaPromise;
   const { rows, columns } = runFullScan({ tables, stmt, scalarCache, optionOrders, sortKinds });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
 async function executeUnion(stmt, client, options, cacheContext) {
-  const leftResult = stmt.left.type === "UNION" ? await executeUnion(stmt.left, client, options, cacheContext) : await executeSelect(stmt.left, client, options, cacheContext);
-  const rightResult = await executeSelect(stmt.right, client, options, cacheContext);
+  const [leftResult, rightResult] = await Promise.all([
+    stmt.left.type === "UNION" ? executeUnion(stmt.left, client, options, cacheContext) : executeSelect(stmt.left, client, options, cacheContext),
+    executeSelect(stmt.right, client, options, cacheContext)
+  ]);
   const leftCols = leftResult.columns;
   const rightCols = rightResult.columns;
   const remappedRight = rightResult.rows.map((row) => {
@@ -4158,17 +4772,17 @@ async function executeUnion(stmt, client, options, cacheContext) {
 function deduplicateRows(rows, columns) {
   const seen = /* @__PURE__ */ new Set();
   return rows.filter((row) => {
-    const key = columns.map((c) => row[c] ?? "").join("\0");
+    const key = JSON.stringify(columns.map((c) => row[c] ?? ""));
     if (seen.has(key)) return false;
     seen.add(key);
     return true;
   });
 }
-async function executeWith(stmt, client, options, cacheContext) {
-  if (canInlineSingleCte(stmt)) {
+async function executeWith(stmt, client, options, cacheContext, seed) {
+  if ((seed == null || seed.size === 0) && canInlineSingleCte(stmt)) {
     return executeSelect(buildInlinedQuery(stmt), client, options, cacheContext);
   }
-  const cteCache = /* @__PURE__ */ new Map();
+  const cteCache = new Map(seed ?? []);
   for (const cte of stmt.ctes) {
     let result;
     if (cte.query.type === "SHOW_APPS") {
@@ -4261,8 +4875,10 @@ function stripCteAliasFromFieldValue(fv, alias) {
 }
 async function executeQueryWithCte(query, client, options, cteCache, cacheContext) {
   if (query.type === "UNION") {
-    const leftResult = await executeQueryWithCte(query.left, client, options, cteCache, cacheContext);
-    const rightResult = await executeQueryWithCte(query.right, client, options, cteCache, cacheContext);
+    const [leftResult, rightResult] = await Promise.all([
+      executeQueryWithCte(query.left, client, options, cteCache, cacheContext),
+      executeQueryWithCte(query.right, client, options, cteCache, cacheContext)
+    ]);
     const leftCols = leftResult.columns;
     const rightCols = rightResult.columns;
     const remapped = rightResult.rows.map((row) => {
@@ -4278,7 +4894,7 @@ async function executeQueryWithCte(query, client, options, cteCache, cacheContex
   }
   const hasCteRef = query.from.cteName != null || query.joins.some((j) => j.table.cteName != null);
   if (!hasCteRef) {
-    return executeSelect(query, client, options, cacheContext);
+    return executeSelect(query, client, options, cacheContext, cteCache);
   }
   return executeFullScanWithCte(query, client, options, cteCache, cacheContext);
 }
@@ -4286,9 +4902,17 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
   const parallel = options.fetchParallel ?? 1;
-  await resolveSubqueries(stmt.where, client, options, cacheContext);
-  await resolveSubqueries(stmt.having, client, options, cacheContext);
-  const tables = /* @__PURE__ */ new Map();
+  await Promise.all([
+    resolveSubqueries(stmt.where, client, options, cacheContext, cteCache),
+    resolveSubqueries(stmt.having, client, options, cacheContext, cteCache)
+  ]);
+  const scalarCachePromise = resolveScalarColumns(stmt.columns, client, options, cacheContext, cteCache);
+  const orderByMetaPromise = buildOrderByMetaForSelect(stmt, client, cacheContext);
+  scalarCachePromise.catch(() => {
+  });
+  orderByMetaPromise.catch(() => {
+  });
+  const tables = /* @__PURE__ */ new Map();
   if (stmt.from.cteName != null) {
     const rows2 = cteCache.get(stmt.from.cteName) ?? [];
     tables.set(stmt.from.alias, rows2.map(processRowToKintoneRecord));
@@ -4334,9 +4958,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     }
   });
   await Promise.all(joinFetches);
-  const scalarCache = await resolveScalarColumns(stmt.columns, client, options, cacheContext);
-  const optionOrders = await buildOptionOrdersForSelect(stmt, client, cacheContext);
-  const sortKinds = await buildSortKindsForSelect(stmt, client, cacheContext);
+  const scalarCache = await scalarCachePromise;
+  const { optionOrders, sortKinds } = await orderByMetaPromise;
   const { rows, columns } = runFullScan({ tables, stmt, scalarCache, optionOrders, sortKinds });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
@@ -4372,6 +4995,78 @@ async function fetchTableRecordsForFullScan(stmt, table, client, maxRecords, par
   const parentRecords = parentResolved.records;
   return expandSubtableRecords(parentRecords, table.subtableCode);
 }
+var UPSERT_IN_CHUNK_SIZE = 50;
+function normalizeKeyPart(v) {
+  const t = v.trim();
+  if (t !== "" && !Number.isNaN(Number(t))) return String(Number(t));
+  return v;
+}
+function upsertCompositeKey(parts) {
+  return JSON.stringify(parts);
+}
+function upsertNormalizedKey(parts, numericKey) {
+  return JSON.stringify(parts.map((p, i) => numericKey[i] ? normalizeKeyPart(p) : p));
+}
+function lookupUpsertTarget(index, keyParts) {
+  const exact = index.raw.get(upsertCompositeKey(keyParts));
+  if (exact !== void 0) return exact;
+  if (!index.numericKey.some(Boolean)) return void 0;
+  return index.normalized.get(upsertNormalizedKey(keyParts, index.numericKey));
+}
+async function resolveUpsertTargets(appId, keyFields, rowKeyValues, client, options, fieldTypes) {
+  const maxRecords = options.maxRecords ?? 1e4;
+  const parallel = options.fetchParallel ?? 1;
+  const numericKey = keyFields.map((f) => fieldTypes.get(f) === "NUMBER");
+  const index = { raw: /* @__PURE__ */ new Map(), normalized: /* @__PURE__ */ new Map(), numericKey };
+  const setMax = (map, key, id) => {
+    const cur = map.get(key);
+    if (cur === void 0 || id > cur) map.set(key, id);
+  };
+  const addRecordToIndex = (parts, id) => {
+    setMax(index.raw, upsertCompositeKey(parts), id);
+    if (numericKey.some(Boolean)) {
+      setMax(index.normalized, upsertNormalizedKey(parts, numericKey), id);
+    }
+  };
+  const batchFirstKeys = /* @__PURE__ */ new Set();
+  const perRowKeys = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const parts of rowKeyValues) {
+    const composite = upsertCompositeKey(parts);
+    if (seen.has(composite)) continue;
+    seen.add(composite);
+    if (parts.some((p) => p === "")) perRowKeys.push(parts);
+    else batchFirstKeys.add(parts[0]);
+  }
+  const fields = ["$id", ...keyFields];
+  for (const chunk2 of splitChunks([...batchFirstKeys], UPSERT_IN_CHUNK_SIZE)) {
+    const query = `${keyFields[0]} in (${chunk2.map(sqlQuote).join(",")})`;
+    const records = await fetchAll(client.getRecords, appId, query, fields, { maxRecords, parallel });
+    for (const rec of records) {
+      const id = Number(rec["$id"]?.value);
+      if (!Number.isFinite(id)) continue;
+      addRecordToIndex(keyFields.map((f) => toScalarText(rec[f]?.value)), id);
+    }
+  }
+  for (const parts of perRowKeys) {
+    const query = keyFields.map((f, i) => `${f} = ${sqlQuote(parts[i])}`).join(" and ");
+    const existing = await fetchAll(client.getRecords, appId, query, ["$id"], { maxRecords, parallel });
+    if (existing.length === 0) continue;
+    addRecordToIndex(parts, maxRecordId(existing));
+  }
+  return index;
+}
+function maxRecordId(records) {
+  let max = Number.NEGATIVE_INFINITY;
+  for (const r of records) {
+    const n = Number(r["$id"]?.value);
+    if (Number.isFinite(n) && n > max) max = n;
+  }
+  if (!Number.isFinite(max)) {
+    throw new Error("\u30EC\u30B3\u30FC\u30C9\u306B\u6570\u5024\u306E $id \u304C\u542B\u307E\u308C\u3066\u3044\u307E\u305B\u3093\u3002");
+  }
+  return max;
+}
 function toScalarText(value) {
   if (typeof value === "string") return value;
   if (value === null || value === void 0) return "";
@@ -4509,6 +5204,16 @@ async function getSortKindMapByApp(appId, client, cacheContext) {
   setScopedCacheValue(sortKindCache, cacheContext, appId, map);
   return map;
 }
+async function buildOrderByMetaForSelect(stmt, client, cacheContext) {
+  if (stmt.orderBy.length === 0) {
+    return { optionOrders: /* @__PURE__ */ new Map(), sortKinds: /* @__PURE__ */ new Map() };
+  }
+  const [optionOrders, sortKinds] = await Promise.all([
+    buildOptionOrdersForSelect(stmt, client, cacheContext),
+    buildSortKindsForSelect(stmt, client, cacheContext)
+  ]);
+  return { optionOrders, sortKinds };
+}
 async function buildOptionOrdersForSelect(stmt, client, cacheContext) {
   const optionOrders = /* @__PURE__ */ new Map();
   const tables = [stmt.from, ...stmt.joins.map((j) => j.table)];
@@ -4582,9 +5287,9 @@ function convertProcessRowValue(raw, dstFieldType) {
   }
   return raw;
 }
-async function executeInsert(stmt, client, cacheContext) {
+async function executeInsert(stmt, client, options, cacheContext) {
   if (stmt.subtableCode) {
-    return executeInsertSubtable(stmt, client, cacheContext);
+    return executeInsertSubtable(stmt, client, options, cacheContext);
   }
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
   const batches = insertToPostBatches(stmt, fieldTypes);
@@ -4599,14 +5304,18 @@ async function executeInsert(stmt, client, cacheContext) {
     insertedCount: createdIds.flat().length
   };
 }
-async function executeInsertSelect(stmt, client, options, cacheContext) {
-  const selectResult = await executeSelect(stmt.select, client, options, cacheContext);
+async function executeInsertSelect(stmt, client, options, cacheContext, cteCache) {
+  const selectResult = cteCache !== void 0 && cteCache.size > 0 ? await executeQueryWithCte(stmt.select, client, options, cteCache, cacheContext) : await executeSelect(stmt.select, client, options, cacheContext);
   const { rows, columns } = selectResult;
   if (columns.length !== stmt.fields.length) {
     throw new Error(
       `SELECT \u306E\u5217\u6570\uFF08${columns.length}\uFF09\u3068 INSERT \u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u6570\uFF08${stmt.fields.length}\uFF09\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093`
     );
   }
+  if (options.confirm) {
+    const ok = await options.confirm(rows.length, "INSERT");
+    if (!ok) throw new OperationCancelledError("INSERT", rows.length);
+  }
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
   const allRecords = rows.map((row) => {
     const record = {};
@@ -4699,26 +5408,19 @@ async function executeDelete(stmt, client, options, cacheContext) {
   return { type: "DELETE", deletedCount: ids.length };
 }
 async function executeUpsert(stmt, client, options, cacheContext) {
-  const maxRecords = options.maxRecords ?? 1e4;
   const toInsert = [];
   const toUpdate = [];
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
-  for (const row of stmt.values) {
-    const keyConditions = stmt.keyFields.map((key) => {
+  const rowKeyValues = stmt.values.map(
+    (row) => stmt.keyFields.map((key) => {
       const idx = stmt.fields.indexOf(key);
       if (idx === -1) throw new Error(`ON DUPLICATE \u306E\u30AD\u30FC\u300C${key}\u300D\u304C INSERT \u30D5\u30A3\u30FC\u30EB\u30C9\u306B\u542B\u307E\u308C\u3066\u3044\u307E\u305B\u3093`);
       const val = row[idx];
-      const valStr = val.type === "STRING" ? val.value : val.type === "NUMBER" ? String(val.value) : val.type === "CASE_VALUE" ? evalCaseWhen(val.expr, {}) : val.elements.map((e) => e.value).join(",");
-      return `${key} = "${valStr.replace(/"/g, '\\"')}"`;
-    });
-    const query = keyConditions.join(" and ");
-    const existing = await fetchAll(
-      client.getRecords,
-      stmt.appId,
-      query,
-      ["$id"],
-      { maxRecords, parallel: options.fetchParallel ?? 1 }
-    );
+      return val.type === "STRING" ? val.value : val.type === "NUMBER" ? String(val.value) : val.type === "CASE_VALUE" ? evalCaseWhen(val.expr, {}) : val.elements.map((e) => e.value).join(",");
+    })
+  );
+  const targetIndex = await resolveUpsertTargets(stmt.appId, stmt.keyFields, rowKeyValues, client, options, fieldTypes);
+  stmt.values.forEach((row, rowIdx) => {
     const record = {};
     stmt.fields.forEach((field, i) => {
       const val = row[i];
@@ -4728,13 +5430,13 @@ async function executeUpsert(stmt, client, options, cacheContext) {
         record[field] = { value: toKintoneValue(val, fieldTypes.get(field)) };
       }
     });
-    if (existing.length > 0) {
-      const id = Number(existing[0]["$id"].value);
+    const id = lookupUpsertTarget(targetIndex, rowKeyValues[rowIdx]);
+    if (id !== void 0) {
       toUpdate.push({ id, record });
     } else {
       toInsert.push(record);
     }
-  }
+  });
   if (options.confirm && toInsert.length + toUpdate.length > 0) {
     const total = toInsert.length + toUpdate.length;
     const ok = await options.confirm(total, "UPDATE");
@@ -4754,18 +5456,17 @@ async function executeUpsert(stmt, client, options, cacheContext) {
     updatedCount: toUpdate.length
   };
 }
-async function executeInsertSubtable(stmt, client, _cacheContext) {
+async function executeInsertSubtable(stmt, client, options, _cacheContext) {
   const subtableCode = stmt.subtableCode;
   const pidIndex = stmt.fields.indexOf("_pid");
   if (pidIndex < 0) {
     throw new Error("\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB INSERT \u306B\u306F _pid \u304C\u5FC5\u9808\u3067\u3059");
   }
-  const parents = await fetchAll(client.getRecords, stmt.appId, "", [], { maxRecords: 1e4, parallel: 1 });
-  const parentMap = /* @__PURE__ */ new Map();
-  for (const p of parents) {
-    const pid = String(p["$id"]?.value ?? "");
-    if (pid) parentMap.set(pid, p);
-  }
+  const parents = await fetchAll(client.getRecords, stmt.appId, "", [], {
+    maxRecords: options.maxRecords ?? 1e4,
+    parallel: options.fetchParallel ?? 1
+  });
+  const parentMap = buildParentIdMap(parents);
   const insertsByParent = /* @__PURE__ */ new Map();
   for (const rowValues of stmt.values) {
     const pid = valueToString(rowValues[pidIndex]);
@@ -4832,8 +5533,9 @@ async function executeUpdateSubtable(stmt, client, options, _cacheContext) {
     }
     byRid.set(t.rowId, updates);
   }
+  const parentById = buildParentIdMap(parents);
   for (const [pid, updateMap] of updatesByParent.entries()) {
-    const parent = parents.find((p) => String(p["$id"]?.value ?? "") === pid);
+    const parent = parentById.get(pid);
     if (!parent) continue;
     const currentRows = getMutableTableRows(parent, subtableCode);
     const payloadRows = currentRows.map((row) => {
@@ -4873,8 +5575,9 @@ async function executeDeleteSubtable(stmt, client, options, _cacheContext) {
     if (bucket) bucket.push(t.rowIndex);
     else byParent.set(t.parentId, [t.rowIndex]);
   }
+  const parentById = buildParentIdMap(parents);
   for (const [pid, idxs] of byParent.entries()) {
-    const parent = parents.find((p) => String(p["$id"]?.value ?? "") === pid);
+    const parent = parentById.get(pid);
     if (!parent) continue;
     const rows = getMutableTableRows(parent, subtableCode);
     const rm = new Set(idxs);
@@ -4883,6 +5586,14 @@ async function executeDeleteSubtable(stmt, client, options, _cacheContext) {
   }
   return { type: "DELETE", deletedCount: targets.length };
 }
+function buildParentIdMap(parents) {
+  const map = /* @__PURE__ */ new Map();
+  for (const p of parents) {
+    const pid = String(p["$id"]?.value ?? "");
+    if (pid) map.set(pid, p);
+  }
+  return map;
+}
 function expandRowsForSubtableDml(parents, subtableCode) {
   const out = [];
   for (const parent of parents) {
@@ -5018,8 +5729,9 @@ async function executeReorder(stmt, client, options, _cacheContext) {
     const ok = await options.confirm(targetParentIds.size, "UPDATE");
     if (!ok) throw new OperationCancelledError("UPDATE", targetParentIds.size);
   }
+  const parentById = buildParentIdMap(parents);
   for (const pid of targetParentIds) {
-    const parent = parents.find((p) => String(p["$id"]?.value ?? "") === pid);
+    const parent = parentById.get(pid);
     if (!parent) continue;
     const rows = getMutableTableRows(parent, stmt.subtableCode);
     const sortable = rows.map((row, i) => ({ row, i, flat: buildFlatRowForSort(parent, stmt.subtableCode, row, i) }));
@@ -5067,7 +5779,6 @@ function evalOrderKeyForRow(key, row) {
   }
 }
 async function executeUpsertSelect(stmt, client, options, cacheContext) {
-  const maxRecords = options.maxRecords ?? 1e4;
   const selectResult = await executeSelect(stmt.select, client, options, cacheContext);
   const { rows, columns } = selectResult;
   if (columns.length !== stmt.fields.length) {
@@ -5082,29 +5793,26 @@ async function executeUpsertSelect(stmt, client, options, cacheContext) {
   }
   const toInsert = [];
   const toUpdate = [];
-  for (const row of rows) {
+  const records = rows.map((row) => {
     const record = {};
     stmt.fields.forEach((field, i) => {
       record[field] = { value: row[columns[i]] ?? "" };
     });
-    const keyConditions = stmt.keyFields.map((key) => {
-      const val = String(record[key]?.value ?? "");
-      return `${key} = "${val.replace(/"/g, '\\"')}"`;
-    });
-    const query = keyConditions.join(" and ");
-    const existing = await fetchAll(
-      client.getRecords,
-      stmt.appId,
-      query,
-      ["$id"],
-      { maxRecords, parallel: options.fetchParallel ?? 1 }
-    );
-    if (existing.length > 0) {
-      toUpdate.push({ id: Number(existing[0]["$id"].value), record });
+    return record;
+  });
+  const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
+  const rowKeyValues = records.map(
+    (record) => stmt.keyFields.map((key) => String(record[key]?.value ?? ""))
+  );
+  const targetIndex = await resolveUpsertTargets(stmt.appId, stmt.keyFields, rowKeyValues, client, options, fieldTypes);
+  records.forEach((record, rowIdx) => {
+    const id = lookupUpsertTarget(targetIndex, rowKeyValues[rowIdx]);
+    if (id !== void 0) {
+      toUpdate.push({ id, record });
     } else {
       toInsert.push(record);
     }
-  }
+  });
   if (options.confirm && toInsert.length + toUpdate.length > 0) {
     const total = toInsert.length + toUpdate.length;
     const ok = await options.confirm(total, "UPDATE");
@@ -5155,37 +5863,51 @@ function parseSql(sql) {
     throw e;
   }
 }
-async function resolveSubqueries(where, client, options, cacheContext) {
+async function resolveSubqueries(where, client, options, cacheContext, cteCache) {
+  const tasks = [];
+  collectSubqueryTasks(where, client, options, cacheContext, tasks, cteCache);
+  await Promise.all(tasks);
+}
+function runSubquery(query, client, options, cacheContext, cteCache) {
+  if (cteCache !== void 0 && cteCache.size > 0) {
+    return executeQueryWithCte(query, client, options, cteCache, cacheContext);
+  }
+  return executeSelect(query, client, options, cacheContext);
+}
+function collectSubqueryTasks(where, client, options, cacheContext, tasks, cteCache) {
   if (where === null) return;
   switch (where.type) {
     case "BINARY": {
       const right = where.right;
       if (right.type === "SUBQUERY_IN_LIST") {
-        const result = await executeSelect(right.query, client, options, cacheContext);
-        const col = right.column ?? (result.columns[0] ?? "");
-        const resolved = new Set(result.rows.map((r) => r[col] ?? ""));
-        right.resolved = resolved;
+        tasks.push(runSubquery(right.query, client, options, cacheContext, cteCache).then((result) => {
+          const col = right.column ?? (result.columns[0] ?? "");
+          right.resolved = new Set(result.rows.map((r) => r[col] ?? ""));
+        }));
       }
       if (right.type === "SCALAR_SUBQUERY") {
-        const result = await executeSelect(right.query, client, options, cacheContext);
-        if (result.rowCount === 0) throw new Error("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u304C\u5024\u3092\u8FD4\u3057\u307E\u305B\u3093\u3067\u3057\u305F");
-        if (result.rowCount > 1) throw new Error("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u304C\u8907\u6570\u884C\u3092\u8FD4\u3057\u307E\u3057\u305F\uFF081\u884C\u306E\u307F\u8A31\u53EF\uFF09");
-        const col = result.columns[0] ?? "";
-        right.resolved = result.rows[0]?.[col] ?? "";
+        tasks.push(runSubquery(right.query, client, options, cacheContext, cteCache).then((result) => {
+          if (result.rowCount === 0) throw new Error("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u304C\u5024\u3092\u8FD4\u3057\u307E\u305B\u3093\u3067\u3057\u305F");
+          if (result.rowCount > 1) throw new Error("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u304C\u8907\u6570\u884C\u3092\u8FD4\u3057\u307E\u3057\u305F\uFF081\u884C\u306E\u307F\u8A31\u53EF\uFF09");
+          const col = result.columns[0] ?? "";
+          right.resolved = result.rows[0]?.[col] ?? "";
+        }));
       }
       break;
     }
     case "LOGICAL":
-      await resolveSubqueries(where.left, client, options, cacheContext);
-      await resolveSubqueries(where.right, client, options, cacheContext);
+      collectSubqueryTasks(where.left, client, options, cacheContext, tasks, cteCache);
+      collectSubqueryTasks(where.right, client, options, cacheContext, tasks, cteCache);
       break;
     case "NOT":
     case "GROUP":
-      await resolveSubqueries(where.expr, client, options, cacheContext);
+      collectSubqueryTasks(where.expr, client, options, cacheContext, tasks, cteCache);
       break;
     case "EXISTS": {
-      const result = await executeSelect(where.query, client, options, cacheContext);
-      where.resolved = result.rowCount > 0;
+      const node = where;
+      tasks.push(runSubquery(node.query, client, options, cacheContext, cteCache).then((result) => {
+        node.resolved = result.rowCount > 0;
+      }));
       break;
     }
   }
@@ -5201,19 +5923,83 @@ async function resolveSetSubqueries(assignments, client, options, cacheContext)
     a.value = { type: "STRING", value: resolved };
   }
 }
-async function resolveScalarColumns(columns, client, options, cacheContext) {
-  const cache = /* @__PURE__ */ new Map();
+async function resolveScalarColumns(columns, client, options, cacheContext, cteCache) {
+  const byQuery = /* @__PURE__ */ new Map();
+  const pending = [];
   for (let i = 0; i < columns.length; i++) {
     const col = columns[i];
     if (col.type !== "SCALAR_SUBQUERY_COL") continue;
-    const result = await executeSelect(col.query, client, options, cacheContext);
-    if (result.rowCount === 0) throw new Error("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u304C\u5024\u3092\u8FD4\u3057\u307E\u305B\u3093\u3067\u3057\u305F");
-    if (result.rowCount > 1) throw new Error("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u304C\u8907\u6570\u884C\u3092\u8FD4\u3057\u307E\u3057\u305F\uFF081\u884C\u306E\u307F\u8A31\u53EF\uFF09");
-    const firstCol = result.columns[0] ?? "";
-    cache.set(i, result.rows[0]?.[firstCol] ?? "");
+    const key = JSON.stringify(col.query);
+    let promise = byQuery.get(key);
+    if (!promise) {
+      promise = runSubquery(col.query, client, options, cacheContext, cteCache).then((result) => {
+        if (result.rowCount === 0) throw new Error("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u304C\u5024\u3092\u8FD4\u3057\u307E\u305B\u3093\u3067\u3057\u305F");
+        if (result.rowCount > 1) throw new Error("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u304C\u8907\u6570\u884C\u3092\u8FD4\u3057\u307E\u3057\u305F\uFF081\u884C\u306E\u307F\u8A31\u53EF\uFF09");
+        const firstCol = result.columns[0] ?? "";
+        return result.rows[0]?.[firstCol] ?? "";
+      });
+      byQuery.set(key, promise);
+    }
+    pending.push([i, promise]);
   }
+  const values = await Promise.all(pending.map(([, promise]) => promise));
+  const cache = /* @__PURE__ */ new Map();
+  pending.forEach(([i], idx) => cache.set(i, values[idx]));
   return cache;
 }
+function buildBatchExplainPlans(sql) {
+  const statements = parseSqlBatch(sql);
+  const analysis = analyzeBatch(statements);
+  return {
+    statementCount: statements.length,
+    statements: statements.map((stmt, i) => ({
+      index: i,
+      type: analysis.statements[i].statementType,
+      plan: buildBatchStatementPlan(stmt, analysis.statements[i])
+    }))
+  };
+}
+function buildBatchStatementPlan(stmt, info) {
+  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`,
+      `  rows:          \u5B9F\u4F53\u5316\u524D\u306E\u305F\u3081\u4E0D\u660E\uFF08\u4E0A\u9650 ${TEMP_TABLE_MAX_ROWS} \u884C\u3001\u8D85\u904E\u306F\u30A8\u30E9\u30FC\uFF09`,
+      ...buildPlanForBatchQuery(stmt.query, info).map((l) => `  ${l}`)
+    ];
+  }
+  if (stmt.type === "DROP_TEMP_TABLE") {
+    return [
+      `DROP TEMP TABLE ${stmt.name}`,
+      "  \u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u30B9\u30C8\u30A2\u306E\u89E3\u653E\u306E\u307F\uFF08kintone \u30A2\u30AF\u30BB\u30B9\u306A\u3057\uFF09"
+    ];
+  }
+  if (stmt.type === "SHOW_APPS") return ["SHOW APPS\uFF08\u30A2\u30D7\u30EA\u4E00\u89A7\u306E\u53D6\u5F97\uFF09"];
+  if (stmt.type === "DESCRIBE") return [`DESCRIBE APP${stmt.appId}\uFF08\u30D5\u30A3\u30FC\u30EB\u30C9\u5B9A\u7FA9\u306E\u53D6\u5F97\uFF09`];
+  if (stmt.type === "EXPLAIN") return buildPlanForBatchQuery(stmt.query, info);
+  return buildPlanForBatchQuery(stmt, info);
+}
+function buildPlanForBatchQuery(query, info) {
+  if (info.tempTablesReferenced.length === 0) {
+    return buildExplainPlan(query);
+  }
+  const lines = [];
+  if (query.type === "INSERT_SELECT") {
+    lines.push(
+      `INSERT INTO APP${query.appId} ... SELECT\uFF08\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u30BD\u30FC\u30B9\u3002\u5B9F\u884C\u6642\u306B\u4EF6\u6570\u78BA\u5B9A \u2192 dmlMaxRows \u9069\u7528\uFF09`
+    );
+  }
+  lines.push("  mode:          FULL_SCAN\uFF08\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u53C2\u7167\uFF09");
+  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 apps = info.appIds.filter((a) => query.type !== "INSERT_SELECT" || a !== query.appId);
+  if (apps.length > 0) {
+    lines.push(`  app:           ${apps.map((a) => `APP${a}`).join(", ")}`);
+  }
+  lines.push("  note:          \u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u3078\u306E WHERE \u30D7\u30C3\u30B7\u30E5\u30C0\u30A6\u30F3\u306F\u884C\u308F\u308C\u306A\u3044");
+  return lines;
+}
 function executeExplain(stmt) {
   const lines = buildExplainPlan(stmt.query);
   return {
@@ -5534,6 +6320,10 @@ function parseSqlStatement(sql) {
   const tokens = new Lexer(sql).tokenize();
   return new Parser(tokens).parse();
 }
+function parseSqlStatements(sql) {
+  const tokens = new Lexer(sql).tokenize();
+  return new Parser(tokens).parseStatements();
+}
 
 // src/core/displayFormat.ts
 var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
@@ -5619,207 +6409,6 @@ function isSubtableRow(v) {
   return typeof obj.id === "string" && typeof obj.value === "object" && obj.value !== null;
 }
 
-// src/cli/nodeKintoneClient.ts
-function createNodeKintoneClient(baseUrl, tokenResolver) {
-  const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
-  const apiBasePath = tokenResolver.guestSpaceId && tokenResolver.guestSpaceId > 0 ? `/k/guest/${tokenResolver.guestSpaceId}/v1` : "/k/v1";
-  async function requestJson(path, init, appIdForToken) {
-    const headers = new Headers(init.headers ?? {});
-    if (tokenResolver.auth.type === "token") {
-      headers.set("X-Cybozu-API-Token", tokenResolver.auth.resolveToken(appIdForToken));
-    } else {
-      const credentials = `${tokenResolver.auth.username}:${tokenResolver.auth.password}`;
-      const encoded = Buffer.from(credentials, "utf-8").toString("base64");
-      headers.set("X-Cybozu-Authorization", encoded);
-    }
-    headers.set("Accept", "application/json");
-    const method = String(init.method ?? "GET").toUpperCase();
-    if (method !== "GET" && method !== "HEAD") {
-      headers.set("Content-Type", "application/json");
-    }
-    const timeoutMs = tokenResolver.timeoutMs ?? 3e4;
-    const url = `${normalizedBaseUrl}${path}`;
-    if (tokenResolver.debug) {
-      tokenResolver.log?.(`[debug] request ${String(init.method ?? "GET")} ${url}`);
-      if (tokenResolver.debugHeaders) {
-        const authHeader = headers.get("X-Cybozu-API-Token") ? "X-Cybozu-API-Token=***" : headers.get("X-Cybozu-Authorization") ? "X-Cybozu-Authorization=***" : "Auth=(none)";
-        tokenResolver.log?.(
-          `[debug] request-headers ${authHeader} Content-Type=${headers.get("Content-Type") ?? "(none)"} Accept=${headers.get("Accept") ?? "(none)"}`
-        );
-      }
-    }
-    const res = await fetch(url, {
-      ...init,
-      headers,
-      signal: AbortSignal.timeout(timeoutMs)
-    });
-    if (!res.ok) {
-      const bodyText = await res.text();
-      if (tokenResolver.debug) {
-        tokenResolver.log?.(`[debug] response status=${res.status} body=${bodyText}`);
-      }
-      throw new Error(`kintone API error ${res.status}: ${bodyText}`);
-    }
-    if (tokenResolver.debug) {
-      tokenResolver.log?.(`[debug] response status=${res.status}`);
-    }
-    return await res.json();
-  }
-  function shouldRetryWithRecordNumberOrder(path, bodyText) {
-    if (!path.includes("/v1/records.json?")) return false;
-    if (!bodyText.includes('"code":"CB_IL02"')) return false;
-    const queryPart = path.split("query=")[1] ?? "";
-    const query = decodeURIComponent(queryPart.split("&")[0] ?? "");
-    if (!query.includes("limit")) return false;
-    if (!query.includes("offset")) return false;
-    if (query.toLowerCase().includes("order by")) return false;
-    return true;
-  }
-  function rewriteQueryWithRecordNumberOrder(path) {
-    const [base, rest] = path.split("query=");
-    if (!rest) return path;
-    const [encodedQuery, ...tail] = rest.split("&");
-    const query = decodeURIComponent(encodedQuery ?? "");
-    const rewritten = `order by \u30EC\u30B3\u30FC\u30C9\u756A\u53F7 asc ${query}`.trim();
-    const nextQuery = encodeURIComponent(rewritten);
-    return `${base}query=${nextQuery}${tail.length > 0 ? `&${tail.join("&")}` : ""}`;
-  }
-  return {
-    async getRecords(params) {
-      const queryPart = `query=${encodeURIComponent(params.query)}`;
-      const appPart = `app=${encodeURIComponent(String(params.app))}`;
-      const fieldParts = params.fields.map((f) => `fields[]=${encodeURIComponent(f)}`);
-      const qs = [appPart, queryPart, ...fieldParts].join("&");
-      if (tokenResolver.debug) {
-        tokenResolver.log?.(
-          `[debug] getRecords app=${params.app} query="${params.query}" fields=${params.fields.length > 0 ? params.fields.join(",") : "(all)"} auth=${tokenResolver.auth.type}`
-        );
-      }
-      const path = `${apiBasePath}/records.json?${qs}`;
-      try {
-        return await requestJson(
-          path,
-          { method: "GET" },
-          params.app
-        );
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (!shouldRetryWithRecordNumberOrder(path, msg)) throw err;
-        const retryPath = rewriteQueryWithRecordNumberOrder(path);
-        if (tokenResolver.debug) {
-          tokenResolver.log?.("[debug] retry with fallback query order by \u30EC\u30B3\u30FC\u30C9\u756A\u53F7 asc");
-        }
-        return await requestJson(
-          retryPath,
-          { method: "GET" },
-          params.app
-        );
-      }
-    },
-    async postRecords(_params) {
-      const res = await requestJson(
-        `${apiBasePath}/records.json`,
-        {
-          method: "POST",
-          body: JSON.stringify({
-            app: _params.app,
-            records: _params.records
-          })
-        },
-        _params.app
-      );
-      return { ids: res.ids };
-    },
-    async putRecords(_params) {
-      await requestJson(
-        `${apiBasePath}/records.json`,
-        {
-          method: "PUT",
-          body: JSON.stringify({
-            app: _params.app,
-            records: _params.records
-          })
-        },
-        _params.app
-      );
-    },
-    async deleteRecords(_params) {
-      await requestJson(
-        `${apiBasePath}/records.json`,
-        {
-          method: "DELETE",
-          body: JSON.stringify({
-            app: _params.app,
-            ids: _params.ids
-          })
-        },
-        _params.app
-      );
-    },
-    async getApps() {
-      const PAGE = 100;
-      const all = [];
-      let offset = 0;
-      while (true) {
-        const qs = new URLSearchParams();
-        qs.set("limit", String(PAGE));
-        qs.set("offset", String(offset));
-        const res = await requestJson(
-          `${apiBasePath}/apps.json?${qs.toString()}`,
-          { method: "GET" },
-          0
-        );
-        for (const app of res.apps) {
-          all.push({
-            appId: Number(app.appId),
-            name: app.name,
-            description: app.description
-          });
-        }
-        if (res.apps.length < PAGE) break;
-        offset += PAGE;
-      }
-      return all;
-    },
-    async getFields(appId) {
-      const qs = new URLSearchParams();
-      qs.set("app", String(appId));
-      const res = await requestJson(
-        `${apiBasePath}/app/form/fields.json?${qs.toString()}`,
-        { method: "GET" },
-        appId
-      );
-      return Object.values(res.properties).map((f) => ({
-        code: f.code,
-        label: f.label,
-        fieldType: f.type,
-        optionOrder: toOptionOrderMap(f.options),
-        sortKind: detectSortKind(f.type, f.format)
-      }));
-    }
-  };
-}
-function toOptionOrderMap(options) {
-  if (!options || typeof options !== "object") return void 0;
-  const order = {};
-  let hasAny = false;
-  for (const [label, meta] of Object.entries(options)) {
-    const n = Number(meta?.index);
-    if (!Number.isFinite(n)) continue;
-    order[label] = n;
-    hasAny = true;
-  }
-  return hasAny ? order : void 0;
-}
-function detectSortKind(fieldType, calcFormat) {
-  if (fieldType === "NUMBER" || fieldType === "RECORD_NUMBER") return "number";
-  if (fieldType === "CALC") {
-    if (calcFormat === "NUMBER" || calcFormat === "NUMBER_DIGIT") return "number";
-    return "string";
-  }
-  return void 0;
-}
-
 // src/node/appProfiles.ts
 var import_fs = require("fs");
 function parseTokenMap(raw) {
@@ -5940,119 +6529,450 @@ function collectAppProfileTokens(sql) {
           i += 2;
           break;
         }
-        i++;
+        i++;
+      }
+      continue;
+    }
+    const parsed = tryParseAppProfileToken(sql, i);
+    if (!parsed) {
+      i++;
+      continue;
+    }
+    tokens.push(parsed);
+    i = parsed.fullEnd;
+  }
+  return tokens;
+}
+function nextVirtualAppId(used) {
+  let id = 9e8;
+  while (used.has(id)) id++;
+  used.add(id);
+  return id;
+}
+function normalizeSqlAppProfiles(sql, defaultProfile = "dev") {
+  const tokens = collectAppProfileTokens(sql);
+  const hasProfileSyntax = tokens.some((t) => t.profile !== null);
+  const profilesByApp = /* @__PURE__ */ new Map();
+  const normalizedProfile = (profile) => profile ?? defaultProfile;
+  for (const t of tokens) {
+    const p = normalizedProfile(t.profile);
+    let set = profilesByApp.get(t.appId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      profilesByApp.set(t.appId, set);
+    }
+    set.add(p.toLowerCase());
+  }
+  const usedAppIds = new Set(tokens.map((t) => t.appId));
+  const pairToMapped = /* @__PURE__ */ new Map();
+  const appBindingByMappedApp = /* @__PURE__ */ new Map();
+  for (const [appId, pSet] of profilesByApp.entries()) {
+    const profiles = [...pSet].sort();
+    if (profiles.length <= 1) continue;
+    for (const pLower of profiles) {
+      const mapped = nextVirtualAppId(usedAppIds);
+      pairToMapped.set(`${appId}@${pLower}`, mapped);
+      appBindingByMappedApp.set(mapped, { appId, profile: pLower });
+    }
+  }
+  const out = [];
+  let cursor = 0;
+  for (const t of tokens) {
+    const p = normalizedProfile(t.profile);
+    const pLower = p.toLowerCase();
+    const mapped = pairToMapped.get(`${t.appId}@${pLower}`) ?? t.appId;
+    appBindingByMappedApp.set(mapped, { appId: t.appId, profile: pLower });
+    out.push(sql.slice(cursor, t.start));
+    out.push(sql.slice(t.start, t.digitStart));
+    out.push(String(mapped));
+    out.push(sql.slice(t.digitEnd, t.appEnd));
+    cursor = t.fullEnd;
+  }
+  out.push(sql.slice(cursor));
+  return {
+    normalizedSql: out.join(""),
+    hasProfileSyntax,
+    appBindingByMappedApp
+  };
+}
+function buildCacheContext(defaultProfile, appBindingByMappedApp) {
+  if (appBindingByMappedApp.size === 0) return `default:${defaultProfile.toLowerCase()}`;
+  const pairs = [...appBindingByMappedApp.entries()].sort((a, b) => a[0] - b[0]).map(([mappedAppId, b]) => `M${mappedAppId}=APP${b.appId}@${b.profile}`);
+  return `apps:${pairs.join(",")}`;
+}
+function formatResolvedAppProfiles(sql, defaultProfile) {
+  const parsed = normalizeSqlAppProfiles(sql, defaultProfile);
+  if (parsed.appBindingByMappedApp.size === 0) return "(none)";
+  return [...parsed.appBindingByMappedApp.values()].map((b) => `APP${b.appId}->${b.profile}`).join(", ");
+}
+
+// src/cli/consoleInput.ts
+function decideConsoleInput(buffer, line) {
+  const t = line.trim();
+  if (t.startsWith(":")) return { kind: "meta" };
+  const newBuffer = buffer.length > 0 ? `${buffer}
+${line}` : line;
+  if (newBuffer.trim().length === 0) return { kind: "ignore" };
+  if (isBatchConstruction(newBuffer)) return { kind: "continue", buffer: newBuffer };
+  if (!t.endsWith(";")) return { kind: "continue", buffer: newBuffer };
+  const parsed = tryParseStatements(newBuffer);
+  if (parsed.kind === "ok") {
+    if (parsed.count === 0) return { kind: "ignore" };
+    if (parsed.hasTempTable) return { kind: "continue", buffer: newBuffer };
+    return parsed.count === 1 ? { kind: "execute-single", sql: newBuffer } : { kind: "execute-batch", sql: newBuffer };
+  }
+  if (parsed.continuable) return { kind: "continue", buffer: newBuffer };
+  return { kind: "error", message: parsed.message };
+}
+function decideRun(buffer) {
+  if (buffer.trim().length === 0) {
+    return { kind: "error", message: "ArgumentError: input buffer is empty (nothing to :run)" };
+  }
+  const parsed = tryParseStatements(buffer);
+  if (parsed.kind === "fail") return { kind: "error", message: parsed.message };
+  return { kind: "execute-batch", sql: buffer };
+}
+function isBatchConstruction(buffer) {
+  return /^create\s+temp\s+table\b/i.test(stripLeadingCommentsAndWs(buffer));
+}
+function stripLeadingCommentsAndWs(sql) {
+  let s = sql;
+  while (true) {
+    const before = s;
+    s = s.replace(/^\s+/, "");
+    s = s.replace(/^--[^\n]*(\n|$)/, "");
+    s = s.replace(/^\/\*[\s\S]*?\*\//, "");
+    if (s === before) return s;
+  }
+}
+function toParseInput(sql) {
+  try {
+    return normalizeSqlAppProfiles(sql, "console").normalizedSql;
+  } catch {
+    return sql;
+  }
+}
+function tryParseStatements(sql) {
+  try {
+    const stmts = new Parser(new Lexer(toParseInput(sql)).tokenize()).parseStatements();
+    return {
+      kind: "ok",
+      count: stmts.length,
+      hasTempTable: stmts.some(
+        (s) => s.type === "CREATE_TEMP_TABLE" || s.type === "DROP_TEMP_TABLE"
+      )
+    };
+  } catch (e) {
+    if (e instanceof LexError) {
+      return { kind: "fail", continuable: e.unterminated, message: e.message };
+    }
+    if (e instanceof ParseError) {
+      return { kind: "fail", continuable: e.token.kind === "EOF" /* EOF */, message: e.message };
+    }
+    throw e;
+  }
+}
+
+// src/api/requestGate.ts
+var DEFAULT_MAX_CONCURRENT = 10;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_BASE_DELAY_MS = 500;
+var DEFAULT_MAX_DELAY_MS = 8e3;
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 429, 502, 503, 504]);
+function isRetryableError(err) {
+  if (!(err instanceof Error)) return false;
+  const status = err.message.match(/^kintone API error (\d{3}):/);
+  if (status) return RETRYABLE_STATUSES.has(Number(status[1]));
+  if (err.name === "AbortError" || err.name === "TimeoutError") return true;
+  if (/fetch failed/i.test(err.message)) return true;
+  return false;
+}
+var RequestGate = class {
+  constructor(options = {}) {
+    this.active = 0;
+    this.waiters = [];
+    this.maxConcurrent = clampInt(options.maxConcurrent ?? DEFAULT_MAX_CONCURRENT, 1, 50);
+    this.maxRetries = clampInt(options.maxRetries ?? DEFAULT_MAX_RETRIES, 0, 10);
+    this.baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+    this.maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+    this.sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    this.random = options.random ?? Math.random;
+  }
+  /** 現在の同時実行数（テスト・診断用） */
+  get activeCount() {
+    return this.active;
+  }
+  get limit() {
+    return this.maxConcurrent;
+  }
+  /** GET 系: セマフォ + リトライ付きで実行する */
+  async runReadOnly(fn) {
+    let attempt = 0;
+    while (true) {
+      try {
+        return await this.withSlot(fn);
+      } catch (err) {
+        if (attempt >= this.maxRetries || !isRetryableError(err)) throw err;
+        await this.sleep(this.backoffDelay(attempt));
+        attempt += 1;
+      }
+    }
+  }
+  /** 書き込み系: セマフォのみ（リトライしない — 二重実行防止） */
+  async runMutation(fn) {
+    return this.withSlot(fn);
+  }
+  async withSlot(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  async acquire() {
+    if (this.active < this.maxConcurrent) {
+      this.active += 1;
+      return;
+    }
+    await new Promise((resolve2) => this.waiters.push(resolve2));
+    this.active += 1;
+  }
+  release() {
+    this.active -= 1;
+    const next = this.waiters.shift();
+    if (next) next();
+  }
+  /** 指数バックオフ + ジッタ（attempt: 0 始まり） */
+  backoffDelay(attempt) {
+    const base = Math.min(this.baseDelayMs * 2 ** attempt, this.maxDelayMs);
+    const jitter = 1 + (this.random() - 0.5) * 0.5;
+    return Math.round(base * jitter);
+  }
+};
+function withRequestGate(client, gate) {
+  return {
+    getRecords: (params) => gate.runReadOnly(() => client.getRecords(params)),
+    getApps: () => gate.runReadOnly(() => client.getApps()),
+    getFields: (appId) => gate.runReadOnly(() => client.getFields(appId)),
+    postRecords: (params) => gate.runMutation(() => client.postRecords(params)),
+    putRecords: (params) => gate.runMutation(() => client.putRecords(params)),
+    deleteRecords: (params) => gate.runMutation(() => client.deleteRecords(params))
+  };
+}
+var globalGate = null;
+function getGlobalRequestGate(limitHint) {
+  if (globalGate === null) {
+    const envValue = Number(process.env.KSQL_MAX_CONCURRENT);
+    const limit = Number.isInteger(envValue) && envValue > 0 ? envValue : limitHint;
+    globalGate = new RequestGate({ maxConcurrent: limit });
+  }
+  return globalGate;
+}
+function clampInt(v, min, max) {
+  if (!Number.isFinite(v)) return min;
+  return Math.max(min, Math.min(max, Math.trunc(v)));
+}
+
+// src/cli/nodeKintoneClient.ts
+function createNodeKintoneClient(baseUrl, tokenResolver) {
+  const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+  const apiBasePath = tokenResolver.guestSpaceId && tokenResolver.guestSpaceId > 0 ? `/k/guest/${tokenResolver.guestSpaceId}/v1` : "/k/v1";
+  async function requestJson(path, init, appIdForToken) {
+    const headers = new Headers(init.headers ?? {});
+    if (tokenResolver.auth.type === "token") {
+      headers.set("X-Cybozu-API-Token", tokenResolver.auth.resolveToken(appIdForToken));
+    } else {
+      const credentials = `${tokenResolver.auth.username}:${tokenResolver.auth.password}`;
+      const encoded = Buffer.from(credentials, "utf-8").toString("base64");
+      headers.set("X-Cybozu-Authorization", encoded);
+    }
+    headers.set("Accept", "application/json");
+    const method = String(init.method ?? "GET").toUpperCase();
+    if (method !== "GET" && method !== "HEAD") {
+      headers.set("Content-Type", "application/json");
+    }
+    const timeoutMs = tokenResolver.timeoutMs ?? 3e4;
+    const url = `${normalizedBaseUrl}${path}`;
+    if (tokenResolver.debug) {
+      tokenResolver.log?.(`[debug] request ${String(init.method ?? "GET")} ${url}`);
+      if (tokenResolver.debugHeaders) {
+        const authHeader = headers.get("X-Cybozu-API-Token") ? "X-Cybozu-API-Token=***" : headers.get("X-Cybozu-Authorization") ? "X-Cybozu-Authorization=***" : "Auth=(none)";
+        tokenResolver.log?.(
+          `[debug] request-headers ${authHeader} Content-Type=${headers.get("Content-Type") ?? "(none)"} Accept=${headers.get("Accept") ?? "(none)"}`
+        );
+      }
+    }
+    const res = await fetch(url, {
+      ...init,
+      headers,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok) {
+      const bodyText = await res.text();
+      if (tokenResolver.debug) {
+        tokenResolver.log?.(`[debug] response status=${res.status} body=${bodyText}`);
+      }
+      throw new Error(`kintone API error ${res.status}: ${bodyText}`);
+    }
+    if (tokenResolver.debug) {
+      tokenResolver.log?.(`[debug] response status=${res.status}`);
+    }
+    return await res.json();
+  }
+  function shouldRetryWithRecordNumberOrder(path, bodyText) {
+    if (!path.includes("/v1/records.json?")) return false;
+    if (!bodyText.includes('"code":"CB_IL02"')) return false;
+    const queryPart = path.split("query=")[1] ?? "";
+    const query = decodeURIComponent(queryPart.split("&")[0] ?? "");
+    if (!query.includes("limit")) return false;
+    if (!query.includes("offset")) return false;
+    if (query.toLowerCase().includes("order by")) return false;
+    return true;
+  }
+  function rewriteQueryWithRecordNumberOrder(path) {
+    const [base, rest] = path.split("query=");
+    if (!rest) return path;
+    const [encodedQuery, ...tail] = rest.split("&");
+    const query = decodeURIComponent(encodedQuery ?? "");
+    const rewritten = `order by \u30EC\u30B3\u30FC\u30C9\u756A\u53F7 asc ${query}`.trim();
+    const nextQuery = encodeURIComponent(rewritten);
+    return `${base}query=${nextQuery}${tail.length > 0 ? `&${tail.join("&")}` : ""}`;
+  }
+  return {
+    async getRecords(params) {
+      const queryPart = `query=${encodeURIComponent(params.query)}`;
+      const appPart = `app=${encodeURIComponent(String(params.app))}`;
+      const fieldParts = params.fields.map((f) => `fields[]=${encodeURIComponent(f)}`);
+      const qs = [appPart, queryPart, ...fieldParts].join("&");
+      if (tokenResolver.debug) {
+        tokenResolver.log?.(
+          `[debug] getRecords app=${params.app} query="${params.query}" fields=${params.fields.length > 0 ? params.fields.join(",") : "(all)"} auth=${tokenResolver.auth.type}`
+        );
+      }
+      const path = `${apiBasePath}/records.json?${qs}`;
+      try {
+        return await requestJson(
+          path,
+          { method: "GET" },
+          params.app
+        );
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (!shouldRetryWithRecordNumberOrder(path, msg)) throw err;
+        const retryPath = rewriteQueryWithRecordNumberOrder(path);
+        if (tokenResolver.debug) {
+          tokenResolver.log?.("[debug] retry with fallback query order by \u30EC\u30B3\u30FC\u30C9\u756A\u53F7 asc");
+        }
+        return await requestJson(
+          retryPath,
+          { method: "GET" },
+          params.app
+        );
+      }
+    },
+    async postRecords(_params) {
+      const res = await requestJson(
+        `${apiBasePath}/records.json`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            app: _params.app,
+            records: _params.records
+          })
+        },
+        _params.app
+      );
+      return { ids: res.ids };
+    },
+    async putRecords(_params) {
+      await requestJson(
+        `${apiBasePath}/records.json`,
+        {
+          method: "PUT",
+          body: JSON.stringify({
+            app: _params.app,
+            records: _params.records
+          })
+        },
+        _params.app
+      );
+    },
+    async deleteRecords(_params) {
+      await requestJson(
+        `${apiBasePath}/records.json`,
+        {
+          method: "DELETE",
+          body: JSON.stringify({
+            app: _params.app,
+            ids: _params.ids
+          })
+        },
+        _params.app
+      );
+    },
+    async getApps() {
+      const PAGE = 100;
+      const all = [];
+      let offset = 0;
+      while (true) {
+        const qs = new URLSearchParams();
+        qs.set("limit", String(PAGE));
+        qs.set("offset", String(offset));
+        const res = await requestJson(
+          `${apiBasePath}/apps.json?${qs.toString()}`,
+          { method: "GET" },
+          0
+        );
+        for (const app of res.apps) {
+          all.push({
+            appId: Number(app.appId),
+            name: app.name,
+            description: app.description
+          });
+        }
+        if (res.apps.length < PAGE) break;
+        offset += PAGE;
       }
-      continue;
-    }
-    const parsed = tryParseAppProfileToken(sql, i);
-    if (!parsed) {
-      i++;
-      continue;
-    }
-    tokens.push(parsed);
-    i = parsed.fullEnd;
-  }
-  return tokens;
-}
-function nextVirtualAppId(used) {
-  let id = 9e8;
-  while (used.has(id)) id++;
-  used.add(id);
-  return id;
-}
-function normalizeSqlAppProfiles(sql, defaultProfile = "dev") {
-  const tokens = collectAppProfileTokens(sql);
-  const hasProfileSyntax = tokens.some((t) => t.profile !== null);
-  const profilesByApp = /* @__PURE__ */ new Map();
-  const normalizedProfile = (profile) => profile ?? defaultProfile;
-  for (const t of tokens) {
-    const p = normalizedProfile(t.profile);
-    let set = profilesByApp.get(t.appId);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      profilesByApp.set(t.appId, set);
-    }
-    set.add(p.toLowerCase());
-  }
-  const usedAppIds = new Set(tokens.map((t) => t.appId));
-  const pairToMapped = /* @__PURE__ */ new Map();
-  const appBindingByMappedApp = /* @__PURE__ */ new Map();
-  for (const [appId, pSet] of profilesByApp.entries()) {
-    const profiles = [...pSet].sort();
-    if (profiles.length <= 1) continue;
-    for (const pLower of profiles) {
-      const mapped = nextVirtualAppId(usedAppIds);
-      pairToMapped.set(`${appId}@${pLower}`, mapped);
-      appBindingByMappedApp.set(mapped, { appId, profile: pLower });
+      return all;
+    },
+    async getFields(appId) {
+      const qs = new URLSearchParams();
+      qs.set("app", String(appId));
+      const res = await requestJson(
+        `${apiBasePath}/app/form/fields.json?${qs.toString()}`,
+        { method: "GET" },
+        appId
+      );
+      return Object.values(res.properties).map((f) => ({
+        code: f.code,
+        label: f.label,
+        fieldType: f.type,
+        optionOrder: toOptionOrderMap(f.options),
+        sortKind: detectSortKind(f.type, f.format)
+      }));
     }
-  }
-  const out = [];
-  let cursor = 0;
-  for (const t of tokens) {
-    const p = normalizedProfile(t.profile);
-    const pLower = p.toLowerCase();
-    const mapped = pairToMapped.get(`${t.appId}@${pLower}`) ?? t.appId;
-    appBindingByMappedApp.set(mapped, { appId: t.appId, profile: pLower });
-    out.push(sql.slice(cursor, t.start));
-    out.push(sql.slice(t.start, t.digitStart));
-    out.push(String(mapped));
-    out.push(sql.slice(t.digitEnd, t.appEnd));
-    cursor = t.fullEnd;
-  }
-  out.push(sql.slice(cursor));
-  return {
-    normalizedSql: out.join(""),
-    hasProfileSyntax,
-    appBindingByMappedApp
   };
 }
-function buildCacheContext(defaultProfile, appBindingByMappedApp) {
-  if (appBindingByMappedApp.size === 0) return `default:${defaultProfile.toLowerCase()}`;
-  const pairs = [...appBindingByMappedApp.entries()].sort((a, b) => a[0] - b[0]).map(([mappedAppId, b]) => `M${mappedAppId}=APP${b.appId}@${b.profile}`);
-  return `apps:${pairs.join(",")}`;
-}
-function formatResolvedAppProfiles(sql, defaultProfile) {
-  const parsed = normalizeSqlAppProfiles(sql, defaultProfile);
-  if (parsed.appBindingByMappedApp.size === 0) return "(none)";
-  return [...parsed.appBindingByMappedApp.values()].map((b) => `APP${b.appId}->${b.profile}`).join(", ");
-}
-
-// src/node/dmlGuard.ts
-function getStatementType(stmt) {
-  if (!stmt || typeof stmt !== "object") return "UNKNOWN";
-  const obj = stmt;
-  return typeof obj.type === "string" ? obj.type : "UNKNOWN";
-}
-function isDmlType(type) {
-  return type === "INSERT" || type === "INSERT_SELECT" || type === "UPDATE" || type === "DELETE" || type === "UPSERT" || type === "UPSERT_SELECT" || type === "REORDER";
-}
-function hasWhereClause(stmt) {
-  if (!stmt || typeof stmt !== "object") return false;
-  const obj = stmt;
-  return obj.where !== null && obj.where !== void 0;
-}
-function isNoFromSelectStatement(stmt) {
-  if (!stmt || typeof stmt !== "object") return false;
-  const obj = stmt;
-  return obj.type === "SELECT" && obj.from?.appId === 0 && obj.from?.cteName === "__NO_FROM__";
-}
-function getInsertValuesCount(stmt) {
-  if (!stmt || typeof stmt !== "object") return null;
-  const obj = stmt;
-  if (obj.type !== "INSERT") return null;
-  return Array.isArray(obj.values) ? obj.values.length : null;
-}
-function collectDmlTargetFields(stmt) {
-  if (!stmt || typeof stmt !== "object") return [];
-  const obj = stmt;
-  if (!obj.type) return [];
-  if (obj.type === "UPDATE") {
-    return (obj.assignments ?? []).map((a) => a.field).filter((f) => Boolean(f));
+function toOptionOrderMap(options) {
+  if (!options || typeof options !== "object") return void 0;
+  const order = {};
+  let hasAny = false;
+  for (const [label, meta] of Object.entries(options)) {
+    const n = Number(meta?.index);
+    if (!Number.isFinite(n)) continue;
+    order[label] = n;
+    hasAny = true;
   }
-  if (obj.type === "INSERT" || obj.type === "INSERT_SELECT" || obj.type === "UPSERT" || obj.type === "UPSERT_SELECT") {
-    return [...obj.fields ?? [], ...obj.keyFields ?? []];
+  return hasAny ? order : void 0;
+}
+function detectSortKind(fieldType, calcFormat) {
+  if (fieldType === "NUMBER" || fieldType === "RECORD_NUMBER") return "number";
+  if (fieldType === "CALC") {
+    if (calcFormat === "NUMBER" || calcFormat === "NUMBER_DIGIT") return "number";
+    return "string";
   }
-  return [];
+  return void 0;
 }
 
 // src/cli/index.ts
@@ -6070,6 +6990,7 @@ Options:
   --dry-run                  Parse and show execution plan only
   --format <type>            Output format: table | json | jsonl | csv | markdown | md
   --max-records <n>          Max records to fetch (default: 500)
+  --fetch-parallel <n>       Parallel page fetches per query: 1-10 (default: 3)
   --on-limit <mode>          On record limit: error | truncate
   --timeout <ms>             Request timeout in milliseconds (default: 30000)
   --config <path>            Config file path (default: ./ksql.config.json)
@@ -6102,6 +7023,7 @@ Options:
   --yes                      Skip DML confirmation prompt
   --allow-without-where      Allow UPDATE/DELETE without WHERE
   --dml-max-rows <n>         Max affected rows for DML guard (default: 100)
+  --continue-on-error        Batch: keep executing after a statement error (read-only batch only)
   -h, --help                 Show help
   -v, --version              Show version
 `;
@@ -6115,6 +7037,7 @@ function parseArgs(argv) {
     dryRun: false,
     format: null,
     maxRecords: null,
+    fetchParallel: null,
     onLimit: null,
     timeout: null,
     configPath: null,
@@ -6141,6 +7064,7 @@ function parseArgs(argv) {
     allowDml: false,
     yes: false,
     allowWithoutWhere: false,
+    continueOnError: false,
     dmlMaxRows: null,
     userFormat: null,
     arrayFormat: null,
@@ -6210,6 +7134,10 @@ function parseArgs(argv) {
       out.allowWithoutWhere = true;
       continue;
     }
+    if (a === "--continue-on-error") {
+      out.continueOnError = true;
+      continue;
+    }
     const v = argv[i + 1];
     if (a === "-e" || a === "--execute") {
       out.executeSql = v ?? "";
@@ -6329,6 +7257,13 @@ function parseArgs(argv) {
       i++;
       continue;
     }
+    if (a === "--fetch-parallel") {
+      const n = Number(v);
+      if (!Number.isInteger(n) || n < 1 || n > 10) throw new Error("ArgumentError: --fetch-parallel must be an integer between 1 and 10.");
+      out.fetchParallel = n;
+      i++;
+      continue;
+    }
     if (a === "--timeout") {
       const n = Number(v);
       if (!Number.isInteger(n) || n <= 0) throw new Error("ArgumentError: --timeout must be a positive integer.");
@@ -6545,6 +7480,50 @@ function toExitCodeFromError(err) {
   if (msg.startsWith("AuthError:")) return 3;
   return 1;
 }
+function buildBatchStatementSummary(s) {
+  const parts = [`[${s.index + 1}] ${s.type}`, s.status];
+  if (s.tempTable) parts.push(`temp=${s.tempTable}`);
+  if (s.rowCount !== void 0) parts.push(`rows=${s.rowCount}`);
+  if (s.status === "success" && s.result?.type === "SELECT") parts.push(`rowCount=${s.result.rowCount}`);
+  if (s.status === "success" && s.result && s.result.type !== "SELECT") {
+    const r = s.result;
+    if (r.type === "INSERT") parts.push(`inserted=${r.insertedCount}`);
+    else if (r.type === "UPDATE") parts.push(`updated=${r.updatedCount}`);
+    else if (r.type === "DELETE") parts.push(`deleted=${r.deletedCount}`);
+    else if (r.type === "UPSERT") parts.push(`inserted=${r.insertedCount} updated=${r.updatedCount}`);
+    else parts.push(`reordered=${r.reorderedParentCount}`);
+  }
+  if (s.status === "error" && s.error) parts.push(s.error.message);
+  if (s.status === "skipped" && s.skippedReason) parts.push(`reason=${s.skippedReason}`);
+  return parts.join(" ");
+}
+function buildBatchDmlConfirmMessage(analysis) {
+  const lines = ["[DML Confirm] batch"];
+  for (const s of analysis.statements) {
+    if (!s.isDml) continue;
+    const app = s.targetAppId !== null ? `APP${s.targetAppId}` : "-";
+    lines.push(`  [${s.index + 1}] ${s.statementType} app=${app} where=${s.hasWhere ? "yes" : "no"}`);
+  }
+  return lines.join("\n");
+}
+function writeBatchOutput(batch, opts) {
+  const outputs = [];
+  for (const s of batch.statements) {
+    if (!opts.quiet) process.stderr.write(`${buildBatchStatementSummary(s)}
+`);
+    if (s.status === "success" && s.result?.type === "SELECT") {
+      outputs.push(buildOutput(s.result, opts.format, opts.noHeader, opts.pretty, opts.displayOptions));
+    }
+  }
+  const output = outputs.join("\n\n");
+  if (opts.outputPath) (0, import_fs2.writeFileSync)(opts.outputPath, `${output}
+`, "utf-8");
+  else if (output) process.stdout.write(`${output}
+`);
+  if (batch.ok) return 0;
+  const firstError = batch.statements.find((s) => s.status === "error");
+  return firstError?.error ? toExitCodeFromError(new Error(firstError.error.message)) : 1;
+}
 function shouldExitOnEmpty(dryRun, exitOnEmpty, rowCount) {
   if (dryRun) return false;
   return exitOnEmpty && rowCount === 0;
@@ -6609,6 +7588,7 @@ function parseConsoleMetaCommand(line) {
   if (!t.startsWith(":")) return { kind: "none" };
   if (t === ":help") return { kind: "help" };
   if (t === ":exit" || t === ":quit") return { kind: "exit" };
+  if (t === ":run") return { kind: "run" };
   if (t === ":clear") return { kind: "clear" };
   if (t === ":last") return { kind: "show-last" };
   if (t === ":buffer") return { kind: "show-buffer" };
@@ -6680,6 +7660,7 @@ 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, "--fetch-parallel", base.fetchParallel);
   pushOpt(argv, "--on-limit", base.onLimit);
   pushOpt(argv, "--timeout", base.timeout);
   pushOpt(argv, "--output", base.outputPath);
@@ -6702,6 +7683,7 @@ function buildReplExecArgv(base, sql, dryRun, format) {
   if (base.allowDml) argv.push("--yes");
   if (base.allowDml) argv.push("--allow-dml");
   if (base.allowWithoutWhere) argv.push("--allow-without-where");
+  if (base.continueOnError) argv.push("--continue-on-error");
   return argv;
 }
 function normalizeConsoleInputLine(line) {
@@ -6773,7 +7755,21 @@ async function confirmDmlInConsole(sql, opts, queue, defaultProfile = "dev") {
   if (!opts.allowDml || opts.yes || opts.dryRun) return true;
   try {
     const normalized = normalizeSqlAppProfiles(sql, defaultProfile);
-    const stmt = parseSqlStatement(normalized.normalizedSql);
+    const statements = parseSqlStatements(normalized.normalizedSql);
+    if (statements.length > 1) {
+      const analysis = analyzeBatch(statements);
+      if (!analysis.containsDml) return true;
+      const message = buildBatchDmlConfirmMessage(analysis);
+      if (queue) {
+        process.stdout.write(`${message}
+Proceed? (yes/no): `);
+        const input = await queue.next();
+        if (input.kind !== "line") return false;
+        return parseConfirmAnswer(input.line);
+      }
+      return await promptDmlConfirm(message);
+    }
+    const stmt = statements[0];
     const stmtType = getStatementType(stmt);
     if (!isDmlType(stmtType)) return true;
     const compact = sql.replace(/\s+/g, " ").trim();
@@ -6885,17 +7881,47 @@ async function runConsole(base) {
       const line = normalizeConsoleInputLine(input.line);
       const t = line.trim();
       emptyPromptSigintArmed = false;
-      if (buffer.length === 0) {
+      if (t.startsWith(":")) {
         const meta = parseConsoleMetaCommand(t);
         if (meta.kind === "none") {
         } else if (meta.kind === "exit") {
           return 0;
+        } else if (meta.kind === "run") {
+          const runDecision = decideRun(buffer);
+          if (runDecision.kind === "error") {
+            process.stderr.write(`${runDecision.message}
+`);
+            continue;
+          }
+          const sql2 = runDecision.sql.trim();
+          {
+            const ok = await confirmDmlInConsole(sql2, {
+              allowDml: base.allowDml,
+              yes: base.yes,
+              dryRun
+            }, queue, profile ?? "dev");
+            if (!ok) {
+              process.stderr.write("DML was cancelled by user.\n");
+              continue;
+            }
+          }
+          buffer = "";
+          lastSql = sql2;
+          lastResolvedProfiles = formatResolvedAppProfiles(sql2, profile ?? "dev");
+          history.push(sql2);
+          appendHistory(sql2);
+          const { code: code2, stdout: stdout2 } = await runWithArgvCapture(buildReplExecArgvWithProfile(base, sql2, dryRun, format, profile));
+          lastOutput = stdout2;
+          if (code2 !== 0) process.stderr.write(`(last exit code: ${code2})
+`);
+          continue;
         } else if (meta.kind === "help") {
           process.stdout.write(
             [
               "console commands:",
               "  :help",
               "  :exit | :quit",
+              "  :run",
               "  :clear",
               "  :last",
               "  :buffer",
@@ -7043,10 +8069,22 @@ async function runConsole(base) {
           continue;
         }
       }
-      buffer = buffer.length > 0 ? `${buffer}
-${line}` : line;
-      if (!t.endsWith(";")) continue;
-      const sql = buffer.replace(/;\s*$/, "").trim();
+      const decision = decideConsoleInput(buffer, line);
+      if (decision.kind === "ignore") continue;
+      if (decision.kind === "continue") {
+        buffer = decision.buffer;
+        continue;
+      }
+      if (decision.kind === "error") {
+        buffer = "";
+        process.stderr.write(`${decision.message}
+(input buffer cleared)
+`);
+        continue;
+      }
+      if (decision.kind === "meta") continue;
+      const isBatchExec = decision.kind === "execute-batch";
+      const sql = isBatchExec ? decision.sql.trim() : decision.sql.replace(/;\s*$/, "").trim();
       buffer = "";
       if (!sql) continue;
       {
@@ -7122,6 +8160,9 @@ async function run() {
   let hasWhere = true;
   let insertValuesCount = null;
   let isDmlStatement = false;
+  let isBatchSql = false;
+  let batchContainsDml = false;
+  let batchAnalysis = null;
   if (args.diagRecordId === null) {
     sql = args.executeSql;
     if (!sql && args.filePath) sql = (0, import_fs2.readFileSync)(args.filePath, "utf-8");
@@ -7140,17 +8181,24 @@ async function run() {
       return 2;
     }
     try {
-      const stmt = parseSqlStatement(sql);
-      parsedStmt = stmt;
-      stmtType = getStatementType(stmt);
-      isDmlStatement = isDmlType(stmtType);
-      hasWhere = hasWhereClause(stmt);
-      insertValuesCount = getInsertValuesCount(stmt);
-      const supported = stmtType === "SELECT" || stmtType === "UNION" || stmtType === "WITH" || stmtType === "EXPLAIN" || stmtType === "SHOW_APPS" || stmtType === "DESCRIBE" || isDmlStatement;
-      if (!supported) {
-        process.stderr.write(`ArgumentError: unsupported statement type in CLI: ${stmtType}
+      const statements = parseSqlStatements(sql);
+      if (statements.length > 1) {
+        batchAnalysis = analyzeBatch(statements);
+        isBatchSql = true;
+        batchContainsDml = batchAnalysis.containsDml;
+      } else {
+        const stmt = parseSqlStatement(sql);
+        parsedStmt = stmt;
+        stmtType = getStatementType(stmt);
+        isDmlStatement = isDmlType(stmtType);
+        hasWhere = hasWhereClause(stmt);
+        insertValuesCount = getInsertValuesCount(stmt);
+        const supported = stmtType === "SELECT" || stmtType === "UNION" || stmtType === "WITH" || stmtType === "EXPLAIN" || stmtType === "SHOW_APPS" || stmtType === "DESCRIBE" || isDmlStatement;
+        if (!supported) {
+          process.stderr.write(`ArgumentError: unsupported statement type in CLI: ${stmtType}
 `);
-        return 2;
+          return 2;
+        }
       }
     } catch (err) {
       process.stderr.write(`${err instanceof Error ? err.message : String(err)}
@@ -7159,8 +8207,13 @@ async function run() {
     }
   }
   const maxRecords = args.maxRecords ?? envInt("KSQL_MAX_RECORDS") ?? profile.query?.maxRecords ?? 500;
+  const fetchParallel = args.fetchParallel ?? envInt("KSQL_FETCH_PARALLEL") ?? profile.query?.fetchParallel ?? 3;
   const onLimit = args.onLimit ?? envOnLimit("KSQL_ON_LIMIT") ?? profile.query?.onLimit ?? "error";
   const timeout = args.timeout ?? envInt("KSQL_TIMEOUT") ?? profile.query?.timeout ?? 3e4;
+  if (!Number.isInteger(fetchParallel) || fetchParallel < 1 || fetchParallel > 10) {
+    process.stderr.write("ArgumentError: fetch-parallel must be an integer between 1 and 10.\n");
+    return 2;
+  }
   const rawFormat = args.format ?? envFormat("KSQL_FORMAT") ?? profile.output?.format ?? "table";
   const format = normalizeOutputFormat(rawFormat);
   if (!format) {
@@ -7199,6 +8252,24 @@ async function run() {
     process.stderr.write("ArgumentError: no APPxxx found in SQL and --app is not set.\n");
     return 2;
   }
+  if (isBatchSql) {
+    if (batchContainsDml && !allowDml) {
+      process.stderr.write("ArgumentError: DML is disabled. Use --allow-dml to enable UPDATE/DELETE/INSERT/UPSERT/REORDER.\n");
+      return 2;
+    }
+    if (args.dryRun) {
+      const plans = buildBatchExplainPlans(sql);
+      const out = [];
+      plans.statements.forEach((p) => {
+        if (p.index > 0) out.push("");
+        out.push(`[${p.index + 1}] ${p.type}`);
+        out.push(...p.plan);
+      });
+      process.stdout.write(`${out.join("\n")}
+`);
+      return 0;
+    }
+  }
   if (isDmlStatement) {
     if (hasProfileSyntax && stmtType === "DELETE") {
       process.stderr.write("ArgumentError: @profile is not supported for DELETE yet.\n");
@@ -7446,6 +8517,9 @@ async function run() {
       getApps: () => defaultClient.getApps()
     };
   }
+  if (!args.dryRun) {
+    client = withRequestGate(client, getGlobalRequestGate(profile.query?.maxConcurrent));
+  }
   try {
     if (isDmlStatement && !args.dryRun) {
       const stmtAppId = parsedStmt && typeof parsedStmt === "object" && typeof parsedStmt.appId === "number" ? parsedStmt.appId : appIds[0];
@@ -7473,8 +8547,33 @@ async function run() {
       return await promptDmlConfirm(`[DML Confirm] type=${operation} estimatedRows=${count}
 query=${label}`);
     };
+    if (isBatchSql) {
+      if (batchContainsDml && !yes && batchAnalysis) {
+        const ok = await promptDmlConfirm(buildBatchDmlConfirmMessage(batchAnalysis));
+        if (!ok) {
+          process.stderr.write("DML was cancelled by user.\n");
+          return 2;
+        }
+      }
+      const batchResult = await executeBatch(sql, client, {
+        maxRecords,
+        fetchParallel,
+        onLimitReached: onLimit,
+        cacheContext,
+        continueOnError: args.continueOnError,
+        timeoutMs: timeout,
+        confirm: batchContainsDml ? async (count, operation) => {
+          if (count > dmlMaxRows) {
+            throw new Error(`ArgumentError: ${operation} affected rows (${count}) exceed --dml-max-rows (${dmlMaxRows}).`);
+          }
+          return true;
+        } : void 0
+      });
+      return writeBatchOutput(batchResult, { format, noHeader, pretty, displayOptions, outputPath, quiet });
+    }
     const result = args.dryRun ? await execute(`EXPLAIN ${sql}`, client, { maxRecords, onLimitReached: onLimit, cacheContext }) : await execute(sql, client, {
       maxRecords,
+      fetchParallel,
       onLimitReached: onLimit,
       confirm: isDmlStatement ? confirm : void 0,
       cacheContext
@@ -7521,6 +8620,8 @@ if (isDirectCliRun()) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HELP_TEXT,
+  buildBatchDmlConfirmMessage,
+  buildBatchStatementSummary,
   buildOutput,
   extractAppIds,
   normalizeAppKey,