@rex0220/kintone-sql-tools 3.9.0 → 3.10.0

package/dist-cli/ksql.js

@@ -4020,18 +4020,18 @@ function assertSafeParentWhere(where, multipleParents) {
   if (!multipleParents) {
     unsupported("a parent WHERE other than the single condition $id = <positive safe integer> in this phase");
   }
-  assertSafeParentPredicateNode(where);
+  assertSafeParentPredicateNode(where, multipleParents);
 }
-function assertSafeParentPredicateNode(node) {
+function assertSafeParentPredicateNode(node, allowKlike) {
   if (Array.isArray(node)) {
-    for (const value of node) assertSafeParentPredicateNode(value);
+    for (const value of node) assertSafeParentPredicateNode(value, allowKlike);
     return;
   }
   if (node === null || typeof node !== "object") return;
   const item = node;
   const type = typeof item["type"] === "string" ? item["type"] : null;
   const op = typeof item["op"] === "string" ? item["op"] : null;
-  if (op === "KLIKE" || op === "NOT_KLIKE") unsupported("KLIKE in parent WHERE");
+  if (!allowKlike && (op === "KLIKE" || op === "NOT_KLIKE")) unsupported("KLIKE in parent WHERE");
   if (type === "SELECT" || type === "SCALAR_SUBQUERY" || type === "SUBQUERY_IN_LIST" || type === "EXISTS") {
     unsupported("subqueries in parent WHERE");
   }
@@ -4040,7 +4040,7 @@ function assertSafeParentPredicateNode(node) {
     unsupported("aggregate or window expressions in parent WHERE");
   }
   if (type === "KINTONE_FUNC") unsupported("non-deterministic kintone functions in parent WHERE");
-  for (const value of Object.values(item)) assertSafeParentPredicateNode(value);
+  for (const value of Object.values(item)) assertSafeParentPredicateNode(value, allowKlike);
 }
 function assertSafeChildPredicate(where, idxSelectors) {
   assertSafeApplyNode(where, "child row selectors", idxSelectors);
@@ -5082,31 +5082,31 @@ function isTargetField(field, options) {
 }
 
 // src/core/optimization/klikePushdownPlan.ts
+function buildSingleTableKlikePushdownPlan(where, options = {}) {
+  const condition = where !== null && options.extractCondition !== false ? extractSafePushdownLeaves(where, options) : null;
+  const appliedKlikes = /* @__PURE__ */ new Set();
+  collectKlikes(condition, appliedKlikes);
+  const allKlikes = /* @__PURE__ */ new Set();
+  collectKlikes(where, allKlikes);
+  return { condition, appliedKlikes, allKlikes: [...allKlikes] };
+}
 function buildKlikePushdownPlan(stmt, options = {}) {
   const joinsAreSafeForKlike = stmt.joins.every((join2) => join2.type === "INNER");
   const common = {
     allowKlike: joinsAreSafeForKlike,
     allowUnresolvedKlikeVariables: options.allowUnresolvedVariables
   };
-  let mainCondition = null;
-  if (stmt.where !== null && !stmt.from.subtableCode && stmt.from.cteName === null) {
-    if (stmt.joins.length === 0) {
-      mainCondition = extractSafePushdownLeaves(stmt.where, {
-        ...common,
-        tableAlias: stmt.from.alias ?? void 0,
-        allowUnqualifiedFields: true,
-        fieldTypes: options.fieldTypesByApp?.get(stmt.from.appId),
-        fieldOptions: options.fieldOptionsByApp?.get(stmt.from.appId)
-      });
-    } else if (stmt.from.alias) {
-      mainCondition = extractSafePushdownLeaves(stmt.where, {
-        ...common,
-        tableAlias: stmt.from.alias,
-        fieldTypes: options.fieldTypesByApp?.get(stmt.from.appId),
-        fieldOptions: options.fieldOptionsByApp?.get(stmt.from.appId)
-      });
-    }
-  }
+  const mainIsPhysical = !stmt.from.subtableCode && stmt.from.cteName === null;
+  const mainHasUsableAlias = stmt.joins.length === 0 || stmt.from.alias !== null;
+  const mainPlan = buildSingleTableKlikePushdownPlan(stmt.where, {
+    ...common,
+    extractCondition: mainIsPhysical && mainHasUsableAlias,
+    tableAlias: stmt.from.alias ?? void 0,
+    allowUnqualifiedFields: stmt.joins.length === 0,
+    fieldTypes: options.fieldTypesByApp?.get(stmt.from.appId),
+    fieldOptions: options.fieldOptionsByApp?.get(stmt.from.appId)
+  });
+  const mainCondition = mainPlan.condition;
   const joinConditions = /* @__PURE__ */ new Map();
   if (stmt.where !== null) {
     for (const join2 of stmt.joins) {
@@ -5120,16 +5120,13 @@ function buildKlikePushdownPlan(stmt, options = {}) {
       if (condition !== null) joinConditions.set(join2.table.alias, condition);
     }
   }
-  const appliedKlikes = /* @__PURE__ */ new Set();
-  collectKlikes(mainCondition, appliedKlikes);
+  const appliedKlikes = new Set(mainPlan.appliedKlikes);
   for (const condition of joinConditions.values()) collectKlikes(condition, appliedKlikes);
-  const allKlikes = /* @__PURE__ */ new Set();
-  collectKlikes(stmt.where, allKlikes);
   return {
     mainCondition,
     joinConditions,
     appliedKlikes,
-    allKlikes: [...allKlikes]
+    allKlikes: mainPlan.allKlikes
   };
 }
 function unappliedKlikes(plan) {
@@ -5197,16 +5194,65 @@ function validateStatement(stmt) {
     case "ASSERT":
       validateNestedSelects(stmt);
       return;
+    case "UPDATE":
+      if (stmt.applyBlocks?.length && !isSinglePositiveRecordIdWhere(stmt.where) && whereHasKlike(stmt.where)) {
+        validateKlikeWhereExpressions(stmt.where);
+        validateNestedSelects(stmt);
+        return;
+      }
+      if (containsKlike(stmt) && stmt.subtableCode) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE \u306E WHERE \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
+        );
+      }
+      if (!stmt.applyBlocks?.length && !stmt.subtableCode && whereHasKlike(stmt.where) && !containsKlikeOutsideWhereAndNestedSelects(stmt, stmt.where)) {
+        validateKlikeWhereExpressions(stmt.where);
+        validateNestedSelects(stmt);
+        return;
+      }
+      if (containsKlike(stmt)) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F\u901A\u5E38\u89AA UPDATE \u306E WHERE\u3001\u307E\u305F\u306F APPLY \u8907\u6570\u89AA UPDATE \u306E\u5B89\u5168\u306A\u89AA WHERE \u3060\u3051\u3067\u4F7F\u7528\u3067\u304D\u307E\u3059"
+        );
+      }
+      return;
+    case "DELETE":
+      if (containsKlike(stmt) && stmt.subtableCode) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB DELETE \u306E WHERE \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
+        );
+      }
+      if (!stmt.subtableCode && whereHasKlike(stmt.where)) {
+        validateKlikeWhereExpressions(stmt.where);
+        validateNestedSelects(stmt);
+        return;
+      }
+      if (containsKlike(stmt)) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F\u901A\u5E38\u89AA DELETE \u306E WHERE \u3060\u3051\u3067\u4F7F\u7528\u3067\u304D\u307E\u3059"
+        );
+      }
+      return;
     case "INSERT":
     case "INSERT_SELECT":
