@rex0220/kintone-sql-tools 3.22.0 → 3.24.0

package/dist-cli/ksql.js

@@ -5186,8 +5186,8 @@ function selectToFetchAllParams(stmt, appId) {
     // 全件取得なので全フィールドを取得する
   };
 }
-function selectToFetchAllFields(stmt, targetTable) {
-  const plan = collectRequiredFieldsByTable(stmt);
+function selectToFetchAllFields(stmt, targetTable, plainGroupByPlan) {
+  const plan = collectRequiredFieldsByTable(stmt, plainGroupByPlan);
   const target = plan.get(targetTable);
   if (!target) return [];
   if (target.allFields) return [];
@@ -5312,7 +5312,8 @@ function caseResultHasAggregate(result) {
   if (result.type === "ARRAY" || result.type === "FIELD_REF" || result.type === "ARITH") return false;
   return scalarValueHasAggregate(result);
 }
-function collectRequiredFieldsByTable(stmt) {
+function collectRequiredFieldsByTable(stmt, plainGroupByPlan) {
+  const allTables = [stmt.from, ...stmt.joins.map((j) => j.table)];
   const physicalTables = [stmt.from, ...stmt.joins.map((j) => j.table)].filter((t) => t.cteName === null);
   const states = /* @__PURE__ */ new Map();
   for (const table of physicalTables) {
@@ -5361,7 +5362,7 @@ function collectRequiredFieldsByTable(stmt) {
     if (!fieldName) return;
     st.fields.add(fieldName);
   };
-  const addFieldName = (rawName, phase = "select") => {
+  const addFieldName = (rawName, phase = "select", groupResolution) => {
     if (!rawName || rawName === "*") return;
     if (rawName === "_p.*") {
       markAllSubtableTables();
@@ -5384,6 +5385,15 @@ function collectRequiredFieldsByTable(stmt) {
       }
       return;
     }
+    if (phase === "groupBy" && groupResolution !== void 0) {
+      if (groupResolution.kind === "PHYSICAL") {
+        const source = allTables[groupResolution.sourceIndex];
+        if (source?.cteName === null) {
+          addFieldToTable(source, groupResolution.fieldCode);
+        }
+      }
+      return;
+    }
     if ((phase === "orderBy" || phase === "having" || phase === "groupBy") && selectAliases.has(rawName)) {
       return;
     }
@@ -5544,9 +5554,9 @@ function collectRequiredFieldsByTable(stmt) {
         return;
     }
   };
-  const walkGroupByKey = (k) => {
+  const walkGroupByKey = (k, resolution) => {
     if (k.type === "FIELD_NAME") {
-      addFieldName(k.name, "groupBy");
+      addFieldName(k.name, "groupBy", resolution);
       return;
     }
     if (k.type === "ARITH_KEY") {
@@ -5619,7 +5629,9 @@ function collectRequiredFieldsByTable(stmt) {
   walkWhere(stmt.where, "where");
   const grouping = normalizeGroupingSpec(stmt);
   if (grouping.type === "PLAIN") {
-    for (const item of grouping.allItems) walkGroupByKey(item);
+    grouping.allItems.forEach(
+      (item, index) => walkGroupByKey(item, plainGroupByPlan?.items[index])
+    );
   } else if (grouping.type === "GROUPING_SETS") {
     for (const item of grouping.allItems) {
       addFieldRef(item.field, item.tableAlias, "select");
@@ -6853,8 +6865,8 @@ function parseOptionValues(value, fieldType) {
 }
 function optionVector(value, semantics) {
   const order = semantics.optionOrder ?? /* @__PURE__ */ new Map();
-  const unique = [...new Set(parseOptionValues(value, semantics.fieldType))];
-  const vector = unique.map((label) => {
+  const unique2 = [...new Set(parseOptionValues(value, semantics.fieldType))];
+  const vector = unique2.map((label) => {
     const rank = order.get(label);
     return rank === void 0 ? { knownBand: 1, rank: 0, label } : { knownBand: 0, rank, label };
   });
@@ -10802,10 +10814,10 @@ function planKorder(input) {
   if (stmt.limit !== null && !Number.isSafeInteger(scanRows)) {
     reasons.push(`KORDER_SCAN_ROWS_INVALID(offset=${offset}, limit=${stmt.limit})`);
   }
-  const unique = [...new Set(reasons)];
-  if (unique.length > 0) {
+  const unique2 = [...new Set(reasons)];
+  if (unique2.length > 0) {
     throw new Error(
-      `ArgumentError: KORDER BY cannot be executed (mode=KINTONE_NATIVE; ${unique.join(", ")}). Use ORDER BY for canonical local ordering or simplify the query.`
+      `ArgumentError: KORDER BY cannot be executed (mode=KINTONE_NATIVE; ${unique2.join(", ")}). Use ORDER BY for canonical local ordering or simplify the query.`
     );
   }
   const native = stmt.limit <= 500 && offset <= 1e4 && stmt.limit <= input.maxRecords;
@@ -10905,6 +10917,148 @@ function buildKorderCursorQuery(stmt) {
   return parts.join(" ");
 }
 
+// src/core/systemFields.ts
+var APP_SYSTEM_FIELD_CODES = [
+  "$id",
+  "$revision",
+  "\u30EC\u30B3\u30FC\u30C9\u756A\u53F7",
+  "\u4F5C\u6210\u8005",
+  "\u4F5C\u6210\u65E5\u6642",
+  "\u66F4\u65B0\u8005",
+  "\u66F4\u65B0\u65E5\u6642",
+  "\u30B9\u30C6\u30FC\u30BF\u30B9",
+  "\u4F5C\u696D\u8005"
+];
+function isSystemLikeFieldCode(code) {
+  return code.startsWith("_") || code.startsWith("$");
+}
+
+// src/core/optimization/plainGroupByPlan.ts
+var AGGREGATE_REFERENCE_PREFIX = /^(COUNT|SUM|AVG|MAX|MIN|GROUP_CONCAT|STDDEV_POP|STDDEV_SAMP|VAR_POP|VAR_SAMP|MEDIAN|MODE)\(/;
+function containsAggregateColumnNode(node) {
+  if (node === null || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some(containsAggregateColumnNode);
+  const value = node;
+  if (value["type"] === "AGGREGATE" || value["type"] === "ARITH_AGG_COL") return true;
+  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return false;
+  if (value["type"] === "FIELD" && typeof value["field"] === "string") {
+    return AGGREGATE_REFERENCE_PREFIX.test(value["field"]);
+  }
+  return Object.values(value).some(containsAggregateColumnNode);
+}
+function classifyPreGroupAlias(column) {
+  switch (column.type) {
+    case "AGGREGATE":
+    case "ARITH_AGG_COL":
+      return "AGGREGATE_DEPENDENT";
+    case "GROUPING_COL":
+    case "WINDOW_COL":
+      return "POST_GROUP_ONLY";
+    case "VARIABLE_COL":
+      throw new Error("InternalError: unresolved VARIABLE_COL reached GROUP BY alias planning.");
+    case "WILDCARD":
+    case "PARENT_WILDCARD":
+    case "FIELD":
+    case "LITERAL_COL":
+    case "ARITH_COL":
+    case "CASE_COL":
+    case "STRFUNC_COL":
+    case "SCALAR_VALUE_COL":
+    case "SCALAR_SUBQUERY_COL":
+      return containsAggregate(column) || containsAggregateColumnNode(column) ? "AGGREGATE_DEPENDENT" : "SAFE";
+  }
+}
+var SUBTABLE_SYSTEM_COLUMNS = ["_pid", "_rid", "_idx"];
+function unique(values) {
+  return [...new Set(values)];
+}
+function sourceColumns(input) {
+  switch (input.kind) {
+    case "APP":
+      return unique([
+        ...input.fieldCodes,
+        ...APP_SYSTEM_FIELD_CODES
+      ]);
+    case "SUBTABLE":
+      return unique([
+        ...input.childFieldCodes,
+        ...SUBTABLE_SYSTEM_COLUMNS,
+        ...input.parentFieldCodes.map((field) => `_p.${field}`)
+      ]);
+    case "MATERIALIZED":
+      return unique(input.columns);
+  }
+}
+function resolvePlainGroupBySourceSchemas(stmt, lookup) {
+  const sources = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  return sources.map((source, sourceIndex) => ({
+    sourceIndex,
+    qualifier: source.alias ?? source.cteName,
+    columns: sourceColumns(lookup(source, sourceIndex))
+  }));
+}
+function parseGroupName(name) {
+  if (name.startsWith("_p.")) return { qualifier: null, fieldCode: name };
+  const dot = name.indexOf(".");
+  if (dot <= 0 || dot === name.length - 1) {
+    return { qualifier: null, fieldCode: name };
+  }
+  return { qualifier: name.slice(0, dot), fieldCode: name.slice(dot + 1) };
+}
+function runtimeKey(source, fieldCode) {
+  return source.qualifier === null ? fieldCode : `${source.qualifier}.${fieldCode}`;
+}
+function explicitAlias(column) {
+  return "alias" in column && typeof column.alias === "string" ? column.alias : null;
+}
+function resolveFieldName(name, columns, schemas) {
+  const parsed = parseGroupName(name);
+  const candidateSources = parsed.qualifier === null ? schemas : schemas.filter((source) => source.qualifier === parsed.qualifier);
+  const physical = candidateSources.filter((source) => source.columns.includes(parsed.fieldCode));
+  if (physical.length > 1) {
+    throw new Error(
+      `ArgumentError: GROUP BY field ${name} is ambiguous across multiple sources (reason=GROUP_BY_FIELD_AMBIGUOUS).`
+    );
+  }
+  if (physical.length === 1) {
+    const source = physical[0];
+    return {
+      kind: "PHYSICAL",
+      sourceIndex: source.sourceIndex,
+      fieldCode: parsed.fieldCode,
+      runtimeKey: runtimeKey(source, parsed.fieldCode)
+    };
+  }
+  if (parsed.qualifier !== null) return { kind: "UNKNOWN", name };
+  const aliases = columns.flatMap(
+    (column, columnIndex) => explicitAlias(column) === name ? [{ column, columnIndex }] : []
+  );
+  if (aliases.length > 1) return { kind: "ALIAS_REJECT", reason: "DUPLICATE" };
+  if (aliases.length === 1) {
+    const candidate = aliases[0];
+    const classification = classifyPreGroupAlias(candidate.column);
+    if (classification === "SAFE") {
+      return { kind: "ALIAS_SAFE", columnIndex: candidate.columnIndex };
+    }
+    return {
+      kind: "ALIAS_REJECT",
+      reason: classification === "AGGREGATE_DEPENDENT" ? "AGGREGATE" : "POST_GROUP_ONLY"
+    };
+  }
+  const aggregateSyntheticMatch = columns.some(
+    (column) => column.type === "AGGREGATE" && column.alias === null && aggregateSyntheticName(column.func, column.distinct, column.arg) === name
+  );
+  if (aggregateSyntheticMatch) return { kind: "ALIAS_REJECT", reason: "AGGREGATE" };
+  return { kind: "UNKNOWN", name };
+}
+function planPlainGroupByResolution(groupBy, columns, schemas) {
+  return {
+    items: groupBy.map(
+      (key) => key.type === "FIELD_NAME" ? resolveFieldName(key.name, columns, schemas) : { kind: "EXPRESSION" }
+    )
+  };
+}
+
 // src/engine/process.ts
 function flatten(record, alias) {
   const row = {};
@@ -10986,10 +11140,21 @@ function hasAggregateColumns(columns) {
     (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(c.expr)
   );
 }
-function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind) {
+function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolutionPlan, aliasEvaluationContext = {}) {
+  if (resolutionPlan && resolutionPlan.items.length !== groupByKeys.length) {
+    throw new Error("InternalError: plain GROUP BY resolution plan length does not match group keys.");
+  }
   const groups = /* @__PURE__ */ new Map();
   for (const row of rows) {
-    const key = groupByKeys.map((k) => evalGroupByKey(k, row)).join("\0");
+    const key = groupByKeys.map(
+      (groupKey, index) => evalGroupByKey(
+        groupKey,
+        row,
+        resolutionPlan?.items[index],
+        columns,
+        aliasEvaluationContext
+      )
+    ).join("\0");
     const bucket = groups.get(key);
     if (bucket) bucket.push(row);
     else groups.set(key, [row]);
@@ -11097,8 +11262,32 @@ function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortK
     }
   }
 }
-function evalGroupByKey(key, row) {
-  if (key.type === "FIELD_NAME") return row[key.name] ?? "";
+function evalGroupByKey(key, row, resolution, columns, aliasEvaluationContext) {
+  if (key.type === "FIELD_NAME") {
+    if (!resolution) return row[key.name] ?? "";
+    if (resolution.kind === "PHYSICAL") return row[resolution.runtimeKey] ?? "";
+    if (resolution.kind === "ALIAS_SAFE") {
+      const column = columns[resolution.columnIndex];
+      if (!column) {
+        throw new Error(
+          `InternalError: GROUP BY alias column index ${resolution.columnIndex} is out of range.`
+        );
+      }
+      const value = evaluateSelectColumnValue(
+        column,
+        row,
+        resolution.columnIndex,
+        aliasEvaluationContext
+      );
+      if (typeof value !== "string") {
+        throw new Error("InternalError: GROUP BY alias resolved to an expanded SELECT column.");
+      }
+      return value;
+    }
+    throw new Error(
+      `InternalError: unresolved plain GROUP BY item ${resolution.kind} reached evaluation.`
+    );
+  }
   if (key.type === "FUNC_KEY") return evalStringFunc(key.expr, row);
   return String(evalArithExpr(key.expr, row));
 }
@@ -11536,7 +11725,7 @@ function buildDistinctTuple(columns, row, context = {}) {
     return typeof value === "string" ? value : value.entries.map(([, entryValue]) => entryValue);
   });
 }
-function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, resolveFieldSemantics2, hiddenQualifiedAliases) {
+function project(rows, columns, scalarCache, resolveFieldType, sourceColumns2, resolveFieldSemantics2, hiddenQualifiedAliases) {
   if (columns.length === 1 && columns[0].type === "WILDCARD") {
     const projected2 = rows.map((row) => {
       const visible = stripHiddenQualifiedColumns(
@@ -11554,7 +11743,7 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, re
       }
       return out;
     });
-    const cols = projected2.length > 0 ? Object.keys(projected2[0]) : [...sourceColumns ?? []];
+    const cols = projected2.length > 0 ? Object.keys(projected2[0]) : [...sourceColumns2 ?? []];
     return { rows: projected2, columns: cols };
   }
   const defaultFieldKeys = buildDefaultFieldOutputKeys(columns);
@@ -11898,10 +12087,11 @@ function runFullScan(input) {
     havingFieldSemanticsResolver,
     aggregateSortKindResolver,
     appliedKlikes,
-    sourceColumns,
+    sourceColumns: sourceColumns2,
     tableColumns,
     hiddenQualifiedAliases,
-    resolvedGroupingSpec
+    resolvedGroupingSpec,
+    plainGroupByPlan
   } = input;
   const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns);
   for (const [key, value] of orderSemantics ?? []) effectiveOrderSemantics.set(key, value);
@@ -11948,7 +12138,13 @@ function runFullScan(input) {
       rows,
       grouping.type === "PLAIN" ? grouping.allItems : [],
       stmt.columns,
-      aggregateSortKindResolver
+      aggregateSortKindResolver,
+      grouping.type === "PLAIN" ? plainGroupByPlan : void 0,
+      {
+        scalarCache,
+        resolveFieldType: fieldTypeResolver,
+        resolveFieldSemantics: fieldSemanticsResolver
+      }
     );
   }
   rows = applyHaving(rows, stmt.having, havingFieldTypeResolver, havingFieldSemanticsResolver);
@@ -11976,7 +12172,7 @@ function runFullScan(input) {
     stmt.columns,
     scalarCache,
     fieldTypeResolver,
-    sourceColumns,
+    sourceColumns2,
     fieldSemanticsResolver,
     hiddenQualifiedAliases
   );
@@ -12408,6 +12604,133 @@ function requireExactRelativeDatePushdown(result) {
   };
 }
 
+// src/core/optimization/relativeDateFullScanExactPlan.ts
+function buildRelativeDateFullScanExactPlan(input) {
+  const {
+    select,
+    selectMode,
+    capability,
+    context,
+    serializedWholeWhere,
+    relativeFunctionNames
+  } = input;
+  if (select.where === null) return null;
+  if (select.from.appId <= 0 || select.from.cteName !== null) return null;
+  if (select.from.subtableCode) return null;
+  if (select.joins.length > 0) return null;
+  if (!context.allowFullScanExact) return null;
+  if (select.orderMode === "KINTONE_NATIVE") return null;
+  const hasCanonicalOrder2 = select.orderMode === "CANONICAL" && select.orderBy.length > 0;
+  if (selectMode !== "FULL_SCAN" && !hasCanonicalOrder2) return null;
+  if (capability.capability !== "EXACT_PUSHDOWN") return null;
+  const occurrences = relativeDateFunctionOccurrencesInWhere(select.where);
+  if (occurrences.length === 0) return null;
+  if (!sameOccurrenceList(occurrences, relativeFunctionNames)) return null;
+  if (serializedWholeWhere === null || !serializedMultisetContains(serializedWholeWhere, occurrences)) {
+    return null;
+  }
+  const prefilterPlan = {
+    prefilterWhere: select.where,
+    residualWhere: null,
+    exactRelativeLeaves: collectExactRelativeLeaves(select.where),
+    relativeFunctionNames: new Set(occurrences),
+    appliedKlikes: /* @__PURE__ */ new Set(),
+    capability: capability.capability,
+    reasons: capability.reasons
+  };
+  const plan = {
+    allowForm: "FULL_SCAN_EXACT",
+    clientWhereEvaluation: false,
+    serializedWholeWhere,
+    prefilterPlan
+  };
+  assertRelativeDateFullScanExactPlan(plan, input, occurrences);
+  return plan;
+}
+function assertRelativeDateFullScanExactPlan(plan, input, occurrences) {
+  if (plan.allowForm !== "FULL_SCAN_EXACT") {
+    throw new Error("FULL_SCAN_EXACT invariant: allowForm");
+  }
+  if (plan.clientWhereEvaluation !== false) {
+    throw new Error("FULL_SCAN_EXACT invariant: clientWhereEvaluation");
+  }
+  if (input.capability.capability !== "EXACT_PUSHDOWN") {
+    throw new Error("FULL_SCAN_EXACT invariant: capability");
+  }
+  if (input.select.where === null || plan.prefilterPlan.prefilterWhere !== input.select.where) {
+    throw new Error("FULL_SCAN_EXACT invariant: whole WHERE identity");
+  }
+  if (plan.prefilterPlan.residualWhere !== null) {
+    throw new Error("FULL_SCAN_EXACT invariant: residualWhere");
+  }
+  if (plan.prefilterPlan.capability !== "EXACT_PUSHDOWN") {
+    throw new Error("FULL_SCAN_EXACT invariant: transport capability");
+  }
+  if (!serializedMultisetContains(plan.serializedWholeWhere, occurrences)) {
+    throw new Error("FULL_SCAN_EXACT invariant: relative occurrence serialization");
+  }
+}
+function relativeDateFunctionOccurrencesInWhere(where) {
+  const names = [];
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const value = node;
+    if (value["type"] === "SELECT") return;
+    if (value["type"] === "KINTONE_FUNC" && typeof value["name"] === "string" && isRelativeDateFunctionName(value["name"])) {
+      names.push(value["name"]);
+      return;
+    }
+    Object.values(value).forEach(visit);
+  };
+  visit(where);
+  return names;
+}
+function collectExactRelativeLeaves(where) {
+  const leaves = [];
+  const visit = (node) => {
+    switch (node.type) {
+      case "BINARY":
+        if (node.right.type === "KINTONE_FUNC" && isRelativeDateFunctionName(node.right.name)) {
+          leaves.push(node);
+        }
+        return;
+      case "LOGICAL":
+        visit(node.left);
+        visit(node.right);
+        return;
+      case "NOT":
+      case "GROUP":
+        visit(node.expr);
+        return;
+      case "EXISTS":
+      case "NULL_CHECK":
+      case "BOOLEAN":
+        return;
+    }
+  };
+  visit(where);
+  return leaves;
+}
+function sameOccurrenceList(actual, expected) {
+  return actual.length === expected.length && actual.every((name, index) => name === expected[index]);
+}
+function serializedMultisetContains(query, expectedNames) {
+  const expected = /* @__PURE__ */ new Map();
+  for (const name of expectedNames) {
+    if (!isRelativeDateFunctionName(name)) return false;
+    expected.set(name, (expected.get(name) ?? 0) + 1);
+  }
+  for (const [name, count] of expected) {
+    const matches = query.match(new RegExp(`\\b${name}\\s*\\(`, "g"));
+    if ((matches?.length ?? 0) < count) return false;
+  }
+  return true;
+}
+
 // src/core/optimization/relativeDatePushdownGuard.ts
 function relativeDateFunctionNamesInNode(node, stopAtNestedSelect) {
   const names = [];
@@ -12453,7 +12776,7 @@ function nestedSelects(node, root) {
   visit(node);
   return found;
 }
-function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = true) {
+function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = true, allowFullScanExact = true) {
   const functionNames = relativeDateFunctionNamesInWhere(select.where);
   if (functionNames.length > 0) {
     candidates.push({
@@ -12462,7 +12785,9 @@ function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = t
       where: select.where,
       functionNames,
       path,
-      allowPhase2Prefilter: allowPhase2
+      allowPhase2Prefilter: allowPhase2,
+      allowFullScanExact,
+      relativeFunctionOccurrences: relativeDateFunctionOccurrencesInWhere(select.where)
     });
   }
   nestedSelects(select, select).forEach(
@@ -12471,31 +12796,35 @@ function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = t
       `${path}.select-source[${index}]`,
       candidates,
       forceForbidden,
-      allowPhase2
+      allowPhase2,
+      allowFullScanExact
     )
   );
 }
-function collectUnion(union, path, candidates, forceForbidden) {
-  if (union.left.type === "UNION") collectUnion(union.left, `${path}.left`, candidates, forceForbidden);
-  else collectSelect(union.left, `${path}.left`, candidates, forceForbidden);
-  collectSelect(union.right, `${path}.right`, candidates, forceForbidden);
+function collectUnion(union, path, candidates, forceForbidden, allowFullScanExact = true) {
+  if (union.left.type === "UNION") {
+    collectUnion(union.left, `${path}.left`, candidates, forceForbidden, allowFullScanExact);
+  } else {
+    collectSelect(union.left, `${path}.left`, candidates, forceForbidden, true, allowFullScanExact);
+  }
+  collectSelect(union.right, `${path}.right`, candidates, forceForbidden, true, allowFullScanExact);
 }
 function collectWith(statement, path, candidates, inheritedForbidden) {
   if (!inheritedForbidden && canInlineSingleCte(statement)) {
-    collectSelect(buildInlinedQuery(statement), `${path}.inlined`, candidates, false);
+    collectSelect(buildInlinedQuery(statement), `${path}.inlined`, candidates, false, true, false);
     return;
   }
   statement.ctes.forEach((cte, index) => {
     if (cte.query.type === "SELECT") {
-      collectSelect(cte.query, `${path}.cte[${index}]`, candidates, true);
+      collectSelect(cte.query, `${path}.cte[${index}]`, candidates, true, true, false);
     } else if (cte.query.type === "UNION") {
-      collectUnion(cte.query, `${path}.cte[${index}]`, candidates, true);
+      collectUnion(cte.query, `${path}.cte[${index}]`, candidates, true, false);
     }
   });
   if (statement.query.type === "SELECT") {
-    collectSelect(statement.query, `${path}.main`, candidates, true);
+    collectSelect(statement.query, `${path}.main`, candidates, true, true, false);
   } else {
-    collectUnion(statement.query, `${path}.main`, candidates, true);
+    collectUnion(statement.query, `${path}.main`, candidates, true, false);
   }
 }
 function collectStatement(statement, path, candidates, forceForbidden = false) {
@@ -12511,8 +12840,8 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
       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);
+      else if (statement.query.type === "UNION") collectUnion(statement.query, `${path}.query`, candidates, true, false);
+      else collectSelect(statement.query, `${path}.query`, candidates, true, true, false);
       return;
     case "EXPLAIN":
       collectStatement(statement.query, `${path}.query`, candidates, forceForbidden);
@@ -12526,11 +12855,13 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
           source: statement,
           where: statement.where,
           functionNames,
-          path
+          path,
+          allowFullScanExact: false,
+          relativeFunctionOccurrences: relativeDateFunctionOccurrencesInWhere(statement.where)
         });
       }
       nestedSelects(statement, statement).forEach(
-        (select, index) => collectSelect(select, `${path}.select-source[${index}]`, candidates, true)
+        (select, index) => collectSelect(select, `${path}.select-source[${index}]`, candidates, true, true, false)
       );
       return;
     }
@@ -12544,7 +12875,9 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
           source: statement,
           where: statement.where,
           functionNames,
-          path
+          path,
+          allowFullScanExact: false,
+          relativeFunctionOccurrences: relativeDateFunctionOccurrencesInWhere(statement.where)
         });
       }
       if (statement.type === "UPDATE" && statement.applyBlocks?.length) {
@@ -12555,7 +12888,9 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
             source: statement,
             where: null,
             functionNames: applyFunctions,
-            path: `${path}.apply`
+            path: `${path}.apply`,
+            allowFullScanExact: false,
+            relativeFunctionOccurrences: []
           });
         }
       }
@@ -12565,6 +12900,7 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
           `${path}.select-source[${index}]`,
           candidates,
           forceForbidden,
+          false,
           false
         )
       );
@@ -12577,6 +12913,7 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
           `${path}.select-source[${index}]`,
           candidates,
           forceForbidden,
+          false,
           false
         )
       );
