@rex0220/kintone-sql-tools 3.19.0 → 3.21.0

package/dist-cli/ksql.js

@@ -783,6 +783,26 @@ function aggregateOperandLabel(node) {
   return `${aggregateOperandLabel(node.left)}${node.op}${aggregateOperandLabel(node.right)}`;
 }
 
+// src/core/relativeDateFunction.ts
+var RELATIVE_DATE_FUNCTION_NAMES = /* @__PURE__ */ new Set([
+  "YESTERDAY",
+  "TOMORROW",
+  "FROM_TODAY",
+  "THIS_WEEK",
+  "LAST_WEEK",
+  "NEXT_WEEK",
+  "THIS_MONTH",
+  "LAST_MONTH",
+  "NEXT_MONTH",
+  "THIS_YEAR",
+  "LAST_YEAR",
+  "NEXT_YEAR"
+]);
+var WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN = "WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN";
+function isRelativeDateFunctionName(name) {
+  return RELATIVE_DATE_FUNCTION_NAMES.has(name);
+}
+
 // src/parser/parser.ts
 var MAX_BATCH_STATEMENTS = 20;
 var PARSER_SCALAR_FUNCTION_TOKEN_MAP = Object.freeze({
@@ -883,12 +903,35 @@ var PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP = Object.freeze({
 function isContextualFunctionToken(kind) {
   return PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP[kind] !== void 0;
 }
+var PARSER_IDENT_RELATIVE_DATE_FUNCTIONS = Object.freeze(
+  [...RELATIVE_DATE_FUNCTION_NAMES]
+);
+var RELATIVE_DATE_PERIOD_UNITS = /* @__PURE__ */ new Set(["DAYS", "WEEKS", "MONTHS", "YEARS"]);
+var RELATIVE_DATE_WEEKDAYS = /* @__PURE__ */ new Set([
+  "SUNDAY",
+  "MONDAY",
+  "TUESDAY",
+  "WEDNESDAY",
+  "THURSDAY",
+  "FRIDAY",
+  "SATURDAY"
+]);
+function isRelativeDatePeriodUnit(value) {
+  return RELATIVE_DATE_PERIOD_UNITS.has(value);
+}
+function isRelativeDateWeekday(value) {
+  return RELATIVE_DATE_WEEKDAYS.has(value);
+}
+function isRelativeDateMonthDay(value) {
+  return Number.isInteger(value) && value >= 1 && value <= 31;
+}
 var PARSER_FUNCTION_SPELLINGS = Object.freeze(Array.from(/* @__PURE__ */ new Set([
   ...Object.keys(PARSER_SCALAR_FUNCTION_TOKEN_MAP),
   ...PARSER_IDENT_SCALAR_FUNCTIONS,
   ...Object.keys(PARSER_AGGREGATE_FUNCTION_TOKEN_MAP),
   ...Object.keys(PARSER_WINDOW_FUNCTION_TOKEN_MAP),
   ...Object.keys(PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP),
+  ...PARSER_IDENT_RELATIVE_DATE_FUNCTIONS,
   "IF"
 ])));
 var FUNC_CALL_PREFIX_KINDS = /* @__PURE__ */ new Set([
@@ -989,6 +1032,8 @@ var Parser = class {
     this.insideAggregateArg = 0;
     /** GROUPING(field) is limited to the explicitly selected query context. */
     this.groupingFieldContext = "FORBIDDEN";
+    /** True only while parsing an actual SQL WHERE clause (including nested groups). */
+    this.allowRelativeDateFunctions = false;
     /** WITH 句で定義された CTE 名のセット（parseTableRef で参照） */
     this.cteNames = /* @__PURE__ */ new Set();
     /** パース中に出現した一時テーブル参照（#name）のトークン。単文 API での拒否に使う */
@@ -1500,7 +1545,7 @@ var Parser = class {
       this.advance();
       summary = true;
     }
-    const where = this.consume("WHERE" /* WHERE */) ? this.parseWhereExpr() : null;
+    const where = this.consume("WHERE" /* WHERE */) ? this.parseWhereExpr(void 0, true) : null;
     const checks = this.parseCheckGroups();
     let errorTable;
     if (this.consume("INTO" /* INTO */)) {
@@ -1719,7 +1764,7 @@ var Parser = class {
     const hasFrom = this.consume("FROM" /* FROM */);
     const from = hasFrom ? this.parseTableRef() : { appId: 0, alias: null, cteName: NO_FROM_CTE_NAME };
     const joins = hasFrom ? this.parseJoins() : [];
-    const where = this.consume("WHERE" /* WHERE */) ? this.parseWhereExpr() : null;
+    const where = this.consume("WHERE" /* WHERE */) ? this.parseWhereExpr(void 0, true) : null;
     let groupBy = [];
     let grouping;
     let having = null;
@@ -2586,13 +2631,16 @@ var Parser = class {
   // ----------------------------------------------------------
   // WHERE 式（再帰下降・優先順位付き）
   // ----------------------------------------------------------
-  parseWhereExpr(groupingFieldContext = this.groupingFieldContext) {
+  parseWhereExpr(groupingFieldContext = this.groupingFieldContext, allowRelativeDateFunctions = this.allowRelativeDateFunctions) {
     const previousContext = this.groupingFieldContext;
-    this.groupingFieldContext = groupingFieldContext;
+    const previousAllowRelativeDateFunctions = this.allowRelativeDateFunctions;
+    this.groupingFieldContext = groupingFieldContext ?? previousContext;
+    this.allowRelativeDateFunctions = allowRelativeDateFunctions;
     try {
       return this.parseOrExpr();
     } finally {
       this.groupingFieldContext = previousContext;
+      this.allowRelativeDateFunctions = previousAllowRelativeDateFunctions;
     }
   }
   // OR（最低優先度）
@@ -2671,9 +2719,9 @@ var Parser = class {
       return { type: "NULL_CHECK", field, not };
     }
     if (this.consume("BETWEEN" /* BETWEEN */)) {
-      const low = this.parseSqlValue();
+      const low = this.parseWhereSqlValue();
       this.expect("AND" /* AND */);
-      const high = this.parseSqlValue();
+      const high = this.parseWhereSqlValue();
       return {
         type: "LOGICAL",
         op: "AND",
@@ -2708,7 +2756,7 @@ var Parser = class {
       return { type: "BINARY", op: "KLIKE", left: field, right: pattern };
     }
     const op = this.parseCompareOp();
-    const right = this.parseSqlValue();
+    const right = this.parseWhereSqlValue();
     return { type: "BINARY", op, left: field, right };
   }
   parseCompareOp() {
@@ -2813,6 +2861,105 @@ var Parser = class {
     return { type: "FIELD", tableAlias: qi.tableAlias, field: qi.field };
   }
   // 右辺の値
+  parseWhereSqlValue() {
+    const tok = this.peek();
+    if (this.allowRelativeDateFunctions && tok.kind === "IDENT" /* IDENT */ && this.peekAt(1).kind === "(" /* LPAREN */ && isRelativeDateFunctionName(tok.value.toUpperCase())) {
+      return this.parseRelativeDateFunction();
+    }
+    return this.parseSqlValue();
+  }
+  parseRelativeDateFunction() {
+    const nameToken = this.expect("IDENT" /* IDENT */);
+    const name = nameToken.value.toUpperCase();
+    this.expect("(" /* LPAREN */);
+    switch (name) {
+      case "YESTERDAY":
+      case "TOMORROW":
+      case "THIS_YEAR":
+      case "LAST_YEAR":
+      case "NEXT_YEAR":
+        this.expect(")" /* RPAREN */, `${name}() \u306F\u5F15\u6570\u3092\u53D7\u3051\u53D6\u308A\u307E\u305B\u3093`);
+        return { type: "KINTONE_FUNC", name, args: { kind: "NONE" } };
+      case "FROM_TODAY": {
+        let sign = "";
+        if (this.consume("-" /* MINUS */)) sign = "-";
+        if (this.peek().kind === "+" /* PLUS */) {
+          throw new ParseError("FROM_TODAY \u306E offset \u306B + \u7B26\u53F7\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", this.peek());
+        }
+        const offsetToken = this.expect(
+          "NUMBER" /* NUMBER */,
+          "FROM_TODAY \u306B\u306F\u6574\u6570 offset \u3068\u5358\u4F4D\u304C\u5FC5\u8981\u3067\u3059"
+        );
+        if (!/^\d+$/.test(offsetToken.value)) {
+          throw new ParseError("FROM_TODAY \u306E offset \u306F10\u9032\u6574\u6570\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044", offsetToken);
+        }
+        const rawOffset = `${sign}${offsetToken.value}`;
+        const offset = Number(rawOffset);
+        if (!Number.isSafeInteger(offset)) {
+          throw new ParseError("FROM_TODAY \u306E offset \u306F\u5B89\u5168\u306A\u6574\u6570\u306E\u7BC4\u56F2\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044", offsetToken);
+        }
+        this.expect("," /* COMMA */, "FROM_TODAY \u306E offset \u3068\u5358\u4F4D\u306F\u30AB\u30F3\u30DE\u3067\u533A\u5207\u3063\u3066\u304F\u3060\u3055\u3044");
+        const unitToken = this.expect(
+          "IDENT" /* IDENT */,
+          "FROM_TODAY \u306E\u5358\u4F4D\u306B\u306F\u975E\u5F15\u7528\u306E DAYS / WEEKS / MONTHS / YEARS \u304C\u5FC5\u8981\u3067\u3059"
+        );
+        const unit = unitToken.value.toUpperCase();
+        if (!isRelativeDatePeriodUnit(unit)) {
+          throw new ParseError("FROM_TODAY \u306E\u5358\u4F4D\u306B\u306F DAYS / WEEKS / MONTHS / YEARS \u304C\u5FC5\u8981\u3067\u3059", unitToken);
+        }
+        this.expect(")" /* RPAREN */, "FROM_TODAY \u306F offset \u3068\u5358\u4F4D\u306E2\u5F15\u6570\u3060\u3051\u3092\u53D7\u3051\u53D6\u308A\u307E\u3059");
+        const offsetText = String(offset === 0 ? 0 : offset);
+        return {
+          type: "KINTONE_FUNC",
+          name,
+          args: { kind: "FROM_TODAY", offset, offsetText, unit }
+        };
+      }
+      case "THIS_WEEK":
+      case "LAST_WEEK":
+      case "NEXT_WEEK": {
+        let weekday = null;
+        if (this.peek().kind !== ")" /* RPAREN */) {
+          const weekdayToken = this.expect(
+            "IDENT" /* IDENT */,
+            `${name} \u306E\u66DC\u65E5\u306B\u306F\u975E\u5F15\u7528\u306E SUNDAY ... SATURDAY \u304C\u5FC5\u8981\u3067\u3059`
+          );
+          const candidate = weekdayToken.value.toUpperCase();
+          if (!isRelativeDateWeekday(candidate)) {
+            throw new ParseError(`${name} \u306E\u66DC\u65E5\u304C\u4E0D\u6B63\u3067\u3059`, weekdayToken);
+          }
+          weekday = candidate;
+        }
+        this.expect(")" /* RPAREN */, `${name} \u306F\u66DC\u65E5\u3092\u6700\u59271\u500B\u3060\u3051\u53D7\u3051\u53D6\u308A\u307E\u3059`);
+        return { type: "KINTONE_FUNC", name, args: { kind: "WEEK", weekday } };
+      }
+      case "THIS_MONTH":
+      case "LAST_MONTH":
+      case "NEXT_MONTH": {
+        let day = null;
+        if (this.peek().kind !== ")" /* RPAREN */) {
+          const dayToken = this.peek();
+          if (dayToken.kind === "IDENT" /* IDENT */ && dayToken.value.toUpperCase() === "LAST") {
+            this.advance();
+            day = "LAST";
+          } else if (dayToken.kind === "NUMBER" /* NUMBER */ && /^\d+$/.test(dayToken.value)) {
+            this.advance();
+            const candidate = Number(dayToken.value);
+            if (!isRelativeDateMonthDay(candidate)) {
+              throw new ParseError(`${name} \u306E\u65E5\u306F 1 \u304B\u3089 31 \u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044`, dayToken);
+            }
+            day = candidate;
+          } else {
+            throw new ParseError(`${name} \u306E\u65E5\u306F\u975E\u5F15\u7528\u306E LAST \u307E\u305F\u306F 1 \u304B\u3089 31 \u304C\u5FC5\u8981\u3067\u3059`, dayToken);
+          }
+        }
+        this.expect(")" /* RPAREN */, `${name} \u306F\u65E5\u3092\u6700\u59271\u500B\u3060\u3051\u53D7\u3051\u53D6\u308A\u307E\u3059`);
+        return { type: "KINTONE_FUNC", name, args: { kind: "MONTH", day } };
+      }
+      default:
+        throw new ParseError(`\u672A\u77E5\u306E\u76F8\u5BFE\u65E5\u4ED8\u95A2\u6570 ${name} \u3067\u3059`, nameToken);
+    }
+  }
   parseSqlValue() {
     const tok = this.peek();
     if (tok.kind === "VARIABLE" /* VARIABLE */) {
@@ -3382,7 +3529,7 @@ var Parser = class {
         whereTok
       );
     }
-    const where = this.parseWhereExpr();
+    const where = this.parseWhereExpr(void 0, true);
     const applyBlocks = [];
     while (this.isApplyBlockStart()) applyBlocks.push(this.parseApplyBlock());
     if (this.isSoftKeyword("APPLY") && this.peekAt(1).kind === "IDENT" /* IDENT */ && this.peekAt(1).value.toUpperCase() === "SUBTABLE") {
@@ -3514,7 +3661,7 @@ var Parser = class {
     throw new ParseError("APPLY \u306E\u64CD\u4F5C\u306B\u306F PATCH / APPEND / REMOVE / ADD \u304C\u5FC5\u8981\u3067\u3059", this.peek());
   }
   parseApplyRowSelector() {
-    if (this.consume("WHERE" /* WHERE */)) return { kind: "WHERE", where: this.parseWhereExpr() };
+    if (this.consume("WHERE" /* WHERE */)) return { kind: "WHERE", where: this.parseWhereExpr(void 0, true) };
     if (this.consume("ALL" /* ALL */)) {
       if (!this.isSoftKeyword("ROWS")) throw new ParseError("ALL \u306E\u5F8C\u306B\u306F ROWS \u304C\u5FC5\u8981\u3067\u3059", this.peek());
       this.advance();
@@ -3834,7 +3981,7 @@ var Parser = class {
         whereTok
       );
     }
-    const where = this.parseWhereExpr();
+    const where = this.parseWhereExpr(void 0, true);
     return subtableCode ? { type: "DELETE", appId, subtableCode, where } : { type: "DELETE", appId, where };
   }
   // ----------------------------------------------------------
@@ -3864,7 +4011,7 @@ var Parser = class {
       if (!this.consume("WHERE" /* WHERE */)) {
         throw new ParseError("REORDER \u306B\u306F WHERE \u53E5\u304C\u5FC5\u9808\u3067\u3059\uFF08\u8AA4\u64CD\u4F5C\u9632\u6B62\uFF09", whereTok);
       }
-      where = this.parseWhereExpr();
+      where = this.parseWhereExpr(void 0, true);
     }
     return {
       type: "REORDER",
@@ -4591,7 +4738,9 @@ function assertSafeParentPredicateNode(node, allowKlike) {
   if ((type === "FIELD" || type === "FIELD_REF") && typeof item["field"] === "string" && /^(count|sum|avg|min|max|group_concat)\s*\(/i.test(item["field"])) {
     unsupported("aggregate or window expressions in parent WHERE");
   }
-  if (type === "KINTONE_FUNC") unsupported("non-deterministic kintone functions in parent WHERE");
+  if (type === "KINTONE_FUNC" && !(typeof item["name"] === "string" && isRelativeDateFunctionName(item["name"]))) {
+    unsupported("non-deterministic kintone functions in parent WHERE");
+  }
   for (const value of Object.values(item)) assertSafeParentPredicateNode(value, allowKlike);
 }
 function assertSafeChildPredicate(where, idxSelectors) {
@@ -4612,7 +4761,9 @@ function assertSafeApplyNode(node, context, allowIdx = false) {
     unsupported(`subqueries in ${context}`);
   }
   if (type === "WINDOW_COL" || type === "AGGREGATE" || type === "AGG_REF" || type === "AGG_ARITH" || type === "ARITH_AGG_COL") unsupported(`aggregate or window expressions in ${context}`);
-  if (type === "KINTONE_FUNC") unsupported(`non-deterministic kintone functions in ${context}`);
+  if (type === "KINTONE_FUNC" && !(typeof item["name"] === "string" && isRelativeDateFunctionName(item["name"]))) {
+    unsupported(`non-deterministic kintone functions in ${context}`);
+  }
   if (type === "FIELD") {
     const alias = item["tableAlias"];
     const field = item["field"];
@@ -4864,7 +5015,67 @@ function convertString(v) {
   return `"${v.value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
 function convertKintoneFunc(v) {
-  return `${v.name}()`;
+  switch (v.name) {
+    case "TODAY":
+    case "NOW":
+    case "LOGINUSER":
+      return `${v.name}()`;
+  }
+  return convertRelativeDateFunction(v);
+}
+function convertRelativeDateFunction(v) {
+  switch (v.name) {
+    case "YESTERDAY":
+    case "TOMORROW":
+    case "THIS_YEAR":
+    case "LAST_YEAR":
+    case "NEXT_YEAR":
+      if (v.args?.kind !== "NONE") return failInvalidRelativeDateFunction();
+      return `${v.name}()`;
+    case "FROM_TODAY":
+      if (v.args?.kind !== "FROM_TODAY" || !isValidRelativeDateOffset(v.args.offset, v.args.offsetText) || !RELATIVE_DATE_PERIOD_UNITS2.has(v.args.unit)) {
+        return failInvalidRelativeDateFunction();
+      }
+      return `${v.name}(${v.args.offsetText}, ${v.args.unit})`;
+    case "THIS_WEEK":
+    case "LAST_WEEK":
+    case "NEXT_WEEK":
+      if (v.args?.kind !== "WEEK" || v.args.weekday !== null && !RELATIVE_DATE_WEEKDAYS2.has(v.args.weekday)) {
+        return failInvalidRelativeDateFunction();
+      }
+      return v.args.weekday === null ? `${v.name}()` : `${v.name}(${v.args.weekday})`;
+    case "THIS_MONTH":
+    case "LAST_MONTH":
+    case "NEXT_MONTH":
+      if (v.args?.kind !== "MONTH" || !isValidRelativeDateMonthDay(v.args.day)) {
+        return failInvalidRelativeDateFunction();
+      }
+      return v.args.day === null ? `${v.name}()` : `${v.name}(${v.args.day})`;
+  }
+  return failInvalidRelativeDateFunction();
+}
+var RELATIVE_DATE_PERIOD_UNITS2 = /* @__PURE__ */ new Set(["DAYS", "WEEKS", "MONTHS", "YEARS"]);
+var RELATIVE_DATE_WEEKDAYS2 = /* @__PURE__ */ new Set([
+  "SUNDAY",
+  "MONDAY",
+  "TUESDAY",
+  "WEDNESDAY",
+  "THURSDAY",
+  "FRIDAY",
+  "SATURDAY"
+]);
+function isValidRelativeDateOffset(offset, offsetText) {
+  if (!Number.isSafeInteger(offset)) return false;
+  if (!/^(?:0|[1-9]\d*|-[1-9]\d*)$/.test(offsetText)) return false;
+  return Number(offsetText) === offset;
+}
+function isValidRelativeDateMonthDay(day) {
+  return day === null || day === "LAST" || typeof day === "number" && Number.isInteger(day) && day >= 1 && day <= 31;
+}
+function failInvalidRelativeDateFunction() {
+  throw new KintoneQueryError(
+    "internal error: invalid relative date function AST reached kintone query conversion"
+  );
 }
 function convertInList(v, op) {
   if (op !== "IN" && op !== "NOT_IN") {
@@ -7489,7 +7700,7 @@ function resolveValue(value, row, resolveFieldType, resolveFieldSemantics2) {
     case "NUMBER":
       return numberLiteralText(value);
     case "KINTONE_FUNC":
-      return resolveKintoneFunc(value.name);
+      return resolveKintoneFuncValue(value.name);
     case "IN_LIST":
       return "";
     // IN は evalOp で別処理
@@ -7558,6 +7769,21 @@ function resolveKintoneFunc(name) {
       return "";
   }
 }
+function resolveKintoneFuncValue(name) {
+  if (isRelativeDateFunctionName(name)) {
+    throw new Error(
+      `${name}: ${WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN}`
+    );
+  }
+  switch (name) {
+    case "TODAY":
+    case "NOW":
+    case "LOGINUSER":
+      return resolveKintoneFunc(name);
+    default:
+      throw new Error(`InternalError: unexpected KINTONE_FUNC name: ${name}`);
+  }
+}
 var likeRegexCache = /* @__PURE__ */ new Map();
 var LIKE_REGEX_CACHE_MAX = 200;
 function matchLike(value, pattern) {
@@ -10535,7 +10761,10 @@ function planKorder(input) {
   if (stmt.from.cteName !== null || stmt.from.subtableCode || input.staticMode !== "SIMPLE") {
     reasons.push("KORDER_QUERY_SHAPE_UNSUPPORTED");
   }
-  if (input.whereCapability !== "EXACT_PUSHDOWN") reasons.push("KORDER_WHERE_NOT_EXACT");
+  if (input.whereCapability !== "EXACT_PUSHDOWN") {
+    reasons.push(...(input.whereReasons ?? []).filter((reason) => reason.functionName !== void 0).map((reason) => reason.code));
+    reasons.push("KORDER_WHERE_NOT_EXACT");
+  }
   if (input.hasKlike) reasons.push("KORDER_KLIKE_UNSUPPORTED");
   if (stmt.orderBy.length === 0) reasons.push("KORDER_KEY_REQUIRED");
   for (const item of stmt.orderBy) {
@@ -11700,7 +11929,8 @@ function runFullScan(input) {
     });
     knownColumns = mergeKnownColumns(knownColumns, rightColumns, rows);
   }
-  rows = applyFilter(rows, stmt.where, fieldTypeResolver, appliedKlikes, fieldSemanticsResolver);
+  const filterWhere = input.residualWhere !== void 0 ? input.residualWhere : stmt.where;
+  rows = applyFilter(rows, filterWhere, fieldTypeResolver, appliedKlikes, fieldSemanticsResolver);
   const grouping = normalizeGroupingSpec(stmt);
   if (grouping.type === "GROUPING_SETS") {
     if (!resolvedGroupingSpec) {
@@ -11861,6 +12091,13 @@ function deepClone(value, seen = /* @__PURE__ */ new Map()) {
 
 // src/core/optimization/whereCapability.ts
 var RANGE_AND_EQUALITY = ["=", "!=", ">", "<", ">=", "<="];
+var RELATIVE_DATE_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "DATE",
+  "DATETIME",
+  "CREATED_TIME",
+  "UPDATED_TIME"
+]);
+var RELATIVE_DATE_OPERATORS = new Set(RANGE_AND_EQUALITY);
 var EQUALITY_IN = ["=", "!=", "in", "not in"];
 var NATIVE_OPERATORS = /* @__PURE__ */ new Map([
   ["RECORD_NUMBER", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
@@ -11936,7 +12173,7 @@ function classifyNode(where, resolveField2) {
     case "BOOLEAN":
       return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
     case "BINARY":
-      return classifyBinary(where.op, where.left, where.right.type, resolveField2);
+      return classifyBinary(where.op, where.left, where.right, resolveField2);
     case "NULL_CHECK":
       if (where.field.type !== "FIELD") return localExpression();
       return classifyLocalOnlyField(where.field, where.not ? "IS NOT NULL" : "IS NULL", resolveField2);
@@ -11946,7 +12183,14 @@ function classifyNode(where, resolveField2) {
       return classifyNode(where.expr, resolveField2);
     case "NOT": {
       const inner = classifyNode(where.expr, resolveField2);
-      return inner.capability === "SUPERSET_PREFILTER" ? { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] } : inner;
+      if (inner.capability !== "SUPERSET_PREFILTER") return inner;
+      if (!hasRelativeDateReason(inner.reasons)) {
+        return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
+      }
+      return requireExactRelativeDatePushdown({
+        capability: "LOCAL_ONLY",
+        reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }, ...inner.reasons]
+      });
     }
     case "LOGICAL": {
       const left = classifyNode(where.left, resolveField2);
@@ -11955,7 +12199,10 @@ function classifyNode(where, resolveField2) {
     }
   }
 }
-function classifyBinary(op, left, rightType, resolveField2) {
+function classifyBinary(op, left, right, resolveField2) {
+  if (right.type === "KINTONE_FUNC" && isRelativeDateFunctionName(right.name)) {
+    return classifyRelativeDateBinary(op, left, right, resolveField2);
+  }
   if (left.type !== "FIELD") return localExpression();
   const semantics = resolveField2(left);
   if (!semantics) {
@@ -11966,7 +12213,7 @@ function classifyBinary(op, left, rightType, resolveField2) {
   }
   const nativeOp = normalizeOperator(op);
   const native = nativeWhereOperatorsForType(semantics.fieldType);
-  const rightCanPush = rightType === "STRING" || rightType === "NUMBER" || rightType === "IN_LIST" || rightType === "KINTONE_FUNC";
+  const rightCanPush = right.type === "STRING" || right.type === "NUMBER" || right.type === "IN_LIST" || isLegacyKintoneFunction(right);
   const structureAllows = !semantics.requiresCollectionOperators || nativeOp !== "=" && nativeOp !== "!=";
   const sqlLikeIsResidual = op === "LIKE" || op === "NOT_LIKE";
   if (rightCanPush && structureAllows && native.has(nativeOp) && !sqlLikeIsResidual) {
@@ -11990,6 +12237,92 @@ function classifyBinary(op, left, rightType, resolveField2) {
     }]
   };
 }
+function isLegacyKintoneFunction(value) {
+  return value.type === "KINTONE_FUNC" && (value.name === "TODAY" || value.name === "NOW" || value.name === "LOGINUSER");
+}
+function classifyRelativeDateBinary(op, left, right, resolveField2) {
+  const operator = normalizeOperator(op);
+  const functionName = right.name;
+  if (left.type !== "FIELD") {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_CONTEXT_UNSUPPORTED",
+      functionName,
+      void 0,
+      void 0,
+      operator
+    );
+  }
+  const semantics = resolveField2(left);
+  if (!semantics) {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_FIELD_TYPE_UNSUPPORTED",
+      functionName,
+      left.field,
+      void 0,
+      operator
+    );
+  }
+  if (!hasValidRelativeDateArguments(right)) {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_ARGUMENT_INVALID",
+      functionName,
+      left.field,
+      semantics.fieldType,
+      operator
+    );
+  }
+  if (!RELATIVE_DATE_OPERATORS.has(operator)) {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_OPERATOR_UNSUPPORTED",
+      functionName,
+      left.field,
+      semantics.fieldType,
+      operator
+    );
+  }
+  if (!RELATIVE_DATE_FIELD_TYPES.has(semantics.fieldType) || semantics.inSubtable || semantics.requiresCollectionOperators) {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_FIELD_TYPE_UNSUPPORTED",
+      functionName,
+      left.field,
+      semantics.fieldType,
+      operator
+    );
+  }
+  return {
+    capability: "EXACT_PUSHDOWN",
+    reasons: [{
+      code: "WHERE_EXACT",
+      functionName,
+      field: left.field,
+      fieldType: semantics.fieldType,
+      operator
+    }]
+  };
+}
+function hasValidRelativeDateArguments(value) {
+  if (!("args" in value) || !value.args) return false;
+  switch (value.name) {
+    case "YESTERDAY":
+    case "TOMORROW":
+    case "THIS_YEAR":
+    case "LAST_YEAR":
+    case "NEXT_YEAR":
+      return value.args.kind === "NONE";
+    case "FROM_TODAY":
+      return value.args.kind === "FROM_TODAY" && Number.isSafeInteger(value.args.offset) && value.args.offsetText === String(value.args.offset === 0 ? 0 : value.args.offset) && (value.args.unit === "DAYS" || value.args.unit === "WEEKS" || value.args.unit === "MONTHS" || value.args.unit === "YEARS");
+    case "THIS_WEEK":
+    case "LAST_WEEK":
+    case "NEXT_WEEK":
+      return value.args.kind === "WEEK" && (value.args.weekday === null || value.args.weekday === "SUNDAY" || value.args.weekday === "MONDAY" || value.args.weekday === "TUESDAY" || value.args.weekday === "WEDNESDAY" || value.args.weekday === "THURSDAY" || value.args.weekday === "FRIDAY" || value.args.weekday === "SATURDAY");
+    case "THIS_MONTH":
+    case "LAST_MONTH":
+    case "NEXT_MONTH":
+      return value.args.kind === "MONTH" && (value.args.day === null || value.args.day === "LAST" || Number.isInteger(value.args.day) && value.args.day >= 1 && value.args.day <= 31);
+    default:
+      return false;
+  }
+}
 function classifyLocalOnlyField(field, operator, resolveField2) {
   const semantics = resolveField2(field);
   if (!semantics) return unsupported2("WHERE_FIELD_UNRESOLVED", field.field, void 0, operator);
@@ -12027,18 +12360,18 @@ function normalizeOperator(op) {
 function combineLogical(op, left, right) {
   const reasons = [...left.reasons, ...right.reasons];
   if (left.capability === "UNSUPPORTED" || right.capability === "UNSUPPORTED") {
-    return { capability: "UNSUPPORTED", reasons };
+    return requireExactRelativeDatePushdown({ 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 {
+    return requireExactRelativeDatePushdown({
       capability: "SUPERSET_PREFILTER",
       reasons: [{ code: "WHERE_SUPERSET_PREFILTER" }, ...reasons]
-    };
+    });
   }
-  return { capability: "LOCAL_ONLY", reasons };
+  return requireExactRelativeDatePushdown({ capability: "LOCAL_ONLY", reasons });
 }
 function localExpression() {
   return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
@@ -12046,6 +12379,656 @@ function localExpression() {
 function unsupported2(code, field, fieldType, operator) {
   return { capability: "UNSUPPORTED", reasons: [{ code, field, fieldType, operator }] };
 }
+function relativeDateUnsupported(code, functionName, field, fieldType, operator) {
+  return requireExactRelativeDatePushdown({
+    capability: "UNSUPPORTED",
+    reasons: [{ code, functionName, field, fieldType, operator }]
+  });
+}
+function hasRelativeDateReason(reasons) {
+  return reasons.some((reason) => reason.functionName !== void 0);
+}
+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);
+  return {
+    capability: result.capability,
+    reasons: [
+      ...result.reasons,
+      {
+        code: "WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN",
+        functionName: relative.functionName,
+        field: relative.field,
+        fieldType: relative.fieldType,
+        operator: relative.operator
+      }
+    ]
+  };
+}
+
+// src/core/optimization/relativeDatePushdownGuard.ts
+function relativeDateFunctionNamesInNode(node, stopAtNestedSelect) {
+  const names = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (valueNode) => {
+    if (Array.isArray(valueNode)) {
+      valueNode.forEach(visit);
+      return;
+    }
+    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"])) {
+      seen.add(value["name"]);
+      names.push(value["name"]);
+      return;
+    }
+    if (stopAtNestedSelect && value["type"] === "SELECT") return;
+    Object.values(value).forEach(visit);
+  };
+  visit(node);
+  return names;
+}
+function relativeDateFunctionNamesInWhere(where) {
+  return relativeDateFunctionNamesInNode(where, true);
+}
+function nestedSelects(node, root) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    if (value === null || typeof value !== "object" || seen.has(value)) return;
+    seen.add(value);
+    const object = value;
+    if (object["type"] === "SELECT" && value !== root) {
+      found.push(value);
+      return;
+    }
+    Object.values(object).forEach(visit);
+  };
+  visit(node);
+  return found;
+}
+function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = true) {
+  const functionNames = relativeDateFunctionNamesInWhere(select.where);
+  if (functionNames.length > 0) {
+    candidates.push({
+      kind: forceForbidden ? "FORBIDDEN" : "SELECT",
+      source: select,
+      where: select.where,
+      functionNames,
+      path,
+      allowPhase2Prefilter: allowPhase2
+    });
+  }
+  nestedSelects(select, select).forEach(
+    (nested, index) => collectSelect(
+      nested,
+      `${path}.select-source[${index}]`,
+      candidates,
+      forceForbidden,
+      allowPhase2
+    )
+  );
+}
+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 collectWith(statement, path, candidates, inheritedForbidden) {
+  if (!inheritedForbidden && canInlineSingleCte(statement)) {
+    collectSelect(buildInlinedQuery(statement), `${path}.inlined`, candidates, false);
+    return;
+  }
+  statement.ctes.forEach((cte, index) => {
+    if (cte.query.type === "SELECT") {
+      collectSelect(cte.query, `${path}.cte[${index}]`, candidates, true);
+    } else if (cte.query.type === "UNION") {
+      collectUnion(cte.query, `${path}.cte[${index}]`, candidates, true);
+    }
+  });
+  if (statement.query.type === "SELECT") {
+    collectSelect(statement.query, `${path}.main`, candidates, true);
+  } else {
+    collectUnion(statement.query, `${path}.main`, candidates, true);
+  }
+}
+function collectStatement(statement, path, candidates, forceForbidden = false) {
+  switch (statement.type) {
+    case "SELECT":
+      collectSelect(statement, path, candidates, forceForbidden);
+      return;
+    case "UNION":
+      collectUnion(statement, path, candidates, forceForbidden);
+      return;
+    case "WITH":
+      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);
+      return;
+    case "EXPLAIN":
+      collectStatement(statement.query, `${path}.query`, candidates, forceForbidden);
+      return;
+    case "VALIDATE":
+    case "REORDER": {
+      const functionNames = relativeDateFunctionNamesInWhere(statement.where);
+      if (functionNames.length > 0) {
+        candidates.push({
+          kind: "FORBIDDEN",
+          source: statement,
+          where: statement.where,
+          functionNames,
+          path
+        });
+      }
+      nestedSelects(statement, statement).forEach(
+        (select, index) => collectSelect(select, `${path}.select-source[${index}]`, candidates, true)
+      );
+      return;
+    }
+    case "UPDATE":
+    case "DELETE": {
+      const functionNames = relativeDateFunctionNamesInWhere(statement.where);
+      if (functionNames.length > 0) {
+        const forbidden = forceForbidden || Boolean(statement.subtableCode) || statement.type === "UPDATE" && (statement.from != null || Boolean(statement.applyBlocks?.length));
+        candidates.push({
+          kind: forbidden ? "FORBIDDEN" : "DML",
+          source: statement,
+          where: statement.where,
+          functionNames,
+          path
+        });
+      }
+      if (statement.type === "UPDATE" && statement.applyBlocks?.length) {
+        const applyFunctions = relativeDateFunctionNamesInNode(statement.applyBlocks, true);
+        if (applyFunctions.length > 0) {
+          candidates.push({
+            kind: "FORBIDDEN",
+            source: statement,
+            where: null,
+            functionNames: applyFunctions,
+            path: `${path}.apply`
+          });
+        }
+      }
+      nestedSelects(statement, statement).forEach(
+        (select, index) => collectSelect(
+          select,
+          `${path}.select-source[${index}]`,
+          candidates,
+          forceForbidden,
+          false
+        )
+      );
+      return;
+    }
+    default:
+      nestedSelects(statement, statement).forEach(
+        (select, index) => collectSelect(
+          select,
+          `${path}.select-source[${index}]`,
+          candidates,
+          forceForbidden,
+          false
+        )
+      );
+  }
+}
+function serializationContainsFunctions(query, names) {
+  return names.every((name) => new RegExp(`\\b${name}\\s*\\(`).test(query));
+}
+function allowRelativeDatePrefilterPlan(select, decomposition) {
+  return decomposition.eligible === true && resolveSelectMode(select) === "FULL_SCAN" && select.orderMode !== "KINTONE_NATIVE" && select.from.cteName === null && !select.from.subtableCode && select.joins.length === 0;
+}
+function rejectedNode(candidate) {
+  return {
+    kind: candidate.kind,
+    source: candidate.source,
+    functionNames: candidate.functionNames,
+    path: candidate.path,
+    clientWhereEvaluation: true,
+    allowed: false
+  };
+}
+function relativeDateReasonCodes(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)) {
+    codes.push(WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN);
+  }
+  return [...new Set(codes)];
+}
+function rejectionFor(candidate, capability) {
+  const reasonCodes = relativeDateReasonCodes(capability);
+  return {
+    functionName: candidate.functionNames[0],
+    path: candidate.path,
+    code: reasonCodes.find(
+      (code) => code !== WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN
+    ) ?? WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN,
+    reasonCodes
+  };
+}
+async function buildRelativeDatePushdownPlan(statement, resolver) {
+  const candidates = [];
+  collectStatement(statement, "statement", candidates);
+  const nodes = [];
+  for (const candidate of candidates) {
+    if (candidate.kind === "FORBIDDEN") {
+      const node2 = rejectedNode(candidate);
+      nodes.push(node2);
+      return {
+        hasRelativeDate: true,
+        nodes,
+        allowed: false,
+        rejection: rejectionFor(candidate)
+      };
+    }
+    if (candidate.kind === "SELECT") {
+      const select = candidate.source;
+      const physicalTopLevel = select.from.cteName === null && !select.from.subtableCode && select.joins.length === 0;
+      const selectMode = resolveSelectMode(select);
+      const capability2 = await resolver.select(select);
+      let restQuery2 = "";
+      try {
+        restQuery2 = candidate.where === null ? "" : whereToKintone(candidate.where);
+      } catch {
+        restQuery2 = "";
+      }
+      let allowed2 = physicalTopLevel && selectMode === "SIMPLE" && (select.orderBy.length === 0 || select.orderMode === "KINTONE_NATIVE") && capability2.capability === "EXACT_PUSHDOWN" && serializationContainsFunctions(restQuery2, candidate.functionNames);
+      let prefilterPlan;
+      let phase2PrefilterEligible;
+      if (!allowed2 && candidate.allowPhase2Prefilter !== false && capability2.capability === "SUPERSET_PREFILTER" && resolver.prefilterDecomposition) {
+        const decomposition = await resolver.prefilterDecomposition(select);
+        if (decomposition?.eligible === true && allowRelativeDatePrefilterPlan(select, decomposition)) {
+          prefilterPlan = decomposition.plan;
+          phase2PrefilterEligible = true;
+          allowed2 = true;
+        }
+      }
+      const node2 = {
+        kind: candidate.kind,
+        source: candidate.source,
+        functionNames: candidate.functionNames,
+        path: candidate.path,
+        selectMode,
+        capability: capability2,
+        restQuery: restQuery2,
+        ...prefilterPlan ? { prefilterPlan, phase2PrefilterEligible } : {},
+        clientWhereEvaluation: !allowed2,
+        allowed: allowed2
+      };
+      nodes.push(node2);
+      if (!allowed2) {
+        return {
+          hasRelativeDate: true,
+          nodes,
+          allowed: false,
+          rejection: rejectionFor(candidate, capability2)
+        };
+      }
+      continue;
+    }
+    const dml = candidate.source;
+    const capability = await resolver.dml(dml);
+    let restQuery = "";
+    try {
+      restQuery = candidate.where === null ? "" : whereToKintone(candidate.where);
+    } catch {
+      restQuery = "";
+    }
+    const allowed = capability.capability === "EXACT_PUSHDOWN" && serializationContainsFunctions(restQuery, candidate.functionNames);
+    const node = {
+      kind: candidate.kind,
+      source: candidate.source,
+      functionNames: candidate.functionNames,
+      path: candidate.path,
+      capability,
+      restQuery,
+      clientWhereEvaluation: !allowed,
+      allowed
+    };
+    nodes.push(node);
+    if (!allowed) {
+      return {
+        hasRelativeDate: true,
+        nodes,
+        allowed: false,
+        rejection: rejectionFor(candidate, capability)
+      };
+    }
+  }
+  return {
+    hasRelativeDate: candidates.length > 0,
+    nodes,
+    allowed: true
+  };
+}
+function assertRelativeDatePushdownPlan(plan) {
+  if (!plan.allowed && plan.rejection) {
+    const details = plan.rejection.reasonCodes.filter(
+      (code) => code !== WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN
+    );
+    throw new Error(
+      `${plan.rejection.functionName}: ${WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN}${details.length > 0 ? ` (reason=${details.join(", ")})` : ""} (path=${plan.rejection.path})`
+    );
+  }
+}
+
+// src/core/optimization/relativeDatePrefilterPlan.ts
+function decomposeRelativeDatePrefilter(stmt, resolveField2, testSeam = {}) {
+  const capability = classifyWhereCapability(stmt.where, resolveField2);
+  const reject = (reasonCodes, disposition = "INELIGIBLE") => ({
+    eligible: false,
+    disposition,
+    reasonCodes,
+    capability: capability.capability,
+    reasons: capability.reasons
+  });
+  if (stmt.where === null) return reject(["NO_WHERE"]);
+  if (stmt.from.subtableCode) return reject(["SUBTABLE_UNSUPPORTED"]);
+  if (stmt.joins.length > 0) return reject(["JOIN_UNSUPPORTED"]);
+  if (stmt.from.cteName !== null || stmt.from.appId <= 0) {
+    return reject(["NOT_DIRECT_PHYSICAL_APP"]);
+  }
+  const occurrences = collectRelativeOccurrences(stmt.where);
+  if (occurrences.length === 0) return reject(["NO_RELATIVE_DATE"]);
+  const spine = collectRelativeLeavesOnAndSpine(stmt.where, resolveField2);
+  if (!spine.ok) return reject(spine.reasonCodes);
+  if (!sameRelativeMultiset(occurrences, spine.leaves)) {
+    return reject(["RELATIVE_DATE_LEAF_COUNT_MISMATCH"]);
+  }
+  if (capability.capability === "EXACT_PUSHDOWN") {
+    return reject(["DEFER_TO_PHASE1"], "DEFER_PHASE1");
+  }
+  if (capability.capability !== "SUPERSET_PREFILTER") {
+    return reject(["CAPABILITY_NOT_SUPERSET_PREFILTER"]);
+  }
+  const fieldMetadata = collectFieldMetadata(stmt.where, resolveField2);
+  const safePlan = buildSingleTableKlikePushdownPlan(stmt.where, {
+    tableAlias: stmt.from.alias ?? void 0,
+    allowUnqualifiedFields: true,
+    allowKlike: true,
+    fieldTypes: fieldMetadata.fieldTypes,
+    fieldOptions: fieldMetadata.fieldOptions
+  });
+  const serialize = testSeam.serialize ?? whereToKintone;
+  const containsFunctions = testSeam.containsFunctions ?? serializationContainsFunctions;
+  const confirmedLeaves = [];
+  for (const leaf of spine.leaves) {
+    const name = relativeNameOf(leaf);
+    if (name === null) return reject(["RELATIVE_DATE_LEAF_COUNT_MISMATCH"]);
+    let query;
+    try {
+      query = serialize(leaf);
+    } catch {
+      return reject(["PREFILTER_SERIALIZATION_FAILED"]);
+    }
+    if (!containsFunctions(query, [name])) {
+      return reject(["PREFILTER_FUNCTION_MISSING"]);
+    }
+    confirmedLeaves.push(leaf);
+  }
+  const safeLeaves = collectBinaryIdentities(safePlan.condition);
+  const adoptedLeaves = new Set(confirmedLeaves);
+  const prefilterWhere = selectPrefilterInOriginalOrder(
+    stmt.where,
+    adoptedLeaves,
+    safeLeaves
+  );
+  if (prefilterWhere === null) {
+    return reject(["RELATIVE_DATE_LEAF_COUNT_MISMATCH"]);
+  }
+  let prefilterQuery;
+  try {
+    prefilterQuery = serialize(prefilterWhere);
+  } catch {
+    return reject(["PREFILTER_SERIALIZATION_FAILED"]);
+  }
+  const expectedNames = confirmedLeaves.map((leaf) => relativeNameOf(leaf));
+  if (!containsFunctions(prefilterQuery, [...new Set(expectedNames)]) || !serializedMultisetContains(prefilterQuery, expectedNames)) {
+    return reject(["PREFILTER_FUNCTION_MISSING"]);
+  }
+  const residualWhere = testSeam.rewriteResidual ? testSeam.rewriteResidual(stmt.where, adoptedLeaves) : replaceAdoptedLeaves(stmt.where, adoptedLeaves);
+  if (residualWhere !== null && collectRelativeOccurrences(residualWhere).length > 0) {
+    return reject(["RESIDUAL_RELATIVE_DATE_REMAINED"]);
+  }
+  if (residualWhere === null) {
+    return reject(["DEFER_TO_PHASE1"], "DEFER_PHASE1");
+  }
+  const relativeFunctionNames = /* @__PURE__ */ new Set();
+  for (const name of expectedNames) relativeFunctionNames.add(name);
+  return {
+    eligible: true,
+    plan: {
+      prefilterWhere,
+      residualWhere,
+      exactRelativeLeaves: confirmedLeaves,
+      relativeFunctionNames,
+      appliedKlikes: safePlan.appliedKlikes,
+      capability: capability.capability,
+      reasons: capability.reasons
+    }
+  };
+}
+function collectRelativeLeavesOnAndSpine(where, resolveField2) {
+  const leaves = [];
+  let failure = null;
+  const visit = (node) => {
+    if (failure !== null) return;
+    switch (node.type) {
+      case "GROUP":
+        visit(node.expr);
+        return;
+      case "LOGICAL":
+        if (node.op === "AND") {
+          visit(node.left);
+          visit(node.right);
+          return;
+        }
+        if (collectRelativeOccurrences(node).length > 0) {
+          failure = "RELATIVE_DATE_CONTEXT_UNSUPPORTED";
+        }
+        return;
+      case "NOT":
+        if (collectRelativeOccurrences(node).length > 0) {
+          failure = "RELATIVE_DATE_CONTEXT_UNSUPPORTED";
+        }
+        return;
+      case "BINARY": {
+        const name = relativeNameOf(node);
+        if (name === null) return;
+        const result = classifyRelativeDateBinary(
+          node.op,
+          node.left,
+          node.right,
+          resolveField2
+        );
+        if (result.capability !== "EXACT_PUSHDOWN") {
+          failure = "RELATIVE_DATE_LEAF_NOT_EXACT";
+          return;
+        }
+        leaves.push(node);
+        return;
+      }
+      case "EXISTS":
+        if (collectRelativeOccurrences(node).length > 0) {
+          failure = "RELATIVE_DATE_CONTEXT_UNSUPPORTED";
+        }
+        return;
+      case "NULL_CHECK":
+      case "BOOLEAN":
+        return;
+    }
+  };
+  visit(where);
+  return failure === null ? { ok: true, leaves } : { ok: false, reasonCodes: [failure] };
+}
+function relativeNameOf(leaf) {
+  return leaf.right.type === "KINTONE_FUNC" && isRelativeDateFunctionName(leaf.right.name) ? leaf.right.name : null;
+}
+function collectRelativeOccurrences(where) {
+  const found = [];
+  const visitWhere = (node) => {
+    if (node.type === "BINARY" && relativeNameOf(node) !== null) {
+      found.push(node);
+      return;
+    }
+    switch (node.type) {
+      case "LOGICAL":
+        visitWhere(node.left);
+        visitWhere(node.right);
+        return;
+      case "NOT":
+      case "GROUP":
+        visitWhere(node.expr);
+        return;
+      case "EXISTS":
+        if (node.query.where !== null) visitWhere(node.query.where);
+        return;
+      case "BINARY":
+      case "NULL_CHECK":
+      case "BOOLEAN":
+        return;
+    }
+  };
+  visitWhere(where);
+  return found;
+}
+function sameRelativeMultiset(occurrences, candidates) {
+  if (occurrences.length !== candidates.length) return false;
+  const remaining = new Set(candidates);
+  for (const occurrence of occurrences) {
+    if (!remaining.delete(occurrence)) return false;
+  }
+  return remaining.size === 0;
+}
+function collectBinaryIdentities(where) {
+  const found = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    switch (node.type) {
+      case "BINARY":
+        found.add(node);
+        return;
+      case "LOGICAL":
+        visit(node.left);
+        visit(node.right);
+        return;
+      case "NOT":
+      case "GROUP":
+        visit(node.expr);
+        return;
+      case "NULL_CHECK":
+      case "EXISTS":
+      case "BOOLEAN":
+        return;
+    }
+  };
+  if (where !== null) visit(where);
+  return found;
+}
+function selectPrefilterInOriginalOrder(where, relativeLeaves, safeLeaves) {
+  switch (where.type) {
+    case "BINARY":
+      return relativeLeaves.has(where) || safeLeaves.has(where) ? where : null;
+    case "LOGICAL":
+      if (where.op !== "AND") return null;
+      {
+        const left = selectPrefilterInOriginalOrder(where.left, relativeLeaves, safeLeaves);
+        const right = selectPrefilterInOriginalOrder(where.right, relativeLeaves, safeLeaves);
+        if (left !== null && right !== null) return { ...where, left, right };
+        return left ?? right;
+      }
+    case "GROUP": {
+      const expr = selectPrefilterInOriginalOrder(where.expr, relativeLeaves, safeLeaves);
+      return expr === null ? null : { ...where, expr };
+    }
+    case "NULL_CHECK":
+    case "NOT":
+    case "EXISTS":
+    case "BOOLEAN":
+      return null;
+  }
+}
+var TRUE_PREDICATE = { type: "BOOLEAN", value: true };
+function replaceAdoptedLeaves(where, adoptedLeaves) {
+  if (where.type === "BINARY" && adoptedLeaves.has(where)) return TRUE_PREDICATE;
+  switch (where.type) {
+    case "LOGICAL": {
+      if (where.op !== "AND") return where;
+      const left = replaceAdoptedLeaves(where.left, adoptedLeaves) ?? TRUE_PREDICATE;
+      const right = replaceAdoptedLeaves(where.right, adoptedLeaves) ?? TRUE_PREDICATE;
+      if (isTrue(left)) return isTrue(right) ? null : right;
+      if (isTrue(right)) return left;
+      if (left === where.left && right === where.right) return where;
+      return { ...where, left, right };
+    }
+    case "GROUP": {
+      const expr = replaceAdoptedLeaves(where.expr, adoptedLeaves) ?? TRUE_PREDICATE;
+      if (isTrue(expr)) return TRUE_PREDICATE;
+      return expr === where.expr ? where : { ...where, expr };
+    }
+    case "BINARY":
+    case "NULL_CHECK":
+    case "NOT":
+    case "EXISTS":
+    case "BOOLEAN":
+      return where;
+  }
+}
+function isTrue(where) {
+  return where.type === "BOOLEAN" && where.value;
+}
+function collectFieldMetadata(where, resolveField2) {
+  const fields = /* @__PURE__ */ new Map();
+  const visitValue = (value) => {
+    if (value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      value.forEach(visitValue);
+      return;
+    }
+    const record = value;
+    if (record["type"] === "SELECT") return;
+    if (record["type"] === "FIELD" && typeof record["field"] === "string" && typeof record["tableAlias"] !== "undefined") {
+      fields.set(record["field"], value);
+      return;
+    }
+    Object.values(record).forEach(visitValue);
+  };
+  visitValue(where);
+  const fieldTypes = /* @__PURE__ */ new Map();
+  const fieldOptions = /* @__PURE__ */ new Map();
+  for (const [fieldCode, field] of fields) {
+    const semantics = resolveField2(field);
+    if (!semantics) continue;
+    fieldTypes.set(fieldCode, semantics.fieldType);
+    if (semantics.optionOrder) {
+      fieldOptions.set(fieldCode, new Set(semantics.optionOrder.keys()));
+    }
+  }
+  return { fieldTypes, fieldOptions };
+}
+function serializedMultisetContains(query, expectedNames) {
+  const expected = /* @__PURE__ */ new Map();
+  for (const name of expectedNames) {
+    if (!RELATIVE_DATE_FUNCTION_NAMES.has(name)) return false;
+    expected.set(name, (expected.get(name) ?? 0) + 1);
+  }
+  for (const [name, count] of expected) {
+    const matches = query.match(new RegExp(`\\b${name}\\s*\\(`, "g"));
+    if ((matches?.length ?? 0) < count) return false;
+  }
+  return true;
+}
 
 // src/import/sourceLoader.ts
 var IMPORT_MAX_BYTES = 10 * 1024 * 1024;
@@ -13102,7 +14085,29 @@ function attachSearchAbortWarning(result, collector) {
   warnings.add(SEARCH_ABORTED_WARNING);
   return { ...result, warnings: [...warnings] };
 }
+async function assertRelativeDateExecutionPlan(stmt, client, cacheContext) {
+  const plan = await resolveRelativeDateExecutionPlan(stmt, client, cacheContext);
+  assertRelativeDatePushdownPlan(plan);
+  return plan;
+}
+async function resolveRelativeDateExecutionPlan(stmt, client, cacheContext) {
+  return buildRelativeDatePushdownPlan(stmt, {
+    select: (select) => resolveSelectWhereCapability(select, client, cacheContext),
+    dml: (dml) => resolveDmlWhereCapability(dml, client, cacheContext),
+    prefilterDecomposition: async (select) => {
+      if (select.where === null) return null;
+      const resolver = await buildWhereFieldSemanticsResolver(
+        select,
+        client,
+        cacheContext
+      );
+      return decomposeRelativeDatePrefilter(select, resolver);
+    }
+  });
+}
 async function executeParsedStatement(stmt, client, options, cacheContext) {
+  const relativeDatePlan = await resolveRelativeDateExecutionPlan(stmt, client, cacheContext);
+  if (stmt.type !== "EXPLAIN") assertRelativeDatePushdownPlan(relativeDatePlan);
   const unresolved = findVariableRef(stmt);
   if (unresolved !== null && !isApplyParentKlikeStatement(stmt)) {
     throw new Error(`ParseError: variable @${unresolved} is not defined in a batch.`);
@@ -13164,7 +14169,8 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
         options.maxRecords ?? 1e4,
         options.cursorMaxActive ?? 2,
         stmt.query.type === "UPDATE" && stmt.query.applyBlocks?.length ? resolveApplyGuardLimit(options.dmlMaxRows, "dmlMaxRows", DEFAULT_APPLY_MAX_ROWS) : DEFAULT_APPLY_MAX_ROWS,
-        stmt.query.type === "UPDATE" && stmt.query.applyBlocks?.length ? resolveApplyGuardLimit(options.dmlMaxSubtableRows, "dmlMaxSubtableRows", DEFAULT_APPLY_MAX_SUBTABLE_ROWS) : DEFAULT_APPLY_MAX_SUBTABLE_ROWS
+        stmt.query.type === "UPDATE" && stmt.query.applyBlocks?.length ? resolveApplyGuardLimit(options.dmlMaxSubtableRows, "dmlMaxSubtableRows", DEFAULT_APPLY_MAX_SUBTABLE_ROWS) : DEFAULT_APPLY_MAX_SUBTABLE_ROWS,
+        relativeDatePlan
       );
     // 一時テーブルはバッチスコープのため単文実行では拒否する（executeBatch を使う）
     case "CREATE_TEMP_TABLE":
@@ -13548,6 +14554,7 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
   if (stmt.type === "SET_VARIABLE") {
     const resolvedStmt2 = resolveBatchVariableReferences(stmt, variables);
     validateKlikeStatement(resolvedStmt2);
+    await assertRelativeDateExecutionPlan(resolvedStmt2, client, cacheContext);
     if (resolvedStmt2.expr.type === "ARRAY") {
       variables.set(stmt.name, {
         type: "array",
@@ -13604,6 +14611,7 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
   assertApplyScope("phase15b", resolvedStmt);
   assertApplyExecutionScope("phase15b", resolvedStmt);
   validateKlikeStatement(resolvedStmt);
+  await assertRelativeDateExecutionPlan(resolvedStmt, client, cacheContext);
   if (resolvedStmt.type === "VALIDATE") {
     const result = await executeExistingRecordValidationCore(
       resolvedStmt,
@@ -14161,16 +15169,27 @@ function hasCanonicalOrder(stmt) {
     (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
   );
 }
-async function assertDmlWhereCapability(stmt, client, cacheContext) {
-  if (stmt.subtableCode || stmt.type === "UPDATE" && stmt.from != null) return;
+async function resolveDmlWhereCapability(stmt, client, cacheContext) {
+  if (stmt.subtableCode || stmt.type === "UPDATE" && stmt.from != null) {
+    return {
+      capability: "LOCAL_ONLY",
+      reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }]
+    };
+  }
   const fields = whereNeedsFieldMetadata(stmt.where) ? await getFieldsCached(stmt.appId, client, cacheContext) : [];
   const byCode = new Map(fields.map((field) => [field.code, field]));
-  if (stmt.where.type === "BOOLEAN" && stmt.where.value === false) return;
-  const result = classifyWhereCapability(stmt.where, (field) => {
+  if (stmt.where.type === "BOOLEAN" && stmt.where.value === false) {
+    return classifyWhereCapability(null, () => void 0);
+  }
+  return classifyWhereCapability(stmt.where, (field) => {
     if (field.field === "$id") return resolveFieldSemantics({ fieldType: "__ID__" });
     const info = byCode.get(field.field);
     return info?.semantics ?? (info ? resolveFieldSemantics(info) : void 0);
   });
+}
+async function assertDmlWhereCapability(stmt, client, cacheContext) {
+  if (stmt.subtableCode || stmt.type === "UPDATE" && stmt.from != null) return;
+  const result = await resolveDmlWhereCapability(stmt, client, cacheContext);
   if (result.capability !== "EXACT_PUSHDOWN") {
     throw new DmlConvertError(
       `WHERE predicate cannot be represented by kintone REST (${formatWhereCapabilityFailure(result)})`
@@ -14192,6 +15211,14 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
   if (whereCapability.capability === "UNSUPPORTED") {
     throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(whereCapability)}).`);
   }
+  let prefilterPlan;
+  if (whereCapability.capability === "SUPERSET_PREFILTER") {
+    const resolver = await buildWhereFieldSemanticsResolver(stmt, client, cacheContext, cteCache);
+    const decomposition = decomposeRelativeDatePrefilter(stmt, resolver);
+    if (decomposition.eligible && allowRelativeDatePrefilterPlan(stmt, decomposition)) {
+      prefilterPlan = decomposition.plan;
+    }
+  }
   const staticMode = resolveSelectMode(stmt);
   const mode = whereCapability.capability === "EXACT_PUSHDOWN" ? staticMode : "FULL_SCAN";
   const orderMeta = await buildOrderByMetaForSelect(stmt, client, cacheContext, cteCache);
@@ -14199,6 +15226,7 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     stmt,
     staticMode: mode,
     whereCapability: whereCapability.capability,
+    whereReasons: whereCapability.reasons,
     orderSemantics: orderMeta.semantics,
     maxRecords: options.maxRecords ?? 1e4,
     hasKlike: whereHasKlike(stmt.where)
@@ -14221,7 +15249,8 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
         cacheContext,
         cteCache,
         whereCapability.capability === "EXACT_PUSHDOWN",
-        orderMeta
+        orderMeta,
+        prefilterPlan
       );
     }
   } catch (error) {
@@ -15139,7 +16168,7 @@ function buildSelectFieldTypeResolvers(stmt, fieldTypesByApp) {
   };
   return { row, having };
 }
-async function executeFullScanSelect(stmt, client, options, cacheContext, cteCache, allowOriginalWherePushdown = true, preloadedOrderMeta) {
+async function executeFullScanSelect(stmt, client, options, cacheContext, cteCache, allowOriginalWherePushdown = true, preloadedOrderMeta, prefilterPlan) {
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
   const parallel = options.fetchParallel ?? 1;
@@ -15165,6 +16194,10 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   validateKlikePushdownPlan(pushdownPlan);
   const mainPushDown = pushdownPlan.mainCondition;
   const tableConditions = pushdownPlan.joinConditions;
+  if (prefilterPlan && allowOriginalWherePushdown) {
+    throw new Error("internal error: relative-date prefilter must disable original WHERE pushdown.");
+  }
+  const mainFetchCondition = prefilterPlan ? prefilterPlan.prefilterWhere : mainPushDown;
   const constantFalse = isConstantFalseWhere(stmt.where);
   const mainFetch = constantFalse ? Promise.resolve([]) : fetchTableRecordsForFullScan(
     stmt,
@@ -15175,7 +16208,7 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     true,
     options.onLimitReached ?? "error",
     warnings,
-    mainPushDown,
+    mainFetchCondition,
     allowOriginalWherePushdown
   );
   const parallelJoins = [];
@@ -15256,7 +16289,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     havingFieldTypeResolver: fieldTypeResolvers.having,
     havingFieldSemanticsResolver,
     aggregateSortKindResolver,
-    appliedKlikes: pushdownPlan.appliedKlikes,
+    appliedKlikes: prefilterPlan?.appliedKlikes ?? pushdownPlan.appliedKlikes,
+    ...prefilterPlan ? { residualWhere: prefilterPlan.residualWhere } : {},
     resolvedGroupingSpec: resolvedGroupingSpecs.get(stmt)
   });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
@@ -15394,6 +16428,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     stmt,
     staticMode: "FULL_SCAN",
     whereCapability: whereCapability.capability,
+    whereReasons: whereCapability.reasons,
     orderSemantics: orderMeta.semantics,
     maxRecords,
     hasKlike: whereHasKlike(stmt.where)
@@ -18875,7 +19910,7 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
 }
 var validateExplainInfo = /* @__PURE__ */ new WeakMap();
 var applyParentExplainPlan = /* @__PURE__ */ new WeakMap();
-async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords = 1e4) {
+async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords = 1e4, relativeDatePlan) {
   const fieldApps = /* @__PURE__ */ new Set();
   const processStatusApps = /* @__PURE__ */ new Set();
   const numberPrecisionApps = /* @__PURE__ */ new Set();
@@ -18897,6 +19932,10 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
   const capabilities = /* @__PURE__ */ new Map();
   const orderPlans = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
+  const sharedRelativeDatePlan = relativeDatePlan ?? await resolveRelativeDateExecutionPlan(query, tracedClient, cacheContext);
+  const relativeNodeFor = (source) => sharedRelativeDatePlan.nodes.find(
+    (node) => node.source === source || JSON.stringify(node.source) === JSON.stringify(source)
+  );
   const visit = async (node) => {
     if (node === null || typeof node !== "object") return;
     if (seen.has(node)) return;
@@ -18915,7 +19954,8 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         physicalApps.forEach((appId) => fieldApps.add(appId));
       }
       const capability = await resolveSelectWhereCapability(select, tracedClient, cacheContext);
-      if (capability.capability === "UNSUPPORTED") {
+      const relativeNode = relativeNodeFor(select);
+      if (capability.capability === "UNSUPPORTED" && !relativeNode) {
         throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
       }
       capabilities.set(select, capability);
@@ -18929,12 +19969,13 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
           }
         }
         const hasUnmaterializedSource = [select.from, ...select.joins.map((join2) => join2.table)].some((table) => table.cteName !== null);
-        if (hasCanonicalOrder(select) && !hasUnmaterializedSource) {
+        if (hasCanonicalOrder(select) && !hasUnmaterializedSource && relativeNode?.allowed !== false) {
           const mode = capability.capability === "EXACT_PUSHDOWN" ? resolveSelectMode(select) : "FULL_SCAN";
           orderPlans.set(select, (select.orderMode === "KINTONE_NATIVE" ? planKorder : planCanonicalOrder)({
             stmt: select,
             staticMode: mode,
             whereCapability: capability.capability,
+            whereReasons: capability.reasons,
             orderSemantics: meta.semantics,
             maxRecords,
             hasKlike: whereHasKlike(select.where)
@@ -19010,7 +20051,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         }
       }
       const dml = node;
-      if (dml.type !== "UPDATE" || !usesApplyParentResidualSelection(dml)) {
+      if ((dml.type !== "UPDATE" || !usesApplyParentResidualSelection(dml)) && relativeNodeFor(dml)?.allowed !== false) {
         await assertDmlWhereCapability(dml, tracedClient, cacheContext);
       }
     }
@@ -19020,23 +20061,32 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
   if (typeof query === "object" && query !== null && query.type === "WITH" && canInlineSingleCte(query)) {
     const inlined = buildInlinedQuery(query);
     const capability = await resolveSelectWhereCapability(inlined, tracedClient, cacheContext);
-    if (capability.capability === "UNSUPPORTED") {
+    const relativeNode = relativeNodeFor(inlined);
+    if (capability.capability === "UNSUPPORTED" && !relativeNode) {
       throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
     }
     capabilities.set(inlined, capability);
-    if (hasCanonicalOrder(inlined)) {
+    if (hasCanonicalOrder(inlined) && relativeNode?.allowed !== false) {
       const meta = await buildOrderByMetaForSelect(inlined, tracedClient, cacheContext);
       orderPlans.set(inlined, (inlined.orderMode === "KINTONE_NATIVE" ? planKorder : planCanonicalOrder)({
         stmt: inlined,
         staticMode: capability.capability === "EXACT_PUSHDOWN" ? resolveSelectMode(inlined) : "FULL_SCAN",
         whereCapability: capability.capability,
+        whereReasons: capability.reasons,
         orderSemantics: meta.semantics,
         maxRecords,
         hasKlike: whereHasKlike(inlined.where)
       }));
     }
   }
-  return { capabilities, orderPlans, fieldApps, processStatusApps, numberPrecisionApps };
+  return {
+    capabilities,
+    orderPlans,
+    fieldApps,
+    processStatusApps,
+    numberPrecisionApps,
+    relativeDatePlan: sharedRelativeDatePlan
+  };
 }
 function explainMetadataLines(analysis) {
   return [
@@ -19045,6 +20095,158 @@ function explainMetadataLines(analysis) {
     ...[...analysis.numberPrecisionApps].sort((a, b) => a - b).map((appId) => `  metadata API: number precision APP${appId}`)
   ];
 }
+function renderResidualOperator(op) {
+  switch (op) {
+    case "NOT_LIKE":
+      return "NOT LIKE";
+    case "NOT_KLIKE":
+      return "NOT KLIKE";
+    case "NOT_IN":
+      return "NOT IN";
+    case "LIKE":
+    case "KLIKE":
+    case "IN":
+    case "=":
+    case "!=":
+    case "<>":
+    case ">":
+    case "<":
+    case ">=":
+    case "<=":
+      return op;
+    default:
+      return "<op>";
+  }
+}
+function relativeReasonOperator(op) {
+  return op === "<>" ? "!=" : op;
+}
+function renderResidualValue(node) {
+  if (node === null || typeof node !== "object") return "<expr>";
+  const value = node;
+  switch (value["type"]) {
+    case "FIELD":
+      return typeof value["field"] === "string" ? `${typeof value["tableAlias"] === "string" ? `${value["tableAlias"]}.` : ""}${value["field"]}` : "<expr>";
+    case "FIELD_REF":
+      return typeof value["field"] === "string" ? value["field"] : "<expr>";
+    case "NUMBER":
+      return typeof value["raw"] === "string" ? value["raw"] : typeof value["value"] === "number" ? String(value["value"]) : "<expr>";
+    case "STRING":
+      return typeof value["value"] === "string" ? `'${value["value"].replace(/'/g, "''")}'` : "<expr>";
+    case "VARIABLE":
+      return typeof value["name"] === "string" ? `@${value["name"]}` : "<expr>";
+    case "VARIABLE_IN_LIST":
+      return typeof value["name"] === "string" ? `@${value["name"]}` : "<expr>";
+    case "STRING_FUNC": {
+      if (typeof value["func"] !== "string" || !Array.isArray(value["args"])) return "<expr>";
+      return `${value["func"]}(${value["args"].map(renderResidualValue).join(", ")})`;
+    }
+    case "FUNC_FIELD":
+    case "ARITH_FIELD":
+    case "CASE_FIELD":
+    case "ARITH_VALUE":
+    case "CASE_VALUE":
+      return renderResidualValue(value["expr"]);
+    case "GROUPING_FIELD":
+      return `GROUPING(${renderResidualValue(value["ref"])})`;
+    case "GROUPING_REF":
+      return renderResidualValue(value["field"]);
+    case "ARITH":
+    case "SCALAR_ARITH":
+    case "CONCAT_OP":
+      return `(${renderResidualValue(value["left"])} ${typeof value["op"] === "string" ? value["op"] : value["type"] === "CONCAT_OP" ? "||" : "<op>"} ${renderResidualValue(value["right"])})`;
+    case "KINTONE_FUNC":
+      return typeof value["name"] === "string" ? `${value["name"]}(...)` : "<expr>";
+    case "IN_LIST":
+      return Array.isArray(value["values"]) ? `(${value["values"].map(renderResidualValue).join(", ")})` : "<expr>";
+    case "ARRAY":
+      return Array.isArray(value["elements"]) ? `[${value["elements"].map(renderResidualValue).join(", ")}]` : "<expr>";
+    case "CASE":
+    case "CASE_WHEN":
+      return "CASE ... END";
+    default:
+      return "<expr>";
+  }
+}
+function renderRelativeDateResidualWhere(where) {
+  try {
+    const node = where;
+    switch (node["type"]) {
+      case "BINARY":
+        return `${renderResidualValue(node["left"])} ${renderResidualOperator(node["op"])} ${renderResidualValue(node["right"])}`;
+      case "NULL_CHECK":
+        return `${renderResidualValue(node["field"])} IS ${node["not"] === true ? "NOT " : ""}NULL`;
+      case "LOGICAL":
+        return `(${renderRelativeDateResidualWhere(node["left"])} ${node["op"] === "AND" || node["op"] === "OR" ? node["op"] : "<op>"} ${renderRelativeDateResidualWhere(node["right"])})`;
+      case "NOT":
+        return `NOT (${renderRelativeDateResidualWhere(node["expr"])})`;
+      case "GROUP":
+        return `(${renderRelativeDateResidualWhere(node["expr"])})`;
+      case "BOOLEAN":
+        return node["value"] === true ? "TRUE" : node["value"] === false ? "FALSE" : "<expr>";
+      default:
+        return "<expr>";
+    }
+  } catch {
+    return "<expr>";
+  }
+}
+function relativeDateExplainLines(plan) {
+  if (!plan.hasRelativeDate) return [];
+  if (!plan.allowed && plan.rejection) {
+    return [
+      `  relative date function: ${plan.rejection.functionName}`,
+      "  plan status: rejected",
+      `  reason: ${plan.rejection.reasonCodes.join(", ")}`,
+      "  client evaluation: forbidden",
+      "  records/cursor/mutation API during EXPLAIN: none"
+    ];
+  }
+  const lines = [];
+  for (const node of plan.nodes) {
+    const prefilterPlan = node.prefilterPlan;
+    if (node.allowed && prefilterPlan?.prefilterWhere && prefilterPlan.residualWhere) {
+      for (const leaf of prefilterPlan.exactRelativeLeaves) {
+        const functionName = leaf.right.type === "KINTONE_FUNC" ? leaf.right.name : "(unknown)";
+        const field = leaf.left.type === "FIELD" ? leaf.left.field : void 0;
+        const operator = relativeReasonOperator(leaf.op);
+        const detail = node.capability?.reasons.find(
+          (reason) => reason.functionName === functionName && (field === void 0 || reason.field === field) && reason.operator === operator
+        );
+        lines.push(
+          `  relative date function: ${functionName}`,
+          "  relative date evaluation: kintone server exact prefilter",
+          `  field: ${detail?.field ?? field ?? "(unknown)"} (${detail?.fieldType ?? "unknown"})`,
+          `  operator: ${detail?.operator ?? operator}`
+        );
+      }
+      const serverPrefilter = whereToKintone(prefilterPlan.prefilterWhere);
+      lines.push(
+        "  where capability: SUPERSET_PREFILTER",
+        `  server prefilter: ${serverPrefilter}`,
+        `  client residual: ${renderRelativeDateResidualWhere(prefilterPlan.residualWhere)}`,
+        "  relative date client evaluations: 0",
+        `  kintone query: ${serverPrefilter}`
+      );
+      continue;
+    }
+    for (const functionName of node.functionNames) {
+      const detail = node.capability?.reasons.find(
+        (reason) => reason.functionName === functionName
+      );
+      lines.push(
+        `  relative date function: ${functionName}`,
+        "  evaluation: kintone server",
+        `  field: ${detail?.field ?? "(unknown)"} (${detail?.fieldType ?? "unknown"})`,
+        `  operator: ${detail?.operator ?? "(unknown)"}`,
+        `  where capability: ${node.capability?.capability ?? "(unknown)"}`,
+        "  client evaluation: forbidden",
+        `  kintone query: ${node.restQuery || "(\u306A\u3057)"}`
+      );
+    }
+  }
+  return lines;
+}
 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);
@@ -19055,15 +20257,25 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
     const stmt = statements[i];
     const planStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveBatchVariableReferences(stmt.expr, variables) } : stmt : resolveBatchVariableReferences(stmt, variables);
     validateKlikeStatement(planStmt);
-    const whereAnalysis = await buildExplainWhereAnalysis(planStmt, client, cacheContext, maxRecords);
-    const statementPlan = addCursorConcurrency(buildBatchStatementPlan(
+    const relativeDatePlan = await resolveRelativeDateExecutionPlan(planStmt, client, cacheContext);
+    const whereAnalysis = await buildExplainWhereAnalysis(
       planStmt,
-      analysis.statements[i],
-      whereAnalysis.capabilities,
-      whereAnalysis.orderPlans,
-      dmlMaxRows,
-      dmlMaxSubtableRows
-    ), cursorMaxActive);
+      client,
+      cacheContext,
+      maxRecords,
+      relativeDatePlan
+    );
+    const statementPlan = relativeDatePlan.hasRelativeDate && !relativeDatePlan.allowed ? relativeDateExplainLines(relativeDatePlan) : [
+      ...relativeDateExplainLines(relativeDatePlan),
+      ...addCursorConcurrency(buildBatchStatementPlan(
+        planStmt,
+        analysis.statements[i],
+        whereAnalysis.capabilities,
+        whereAnalysis.orderPlans,
+        dmlMaxRows,
+        dmlMaxSubtableRows
+      ), cursorMaxActive)
+    ];
     const metadataPlan = explainMetadataLines(whereAnalysis);
     plans.push({
       index: i,
@@ -19172,10 +20384,19 @@ function buildPlanForBatchQuery(query, info, capabilities, orderPlans) {
   lines.push("  note:          \u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u3078\u306E WHERE \u30D7\u30C3\u30B7\u30E5\u30C0\u30A6\u30F3\u306F\u884C\u308F\u308C\u306A\u3044");
   return lines;
 }
-async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxActive, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS) {
-  const analysis = await buildExplainWhereAnalysis(stmt.query, client, cacheContext, maxRecords);
-  const lines = [
+async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxActive, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, relativeDatePlan) {
+  const sharedPlan = relativeDatePlan ?? await resolveRelativeDateExecutionPlan(stmt.query, client, cacheContext);
+  const analysis = await buildExplainWhereAnalysis(
+    stmt.query,
+    client,
+    cacheContext,
+    maxRecords,
+    sharedPlan
+  );
+  const relativeLines = relativeDateExplainLines(sharedPlan);
+  const lines = sharedPlan.hasRelativeDate && !sharedPlan.allowed ? [...explainMetadataLines(analysis), ...relativeLines] : [
     ...explainMetadataLines(analysis),
+    ...relativeLines,
     ...addCursorConcurrency(
       buildExplainPlan(
         stmt.query,