+      if (containsKlike(stmt)) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F INSERT / INSERT SELECT \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
+        );
+      }
+      return;
     case "UPSERT":
     case "UPSERT_SELECT":
-    case "UPDATE":
-    case "DELETE":
+      if (containsKlike(stmt)) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F UPSERT / UPSERT SELECT \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
+        );
+      }
+      return;
     case "REORDER":
       if (containsKlike(stmt)) {
         throw new KlikeValidationError(
-          "KLIKE / NOT KLIKE \u306F\u5168 DML\uFF08UPDATE / DELETE / INSERT / UPSERT / REORDER\uFF09\u3067\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
+          "KLIKE / NOT KLIKE \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB REORDER \u306E WHERE \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
         );
       }
       return;
@@ -5221,6 +5267,22 @@ function validateStatement(stmt) {
       return;
   }
 }
+function validateKlikeWhereExpressions(where) {
+  walkWithoutNestedSelects(where, (expr) => {
+    if (!isKlike(expr)) return;
+    const right = expr.right;
+    if (right.type !== "STRING" && right.type !== "VARIABLE") {
+      throw new KlikeValidationError(
+        "KLIKE / NOT KLIKE \u306E\u53F3\u8FBA\u306B\u306F\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u307E\u305F\u306F\u6587\u5B57\u5217\u30D0\u30C3\u30C1\u5909\u6570\u304C\u5FC5\u8981\u3067\u3059"
+      );
+    }
+    if (right.type === "STRING" && right.value.includes("%")) {
+      throw new KlikeValidationError(
+        "KLIKE / NOT KLIKE \u306E\u691C\u7D22\u8A9E\u306B % \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002SQL \u30EF\u30A4\u30EB\u30C9\u30AB\u30FC\u30C9\u691C\u7D22\u306B\u306F LIKE \u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044"
+      );
+    }
+  });
+}
 function validateSelectLike(query) {
   if (query.type === "SELECT") validateSelect(query);
   else if (query.type === "UNION") validateUnion(query);
@@ -5289,6 +5351,25 @@ function containsKlike(node) {
   });
   return found;
 }
