@rex0220/kintone-sql-tools 3.9.0 → 3.11.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);
@@ -4930,6 +4930,9 @@ function canInlineSingleCte(stmt) {
   if (stmt.ctes.length !== 1) return false;
   const cteDef = stmt.ctes[0];
   if (cteDef.query.type !== "SELECT" || resolveSelectMode(cteDef.query) !== "SIMPLE") return false;
+  if (!cteDef.query.columns.every(
+    (column) => column.type === "WILDCARD" || column.type === "FIELD" && (column.alias === null || column.alias === column.field)
+  )) return false;
   const finalQuery = stmt.query;
   if (finalQuery.type !== "SELECT") return false;
   if (finalQuery.from.cteName !== cteDef.name || finalQuery.joins.length > 0) return false;
@@ -5082,31 +5085,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 +5123,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 +5197,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 +5270,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 +5354,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 +6682,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 +9447,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;
@@ -9609,10 +9703,12 @@ function flatten(record, alias) {
   }
   return row;
 }
-function applyJoin(leftRows, rightRows, join2) {
+function applyJoin(leftRows, rightRows, join2, columns = {}) {
   const { on, type: joinType } = join2;
   const leftKey = on.left.tableAlias ? `${on.left.tableAlias}.${on.left.field}` : on.left.field;
   const rightKey = on.right.tableAlias ? `${on.right.tableAlias}.${on.right.field}` : on.right.field;
+  assertJoinKeyAvailable(leftRows, leftKey, columns.leftColumns);
+  assertJoinKeyAvailable(rightRows, rightKey, columns.rightColumns);
   if (joinType === "RIGHT") {
     const leftIndex = /* @__PURE__ */ new Map();
     for (const lRow of leftRows) {
@@ -9622,7 +9718,7 @@ function applyJoin(leftRows, rightRows, join2) {
       else leftIndex.set(k, [lRow]);
     }
     const emptyLeft = {};
-    for (const key of Object.keys(leftRows[0] ?? {})) emptyLeft[key] = "";
+    for (const key of columns.leftColumns ?? Object.keys(leftRows[0] ?? {})) emptyLeft[key] = "";
     const result2 = [];
     for (const rRow of rightRows) {
       const k = rRow[rightKey] ?? "";
@@ -9644,7 +9740,7 @@ function applyJoin(leftRows, rightRows, join2) {
   }
   const result = [];
   const emptyRight = {};
-  for (const key of Object.keys(rightRows[0] ?? {})) emptyRight[key] = "";
+  for (const key of columns.rightColumns ?? Object.keys(rightRows[0] ?? {})) emptyRight[key] = "";
   for (const lRow of leftRows) {
     const k = lRow[leftKey] ?? "";
     const matched = rightIndex.get(k) ?? [];
@@ -9658,6 +9754,12 @@ function applyJoin(leftRows, rightRows, join2) {
   }
   return result;
 }
+function assertJoinKeyAvailable(rows, key, savedColumns) {
+  const missing = rows.length > 0 ? rows.some((row) => !Object.prototype.hasOwnProperty.call(row, key)) : savedColumns !== void 0 && !savedColumns.includes(key);
+  if (missing) {
+    throw new Error(`ArgumentError: JOIN key ${key} is not available in the materialized table.`);
+  }
+}
 function applyFilter(rows, where, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
   if (where === null) return rows;
   return rows.filter((row) => evalWhere(where, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2));
@@ -9956,9 +10058,12 @@ function applyLimit(rows, limit, offset) {
   if (limit === null) return rows.slice(start);
   return rows.slice(start, start + limit);
 }
-function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, resolveFieldSemantics2) {
+function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, resolveFieldSemantics2, hiddenQualifiedAliases) {
   if (columns.length === 1 && columns[0].type === "WILDCARD") {
-    const projected2 = rows.map((row) => stripParentShortcutColumns(row));
+    const projected2 = rows.map((row) => stripHiddenQualifiedColumns(
+      stripParentShortcutColumns(row),
+      hiddenQualifiedAliases
+    ));
     const cols = projected2.length > 0 ? Object.keys(projected2[0]) : [...sourceColumns ?? []];
     return { rows: projected2, columns: cols };
   }
@@ -9978,7 +10083,10 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, re
         case "VARIABLE_COL":
           throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
         case "WILDCARD":
-          Object.assign(out, stripParentShortcutColumns(row));
+          Object.assign(out, stripHiddenQualifiedColumns(
+            stripParentShortcutColumns(row),
+            hiddenQualifiedAliases
+          ));
           break;
         case "PARENT_WILDCARD": {
           const parentKeys = Object.keys(row).filter((k) => k.startsWith("_p.")).sort();
@@ -10231,6 +10339,27 @@ function resolveAggInStringFuncExpr(expr, rows, resolveAggSortKind) {
     args: expr.args.map((arg) => resolveAggInStringFuncArg(arg, rows, resolveAggSortKind))
   };
 }
+function stripHiddenQualifiedColumns(row, hiddenQualifiedAliases) {
+  if (!hiddenQualifiedAliases || hiddenQualifiedAliases.size === 0) return row;
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    if ([...hiddenQualifiedAliases].some((alias) => key.startsWith(`${alias}.`))) continue;
+    out[key] = value;
+  }
+  return out;
+}
+function flattenedColumns(columns, alias) {
+  if (columns === void 0) return void 0;
+  return alias ? columns.flatMap((column) => [`${alias}.${column}`, column]) : [...columns];
+}
+function mergeKnownColumns(left, right, rows) {
+  if (left === void 0 && right === void 0 && rows.length === 0) return void 0;
+  return [.../* @__PURE__ */ new Set([
+    ...left ?? [],
+    ...right ?? [],
+    ...Object.keys(rows[0] ?? {})
+  ])];
+}
 function deriveOutputOrderSemantics(columns) {
   const result = /* @__PURE__ */ new Map();
   for (const column of columns) {
@@ -10265,7 +10394,9 @@ function runFullScan(input) {
     havingFieldSemanticsResolver,
     aggregateSortKindResolver,
     appliedKlikes,
-    sourceColumns
+    sourceColumns,
+    tableColumns,
+    hiddenQualifiedAliases
   } = input;
   const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns);
   for (const [key, value] of orderSemantics ?? []) effectiveOrderSemantics.set(key, value);
@@ -10273,11 +10404,25 @@ function runFullScan(input) {
   const mainAlias = stmt.from.alias;
   const mainRecords = tables.get(mainAlias) ?? tables.get(null) ?? [];
   rows = mainRecords.map((r) => flatten(r, mainAlias));
+  let knownColumns = mergeKnownColumns(
+    flattenedColumns(tableColumns?.get(mainAlias), mainAlias),
+    void 0,
+    rows
+  );
   for (const join2 of stmt.joins) {
     const rightAlias = join2.table.alias;
     const rightRecords = tables.get(rightAlias) ?? [];
     const rightRows = rightRecords.map((r) => flatten(r, rightAlias));
-    rows = applyJoin(rows, rightRows, join2);
+    const rightColumns = mergeKnownColumns(
+      flattenedColumns(tableColumns?.get(rightAlias), rightAlias),
+      void 0,
+      rightRows
+    );
+    rows = applyJoin(rows, rightRows, join2, {
+      leftColumns: knownColumns,
+      rightColumns
+    });
+    knownColumns = mergeKnownColumns(knownColumns, rightColumns, rows);
   }
   rows = applyFilter(rows, stmt.where, fieldTypeResolver, appliedKlikes, fieldSemanticsResolver);
   if (stmt.groupBy.length > 0 || hasAggregateColumns(stmt.columns)) {
@@ -10290,7 +10435,15 @@ function runFullScan(input) {
   }
   rows = applyOrderBy(rows, stmt.orderBy, optionOrders, sortKinds, effectiveOrderSemantics);
   rows = applyLimit(rows, stmt.limit, stmt.offset);
-  return project(rows, stmt.columns, scalarCache, fieldTypeResolver, sourceColumns, fieldSemanticsResolver);
+  return project(
+    rows,
+    stmt.columns,
+    scalarCache,
+    fieldTypeResolver,
+    sourceColumns,
+    fieldSemanticsResolver,
+    hiddenQualifiedAliases
+  );
 }
 
 // src/converter/subtableAdapter.ts
@@ -11645,7 +11798,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);
@@ -12602,7 +12755,7 @@ async function buildWhereFieldSemanticsResolver(stmt, client, cacheContext, mate
       if (field.tableAlias === "_p" && stmt.from.subtableCode && stmt.from.cteName === null) {
         return fromPhysical(stmt.from, field.field, false);
       }
-      const table = tables.find((candidate) => candidate.alias === field.tableAlias);
+      const table = tables.find((candidate) => effectiveTableAlias(candidate) === field.tableAlias);
       if (!table) return void 0;
       if (table.cteName !== null) {
         return materializedTables?.get(table.cteName)?.columnMeta?.get(field.field)?.semantics ?? syntheticSemantics("string");
@@ -13036,8 +13189,11 @@ function collectSelectTypedInFieldRefs(stmt) {
   }
   return refs;
 }
+function effectiveTableAlias(table) {
+  return table.alias ?? table.cteName;
+}
 function findTableForAlias(stmt, alias) {
-  return [stmt.from, ...stmt.joins.map((join2) => join2.table)].find((table) => table.alias === alias);
+  return [stmt.from, ...stmt.joins.map((join2) => join2.table)].find((table) => effectiveTableAlias(table) === alias);
 }
 function physicalSelectTables(stmt) {
   return [stmt.from, ...stmt.joins.map((join2) => join2.table)].filter((table) => table.cteName === null);
@@ -13189,7 +13345,7 @@ async function loadAggregateSortKindResolver(stmt, client, cacheContext, materia
       if (ref.tableAlias === "_p" && stmt.from.subtableCode && stmt.from.cteName === null) {
         info = fieldInfosByApp.get(stmt.from.appId)?.get(ref.field);
       } else {
-        const table = tables.find((candidate) => candidate.alias === ref.tableAlias);
+        const table = tables.find((candidate) => effectiveTableAlias(candidate) === ref.tableAlias);
         if (!table) return void 0;
         if (table.cteName !== null) {
           return materializedTables?.get(table.cteName)?.columnMeta?.get(ref.field)?.semantics ?? syntheticSemantics("string");
@@ -13214,7 +13370,7 @@ async function loadAggregateSortKindResolver(stmt, client, cacheContext, materia
       return matches[0];
     }
     if (!info) return void 0;
-    const sourceTable = ref.tableAlias !== null ? tables.find((table) => table.alias === ref.tableAlias) : stmt.joins.length === 0 ? stmt.from : void 0;
+    const sourceTable = ref.tableAlias !== null ? tables.find((table) => effectiveTableAlias(table) === ref.tableAlias) : stmt.joins.length === 0 ? stmt.from : void 0;
     return semanticsForInfo(info, sourceTable?.appId ?? stmt.from.appId);
   };
 }
@@ -13344,7 +13500,7 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
         const info2 = physicalInfos.get(stmt.from.appId)?.get(ref.field);
         return info2 ? materializedMetaFromFieldInfo(info2, stmt.from.appId) : void 0;
       }
-      const table = tables.find((candidate) => candidate.alias === ref.tableAlias);
+      const table = tables.find((candidate) => effectiveTableAlias(candidate) === ref.tableAlias);
       if (!table) return void 0;
       if (table.cteName !== null) return materializedTables?.get(table.cteName)?.columnMeta?.get(ref.field);
       const info = physicalInfos.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
@@ -13449,7 +13605,7 @@ function buildSelectFieldTypeResolvers(stmt, fieldTypesByApp) {
       if (field.tableAlias === "_p" && stmt.from.subtableCode && stmt.from.cteName === null) {
         return fieldTypesByApp.get(stmt.from.appId)?.get(field.field);
       }
-      const table = tables.find((candidate) => candidate.alias === field.tableAlias);
+      const table = tables.find((candidate) => effectiveTableAlias(candidate) === field.tableAlias);
       if (!table || table.cteName !== null) return void 0;
       return subtableSystemFieldType(table, field.field) ?? fieldTypesByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, field.field));
     }
@@ -13674,6 +13830,37 @@ async function executeQueryWithCte(query, client, options, cteCache, cacheContex
   return result;
 }
 async function executeFullScanWithCte(stmt, client, options, cteCache, cacheContext) {
+  const hiddenQualifiedAliases = /* @__PURE__ */ new Set();
+  const withEffectiveAlias = (table) => {
+    if (table.alias !== null || table.cteName === null) return table;
+    const alias = effectiveTableAlias(table);
+    hiddenQualifiedAliases.add(alias);
+    return { ...table, alias };
+  };
+  stmt = {
+    ...stmt,
+    from: withEffectiveAlias(stmt.from),
+    joins: stmt.joins.map((join2) => ({ ...join2, table: withEffectiveAlias(join2.table) }))
+  };
+  const aliases = /* @__PURE__ */ new Set();
+  for (const table of [stmt.from, ...stmt.joins.map((join2) => join2.table)]) {
+    const alias = effectiveTableAlias(table);
+    if (alias === null) continue;
+    if (aliases.has(alias)) {
+      throw new Error(`ArgumentError: effective alias ${alias} is used by multiple tables.`);
+    }
+    aliases.add(alias);
+  }
+  const requireMaterializedTable = (name) => {
+    const table = cteCache.get(name);
+    if (!table) {
+      throw new Error(`ArgumentError: materialized source ${name} is not available.`);
+    }
+    return table;
+  };
+  for (const table of [stmt.from, ...stmt.joins.map((join2) => join2.table)]) {
+    if (table.cteName !== null) requireMaterializedTable(table.cteName);
+  }
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
   const parallel = options.fetchParallel ?? 1;
@@ -13720,9 +13907,11 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   orderByMetaPromise.catch(() => {
   });
   const tables = /* @__PURE__ */ new Map();
+  const tableColumns = /* @__PURE__ */ new Map();
   if (stmt.from.cteName != null) {
-    const table = cteCache.get(stmt.from.cteName);
-    tables.set(stmt.from.alias, (table?.rows ?? []).map(processRowToKintoneRecord));
+    const table = requireMaterializedTable(stmt.from.cteName);
+    tables.set(stmt.from.alias, table.rows.map(processRowToKintoneRecord));
+    tableColumns.set(stmt.from.alias, table.columns);
   } else {
     const mainRecords = await fetchTableRecordsForFullScan(
       stmt,
@@ -13740,8 +13929,9 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   }
   const joinFetches = stmt.joins.map(async (join2) => {
     if (join2.table.cteName != null) {
-      const table = cteCache.get(join2.table.cteName);
-      tables.set(join2.table.alias, (table?.rows ?? []).map(processRowToKintoneRecord));
+      const table = requireMaterializedTable(join2.table.cteName);
+      tables.set(join2.table.alias, table.rows.map(processRowToKintoneRecord));
+      tableColumns.set(join2.table.alias, table.columns);
     } else {
       const pushDownCond = join2.table.alias ? pushdownPlan.joinConditions.get(join2.table.alias) ?? null : null;
       const optimized = await tryFetchJoinRecordsBySourceKeys(
@@ -13772,7 +13962,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   await Promise.all(joinFetches);
   const scalarCache = await scalarCachePromise;
   const { optionOrders, sortKinds, semantics } = await orderByMetaPromise;
-  const sourceColumns = stmt.joins.length === 0 && stmt.from.cteName != null ? cteCache.get(stmt.from.cteName)?.columns : void 0;
+  const sourceColumns = stmt.joins.length === 0 && stmt.from.cteName != null ? requireMaterializedTable(stmt.from.cteName).columns : void 0;
   const { rows, columns } = runFullScan({
     tables,
     stmt,
@@ -13786,7 +13976,9 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     havingFieldSemanticsResolver,
     aggregateSortKindResolver,
     appliedKlikes: pushdownPlan.appliedKlikes,
-    sourceColumns
+    sourceColumns,
+    tableColumns,
+    hiddenQualifiedAliases
   });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
@@ -14088,7 +14280,7 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
         const info2 = infosByApp.get(stmt.from.appId)?.get(ref.field);
         return info2 ? materializedMetaFromFieldInfo(info2, stmt.from.appId) : void 0;
       }
-      const table = tables.find((candidate) => candidate.alias === ref.tableAlias);
+      const table = tables.find((candidate) => effectiveTableAlias(candidate) === ref.tableAlias);
       if (!table) return void 0;
       if (table.cteName !== null) return materializedTables?.get(table.cteName)?.columnMeta?.get(ref.field);
       const info = infosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
@@ -16141,16 +16333,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 +16379,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 +17353,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 +17478,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 +17661,8 @@ async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxA
         analysis.capabilities,
         analysis.orderPlans,
         dmlMaxRows,
-        dmlMaxSubtableRows
+        dmlMaxSubtableRows,
+        maxRecords
       ),
       cursorMaxActive
     )
@@ -17390,7 +17685,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 +17698,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 +18005,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 +18025,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 +18054,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 +18068,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 +18111,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 +19118,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 +19316,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 +19373,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) {