@rex0220/kintone-sql-tools 3.20.0 → 3.21.0

package/dist-cli/ksql.js

@@ -11929,7 +11929,8 @@ function runFullScan(input) {
     });
     knownColumns = mergeKnownColumns(knownColumns, rightColumns, rows);
   }
-  rows = applyFilter(rows, stmt.where, fieldTypeResolver, appliedKlikes, fieldSemanticsResolver);
+  const filterWhere = input.residualWhere !== void 0 ? input.residualWhere : stmt.where;
+  rows = applyFilter(rows, filterWhere, fieldTypeResolver, appliedKlikes, fieldSemanticsResolver);
   const grouping = normalizeGroupingSpec(stmt);
   if (grouping.type === "GROUPING_SETS") {
     if (!resolvedGroupingSpec) {
@@ -12452,7 +12453,7 @@ function nestedSelects(node, root) {
   visit(node);
   return found;
 }
-function collectSelect(select, path, candidates, forceForbidden) {
+function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = true) {
   const functionNames = relativeDateFunctionNamesInWhere(select.where);
   if (functionNames.length > 0) {
     candidates.push({
@@ -12460,11 +12461,18 @@ function collectSelect(select, path, candidates, forceForbidden) {
       source: select,
       where: select.where,
       functionNames,
-      path
+      path,
+      allowPhase2Prefilter: allowPhase2
     });
   }
   nestedSelects(select, select).forEach(
-    (nested, index) => collectSelect(nested, `${path}.select-source[${index}]`, candidates, forceForbidden)
+    (nested, index) => collectSelect(
+      nested,
+      `${path}.select-source[${index}]`,
+      candidates,
+      forceForbidden,
+      allowPhase2
+    )
   );
 }
 function collectUnion(union, path, candidates, forceForbidden) {
@@ -12552,19 +12560,34 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
         }
       }
       nestedSelects(statement, statement).forEach(
-        (select, index) => collectSelect(select, `${path}.select-source[${index}]`, candidates, forceForbidden)
+        (select, index) => collectSelect(
+          select,
+          `${path}.select-source[${index}]`,
+          candidates,
+          forceForbidden,
+          false
+        )
       );
       return;
     }
     default:
       nestedSelects(statement, statement).forEach(
-        (select, index) => collectSelect(select, `${path}.select-source[${index}]`, candidates, forceForbidden)
+        (select, index) => collectSelect(
+          select,
+          `${path}.select-source[${index}]`,
+          candidates,
+          forceForbidden,
+          false
+        )
       );
   }
 }
 function serializationContainsFunctions(query, names) {
   return names.every((name) => new RegExp(`\\b${name}\\s*\\(`).test(query));
 }
+function allowRelativeDatePrefilterPlan(select, decomposition) {
+  return decomposition.eligible === true && resolveSelectMode(select) === "FULL_SCAN" && select.orderMode !== "KINTONE_NATIVE" && select.from.cteName === null && !select.from.subtableCode && select.joins.length === 0;
+}
 function rejectedNode(candidate) {
   return {
     kind: candidate.kind,
@@ -12621,7 +12644,17 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
       } catch {
         restQuery2 = "";
       }
-      const allowed2 = physicalTopLevel && selectMode === "SIMPLE" && (select.orderBy.length === 0 || select.orderMode === "KINTONE_NATIVE") && capability2.capability === "EXACT_PUSHDOWN" && serializationContainsFunctions(restQuery2, candidate.functionNames);
+      let allowed2 = physicalTopLevel && selectMode === "SIMPLE" && (select.orderBy.length === 0 || select.orderMode === "KINTONE_NATIVE") && capability2.capability === "EXACT_PUSHDOWN" && serializationContainsFunctions(restQuery2, candidate.functionNames);
+      let prefilterPlan;
+      let phase2PrefilterEligible;
+      if (!allowed2 && candidate.allowPhase2Prefilter !== false && capability2.capability === "SUPERSET_PREFILTER" && resolver.prefilterDecomposition) {
+        const decomposition = await resolver.prefilterDecomposition(select);
+        if (decomposition?.eligible === true && allowRelativeDatePrefilterPlan(select, decomposition)) {
+          prefilterPlan = decomposition.plan;
+          phase2PrefilterEligible = true;
+          allowed2 = true;
+        }
+      }
       const node2 = {
         kind: candidate.kind,
         source: candidate.source,
@@ -12630,6 +12663,7 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
         selectMode,
         capability: capability2,
         restQuery: restQuery2,
+        ...prefilterPlan ? { prefilterPlan, phase2PrefilterEligible } : {},
         clientWhereEvaluation: !allowed2,
         allowed: allowed2
       };
@@ -12690,6 +12724,312 @@ function assertRelativeDatePushdownPlan(plan) {
   }
 }
 
