@rex0220/kintone-sql-tools 1.1.2 → 1.3.0

package/dist-cli/ksql.js

@@ -34,7 +34,7 @@ __export(index_exports, {
   shouldExitOnEmpty: () => shouldExitOnEmpty
 });
 module.exports = __toCommonJS(index_exports);
-var import_fs = require("fs");
+var import_fs2 = require("fs");
 var import_path = require("path");
 var import_readline = require("readline");
 var import_os = require("os");
@@ -2804,23 +2804,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 +3256,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 +3414,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 +3424,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 });
     }
   }
@@ -3489,12 +3499,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 +3552,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 +3646,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 +3669,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,6 +3913,56 @@ 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);
   switch (stmt.type) {
@@ -3894,7 +3973,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":
@@ -4009,8 +4088,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,11 +4116,12 @@ 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})`);
     }
@@ -4052,8 +4131,10 @@ async function executeFullScanSelect(stmt, client, options, cacheContext) {
   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),
+    resolveSubqueries(stmt.having, client, options, cacheContext)
+  ]);
   const tableConditions = /* @__PURE__ */ new Map();
   if (stmt.where !== null) {
     if (stmt.from.alias) {
@@ -4102,6 +4183,12 @@ async function executeFullScanSelect(stmt, client, options, cacheContext) {
       onOptJoins.push(join2);
     }
   }
+  const scalarCachePromise = resolveScalarColumns(stmt.columns, client, options, cacheContext);
+  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 +4220,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,7 +4246,7 @@ 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;
@@ -4261,8 +4349,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) => {
@@ -4286,8 +4376,16 @@ 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);
+  await Promise.all([
+    resolveSubqueries(stmt.where, client, options, cacheContext),
+    resolveSubqueries(stmt.having, client, options, cacheContext)
+  ]);
+  const scalarCachePromise = resolveScalarColumns(stmt.columns, client, options, cacheContext);
+  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) ?? [];
@@ -4334,9 +4432,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 +4469,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 +4678,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 +4761,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);
@@ -4699,26 +4878,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 +4900,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 +4926,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 +5003,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 +5045,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 +5056,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 +5199,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 +5249,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 +5263,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");
@@ -5156,36 +5334,44 @@ function parseSql(sql) {
   }
 }
 async function resolveSubqueries(where, client, options, cacheContext) {
+  const tasks = [];
+  collectSubqueryTasks(where, client, options, cacheContext, tasks);
+  await Promise.all(tasks);
+}
+function collectSubqueryTasks(where, client, options, cacheContext, tasks) {
   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(executeSelect(right.query, client, options, cacheContext).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(executeSelect(right.query, client, options, cacheContext).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);
+      collectSubqueryTasks(where.right, client, options, cacheContext, tasks);
       break;
     case "NOT":
     case "GROUP":
-      await resolveSubqueries(where.expr, client, options, cacheContext);
+      collectSubqueryTasks(where.expr, client, options, cacheContext, tasks);
       break;
     case "EXISTS": {
-      const result = await executeSelect(where.query, client, options, cacheContext);
-      where.resolved = result.rowCount > 0;
+      const node = where;
+      tasks.push(executeSelect(node.query, client, options, cacheContext).then((result) => {
+        node.resolved = result.rowCount > 0;
+      }));
       break;
     }
   }
@@ -5202,16 +5388,27 @@ async function resolveSetSubqueries(assignments, client, options, cacheContext)
   }
 }
 async function resolveScalarColumns(columns, client, options, cacheContext) {
-  const cache = /* @__PURE__ */ new Map();
+  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 = executeSelect(col.query, client, options, cacheContext).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 executeExplain(stmt) {
@@ -5820,149 +6017,386 @@ function detectSortKind(fieldType, calcFormat) {
   return void 0;
 }
 
-// src/cli/index.ts
-var HELP_TEXT = `ksql - Execute SQL against kintone apps
-
-Usage:
-  ksql [options]
-  ksql -e "<SQL>"
-  ksql -f <file.sql>
-
-Options:
-  -e, --execute <sql>        Execute SQL string
-  -f, --file <path>          Execute SQL file
-  --console                  Start interactive console mode
-  --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)
-  --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)
-  --profile <name>           Profile name in config
-  --base-url <url>           kintone base URL
-  --guest-space-id <id>      Guest space ID (uses /k/guest/<id>/v1 APIs)
-  --auth <type>              Auth type: token | userpass | auto
-  --username <name>          Login username (for userpass auth)
-  --password <pass>          Login password (for userpass auth)
-  --token <token>            Single-app token
-  --token-map <mapping>      App token map (APP100=...,APP101=...)
-  --token-file <path>        JSON file for app token map
-  --app <id>                 Default app id context
-  --diag-record-id <id>      Diagnostic: GET record.json by app+id
-  --no-header                Hide table header
-  --pretty                   Pretty-print JSON output
-  --user-format <mode>       User field format: full | name | code
-  --array-format <mode>      Array field format: full | join
-  --table-format <mode>      Subtable format: full | count
-  --date-format <mode>       Date format: full | local
-  --attachment-format <mode> Attachment format: full | name | fileKey
-  --output <path>            Write output to file
-  --no-color                 Disable ANSI colors
-  --quiet                    Suppress non-result logs
-  --debug                    Show request/response debug logs
-  --debug-url                Show only HTTP request URL debug logs
-  --debug-headers            Show request headers in debug logs (masked)
-  --exit-on-empty            Return exit code 1 when rowCount is 0
-  --allow-dml                Enable UPDATE/DELETE/INSERT/UPSERT execution
-  --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)
-  -h, --help                 Show help
-  -v, --version              Show version
-`;
-function parseArgs(argv) {
-  const out = {
-    help: false,
-    version: false,
-    executeSql: null,
-    filePath: null,
-    console: false,
-    dryRun: false,
-    format: null,
-    maxRecords: null,
-    onLimit: null,
-    timeout: null,
-    configPath: null,
-    profile: null,
-    baseUrl: null,
-    guestSpaceId: null,
-    auth: null,
-    username: null,
-    password: null,
-    token: null,
-    tokenMap: {},
-    tokenFile: null,
-    app: null,
-    diagRecordId: null,
-    noHeader: false,
-    pretty: false,
-    outputPath: null,
-    noColor: false,
-    quiet: false,
-    debug: false,
-    debugUrl: false,
-    debugHeaders: false,
-    exitOnEmpty: false,
-    allowDml: false,
-    yes: false,
-    allowWithoutWhere: false,
-    dmlMaxRows: null,
-    userFormat: null,
-    arrayFormat: null,
-    tableFormat: null,
-    dateFormat: null,
-    attachmentFormat: null
-  };
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === "-h" || a === "--help") {
-      out.help = true;
-      continue;
-    }
-    if (a === "-v" || a === "--version") {
-      out.version = true;
-      continue;
-    }
-    if (a === "--console") {
-      out.console = true;
-      continue;
-    }
-    if (a === "--dry-run") {
-      out.dryRun = true;
-      continue;
-    }
-    if (a === "--no-header") {
-      out.noHeader = true;
-      continue;
-    }
-    if (a === "--pretty") {
-      out.pretty = true;
-      continue;
-    }
-    if (a === "--no-color") {
-      out.noColor = true;
-      continue;
-    }
-    if (a === "--quiet") {
-      out.quiet = true;
-      continue;
-    }
-    if (a === "--debug") {
-      out.debug = true;
-      continue;
-    }
-    if (a === "--debug-url") {
-      out.debugUrl = true;
-      continue;
-    }
-    if (a === "--debug-headers") {
-      out.debugHeaders = true;
-      continue;
-    }
-    if (a === "--exit-on-empty") {
-      out.exitOnEmpty = true;
-      continue;
-    }
+// src/node/appProfiles.ts
+var import_fs = require("fs");
+function parseTokenMap(raw) {
+  const out = {};
+  if (!raw.trim()) return out;
+  const pairs = raw.split(",");
+  for (const pair of pairs) {
+    const idx = pair.indexOf("=");
+    if (idx <= 0) throw new Error("ArgumentError: --token-map must be APPxxx=token pairs.");
+    const key = normalizeAppKey(pair.slice(0, idx).trim());
+    const value = pair.slice(idx + 1).trim();
+    if (!value) throw new Error(`ArgumentError: token is empty for ${key}.`);
+    out[key] = value;
+  }
+  return out;
+}
+function parseTokenFile(path) {
+  const raw = (0, import_fs.readFileSync)(path, "utf-8");
+  const parsed = JSON.parse(raw);
+  const out = {};
+  for (const [k, v] of Object.entries(parsed)) out[normalizeAppKey(k)] = String(v);
+  return out;
+}
+function normalizeAppKey(v) {
+  const m1 = v.match(/^APP(\d+)$/i);
+  if (m1) return `APP${m1[1]}`;
+  const m2 = v.match(/^(\d+)$/);
+  if (m2) return `APP${m2[1]}`;
+  throw new Error(`ArgumentError: invalid app key "${v}"`);
+}
+function extractAppIds(sql) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of sql.matchAll(/\bAPP(\d+)\b/gi)) out.add(Number(m[1]));
+  return [...out];
+}
+function isSqlIdentContinue(ch) {
+  if (!ch) return false;
+  const cp = ch.codePointAt(0);
+  return cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp >= 48 && cp <= 57 || cp === 95 || cp === 36 || cp >= 12352 && cp <= 12543 || cp >= 13312 && cp <= 40959 || cp >= 63744 && cp <= 64255 || cp >= 65281 && cp <= 65376;
+}
+function isProfileNameChar(ch) {
+  if (!ch) return false;
+  const cp = ch.codePointAt(0);
+  return cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp >= 48 && cp <= 57 || ch === "_" || ch === "-" || ch === "." || ch === "$";
+}
+function tryParseAppProfileToken(sql, start) {
+  const head = sql.slice(start, start + 3);
+  if (head.toUpperCase() !== "APP") return null;
+  const prev = start > 0 ? sql[start - 1] : "";
+  if (isSqlIdentContinue(prev)) return null;
+  let i = start + 3;
+  const digitStart = i;
+  while (i < sql.length && /[0-9]/.test(sql[i])) i++;
+  const digitEnd = i;
+  if (digitEnd === digitStart) return null;
+  if (sql[i] === "$") {
+    i++;
+    const subStart = i;
+    while (i < sql.length && isSqlIdentContinue(sql[i])) i++;
+    if (i === subStart) return null;
+  }
+  const appEnd = i;
+  let profile = null;
+  if (sql[i] === "@") {
+    i++;
+    const pStart = i;
+    while (i < sql.length && isProfileNameChar(sql[i])) i++;
+    if (i === pStart) return null;
+    profile = sql.slice(pStart, i);
+  }
+  const next = i < sql.length ? sql[i] : "";
+  if (isSqlIdentContinue(next)) return null;
+  return {
+    appId: Number(sql.slice(digitStart, digitEnd)),
+    profile,
+    start,
+    digitStart,
+    digitEnd,
+    appEnd,
+    fullEnd: i
+  };
+}
+function collectAppProfileTokens(sql) {
+  const tokens = [];
+  let i = 0;
+  while (i < sql.length) {
+    const ch = sql[i];
+    if (ch === "'") {
+      i++;
+      while (i < sql.length) {
+        if (sql[i] === "'") {
+          i++;
+          if (i < sql.length && sql[i] === "'") {
+            i++;
+            continue;
+          }
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (ch === "`") {
+      i++;
+      while (i < sql.length && sql[i] !== "`") i++;
+      if (i < sql.length) i++;
+      continue;
+    }
+    if (ch === "-" && sql[i + 1] === "-") {
+      i += 2;
+      while (i < sql.length && sql[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && sql[i + 1] === "*") {
+      i += 2;
+      while (i < sql.length) {
+        if (sql[i] === "*" && sql[i + 1] === "/") {
+          i += 2;
+          break;
+        }
+        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/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));
+  }
+  if (obj.type === "INSERT" || obj.type === "INSERT_SELECT" || obj.type === "UPSERT" || obj.type === "UPSERT_SELECT") {
+    return [...obj.fields ?? [], ...obj.keyFields ?? []];
+  }
+  return [];
+}
+
+// src/cli/index.ts
+var HELP_TEXT = `ksql - Execute SQL against kintone apps
+
+Usage:
+  ksql [options]
+  ksql -e "<SQL>"
+  ksql -f <file.sql>
+
+Options:
+  -e, --execute <sql>        Execute SQL string
+  -f, --file <path>          Execute SQL file
+  --console                  Start interactive console mode
+  --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)
+  --profile <name>           Profile name in config
+  --base-url <url>           kintone base URL
+  --guest-space-id <id>      Guest space ID (uses /k/guest/<id>/v1 APIs)
+  --auth <type>              Auth type: token | userpass | auto
+  --username <name>          Login username (for userpass auth)
+  --password <pass>          Login password (for userpass auth)
+  --token <token>            Single-app token
+  --token-map <mapping>      App token map (APP100=...,APP101=...)
+  --token-file <path>        JSON file for app token map
+  --app <id>                 Default app id context
+  --diag-record-id <id>      Diagnostic: GET record.json by app+id
+  --no-header                Hide table header
+  --pretty                   Pretty-print JSON output
+  --user-format <mode>       User field format: full | name | code
+  --array-format <mode>      Array field format: full | join
+  --table-format <mode>      Subtable format: full | count
+  --date-format <mode>       Date format: full | local
+  --attachment-format <mode> Attachment format: full | name | fileKey
+  --output <path>            Write output to file
+  --no-color                 Disable ANSI colors
+  --quiet                    Suppress non-result logs
+  --debug                    Show request/response debug logs
+  --debug-url                Show only HTTP request URL debug logs
+  --debug-headers            Show request headers in debug logs (masked)
+  --exit-on-empty            Return exit code 1 when rowCount is 0
+  --allow-dml                Enable UPDATE/DELETE/INSERT/UPSERT/REORDER execution
+  --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)
+  -h, --help                 Show help
+  -v, --version              Show version
+`;
+function parseArgs(argv) {
+  const out = {
+    help: false,
+    version: false,
+    executeSql: null,
+    filePath: null,
+    console: false,
+    dryRun: false,
+    format: null,
+    maxRecords: null,
+    fetchParallel: null,
+    onLimit: null,
+    timeout: null,
+    configPath: null,
+    profile: null,
+    baseUrl: null,
+    guestSpaceId: null,
+    auth: null,
+    username: null,
+    password: null,
+    token: null,
+    tokenMap: {},
+    tokenFile: null,
+    app: null,
+    diagRecordId: null,
+    noHeader: false,
+    pretty: false,
+    outputPath: null,
+    noColor: false,
+    quiet: false,
+    debug: false,
+    debugUrl: false,
+    debugHeaders: false,
+    exitOnEmpty: false,
+    allowDml: false,
+    yes: false,
+    allowWithoutWhere: false,
+    dmlMaxRows: null,
+    userFormat: null,
+    arrayFormat: null,
+    tableFormat: null,
+    dateFormat: null,
+    attachmentFormat: null
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") {
+      out.help = true;
+      continue;
+    }
+    if (a === "-v" || a === "--version") {
+      out.version = true;
+      continue;
+    }
+    if (a === "--console") {
+      out.console = true;
+      continue;
+    }
+    if (a === "--dry-run") {
+      out.dryRun = true;
+      continue;
+    }
+    if (a === "--no-header") {
+      out.noHeader = true;
+      continue;
+    }
+    if (a === "--pretty") {
+      out.pretty = true;
+      continue;
+    }
+    if (a === "--no-color") {
+      out.noColor = true;
+      continue;
+    }
+    if (a === "--quiet") {
+      out.quiet = true;
+      continue;
+    }
+    if (a === "--debug") {
+      out.debug = true;
+      continue;
+    }
+    if (a === "--debug-url") {
+      out.debugUrl = true;
+      continue;
+    }
+    if (a === "--debug-headers") {
+      out.debugHeaders = true;
+      continue;
+    }
+    if (a === "--exit-on-empty") {
+      out.exitOnEmpty = true;
+      continue;
+    }
     if (a === "--allow-dml") {
       out.allowDml = true;
       continue;
@@ -6094,6 +6528,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.");
@@ -6128,216 +6569,14 @@ function parseArgs(argv) {
 }
 function getVersion() {
   const pkgPath = (0, import_path.resolve)(__dirname, "../package.json");
-  const raw = (0, import_fs.readFileSync)(pkgPath, "utf-8");
+  const raw = (0, import_fs2.readFileSync)(pkgPath, "utf-8");
   const pkg = JSON.parse(raw);
   return pkg.version ?? "0.0.0";
 }
 function loadConfig(configPath) {
-  const raw = (0, import_fs.readFileSync)(configPath, "utf-8");
+  const raw = (0, import_fs2.readFileSync)(configPath, "utf-8");
   return JSON.parse(raw);
 }
-function parseTokenMap(raw) {
-  const out = {};
-  if (!raw.trim()) return out;
-  const pairs = raw.split(",");
-  for (const pair of pairs) {
-    const idx = pair.indexOf("=");
-    if (idx <= 0) throw new Error("ArgumentError: --token-map must be APPxxx=token pairs.");
-    const key = normalizeAppKey(pair.slice(0, idx).trim());
-    const value = pair.slice(idx + 1).trim();
-    if (!value) throw new Error(`ArgumentError: token is empty for ${key}.`);
-    out[key] = value;
-  }
-  return out;
-}
-function parseTokenFile(path) {
-  const raw = (0, import_fs.readFileSync)(path, "utf-8");
-  const parsed = JSON.parse(raw);
-  const out = {};
-  for (const [k, v] of Object.entries(parsed)) out[normalizeAppKey(k)] = String(v);
-  return out;
-}
-function normalizeAppKey(v) {
-  const m1 = v.match(/^APP(\d+)$/i);
-  if (m1) return `APP${m1[1]}`;
-  const m2 = v.match(/^(\d+)$/);
-  if (m2) return `APP${m2[1]}`;
-  throw new Error(`ArgumentError: invalid app key "${v}"`);
-}
-function extractAppIds(sql) {
-  const out = /* @__PURE__ */ new Set();
-  for (const m of sql.matchAll(/\bAPP(\d+)\b/gi)) out.add(Number(m[1]));
-  return [...out];
-}
-function isSqlIdentContinue(ch) {
-  if (!ch) return false;
-  const cp = ch.codePointAt(0);
-  return cp >= 65 && cp <= 90 || // A-Z
-  cp >= 97 && cp <= 122 || // a-z
-  cp >= 48 && cp <= 57 || // 0-9
-  cp === 95 || // _
-  cp === 36 || // $
-  cp >= 12352 && cp <= 12543 || cp >= 13312 && cp <= 40959 || cp >= 63744 && cp <= 64255 || cp >= 65281 && cp <= 65376;
-}
-function isProfileNameChar(ch) {
-  if (!ch) return false;
-  const cp = ch.codePointAt(0);
-  return cp >= 65 && cp <= 90 || // A-Z
-  cp >= 97 && cp <= 122 || // a-z
-  cp >= 48 && cp <= 57 || // 0-9
-  ch === "_" || ch === "-" || ch === "." || ch === "$";
-}
-function tryParseAppProfileToken(sql, start) {
-  const head = sql.slice(start, start + 3);
-  if (head.toUpperCase() !== "APP") return null;
-  const prev = start > 0 ? sql[start - 1] : "";
-  if (isSqlIdentContinue(prev)) return null;
-  let i = start + 3;
-  const digitStart = i;
-  while (i < sql.length && /[0-9]/.test(sql[i])) i++;
-  const digitEnd = i;
-  if (digitEnd === digitStart) return null;
-  if (sql[i] === "$") {
-    i++;
-    const subStart = i;
-    while (i < sql.length && isSqlIdentContinue(sql[i])) i++;
-    if (i === subStart) return null;
-  }
-  const appEnd = i;
-  let profile = null;
-  if (sql[i] === "@") {
-    i++;
-    const pStart = i;
-    while (i < sql.length && isProfileNameChar(sql[i])) i++;
-    if (i === pStart) return null;
-    profile = sql.slice(pStart, i);
-  }
-  const next = i < sql.length ? sql[i] : "";
-  if (isSqlIdentContinue(next)) return null;
-  return {
-    appId: Number(sql.slice(digitStart, digitEnd)),
-    profile,
-    start,
-    digitStart,
-    digitEnd,
-    appEnd,
-    fullEnd: i
-  };
-}
-function collectAppProfileTokens(sql) {
-  const tokens = [];
-  let i = 0;
-  while (i < sql.length) {
-    const ch = sql[i];
-    if (ch === "'") {
-      i++;
-      while (i < sql.length) {
-        if (sql[i] === "'") {
-          i++;
-          if (i < sql.length && sql[i] === "'") {
-            i++;
-            continue;
-          }
-          break;
-        }
-        i++;
-      }
-      continue;
-    }
-    if (ch === "`") {
-      i++;
-      while (i < sql.length && sql[i] !== "`") i++;
-      if (i < sql.length) i++;
-      continue;
-    }
-    if (ch === "-" && sql[i + 1] === "-") {
-      i += 2;
-      while (i < sql.length && sql[i] !== "\n") i++;
-      continue;
-    }
-    if (ch === "/" && sql[i + 1] === "*") {
-      i += 2;
-      while (i < sql.length) {
-        if (sql[i] === "*" && sql[i + 1] === "/") {
-          i += 2;
-          break;
-        }
-        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(", ");
-}
 function resolveTokenValue(raw) {
   if (raw.startsWith("env:")) {
     const envKey = raw.slice(4);
@@ -6379,42 +6618,6 @@ function envAuth(name) {
   if (v === "token" || v === "userpass" || v === "auto") return v;
   return null;
 }
-function isDmlType(type) {
-  return type === "INSERT" || type === "INSERT_SELECT" || type === "UPDATE" || type === "DELETE" || type === "UPSERT" || type === "UPSERT_SELECT";
-}
-function hasWhereClause(stmt) {
-  if (!stmt || typeof stmt !== "object") return false;
-  const obj = stmt;
-  return obj.where !== null && obj.where !== void 0;
-}
-function getStatementType(stmt) {
-  if (!stmt || typeof stmt !== "object") return "UNKNOWN";
-  const obj = stmt;
-  return typeof obj.type === "string" ? obj.type : "UNKNOWN";
-}
-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 [];
-}
 function normalizeUnique(values) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -6683,6 +6886,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);
@@ -6799,9 +7003,9 @@ function getHistoryPath() {
 }
 function loadHistory(maxItems = 200) {
   const p = getHistoryPath();
-  if (!(0, import_fs.existsSync)(p)) return [];
+  if (!(0, import_fs2.existsSync)(p)) return [];
   try {
-    const raw = (0, import_fs.readFileSync)(p, "utf-8");
+    const raw = (0, import_fs2.readFileSync)(p, "utf-8");
     const lines = raw.split(/\r?\n/).map((s) => s.trim()).filter((s) => s.length > 0);
     return lines.slice(-maxItems);
   } catch {
@@ -6811,26 +7015,26 @@ function loadHistory(maxItems = 200) {
 function appendHistory(sql) {
   const p = getHistoryPath();
   try {
-    (0, import_fs.appendFileSync)(p, `${sql.replace(/\s+/g, " ").trim()}
+    (0, import_fs2.appendFileSync)(p, `${sql.replace(/\s+/g, " ").trim()}
 `, "utf-8");
   } catch {
   }
 }
 function editBufferWithExternalEditor(current) {
   const editor = process.env.KSQL_EDITOR ?? process.env.VISUAL ?? process.env.EDITOR ?? (process.platform === "win32" ? "notepad" : "vi");
-  const dir = (0, import_fs.mkdtempSync)((0, import_path.join)((0, import_os.tmpdir)(), "ksql-edit-"));
+  const dir = (0, import_fs2.mkdtempSync)((0, import_path.join)((0, import_os.tmpdir)(), "ksql-edit-"));
   const filePath = (0, import_path.join)(dir, "query.sql");
   try {
-    (0, import_fs.writeFileSync)(filePath, current, "utf-8");
+    (0, import_fs2.writeFileSync)(filePath, current, "utf-8");
     const cmd = `"${editor}" "${filePath}"`;
     const res = (0, import_child_process.spawnSync)(cmd, { stdio: "inherit", shell: true });
     if (res.error) throw res.error;
     if ((res.status ?? 0) !== 0) {
       throw new Error(`Editor exited with code ${res.status ?? 1}`);
     }
-    return (0, import_fs.readFileSync)(filePath, "utf-8").replace(/\r\n/g, "\n");
+    return (0, import_fs2.readFileSync)(filePath, "utf-8").replace(/\r\n/g, "\n");
   } finally {
-    (0, import_fs.rmSync)(dir, { recursive: true, force: true });
+    (0, import_fs2.rmSync)(dir, { recursive: true, force: true });
   }
 }
 async function runConsole(base) {
@@ -7012,11 +7216,11 @@ async function runConsole(base) {
           }
           try {
             if (meta.append) {
-              (0, import_fs.appendFileSync)(meta.path, lastOutput, "utf-8");
+              (0, import_fs2.appendFileSync)(meta.path, lastOutput, "utf-8");
               process.stdout.write(`saved (append): ${meta.path}
 `);
             } else {
-              (0, import_fs.writeFileSync)(meta.path, lastOutput, "utf-8");
+              (0, import_fs2.writeFileSync)(meta.path, lastOutput, "utf-8");
               process.stdout.write(`saved: ${meta.path}
 `);
             }
@@ -7127,7 +7331,7 @@ async function run() {
   let isDmlStatement = false;
   if (args.diagRecordId === null) {
     sql = args.executeSql;
-    if (!sql && args.filePath) sql = (0, import_fs.readFileSync)(args.filePath, "utf-8");
+    if (!sql && args.filePath) sql = (0, import_fs2.readFileSync)(args.filePath, "utf-8");
     if (!sql || !sql.trim()) {
       process.stderr.write("ArgumentError: SQL is empty.\n");
       return 2;
@@ -7162,8 +7366,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) {
@@ -7208,7 +7417,7 @@ async function run() {
       return 2;
     }
     if (!allowDml) {
-      process.stderr.write("ArgumentError: DML is disabled. Use --allow-dml to enable UPDATE/DELETE/INSERT/UPSERT.\n");
+      process.stderr.write("ArgumentError: DML is disabled. Use --allow-dml to enable UPDATE/DELETE/INSERT/UPSERT/REORDER.\n");
       return 2;
     }
     if ((stmtType === "UPDATE" || stmtType === "DELETE") && !hasWhere && !allowWithoutWhere) {
@@ -7478,13 +7687,14 @@ query=${label}`);
     };
     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
     });
     if (result.type !== "SELECT") {
       const output2 = buildMutationOutput(result, format, noHeader, pretty);
-      if (outputPath) (0, import_fs.writeFileSync)(outputPath, `${output2}
+      if (outputPath) (0, import_fs2.writeFileSync)(outputPath, `${output2}
 `, "utf-8");
       else if (output2) process.stdout.write(`${output2}
 `);
@@ -7493,7 +7703,7 @@ query=${label}`);
       return 0;
     }
     const output = buildOutput(result, format, noHeader, pretty, displayOptions);
-    if (outputPath) (0, import_fs.writeFileSync)(outputPath, `${output}
+    if (outputPath) (0, import_fs2.writeFileSync)(outputPath, `${output}
 `, "utf-8");
     else if (output) process.stdout.write(`${output}
 `);