@rex0220/kintone-sql-tools 3.23.0 → 3.25.0

package/dist-cli/ksql.js

@@ -798,10 +798,26 @@ var RELATIVE_DATE_FUNCTION_NAMES = /* @__PURE__ */ new Set([
   "LAST_YEAR",
   "NEXT_YEAR"
 ]);
+var LEGACY_KINTONE_FUNCTION_NAMES = /* @__PURE__ */ new Set([
+  "TODAY",
+  "NOW",
+  "LOGINUSER"
+]);
+var SERVER_ONLY_WHERE_FUNCTION_NAMES = /* @__PURE__ */ new Set([
+  ...LEGACY_KINTONE_FUNCTION_NAMES,
+  ...RELATIVE_DATE_FUNCTION_NAMES
+]);
 var WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN = "WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN";
+var WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN = "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN";
 function isRelativeDateFunctionName(name) {
   return RELATIVE_DATE_FUNCTION_NAMES.has(name);
 }
+function isLegacyKintoneFunctionName(name) {
+  return LEGACY_KINTONE_FUNCTION_NAMES.has(name);
+}
+function isServerOnlyWhereFunctionName(name) {
+  return SERVER_ONLY_WHERE_FUNCTION_NAMES.has(name);
+}
 
 // src/parser/parser.ts
 var MAX_BATCH_STATEMENTS = 20;
