@rex0220/kintone-sql-tools 3.60.0 → 3.61.0

package/dist-cli/ksql.js

@@ -12042,251 +12042,27 @@ function isOuterJoinNonPreservedTable(statement, table, isMainTable) {
   return false;
 }
 
-// src/core/explainMetadata.ts
-function buildGroupingExplainMetadata(statement, canonicalItemCount) {
-  const grouping = normalizeGroupingSpec(statement);
-  if (grouping.type !== "GROUPING_SETS") return null;
-  return {
-    source: grouping.source,
-    expandedSetCount: grouping.sets.length,
-    groupingItemCount: canonicalItemCount ?? grouping.allItems.length,
-    setLimit: B65_MAX_GROUPING_SETS,
-    itemLimit: B65_MAX_GROUPING_ITEMS,
-    outputRowLimit: B65_MAX_GENERATED_ROWS
-  };
-}
-function whereNeedsFieldMetadata(where) {
-  if (where === null) return false;
-  switch (where.type) {
-    case "BINARY":
-      return valueNeedsFieldMetadata(where.left);
-    case "NULL_CHECK":
-      return valueNeedsFieldMetadata(where.field);
-    case "LOGICAL":
-      return whereNeedsFieldMetadata(where.left) || whereNeedsFieldMetadata(where.right);
-    case "NOT":
-    case "GROUP":
-      return whereNeedsFieldMetadata(where.expr);
-    case "EXISTS":
-    case "BOOLEAN":
-      return false;
-  }
-}
-function valueNeedsFieldMetadata(value) {
-  if (Array.isArray(value)) return value.some(valueNeedsFieldMetadata);
-  if (value === null || typeof value !== "object") return false;
-  const item = value;
-  if (item["type"] === "FIELD") return item["field"] !== "$id";
-  if (item["type"] === "SELECT") return false;
-  return Object.values(item).some(valueNeedsFieldMetadata);
-}
-function selectNeedsOwnMetadata(statement) {
-  return whereNeedsFieldMetadata(statement.where) || statement.groupBy.length > 0 || normalizeGroupingSpec(statement).type === "GROUPING_SETS" || statement.orderBy.length > 0 || statement.columns.some(
-    (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
-  );
-}
-function explainNeedsAppMetadata(statement) {
-  const seen = /* @__PURE__ */ new Set();
-  const visit = (node) => {
-    if (node === null || typeof node !== "object") return false;
-    if (seen.has(node)) return false;
-    seen.add(node);
-    if (Array.isArray(node)) return node.some(visit);
-    const item = node;
-    if (item["type"] === "VALIDATE") return true;
-    if (item["type"] === "SELECT" && selectNeedsOwnMetadata(node)) {
-      return true;
-    }
-    if ((item["type"] === "UPDATE" || item["type"] === "DELETE") && whereNeedsFieldMetadata(node.where)) {
-      return true;
-    }
-    if (item["type"] === "UPDATE" && Array.isArray(item["applyBlocks"]) && item["applyBlocks"].length > 0) return true;
-    return Object.values(item).some(visit);
-  };
-  return visit(statement);
-}
-
-// src/api/fetchAll.ts
-async function fetchAll(fetcher, app, query, fields, options = {}) {
-  const pageSize = options.pageSize ?? PAGE_SIZE_DEFAULT;
-  const parallel = Math.max(1, options.parallel ?? PARALLEL_DEFAULT);
-  const maxRecords = options.maxRecords ?? MAX_RECORDS_DEFAULT;
-  const onLimit = options.onLimit ?? "error";
-  const stopAfter = options.stopAfter;
-  if (stopAfter !== void 0 && (!Number.isSafeInteger(stopAfter) || stopAfter <= 0 || stopAfter > maxRecords)) {
-    throw new RangeError("stopAfter must be a positive safe integer <= maxRecords");
-  }
-  const fetchCap = stopAfter ?? maxRecords;
-  const fetchFields = fields.length > 0 && !fields.includes("$id") ? [...fields, "$id"] : fields;
-  const allRecords = [];
-  let notified = false;
-  const limitMessage = `\u53D6\u5F97\u4EF6\u6570\u304C\u4E0A\u9650\uFF08${maxRecords} \u4EF6\uFF09\u3092\u8D85\u3048\u307E\u3057\u305F\u3002WHERE \u53E5\u3067\u7D5E\u308A\u8FBC\u3080\u304B\u3001maxRecords \u3092\u5F15\u304D\u4E0A\u3052\u3066\u304F\u3060\u3055\u3044\u3002`;
-  let cursorId = 0;
-  let windowOffset = 0;
-  const cursorQuery0 = buildCursorQuery(query, cursorId);
-  const first = await fetchPage(fetcher, app, cursorQuery0, fetchFields, pageSize, windowOffset);
-  notifySearchAborted(first, options);
-  allRecords.push(...first.records);
-  if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
-    return allRecords.slice(0, stopAfter);
-  }
-  if (allRecords.length > maxRecords) {
-    if (onLimit === "truncate") {
-      if (!notified && options.onTruncate) {
-        options.onTruncate(maxRecords);
-        notified = true;
-      }
-      return allRecords.slice(0, maxRecords);
-    }
-    throw new FetchAllLimitError(limitMessage);
-  }
-  if (first.records.length < pageSize) return allRecords;
-  windowOffset += pageSize;
-  if (windowOffset >= KINTONE_MAX_OFFSET) {
-    cursorId = getLastId(first.records);
-    windowOffset = 0;
-  }
-  while (true) {
-    if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
-      return allRecords.slice(0, stopAfter);
-    }
-    if (allRecords.length >= maxRecords) {
-      if (onLimit === "truncate") {
-        if (!notified && options.onTruncate) {
-          options.onTruncate(maxRecords);
-          notified = true;
-        }
-        return allRecords.slice(0, maxRecords);
-      }
-      throw new FetchAllLimitError(limitMessage);
-    }
-    const remaining = fetchCap - allRecords.length;
-    const maxPagesByLimit = Math.ceil(remaining / pageSize);
-    const batchParallel = Math.max(1, Math.min(parallel, maxPagesByLimit));
-    const batchOffsets = [];
-    for (let i = 0; i < batchParallel; i++) {
-      const off = windowOffset + i * pageSize;
-      if (off >= KINTONE_MAX_OFFSET) break;
-      batchOffsets.push(off);
-    }
-    const cq = buildCursorQuery(query, cursorId);
-    const responses = await Promise.all(
-      batchOffsets.map(
-        (offset) => fetchPage(fetcher, app, cq, fetchFields, pageSize, offset)
-      )
-    );
-    for (const response of responses) notifySearchAborted(response, options);
-    let done = false;
-    for (const res of responses) {
-      allRecords.push(...res.records);
-      if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
-        return allRecords.slice(0, stopAfter);
-      }
-      if (allRecords.length > maxRecords) {
-        if (onLimit === "truncate") {
-          if (!notified && options.onTruncate) {
-            options.onTruncate(maxRecords);
-            notified = true;
-          }
-          return allRecords.slice(0, maxRecords);
-        }
-        throw new FetchAllLimitError(limitMessage);
-      }
-      if (res.records.length < pageSize) {
-        done = true;
-        break;
-      }
-    }
-    if (done) break;
-    windowOffset += pageSize * batchOffsets.length;
-    if (windowOffset >= KINTONE_MAX_OFFSET) {
-      const lastRes = responses[responses.length - 1];
-      cursorId = getLastId(lastRes.records);
-      windowOffset = 0;
-    }
-  }
-  return allRecords;
-}
-function notifySearchAborted(response, options) {
-  if (response.searchAborted) options.onSearchAborted?.();
-}
-function extractIds(records) {
-  return records.map((r) => {
-    const raw = r["$id"]?.value;
-    if (raw === void 0) {
-      throw new Error(
-        '\u30EC\u30B3\u30FC\u30C9\u306B $id \u30D5\u30A3\u30FC\u30EB\u30C9\u304C\u542B\u307E\u308C\u3066\u3044\u307E\u305B\u3093\u3002fields \u306B "$id" \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002'
-      );
-    }
-    const id = Number(raw);
-    if (!Number.isFinite(id)) {
-      throw new Error(`$id \u306E\u5024\u304C\u6570\u5024\u3067\u306F\u3042\u308A\u307E\u305B\u3093: ${raw}`);
-    }
-    return id;
-  });
-}
-var PAGE_SIZE_DEFAULT = 500;
-var PARALLEL_DEFAULT = 1;
-var MAX_RECORDS_DEFAULT = 1e4;
-var KINTONE_MAX_OFFSET = 1e4;
-async function fetchPage(fetcher, app, query, fields, pageSize, offset) {
-  const pageQuery = buildPageQuery(query, pageSize, offset);
-  return fetcher({ app, query: pageQuery, fields });
-}
-function buildCursorQuery(baseQuery, cursorId) {
-  const base = baseQuery.trimEnd();
-  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();
-  const suffix = `limit ${pageSize} offset ${offset}`;
-  return base ? `${base} ${suffix}` : suffix;
-}
-function getLastId(records) {
-  const last = records[records.length - 1];
-  const raw = last?.["$id"]?.value;
-  if (raw === void 0) return 0;
-  const id = Number(raw);
-  return Number.isFinite(id) ? id : 0;
+// src/core/optimization/joinDateTimeLiteralPolicy.ts
+function isCanonicalJoinDate(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return false;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (year < 1 || year > 9999) return false;
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(0, 0, 0, 0);
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
 }
-var FetchAllLimitError = class extends Error {
-  constructor(message, completeInputWrapped = false) {
-    super(message);
-    this.completeInputWrapped = completeInputWrapped;
-    this.name = "FetchAllLimitError";
-  }
-};
-
-// src/core/optimization/sharedPlanner.ts
-async function fetchRecordsForSharedPlan(getRecords, app, query, fields, options) {
-  const records = await fetchAll(getRecords, app, query, fields, {
-    maxRecords: options.maxRecords,
-    parallel: options.parallel,
-    onLimit: options.onLimit ?? "error",
-    onTruncate: options.onTruncate,
-    onSearchAborted: options.onSearchAborted
-  });
-  return {
-    records,
-    metrics: { fetchedRows: records.length }
-  };
+function isCanonicalJoinTime(value) {
+  const match = /^(\d{2}):(\d{2})$/.exec(value);
+  return match !== null && Number(match[1]) <= 23 && Number(match[2]) <= 59;
 }
-async function resolveDmlTargetIds(getRecords, app, query, options) {
-  const { records, metrics } = await fetchRecordsForSharedPlan(
-    getRecords,
-    app,
-    query,
-    ["$id"],
-    options
-  );
-  return {
-    ids: extractIds(records),
-    metrics
-  };
+function isCanonicalJoinDateTime(value) {
+  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/.exec(value);
+  if (!match || !isCanonicalJoinDate(match[1])) return false;
+  return Number(match[2]) <= 23 && Number(match[3]) <= 59 && Number(match[4]) <= 59;
 }
 
 // src/core/optimization/whereCapability.ts
@@ -12701,117 +12477,432 @@ function combineLogical(op, left, right) {
   if (left.capability === "UNSUPPORTED" || right.capability === "UNSUPPORTED") {
     return requireExactFunctionPushdown({ capability: "UNSUPPORTED", reasons });
   }
-  if (left.capability === "EXACT_PUSHDOWN" && right.capability === "EXACT_PUSHDOWN") {
-    return { capability: "EXACT_PUSHDOWN", reasons };
+  if (left.capability === "EXACT_PUSHDOWN" && right.capability === "EXACT_PUSHDOWN") {
+    return { capability: "EXACT_PUSHDOWN", reasons };
+  }
+  if (op === "AND" && (left.capability === "EXACT_PUSHDOWN" || right.capability === "EXACT_PUSHDOWN" || left.capability === "SUPERSET_PREFILTER" || right.capability === "SUPERSET_PREFILTER")) {
+    return requireExactFunctionPushdown({
+      capability: "SUPERSET_PREFILTER",
+      reasons: [{ code: "WHERE_SUPERSET_PREFILTER" }, ...reasons]
+    });
+  }
+  return requireExactFunctionPushdown({ capability: "LOCAL_ONLY", reasons });
+}
+function localExpression() {
+  return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
+}
+function unsupported2(code, field, fieldType, operator) {
+  return { capability: "UNSUPPORTED", reasons: [{ code, field, fieldType, operator }] };
+}
+function legacyKintoneFunctionUnsupported(code, functionName, field, fieldType, operator) {
+  return requireExactFunctionPushdown({
+    capability: "UNSUPPORTED",
+    reasons: [{ code, functionName, field, fieldType, operator }]
+  });
+}
+function relativeDateUnsupported(code, functionName, field, fieldType, operator) {
+  return requireExactRelativeDatePushdown({
+    capability: "UNSUPPORTED",
+    reasons: [{ code, functionName, field, fieldType, operator }]
+  });
+}
+function hasRelativeDateReason(reasons) {
+  return reasons.some(
+    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
+  );
+}
+function hasLegacyKintoneFunctionReason(reasons) {
+  return reasons.some(
+    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
+  );
+}
+function requireExactRelativeDatePushdown(result) {
+  if (result.capability === "EXACT_PUSHDOWN" || !hasRelativeDateReason(result.reasons) || result.reasons.some((reason) => reason.code === "WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN")) {
+    return result;
+  }
+  const relative = result.reasons.find(
+    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
+  );
+  return {
+    capability: result.capability,
+    reasons: [
+      ...result.reasons,
+      {
+        code: "WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN",
+        functionName: relative.functionName,
+        field: relative.field,
+        fieldType: relative.fieldType,
+        operator: relative.operator
+      }
+    ]
+  };
+}
+function requireExactLegacyKintoneFunctionPushdown(result) {
+  if (result.capability === "EXACT_PUSHDOWN" || !hasLegacyKintoneFunctionReason(result.reasons) || result.reasons.some(
+    (reason) => reason.code === "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN"
+  )) {
+    return result;
+  }
+  const legacy = result.reasons.find(
+    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
+  );
+  return {
+    capability: result.capability,
+    reasons: [
+      ...result.reasons,
+      {
+        code: "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN",
+        functionName: legacy.functionName,
+        field: legacy.field,
+        fieldType: legacy.fieldType,
+        operator: legacy.operator
+      }
+    ]
+  };
+}
+function requireExactFunctionPushdown(result) {
+  return requireExactLegacyKintoneFunctionPushdown(
+    requireExactRelativeDatePushdown(result)
+  );
+}
+
+// src/core/optimization/joinKeyPrefilter.ts
+var JOIN_KEY_IN_CHUNK_SIZE = 50;
+function buildJoinKeyPrefilterQueries(plan, field, quoteValue) {
+  if (plan.kind === "RANGE") {
+    return [`${field} >= ${quoteValue(plan.min)} and ${field} <= ${quoteValue(plan.max)}`];
+  }
+  if (plan.kind !== "IN") return [];
+  const queries = [];
+  for (let offset = 0; offset < plan.values.length; offset += JOIN_KEY_IN_CHUNK_SIZE) {
+    const chunk3 = plan.values.slice(offset, offset + JOIN_KEY_IN_CHUNK_SIZE);
+    queries.push(`${field} in (${chunk3.map(quoteValue).join(",")})`);
+  }
+  return queries;
+}
+var DATETIME_TYPES = /* @__PURE__ */ new Set(["DATETIME", "CREATED_TIME", "UPDATED_TIME"]);
+var JOIN_KEY_EMPTY_IN_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "SINGLE_LINE_TEXT",
+  "LINK",
+  "NUMBER",
+  "CALC",
+  "DROP_DOWN",
+  "RADIO_BUTTON",
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "STATUS"
+]);
+function canonicalFor(fieldType, value) {
+  if (fieldType === "DATE") return isCanonicalJoinDate(value);
+  if (fieldType === "TIME") return isCanonicalJoinTime(value);
+  if (DATETIME_TYPES.has(fieldType)) return isCanonicalJoinDateTime(value);
+  return false;
+}
+function semanticsMatch(fieldType, semantics) {
+  if (!semantics || semantics.compareMode !== "string") return false;
+  if (fieldType === "DATE") return semantics.fieldType === "DATE";
+  if (fieldType === "TIME") return semantics.fieldType === "TIME";
+  if (DATETIME_TYPES.has(fieldType)) return DATETIME_TYPES.has(semantics.fieldType);
+  return false;
+}
+function planJoinKeyPrefilter(input) {
+  if (input.sourceRowCount === 0) return { kind: "EMPTY_SOURCE" };
+  if (!input.fieldType) {
+    return { kind: "FALLBACK", reason: "JOIN_KEY_FIELD_TYPE_UNRESOLVED" };
+  }
+  const operators = nativeWhereOperatorsForType(input.fieldType);
+  if (operators.has("in")) {
+    if (input.values === void 0) {
+      return { kind: "FALLBACK", reason: "JOIN_KEY_VALUES_RUNTIME" };
+    }
+    if (input.hasEmptyValue && !JOIN_KEY_EMPTY_IN_FIELD_TYPES.has(input.fieldType)) {
+      return { kind: "FALLBACK", reason: "JOIN_KEY_EMPTY_VALUE" };
+    }
+    const values2 = [...new Set(input.values)];
+    if (values2.length === 0) return { kind: "EMPTY_SOURCE" };
+    if (values2.length > input.maxInKeys) {
+      return { kind: "FALLBACK", reason: "JOIN_KEY_LIMIT_EXCEEDED" };
+    }
+    return { kind: "IN", values: values2, relation: "exact" };
+  }
+  if (!operators.has(">=") || !operators.has("<=")) {
+    return { kind: "FALLBACK", reason: "JOIN_KEY_OPERATOR_UNAVAILABLE" };
+  }
+  if (input.values === void 0) {
+    return { kind: "RANGE_CANDIDATE", relation: "superset", reason: "JOIN_KEY_VALUES_RUNTIME" };
+  }
+  if (!semanticsMatch(input.fieldType, input.sourceSemantics)) {
+    return { kind: "FALLBACK", reason: "JOIN_KEY_SEMANTICS_UNRESOLVED" };
+  }
+  const sourceSemantics = input.sourceSemantics;
+  if (input.hasEmptyValue) {
+    return { kind: "FALLBACK", reason: "JOIN_KEY_EMPTY_VALUE" };
+  }
+  const values = [...new Set(input.values)];
+  if (values.some((value) => !canonicalFor(input.fieldType, value))) {
+    return { kind: "FALLBACK", reason: "JOIN_KEY_NON_CANONICAL_VALUE" };
+  }
+  if (values.length === 0) {
+    return { kind: "FALLBACK", reason: "JOIN_KEY_EMPTY_VALUE" };
+  }
+  let min = values[0];
+  let max = values[0];
+  for (let i = 1; i < values.length; i += 1) {
+    const value = values[i];
+    if (compareCanonicalValues(value, min, sourceSemantics) < 0) min = value;
+    if (compareCanonicalValues(value, max, sourceSemantics) > 0) max = value;
+  }
+  return { kind: "RANGE", min, max, relation: "superset" };
+}
+
+// src/core/explainMetadata.ts
+function buildGroupingExplainMetadata(statement, canonicalItemCount) {
+  const grouping = normalizeGroupingSpec(statement);
+  if (grouping.type !== "GROUPING_SETS") return null;
+  return {
+    source: grouping.source,
+    expandedSetCount: grouping.sets.length,
+    groupingItemCount: canonicalItemCount ?? grouping.allItems.length,
+    setLimit: B65_MAX_GROUPING_SETS,
+    itemLimit: B65_MAX_GROUPING_ITEMS,
+    outputRowLimit: B65_MAX_GENERATED_ROWS
+  };
+}
+function whereNeedsFieldMetadata(where) {
+  if (where === null) return false;
+  switch (where.type) {
+    case "BINARY":
+      return valueNeedsFieldMetadata(where.left);
+    case "NULL_CHECK":
+      return valueNeedsFieldMetadata(where.field);
+    case "LOGICAL":
+      return whereNeedsFieldMetadata(where.left) || whereNeedsFieldMetadata(where.right);
+    case "NOT":
+    case "GROUP":
+      return whereNeedsFieldMetadata(where.expr);
+    case "EXISTS":
+    case "BOOLEAN":
+      return false;
+  }
+}
+function valueNeedsFieldMetadata(value) {
+  if (Array.isArray(value)) return value.some(valueNeedsFieldMetadata);
+  if (value === null || typeof value !== "object") return false;
+  const item = value;
+  if (item["type"] === "FIELD") return item["field"] !== "$id";
+  if (item["type"] === "SELECT") return false;
+  return Object.values(item).some(valueNeedsFieldMetadata);
+}
+function selectNeedsOwnMetadata(statement) {
+  return whereNeedsFieldMetadata(statement.where) || statement.groupBy.length > 0 || normalizeGroupingSpec(statement).type === "GROUPING_SETS" || statement.orderBy.length > 0 || statement.joins.some(
+    (join2) => join2.table.appId > 0 && join2.table.cteName === null && (join2.on.left.field !== "$id" || join2.on.right.field !== "$id")
+  ) || statement.columns.some(
+    (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
+  );
+}
+function explainNeedsAppMetadata(statement) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (node === null || typeof node !== "object") return false;
+    if (seen.has(node)) return false;
+    seen.add(node);
+    if (Array.isArray(node)) return node.some(visit);
+    const item = node;
+    if (item["type"] === "VALIDATE") return true;
+    if (item["type"] === "SELECT" && selectNeedsOwnMetadata(node)) {
+      return true;
+    }
+    if ((item["type"] === "UPDATE" || item["type"] === "DELETE") && whereNeedsFieldMetadata(node.where)) {
+      return true;
+    }
+    if (item["type"] === "UPDATE" && Array.isArray(item["applyBlocks"]) && item["applyBlocks"].length > 0) return true;
+    return Object.values(item).some(visit);
+  };
+  return visit(statement);
+}
+
+// src/api/fetchAll.ts
+async function fetchAll(fetcher, app, query, fields, options = {}) {
+  const pageSize = options.pageSize ?? PAGE_SIZE_DEFAULT;
+  const parallel = Math.max(1, options.parallel ?? PARALLEL_DEFAULT);
+  const maxRecords = options.maxRecords ?? MAX_RECORDS_DEFAULT;
+  const onLimit = options.onLimit ?? "error";
+  const stopAfter = options.stopAfter;
+  if (stopAfter !== void 0 && (!Number.isSafeInteger(stopAfter) || stopAfter <= 0 || stopAfter > maxRecords)) {
+    throw new RangeError("stopAfter must be a positive safe integer <= maxRecords");
+  }
+  const fetchCap = stopAfter ?? maxRecords;
+  const fetchFields = fields.length > 0 && !fields.includes("$id") ? [...fields, "$id"] : fields;
+  const allRecords = [];
+  let notified = false;
+  const limitMessage = `\u53D6\u5F97\u4EF6\u6570\u304C\u4E0A\u9650\uFF08${maxRecords} \u4EF6\uFF09\u3092\u8D85\u3048\u307E\u3057\u305F\u3002WHERE \u53E5\u3067\u7D5E\u308A\u8FBC\u3080\u304B\u3001maxRecords \u3092\u5F15\u304D\u4E0A\u3052\u3066\u304F\u3060\u3055\u3044\u3002`;
+  let cursorId = 0;
+  let windowOffset = 0;
+  const cursorQuery0 = buildCursorQuery(query, cursorId);
+  const first = await fetchPage(fetcher, app, cursorQuery0, fetchFields, pageSize, windowOffset);
+  notifySearchAborted(first, options);
+  allRecords.push(...first.records);
+  if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
+    return allRecords.slice(0, stopAfter);
+  }
+  if (allRecords.length > maxRecords) {
+    if (onLimit === "truncate") {
+      if (!notified && options.onTruncate) {
+        options.onTruncate(maxRecords);
+        notified = true;
+      }
+      return allRecords.slice(0, maxRecords);
+    }
+    throw new FetchAllLimitError(limitMessage);
+  }
+  if (first.records.length < pageSize) return allRecords;
+  windowOffset += pageSize;
+  if (windowOffset >= KINTONE_MAX_OFFSET) {
+    cursorId = getLastId(first.records);
+    windowOffset = 0;
   }
-  if (op === "AND" && (left.capability === "EXACT_PUSHDOWN" || right.capability === "EXACT_PUSHDOWN" || left.capability === "SUPERSET_PREFILTER" || right.capability === "SUPERSET_PREFILTER")) {
-    return requireExactFunctionPushdown({
-      capability: "SUPERSET_PREFILTER",
-      reasons: [{ code: "WHERE_SUPERSET_PREFILTER" }, ...reasons]
-    });
+  while (true) {
+    if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
+      return allRecords.slice(0, stopAfter);
+    }
+    if (allRecords.length >= maxRecords) {
+      if (onLimit === "truncate") {
+        if (!notified && options.onTruncate) {
+          options.onTruncate(maxRecords);
+          notified = true;
+        }
+        return allRecords.slice(0, maxRecords);
+      }
+      throw new FetchAllLimitError(limitMessage);
+    }
+    const remaining = fetchCap - allRecords.length;
+    const maxPagesByLimit = Math.ceil(remaining / pageSize);
+    const batchParallel = Math.max(1, Math.min(parallel, maxPagesByLimit));
+    const batchOffsets = [];
+    for (let i = 0; i < batchParallel; i++) {
+      const off = windowOffset + i * pageSize;
+      if (off >= KINTONE_MAX_OFFSET) break;
+      batchOffsets.push(off);
+    }
+    const cq = buildCursorQuery(query, cursorId);
+    const responses = await Promise.all(
+      batchOffsets.map(
+        (offset) => fetchPage(fetcher, app, cq, fetchFields, pageSize, offset)
+      )
+    );
+    for (const response of responses) notifySearchAborted(response, options);
+    let done = false;
+    for (const res of responses) {
+      allRecords.push(...res.records);
+      if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
+        return allRecords.slice(0, stopAfter);
+      }
+      if (allRecords.length > maxRecords) {
+        if (onLimit === "truncate") {
+          if (!notified && options.onTruncate) {
+            options.onTruncate(maxRecords);
+            notified = true;
+          }
+          return allRecords.slice(0, maxRecords);
+        }
+        throw new FetchAllLimitError(limitMessage);
+      }
+      if (res.records.length < pageSize) {
+        done = true;
+        break;
+      }
+    }
+    if (done) break;
+    windowOffset += pageSize * batchOffsets.length;
+    if (windowOffset >= KINTONE_MAX_OFFSET) {
+      const lastRes = responses[responses.length - 1];
+      cursorId = getLastId(lastRes.records);
+      windowOffset = 0;
+    }
   }