@@ -12655,6 +12992,21 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
           allowed2 = true;
         }
       }
+      let fullScanExactPlan;
+      if (!allowed2 && capability2.capability === "EXACT_PUSHDOWN") {
+        fullScanExactPlan = buildRelativeDateFullScanExactPlan({
+          select,
+          selectMode,
+          capability: capability2,
+          context: { allowFullScanExact: candidate.allowFullScanExact },
+          serializedWholeWhere: restQuery2 || null,
+          relativeFunctionNames: candidate.relativeFunctionOccurrences
+        }) ?? void 0;
+        if (fullScanExactPlan) {
+          prefilterPlan = fullScanExactPlan.prefilterPlan;
+          allowed2 = true;
+        }
+      }
       const node2 = {
         kind: candidate.kind,
         source: candidate.source,
@@ -12664,6 +13016,7 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
         capability: capability2,
         restQuery: restQuery2,
         ...prefilterPlan ? { prefilterPlan, phase2PrefilterEligible } : {},
+        ...fullScanExactPlan ? { fullScanExactPlan, allowForm: fullScanExactPlan.allowForm } : {},
         clientWhereEvaluation: !allowed2,
         allowed: allowed2
       };
@@ -12795,7 +13148,7 @@ function decomposeRelativeDatePrefilter(stmt, resolveField2, testSeam = {}) {
     return reject(["PREFILTER_SERIALIZATION_FAILED"]);
   }
   const expectedNames = confirmedLeaves.map((leaf) => relativeNameOf(leaf));
