@rex0220/kintone-sql-tools 3.59.0 → 3.61.0

package/dist-cli/ksql.js

@@ -3187,7 +3187,7 @@ var Parser = class {
       return { type: "BINARY", op: "KLIKE", left: field, right: pattern };
     }
     const op = this.parseCompareOp();
-    const right = this.parseWhereSqlValue();
+    const right = this.parseWhereSqlValue(op !== "LIKE");
     return { type: "BINARY", op, left: field, right };
   }
   parseCompareOp() {
@@ -3310,8 +3310,13 @@ var Parser = class {
     return { type: "FIELD", tableAlias: qi.tableAlias, field: qi.field };
   }
   // 右辺の値
-  parseWhereSqlValue() {
+  parseWhereSqlValue(allowUnaryPlusNumberLiteral = true) {
     const tok = this.peek();
+    if (allowUnaryPlusNumberLiteral && tok.kind === "+" /* PLUS */) {
+      this.advance();
+      const number = this.expect("NUMBER" /* NUMBER */, "\u5358\u9805 + \u306E\u76F4\u5F8C\u306B\u306F\u6570\u5024\u30EA\u30C6\u30E9\u30EB\u304C\u5FC5\u8981\u3067\u3059");
+      return makeNumberLiteral(`+${number.value}`);
+    }
     if (this.allowRelativeDateFunctions && tok.kind === "IDENT" /* IDENT */ && this.peekAt(1).kind === "(" /* LPAREN */ && isRelativeDateFunctionName(tok.value.toUpperCase())) {
       return this.parseRelativeDateFunction();
     }
@@ -12037,414 +12042,191 @@ function isOuterJoinNonPreservedTable(statement, table, isMainTable) {
   return false;
 }
 
-// src/core/explainMetadata.ts
-function buildGroupingExplainMetadata(statement, canonicalItemCount) {
-  const grouping = normalizeGroupingSpec(statement);
-  if (grouping.type !== "GROUPING_SETS") return null;
-  return {
-    source: grouping.source,
-    expandedSetCount: grouping.sets.length,
-    groupingItemCount: canonicalItemCount ?? grouping.allItems.length,
-    setLimit: B65_MAX_GROUPING_SETS,
-    itemLimit: B65_MAX_GROUPING_ITEMS,
-    outputRowLimit: B65_MAX_GENERATED_ROWS
-  };
+// src/core/optimization/joinDateTimeLiteralPolicy.ts
+function isCanonicalJoinDate(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return false;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (year < 1 || year > 9999) return false;
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(0, 0, 0, 0);
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
 }
-function whereNeedsFieldMetadata(where) {
-  if (where === null) return false;
-  switch (where.type) {
-    case "BINARY":
-      return valueNeedsFieldMetadata(where.left);
-    case "NULL_CHECK":
-      return valueNeedsFieldMetadata(where.field);
-    case "LOGICAL":
-      return whereNeedsFieldMetadata(where.left) || whereNeedsFieldMetadata(where.right);
-    case "NOT":
-    case "GROUP":
-      return whereNeedsFieldMetadata(where.expr);
-    case "EXISTS":
-    case "BOOLEAN":
-      return false;
-  }
+function isCanonicalJoinTime(value) {
+  const match = /^(\d{2}):(\d{2})$/.exec(value);
+  return match !== null && Number(match[1]) <= 23 && Number(match[2]) <= 59;
 }
-function valueNeedsFieldMetadata(value) {
-  if (Array.isArray(value)) return value.some(valueNeedsFieldMetadata);
-  if (value === null || typeof value !== "object") return false;
-  const item = value;
-  if (item["type"] === "FIELD") return item["field"] !== "$id";
-  if (item["type"] === "SELECT") return false;
-  return Object.values(item).some(valueNeedsFieldMetadata);
+function isCanonicalJoinDateTime(value) {
+  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/.exec(value);
+  if (!match || !isCanonicalJoinDate(match[1])) return false;
+  return Number(match[2]) <= 23 && Number(match[3]) <= 59 && Number(match[4]) <= 59;
 }
-function selectNeedsOwnMetadata(statement) {
-  return whereNeedsFieldMetadata(statement.where) || statement.groupBy.length > 0 || normalizeGroupingSpec(statement).type === "GROUPING_SETS" || statement.orderBy.length > 0 || statement.columns.some(
-    (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
-  );
+
+// 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 LEGACY_KINTONE_FUNCTION_FIELD_TYPES = /* @__PURE__ */ new Map([
+  ["TODAY", /* @__PURE__ */ new Set(["DATE", "DATETIME", "CREATED_TIME", "UPDATED_TIME"])],
+  ["NOW", /* @__PURE__ */ new Set(["DATETIME", "CREATED_TIME", "UPDATED_TIME"])],
+  ["LOGINUSER", /* @__PURE__ */ new Set(["CREATOR", "MODIFIER", "USER_SELECT"])],
+  ["PRIMARY_ORGANIZATION", /* @__PURE__ */ new Set(["ORGANIZATION_SELECT"])]
+]);
+var LEGACY_KINTONE_FUNCTION_OPERATORS = /* @__PURE__ */ new Map([
+  ["TODAY", new Set(RANGE_AND_EQUALITY)],
+  ["NOW", new Set(RANGE_AND_EQUALITY)],
+  ["LOGINUSER", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["PRIMARY_ORGANIZATION", /* @__PURE__ */ new Set(["in", "not in"])]
+]);
+var EQUALITY_IN = ["=", "!=", "in", "not in"];
+var NATIVE_OPERATORS = /* @__PURE__ */ new Map([
+  ["RECORD_NUMBER", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
+  ["__ID__", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
+  ["CREATOR", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["MODIFIER", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["CREATED_TIME", new Set(RANGE_AND_EQUALITY)],
+  ["UPDATED_TIME", new Set(RANGE_AND_EQUALITY)],
+  ["DATE", new Set(RANGE_AND_EQUALITY)],
+  ["TIME", new Set(RANGE_AND_EQUALITY)],
+  ["DATETIME", new Set(RANGE_AND_EQUALITY)],
+  ["SINGLE_LINE_TEXT", /* @__PURE__ */ new Set(["=", "!=", "in", "not in", "like", "not like"])],
+  ["LINK", /* @__PURE__ */ new Set(["=", "!=", "in", "not in", "like", "not like"])],
+  ["NUMBER", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
+  ["CALC", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
+  ["MULTI_LINE_TEXT", /* @__PURE__ */ new Set(["like", "not like"])],
+  ["RICH_TEXT", /* @__PURE__ */ new Set(["like", "not like"])],
+  ["CHECK_BOX", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["RADIO_BUTTON", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["DROP_DOWN", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["MULTI_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["FILE", /* @__PURE__ */ new Set(["like", "not like"])],
+  ["USER_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["ORGANIZATION_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["GROUP_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["STATUS", new Set(EQUALITY_IN)],
+  ["STATUS_ASSIGNEE", /* @__PURE__ */ new Set(["in", "not in"])]
+]);
+var LOCAL_VALID_OPERATORS = /* @__PURE__ */ new Map([
+  ["CREATOR", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["MODIFIER", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["CHECK_BOX", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["MULTI_SELECT", /* @__PURE__ */ new Set(["in", "not in"])]
+]);
+var LOCAL_SCALAR_TYPES = /* @__PURE__ */ new Set([
+  "RECORD_NUMBER",
+  "__ID__",
+  "CREATOR",
+  "MODIFIER",
+  "CREATED_TIME",
+  "UPDATED_TIME",
+  "DATE",
+  "TIME",
+  "DATETIME",
+  "SINGLE_LINE_TEXT",
+  "LINK",
+  "NUMBER",
+  "CALC",
+  "MULTI_LINE_TEXT",
+  "RICH_TEXT",
+  "RADIO_BUTTON",
+  "DROP_DOWN",
+  "STATUS",
+  // 一時表・CTE・式列は kintone REST へは送らず、共有ローカル評価器で扱う。
+  "KSQL_STRING",
+  "KSQL_NUMBER",
+  "KSQL_BOOLEAN"
+]);
+var LOCAL_COLLECTION_TYPES = /* @__PURE__ */ new Set([
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "FILE",
+  "USER_SELECT",
+  "ORGANIZATION_SELECT",
+  "GROUP_SELECT",
+  "STATUS_ASSIGNEE",
+  "CATEGORY"
+]);
+function nativeWhereOperatorsForType(fieldType) {
+  return NATIVE_OPERATORS.get(fieldType) ?? /* @__PURE__ */ new Set();
 }
-function explainNeedsAppMetadata(statement) {
-  const seen = /* @__PURE__ */ new Set();
+function normalizeChoiceEquality(where, resolveField2) {
+  const rewrites = [];
   const visit = (node) => {
-    if (node === null || typeof node !== "object") return false;
-    if (seen.has(node)) return false;
-    seen.add(node);
-    if (Array.isArray(node)) return node.some(visit);
-    const item = node;
-    if (item["type"] === "VALIDATE") return true;
-    if (item["type"] === "SELECT" && selectNeedsOwnMetadata(node)) {
-      return true;
+    if (node.type === "BINARY") {
+      if ((node.op === "=" || node.op === "!=" || node.op === "<>") && node.left.type === "FIELD" && node.right.type === "STRING" && node.right.value !== "") {
+        const semantics = resolveField2(node.left);
+        if (semantics !== void 0 && semantics.compareMode === "option" && LOCAL_SCALAR_TYPES.has(semantics.fieldType) && nativeWhereOperatorsForType(semantics.fieldType).has("in") && semantics.optionOrder?.has(node.right.value) === true) {
+          const normalizedOperator = node.op === "=" ? "IN" : "NOT_IN";
+          rewrites.push({
+            field: node.left,
+            originalOperator: node.op,
+            normalizedOperator,
+            value: node.right.value
+          });
+          return {
+            ...node,
+            op: normalizedOperator,
+            right: { type: "IN_LIST", values: [node.right] }
+          };
+        }
+      }
+      return node;
     }
-    if ((item["type"] === "UPDATE" || item["type"] === "DELETE") && whereNeedsFieldMetadata(node.where)) {
-      return true;
+    if (node.type === "LOGICAL") {
+      const left = visit(node.left);
+      const right = visit(node.right);
+      return left === node.left && right === node.right ? node : { ...node, left, right };
     }
-    if (item["type"] === "UPDATE" && Array.isArray(item["applyBlocks"]) && item["applyBlocks"].length > 0) return true;
-    return Object.values(item).some(visit);
+    if (node.type === "GROUP" || node.type === "NOT") {
+      const expr = visit(node.expr);
+      return expr === node.expr ? node : { ...node, expr };
+    }
+    return node;
   };
-  return visit(statement);
+  return { normalizedWhere: visit(where), rewrites };
 }
-
-// src/api/fetchAll.ts
-async function fetchAll(fetcher, app, query, fields, options = {}) {
-  const pageSize = options.pageSize ?? PAGE_SIZE_DEFAULT;
-  const parallel = Math.max(1, options.parallel ?? PARALLEL_DEFAULT);
-  const maxRecords = options.maxRecords ?? MAX_RECORDS_DEFAULT;
-  const onLimit = options.onLimit ?? "error";
-  const stopAfter = options.stopAfter;
-  if (stopAfter !== void 0 && (!Number.isSafeInteger(stopAfter) || stopAfter <= 0 || stopAfter > maxRecords)) {
-    throw new RangeError("stopAfter must be a positive safe integer <= maxRecords");
-  }
-  const fetchCap = stopAfter ?? maxRecords;
-  const fetchFields = fields.length > 0 && !fields.includes("$id") ? [...fields, "$id"] : fields;
-  const allRecords = [];
-  let notified = false;
-  const limitMessage = `\u53D6\u5F97\u4EF6\u6570\u304C\u4E0A\u9650\uFF08${maxRecords} \u4EF6\uFF09\u3092\u8D85\u3048\u307E\u3057\u305F\u3002WHERE \u53E5\u3067\u7D5E\u308A\u8FBC\u3080\u304B\u3001maxRecords \u3092\u5F15\u304D\u4E0A\u3052\u3066\u304F\u3060\u3055\u3044\u3002`;
-  let cursorId = 0;
-  let windowOffset = 0;
-  const cursorQuery0 = buildCursorQuery(query, cursorId);
-  const first = await fetchPage(fetcher, app, cursorQuery0, fetchFields, pageSize, windowOffset);
-  notifySearchAborted(first, options);
-  allRecords.push(...first.records);
-  if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
-    return allRecords.slice(0, stopAfter);
+function classifyWhereCapability(where, resolveField2) {
+  if (where === null) {
+    return { capability: "EXACT_PUSHDOWN", reasons: [{ code: "WHERE_EXACT" }] };
   }
-  if (allRecords.length > maxRecords) {
-    if (onLimit === "truncate") {
-      if (!notified && options.onTruncate) {
-        options.onTruncate(maxRecords);
-        notified = true;
+  return classifyNode(where, resolveField2);
+}
+function classifyNode(where, resolveField2) {
+  switch (where.type) {
+    case "BOOLEAN":
+      return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
+    case "BINARY":
+      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);
+    case "EXISTS":
+      return localExpression();
+    case "GROUP":
+      return classifyNode(where.expr, resolveField2);
+    case "NOT": {
+      const inner = classifyNode(where.expr, resolveField2);
+      if (inner.capability !== "SUPERSET_PREFILTER") return inner;
+      if (!hasRelativeDateReason(inner.reasons)) {
+        return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
       }
-      return allRecords.slice(0, maxRecords);
-    }
-    throw new FetchAllLimitError(limitMessage);
-  }
-  if (first.records.length < pageSize) return allRecords;
-  windowOffset += pageSize;
-  if (windowOffset >= KINTONE_MAX_OFFSET) {
-    cursorId = getLastId(first.records);
-    windowOffset = 0;
-  }
-  while (true) {
-    if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
-      return allRecords.slice(0, stopAfter);
-    }
-    if (allRecords.length >= maxRecords) {
-      if (onLimit === "truncate") {
-        if (!notified && options.onTruncate) {
-          options.onTruncate(maxRecords);
-          notified = true;
-        }
-        return allRecords.slice(0, maxRecords);
-      }
-      throw new FetchAllLimitError(limitMessage);
-    }
-    const remaining = fetchCap - allRecords.length;
-    const maxPagesByLimit = Math.ceil(remaining / pageSize);
-    const batchParallel = Math.max(1, Math.min(parallel, maxPagesByLimit));
-    const batchOffsets = [];
-    for (let i = 0; i < batchParallel; i++) {
-      const off = windowOffset + i * pageSize;
-      if (off >= KINTONE_MAX_OFFSET) break;
-      batchOffsets.push(off);
-    }
-    const cq = buildCursorQuery(query, cursorId);
-    const responses = await Promise.all(
-      batchOffsets.map(
-        (offset) => fetchPage(fetcher, app, cq, fetchFields, pageSize, offset)
-      )
-    );
-    for (const response of responses) notifySearchAborted(response, options);
-    let done = false;
-    for (const res of responses) {
-      allRecords.push(...res.records);
-      if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
-        return allRecords.slice(0, stopAfter);
-      }
-      if (allRecords.length > maxRecords) {
-        if (onLimit === "truncate") {
-          if (!notified && options.onTruncate) {
-            options.onTruncate(maxRecords);
-            notified = true;
-          }
-          return allRecords.slice(0, maxRecords);
-        }
-        throw new FetchAllLimitError(limitMessage);
-      }
-      if (res.records.length < pageSize) {
-        done = true;
-        break;
-      }
-    }
-    if (done) break;
-    windowOffset += pageSize * batchOffsets.length;
-    if (windowOffset >= KINTONE_MAX_OFFSET) {
-      const lastRes = responses[responses.length - 1];
-      cursorId = getLastId(lastRes.records);
-      windowOffset = 0;
-    }
-  }
-  return allRecords;
-}
-function notifySearchAborted(response, options) {
-  if (response.searchAborted) options.onSearchAborted?.();
-}
-function extractIds(records) {
-  return records.map((r) => {
-    const raw = r["$id"]?.value;
-    if (raw === void 0) {
-      throw new Error(
-        '\u30EC\u30B3\u30FC\u30C9\u306B $id \u30D5\u30A3\u30FC\u30EB\u30C9\u304C\u542B\u307E\u308C\u3066\u3044\u307E\u305B\u3093\u3002fields \u306B "$id" \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002'
-      );
-    }
-    const id = Number(raw);
-    if (!Number.isFinite(id)) {
-      throw new Error(`$id \u306E\u5024\u304C\u6570\u5024\u3067\u306F\u3042\u308A\u307E\u305B\u3093: ${raw}`);
-    }
-    return id;
-  });
-}
-var PAGE_SIZE_DEFAULT = 500;
-var PARALLEL_DEFAULT = 1;
-var MAX_RECORDS_DEFAULT = 1e4;
-var KINTONE_MAX_OFFSET = 1e4;
-async function fetchPage(fetcher, app, query, fields, pageSize, offset) {
-  const pageQuery = buildPageQuery(query, pageSize, offset);
-  return fetcher({ app, query: pageQuery, fields });
-}
-function buildCursorQuery(baseQuery, cursorId) {
-  const base = baseQuery.trimEnd();
-  if (cursorId <= 0) {
-    return base ? `${base} order by $id asc` : "order by $id asc";
-  }
-  const cursor = `$id > ${cursorId} order by $id asc`;
-  return base ? `(${base}) and ${cursor}` : cursor;
-}
-function buildPageQuery(query, pageSize, offset) {
-  const base = query.trimEnd();
-  const suffix = `limit ${pageSize} offset ${offset}`;
-  return base ? `${base} ${suffix}` : suffix;
-}
-function getLastId(records) {
-  const last = records[records.length - 1];
-  const raw = last?.["$id"]?.value;
-  if (raw === void 0) return 0;
-  const id = Number(raw);
-  return Number.isFinite(id) ? id : 0;
-}
-var FetchAllLimitError = class extends Error {
-  constructor(message, completeInputWrapped = false) {
-    super(message);
-    this.completeInputWrapped = completeInputWrapped;
-    this.name = "FetchAllLimitError";
-  }
-};
-
-// src/core/optimization/sharedPlanner.ts
-async function fetchRecordsForSharedPlan(getRecords, app, query, fields, options) {
-  const records = await fetchAll(getRecords, app, query, fields, {
-    maxRecords: options.maxRecords,
-    parallel: options.parallel,
-    onLimit: options.onLimit ?? "error",
-    onTruncate: options.onTruncate,
-    onSearchAborted: options.onSearchAborted
-  });
-  return {
-    records,
-    metrics: { fetchedRows: records.length }
-  };
-}
-async function resolveDmlTargetIds(getRecords, app, query, options) {
-  const { records, metrics } = await fetchRecordsForSharedPlan(
-    getRecords,
-    app,
-    query,
-    ["$id"],
-    options
-  );
-  return {
-    ids: extractIds(records),
-    metrics
-  };
-}
-
-// 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 LEGACY_KINTONE_FUNCTION_FIELD_TYPES = /* @__PURE__ */ new Map([
-  ["TODAY", /* @__PURE__ */ new Set(["DATE", "DATETIME", "CREATED_TIME", "UPDATED_TIME"])],
-  ["NOW", /* @__PURE__ */ new Set(["DATETIME", "CREATED_TIME", "UPDATED_TIME"])],
-  ["LOGINUSER", /* @__PURE__ */ new Set(["CREATOR", "MODIFIER", "USER_SELECT"])],
-  ["PRIMARY_ORGANIZATION", /* @__PURE__ */ new Set(["ORGANIZATION_SELECT"])]
-]);
-var LEGACY_KINTONE_FUNCTION_OPERATORS = /* @__PURE__ */ new Map([
-  ["TODAY", new Set(RANGE_AND_EQUALITY)],
-  ["NOW", new Set(RANGE_AND_EQUALITY)],
-  ["LOGINUSER", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["PRIMARY_ORGANIZATION", /* @__PURE__ */ new Set(["in", "not in"])]
-]);
-var EQUALITY_IN = ["=", "!=", "in", "not in"];
-var NATIVE_OPERATORS = /* @__PURE__ */ new Map([
-  ["RECORD_NUMBER", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
-  ["__ID__", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
-  ["CREATOR", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["MODIFIER", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["CREATED_TIME", new Set(RANGE_AND_EQUALITY)],
-  ["UPDATED_TIME", new Set(RANGE_AND_EQUALITY)],
-  ["DATE", new Set(RANGE_AND_EQUALITY)],
-  ["TIME", new Set(RANGE_AND_EQUALITY)],
-  ["DATETIME", new Set(RANGE_AND_EQUALITY)],
-  ["SINGLE_LINE_TEXT", /* @__PURE__ */ new Set(["=", "!=", "in", "not in", "like", "not like"])],
-  ["LINK", /* @__PURE__ */ new Set(["=", "!=", "in", "not in", "like", "not like"])],
-  ["NUMBER", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
-  ["CALC", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
-  ["MULTI_LINE_TEXT", /* @__PURE__ */ new Set(["like", "not like"])],
-  ["RICH_TEXT", /* @__PURE__ */ new Set(["like", "not like"])],
-  ["CHECK_BOX", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["RADIO_BUTTON", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["DROP_DOWN", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["MULTI_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["FILE", /* @__PURE__ */ new Set(["like", "not like"])],
-  ["USER_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["ORGANIZATION_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["GROUP_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["STATUS", new Set(EQUALITY_IN)]
-]);
-var LOCAL_VALID_OPERATORS = /* @__PURE__ */ new Map([
-  ["CREATOR", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["MODIFIER", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["CHECK_BOX", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["MULTI_SELECT", /* @__PURE__ */ new Set(["in", "not in"])]
-]);
-var LOCAL_SCALAR_TYPES = /* @__PURE__ */ new Set([
-  "RECORD_NUMBER",
-  "__ID__",
-  "CREATOR",
-  "MODIFIER",
-  "CREATED_TIME",
-  "UPDATED_TIME",
-  "DATE",
-  "TIME",
-  "DATETIME",
-  "SINGLE_LINE_TEXT",
-  "LINK",
-  "NUMBER",
-  "CALC",
-  "MULTI_LINE_TEXT",
-  "RICH_TEXT",
-  "RADIO_BUTTON",
-  "DROP_DOWN",
-  "STATUS",
-  // 一時表・CTE・式列は kintone REST へは送らず、共有ローカル評価器で扱う。
-  "KSQL_STRING",
-  "KSQL_NUMBER",
-  "KSQL_BOOLEAN"
-]);
-var LOCAL_COLLECTION_TYPES = /* @__PURE__ */ new Set([
-  "CHECK_BOX",
-  "MULTI_SELECT",
-  "FILE",
-  "USER_SELECT",
-  "ORGANIZATION_SELECT",
-  "GROUP_SELECT",
-  "STATUS_ASSIGNEE",
-  "CATEGORY"
-]);
-function nativeWhereOperatorsForType(fieldType) {
-  return NATIVE_OPERATORS.get(fieldType) ?? /* @__PURE__ */ new Set();
-}
-function normalizeChoiceEquality(where, resolveField2) {
-  const rewrites = [];
-  const visit = (node) => {
-    if (node.type === "BINARY") {
-      if ((node.op === "=" || node.op === "!=" || node.op === "<>") && node.left.type === "FIELD" && node.right.type === "STRING" && node.right.value !== "") {
-        const semantics = resolveField2(node.left);
-        if (semantics !== void 0 && semantics.compareMode === "option" && LOCAL_SCALAR_TYPES.has(semantics.fieldType) && nativeWhereOperatorsForType(semantics.fieldType).has("in") && semantics.optionOrder?.has(node.right.value) === true) {
-          const normalizedOperator = node.op === "=" ? "IN" : "NOT_IN";
-          rewrites.push({
-            field: node.left,
-            originalOperator: node.op,
-            normalizedOperator,
-            value: node.right.value
-          });
-          return {
-            ...node,
-            op: normalizedOperator,
-            right: { type: "IN_LIST", values: [node.right] }
-          };
-        }
-      }
-      return node;
-    }
-    if (node.type === "LOGICAL") {
-      const left = visit(node.left);
-      const right = visit(node.right);
-      return left === node.left && right === node.right ? node : { ...node, left, right };
-    }
-    if (node.type === "GROUP" || node.type === "NOT") {
-      const expr = visit(node.expr);
-      return expr === node.expr ? node : { ...node, expr };
-    }
-    return node;
-  };
-  return { normalizedWhere: visit(where), rewrites };
-}
-function classifyWhereCapability(where, resolveField2) {
-  if (where === null) {
-    return { capability: "EXACT_PUSHDOWN", reasons: [{ code: "WHERE_EXACT" }] };
-  }
-  return classifyNode(where, resolveField2);
-}
-function classifyNode(where, resolveField2) {
-  switch (where.type) {
-    case "BOOLEAN":
-      return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
-    case "BINARY":
-      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);
-    case "EXISTS":
-      return localExpression();
-    case "GROUP":
-      return classifyNode(where.expr, resolveField2);
-    case "NOT": {
-      const inner = classifyNode(where.expr, resolveField2);
-      if (inner.capability !== "SUPERSET_PREFILTER") return inner;
-      if (!hasRelativeDateReason(inner.reasons)) {
-        return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
-      }
-      return requireExactFunctionPushdown({
-        capability: "LOCAL_ONLY",
-        reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }, ...inner.reasons]
-      });
-    }
-    case "LOGICAL": {
-      const left = classifyNode(where.left, resolveField2);
-      const right = classifyNode(where.right, resolveField2);
-      return combineLogical(where.op, left, right);
+      return requireExactFunctionPushdown({
+        capability: "LOCAL_ONLY",
+        reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }, ...inner.reasons]
+      });
+    }
+    case "LOGICAL": {
+      const left = classifyNode(where.left, resolveField2);
+      const right = classifyNode(where.right, resolveField2);
+      return combineLogical(where.op, left, right);
     }
   }
 }
@@ -12505,24 +12287,68 @@ function classifyBinary(op, left, right, resolveField2) {
     };
   }
   return {
-    capability: "LOCAL_ONLY",
+    capability: "LOCAL_ONLY",
+    reasons: [{
+      code: "WHERE_RESIDUAL",
+      field: left.field,
+      fieldType: semantics.fieldType,
+      operator: nativeOp
+    }]
+  };
+}
+function isLegacyKintoneFunction(value) {
+  return value.type === "KINTONE_FUNC" && LEGACY_KINTONE_FUNCTION_NAMES.has(value.name);
+}
+function classifyLegacyKintoneFunctionBinary(op, left, right, resolveField2) {
+  const operator = normalizeOperator(op);
+  const functionName = right.name;
+  if (!LEGACY_KINTONE_FUNCTION_NAMES.has(functionName) || left.type !== "FIELD") {
+    return legacyKintoneFunctionUnsupported(
+      "WHERE_KINTONE_FUNCTION_CONTEXT_UNSUPPORTED",
+      functionName,
+      void 0,
+      void 0,
+      operator
+    );
+  }
+  const semantics = resolveField2(left);
+  const validFieldTypes = LEGACY_KINTONE_FUNCTION_FIELD_TYPES.get(functionName);
+  if (!semantics || !validFieldTypes.has(semantics.fieldType) || semantics.inSubtable || semantics.requiresCollectionOperators) {
+    return legacyKintoneFunctionUnsupported(
+      "WHERE_KINTONE_FUNCTION_FIELD_TYPE_UNSUPPORTED",
+      functionName,
+      left.field,
+      semantics?.fieldType,
+      operator
+    );
+  }
+  const validOperators = LEGACY_KINTONE_FUNCTION_OPERATORS.get(functionName);
+  if (!validOperators.has(operator)) {
+    return legacyKintoneFunctionUnsupported(
+      "WHERE_KINTONE_FUNCTION_OPERATOR_UNSUPPORTED",
+      functionName,
+      left.field,
+      semantics.fieldType,
+      operator
+    );
+  }
+  return {
+    capability: "EXACT_PUSHDOWN",
     reasons: [{
-      code: "WHERE_RESIDUAL",
+      code: "WHERE_EXACT",
+      functionName,
       field: left.field,
       fieldType: semantics.fieldType,
-      operator: nativeOp
+      operator
     }]
   };
 }
-function isLegacyKintoneFunction(value) {
-  return value.type === "KINTONE_FUNC" && LEGACY_KINTONE_FUNCTION_NAMES.has(value.name);
-}
-function classifyLegacyKintoneFunctionBinary(op, left, right, resolveField2) {
+function classifyRelativeDateBinary(op, left, right, resolveField2) {
   const operator = normalizeOperator(op);
   const functionName = right.name;
-  if (!LEGACY_KINTONE_FUNCTION_NAMES.has(functionName) || left.type !== "FIELD") {
-    return legacyKintoneFunctionUnsupported(
-      "WHERE_KINTONE_FUNCTION_CONTEXT_UNSUPPORTED",
+  if (left.type !== "FIELD") {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_CONTEXT_UNSUPPORTED",
       functionName,
       void 0,
       void 0,
@@ -12530,258 +12356,567 @@ function classifyLegacyKintoneFunctionBinary(op, left, right, resolveField2) {
     );
   }
   const semantics = resolveField2(left);
-  const validFieldTypes = LEGACY_KINTONE_FUNCTION_FIELD_TYPES.get(functionName);
-  if (!semantics || !validFieldTypes.has(semantics.fieldType) || semantics.inSubtable || semantics.requiresCollectionOperators) {
-    return legacyKintoneFunctionUnsupported(
-      "WHERE_KINTONE_FUNCTION_FIELD_TYPE_UNSUPPORTED",
+  if (!semantics) {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_FIELD_TYPE_UNSUPPORTED",
       functionName,
       left.field,
-      semantics?.fieldType,
+      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);
+  if (!isLocallyValidOperator(semantics.fieldType, operator)) {
+    return unsupported2(
+      "WHERE_OPERATOR_INVALID_FOR_FIELD_TYPE",
+      field.field,
+      semantics.fieldType,
       operator
     );
   }
-  const validOperators = LEGACY_KINTONE_FUNCTION_OPERATORS.get(functionName);
-  if (!validOperators.has(operator)) {
-    return legacyKintoneFunctionUnsupported(
-      "WHERE_KINTONE_FUNCTION_OPERATOR_UNSUPPORTED",
-      functionName,
-      left.field,
-      semantics.fieldType,
-      operator
-    );
+  if (!LOCAL_SCALAR_TYPES.has(semantics.fieldType) && !LOCAL_COLLECTION_TYPES.has(semantics.fieldType)) {
+    return unsupported2("WHERE_OPERATOR_UNSUPPORTED", field.field, semantics.fieldType, operator);
+  }
+  return {
+    capability: "LOCAL_ONLY",
+    reasons: [{ code: "WHERE_RESIDUAL", field: field.field, fieldType: semantics.fieldType, operator }]
+  };
+}
+function isLocallyValidOperator(fieldType, operator) {
+  const policy = LOCAL_VALID_OPERATORS.get(fieldType);
+  return policy === void 0 || policy.has(operator);
+}
+function hasLocalContract(fieldType, op) {
+  if (LOCAL_SCALAR_TYPES.has(fieldType)) return true;
+  if (!LOCAL_COLLECTION_TYPES.has(fieldType)) return false;
+  return op === "=" || op === "!=" || op === "<>" || op === "IN" || op === "NOT_IN" || op === "LIKE" || op === "NOT_LIKE" || op === "KLIKE" || op === "NOT_KLIKE";
+}
+function normalizeOperator(op) {
+  switch (op) {
+    case "<>":
+      return "!=";
+    case "IN":
+      return "in";
+    case "NOT_IN":
+      return "not in";
+    case "LIKE":
+    case "KLIKE":
+      return "like";
+    case "NOT_LIKE":
+    case "NOT_KLIKE":
+      return "not like";
+    default:
+      return op;
+  }
+}
+function combineLogical(op, left, right) {
+  const reasons = [...left.reasons, ...right.reasons];
+  if (left.capability === "UNSUPPORTED" || right.capability === "UNSUPPORTED") {
+    return requireExactFunctionPushdown({ capability: "UNSUPPORTED", reasons });
+  }
+  if (left.capability === "EXACT_PUSHDOWN" && right.capability === "EXACT_PUSHDOWN") {
+    return { capability: "EXACT_PUSHDOWN", reasons };
+  }
+  if (op === "AND" && (left.capability === "EXACT_PUSHDOWN" || right.capability === "EXACT_PUSHDOWN" || left.capability === "SUPERSET_PREFILTER" || right.capability === "SUPERSET_PREFILTER")) {
+    return requireExactFunctionPushdown({
+      capability: "SUPERSET_PREFILTER",
+      reasons: [{ code: "WHERE_SUPERSET_PREFILTER" }, ...reasons]
+    });
+  }
+  return requireExactFunctionPushdown({ capability: "LOCAL_ONLY", reasons });
+}
+function localExpression() {
+  return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
+}
+function unsupported2(code, field, fieldType, operator) {
+  return { capability: "UNSUPPORTED", reasons: [{ code, field, fieldType, operator }] };
+}
+function legacyKintoneFunctionUnsupported(code, functionName, field, fieldType, operator) {
+  return requireExactFunctionPushdown({
+    capability: "UNSUPPORTED",
+    reasons: [{ code, functionName, field, fieldType, operator }]
+  });
+}
+function relativeDateUnsupported(code, functionName, field, fieldType, operator) {
+  return requireExactRelativeDatePushdown({
+    capability: "UNSUPPORTED",
+    reasons: [{ code, functionName, field, fieldType, operator }]
+  });
+}
+function hasRelativeDateReason(reasons) {
+  return reasons.some(
+    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
+  );
+}
+function hasLegacyKintoneFunctionReason(reasons) {
+  return reasons.some(
+    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
+  );
+}
+function requireExactRelativeDatePushdown(result) {
+  if (result.capability === "EXACT_PUSHDOWN" || !hasRelativeDateReason(result.reasons) || result.reasons.some((reason) => reason.code === "WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN")) {
+    return result;
+  }
+  const relative = result.reasons.find(
+    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
+  );
+  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
+      }
+    ]
+  };
+}
+function requireExactLegacyKintoneFunctionPushdown(result) {
+  if (result.capability === "EXACT_PUSHDOWN" || !hasLegacyKintoneFunctionReason(result.reasons) || result.reasons.some(
+    (reason) => reason.code === "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN"
+  )) {
+    return result;
+  }
+  const legacy = result.reasons.find(
+    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
+  );
+  return {
+    capability: result.capability,
+    reasons: [
+      ...result.reasons,
+      {
+        code: "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN",
+        functionName: legacy.functionName,
+        field: legacy.field,
+        fieldType: legacy.fieldType,
+        operator: legacy.operator
+      }
+    ]
+  };
+}
+function requireExactFunctionPushdown(result) {
+  return requireExactLegacyKintoneFunctionPushdown(
+    requireExactRelativeDatePushdown(result)
+  );
+}
+
+// src/core/optimization/joinKeyPrefilter.ts
+var JOIN_KEY_IN_CHUNK_SIZE = 50;
+function buildJoinKeyPrefilterQueries(plan, field, quoteValue) {
+  if (plan.kind === "RANGE") {
+    return [`${field} >= ${quoteValue(plan.min)} and ${field} <= ${quoteValue(plan.max)}`];
+  }
+  if (plan.kind !== "IN") return [];
+  const queries = [];
+  for (let offset = 0; offset < plan.values.length; offset += JOIN_KEY_IN_CHUNK_SIZE) {
+    const chunk3 = plan.values.slice(offset, offset + JOIN_KEY_IN_CHUNK_SIZE);
+    queries.push(`${field} in (${chunk3.map(quoteValue).join(",")})`);
+  }
+  return queries;
+}
+var DATETIME_TYPES = /* @__PURE__ */ new Set(["DATETIME", "CREATED_TIME", "UPDATED_TIME"]);
+var JOIN_KEY_EMPTY_IN_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "SINGLE_LINE_TEXT",
+  "LINK",
+  "NUMBER",
+  "CALC",
+  "DROP_DOWN",
+  "RADIO_BUTTON",
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "STATUS"
+]);
+function canonicalFor(fieldType, value) {
+  if (fieldType === "DATE") return isCanonicalJoinDate(value);
+  if (fieldType === "TIME") return isCanonicalJoinTime(value);
+  if (DATETIME_TYPES.has(fieldType)) return isCanonicalJoinDateTime(value);
+  return false;
+}
+function semanticsMatch(fieldType, semantics) {
+  if (!semantics || semantics.compareMode !== "string") return false;
+  if (fieldType === "DATE") return semantics.fieldType === "DATE";
+  if (fieldType === "TIME") return semantics.fieldType === "TIME";
+  if (DATETIME_TYPES.has(fieldType)) return DATETIME_TYPES.has(semantics.fieldType);
+  return false;
+}
+function planJoinKeyPrefilter(input) {
+  if (input.sourceRowCount === 0) return { kind: "EMPTY_SOURCE" };
+  if (!input.fieldType) {
+    return { kind: "FALLBACK", reason: "JOIN_KEY_FIELD_TYPE_UNRESOLVED" };
+  }
+  const operators = nativeWhereOperatorsForType(input.fieldType);
+  if (operators.has("in")) {
+    if (input.values === void 0) {
+      return { kind: "FALLBACK", reason: "JOIN_KEY_VALUES_RUNTIME" };
+    }
+    if (input.hasEmptyValue && !JOIN_KEY_EMPTY_IN_FIELD_TYPES.has(input.fieldType)) {
+      return { kind: "FALLBACK", reason: "JOIN_KEY_EMPTY_VALUE" };
+    }
+    const values2 = [...new Set(input.values)];
+    if (values2.length === 0) return { kind: "EMPTY_SOURCE" };
+    if (values2.length > input.maxInKeys) {
+      return { kind: "FALLBACK", reason: "JOIN_KEY_LIMIT_EXCEEDED" };
+    }
+    return { kind: "IN", values: values2, relation: "exact" };
   }
-  return {
-    capability: "EXACT_PUSHDOWN",
-    reasons: [{
-      code: "WHERE_EXACT",
-      functionName,
-      field: left.field,
-      fieldType: semantics.fieldType,
-      operator
-    }]
-  };
-}
-function classifyRelativeDateBinary(op, left, right, resolveField2) {
-  const operator = normalizeOperator(op);
-  const functionName = right.name;
-  if (left.type !== "FIELD") {
-    return relativeDateUnsupported(
-      "WHERE_RELATIVE_DATE_CONTEXT_UNSUPPORTED",
-      functionName,
-      void 0,
-      void 0,
-      operator
-    );
+  if (!operators.has(">=") || !operators.has("<=")) {
+    return { kind: "FALLBACK", reason: "JOIN_KEY_OPERATOR_UNAVAILABLE" };
   }
-  const semantics = resolveField2(left);
-  if (!semantics) {
-    return relativeDateUnsupported(
-      "WHERE_RELATIVE_DATE_FIELD_TYPE_UNSUPPORTED",
-      functionName,
-      left.field,
-      void 0,
-      operator
-    );
+  if (input.values === void 0) {
+    return { kind: "RANGE_CANDIDATE", relation: "superset", reason: "JOIN_KEY_VALUES_RUNTIME" };
   }
-  if (!hasValidRelativeDateArguments(right)) {
-    return relativeDateUnsupported(
-      "WHERE_RELATIVE_DATE_ARGUMENT_INVALID",
-      functionName,
-      left.field,
-      semantics.fieldType,
-      operator
-    );
+  if (!semanticsMatch(input.fieldType, input.sourceSemantics)) {
+    return { kind: "FALLBACK", reason: "JOIN_KEY_SEMANTICS_UNRESOLVED" };
   }
-  if (!RELATIVE_DATE_OPERATORS.has(operator)) {
-    return relativeDateUnsupported(
-      "WHERE_RELATIVE_DATE_OPERATOR_UNSUPPORTED",
-      functionName,
-      left.field,
-      semantics.fieldType,
-      operator
-    );
+  const sourceSemantics = input.sourceSemantics;
+  if (input.hasEmptyValue) {
+    return { kind: "FALLBACK", reason: "JOIN_KEY_EMPTY_VALUE" };
   }
-  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
-    );
+  const values = [...new Set(input.values)];
+  if (values.some((value) => !canonicalFor(input.fieldType, value))) {
+    return { kind: "FALLBACK", reason: "JOIN_KEY_NON_CANONICAL_VALUE" };
+  }
+  if (values.length === 0) {
+    return { kind: "FALLBACK", reason: "JOIN_KEY_EMPTY_VALUE" };
   }
+  let min = values[0];
+  let max = values[0];
+  for (let i = 1; i < values.length; i += 1) {
+    const value = values[i];
+    if (compareCanonicalValues(value, min, sourceSemantics) < 0) min = value;
+    if (compareCanonicalValues(value, max, sourceSemantics) > 0) max = value;
+  }
+  return { kind: "RANGE", min, max, relation: "superset" };
+}
+
+// src/core/explainMetadata.ts
+function buildGroupingExplainMetadata(statement, canonicalItemCount) {
+  const grouping = normalizeGroupingSpec(statement);
+  if (grouping.type !== "GROUPING_SETS") return null;
   return {
-    capability: "EXACT_PUSHDOWN",
-    reasons: [{
-      code: "WHERE_EXACT",
-      functionName,
-      field: left.field,
-      fieldType: semantics.fieldType,
-      operator
-    }]
+    source: grouping.source,
+    expandedSetCount: grouping.sets.length,
+    groupingItemCount: canonicalItemCount ?? grouping.allItems.length,
+    setLimit: B65_MAX_GROUPING_SETS,
+    itemLimit: B65_MAX_GROUPING_ITEMS,
+    outputRowLimit: B65_MAX_GENERATED_ROWS
   };
 }
-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:
+function whereNeedsFieldMetadata(where) {
+  if (where === null) return false;
+  switch (where.type) {
+    case "BINARY":
+      return valueNeedsFieldMetadata(where.left);
+    case "NULL_CHECK":
+      return valueNeedsFieldMetadata(where.field);
+    case "LOGICAL":
+      return whereNeedsFieldMetadata(where.left) || whereNeedsFieldMetadata(where.right);
+    case "NOT":
+    case "GROUP":
+      return whereNeedsFieldMetadata(where.expr);
+    case "EXISTS":
+    case "BOOLEAN":
       return false;
   }
 }
-function classifyLocalOnlyField(field, operator, resolveField2) {
-  const semantics = resolveField2(field);
-  if (!semantics) return unsupported2("WHERE_FIELD_UNRESOLVED", field.field, void 0, operator);
-  if (!isLocallyValidOperator(semantics.fieldType, operator)) {
-    return unsupported2(
-      "WHERE_OPERATOR_INVALID_FOR_FIELD_TYPE",
-      field.field,
-      semantics.fieldType,
-      operator
-    );
+function valueNeedsFieldMetadata(value) {
+  if (Array.isArray(value)) return value.some(valueNeedsFieldMetadata);
+  if (value === null || typeof value !== "object") return false;
+  const item = value;
+  if (item["type"] === "FIELD") return item["field"] !== "$id";
+  if (item["type"] === "SELECT") return false;
+  return Object.values(item).some(valueNeedsFieldMetadata);
+}
+function selectNeedsOwnMetadata(statement) {
+  return whereNeedsFieldMetadata(statement.where) || statement.groupBy.length > 0 || normalizeGroupingSpec(statement).type === "GROUPING_SETS" || statement.orderBy.length > 0 || statement.joins.some(
+    (join2) => join2.table.appId > 0 && join2.table.cteName === null && (join2.on.left.field !== "$id" || join2.on.right.field !== "$id")
+  ) || statement.columns.some(
+    (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
+  );
+}
+function explainNeedsAppMetadata(statement) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (node === null || typeof node !== "object") return false;
+    if (seen.has(node)) return false;
+    seen.add(node);
+    if (Array.isArray(node)) return node.some(visit);
+    const item = node;
+    if (item["type"] === "VALIDATE") return true;
+    if (item["type"] === "SELECT" && selectNeedsOwnMetadata(node)) {
+      return true;
+    }
+    if ((item["type"] === "UPDATE" || item["type"] === "DELETE") && whereNeedsFieldMetadata(node.where)) {
+      return true;
+    }
+    if (item["type"] === "UPDATE" && Array.isArray(item["applyBlocks"]) && item["applyBlocks"].length > 0) return true;
+    return Object.values(item).some(visit);
+  };
+  return visit(statement);
+}
+
+// src/api/fetchAll.ts
+async function fetchAll(fetcher, app, query, fields, options = {}) {
+  const pageSize = options.pageSize ?? PAGE_SIZE_DEFAULT;
+  const parallel = Math.max(1, options.parallel ?? PARALLEL_DEFAULT);
+  const maxRecords = options.maxRecords ?? MAX_RECORDS_DEFAULT;
+  const onLimit = options.onLimit ?? "error";
+  const stopAfter = options.stopAfter;
+  if (stopAfter !== void 0 && (!Number.isSafeInteger(stopAfter) || stopAfter <= 0 || stopAfter > maxRecords)) {
+    throw new RangeError("stopAfter must be a positive safe integer <= maxRecords");
   }
-  if (!LOCAL_SCALAR_TYPES.has(semantics.fieldType) && !LOCAL_COLLECTION_TYPES.has(semantics.fieldType)) {
-    return unsupported2("WHERE_OPERATOR_UNSUPPORTED", field.field, semantics.fieldType, operator);
+  const fetchCap = stopAfter ?? maxRecords;
+  const fetchFields = fields.length > 0 && !fields.includes("$id") ? [...fields, "$id"] : fields;
+  const allRecords = [];
+  let notified = false;
+  const limitMessage = `\u53D6\u5F97\u4EF6\u6570\u304C\u4E0A\u9650\uFF08${maxRecords} \u4EF6\uFF09\u3092\u8D85\u3048\u307E\u3057\u305F\u3002WHERE \u53E5\u3067\u7D5E\u308A\u8FBC\u3080\u304B\u3001maxRecords \u3092\u5F15\u304D\u4E0A\u3052\u3066\u304F\u3060\u3055\u3044\u3002`;
+  let cursorId = 0;
+  let windowOffset = 0;
+  const cursorQuery0 = buildCursorQuery(query, cursorId);
+  const first = await fetchPage(fetcher, app, cursorQuery0, fetchFields, pageSize, windowOffset);
+  notifySearchAborted(first, options);
+  allRecords.push(...first.records);
+  if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
+    return allRecords.slice(0, stopAfter);
+  }
+  if (allRecords.length > maxRecords) {
+    if (onLimit === "truncate") {
+      if (!notified && options.onTruncate) {
+        options.onTruncate(maxRecords);
+        notified = true;
+      }
+      return allRecords.slice(0, maxRecords);
+    }
+    throw new FetchAllLimitError(limitMessage);
+  }
+  if (first.records.length < pageSize) return allRecords;
+  windowOffset += pageSize;
+  if (windowOffset >= KINTONE_MAX_OFFSET) {
+    cursorId = getLastId(first.records);
+    windowOffset = 0;
+  }
+  while (true) {
+    if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
+      return allRecords.slice(0, stopAfter);
+    }
+    if (allRecords.length >= maxRecords) {
+      if (onLimit === "truncate") {
+        if (!notified && options.onTruncate) {
+          options.onTruncate(maxRecords);
+          notified = true;
+        }
+        return allRecords.slice(0, maxRecords);
+      }
+      throw new FetchAllLimitError(limitMessage);
+    }
+    const remaining = fetchCap - allRecords.length;
+    const maxPagesByLimit = Math.ceil(remaining / pageSize);
+    const batchParallel = Math.max(1, Math.min(parallel, maxPagesByLimit));
+    const batchOffsets = [];
+    for (let i = 0; i < batchParallel; i++) {
+      const off = windowOffset + i * pageSize;
+      if (off >= KINTONE_MAX_OFFSET) break;
+      batchOffsets.push(off);
+    }
+    const cq = buildCursorQuery(query, cursorId);
+    const responses = await Promise.all(
+      batchOffsets.map(
+        (offset) => fetchPage(fetcher, app, cq, fetchFields, pageSize, offset)
+      )
+    );
+    for (const response of responses) notifySearchAborted(response, options);
+    let done = false;
+    for (const res of responses) {
+      allRecords.push(...res.records);
+      if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
+        return allRecords.slice(0, stopAfter);
+      }
+      if (allRecords.length > maxRecords) {
+        if (onLimit === "truncate") {
+          if (!notified && options.onTruncate) {
+            options.onTruncate(maxRecords);
+            notified = true;
+          }
+          return allRecords.slice(0, maxRecords);
+        }
+        throw new FetchAllLimitError(limitMessage);
+      }
+      if (res.records.length < pageSize) {
+        done = true;
+        break;
+      }
+    }
+    if (done) break;
+    windowOffset += pageSize * batchOffsets.length;
+    if (windowOffset >= KINTONE_MAX_OFFSET) {
+      const lastRes = responses[responses.length - 1];
+      cursorId = getLastId(lastRes.records);
+      windowOffset = 0;
+    }
   }
-  return {
-    capability: "LOCAL_ONLY",
-    reasons: [{ code: "WHERE_RESIDUAL", field: field.field, fieldType: semantics.fieldType, operator }]
-  };
+  return allRecords;
 }
-function isLocallyValidOperator(fieldType, operator) {
-  const policy = LOCAL_VALID_OPERATORS.get(fieldType);
-  return policy === void 0 || policy.has(operator);
+function notifySearchAborted(response, options) {
+  if (response.searchAborted) options.onSearchAborted?.();
 }
-function hasLocalContract(fieldType, op) {
-  if (LOCAL_SCALAR_TYPES.has(fieldType)) return true;
-  if (!LOCAL_COLLECTION_TYPES.has(fieldType)) return false;
-  return op === "=" || op === "!=" || op === "<>" || op === "IN" || op === "NOT_IN" || op === "LIKE" || op === "NOT_LIKE" || op === "KLIKE" || op === "NOT_KLIKE";
+function extractIds(records) {
+  return records.map((r) => {
+    const raw = r["$id"]?.value;
+    if (raw === void 0) {
+      throw new Error(
+        '\u30EC\u30B3\u30FC\u30C9\u306B $id \u30D5\u30A3\u30FC\u30EB\u30C9\u304C\u542B\u307E\u308C\u3066\u3044\u307E\u305B\u3093\u3002fields \u306B "$id" \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002'
+      );
+    }
+    const id = Number(raw);
+    if (!Number.isFinite(id)) {
+      throw new Error(`$id \u306E\u5024\u304C\u6570\u5024\u3067\u306F\u3042\u308A\u307E\u305B\u3093: ${raw}`);
+    }
+    return id;
+  });
 }
-function normalizeOperator(op) {
-  switch (op) {
-    case "<>":
-      return "!=";
-    case "IN":
-      return "in";
-    case "NOT_IN":
-      return "not in";
-    case "LIKE":
-    case "KLIKE":
-      return "like";
-    case "NOT_LIKE":
-    case "NOT_KLIKE":
-      return "not like";
-    default:
-      return op;
-  }
+var PAGE_SIZE_DEFAULT = 500;
+var PARALLEL_DEFAULT = 1;
+var MAX_RECORDS_DEFAULT = 1e4;
+var KINTONE_MAX_OFFSET = 1e4;
+async function fetchPage(fetcher, app, query, fields, pageSize, offset) {
+  const pageQuery = buildPageQuery(query, pageSize, offset);
+  return fetcher({ app, query: pageQuery, fields });
 }
-function combineLogical(op, left, right) {
-  const reasons = [...left.reasons, ...right.reasons];
-  if (left.capability === "UNSUPPORTED" || right.capability === "UNSUPPORTED") {
-    return requireExactFunctionPushdown({ capability: "UNSUPPORTED", reasons });
-  }
-  if (left.capability === "EXACT_PUSHDOWN" && right.capability === "EXACT_PUSHDOWN") {
-    return { capability: "EXACT_PUSHDOWN", reasons };
-  }
-  if (op === "AND" && (left.capability === "EXACT_PUSHDOWN" || right.capability === "EXACT_PUSHDOWN" || left.capability === "SUPERSET_PREFILTER" || right.capability === "SUPERSET_PREFILTER")) {
-    return requireExactFunctionPushdown({
-      capability: "SUPERSET_PREFILTER",
-      reasons: [{ code: "WHERE_SUPERSET_PREFILTER" }, ...reasons]
-    });
+function buildCursorQuery(baseQuery, cursorId) {
+  const base = baseQuery.trimEnd();
+  if (cursorId <= 0) {
+    return base ? `${base} order by $id asc` : "order by $id asc";
   }
-  return requireExactFunctionPushdown({ capability: "LOCAL_ONLY", reasons });
-}
-function localExpression() {
-  return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
-}
-function unsupported2(code, field, fieldType, operator) {
-  return { capability: "UNSUPPORTED", reasons: [{ code, field, fieldType, operator }] };
-}
-function legacyKintoneFunctionUnsupported(code, functionName, field, fieldType, operator) {
-  return requireExactFunctionPushdown({
-    capability: "UNSUPPORTED",
-    reasons: [{ code, functionName, field, fieldType, operator }]
-  });
-}
-function relativeDateUnsupported(code, functionName, field, fieldType, operator) {
-  return requireExactRelativeDatePushdown({
-    capability: "UNSUPPORTED",
-    reasons: [{ code, functionName, field, fieldType, operator }]
-  });
+  const cursor = `$id > ${cursorId} order by $id asc`;
+  return base ? `(${base}) and ${cursor}` : cursor;
 }
-function hasRelativeDateReason(reasons) {
-  return reasons.some(
-    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
-  );
+function buildPageQuery(query, pageSize, offset) {
+  const base = query.trimEnd();
+  const suffix = `limit ${pageSize} offset ${offset}`;
+  return base ? `${base} ${suffix}` : suffix;
 }
-function hasLegacyKintoneFunctionReason(reasons) {
-  return reasons.some(
-    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
-  );
+function getLastId(records) {
+  const last = records[records.length - 1];
+  const raw = last?.["$id"]?.value;
+  if (raw === void 0) return 0;
+  const id = Number(raw);
+  return Number.isFinite(id) ? id : 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;
+var FetchAllLimitError = class extends Error {
+  constructor(message, completeInputWrapped = false) {
+    super(message);
+    this.completeInputWrapped = completeInputWrapped;
+    this.name = "FetchAllLimitError";
   }
-  const relative = result.reasons.find(
-    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
-  );
+};
+
+// src/core/optimization/sharedPlanner.ts
+async function fetchRecordsForSharedPlan(getRecords, app, query, fields, options) {
+  const records = await fetchAll(getRecords, app, query, fields, {
+    maxRecords: options.maxRecords,
+    parallel: options.parallel,
+    onLimit: options.onLimit ?? "error",
+    onTruncate: options.onTruncate,
+    onSearchAborted: options.onSearchAborted
+  });
   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
-      }
-    ]
+    records,
+    metrics: { fetchedRows: records.length }
   };
 }
-function requireExactLegacyKintoneFunctionPushdown(result) {
-  if (result.capability === "EXACT_PUSHDOWN" || !hasLegacyKintoneFunctionReason(result.reasons) || result.reasons.some(
-    (reason) => reason.code === "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN"
-  )) {
-    return result;
-  }
-  const legacy = result.reasons.find(
-    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
+async function resolveDmlTargetIds(getRecords, app, query, options) {
+  const { records, metrics } = await fetchRecordsForSharedPlan(
+    getRecords,
+    app,
+    query,
+    ["$id"],
+    options
   );
   return {
-    capability: result.capability,
-    reasons: [
-      ...result.reasons,
-      {
-        code: "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN",
-        functionName: legacy.functionName,
-        field: legacy.field,
-        fieldType: legacy.fieldType,
-        operator: legacy.operator
-      }
-    ]
+    ids: extractIds(records),
+    metrics
   };
 }
-function requireExactFunctionPushdown(result) {
-  return requireExactLegacyKintoneFunctionPushdown(
-    requireExactRelativeDatePushdown(result)
-  );
+
+// src/core/optimization/joinNumberLiteralPolicy.ts
+function isJoinNumberLiteralSupported(literal) {
+  const source = literal.raw ?? String(literal.value);
+  const decimal = parseExactDecimal(source);
+  if (decimal === null) return false;
+  if (decimal.sign === 0) return numberLiteralText(literal) === "0";
+  const fractionDigits = Math.max(decimal.scale, 0);
+  const integerDigits = Math.max(decimal.coefficient.length - decimal.scale, 0);
+  if (fractionDigits > 10 || integerDigits + fractionDigits > 30) {
+    return false;
+  }
+  const canonical = formatPlainDecimal(decimal);
+  return numberLiteralText(literal) === canonical;
 }
 
 // src/core/optimization/joinPredicatePushdown.ts
@@ -12792,6 +12927,14 @@ var SELECTION_TYPES = /* @__PURE__ */ new Set([
   "MULTI_SELECT",
   "STATUS"
 ]);
+var USER_CODE_TYPES = /* @__PURE__ */ new Set([
+  "CREATOR",
+  "MODIFIER",
+  "USER_SELECT",
+  "ORGANIZATION_SELECT",
+  "GROUP_SELECT",
+  "STATUS_ASSIGNEE"
+]);
 var KLIKE_TYPES = /* @__PURE__ */ new Set([
   "SINGLE_LINE_TEXT",
   "LINK",
@@ -12799,7 +12942,7 @@ var KLIKE_TYPES = /* @__PURE__ */ new Set([
   "RICH_TEXT",
   "FILE"
 ]);
-var DATETIME_EQUALITY_TYPES = /* @__PURE__ */ new Set([
+var DATETIME_TYPES2 = /* @__PURE__ */ new Set([
   "DATETIME",
   "CREATED_TIME",
   "UPDATED_TIME"
@@ -13395,21 +13538,45 @@ function classifySupportedLeaf(predicate, owner, fieldType) {
     return isPositiveSafeInteger(predicate.right) && (predicate.op === "=" || predicate.op === "<" || predicate.op === ">" || predicate.op === "<=" || predicate.op === ">=") ? "exact" : "unsafe";
   }
   if (fieldType === "RECORD_NUMBER") {
-    return "unsafe";
+    return classifySupersetScalarOrListLiteral(predicate);
   }
   if (fieldType === "NUMBER") {
-    if (predicate.right.type !== "NUMBER") return "unsafe";
-    if (predicate.op === "=") return "superset";
-    return (predicate.op === "<" || predicate.op === ">") && isSafeIntegerLiteral(predicate.right) ? "superset" : "unsafe";
+    if ((predicate.op === "IN" || predicate.op === "NOT_IN") && predicate.right.type === "IN_LIST" && predicate.right.values.length > 0 && predicate.right.values.every(
+      (value) => value.type === "NUMBER" && isJoinNumberLiteralSupported(value)
+    )) {
+      return "exact";
+    }
+    if ((predicate.op === "=" || predicate.op === "!=" || predicate.op === "<>" || predicate.op === "<" || predicate.op === ">" || predicate.op === "<=" || predicate.op === ">=") && predicate.right.type === "NUMBER" && isJoinNumberLiteralSupported(predicate.right)) {
+      return "exact";
+    }
+    return "unsafe";
+  }
+  if (fieldType === "CALC") {
+    return classifySupersetScalarOrListLiteral(predicate);
+  }
+  if (USER_CODE_TYPES.has(fieldType)) {
+    if (predicate.op !== "IN" && predicate.op !== "NOT_IN" || predicate.right.type !== "IN_LIST" || predicate.right.values.length === 0) return "unsafe";
+    return predicate.right.values.every(
+      (value) => value.type === "STRING" && value.value !== ""
+    ) ? "exact" : "unsafe";
   }
-  if (fieldType === "SINGLE_LINE_TEXT") {
-    return predicate.op === "=" && predicate.right.type === "STRING" && predicate.right.value !== "" ? "superset" : "unsafe";
+  if (fieldType === "SINGLE_LINE_TEXT" || fieldType === "LINK") {
+    if ((predicate.op === "IN" || predicate.op === "NOT_IN") && predicate.right.type === "IN_LIST" && predicate.right.values.length > 0 && predicate.right.values.every(
+      (value) => value.type === "STRING" && value.value !== ""
+    )) {
+      return "exact";
+    }
+    return (predicate.op === "=" || predicate.op === "!=" || predicate.op === "<>") && predicate.right.type === "STRING" && predicate.right.value !== "" ? "exact" : "unsafe";
   }
-  if (fieldType === "DATE" || fieldType === "TIME" || DATETIME_EQUALITY_TYPES.has(fieldType)) {
-    if (predicate.op !== "=" || predicate.right.type !== "STRING") return "unsafe";
-    if (fieldType === "DATE") return isCanonicalDate(predicate.right.value) ? "superset" : "unsafe";
-    if (fieldType === "TIME") return isCanonicalTime(predicate.right.value) ? "superset" : "unsafe";
-    return isCanonicalDateTime(predicate.right.value) ? "superset" : "unsafe";
+  if (fieldType === "DATE" || fieldType === "TIME" || DATETIME_TYPES2.has(fieldType)) {
+    if (predicate.op !== "=" && predicate.op !== "!=" && predicate.op !== "<>" && predicate.op !== "<" && predicate.op !== ">" && predicate.op !== "<=" && predicate.op !== ">=" || predicate.right.type !== "STRING") return "unsafe";
+    if (fieldType === "DATE") {
+      return isCanonicalJoinDate(predicate.right.value) ? "exact" : "unsafe";
+    }
+    if (fieldType === "TIME") {
+      return isCanonicalJoinTime(predicate.right.value) ? "exact" : "unsafe";
+    }
+    return isCanonicalJoinDateTime(predicate.right.value) ? "exact" : "unsafe";
   }
   if (SELECTION_TYPES.has(fieldType)) {
     if (predicate.op !== "IN" && predicate.op !== "NOT_IN" || predicate.right.type !== "IN_LIST" || predicate.right.values.length === 0) return "unsafe";
@@ -13421,6 +13588,19 @@ function classifySupportedLeaf(predicate, owner, fieldType) {
   }
   return "unsafe";
 }
+function classifySupersetScalarOrListLiteral(predicate) {
+  const supportedLiteral = (value) => value.type === "NUMBER" && isJoinNumberLiteralSupported(value) || value.type === "STRING" && value.value !== "";
+  if ((predicate.op === "IN" || predicate.op === "NOT_IN") && predicate.right.type === "IN_LIST") {
+    const values = predicate.right.values;
+    if (values.length > 0 && values.every(supportedLiteral) && values.every((value) => value.type === values[0].type)) {
+      return "superset";
+    }
+  }
+  if ((predicate.op === "=" || predicate.op === "!=" || predicate.op === "<>" || predicate.op === "<" || predicate.op === ">" || predicate.op === "<=" || predicate.op === ">=") && supportedLiteral(predicate.right)) {
+    return "superset";
+  }
+  return "unsafe";
+}
 function owned(source, fieldCode) {
   return Object.freeze({
     status: "OWNED",
@@ -13445,24 +13625,6 @@ function isPositiveSafeInteger(value) {
 function isSafeIntegerLiteral(value) {
   return /^-?\d+$/.test(numberLiteralText(value)) && Number.isSafeInteger(value.value);
 }
-function isCanonicalDate(value) {
-  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
-  if (!match) return false;
-  const year = Number(match[1]);
-  const month = Number(match[2]);
-  const day = Number(match[3]);
-  const date = new Date(Date.UTC(year, month - 1, day));
-  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
-}
-function isCanonicalTime(value) {
-  const match = /^(\d{2}):(\d{2})$/.exec(value);
-  return match !== null && Number(match[1]) <= 23 && Number(match[2]) <= 59;
-}
-function isCanonicalDateTime(value) {
-  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/.exec(value);
-  if (!match || !isCanonicalDate(match[1])) return false;
-  return Number(match[2]) <= 23 && Number(match[3]) <= 59 && Number(match[4]) <= 59;
-}
 function collectKlikes2(where, out) {
   if (where === null) return;
   if (isKlike(where)) {
@@ -20174,6 +20336,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
       parallel,
       options.onLimitReached ?? "error",
       warnings,
+      cacheContext,
+      cteCache,
       null,
       plainGroupByPlan,
       ""
@@ -20562,6 +20726,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
         parallel,
         effectiveOptions.onLimitReached ?? "error",
         warnings,
+        cacheContext,
+        cteCache,
         pushDownCond,
         plainGroupByPlan
       );
@@ -20754,10 +20920,9 @@ function splitChunks(items, size) {
   for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
   return out;
 }
-var JOIN_IN_CHUNK_SIZE = 50;
 var JOIN_IN_MAX_CHUNKS = 6;
-var JOIN_IN_MAX_KEYS = JOIN_IN_CHUNK_SIZE * JOIN_IN_MAX_CHUNKS;
-async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxRecords, parallel, onLimit, warnings, pushDownCond = null, plainGroupByPlan, additionalPushQuery = "") {
+var JOIN_IN_MAX_KEYS = JOIN_KEY_IN_CHUNK_SIZE * JOIN_IN_MAX_CHUNKS;
+async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxRecords, parallel, onLimit, warnings, cacheContext, materializedTables, pushDownCond = null, plainGroupByPlan, additionalPushQuery = "") {
   if (join2.type !== "INNER") return null;
   if (!join2.table.alias) return null;
   if (join2.table.subtableCode) return null;
@@ -20780,17 +20945,47 @@ async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxR
   }
   const sourceRows2 = tables.get(sourceAlias);
   if (!sourceRows2) return null;
-  const keys = /* @__PURE__ */ new Set();
+  const sourceTable = [stmt.from, ...stmt.joins.map((candidate) => candidate.table)].find((table) => effectiveTableAlias(table) === sourceAlias);
+  const targetInfo = (await getFieldsCached(join2.table.appId, client, cacheContext)).find((info) => info.code === fieldCodeForTypeLookup(join2.table, joinField));
+  const targetMeta = targetInfo ? materializedMetaFromFieldInfo(targetInfo, join2.table.appId) : systemColumnMeta(joinField);
+  let sourceMeta;
+  if (sourceTable?.cteName !== null && sourceTable?.cteName !== void 0) {
+    sourceMeta = materializedTables?.get(sourceTable.cteName)?.columnMeta?.get(sourceField);
+  } else if (sourceTable) {
+    const sourceInfo = (await getFieldsCached(sourceTable.appId, client, cacheContext)).find((info) => info.code === fieldCodeForTypeLookup(sourceTable, sourceField));
+    sourceMeta = sourceInfo ? materializedMetaFromFieldInfo(sourceInfo, sourceTable.appId) : systemColumnMeta(sourceField);
+  }
+  const keys = [];
+  let hasEmptyValue = false;
   for (const row of sourceRows2) {
     const raw = row[sourceField]?.value;
-    const txt = toScalarText(raw).trim();
-    if (txt.length > 0) keys.add(txt);
+    const txt = toScalarText(raw);
+    if (raw === null || raw === void 0 || txt.length === 0) hasEmptyValue = true;
+    keys.push(txt);
+  }
+  const keyPlan = planJoinKeyPrefilter({
+    fieldType: targetMeta?.fieldType,
+    sourceSemantics: sourceMeta?.semantics,
+    sourceRowCount: sourceRows2.length,
+    values: keys,
+    hasEmptyValue,
+    maxInKeys: JOIN_IN_MAX_KEYS
+  });
+  if (keyPlan.kind === "EMPTY_SOURCE") return [];
+  if (keyPlan.kind === "FALLBACK") {
+    if (keyPlan.reason === "JOIN_KEY_LIMIT_EXCEEDED") {
+      const count = new Set(keys).size;
+      warnings.add(
+        `JOIN\u30AD\u30FC\u304C ${count} \u4EF6\u306E\u305F\u3081 ON \u6700\u9069\u5316\u3092\u30B9\u30AD\u30C3\u30D7\u3057\u3001JOIN\u5148\u3092\u5168\u4EF6\u53D6\u5F97\u3057\u307E\u3059\uFF08\u4E0A\u9650 ${JOIN_IN_MAX_KEYS} \u4EF6\uFF09\u3002`
+      );
+    }
+    return null;
   }
-  const values = [...keys];
-  if (values.length === 0) return [];
-  if (values.length > JOIN_IN_MAX_KEYS) {
+  if (keyPlan.kind === "RANGE_CANDIDATE") return null;
+  const prefilterQueries = buildJoinKeyPrefilterQueries(keyPlan, joinField, sqlQuote);
+  if (prefilterQueries.length === 0) {
     warnings.add(
-      `JOIN\u30AD\u30FC\u304C ${values.length} \u4EF6\u306E\u305F\u3081 ON \u6700\u9069\u5316\u3092\u30B9\u30AD\u30C3\u30D7\u3057\u3001JOIN\u5148\u3092\u5168\u4EF6\u53D6\u5F97\u3057\u307E\u3059\uFF08\u4E0A\u9650 ${JOIN_IN_MAX_KEYS} \u4EF6\uFF09\u3002`
+      `JOIN\u30AD\u30FC\u304C 0 \u4EF6\u306E\u305F\u3081 ON \u6700\u9069\u5316\u3092\u30B9\u30AD\u30C3\u30D7\u3057\u3001JOIN\u5148\u3092\u5168\u4EF6\u53D6\u5F97\u3057\u307E\u3059\uFF08\u4E0A\u9650 ${JOIN_IN_MAX_KEYS} \u4EF6\uFF09\u3002`
     );
     return null;
   }
@@ -20799,18 +20994,16 @@ async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxR
     warnings.add(`\u53D6\u5F97\u4E0A\u9650\uFF08${max} \u4EF6\uFF09\u306B\u9054\u3057\u305F\u305F\u3081\u3001${max} \u4EF6\u3067\u6253\u3061\u5207\u3063\u3066\u8868\u793A\u3057\u3066\u3044\u307E\u3059\u3002`);
     markLimitReached(client, join2.table.appId);
   };
-  const chunks = splitChunks(values, JOIN_IN_CHUNK_SIZE);
   const merged = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const chunk3 of chunks) {
-    const inClause = `${joinField} in (${chunk3.map(sqlQuote).join(",")})`;
+  for (const joinKeyQuery of prefilterQueries) {
     const pushQueries = [
       pushDownCond !== null ? whereToKintone(pushDownCond) : "",
       additionalPushQuery
     ].filter((query2) => query2 !== "");
     const query = pushQueries.reduce(
       (combined, pushQuery) => `(${combined}) and (${pushQuery})`,
-      inClause
+      joinKeyQuery
     );
     const resolved = await fetchRecordsForSharedPlan(client.getRecords, join2.table.appId, query, fields, {
       parallel,
@@ -24050,6 +24243,7 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
   return cache;
 }
 var explainJoinPushdownPlans = /* @__PURE__ */ new WeakMap();
+var explainJoinKeyPrefilters = /* @__PURE__ */ new WeakMap();
 var explainChoiceEqualityRewrites = /* @__PURE__ */ new WeakMap();
 var validateExplainInfo = /* @__PURE__ */ new WeakMap();
 var applyParentExplainPlan = /* @__PURE__ */ new WeakMap();
@@ -24081,6 +24275,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     (node) => node.source === source || JSON.stringify(node.source) === JSON.stringify(source)
   );
   const explainRelations = new Map(initialRelations ?? []);
+  const staticExplainRelations = new Set(initialRelations?.keys() ?? []);
   const explainSourceColumns = async (select) => {
     const tables = [select.from, ...select.joins.map((join2) => join2.table)];
     if (tables.length > 1 && select.columns.some(
@@ -24160,6 +24355,17 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       const withStatement = node;
       for (const cte of withStatement.ctes) {
         await preflightExplainRelations(cte.query);
+        if (cte.query.type === "GENERATE_SERIES") {
+          const generated = executeGenerateSeries(cte.query);
+          explainRelations.set(cte.name, {
+            rows: generated.rows,
+            columns: generated.columns,
+            columnMeta: materializedMetaBySelectResult.get(generated),
+            uniqueGeneratedColumn: cte.query.columnAlias
+          });
+          staticExplainRelations.add(cte.name);
+          continue;
+        }
         const columns = await inferExplainRelationColumns(cte.query);
         explainRelations.set(cte.name, { rows: [], columns });
       }
@@ -24240,6 +24446,71 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         await loadTypedPushdownMeta(select, tracedClient, cacheContext)
       );
       if (joinPushdownPlan) explainJoinPushdownPlans.set(select, joinPushdownPlan);
+      const joinKeyPlans = /* @__PURE__ */ new Map();
+      for (const join2 of select.joins) {
+        const joinAlias = join2.table.alias;
+        if (join2.type !== "INNER" || !joinAlias || join2.table.subtableCode) continue;
+        const leftAlias = join2.on.left.tableAlias;
+        const rightAlias = join2.on.right.tableAlias;
+        if (!leftAlias || !rightAlias) continue;
+        const sourceAlias = leftAlias === joinAlias && rightAlias !== joinAlias ? rightAlias : rightAlias === joinAlias && leftAlias !== joinAlias ? leftAlias : void 0;
+        const sourceField = leftAlias === joinAlias ? join2.on.right.field : join2.on.left.field;
+        const joinField = leftAlias === joinAlias ? join2.on.left.field : join2.on.right.field;
+        if (!sourceAlias) continue;
+        const sourceTable = [select.from, ...select.joins.map((candidate) => candidate.table)].find((table) => effectiveTableAlias(table) === sourceAlias);
+        const targetInfos = await getFieldsCached(join2.table.appId, tracedClient, cacheContext);
+        const targetInfo = targetInfos.find((info) => info.code === fieldCodeForTypeLookup(join2.table, joinField));
+        const targetMeta = targetInfo ? materializedMetaFromFieldInfo(targetInfo, join2.table.appId) : systemColumnMeta(joinField);
+        let sourceMeta;
+        let values;
+        let sourceRowCount;
+        let hasEmptyValue;
+        if (sourceTable?.cteName !== null && sourceTable?.cteName !== void 0) {
+          const relation = explainRelations.get(sourceTable.cteName);
+          sourceMeta = relation?.columnMeta?.get(sourceField);
+          if (staticExplainRelations.has(sourceTable.cteName) && relation) {
+            sourceRowCount = relation.rows.length;
+            values = relation.rows.map((row) => toScalarText(row[sourceField]));
+            hasEmptyValue = values.some((value) => value.length === 0);
+          }
+        } else if (sourceTable) {
+          const info = (await getFieldsCached(sourceTable.appId, tracedClient, cacheContext)).find((candidate) => candidate.code === fieldCodeForTypeLookup(sourceTable, sourceField));
+          sourceMeta = info ? materializedMetaFromFieldInfo(info, sourceTable.appId) : systemColumnMeta(sourceField);
+        }
+        const plan = planJoinKeyPrefilter({
+          fieldType: targetMeta?.fieldType,
+          sourceSemantics: sourceMeta?.semantics,
+          sourceRowCount,
+          values,
+          hasEmptyValue,
+          maxInKeys: JOIN_IN_MAX_KEYS
+        });
+        if (plan.kind === "FALLBACK" && plan.reason === "JOIN_KEY_VALUES_RUNTIME") {
+          const runtimePlanConsumesJoin = joinPushdownPlan?.joinPlan.items.some(
+            (item) => item.targetAlias === joinAlias
+          ) || joinPushdownPlan?.joinPlan.serverFunctionConsumptions.some(
+            (consumption) => consumption.targetAlias === joinAlias
+          );
+          if (runtimePlanConsumesJoin) continue;
+        }
+        const queries = buildJoinKeyPrefilterQueries(plan, joinField, sqlQuote);
+        const additionalCandidate = select.where ? extractTypedPushdownCandidates(select.where, { tableAlias: joinAlias }) : null;
+        let additionalQuery;
+        let additionalRelation;
+        if (additionalCandidate) {
+          const infoByCode = new Map(targetInfos.map((info) => [info.code, info]));
+          const additionalCapability = classifyWhereCapability(additionalCandidate, (field) => {
+            const info = infoByCode.get(field.field);
+            return info?.semantics ?? (info ? resolveFieldSemantics(info) : systemColumnMeta(field.field)?.semantics);
+          });
+          if (additionalCapability.capability === "EXACT_PUSHDOWN" || additionalCapability.capability === "SUPERSET_PREFILTER") {
+            additionalQuery = whereToKintone(additionalCandidate);
+            additionalRelation = additionalCapability.capability === "EXACT_PUSHDOWN" ? "exact" : "superset";
+          }
+        }
+        joinKeyPlans.set(joinAlias, { plan, queries, additionalQuery, additionalRelation });
+      }
+      if (joinKeyPlans.size > 0) explainJoinKeyPrefilters.set(select, joinKeyPlans);
       if (select.orderBy.length > 0 || select.columns.some((column) => column.type === "WINDOW_COL" && column.orderBy.length > 0)) {
         const meta = await buildOrderByMetaForSelect(select, tracedClient, cacheContext);
         if (select.orderMode !== "KINTONE_NATIVE") {
@@ -25356,9 +25627,13 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
       const joinPushDown = join2.table.alias ? pushdownPlan.joinConditions.get(join2.table.alias) ?? null : null;
       const joinCandidate = join2.table.alias && !join2.table.subtableCode && join2.table.cteName === null && stmt.where ? extractTypedPushdownCandidates(stmt.where, { tableAlias: join2.table.alias }) : null;
       const joinBoundQuery = join2.table.alias ? runtimeJoinPlan?.queriesByAlias.get(join2.table.alias) : void 0;
-      const joinQ = joinBoundQuery || (joinPushDown !== null ? whereToKintone(joinPushDown) : "(\u5168\u4EF6\u53D6\u5F97)");
+      const joinKey = join2.table.alias ? explainJoinKeyPrefilters.get(stmt)?.get(join2.table.alias) : void 0;
+      const baseJoinQ = joinBoundQuery || (joinPushDown !== null ? whereToKintone(joinPushDown) : joinKey?.additionalQuery ? joinKey.additionalQuery : "(\u5168\u4EF6\u53D6\u5F97)");
+      const runtimeJoinKeyCandidate = joinKey?.plan.kind === "RANGE_CANDIDATE" || joinKey?.plan.kind === "FALLBACK" && joinKey.plan.reason === "JOIN_KEY_VALUES_RUNTIME";
+      const joinQueries = joinKey && joinKey.queries.length > 0 ? joinKey.queries.map((query) => baseJoinQ !== "(\u5168\u4EF6\u53D6\u5F97)" ? `(${query}) and (${baseJoinQ})` : query) : [runtimeJoinKeyCandidate ? "(runtime source keys)" : baseJoinQ];
+      const joinQ = joinQueries.join(" | ");
       lines.push(`  ${joinType}:        APP${join2.table.appId}${joinAliasStr} (${join2.table.appId})`);
-      lines.push(`  kintone query: ${joinQ}`);
+      for (const query of joinQueries) lines.push(`  kintone query: ${query}`);
       const joinPlanItem = runtimeJoinPlan?.joinPlan.items.find(
         (item) => item.targetAlias === join2.table.alias
       );
@@ -25366,8 +25641,8 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
         (consumption) => consumption.targetAlias === join2.table.alias
       );
       if (emitFetch && join2.table.cteName === null) {
-        const joinPending = !runtimeJoinPlan && joinCandidate !== null;
-        const joinFetchScope = joinQ === "(\u5168\u4EF6\u53D6\u5F97)" ? "ALL" : joinPending ? "PREFILTERED" : joinPlanItem?.relation === "exact" || joinFunctionConsumption ? "EXACT" : "PREFILTERED";
+        const joinPending = runtimeJoinKeyCandidate || !joinKey && !runtimeJoinPlan && joinCandidate !== null;
+        const joinFetchScope = joinQ === "(\u5168\u4EF6\u53D6\u5F97)" ? "ALL" : joinPending ? "PREFILTERED" : joinKey?.plan.kind === "IN" && joinPlanItem?.relation !== "superset" && joinKey.additionalRelation !== "superset" ? "EXACT" : joinPlanItem?.relation === "exact" || joinFunctionConsumption ? "EXACT" : "PREFILTERED";
         lines.push(renderFetchScope(createExplainFetchSource(
           collector,
           join2.table.appId,
@@ -25378,7 +25653,25 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
           joinPending
         )));
       }
-      if (joinPlanItem || joinFunctionConsumption) {
+      if (joinKey) {
+        if (joinKey.plan.kind === "RANGE") {
+          lines.push("  join key prefilter: range");
+          for (const query of joinQueries) lines.push(`  pushdown applied: ${query}`);
+          lines.push("  relation: superset");
+        } else if (joinKey.plan.kind === "IN") {
+          const relation = joinPlanItem?.relation === "superset" || joinKey.additionalRelation === "superset" ? "superset" : "exact";
+          lines.push("  join key prefilter: in");
+          for (const query of joinQueries) lines.push(`  pushdown applied: ${query}`);
+          lines.push(`  relation: ${relation}`);
+        } else if (joinKey.plan.kind === "RANGE_CANDIDATE") {
+          lines.push("  join key prefilter: range candidate");
+          lines.push("  relation: superset");
+          lines.push(`  join key prefilter reason: ${joinKey.plan.reason}`);
+        } else if (joinKey.plan.kind === "FALLBACK") {
+          lines.push(joinKey.plan.reason === "JOIN_KEY_VALUES_RUNTIME" ? "  join key prefilter: runtime candidate" : "  join key prefilter: not applied");
+          lines.push(`  join key prefilter reason: ${joinKey.plan.reason}`);
+        }
+      } else if (joinPlanItem || joinFunctionConsumption) {
         lines.push(`  pushdown applied: ${joinBoundQuery}`);
         lines.push(`  relation: ${joinPlanItem?.relation ?? "exact"}`);
       } else if (!runtimeJoinPlan && joinCandidate !== null) {