@rex0220/kintone-sql-tools 1.9.0 → 1.11.0

package/dist-cli/ksql.js

@@ -25,6 +25,7 @@ __export(index_exports, {
   buildBatchDmlConfirmMessage: () => buildBatchDmlConfirmMessage,
   buildBatchStatementSummary: () => buildBatchStatementSummary,
   buildOutput: () => buildOutput,
+  buildReplExecArgv: () => buildReplExecArgv,
   extractAppIds: () => extractAppIds,
   normalizeAppKey: () => normalizeAppKey,
   normalizeSqlAppProfiles: () => normalizeSqlAppProfiles,
@@ -33,7 +34,8 @@ __export(index_exports, {
   parseConsoleMetaCommand: () => parseConsoleMetaCommand,
   parseTokenFile: () => parseTokenFile,
   parseTokenMap: () => parseTokenMap,
-  shouldExitOnEmpty: () => shouldExitOnEmpty
+  shouldExitOnEmpty: () => shouldExitOnEmpty,
+  writeBatchOutput: () => writeBatchOutput
 });
 module.exports = __toCommonJS(index_exports);
 var import_fs2 = require("fs");
@@ -83,6 +85,7 @@ var KEYWORDS = /* @__PURE__ */ new Map([
   ["AVG", "AVG" /* AVG */],
   ["MAX", "MAX" /* MAX */],
   ["MIN", "MIN" /* MIN */],
+  ["ASSERT", "ASSERT" /* ASSERT */],
   ["AND", "AND" /* AND */],
   ["OR", "OR" /* OR */],
   ["NOT", "NOT" /* NOT */],
@@ -428,6 +431,58 @@ function isJapanese(cp) {
 
 // src/parser/parser.ts
 var MAX_BATCH_STATEMENTS = 20;
+var FUNC_CALL_PREFIX_KINDS = /* @__PURE__ */ new Set([
+  "IDENT" /* IDENT */,
+  "BIDENT" /* BIDENT */,
+  "COUNT" /* COUNT */,
+  "SUM" /* SUM */,
+  "AVG" /* AVG */,
+  "MAX" /* MAX */,
+  "MIN" /* MIN */,
+  "TODAY" /* TODAY */,
+  "NOW" /* NOW */,
+  "LOGINUSER" /* LOGINUSER */,
+  "UPPER" /* UPPER */,
+  "LOWER" /* LOWER */,
+  "TRIM" /* TRIM */,
+  "LTRIM" /* LTRIM */,
+  "RTRIM" /* RTRIM */,
+  "LENGTH" /* LENGTH */,
+  "SUBSTRING" /* SUBSTRING */,
+  "SUBSTR" /* SUBSTR */,
+  "CONCAT" /* CONCAT */,
+  "REPLACE" /* REPLACE */,
+  "COALESCE" /* COALESCE */,
+  "NULLIF" /* NULLIF */,
+  "ISNULL" /* ISNULL */,
+  "CAST" /* CAST */,
+  "CONVERT" /* CONVERT */,
+  "FORMAT" /* FORMAT */,
+  "ROUND" /* ROUND */,
+  "FLOOR" /* FLOOR */,
+  "CEIL" /* CEIL */,
+  "CEILING" /* CEILING */,
+  "ABS" /* ABS */,
+  "MOD" /* MOD */,
+  "POWER" /* POWER */,
+  "POW" /* POW */,
+  "SQRT" /* SQRT */,
+  "YEAR" /* YEAR */,
+  "MONTH" /* MONTH */,
+  "DAY" /* DAY */,
+  "DATE_FORMAT" /* DATE_FORMAT */,
+  "DATEDIFF" /* DATEDIFF */,
+  "DATE_ADD" /* DATE_ADD */,
+  "IF" /* IF */
+]);
+function needsSpaceBetween(prev, cur) {
+  if (prev.kind === "(" /* LPAREN */ || prev.kind === "." /* DOT */) return false;
+  if (cur.kind === ")" /* RPAREN */ || cur.kind === "," /* COMMA */ || cur.kind === "." /* DOT */) return false;
+  if (cur.kind === "(" /* LPAREN */) {
+    return !FUNC_CALL_PREFIX_KINDS.has(prev.kind);
+  }
+  return true;
+}
 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`);
@@ -517,6 +572,8 @@ var Parser = class {
         return this.parseDescribe();
       case "EXPLAIN" /* EXPLAIN */:
         return this.parseExplain();
+      case "ASSERT" /* ASSERT */:
+        return this.parseAssert();
       case "IDENT" /* IDENT */: {
         const upper = tok.value.toUpperCase();
         if (upper === "CREATE") return this.parseCreateTempTable();
@@ -527,7 +584,7 @@ var Parser = class {
         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",
+      "SELECT / INSERT / UPDATE / DELETE / REORDER / WITH / SHOW / DESCRIBE / EXPLAIN / CREATE TEMP TABLE / DROP TEMP TABLE / ASSERT \u306E\u3044\u305A\u308C\u304B\u3067\u59CB\u307E\u308B SQL \u6587\u304C\u5FC5\u8981\u3067\u3059",
       tok
     );
   }
@@ -621,6 +678,174 @@ var Parser = class {
     return { type: "EXPLAIN", query };
   }
   // ----------------------------------------------------------
+  // ASSERT
+  //
+  //   ASSERT <式> <比較演算子> <式>
+  //   ASSERT <式> BETWEEN <式> AND <式>
+  //
+  // 式: リテラル / 算術式 / スカラーサブクエリ。
+  // フィールド参照（FROM コンテキストがない）・AND / OR 複合条件・
+  // 裸の値のみ（ASSERT 1）は ParseError。
+  // ----------------------------------------------------------
+  parseAssert() {
+    this.expect("ASSERT" /* ASSERT */);
+    const condStart = this.pos;
+    const left = this.parseAssertOperand();
+    const opTok = this.peek();
+    if (this.consume("BETWEEN" /* BETWEEN */)) {
+      const low = this.parseAssertOperand();
+      this.expect(
+        "AND" /* AND */,
+        "ASSERT \u306E BETWEEN \u306B\u306F AND \u304C\u5FC5\u8981\u3067\u3059\uFF08\u4F8B: ASSERT (SELECT COUNT(*) FROM #t) BETWEEN 1 AND 500\uFF09"
+      );
+      const high = this.parseAssertOperand();
+      this.rejectAssertCompound();
+      return {
+        type: "ASSERT",
+        left,
+        op: "BETWEEN",
+        right: null,
+        low,
+        high,
+        text: this.renderTokenRange(condStart, this.pos)
+      };
+    }
+    const op = this.tryAssertCompareOp();
+    if (op === null) {
+      throw new ParseError(
+        "ASSERT \u306B\u306F\u6BD4\u8F03\u6F14\u7B97\u5B50\uFF08= <> < <= > >=\uFF09\u307E\u305F\u306F BETWEEN \u304C\u5FC5\u8981\u3067\u3059\uFF08\u5024\u306E\u307F\u306E ASSERT \u306F\u4E0D\u53EF\uFF09",
+        opTok
+      );
+    }
+    const right = this.parseAssertOperand();
+    this.rejectAssertCompound();
+    return {
+      type: "ASSERT",
+      left,
+      op,
+      right,
+      low: null,
+      high: null,
+      text: this.renderTokenRange(condStart, this.pos)
+    };
+  }
+  /** ASSERT のオペランド: 文字列 / スカラーサブクエリ / 数値算術式 */
+  parseAssertOperand() {
+    const tok = this.peek();
+    if (tok.kind === "STRING" /* STRING */) {
+      this.advance();
+      return { type: "STRING", value: tok.value };
+    }
+    if (tok.kind === "(" /* LPAREN */ && this.peekAt(1).kind === "SELECT" /* SELECT */) {
+      this.advance();
+      const query = this.parseSelect();
+      this.expect(")" /* RPAREN */);
+      if (this.isArithOp(this.peek().kind)) {
+        throw new ParseError(
+          "\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u306E\u5F8C\u306B\u7B97\u8853\u6F14\u7B97\u5B50\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002\u30B5\u30D6\u30AF\u30A8\u30EA\u5185\u3067\u8A08\u7B97\u3057\u3066\u304F\u3060\u3055\u3044\uFF08\u4F8B: ASSERT (SELECT COUNT(*) * 2 FROM APP100) > 10\uFF09",
+          this.peek()
+        );
+      }
+      const hasWildcard = query.columns.some(
+        (c) => c.type === "WILDCARD" || c.type === "PARENT_WILDCARD"
+      );
+      if (!hasWildcard && query.columns.length > 1) {
+        throw new ParseError("scalar subquery in ASSERT must return exactly 1 column.", tok);
+      }
+      return { type: "SCALAR_SUBQUERY", query };
+    }
+    if (tok.kind === "NUMBER" /* NUMBER */ || tok.kind === "(" /* LPAREN */ || tok.kind === "-" /* MINUS */) {
+      const expr = this.parseArithAddSub();
+      this.rejectNonLiteralArith(expr, tok);
+      if (expr.type === "NUMBER") return expr;
+      return expr;
+    }
+    if (this.tryStringFuncName() !== null) {
+      throw new ParseError(
+        "ASSERT \u306E\u5F0F\u3067\u306F\u95A2\u6570\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\uFF08\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u5185\u3067\u8A08\u7B97\u3057\u3066\u304F\u3060\u3055\u3044\uFF09",
+        tok
+      );
+    }
+    throw new ParseError(
+      "ASSERT \u306E\u5F0F\u306B\u306F\u30EA\u30C6\u30E9\u30EB\u30FB\u7B97\u8853\u5F0F\u30FB\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\uFF08\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\uFF09",
+      tok
+    );
+  }
+  /** ASSERT の算術式にフィールド参照・関数呼び出しが含まれていたら拒否する */
+  rejectNonLiteralArith(node, tok) {
+    if (node.type === "FIELD_REF") {
+      throw new ParseError(
+        `ASSERT \u3067\u306F\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\uFF08FROM \u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u304C\u3042\u308A\u307E\u305B\u3093\uFF09: ${node.field}`,
+        tok
+      );
+    }
+    if (node.type === "STRING_FUNC") {
+      throw new ParseError(
+        "ASSERT \u306E\u5F0F\u3067\u306F\u95A2\u6570\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\uFF08\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u5185\u3067\u8A08\u7B97\u3057\u3066\u304F\u3060\u3055\u3044\uFF09",
+        tok
+      );
+    }
+    if (node.type === "ARITH") {
+      this.rejectNonLiteralArith(node.left, tok);
+      this.rejectNonLiteralArith(node.right, tok);
+    }
+  }
+  /** ASSERT の比較演算子を読む（該当しなければ null・消費しない） */
+  tryAssertCompareOp() {
+    switch (this.peek().kind) {
+      case "=" /* EQ */:
+        this.advance();
+        return "=";
+      case "!=" /* NEQ */:
+        this.advance();
+        return "!=";
+      case "<>" /* LT_GT */:
+        this.advance();
+        return "<>";
+      case ">" /* GT */:
+        this.advance();
+        return ">";
+      case "<" /* LT */:
+        this.advance();
+        return "<";
+      case ">=" /* GTE */:
+        this.advance();
+        return ">=";
+      case "<=" /* LTE */:
+        this.advance();
+        return "<=";
+      default:
+        return null;
+    }
+  }
+  /** ASSERT は AND / OR による複合条件に対応しない（初期版仕様） */
+  rejectAssertCompound() {
+    const tok = this.peek();
+    if (tok.kind === "AND" /* AND */ || tok.kind === "OR" /* OR */) {
+      throw new ParseError(
+        "ASSERT \u306F AND / OR \u306B\u3088\u308B\u8907\u5408\u6761\u4EF6\u306B\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u305B\u3093\uFF08\u8907\u6570\u306E ASSERT \u6587\u306B\u5206\u3051\u3066\u304F\u3060\u3055\u3044\uFF09",
+        tok
+      );
+    }
+  }
+  /**
+   * トークン列 [fromIdx, toIdx) を SQL 風テキストに再構成する。
+   * AssertError の "assertion failed: <条件>" メッセージ用（正規化表示で十分）。
+   */
+  renderTokenRange(fromIdx, toIdx) {
+    let out = "";
+    for (let i = fromIdx; i < toIdx; i++) {
+      const t = this.tokens[i];
+      let text;
+      if (t.kind === "STRING" /* STRING */) text = `'${t.value.replace(/'/g, "''")}'`;
+      else if (t.kind === "BIDENT" /* BIDENT */) text = `\`${t.value}\``;
+      else text = t.value;
+      if (out.length > 0 && needsSpaceBetween(this.tokens[i - 1], t)) out += " ";
+      out += text;
+    }
+    return out;
+  }
+  // ----------------------------------------------------------
   // SELECT
   // ----------------------------------------------------------
   parseSelect() {
@@ -1970,7 +2195,7 @@ 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";
+  return type === "SELECT" || type === "UNION" || type === "WITH" || type === "EXPLAIN" || type === "SHOW_APPS" || type === "DESCRIBE" || type === "CREATE_TEMP_TABLE" || type === "DROP_TEMP_TABLE" || type === "ASSERT";
 }
 function hasWhereClause(stmt) {
   if (!stmt || typeof stmt !== "object") return false;
@@ -4351,6 +4576,8 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
       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).");
+    case "ASSERT":
+      return executeAssert(stmt, client, options, cacheContext);
   }
 }
 var TEMP_TABLE_MAX_ROWS = 1e4;