-  return requireExactFunctionPushdown({ capability: "LOCAL_ONLY", reasons });
-}
-function localExpression() {
-  return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
+  return allRecords;
 }
-function unsupported2(code, field, fieldType, operator) {
-  return { capability: "UNSUPPORTED", reasons: [{ code, field, fieldType, operator }] };
+function notifySearchAborted(response, options) {
+  if (response.searchAborted) options.onSearchAborted?.();
 }
-function legacyKintoneFunctionUnsupported(code, functionName, field, fieldType, operator) {
-  return requireExactFunctionPushdown({
-    capability: "UNSUPPORTED",
-    reasons: [{ code, functionName, field, fieldType, operator }]
+function extractIds(records) {
+  return records.map((r) => {
+    const raw = r["$id"]?.value;
+    if (raw === void 0) {
+      throw new Error(
+        '\u30EC\u30B3\u30FC\u30C9\u306B $id \u30D5\u30A3\u30FC\u30EB\u30C9\u304C\u542B\u307E\u308C\u3066\u3044\u307E\u305B\u3093\u3002fields \u306B "$id" \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002'
+      );
+    }
+    const id = Number(raw);
+    if (!Number.isFinite(id)) {
+      throw new Error(`$id \u306E\u5024\u304C\u6570\u5024\u3067\u306F\u3042\u308A\u307E\u305B\u3093: ${raw}`);
+    }
+    return id;
   });
 }
-function relativeDateUnsupported(code, functionName, field, fieldType, operator) {
-  return requireExactRelativeDatePushdown({
-    capability: "UNSUPPORTED",
-    reasons: [{ code, functionName, field, fieldType, operator }]
-  });
+var PAGE_SIZE_DEFAULT = 500;
+var PARALLEL_DEFAULT = 1;
+var MAX_RECORDS_DEFAULT = 1e4;
+var KINTONE_MAX_OFFSET = 1e4;
+async function fetchPage(fetcher, app, query, fields, pageSize, offset) {
+  const pageQuery = buildPageQuery(query, pageSize, offset);
+  return fetcher({ app, query: pageQuery, fields });
 }
-function hasRelativeDateReason(reasons) {
-  return reasons.some(
-    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
-  );
+function buildCursorQuery(baseQuery, cursorId) {
+  const base = baseQuery.trimEnd();
+  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 hasLegacyKintoneFunctionReason(reasons) {
-  return reasons.some(
-    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
-  );
+function buildPageQuery(query, pageSize, offset) {
+  const base = query.trimEnd();
+  const suffix = `limit ${pageSize} offset ${offset}`;
+  return base ? `${base} ${suffix}` : suffix;
 }
-function requireExactRelativeDatePushdown(result) {
-  if (result.capability === "EXACT_PUSHDOWN" || !hasRelativeDateReason(result.reasons) || result.reasons.some((reason) => reason.code === "WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN")) {
-    return result;
+function getLastId(records) {
+  const last = records[records.length - 1];
+  const raw = last?.["$id"]?.value;
+  if (raw === void 0) return 0;
+  const id = Number(raw);
+  return Number.isFinite(id) ? id : 0;
+}
+var FetchAllLimitError = class extends Error {
+  constructor(message, completeInputWrapped = false) {
+    super(message);
+    this.completeInputWrapped = completeInputWrapped;
+    this.name = "FetchAllLimitError";
   }
-  const relative = result.reasons.find(
-    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
-  );
+};
+
+// src/core/optimization/sharedPlanner.ts
+async function fetchRecordsForSharedPlan(getRecords, app, query, fields, options) {
+  const records = await fetchAll(getRecords, app, query, fields, {
+    maxRecords: options.maxRecords,
+    parallel: options.parallel,
+    onLimit: options.onLimit ?? "error",
+    onTruncate: options.onTruncate,
+    onSearchAborted: options.onSearchAborted
+  });
   return {
-    capability: result.capability,
-    reasons: [
-      ...result.reasons,
-      {
-        code: "WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN",
-        functionName: relative.functionName,
-        field: relative.field,
-        fieldType: relative.fieldType,
-        operator: relative.operator
-      }
-    ]
+    records,
+    metrics: { fetchedRows: records.length }
   };
 }
-function requireExactLegacyKintoneFunctionPushdown(result) {
-  if (result.capability === "EXACT_PUSHDOWN" || !hasLegacyKintoneFunctionReason(result.reasons) || result.reasons.some(
-    (reason) => reason.code === "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN"
-  )) {
-    return result;
-  }
-  const legacy = result.reasons.find(
-    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
+async function resolveDmlTargetIds(getRecords, app, query, options) {
+  const { records, metrics } = await fetchRecordsForSharedPlan(
+    getRecords,
+    app,
+    query,
+    ["$id"],
+    options
   );
   return {
-    capability: result.capability,
-    reasons: [
-      ...result.reasons,
-      {
-        code: "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN",
-        functionName: legacy.functionName,
-        field: legacy.field,
-        fieldType: legacy.fieldType,
-        operator: legacy.operator
-      }
-    ]
+    ids: extractIds(records),
+    metrics
   };
 }
-function requireExactFunctionPushdown(result) {
-  return requireExactLegacyKintoneFunctionPushdown(
-    requireExactRelativeDatePushdown(result)
-  );
-}
-
-// src/core/optimization/joinDateTimeLiteralPolicy.ts
-function isCanonicalJoinDate(value) {
-  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
-  if (!match) return false;
-  const year = Number(match[1]);
-  const month = Number(match[2]);
-  const day = Number(match[3]);
-  if (year < 1 || year > 9999) return false;
-  const date = /* @__PURE__ */ new Date(0);
-  date.setUTCFullYear(year, month - 1, day);
-  date.setUTCHours(0, 0, 0, 0);
-  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
-}
-function isCanonicalJoinTime(value) {
-  const match = /^(\d{2}):(\d{2})$/.exec(value);
-  return match !== null && Number(match[1]) <= 23 && Number(match[2]) <= 59;
-}
-function isCanonicalJoinDateTime(value) {
-  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/.exec(value);
-  if (!match || !isCanonicalJoinDate(match[1])) return false;
-  return Number(match[2]) <= 23 && Number(match[3]) <= 59 && Number(match[4]) <= 59;
-}
 
 // src/core/optimization/joinNumberLiteralPolicy.ts
 function isJoinNumberLiteralSupported(literal) {
@@ -12851,7 +12942,7 @@ var KLIKE_TYPES = /* @__PURE__ */ new Set([
   "RICH_TEXT",
   "FILE"
 ]);
-var DATETIME_TYPES = /* @__PURE__ */ new Set([
+var DATETIME_TYPES2 = /* @__PURE__ */ new Set([
   "DATETIME",
   "CREATED_TIME",
   "UPDATED_TIME"
@@ -13477,7 +13568,7 @@ function classifySupportedLeaf(predicate, owner, fieldType) {
     }
     return (predicate.op === "=" || predicate.op === "!=" || predicate.op === "<>") && predicate.right.type === "STRING" && predicate.right.value !== "" ? "exact" : "unsafe";
   }
-  if (fieldType === "DATE" || fieldType === "TIME" || DATETIME_TYPES.has(fieldType)) {
+  if (fieldType === "DATE" || fieldType === "TIME" || DATETIME_TYPES2.has(fieldType)) {
     if (predicate.op !== "=" && predicate.op !== "!=" && predicate.op !== "<>" && predicate.op !== "<" && predicate.op !== ">" && predicate.op !== "<=" && predicate.op !== ">=" || predicate.right.type !== "STRING") return "unsafe";
     if (fieldType === "DATE") {
       return isCanonicalJoinDate(predicate.right.value) ? "exact" : "unsafe";
@@ -20245,6 +20336,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
       parallel,
       options.onLimitReached ?? "error",
       warnings,
+      cacheContext,
+      cteCache,
       null,
       plainGroupByPlan,
       ""
@@ -20633,6 +20726,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
         parallel,
         effectiveOptions.onLimitReached ?? "error",
         warnings,
+        cacheContext,
+        cteCache,
         pushDownCond,
         plainGroupByPlan
       );
@@ -20825,10 +20920,9 @@ function splitChunks(items, size) {
   for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
   return out;
 }
-var JOIN_IN_CHUNK_SIZE = 50;
 var JOIN_IN_MAX_CHUNKS = 6;
-var JOIN_IN_MAX_KEYS = JOIN_IN_CHUNK_SIZE * JOIN_IN_MAX_CHUNKS;
-async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxRecords, parallel, onLimit, warnings, pushDownCond = null, plainGroupByPlan, additionalPushQuery = "") {
+var JOIN_IN_MAX_KEYS = JOIN_KEY_IN_CHUNK_SIZE * JOIN_IN_MAX_CHUNKS;
+async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxRecords, parallel, onLimit, warnings, cacheContext, materializedTables, pushDownCond = null, plainGroupByPlan, additionalPushQuery = "") {
   if (join2.type !== "INNER") return null;
   if (!join2.table.alias) return null;
   if (join2.table.subtableCode) return null;
@@ -20851,17 +20945,47 @@ async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxR
   }
   const sourceRows2 = tables.get(sourceAlias);
   if (!sourceRows2) return null;
-  const keys = /* @__PURE__ */ new Set();
+  const sourceTable = [stmt.from, ...stmt.joins.map((candidate) => candidate.table)].find((table) => effectiveTableAlias(table) === sourceAlias);
+  const targetInfo = (await getFieldsCached(join2.table.appId, client, cacheContext)).find((info) => info.code === fieldCodeForTypeLookup(join2.table, joinField));
+  const targetMeta = targetInfo ? materializedMetaFromFieldInfo(targetInfo, join2.table.appId) : systemColumnMeta(joinField);
+  let sourceMeta;
+  if (sourceTable?.cteName !== null && sourceTable?.cteName !== void 0) {
+    sourceMeta = materializedTables?.get(sourceTable.cteName)?.columnMeta?.get(sourceField);
+  } else if (sourceTable) {
+    const sourceInfo = (await getFieldsCached(sourceTable.appId, client, cacheContext)).find((info) => info.code === fieldCodeForTypeLookup(sourceTable, sourceField));
+    sourceMeta = sourceInfo ? materializedMetaFromFieldInfo(sourceInfo, sourceTable.appId) : systemColumnMeta(sourceField);
+  }
+  const keys = [];
+  let hasEmptyValue = false;
   for (const row of sourceRows2) {
     const raw = row[sourceField]?.value;
-    const txt = toScalarText(raw).trim();
-    if (txt.length > 0) keys.add(txt);
+    const txt = toScalarText(raw);
+    if (raw === null || raw === void 0 || txt.length === 0) hasEmptyValue = true;
+    keys.push(txt);
+  }
+  const keyPlan = planJoinKeyPrefilter({
+    fieldType: targetMeta?.fieldType,
+    sourceSemantics: sourceMeta?.semantics,
+    sourceRowCount: sourceRows2.length,
+    values: keys,
+    hasEmptyValue,
+    maxInKeys: JOIN_IN_MAX_KEYS
+  });
+  if (keyPlan.kind === "EMPTY_SOURCE") return [];
+  if (keyPlan.kind === "FALLBACK") {
+    if (keyPlan.reason === "JOIN_KEY_LIMIT_EXCEEDED") {
+      const count = new Set(keys).size;
+      warnings.add(
+        `JOIN\u30AD\u30FC\u304C ${count} \u4EF6\u306E\u305F\u3081 ON \u6700\u9069\u5316\u3092\u30B9\u30AD\u30C3\u30D7\u3057\u3001JOIN\u5148\u3092\u5168\u4EF6\u53D6\u5F97\u3057\u307E\u3059\uFF08\u4E0A\u9650 ${JOIN_IN_MAX_KEYS} \u4EF6\uFF09\u3002`
+      );
+    }
+    return null;
   }
-  const values = [...keys];
-  if (values.length === 0) return [];
-  if (values.length > JOIN_IN_MAX_KEYS) {
+  if (keyPlan.kind === "RANGE_CANDIDATE") return null;
+  const prefilterQueries = buildJoinKeyPrefilterQueries(keyPlan, joinField, sqlQuote);
+  if (prefilterQueries.length === 0) {
     warnings.add(
-      `JOIN\u30AD\u30FC\u304C ${values.length} \u4EF6\u306E\u305F\u3081 ON \u6700\u9069\u5316\u3092\u30B9\u30AD\u30C3\u30D7\u3057\u3001JOIN\u5148\u3092\u5168\u4EF6\u53D6\u5F97\u3057\u307E\u3059\uFF08\u4E0A\u9650 ${JOIN_IN_MAX_KEYS} \u4EF6\uFF09\u3002`
+      `JOIN\u30AD\u30FC\u304C 0 \u4EF6\u306E\u305F\u3081 ON \u6700\u9069\u5316\u3092\u30B9\u30AD\u30C3\u30D7\u3057\u3001JOIN\u5148\u3092\u5168\u4EF6\u53D6\u5F97\u3057\u307E\u3059\uFF08\u4E0A\u9650 ${JOIN_IN_MAX_KEYS} \u4EF6\uFF09\u3002`
     );
     return null;
   }
@@ -20870,18 +20994,16 @@ async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxR
     warnings.add(`\u53D6\u5F97\u4E0A\u9650\uFF08${max} \u4EF6\uFF09\u306B\u9054\u3057\u305F\u305F\u3081\u3001${max} \u4EF6\u3067\u6253\u3061\u5207\u3063\u3066\u8868\u793A\u3057\u3066\u3044\u307E\u3059\u3002`);
     markLimitReached(client, join2.table.appId);
   };
-  const chunks = splitChunks(values, JOIN_IN_CHUNK_SIZE);
   const merged = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const chunk3 of chunks) {
-    const inClause = `${joinField} in (${chunk3.map(sqlQuote).join(",")})`;
+  for (const joinKeyQuery of prefilterQueries) {
     const pushQueries = [
       pushDownCond !== null ? whereToKintone(pushDownCond) : "",
       additionalPushQuery
     ].filter((query2) => query2 !== "");
     const query = pushQueries.reduce(
       (combined, pushQuery) => `(${combined}) and (${pushQuery})`,
-      inClause
+      joinKeyQuery
     );
     const resolved = await fetchRecordsForSharedPlan(client.getRecords, join2.table.appId, query, fields, {
       parallel,
@@ -24121,6 +24243,7 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
   return cache;
 }
 var explainJoinPushdownPlans = /* @__PURE__ */ new WeakMap();
+var explainJoinKeyPrefilters = /* @__PURE__ */ new WeakMap();
 var explainChoiceEqualityRewrites = /* @__PURE__ */ new WeakMap();
 var validateExplainInfo = /* @__PURE__ */ new WeakMap();
 var applyParentExplainPlan = /* @__PURE__ */ new WeakMap();
@@ -24152,6 +24275,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     (node) => node.source === source || JSON.stringify(node.source) === JSON.stringify(source)
   );
   const explainRelations = new Map(initialRelations ?? []);
+  const staticExplainRelations = new Set(initialRelations?.keys() ?? []);
   const explainSourceColumns = async (select) => {
     const tables = [select.from, ...select.joins.map((join2) => join2.table)];
     if (tables.length > 1 && select.columns.some(
@@ -24231,6 +24355,17 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       const withStatement = node;
       for (const cte of withStatement.ctes) {
         await preflightExplainRelations(cte.query);
+        if (cte.query.type === "GENERATE_SERIES") {
+          const generated = executeGenerateSeries(cte.query);
+          explainRelations.set(cte.name, {
+            rows: generated.rows,
+            columns: generated.columns,
+            columnMeta: materializedMetaBySelectResult.get(generated),
+            uniqueGeneratedColumn: cte.query.columnAlias
+          });
+          staticExplainRelations.add(cte.name);
+          continue;
+        }
         const columns = await inferExplainRelationColumns(cte.query);
         explainRelations.set(cte.name, { rows: [], columns });
       }
@@ -24311,6 +24446,71 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         await loadTypedPushdownMeta(select, tracedClient, cacheContext)
       );
       if (joinPushdownPlan) explainJoinPushdownPlans.set(select, joinPushdownPlan);
+      const joinKeyPlans = /* @__PURE__ */ new Map();
+      for (const join2 of select.joins) {
+        const joinAlias = join2.table.alias;
+        if (join2.type !== "INNER" || !joinAlias || join2.table.subtableCode) continue;
+        const leftAlias = join2.on.left.tableAlias;
+        const rightAlias = join2.on.right.tableAlias;
+        if (!leftAlias || !rightAlias) continue;
+        const sourceAlias = leftAlias === joinAlias && rightAlias !== joinAlias ? rightAlias : rightAlias === joinAlias && leftAlias !== joinAlias ? leftAlias : void 0;
+        const sourceField = leftAlias === joinAlias ? join2.on.right.field : join2.on.left.field;
+        const joinField = leftAlias === joinAlias ? join2.on.left.field : join2.on.right.field;
+        if (!sourceAlias) continue;
+        const sourceTable = [select.from, ...select.joins.map((candidate) => candidate.table)].find((table) => effectiveTableAlias(table) === sourceAlias);
+        const targetInfos = await getFieldsCached(join2.table.appId, tracedClient, cacheContext);
+        const targetInfo = targetInfos.find((info) => info.code === fieldCodeForTypeLookup(join2.table, joinField));
+        const targetMeta = targetInfo ? materializedMetaFromFieldInfo(targetInfo, join2.table.appId) : systemColumnMeta(joinField);
+        let sourceMeta;
+        let values;
+        let sourceRowCount;
+        let hasEmptyValue;
+        if (sourceTable?.cteName !== null && sourceTable?.cteName !== void 0) {
+          const relation = explainRelations.get(sourceTable.cteName);
+          sourceMeta = relation?.columnMeta?.get(sourceField);
+          if (staticExplainRelations.has(sourceTable.cteName) && relation) {
+            sourceRowCount = relation.rows.length;
+            values = relation.rows.map((row) => toScalarText(row[sourceField]));
+            hasEmptyValue = values.some((value) => value.length === 0);
+          }
+        } else if (sourceTable) {
+          const info = (await getFieldsCached(sourceTable.appId, tracedClient, cacheContext)).find((candidate) => candidate.code === fieldCodeForTypeLookup(sourceTable, sourceField));
+          sourceMeta = info ? materializedMetaFromFieldInfo(info, sourceTable.appId) : systemColumnMeta(sourceField);
+        }
+        const plan = planJoinKeyPrefilter({
+          fieldType: targetMeta?.fieldType,
+          sourceSemantics: sourceMeta?.semantics,
+          sourceRowCount,
+          values,
+          hasEmptyValue,
+          maxInKeys: JOIN_IN_MAX_KEYS
+        });
+        if (plan.kind === "FALLBACK" && plan.reason === "JOIN_KEY_VALUES_RUNTIME") {
+          const runtimePlanConsumesJoin = joinPushdownPlan?.joinPlan.items.some(
+            (item) => item.targetAlias === joinAlias
+          ) || joinPushdownPlan?.joinPlan.serverFunctionConsumptions.some(
+            (consumption) => consumption.targetAlias === joinAlias
+          );
+          if (runtimePlanConsumesJoin) continue;
+        }
+        const queries = buildJoinKeyPrefilterQueries(plan, joinField, sqlQuote);
+        const additionalCandidate = select.where ? extractTypedPushdownCandidates(select.where, { tableAlias: joinAlias }) : null;
+        let additionalQuery;
+        let additionalRelation;
+        if (additionalCandidate) {
+          const infoByCode = new Map(targetInfos.map((info) => [info.code, info]));
+          const additionalCapability = classifyWhereCapability(additionalCandidate, (field) => {
+            const info = infoByCode.get(field.field);
+            return info?.semantics ?? (info ? resolveFieldSemantics(info) : systemColumnMeta(field.field)?.semantics);
+          });
+          if (additionalCapability.capability === "EXACT_PUSHDOWN" || additionalCapability.capability === "SUPERSET_PREFILTER") {
+            additionalQuery = whereToKintone(additionalCandidate);
+            additionalRelation = additionalCapability.capability === "EXACT_PUSHDOWN" ? "exact" : "superset";
+          }
+        }
+        joinKeyPlans.set(joinAlias, { plan, queries, additionalQuery, additionalRelation });
+      }
+      if (joinKeyPlans.size > 0) explainJoinKeyPrefilters.set(select, joinKeyPlans);
       if (select.orderBy.length > 0 || select.columns.some((column) => column.type === "WINDOW_COL" && column.orderBy.length > 0)) {
         const meta = await buildOrderByMetaForSelect(select, tracedClient, cacheContext);
         if (select.orderMode !== "KINTONE_NATIVE") {
@@ -25427,9 +25627,13 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
       const joinPushDown = join2.table.alias ? pushdownPlan.joinConditions.get(join2.table.alias) ?? null : null;
       const joinCandidate = join2.table.alias && !join2.table.subtableCode && join2.table.cteName === null && stmt.where ? extractTypedPushdownCandidates(stmt.where, { tableAlias: join2.table.alias }) : null;
       const joinBoundQuery = join2.table.alias ? runtimeJoinPlan?.queriesByAlias.get(join2.table.alias) : void 0;
-      const joinQ = joinBoundQuery || (joinPushDown !== null ? whereToKintone(joinPushDown) : "(\u5168\u4EF6\u53D6\u5F97)");
+      const joinKey = join2.table.alias ? explainJoinKeyPrefilters.get(stmt)?.get(join2.table.alias) : void 0;
+      const baseJoinQ = joinBoundQuery || (joinPushDown !== null ? whereToKintone(joinPushDown) : joinKey?.additionalQuery ? joinKey.additionalQuery : "(\u5168\u4EF6\u53D6\u5F97)");
+      const runtimeJoinKeyCandidate = joinKey?.plan.kind === "RANGE_CANDIDATE" || joinKey?.plan.kind === "FALLBACK" && joinKey.plan.reason === "JOIN_KEY_VALUES_RUNTIME";
+      const joinQueries = joinKey && joinKey.queries.length > 0 ? joinKey.queries.map((query) => baseJoinQ !== "(\u5168\u4EF6\u53D6\u5F97)" ? `(${query}) and (${baseJoinQ})` : query) : [runtimeJoinKeyCandidate ? "(runtime source keys)" : baseJoinQ];
+      const joinQ = joinQueries.join(" | ");
       lines.push(`  ${joinType}:        APP${join2.table.appId}${joinAliasStr} (${join2.table.appId})`);
-      lines.push(`  kintone query: ${joinQ}`);
+      for (const query of joinQueries) lines.push(`  kintone query: ${query}`);
       const joinPlanItem = runtimeJoinPlan?.joinPlan.items.find(
         (item) => item.targetAlias === join2.table.alias
       );
@@ -25437,8 +25641,8 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
         (consumption) => consumption.targetAlias === join2.table.alias
       );
       if (emitFetch && join2.table.cteName === null) {
-        const joinPending = !runtimeJoinPlan && joinCandidate !== null;
-        const joinFetchScope = joinQ === "(\u5168\u4EF6\u53D6\u5F97)" ? "ALL" : joinPending ? "PREFILTERED" : joinPlanItem?.relation === "exact" || joinFunctionConsumption ? "EXACT" : "PREFILTERED";
+        const joinPending = runtimeJoinKeyCandidate || !joinKey && !runtimeJoinPlan && joinCandidate !== null;
+        const joinFetchScope = joinQ === "(\u5168\u4EF6\u53D6\u5F97)" ? "ALL" : joinPending ? "PREFILTERED" : joinKey?.plan.kind === "IN" && joinPlanItem?.relation !== "superset" && joinKey.additionalRelation !== "superset" ? "EXACT" : joinPlanItem?.relation === "exact" || joinFunctionConsumption ? "EXACT" : "PREFILTERED";
         lines.push(renderFetchScope(createExplainFetchSource(
           collector,
           join2.table.appId,
@@ -25449,7 +25653,25 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
           joinPending
         )));
       }
-      if (joinPlanItem || joinFunctionConsumption) {
+      if (joinKey) {
+        if (joinKey.plan.kind === "RANGE") {
+          lines.push("  join key prefilter: range");
+          for (const query of joinQueries) lines.push(`  pushdown applied: ${query}`);
+          lines.push("  relation: superset");
+        } else if (joinKey.plan.kind === "IN") {
+          const relation = joinPlanItem?.relation === "superset" || joinKey.additionalRelation === "superset" ? "superset" : "exact";
+          lines.push("  join key prefilter: in");
+          for (const query of joinQueries) lines.push(`  pushdown applied: ${query}`);
+          lines.push(`  relation: ${relation}`);
+        } else if (joinKey.plan.kind === "RANGE_CANDIDATE") {
+          lines.push("  join key prefilter: range candidate");
+          lines.push("  relation: superset");
+          lines.push(`  join key prefilter reason: ${joinKey.plan.reason}`);
+        } else if (joinKey.plan.kind === "FALLBACK") {
+          lines.push(joinKey.plan.reason === "JOIN_KEY_VALUES_RUNTIME" ? "  join key prefilter: runtime candidate" : "  join key prefilter: not applied");
+          lines.push(`  join key prefilter reason: ${joinKey.plan.reason}`);
+        }
+      } else if (joinPlanItem || joinFunctionConsumption) {
         lines.push(`  pushdown applied: ${joinBoundQuery}`);
         lines.push(`  relation: ${joinPlanItem?.relation ?? "exact"}`);
       } else if (!runtimeJoinPlan && joinCandidate !== null) {