+// src/core/optimization/relativeDatePrefilterPlan.ts
+function decomposeRelativeDatePrefilter(stmt, resolveField2, testSeam = {}) {
+  const capability = classifyWhereCapability(stmt.where, resolveField2);
+  const reject = (reasonCodes, disposition = "INELIGIBLE") => ({
+    eligible: false,
+    disposition,
+    reasonCodes,
+    capability: capability.capability,
+    reasons: capability.reasons
+  });
+  if (stmt.where === null) return reject(["NO_WHERE"]);
+  if (stmt.from.subtableCode) return reject(["SUBTABLE_UNSUPPORTED"]);
+  if (stmt.joins.length > 0) return reject(["JOIN_UNSUPPORTED"]);
+  if (stmt.from.cteName !== null || stmt.from.appId <= 0) {
+    return reject(["NOT_DIRECT_PHYSICAL_APP"]);
+  }
+  const occurrences = collectRelativeOccurrences(stmt.where);
+  if (occurrences.length === 0) return reject(["NO_RELATIVE_DATE"]);
+  const spine = collectRelativeLeavesOnAndSpine(stmt.where, resolveField2);
+  if (!spine.ok) return reject(spine.reasonCodes);
+  if (!sameRelativeMultiset(occurrences, spine.leaves)) {
+    return reject(["RELATIVE_DATE_LEAF_COUNT_MISMATCH"]);
+  }
+  if (capability.capability === "EXACT_PUSHDOWN") {
+    return reject(["DEFER_TO_PHASE1"], "DEFER_PHASE1");
+  }
+  if (capability.capability !== "SUPERSET_PREFILTER") {
+    return reject(["CAPABILITY_NOT_SUPERSET_PREFILTER"]);
+  }
+  const fieldMetadata = collectFieldMetadata(stmt.where, resolveField2);
+  const safePlan = buildSingleTableKlikePushdownPlan(stmt.where, {
+    tableAlias: stmt.from.alias ?? void 0,
+    allowUnqualifiedFields: true,
+    allowKlike: true,
+    fieldTypes: fieldMetadata.fieldTypes,
+    fieldOptions: fieldMetadata.fieldOptions
+  });
+  const serialize = testSeam.serialize ?? whereToKintone;
+  const containsFunctions = testSeam.containsFunctions ?? serializationContainsFunctions;
+  const confirmedLeaves = [];
+  for (const leaf of spine.leaves) {
+    const name = relativeNameOf(leaf);
+    if (name === null) return reject(["RELATIVE_DATE_LEAF_COUNT_MISMATCH"]);
+    let query;
+    try {
+      query = serialize(leaf);
+    } catch {
+      return reject(["PREFILTER_SERIALIZATION_FAILED"]);
+    }
+    if (!containsFunctions(query, [name])) {
+      return reject(["PREFILTER_FUNCTION_MISSING"]);
+    }
+    confirmedLeaves.push(leaf);
+  }
+  const safeLeaves = collectBinaryIdentities(safePlan.condition);
+  const adoptedLeaves = new Set(confirmedLeaves);
+  const prefilterWhere = selectPrefilterInOriginalOrder(
+    stmt.where,
+    adoptedLeaves,
+    safeLeaves
+  );
+  if (prefilterWhere === null) {
+    return reject(["RELATIVE_DATE_LEAF_COUNT_MISMATCH"]);
+  }
+  let prefilterQuery;
+  try {
+    prefilterQuery = serialize(prefilterWhere);
+  } catch {
+    return reject(["PREFILTER_SERIALIZATION_FAILED"]);
+  }
+  const expectedNames = confirmedLeaves.map((leaf) => relativeNameOf(leaf));
+  if (!containsFunctions(prefilterQuery, [...new Set(expectedNames)]) || !serializedMultisetContains(prefilterQuery, expectedNames)) {
+    return reject(["PREFILTER_FUNCTION_MISSING"]);
+  }
+  const residualWhere = testSeam.rewriteResidual ? testSeam.rewriteResidual(stmt.where, adoptedLeaves) : replaceAdoptedLeaves(stmt.where, adoptedLeaves);
+  if (residualWhere !== null && collectRelativeOccurrences(residualWhere).length > 0) {
+    return reject(["RESIDUAL_RELATIVE_DATE_REMAINED"]);
+  }
+  if (residualWhere === null) {
+    return reject(["DEFER_TO_PHASE1"], "DEFER_PHASE1");
+  }
+  const relativeFunctionNames = /* @__PURE__ */ new Set();
+  for (const name of expectedNames) relativeFunctionNames.add(name);
+  return {
+    eligible: true,
+    plan: {
+      prefilterWhere,
+      residualWhere,
+      exactRelativeLeaves: confirmedLeaves,
+      relativeFunctionNames,
+      appliedKlikes: safePlan.appliedKlikes,
+      capability: capability.capability,
+      reasons: capability.reasons
+    }
+  };
+}
+function collectRelativeLeavesOnAndSpine(where, resolveField2) {
+  const leaves = [];
+  let failure = null;
+  const visit = (node) => {
+    if (failure !== null) return;
+    switch (node.type) {
+      case "GROUP":
+        visit(node.expr);
+        return;
+      case "LOGICAL":
+        if (node.op === "AND") {
+          visit(node.left);
+          visit(node.right);
+          return;
+        }
+        if (collectRelativeOccurrences(node).length > 0) {
+          failure = "RELATIVE_DATE_CONTEXT_UNSUPPORTED";
+        }
+        return;
+      case "NOT":
+        if (collectRelativeOccurrences(node).length > 0) {
+          failure = "RELATIVE_DATE_CONTEXT_UNSUPPORTED";
+        }
+        return;
+      case "BINARY": {
+        const name = relativeNameOf(node);
+        if (name === null) return;
+        const result = classifyRelativeDateBinary(
+          node.op,
+          node.left,
+          node.right,
+          resolveField2
+        );
+        if (result.capability !== "EXACT_PUSHDOWN") {
+          failure = "RELATIVE_DATE_LEAF_NOT_EXACT";
+          return;
+        }
+        leaves.push(node);
+        return;
+      }
+      case "EXISTS":
+        if (collectRelativeOccurrences(node).length > 0) {
+          failure = "RELATIVE_DATE_CONTEXT_UNSUPPORTED";
+        }
+        return;
+      case "NULL_CHECK":
+      case "BOOLEAN":
+        return;
+    }
+  };
+  visit(where);
+  return failure === null ? { ok: true, leaves } : { ok: false, reasonCodes: [failure] };
+}
+function relativeNameOf(leaf) {
+  return leaf.right.type === "KINTONE_FUNC" && isRelativeDateFunctionName(leaf.right.name) ? leaf.right.name : null;
+}
+function collectRelativeOccurrences(where) {
+  const found = [];
+  const visitWhere = (node) => {
+    if (node.type === "BINARY" && relativeNameOf(node) !== null) {
+      found.push(node);
+      return;
+    }
+    switch (node.type) {
+      case "LOGICAL":
+        visitWhere(node.left);
+        visitWhere(node.right);
+        return;
+      case "NOT":
+      case "GROUP":
+        visitWhere(node.expr);
+        return;
+      case "EXISTS":
+        if (node.query.where !== null) visitWhere(node.query.where);
+        return;
+      case "BINARY":
+      case "NULL_CHECK":
+      case "BOOLEAN":
+        return;
+    }
+  };
+  visitWhere(where);
+  return found;
+}
+function sameRelativeMultiset(occurrences, candidates) {
+  if (occurrences.length !== candidates.length) return false;
+  const remaining = new Set(candidates);
+  for (const occurrence of occurrences) {
+    if (!remaining.delete(occurrence)) return false;
+  }
+  return remaining.size === 0;
+}
+function collectBinaryIdentities(where) {
+  const found = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    switch (node.type) {
+      case "BINARY":
+        found.add(node);
+        return;
+      case "LOGICAL":
+        visit(node.left);
+        visit(node.right);
+        return;
+      case "NOT":
+      case "GROUP":
+        visit(node.expr);
+        return;
+      case "NULL_CHECK":
+      case "EXISTS":
+      case "BOOLEAN":
+        return;
+    }
+  };
+  if (where !== null) visit(where);
+  return found;
+}
+function selectPrefilterInOriginalOrder(where, relativeLeaves, safeLeaves) {
+  switch (where.type) {
+    case "BINARY":
+      return relativeLeaves.has(where) || safeLeaves.has(where) ? where : null;
+    case "LOGICAL":
+      if (where.op !== "AND") return null;
+      {
+        const left = selectPrefilterInOriginalOrder(where.left, relativeLeaves, safeLeaves);
+        const right = selectPrefilterInOriginalOrder(where.right, relativeLeaves, safeLeaves);
+        if (left !== null && right !== null) return { ...where, left, right };
+        return left ?? right;
+      }
+    case "GROUP": {
+      const expr = selectPrefilterInOriginalOrder(where.expr, relativeLeaves, safeLeaves);
+      return expr === null ? null : { ...where, expr };
+    }
+    case "NULL_CHECK":
+    case "NOT":
+    case "EXISTS":
+    case "BOOLEAN":
+      return null;
+  }
+}
+var TRUE_PREDICATE = { type: "BOOLEAN", value: true };
+function replaceAdoptedLeaves(where, adoptedLeaves) {
+  if (where.type === "BINARY" && adoptedLeaves.has(where)) return TRUE_PREDICATE;
+  switch (where.type) {
+    case "LOGICAL": {
+      if (where.op !== "AND") return where;
+      const left = replaceAdoptedLeaves(where.left, adoptedLeaves) ?? TRUE_PREDICATE;
+      const right = replaceAdoptedLeaves(where.right, adoptedLeaves) ?? TRUE_PREDICATE;
+      if (isTrue(left)) return isTrue(right) ? null : right;
+      if (isTrue(right)) return left;
+      if (left === where.left && right === where.right) return where;
+      return { ...where, left, right };
+    }
+    case "GROUP": {
+      const expr = replaceAdoptedLeaves(where.expr, adoptedLeaves) ?? TRUE_PREDICATE;
+      if (isTrue(expr)) return TRUE_PREDICATE;
+      return expr === where.expr ? where : { ...where, expr };
+    }
+    case "BINARY":
+    case "NULL_CHECK":
+    case "NOT":
+    case "EXISTS":
+    case "BOOLEAN":
+      return where;
+  }
+}
+function isTrue(where) {
+  return where.type === "BOOLEAN" && where.value;
+}
+function collectFieldMetadata(where, resolveField2) {
+  const fields = /* @__PURE__ */ new Map();
+  const visitValue = (value) => {
+    if (value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      value.forEach(visitValue);
+      return;
+    }
+    const record = value;
+    if (record["type"] === "SELECT") return;
+    if (record["type"] === "FIELD" && typeof record["field"] === "string" && typeof record["tableAlias"] !== "undefined") {
+      fields.set(record["field"], value);
+      return;
+    }
+    Object.values(record).forEach(visitValue);
+  };
+  visitValue(where);
+  const fieldTypes = /* @__PURE__ */ new Map();
+  const fieldOptions = /* @__PURE__ */ new Map();
+  for (const [fieldCode, field] of fields) {
+    const semantics = resolveField2(field);
+    if (!semantics) continue;
+    fieldTypes.set(fieldCode, semantics.fieldType);
+    if (semantics.optionOrder) {
+      fieldOptions.set(fieldCode, new Set(semantics.optionOrder.keys()));
+    }
+  }
+  return { fieldTypes, fieldOptions };
+}
+function serializedMultisetContains(query, expectedNames) {
+  const expected = /* @__PURE__ */ new Map();
+  for (const name of expectedNames) {
+    if (!RELATIVE_DATE_FUNCTION_NAMES.has(name)) return false;
+    expected.set(name, (expected.get(name) ?? 0) + 1);
+  }
+  for (const [name, count] of expected) {
+    const matches = query.match(new RegExp(`\\b${name}\\s*\\(`, "g"));
+    if ((matches?.length ?? 0) < count) return false;
+  }
+  return true;
+}
+
 // src/import/sourceLoader.ts
 var IMPORT_MAX_BYTES = 10 * 1024 * 1024;
 var ImportSourceError = class extends Error {
@@ -13753,7 +14093,16 @@ async function assertRelativeDateExecutionPlan(stmt, client, cacheContext) {
 async function resolveRelativeDateExecutionPlan(stmt, client, cacheContext) {
   return buildRelativeDatePushdownPlan(stmt, {
     select: (select) => resolveSelectWhereCapability(select, client, cacheContext),
-    dml: (dml) => resolveDmlWhereCapability(dml, client, cacheContext)
+    dml: (dml) => resolveDmlWhereCapability(dml, client, cacheContext),
+    prefilterDecomposition: async (select) => {
+      if (select.where === null) return null;
+      const resolver = await buildWhereFieldSemanticsResolver(
+        select,
+        client,
+        cacheContext
+      );
+      return decomposeRelativeDatePrefilter(select, resolver);
+    }
   });
 }
 async function executeParsedStatement(stmt, client, options, cacheContext) {
@@ -14862,6 +15211,14 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
   if (whereCapability.capability === "UNSUPPORTED") {
     throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(whereCapability)}).`);
   }
+  let prefilterPlan;
+  if (whereCapability.capability === "SUPERSET_PREFILTER") {
+    const resolver = await buildWhereFieldSemanticsResolver(stmt, client, cacheContext, cteCache);
+    const decomposition = decomposeRelativeDatePrefilter(stmt, resolver);
+    if (decomposition.eligible && allowRelativeDatePrefilterPlan(stmt, decomposition)) {
+      prefilterPlan = decomposition.plan;
+    }
+  }
   const staticMode = resolveSelectMode(stmt);
   const mode = whereCapability.capability === "EXACT_PUSHDOWN" ? staticMode : "FULL_SCAN";
   const orderMeta = await buildOrderByMetaForSelect(stmt, client, cacheContext, cteCache);
@@ -14892,7 +15249,8 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
         cacheContext,
         cteCache,
         whereCapability.capability === "EXACT_PUSHDOWN",
-        orderMeta
+        orderMeta,
+        prefilterPlan
       );
     }
   } catch (error) {
@@ -15810,7 +16168,7 @@ function buildSelectFieldTypeResolvers(stmt, fieldTypesByApp) {
   };
   return { row, having };
 }
-async function executeFullScanSelect(stmt, client, options, cacheContext, cteCache, allowOriginalWherePushdown = true, preloadedOrderMeta) {
+async function executeFullScanSelect(stmt, client, options, cacheContext, cteCache, allowOriginalWherePushdown = true, preloadedOrderMeta, prefilterPlan) {
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
   const parallel = options.fetchParallel ?? 1;
@@ -15836,6 +16194,10 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   validateKlikePushdownPlan(pushdownPlan);
   const mainPushDown = pushdownPlan.mainCondition;
   const tableConditions = pushdownPlan.joinConditions;
+  if (prefilterPlan && allowOriginalWherePushdown) {
+    throw new Error("internal error: relative-date prefilter must disable original WHERE pushdown.");
+  }
+  const mainFetchCondition = prefilterPlan ? prefilterPlan.prefilterWhere : mainPushDown;
   const constantFalse = isConstantFalseWhere(stmt.where);
   const mainFetch = constantFalse ? Promise.resolve([]) : fetchTableRecordsForFullScan(
     stmt,
@@ -15846,7 +16208,7 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     true,
     options.onLimitReached ?? "error",
     warnings,
-    mainPushDown,
+    mainFetchCondition,
     allowOriginalWherePushdown
   );
   const parallelJoins = [];
@@ -15927,7 +16289,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     havingFieldTypeResolver: fieldTypeResolvers.having,
     havingFieldSemanticsResolver,
     aggregateSortKindResolver,
-    appliedKlikes: pushdownPlan.appliedKlikes,
+    appliedKlikes: prefilterPlan?.appliedKlikes ?? pushdownPlan.appliedKlikes,
+    ...prefilterPlan ? { residualWhere: prefilterPlan.residualWhere } : {},
     resolvedGroupingSpec: resolvedGroupingSpecs.get(stmt)
   });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
@@ -19732,6 +20095,102 @@ function explainMetadataLines(analysis) {
     ...[...analysis.numberPrecisionApps].sort((a, b) => a - b).map((appId) => `  metadata API: number precision APP${appId}`)
   ];
 }
+function renderResidualOperator(op) {
+  switch (op) {
+    case "NOT_LIKE":
+      return "NOT LIKE";
+    case "NOT_KLIKE":
+      return "NOT KLIKE";
+    case "NOT_IN":
+      return "NOT IN";
+    case "LIKE":
+    case "KLIKE":
+    case "IN":
+    case "=":
+    case "!=":
+    case "<>":
+    case ">":
+    case "<":
+    case ">=":
+    case "<=":
+      return op;
+    default:
+      return "<op>";
+  }
+}
+function relativeReasonOperator(op) {
+  return op === "<>" ? "!=" : op;
+}
+function renderResidualValue(node) {
+  if (node === null || typeof node !== "object") return "<expr>";
+  const value = node;
+  switch (value["type"]) {
+    case "FIELD":
+      return typeof value["field"] === "string" ? `${typeof value["tableAlias"] === "string" ? `${value["tableAlias"]}.` : ""}${value["field"]}` : "<expr>";
+    case "FIELD_REF":
+      return typeof value["field"] === "string" ? value["field"] : "<expr>";
+    case "NUMBER":
+      return typeof value["raw"] === "string" ? value["raw"] : typeof value["value"] === "number" ? String(value["value"]) : "<expr>";
+    case "STRING":
+      return typeof value["value"] === "string" ? `'${value["value"].replace(/'/g, "''")}'` : "<expr>";
+    case "VARIABLE":
+      return typeof value["name"] === "string" ? `@${value["name"]}` : "<expr>";
+    case "VARIABLE_IN_LIST":
+      return typeof value["name"] === "string" ? `@${value["name"]}` : "<expr>";
+    case "STRING_FUNC": {
+      if (typeof value["func"] !== "string" || !Array.isArray(value["args"])) return "<expr>";
+      return `${value["func"]}(${value["args"].map(renderResidualValue).join(", ")})`;
+    }
+    case "FUNC_FIELD":
+    case "ARITH_FIELD":
+    case "CASE_FIELD":
+    case "ARITH_VALUE":
+    case "CASE_VALUE":
+      return renderResidualValue(value["expr"]);
+    case "GROUPING_FIELD":
+      return `GROUPING(${renderResidualValue(value["ref"])})`;
+    case "GROUPING_REF":
+      return renderResidualValue(value["field"]);
+    case "ARITH":
+    case "SCALAR_ARITH":
+    case "CONCAT_OP":
+      return `(${renderResidualValue(value["left"])} ${typeof value["op"] === "string" ? value["op"] : value["type"] === "CONCAT_OP" ? "||" : "<op>"} ${renderResidualValue(value["right"])})`;
+    case "KINTONE_FUNC":
+      return typeof value["name"] === "string" ? `${value["name"]}(...)` : "<expr>";
+    case "IN_LIST":
+      return Array.isArray(value["values"]) ? `(${value["values"].map(renderResidualValue).join(", ")})` : "<expr>";
+    case "ARRAY":
+      return Array.isArray(value["elements"]) ? `[${value["elements"].map(renderResidualValue).join(", ")}]` : "<expr>";
+    case "CASE":
+    case "CASE_WHEN":
+      return "CASE ... END";
+    default:
+      return "<expr>";
+  }
+}
+function renderRelativeDateResidualWhere(where) {
+  try {
+    const node = where;
+    switch (node["type"]) {
+      case "BINARY":
+        return `${renderResidualValue(node["left"])} ${renderResidualOperator(node["op"])} ${renderResidualValue(node["right"])}`;
+      case "NULL_CHECK":
+        return `${renderResidualValue(node["field"])} IS ${node["not"] === true ? "NOT " : ""}NULL`;
+      case "LOGICAL":
+        return `(${renderRelativeDateResidualWhere(node["left"])} ${node["op"] === "AND" || node["op"] === "OR" ? node["op"] : "<op>"} ${renderRelativeDateResidualWhere(node["right"])})`;
+      case "NOT":
+        return `NOT (${renderRelativeDateResidualWhere(node["expr"])})`;
+      case "GROUP":
+        return `(${renderRelativeDateResidualWhere(node["expr"])})`;
+      case "BOOLEAN":
+        return node["value"] === true ? "TRUE" : node["value"] === false ? "FALSE" : "<expr>";
+      default:
+        return "<expr>";
+    }
+  } catch {
+    return "<expr>";
+  }
+}
 function relativeDateExplainLines(plan) {
   if (!plan.hasRelativeDate) return [];
   if (!plan.allowed && plan.rejection) {
@@ -19745,6 +20204,32 @@ function relativeDateExplainLines(plan) {
   }
   const lines = [];
   for (const node of plan.nodes) {
+    const prefilterPlan = node.prefilterPlan;
+    if (node.allowed && prefilterPlan?.prefilterWhere && prefilterPlan.residualWhere) {
+      for (const leaf of prefilterPlan.exactRelativeLeaves) {
+        const functionName = leaf.right.type === "KINTONE_FUNC" ? leaf.right.name : "(unknown)";
+        const field = leaf.left.type === "FIELD" ? leaf.left.field : void 0;
+        const operator = relativeReasonOperator(leaf.op);
+        const detail = node.capability?.reasons.find(
+          (reason) => reason.functionName === functionName && (field === void 0 || reason.field === field) && reason.operator === operator
+        );
+        lines.push(
+          `  relative date function: ${functionName}`,
+          "  relative date evaluation: kintone server exact prefilter",
+          `  field: ${detail?.field ?? field ?? "(unknown)"} (${detail?.fieldType ?? "unknown"})`,
+          `  operator: ${detail?.operator ?? operator}`
+        );
+      }
+      const serverPrefilter = whereToKintone(prefilterPlan.prefilterWhere);
+      lines.push(
+        "  where capability: SUPERSET_PREFILTER",
+        `  server prefilter: ${serverPrefilter}`,
+        `  client residual: ${renderRelativeDateResidualWhere(prefilterPlan.residualWhere)}`,
+        "  relative date client evaluations: 0",
+        `  kintone query: ${serverPrefilter}`
+      );
+      continue;
+    }
     for (const functionName of node.functionNames) {
       const detail = node.capability?.reasons.find(
         (reason) => reason.functionName === functionName