@rex0220/kintone-sql-tools 3.22.0 → 3.23.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
   );
@@ -15229,6 +15425,12 @@ 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") {
@@ -15273,7 +15475,8 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
         cteCache,
         whereCapability.capability === "EXACT_PUSHDOWN",
         orderMeta,
-        prefilterPlan
+        prefilterPlan,
+        plainGroupByPlan
       );
     }
   } catch (error) {
@@ -15287,6 +15490,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 +16493,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 +16523,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 +16535,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     options.onLimitReached ?? "error",
     warnings,
     mainFetchCondition,
-    allowOriginalWherePushdown
+    allowOriginalWherePushdown,
+    plainGroupByPlan
   );
   const parallelJoins = [];
   const onOptJoins = [];
@@ -16281,17 +16558,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 +16586,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 +16598,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 +16619,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 +16713,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 +16790,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 +16817,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 +16838,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 +16850,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 +16873,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 +16886,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 +17001,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 +17038,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 +17080,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 +20275,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 +20293,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 +20322,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 +20435,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
   return {
     capabilities,
     orderPlans,
+    plainGroupByPlans,
     fieldApps,
     processStatusApps,
     numberPrecisionApps,
@@ -20459,7 +20759,8 @@ async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxA
         analysis.orderPlans,
         dmlMaxRows,
         dmlMaxSubtableRows,
-        maxRecords
+        maxRecords,
+        analysis.plainGroupByPlans
       ),
       cursorMaxActive
     )
@@ -20482,13 +20783,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 +20875,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 +20902,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 +20930,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 +20994,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 +21007,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 +21021,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 +21038,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 +21098,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 +21107,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 +21136,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 +21154,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 +21162,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 +21316,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 +21326,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) {