+function containsKlikeOutsideWhereAndNestedSelects(node, allowedWhere) {
+  let found = false;
+  const visit = (value) => {
+    if (found || value === allowedWhere || value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item);
+      return;
+    }
+    const obj = value;
+    if (obj.type === "SELECT") return;
+    if (obj.type === "BINARY" && (obj.op === "KLIKE" || obj.op === "NOT_KLIKE")) {
+      found = true;
+      return;
+    }
+    for (const child of Object.values(obj)) visit(child);
+  };
+  visit(node);
+  return found;
+}
 function isDescendantOf(root, target) {
   if (root === null) return false;
   if (root === target) return true;
@@ -6598,11 +6679,6 @@ function evaluateCustomChecks(groups, row, resolveFieldType) {
 
 // src/converter/dmlToKintone.ts
 function assertDmlWhereIsSafe(where) {
-  if (whereHasKlike(where)) {
-    throw new DmlConvertError(
-      "UPDATE / DELETE \u306E WHERE \u306B KLIKE / NOT KLIKE \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002kintone \u30AD\u30FC\u30EF\u30FC\u30C9\u691C\u7D22\u306E\u6253\u3061\u5207\u308A\u3092\u691C\u51FA\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u5168 DML \u3067\u5B89\u5168\u4E0A\u62D2\u5426\u3057\u3066\u3044\u307E\u3059\u3002"
-    );
-  }
   if (!whereHasLike(where)) return;
   throw new DmlConvertError(
     "UPDATE / DELETE \u306E WHERE \u306B LIKE / NOT LIKE \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002LIKE \u306F kSQL \u306E\u610F\u5473\u8AD6\u306B\u5F93\u3063\u3066 JS \u3067\u8A55\u4FA1\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u304C\u3001\u89AA\u30EC\u30B3\u30FC\u30C9 DML \u306B\u306F JS \u8A55\u4FA1\u7D4C\u8DEF\u304C\u306A\u3044\u305F\u3081\u3001\u5B89\u5168\u4E0A\u62D2\u5426\u3057\u307E\u3057\u305F\u3002SELECT \u3067\u5BFE\u8C61\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u3092\u78BA\u8A8D\u3057\u3001IN \u307E\u305F\u306F\u5B8C\u5168\u4E00\u81F4\u3067\u5BFE\u8C61\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
@@ -9368,6 +9444,21 @@ async function resolveDmlTargetIds(getRecords, app, query, options) {
   };
 }
 
+// src/core/optimization/applyParentSelectionPlan.ts
+function buildApplyParentSelectionPlan(where, metadata) {
+  const plan = buildSingleTableKlikePushdownPlan(where, {
+    allowUnqualifiedFields: true,
+    allowKlike: true,
+    fieldTypes: metadata.fieldTypes,
+    fieldOptions: metadata.fieldOptions
+  });
+  return {
+    prefilter: plan.condition,
+    appliedKlikes: plan.appliedKlikes,
+    unappliedKlikes: plan.allKlikes.filter((expr) => !plan.appliedKlikes.has(expr))
+  };
+}
+
 // src/core/optimization/canonicalOrderPlanner.ts
 var REST_OFFSET_MAX = 1e4;
 var REST_LIMIT_MAX = 500;
@@ -11645,7 +11736,7 @@ function attachSearchAbortWarning(result, collector) {
 }
 async function executeParsedStatement(stmt, client, options, cacheContext) {
   const unresolved = findVariableRef(stmt);
-  if (unresolved !== null) {
+  if (unresolved !== null && !isApplyParentKlikeStatement(stmt)) {
     throw new Error(`ParseError: variable @${unresolved} is not defined in a batch.`);
   }
   assertApplyScope("phase15b", stmt);
@@ -16141,16 +16232,21 @@ async function executeMultipleParentApplyPreflight(stmt, client, options, cacheC
   );
   const fieldInfos = await getFieldsCached(stmt.appId, client, cacheContext);
   const metadata = resolveApplyPatchMetadata(stmt, fieldInfos);
-  const fields = collectApplySnapshotFields(stmt, fieldInfos);
-  const baseQuery = updateToGetQuery(stmt).query;
-  const detectionLimit = dmlMaxRows + 1;
-  const snapshots = await fetchAll(client.getRecords, stmt.appId, baseQuery, [...fields], {
-    pageSize: Math.min(500, detectionLimit),
-    parallel: options.fetchParallel ?? 1,
-    maxRecords: detectionLimit,
-    stopAfter: detectionLimit,
-    onLimit: "error"
-  });
+  let snapshots;
+  if (usesApplyParentResidualSelection(stmt)) {
+    snapshots = await selectApplyParentSnapshots(stmt, client, options, fieldInfos, cacheContext);
+  } else {
+    const fields = collectApplySnapshotFields(stmt, fieldInfos);
+    const baseQuery = updateToGetQuery(stmt).query;
+    const detectionLimit = dmlMaxRows + 1;
+    snapshots = await fetchAll(client.getRecords, stmt.appId, baseQuery, [...fields], {
+      pageSize: Math.min(500, detectionLimit),
+      parallel: options.fetchParallel ?? 1,
+      maxRecords: detectionLimit,
+      stopAfter: detectionLimit,
+      onLimit: "error"
+    });
+  }
   if (!stmt.validateOnly && snapshots.length > dmlMaxRows) {
     throw new Error(`ArgumentError: APPLY parent rows (${snapshots.length}) exceed dmlMaxRows (${dmlMaxRows}).`);
   }
@@ -16182,6 +16278,95 @@ async function executeMultipleParentApplyPreflight(stmt, client, options, cacheC
   const result = await executePreparedApplyWrite(prepared, client, diagnostic2);
   return { ...result, diagnostic: withApplyDiagnosticProgress(diagnostic2, result) };
 }
+function usesApplyParentResidualSelection(stmt) {
+  return (stmt.applyBlocks?.length ?? 0) > 0 && !isSinglePositiveRecordIdWhere(stmt.where) && (whereHasLike(stmt.where) || whereHasKlike(stmt.where));
+}
+function isApplyParentKlikeStatement(stmt) {
+  const target = stmt.type === "EXPLAIN" ? stmt.query : stmt;
+  return target.type === "UPDATE" && usesApplyParentResidualSelection(target) && whereHasKlike(target.where);
+}
+var APPLY_PARENT_UNAPPLIED_KLIKE_ERROR = "APPLY \u8907\u6570\u89AA UPDATE \u306E\u89AA WHERE \u306B\u3001\u5B89\u5168\u306B\u62BC\u3057\u4E0B\u3052\u3089\u308C\u306A\u3044 KLIKE / NOT KLIKE \u304C\u3042\u308A\u307E\u3059\u3002\nOR / NOT \u914D\u4E0B\u306A\u3069 native query \u3078\u5B8C\u5168\u306B\u9069\u7528\u3067\u304D\u306A\u3044 KLIKE \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002\nWHERE \u3092 AND \u306E\u5B89\u5168\u306A KLIKE \u6761\u4EF6\u3078\u66F8\u304D\u63DB\u3048\u308B\u304B\u3001SELECT \u3067\u78BA\u8A8D\u3057\u305F $id IN (...) \u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
+function assertApplyParentKlikesFullyApplied(plan) {
+  if (plan.unappliedKlikes.length > 0) throw new Error(`UnsupportedError: ${APPLY_PARENT_UNAPPLIED_KLIKE_ERROR}`);
+}
+async function selectApplyParentSnapshots(stmt, client, options, fieldInfos, cacheContext) {
+  const topLevelInfos = fieldInfos.filter((field) => !field.inSubtable);
+  const infoByCode = new Map(topLevelInfos.map((field) => [field.code, field]));
+  const fieldTypes = new Map(topLevelInfos.map((field) => [field.code, field.fieldType]));
+  const fieldOptions = new Map(topLevelInfos.flatMap((field) => field.optionOrder ? [[field.code, new Set(Object.keys(field.optionOrder))]] : []));
+  const selectionPlan = buildApplyParentSelectionPlan(stmt.where, { fieldTypes, fieldOptions });
+  assertApplyParentKlikesFullyApplied(selectionPlan);
+  const prefilterQuery = selectionPlan.prefilter === null ? "" : whereToKintone(selectionPlan.prefilter);
+  const fields = new Set(collectApplySnapshotFields(stmt, fieldInfos));
+  for (const field of collectApplyParentWhereFields(stmt.where)) fields.add(field);
+  const resolvers = await buildApplyParentFieldResolvers(
+    stmt.appId,
+    stmt.where,
+    infoByCode,
+    client,
+    cacheContext
+  );
+  const candidates = await fetchAll(
+    client.getRecords,
+    stmt.appId,
+    prefilterQuery,
+    [...fields],
+    {
+      maxRecords: options.maxRecords ?? 1e4,
+      parallel: options.fetchParallel ?? 1,
+      onLimit: "error"
+      // prefilter は target の超集合なので stopAfter を設定せず最後まで取得する。
+    }
+  );
+  return candidates.map((snapshot) => ({ snapshot, row: flatten(snapshot, null) })).filter(({ row }) => evalWhere(
+    stmt.where,
+    row,
+    resolvers.fieldTypeResolver,
+    selectionPlan.appliedKlikes,
+    resolvers.fieldSemanticsResolver
+  )).map(({ snapshot }) => snapshot);
+}
+function collectApplyParentWhereFields(where) {
+  return collectValidateWhereFields(where);
+}
+async function buildApplyParentFieldResolvers(appId, where, infoByCode, client, cacheContext) {
+  const orderedFields = collectOrderedWhereFields(where);
+  const needsStatusOrder = [...orderedFields].some((field) => infoByCode.get(field)?.fieldType === "STATUS");
+  const statusOrder = needsStatusOrder ? await loadProcessStatusOrder(appId, client, cacheContext) : void 0;
+  const fieldTypeResolver = (field) => field.field === "$id" ? "NUMBER" : infoByCode.get(field.field)?.fieldType;
+  const fieldSemanticsResolver = (field) => {
+    if (field.field === "$id") {
+      return withFieldSemanticSource(resolveFieldSemantics({ fieldType: "__ID__" }), appId, "$id");
+    }
+    const info = infoByCode.get(field.field);
+    if (!info) return void 0;
+    const base = info.semantics ?? resolveFieldSemantics(info);
+    const semantics = info.fieldType === "STATUS" && statusOrder ? { ...base, optionOrder: statusOrder } : base;
+    return withFieldSemanticSource(semantics, appId, info.code);
+  };
+  return { fieldTypeResolver, fieldSemanticsResolver };
+}
+function collectOrderedWhereFields(where) {
+  const fields = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const value = node;
+    if (value["type"] === "SELECT") return;
+    if (value["type"] === "BINARY" && [">", "<", ">=", "<="].includes(String(value["op"]))) {
+      const left = value["left"];
+      if (left?.["type"] === "FIELD" && typeof left["field"] === "string") {
+        fields.add(left["field"]);
+      }
+    }
+    Object.values(value).forEach(visit);
+  };
+  visit(where);
+  return fields;
+}
 function materializePreparedApplyInsertValidation(stmt, prepared, fieldInfos) {
   const errors = prepared.validations.flatMap((validation) => validation.errors);
   const invalidRows = prepared.validations.reduce(
@@ -17067,6 +17252,7 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
   return cache;
 }
 var validateExplainInfo = /* @__PURE__ */ new WeakMap();
+var applyParentExplainPlan = /* @__PURE__ */ new WeakMap();
 async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords = 1e4) {
   const fieldApps = /* @__PURE__ */ new Set();
   const processStatusApps = /* @__PURE__ */ new Set();
@@ -17191,12 +17377,19 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         const update = node;
         const fields = await getFieldsCached(update.appId, tracedClient, cacheContext);
         resolveApplyPatchMetadata(update, fields);
+        if (usesApplyParentResidualSelection(update)) {
+          const topLevel = fields.filter((field) => !field.inSubtable);
+          const selectionPlan = buildApplyParentSelectionPlan(update.where, {
+            fieldTypes: new Map(topLevel.map((field) => [field.code, field.fieldType])),
+            fieldOptions: new Map(topLevel.flatMap((field) => field.optionOrder ? [[field.code, new Set(Object.keys(field.optionOrder))]] : []))
+          });
+          applyParentExplainPlan.set(update, selectionPlan);
+        }
+      }
+      const dml = node;
+      if (dml.type !== "UPDATE" || !usesApplyParentResidualSelection(dml)) {
+        await assertDmlWhereCapability(dml, tracedClient, cacheContext);
       }
-      await assertDmlWhereCapability(
-        node,
-        tracedClient,
-        cacheContext
-      );
     }
     await Promise.all(Object.values(typed).map(visit));
   };
@@ -17367,7 +17560,8 @@ async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxA
         analysis.capabilities,
         analysis.orderPlans,
         dmlMaxRows,
-        dmlMaxSubtableRows
+        dmlMaxSubtableRows,
+        maxRecords
       ),
       cursorMaxActive
     )