@@ -3034,7 +3050,8 @@ var Parser = class {
   // IN リストの値
   parseInValues() {
     const values = [];
-    const invalidValueMessage = "IN \u30EA\u30B9\u30C8\u306B\u306F\u6587\u5B57\u5217\u3001\u6570\u5024\u3001\u307E\u305F\u306F\u30D0\u30C3\u30C1\u5909\u6570\u304C\u5FC5\u8981\u3067\u3059";
+    const invalidValueMessage = "IN \u30EA\u30B9\u30C8\u306B\u306F\u6587\u5B57\u5217\u3001\u6570\u5024\u3001\u30D0\u30C3\u30C1\u5909\u6570\u3001\u307E\u305F\u306F\u5358\u72EC\u306E LOGINUSER() \u304C\u5FC5\u8981\u3067\u3059";
+    const mixedLoginUserMessage = "LOGINUSER() \u306F IN / NOT IN \u30EA\u30B9\u30C8\u306E\u5358\u72EC\u8981\u7D20\u3068\u3057\u3066\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059";
     do {
       const tok = this.advance();
       if (tok.kind === "STRING" /* STRING */) {
@@ -3051,6 +3068,16 @@ var Parser = class {
         values.push(makeNumberLiteral(`${sign}${number.value}`));
       } else if (tok.kind === "VARIABLE" /* VARIABLE */) {
         values.push({ type: "VARIABLE", name: tok.value.slice(1).toLowerCase() });
+      } else if (tok.kind === "LOGINUSER" /* LOGINUSER */) {
+        if (values.length > 0) {
+          throw new ParseError(mixedLoginUserMessage, tok);
+        }
+        this.expect("(" /* LPAREN */, "LOGINUSER \u306E\u76F4\u5F8C\u306B\u306F\u7A7A\u5F15\u6570\u306E () \u304C\u5FC5\u8981\u3067\u3059");
+        this.expect(")" /* RPAREN */, "LOGINUSER \u306E\u76F4\u5F8C\u306B\u306F\u7A7A\u5F15\u6570\u306E () \u304C\u5FC5\u8981\u3067\u3059");
+        values.push({ type: "KINTONE_FUNC", name: "LOGINUSER" });
+        if (this.peek().kind === "," /* COMMA */) {
+          throw new ParseError(mixedLoginUserMessage, this.peek());
+        }
       } else {
         throw new ParseError(invalidValueMessage, tok);
       }
@@ -5082,9 +5109,11 @@ function convertInList(v, op) {
     throw new KintoneQueryError("IN_LIST \u306F IN / NOT IN \u6F14\u7B97\u5B50\u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059");
   }
   assertResolvedInListValues(v.values);
-  const values = v.values.map(
-    (item) => item.type === "STRING" ? convertString(item) : numberLiteralText(item)
-  ).join(",");
+  const values = v.values.map((item) => {
+    if (item.type === "STRING") return convertString(item);
+    if (item.type === "NUMBER") return numberLiteralText(item);
+    return convertKintoneFunc(item);
+  }).join(",");
   return `(${values})`;
 }
 function assertResolvedInListValues(values) {
@@ -7682,6 +7711,12 @@ function assertResolvedInListValues2(values) {
   if (unresolved?.type === "VARIABLE") {
     throw new Error(`ParseError: unresolved batch variable @${unresolved.name}.`);
   }
+  const serverOnlyFunction = values.find((item) => item.type === "KINTONE_FUNC");
+  if (serverOnlyFunction?.type === "KINTONE_FUNC") {
+    throw new Error(
+      `${serverOnlyFunction.name}: ${WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN}`
+    );
+  }
 }
 function evalNullCheck(expr, row) {
   const val = resolveField(expr.field, row);
@@ -7787,11 +7822,12 @@ function resolveKintoneFuncValue(name) {
       `${name}: ${WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN}`
     );
   }
+  if (isLegacyKintoneFunctionName(name)) {
+    throw new Error(
+      `${name}: ${WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN}`
+    );
+  }
   switch (name) {
-    case "TODAY":
-    case "NOW":
-    case "LOGINUSER":
-      return resolveKintoneFunc(name);
     default:
       throw new Error(`InternalError: unexpected KINTONE_FUNC name: ${name}`);
   }
@@ -12294,6 +12330,16 @@ var RELATIVE_DATE_FIELD_TYPES = /* @__PURE__ */ new Set([
   "UPDATED_TIME"
 ]);
 var RELATIVE_DATE_OPERATORS = new Set(RANGE_AND_EQUALITY);
+var LEGACY_KINTONE_FUNCTION_FIELD_TYPES = /* @__PURE__ */ new Map([
+  ["TODAY", /* @__PURE__ */ new Set(["DATE", "DATETIME", "CREATED_TIME", "UPDATED_TIME"])],
+  ["NOW", /* @__PURE__ */ new Set(["DATETIME", "CREATED_TIME", "UPDATED_TIME"])],
+  ["LOGINUSER", /* @__PURE__ */ new Set(["CREATOR", "MODIFIER", "USER_SELECT"])]
+]);
+var LEGACY_KINTONE_FUNCTION_OPERATORS = /* @__PURE__ */ new Map([
+  ["TODAY", new Set(RANGE_AND_EQUALITY)],
+  ["NOW", new Set(RANGE_AND_EQUALITY)],
+  ["LOGINUSER", /* @__PURE__ */ new Set(["in", "not in"])]
+]);
 var EQUALITY_IN = ["=", "!=", "in", "not in"];
 var NATIVE_OPERATORS = /* @__PURE__ */ new Map([
   ["RECORD_NUMBER", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
@@ -12321,6 +12367,12 @@ var NATIVE_OPERATORS = /* @__PURE__ */ new Map([
   ["GROUP_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
   ["STATUS", new Set(EQUALITY_IN)]
 ]);
+var LOCAL_VALID_OPERATORS = /* @__PURE__ */ new Map([
+  ["CREATOR", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["MODIFIER", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["CHECK_BOX", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["MULTI_SELECT", /* @__PURE__ */ new Set(["in", "not in"])]
+]);
 var LOCAL_SCALAR_TYPES = /* @__PURE__ */ new Set([
   "RECORD_NUMBER",
   "__ID__",
@@ -12383,7 +12435,7 @@ function classifyNode(where, resolveField2) {
       if (!hasRelativeDateReason(inner.reasons)) {
         return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
       }
-      return requireExactRelativeDatePushdown({
+      return requireExactFunctionPushdown({
         capability: "LOCAL_ONLY",
         reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }, ...inner.reasons]
       });
@@ -12399,15 +12451,43 @@ function classifyBinary(op, left, right, resolveField2) {
   if (right.type === "KINTONE_FUNC" && isRelativeDateFunctionName(right.name)) {
     return classifyRelativeDateBinary(op, left, right, resolveField2);
   }
+  if (right.type === "KINTONE_FUNC" && isLegacyKintoneFunction(right)) {
+    return classifyLegacyKintoneFunctionBinary(op, left, right, resolveField2);
+  }
+  if (right.type === "IN_LIST") {
+    const functions = right.values.filter(
+      (value) => value.type === "KINTONE_FUNC"
+    );
+    if (functions.length > 0) {
+      if (right.values.length === 1 && functions.length === 1) {
+        return classifyLegacyKintoneFunctionBinary(op, left, functions[0], resolveField2);
+      }
+      return legacyKintoneFunctionUnsupported(
+        "WHERE_KINTONE_FUNCTION_CONTEXT_UNSUPPORTED",
+        functions[0].name,
+        left.type === "FIELD" ? left.field : void 0,
+        left.type === "FIELD" ? resolveField2(left)?.fieldType : void 0,
+        normalizeOperator(op)
+      );
+    }
+  }
   if (left.type !== "FIELD") return localExpression();
   const semantics = resolveField2(left);
   if (!semantics) {
     return unsupported2("WHERE_FIELD_UNRESOLVED", left.field, void 0, normalizeOperator(op));
   }
+  const nativeOp = normalizeOperator(op);
+  if (!isLocallyValidOperator(semantics.fieldType, nativeOp)) {
+    return unsupported2(
+      "WHERE_OPERATOR_INVALID_FOR_FIELD_TYPE",
+      left.field,
+      semantics.fieldType,
+      nativeOp
+    );
+  }
   if (!hasLocalContract(semantics.fieldType, op)) {
-    return unsupported2("WHERE_OPERATOR_UNSUPPORTED", left.field, semantics.fieldType, normalizeOperator(op));
+    return unsupported2("WHERE_OPERATOR_UNSUPPORTED", left.field, semantics.fieldType, nativeOp);
   }
-  const nativeOp = normalizeOperator(op);
   const native = nativeWhereOperatorsForType(semantics.fieldType);
   const rightCanPush = right.type === "STRING" || right.type === "NUMBER" || right.type === "IN_LIST" || isLegacyKintoneFunction(right);
   const structureAllows = !semantics.requiresCollectionOperators || nativeOp !== "=" && nativeOp !== "!=";
@@ -12434,7 +12514,51 @@ function classifyBinary(op, left, right, resolveField2) {
   };
 }
 function isLegacyKintoneFunction(value) {
-  return value.type === "KINTONE_FUNC" && (value.name === "TODAY" || value.name === "NOW" || value.name === "LOGINUSER");
+  return value.type === "KINTONE_FUNC" && LEGACY_KINTONE_FUNCTION_NAMES.has(value.name);
+}
+function classifyLegacyKintoneFunctionBinary(op, left, right, resolveField2) {
+  const operator = normalizeOperator(op);
+  const functionName = right.name;
+  if (!LEGACY_KINTONE_FUNCTION_NAMES.has(functionName) || left.type !== "FIELD") {
+    return legacyKintoneFunctionUnsupported(
+      "WHERE_KINTONE_FUNCTION_CONTEXT_UNSUPPORTED",
+      functionName,
+      void 0,
+      void 0,
+      operator
+    );
+  }
+  const semantics = resolveField2(left);
+  const validFieldTypes = LEGACY_KINTONE_FUNCTION_FIELD_TYPES.get(functionName);
+  if (!semantics || !validFieldTypes.has(semantics.fieldType) || semantics.inSubtable || semantics.requiresCollectionOperators) {
+    return legacyKintoneFunctionUnsupported(
+      "WHERE_KINTONE_FUNCTION_FIELD_TYPE_UNSUPPORTED",
+      functionName,
+      left.field,
+      semantics?.fieldType,
+      operator
+    );
+  }
+  const validOperators = LEGACY_KINTONE_FUNCTION_OPERATORS.get(functionName);
+  if (!validOperators.has(operator)) {
+    return legacyKintoneFunctionUnsupported(
+      "WHERE_KINTONE_FUNCTION_OPERATOR_UNSUPPORTED",
+      functionName,
+      left.field,
+      semantics.fieldType,
+      operator
+    );
+  }
+  return {
+    capability: "EXACT_PUSHDOWN",
+    reasons: [{
+      code: "WHERE_EXACT",
+      functionName,
+      field: left.field,
+      fieldType: semantics.fieldType,
+      operator
+    }]
+  };
 }
 function classifyRelativeDateBinary(op, left, right, resolveField2) {
   const operator = normalizeOperator(op);
@@ -12522,6 +12646,14 @@ function hasValidRelativeDateArguments(value) {
 function classifyLocalOnlyField(field, operator, resolveField2) {
   const semantics = resolveField2(field);
   if (!semantics) return unsupported2("WHERE_FIELD_UNRESOLVED", field.field, void 0, operator);
+  if (!isLocallyValidOperator(semantics.fieldType, operator)) {
+    return unsupported2(
+      "WHERE_OPERATOR_INVALID_FOR_FIELD_TYPE",
+      field.field,
+      semantics.fieldType,
+      operator
+    );
+  }
   if (!LOCAL_SCALAR_TYPES.has(semantics.fieldType) && !LOCAL_COLLECTION_TYPES.has(semantics.fieldType)) {
     return unsupported2("WHERE_OPERATOR_UNSUPPORTED", field.field, semantics.fieldType, operator);
   }
@@ -12530,6 +12662,10 @@ function classifyLocalOnlyField(field, operator, resolveField2) {
     reasons: [{ code: "WHERE_RESIDUAL", field: field.field, fieldType: semantics.fieldType, operator }]
   };
 }
+function isLocallyValidOperator(fieldType, operator) {
+  const policy = LOCAL_VALID_OPERATORS.get(fieldType);
+  return policy === void 0 || policy.has(operator);
+}
 function hasLocalContract(fieldType, op) {
   if (LOCAL_SCALAR_TYPES.has(fieldType)) return true;
   if (!LOCAL_COLLECTION_TYPES.has(fieldType)) return false;
@@ -12556,18 +12692,18 @@ function normalizeOperator(op) {
 function combineLogical(op, left, right) {
   const reasons = [...left.reasons, ...right.reasons];
   if (left.capability === "UNSUPPORTED" || right.capability === "UNSUPPORTED") {
-    return requireExactRelativeDatePushdown({ capability: "UNSUPPORTED", reasons });
+    return requireExactFunctionPushdown({ capability: "UNSUPPORTED", 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 requireExactRelativeDatePushdown({
+    return requireExactFunctionPushdown({
       capability: "SUPERSET_PREFILTER",
       reasons: [{ code: "WHERE_SUPERSET_PREFILTER" }, ...reasons]
     });
   }
-  return requireExactRelativeDatePushdown({ capability: "LOCAL_ONLY", reasons });
+  return requireExactFunctionPushdown({ capability: "LOCAL_ONLY", reasons });
 }
 function localExpression() {
   return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
@@ -12575,6 +12711,12 @@ function localExpression() {
 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",
@@ -12582,13 +12724,22 @@ function relativeDateUnsupported(code, functionName, field, fieldType, operator)
   });
 }
 function hasRelativeDateReason(reasons) {
-  return reasons.some((reason) => reason.functionName !== void 0);
+  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.functionName !== void 0);
+  const relative = result.reasons.find(
+    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
+  );
   return {
     capability: result.capability,
     reasons: [
@@ -12603,6 +12754,161 @@ function requireExactRelativeDatePushdown(result) {
     ]
   };
 }
+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/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) {
@@ -12615,7 +12921,7 @@ function relativeDateFunctionNamesInNode(node, stopAtNestedSelect) {
     }
     if (valueNode === null || typeof valueNode !== "object") return;
     const value = valueNode;
-    if (value["type"] === "KINTONE_FUNC" && typeof value["name"] === "string" && isRelativeDateFunctionName(value["name"]) && !seen.has(value["name"])) {
+    if (value["type"] === "KINTONE_FUNC" && typeof value["name"] === "string" && isServerOnlyWhereFunctionName(value["name"]) && !seen.has(value["name"])) {
       seen.add(value["name"]);
       names.push(value["name"]);
       return;
@@ -12649,7 +12955,7 @@ function nestedSelects(node, root) {
   visit(node);
   return found;
 }
-function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = true) {
+function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = true, allowFullScanExact = true, forceNestedForbidden = forceForbidden) {
   const functionNames = relativeDateFunctionNamesInWhere(select.where);
   if (functionNames.length > 0) {
     candidates.push({
@@ -12658,7 +12964,9 @@ function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = t
       where: select.where,
       functionNames,
       path,
-      allowPhase2Prefilter: allowPhase2
+      allowPhase2Prefilter: allowPhase2,
+      allowFullScanExact,
+      relativeFunctionOccurrences: serverOnlyFunctionOccurrencesInWhere(select.where)
     });
   }
   nestedSelects(select, select).forEach(
@@ -12666,32 +12974,53 @@ function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = t
       nested,
       `${path}.select-source[${index}]`,
       candidates,
-      forceForbidden,
-      allowPhase2
+      forceNestedForbidden,
+      forceNestedForbidden ? false : allowPhase2,
+      forceNestedForbidden ? false : allowFullScanExact,
+      forceNestedForbidden
     )
   );
 }
-function collectUnion(union, path, candidates, forceForbidden) {
-  if (union.left.type === "UNION") collectUnion(union.left, `${path}.left`, candidates, forceForbidden);
-  else collectSelect(union.left, `${path}.left`, candidates, forceForbidden);
-  collectSelect(union.right, `${path}.right`, candidates, forceForbidden);
+function collectUnion(union, path, candidates, forceForbidden, allowFullScanExact = true) {
+  if (union.left.type === "UNION") {
+    collectUnion(union.left, `${path}.left`, candidates, forceForbidden, allowFullScanExact);
+  } else {
+    collectSelect(union.left, `${path}.left`, candidates, forceForbidden, true, allowFullScanExact);
+  }
+  collectSelect(union.right, `${path}.right`, candidates, forceForbidden, true, allowFullScanExact);
 }
 function collectWith(statement, path, candidates, inheritedForbidden) {
   if (!inheritedForbidden && canInlineSingleCte(statement)) {
-    collectSelect(buildInlinedQuery(statement), `${path}.inlined`, candidates, false);
+    collectSelect(buildInlinedQuery(statement), `${path}.inlined`, candidates, false, true, true);
     return;
   }
   statement.ctes.forEach((cte, index) => {
     if (cte.query.type === "SELECT") {
-      collectSelect(cte.query, `${path}.cte[${index}]`, candidates, true);
+      collectSelect(
+        cte.query,
+        `${path}.cte[${index}]`,
+        candidates,
+        inheritedForbidden,
+        false,
+        !inheritedForbidden,
+        true
+      );
     } else if (cte.query.type === "UNION") {
-      collectUnion(cte.query, `${path}.cte[${index}]`, candidates, true);
+      collectUnion(cte.query, `${path}.cte[${index}]`, candidates, true, false);
     }
   });
   if (statement.query.type === "SELECT") {
-    collectSelect(statement.query, `${path}.main`, candidates, true);
+    collectSelect(
+      statement.query,
+      `${path}.main`,
+      candidates,
+      inheritedForbidden,
+      false,
+      !inheritedForbidden,
+      true
+    );
   } else {
-    collectUnion(statement.query, `${path}.main`, candidates, true);
+    collectUnion(statement.query, `${path}.main`, candidates, true, false);
   }
 }
 function collectStatement(statement, path, candidates, forceForbidden = false) {
@@ -12706,9 +13035,9 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
       collectWith(statement, path, candidates, forceForbidden);
       return;
     case "CREATE_TEMP_TABLE":
-      if (statement.query.type === "WITH") collectWith(statement.query, `${path}.query`, candidates, true);
-      else if (statement.query.type === "UNION") collectUnion(statement.query, `${path}.query`, candidates, true);
-      else collectSelect(statement.query, `${path}.query`, candidates, true);
+      if (statement.query.type === "WITH") collectWith(statement.query, `${path}.query`, candidates, false);
+      else if (statement.query.type === "UNION") collectUnion(statement.query, `${path}.query`, candidates, true, false);
+      else collectSelect(statement.query, `${path}.query`, candidates, false, false, true, true);
       return;
     case "EXPLAIN":
       collectStatement(statement.query, `${path}.query`, candidates, forceForbidden);
@@ -12722,11 +13051,13 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
           source: statement,
           where: statement.where,
           functionNames,
-          path
+          path,
+          allowFullScanExact: false,
+          relativeFunctionOccurrences: serverOnlyFunctionOccurrencesInWhere(statement.where)
         });
       }
       nestedSelects(statement, statement).forEach(
-        (select, index) => collectSelect(select, `${path}.select-source[${index}]`, candidates, true)
+        (select, index) => collectSelect(select, `${path}.select-source[${index}]`, candidates, true, true, false)
       );
       return;
     }
@@ -12740,7 +13071,9 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
           source: statement,
           where: statement.where,
           functionNames,
-          path
+          path,
+          allowFullScanExact: false,
+          relativeFunctionOccurrences: serverOnlyFunctionOccurrencesInWhere(statement.where)
         });
       }
       if (statement.type === "UPDATE" && statement.applyBlocks?.length) {
@@ -12751,7 +13084,9 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
             source: statement,
             where: null,
             functionNames: applyFunctions,
-            path: `${path}.apply`
+            path: `${path}.apply`,
+            allowFullScanExact: false,
+            relativeFunctionOccurrences: []
           });
         }
       }
@@ -12761,6 +13096,7 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
           `${path}.select-source[${index}]`,
           candidates,
           forceForbidden,
+          false,
           false
         )
       );
@@ -12773,13 +13109,23 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
           `${path}.select-source[${index}]`,
           candidates,
           forceForbidden,
+          false,
           false
         )
       );
   }
 }
 function serializationContainsFunctions(query, names) {
-  return names.every((name) => new RegExp(`\\b${name}\\s*\\(`).test(query));
+  const expected = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    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;
 }
 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;
@@ -12794,23 +13140,36 @@ function rejectedNode(candidate) {
     allowed: false
   };
 }
-function relativeDateReasonCodes(capability) {
+function serverFunctionReasonCodes(functionName, capability) {
   const codes = (capability?.reasons ?? []).filter(
-    (reason) => reason.functionName !== void 0
-  ).map((reason) => reason.code).filter((code) => code.startsWith("WHERE_RELATIVE_DATE_"));
-  if (!codes.includes(WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN)) {
+    (reason) => reason.functionName === functionName
+  ).map((reason) => reason.code).filter(
+    (code) => code.startsWith("WHERE_RELATIVE_DATE_") || code.startsWith("WHERE_KINTONE_FUNCTION_")
+  );
+  if (isLegacyKintoneFunctionName(functionName)) {
+    if (!codes.some(
+      (code) => code !== WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN
+    )) {
+      codes.unshift("WHERE_KINTONE_FUNCTION_CONTEXT_UNSUPPORTED");
+    }
+    if (!codes.includes(WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN)) {
+      codes.push(WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN);
+    }
+  } else if (!codes.includes(WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN)) {
     codes.push(WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN);
   }
   return [...new Set(codes)];
 }
 function rejectionFor(candidate, capability) {
-  const reasonCodes = relativeDateReasonCodes(capability);
+  const functionName = candidate.functionNames[0];
+  const requiresExact = isLegacyKintoneFunctionName(functionName) ? WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN : WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN;
+  const reasonCodes = serverFunctionReasonCodes(functionName, capability);
   return {
-    functionName: candidate.functionNames[0],
+    functionName,
     path: candidate.path,
     code: reasonCodes.find(
-      (code) => code !== WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN
-    ) ?? WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN,
+      (code) => code !== requiresExact
+    ) ?? requiresExact,
     reasonCodes
   };
 }
@@ -12823,7 +13182,8 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
       const node2 = rejectedNode(candidate);
       nodes.push(node2);
       return {
-        hasRelativeDate: true,
+        hasRelativeDate: candidate.functionNames.some(isRelativeDateFunctionName),
+        hasServerOnlyWhereFunction: true,
         nodes,
         allowed: false,
         rejection: rejectionFor(candidate)
@@ -12840,7 +13200,10 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
       } catch {
         restQuery2 = "";
       }
-      let 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.relativeFunctionOccurrences
+      );
       let prefilterPlan;
       let phase2PrefilterEligible;
       if (!allowed2 && candidate.allowPhase2Prefilter !== false && capability2.capability === "SUPERSET_PREFILTER" && resolver.prefilterDecomposition) {
@@ -12851,6 +13214,21 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
           allowed2 = true;
         }
       }
+      let fullScanExactPlan;
+      if (!allowed2 && capability2.capability === "EXACT_PUSHDOWN") {
+        fullScanExactPlan = buildRelativeDateFullScanExactPlan({
+          select,
+          selectMode,
+          capability: capability2,
+          context: { allowFullScanExact: candidate.allowFullScanExact },
+          serializedWholeWhere: restQuery2 || null,
+          relativeFunctionNames: candidate.relativeFunctionOccurrences
+        }) ?? void 0;
+        if (fullScanExactPlan) {
+          prefilterPlan = fullScanExactPlan.prefilterPlan;
+          allowed2 = true;
+        }
+      }
       const node2 = {
         kind: candidate.kind,
         source: candidate.source,
@@ -12860,13 +13238,17 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
         capability: capability2,
         restQuery: restQuery2,
         ...prefilterPlan ? { prefilterPlan, phase2PrefilterEligible } : {},
+        ...fullScanExactPlan ? { fullScanExactPlan, allowForm: fullScanExactPlan.allowForm } : {},
         clientWhereEvaluation: !allowed2,
         allowed: allowed2
       };
       nodes.push(node2);
       if (!allowed2) {
         return {
-          hasRelativeDate: true,
+          hasRelativeDate: candidates.some(
+            (entry) => entry.functionNames.some(isRelativeDateFunctionName)
+          ),
+          hasServerOnlyWhereFunction: true,
           nodes,
           allowed: false,
           rejection: rejectionFor(candidate, capability2)
@@ -12882,7 +13264,10 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
     } catch {
       restQuery = "";
     }
-    const allowed = capability.capability === "EXACT_PUSHDOWN" && serializationContainsFunctions(restQuery, candidate.functionNames);
+    const allowed = capability.capability === "EXACT_PUSHDOWN" && serializationContainsFunctions(
+      restQuery,
+      candidate.relativeFunctionOccurrences
+    );
     const node = {
       kind: candidate.kind,
       source: candidate.source,
@@ -12896,7 +13281,10 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
     nodes.push(node);
     if (!allowed) {
       return {
-        hasRelativeDate: true,
+        hasRelativeDate: candidates.some(
+          (entry) => entry.functionNames.some(isRelativeDateFunctionName)
+        ),
+        hasServerOnlyWhereFunction: true,
         nodes,
         allowed: false,
         rejection: rejectionFor(candidate, capability)
@@ -12904,18 +13292,22 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
     }
   }
   return {
-    hasRelativeDate: candidates.length > 0,
+    hasRelativeDate: candidates.some(
+      (entry) => entry.functionNames.some(isRelativeDateFunctionName)
+    ),
+    hasServerOnlyWhereFunction: candidates.length > 0,
     nodes,
     allowed: true
   };
 }
 function assertRelativeDatePushdownPlan(plan) {
   if (!plan.allowed && plan.rejection) {
+    const requiresExact = isLegacyKintoneFunctionName(plan.rejection.functionName) ? WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN : WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN;
     const details = plan.rejection.reasonCodes.filter(
-      (code) => code !== WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN
+      (code) => code !== requiresExact
     );
     throw new Error(
-      `${plan.rejection.functionName}: ${WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN}${details.length > 0 ? ` (reason=${details.join(", ")})` : ""} (path=${plan.rejection.path})`
+      `${plan.rejection.functionName}: ${requiresExact}${details.length > 0 ? ` (reason=${details.join(", ")})` : ""} (path=${plan.rejection.path})`
     );
   }
 }
@@ -12936,9 +13328,9 @@ function decomposeRelativeDatePrefilter(stmt, resolveField2, testSeam = {}) {
   if (stmt.from.cteName !== null || stmt.from.appId <= 0) {
     return reject(["NOT_DIRECT_PHYSICAL_APP"]);
   }
-  const occurrences = collectRelativeOccurrences(stmt.where);
+  const occurrences = collectServerFunctionOccurrences(stmt.where);
   if (occurrences.length === 0) return reject(["NO_RELATIVE_DATE"]);
-  const spine = collectRelativeLeavesOnAndSpine(stmt.where, resolveField2);
+  const spine = collectServerFunctionLeavesOnAndSpine(stmt.where, resolveField2);
   if (!spine.ok) return reject(spine.reasonCodes);
   if (!sameRelativeMultiset(occurrences, spine.leaves)) {
     return reject(["RELATIVE_DATE_LEAF_COUNT_MISMATCH"]);
@@ -12961,7 +13353,7 @@ function decomposeRelativeDatePrefilter(stmt, resolveField2, testSeam = {}) {
   const containsFunctions = testSeam.containsFunctions ?? serializationContainsFunctions;
   const confirmedLeaves = [];
   for (const leaf of spine.leaves) {
-    const name = relativeNameOf(leaf);
+    const name = serverFunctionNameOf(leaf);
     if (name === null) return reject(["RELATIVE_DATE_LEAF_COUNT_MISMATCH"]);
     let query;
     try {
@@ -12990,12 +13382,12 @@ function decomposeRelativeDatePrefilter(stmt, resolveField2, testSeam = {}) {
   } catch {
     return reject(["PREFILTER_SERIALIZATION_FAILED"]);
   }
-  const expectedNames = confirmedLeaves.map((leaf) => relativeNameOf(leaf));
-  if (!containsFunctions(prefilterQuery, [...new Set(expectedNames)]) || !serializedMultisetContains(prefilterQuery, expectedNames)) {
+  const expectedNames = confirmedLeaves.map((leaf) => serverFunctionNameOf(leaf));
+  if (!containsFunctions(prefilterQuery, [...new Set(expectedNames)]) || !serializedMultisetContains2(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) {
+  if (residualWhere !== null && collectServerFunctionOccurrences(residualWhere).length > 0) {
     return reject(["RESIDUAL_RELATIVE_DATE_REMAINED"]);
   }
   if (residualWhere === null) {
@@ -13016,7 +13408,7 @@ function decomposeRelativeDatePrefilter(stmt, resolveField2, testSeam = {}) {
     }
   };
 }
-function collectRelativeLeavesOnAndSpine(where, resolveField2) {
+function collectServerFunctionLeavesOnAndSpine(where, resolveField2) {
   const leaves = [];
   let failure = null;
   const visit = (node) => {
@@ -13031,24 +13423,19 @@ function collectRelativeLeavesOnAndSpine(where, resolveField2) {
           visit(node.right);
           return;
         }
-        if (collectRelativeOccurrences(node).length > 0) {
+        if (collectServerFunctionOccurrences(node).length > 0) {
           failure = "RELATIVE_DATE_CONTEXT_UNSUPPORTED";
         }
         return;
       case "NOT":
-        if (collectRelativeOccurrences(node).length > 0) {
+        if (collectServerFunctionOccurrences(node).length > 0) {
           failure = "RELATIVE_DATE_CONTEXT_UNSUPPORTED";
         }
         return;
       case "BINARY": {
-        const name = relativeNameOf(node);
+        const name = serverFunctionNameOf(node);
         if (name === null) return;
-        const result = classifyRelativeDateBinary(
-          node.op,
-          node.left,
-          node.right,
-          resolveField2
-        );
+        const result = classifyWhereCapability(node, resolveField2);
         if (result.capability !== "EXACT_PUSHDOWN") {
           failure = "RELATIVE_DATE_LEAF_NOT_EXACT";
           return;
@@ -13057,7 +13444,7 @@ function collectRelativeLeavesOnAndSpine(where, resolveField2) {
         return;
       }
       case "EXISTS":
-        if (collectRelativeOccurrences(node).length > 0) {
+        if (collectServerFunctionOccurrences(node).length > 0) {
           failure = "RELATIVE_DATE_CONTEXT_UNSUPPORTED";
         }
         return;
@@ -13069,13 +13456,19 @@ function collectRelativeLeavesOnAndSpine(where, resolveField2) {
   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 serverFunctionNameOf(leaf) {
+  if (leaf.right.type === "KINTONE_FUNC" && isServerOnlyWhereFunctionName(leaf.right.name)) {
+    return leaf.right.name;
+  }
+  if (leaf.right.type === "IN_LIST" && leaf.right.values.length === 1 && leaf.right.values[0].type === "KINTONE_FUNC" && isServerOnlyWhereFunctionName(leaf.right.values[0].name)) {
+    return leaf.right.values[0].name;
+  }
+  return null;
 }
-function collectRelativeOccurrences(where) {
+function collectServerFunctionOccurrences(where) {
   const found = [];
   const visitWhere = (node) => {
-    if (node.type === "BINARY" && relativeNameOf(node) !== null) {
+    if (node.type === "BINARY" && serverFunctionNameOf(node) !== null) {
       found.push(node);
       return;
     }
@@ -13213,10 +13606,10 @@ function collectFieldMetadata(where, resolveField2) {
   }
   return { fieldTypes, fieldOptions };
 }
-function serializedMultisetContains(query, expectedNames) {
+function serializedMultisetContains2(query, expectedNames) {
   const expected = /* @__PURE__ */ new Map();
   for (const name of expectedNames) {
-    if (!RELATIVE_DATE_FUNCTION_NAMES.has(name)) return false;
+    if (!SERVER_ONLY_WHERE_FUNCTION_NAMES.has(name)) return false;
     expected.set(name, (expected.get(name) ?? 0) + 1);
   }
   for (const [name, count] of expected) {
@@ -15370,7 +15763,7 @@ async function resolveSelectWhereCapability(stmt, client, cacheContext, material
 }
 function formatWhereCapabilityFailure(result) {
   const reason = result.reasons.find(
-    (candidate) => candidate.code === "WHERE_FIELD_UNRESOLVED" || candidate.code === "WHERE_OPERATOR_UNSUPPORTED"
+    (candidate) => candidate.code === "WHERE_FIELD_UNRESOLVED" || candidate.code === "WHERE_OPERATOR_UNSUPPORTED" || candidate.code === "WHERE_OPERATOR_INVALID_FOR_FIELD_TYPE"
   ) ?? result.reasons[0];
   const details = [
     reason?.field ? `field=${reason.field}` : null,
@@ -15436,7 +15829,9 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
   if (whereCapability.capability === "UNSUPPORTED") {
     throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(whereCapability)}).`);
   }
+  const staticMode = resolveSelectMode(stmt);
   let prefilterPlan;
+  let fullScanExactPlan;
   if (whereCapability.capability === "SUPERSET_PREFILTER") {
     const resolver = await buildWhereFieldSemanticsResolver(stmt, client, cacheContext, cteCache);
     const decomposition = decomposeRelativeDatePrefilter(stmt, resolver);
@@ -15444,7 +15839,23 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
       prefilterPlan = decomposition.plan;
     }
   }
-  const staticMode = resolveSelectMode(stmt);
+  if (prefilterPlan === void 0 && whereCapability.capability === "EXACT_PUSHDOWN" && stmt.where !== null) {
+    let serializedWholeWhere = null;
+    try {
+      serializedWholeWhere = whereToKintone(stmt.where);
+    } catch {
+      serializedWholeWhere = null;
+    }
+    fullScanExactPlan = buildRelativeDateFullScanExactPlan({
+      select: stmt,
+      selectMode: staticMode,
+      capability: whereCapability,
+      context: { allowFullScanExact: true },
+      serializedWholeWhere,
+      relativeFunctionNames: serverOnlyFunctionOccurrencesInWhere(stmt.where)
+    }) ?? void 0;
+    if (fullScanExactPlan) prefilterPlan = fullScanExactPlan.prefilterPlan;
+  }
   const mode = whereCapability.capability === "EXACT_PUSHDOWN" ? staticMode : "FULL_SCAN";
   const orderMeta = await buildOrderByMetaForSelect(stmt, client, cacheContext, cteCache);
   const orderPlan = hasCanonicalOrder(stmt) ? (stmt.orderMode === "KINTONE_NATIVE" ? planKorder : planCanonicalOrder)({
@@ -15462,18 +15873,31 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     client,
     cacheContext
   );
-  const completePolicy = buildCompleteInputPolicy(stmt, options, orderPlan);
+  const completePolicy = buildCompleteInputPolicy(
+    stmt,
+    options,
+    orderPlan
+  );
+  const failClosedForB72Local = fullScanExactPlan !== void 0 && (staticMode === "FULL_SCAN" || orderPlan?.kind === "CANONICAL_LOCAL");
+  const executionClient = failClosedForB72Local ? wrapClientWithSearchAbort(client, { aborted: false }, true) : client;
   try {
     if (mode === "SIMPLE") {
-      result = await executeSimpleSelect(stmt, client, completePolicy.effectiveOptions, cacheContext, orderPlan, orderMeta);
+      result = await executeSimpleSelect(
+        stmt,
+        executionClient,
+        completePolicy.effectiveOptions,
+        cacheContext,
+        orderPlan,
+        orderMeta
+      );
     } else {
       result = await executeFullScanSelect(
         stmt,
-        client,
+        executionClient,
         completePolicy.effectiveOptions,
         cacheContext,
         cteCache,
-        whereCapability.capability === "EXACT_PUSHDOWN",
+        whereCapability.capability === "EXACT_PUSHDOWN" && prefilterPlan === void 0,
         orderMeta,
         prefilterPlan,
         plainGroupByPlan
@@ -20510,7 +20934,7 @@ function renderResidualValue(node) {
     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>";
+      return typeof value["name"] === "string" ? value["name"] === "LOGINUSER" ? "LOGINUSER()" : `${value["name"]}(...)` : "<expr>";
     case "IN_LIST":
       return Array.isArray(value["values"]) ? `(${value["values"].map(renderResidualValue).join(", ")})` : "<expr>";
     case "ARRAY":
@@ -20546,10 +20970,11 @@ function renderRelativeDateResidualWhere(where) {
   }
 }
 function relativeDateExplainLines(plan) {
-  if (!plan.hasRelativeDate) return [];
+  if (!plan.hasServerOnlyWhereFunction) return [];
   if (!plan.allowed && plan.rejection) {
+    const label = isRelativeDateFunctionName(plan.rejection.functionName) ? "relative date function" : "kintone function";
     return [
-      `  relative date function: ${plan.rejection.functionName}`,
+      `  ${label}: ${plan.rejection.functionName}`,
       "  plan status: rejected",
       `  reason: ${plan.rejection.reasonCodes.join(", ")}`,
       "  client evaluation: forbidden",
@@ -20558,18 +20983,46 @@ function relativeDateExplainLines(plan) {
   }
   const lines = [];
   for (const node of plan.nodes) {
+    const fullScanExactPlan = node.fullScanExactPlan;
+    if (node.allowed && node.allowForm === "FULL_SCAN_EXACT" && fullScanExactPlan) {
+      for (const leaf of fullScanExactPlan.prefilterPlan.exactRelativeLeaves) {
+        const functionName = serverFunctionNameOfExplainLeaf(leaf);
+        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(
+          `  ${serverFunctionLabel(functionName)}: ${functionName}`,
+          `  ${serverFunctionEvaluationLabel(functionName)}: kintone server whole-WHERE exact`,
+          `  field: ${detail?.field ?? field ?? "(unknown)"} (${detail?.fieldType ?? "unknown"})`,
+          `  operator: ${detail?.operator ?? operator}`
+        );
+      }
+      const wholeWhereQuery = fullScanExactPlan.serializedWholeWhere;
+      lines.push(
+        "  where capability: EXACT_PUSHDOWN",
+        `  server predicate: ${wholeWhereQuery}`,
+        "  client residual: (none)",
+        `  ${serverFunctionClientEvaluationLabel(
+          fullScanExactPlan.prefilterPlan.exactRelativeLeaves
+        )}: 0`,
+        `  kintone query: ${wholeWhereQuery}`
+      );
+      continue;
+    }
     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 functionName = serverFunctionNameOfExplainLeaf(leaf);
         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",
+          `  ${serverFunctionLabel(functionName)}: ${functionName}`,
+          `  ${serverFunctionEvaluationLabel(functionName)}: kintone server exact prefilter`,
           `  field: ${detail?.field ?? field ?? "(unknown)"} (${detail?.fieldType ?? "unknown"})`,
           `  operator: ${detail?.operator ?? operator}`
         );
@@ -20579,7 +21032,7 @@ function relativeDateExplainLines(plan) {
         "  where capability: SUPERSET_PREFILTER",
         `  server prefilter: ${serverPrefilter}`,
         `  client residual: ${renderRelativeDateResidualWhere(prefilterPlan.residualWhere)}`,
-        "  relative date client evaluations: 0",
+        `  ${serverFunctionClientEvaluationLabel(prefilterPlan.exactRelativeLeaves)}: 0`,
         `  kintone query: ${serverPrefilter}`
       );
       continue;
@@ -20588,6 +21041,19 @@ function relativeDateExplainLines(plan) {
       const detail = node.capability?.reasons.find(
         (reason) => reason.functionName === functionName
       );
+      if (!isRelativeDateFunctionName(functionName)) {
+        lines.push(
+          `  kintone function: ${functionName}`,
+          "  kintone function evaluation: kintone server",
+          `  field: ${detail?.field ?? "(unknown)"} (${detail?.fieldType ?? "unknown"})`,
+          `  operator: ${detail?.operator ?? "(unknown)"}`,
+          `  where capability: ${node.capability?.capability ?? "(unknown)"}`,
+          "  client residual: (none)",
+          "  kintone function client evaluations: 0",
+          `  kintone query: ${node.restQuery || "(\u306A\u3057)"}`
+        );
+        continue;
+      }
       lines.push(
         `  relative date function: ${functionName}`,
         "  evaluation: kintone server",
@@ -20601,6 +21067,24 @@ function relativeDateExplainLines(plan) {
   }
   return lines;
 }
+function serverFunctionLabel(functionName) {
+  return isRelativeDateFunctionName(functionName) ? "relative date function" : "kintone function";
+}
+function serverFunctionNameOfExplainLeaf(leaf) {
+  if (leaf.right.type === "KINTONE_FUNC") return leaf.right.name;
+  if (leaf.right.type === "IN_LIST" && leaf.right.values.length === 1 && leaf.right.values[0].type === "KINTONE_FUNC") {
+    return leaf.right.values[0].name;
+  }
+  return "(unknown)";
+}
+function serverFunctionEvaluationLabel(functionName) {
+  return isRelativeDateFunctionName(functionName) ? "relative date evaluation" : "kintone function evaluation";
+}
+function serverFunctionClientEvaluationLabel(leaves) {
+  return leaves.every(
+    (leaf) => leaf.right.type === "KINTONE_FUNC" && isRelativeDateFunctionName(leaf.right.name)
+  ) ? "relative date client evaluations" : "kintone function client evaluations";
+}
 async function buildBatchExplainPlans(sql, client, injectedVariables, cacheContext = "batch-explain", maxRecords = 1e4, cursorMaxActive = 2, enableImport = false, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS) {
   const statements = parseSqlBatch(sql, enableImport);
   const analysis = analyzeBatch(statements);
@@ -20619,7 +21103,7 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
       maxRecords,
       relativeDatePlan
     );
-    const statementPlan = relativeDatePlan.hasRelativeDate && !relativeDatePlan.allowed ? relativeDateExplainLines(relativeDatePlan) : [
+    const statementPlan = relativeDatePlan.hasServerOnlyWhereFunction && !relativeDatePlan.allowed ? relativeDateExplainLines(relativeDatePlan) : [
       ...relativeDateExplainLines(relativeDatePlan),
       ...addCursorConcurrency(buildBatchStatementPlan(
         planStmt,
@@ -20748,7 +21232,7 @@ async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxA
     sharedPlan
   );
   const relativeLines = relativeDateExplainLines(sharedPlan);
-  const lines = sharedPlan.hasRelativeDate && !sharedPlan.allowed ? [...explainMetadataLines(analysis), ...relativeLines] : [
+  const lines = sharedPlan.hasServerOnlyWhereFunction && !sharedPlan.allowed ? [...explainMetadataLines(analysis), ...relativeLines] : [
     ...explainMetadataLines(analysis),
     ...relativeLines,
     ...addCursorConcurrency(