@@ -4425,6 +4652,8 @@ async function executeBatch(sql, client, options = {}) {
       failed.add(i);
       if (e instanceof BatchTimeoutError) {
         aborted = "timeout";
+      } else if (e instanceof AssertError) {
+        aborted = "assertion";
       } else if (!options.continueOnError) {
         aborted = "fail-fast";
       }
@@ -4457,6 +4686,10 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
   if (stmt.type === "EXPLAIN") {
     return { result: await executeParsedStatement(stmt, client, options, cacheContext) };
   }
+  if (stmt.type === "ASSERT") {
+    await executeAssert(stmt, client, options, cacheContext, tempTables);
+    return {};
+  }
   if (info.tempTablesReferenced.length > 0) {
     if (stmt.type === "SELECT" || stmt.type === "UNION") {
       return { result: await executeQueryWithCte(stmt, client, options, tempTables, cacheContext) };
@@ -4533,6 +4766,107 @@ function parseSqlBatch(sql) {
   const tokens = new Lexer(sql).tokenize();
   return new Parser(tokens).parseStatements();
 }
+var AssertError = class extends Error {
+  constructor(message) {
+    super(`AssertError: ${message}`);
+    this.name = "AssertError";
+  }
+};
+async function executeAssert(stmt, client, options, cacheContext, tempTables) {
+  const left = await evalAssertOperand(stmt.left, client, options, cacheContext, tempTables);
+  if (stmt.op === "BETWEEN") {
+    if (stmt.low === null || stmt.high === null) {
+      throw new Error("ArgumentError: malformed ASSERT statement.");
+    }
+    const low = await evalAssertOperand(stmt.low, client, options, cacheContext, tempTables);
+    const high = await evalAssertOperand(stmt.high, client, options, cacheContext, tempTables);
+    if (!compareAssertValues(">=", left, low) || !compareAssertValues("<=", left, high)) {
+      throw new AssertError(`assertion failed: ${stmt.text} (actual: ${left}).`);
+    }
+    return { type: "ASSERT", condition: stmt.text };
+  }
+  if (stmt.right === null) {
+    throw new Error("ArgumentError: malformed ASSERT statement.");
+  }
+  const right = await evalAssertOperand(stmt.right, client, options, cacheContext, tempTables);
+  if (!compareAssertValues(stmt.op, left, right)) {
+    throw new AssertError(`assertion failed: ${stmt.text} (actual: ${left}).`);
+  }
+  return { type: "ASSERT", condition: stmt.text };
+}
+async function evalAssertOperand(operand, client, options, cacheContext, tempTables) {
+  switch (operand.type) {
+    case "NUMBER":
+      return String(operand.value);
+    case "STRING":
+      return operand.value;
+    case "ARITH":
+      return String(evalAssertArith(operand));
+    case "SCALAR_SUBQUERY": {
+      const { query, probed } = withScalarProbeLimit(operand.query);
+      const result = await runSubquery(query, client, options, cacheContext, tempTables);
+      if (result.columns.length > 1) {
+        throw new AssertError(
+          `scalar subquery returned ${result.columns.length} columns (expected 1 column).`
+        );
+      }
+      if (result.rowCount === 0) {
+        throw new AssertError("scalar subquery returned no rows (expected 1 row).");
+      }
+      if (result.rowCount > 1) {
+        const rows = probed && result.rowCount === 2 ? "2 or more rows" : `${result.rowCount} rows`;
+        throw new AssertError(`scalar subquery returned ${rows} (expected 1 row).`);
+      }
+      const col = result.columns[0] ?? "";
+      return result.rows[0]?.[col] ?? "";
+    }
+  }
+}
+function withScalarProbeLimit(query) {
+  const hasAgg = query.groupBy.length > 0 || query.columns.some((c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL");
+  if (hasAgg || query.distinct || query.limit !== null) return { query, probed: false };
+  return { query: { ...query, limit: 2 }, probed: true };
+}
+function evalAssertArith(node) {
+  if (node.type === "NUMBER") return node.value;
+  if (node.type === "ARITH") {
+    const left = evalAssertArith(node.left);
+    const right = evalAssertArith(node.right);
+    switch (node.op) {
+      case "+":
+        return left + right;
+      case "-":
+        return left - right;
+      case "*":
+        return left * right;
+      case "/":
+        return left / right;
+      case "%":
+        return left % right;
+    }
+  }
+  throw new Error(`ArgumentError: unsupported operand in ASSERT expression: ${node.type}`);
+}
+function compareAssertValues(op, leftStr, rightStr) {
+  const leftNum = Number(leftStr);
+  const rightNum = Number(rightStr);
+  const numeric = !Number.isNaN(leftNum) && !Number.isNaN(rightNum);
+  switch (op) {
+    case "=":
+      return leftStr === rightStr;
+    case "!=":
+    case "<>":
+      return leftStr !== rightStr;
+    case ">":
+      return numeric ? leftNum > rightNum : leftStr > rightStr;
+    case "<":
+      return numeric ? leftNum < rightNum : leftStr < rightStr;
+    case ">=":
+      return numeric ? leftNum >= rightNum : leftStr >= rightStr;
+    case "<=":
+      return numeric ? leftNum <= rightNum : leftStr <= rightStr;
+  }
+}
 async function executeSelect(stmt, client, options, cacheContext, cteCache) {
   if (isNoFromSelect(stmt)) {
     return executeNoFromSelect(stmt);
@@ -5977,7 +6311,7 @@ function buildBatchStatementPlan(stmt, info) {
     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`,
+      `  rows:          \u5B9F\u4F53\u5316\u524D\u306E\u305F\u3081\u4E0D\u660E\uFF08\u65E2\u5B9A\u4E0A\u9650 ${TEMP_TABLE_MAX_ROWS} \u884C\u3001tempTableMaxRows \u3067\u5909\u66F4\u53EF\u3001\u8D85\u904E\u306F\u30A8\u30E9\u30FC\uFF09`,
       ...buildPlanForBatchQuery(stmt.query, info).map((l) => `  ${l}`)
     ];
   }
@@ -5990,8 +6324,33 @@ function buildBatchStatementPlan(stmt, info) {
   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);
+  if (stmt.type === "ASSERT") {
+    const lines = [
+      `ASSERT ${stmt.text}`,
+      "  check:         \u5B9F\u884C\u6642\u306B\u6761\u4EF6\u8A55\u4FA1\uFF08\u4E0D\u6210\u7ACB\u306F AssertError \u3067\u30D0\u30C3\u30C1\u505C\u6B62\u3001\u4EE5\u964D\u306E\u6587\u306F skipped\uFF09"
+    ];
+    const subqueries = [stmt.left, stmt.right, stmt.low, stmt.high].filter(
+      (o) => o !== null && o.type === "SCALAR_SUBQUERY"
+    );
+    subqueries.forEach((sq, i) => {
+      lines.push(subqueries.length > 1 ? `  subquery[${i + 1}]:` : "  subquery:");
+      const subInfo = hasTempTableRef(sq.query) ? info : { ...info, tempTablesReferenced: [] };
+      lines.push(...buildPlanForBatchQuery(sq.query, subInfo).map((l) => `  ${l}`));
+    });
+    return lines;
+  }
   return buildPlanForBatchQuery(stmt, info);
 }
+function hasTempTableRef(node) {
+  if (Array.isArray(node)) return node.some(hasTempTableRef);
+  if (node !== null && typeof node === "object") {
+    const obj = node;
+    const cte = obj["cteName"];
+    if (typeof cte === "string" && cte.startsWith("#")) return true;
+    return Object.values(obj).some(hasTempTableRef);
+  }
+  return false;
+}
 function buildPlanForBatchQuery(query, info) {
   if (info.tempTablesReferenced.length === 0) {
     return buildExplainPlan(query);
@@ -6428,6 +6787,90 @@ function isSubtableRow(v) {
   return typeof obj.id === "string" && typeof obj.value === "object" && obj.value !== null;
 }
 
+// src/output/batchEnvelope.ts
+function toMutationSummary(result) {
+  if (result.type === "INSERT") {
+    return { insertedCount: result.insertedCount, createdIds: result.createdIds };
+  }
+  if (result.type === "UPDATE") return { updatedCount: result.updatedCount };
+  if (result.type === "DELETE") return { deletedCount: result.deletedCount };
+  if (result.type === "UPSERT") {
+    return { insertedCount: result.insertedCount, updatedCount: result.updatedCount };
+  }
+  return { reorderedParentCount: result.reorderedParentCount };
+}
+function buildBatchEnvelope(batch, options = {}) {
+  const { maxTotalRecords } = options;
+  const results = [];
+  let totalRows = 0;
+  const statements = batch.statements.map((s) => {
+    const entry = {
+      index: s.index,
+      type: s.type,
+      status: s.status
+    };
+    if (s.status === "error" && s.error) entry.error = s.error;
+    if (s.status === "skipped" && s.skippedReason) entry.skippedReason = s.skippedReason;
+    if (s.tempTable !== void 0) entry.tempTable = s.tempTable;
+    if (s.rowCount !== void 0) entry.rowCount = s.rowCount;
+    if (s.status === "success" && s.result?.type === "SELECT") {
+      totalRows += s.result.rowCount;
+      if (maxTotalRecords !== void 0 && totalRows > maxTotalRecords) {
+        throw new Error(
+          `ArgumentError: batch total rows (${totalRows}) exceed maxTotalRecords (${maxTotalRecords}).`
+        );
+      }
+      entry.resultIndex = results.length;
+      results.push({
+        columns: s.result.columns,
+        rows: s.result.rows,
+        rowCount: s.result.rowCount,
+        warnings: s.result.warnings ?? []
+      });
+    } else if (s.status === "success" && s.result && s.result.type !== "SELECT" && s.result.type !== "ASSERT") {
+      Object.assign(entry, toMutationSummary(s.result));
+    }
+    return entry;
+  });
+  return {
+    ok: batch.ok,
+    batch: true,
+    statementCount: batch.statementCount,
+    statements,
+    results,
+    // バッチ全体の警告（仕様 §6.2）。文ごとの警告は results[].warnings に入る
+    warnings: []
+  };
+}
+
+// src/node/config.ts
+function envString(name) {
+  const v = process.env[name];
+  return v && v.trim() ? v : null;
+}
+function envInt(name) {
+  const v = envString(name);
+  if (v === null) return null;
+  const n = Number(v);
+  if (!Number.isInteger(n) || n <= 0) return null;
+  return n;
+}
+function envNonNegativeInt(name) {
+  const v = envString(name);
+  if (v === null) return null;
+  const n = Number(v);
+  if (!Number.isInteger(n) || n < 0) return null;
+  return n;
+}
+function resolveRequestGateOptions(base) {
+  return {
+    ...base,
+    maxConcurrent: envInt("KSQL_MAX_CONCURRENT") ?? base.maxConcurrent,
+    // KSQL_RETRY=0（リトライ無効）は有効値のため envNonNegativeInt で読む
+    maxRetries: envNonNegativeInt("KSQL_RETRY") ?? base.maxRetries
+  };
+}
+
 // src/node/appProfiles.ts
 var import_fs = require("fs");
 function parseTokenMap(raw) {
@@ -6712,8 +7155,11 @@ var RequestGate = class {
     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.baseDelayMs = clampInt(options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS, 1, 6e4);
+    this.maxDelayMs = Math.max(
+      clampInt(options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS, 1, 6e5),
+      this.baseDelayMs
+    );
     this.sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     this.random = options.random ?? Math.random;
   }
@@ -6724,6 +7170,18 @@ var RequestGate = class {
   get limit() {
     return this.maxConcurrent;
   }
+  /** 解決済みの GET リトライ回数（テスト・診断用） */
+  get retries() {
+    return this.maxRetries;
+  }
+  /** 解決済みのバックオフ初期値ミリ秒（テスト・診断用） */
+  get retryBaseDelayMs() {
+    return this.baseDelayMs;
+  }
+  /** 解決済みのバックオフ上限ミリ秒（テスト・診断用） */
+  get retryMaxDelayMs() {
+    return this.maxDelayMs;
+  }
   /** GET 系: セマフォ + リトライ付きで実行する */
   async runReadOnly(fn) {
     let attempt = 0;
@@ -6780,11 +7238,11 @@ function withRequestGate(client, gate) {
   };
 }
 var globalGate = null;
-function getGlobalRequestGate(limitHint) {
+function getGlobalRequestGate(options) {
   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 });
+    globalGate = new RequestGate(
+      typeof options === "number" ? { maxConcurrent: options } : options ?? {}
+    );
   }
   return globalGate;
 }
@@ -7008,10 +7466,17 @@ Options:
   --console                  Start interactive console mode
   --dry-run                  Parse and show execution plan only
   --format <type>            Output format: table | json | jsonl | csv | markdown | md
+                             (batch + json: prints one JSON envelope for the whole batch)
   --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
+  --temp-table-max-rows <n>  Max rows per temp table (default: 10000, always errors on overflow)
   --timeout <ms>             Request timeout in milliseconds (default: 30000)
+  --max-concurrent <n>       Max concurrent kintone requests: 1-50 (default: 10)
+                             (process-wide; fixed at first resolution; KSQL_MAX_CONCURRENT wins)
+  --retry <n>                GET retry count: 0-10, 0 disables (default: 3; KSQL_RETRY wins)
+  --retry-base-delay <ms>    GET retry backoff base delay (default: 500)
+  --retry-max-delay <ms>     GET retry backoff max delay (default: 8000)
   --config <path>            Config file path (default: ./ksql.config.json)
   --profile <name>           Profile name in config
   --base-url <url>           kintone base URL
@@ -7058,6 +7523,7 @@ function parseArgs(argv) {
     maxRecords: null,
     fetchParallel: null,
     onLimit: null,
+    tempTableMaxRows: null,
     timeout: null,
     configPath: null,
     profile: null,
@@ -7085,6 +7551,10 @@ function parseArgs(argv) {
     allowWithoutWhere: false,
     continueOnError: false,
     dmlMaxRows: null,
+    maxConcurrent: null,
+    retry: null,
+    retryBaseDelay: null,
+    retryMaxDelay: null,
     userFormat: null,
     arrayFormat: null,
     tableFormat: null,
@@ -7276,6 +7746,13 @@ function parseArgs(argv) {
       i++;
       continue;
     }
+    if (a === "--temp-table-max-rows") {
+      const n = Number(v);
+      if (!Number.isInteger(n) || n <= 0) throw new Error("ArgumentError: --temp-table-max-rows must be a positive integer.");
+      out.tempTableMaxRows = n;
+      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.");
@@ -7311,6 +7788,34 @@ function parseArgs(argv) {
       i++;
       continue;
     }
+    if (a === "--max-concurrent") {
+      const n = Number(v);
+      if (!Number.isInteger(n) || n < 1 || n > 50) throw new Error("ArgumentError: --max-concurrent must be an integer between 1 and 50.");
+      out.maxConcurrent = n;
+      i++;
+      continue;
+    }
+    if (a === "--retry") {
+      const n = Number(v);
+      if (!Number.isInteger(n) || n < 0 || n > 10) throw new Error("ArgumentError: --retry must be an integer between 0 and 10 (0 disables retry).");
+      out.retry = n;
+      i++;
+      continue;
+    }
+    if (a === "--retry-base-delay") {
+      const n = Number(v);
+      if (!Number.isInteger(n) || n <= 0) throw new Error("ArgumentError: --retry-base-delay must be a positive integer (ms).");
+      out.retryBaseDelay = n;
+      i++;
+      continue;
+    }
+    if (a === "--retry-max-delay") {
+      const n = Number(v);
+      if (!Number.isInteger(n) || n <= 0) throw new Error("ArgumentError: --retry-max-delay must be a positive integer (ms).");
+      out.retryMaxDelay = n;
+      i++;
+      continue;
+    }
     throw new Error(`ArgumentError: unknown option ${a}`);
   }
   return out;
@@ -7334,35 +7839,35 @@ function resolveTokenValue(raw) {
   }
   return raw;
 }
-function envString(name) {
+function envString2(name) {
   const v = process.env[name];
   return v && v.trim() ? v : null;
 }
-function envInt(name) {
-  const v = envString(name);
+function envInt2(name) {
+  const v = envString2(name);
   if (v === null) return null;
   const n = Number(v);
   if (!Number.isInteger(n) || n <= 0) return null;
   return n;
 }
 function envBool(name) {
-  const v = envString(name);
+  const v = envString2(name);
   if (v === null) return null;
   if (v === "1" || v.toLowerCase() === "true") return true;
   if (v === "0" || v.toLowerCase() === "false") return false;
   return null;
 }
 function envFormat(name) {
-  const v = envString(name);
+  const v = envString2(name);
   return normalizeOutputFormat(v);
 }
 function envOnLimit(name) {
-  const v = envString(name);
+  const v = envString2(name);
   if (v === "error" || v === "truncate") return v;
   return null;
 }
 function envAuth(name) {
-  const v = envString(name);
+  const v = envString2(name);
   if (v === "token" || v === "userpass" || v === "auto") return v;
   return null;
 }
@@ -7387,6 +7892,12 @@ function getAffectedCount(result) {
   if (result.type === "REORDER") return result.reorderedParentCount;
   return 0;
 }
+function buildAssertOutput(result, format, pretty) {
+  const payload = { ok: true, type: result.type, condition: result.condition };
+  if (format === "json") return JSON.stringify(payload, null, pretty ? 2 : 0);
+  if (format === "jsonl") return JSON.stringify(payload);
+  return `assertion ok: ${result.condition}`;
+}
 function buildMutationOutput(result, format, noHeader, pretty) {
   const row = { type: result.type };
   if (result.type === "INSERT") {
@@ -7510,7 +8021,7 @@ function buildBatchStatementSummary(s) {
     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}`);
+    else if (r.type === "REORDER") 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}`);
@@ -7526,15 +8037,11 @@ function buildBatchDmlConfirmMessage(analysis) {
   return lines.join("\n");
 }
 function writeBatchOutput(batch, opts) {
-  const outputs = [];
-  for (const s of batch.statements) {
-    if (!opts.quiet) process.stderr.write(`${buildBatchStatementSummary(s)}
+  const output = opts.format === "json" ? JSON.stringify(buildBatchEnvelope(batch), null, opts.pretty ? 2 : 0) : buildBatchResultsOutput(batch, opts);
+  if (!opts.quiet) {
+    for (const s of batch.statements) 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}
@@ -7543,6 +8050,15 @@ function writeBatchOutput(batch, opts) {
   const firstError = batch.statements.find((s) => s.status === "error");
   return firstError?.error ? toExitCodeFromError(new Error(firstError.error.message)) : 1;
 }
+function buildBatchResultsOutput(batch, opts) {
+  const outputs = [];
+  for (const s of batch.statements) {
+    if (s.status === "success" && s.result?.type === "SELECT") {
+      outputs.push(buildOutput(s.result, opts.format, opts.noHeader, opts.pretty, opts.displayOptions));
+    }
+  }
+  return outputs.join("\n\n");
+}
 function shouldExitOnEmpty(dryRun, exitOnEmpty, rowCount) {
   if (dryRun) return false;
   return exitOnEmpty && rowCount === 0;
@@ -7681,6 +8197,7 @@ function buildReplExecArgv(base, sql, dryRun, format) {
   pushOpt(argv, "--max-records", base.maxRecords);
   pushOpt(argv, "--fetch-parallel", base.fetchParallel);
   pushOpt(argv, "--on-limit", base.onLimit);
+  pushOpt(argv, "--temp-table-max-rows", base.tempTableMaxRows);
   pushOpt(argv, "--timeout", base.timeout);
   pushOpt(argv, "--output", base.outputPath);
   pushOpt(argv, "--user-format", base.userFormat);
@@ -7689,6 +8206,10 @@ function buildReplExecArgv(base, sql, dryRun, format) {
   pushOpt(argv, "--date-format", base.dateFormat);
   pushOpt(argv, "--attachment-format", base.attachmentFormat);
   pushOpt(argv, "--dml-max-rows", base.dmlMaxRows);
+  pushOpt(argv, "--max-concurrent", base.maxConcurrent);
+  pushOpt(argv, "--retry", base.retry);
+  pushOpt(argv, "--retry-base-delay", base.retryBaseDelay);
+  pushOpt(argv, "--retry-max-delay", base.retryMaxDelay);
   const tokenMapArg = buildTokenMapArg(base.tokenMap);
   if (tokenMapArg) argv.push("--token-map", tokenMapArg);
   if (base.noHeader) argv.push("--no-header");
@@ -8163,13 +8684,13 @@ async function run() {
     process.stderr.write("ArgumentError: specify -e/--execute or -f/--file. Use --help for details.\n");
     return 2;
   }
-  const configPath = args.configPath ?? envString("KSQL_CONFIG") ?? "./ksql.config.json";
+  const configPath = args.configPath ?? envString2("KSQL_CONFIG") ?? "./ksql.config.json";
   let config = {};
   try {
     config = loadConfig(configPath);
   } catch {
   }
-  const profileName = args.profile ?? envString("KSQL_PROFILE") ?? config.defaultProfile ?? "dev";
+  const profileName = args.profile ?? envString2("KSQL_PROFILE") ?? config.defaultProfile ?? "dev";
   const profile = config.profiles?.[profileName] ?? {};
   let sql = null;
   let hasProfileSyntax = false;
@@ -8212,7 +8733,7 @@ async function run() {
         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;
+        const supported = stmtType === "SELECT" || stmtType === "UNION" || stmtType === "WITH" || stmtType === "EXPLAIN" || stmtType === "SHOW_APPS" || stmtType === "DESCRIBE" || stmtType === "ASSERT" || isDmlStatement;
         if (!supported) {
           process.stderr.write(`ArgumentError: unsupported statement type in CLI: ${stmtType}
 `);
@@ -8225,10 +8746,11 @@ async function run() {
       return 1;
     }
   }
-  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 maxRecords = args.maxRecords ?? envInt2("KSQL_MAX_RECORDS") ?? profile.query?.maxRecords ?? 500;
+  const fetchParallel = args.fetchParallel ?? envInt2("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;
+  const timeout = args.timeout ?? envInt2("KSQL_TIMEOUT") ?? profile.query?.timeout ?? 3e4;
+  const tempTableMaxRows = args.tempTableMaxRows ?? envInt2("KSQL_TEMP_TABLE_MAX_ROWS") ?? profile.query?.tempTableMaxRows ?? void 0;
   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;
@@ -8245,12 +8767,12 @@ async function run() {
   const quiet = args.quiet || envBool("KSQL_QUIET") === true || Boolean(profile.output?.quiet);
   const debug = args.debug || args.debugUrl || envBool("KSQL_DEBUG") === true || envBool("KSQL_DEBUG_URL") === true;
   const debugHeaders = args.debugHeaders || envBool("KSQL_DEBUG_HEADERS") === true;
-  const outputPath = args.outputPath ?? envString("KSQL_OUTPUT") ?? profile.output?.output ?? null;
+  const outputPath = args.outputPath ?? envString2("KSQL_OUTPUT") ?? profile.output?.output ?? null;
   const exitOnEmpty = args.exitOnEmpty || envBool("KSQL_EXIT_ON_EMPTY") === true || Boolean(profile.output?.exitOnEmpty);
   const allowDml = args.allowDml || envBool("KSQL_ALLOW_DML") === true || Boolean(profile.dml?.allowDml);
   const yes = args.yes || envBool("KSQL_YES") === true || Boolean(profile.dml?.yes);
   const allowWithoutWhere = args.allowWithoutWhere || envBool("KSQL_ALLOW_WITHOUT_WHERE") === true || Boolean(profile.dml?.allowWithoutWhere);
-  const dmlMaxRows = args.dmlMaxRows ?? envInt("KSQL_DML_MAX_ROWS") ?? profile.dml?.maxRows ?? 100;
+  const dmlMaxRows = args.dmlMaxRows ?? envInt2("KSQL_DML_MAX_ROWS") ?? profile.dml?.maxRows ?? 100;
   if (format === "markdown" && noHeader) {
     process.stderr.write("ArgumentError: --no-header cannot be used with --format markdown|md.\n");
     return 2;
@@ -8264,7 +8786,7 @@ async function run() {
     attachmentFormat: args.attachmentFormat ?? profile.output?.attachmentFormat ?? "full"
   };
   const appIds = sql ? extractAppIds(sql) : [];
-  const defaultApp = args.app ?? envInt("KSQL_APP") ?? profile.app ?? null;
+  const defaultApp = args.app ?? envInt2("KSQL_APP") ?? profile.app ?? null;
   if (appIds.length === 0 && defaultApp !== null) appIds.push(defaultApp);
   const allowNoFromSelect = isNoFromSelectStatement(parsedStmt) || stmtType === "SHOW_APPS";
   if (appIds.length === 0 && !allowNoFromSelect && !args.dryRun && args.diagRecordId === null) {
@@ -8324,10 +8846,10 @@ async function run() {
         return 2;
       }
     }
-    const mapFromEnv = envString("KSQL_TOKEN_MAP") ? parseTokenMap(envString("KSQL_TOKEN_MAP")) : {};
+    const mapFromEnv = envString2("KSQL_TOKEN_MAP") ? parseTokenMap(envString2("KSQL_TOKEN_MAP")) : {};
     const mapFromFile = args.tokenFile ? parseTokenFile(args.tokenFile) : {};
     const mapFromArg = args.tokenMap;
-    const singleToken = args.token ?? envString("KSQL_TOKEN");
+    const singleToken = args.token ?? envString2("KSQL_TOKEN");
     const profileClientMap = /* @__PURE__ */ new Map();
     const missingAppProfiles = [];
     const usedProfiles = /* @__PURE__ */ new Set([...appProfileByApp.values(), profileName]);
@@ -8338,17 +8860,17 @@ async function run() {
 `);
         return 2;
       }
-      const baseUrl = args.baseUrl ?? envString("KSQL_BASE_URL") ?? p.baseUrl ?? "";
-      const guestSpaceId = args.guestSpaceId ?? envInt("KSQL_GUEST_SPACE_ID") ?? p.guestSpaceId ?? null;
+      const baseUrl = args.baseUrl ?? envString2("KSQL_BASE_URL") ?? p.baseUrl ?? "";
+      const guestSpaceId = args.guestSpaceId ?? envInt2("KSQL_GUEST_SPACE_ID") ?? p.guestSpaceId ?? null;
       if (!baseUrl) {
         process.stderr.write(`AuthError: --base-url is required for profile "${pName}".
 `);
         return 3;
       }
       const authReq = args.auth ?? envAuth("KSQL_AUTH") ?? p.auth ?? "auto";
-      const username = args.username ?? envString("KSQL_USERNAME") ?? p.username ?? null;
-      const passwordFromEnvRef = p.passwordEnv ? envString(p.passwordEnv) : null;
-      const password = args.password ?? envString("KSQL_PASSWORD") ?? passwordFromEnvRef ?? p.password ?? null;
+      const username = args.username ?? envString2("KSQL_USERNAME") ?? p.username ?? null;
+      const passwordFromEnvRef = p.passwordEnv ? envString2(p.passwordEnv) : null;
+      const password = args.password ?? envString2("KSQL_PASSWORD") ?? passwordFromEnvRef ?? p.password ?? null;
       const hasUserPass = Boolean(username && password);
       const auth = authReq === "auto" ? hasUserPass ? "userpass" : "token" : authReq;
       if (auth === "userpass") {
@@ -8429,17 +8951,17 @@ async function run() {
 `);
         return 2;
       }
-      const baseUrl = args.baseUrl ?? envString("KSQL_BASE_URL") ?? diagProfile.baseUrl ?? "";
-      const guestSpaceId = args.guestSpaceId ?? envInt("KSQL_GUEST_SPACE_ID") ?? diagProfile.guestSpaceId ?? null;
+      const baseUrl = args.baseUrl ?? envString2("KSQL_BASE_URL") ?? diagProfile.baseUrl ?? "";
+      const guestSpaceId = args.guestSpaceId ?? envInt2("KSQL_GUEST_SPACE_ID") ?? diagProfile.guestSpaceId ?? null;
       if (!baseUrl) {
         process.stderr.write(`AuthError: --base-url is required for profile "${diagProfileName}".
 `);
         return 3;
       }
       const authReq = args.auth ?? envAuth("KSQL_AUTH") ?? diagProfile.auth ?? "auto";
-      const username = args.username ?? envString("KSQL_USERNAME") ?? diagProfile.username ?? null;
-      const passwordFromEnvRef = diagProfile.passwordEnv ? envString(diagProfile.passwordEnv) : null;
-      const password = args.password ?? envString("KSQL_PASSWORD") ?? passwordFromEnvRef ?? diagProfile.password ?? null;
+      const username = args.username ?? envString2("KSQL_USERNAME") ?? diagProfile.username ?? null;
+      const passwordFromEnvRef = diagProfile.passwordEnv ? envString2(diagProfile.passwordEnv) : null;
+      const password = args.password ?? envString2("KSQL_PASSWORD") ?? passwordFromEnvRef ?? diagProfile.password ?? null;
       const hasUserPass = Boolean(username && password);
       const auth = authReq === "auto" ? hasUserPass ? "userpass" : "token" : authReq;
       try {
@@ -8537,7 +9059,12 @@ async function run() {
     };
   }
   if (!args.dryRun) {
-    client = withRequestGate(client, getGlobalRequestGate(profile.query?.maxConcurrent));
+    client = withRequestGate(client, getGlobalRequestGate(resolveRequestGateOptions({
+      maxConcurrent: args.maxConcurrent ?? profile.query?.maxConcurrent,
+      maxRetries: args.retry ?? profile.query?.retry,
+      baseDelayMs: args.retryBaseDelay ?? profile.query?.retryBaseDelayMs,
+      maxDelayMs: args.retryMaxDelay ?? profile.query?.retryMaxDelayMs
+    })));
   }
   try {
     if (isDmlStatement && !args.dryRun) {
@@ -8580,6 +9107,7 @@ query=${label}`);
         onLimitReached: onLimit,
         cacheContext,
         continueOnError: args.continueOnError,
+        tempTableMaxRows,
         timeoutMs: timeout,
         confirm: batchContainsDml ? async (count, operation) => {
           if (count > dmlMaxRows) {
@@ -8597,6 +9125,14 @@ query=${label}`);
       confirm: isDmlStatement ? confirm : void 0,
       cacheContext
     });
+    if (result.type === "ASSERT") {
+      const output2 = buildAssertOutput(result, format, pretty);
+      if (outputPath) (0, import_fs2.writeFileSync)(outputPath, `${output2}
+`, "utf-8");
+      else if (output2) process.stdout.write(`${output2}
+`);
+      return 0;
+    }
     if (result.type !== "SELECT") {
       const output2 = buildMutationOutput(result, format, noHeader, pretty);
       if (outputPath) (0, import_fs2.writeFileSync)(outputPath, `${output2}
@@ -8642,6 +9178,7 @@ if (isDirectCliRun()) {
   buildBatchDmlConfirmMessage,
   buildBatchStatementSummary,
   buildOutput,
+  buildReplExecArgv,
   extractAppIds,
   normalizeAppKey,
   normalizeSqlAppProfiles,
@@ -8650,5 +9187,6 @@ if (isDirectCliRun()) {
   parseConsoleMetaCommand,
   parseTokenFile,
   parseTokenMap,
-  shouldExitOnEmpty
+  shouldExitOnEmpty,
+  writeBatchOutput
 });