@rex0220/kintone-sql-tools 3.17.1 → 3.18.0

package/dist-cli/ksql.js

@@ -584,6 +584,87 @@ function numberLiteralText(node) {
   return toPlainDecimal(source) ?? source;
 }
 
+// src/core/grouping.ts
+var B65_MAX_GROUPING_SETS = 64;
+var B65_MAX_GROUPING_ITEMS = 16;
+var B65_MAX_GENERATED_ROWS = 5e4;
+function expandCubeGroupingSets(items) {
+  let expandedSetCount = 1;
+  for (const _item of 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).`
+      );
+    }
+    expandedSetCount *= 2;
+  }
+  let sets = [{ items: [] }];
+  for (const item of items) {
+    sets = sets.flatMap((set) => [
+      { items: [...set.items, item] },
+      { items: [...set.items] }
+    ]);
+  }
+  return sets;
+}
+function groupingFieldSyntaxKey(item) {
+  return `${item.tableAlias ?? ""}\0${item.field}`;
+}
+function normalizeGroupingSpec(stmt) {
+  if (stmt.grouping !== void 0 && stmt.groupBy.length > 0) {
+    throw new Error("internal error: SELECT cannot contain both groupBy and grouping.");
+  }
+  if (stmt.grouping === void 0) {
+    return stmt.groupBy.length === 0 ? { type: "NONE" } : { type: "PLAIN", allItems: stmt.groupBy, sets: [stmt.groupBy] };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const allItems = [];
+  for (const set of stmt.grouping.sets) {
+    for (const item of set.items) {
+      const key = groupingFieldSyntaxKey(item);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      allItems.push(item);
+    }
+  }
+  const sets = stmt.grouping.sets.map((set) => ({ items: [...set.items] }));
+  return {
+    type: "GROUPING_SETS",
+    source: stmt.grouping.source,
+    allItems,
+    sets
+  };
+}
+function hasGroupingClause(stmt) {
+  return normalizeGroupingSpec(stmt).type !== "NONE";
+}
+function resolveGroupingSpec(stmt, resolve2) {
+  const normalized = normalizeGroupingSpec(stmt);
+  if (normalized.type !== "GROUPING_SETS") return null;
+  const byCanonicalId = /* @__PURE__ */ new Map();
+  const resolveItem = (field) => {
+    const resolved = resolve2(field);
+    const existing = byCanonicalId.get(resolved.canonicalId);
+    if (existing) return existing;
+    const item = { ...resolved, field };
+    byCanonicalId.set(item.canonicalId, item);
+    return item;
+  };
+  const allItems = normalized.allItems.map(resolveItem).filter(
+    (item, index, items) => items.findIndex((candidate) => candidate.canonicalId === item.canonicalId) === index
+  );
+  const sets = normalized.sets.map((set) => ({
+    items: set.items.map(resolveItem)
+  }));
+  return {
+    type: "GROUPING_SETS",
+    source: normalized.source,
+    allItems,
+    sets
+  };
+}
+
 // src/core/aggregateExpression.ts
 function quote(value) {
   return `'${value.replace(/'/g, "''")}'`;
@@ -906,8 +987,8 @@ var Parser = class {
     this.scalarAllowsCase = true;
     this.pos = 0;
     this.insideAggregateArg = 0;
-    /** GROUPING(field) is only legal while parsing a SELECT CASE condition. */
-    this.groupingFieldAllowedDepth = 0;
+    /** GROUPING(field) is limited to the explicitly selected query context. */
+    this.groupingFieldContext = "FORBIDDEN";
     /** WITH 句で定義された CTE 名のセット（parseTableRef で参照） */
     this.cteNames = /* @__PURE__ */ new Set();
     /** パース中に出現した一時テーブル参照（#name）のトークン。単文 API での拒否に使う */
@@ -1652,7 +1733,7 @@ var Parser = class {
       } else if (this.isRollupStart()) {
         grouping = this.parseRollupClause();
       } else if (this.isCubeStart()) {
-        throw new ParseError("B65: CUBE is not supported in Phase1.", this.peek());
+        grouping = this.parseCubeClause();
       } else {
         groupBy = this.parseGroupByKeys();
       }
@@ -1660,7 +1741,7 @@ var Parser = class {
         throw new ParseError("B65: ordinary GROUP BY items cannot be mixed with grouping elements.", this.peek());
       }
       if (this.consume("HAVING" /* HAVING */)) {
-        having = this.parseWhereExpr();
+        having = this.parseWhereExpr("HAVING");
       }
     }
     let orderMode = "CANONICAL";
