@rex0220/kintone-sql-tools 3.19.0 → 3.20.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) {
@@ -11861,6 +12090,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 +12172,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 +12182,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 +12198,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 +12212,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 +12236,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 +12359,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 +12378,317 @@ 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) {
+  const functionNames = relativeDateFunctionNamesInWhere(select.where);
+  if (functionNames.length > 0) {
+    candidates.push({
+      kind: forceForbidden ? "FORBIDDEN" : "SELECT",
+      source: select,
+      where: select.where,
+      functionNames,
+      path
+    });
+  }
+  nestedSelects(select, select).forEach(
+    (nested, index) => collectSelect(nested, `${path}.select-source[${index}]`, candidates, forceForbidden)
+  );
+}
+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)
+      );
+      return;
+    }
+    default:
+      nestedSelects(statement, statement).forEach(
+        (select, index) => collectSelect(select, `${path}.select-source[${index}]`, candidates, forceForbidden)
+      );
+  }
+}
+function serializationContainsFunctions(query, names) {
+  return names.every((name) => new RegExp(`\\b${name}\\s*\\(`).test(query));
+}
+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 = "";
+      }
+      const allowed2 = physicalTopLevel && selectMode === "SIMPLE" && (select.orderBy.length === 0 || select.orderMode === "KINTONE_NATIVE") && capability2.capability === "EXACT_PUSHDOWN" && serializationContainsFunctions(restQuery2, candidate.functionNames);
+      const node2 = {
+        kind: candidate.kind,
+        source: candidate.source,
+        functionNames: candidate.functionNames,
+        path: candidate.path,
+        selectMode,
+        capability: capability2,
+        restQuery: restQuery2,
+        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/import/sourceLoader.ts
 var IMPORT_MAX_BYTES = 10 * 1024 * 1024;
@@ -13102,7 +13745,20 @@ 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)
+  });
+}
 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 +13820,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 +14205,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 +14262,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 +14820,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)})`
@@ -14199,6 +14869,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)
@@ -15394,6 +16065,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 +19547,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 +19569,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 +19591,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 +19606,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 +19688,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 +19698,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 +19732,36 @@ function explainMetadataLines(analysis) {
     ...[...analysis.numberPrecisionApps].sort((a, b) => a - b).map((appId) => `  metadata API: number precision APP${appId}`)
   ];
 }
+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) {
+    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 +19772,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 +19899,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,