@rex0220/kintone-sql-tools 3.26.0 → 3.28.0

package/dist-cli/ksql.js

@@ -5957,6 +5957,133 @@ function collectKlikes(where, out) {
   }
 }
 
+// src/core/optimization/relativeDateFullScanExactPlan.ts
+function buildRelativeDateFullScanExactPlan(input) {
+  const {
+    select,
+    selectMode,
+    capability,
+    context,
+    serializedWholeWhere,
+    relativeFunctionNames
+  } = input;
+  if (select.where === null) return null;
+  if (select.from.appId <= 0 || select.from.cteName !== null) return null;
+  if (select.from.subtableCode) return null;
+  if (select.joins.length > 0) return null;
+  if (!context.allowFullScanExact) return null;
+  if (select.orderMode === "KINTONE_NATIVE") return null;
+  const hasCanonicalOrder2 = select.orderMode === "CANONICAL" && select.orderBy.length > 0;
+  if (selectMode !== "FULL_SCAN" && !hasCanonicalOrder2) return null;
+  if (capability.capability !== "EXACT_PUSHDOWN") return null;
+  const occurrences = serverOnlyFunctionOccurrencesInWhere(select.where);
+  if (occurrences.length === 0) return null;
+  if (!sameOccurrenceList(occurrences, relativeFunctionNames)) return null;
+  if (serializedWholeWhere === null || !serializedMultisetContains(serializedWholeWhere, occurrences)) {
+    return null;
+  }
+  const prefilterPlan = {
+    prefilterWhere: select.where,
+    residualWhere: null,
+    exactRelativeLeaves: collectExactServerFunctionLeaves(select.where),
+    relativeFunctionNames: new Set(occurrences),
+    appliedKlikes: /* @__PURE__ */ new Set(),
+    capability: capability.capability,
+    reasons: capability.reasons
+  };
+  const plan = {
+    allowForm: "FULL_SCAN_EXACT",
+    clientWhereEvaluation: false,
+    serializedWholeWhere,
+    prefilterPlan
+  };
+  assertRelativeDateFullScanExactPlan(plan, input, occurrences);
+  return plan;
+}
+function assertRelativeDateFullScanExactPlan(plan, input, occurrences) {
+  if (plan.allowForm !== "FULL_SCAN_EXACT") {
+    throw new Error("FULL_SCAN_EXACT invariant: allowForm");
+  }
+  if (plan.clientWhereEvaluation !== false) {
+    throw new Error("FULL_SCAN_EXACT invariant: clientWhereEvaluation");
+  }
+  if (input.capability.capability !== "EXACT_PUSHDOWN") {
+    throw new Error("FULL_SCAN_EXACT invariant: capability");
+  }
+  if (input.select.where === null || plan.prefilterPlan.prefilterWhere !== input.select.where) {
+    throw new Error("FULL_SCAN_EXACT invariant: whole WHERE identity");
+  }
+  if (plan.prefilterPlan.residualWhere !== null) {
+    throw new Error("FULL_SCAN_EXACT invariant: residualWhere");
+  }
+  if (plan.prefilterPlan.capability !== "EXACT_PUSHDOWN") {
+    throw new Error("FULL_SCAN_EXACT invariant: transport capability");
+  }
+  if (!serializedMultisetContains(plan.serializedWholeWhere, occurrences)) {
+    throw new Error("FULL_SCAN_EXACT invariant: relative occurrence serialization");
+  }
+}
+function serverOnlyFunctionOccurrencesInWhere(where) {
+  const names = [];
+  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"] === "KINTONE_FUNC" && typeof value["name"] === "string" && isServerOnlyWhereFunctionName(value["name"])) {
+      names.push(value["name"]);
+      return;
+    }
+    Object.values(value).forEach(visit);
+  };
+  visit(where);
+  return names;
+}
+function collectExactServerFunctionLeaves(where) {
+  const leaves = [];
+  const visit = (node) => {
+    switch (node.type) {
+      case "BINARY":
+        if (node.right.type === "KINTONE_FUNC" && isServerOnlyWhereFunctionName(node.right.name) || node.right.type === "IN_LIST" && node.right.values.length === 1 && node.right.values[0].type === "KINTONE_FUNC" && isServerOnlyWhereFunctionName(node.right.values[0].name)) {
+          leaves.push(node);
+        }
+        return;
+      case "LOGICAL":
+        visit(node.left);
+        visit(node.right);
+        return;
+      case "NOT":
+      case "GROUP":
+        visit(node.expr);
+        return;
+      case "EXISTS":
+      case "NULL_CHECK":
+      case "BOOLEAN":
+        return;
+    }
+  };
+  visit(where);
+  return leaves;
+}
+function sameOccurrenceList(actual, expected) {
+  return actual.length === expected.length && actual.every((name, index) => name === expected[index]);
+}
+function serializedMultisetContains(query, expectedNames) {
+  const expected = /* @__PURE__ */ new Map();
+  for (const name of expectedNames) {
+    if (!isServerOnlyWhereFunctionName(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/core/klikeValidation.ts
 var KlikeValidationError = class extends Error {
   constructor(message) {
@@ -6115,6 +6242,10 @@ function validateSelect(stmt) {
         validateNestedSelects(stmt);
         return;
       }
+      if (canDeferJoinWholeWhereKlikeValidation(stmt)) {
+        validateNestedSelects(stmt);
+        return;
+      }
       throw new KlikeValidationError(
         "FULL_SCAN \u306E KLIKE / NOT KLIKE \u306F\u3001\u7269\u7406\u30C6\u30FC\u30D6\u30EB\u306B\u5BFE\u3059\u308B AND \u30EA\u30FC\u30D5\u3068\u3057\u3066\u5FC5\u305A\u62BC\u3057\u4E0B\u3052\u3089\u308C\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002OR / NOT \u914D\u4E0B\u3001CTE\u30FB\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u3001LEFT / RIGHT JOIN \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
       );
@@ -6122,6 +6253,11 @@ function validateSelect(stmt) {
   }
   validateNestedSelects(stmt);
 }
+function canDeferJoinWholeWhereKlikeValidation(stmt) {
+  return stmt.where !== null && serverOnlyFunctionOccurrencesInWhere(stmt.where).length > 0 && stmt.joins.length > 0 && stmt.joins.every((join2) => join2.type === "INNER") && [stmt.from, ...stmt.joins.map((join2) => join2.table)].every(
+    (table) => table.alias !== null && table.cteName === null && !table.subtableCode
+  );
+}
 function validateOwnKlikeExpressions(stmt) {
   walkWithoutNestedSelects(stmt, (where) => {
     if (!isKlike(where)) return;
@@ -10453,6 +10589,28 @@ function validateDeclaredBatchVariables(statements, input) {
   return normalized;
 }
 
+// src/core/outerJoinSearchAbortGuard.ts
+function isOuterJoinSelect(value) {
+  if (value["type"] !== "SELECT" || !Array.isArray(value["joins"])) return false;
+  return value["joins"].some((join2) => {
+    if (join2 === null || typeof join2 !== "object") return false;
+    const type = join2["type"];
+    return type === "LEFT" || type === "RIGHT";
+  });
+}
+function statementContainsOuterJoin(statement) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    if (Array.isArray(value)) return value.some(visit);
+    if (value === null || typeof value !== "object" || seen.has(value)) return false;
+    seen.add(value);
+    const object = value;
+    if (isOuterJoinSelect(object)) return true;
+    return Object.values(object).some(visit);
+  };
+  return visit(statement);
+}
+
 // src/core/explainMetadata.ts
 function buildGroupingExplainMetadata(statement, canonicalItemCount) {
   const grouping = normalizeGroupingSpec(statement);
@@ -11211,6 +11369,30 @@ function classifyJoinPushdownLeaf(predicate, sources) {
   const relation = classifySupportedLeaf(predicate, owner, fieldType);
   return relation === "unsafe" ? unsafe() : Object.freeze({ relation, owner });
 }
+function classifyJoinServerFunctionLeaf(predicate, sources) {
+  const functionOccurrences = serverOnlyFunctionOccurrencesInWhere(predicate);
+  if (functionOccurrences.length === 0 || predicate.left.type !== "FIELD") {
+    return Object.freeze({ relation: "unsafe" });
+  }
+  const owner = resolveJoinFieldOwner(predicate.left, sources);
+  if (owner.status !== "OWNED" || owner.source.sourceKind !== "APP") {
+    return Object.freeze({ relation: "unsafe" });
+  }
+  const capability = classifyWhereCapability(predicate, (field) => {
+    const resolved = resolveJoinFieldOwner(field, sources);
+    if (resolved.status !== "OWNED" || resolved.source !== owner.source) return void 0;
+    const type = resolved.source.fieldTypes.get(resolved.fieldCode);
+    return type === void 0 ? void 0 : resolveFieldSemantics({ fieldType: type });
+  });
+  if (capability.capability !== "EXACT_PUSHDOWN") {
+    return Object.freeze({ relation: "unsafe" });
+  }
+  return Object.freeze({
+    relation: "function-leaf-exact",
+    owner,
+    functionOccurrences: Object.freeze([...functionOccurrences])
+  });
+}
 function buildJoinPushdownPlan(where, sources) {
   const allKlikes = /* @__PURE__ */ new Set();
   collectKlikes2(where, allKlikes);
@@ -11221,15 +11403,370 @@ function buildJoinPushdownPlan(where, sources) {
     predicate: fragment.predicate,
     relation: fragment.relation
   }));
+  const serverFunctionFoundation = buildServerFunctionFoundation(where, sources);
   const appliedKlikes = /* @__PURE__ */ new Set();
-  for (const item of items) collectKlikes2(item.predicate, appliedKlikes);
+  if (serverFunctionFoundation.serverFunctionCandidate?.variant === "WHOLE_WHERE_EXACT") {
+    for (const klike of allKlikes) appliedKlikes.add(klike);
+  } else {
+    for (const item of items) collectKlikes2(item.predicate, appliedKlikes);
+  }
   return Object.freeze({
     items: Object.freeze(items),
     appliedKlikes,
     allKlikes: Object.freeze([...allKlikes]),
-    rejections: Object.freeze(collectRejections(where, sources))
+    rejections: Object.freeze(collectRejections(where, sources)),
+    fetchQueriesByAlias: /* @__PURE__ */ new Map(),
+    ...serverFunctionFoundation
+  });
+}
+function bindJoinServerFunctionFetches(plan, sources) {
+  if (plan.serverFunctionCandidate?.staticContract !== "CONFIRMED" || plan.serverFunctionConsumptions.length === 0 || plan.residualServerFunctionOccurrences.length !== 0 || !sameStringMultiset(
+    plan.allServerFunctionOccurrences,
+    plan.adoptedServerFunctionOccurrences
+  ) || plan.allKlikes.some((klike) => !plan.appliedKlikes.has(klike))) {
+    return plan;
+  }
+  const queryPartsByAlias = /* @__PURE__ */ new Map();
+  const append = (alias, query) => {
+    const parts = queryPartsByAlias.get(alias);
+    if (parts) parts.push(query);
+    else queryPartsByAlias.set(alias, [query]);
+  };
+  try {
+    if (plan.serverFunctionCandidate.variant === "EXACT_LEAF") {
+      for (const item of plan.items) {
+        append(item.targetAlias, serializeJoinPushdownItem(item, sources));
+      }
+    }
+    for (const consumption of plan.serverFunctionConsumptions) {
+      const source = sources.find(
+        (candidate) => candidate.alias === consumption.targetAlias && candidate.appId === consumption.appId && candidate.sourceKind === "APP"
+      );
+      if (!source) return plan;
+      const serialized = serializeJoinPushdownItem({
+        targetAlias: consumption.targetAlias,
+        appId: consumption.appId,
+        predicate: consumption.predicate,
+        relation: "exact"
+      }, sources);
+      if (serialized !== consumption.serializedPredicate || !sameStringMultiset(
+        serverFunctionOccurrencesInSerializedQuery(serialized),
+        consumption.functionOccurrences
+      )) {
+        return plan;
+      }
+      append(consumption.targetAlias, serialized);
+    }
+  } catch {
+    return plan;
+  }
+  const fetchQueriesByAlias = /* @__PURE__ */ new Map();
+  for (const [alias, parts] of queryPartsByAlias) {
+    fetchQueriesByAlias.set(
+      alias,
+      parts.length === 1 ? parts[0] : parts.map((part) => `(${part})`).join(" and ")
+    );
+  }
+  const boundConsumptions = plan.serverFunctionConsumptions.map((consumption) => {
+    const query = fetchQueriesByAlias.get(consumption.targetAlias);
+    if (!query) return null;
+    return Object.freeze({
+      ...consumption,
+      fetchBinding: Object.freeze({
+        status: "BOUND_TO_TARGET_FETCH",
+        targetAlias: consumption.targetAlias,
+        appId: consumption.appId,
+        query
+      })
+    });
+  });
+  if (boundConsumptions.some((consumption) => consumption === null)) return plan;
+  return Object.freeze({
+    ...plan,
+    serverFunctionCandidate: Object.freeze({
+      ...plan.serverFunctionCandidate,
+      fetchContract: "CONFIRMED"
+    }),
+    serverFunctionConsumptions: Object.freeze(
+      boundConsumptions
+    ),
+    fetchQueriesByAlias
   });
 }
+function isJoinServerFunctionFetchPlan(plan) {
+  if (plan.serverFunctionCandidate === null || plan.serverFunctionCandidate.staticContract !== "CONFIRMED" || plan.serverFunctionCandidate.fetchContract !== "CONFIRMED" || plan.serverFunctionConsumptions.length === 0 || plan.residualServerFunctionOccurrences.length !== 0 || !sameStringMultiset(
+    plan.allServerFunctionOccurrences,
+    plan.adoptedServerFunctionOccurrences
+  )) {
+    return false;
+  }
+  if (!plan.serverFunctionConsumptions.every((consumption) => {
+    const binding = consumption.fetchBinding;
+    return binding !== "PENDING_STEP_2" && binding.status === "BOUND_TO_TARGET_FETCH" && binding.targetAlias === consumption.targetAlias && binding.appId === consumption.appId && binding.query === plan.fetchQueriesByAlias.get(consumption.targetAlias) && binding.query.includes(consumption.serializedPredicate);
+  })) {
+    return false;
+  }
+  for (const [alias, query] of plan.fetchQueriesByAlias) {
+    const expected = plan.serverFunctionConsumptions.filter((consumption) => consumption.targetAlias === alias).flatMap((consumption) => [...consumption.functionOccurrences]);
+    if (expected.length > 0 && !sameStringMultiset(
+      serverFunctionOccurrencesInSerializedQuery(query),
+      expected
+    )) {
+      return false;
+    }
+  }
+  if (plan.serverFunctionCandidate.variant === "WHOLE_WHERE_EXACT" && (plan.serverFunctionConsumptions.length !== 1 || plan.serverFunctionConsumptions[0].consumption !== "whole-where" || plan.residualWhere !== null || plan.allKlikes.some((klike) => !plan.appliedKlikes.has(klike)) || countSerializedKlikes(queryForWholeWhere(plan)) !== plan.allKlikes.length)) {
+    return false;
+  }
+  return true;
+}
+function buildServerFunctionFoundation(where, sources) {
+  if (where === null) return emptyServerFunctionFoundation(null);
+  const allOccurrences = Object.freeze([
+    ...serverOnlyFunctionOccurrencesInWhere(where)
+  ]);
+  if (allOccurrences.length === 0) return emptyServerFunctionFoundation(where);
+  const wholeWhere = buildWholeWhereServerFunctionFoundation(
+    where,
+    sources,
+    allOccurrences
+  );
+  if (wholeWhere !== null) return wholeWhere;
+  const candidates = collectServerFunctionLeavesOnAndSpine(where);
+  const consumptions = [];
+  const adoptedLeaves = /* @__PURE__ */ new Set();
+  for (const leaf of candidates) {
+    const classification = classifyJoinServerFunctionLeaf(leaf, sources);
+    if (classification.relation !== "function-leaf-exact") continue;
+    const guardItem = {
+      targetAlias: classification.owner.alias,
+      appId: classification.owner.appId,
+      predicate: leaf,
+      relation: "exact"
+    };
+    let serializedPredicate;
+    try {
+      serializedPredicate = serializeJoinPushdownItem(guardItem, sources);
+    } catch {
+      continue;
+    }
+    const serializedOccurrences = serverFunctionOccurrencesInSerializedQuery(serializedPredicate);
+    if (!sameStringMultiset(serializedOccurrences, classification.functionOccurrences)) {
+      continue;
+    }
+    adoptedLeaves.add(leaf);
+    consumptions.push(Object.freeze({
+      targetAlias: classification.owner.alias,
+      appId: classification.owner.appId,
+      predicate: leaf,
+      functionLeaves: Object.freeze([leaf]),
+      functionOccurrences: classification.functionOccurrences,
+      relation: classification.relation,
+      consumption: "leaf",
+      serializedPredicate,
+      staticProof: Object.freeze({
+        classifier: "EXACT_PUSHDOWN",
+        ownership: "OWNED",
+        serialization: "OCCURRENCE_MULTISET_EXACT",
+        residualIdentityConsumption: "CONFIRMED"
+      }),
+      fetchBinding: "PENDING_STEP_2"
+    }));
+  }
+  const residualWhere = removeAdoptedLeavesFromAndSpine(where, adoptedLeaves);
+  const residualOccurrences = Object.freeze(residualWhere === null ? [] : [...serverOnlyFunctionOccurrencesInWhere(residualWhere)]);
+  const adoptedOccurrences = Object.freeze(consumptions.flatMap(
+    (consumption) => [...consumption.functionOccurrences]
+  ));
+  const staticContract = sameStringMultiset(allOccurrences, adoptedOccurrences) && residualOccurrences.length === 0 ? "CONFIRMED" : "INCOMPLETE";
+  return {
+    serverFunctionCandidate: Object.freeze({
+      variant: "EXACT_LEAF",
+      staticContract,
+      fetchContract: "PENDING_STEP_2"
+    }),
+    serverFunctionConsumptions: Object.freeze(consumptions),
+    allServerFunctionOccurrences: allOccurrences,
+    adoptedServerFunctionOccurrences: adoptedOccurrences,
+    residualWhere,
+    residualServerFunctionOccurrences: residualOccurrences
+  };
+}
+function buildWholeWhereServerFunctionFoundation(where, sources, allOccurrences) {
+  const owner = classifyWholeWhereExactOwner(where, sources);
+  if (owner === null) return null;
+  const item = {
+    targetAlias: owner.alias,
+    appId: owner.appId,
+    predicate: where,
+    relation: "exact"
+  };
+  let serializedPredicate;
+  try {
+    serializedPredicate = serializeJoinPushdownItem(item, sources);
+  } catch {
+    return null;
+  }
+  if (!sameStringMultiset(
+    serverFunctionOccurrencesInSerializedQuery(serializedPredicate),
+    allOccurrences
+  )) {
+    return null;
+  }
+  const allKlikes = /* @__PURE__ */ new Set();
+  collectKlikes2(where, allKlikes);
+  if (countSerializedKlikes(serializedPredicate) !== allKlikes.size) return null;
+  const functionLeaves = Object.freeze(collectServerFunctionLeaves(where));
+  const consumption = Object.freeze({
+    targetAlias: owner.alias,
+    appId: owner.appId,
+    predicate: where,
+    functionLeaves,
+    functionOccurrences: Object.freeze([...allOccurrences]),
+    relation: "function-leaf-exact",
+    consumption: "whole-where",
+    serializedPredicate,
+    staticProof: Object.freeze({
+      classifier: "EXACT_PUSHDOWN",
+      ownership: "OWNED",
+      serialization: "OCCURRENCE_MULTISET_EXACT",
+      residualIdentityConsumption: "CONFIRMED"
+    }),
+    fetchBinding: "PENDING_STEP_2"
+  });
+  return {
+    serverFunctionCandidate: Object.freeze({
+      variant: "WHOLE_WHERE_EXACT",
+      staticContract: "CONFIRMED",
+      fetchContract: "PENDING_STEP_2"
+    }),
+    serverFunctionConsumptions: Object.freeze([consumption]),
+    allServerFunctionOccurrences: Object.freeze([...allOccurrences]),
+    adoptedServerFunctionOccurrences: Object.freeze([...allOccurrences]),
+    residualWhere: null,
+    residualServerFunctionOccurrences: Object.freeze([])
+  };
+}
+function classifyWholeWhereExactOwner(where, sources) {
+  switch (where.type) {
+    case "BINARY": {
+      const functionOccurrences = serverOnlyFunctionOccurrencesInWhere(where);
+      if (functionOccurrences.length > 0) {
+        const classification2 = classifyJoinServerFunctionLeaf(where, sources);
+        return classification2.relation === "function-leaf-exact" ? classification2.owner : null;
+      }
+      const classification = classifyJoinPushdownLeaf(where, sources);
+      return classification.relation === "exact" && classification.owner !== void 0 ? classification.owner : null;
+    }
+    case "LOGICAL": {
+      const left = classifyWholeWhereExactOwner(where.left, sources);
+      const right = classifyWholeWhereExactOwner(where.right, sources);
+      return left !== null && right !== null && sameOwner(left, right) ? left : null;
+    }
+    case "GROUP":
+    case "NOT":
+      return classifyWholeWhereExactOwner(where.expr, sources);
+    case "NULL_CHECK":
+    case "EXISTS":
+    case "BOOLEAN":
+      return null;
+  }
+}
+function collectServerFunctionLeaves(where) {
+  switch (where.type) {
+    case "BINARY":
+      return serverOnlyFunctionOccurrencesInWhere(where).length > 0 ? [where] : [];
+    case "LOGICAL":
+      return [
+        ...collectServerFunctionLeaves(where.left),
+        ...collectServerFunctionLeaves(where.right)
+      ];
+    case "GROUP":
+    case "NOT":
+      return collectServerFunctionLeaves(where.expr);
+    case "NULL_CHECK":
+    case "EXISTS":
+    case "BOOLEAN":
+      return [];
+  }
+}
+function emptyServerFunctionFoundation(where) {
+  const occurrences = where === null ? [] : serverOnlyFunctionOccurrencesInWhere(where);
+  return {
+    serverFunctionCandidate: null,
+    serverFunctionConsumptions: Object.freeze([]),
+    allServerFunctionOccurrences: Object.freeze([...occurrences]),
+    adoptedServerFunctionOccurrences: Object.freeze([]),
+    residualWhere: where,
+    residualServerFunctionOccurrences: Object.freeze([...occurrences])
+  };
+}
+function collectServerFunctionLeavesOnAndSpine(where) {
+  switch (where.type) {
+    case "BINARY":
+      return serverOnlyFunctionOccurrencesInWhere(where).length > 0 ? [where] : [];
+    case "LOGICAL":
+      return where.op === "AND" ? [
+        ...collectServerFunctionLeavesOnAndSpine(where.left),
+        ...collectServerFunctionLeavesOnAndSpine(where.right)
+      ] : [];
+    case "GROUP":
+      return collectServerFunctionLeavesOnAndSpine(where.expr);
+    case "NOT":
+    case "NULL_CHECK":
+    case "EXISTS":
+    case "BOOLEAN":
+      return [];
+  }
+}
+function removeAdoptedLeavesFromAndSpine(where, adoptedLeaves) {
+  if (where.type === "BINARY") return adoptedLeaves.has(where) ? null : where;
+  if (where.type === "LOGICAL") {
+    if (where.op !== "AND") return where;
+    const left = removeAdoptedLeavesFromAndSpine(where.left, adoptedLeaves);
+    const right = removeAdoptedLeavesFromAndSpine(where.right, adoptedLeaves);
+    if (left === null) return right;
+    if (right === null) return left;
+    if (left === where.left && right === where.right) return where;
+    return { ...where, left, right };
+  }
+  if (where.type === "GROUP") {
+    const expr = removeAdoptedLeavesFromAndSpine(where.expr, adoptedLeaves);
+    if (expr === null) return null;
+    return expr === where.expr ? where : { ...where, expr };
+  }
+  return where;
+}
+function serverFunctionOccurrencesInSerializedQuery(query) {
+  const matches = [];
+  for (const name of SERVER_ONLY_WHERE_FUNCTION_NAMES) {
+    const pattern = new RegExp(`\\b${name}\\s*\\(`, "g");
+    let match;
+    while ((match = pattern.exec(query)) !== null) {
+      matches.push({ name, index: match.index });
+    }
+  }
+  return matches.sort((left, right) => left.index - right.index).map((match) => match.name);
+}
+function sameStringMultiset(left, right) {
+  if (left.length !== right.length) return false;
+  const counts = /* @__PURE__ */ new Map();
+  for (const value of left) counts.set(value, (counts.get(value) ?? 0) + 1);
+  for (const value of right) {
+    const count = counts.get(value);
+    if (count === void 0) return false;
+    if (count === 1) counts.delete(value);
+    else counts.set(value, count - 1);
+  }
+  return counts.size === 0;
+}
+function countSerializedKlikes(query) {
+  return [...query.matchAll(/\s(?:not\s+)?like\s/g)].length;
+}
+function queryForWholeWhere(plan) {
+  const consumption = plan.serverFunctionConsumptions[0];
+  return consumption === void 0 ? "" : plan.fetchQueriesByAlias.get(consumption.targetAlias) ?? "";
+}
 function collectRejections(where, sources) {
   if (where === null) return [];
   const reasons = /* @__PURE__ */ new Set();
@@ -11300,6 +11837,9 @@ function assertPredicateOwnership(predicate, item, sources) {
     case "GROUP":
       assertPredicateOwnership(predicate.expr, item, sources);
       return;
+    case "NOT":
+      assertPredicateOwnership(predicate.expr, item, sources);
+      return;
     case "BINARY": {
       if (predicate.left.type !== "FIELD" || containsFieldReference(predicate.right)) {
         throw joinOwnershipError(item, "predicate contains a non-target or RHS field reference");
@@ -11310,7 +11850,6 @@ function assertPredicateOwnership(predicate, item, sources) {
       }
       return;
     }
-    case "NOT":
     case "NULL_CHECK":
     case "EXISTS":
     case "BOOLEAN":
@@ -13116,133 +13655,6 @@ function deepClone(value, seen = /* @__PURE__ */ new Map()) {
   return clone;
 }
 
-// src/core/optimization/relativeDateFullScanExactPlan.ts
-function buildRelativeDateFullScanExactPlan(input) {
-  const {
-    select,
-    selectMode,
-    capability,
-    context,
-    serializedWholeWhere,
-    relativeFunctionNames
-  } = input;
-  if (select.where === null) return null;
-  if (select.from.appId <= 0 || select.from.cteName !== null) return null;
-  if (select.from.subtableCode) return null;
-  if (select.joins.length > 0) return null;
-  if (!context.allowFullScanExact) return null;
-  if (select.orderMode === "KINTONE_NATIVE") return null;
-  const hasCanonicalOrder2 = select.orderMode === "CANONICAL" && select.orderBy.length > 0;
-  if (selectMode !== "FULL_SCAN" && !hasCanonicalOrder2) return null;
-  if (capability.capability !== "EXACT_PUSHDOWN") return null;
-  const occurrences = serverOnlyFunctionOccurrencesInWhere(select.where);
-  if (occurrences.length === 0) return null;
-  if (!sameOccurrenceList(occurrences, relativeFunctionNames)) return null;
-  if (serializedWholeWhere === null || !serializedMultisetContains(serializedWholeWhere, occurrences)) {
-    return null;
-  }
-  const prefilterPlan = {
-    prefilterWhere: select.where,
-    residualWhere: null,
-    exactRelativeLeaves: collectExactServerFunctionLeaves(select.where),
-    relativeFunctionNames: new Set(occurrences),
-    appliedKlikes: /* @__PURE__ */ new Set(),
-    capability: capability.capability,
-    reasons: capability.reasons
-  };
-  const plan = {
-    allowForm: "FULL_SCAN_EXACT",
-    clientWhereEvaluation: false,
-    serializedWholeWhere,
-    prefilterPlan
-  };
-  assertRelativeDateFullScanExactPlan(plan, input, occurrences);
-  return plan;
-}
-function assertRelativeDateFullScanExactPlan(plan, input, occurrences) {
-  if (plan.allowForm !== "FULL_SCAN_EXACT") {
-    throw new Error("FULL_SCAN_EXACT invariant: allowForm");
-  }
-  if (plan.clientWhereEvaluation !== false) {
-    throw new Error("FULL_SCAN_EXACT invariant: clientWhereEvaluation");
-  }
-  if (input.capability.capability !== "EXACT_PUSHDOWN") {
-    throw new Error("FULL_SCAN_EXACT invariant: capability");
-  }
-  if (input.select.where === null || plan.prefilterPlan.prefilterWhere !== input.select.where) {
-    throw new Error("FULL_SCAN_EXACT invariant: whole WHERE identity");
-  }
-  if (plan.prefilterPlan.residualWhere !== null) {
-    throw new Error("FULL_SCAN_EXACT invariant: residualWhere");
-  }
-  if (plan.prefilterPlan.capability !== "EXACT_PUSHDOWN") {
-    throw new Error("FULL_SCAN_EXACT invariant: transport capability");
-  }
-  if (!serializedMultisetContains(plan.serializedWholeWhere, occurrences)) {
-    throw new Error("FULL_SCAN_EXACT invariant: relative occurrence serialization");
-  }
-}
-function serverOnlyFunctionOccurrencesInWhere(where) {
-  const names = [];
-  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"] === "KINTONE_FUNC" && typeof value["name"] === "string" && isServerOnlyWhereFunctionName(value["name"])) {
-      names.push(value["name"]);
-      return;
-    }
-    Object.values(value).forEach(visit);
-  };
-  visit(where);
-  return names;
-}
-function collectExactServerFunctionLeaves(where) {
-  const leaves = [];
-  const visit = (node) => {
-    switch (node.type) {
-      case "BINARY":
-        if (node.right.type === "KINTONE_FUNC" && isServerOnlyWhereFunctionName(node.right.name) || node.right.type === "IN_LIST" && node.right.values.length === 1 && node.right.values[0].type === "KINTONE_FUNC" && isServerOnlyWhereFunctionName(node.right.values[0].name)) {
-          leaves.push(node);
-        }
-        return;
-      case "LOGICAL":
-        visit(node.left);
-        visit(node.right);
-        return;
-      case "NOT":
-      case "GROUP":
-        visit(node.expr);
-        return;
-      case "EXISTS":
-      case "NULL_CHECK":
-      case "BOOLEAN":
-        return;
-    }
-  };
-  visit(where);
-  return leaves;
-}
-function sameOccurrenceList(actual, expected) {
-  return actual.length === expected.length && actual.every((name, index) => name === expected[index]);
-}
-function serializedMultisetContains(query, expectedNames) {
-  const expected = /* @__PURE__ */ new Map();
-  for (const name of expectedNames) {
-    if (!isServerOnlyWhereFunctionName(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/core/optimization/relativeDatePushdownGuard.ts
 function relativeDateFunctionNamesInNode(node, stopAtNestedSelect) {
   const names = [];
@@ -13463,6 +13875,11 @@ function serializationContainsFunctions(query, names) {
 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 allowJoinServerFunctionPlan(select, plan) {
+  return select.where !== null && select.joins.length > 0 && select.joins.every((join2) => join2.type === "INNER") && [select.from, ...select.joins.map((join2) => join2.table)].every(
+    (table) => table.alias !== null && table.cteName === null && !table.subtableCode
+  ) && isJoinServerFunctionFetchPlan(plan);
+}
 function rejectedNode(candidate) {
   return {
     kind: candidate.kind,
@@ -13562,6 +13979,14 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
           allowed2 = true;
         }
       }
+      let joinServerFunctionPlan;
+      if (!allowed2 && resolver.joinServerFunctionPlan) {
+        const candidatePlan = await resolver.joinServerFunctionPlan(select);
+        if (candidatePlan !== null && allowJoinServerFunctionPlan(select, candidatePlan)) {
+          joinServerFunctionPlan = candidatePlan;
+          allowed2 = true;
+        }
+      }
       const node2 = {
         kind: candidate.kind,
         source: candidate.source,
@@ -13572,6 +13997,11 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
         restQuery: restQuery2,
         ...prefilterPlan ? { prefilterPlan, phase2PrefilterEligible } : {},
         ...fullScanExactPlan ? { fullScanExactPlan, allowForm: fullScanExactPlan.allowForm } : {},
+        ...joinServerFunctionPlan ? {
+          joinServerFunctionPlan,
+          allowForm: "JOIN_SERVER_FUNCTION_EXACT",
+          joinServerFunctionVariant: joinServerFunctionPlan.serverFunctionCandidate.variant
+        } : {},
         clientWhereEvaluation: !allowed2,
         allowed: allowed2
       };
@@ -13663,7 +14093,7 @@ function decomposeRelativeDatePrefilter(stmt, resolveField2, testSeam = {}) {
   }
   const occurrences = collectServerFunctionOccurrences(stmt.where);
   if (occurrences.length === 0) return reject(["NO_RELATIVE_DATE"]);
-  const spine = collectServerFunctionLeavesOnAndSpine(stmt.where, resolveField2);
+  const spine = collectServerFunctionLeavesOnAndSpine2(stmt.where, resolveField2);
   if (!spine.ok) return reject(spine.reasonCodes);
   if (!sameRelativeMultiset(occurrences, spine.leaves)) {
     return reject(["RELATIVE_DATE_LEAF_COUNT_MISMATCH"]);
@@ -13741,7 +14171,7 @@ function decomposeRelativeDatePrefilter(stmt, resolveField2, testSeam = {}) {
     }
   };
 }
-function collectServerFunctionLeavesOnAndSpine(where, resolveField2) {
+function collectServerFunctionLeavesOnAndSpine2(where, resolveField2) {
   const leaves = [];
   let failure = null;
   const visit = (node) => {
@@ -14840,7 +15270,7 @@ async function execute(sql, client, options = {}) {
   const guardedClient = wrapClientWithSearchAbort(
     countedClient,
     collector,
-    !isSelectLikeStatement(stmt)
+    !isSelectLikeStatement(stmt) || statementContainsOuterJoin(stmt)
   );
   const result = await executeParsedStatement(
     stmt,
@@ -14959,9 +15389,14 @@ function wrapClientWithMetrics(client, metrics) {
     }
   };
 }
+var SEARCH_ABORT_FAIL_CLOSED = /* @__PURE__ */ Symbol("searchAbortFailClosed");
 function wrapClientWithSearchAbort(client, collector, failClosed) {
+  if (failClosed && client[SEARCH_ABORT_FAIL_CLOSED]) {
+    return client;
+  }
   return {
     ...client,
+    ...failClosed ? { [SEARCH_ABORT_FAIL_CLOSED]: true } : {},
     getRecords: async (params) => {
       const response = await client.getRecords(params);
       if (response.searchAborted) {
@@ -15029,6 +15464,15 @@ async function resolveRelativeDateExecutionPlan(stmt, client, cacheContext) {
         cacheContext
       );
       return decomposeRelativeDatePrefilter(select, resolver);
+    },
+    joinServerFunctionPlan: async (select) => {
+      const metadata = await loadTypedPushdownMeta(select, client, cacheContext);
+      const runtimePlan = buildRuntimeJoinPushdownPlan(select, metadata);
+      if (runtimePlan === null) return null;
+      if (isJoinServerFunctionFetchPlan(runtimePlan.joinPlan)) {
+        boundJoinRuntimePlans.set(select, runtimePlan);
+      }
+      return runtimePlan.joinPlan;
     }
   });
 }
@@ -15446,7 +15890,7 @@ async function executeBatch(sql, client, options = {}) {
       const statementClient = wrapClientWithSearchAbort(
         countedClient,
         searchAbortCollector,
-        info.statementType !== "SELECT" && info.statementType !== "UNION" && info.statementType !== "WITH"
+        info.statementType !== "SELECT" && info.statementType !== "UNION" && info.statementType !== "WITH" || statementContainsOuterJoin(statements[i])
       );
       const cursorScope = wrapClientWithCursorScope(statementClient);
       const outcome = await runWithDeadline(
@@ -16653,6 +17097,7 @@ function extractMainTypedPushdownCandidate(stmt) {
   if (!stmt.from.alias) return null;
   return extractTypedPushdownCandidates(stmt.where, { tableAlias: stmt.from.alias });
 }
+var boundJoinRuntimePlans = /* @__PURE__ */ new WeakMap();
 function buildRuntimeJoinPushdownPlan(stmt, metadata) {
   if (stmt.joins.length === 0 || stmt.where === null || stmt.joins.some((join2) => join2.type !== "INNER")) {
     return null;
@@ -16673,11 +17118,17 @@ function buildRuntimeJoinPushdownPlan(stmt, metadata) {
     ]),
     fieldOptions: metadata.fieldOptionsByApp.get(table.appId)
   }));
-  const plan = buildJoinPushdownPlan(stmt.where, sources);
+  const staticPlan = buildJoinPushdownPlan(stmt.where, sources);
+  const plan = bindJoinServerFunctionFetches(staticPlan, sources);
   const conditionsByAlias = /* @__PURE__ */ new Map();
   const queriesByAlias = /* @__PURE__ */ new Map();
+  for (const [alias, query] of plan.fetchQueriesByAlias) {
+    queriesByAlias.set(alias, query);
+  }
   for (const item of plan.items) {
-    queriesByAlias.set(item.targetAlias, serializeJoinPushdownItem(item, sources));
+    if (!queriesByAlias.has(item.targetAlias)) {
+      queriesByAlias.set(item.targetAlias, serializeJoinPushdownItem(item, sources));
+    }
     conditionsByAlias.set(item.targetAlias, item.predicate);
   }
   const mainAlias = stmt.from.alias;
@@ -17319,15 +17770,24 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     whereNeedsFieldMetadata(stmt.having) || selectCaseConditionsNeedFieldMetadata(stmt)
   );
   const havingFieldSemanticsResolver = buildHavingFieldSemanticsResolver(stmt, fieldSemanticsResolver);
-  const pushdownPlan = buildRuntimeJoinPushdownPlan(stmt, pushdownMeta) ?? buildKlikePushdownPlan(stmt, pushdownMeta);
+  const preboundJoinPlan = boundJoinRuntimePlans.get(stmt);
+  if (preboundJoinPlan && !isJoinServerFunctionFetchPlan(preboundJoinPlan.joinPlan)) {
+    throw new Error("InternalError: JOIN server-function fetch binding changed before records API.");
+  }
+  const pushdownPlan = preboundJoinPlan ?? buildRuntimeJoinPushdownPlan(stmt, pushdownMeta) ?? buildKlikePushdownPlan(stmt, pushdownMeta);
   validateKlikePushdownPlan(pushdownPlan);
+  const runtimeJoinPlan = "joinPlan" in pushdownPlan ? pushdownPlan : null;
+  const boundServerFunctionPlan = runtimeJoinPlan && isJoinServerFunctionFetchPlan(runtimeJoinPlan.joinPlan) ? runtimeJoinPlan : null;
   const fetchClient = client;
   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 mainFetchCondition = prefilterPlan ? prefilterPlan.prefilterWhere : boundServerFunctionPlan ? null : mainPushDown;
+  const mainBoundQuery = boundServerFunctionPlan?.queriesByAlias.get(
+    stmt.from.alias
+  ) ?? "";
   const scalarCache = await resolveScalarColumns(stmt.columns, client, options, cacheContext, cteCache);
   const constantFalse = isConstantFalseWhere(stmt.where);
   const mainFetch = constantFalse ? Promise.resolve([]) : fetchTableRecordsForFullScan(
@@ -17340,8 +17800,9 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     options.onLimitReached ?? "error",
     warnings,
     mainFetchCondition,
-    allowOriginalWherePushdown,
-    plainGroupByPlan
+    boundServerFunctionPlan ? false : allowOriginalWherePushdown,
+    plainGroupByPlan,
+    mainBoundQuery
   );
   const parallelJoins = [];
   const onOptJoins = [];
@@ -17350,8 +17811,9 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
       parallelJoins.push({ join: join2, promise: Promise.resolve([]) });
       continue;
     }
-    const jCond = join2.table.alias ? tableConditions.get(join2.table.alias) ?? null : null;
-    if (jCond !== null) {
+    const boundQuery = join2.table.alias ? boundServerFunctionPlan?.queriesByAlias.get(join2.table.alias) ?? "" : "";
+    const jCond = boundServerFunctionPlan ? null : join2.table.alias ? tableConditions.get(join2.table.alias) ?? null : null;
+    if (jCond !== null || boundQuery !== "") {
       parallelJoins.push({
         join: join2,
         promise: fetchTableRecordsForFullScan(
@@ -17365,7 +17827,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
           warnings,
           jCond,
           true,
-          plainGroupByPlan
+          plainGroupByPlan,
+          boundQuery
         )
       });
     } else {
@@ -17425,7 +17888,7 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     havingFieldSemanticsResolver,
     aggregateSortKindResolver,
     appliedKlikes: prefilterPlan?.appliedKlikes ?? pushdownPlan.appliedKlikes,
-    ...prefilterPlan ? { residualWhere: prefilterPlan.residualWhere } : {},
+    ...prefilterPlan ? { residualWhere: prefilterPlan.residualWhere } : boundServerFunctionPlan ? { residualWhere: boundServerFunctionPlan.joinPlan.residualWhere } : {},
     resolvedGroupingSpec: resolvedGroupingSpecs.get(stmt),
     plainGroupByPlan
   });
@@ -21133,8 +21596,11 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
       }
       capabilities.set(select, capability);
-      const joinPushdownMeta = await loadTypedPushdownMeta(select, tracedClient, cacheContext);
-      const joinPushdownPlan = buildRuntimeJoinPushdownPlan(select, joinPushdownMeta);
+      const preboundJoinPushdownPlan = boundJoinRuntimePlans.get(select);
+      const joinPushdownPlan = preboundJoinPushdownPlan ?? buildRuntimeJoinPushdownPlan(
+        select,
+        await loadTypedPushdownMeta(select, tracedClient, cacheContext)
+      );
       if (joinPushdownPlan) explainJoinPushdownPlans.set(select, joinPushdownPlan);
       if (select.orderBy.length > 0 || select.columns.some((column) => column.type === "WINDOW_COL" && column.orderBy.length > 0)) {
         const meta = await buildOrderByMetaForSelect(select, tracedClient, cacheContext);
@@ -21372,9 +21838,15 @@ function relativeDateExplainLines(plan) {
   if (!plan.hasServerOnlyWhereFunction) return [];
   if (!plan.allowed && plan.rejection) {
     const label = isRelativeDateFunctionName(plan.rejection.functionName) ? "relative date function" : "kintone function";
+    const rejectedNode2 = plan.nodes[plan.nodes.length - 1];
+    const detail = rejectedNode2?.capability?.reasons.find(
+      (reason) => reason.functionName === plan.rejection.functionName
+    );
+    const target = rejectedNode2 ? findServerFunctionExplainTarget(rejectedNode2.source, plan.rejection.functionName) : null;
     return [
       `  ${label}: ${plan.rejection.functionName}`,
       "  plan status: rejected",
+      `  target alias / field: ${target?.alias ?? "(unknown)"} / ${detail?.field ?? target?.field ?? "(unknown)"}`,
       `  reason: ${plan.rejection.reasonCodes.join(", ")}`,
       "  client evaluation: forbidden",
       "  records/cursor/mutation API during EXPLAIN: none"
@@ -21382,6 +21854,41 @@ function relativeDateExplainLines(plan) {
   }
   const lines = [];
   for (const node of plan.nodes) {
+    const joinServerFunctionPlan = node.joinServerFunctionPlan;
+    if (node.allowed && node.allowForm === "JOIN_SERVER_FUNCTION_EXACT" && joinServerFunctionPlan) {
+      const variant = node.joinServerFunctionVariant === "WHOLE_WHERE_EXACT" ? "whole-WHERE" : "leaf";
+      lines.push(
+        `  allow form: JOIN_SERVER_FUNCTION_EXACT (${variant})`
+      );
+      for (const consumption of joinServerFunctionPlan.serverFunctionConsumptions) {
+        for (const leaf of consumption.functionLeaves) {
+          const functionName = serverFunctionNameOfExplainLeaf(leaf);
+          const field = leaf.left.type === "FIELD" ? leaf.left.field : "(unknown)";
+          lines.push(
+            `  ${serverFunctionLabel(functionName)}: ${functionName}`,
+            `  ${serverFunctionEvaluationLabel(functionName)}: kintone server exact JOIN prefilter`,
+            `  target alias / APP: ${consumption.targetAlias} / APP${consumption.appId}`,
+            `  field: ${field}`,
+            `  function leaf relation: ${consumption.relation}`,
+            `  consumption: ${consumption.consumption}`
+          );
+        }
+      }
+      lines.push(
+        `  client residual: ${joinServerFunctionPlan.residualWhere === null ? "(none)" : renderRelativeDateResidualWhere(joinServerFunctionPlan.residualWhere)}`
+      );
+      if (joinServerFunctionPlan.adoptedServerFunctionOccurrences.some(
+        isRelativeDateFunctionName
+      )) {
+        lines.push("  relative date client evaluations: 0");
+      }
+      if (joinServerFunctionPlan.adoptedServerFunctionOccurrences.some(
+        (name) => !isRelativeDateFunctionName(name)
+      )) {
+        lines.push("  kintone function client evaluations: 0");
+      }
+      continue;
+    }
     const fullScanExactPlan = node.fullScanExactPlan;
     if (node.allowed && node.allowForm === "FULL_SCAN_EXACT" && fullScanExactPlan) {
       for (const leaf of fullScanExactPlan.prefilterPlan.exactRelativeLeaves) {
@@ -21466,6 +21973,36 @@ function relativeDateExplainLines(plan) {
   }
   return lines;
 }
+function findServerFunctionExplainTarget(source, functionName) {
+  const where = "where" in source ? source.where : null;
+  let found = null;
+  const visit = (value) => {
+    if (found || value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    const node = value;
+    if (node["type"] === "BINARY") {
+      const left = node["left"];
+      const right = node["right"];
+      const directlyMatches = right?.["type"] === "KINTONE_FUNC" && right["name"] === functionName;
+      const listMatches = right?.["type"] === "IN_LIST" && Array.isArray(right["values"]) && right["values"].some(
+        (entry) => entry !== null && typeof entry === "object" && entry["type"] === "KINTONE_FUNC" && entry["name"] === functionName
+      );
+      if ((directlyMatches || listMatches) && left?.["type"] === "FIELD" && typeof left["field"] === "string") {
+        found = {
+          alias: typeof left["tableAlias"] === "string" ? left["tableAlias"] : null,
+          field: left["field"]
+        };
+        return;
+      }
+    }
+    Object.values(node).forEach(visit);
+  };
+  visit(where);
+  return found;
+}
 function serverFunctionLabel(functionName) {
   return isRelativeDateFunctionName(functionName) ? "relative date function" : "kintone function";
 }
@@ -21883,10 +22420,22 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
         lines.push("  join pushdown plan: applied (runtime metadata resolved)");
         lines.push("  runtime plan timing: variables/subqueries resolved -> metadata resolved -> immutable plan");
         lines.push("  EXPLAIN unresolved subqueries: not applied (records API is not called)");
-        lines.push("  residual: original WHERE");
+        if (runtimeJoinPlan.joinPlan.serverFunctionCandidate) {
+          lines.push(
+            `  allow form: JOIN_SERVER_FUNCTION_EXACT (${runtimeJoinPlan.joinPlan.serverFunctionCandidate.variant === "WHOLE_WHERE_EXACT" ? "whole-WHERE" : "leaf"})`
+          );
+        }
+        lines.push(
+          `  client residual: ${runtimeJoinPlan.joinPlan.residualWhere === null ? "(none)" : renderRelativeDateResidualWhere(runtimeJoinPlan.joinPlan.residualWhere)}`
+        );
         lines.push(`  KLIKE applied nodes: ${runtimeJoinPlan.joinPlan.appliedKlikes.size}`);
-        for (const rejection of runtimeJoinPlan.joinPlan.rejections) {
-          lines.push(`  join pushdown not applied: ${rejection.reason}`);
+        lines.push(
+          `  KLIKE unapplied nodes: ${runtimeJoinPlan.joinPlan.allKlikes.length - runtimeJoinPlan.joinPlan.appliedKlikes.size}`
+        );
+        if (runtimeJoinPlan.joinPlan.residualWhere !== null) {
+          for (const rejection of runtimeJoinPlan.joinPlan.rejections) {
+            lines.push(`  join pushdown not applied: ${rejection.reason}`);
+          }
         }
       } else {
         const reason = stmt.joins.some((join2) => join2.type !== "INNER") ? "OUTER_JOIN" : [stmt.from, ...stmt.joins.map((join2) => join2.table)].some(
@@ -21901,15 +22450,19 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
     const mainPushDown = pushdownPlan.mainCondition;
     const mainCandidate = extractMainTypedPushdownCandidate(stmt);
     const exactOriginalWhere = stmt.joins.length === 0 && whereCapability?.capability === "EXACT_PUSHDOWN" && stmt.where !== null && !whereRequiresJsEval(stmt.where) ? whereToKintone(stmt.where) : "";
-    const mainQ = mainPushDown !== null ? whereToKintone(mainPushDown) : exactOriginalWhere || "(\u5168\u4EF6\u53D6\u5F97)";
+    const mainBoundQuery = stmt.from.alias ? runtimeJoinPlan?.queriesByAlias.get(stmt.from.alias) : void 0;
+    const mainQ = mainBoundQuery || (mainPushDown !== null ? whereToKintone(mainPushDown) : exactOriginalWhere || "(\u5168\u4EF6\u53D6\u5F97)");
     lines.push(`  app:           APP${stmt.from.appId}${mainAliasStr} (${stmt.from.appId})`);
     lines.push(`  kintone query: ${mainQ}`);
     const mainJoinItem = runtimeJoinPlan?.joinPlan.items.find(
       (item) => item.targetAlias === stmt.from.alias
     );
-    if (mainJoinItem) {
-      lines.push(`  pushdown applied: ${runtimeJoinPlan.queriesByAlias.get(mainJoinItem.targetAlias)}`);
-      lines.push(`  relation: ${mainJoinItem.relation}`);
+    const mainFunctionConsumption = runtimeJoinPlan?.joinPlan.serverFunctionConsumptions.find(
+      (consumption) => consumption.targetAlias === stmt.from.alias
+    );
+    if (mainJoinItem || mainFunctionConsumption) {
+      lines.push(`  pushdown applied: ${mainBoundQuery}`);
+      lines.push(`  relation: ${mainJoinItem?.relation ?? "exact"}`);
     } else if (!runtimeJoinPlan && mainCandidate !== null) {
       lines.push(`  pushdown candidate: ${whereToKintone(mainCandidate)}\uFF08\u5B9F\u884C\u6642\u306E\u578B\u30FB\u5B9F\u5728\u78BA\u8A8D\u5F85\u3061\uFF09`);
     }
@@ -21920,15 +22473,19 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
       const joinType = join2.type === "INNER" ? "JOIN" : `${join2.type} JOIN`;
       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 joinQ = joinPushDown !== null ? whereToKintone(joinPushDown) : "(\u5168\u4EF6\u53D6\u5F97)";
+      const joinBoundQuery = join2.table.alias ? runtimeJoinPlan?.queriesByAlias.get(join2.table.alias) : void 0;
+      const joinQ = joinBoundQuery || (joinPushDown !== null ? whereToKintone(joinPushDown) : "(\u5168\u4EF6\u53D6\u5F97)");
       lines.push(`  ${joinType}:        APP${join2.table.appId}${joinAliasStr} (${join2.table.appId})`);
       lines.push(`  kintone query: ${joinQ}`);
       const joinPlanItem = runtimeJoinPlan?.joinPlan.items.find(
         (item) => item.targetAlias === join2.table.alias
       );
-      if (joinPlanItem) {
-        lines.push(`  pushdown applied: ${runtimeJoinPlan.queriesByAlias.get(joinPlanItem.targetAlias)}`);
-        lines.push(`  relation: ${joinPlanItem.relation}`);
+      const joinFunctionConsumption = runtimeJoinPlan?.joinPlan.serverFunctionConsumptions.find(
+        (consumption) => consumption.targetAlias === join2.table.alias
+      );
+      if (joinPlanItem || joinFunctionConsumption) {
+        lines.push(`  pushdown applied: ${joinBoundQuery}`);
+        lines.push(`  relation: ${joinPlanItem?.relation ?? "exact"}`);
       } else if (!runtimeJoinPlan && joinCandidate !== null) {
         lines.push(`  pushdown candidate: ${whereToKintone(joinCandidate)}\uFF08\u5B9F\u884C\u6642\u306E\u578B\u30FB\u5B9F\u5728\u78BA\u8A8D\u5F85\u3061\uFF09`);
       }