-  if (!containsFunctions(prefilterQuery, [...new Set(expectedNames)]) || !serializedMultisetContains(prefilterQuery, expectedNames)) {
+  if (!containsFunctions(prefilterQuery, [...new Set(expectedNames)]) || !serializedMultisetContains2(prefilterQuery, expectedNames)) {
     return reject(["PREFILTER_FUNCTION_MISSING"]);
   }
   const residualWhere = testSeam.rewriteResidual ? testSeam.rewriteResidual(stmt.where, adoptedLeaves) : replaceAdoptedLeaves(stmt.where, adoptedLeaves);
@@ -13017,7 +13370,7 @@ function collectFieldMetadata(where, resolveField2) {
   }
   return { fieldTypes, fieldOptions };
 }
-function serializedMultisetContains(query, expectedNames) {
+function serializedMultisetContains2(query, expectedNames) {
   const expected = /* @__PURE__ */ new Map();
   for (const name of expectedNames) {
     if (!RELATIVE_DATE_FUNCTION_NAMES.has(name)) return false;
@@ -15229,12 +15582,20 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     }
     return result;
   }
+  const plainGroupByPlan = await buildRuntimePlainGroupByPlan(
+    stmt,
+    client,
+    cacheContext,
+    cteCache
+  );
   await resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache);
   const whereCapability = await resolveSelectWhereCapability(stmt, client, cacheContext, cteCache);
   if (whereCapability.capability === "UNSUPPORTED") {
     throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(whereCapability)}).`);
   }
+  const staticMode = resolveSelectMode(stmt);
   let prefilterPlan;
+  let fullScanExactPlan;
   if (whereCapability.capability === "SUPERSET_PREFILTER") {
     const resolver = await buildWhereFieldSemanticsResolver(stmt, client, cacheContext, cteCache);
     const decomposition = decomposeRelativeDatePrefilter(stmt, resolver);
@@ -15242,7 +15603,23 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
       prefilterPlan = decomposition.plan;
     }
   }
-  const staticMode = resolveSelectMode(stmt);
+  if (prefilterPlan === void 0 && whereCapability.capability === "EXACT_PUSHDOWN" && stmt.where !== null) {
+    let serializedWholeWhere = null;
+    try {
+      serializedWholeWhere = whereToKintone(stmt.where);
+    } catch {
+      serializedWholeWhere = null;
+    }
+    fullScanExactPlan = buildRelativeDateFullScanExactPlan({
+      select: stmt,
+      selectMode: staticMode,
+      capability: whereCapability,
+      context: { allowFullScanExact: true },
+      serializedWholeWhere,
+      relativeFunctionNames: relativeDateFunctionOccurrencesInWhere(stmt.where)
+    }) ?? void 0;
+    if (fullScanExactPlan) prefilterPlan = fullScanExactPlan.prefilterPlan;
+  }
   const mode = whereCapability.capability === "EXACT_PUSHDOWN" ? staticMode : "FULL_SCAN";
   const orderMeta = await buildOrderByMetaForSelect(stmt, client, cacheContext, cteCache);
   const orderPlan = hasCanonicalOrder(stmt) ? (stmt.orderMode === "KINTONE_NATIVE" ? planKorder : planCanonicalOrder)({
@@ -15260,20 +15637,34 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     client,
     cacheContext
   );
-  const completePolicy = buildCompleteInputPolicy(stmt, options, orderPlan);
+  const completePolicy = buildCompleteInputPolicy(
+    stmt,
+    options,
+    orderPlan
+  );
+  const failClosedForB72Local = fullScanExactPlan !== void 0 && (staticMode === "FULL_SCAN" || orderPlan?.kind === "CANONICAL_LOCAL");
+  const executionClient = failClosedForB72Local ? wrapClientWithSearchAbort(client, { aborted: false }, true) : client;
   try {
     if (mode === "SIMPLE") {
-      result = await executeSimpleSelect(stmt, client, completePolicy.effectiveOptions, cacheContext, orderPlan, orderMeta);
+      result = await executeSimpleSelect(
+        stmt,
+        executionClient,
+        completePolicy.effectiveOptions,
+        cacheContext,
+        orderPlan,
+        orderMeta
+      );
     } else {
       result = await executeFullScanSelect(
         stmt,
-        client,
+        executionClient,
         completePolicy.effectiveOptions,
         cacheContext,
         cteCache,
-        whereCapability.capability === "EXACT_PUSHDOWN",
+        whereCapability.capability === "EXACT_PUSHDOWN" && prefilterPlan === void 0,
         orderMeta,
-        prefilterPlan
+        prefilterPlan,
+        plainGroupByPlan
       );
     }
   } catch (error) {
@@ -15287,6 +15678,78 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
   }
   return result;
 }
+async function buildRuntimePlainGroupByPlan(stmt, client, cacheContext, materializedTables) {
+  if (stmt.groupBy.length === 0) return void 0;
+  const sources = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  const inputs = await Promise.all(sources.map(async (source) => {
+    if (source.cteName !== null) {
+      const materialized = materializedTables?.get(source.cteName);
+      if (!materialized) {
+        throw new Error(`InternalError: materialized schema ${source.cteName} is not available for GROUP BY planning.`);
+      }
+      return { kind: "MATERIALIZED", columns: materialized.columns };
+    }
+    const fields = await getFieldsCached(source.appId, client, cacheContext);
+    if (!source.subtableCode) {
+      return {
+        kind: "APP",
+        fieldCodes: fields.filter((field) => !field.inSubtable).map((field) => field.code)
+      };
+    }
+    const exactChildren = fields.filter(
+      (field) => field.inSubtable && field.subtableCode === source.subtableCode
+    );
+    const childFields = exactChildren.length > 0 ? exactChildren : fields.filter((field) => field.inSubtable && field.subtableCode === void 0);
+    return {
+      kind: "SUBTABLE",
+      childFieldCodes: childFields.map((field) => field.code),
+      parentFieldCodes: fields.filter((field) => !field.inSubtable).map((field) => field.code)
+    };
+  }));
+  const schemas = resolvePlainGroupBySourceSchemas(
+    stmt,
+    (_source, sourceIndex) => inputs[sourceIndex]
+  );
+  const groupBy = stmt.groupBy;
+  const plan = planPlainGroupByResolution(groupBy, stmt.columns, schemas);
+  assertRuntimePlainGroupByPlan(stmt, groupBy, plan);
+  return plan;
+}
+function assertRuntimePlainGroupByPlan(stmt, groupBy, plan) {
+  const physicalAppIds = [
+    stmt.from,
+    ...stmt.joins.map((join2) => join2.table)
+  ].flatMap((source) => source.cteName === null ? [source.appId] : []);
+  const uniquePhysicalAppIds = [...new Set(physicalAppIds)];
+  const primaryPhysicalAppId = uniquePhysicalAppIds.length === 1 ? uniquePhysicalAppIds[0] : stmt.from.cteName === null ? stmt.from.appId : null;
+  plan.items.forEach((item, index) => {
+    if (item.kind === "EXPRESSION" || item.kind === "PHYSICAL" || item.kind === "ALIAS_SAFE") return;
+    const key = groupBy[index];
+    const name = key?.type === "FIELD_NAME" ? key.name : "(expression)";
+    if (item.kind === "UNKNOWN") {
+      const appSuffix = primaryPhysicalAppId === null ? "" : ` (APP${primaryPhysicalAppId})`;
+      throw new Error(`ArgumentError: unknown field code(s): ${item.name}${appSuffix}`);
+    }
+    if (item.kind === "ALIAS_REJECT") {
+      if (item.reason === "DUPLICATE") {
+        throw new Error(
+          `ArgumentError: GROUP BY alias ${name} is ambiguous across multiple SELECT columns (reason=GROUP_BY_ALIAS_AMBIGUOUS).`
+        );
+      }
+      if (item.reason === "POST_GROUP_ONLY") {
+        throw new Error(
+          `ArgumentError: GROUP BY alias ${name} requires post-group evaluation (reason=GROUP_BY_ALIAS_POST_GROUP_ONLY).`
+        );
+      }
+      throw new Error(
+        `ArgumentError: GROUP BY alias ${name} depends on aggregate evaluation (reason=GROUP_BY_ALIAS_AGGREGATE).`
+      );
+    }
+    throw new Error(
+      `InternalError: deferred GROUP BY field ${item.name} reached runtime planning.`
+    );
+  });
+}
 var resolvedGroupingSpecs = /* @__PURE__ */ new WeakMap();
 async function validateStatementGroupingPlanning(statement, client, cacheContext) {
   const seen = /* @__PURE__ */ new Set();
@@ -16218,7 +16681,7 @@ function buildSelectFieldTypeResolvers(stmt, fieldTypesByApp) {
   };
   return { row, having };
 }
-async function executeFullScanSelect(stmt, client, options, cacheContext, cteCache, allowOriginalWherePushdown = true, preloadedOrderMeta, prefilterPlan) {
+async function executeFullScanSelect(stmt, client, options, cacheContext, cteCache, allowOriginalWherePushdown = true, preloadedOrderMeta, prefilterPlan, plainGroupByPlan) {
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
   const parallel = options.fetchParallel ?? 1;
@@ -16248,6 +16711,7 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     throw new Error("internal error: relative-date prefilter must disable original WHERE pushdown.");
   }
   const mainFetchCondition = prefilterPlan ? prefilterPlan.prefilterWhere : mainPushDown;
+  const scalarCache = await resolveScalarColumns(stmt.columns, client, options, cacheContext, cteCache);
   const constantFalse = isConstantFalseWhere(stmt.where);
   const mainFetch = constantFalse ? Promise.resolve([]) : fetchTableRecordsForFullScan(
     stmt,
@@ -16259,7 +16723,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     options.onLimitReached ?? "error",
     warnings,
     mainFetchCondition,
-    allowOriginalWherePushdown
+    allowOriginalWherePushdown,
+    plainGroupByPlan
   );
   const parallelJoins = [];
   const onOptJoins = [];
@@ -16281,17 +16746,16 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
           false,
           options.onLimitReached ?? "error",
           warnings,
-          jCond
+          jCond,
+          true,
+          plainGroupByPlan
         )
       });
     } else {
       onOptJoins.push(join2);
     }
   }
-  const scalarCachePromise = resolveScalarColumns(stmt.columns, client, options, cacheContext, cteCache);
   const orderByMetaPromise = preloadedOrderMeta ? Promise.resolve(preloadedOrderMeta) : buildOrderByMetaForSelect(stmt, client, cacheContext, cteCache);
-  scalarCachePromise.catch(() => {
-  });
   orderByMetaPromise.catch(() => {
   });
   const mainRecords = await mainFetch;
@@ -16310,7 +16774,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
       parallel,
       options.onLimitReached ?? "error",
       warnings,
-      null
+      null,
+      plainGroupByPlan
     );
     const joinRecords = optimized ?? await fetchTableRecordsForFullScan(
       stmt,
@@ -16321,11 +16786,12 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
       false,
       options.onLimitReached ?? "error",
       warnings,
-      null
+      null,
+      true,
+      plainGroupByPlan
     );
     tables.set(join2.table.alias, joinRecords);
   }));
-  const scalarCache = await scalarCachePromise;
   const { optionOrders, sortKinds, semantics } = await orderByMetaPromise;
   const { rows, columns } = runFullScan({
     tables,
@@ -16341,7 +16807,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     aggregateSortKindResolver,
     appliedKlikes: prefilterPlan?.appliedKlikes ?? pushdownPlan.appliedKlikes,
     ...prefilterPlan ? { residualWhere: prefilterPlan.residualWhere } : {},
-    resolvedGroupingSpec: resolvedGroupingSpecs.get(stmt)
+    resolvedGroupingSpec: resolvedGroupingSpecs.get(stmt),
+    plainGroupByPlan
   });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
@@ -16434,6 +16901,12 @@ async function executeQueryWithCte(query, client, options, cteCache, cacheContex
 async function executeFullScanWithCte(stmt, client, options, cteCache, cacheContext) {
   await validateSelectGroupingPlanning(stmt, client, cacheContext, cteCache);
   const resolvedGroupingSpec = resolvedGroupingSpecs.get(stmt);
+  const plainGroupByPlan = await buildRuntimePlainGroupByPlan(
+    stmt,
+    client,
+    cacheContext,
+    cteCache
+  );
   const hiddenQualifiedAliases = /* @__PURE__ */ new Set();
   const withEffectiveAlias = (table) => {
     if (table.alias !== null || table.cteName === null) return table;
@@ -16505,10 +16978,14 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   const havingFieldSemanticsResolver = buildHavingFieldSemanticsResolver(stmt, fieldSemanticsResolver);
   const pushdownPlan = buildKlikePushdownPlan(stmt, pushdownMeta);
   validateKlikePushdownPlan(pushdownPlan);
-  const scalarCachePromise = resolveScalarColumns(stmt.columns, client, effectiveOptions, cacheContext, cteCache);
+  const scalarCache = await resolveScalarColumns(
+    stmt.columns,
+    client,
+    effectiveOptions,
+    cacheContext,
+    cteCache
+  );
   const orderByMetaPromise = Promise.resolve(orderMeta);
-  scalarCachePromise.catch(() => {
-  });
   orderByMetaPromise.catch(() => {
   });
   const tables = /* @__PURE__ */ new Map();
@@ -16528,7 +17005,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
       effectiveOptions.onLimitReached ?? "error",
       warnings,
       pushdownPlan.mainCondition,
-      whereCapability.capability === "EXACT_PUSHDOWN"
+      whereCapability.capability === "EXACT_PUSHDOWN",
+      plainGroupByPlan
     ));
     tables.set(stmt.from.alias, mainRecords);
   }
@@ -16548,7 +17026,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
         parallel,
         effectiveOptions.onLimitReached ?? "error",
         warnings,
-        pushDownCond
+        pushDownCond,
+        plainGroupByPlan
       );
       const joinRecords = optimized ?? await fetchTableRecordsForFullScan(
         stmt,
@@ -16559,15 +17038,16 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
         false,
         effectiveOptions.onLimitReached ?? "error",
         warnings,
-        pushDownCond
+        pushDownCond,
+        true,
+        plainGroupByPlan
       );
       tables.set(join2.table.alias, joinRecords);
     }
   }));
   await Promise.all(joinFetches);
-  const scalarCache = await scalarCachePromise;
   const { optionOrders, sortKinds, semantics } = await orderByMetaPromise;
-  const sourceColumns = stmt.joins.length === 0 && stmt.from.cteName != null ? requireMaterializedTable(stmt.from.cteName).columns : void 0;
+  const sourceColumns2 = stmt.joins.length === 0 && stmt.from.cteName != null ? requireMaterializedTable(stmt.from.cteName).columns : void 0;
   const { rows, columns } = runFullScan({
     tables,
     stmt,
@@ -16581,10 +17061,11 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     havingFieldSemanticsResolver,
     aggregateSortKindResolver,
     appliedKlikes: pushdownPlan.appliedKlikes,
-    sourceColumns,
+    sourceColumns: sourceColumns2,
     tableColumns,
     hiddenQualifiedAliases,
-    resolvedGroupingSpec
+    resolvedGroupingSpec,
+    plainGroupByPlan
   });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
@@ -16593,8 +17074,8 @@ function processRowToKintoneRecord(row) {
     Object.entries(row).map(([k, v]) => [k, { value: v ?? "" }])
   );
 }
-async function fetchTableRecordsForFullScan(stmt, table, client, maxRecords, parallel, isMainTable, onLimit, warnings, pushDownCond = null, allowOriginalWherePushdown = true) {
-  const fields = selectToFetchAllFields(stmt, table);
+async function fetchTableRecordsForFullScan(stmt, table, client, maxRecords, parallel, isMainTable, onLimit, warnings, pushDownCond = null, allowOriginalWherePushdown = true, plainGroupByPlan) {
+  const fields = selectToFetchAllFields(stmt, table, plainGroupByPlan);
   const onTruncate = (max) => {
     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`);
   };
