@rex0220/kintone-sql-tools 3.56.3 → 3.58.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).`
       );
     }
   }
@@ -10378,11 +10780,11 @@ function validatePostImage(record, fieldIndex, numberPrecision, statementNumber,
     else normalizedRecord[field.code] = { value: preserveCodeObjects(raw, field.fieldType, result.value) };
   }
   for (const [tableCode, children] of fieldIndex.subtables) {
-    const sourceRows = record[tableCode]?.value;
-    if (!Array.isArray(sourceRows)) continue;
+    const sourceRows2 = record[tableCode]?.value;
+    if (!Array.isArray(sourceRows2)) continue;
     const normalizedRows = normalizedRecord[tableCode]?.value;
-    for (let rowIndex = 0; rowIndex < sourceRows.length; rowIndex++) {
-      const sourceRow = sourceRows[rowIndex];
+    for (let rowIndex = 0; rowIndex < sourceRows2.length; rowIndex++) {
+      const sourceRow = sourceRows2[rowIndex];
       const normalizedRow = normalizedRows[rowIndex];
       for (const field of children) {
         const raw = sourceRow.value?.[field.code]?.value;
@@ -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",
@@ -13279,6 +13539,65 @@ async function deriveEmptyWildcardColumns(fields, subtableCode, loadProcessStatu
 }
 
 // src/engine/process.ts
+var materializedSelectValues = /* @__PURE__ */ new WeakMap();
+var sourceRows = /* @__PURE__ */ new WeakMap();
+function asProcessingRow(source) {
+  if (sourceRows.has(source)) return source;
+  let row;
+  row = new Proxy(source, {
+    get(target, property, receiver) {
+      if (typeof property !== "string" || Object.prototype.hasOwnProperty.call(target, property)) {
+        return Reflect.get(target, property, receiver);
+      }
+      return getMaterializedLookupValue(row, property);
+    },
+    has(target, property) {
+      return Reflect.has(target, property) || typeof property === "string" && getMaterializedLookupValue(row, property) !== void 0;
+    },
+    getOwnPropertyDescriptor(target, property) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, property);
+      if (descriptor || typeof property !== "string") return descriptor;
+      const value = getMaterializedLookupValue(row, property);
+      return value === void 0 ? void 0 : { configurable: true, enumerable: false, writable: false, value };
+    }
+  });
+  sourceRows.set(row, source);
+  return row;
+}
+function sourceRowForEvaluation(row) {
+  return sourceRows.get(row) ?? row;
+}
+function materializedValuesFor(row) {
+  let values = materializedSelectValues.get(row);
+  if (!values) {
+    values = { byColumn: /* @__PURE__ */ new Map(), byLookupKey: /* @__PURE__ */ new Map() };
+    materializedSelectValues.set(row, values);
+  }
+  return values;
+}
+function setMaterializedSelectValue(row, columnIndex, value, lookupKeys = []) {
+  const values = materializedValuesFor(row);
+  values.byColumn.set(columnIndex, value);
+  for (const key of lookupKeys) values.byLookupKey.set(key, value);
+}
+function getMaterializedSelectValue(row, columnIndex) {
+  return materializedSelectValues.get(row)?.byColumn.get(columnIndex);
+}
+function getMaterializedLookupValue(row, key) {
+  return materializedSelectValues.get(row)?.byLookupKey.get(key);
+}
+function getLegacyMaterializedValue(row, key) {
+  return materializedSelectValues.has(row) ? void 0 : row[key];
+}
+function havingEvaluationRow(row) {
+  const lookups = materializedSelectValues.get(row)?.byLookupKey;
+  if (!lookups || lookups.size === 0) return row;
+  const evaluationRow = { ...row };
+  for (const [key, value] of lookups) evaluationRow[key] = value;
+  const groupingMeta = getGroupingRowMeta(row);
+  if (groupingMeta) attachGroupingRowMeta(evaluationRow, groupingMeta.includedCanonicalIds);
+  return evaluationRow;
+}
 function flatten(record, alias) {
   const row = {};
   for (const [field, fv] of Object.entries(record)) {
@@ -13383,7 +13702,7 @@ function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolution
   }
   const result = [];
   for (const groupRows of groups.values()) {
-    const outRow = { ...groupRows[0] };
+    const outRow = asProcessingRow({ ...groupRows[0] });
     for (const k of groupByKeys) {
       if (k.type === "ARITH_KEY") {
         outRow[arithColDefaultKey(k.expr)] = String(evalArithExpr(k.expr, groupRows[0]));
@@ -13435,7 +13754,7 @@ function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {})
     }
     const includedCanonicalIds = new Set(set.items.map((item) => item.canonicalId));
     for (const groupRows of buckets) {
-      const outRow = { ...groupRows[0] };
+      const outRow = asProcessingRow({ ...groupRows[0] });
       const includedValues = /* @__PURE__ */ new Map();
       for (const item of set.items) {
         if (!includedValues.has(item.canonicalId)) {
@@ -13465,32 +13784,52 @@ function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortK
     if (col.type === "AGGREGATE") {
       const syntheticKey = aggregateSyntheticName(col.func, col.distinct, col.arg);
       const value = String(evalAggregate(col.func, col.distinct, col.arg, col.separator, groupRows, resolveAggSortKind));
-      outRow[col.alias ?? syntheticKey] = value;
-      if (col.alias) outRow[syntheticKey] = value;
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        value,
+        col.alias ? [col.alias, syntheticKey] : [syntheticKey]
+      );
     } else if (col.type === "ARITH_AGG_COL") {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const outputKey = col.alias ?? aggArithDefaultKey(col.expr);
-      outRow[outputKey] = String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind));
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind)),
+        [outputKey]
+      );
     } else if (col.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(col.expr)) {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const outputKey = col.alias ?? stringFuncDefaultKey(col.expr);
       const resolvedExpr = resolveAggInStringFuncExpr(col.expr, groupRows, resolveAggSortKind);
-      outRow[outputKey] = evalStringFunc(resolvedExpr, outRow);
+      setMaterializedSelectValue(outRow, columnIndex, evalStringFunc(resolvedExpr, outRow), [outputKey]);
     } else if (col.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(col.expr)) {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const outputKey = col.alias ?? scalarValueDefaultKey(col.expr);
       const resolvedExpr = resolveAggInScalarValue(col.expr, groupRows, resolveAggSortKind);
-      outRow[outputKey] = String(evalScalarValueExpr(resolvedExpr, outRow));
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        String(evalScalarValueExpr(resolvedExpr, outRow)),
+        [outputKey]
+      );
     } else if (col.type === "CASE_COL" && containsAggregate2(col.expr)) {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const resolvedExpr = resolveAggInCaseExpr(col.expr, groupRows, resolveAggSortKind);
       const resolveAggregateSemantics = (field) => field.aggregateRef ? aggregateResultSemantics(field.aggregateRef, resolveAggSortKind) : void 0;
-      outRow[caseMaterializedKey(col.alias, columnIndex)] = evalCaseWhen(
+      const value = evalCaseWhen(
         resolvedExpr,
         outRow,
         void 0,
         resolveAggregateSemantics
       );
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        value,
+        [caseMaterializedKey(col.alias, columnIndex)]
+      );
     }
   }
 }
@@ -13516,8 +13855,8 @@ function materializeAggregateDependencies(outRow, rows, node, resolveAggSortKind
   collectAggregateRefs(node, refs);
   for (const ref of refs) {
     const key = aggregateSyntheticName(ref.func, ref.distinct, ref.arg);
-    if (outRow[key] !== void 0) continue;
-    outRow[key] = String(evalAggregate(
+    if (getMaterializedLookupValue(outRow, key) !== void 0) continue;
+    const value = String(evalAggregate(
       ref.func,
       ref.distinct,
       ref.arg,
@@ -13525,6 +13864,7 @@ function materializeAggregateDependencies(outRow, rows, node, resolveAggSortKind
       rows,
       resolveAggSortKind
     ));
+    materializedValuesFor(outRow).byLookupKey.set(key, value);
   }
 }
 function evalGroupByKey(key, row, resolution, columns, aliasEvaluationContext) {
@@ -13639,7 +13979,8 @@ function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind)
   }
 }
 function aggregateRowValues(func, arg, rows) {
-  return rows.map((row) => {
+  return rows.map((processingRow) => {
+    const row = sourceRowForEvaluation(processingRow);
     let strVal;
     if (arg.type === "FIELD_REF") {
       const raw = row[arg.field];
@@ -13720,7 +14061,13 @@ function aggregateResultSemantics(ref, resolver) {
 }
 function applyHaving(rows, having, resolveFieldType, resolveFieldSemantics2) {
   if (having === null) return rows;
-  return rows.filter((row) => evalWhere(having, row, resolveFieldType, void 0, resolveFieldSemantics2));
+  return rows.filter((row) => evalWhere(
+    having,
+    havingEvaluationRow(row),
+    resolveFieldType,
+    void 0,
+    resolveFieldSemantics2
+  ));
 }
 function applyDistinct(rows, columns, scalarCache, resolveFieldType, resolveFieldSemantics2) {
   if (rows.length === 0) return rows;
@@ -13832,13 +14179,14 @@ var NUMERIC_ORDER_FUNCTIONS = /* @__PURE__ */ new Set([
   "WEEK"
 ]);
 function evalOrderKey(key, row, aliasEvaluator) {
+  const sourceRow = sourceRowForEvaluation(row);
   switch (key.type) {
     case "FIELD_NAME":
-      return aliasEvaluator?.(key.name, row) ?? row[key.name] ?? "";
+      return aliasEvaluator?.(key.name, row) ?? getMaterializedLookupValue(row, key.name) ?? sourceRow[key.name] ?? "";
     case "ARITH_KEY":
-      return String(evalArithExpr(key.expr, row));
+      return String(evalArithExpr(key.expr, sourceRow));
     case "FUNC_KEY":
-      return evalStringFunc(key.expr, row);
+      return evalStringFunc(key.expr, sourceRow);
     case "GROUPING_KEY":
       return evalGroupingRef(key.ref, row);
   }
@@ -13850,38 +14198,41 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
     const alias = column.alias;
     switch (column.type) {
       case "FIELD":
-        evaluators.set(alias, (row) => resolveFieldRef(row, column.field));
+        evaluators.set(alias, (row) => resolveFieldRef(sourceRowForEvaluation(row), column.field));
         break;
       case "LITERAL_COL":
         evaluators.set(alias, () => column.value);
         break;
       case "AGGREGATE": {
-        const source = aggregateSyntheticName(column.func, column.distinct, column.arg);
-        evaluators.set(alias, (row) => row[alias] ?? row[source] ?? "0");
+        evaluators.set(alias, (row) => getMaterializedSelectValue(row, columnIndex) ?? "0");
         break;
       }
       case "ARITH_AGG_COL": {
-        const source = aggArithDefaultKey(column.expr);
-        evaluators.set(alias, (row) => row[alias] ?? row[source] ?? "0");
+        evaluators.set(alias, (row) => getMaterializedSelectValue(row, columnIndex) ?? "0");
         break;
       }
       case "WINDOW_COL":
-        evaluators.set(alias, (row) => row[alias] ?? "");
+        evaluators.set(alias, (row) => getMaterializedSelectValue(row, columnIndex) ?? "");
         break;
       case "ARITH_COL":
-        evaluators.set(alias, (row) => String(evalArithExpr(column.expr, row)));
+        evaluators.set(alias, (row) => String(evalArithExpr(column.expr, sourceRowForEvaluation(row))));
         break;
       case "STRFUNC_COL": {
         const source = stringFuncDefaultKey(column.expr);
-        evaluators.set(alias, (row) => hasAggregateInStringFuncExpr2(column.expr) ? row[alias] ?? row[source] ?? evalStringFunc(column.expr, row, resolveFieldType, resolveFieldSemantics2) : evalStringFunc(column.expr, row, resolveFieldType, resolveFieldSemantics2));
+        evaluators.set(alias, (row) => hasAggregateInStringFuncExpr2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? evalStringFunc(column.expr, sourceRowForEvaluation(row), resolveFieldType, resolveFieldSemantics2) : evalStringFunc(column.expr, sourceRowForEvaluation(row), resolveFieldType, resolveFieldSemantics2));
         break;
       }
       case "CASE_COL":
-        evaluators.set(alias, (row) => containsAggregate2(column.expr) ? row[alias] ?? "" : evalCaseWhen(column.expr, row, resolveFieldType, resolveFieldSemantics2));
+        evaluators.set(alias, (row) => containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? "" : evalCaseWhen(column.expr, sourceRowForEvaluation(row), resolveFieldType, resolveFieldSemantics2));
         break;
       case "SCALAR_VALUE_COL": {
         const source = scalarValueDefaultKey(column.expr);
-        evaluators.set(alias, (row) => scalarValueHasAggregate2(column.expr) ? row[alias] ?? row[source] ?? "" : String(evalScalarValueExpr(column.expr, row, resolveFieldType, resolveFieldSemantics2)));
+        evaluators.set(alias, (row) => scalarValueHasAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? "" : String(evalScalarValueExpr(
+          column.expr,
+          sourceRowForEvaluation(row),
+          resolveFieldType,
+          resolveFieldSemantics2
+        )));
         break;
       }
       case "SCALAR_SUBQUERY_COL":
@@ -13897,9 +14248,10 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
   return (name, row) => evaluators.get(name)?.(row);
 }
 function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, resolveAggSortKind) {
-  const windows = columns.filter((column) => column.type === "WINDOW_COL");
+  const windows = columns.map((column, columnIndex) => ({ column, columnIndex })).filter((item) => item.column.type === "WINDOW_COL");
   if (rows.length === 0 || windows.length === 0) return rows;
-  for (const window of windows) {
+  for (let index = 0; index < rows.length; index++) rows[index] = asProcessingRow(rows[index]);
+  for (const { column: window, columnIndex } of windows) {
     const partitions = /* @__PURE__ */ new Map();
     for (const row of rows) {
       const key = JSON.stringify(window.partitionBy.map((ref) => resolveWindowField(row, ref)));
@@ -13911,11 +14263,11 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, re
       const sortedResult = sortDecoratedRows(partition, window.orderBy, optionOrders, sortKinds, fieldSemantics2);
       const sorted = sortedResult.rows;
       if (isAggregateWindow(window)) {
-        applyAggregateWindow(window, sortedResult, resolveAggSortKind);
+        applyAggregateWindow(window, columnIndex, sortedResult, resolveAggSortKind);
         continue;
       }
       if (isValueWindow(window)) {
-        applyValueWindow(window, sorted);
+        applyValueWindow(window, columnIndex, sorted);
         continue;
       }
       if (!isRankingWindow(window)) {
@@ -13929,27 +14281,32 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, re
           denseRank++;
         }
         const value = window.func === "ROW_NUMBER" ? index + 1 : window.func === "RANK" ? rank : denseRank;
-        sorted[index].row[window.alias] = String(value);
+        setMaterializedSelectValue(sorted[index].row, columnIndex, String(value), [window.alias]);
       }
     }
   }
   return rows;
 }
 function evaluateValueWindowArg(arg, row) {
-  const value = evalScalarValueExprNullable(arg, row);
+  const value = evalScalarValueExprNullable(arg, sourceRowForEvaluation(row));
   if (value === null || value === void 0) return "";
   if (typeof value === "number" && !Number.isFinite(value)) return "";
   return String(value);
 }
-function applyValueWindow(window, sorted) {
+function applyValueWindow(window, columnIndex, sorted) {
   const values = sorted.map((item) => evaluateValueWindowArg(window.arg, item.row));
   const direction = window.valueFunc === "LAG" ? -1 : 1;
   for (let index = 0; index < sorted.length; index++) {
     const target = index + direction * window.offset;
-    sorted[index].row[window.alias] = target >= 0 && target < values.length ? values[target] : "";
+    setMaterializedSelectValue(
+      sorted[index].row,
+      columnIndex,
+      target >= 0 && target < values.length ? values[target] : "",
+      [window.alias]
+    );
   }
 }
-function applyAggregateWindow(window, sortedResult, resolveAggSortKind) {
+function applyAggregateWindow(window, columnIndex, sortedResult, resolveAggSortKind) {
   const sorted = sortedResult.rows;
   const values = window.arg.type === "WILDCARD" ? null : aggregateRowValues(window.aggFunc, window.arg, sorted.map((item) => item.row));
   const comparison = window.arg.type === "WILDCARD" ? void 0 : resolveAggregateArgSemantics(window.arg, resolveAggSortKind);
@@ -13982,23 +14339,29 @@ function applyAggregateWindow(window, sortedResult, resolveAggSortKind) {
   }
   if (window.frame === null) {
     const finalValue = output[output.length - 1];
-    for (const item of sorted) item.row[window.alias] = finalValue;
+    for (const item of sorted) {
+      setMaterializedSelectValue(item.row, columnIndex, finalValue, [window.alias]);
+    }
     return;
   }
   if (window.frame.unit === "RANGE") {
     for (let start = 0; start < sorted.length; ) {
       let end = start;
       while (end + 1 < sorted.length && sortedResult.compare(sorted[end], sorted[end + 1]) === 0) end++;
-      for (let index = start; index <= end; index++) sorted[index].row[window.alias] = output[end];
+      for (let index = start; index <= end; index++) {
+        setMaterializedSelectValue(sorted[index].row, columnIndex, output[end], [window.alias]);
+      }
       start = end + 1;
     }
     return;
   }
-  for (let index = 0; index < sorted.length; index++) sorted[index].row[window.alias] = output[index];
+  for (let index = 0; index < sorted.length; index++) {
+    setMaterializedSelectValue(sorted[index].row, columnIndex, output[index], [window.alias]);
+  }
 }
 function resolveWindowField(row, ref) {
   const name = ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
-  return resolveFieldRef(row, name);
+  return resolveFieldRef(sourceRowForEvaluation(row), name);
 }
 function applyLimit(rows, limit, offset) {
   const start = offset ?? 0;
@@ -14006,41 +14369,42 @@ function applyLimit(rows, limit, offset) {
   return rows.slice(start, start + limit);
 }
 function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
+  const sourceRow = sourceRowForEvaluation(row);
   switch (column.type) {
     case "VARIABLE_COL":
       throw new Error(`internal error: unresolved SELECT variable @${column.name}`);
     case "WILDCARD": {
-      const keys = context.wildcardKeys ?? Object.keys(row);
+      const keys = context.wildcardKeys ?? Object.keys(sourceRow);
       return {
         kind: "EXPANDED",
-        entries: keys.map((key) => [key, row[key] !== void 0 ? row[key] : null])
+        entries: keys.map((key) => [key, sourceRow[key] !== void 0 ? sourceRow[key] : null])
       };
     }
     case "PARENT_WILDCARD": {
-      const keys = context.parentWildcardKeys ?? Object.keys(row).filter((key) => key.startsWith("_p.")).sort();
+      const keys = context.parentWildcardKeys ?? Object.keys(sourceRow).filter((key) => key.startsWith("_p.")).sort();
       return {
         kind: "EXPANDED",
-        entries: keys.map((key) => [key, row[key] !== void 0 ? row[key] : null])
+        entries: keys.map((key) => [key, sourceRow[key] !== void 0 ? sourceRow[key] : null])
       };
     }
     case "FIELD":
-      return resolveFieldRef(row, column.field);
+      return resolveFieldRef(sourceRow, column.field);
     case "LITERAL_COL":
       return column.value;
     case "AGGREGATE": {
       const source = aggregateSyntheticName(column.func, column.distinct, column.arg);
-      return row[column.alias ?? source] ?? row[source] ?? "0";
+      return getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? source) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, column.alias ?? source) ?? getLegacyMaterializedValue(row, source) ?? "0";
     }
     case "ARITH_AGG_COL": {
       const source = column.alias ?? aggArithDefaultKey(column.expr);
-      return row[source] ?? "0";
+      return getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, source) ?? "0";
     }
     case "ARITH_COL":
-      return String(evalArithExpr(column.expr, row));
+      return String(evalArithExpr(column.expr, sourceRow));
     case "CASE_COL":
-      return containsAggregate2(column.expr) ? row[caseMaterializedKey(column.alias, columnIndex)] ?? "" : evalCaseWhen(
+      return containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? getLegacyMaterializedValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? "" : evalCaseWhen(
         column.expr,
-        row,
+        sourceRow,
         context.resolveFieldType,
         context.resolveFieldSemantics
       );
@@ -14048,23 +14412,23 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
       return evalGroupingRef(column.ref, row);
     case "STRFUNC_COL": {
       const source = stringFuncDefaultKey(column.expr);
-      return hasAggregateInStringFuncExpr2(column.expr) ? row[column.alias ?? source] ?? row[source] ?? evalStringFunc(
+      return hasAggregateInStringFuncExpr2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? source) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, column.alias ?? source) ?? getLegacyMaterializedValue(row, source) ?? evalStringFunc(
         column.expr,
-        row,
+        sourceRow,
         context.resolveFieldType,
         context.resolveFieldSemantics
       ) : evalStringFunc(
         column.expr,
-        row,
+        sourceRow,
         context.resolveFieldType,
         context.resolveFieldSemantics
       );
     }
     case "SCALAR_VALUE_COL": {
       const source = scalarValueDefaultKey(column.expr);
-      return scalarValueHasAggregate2(column.expr) ? row[column.alias ?? source] ?? row[source] ?? "" : String(evalScalarValueExpr(
+      return scalarValueHasAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? source) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, column.alias ?? source) ?? getLegacyMaterializedValue(row, source) ?? "" : String(evalScalarValueExpr(
         column.expr,
-        row,
+        sourceRow,
         context.resolveFieldType,
         context.resolveFieldSemantics
       ));
@@ -14072,7 +14436,7 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
     case "SCALAR_SUBQUERY_COL":
       return context.scalarCache?.get(columnIndex) ?? "";
     case "WINDOW_COL":
-      return row[column.alias] ?? "";
+      return getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias) ?? getLegacyMaterializedValue(row, column.alias) ?? "";
   }
 }
 function buildDistinctTuple(columns, row, context = {}) {
@@ -16166,9 +16530,9 @@ function render(value) {
 function buildImportRecordPayload(top, subtables, rowIdMode) {
   const record = {};
   for (const [code, value] of top) record[code] = { value };
-  for (const [tableCode, sourceRows] of subtables) {
+  for (const [tableCode, sourceRows2] of subtables) {
     record[tableCode] = {
-      value: sourceRows.map((sourceRow) => ({
+      value: sourceRows2.map((sourceRow) => ({
         ...rowIdMode === "PRESERVE" && sourceRow.rowId ? { id: sourceRow.rowId } : {},
         value: Object.fromEntries([...sourceRow.values].map(([childCode, value]) => [childCode, { value }]))
       }))
@@ -17189,7 +17553,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);
@@ -17725,7 +18095,7 @@ function canProveTotalWindowOrder(stmt, orderBy, resolveField2, context) {
 }
 function tieBreakAdvice(context, kind) {
   if (context !== "DIRECT") {
-    return "\u305D\u306E\u8868\u306E\u4E2D\u3067\u4E00\u610F\u306B\u306A\u308B\u5217\uFF08\u5143\u306E\u96C6\u7D04\u306E\u30AD\u30FC\u306A\u3069\uFF09\u3092 ORDER BY \u306B\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002\u96C6\u7D04\u7D50\u679C\u306E\u5217\u306F\u4E00\u610F\u3067\u3082\u8A3C\u660E\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u3059\u3067\u306B\u4E00\u610F\u306A\u5834\u5408\u3082\u3053\u306E\u8B66\u544A\u304C\u51FA\u307E\u3059\u3002";
+    return "\u305D\u306E\u8868\u306E\u4E2D\u3067\u4E00\u610F\u306B\u306A\u308B\u5217\uFF08\u5143\u306E\u96C6\u7D04\u306E\u30AD\u30FC\u306A\u3069\uFF09\u3092 ORDER BY \u306B\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002\u96C6\u7D04\u7D50\u679C\u306E\u5217\u306F\u4E00\u610F\u3067\u3082\u8A3C\u660E\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u3059\u3067\u306B\u4E00\u610F\u306A\u5834\u5408\u3082\u3053\u306E\u8B66\u544A\u304C\u51FA\u307E\u3059\u3002\u5143\u306E\u96C6\u7D04\u306E\u30AD\u30FC\u3092\u3059\u3079\u3066 ORDER BY \u306B\u542B\u3081\u3066\u3044\u308B\u306A\u3089\u3001\u3053\u306E\u8B66\u544A\u306F\u7121\u8996\u3057\u3066\u69CB\u3044\u307E\u305B\u3093\u3002";
   }
   return kind === "RANGE" ? "ORDER BY \u306B\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u306A\u3069\u306E\u30BF\u30A4\u30D6\u30EC\u30FC\u30AF\u30AD\u30FC\u3092\u8DB3\u3057\u3066\u304F\u3060\u3055\u3044\u3002" : "\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u7B49\u3092 ORDER BY \u306B\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
 }
@@ -17998,7 +18368,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 +18411,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 +18470,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 +18520,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 +18534,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 +18545,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 +18553,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 +18565,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 +19706,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 +19730,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 };
@@ -20084,10 +20474,10 @@ async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxR
   } else {
     return null;
   }
-  const sourceRows = tables.get(sourceAlias);
-  if (!sourceRows) return null;
+  const sourceRows2 = tables.get(sourceAlias);
+  if (!sourceRows2) return null;
   const keys = /* @__PURE__ */ new Set();
-  for (const row of sourceRows) {
+  for (const row of sourceRows2) {
     const raw = row[sourceField]?.value;
     const txt = toScalarText(raw).trim();
     if (txt.length > 0) keys.add(txt);
@@ -20997,7 +21387,7 @@ async function materializeValidationCandidates(stmt, operation, client, options,
     );
   }
   let rows;
-  let sourceRows;
+  let sourceRows2;
   let sourcePresence;
   let sourceRowErrors;
   let evaluationTypes;
@@ -21018,7 +21408,7 @@ async function materializeValidationCandidates(stmt, operation, client, options,
       throw customCheckParseError("CHECK \u4ED8\u304D DML \u30BD\u30FC\u30B9 SELECT \u306E\u51FA\u529B\u540D\u306F\u4E00\u610F\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059");
     }
     assertInsertCheckRefs(stmt, selectResult.columns);
-    sourceRows = selectResult.rows;
+    sourceRows2 = selectResult.rows;
     sourcePresence = selectResult.importPresence;
     sourceRowErrors = selectResult.importRowErrors;
     const meta = selectResult.columnMeta;
@@ -21039,7 +21429,7 @@ async function materializeValidationCandidates(stmt, operation, client, options,
     )),
     preErrors: [...sourceRowErrors?.[index] ?? []],
     record: {},
-    evaluationRow: sourceRows?.[index] ?? Object.fromEntries(
+    evaluationRow: sourceRows2?.[index] ?? Object.fromEntries(
       stmt.fields.map((field, i) => [field, renderValidationValue(values[i])])
     ),
     evaluationFieldTypes: evaluationTypes
@@ -21335,7 +21725,7 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
   const checkScope = await resolveUpdateFromCheckScope(stmt, from, client, cacheContext, tempTables);
   const sourceFields = [...new Set(stmt.assignments.filter((a) => a.value.type === "SOURCE_FIELD").map((a) => a.value.type === "SOURCE_FIELD" ? a.value.field : "").concat(checkScope.sourceFields))];
   const requiredSourceFields = [.../* @__PURE__ */ new Set([from.joinKeyField, ...sourceFields])];
-  const sourceRows = await loadUpdateFromSourceRows(
+  const sourceRows2 = await loadUpdateFromSourceRows(
     from,
     requiredSourceFields,
     sourceFields,
@@ -21346,7 +21736,7 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
   );
   const sourceByKey = /* @__PURE__ */ new Map();
   const sourceQueryByKey = /* @__PURE__ */ new Map();
-  for (const row of sourceRows) {
+  for (const row of sourceRows2) {
     if (!Object.prototype.hasOwnProperty.call(row, from.joinKeyField)) {
       throw new Error(`ArgumentError: UPDATE ... FROM source column ${from.joinKeyField} does not exist.`);
     }
@@ -23359,7 +23749,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 +23776,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 +24560,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 +24568,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 +24863,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)) {