@rex0220/kintone-sql-tools 1.4.1 → 1.9.0

package/dist-cli/ksql.js

@@ -4367,9 +4367,9 @@ async function executeBatch(sql, client, options = {}) {
   }
   for (const s of analysis.statements) {
     if (!s.isDml || s.tempTablesReferenced.length === 0) continue;
-    if (s.statementType === "INSERT_SELECT" && s.tempOnlySource) continue;
+    if (s.statementType === "INSERT_SELECT" || s.statementType === "UPSERT_SELECT") continue;
     throw new BatchAnalysisError(
-      s.statementType === "INSERT_SELECT" ? `ArgumentError: INSERT_SELECT in a batch must select from temp tables only. (statement ${s.index})` : `ArgumentError: temp table references in ${s.statementType} are not supported yet.`,
+      `ArgumentError: temp table references in ${s.statementType} are not supported yet.`,
       s.index
     );
   }
@@ -4405,8 +4405,18 @@ async function executeBatch(sql, client, options = {}) {
     }
     try {
       const remaining = deadline !== null ? deadline - Date.now() : null;
+      const userConfirm = options.confirm;
+      const stmtOptions = userConfirm ? {
+        ...options,
+        confirm: (count, operation) => userConfirm(count, operation, {
+          statementIndex: i,
+          statementCount: statements.length,
+          statementType: info.statementType,
+          targetAppId: info.targetAppId
+        })
+      } : options;
       const outcome = await runWithDeadline(
-        executeBatchStatement(statements[i], info, countedClient, options, cacheContext, tempTables),
+        executeBatchStatement(statements[i], info, countedClient, stmtOptions, cacheContext, tempTables),
         remaining
       );
       results.push({ ...base, status: "success", ...outcome });
@@ -4457,6 +4467,9 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
     if (stmt.type === "INSERT_SELECT") {
       return { result: await executeInsertSelect(stmt, client, options, cacheContext, tempTables) };
     }
+    if (stmt.type === "UPSERT_SELECT") {
+      return { result: await executeUpsertSelect(stmt, client, options, cacheContext, tempTables) };
+    }
     throw new Error(`ArgumentError: temp table references in ${stmt.type} are not supported yet.`);
   }
   return { result: await executeParsedStatement(stmt, client, options, cacheContext) };
@@ -5778,8 +5791,8 @@ function evalOrderKeyForRow(key, row) {
       return evalStringFunc(key.expr, row);
   }
 }
