Support PostgreSQL GROUP BY CUBE()

Author: nene

src/cst/Select.ts

@@ -36,6 +36,7 @@ export type AllSelectNodes =
   | WhereClause
   | GroupByClause
   | GroupByRollup
+  | GroupByCube
   | HavingClause
   | WindowClause
   | QualifyClause
@@ -265,7 +266,7 @@ export interface GroupByClause extends BaseNode {
   type: "group_by_clause";
   groupByKw: [Keyword<"GROUP">, Keyword<"BY">];
   distinctKw?: Keyword<"ALL" | "DISTINCT">; // PostgreSQL
-  columns: ListExpr<Expr | GroupByRollup>;
+  columns: ListExpr<Expr | GroupByRollup | GroupByCube>;
   withRollupKw?: [Keyword<"WITH">, Keyword<"ROLLUP">]; // MySQL, MariaDB
 }
 
@@ -276,6 +277,13 @@ export interface GroupByRollup extends BaseNode {
   columns: ParenExpr<ListExpr<Expr>>;
 }
 
+// PostgreSQL
+export interface GroupByCube extends BaseNode {
+  type: "group_by_cube";
+  cubeKw: Keyword<"CUBE">;
+  columns: ParenExpr<ListExpr<Expr>>;
+}
+
 export interface HavingClause extends BaseNode {
   type: "having_clause";
   havingKw: Keyword<"HAVING">;

src/parser.pegjs

@@ -801,6 +801,7 @@ group_by_distinct
 
 grouping_element
   = group_by_rollup
+  / group_by_cube
   / paren$empty_list
   / expr
 
@@ -813,6 +814,15 @@ group_by_rollup
     });
   }
 
+group_by_cube
+  = kw:(CUBE __) cols:paren$list$expr &postgres {
+    return loc({
+      type: "group_by_cube",
+      cubeKw: read(kw),
+      columns: cols,
+    });
+  }
+
 /**
  * SELECT .. HAVING
  * --------------------------------------------------------------------------------------
@@ -5915,6 +5925,7 @@ COPY                = kw:"COPY"i                !ident_part { return loc(createK
 COUNT               = kw:"COUNT"i               !ident_part { return loc(createKeyword(kw)); }
 CREATE              = kw:"CREATE"i              !ident_part { return loc(createKeyword(kw)); }
 CROSS               = kw:"CROSS"i               !ident_part { return loc(createKeyword(kw)); }
+CUBE                = kw:"CUBE"i                !ident_part { return loc(createKeyword(kw)); }
 CUME_DIST           = kw:"CUME_DIST"i           !ident_part { return loc(createKeyword(kw)); }
 CURRENT             = kw:"CURRENT"i             !ident_part { return loc(createKeyword(kw)); }
 CURRENT_CATALOG     = kw:"CURRENT_CATALOG"i     !ident_part { return loc(createKeyword(kw)); }

src/showNode/select.ts

@@ -102,6 +102,7 @@ export const selectMap: FullTransformMap<string, AllSelectNodes> = {
   group_by_clause: (node) =>
     show([node.groupByKw, node.distinctKw, node.columns, node.withRollupKw]),
   group_by_rollup: (node) => show([node.rollupKw, node.columns]),
+  group_by_cube: (node) => show([node.cubeKw, node.columns]),
   having_clause: (node) => show([node.havingKw, node.expr]),
   qualify_clause: (node) => show([node.qualifyKw, node.expr]),
   order_by_clause: (node) =>

test/select/group_by.test.ts

@@ -27,17 +27,22 @@ describe("select GROUP BY", () => {
     });
 
     dialect("postgresql", () => {
-      it("supports multiple ROLLUPs in one GROUP BY", () => {
-        testClauseWc("GROUP BY ROLLUP(id), ROLLUP(name)");
+      it("supports GROUP BY CUBE()", () => {
+        testClauseWc("GROUP BY CUBE (id, name + age)");
+        testClauseWc("GROUP BY CUBE (id, (name, age))");
       });
 
-      it("parses multiple ROLLUPs as group_by_rollup nodes", () => {
-        const clause = parseClause("GROUP BY ROLLUP(id), ROLLUP(name)");
+      it("supports multiple ROLLUPs and CUBEs in one GROUP BY", () => {
+        testClauseWc("GROUP BY ROLLUP(id), CUBE(name)");
+      });
+
+      it("parses multiple ROLLUPs & CUBEs as group_by_rollup/cube nodes", () => {
+        const clause = parseClause("GROUP BY ROLLUP(id), CUBE(name)");
         if (clause.type !== "group_by_clause") {
           throw new Error("Expected group_by_clause");
         }
         expect(clause.columns.items[0].type).toBe("group_by_rollup");
-        expect(clause.columns.items[1].type).toBe("group_by_rollup");
+        expect(clause.columns.items[1].type).toBe("group_by_cube");
       });
     });
   });