@@ -2188,12 +2269,7 @@ var Parser = class {
   }
   parseCaseCondition(allowGroupingCondition) {
     if (!allowGroupingCondition) return this.parseWhereExpr();
-    this.groupingFieldAllowedDepth++;
-    try {
-      return this.parseWhereExpr();
-    } finally {
-      this.groupingFieldAllowedDepth--;
-    }
+    return this.parseWhereExpr("SELECT_CASE");
   }
   /** THEN / ELSE の結果値。`||` を含む場合だけ新スカラー文法へ渡す。 */
   parseCaseResult() {
@@ -2510,8 +2586,14 @@ var Parser = class {
   // ----------------------------------------------------------
   // WHERE 式（再帰下降・優先順位付き）
   // ----------------------------------------------------------
-  parseWhereExpr() {
-    return this.parseOrExpr();
+  parseWhereExpr(groupingFieldContext = this.groupingFieldContext) {
+    const previousContext = this.groupingFieldContext;
+    this.groupingFieldContext = groupingFieldContext;
+    try {
+      return this.parseOrExpr();
+    } finally {
+      this.groupingFieldContext = previousContext;
+    }
   }
   // OR（最低優先度）
   parseOrExpr() {
@@ -2680,9 +2762,9 @@ var Parser = class {
       throw new ParseError("B65: GROUPING_ID is not supported in Phase1.", this.peek());
     }
     if (this.isGroupingFunctionStart()) {
-      if (this.groupingFieldAllowedDepth === 0) {
+      if (this.groupingFieldContext === "FORBIDDEN" || this.insideAggregateArg > 0) {
         throw new ParseError(
-          "B65: GROUPING() is only allowed in SELECT, SELECT CASE conditions, and direct ORDER BY.",
+          "B65: GROUPING() is only allowed in SELECT, SELECT CASE conditions, HAVING, and direct ORDER BY.",
           this.peek()
         );
       }
@@ -2942,6 +3024,25 @@ var Parser = class {
       sets
     };
   }
+  parseCubeClause() {
+    this.advance();
+    this.expect("(" /* LPAREN */);
+    if (this.peek().kind === ")" /* RPAREN */) {
+      throw new ParseError("B65: CUBE requires at least one field.", this.peek());
+    }
+    const items = [];
+    do {
+      items.push(this.parseGroupingFieldItem());
+    } while (this.consume("," /* COMMA */));
+    this.expect(")" /* RPAREN */);
+    const sets = expandCubeGroupingSets(items);
+    return {
+      type: "GROUPING_SETS",
+      source: "CUBE",
+      allItems: this.groupingAllItems(sets),
+      sets
+    };
+  }
   parseGroupingRef() {
     const start = this.advance();
     this.expect("(" /* LPAREN */);
@@ -3930,67 +4031,6 @@ function extractTableRef(name, tok) {
   return { appId: Number(m[1]), subtableCode: m[2] ?? null };
 }
 
-// src/core/grouping.ts
-var B65_MAX_GROUPING_SETS = 64;
-var B65_MAX_GROUPING_ITEMS = 16;
-var B65_MAX_GENERATED_ROWS = 5e4;
-function groupingFieldSyntaxKey(item) {
-  return `${item.tableAlias ?? ""}\0${item.field}`;
-}
-function normalizeGroupingSpec(stmt) {
-  if (stmt.grouping !== void 0 && stmt.groupBy.length > 0) {
-    throw new Error("internal error: SELECT cannot contain both groupBy and grouping.");
-  }
-  if (stmt.grouping === void 0) {
-    return stmt.groupBy.length === 0 ? { type: "NONE" } : { type: "PLAIN", allItems: stmt.groupBy, sets: [stmt.groupBy] };
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const allItems = [];
-  for (const set of stmt.grouping.sets) {
-    for (const item of set.items) {
-      const key = groupingFieldSyntaxKey(item);
-      if (seen.has(key)) continue;
-      seen.add(key);
-      allItems.push(item);
-    }
-  }
-  const sets = stmt.grouping.sets.map((set) => ({ items: [...set.items] }));
-  return {
-    type: "GROUPING_SETS",
-    source: stmt.grouping.source,
-    allItems,
-    sets
-  };
-}
-function hasGroupingClause(stmt) {
-  return normalizeGroupingSpec(stmt).type !== "NONE";
-}
-function resolveGroupingSpec(stmt, resolve2) {
-  const normalized = normalizeGroupingSpec(stmt);
-  if (normalized.type !== "GROUPING_SETS") return null;
-  const byCanonicalId = /* @__PURE__ */ new Map();
-  const resolveItem = (field) => {
-    const resolved = resolve2(field);
-    const existing = byCanonicalId.get(resolved.canonicalId);
-    if (existing) return existing;
-    const item = { ...resolved, field };
-    byCanonicalId.set(item.canonicalId, item);
-    return item;
-  };
-  const allItems = normalized.allItems.map(resolveItem).filter(
-    (item, index, items) => items.findIndex((candidate) => candidate.canonicalId === item.canonicalId) === index
-  );
-  const sets = normalized.sets.map((set) => ({
-    items: set.items.map(resolveItem)
-  }));
-  return {
-    type: "GROUPING_SETS",
-    source: normalized.source,
-    allItems,
-    sets
-  };
-}
-
 // src/core/dmlGuard.ts
 function getStatementType(stmt) {
   if (!stmt || typeof stmt !== "object") return "UNKNOWN";
@@ -5926,6 +5966,272 @@ function isSelectObject(value) {
   return value !== null && typeof value === "object" && value.type === "SELECT";
 }
 
+// src/engine/groupingRowMeta.ts
+var groupingRowMetaKey = /* @__PURE__ */ Symbol("ksql.groupingRowMeta");
+var groupingRefCanonicalIds = /* @__PURE__ */ new WeakMap();
+function attachGroupingRowMeta(row, includedCanonicalIds) {
+  Object.defineProperty(row, groupingRowMetaKey, {
+    value: { includedCanonicalIds },
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return row;
+}
+function getGroupingRowMeta(row) {
+  return row[groupingRowMetaKey];
+}
+function readGroupingMembership(row) {
+  return getGroupingRowMeta(row)?.includedCanonicalIds;
+}
+function bindGroupingRefCanonicalId(ref, canonicalId) {
+  groupingRefCanonicalIds.set(ref, canonicalId);
+}
+function evalGroupingRef(ref, row) {
+  const membership = readGroupingMembership(row);
+  if (!membership) {
+    throw new Error("internal error: GROUPING() evaluation requires B65 grouping row membership.");
+  }
+  const canonicalId = groupingRefCanonicalIds.get(ref);
+  if (!canonicalId) {
+    throw new Error("internal error: GROUPING() reference was not resolved during B65 planning.");
+  }
+  return membership.has(canonicalId) ? "0" : "1";
+}
+
+// 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).`
+    );
+  }
+  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).`
+    );
+  }
+};
+function displayField(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)) {
+    node.forEach((item) => collectGroupingRefs(item, out));
+    return;
+  }
+  const value = node;
+  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return;
+  if (value["type"] === "GROUPING_REF") {
+    out.push(value);
+    return;
+  }
+  Object.values(value).forEach((item) => collectGroupingRefs(item, out));
+}
+function collectAggregateArgumentGroupingRefs(node, out) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    node.forEach((item) => collectAggregateArgumentGroupingRefs(item, out));
+    return;
+  }
+  const value = node;
+  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return;
+  if (value["type"] === "AGGREGATE" || value["type"] === "AGG_REF") {
+    collectGroupingRefs(value["arg"], out);
+    return;
+  }
+  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" && 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 containsAggregate(node) {
+  if (node === null || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some(containsAggregate);
+  const value = node;
+  if (value["type"] === "AGG_REF" || value["type"] === "AGG_ARITH") return true;
+  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return false;
+  return Object.values(value).some(containsAggregate);
+}
+function isAggregateMaterializedAlias(column) {
+  if (!("alias" in column) || column.alias === null) return false;
+  if (column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL") return true;
+  if (column.type === "STRFUNC_COL" || column.type === "SCALAR_VALUE_COL") {
+    return containsAggregate(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.`);
+  }
+  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).`
+    );
+  }
+  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 = [];
+  for (const column of stmt.columns) {
+    if (column.type !== "WINDOW_COL") collectGroupingRefs(column, groupingRefs);
+  }
+  collectGroupingRefs(stmt.having, groupingRefs);
+  collectGroupingRefs(stmt.orderBy, groupingRefs);
+  const forbiddenGroupingRefs = [];
+  collectGroupingRefs(stmt.where, forbiddenGroupingRefs);
+  collectGroupingRefs(stmt.joins, forbiddenGroupingRefs);
+  collectAggregateArgumentGroupingRefs(stmt.columns, forbiddenGroupingRefs);
+  collectAggregateArgumentGroupingRefs(stmt.having, forbiddenGroupingRefs);
+  for (const column of stmt.columns) {
+    if (column.type === "WINDOW_COL") collectGroupingRefs(column, forbiddenGroupingRefs);
+  }
+  if (forbiddenGroupingRefs.length > 0) {
+    throw new Error(
+      "ArgumentError: B65 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.");
+    }
+    return;
+  }
+  if (stmt.orderMode === "KINTONE_NATIVE") {
+    throw new Error("ArgumentError: B65 KORDER BY is not supported in Phase1.");
+  }
+  if (stmt.columns.some((column) => column.type === "WINDOW_COL")) {
+    throw new Error("ArgumentError: B65 window functions are not supported in Phase1.");
+  }
+  if (stmt.columns.some(
+    (column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD"
+  )) {
+    throw new Error("ArgumentError: B65 wildcard projection is not supported in Phase1.");
+  }
+}
+function validateGroupingPlanning(stmt, resolve2, planningGuardHook = () => void 0) {
+  validateGroupingStatic(stmt);
+  const normalized = normalizeGroupingSpec(stmt);
+  const groupingRefs = [];
+  for (const column of stmt.columns) {
+    if (column.type !== "WINDOW_COL") collectGroupingRefs(column, groupingRefs);
+  }
+  collectGroupingRefs(stmt.having, groupingRefs);
+  collectGroupingRefs(stmt.orderBy, groupingRefs);
+  if (normalized.type !== "GROUPING_SETS") {
+    return null;
+  }
+  const resolvedSpec = resolveGroupingSpec(stmt, resolve2);
+  const canonicalItems = /* @__PURE__ */ new Set();
+  const resolvedItems = [];
+  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.`);
+    }
+    if (!canonicalItems.has(resolved.canonicalId)) {
+      canonicalItems.add(resolved.canonicalId);
+      resolvedItems.push(resolved);
+    }
+  }
+  planningGuardHook({
+    expandedSetCount: normalized.sets.length,
+    canonicalItemCount: canonicalItems.size
+  });
+  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");
+    }
+  }
+  const collisionKeys = /* @__PURE__ */ new Set();
+  for (const item of resolvedItems) {
+    collisionKeys.add(item.directKey);
+    if (item.unqualifiedBridgeKey !== null) collisionKeys.add(item.unqualifiedBridgeKey);
+  }
+  for (const column of stmt.columns) {
+    if (!isAggregateMaterializedAlias(column)) continue;
+    const alias = "alias" in column ? column.alias : null;
+    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).`
+      );
+    }
+  }
+  return resolvedSpec;
+}
+
 // src/core/batch.ts
 var MAX_TEMP_TABLES = 16;
 var MAX_BATCH_VARIABLES = 64;
@@ -5967,11 +6273,32 @@ function collectVariableRefs(node, refs) {
     for (const v of Object.values(obj)) collectVariableRefs(v, refs);
   }
 }
+function validateGroupingStaticQueries(node) {
+  if (Array.isArray(node)) {
+    for (const value of node) validateGroupingStaticQueries(value);
+    return;
+  }
+  if (node !== null && typeof node === "object") {
+    const obj = node;
+    if (obj["type"] === "SELECT") {
+      validateGroupingStatic(node);
+    }
+    for (const value of Object.values(obj)) validateGroupingStaticQueries(value);
+  }
+}
 function analyzeBatch(statements) {
   if (statements.length === 0) {
     throw new BatchAnalysisError("ArgumentError: SQL is empty.", 0);
   }
   statements.forEach((stmt, index) => {
+    try {
+      validateGroupingStaticQueries(stmt);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new BatchAnalysisError(error.message, index);
+      }
+      throw error;
+    }
     try {
       assertApplyScope("phase15b", stmt);
       validateKlikeStatement(stmt);
@@ -6975,39 +7302,6 @@ function resolveFieldRef(row, field) {
   return "";
 }
 
-// src/engine/groupingRowMeta.ts
-var groupingRowMetaKey = /* @__PURE__ */ Symbol("ksql.groupingRowMeta");
-var groupingRefCanonicalIds = /* @__PURE__ */ new WeakMap();
-function attachGroupingRowMeta(row, includedCanonicalIds) {
-  Object.defineProperty(row, groupingRowMetaKey, {
-    value: { includedCanonicalIds },
-    enumerable: false,
-    configurable: false,
-    writable: false
-  });
-  return row;
-}
-function getGroupingRowMeta(row) {
-  return row[groupingRowMetaKey];
-}
-function readGroupingMembership(row) {
-  return getGroupingRowMeta(row)?.includedCanonicalIds;
-}
-function bindGroupingRefCanonicalId(ref, canonicalId) {
-  groupingRefCanonicalIds.set(ref, canonicalId);
-}
-function evalGroupingRef(ref, row) {
-  const membership = readGroupingMembership(row);
-  if (!membership) {
-    throw new Error("internal error: GROUPING() evaluation requires B65 grouping row membership.");
-  }
-  const canonicalId = groupingRefCanonicalIds.get(ref);
-  if (!canonicalId) {
-    throw new Error("internal error: GROUPING() reference was not resolved during B65 planning.");
-  }
-  return membership.has(canonicalId) ? "0" : "1";
-}
-
 // src/engine/evalWhere.ts
 function evalWhere(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
   switch (expr.type) {
@@ -9949,212 +10243,6 @@ function explainNeedsAppMetadata(statement) {
   return visit(statement);
 }
 
-// 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).`
-    );
-  }
-  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).`
-    );
-  }
-};
-function displayField(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)) {
-    node.forEach((item) => collectGroupingRefs(item, out));
-    return;
-  }
-  const value = node;
-  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return;
-  if (value["type"] === "GROUPING_REF") {
-    out.push(value);
-    return;
-  }
-  Object.values(value).forEach((item) => collectGroupingRefs(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" && 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 containsAggregate(node) {
-  if (node === null || typeof node !== "object") return false;
-  if (Array.isArray(node)) return node.some(containsAggregate);
-  const value = node;
-  if (value["type"] === "AGG_REF" || value["type"] === "AGG_ARITH") return true;
-  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return false;
-  return Object.values(value).some(containsAggregate);
-}
-function isAggregateMaterializedAlias(column) {
-  if (!("alias" in column) || column.alias === null) return false;
-  if (column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL") return true;
-  if (column.type === "STRFUNC_COL" || column.type === "SCALAR_VALUE_COL") {
-    return containsAggregate(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.`);
-  }
-  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).`
-    );
-  }
-  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 validateGroupingPlanning(stmt, resolve2, planningGuardHook = () => void 0) {
-  const normalized = normalizeGroupingSpec(stmt);
-  const groupingRefs = [];
-  for (const column of stmt.columns) {
-    if (column.type !== "WINDOW_COL") collectGroupingRefs(column, groupingRefs);
-  }
-  collectGroupingRefs(stmt.orderBy, groupingRefs);
-  const forbiddenGroupingRefs = [];
-  collectGroupingRefs(stmt.where, forbiddenGroupingRefs);
-  collectGroupingRefs(stmt.having, forbiddenGroupingRefs);
-  for (const column of stmt.columns) {
-    if (column.type === "WINDOW_COL") collectGroupingRefs(column, forbiddenGroupingRefs);
-  }
-  if (forbiddenGroupingRefs.length > 0) {
-    throw new Error(
-      "ArgumentError: B65 GROUPING() is not allowed in WHERE, HAVING, JOIN, window, aggregate arguments, or DML expressions in Phase1."
-    );
-  }
-  if (normalized.type !== "GROUPING_SETS") {
-    if (groupingRefs.length > 0) {
-      throw new Error("ArgumentError: B65 GROUPING() requires GROUP BY ROLLUP or GROUPING SETS.");
-    }
-    return null;
-  }
-  if (stmt.distinct) {
-    throw new Error("ArgumentError: B65 SELECT DISTINCT is not supported in Phase1.");
-  }
-  if (stmt.orderMode === "KINTONE_NATIVE") {
-    throw new Error("ArgumentError: B65 KORDER BY is not supported in Phase1.");
-  }
-  if (stmt.columns.some((column) => column.type === "WINDOW_COL")) {
-    throw new Error("ArgumentError: B65 window functions are not supported in Phase1.");
-  }
-  if (stmt.columns.some(
-    (column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD"
-  )) {
-    throw new Error("ArgumentError: B65 wildcard projection is not supported in Phase1.");
-  }
-  const resolvedSpec = resolveGroupingSpec(stmt, resolve2);
-  const canonicalItems = /* @__PURE__ */ new Set();
-  const resolvedItems = [];
-  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.`);
-    }
-    if (!canonicalItems.has(resolved.canonicalId)) {
-      canonicalItems.add(resolved.canonicalId);
-      resolvedItems.push(resolved);
-    }
-  }
-  planningGuardHook({
-    expandedSetCount: normalized.sets.length,
-    canonicalItemCount: canonicalItems.size
-  });
-  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");
-    }
-  }
-  const collisionKeys = /* @__PURE__ */ new Set();
-  for (const item of resolvedItems) {
-    collisionKeys.add(item.directKey);
-    if (item.unqualifiedBridgeKey !== null) collisionKeys.add(item.unqualifiedBridgeKey);
-  }
-  for (const column of stmt.columns) {
-    if (!isAggregateMaterializedAlias(column)) continue;
-    const alias = "alias" in column ? column.alias : null;
-    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).`
-      );
-    }
-  }
-  return resolvedSpec;
-}
-
 // src/api/fetchAll.ts
 async function fetchAll(fetcher, app, query, fields, options = {}) {
   const pageSize = options.pageSize ?? PAGE_SIZE_DEFAULT;
@@ -10932,9 +11020,13 @@ function applyHaving(rows, having, resolveFieldType, resolveFieldSemantics2) {
   if (having === null) return rows;
   return rows.filter((row) => evalWhere(having, row, resolveFieldType, void 0, resolveFieldSemantics2));
 }
-function applyDistinct(rows, columns) {
+function applyDistinct(rows, columns, scalarCache, resolveFieldType, resolveFieldSemantics2) {
   if (rows.length === 0) return rows;
-  const keyFor = buildDistinctKeyBuilder(rows, columns);
+  const keyFor = buildDistinctKeyBuilder(rows, columns, {
+    scalarCache,
+    resolveFieldType,
+    resolveFieldSemantics: resolveFieldSemantics2
+  });
   const seen = /* @__PURE__ */ new Set();
   return rows.filter((row) => {
     const key = keyFor(row);
@@ -10943,14 +11035,14 @@ function applyDistinct(rows, columns) {
     return true;
   });
 }
-function buildDistinctKeyBuilder(rows, columns) {
+function buildDistinctKeyBuilder(rows, columns, context) {
+  let sortedWildcardKeys = [];
   if (columns.some((c) => c.type === "WILDCARD")) {
     const allKeys = /* @__PURE__ */ new Set();
     for (const row of rows) {
       for (const k of Object.keys(row)) allKeys.add(k);
     }
-    const keys = [...allKeys].sort();
-    return (row) => JSON.stringify(keys.map((k) => row[k] !== void 0 ? row[k] : null));
+    sortedWildcardKeys = [...allKeys].sort();
   }
   let sortedParentKeys = [];
   if (columns.some((c) => c.type === "PARENT_WILDCARD")) {
@@ -10962,25 +11054,12 @@ function buildDistinctKeyBuilder(rows, columns) {
     }
     sortedParentKeys = [...parentKeys].sort();
   }
-  return (row) => {
-    const values = [];
-    for (const col of columns) {
-      if (col.type === "FIELD") {
-        values.push(row[col.field] ?? "");
-        continue;
-      }
-      if (col.type === "WINDOW_COL") {
-        values.push(row[col.alias] ?? "");
-        continue;
-      }
-      if (col.type === "PARENT_WILDCARD") {
-        for (const k of sortedParentKeys) {
-          values.push(row[k] !== void 0 ? row[k] : null);
-        }
-      }
-    }
-    return JSON.stringify(values);
+  const distinctContext = {
+    ...context,
+    wildcardKeys: sortedWildcardKeys,
+    parentWildcardKeys: sortedParentKeys
   };
+  return (row) => JSON.stringify(buildDistinctTuple(columns, row, distinctContext));
 }
 function applyOrderBy(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator) {
   if (orderBy.length === 0) return rows;
@@ -11152,12 +11231,100 @@ function applyLimit(rows, limit, offset) {
   if (limit === null) return rows.slice(start);
   return rows.slice(start, start + limit);
 }
+function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
+  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);
+      return {
+        kind: "EXPANDED",
+        entries: keys.map((key) => [key, row[key] !== void 0 ? row[key] : null])
+      };
+    }
+    case "PARENT_WILDCARD": {
+      const keys = context.parentWildcardKeys ?? Object.keys(row).filter((key) => key.startsWith("_p.")).sort();
+      return {
+        kind: "EXPANDED",
+        entries: keys.map((key) => [key, row[key] !== void 0 ? row[key] : null])
+      };
+    }
+    case "FIELD":
+      return resolveFieldRef(row, 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";
+    }
+    case "ARITH_AGG_COL": {
+      const source = column.alias ?? aggArithDefaultKey(column.expr);
+      return row[source] ?? "0";
+    }
+    case "ARITH_COL":
+      return String(evalArithExpr(column.expr, row));
+    case "CASE_COL":
+      return evalCaseWhen(
+        column.expr,
+        row,
+        context.resolveFieldType,
+        context.resolveFieldSemantics
+      );
+    case "GROUPING_COL":
+      return evalGroupingRef(column.ref, row);
+    case "STRFUNC_COL": {
+      const source = stringFuncDefaultKey(column.expr);
+      return hasAggregateInStringFuncExpr2(column.expr) ? row[column.alias ?? source] ?? row[source] ?? evalStringFunc(
+        column.expr,
+        row,
+        context.resolveFieldType,
+        context.resolveFieldSemantics
+      ) : evalStringFunc(
+        column.expr,
+        row,
+        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(
+        column.expr,
+        row,
+        context.resolveFieldType,
+        context.resolveFieldSemantics
+      ));
+    }
+    case "SCALAR_SUBQUERY_COL":
+      return context.scalarCache?.get(columnIndex) ?? "";
+    case "WINDOW_COL":
+      return row[column.alias] ?? "";
+  }
+}
+function buildDistinctTuple(columns, row, context = {}) {
+  return columns.map((column, columnIndex) => {
+    const value = evaluateSelectColumnValue(column, row, columnIndex, context);
+    return typeof value === "string" ? value : value.entries.map(([, entryValue]) => entryValue);
+  });
+}
 function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, resolveFieldSemantics2, hiddenQualifiedAliases) {
   if (columns.length === 1 && columns[0].type === "WILDCARD") {
-    const projected2 = rows.map((row) => stripHiddenQualifiedColumns(
-      stripParentShortcutColumns(row),
-      hiddenQualifiedAliases
-    ));
+    const projected2 = rows.map((row) => {
+      const visible = stripHiddenQualifiedColumns(
+        stripParentShortcutColumns(row),
+        hiddenQualifiedAliases
+      );
+      const value = evaluateSelectColumnValue(columns[0], row, 0, {
+        wildcardKeys: Object.keys(visible)
+      });
+      const out = {};
+      if (typeof value !== "string") {
+        for (const [key, entryValue] of value.entries) {
+          if (entryValue !== null) out[key] = entryValue;
+        }
+      }
+      return out;
+    });
     const cols = projected2.length > 0 ? Object.keys(projected2[0]) : [...sourceColumns ?? []];
     return { rows: projected2, columns: cols };
   }
@@ -11172,95 +11339,101 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, re
   }
   const projected = rows.map((row, rowIdx) => {
     const out = {};
+    const evaluationContext = {
+      scalarCache,
+      resolveFieldType,
+      resolveFieldSemantics: resolveFieldSemantics2,
+      wildcardKeys: Object.keys(stripHiddenQualifiedColumns(
+        stripParentShortcutColumns(row),
+        hiddenQualifiedAliases
+      )),
+      parentWildcardKeys: Object.keys(row).filter((key) => key.startsWith("_p.")).sort()
+    };
     for (const [colIdx, col] of columns.entries()) {
+      const value = evaluateSelectColumnValue(col, row, colIdx, evaluationContext);
       switch (col.type) {
         case "VARIABLE_COL":
-          throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
+          break;
         case "WILDCARD":
-          Object.assign(out, stripHiddenQualifiedColumns(
-            stripParentShortcutColumns(row),
-            hiddenQualifiedAliases
-          ));
+          if (typeof value !== "string") {
+            for (const [key, entryValue] of value.entries) {
+              if (entryValue !== null) out[key] = entryValue;
+            }
+          }
           break;
         case "PARENT_WILDCARD": {
-          const parentKeys = Object.keys(row).filter((k) => k.startsWith("_p.")).sort();
-          for (const key of parentKeys) {
-            out[key] = row[key] ?? "";
-            if (rowIdx === 0) orderedKeys.push(key);
+          if (typeof value !== "string") {
+            for (const [key, entryValue] of value.entries) {
+              if (entryValue !== null) out[key] = entryValue;
+              if (rowIdx === 0) orderedKeys.push(key);
+            }
           }
           break;
         }
         case "FIELD": {
           const key = outputKeys?.[colIdx] ?? col.alias ?? defaultFieldKeys.get(colIdx) ?? col.field;
-          out[key] = resolveFieldRef(row, col.field);
+          out[key] = value;
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
         case "LITERAL_COL": {
           const key = outputKeys?.[colIdx] ?? col.alias ?? `'${col.value}'`;
-          out[key] = col.value;
+          out[key] = value;
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
         case "AGGREGATE": {
           const srcKey = aggregateSyntheticName(col.func, col.distinct, col.arg);
           const dstKey = outputKeys?.[colIdx] ?? col.alias ?? srcKey;
-          out[dstKey] = row[col.alias ?? srcKey] ?? row[srcKey] ?? "0";
+          out[dstKey] = value;
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(dstKey);
           break;
         }
         case "ARITH_AGG_COL": {
           const key = outputKeys?.[colIdx] ?? col.alias ?? aggArithDefaultKey(col.expr);
-          out[key] = row[key] ?? "0";
+          out[key] = value;
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
         case "ARITH_COL": {
-          const val = evalArithExpr(col.expr, row);
           const key = outputKeys?.[colIdx] ?? col.alias ?? arithColDefaultKey(col.expr);
-          out[key] = String(val);
+          out[key] = value;
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
         case "CASE_COL": {
           const key = outputKeys?.[colIdx] ?? col.alias ?? "case";
-          out[key] = evalCaseWhen(col.expr, row, resolveFieldType, resolveFieldSemantics2);
+          out[key] = value;
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
         case "GROUPING_COL": {
           const key = outputKeys?.[colIdx] ?? col.alias ?? `GROUPING(${col.ref.field.tableAlias ? `${col.ref.field.tableAlias}.` : ""}${col.ref.field.field})`;
-          out[key] = evalGroupingRef(col.ref, row);
+          out[key] = value;
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
         case "STRFUNC_COL": {
           const key = outputKeys?.[colIdx] ?? col.alias ?? stringFuncDefaultKey(col.expr);
-          if (hasAggregateInStringFuncExpr2(col.expr)) {
-            const srcKey = stringFuncDefaultKey(col.expr);
-            out[key] = row[col.alias ?? srcKey] ?? row[srcKey] ?? evalStringFunc(col.expr, row, resolveFieldType, resolveFieldSemantics2);
-          } else {
-            out[key] = evalStringFunc(col.expr, row, resolveFieldType, resolveFieldSemantics2);
-          }
+          out[key] = value;
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
         case "SCALAR_VALUE_COL": {
           const key = outputKeys?.[colIdx] ?? col.alias ?? scalarValueDefaultKey(col.expr);
-          const srcKey = scalarValueDefaultKey(col.expr);
-          out[key] = scalarValueHasAggregate2(col.expr) ? row[col.alias ?? srcKey] ?? row[srcKey] ?? "" : String(evalScalarValueExpr(col.expr, row, resolveFieldType, resolveFieldSemantics2));
+          out[key] = value;
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
         case "SCALAR_SUBQUERY_COL": {
           const key = outputKeys?.[colIdx] ?? col.alias ?? "(subquery)";
-          out[key] = scalarCache?.get(colIdx) ?? "";
+          out[key] = value;
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
         case "WINDOW_COL": {
           const key = outputKeys?.[colIdx] ?? col.alias;
-          out[key] = row[col.alias] ?? "";
+          out[key] = value;
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
@@ -11551,7 +11724,13 @@ function runFullScan(input) {
   rows = applyHaving(rows, stmt.having, havingFieldTypeResolver, havingFieldSemanticsResolver);
   rows = applyWindow(rows, stmt.columns, optionOrders, sortKinds, effectiveOrderSemantics);
   if (stmt.distinct) {
-    rows = applyDistinct(rows, stmt.columns);
+    rows = applyDistinct(
+      rows,
+      stmt.columns,
+      scalarCache,
+      fieldTypeResolver,
+      fieldSemanticsResolver
+    );
   }
   rows = applyOrderBy(
     rows,
@@ -19291,7 +19470,9 @@ function collectFullScanReasons(stmt) {
   if (grouping.type === "PLAIN")
     r.push("GROUP BY \u3042\u308A");
   else if (grouping.type === "GROUPING_SETS")
-    r.push(grouping.source === "ROLLUP" ? "ROLLUP \u3042\u308A" : "GROUPING SETS \u3042\u308A");
+    r.push(
+      grouping.source === "ROLLUP" ? "ROLLUP \u3042\u308A" : grouping.source === "CUBE" ? "CUBE \u3042\u308A" : "GROUPING SETS \u3042\u308A"
+    );
   if (stmt.distinct)
     r.push("DISTINCT \u3042\u308A");
   if (stmt.columns.some((c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL"))