@@ -16708,7 +17189,7 @@ function splitChunks(items, size) {
 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) {
+async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxRecords, parallel, onLimit, warnings, pushDownCond = null, plainGroupByPlan) {
   if (join2.type !== "INNER") return null;
   if (!join2.table.alias) return null;
   if (join2.table.subtableCode) return null;
@@ -16745,7 +17226,7 @@ async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxR
     );
     return null;
   }
-  const fields = selectToFetchAllFields(stmt, join2.table);
+  const fields = selectToFetchAllFields(stmt, join2.table, plainGroupByPlan);
   const onTruncate = (max) => {
     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`);
   };
@@ -16787,9 +17268,6 @@ function setScopedCacheValue(root, cacheContext, appId, value) {
   }
   scoped.set(appId, value);
 }
-function isSystemLikeFieldCode(code) {
-  return code.startsWith("_") || code.startsWith("$");
-}
 async function getFieldsCached(appId, client, cacheContext) {
   const cached = getScopedCacheValue(fieldInfoCache, cacheContext, appId);
   if (cached) return cached;
@@ -19985,6 +20463,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
   };
   const capabilities = /* @__PURE__ */ new Map();
   const orderPlans = /* @__PURE__ */ new Map();
+  const plainGroupByPlans = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
   const sharedRelativeDatePlan = relativeDatePlan ?? await resolveRelativeDateExecutionPlan(query, tracedClient, cacheContext);
   const relativeNodeFor = (source) => sharedRelativeDatePlan.nodes.find(
@@ -20002,6 +20481,15 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     if (typed["type"] === "SELECT") {
       const select = node;
       await validateSelectGroupingPlanning(select, tracedClient, cacheContext);
+      const hasUnmaterializedSource = [select.from, ...select.joins.map((join2) => join2.table)].some((table) => table.cteName !== null);
+      if (normalizeGroupingSpec(select).type === "PLAIN" && !hasUnmaterializedSource) {
+        const plainPlan = await buildRuntimePlainGroupByPlan(
+          select,
+          tracedClient,
+          cacheContext
+        );
+        if (plainPlan) plainGroupByPlans.set(select, plainPlan);
+      }
       const physicalApps = [select.from, ...select.joins.map((join2) => join2.table)].filter((table) => table.cteName === null).map((table) => table.appId);
       const needsWhereSchema = whereNeedsFieldMetadata(select.where);
       if (needsWhereSchema || select.orderBy.length > 0 || select.columns.some((column) => column.type === "WINDOW_COL" && column.orderBy.length > 0)) {
@@ -20022,7 +20510,6 @@ 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 && relativeNode?.allowed !== false) {
           const mode = capability.capability === "EXACT_PUSHDOWN" ? resolveSelectMode(select) : "FULL_SCAN";
           orderPlans.set(select, (select.orderMode === "KINTONE_NATIVE" ? planKorder : planCanonicalOrder)({
@@ -20136,6 +20623,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
   return {
     capabilities,
     orderPlans,
+    plainGroupByPlans,
     fieldApps,
     processStatusApps,
     numberPrecisionApps,
@@ -20258,6 +20746,32 @@ function relativeDateExplainLines(plan) {
   }
   const lines = [];
   for (const node of plan.nodes) {
+    const fullScanExactPlan = node.fullScanExactPlan;
+    if (node.allowed && node.allowForm === "FULL_SCAN_EXACT" && fullScanExactPlan) {
+      for (const leaf of fullScanExactPlan.prefilterPlan.exactRelativeLeaves) {
+        const functionName = leaf.right.type === "KINTONE_FUNC" ? leaf.right.name : "(unknown)";
+        const field = leaf.left.type === "FIELD" ? leaf.left.field : void 0;
+        const operator = relativeReasonOperator(leaf.op);
+        const detail = node.capability?.reasons.find(
+          (reason) => reason.functionName === functionName && (field === void 0 || reason.field === field) && reason.operator === operator
+        );
+        lines.push(
+          `  relative date function: ${functionName}`,
+          "  relative date evaluation: kintone server whole-WHERE exact",
+          `  field: ${detail?.field ?? field ?? "(unknown)"} (${detail?.fieldType ?? "unknown"})`,
+          `  operator: ${detail?.operator ?? operator}`
+        );
+      }
+      const wholeWhereQuery = fullScanExactPlan.serializedWholeWhere;
+      lines.push(
+        "  where capability: EXACT_PUSHDOWN",
+        `  server predicate: ${wholeWhereQuery}`,
+        "  client residual: (none)",
+        "  relative date client evaluations: 0",
+        `  kintone query: ${wholeWhereQuery}`
+      );
+      continue;
+    }
     const prefilterPlan = node.prefilterPlan;
     if (node.allowed && prefilterPlan?.prefilterWhere && prefilterPlan.residualWhere) {
       for (const leaf of prefilterPlan.exactRelativeLeaves) {
@@ -20459,7 +20973,8 @@ async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxA
         analysis.orderPlans,
         dmlMaxRows,
         dmlMaxSubtableRows,
-        maxRecords
+        maxRecords,
+        analysis.plainGroupByPlans
       ),
       cursorMaxActive
     )
@@ -20482,13 +20997,13 @@ function addCursorConcurrency(lines, cursorMaxActive) {
   }
   return result;
 }
-function buildExplainPlan(query, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, maxRecords = 1e4) {
-  if (query.type === "UNION") return buildUnionPlan(query, capabilities, orderPlans);
-  if (query.type === "WITH") return buildWithPlan(query, capabilities, orderPlans);
+function buildExplainPlan(query, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, maxRecords = 1e4, plainGroupByPlans) {
+  if (query.type === "UNION") return buildUnionPlan(query, capabilities, orderPlans, plainGroupByPlans);
+  if (query.type === "WITH") return buildWithPlan(query, capabilities, orderPlans, plainGroupByPlans);
   if (query.type === "INSERT") return buildInsertPlan(query, label, dmlMaxRows, dmlMaxSubtableRows);
-  if (query.type === "INSERT_SELECT") return buildInsertSelectPlan(query, label, capabilities, orderPlans);
+  if (query.type === "INSERT_SELECT") return buildInsertSelectPlan(query, label, capabilities, orderPlans, plainGroupByPlans);
   if (query.type === "UPSERT") return buildUpsertPlan(query, label, dmlMaxRows, dmlMaxSubtableRows);
-  if (query.type === "UPSERT_SELECT") return buildUpsertSelectPlan(query, label, capabilities, orderPlans);
+  if (query.type === "UPSERT_SELECT") return buildUpsertSelectPlan(query, label, capabilities, orderPlans, plainGroupByPlans);
   if (query.type === "UPDATE") return buildUpdatePlan(
     query,
     label,
@@ -20574,7 +21089,7 @@ function buildExplainPlan(query, label, capabilities, orderPlans, dmlMaxRows = 1
       `  duplicateKey:  preflight before lookup/write (requires load)`
     ];
   }
-  return buildSelectPlan(query, label, capabilities, orderPlans);
+  return buildSelectPlan(query, label, capabilities, orderPlans, plainGroupByPlans);
 }
 function buildValidatePlan(stmt, label) {
   const info = validateExplainInfo.get(stmt);
@@ -20601,9 +21116,10 @@ function buildValidatePlan(stmt, label) {
   lines.push("  records/mutation API during EXPLAIN: none; violation count unavailable");
   return lines;
 }
-function buildSelectPlan(stmt, label, capabilities, orderPlans) {
+function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlans) {
   const whereCapability = capabilities?.get(stmt) ?? (capabilities ? [...capabilities].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
   const orderPlan = orderPlans?.get(stmt) ?? (orderPlans ? [...orderPlans].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
+  const plainGroupByPlan = plainGroupByPlans?.get(stmt) ?? (plainGroupByPlans ? [...plainGroupByPlans].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
   const mode = orderPlan?.kind === "CANONICAL_LOCAL" ? "FULL_SCAN" : whereCapability && whereCapability.capability !== "EXACT_PUSHDOWN" ? "FULL_SCAN" : resolveSelectMode(stmt);
   const reasons = collectFullScanReasons(stmt);
   if (whereCapability && whereCapability.capability !== "EXACT_PUSHDOWN") {
@@ -20628,6 +21144,29 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans) {
       `  grouping output rows: runtime checked (limit: ${groupingMetadata.outputRowLimit}, before HAVING/DISTINCT/LIMIT)`
     );
   }
+  const normalizedGrouping = normalizeGroupingSpec(stmt);
+  if (normalizedGrouping.type === "PLAIN") {
+    const groupBy = normalizedGrouping.allItems;
+    if (plainGroupByPlan) {
+      plainGroupByPlan.items.forEach((item, index) => {
+        const key = groupBy[index];
+        if (key?.type !== "FIELD_NAME") return;
+        if (item.kind === "PHYSICAL") {
+          lines.push(
+            `  group key ${key.name}: PHYSICAL (source=${item.sourceIndex}, field=${item.fieldCode})`
+          );
+        }
+      });
+    } else if ([stmt.from, ...stmt.joins.map((join2) => join2.table)].some((table) => table.cteName !== null)) {
+      for (const key of groupBy) {
+        if (key.type === "FIELD_NAME") {
+          lines.push(
+            `  group key ${key.name}: DEFERRED (materialized schema unavailable)`
+          );
+        }
+      }
+    }
+  }
   if (orderPlan) {
     lines.push(`  order plan:    ${orderPlan.kind}`);
     if (orderPlan.reasonCodes.length > 0) lines.push(`  order reason:  ${orderPlan.reasonCodes.join(", ")}`);
@@ -20669,7 +21208,7 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans) {
     lines.push(`  fields:        ${params.fields.length === 0 ? "(\u5168\u30D5\u30A3\u30FC\u30EB\u30C9)" : params.fields.join(", ")}`);
   } else {
     const pushdownPlan = buildKlikePushdownPlan(stmt);
-    const mainFields = selectToFetchAllFields(stmt, stmt.from);
+    const mainFields = selectToFetchAllFields(stmt, stmt.from, plainGroupByPlan);
     const mainAliasStr = stmt.from.alias ? ` AS ${stmt.from.alias}` : "";
     const mainPushDown = pushdownPlan.mainCondition;
     const mainCandidate = extractMainTypedPushdownCandidate(stmt);
@@ -20682,7 +21221,7 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans) {
     }
     lines.push(`  fields:        ${mainFields.length === 0 ? "(\u5168\u30D5\u30A3\u30FC\u30EB\u30C9)" : mainFields.join(", ")}`);
     for (const join2 of stmt.joins) {
-      const joinFields = selectToFetchAllFields(stmt, join2.table);
+      const joinFields = selectToFetchAllFields(stmt, join2.table, plainGroupByPlan);
       const joinAliasStr = join2.table.alias ? ` AS ${join2.table.alias}` : "";
       const joinType = join2.type === "INNER" ? "JOIN" : `${join2.type} JOIN`;
       const joinPushDown = join2.table.alias ? pushdownPlan.joinConditions.get(join2.table.alias) ?? null : null;
@@ -20696,10 +21235,10 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans) {
       lines.push(`  fields:        ${joinFields.length === 0 ? "(\u5168\u30D5\u30A3\u30FC\u30EB\u30C9)" : joinFields.join(", ")}`);
     }
   }
-  lines.push(...collectSubqueryPlans(stmt, capabilities, orderPlans));
+  lines.push(...collectSubqueryPlans(stmt, capabilities, orderPlans, plainGroupByPlans));
   return lines;
 }
-function buildUnionPlan(stmt, capabilities, orderPlans) {
+function buildUnionPlan(stmt, capabilities, orderPlans, plainGroupByPlans) {
   const selects = [];
   const collect = (u) => {
     if (u.type === "SELECT") {
@@ -20713,25 +21252,34 @@ function buildUnionPlan(stmt, capabilities, orderPlans) {
   const lines = [];
   selects.forEach((sel, i) => {
     if (i > 0) lines.push("");
-    lines.push(...buildSelectPlan(sel, `[union:${i + 1}]`, capabilities, orderPlans));
+    lines.push(...buildSelectPlan(sel, `[union:${i + 1}]`, capabilities, orderPlans, plainGroupByPlans));
   });
   return lines;
 }
-function buildWithPlan(stmt, capabilities, orderPlans) {
+function buildWithPlan(stmt, capabilities, orderPlans, plainGroupByPlans) {
   const lines = [];
   for (const cte of stmt.ctes) {
     if (cte.query.type === "SELECT") {
-      lines.push(...buildSelectPlan(cte.query, `[cte: ${cte.name}]`, capabilities, orderPlans));
+      lines.push(...buildSelectPlan(cte.query, `[cte: ${cte.name}]`, capabilities, orderPlans, plainGroupByPlans));
       lines.push("");
     }
   }
   if (stmt.query.type === "SELECT" || stmt.query.type === "UNION") {
-    lines.push(...buildExplainPlan(stmt.query, "[main]", capabilities, orderPlans));
+    lines.push(...buildExplainPlan(
+      stmt.query,
+      "[main]",
+      capabilities,
+      orderPlans,
+      100,
+      DEFAULT_APPLY_MAX_SUBTABLE_ROWS,
+      1e4,
+      plainGroupByPlans
+    ));
   }
   if (canInlineSingleCte(stmt)) {
     lines.push("");
     const inlined = buildInlinedQuery(stmt);
-    lines.push(...buildSelectPlan(inlined, "[effective: inlined CTE]", capabilities, orderPlans));
+    lines.push(...buildSelectPlan(inlined, "[effective: inlined CTE]", capabilities, orderPlans, plainGroupByPlans));
   }
   return lines;
 }
@@ -20764,7 +21312,7 @@ function collectFullScanReasons(stmt) {
     r.push("ORDER BY \u306B\u5F0F");
   return r;
 }
-function collectSubqueryPlans(stmt, capabilities, orderPlans) {
+function collectSubqueryPlans(stmt, capabilities, orderPlans, plainGroupByPlans) {
   const lines = [];
   let idx = 1;
   const visitWhere = (w) => {
@@ -20773,16 +21321,16 @@ function collectSubqueryPlans(stmt, capabilities, orderPlans) {
       case "BINARY":
         if (w.right.type === "SCALAR_SUBQUERY") {
           lines.push("");
-          lines.push(...buildSelectPlan(w.right.query, `[subquery:${idx++}]`, capabilities, orderPlans));
+          lines.push(...buildSelectPlan(w.right.query, `[subquery:${idx++}]`, capabilities, orderPlans, plainGroupByPlans));
         }
         if (w.right.type === "SUBQUERY_IN_LIST") {
           lines.push("");
-          lines.push(...buildSelectPlan(w.right.query, `[subquery:${idx++}]`, capabilities, orderPlans));
+          lines.push(...buildSelectPlan(w.right.query, `[subquery:${idx++}]`, capabilities, orderPlans, plainGroupByPlans));
         }
         break;
       case "EXISTS":
         lines.push("");
-        lines.push(...buildSelectPlan(w.query, `[subquery:${idx++}]`, capabilities, orderPlans));
+        lines.push(...buildSelectPlan(w.query, `[subquery:${idx++}]`, capabilities, orderPlans, plainGroupByPlans));
         break;
       case "LOGICAL":
         visitWhere(w.left);
@@ -20802,7 +21350,7 @@ function collectSubqueryPlans(stmt, capabilities, orderPlans) {
   for (const col of stmt.columns) {
     if (col.type === "SCALAR_SUBQUERY_COL") {
       lines.push("");
-      lines.push(...buildSelectPlan(col.query, `[subquery:${idx++}]`, capabilities, orderPlans));
+      lines.push(...buildSelectPlan(col.query, `[subquery:${idx++}]`, capabilities, orderPlans, plainGroupByPlans));
     }
   }
   if (stmt.having) visitWhere(stmt.having);
@@ -20820,7 +21368,7 @@ function buildInsertPlan(stmt, label, dmlMaxRows = DEFAULT_APPLY_MAX_ROWS, dmlMa
   lines.push(`  fields:  ${stmt.fields.join(", ")}`);
   return stmt.applyBlocks?.length ? [...lines, ...formatStaticApplyDiagnostic(buildStaticApplyDiagnostic(stmt, dmlMaxRows, dmlMaxSubtableRows))] : lines;
 }
-function buildInsertSelectPlan(stmt, label, capabilities, orderPlans) {
+function buildInsertSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlans) {
   const lines = [];
   if (label) lines.push(label);
   lines.push(`  [INSERT SELECT]`);
@@ -20828,7 +21376,7 @@ function buildInsertSelectPlan(stmt, label, capabilities, orderPlans) {
   lines.push(`  fields:  ${stmt.fields.join(", ")}`);
   lines.push(`  api:     POST /k/v1/records.json\uFF08\u4EF6\u6570\u306F SELECT \u7D50\u679C\u306B\u4F9D\u5B58\u3001100 \u4EF6\u3054\u3068\u306B\u30D0\u30C3\u30C1\uFF09`);
   lines.push("");
-  lines.push(...buildSelectPlan(stmt.select, "[source SELECT]", capabilities, orderPlans));
+  lines.push(...buildSelectPlan(stmt.select, "[source SELECT]", capabilities, orderPlans, plainGroupByPlans));
   return lines;
 }
 function buildUpdatePlan(stmt, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, maxRecords = 1e4) {
@@ -20982,7 +21530,7 @@ function formatStaticApplyDiagnostic(diagnostic2) {
   lines.push("records API:            0", "mutation API:           0");
   return lines;
 }
-function buildUpsertSelectPlan(stmt, label, capabilities, orderPlans) {
+function buildUpsertSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlans) {
   const lines = [
     ...label ? [label] : [],
     `  [UPSERT SELECT]`,
@@ -20992,7 +21540,7 @@ function buildUpsertSelectPlan(stmt, label, capabilities, orderPlans) {
     `  api:        GET /k/v1/records.json\uFF08\u91CD\u8907\u5224\u5B9A\uFF09\u2192 POST \u307E\u305F\u306F PUT /k/v1/records.json\uFF08100 \u4EF6\u3054\u3068\u306B\u30D0\u30C3\u30C1\uFF09`,
     ``
   ];
-  lines.push(...buildSelectPlan(stmt.select, "[source SELECT]", capabilities, orderPlans));
+  lines.push(...buildSelectPlan(stmt.select, "[source SELECT]", capabilities, orderPlans, plainGroupByPlans));
   return lines;
 }
 function buildReorderPlan(stmt, label) {