@@ -17390,7 +17584,7 @@ function addCursorConcurrency(lines, cursorMaxActive) {
   }
   return result;
 }
-function buildExplainPlan(query, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS) {
+function buildExplainPlan(query, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, maxRecords = 1e4) {
   if (query.type === "UNION") return buildUnionPlan(query, capabilities, orderPlans);
   if (query.type === "WITH") return buildWithPlan(query, capabilities, orderPlans);
   if (query.type === "INSERT") return buildInsertPlan(query, label, dmlMaxRows, dmlMaxSubtableRows);
@@ -17403,7 +17597,8 @@ function buildExplainPlan(query, label, capabilities, orderPlans, dmlMaxRows = 1
     capabilities,
     orderPlans,
     dmlMaxRows,
-    dmlMaxSubtableRows
+    dmlMaxSubtableRows,
+    maxRecords
   );
   if (query.type === "DELETE") return buildDeletePlan(query, label);
   if (query.type === "REORDER") return buildReorderPlan(query, label);
@@ -17709,9 +17904,9 @@ function buildInsertSelectPlan(stmt, label, capabilities, orderPlans) {
   lines.push(...buildSelectPlan(stmt.select, "[source SELECT]", capabilities, orderPlans));
   return lines;
 }
-function buildUpdatePlan(stmt, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS) {
+function buildUpdatePlan(stmt, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, maxRecords = 1e4) {
   if (stmt.applyBlocks?.length) {
-    return buildUpdateApplyPlan(stmt, label, dmlMaxRows, dmlMaxSubtableRows);
+    return buildUpdateApplyPlan(stmt, label, dmlMaxRows, dmlMaxSubtableRows, maxRecords);
   }
   const isArith = hasArithAssignment(stmt);
   const isStringFunc = stmt.assignments.some((a) => a.value.type === "STRING_FUNC");
@@ -17729,6 +17924,10 @@ function buildUpdatePlan(stmt, label, capabilities, orderPlans, dmlMaxRows = 100
   } else {
     lines.push(`  kintone query: ${safeWhereToKintone(stmt.where)}`);
   }
+  if (!stmt.subtableCode) {
+    lines.push("  selection: exact native pushdown; JS residual none");
+    lines.push("  search abort: DML fail-closed (SearchAbortedError; mutation 0)");
+  }
   lines.push(isConstantFalseWhere(stmt.where) ? "  api:           metadata validation only (records API access: none)" : `  api:           GET /k/v1/records.json \u2192 PUT /k/v1/records.json`);
   const setTypes = [];
   if (isArith) setTypes.push("\u7B97\u8853 SET\uFF08\u73FE\u5728\u5024\u3092\u53D6\u5F97\u3057\u3066\u8A08\u7B97\uFF09");
@@ -17754,7 +17953,7 @@ function buildUpdatePlan(stmt, label, capabilities, orderPlans, dmlMaxRows = 100
   }
   return lines;
 }
-function buildUpdateApplyPlan(stmt, label, dmlMaxRows, dmlMaxSubtableRows) {
+function buildUpdateApplyPlan(stmt, label, dmlMaxRows, dmlMaxSubtableRows, maxRecords) {
   const diagnostic2 = buildStaticApplyDiagnostic(stmt, dmlMaxRows, dmlMaxSubtableRows);
   const branch = diagnostic2.branches[0];
   const blocks = stmt.applyBlocks;
@@ -17768,12 +17967,24 @@ function buildUpdateApplyPlan(stmt, label, dmlMaxRows, dmlMaxSubtableRows) {
   });
   const operationKinds = [...new Set(branch.targets.flatMap((target) => target.operations.map((operation) => operation.kind)))];
   const hasRemove = operationKinds.includes("REMOVE");
+  const selectionPlan = applyParentExplainPlan.get(stmt);
+  const selectionLines = selectionPlan ? [
+    "parent selection:       safe prefilter + JS residual evaluation",
+    `kintone prefilter:      ${selectionPlan.prefilter === null ? "(none; empty query)" : whereToKintone(selectionPlan.prefilter)}`,
+    "JS residual:            original parent WHERE",
+    `applied KLIKE:          ${selectionPlan.appliedKlikes.size}`,
+    `unapplied KLIKE:        ${selectionPlan.unappliedKlikes.length}${selectionPlan.unappliedKlikes.length > 0 ? " (unsupported: cannot be fully applied to native query)" : ""}`,
+    `candidate limit:        maxRecords=${maxRecords}, onLimit=error, stopAfter=none`,
+    `target guard:           dmlMaxRows=${dmlMaxRows} after JS residual evaluation`,
+    "search abort:           DML fail-closed (B7-P3; all surfaces, no surface gate)"
+  ] : [];
   return [
     ...label ? [label] : [],
     "statement:              UPDATE APPLY",
     `target app:             APP${stmt.appId}`,
     `parent selector:        ${safeWhereToKintone(stmt.where)}`,
-    "parent cardinality:     single",
+    `parent cardinality:     ${isSinglePositiveRecordIdWhere(stmt.where) ? "single" : "multiple"}`,
+    ...selectionLines,
     `apply target:           ${branch.targets.map((target) => `${target.field} (${target.targetKind})`).join(" | ")}`,
     `operations:             ${operationKinds.join(" | ")}`,
     `selector:               ${selectorKinds.join(" | ")}`,
@@ -17799,6 +18010,10 @@ function buildDeletePlan(stmt, label) {
   lines.push(`  [DELETE]`);
   lines.push(`  target:        APP${stmt.appId} (${stmt.appId})`);
   lines.push(`  kintone query: ${safeWhereToKintone(stmt.where)}`);
+  if (!stmt.subtableCode) {
+    lines.push("  selection: exact native pushdown; JS residual none");
+    lines.push("  search abort: DML fail-closed (SearchAbortedError; mutation 0)");
+  }
   lines.push(isConstantFalseWhere(stmt.where) ? "  api:           metadata validation only (records API access: none)" : `  api:           GET /k/v1/records.json \u2192 DELETE /k/v1/records.json`);
   return lines;
 }
@@ -18802,6 +19017,12 @@ function getCursorLeaseManager(host, maxActive = DEFAULT_MAX_ACTIVE) {
   return manager;
 }
 
+// src/core/searchAbortWarning.ts
+var SEARCH_ABORTED_HEADER_VALUE = "Filter aborted because of too many search results";
+function isSearchAbortedWarning(value) {
+  return value?.includes(SEARCH_ABORTED_HEADER_VALUE) === true;
+}
+
 // src/node/kintoneMetadata.ts
 var KINTONE_METADATA_RESOURCES = [
   "app",
@@ -18994,7 +19215,6 @@ var KintoneApiError = class extends Error {
     this.name = "KintoneApiError";
   }
 };
-var SEARCH_ABORTED_HEADER_VALUE = "Filter aborted because of too many search results";
 function createNodeKintoneConnection(baseUrl, tokenResolver) {
   const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
   const apiBasePath = tokenResolver.guestSpaceId && tokenResolver.guestSpaceId > 0 ? `/k/guest/${tokenResolver.guestSpaceId}/v1` : "/k/v1";
@@ -19052,10 +19272,9 @@ function createNodeKintoneConnection(baseUrl, tokenResolver) {
     if (tokenResolver.debug) {
       tokenResolver.log?.(`[debug] response status=${res.status}`);
     }
-    const warning = res.headers.get("X-Cybozu-Warning") ?? "";
     return {
       response: res,
-      searchAborted: warning.includes(SEARCH_ABORTED_HEADER_VALUE)
+      searchAborted: isSearchAbortedWarning(res.headers.get("X-Cybozu-Warning"))
     };
   }
   async function requestJsonResponse(path, init, appIdForToken) {