@rex0220/kintone-sql-tools 3.16.1 → 3.17.1

package/dist-cli/ksql.js

@@ -599,6 +599,10 @@ function fieldValueLabel(value) {
   if (value.type === "FIELD") return value.tableAlias ? `${value.tableAlias}.${value.field}` : value.field;
   if (value.type === "FUNC_FIELD") return stringFuncLabel(value.expr);
   if (value.type === "ARITH_FIELD") return arithLabel(value.expr);
+  if (value.type === "GROUPING_FIELD") {
+    const field = value.ref.field;
+    return `GROUPING(${field.tableAlias ? `${field.tableAlias}.` : ""}${field.field})`;
+  }
   return caseLabel(value.expr);
 }
 function sqlValueLabel(value) {
@@ -902,6 +906,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;
     /** WITH 句で定義された CTE 名のセット（parseTableRef で参照） */
     this.cteNames = /* @__PURE__ */ new Set();
     /** パース中に出現した一時テーブル参照（#name）のトークン。単文 API での拒否に使う */
@@ -1273,7 +1279,7 @@ var Parser = class {
       if (projection.from.cteName !== NO_FROM_CTE_NAME || projection.joins.length > 0) {
         throw new ParseError("IMPORT projection cannot use FROM or JOIN.", this.prev());
       }
-      if (projection.where || projection.groupBy.length || projection.having || projection.orderBy.length || projection.limit !== null || projection.offset !== null) {
+      if (projection.where || projection.groupBy.length || projection.grouping !== void 0 || projection.having || projection.orderBy.length || projection.limit !== null || projection.offset !== null) {
         throw new ParseError("IMPORT projection supports SELECT expressions only.", this.prev());
       }
       this.validateImportProjectionScope(projection, this.prev());
@@ -1634,10 +1640,25 @@ var Parser = class {
     const joins = hasFrom ? this.parseJoins() : [];
     const where = this.consume("WHERE" /* WHERE */) ? this.parseWhereExpr() : null;
     let groupBy = [];
+    let grouping;
     let having = null;
     if (this.consume("GROUP" /* GROUP */)) {
       this.expect("BY" /* BY */);
-      groupBy = this.parseGroupByKeys();
+      if (this.peek().kind === "DISTINCT" /* DISTINCT */ || this.isSoftKeyword("DISTINCT")) {
+        throw new ParseError("B65: GROUP BY DISTINCT is not supported in Phase1.", this.peek());
+      }
+      if (this.isGroupingSetsStart()) {
+        grouping = this.parseGroupingSetsClause();
+      } else if (this.isRollupStart()) {
+        grouping = this.parseRollupClause();
+      } else if (this.isCubeStart()) {
+        throw new ParseError("B65: CUBE is not supported in Phase1.", this.peek());
+      } else {
+        groupBy = this.parseGroupByKeys();
+      }
+      if (grouping && this.peek().kind === "," /* COMMA */) {
+        throw new ParseError("B65: ordinary GROUP BY items cannot be mixed with grouping elements.", this.peek());
+      }
       if (this.consume("HAVING" /* HAVING */)) {
         having = this.parseWhereExpr();
       }
@@ -1659,9 +1680,12 @@ var Parser = class {
     const offset = this.consume("OFFSET" /* OFFSET */) ? this.parseUnsignedInt() : null;
     const hasWindow = columns.some((column) => column.type === "WINDOW_COL");
     const hasAggregate = columns.some((column) => this.selectColumnHasAggregate(column));
-    if (hasWindow && (groupBy.length > 0 || hasAggregate)) {
+    if (hasWindow && (groupBy.length > 0 || grouping !== void 0 || hasAggregate)) {
       throw new ParseError("\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u306F GROUP BY / \u96C6\u8A08\u95A2\u6570\u3068\u540C\u3058 SELECT \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", this.peek());
     }
+    if (grouping && orderMode === "KINTONE_NATIVE") {
+      throw new ParseError("B65: KORDER BY cannot be combined with grouping sets in Phase1.", this.peek());
+    }
     return {
       type: "SELECT",
       distinct,
@@ -1670,6 +1694,7 @@ var Parser = class {
       joins,
       where,
       groupBy,
+      ...grouping ? { grouping } : {},
       having,
       orderMode,
       orderBy,
@@ -1730,6 +1755,14 @@ var Parser = class {
     if (this.consume("*" /* STAR */)) {
       return { type: "WILDCARD" };
     }
+    if (this.isUnsupportedGroupingIdStart()) {
+      throw new ParseError("B65: GROUPING_ID is not supported in Phase1.", this.peek());
+    }
+    if (this.isGroupingFunctionStart()) {
+      const ref = this.parseGroupingRef();
+      const alias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
+      return { type: "GROUPING_COL", ref, alias: alias2 };
+    }
     if (this.tryAggregateFunc() === null && this.hasTopLevelTokenBeforeValueEnd("||" /* CONCAT_OP */)) {
       const expr = this.parseScalarValueExpr({ allowAggregateArgs: true });
       const alias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
@@ -1751,12 +1784,12 @@ var Parser = class {
       return this.parseWindowColumn(windowFunc);
     }
     if (this.peek().kind === "CASE" /* CASE */) {
-      const expr = this.parseCaseWhenExpr();
+      const expr = this.parseCaseWhenExpr(true);
       const alias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
       return { type: "CASE_COL", expr, alias: alias2 };
     }
     if (this.peek().kind === "IF" /* IF */) {
-      const expr = this.parseIfExpr();
+      const expr = this.parseIfExpr(true);
       const alias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
       return { type: "CASE_COL", expr, alias: alias2 };
     }
@@ -1842,7 +1875,7 @@ var Parser = class {
         partitionBy.push({ type: "FIELD", tableAlias: ref.tableAlias, field: ref.field });
       } while (this.consume("," /* COMMA */));
     }
-    const orderBy = this.consume("ORDER" /* ORDER */) ? (this.expect("BY" /* BY */), this.parseOrderBy()) : [];
+    const orderBy = this.consume("ORDER" /* ORDER */) ? (this.expect("BY" /* BY */), this.parseOrderBy(false)) : [];
     this.expect(")" /* RPAREN */);
     if (!this.consume("AS" /* AS */)) {
       throw new ParseError("\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u306B\u306F AS alias \u304C\u5FC5\u8981\u3067\u3059", this.peek());
@@ -2118,10 +2151,10 @@ var Parser = class {
   // result: 文字列リテラル / 算術式（フィールド参照・数値含む）
   // ──────────────────────────────────────────────────
   /** IF(条件, then値, else値) → CaseWhenExpr に変換 */
-  parseIfExpr() {
+  parseIfExpr(allowGroupingCondition = false) {
     this.advance();
     this.expect("(" /* LPAREN */);
-    const condition = this.parseWhereExpr();
+    const condition = this.parseCaseCondition(allowGroupingCondition);
     this.expect("," /* COMMA */);
     const thenResult = this.parseCaseResult();
     this.expect("," /* COMMA */);
@@ -2133,12 +2166,12 @@ var Parser = class {
       elseResult
     };
   }
-  parseCaseWhenExpr() {
+  parseCaseWhenExpr(allowGroupingCondition = false) {
     this.expect("CASE" /* CASE */);
     const branches = [];
     while (this.peek().kind === "WHEN" /* WHEN */) {
       this.advance();
-      const condition = this.parseWhereExpr();
+      const condition = this.parseCaseCondition(allowGroupingCondition);
       this.expect("THEN" /* THEN */);
       const result = this.parseCaseResult();
       branches.push({ condition, result });
@@ -2153,6 +2186,15 @@ var Parser = class {
     this.expect("END" /* END */);
     return { type: "CASE_WHEN", branches, elseResult };
   }
+  parseCaseCondition(allowGroupingCondition) {
+    if (!allowGroupingCondition) return this.parseWhereExpr();
+    this.groupingFieldAllowedDepth++;
+    try {
+      return this.parseWhereExpr();
+    } finally {
+      this.groupingFieldAllowedDepth--;
+    }
+  }
   /** THEN / ELSE の結果値。`||` を含む場合だけ新スカラー文法へ渡す。 */
   parseCaseResult() {
     const tok = this.peek();
@@ -2634,6 +2676,18 @@ var Parser = class {
   // - 集計関数（HAVING のみ）: COUNT(*) / SUM(f) ...
   // - 通常フィールド参照: [alias.]field
   parseFieldValue() {
+    if (this.isUnsupportedGroupingIdStart()) {
+      throw new ParseError("B65: GROUPING_ID is not supported in Phase1.", this.peek());
+    }
+    if (this.isGroupingFunctionStart()) {
+      if (this.groupingFieldAllowedDepth === 0) {
+        throw new ParseError(
+          "B65: GROUPING() is only allowed in SELECT, SELECT CASE conditions, and direct ORDER BY.",
+          this.peek()
+        );
+      }
+      return { type: "GROUPING_FIELD", ref: this.parseGroupingRef() };
+    }
     if (this.tryStringFuncName() !== null) {
       const expr = this.parseStringFuncExpr();
       if (this.isArithOp(this.peek().kind)) {
@@ -2787,10 +2841,123 @@ var Parser = class {
   parseGroupByKeys() {
     const keys = [];
     do {
+      if (keys.length > 0 && (this.isRollupStart() || this.isGroupingSetsStart() || this.isCubeStart())) {
+        throw new ParseError("B65: ordinary GROUP BY items cannot be mixed with grouping elements.", this.peek());
+      }
       keys.push(this.parseGroupByKey());
     } while (this.consume("," /* COMMA */));
     return keys;
   }
+  isRollupStart() {
+    return this.isSoftKeyword("ROLLUP") && this.peekAt(1).kind === "(" /* LPAREN */;
+  }
+  isCubeStart() {
+    return this.isSoftKeyword("CUBE") && this.peekAt(1).kind === "(" /* LPAREN */;
+  }
+  isGroupingSetsStart() {
+    return this.isSoftKeyword("GROUPING") && this.peekAt(1).kind === "IDENT" /* IDENT */ && this.peekAt(1).value.toUpperCase() === "SETS" && this.peekAt(2).kind === "(" /* LPAREN */;
+  }
+  isGroupingFunctionStart() {
+    return this.isSoftKeyword("GROUPING") && this.peekAt(1).kind === "(" /* LPAREN */;
+  }
+  isUnsupportedGroupingIdStart() {
+    return this.isSoftKeyword("GROUPING_ID") && this.peekAt(1).kind === "(" /* LPAREN */;
+  }
+  groupingItemSyntaxKey(item) {
+    return `${item.tableAlias ?? ""}\0${item.field}`;
+  }
+  groupingAllItems(sets) {
+    const seen = /* @__PURE__ */ new Set();
+    const allItems = [];
+    for (const set of sets) {
+      for (const item of set.items) {
+        const key = this.groupingItemSyntaxKey(item);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        allItems.push(item);
+      }
+    }
+    return allItems;
+  }
+  parseGroupingFieldItem() {
+    if (this.isRollupStart() || this.isGroupingSetsStart() || this.isCubeStart()) {
+      throw new ParseError("B65: nested grouping elements are not supported in Phase1.", this.peek());
+    }
+    const token = this.peek();
+    const field = this.parseQualifiedIdent();
+    if (this.peek().kind !== "," /* COMMA */ && this.peek().kind !== ")" /* RPAREN */) {
+      throw new ParseError("B65: grouping items must be physical field references only.", token);
+    }
+    return { type: "FIELD", tableAlias: field.tableAlias, field: field.field };
+  }
+  parseGroupingSetsClause() {
+    this.advance();
+    this.advance();
+    this.expect("(" /* LPAREN */);
+    if (this.peek().kind === ")" /* RPAREN */) {
+      throw new ParseError("B65: GROUPING SETS requires at least one grouping set; use (()) for the empty set.", this.peek());
+    }
+    const sets = [];
+    do {
+      if (this.consume("(" /* LPAREN */)) {
+        const items = [];
+        if (this.peek().kind !== ")" /* RPAREN */) {
+          do {
+            items.push(this.parseGroupingFieldItem());
+          } while (this.consume("," /* COMMA */));
+        }
+        this.expect(")" /* RPAREN */);
+        sets.push({ items });
+      } else {
+        sets.push({ items: [this.parseGroupingFieldItem()] });
+      }
+    } while (this.consume("," /* COMMA */));
+    this.expect(")" /* RPAREN */);
+    return {
+      type: "GROUPING_SETS",
+      source: "GROUPING_SETS",
+      allItems: this.groupingAllItems(sets),
+      sets
+    };
+  }
+  parseRollupClause() {
+    this.advance();
+    this.expect("(" /* LPAREN */);
+    if (this.peek().kind === ")" /* RPAREN */) {
+      throw new ParseError("B65: ROLLUP requires at least one field.", this.peek());
+    }
+    const items = [];
+    do {
+      items.push(this.parseGroupingFieldItem());
+    } while (this.consume("," /* COMMA */));
+    this.expect(")" /* RPAREN */);
+    const sets = Array.from(
+      { length: items.length + 1 },
+      (_, index) => ({ items: items.slice(0, items.length - index) })
+    );
+    return {
+      type: "GROUPING_SETS",
+      source: "ROLLUP",
+      allItems: this.groupingAllItems(sets),
+      sets
+    };
+  }
+  parseGroupingRef() {
+    const start = this.advance();
+    this.expect("(" /* LPAREN */);
+    if (this.peek().kind === ")" /* RPAREN */) {
+      throw new ParseError("B65: GROUPING() requires exactly one physical field argument.", this.peek());
+    }
+    const field = this.parseQualifiedIdent();
+    if (this.peek().kind !== ")" /* RPAREN */) {
+      throw new ParseError("B65: GROUPING() requires exactly one physical field argument.", start);
+    }
+    this.expect(")" /* RPAREN */);
+    return {
+      type: "GROUPING_REF",
+      field: { type: "FIELD", tableAlias: field.tableAlias, field: field.field }
+    };
+  }
   /**
    * GROUP BY のキーを解析する。ORDER BY と同じ文法（方向指定なし）。
    *   関数:              SUBSTRING(作成日時, 1, 7) / ROUND(金額, -4)
@@ -2816,10 +2983,10 @@ var Parser = class {
     }
     return { type: "FIELD_NAME", name };
   }
-  parseOrderBy() {
+  parseOrderBy(allowGrouping = true) {
     const items = [];
     do {
-      const key = this.parseOrderByKey();
+      const key = this.parseOrderByKey(allowGrouping);
       let direction = "ASC";
       if (this.consume("DESC" /* DESC */)) direction = "DESC";
       else this.consume("ASC" /* ASC */);
@@ -2834,7 +3001,16 @@ var Parser = class {
    *   フィールド + 算術: 金額 * 1.1
    *   フィールド名/alias: 名前 / total
    */
-  parseOrderByKey() {
+  parseOrderByKey(allowGrouping = true) {
+    if (this.isUnsupportedGroupingIdStart()) {
+      throw new ParseError("B65: GROUPING_ID is not supported in Phase1.", this.peek());
+    }
+    if (this.isGroupingFunctionStart()) {
+      if (!allowGrouping) {
+        throw new ParseError("B65: GROUPING() is not allowed in window ORDER BY.", this.peek());
+      }
+      return { type: "GROUPING_KEY", ref: this.parseGroupingRef() };
+    }
     if (this.tryStringFuncName() !== null) {
       const funcExpr = this.parseStringFuncExpr();
       if (this.isArithOp(this.peek().kind)) {
@@ -3754,6 +3930,67 @@ 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";
@@ -3833,6 +4070,7 @@ function unionCompleteInputReasons(stmt) {
 }
 function selectCompleteInputReasons(stmt) {
   const reasons = /* @__PURE__ */ new Set();
+  if (normalizeGroupingSpec(stmt).type === "GROUPING_SETS") reasons.add("GROUPING_SETS");
   if (stmt.orderBy.length > 0) reasons.add("LOCAL_ORDER");
   for (const column of stmt.columns) {
     if (column.type === "WINDOW_COL" && column.orderBy.length > 0) reasons.add("WINDOW_ORDER");
@@ -4551,6 +4789,9 @@ function convertField(field) {
   if (field.type === "CASE_FIELD") {
     throw new KintoneQueryError("WHERE \u53E5\u306E CASE WHEN \u306F kintone \u30AF\u30A8\u30EA\u306B\u5909\u63DB\u3067\u304D\u307E\u305B\u3093");
   }
+  if (field.type === "GROUPING_FIELD") {
+    throw new KintoneQueryError("GROUPING() \u306F kintone \u30AF\u30A8\u30EA\u306B\u5909\u63DB\u3067\u304D\u307E\u305B\u3093");
+  }
   return quoteIdentifier(field.field);
 }
 function convertValue(value, op) {
@@ -4625,7 +4866,7 @@ function resolveSelectMode(stmt) {
   if (stmt.from.subtableCode) return "FULL_SCAN";
   if (stmt.joins.some((j) => j.table.subtableCode)) return "FULL_SCAN";
   if (stmt.joins.length > 0) return "FULL_SCAN";
-  if (stmt.groupBy.length > 0) return "FULL_SCAN";
+  if (normalizeGroupingSpec(stmt).type !== "NONE") return "FULL_SCAN";
   if (stmt.distinct) return "FULL_SCAN";
   if (hasWindowColumns(stmt.columns)) return "FULL_SCAN";
   if (stmt.columns.some(
@@ -5014,6 +5255,9 @@ function collectRequiredFieldsByTable(stmt) {
       walkArith(fv.expr, phase);
       return;
     }
+    if (fv.type === "GROUPING_FIELD") {
+      return;
+    }
     walkCase(fv.expr, phase);
   };
   const walkSqlValue = (v, phase = "select") => {
@@ -5069,6 +5313,9 @@ function collectRequiredFieldsByTable(stmt) {
       walkArith(k.expr, phase);
       return;
     }
+    if (k.type === "GROUPING_KEY") {
+      return;
+    }
     walkStringFunc(k.expr, phase);
   };
   for (const col of stmt.columns) {
@@ -5104,6 +5351,8 @@ function collectRequiredFieldsByTable(stmt) {
       case "SCALAR_VALUE_COL":
         walkScalar(col.expr, "select");
         break;
+      case "GROUPING_COL":
+        break;
       case "SCALAR_SUBQUERY_COL":
         break;
       case "WINDOW_COL":
@@ -5117,7 +5366,14 @@ function collectRequiredFieldsByTable(stmt) {
     addFieldRef(join2.on.right.field, join2.on.right.tableAlias, "where");
   }
   walkWhere(stmt.where, "where");
-  for (const gk of stmt.groupBy) walkGroupByKey(gk);
+  const grouping = normalizeGroupingSpec(stmt);
+  if (grouping.type === "PLAIN") {
+    for (const item of grouping.allItems) walkGroupByKey(item);
+  } else if (grouping.type === "GROUPING_SETS") {
+    for (const item of grouping.allItems) {
+      addFieldRef(item.field, item.tableAlias, "select");
+    }
+  }
   walkWhere(stmt.having, "having");
   for (const ob of stmt.orderBy) walkOrderByKey(ob.key);
   return states;
@@ -5158,6 +5414,10 @@ function collectSelectOutputNames(columns) {
       if (col.alias) names.add(col.alias);
       continue;
     }
+    if (col.type === "GROUPING_COL") {
+      names.add(col.alias ?? `GROUPING(${col.ref.field.tableAlias ? `${col.ref.field.tableAlias}.` : ""}${col.ref.field.field})`);
+      continue;
+    }
     if (col.type === "SCALAR_SUBQUERY_COL") {
       names.add(col.alias ?? "(subquery)");
       continue;
@@ -5183,7 +5443,7 @@ function canInlineSingleCte(stmt) {
   const finalQuery = stmt.query;
   if (finalQuery.type !== "SELECT") return false;
   if (finalQuery.from.cteName !== cteDef.name || finalQuery.joins.length > 0) return false;
-  if (finalQuery.groupBy.length > 0 || finalQuery.distinct) return false;
+  if (hasGroupingClause(finalQuery) || finalQuery.distinct) return false;
   return !finalQuery.columns.some(
     (column) => column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL"
   );
@@ -6715,6 +6975,39 @@ 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) {
@@ -6821,6 +7114,7 @@ function semanticsForLeft(left, fieldType, resolveSemantics) {
     });
     if (modes.length > 0 && modes.every((mode) => mode.compareMode === modes[0].compareMode)) return modes[0];
   }
+  if (left.type === "GROUPING_FIELD") return syntheticSemantics("number");
   return syntheticSemantics("string");
 }
 var STRING_ARRAY_FIELD_TYPES = /* @__PURE__ */ new Set(["CHECK_BOX", "MULTI_SELECT"]);
@@ -6886,6 +7180,7 @@ function resolveField(field, row, resolveFieldType, resolveFieldSemantics2) {
   if (field.type === "FUNC_FIELD") return evalStringFunc(field.expr, row);
   if (field.type === "ARITH_FIELD") return String(evalArithExpr(field.expr, row));
   if (field.type === "CASE_FIELD") return evalCaseWhen(field.expr, row, resolveFieldType, resolveFieldSemantics2);
+  if (field.type === "GROUPING_FIELD") return evalGroupingRef(field.ref, row);
   const key = field.tableAlias ? `${field.tableAlias}.${field.field}` : field.field;
   return resolveFieldRef(row, key);
 }
@@ -9591,6 +9886,18 @@ function validateDeclaredBatchVariables(statements, input) {
 }
 
 // src/core/explainMetadata.ts
+function buildGroupingExplainMetadata(statement, canonicalItemCount) {
+  const grouping = normalizeGroupingSpec(statement);
+  if (grouping.type !== "GROUPING_SETS") return null;
+  return {
+    source: grouping.source,
+    expandedSetCount: grouping.sets.length,
+    groupingItemCount: canonicalItemCount ?? grouping.allItems.length,
+    setLimit: B65_MAX_GROUPING_SETS,
+    itemLimit: B65_MAX_GROUPING_ITEMS,
+    outputRowLimit: B65_MAX_GENERATED_ROWS
+  };
+}
 function whereNeedsFieldMetadata(where) {
   if (where === null) return false;
   switch (where.type) {
@@ -9617,7 +9924,7 @@ function valueNeedsFieldMetadata(value) {
   return Object.values(item).some(valueNeedsFieldMetadata);
 }
 function selectNeedsOwnMetadata(statement) {
-  return whereNeedsFieldMetadata(statement.where) || statement.orderBy.length > 0 || statement.columns.some(
+  return whereNeedsFieldMetadata(statement.where) || normalizeGroupingSpec(statement).type === "GROUPING_SETS" || statement.orderBy.length > 0 || statement.columns.some(
     (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
   );
 }
@@ -9642,6 +9949,212 @@ 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;
@@ -10177,29 +10690,96 @@ function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind) {
         outRow[stringFuncDefaultKey(k.expr)] = evalStringFunc(k.expr, groupRows[0]);
       }
     }
-    for (const col of columns) {
-      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;
-      } else if (col.type === "ARITH_AGG_COL") {
-        const outputKey = col.alias ?? aggArithDefaultKey(col.expr);
-        outRow[outputKey] = String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind));
-      } else if (col.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(col.expr)) {
-        const outputKey = col.alias ?? stringFuncDefaultKey(col.expr);
-        const resolvedExpr = resolveAggInStringFuncExpr(col.expr, groupRows, resolveAggSortKind);
-        outRow[outputKey] = evalStringFunc(resolvedExpr, outRow);
-      } else if (col.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(col.expr)) {
-        const outputKey = col.alias ?? scalarValueDefaultKey(col.expr);
-        const resolvedExpr = resolveAggInScalarValue(col.expr, groupRows, resolveAggSortKind);
-        outRow[outputKey] = String(evalScalarValueExpr(resolvedExpr, outRow));
+    materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind);
+    result.push(outRow);
+  }
+  return result;
+}
+function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {}) {
+  const result = [];
+  let generatedRows = 0;
+  const countBucket = () => {
+    generatedRows++;
+    if (limits.maxGeneratedRows !== void 0 && generatedRows > limits.maxGeneratedRows) {
+      throw new Error(
+        `LimitError: B65 generated grouping rows ${generatedRows} exceed limit ${limits.maxGeneratedRows} (reason=GROUPING_OUTPUT_LIMIT_EXCEEDED).`
+      );
+    }
+  };
+  for (const set of spec.sets) {
+    const root = { children: /* @__PURE__ */ new Map() };
+    const buckets = [];
+    for (const row of rows) {
+      let node = root;
+      for (const item of set.items) {
+        const value = groupingItemValue(item, row);
+        let child = node.children.get(value);
+        if (!child) {
+          child = { children: /* @__PURE__ */ new Map() };
+          node.children.set(value, child);
+        }
+        node = child;
+      }
+      if (!node.rows) {
+        countBucket();
+        node.rows = [];
+        buckets.push(node.rows);
+      }
+      node.rows.push(row);
+    }
+    if (rows.length === 0 && set.items.length === 0) {
+      countBucket();
+      root.rows = [];
+      buckets.push(root.rows);
+    }
+    const includedCanonicalIds = new Set(set.items.map((item) => item.canonicalId));
+    for (const groupRows of buckets) {
+      const outRow = { ...groupRows[0] };
+      const includedValues = /* @__PURE__ */ new Map();
+      for (const item of set.items) {
+        if (!includedValues.has(item.canonicalId)) {
+          includedValues.set(item.canonicalId, groupingItemValue(item, groupRows[0]));
+        }
       }
+      for (const item of spec.allItems) {
+        const value = includedValues.get(item.canonicalId) ?? "";
+        outRow[item.directKey] = value;
+        if (item.unqualifiedBridgeKey !== null) {
+          outRow[item.unqualifiedBridgeKey] = value;
+        }
+      }
+      materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind);
+      attachGroupingRowMeta(outRow, includedCanonicalIds);
+      result.push(outRow);
     }
-    result.push(outRow);
   }
   return result;
 }
+function groupingItemValue(item, row) {
+  if (!row) return "";
+  return row[item.directKey] ?? (item.unqualifiedBridgeKey === null ? void 0 : row[item.unqualifiedBridgeKey]) ?? "";
+}
+function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind) {
+  for (const col of columns) {
+    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;
+    } else if (col.type === "ARITH_AGG_COL") {
+      const outputKey = col.alias ?? aggArithDefaultKey(col.expr);
+      outRow[outputKey] = String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind));
+    } else if (col.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(col.expr)) {
+      const outputKey = col.alias ?? stringFuncDefaultKey(col.expr);
+      const resolvedExpr = resolveAggInStringFuncExpr(col.expr, groupRows, resolveAggSortKind);
+      outRow[outputKey] = evalStringFunc(resolvedExpr, outRow);
+    } else if (col.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(col.expr)) {
+      const outputKey = col.alias ?? scalarValueDefaultKey(col.expr);
+      const resolvedExpr = resolveAggInScalarValue(col.expr, groupRows, resolveAggSortKind);
+      outRow[outputKey] = String(evalScalarValueExpr(resolvedExpr, outRow));
+    }
+  }
+}
 function evalGroupByKey(key, row) {
   if (key.type === "FIELD_NAME") return row[key.name] ?? "";
   if (key.type === "FUNC_KEY") return evalStringFunc(key.expr, row);
@@ -10412,6 +10992,7 @@ function sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantic
     if (key.type === "FUNC_KEY") {
       return { semantics: syntheticSemantics(NUMERIC_ORDER_FUNCTIONS.has(key.expr.func) ? "number" : "string") };
     }
+    if (key.type === "GROUPING_KEY") return { semantics: syntheticSemantics("number") };
     const semantics = fieldSemantics2?.get(key.name);
     if (semantics) return { semantics };
     const orderMap = optionOrders?.get(key.name);
@@ -10477,6 +11058,8 @@ function evalOrderKey(key, row, aliasEvaluator) {
       return String(evalArithExpr(key.expr, row));
     case "FUNC_KEY":
       return evalStringFunc(key.expr, row);
+    case "GROUPING_KEY":
+      return evalGroupingRef(key.ref, row);
   }
 }
 function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, resolveFieldSemantics2) {
@@ -10523,6 +11106,9 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
       case "SCALAR_SUBQUERY_COL":
         evaluators.set(alias, () => scalarCache?.get(columnIndex) ?? "");
         break;
+      case "GROUPING_COL":
+        evaluators.set(alias, (row) => evalGroupingRef(column.ref, row));
+        break;
       case "VARIABLE_COL":
         break;
     }
@@ -10642,6 +11228,12 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, re
           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);
+          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)) {
@@ -10714,6 +11306,8 @@ function computeOutputKey(col, colIdx, defaultFieldKeys) {
       return col.alias ?? stringFuncDefaultKey(col.expr);
     case "SCALAR_VALUE_COL":
       return col.alias ?? scalarValueDefaultKey(col.expr);
+    case "GROUPING_COL":
+      return col.alias ?? `GROUPING(${col.ref.field.tableAlias ? `${col.ref.field.tableAlias}.` : ""}${col.ref.field.field})`;
     case "SCALAR_SUBQUERY_COL":
       return col.alias ?? "(subquery)";
     case "WINDOW_COL":
@@ -10904,7 +11498,8 @@ function runFullScan(input) {
     appliedKlikes,
     sourceColumns,
     tableColumns,
-    hiddenQualifiedAliases
+    hiddenQualifiedAliases,
+    resolvedGroupingSpec
   } = input;
   const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns);
   for (const [key, value] of orderSemantics ?? []) effectiveOrderSemantics.set(key, value);
@@ -10933,8 +11528,25 @@ function runFullScan(input) {
     knownColumns = mergeKnownColumns(knownColumns, rightColumns, rows);
   }
   rows = applyFilter(rows, stmt.where, fieldTypeResolver, appliedKlikes, fieldSemanticsResolver);
-  if (stmt.groupBy.length > 0 || hasAggregateColumns(stmt.columns)) {
-    rows = applyGroupBy(rows, stmt.groupBy, stmt.columns, aggregateSortKindResolver);
+  const grouping = normalizeGroupingSpec(stmt);
+  if (grouping.type === "GROUPING_SETS") {
+    if (!resolvedGroupingSpec) {
+      throw new Error("internal error: B65 grouping sets require a metadata-resolved grouping spec.");
+    }
+    rows = applyGroupingSets(
+      rows,
+      resolvedGroupingSpec,
+      stmt.columns,
+      aggregateSortKindResolver,
+      { maxGeneratedRows: B65_MAX_GENERATED_ROWS }
+    );
+  } else if (grouping.type === "PLAIN" || hasAggregateColumns(stmt.columns)) {
+    rows = applyGroupBy(
+      rows,
+      grouping.type === "PLAIN" ? grouping.allItems : [],
+      stmt.columns,
+      aggregateSortKindResolver
+    );
   }
   rows = applyHaving(rows, stmt.having, havingFieldTypeResolver, havingFieldSemanticsResolver);
   rows = applyWindow(rows, stmt.columns, optionOrders, sortKinds, effectiveOrderSemantics);
@@ -12319,6 +12931,9 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
   assertApplyScope("phase15b", stmt);
   assertApplyExecutionScope("phase15b", stmt);
   validateKlikeStatement(stmt);
+  if (stmt.type !== "EXPLAIN") {
+    await validateStatementGroupingPlanning(stmt, client, cacheContext);
+  }
   if (stmt.type === "IMPORT") return executeImport(stmt, client, options, cacheContext);
   if (stmt.type === "UPDATE" && stmt.applyBlocks?.length) {
     if (stmt.validationErrorTable) {
@@ -13193,7 +13808,7 @@ async function evaluateScalarSubquery(sourceQuery, client, options, cacheContext
   return result.rows[0]?.[result.columns[0]] ?? "";
 }
 function withScalarProbeLimit(query) {
-  const hasAgg = query.groupBy.length > 0 || query.columns.some((c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL");
+  const hasAgg = normalizeGroupingSpec(query).type !== "NONE" || query.columns.some((c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL");
   if (hasAgg || query.distinct || query.limit !== null) return { query, probed: false };
   return { query: { ...query, limit: 2 }, probed: true };
 }
@@ -13385,6 +14000,7 @@ async function assertDmlWhereCapability(stmt, client, cacheContext) {
 }
 async function executeSelect(stmt, client, options, cacheContext, cteCache, captureColumnMeta = false) {
   let result;
+  await validateSelectGroupingPlanning(stmt, client, cacheContext, cteCache);
   if (isNoFromSelect(stmt)) {
     result = executeNoFromSelect(stmt);
     if (captureColumnMeta) {
@@ -13414,18 +14030,15 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     client,
     cacheContext
   );
-  const completeReasons = orderPlan?.kind === "CANONICAL_REST_TOP_N" || orderPlan?.kind === "KORDER_NATIVE" || orderPlan?.kind === "KORDER_CURSOR" ? completeInputReasons({ ...stmt, orderBy: [] }) : completeInputReasons(stmt);
-  const completeInputRequired = completeReasons.size > 0;
-  const truncateWasDisabled = completeInputRequired && options.onLimitReached === "truncate";
-  const effectiveOptions = truncateWasDisabled ? { ...options, onLimitReached: "error" } : options;
+  const completePolicy = buildCompleteInputPolicy(stmt, options, orderPlan);
   try {
     if (mode === "SIMPLE") {
-      result = await executeSimpleSelect(stmt, client, effectiveOptions, cacheContext, orderPlan, orderMeta);
+      result = await executeSimpleSelect(stmt, client, completePolicy.effectiveOptions, cacheContext, orderPlan, orderMeta);
     } else {
       result = await executeFullScanSelect(
         stmt,
         client,
-        effectiveOptions,
+        completePolicy.effectiveOptions,
         cacheContext,
         cteCache,
         whereCapability.capability === "EXACT_PUSHDOWN",
@@ -13433,23 +14046,145 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
       );
     }
   } catch (error) {
-    if (completeInputRequired && error instanceof FetchAllLimitError) {
-      throw new FetchAllLimitError(
-        completeInputErrorPrefix(completeReasons) + (truncateWasDisabled ? "onLimit=truncate\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002" : "") + error.message
-      );
-    }
-    throw error;
+    throwCompleteInputError(completePolicy, error);
   }
   if (captureColumnMeta) {
     materializedMetaBySelectResult.set(result, await inferSelectColumnMeta(stmt, result.columns, client, cacheContext, cteCache));
   }
   return result;
 }
+var resolvedGroupingSpecs = /* @__PURE__ */ new WeakMap();
+async function validateStatementGroupingPlanning(statement, client, cacheContext) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = async (node) => {
+    if (node === null || typeof node !== "object") return;
+    if (seen.has(node)) return;
+    seen.add(node);
+    if (Array.isArray(node)) {
+      for (const item of node) await visit(item);
+      return;
+    }
+    const value = node;
+    if (value["type"] === "SELECT") {
+      await validateSelectGroupingPlanning(node, client, cacheContext);
+    }
+    for (const child of Object.values(value)) await visit(child);
+  };
+  await visit(statement);
+}
+async function buildGroupingFieldResolver(stmt, client, cacheContext, materializedTables) {
+  const tables = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  const physicalTables = tables.filter((table) => table.cteName === null);
+  const infosByApp = new Map(
+    await Promise.all([...new Set(physicalTables.map((table) => table.appId))].map(async (appId) => {
+      const infos = await getFieldsCached(appId, client, cacheContext);
+      return [appId, new Map(infos.map((info) => [info.code, info]))];
+    }))
+  );
+  const physicalMatch = (table, field) => {
+    if (field === "$id") return "$id";
+    const code = fieldCodeForTypeLookup(table, field);
+    return infosByApp.get(table.appId)?.has(code) ? code : null;
+  };
+  const materializedHas = (table, field) => {
+    if (table.cteName === null) return false;
+    const materialized = materializedTables?.get(table.cteName);
+    return materialized ? materialized.columns.includes(field) : true;
+  };
+  const resolved = (table, tableIndex, field, code) => {
+    const sameNamePhysical = tables.filter(
+      (candidate) => candidate.cteName === null && physicalMatch(candidate, field.field) !== null
+    ).length;
+    const sameNameMaterialized = tables.some((candidate) => materializedHas(candidate, field.field));
+    const alias = effectiveTableAlias(table);
+    return {
+      canonicalId: `source:${tableIndex}:APP${table.appId}:${code}`,
+      directKey: field.tableAlias && alias ? `${field.tableAlias}.${field.field}` : field.field,
+      unqualifiedBridgeKey: sameNamePhysical === 1 && !sameNameMaterialized ? field.field : null,
+      physical: true
+    };
+  };
+  return (field) => {
+    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.`);
+      }
+      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.`
+        );
+      }
+      const code = physicalMatch(table, field.field);
+      if (code === null) {
+        throw new Error(`ArgumentError: B65 field ${field.tableAlias}.${field.field} does not exist in APP${table.appId}.`);
+      }
+      return resolved(table, tableIndex, field, code);
+    }
+    const physicalMatches = tables.flatMap((table, tableIndex) => {
+      if (table.cteName !== null) return [];
+      const code = physicalMatch(table, field.field);
+      return code === null ? [] : [{ table, tableIndex, code }];
+    });
+    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.`);
+    }
+    if (physicalMatches.length === 1 && materializedMatches.length === 0) {
+      const match = physicalMatches[0];
+      return resolved(match.table, match.tableIndex, field, match.code);
+    }
+    if (materializedMatches.length === 1) {
+      throw new Error(
+        `ArgumentError: B65 field ${field.field} resolves to a materialized CTE/temp column; physical APP fields are required.`
+      );
+    }
+    throw new Error(`ArgumentError: B65 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 (resolvedSpec) resolvedGroupingSpecs.set(stmt, resolvedSpec);
+}
 function completeInputErrorPrefix(reasons) {
   const reasonList = [...reasons].join(", ");
-  const subject = reasons.size === 1 && reasons.has("STATISTICAL_AGGREGATE") ? "\u7D71\u8A08\u96C6\u7D04\u306E\u6B63\u3057\u3044\u7D50\u679C" : "ORDER BY\u306E\u6B63\u3057\u3044\u7D50\u679C";
+  const subject = reasons.size === 1 && reasons.has("STATISTICAL_AGGREGATE") ? "\u7D71\u8A08\u96C6\u7D04\u306E\u6B63\u3057\u3044\u7D50\u679C" : reasons.size === 1 && reasons.has("GROUPING_SETS") ? "\u5C0F\u8A08\u30FB\u7DCF\u8A08\u306E\u6B63\u3057\u3044\u7D50\u679C" : reasons.has("GROUPING_SETS") ? "\u30AF\u30A8\u30EA\u306E\u6B63\u3057\u3044\u7D50\u679C" : "ORDER BY\u306E\u6B63\u3057\u3044\u7D50\u679C";
   return `${subject}\u306B\u306F\u5B8C\u5168\u306A\u5019\u88DC\u96C6\u5408\u304C\u5FC5\u8981\u3067\u3059\u3002complete input reason: ${reasonList}\u3002`;
 }
+function buildCompleteInputPolicy(stmt, options, orderPlan) {
+  const reasons = orderPlan?.kind === "CANONICAL_REST_TOP_N" || orderPlan?.kind === "KORDER_NATIVE" || orderPlan?.kind === "KORDER_CURSOR" ? completeInputReasons({ ...stmt, orderBy: [] }) : completeInputReasons(stmt);
+  const truncateWasDisabled = reasons.size > 0 && options.onLimitReached === "truncate";
+  return {
+    reasons,
+    effectiveOptions: truncateWasDisabled ? { ...options, onLimitReached: "error" } : options,
+    truncateWasDisabled
+  };
+}
+function throwCompleteInputError(policy, error) {
+  if (policy.reasons.size > 0 && error instanceof FetchAllLimitError) {
+    throw new FetchAllLimitError(
+      completeInputErrorPrefix(policy.reasons) + (policy.truncateWasDisabled ? "onLimit=truncate\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002" : "") + error.message
+    );
+  }
+  throw error;
+}
+async function withCompleteInputPolicy(policy, action) {
+  try {
+    return await action();
+  } catch (error) {
+    throwCompleteInputError(policy, error);
+  }
+}
 function isConstantFalseWhere(where) {
   return where?.type === "BOOLEAN" && where.value === false;
 }
@@ -13514,7 +14249,7 @@ function validateNoFromColumns(stmt) {
   }
 }
 function executeNoFromSelect(stmt) {
-  if (stmt.joins.length > 0 || stmt.where || stmt.groupBy.length > 0 || stmt.having || stmt.orderBy.length > 0 || stmt.distinct) {
+  if (stmt.joins.length > 0 || stmt.where || normalizeGroupingSpec(stmt).type !== "NONE" || stmt.having || stmt.orderBy.length > 0 || stmt.distinct) {
     throw new Error("ArgumentError: JOIN/WHERE/GROUP BY/HAVING/ORDER BY/DISTINCT are not supported without FROM.");
   }
   validateNoFromColumns(stmt);
@@ -14155,6 +14890,8 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
       }
     } else if (column.type === "ARITH_AGG_COL" || column.type === "ARITH_COL") {
       meta = syntheticColumnMeta("number");
+    } else if (column.type === "GROUPING_COL") {
+      meta = syntheticColumnMeta("number");
     } else if (column.type === "LITERAL_COL") {
       meta = syntheticColumnMeta("string");
     } else if (column.type === "SCALAR_VALUE_COL") {
@@ -14194,7 +14931,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 outputAliases = new Set(
+  const outputAliases2 = new Set(
     stmt.columns.map((column) => "alias" in column ? column.alias : null).filter((alias) => alias !== null)
   );
   const row = (field) => {
@@ -14218,7 +14955,7 @@ function buildSelectFieldTypeResolvers(stmt, fieldTypesByApp) {
     return matches.length === 1 ? matches[0] : void 0;
   };
   const having = (field) => {
-    if (field.tableAlias === null && outputAliases.has(field.field)) return void 0;
+    if (field.tableAlias === null && outputAliases2.has(field.field)) return void 0;
     return row(field);
   };
   return { row, having };
@@ -14340,7 +15077,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     havingFieldTypeResolver: fieldTypeResolvers.having,
     havingFieldSemanticsResolver,
     aggregateSortKindResolver,
-    appliedKlikes: pushdownPlan.appliedKlikes
+    appliedKlikes: pushdownPlan.appliedKlikes,
+    resolvedGroupingSpec: resolvedGroupingSpecs.get(stmt)
   });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
@@ -14427,6 +15165,8 @@ async function executeQueryWithCte(query, client, options, cteCache, cacheContex
   return result;
 }
 async function executeFullScanWithCte(stmt, client, options, cteCache, cacheContext) {
+  await validateSelectGroupingPlanning(stmt, client, cacheContext, cteCache);
+  const resolvedGroupingSpec = resolvedGroupingSpecs.get(stmt);
   const hiddenQualifiedAliases = /* @__PURE__ */ new Set();
   const withEffectiveAlias = (table) => {
     if (table.alias !== null || table.cteName === null) return table;
@@ -14471,16 +15211,16 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(whereCapability)}).`);
   }
   const orderMeta = await buildOrderByMetaForSelect(stmt, client, cacheContext, cteCache);
-  if (hasCanonicalOrder(stmt)) {
-    (stmt.orderMode === "KINTONE_NATIVE" ? planKorder : planCanonicalOrder)({
-      stmt,
-      staticMode: "FULL_SCAN",
-      whereCapability: whereCapability.capability,
-      orderSemantics: orderMeta.semantics,
-      maxRecords,
-      hasKlike: whereHasKlike(stmt.where)
-    });
-  }
+  const orderPlan = hasCanonicalOrder(stmt) ? (stmt.orderMode === "KINTONE_NATIVE" ? planKorder : planCanonicalOrder)({
+    stmt,
+    staticMode: "FULL_SCAN",
+    whereCapability: whereCapability.capability,
+    orderSemantics: orderMeta.semantics,
+    maxRecords,
+    hasKlike: whereHasKlike(stmt.where)
+  }) : null;
+  const completePolicy = buildCompleteInputPolicy(stmt, options, orderPlan);
+  const effectiveOptions = completePolicy.effectiveOptions;
   const [pushdownMeta, typedInFieldTypes, aggregateSortKindResolver] = await Promise.all([
     loadTypedPushdownMeta(stmt, client, cacheContext),
     loadTypedInFieldTypes(stmt, client, cacheContext),
@@ -14497,7 +15237,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   const havingFieldSemanticsResolver = buildHavingFieldSemanticsResolver(stmt, fieldSemanticsResolver);
   const pushdownPlan = buildKlikePushdownPlan(stmt, pushdownMeta);
   validateKlikePushdownPlan(pushdownPlan);
-  const scalarCachePromise = resolveScalarColumns(stmt.columns, client, options, cacheContext, cteCache);
+  const scalarCachePromise = resolveScalarColumns(stmt.columns, client, effectiveOptions, cacheContext, cteCache);
   const orderByMetaPromise = Promise.resolve(orderMeta);
   scalarCachePromise.catch(() => {
   });
@@ -14510,21 +15250,21 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     tables.set(stmt.from.alias, table.rows.map(processRowToKintoneRecord));
     tableColumns.set(stmt.from.alias, table.columns);
   } else {
-    const mainRecords = await fetchTableRecordsForFullScan(
+    const mainRecords = await withCompleteInputPolicy(completePolicy, () => fetchTableRecordsForFullScan(
       stmt,
       stmt.from,
       client,
       maxRecords,
       parallel,
       true,
-      options.onLimitReached ?? "error",
+      effectiveOptions.onLimitReached ?? "error",
       warnings,
       pushdownPlan.mainCondition,
       whereCapability.capability === "EXACT_PUSHDOWN"
-    );
+    ));
     tables.set(stmt.from.alias, mainRecords);
   }
-  const joinFetches = stmt.joins.map(async (join2) => {
+  const joinFetches = stmt.joins.map((join2) => withCompleteInputPolicy(completePolicy, async () => {
     if (join2.table.cteName != null) {
       const table = requireMaterializedTable(join2.table.cteName);
       tables.set(join2.table.alias, table.rows.map(processRowToKintoneRecord));
@@ -14538,7 +15278,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
         client,
         maxRecords,
         parallel,
-        options.onLimitReached ?? "error",
+        effectiveOptions.onLimitReached ?? "error",
         warnings,
         pushDownCond
       );
@@ -14549,13 +15289,13 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
         maxRecords,
         parallel,
         false,
-        options.onLimitReached ?? "error",
+        effectiveOptions.onLimitReached ?? "error",
         warnings,
         pushDownCond
       );
       tables.set(join2.table.alias, joinRecords);
     }
-  });
+  }));
   await Promise.all(joinFetches);
   const scalarCache = await scalarCachePromise;
   const { optionOrders, sortKinds, semantics } = await orderByMetaPromise;
@@ -14575,7 +15315,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     appliedKlikes: pushdownPlan.appliedKlikes,
     sourceColumns,
     tableColumns,
-    hiddenQualifiedAliases
+    hiddenQualifiedAliases,
+    resolvedGroupingSpec
   });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
@@ -14908,6 +15649,8 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
     if (column.type === "FIELD") meta = resolveField2(aggregateFieldRef(column.field));
     else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
       meta = syntheticColumnMeta("number");
+    } else if (column.type === "GROUPING_COL") {
+      meta = syntheticColumnMeta("number");
     } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_VALUE_COL") meta = syntheticColumnMeta("string");
     else if (column.type === "STRFUNC_COL") meta = stringFunctionColumnMeta(column.expr);
     else if (column.type === "SCALAR_SUBQUERY_COL") meta = unknownStringColumnMeta();
@@ -17732,7 +18475,7 @@ function compareByOrder(a, b, orderBy, resolveSemantics) {
   for (const item of orderBy) {
     const av = evalOrderKeyForRow(item.key, a);
     const bv = evalOrderKeyForRow(item.key, b);
-    const semantics = item.key.type === "FIELD_NAME" ? resolveSemantics(aggregateFieldRef(item.key.name)) : item.key.type === "ARITH_KEY" ? syntheticSemantics("number") : stringFunctionColumnMeta(item.key.expr).semantics ?? syntheticSemantics("string");
+    const semantics = item.key.type === "FIELD_NAME" ? resolveSemantics(aggregateFieldRef(item.key.name)) : item.key.type === "ARITH_KEY" ? syntheticSemantics("number") : item.key.type === "FUNC_KEY" ? stringFunctionColumnMeta(item.key.expr).semantics ?? syntheticSemantics("string") : syntheticSemantics("number");
     const cmp = compareCanonicalValues(av, bv, semantics ?? syntheticSemantics("string"));
     if (cmp !== 0) return item.direction === "ASC" ? cmp : -cmp;
   }
@@ -17746,6 +18489,8 @@ function evalOrderKeyForRow(key, row) {
       return String(evalArithExpr(key.expr, row));
     case "FUNC_KEY":
       return evalStringFunc(key.expr, row);
+    case "GROUPING_KEY":
+      throw new Error("ArgumentError: GROUPING() is not supported in REORDER BY.");
   }
 }
 async function executeUpsertSelect(stmt, client, options, cacheContext, cteCache) {
@@ -17984,6 +18729,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     const typed = node;
     if (typed["type"] === "SELECT") {
       const select = node;
+      await validateSelectGroupingPlanning(select, tracedClient, cacheContext);
       const physicalApps = [select.from, ...select.joins.map((join2) => join2.table)].filter((table) => table.cteName === null).map((table) => table.appId);
       const needsWhereSchema = whereNeedsFieldMetadata(select.where);
       if (needsWhereSchema || select.orderBy.length > 0 || select.columns.some((column) => column.type === "WINDOW_COL" && column.orderBy.length > 0)) {
@@ -18410,13 +19156,23 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans) {
     reasons.push(...whereCapability.reasons.map((reason) => reason.code));
   }
   const lines = [];
+  const groupingMetadata = buildGroupingExplainMetadata(
+    stmt,
+    resolvedGroupingSpecs.get(stmt)?.allItems.length
+  );
   if (label) lines.push(label);
   lines.push(`  mode:          ${mode}`);
-  if (isConstantFalseWhere(stmt.where)) {
-    lines.push("  predicate:     constant false");
-    lines.push("  records API access: none");
-    lines.push(`  app:           APP${stmt.from.appId} (${stmt.from.appId})`);
-    return lines;
+  if (groupingMetadata) {
+    lines.push(`  grouping source: ${groupingMetadata.source}`);
+    lines.push(
+      `  grouping sets: ${groupingMetadata.expandedSetCount} (limit: ${groupingMetadata.setLimit})`
+    );
+    lines.push(
+      `  grouping items: ${groupingMetadata.groupingItemCount} (limit: ${groupingMetadata.itemLimit})`
+    );
+    lines.push(
+      `  grouping output rows: runtime checked (limit: ${groupingMetadata.outputRowLimit}, before HAVING/DISTINCT/LIMIT)`
+    );
   }
   if (orderPlan) {
     lines.push(`  order plan:    ${orderPlan.kind}`);
@@ -18430,15 +19186,24 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans) {
       lines.push("  cursor page size: 500");
       lines.push(`  scan rows:     ${orderPlan.scanRows}`);
     }
+  } else if (groupingMetadata) {
+    lines.push("  order plan:    CANONICAL_LOCAL");
   }
   const explainedStmt = orderPlan && !orderPlan.requiresCompleteInput ? { ...stmt, orderBy: [] } : stmt;
   const completeReasons = completeInputReasons(explainedStmt);
   if (orderPlan?.requiresCompleteInput) completeReasons.add("LOCAL_ORDER");
-  if (completeReasons.size > 0) {
+  const constantFalse = isConstantFalseWhere(stmt.where);
+  if (completeReasons.size > 0 && (!constantFalse || groupingMetadata !== null)) {
     lines.push("  complete input: required (onLimit=truncate disabled)");
     lines.push(`  complete input reason: ${[...completeReasons].join(", ")}`);
     lines.push("  onLimit=truncate: disabled");
   }
+  if (constantFalse) {
+    lines.push("  predicate:     constant false");
+    lines.push("  records API access: none");
+    lines.push(`  app:           APP${stmt.from.appId} (${stmt.from.appId})`);
+    return lines;
+  }
   if (mode === "FULL_SCAN" && reasons.length > 0) {
     lines.push(`  reason:        ${reasons.join(", ")}`);
   }
@@ -18522,8 +19287,11 @@ function collectFullScanReasons(stmt) {
     r.push("\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB\u4EEE\u60F3\u30C6\u30FC\u30D6\u30EB");
   if (stmt.joins.length > 0)
     r.push("JOIN \u3042\u308A");
-  if (stmt.groupBy.length > 0)
+  const grouping = normalizeGroupingSpec(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");
   if (stmt.distinct)
     r.push("DISTINCT \u3042\u308A");
   if (stmt.columns.some((c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL"))