@rex0220/kintone-sql-tools 3.56.2 → 3.57.0

package/dist-cli/ksql.js

@@ -604,7 +604,7 @@ function expandCubeGroupingSets(items) {
     if (expandedSetCount > Math.floor(B65_MAX_GROUPING_SETS / 2)) {
       const rejectedSetCount = expandedSetCount * 2;
       throw new Error(
-        `ArgumentError: B65 expanded grouping set count ${rejectedSetCount} exceeds limit ${B65_MAX_GROUPING_SETS} (reason=GROUPING_SET_LIMIT_EXCEEDED).`
+        `ArgumentError: expanded grouping set count ${rejectedSetCount} exceeds limit ${B65_MAX_GROUPING_SETS} (reason=GROUPING_SET_LIMIT_EXCEEDED).`
       );
     }
     expandedSetCount *= 2;
@@ -5622,26 +5622,488 @@ function evalGroupingRef(ref, row) {
   return membership.has(canonicalId) ? "0" : "1";
 }
 
+// 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 containsAggregate2(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 resolvePlainFieldReference(ref, schemas) {
+  const name = ref.tableAlias === null ? ref.field : `${ref.tableAlias}.${ref.field}`;
+  const parsed = ref.tableAlias === null ? parseGroupName(ref.field) : { qualifier: ref.tableAlias, fieldCode: ref.field };
+  const candidateSources = parsed.qualifier === null ? schemas : schemas.filter((source2) => source2.qualifier === parsed.qualifier);
+  const physical = candidateSources.filter((source2) => source2.columns.includes(parsed.fieldCode));
+  if (physical.length > 1) return { kind: "AMBIGUOUS", name };
+  if (physical.length === 0) return { kind: "UNKNOWN", name };
+  const source = physical[0];
+  return {
+    kind: "PHYSICAL",
+    sourceIndex: source.sourceIndex,
+    fieldCode: parsed.fieldCode,
+    runtimeKey: runtimeKey(source, parsed.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/core/aggregateDependencyValidation.ts
+var NON_GROUPED_DEPENDENCY_REASON = "B65_NON_GROUPED_DEPENDENCY";
+var WRAPPER_EXPR = /* @__PURE__ */ new Map([
+  ["ARITH_COL", "expr"],
+  ["ARITH_AGG_COL", "expr"],
+  ["STRFUNC_COL", "expr"],
+  ["SCALAR_VALUE_COL", "expr"],
+  ["CASE_COL", "expr"],
+  ["ARITH_KEY", "expr"],
+  ["FUNC_KEY", "expr"],
+  ["FUNC_FIELD", "expr"],
+  ["ARITH_FIELD", "expr"],
+  ["CASE_FIELD", "expr"],
+  ["ARITH_VALUE", "expr"],
+  ["CASE_VALUE", "expr"],
+  ["AGG_FIELD", "expr"]
+]);
+function refFromName(name) {
+  if (name.startsWith("_p.")) return { type: "FIELD", tableAlias: null, field: name };
+  const dot = name.indexOf(".");
+  return dot > 0 ? { type: "FIELD", tableAlias: name.slice(0, dot), field: name.slice(dot + 1) } : { type: "FIELD", tableAlias: null, field: name };
+}
+function fieldRefFromNode(value) {
+  const type = value["type"];
+  if (type === "FIELD_REF" && typeof value["field"] === "string") {
+    return refFromName(value["field"]);
+  }
+  if (type === "AGG_GROUP_KEY" && typeof value["field"] === "string") {
+    return {
+      type: "FIELD",
+      tableAlias: typeof value["tableAlias"] === "string" ? value["tableAlias"] : null,
+      field: value["field"]
+    };
+  }
+  if (type === "FIELD" && typeof value["field"] === "string") {
+    if (value["aggregateRef"] !== void 0) return null;
+    const tableAlias = typeof value["tableAlias"] === "string" ? value["tableAlias"] : null;
+    return tableAlias === null ? refFromName(value["field"]) : {
+      type: "FIELD",
+      tableAlias,
+      field: value["field"]
+    };
+  }
+  return null;
+}
+function isQueryBoundary(value) {
+  return value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY" || value["type"] === "SCALAR_SUBQUERY_COL" || value["type"] === "SUBQUERY_IN_LIST" || value["type"] === "EXISTS";
+}
+function isAggregateBoundary(value) {
+  return value["type"] === "AGGREGATE" || value["type"] === "AGG_REF";
+}
+function isWindowBoundary(value) {
+  return value["type"] === "WINDOW_COL";
+}
+function numberMeaning(value) {
+  const number = value["value"];
+  if (typeof number !== "number") return "?";
+  if (Object.is(number, -0)) return "0";
+  return String(number);
+}
+function canonicalExpression(node, resolveField2) {
+  if (node === null) return "null";
+  if (typeof node === "string" || typeof node === "boolean") return JSON.stringify(node);
+  if (typeof node === "number") return String(node);
+  if (Array.isArray(node)) {
+    const items = node.map((item) => canonicalExpression(item, resolveField2));
+    return items.some((item) => item === null) ? null : `[${items.join(",")}]`;
+  }
+  if (typeof node !== "object") return null;
+  const value = node;
+  const type = value["type"];
+  if (type === "VARIABLE" || type === "VARIABLE_COL" || isQueryBoundary(value)) return null;
+  if (type === "GROUP" && value["expr"] !== void 0) {
+    return canonicalExpression(value["expr"], resolveField2);
+  }
+  const wrapper = typeof type === "string" ? WRAPPER_EXPR.get(type) : void 0;
+  if (wrapper !== void 0) return canonicalExpression(value[wrapper], resolveField2);
+  if (type === "LITERAL_COL") return `STRING:${JSON.stringify(value["value"] ?? "")}`;
+  if (type === "STRING") return `STRING:${JSON.stringify(value["value"] ?? "")}`;
+  if (type === "NUMBER") return `NUMBER:${numberMeaning(value)}`;
+  if (type === "BOOLEAN") return `BOOLEAN:${String(value["value"])}`;
+  const ref = fieldRefFromNode(value);
+  if (ref !== null) {
+    try {
+      return `FIELD:${resolveField2(ref)}`;
+    } catch {
+      return null;
+    }
+  }
+  if (type === "FIELD" && value["aggregateRef"] !== void 0) return null;
+  const ignored = /* @__PURE__ */ new Set([
+    "alias",
+    "aliasDisplay",
+    "raw",
+    "separator",
+    "distinct",
+    "source"
+  ]);
+  const parts = [];
+  for (const key of Object.keys(value)) {
+    if (key === "type" || ignored.has(key)) continue;
+    const child = canonicalExpression(value[key], resolveField2);
+    if (child === null) return null;
+    parts.push(`${key}=${child}`);
+  }
+  const semanticType = type === "ARITH" || type === "SCALAR_ARITH" ? "ARITH" : String(type ?? "OBJECT");
+  return `${semanticType}(${parts.join(",")})`;
+}
+function explicitAlias2(column) {
+  return "alias" in column && typeof column.alias === "string" ? column.alias : null;
+}
+function aliasesByName(columns) {
+  const result = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    const alias = explicitAlias2(column);
+    if (alias === null) continue;
+    result.set(alias, [...result.get(alias) ?? [], column]);
+  }
+  return result;
+}
+function displayField(ref) {
+  return ref.tableAlias === null ? ref.field : `${ref.tableAlias}.${ref.field}`;
+}
+var AGGREGATE_SYNTHETIC_REFERENCE = /^(COUNT|SUM|AVG|MAX|MIN|GROUP_CONCAT|STDDEV_POP|STDDEV_SAMP|VAR_POP|VAR_SAMP|MEDIAN|MODE)\(/;
+function displayExpression(node) {
+  if (node && typeof node === "object") {
+    const value = node;
+    const ref = fieldRefFromNode(value);
+    if (ref !== null) return displayField(ref);
+    if (value["type"] === "FIELD_NAME" && typeof value["name"] === "string") return value["name"];
+    if (value["type"] === "WILDCARD") return "*";
+    if (value["type"] === "PARENT_WILDCARD") return "_p.*";
+    const alias = value["alias"];
+    if (typeof alias === "string" && alias.length > 0) return alias;
+    const wrapper = typeof value["type"] === "string" ? WRAPPER_EXPR.get(value["type"]) : void 0;
+    if (wrapper !== void 0) {
+      const inner = displayExpression(value[wrapper]);
+      if (inner !== "\u5F0F") return inner;
+    }
+    const func = value["func"];
+    if (typeof func === "string" && func.length > 0) return `${func}(...)`;
+  }
+  return "\u5F0F";
+}
+function dependencyError(clause, expression, dependency, policy) {
+  const dependencyLabel = dependency === "WILDCARD" ? "wildcard" : displayField(dependency);
+  const expressionLabel = dependency === "WILDCARD" ? displayExpression(expression) : displayExpression(expression);
+  const groupText = policy.groupingLabel === null ? "GROUP BY \u304C\u306A\u3044\u305F\u3081\u5165\u529B\u5168\u4F53\u304C1\u30B0\u30EB\u30FC\u30D7\u306B\u306A\u308A" : `${policy.groupingLabel} \u306E\u5404\u30B0\u30EB\u30FC\u30D7\u3067\u306F`;
+  const migration = dependency === "WILDCARD" ? "\u5FC5\u8981\u306A grouping \u5217\u3092\u660E\u793A\u3057\u3066 SELECT \u3057\u3066\u304F\u3060\u3055\u3044\u3002" : `\u300C${dependencyLabel}\u300D\u3092 MIN() \u306A\u3069\u306E\u96C6\u8A08\u95A2\u6570\u3067\u5305\u3080\u304B\u3001GROUP BY \u3078\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044\u3002`;
+  const concreteMigration = dependency !== "WILDCARD" && dependency.tableAlias === null && expressionLabel === dependencyLabel && policy.migrationSourceSql !== void 0 ? policy.migrationGroupingFields && policy.migrationGroupingFields.length > 0 ? ` \u5B9F\u884C\u53EF\u80FD\u306A\u66F8\u304D\u63DB\u3048\u4F8B: \u300CSELECT ${policy.migrationGroupingFields.join(", ")}, MIN(${dependencyLabel}) FROM ${policy.migrationSourceSql} GROUP BY ${policy.migrationGroupingFields.join(", ")}\u300D\u3002` : ` \u5B9F\u884C\u53EF\u80FD\u306A\u66F8\u304D\u63DB\u3048\u4F8B: \u300CSELECT MIN(${dependencyLabel}) FROM ${policy.migrationSourceSql}\u300D\u3002` : "";
+  return new Error(
+    `ArgumentError: ${clause} \u5F0F\u300C${expressionLabel}\u300D\u306F\u96C6\u8A08\u3082\u30B0\u30EB\u30FC\u30D7\u5316\u3082\u3055\u308C\u3066\u3044\u307E\u305B\u3093\uFF08${policy.sourceLabel}\u3001\u975E\u30B0\u30EB\u30FC\u30D7\u5316\u4F9D\u5B58: ${dependencyLabel}\uFF09\u3002${groupText}\u3001\u3069\u306E\u884C\u306E\u5024\u3092\u8FD4\u3059\u304B\u6C7A\u307E\u308A\u307E\u305B\u3093\u3002${migration}${concreteMigration} (reason=${NON_GROUPED_DEPENDENCY_REASON})`
+  );
+}
+function walkDependency(node, context) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const child of node) walkDependency(child, context);
+    return;
+  }
+  const value = node;
+  if (isQueryBoundary(value) || isAggregateBoundary(value) || isWindowBoundary(value)) return;
+  if (value["type"] === "GROUPING_REF" || value["type"] === "GROUPING_FIELD" || value["type"] === "GROUPING_COL" || value["type"] === "GROUPING_KEY") return;
+  if (value["type"] === "WILDCARD" || value["type"] === "PARENT_WILDCARD") {
+    throw dependencyError(context.clause, context.expression, "WILDCARD", context.policy);
+  }
+  const ref = fieldRefFromNode(value);
+  if (ref !== null) {
+    if (context.clause !== "SELECT" && ref.tableAlias === null && AGGREGATE_SYNTHETIC_REFERENCE.test(ref.field)) return;
+    if (context.clause !== "SELECT" && ref.tableAlias === null) {
+      const targets = context.aliases.get(ref.field) ?? [];
+      if (targets.length === 1 && !context.resolvingAliases.has(ref.field)) {
+        const resolvingAliases = new Set(context.resolvingAliases);
+        resolvingAliases.add(ref.field);
+        walkDependency(targets[0], { ...context, resolvingAliases });
+        return;
+      }
+    }
+    const canonical2 = canonicalExpression(value, context.policy.resolveField);
+    if (canonical2 !== null && context.policy.identities.has(canonical2)) return;
+    const identity = `FIELD:${context.policy.resolveField(ref)}`;
+    if (!context.policy.identities.has(identity)) {
+      throw dependencyError(context.clause, context.expression, ref, context.policy);
+    }
+    return;
+  }
+  const canonical = canonicalExpression(value, context.policy.resolveField);
+  if (canonical !== null && context.policy.identities.has(canonical)) return;
+  const wrapper = typeof value["type"] === "string" ? WRAPPER_EXPR.get(value["type"]) : void 0;
+  if (wrapper !== void 0) {
+    walkDependency(value[wrapper], context);
+    return;
+  }
+  for (const key of Object.keys(value)) {
+    if (key === "type" || key === "alias" || key === "aliasDisplay" || key === "raw") continue;
+    walkDependency(value[key], context);
+  }
+}
+function validateAggregateDependencies(stmt, policy) {
+  const aliases = aliasesByName(stmt.columns);
+  for (const column of stmt.columns) {
+    if (column.type === "WINDOW_COL") continue;
+    walkDependency(column, {
+      clause: "SELECT",
+      expression: column,
+      policy,
+      aliases,
+      resolvingAliases: /* @__PURE__ */ new Set()
+    });
+  }
+  if (stmt.having !== null) {
+    walkDependency(stmt.having, {
+      clause: "HAVING",
+      expression: stmt.having,
+      policy,
+      aliases,
+      resolvingAliases: /* @__PURE__ */ new Set()
+    });
+  }
+  for (const order of stmt.orderBy) {
+    const key = order.key.type === "FIELD_NAME" ? refFromName(order.key.name) : order.key;
+    walkDependency(key, {
+      clause: "ORDER BY",
+      expression: key,
+      policy,
+      aliases,
+      resolvingAliases: /* @__PURE__ */ new Set()
+    });
+  }
+}
+function hasAggregateNode(node) {
+  if (node === null || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some(hasAggregateNode);
+  const value = node;
+  if (isQueryBoundary(value) || isWindowBoundary(value)) return false;
+  if (isAggregateBoundary(value) || value["type"] === "ARITH_AGG_COL") return true;
+  return Object.values(value).some(hasAggregateNode);
+}
+function isAggregateQueryBlock(stmt) {
+  return normalizeGroupingSpec(stmt).type !== "NONE" || stmt.columns.some((column) => column.type !== "WINDOW_COL" && hasAggregateNode(column));
+}
+function groupByKeyNode(key) {
+  if (key.type === "FIELD_NAME") return refFromName(key.name);
+  return key.expr;
+}
+function buildOrdinaryDependencyPolicy(stmt, plan, schemas) {
+  const normalized = normalizeGroupingSpec(stmt);
+  if (normalized.type !== "PLAIN") {
+    throw new Error("InternalError: ordinary dependency policy requires plain GROUP BY.");
+  }
+  const groupBy = normalized.allItems;
+  const resolveField2 = (ref) => {
+    const resolution = resolvePlainFieldReference(ref, schemas);
+    if (resolution.kind === "AMBIGUOUS") {
+      throw new Error(`ArgumentError: field ${resolution.name} is ambiguous across multiple sources.`);
+    }
+    if (resolution.kind === "UNKNOWN") return `unknown:${resolution.name}`;
+    return `source:${resolution.sourceIndex}:${resolution.fieldCode}`;
+  };
+  const identities = /* @__PURE__ */ new Set();
+  plan.items.forEach((item, index) => {
+    if (item.kind === "PHYSICAL") {
+      identities.add(`FIELD:source:${item.sourceIndex}:${item.fieldCode}`);
+      return;
+    }
+    if (item.kind === "ALIAS_SAFE") {
+      const key = canonicalExpression(stmt.columns[item.columnIndex], resolveField2);
+      if (key !== null) identities.add(key);
+      return;
+    }
+    if (item.kind === "EXPRESSION") {
+      const key = canonicalExpression(groupByKeyNode(groupBy[index]), resolveField2);
+      if (key !== null) identities.add(key);
+    }
+  });
+  const sources = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  const sourceSql = (source) => `APP${source.appId}${source.subtableCode != null ? `$${source.subtableCode}` : ""}`;
+  const sourceLabel = sources.map((source) => source.cteName ?? sourceSql(source)).join(" / ");
+  const groupingLabel = `GROUP BY ${groupBy.map(
+    (key) => key.type === "FIELD_NAME" ? key.name : displayExpression(key)
+  ).join(", ")}`;
+  const directAppSource = sources.length === 1 && sources[0].cteName === null ? `${sourceSql(sources[0])}${sources[0].alias && sources[0].alias !== sourceSql(sources[0]) ? ` ${sources[0].alias}` : ""}` : void 0;
+  const migrationGroupingFields = groupBy.every(
+    (key, index) => key.type === "FIELD_NAME" && plan.items[index]?.kind === "PHYSICAL"
+  ) ? groupBy.map((key) => key.name) : void 0;
+  return {
+    identities,
+    resolveField: resolveField2,
+    sourceLabel,
+    groupingLabel,
+    migrationSourceSql: directAppSource,
+    migrationGroupingFields
+  };
+}
+function validateAggregateDependenciesStatic(stmt) {
+  if (normalizeGroupingSpec(stmt).type !== "NONE" || !isAggregateQueryBlock(stmt)) return;
+  const policy = {
+    identities: /* @__PURE__ */ new Set(),
+    resolveField: (ref) => `ast:${displayField(ref)}`,
+    sourceLabel: stmt.from.cteName ?? `APP${stmt.from.appId}`,
+    groupingLabel: null,
+    migrationSourceSql: stmt.from.cteName === null && stmt.joins.length === 0 ? `APP${stmt.from.appId}${stmt.from.alias && stmt.from.alias !== `APP${stmt.from.appId}` ? ` ${stmt.from.alias}` : ""}` : void 0
+  };
+  validateAggregateDependencies(stmt, policy);
+}
+function canonicalGroupingFieldIdentity(canonicalId) {
+  return `FIELD:${canonicalId}`;
+}
+
 // src/core/groupingValidation.ts
 var enforceGroupingPlanningCandidateLimits = (facts) => {
   if (facts.expandedSetCount > B65_MAX_GROUPING_SETS) {
     throw new Error(
-      `ArgumentError: B65 expanded grouping set count ${facts.expandedSetCount} exceeds limit ${B65_MAX_GROUPING_SETS} (reason=GROUPING_SET_LIMIT_EXCEEDED).`
+      `ArgumentError: expanded grouping set count ${facts.expandedSetCount} exceeds limit ${B65_MAX_GROUPING_SETS} (reason=GROUPING_SET_LIMIT_EXCEEDED).`
     );
   }
   if (facts.canonicalItemCount > B65_MAX_GROUPING_ITEMS) {
     throw new Error(
-      `ArgumentError: B65 canonical grouping item count ${facts.canonicalItemCount} exceeds limit ${B65_MAX_GROUPING_ITEMS} (reason=GROUPING_ITEM_LIMIT_EXCEEDED).`
+      `ArgumentError: canonical grouping item count ${facts.canonicalItemCount} exceeds limit ${B65_MAX_GROUPING_ITEMS} (reason=GROUPING_ITEM_LIMIT_EXCEEDED).`
     );
   }
 };
-function displayField(field) {
+function displayField2(field) {
   return field.tableAlias ? `${field.tableAlias}.${field.field}` : field.field;
 }
-function refFromName(name) {
-  const dot = name.indexOf(".");
-  return dot > 0 ? { type: "FIELD", tableAlias: name.slice(0, dot), field: name.slice(dot + 1) } : { type: "FIELD", tableAlias: null, field: name };
-}
 function collectGroupingRefs(node, out) {
   if (node === null || typeof node !== "object") return;
   if (Array.isArray(node)) {
@@ -5670,30 +6132,6 @@ function collectAggregateArgumentGroupingRefs(node, out) {
   }
   Object.values(value).forEach((item) => collectAggregateArgumentGroupingRefs(item, out));
 }
-function collectNonAggregateFieldRefs(node, out) {
-  if (node === null || typeof node !== "object") return;
-  if (Array.isArray(node)) {
-    node.forEach((item) => collectNonAggregateFieldRefs(item, out));
-    return;
-  }
-  const value = node;
-  const type = value["type"];
-  if (type === "SELECT" || type === "SCALAR_SUBQUERY" || type === "GROUPING_REF" || type === "AGG_REF" || type === "AGG_ARITH") return;
-  if (type === "FIELD" && value["aggregateRef"] !== void 0) return;
-  if (type === "FIELD" && typeof value["field"] === "string") {
-    out.push({
-      type: "FIELD",
-      tableAlias: typeof value["tableAlias"] === "string" ? value["tableAlias"] : null,
-      field: value["field"]
-    });
-    return;
-  }
-  if (type === "FIELD_REF" && typeof value["field"] === "string") {
-    out.push(refFromName(value["field"]));
-    return;
-  }
-  Object.values(value).forEach((item) => collectNonAggregateFieldRefs(item, out));
-}
 function containsAggregate2(node) {
   if (node === null || typeof node !== "object") return false;
   if (Array.isArray(node)) return node.some(containsAggregate2);
@@ -5710,41 +6148,18 @@ function isAggregateMaterializedAlias(column) {
   }
   return false;
 }
-function outputAliases(columns) {
-  return new Set(columns.flatMap(
-    (column) => "alias" in column && typeof column.alias === "string" ? [column.alias] : []
-  ));
-}
-function isAggregateSyntheticReference(ref) {
-  return ref.tableAlias === null && /^(COUNT|SUM|AVG|MAX|MIN|GROUP_CONCAT|STDDEV_POP|STDDEV_SAMP|VAR_POP|VAR_SAMP|MEDIAN|MODE)\(/.test(ref.field);
-}
 function validateGroupingRefMembership(ref, resolve2, canonicalItems) {
   const resolved = resolve2(ref.field);
   if (!resolved.physical) {
-    throw new Error(`ArgumentError: B65 grouping reference ${displayField(ref.field)} must resolve to a physical APP field.`);
+    throw new Error(`ArgumentError: grouping reference ${displayField2(ref.field)} must resolve to a physical APP field.`);
   }
   if (!canonicalItems.has(resolved.canonicalId)) {
     throw new Error(
-      `ArgumentError: B65 GROUPING argument ${displayField(ref.field)} is not present in grouping allItems (reason=B65_GROUPING_ARG_NOT_ITEM).`
+      `ArgumentError: GROUPING argument ${displayField2(ref.field)} is not present in grouping allItems (reason=B65_GROUPING_ARG_NOT_ITEM).`
     );
   }
   bindGroupingRefCanonicalId(ref, resolved.canonicalId);
 }
-function validateDependency(ref, resolve2, canonicalItems, context) {
-  const resolved = resolve2(ref);
-  if (!resolved.physical || !canonicalItems.has(resolved.canonicalId)) {
-    throw new Error(
-      `ArgumentError: B65 non-aggregate field ${displayField(ref)} in ${context} is not a grouping item (reason=B65_NON_GROUPED_DEPENDENCY).`
-    );
-  }
-}
-function keyDependencies(key) {
-  if (key.type === "GROUPING_KEY") return [];
-  if (key.type === "FIELD_NAME") return [refFromName(key.name)];
-  const refs = [];
-  collectNonAggregateFieldRefs(key, refs);
-  return refs;
-}
 function validateGroupingStatic(stmt) {
   const normalized = normalizeGroupingSpec(stmt);
   const groupingRefs = [];
@@ -5763,25 +6178,28 @@ function validateGroupingStatic(stmt) {
   }
   if (forbiddenGroupingRefs.length > 0) {
     throw new Error(
-      "ArgumentError: B65 GROUPING() is not allowed in WHERE, JOIN, window, aggregate arguments, or DML expressions."
+      "ArgumentError: GROUPING() is not allowed in WHERE, JOIN, window, aggregate arguments, or DML expressions."
     );
   }
   if (normalized.type !== "GROUPING_SETS") {
     if (groupingRefs.length > 0) {
-      throw new Error("ArgumentError: B65 GROUPING() requires GROUP BY ROLLUP or GROUPING SETS.");
+      throw new Error("ArgumentError: GROUPING() requires GROUP BY ROLLUP or GROUPING SETS.");
     }
+    validateAggregateDependenciesStatic(stmt);
     return;
   }
   if (stmt.orderMode === "KINTONE_NATIVE") {
-    throw new Error("ArgumentError: B65 KORDER BY is not supported in Phase1.");
+    throw new Error("ArgumentError: KORDER BY is not supported with extended grouping.");
   }
   if (stmt.columns.some((column) => column.type === "WINDOW_COL")) {
-    throw new Error("ArgumentError: B65 window functions are not supported in Phase1.");
+    throw new Error("ArgumentError: window functions are not supported with extended grouping.");
   }
   if (stmt.columns.some(
     (column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD"
   )) {
-    throw new Error("ArgumentError: B65 wildcard projection is not supported in Phase1.");
+    throw new Error(
+      "ArgumentError: SELECT wildcard \u306F\u96C6\u8A08 query \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002\u5FC5\u8981\u306A grouping \u5217\u3092\u660E\u793A\u3057\u3066\u304F\u3060\u3055\u3044 (reason=B65_NON_GROUPED_DEPENDENCY)."
+    );
   }
 }
 function validateGroupingPlanning(stmt, resolve2, planningGuardHook = () => void 0) {
@@ -5802,7 +6220,7 @@ function validateGroupingPlanning(stmt, resolve2, planningGuardHook = () => void
   for (const item of resolvedSpec.allItems) {
     const resolved = item;
     if (!resolved.physical) {
-      throw new Error(`ArgumentError: B65 grouping item ${displayField(item.field)} must resolve to a physical APP field.`);
+      throw new Error(`ArgumentError: grouping item ${displayField2(item.field)} must resolve to a physical APP field.`);
     }
     if (!canonicalItems.has(resolved.canonicalId)) {
       canonicalItems.add(resolved.canonicalId);
@@ -5816,28 +6234,12 @@ function validateGroupingPlanning(stmt, resolve2, planningGuardHook = () => void
   for (const ref of groupingRefs) {
     validateGroupingRefMembership(ref, resolve2, canonicalItems);
   }
-  const aliases = outputAliases(stmt.columns);
-  for (const column of stmt.columns) {
-    if (column.type === "GROUPING_COL" || column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL" || column.type === "LITERAL_COL" || column.type === "VARIABLE_COL" || column.type === "SCALAR_SUBQUERY_COL") continue;
-    const refs = [];
-    if (column.type === "FIELD") refs.push(refFromName(column.field));
-    else collectNonAggregateFieldRefs(column, refs);
-    for (const ref of refs) validateDependency(ref, resolve2, canonicalItems, "SELECT");
-  }
-  if (stmt.having) {
-    const refs = [];
-    collectNonAggregateFieldRefs(stmt.having, refs);
-    for (const ref of refs) {
-      if (ref.tableAlias === null && aliases.has(ref.field) || isAggregateSyntheticReference(ref)) continue;
-      validateDependency(ref, resolve2, canonicalItems, "HAVING");
-    }
-  }
-  for (const order of stmt.orderBy) {
-    for (const ref of keyDependencies(order.key)) {
-      if (ref.tableAlias === null && aliases.has(ref.field) || isAggregateSyntheticReference(ref)) continue;
-      validateDependency(ref, resolve2, canonicalItems, "ORDER BY");
-    }
-  }
+  validateAggregateDependencies(stmt, {
+    identities: new Set([...canonicalItems].map(canonicalGroupingFieldIdentity)),
+    resolveField: (ref) => resolve2(ref).canonicalId,
+    sourceLabel: stmt.from.cteName ?? `APP${stmt.from.appId}`,
+    groupingLabel: `GROUP BY ${normalized.source}`
+  });
   const collisionKeys = /* @__PURE__ */ new Set();
   for (const item of resolvedItems) {
     collisionKeys.add(item.directKey);
@@ -5849,7 +6251,7 @@ function validateGroupingPlanning(stmt, resolve2, planningGuardHook = () => void
     if (alias === null) continue;
     if (collisionKeys.has(alias)) {
       throw new Error(
-        `ArgumentError: B65 aggregate alias ${alias} collides with a grouping runtime key (reason=B65_AGGREGATE_ALIAS_COLLISION).`
+        `ArgumentError: aggregate alias ${alias} collides with a grouping runtime key (reason=B65_AGGREGATE_ALIAS_COLLISION).`
       );
     }
   }
@@ -13077,148 +13479,6 @@ 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 containsAggregate2(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/core/emptyWildcardSchema.ts
 var EMPTY_WILDCARD_FIELD_TYPE_POLICY = {
   CALC: "RECORD",
@@ -17189,7 +17449,13 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
     return { tempTable: stmt.name };
   }
   if (stmt.type === "EXPLAIN") {
-    return { result: await executeParsedStatement(resolvedStmt, client, options, cacheContext) };
+    const explainStmt = resolvedStmt;
+    explainMaterializedTables.set(explainStmt, tempTables);
+    try {
+      return { result: await executeParsedStatement(explainStmt, client, options, cacheContext) };
+    } finally {
+      explainMaterializedTables.delete(explainStmt);
+    }
   }
   if (resolvedStmt.type === "ASSERT") {
     await executeAssert(resolvedStmt, client, options, cacheContext, tempTables);
@@ -17998,7 +18264,12 @@ function dedupeSubtableOwners(owners) {
   return result;
 }
 async function buildRuntimePlainGroupByPlan(stmt, client, cacheContext, materializedTables) {
-  if (stmt.groupBy.length === 0) return void 0;
+  const normalized = normalizeGroupingSpec(stmt);
+  if (!isAggregateQueryBlock(stmt) || normalized.type === "GROUPING_SETS") {
+    return void 0;
+  }
+  if (normalized.type === "NONE") return void 0;
+  const groupBy = normalized.allItems;
   const sources = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
   const subtableOwners = /* @__PURE__ */ new Map();
   const inputs = await Promise.all(sources.map(async (source) => {
@@ -18036,9 +18307,9 @@ async function buildRuntimePlainGroupByPlan(stmt, client, cacheContext, material
     stmt,
     (_source, sourceIndex) => inputs[sourceIndex]
   );
-  const groupBy = stmt.groupBy;
   const plan = planPlainGroupByResolution(groupBy, stmt.columns, schemas);
   assertRuntimePlainGroupByPlan(stmt, groupBy, plan, subtableOwners);
+  validateAggregateDependencies(stmt, buildOrdinaryDependencyPolicy(stmt, plan, schemas));
   return plan;
 }
 function assertRuntimePlainGroupByPlan(stmt, groupBy, plan, subtableOwners) {
@@ -18095,7 +18366,9 @@ async function validateStatementGroupingPlanning(statement, client, cacheContext
     }
     const value = node;
     if (value["type"] === "SELECT") {
+      for (const child of Object.values(value)) await visit(child);
       await validateSelectGroupingPlanning(node, client, cacheContext);
+      return;
     }
     for (const child of Object.values(value)) await visit(child);
   };
@@ -18143,12 +18416,12 @@ async function buildGroupingFieldResolver(stmt, client, cacheContext, materializ
     if (field.tableAlias !== null) {
       const tableIndex = tables.findIndex((table2) => effectiveTableAlias(table2) === field.tableAlias);
       if (tableIndex < 0) {
-        throw new Error(`ArgumentError: B65 field ${field.tableAlias}.${field.field} has an unknown table alias.`);
+        throw new Error(`ArgumentError: field ${field.tableAlias}.${field.field} has an unknown table alias.`);
       }
       const table = tables[tableIndex];
       if (table.cteName !== null) {
         throw new Error(
-          `ArgumentError: B65 field ${field.tableAlias}.${field.field} resolves to materialized source ${table.cteName}; physical APP fields are required.`
+          `ArgumentError: field ${field.tableAlias}.${field.field} resolves to materialized source ${table.cteName}; physical APP fields are required.`
         );
       }
       const code = physicalMatch(table, field.field);
@@ -18157,7 +18430,7 @@ async function buildGroupingFieldResolver(stmt, client, cacheContext, materializ
         if (owner !== null && owner !== "") {
           throw new Error(subtableGroupingAdvice(field.field, [{ appId: table.appId, owner }]));
         }
-        throw new Error(`ArgumentError: B65 field ${field.tableAlias}.${field.field} does not exist in APP${table.appId}.`);
+        throw new Error(`ArgumentError: field ${field.tableAlias}.${field.field} does not exist in APP${table.appId}.`);
       }
       return resolved(table, tableIndex, field, code);
     }
@@ -18168,7 +18441,7 @@ async function buildGroupingFieldResolver(stmt, client, cacheContext, materializ
     });
     const materializedMatches = tables.filter((table) => materializedHas(table, field.field));
     if (physicalMatches.length + materializedMatches.length > 1) {
-      throw new Error(`ArgumentError: B65 field ${field.field} is ambiguous across multiple sources.`);
+      throw new Error(`ArgumentError: field ${field.field} is ambiguous across multiple sources.`);
     }
     if (physicalMatches.length === 1 && materializedMatches.length === 0) {
       const match = physicalMatches[0];
@@ -18176,7 +18449,7 @@ async function buildGroupingFieldResolver(stmt, client, cacheContext, materializ
     }
     if (materializedMatches.length === 1) {
       throw new Error(
-        `ArgumentError: B65 field ${field.field} resolves to a materialized CTE/temp column; physical APP fields are required.`
+        `ArgumentError: field ${field.field} resolves to a materialized CTE/temp column; physical APP fields are required.`
       );
     }
     const owners = tables.flatMap((table) => {
@@ -18188,21 +18461,34 @@ async function buildGroupingFieldResolver(stmt, client, cacheContext, materializ
     if (uniqueOwners.length > 0) {
       throw new Error(subtableGroupingAdvice(field.field, uniqueOwners));
     }
-    throw new Error(`ArgumentError: B65 field ${field.field} does not exist in a physical APP source.`);
+    throw new Error(`ArgumentError: field ${field.field} does not exist in a physical APP source.`);
   };
 }
 async function validateSelectGroupingPlanning(stmt, client, cacheContext, materializedTables) {
   resolvedGroupingSpecs.delete(stmt);
   const normalized = normalizeGroupingSpec(stmt);
   const hasGroupingNodes = JSON.stringify(stmt.columns).includes('"GROUPING_') || JSON.stringify(stmt.orderBy).includes('"GROUPING_');
-  if (normalized.type === "NONE" && !hasGroupingNodes) return;
-  const resolver = await buildGroupingFieldResolver(stmt, client, cacheContext, materializedTables);
-  const resolvedSpec = validateGroupingPlanning(
-    stmt,
-    resolver,
-    enforceGroupingPlanningCandidateLimits
+  if (normalized.type === "GROUPING_SETS" || hasGroupingNodes) {
+    const resolver = await buildGroupingFieldResolver(stmt, client, cacheContext, materializedTables);
+    const resolvedSpec = validateGroupingPlanning(
+      stmt,
+      resolver,
+      enforceGroupingPlanningCandidateLimits
+    );
+    if (resolvedSpec) resolvedGroupingSpecs.set(stmt, resolvedSpec);
+    return;
+  }
+  if (!isAggregateQueryBlock(stmt)) return;
+  if (normalized.type === "NONE") {
+    validateAggregateDependenciesStatic(stmt);
+    return;
+  }
+  const sources = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  const hasUnavailableMaterializedSource = sources.some(
+    (source) => source.cteName !== null && !materializedTables?.has(source.cteName)
   );
-  if (resolvedSpec) resolvedGroupingSpecs.set(stmt, resolvedSpec);
+  if (hasUnavailableMaterializedSource) return;
+  await buildRuntimePlainGroupByPlan(stmt, client, cacheContext, materializedTables);
 }
 function completeInputErrorPrefix(reasons) {
   const reasonList = [...reasons].join(", ");
@@ -19316,7 +19602,7 @@ function mergeUnionColumnMeta(left, right) {
 function buildSelectFieldTypeResolvers(stmt, fieldTypesByApp) {
   const tables = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
   const physicalTables = tables.filter((table) => table.cteName === null);
-  const outputAliases2 = new Set(
+  const outputAliases = new Set(
     stmt.columns.map((column) => "alias" in column ? column.alias : null).filter((alias) => alias !== null)
   );
   const row = (field) => {
@@ -19340,7 +19626,7 @@ function buildSelectFieldTypeResolvers(stmt, fieldTypesByApp) {
     return matches.length === 1 ? matches[0] : void 0;
   };
   const having = (field) => {
-    if (field.tableAlias === null && outputAliases2.has(field.field)) return void 0;
+    if (field.tableAlias === null && outputAliases.has(field.field)) return void 0;
     return row(field);
   };
   return { row, having };
@@ -23359,7 +23645,7 @@ var explainJoinPushdownPlans = /* @__PURE__ */ new WeakMap();
 var explainChoiceEqualityRewrites = /* @__PURE__ */ new WeakMap();
 var validateExplainInfo = /* @__PURE__ */ new WeakMap();
 var applyParentExplainPlan = /* @__PURE__ */ new WeakMap();
-async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords = 1e4, relativeDatePlan) {
+async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords = 1e4, relativeDatePlan, initialRelations) {
   const fieldApps = /* @__PURE__ */ new Set();
   const processStatusApps = /* @__PURE__ */ new Set();
   const numberPrecisionApps = /* @__PURE__ */ new Set();
@@ -23386,6 +23672,119 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
   const relativeNodeFor = (source) => sharedRelativeDatePlan.nodes.find(
     (node) => node.source === source || JSON.stringify(node.source) === JSON.stringify(source)
   );
+  const explainRelations = new Map(initialRelations ?? []);
+  const explainSourceColumns = async (select) => {
+    const tables = [select.from, ...select.joins.map((join2) => join2.table)];
+    if (tables.length > 1 && select.columns.some(
+      (column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD"
+    )) {
+      throw new Error(
+        "ArgumentError: EXPLAIN could not determine the relation output schema for a multi-source wildcard SELECT."
+      );
+    }
+    const columns = [];
+    for (const table of tables) {
+      if (table.cteName !== null) {
+        if (table.cteName === NO_FROM_CTE_NAME) continue;
+        const relation = explainRelations.get(table.cteName);
+        if (!relation) {
+          throw new Error(
+            `ArgumentError: EXPLAIN could not determine the relation output schema for ${table.cteName}.`
+          );
+        }
+        columns.push(...relation.columns);
+        continue;
+      }
+      const fields = await getFieldsCached(table.appId, tracedClient, cacheContext);
+      if (table.subtableCode) {
+        columns.push(...fields.filter(
+          (field) => field.inSubtable && (field.subtableCode === table.subtableCode || field.subtableCode === void 0)
+        ).map((field) => field.code));
+        columns.push("_pid", "_rid", "_idx");
+        columns.push(...fields.filter((field) => !field.inSubtable).map((field) => `_p.${field.code}`));
+      } else {
+        columns.push(...fields.filter((field) => !field.inSubtable).map((field) => field.code));
+        columns.push(...APP_SYSTEM_FIELD_CODES);
+      }
+    }
+    return [...new Set(columns)];
+  };
+  const inferExplainRelationColumns = async (node) => {
+    if (node === null || typeof node !== "object") {
+      throw new Error("ArgumentError: EXPLAIN could not determine the relation output schema.");
+    }
+    const typed = node;
+    if (typed["type"] === "SELECT") {
+      const select = node;
+      const sourceColumns2 = await explainSourceColumns(select);
+      if (select.columns.length === 1 && select.columns[0].type === "WILDCARD") {
+        return sourceColumns2;
+      }
+      const output = [];
+      for (const column of select.columns) {
+        if (column.type === "WILDCARD") output.push(...sourceColumns2);
+        else if (column.type === "PARENT_WILDCARD") {
+          output.push(...sourceColumns2.filter((name) => name.startsWith("_p.")));
+        } else {
+          output.push(...project([], [column]).columns);
+        }
+      }
+      return output;
+    }
+    if (typed["type"] === "UNION") {
+      return inferExplainRelationColumns(typed["left"]);
+    }
+    if (typed["type"] === "SHOW_APPS") return [...SHOW_APPS_COLUMNS];
+    if (typed["type"] === "DESCRIBE") return [...DESCRIBE_COLUMNS];
+    throw new Error("ArgumentError: EXPLAIN could not determine the relation output schema.");
+  };
+  const preflightExplainRelations = async (node) => {
+    if (node === null || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const child of node) await preflightExplainRelations(child);
+      return;
+    }
+    const typed = node;
+    if (typed["type"] === "WITH") {
+      const withStatement = node;
+      for (const cte of withStatement.ctes) {
+        await preflightExplainRelations(cte.query);
+        const columns = await inferExplainRelationColumns(cte.query);
+        explainRelations.set(cte.name, { rows: [], columns });
+      }
+      await preflightExplainRelations(withStatement.query);
+      return;
+    }
+    if (typed["type"] === "UNION") {
+      await preflightExplainRelations(typed["left"]);
+      await preflightExplainRelations(typed["right"]);
+      return;
+    }
+    if (typed["type"] === "SELECT") {
+      const select = node;
+      for (const column of select.columns) {
+        if (column.type === "SCALAR_SUBQUERY_COL") await preflightExplainRelations(column.query);
+      }
+      await preflightExplainRelations(select.where);
+      await preflightExplainRelations(select.having);
+      await validateSelectGroupingPlanning(
+        select,
+        tracedClient,
+        cacheContext,
+        explainRelations
+      );
+      const plainPlan = await buildRuntimePlainGroupByPlan(
+        select,
+        tracedClient,
+        cacheContext,
+        explainRelations
+      );
+      if (plainPlan) plainGroupByPlans.set(select, plainPlan);
+      return;
+    }
+    for (const child of Object.values(typed)) await preflightExplainRelations(child);
+  };
+  await preflightExplainRelations(query);
   const visit = async (node) => {
     if (node === null || typeof node !== "object") return;
     if (seen.has(node)) return;
@@ -24057,6 +24456,7 @@ function buildPlanForBatchQuery(query, info, capabilities, orderPlans, collector
   lines.push("  note:          \u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u3078\u306E WHERE \u30D7\u30C3\u30B7\u30E5\u30C0\u30A6\u30F3\u306F\u884C\u308F\u308C\u306A\u3044");
   return lines;
 }
+var explainMaterializedTables = /* @__PURE__ */ new WeakMap();
 async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxActive, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, relativeDatePlan) {
   const sharedPlan = relativeDatePlan ?? await resolveRelativeDateExecutionPlan(stmt.query, client, cacheContext);
   const analysis = await buildExplainWhereAnalysis(
@@ -24064,7 +24464,8 @@ async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxA
     client,
     cacheContext,
     maxRecords,
-    sharedPlan
+    sharedPlan,
+    explainMaterializedTables.get(stmt)
   );
   const fetchCollector = { sources: [] };
   const relativeLines = relativeDateExplainLines(sharedPlan);
@@ -24358,6 +24759,12 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
           lines.push(
             `  group key ${key.name}: PHYSICAL (source=${item.sourceIndex}, field=${item.fieldCode})`
           );
+        } else if (item.kind === "ALIAS_SAFE") {
+          lines.push(
+            `  group key ${key.name}: ALIAS_SAFE (column=${item.columnIndex})`
+          );
+        } else if (item.kind === "EXPRESSION") {
+          lines.push(`  group key ${key.name}: EXPRESSION`);
         }
       });
     } else if ([stmt.from, ...stmt.joins.map((join2) => join2.table)].some((table) => table.cteName !== null)) {