-async function executeUpsertSelect(stmt, client, options, cacheContext) {
-  const selectResult = await executeSelect(stmt.select, client, options, cacheContext);
+async function executeUpsertSelect(stmt, client, options, cacheContext, cteCache) {
+  const selectResult = cteCache !== void 0 && cteCache.size > 0 ? await executeQueryWithCte(stmt.select, client, options, cteCache, cacheContext) : await executeSelect(stmt.select, client, options, cacheContext);
   const { rows, columns } = selectResult;
   if (columns.length !== stmt.fields.length) {
     throw new Error(
@@ -5988,12 +6001,18 @@ function buildPlanForBatchQuery(query, info) {
     lines.push(
       `INSERT INTO APP${query.appId} ... SELECT\uFF08\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u30BD\u30FC\u30B9\u3002\u5B9F\u884C\u6642\u306B\u4EF6\u6570\u78BA\u5B9A \u2192 dmlMaxRows \u9069\u7528\uFF09`
     );
+  } else if (query.type === "UPSERT_SELECT") {
+    lines.push(
+      `UPSERT INTO APP${query.appId} ... SELECT\uFF08\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u30BD\u30FC\u30B9\u3002\u7167\u5408\u5F8C\u306B insert + update \u5408\u8A08\u78BA\u5B9A \u2192 dmlMaxRows \u9069\u7528\uFF09`
+    );
   }
   lines.push("  mode:          FULL_SCAN\uFF08\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u53C2\u7167\uFF09");
   lines.push(
     `  temp:          ${info.tempTablesReferenced.join(", ")}\uFF08\u30A4\u30F3\u30E1\u30E2\u30EA\u8D70\u67FB\u3002\u5B9F\u4F53\u5316\u524D\u306E\u305F\u3081\u884C\u6570\u4E0D\u660E\uFF09`
   );
-  const apps = info.appIds.filter((a) => query.type !== "INSERT_SELECT" || a !== query.appId);
+  const apps = info.appIds.filter(
+    (a) => query.type !== "INSERT_SELECT" && query.type !== "UPSERT_SELECT" || a !== query.appId
+  );
   if (apps.length > 0) {
     lines.push(`  app:           ${apps.map((a) => `APP${a}`).join(", ")}`);
   }

package/dist-mcp/ksql-mcp.js

@@ -35271,9 +35271,9 @@ async function executeBatch(sql, client, options = {}) {
   }
   for (const s of analysis.statements) {
     if (!s.isDml || s.tempTablesReferenced.length === 0) continue;
-    if (s.statementType === "INSERT_SELECT" && s.tempOnlySource) continue;
+    if (s.statementType === "INSERT_SELECT" || s.statementType === "UPSERT_SELECT") continue;
     throw new BatchAnalysisError(
-      s.statementType === "INSERT_SELECT" ? `ArgumentError: INSERT_SELECT in a batch must select from temp tables only. (statement ${s.index})` : `ArgumentError: temp table references in ${s.statementType} are not supported yet.`,
+      `ArgumentError: temp table references in ${s.statementType} are not supported yet.`,
       s.index
     );
   }
@@ -35309,8 +35309,18 @@ async function executeBatch(sql, client, options = {}) {
     }
     try {
       const remaining = deadline !== null ? deadline - Date.now() : null;
+      const userConfirm = options.confirm;
+      const stmtOptions = userConfirm ? {
+        ...options,
+        confirm: (count, operation) => userConfirm(count, operation, {
+          statementIndex: i,
+          statementCount: statements.length,
+          statementType: info.statementType,
+          targetAppId: info.targetAppId
+        })
+      } : options;
       const outcome = await runWithDeadline(
-        executeBatchStatement(statements[i], info, countedClient, options, cacheContext, tempTables),
+        executeBatchStatement(statements[i], info, countedClient, stmtOptions, cacheContext, tempTables),
         remaining
       );
       results.push({ ...base, status: "success", ...outcome });
@@ -35361,6 +35371,9 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
     if (stmt.type === "INSERT_SELECT") {
       return { result: await executeInsertSelect(stmt, client, options, cacheContext, tempTables) };
     }
+    if (stmt.type === "UPSERT_SELECT") {
+      return { result: await executeUpsertSelect(stmt, client, options, cacheContext, tempTables) };
+    }
     throw new Error(`ArgumentError: temp table references in ${stmt.type} are not supported yet.`);
   }
   return { result: await executeParsedStatement(stmt, client, options, cacheContext) };
@@ -36682,8 +36695,8 @@ function evalOrderKeyForRow(key, row) {
       return evalStringFunc(key.expr, row);
   }
 }
-async function executeUpsertSelect(stmt, client, options, cacheContext) {
-  const selectResult = await executeSelect(stmt.select, client, options, cacheContext);
+async function executeUpsertSelect(stmt, client, options, cacheContext, cteCache) {
+  const selectResult = cteCache !== void 0 && cteCache.size > 0 ? await executeQueryWithCte(stmt.select, client, options, cteCache, cacheContext) : await executeSelect(stmt.select, client, options, cacheContext);
   const { rows, columns } = selectResult;
   if (columns.length !== stmt.fields.length) {
     throw new Error(
@@ -36892,12 +36905,18 @@ function buildPlanForBatchQuery(query, info) {
     lines.push(
       `INSERT INTO APP${query.appId} ... SELECT\uFF08\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u30BD\u30FC\u30B9\u3002\u5B9F\u884C\u6642\u306B\u4EF6\u6570\u78BA\u5B9A \u2192 dmlMaxRows \u9069\u7528\uFF09`
     );
+  } else if (query.type === "UPSERT_SELECT") {
+    lines.push(
+      `UPSERT INTO APP${query.appId} ... SELECT\uFF08\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u30BD\u30FC\u30B9\u3002\u7167\u5408\u5F8C\u306B insert + update \u5408\u8A08\u78BA\u5B9A \u2192 dmlMaxRows \u9069\u7528\uFF09`
+    );
   }
   lines.push("  mode:          FULL_SCAN\uFF08\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u53C2\u7167\uFF09");
   lines.push(
     `  temp:          ${info.tempTablesReferenced.join(", ")}\uFF08\u30A4\u30F3\u30E1\u30E2\u30EA\u8D70\u67FB\u3002\u5B9F\u4F53\u5316\u524D\u306E\u305F\u3081\u884C\u6570\u4E0D\u660E\uFF09`
   );
-  const apps = info.appIds.filter((a) => query.type !== "INSERT_SELECT" || a !== query.appId);
+  const apps = info.appIds.filter(
+    (a) => query.type !== "INSERT_SELECT" && query.type !== "UPSERT_SELECT" || a !== query.appId
+  );
   if (apps.length > 0) {
     lines.push(`  app:           ${apps.map((a) => `APP${a}`).join(", ")}`);
   }
@@ -38271,6 +38290,24 @@ function requireDmlApproval(input, toolName, suffix = "") {
   }
   return Number(input.dmlMaxRows);
 }
+function containsSelectBasedDml(statements) {
+  return statements.some(
+    (s) => s.statementType === "INSERT_SELECT" || s.statementType === "UPSERT_SELECT"
+  );
+}
+function resolveMutateRuntimeMaxRecords(statements, dmlMaxRows) {
+  return containsSelectBasedDml(statements) ? void 0 : dmlMaxRows + 1;
+}
+var READ_LIMIT_MESSAGE_FRAGMENT = "\u53D6\u5F97\u4EF6\u6570\u304C\u4E0A\u9650";
+var SELECT_BASED_DML_READ_LIMIT_HINT = "SELECT-based DML \u306E\u30BD\u30FC\u30B9\u8AAD\u307F\u53D6\u308A\u4E0A\u9650\u306F dmlMaxRows \u3067\u306F\u306A\u304F maxRecords \u89E3\u6C7A\u5024(KSQL_MAX_RECORDS / profile \u306E query.maxRecords\u3001\u65E2\u5B9A 500)\u3067\u5236\u5FA1\u3055\u308C\u307E\u3059\u3002dmlMaxRows \u306F\u5F71\u97FF\u884C\u6570\u30AC\u30FC\u30C9\u3067\u3059\u3002";
+function appendSelectBasedDmlReadLimitHint(err) {
+  if (err instanceof Error && err.message.includes(READ_LIMIT_MESSAGE_FRAGMENT)) {
+    const hinted = new Error(`${err.message} ${SELECT_BASED_DML_READ_LIMIT_HINT}`);
+    hinted.name = err.name;
+    return hinted;
+  }
+  return err;
+}
 function toToolResult(payload, isError = false) {
   return {
     content: [
@@ -38436,14 +38473,6 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
     for (const s of validation.statements) {
       if (!s.isDml) continue;
       const at = ` (statement ${s.index})`;
-      if (s.statementType === "INSERT_SELECT" && !s.tempOnlySource) {
-        throw new Error(
-          `ArgumentError: INSERT_SELECT in a batch must select from temp tables only.${at}`
-        );
-      }
-      if (s.statementType === "UPSERT_SELECT") {
-        throw new Error(`ArgumentError: ${s.statementType} is not supported by ksql_mutate yet.${at}`);
-      }
       if ((s.statementType === "UPDATE" || s.statementType === "DELETE") && !s.hasWhere) {
         throw new Error(`ArgumentError: ${s.statementType} without WHERE is blocked by ksql_mutate.${at}`);
       }
@@ -38460,10 +38489,13 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
         `ArgumentError: batch INSERT rows (${staticInsertTotal}) exceed dmlTotalMaxRows (${dmlTotalMaxRows}).`
       );
     }
+    const selectBasedDml = containsSelectBasedDml(validation.statements);
     const runtime = await createRuntime(serverOptions, {
       sql: input.sql,
       profile: input.profile,
-      maxRecords: dmlMaxRows + 1,
+      // SELECT-based DML を含む場合は dmlMaxRows で読み取りを絞らない（案A。
+      // resolveMutateRuntimeMaxRecords の doc コメント参照）
+      maxRecords: resolveMutateRuntimeMaxRecords(validation.statements, dmlMaxRows),
       fetchParallel: input.fetchParallel,
       onLimit: DEFAULT_ON_LIMIT,
       timeout: input.timeout
@@ -38489,7 +38521,17 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
         return true;
       }
     });
-    return toBatchQueryPayload(batchResult);
+    const payload = toBatchQueryPayload(batchResult);
+    if (selectBasedDml) {
+      for (const entry of payload.statements) {
+        if (entry.type !== "INSERT_SELECT" && entry.type !== "UPSERT_SELECT") continue;
+        const error51 = entry.error;
+        if (typeof error51?.message !== "string") continue;
+        if (!error51.message.includes(READ_LIMIT_MESSAGE_FRAGMENT)) continue;
+        entry.error = { ...error51, message: `${error51.message} ${SELECT_BASED_DML_READ_LIMIT_HINT}` };
+      }
+    }
+    return payload;
   }
   async function mutate(input) {
     const dmlMaxRows = requireDmlApproval(input, "ksql_mutate");
@@ -38500,40 +38542,40 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
     if (!validation.isDml) {
       throw new Error(`ArgumentError: ${validation.statementType} is not allowed by ksql_mutate. Use ksql_query.`);
     }
-    if (validation.statementType === "INSERT_SELECT") {
-      throw new Error(
-        "ArgumentError: INSERT_SELECT is not supported by ksql_mutate as a single statement. Wrap it in a batch: CREATE TEMP TABLE #t AS SELECT ...; INSERT INTO APPx (...) SELECT ... FROM #t;"
-      );
-    }
-    if (validation.statementType === "UPSERT_SELECT") {
-      throw new Error(`ArgumentError: ${validation.statementType} is not supported by ksql_mutate yet.`);
-    }
     if ((validation.statementType === "UPDATE" || validation.statementType === "DELETE") && !validation.hasWhere) {
       throw new Error(`ArgumentError: ${validation.statementType} without WHERE is blocked by ksql_mutate.`);
     }
     if (validation.insertValuesCount !== null && validation.insertValuesCount > dmlMaxRows) {
       throw new Error(`ArgumentError: INSERT rows (${validation.insertValuesCount}) exceed dmlMaxRows (${dmlMaxRows}).`);
     }
+    const selectBasedDml = containsSelectBasedDml(validation.statements);
     const runtime = await createRuntime(serverOptions, {
       sql: input.sql,
       profile: input.profile,
-      maxRecords: dmlMaxRows + 1,
+      // SELECT-based DML は dmlMaxRows で読み取りを絞らない（案A。
+      // resolveMutateRuntimeMaxRecords の doc コメント参照）
+      maxRecords: resolveMutateRuntimeMaxRecords(validation.statements, dmlMaxRows),
       fetchParallel: input.fetchParallel,
       onLimit: DEFAULT_ON_LIMIT,
       timeout: input.timeout
     });
-    const result = await executeSql(runtime.sql, runtime.client, {
-      maxRecords: runtime.maxRecords,
-      fetchParallel: runtime.fetchParallel,
-      onLimitReached: runtime.onLimit,
-      cacheContext: runtime.cacheContext,
-      confirm: async (count, operation) => {
-        if (count > dmlMaxRows) {
-          throw new Error(`ArgumentError: ${operation} affected rows (${count}) exceed dmlMaxRows (${dmlMaxRows}).`);
+    let result;
+    try {
+      result = await executeSql(runtime.sql, runtime.client, {
+        maxRecords: runtime.maxRecords,
+        fetchParallel: runtime.fetchParallel,
+        onLimitReached: runtime.onLimit,
+        cacheContext: runtime.cacheContext,
+        confirm: async (count, operation) => {
+          if (count > dmlMaxRows) {
+            throw new Error(`ArgumentError: ${operation} affected rows (${count}) exceed dmlMaxRows (${dmlMaxRows}).`);
+          }
+          return true;
         }
-        return true;
-      }
-    });
+      });
+    } catch (err) {
+      throw selectBasedDml ? appendSelectBasedDmlReadLimitHint(err) : err;
+    }
     if (result.type === "SELECT") {
       throw new Error(`ArgumentError: ksql_mutate returned unexpected result type ${result.type}.`);
     }
@@ -38720,7 +38762,7 @@ var mutateInputSchema = external_exports.object({
   profile,
   allowDml: external_exports.literal(true).describe("Must be true to acknowledge that this call writes to kintone."),
   confirmText: external_exports.literal("yes").describe('Must be the literal string "yes" to confirm execution.'),
-  dmlMaxRows: external_exports.number().int().positive().describe("Per-statement cap on affected rows. The call fails before writing if any statement would exceed it."),
+  dmlMaxRows: external_exports.number().int().positive().describe("Per-statement cap on affected rows. The call fails before writing if any statement would exceed it; for UPSERT it counts inserts + updates. It does NOT limit source reads of INSERT/UPSERT ... SELECT: those follow the runtime maxRecords resolution (KSQL_MAX_RECORDS / profile query.maxRecords, default 500; temp tables hold at most 10000 rows), so choose it by intended write count only."),
   fetchParallel,
   timeout,
   dmlTotalMaxRows: external_exports.number().int().positive().describe("Batch (multi-statement) only: cap on total affected rows across the whole batch (default: per-statement dmlMaxRows only). DML batches always run fail-fast.").optional()
@@ -38763,7 +38805,7 @@ var runSavedQueryInputSchema = external_exports.object({
   timeout,
   allowDml: external_exports.literal(true).describe("Required for DML saved queries: must be true to acknowledge writes.").optional(),
   confirmText: external_exports.literal("yes").describe('Required for DML saved queries: must be the literal string "yes".').optional(),
-  dmlMaxRows: external_exports.number().int().positive().describe("Required for DML saved queries: per-statement cap on affected rows.").optional()
+  dmlMaxRows: external_exports.number().int().positive().describe("Required for DML saved queries: per-statement cap on affected rows; for UPSERT it counts inserts + updates. It does NOT limit source reads of INSERT/UPSERT ... SELECT: those follow the runtime maxRecords resolution (KSQL_MAX_RECORDS / profile query.maxRecords, default 500; temp tables hold at most 10000 rows). Note: this tool's maxRecords / onLimit inputs apply to read-only saved queries only.").optional()
 });
 var validateInputShape = validateInputSchema.shape;
 var explainInputShape = explainInputSchema.shape;
@@ -38812,7 +38854,7 @@ Options:
   -h, --help         Show help
 `);
 }
-var SERVER_VERSION = true ? "1.4.1" : "0.0.0-dev";
+var SERVER_VERSION = true ? "1.9.0" : "0.0.0-dev";
 function createServer(args) {
   const server = new McpServer({
     name: "ksql-mcp",
@@ -38839,7 +38881,7 @@ function createServer(args) {
   }, tools.queryTool);
   server.registerTool("ksql_mutate", {
     title: "Run mutating kSQL",
-    description: "Execute DML kSQL with explicit allowDml, confirmText, and dmlMaxRows safety controls. Supports multi-statement DML batches with temp tables. INSERT INTO app ... SELECT is allowed in a batch when it selects only from temp tables (CREATE TEMP TABLE #t AS SELECT ...; INSERT INTO APPx (...) SELECT ... FROM #t;). Standalone INSERT_SELECT and UPSERT_SELECT are rejected.",
+    description: "Execute DML kSQL with explicit allowDml, confirmText, and dmlMaxRows safety controls. Supports multi-statement DML batches with temp tables. INSERT/UPSERT INTO app ... SELECT supports app sources, temp tables, or joins of both. For UPSERT, dmlMaxRows counts inserts + updates. dmlMaxRows caps affected rows only, not source reads: the source SELECT reads up to the runtime maxRecords (KSQL_MAX_RECORDS / profile query.maxRecords, default 500); temp tables hold at most 10000 rows.",
     inputSchema: mutateInputShape
   }, tools.mutateTool);
   server.registerTool("ksql_describe_app", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rex0220/kintone-sql-tools",
-  "version": "1.4.1",
+  "version": "1.9.0",
   "description": "kintone SQL plugin and CLI tools (ksql)",
   "publishConfig": {
     "access": "public"
@@ -34,7 +34,7 @@
     "prepack": "npm run build:cli && npm run build:mcp && npm run build:mcpb",
     "start": "run-p develop upload",
     "develop": "node build.mjs --watch",
-    "upload": "rex0220-plugin-uploader -f dist/ksql-plugin-v1.3.0.zip --watch"
+    "upload": "node scripts/upload-plugin.cjs"
   },
   "files": [
     "dist-cli/",