WL#15843 HeatWave CUBE Support

This worklog implements support for CUBE aggregation extension in
HeatWave using a transformation after the QKRN creation. CUBE is not
yet supported in MySQL, hence this functionality will be available only
in HeatWave.

What is CUBE:
==============
The CUBE group by modifier is a feature in SQL used to generate a
result set that includes all possible combinations of values for
specified columns in the GROUP BY clause. When the CUBE modifier
is used in a GROUP BY statement, it generates a result set that
includes subsets for each possible combination of values from the
specified columns. This includes all possible grouping sets, including
single column values, all combinations of two columns, three columns,
and so on.

SYNTAX:
================
GROUP BY CUBE ( <list of columns separated by comma> )
Another syntax for ROLLUP is also introduced
GROUP BY ROLLUP ( <list of columns separated by comma> )

Please note that the old syntax for ROLLUP
GROUP BY  <list of columns separated by comma>  WITH ROLLUP
also exists.

Execution in PRIMARY and SECONDARY engine
=========================================
The group by modifier CUBE can be executed only in Heatwave.
In case the query cannot be executed in HeatWave or the secondary
engine is switched OFF, then it cannot be executed in MySQL either
since MySQL does not support CUBE. The error message will be
"ERROR HY000: CUBE is not supported"

Constraint
================
Maximum number of Group By modifier branches to be supported is 128.
This constraint can be extracted from GetMaximumNumGrpByColsSupported.

Limitations:
==============
The existing limitations of ROLLUP also apply to CUBE which are :
1) This worklog will only support CUBE modifier for aggregations
 WITHOUT DISTINCT, i.e. AGGREGATION(DISTINCT ...) will not be satisfied.
2) This worklog does NOT support CUBE modifier in the presence of
 duplicate GROUP BY keys.

High level Design:
=================
Say we have a query of the form

SELECT col1, col2, SUM(data) AS summ, GROUPING(col1) as grp1,
        GROUPING(col1, col2) AS grp1_2
FROM t1
GROUP BY CUBE (col1, col2);

The high-level idea is to transform a query into an equivalent form
WITH base AS (
   SELECT col1, col2, SUM(data) AS summ
   FROM t1 GROUP BY col1, col2
)
SELECT col1, col2, summ, 0 as grp1, 0 AS grp1_2 FROM base
 UNION ALL
SELECT col1, NULL, SUM(summ), 0 as grp1, 1 AS grp1_2 FROM base
GROUP BY col1
 UNION ALL
SELECT NULL, col2, SUM(summ), 1 as grp1, 2 AS grp1_2 FROM base
GROUP BY col2
 UNION ALL
SELECT NULL, NULL, SUM(summ), 1 as grp1, 3 AS grp1_2 FROM base
HAVING (SELECT COUNT(*) FROM base) > 0;

Grouping set representation for ROLLUP and CUBE
==========================================================
Group by modifiers such as ROLLUP and CUBE can be represented as
grouping sets, which are determined during query preparation.
The representation of the grouping set is done using a bitfield
in the ORDER object.
case ROLLUP : Say the query has GROUP BY ROLLUP (a,b)
 then the grouping sets will be (a,b) (a) ()
 Here () represents full table aggregate without any grouping.
 Here there are 3 grouping sets ranging from 0 to 2.
 where 0 is the full table aggregate.
 The bitfield associated with Group by element 'a' will be 3 (i,e. 2+1)
 The bitfield associated with Group by element 'b' will be 2 as it is
 part of only set number 2

case CUBE: Say the query has GROUP BY CUBE (a,b)
 then the grouping sets will be (a,b) (a) (b) ()
 The number of grouping sets will be (2^n) where n is the number of
 elements in the GROUP BY list. The bitfield associated with
 Group by element 'a' will be 6 (i,e. 4+2) The bitfield
 associated with Group by element 'b' will be 1.

More implementation Details :
==================================
1) qkrn/rpd_qkrn_transform_rollup.cc is renamed to
qkrn/rpd_qkrn_transform_gb_modifier.cc to make it generic for all
group by modifiers

2) File : handler/ha_rpd_qkrn_expr.cc
Instead of checking for Qkrn_context::FOR_ROLLUP we check for all
types of group by modifiers using the flag Qkrn_context::FOR_GB_MODIFIER

3) File : sql/sql_base.cc
 Fix for the crash of the following query
 Query : SELECT i1 FROM t
         GROUP BY CUBE (i1) HAVING (GROUPING(i1)) > 1;

Problem :The function Group_check::check_expression->find_item_in_list
attempted to find the HAVING condition item (GROUPING(i1)) > 1 in the
select list. However, find_ident field_name is nullptr for the item,
which caused the crash.

4) Bug in ha_rpd.cc
In the case of queries with inner joins, it always returned true,
indicating that the query is pushable. However, the check for constants
in the group by list was never performed for such queries.

5) File :qkrn_bugs_varlen.test
Due to a bug in IsQueryPushable, certain queries with constants in the
group by clause were mistakenly offloaded earlier.

6) File : handler/ha_rpd_qkrn_ap.cc
Previously, ExtractRequiredItemForGroupBy would return the temporary
table item, and the caller would then extract the required items from
the temporary table list as well. Now, the extraction of required items
from the temporary table is performed directly within the function.

7) File: sql/sql_lex.h
The functionality of mark_item_as_maybe_null_if_rollup_item is now
moved to Query_block::prepare.

8) File: handler/ha_rpd_qkrn_ap.cc
The call for !func->has_rollup_expr() is removed as
!HasAggregationItem(func) already performs the same check.

9) File: handler/ha_rpd_qkrn_common.cc
The function IsGroupConcatWithRollup is removed, and instead, the check
is placed within HasIncompatibleGroupConcat.

10) File : cp_func_gconcat.inc
Some of the explain statements are removed since the corresponding
select statements are already present in the file and the file is
executed with the secondary_engine=FORCED flag.

11) Bug#35669045
Query
============
SELECT alias2 . pk AS field1
FROM E AS alias2
GROUP BY CUBE (field1)
ORDER BY STRCMP( '', field1 );

In function Item_field::fix_fields, the item returned from
find_item_in_list is a Item_field, hence  *reference is
NOT updated.

Solution: In function Item_field::fix_fields,
update *reference even for fields

12) Added some custom TPCH queries for comparing performance of CUBE.

13) The flag PROP_ROLLUP_EXPR is replaced with PROP_GROUP_BY_MODIFIER

14) Bug#35779978: At the end of Query_block::prepare, the Grouping set
    dependency flag is set for all the items which are part of the GROUP
    BY list. But the flag was not updated properly for the parent items.

Bug#35669045 - #wl15843-Segmentation fault- Rapid server crash- rpdmqxra2_bv_bitset
Bug#35683655 - #wl15843-Segmentation fault-Mysqld crash- KEY_PART_INFO::init_from_field ()
Bug#35681749 - #wl15843-Segmentation fault:-rpdmpr_bexpr_fromdays_RPDMPR_DTYPE_SB4_RPDMPR_DTYPE
Bug#35690590 - #wl15843-Rapid crash rpdmpr_bexpr_extract_RPDMPR_DTYPE_SB8_RPDMPR_DTYPE_DSB16_RP
Bug#35731905 - #wl15843-Mysqld Crash- Assertion:-rpd::CreateIndividualGroupByModifierBranch
Bug#35750113 - #wl15843:Mysqld-crash-Segmentation fault:rpd::FixColumnIdsInOpnArray
Bug#35672851 - #wl15843-Incorrect offload error messages,QCOMP: window functions failing with ROLLUP
Bug#33814459 - Exception during Qcomp, currently only support tasks with
Bug#35762767 - #wl15843-Segmentation fault:Rpdserver crash:-bv_bitset
Bug#35749317 - #wl15843-Mysqld-crash:Segmentation fault:rpd::ContainsUnsupportedCastEnumToChar
Bug#35779978 - #wl15843-Segmentation fault:Rpdserver crash:-rpdmqxra2_bv_bitset
Bug#35793146 - #wl15843-Mysqld crash-glibcxx_assert_fail-Assertion 'get() != pointer()' failed
Bug#35794723 - #wl15843-Rpdserver crash- Assertion-rpdmpr_winfunc_min_max_remove

Change-Id: I007aa396869d10f0eb787252bfd6eafc2a2a6410

Author: Kajori Banerjee

mysql-test/r/information_schema_keywords.result

@@ -102,7 +102,7 @@ CONVERT	1
 CPU	0
 CREATE	1
 CROSS	1
-CUBE	1
+CUBE	0
 CUME_DIST	1
 CURRENT	0
 CURRENT_DATE	1

mysql-test/r/olap.result

@@ -306,18 +306,17 @@ CONCAT(':',product,':')	SUM(profit)	AVG(profit)
 :TV:	600	120.00000
 NULL	7785	519.00000
 SELECT product, country_id , year, SUM(profit) FROM t1
-GROUP BY product, country_id, year WITH CUBE;
-ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'WITH CUBE' at line 2
+GROUP BY CUBE (product, country_id, year);
+ERROR HY000: Secondary engine operation failed. No secondary engine defined for at least one of the query tables.
 EXPLAIN SELECT product, country_id , year, SUM(profit) FROM t1
-GROUP BY product, country_id, year WITH CUBE;
-ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'WITH CUBE' at line 2
+GROUP BY CUBE (product, country_id, year);
+ERROR HY000: Secondary engine operation failed. No secondary engine defined for at least one of the query tables.
 SELECT product, country_id , year, SUM(profit) FROM t1
-GROUP BY product, country_id, year WITH CUBE UNION ALL
+GROUP BY CUBE (product, country_id, year)
+UNION ALL
 SELECT product, country_id , year, SUM(profit) FROM t1
-GROUP BY product, country_id, year WITH ROLLUP;
-ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'WITH CUBE UNION ALL
-SELECT product, country_id , year, SUM(profit) FROM t1
-GROUP' at line 2
+GROUP BY ROLLUP (product, country_id, year);
+ERROR HY000: Secondary engine operation failed. No secondary engine defined for at least one of the query tables.
 drop table t1,t2;
 CREATE TABLE t1 (i int);
 INSERT INTO t1 VALUES(100);

mysql-test/t/olap.test

@@ -127,20 +127,18 @@ GROUP BY product, country_id, year HAVING country_id is NULL;
 SELECT CONCAT(':',product,':'), SUM(profit), AVG(profit) FROM t1
 GROUP BY product WITH ROLLUP;
 
-# Error handling
-
-# Old, never implemented CUBE syntax
---error ER_PARSE_ERROR
+--error ER_SECONDARY_ENGINE
 SELECT product, country_id , year, SUM(profit) FROM t1
-GROUP BY product, country_id, year WITH CUBE;
---error ER_PARSE_ERROR
+GROUP BY CUBE (product, country_id, year);
+--error ER_SECONDARY_ENGINE
 EXPLAIN SELECT product, country_id , year, SUM(profit) FROM t1
-GROUP BY product, country_id, year WITH CUBE;
---error ER_PARSE_ERROR
+GROUP BY CUBE (product, country_id, year);
+--error ER_SECONDARY_ENGINE
 SELECT product, country_id , year, SUM(profit) FROM t1
-GROUP BY product, country_id, year WITH CUBE UNION ALL
+GROUP BY CUBE (product, country_id, year)
+UNION ALL
 SELECT product, country_id , year, SUM(profit) FROM t1
-GROUP BY product, country_id, year WITH ROLLUP;
+GROUP BY ROLLUP (product, country_id, year);
 
 drop table t1,t2;
 

share/messages_to_clients.txt

@@ -10103,6 +10103,13 @@ ER_BULK_READER_COULDNT_RESOLVE_HOST
 
 ER_START_REPLICA_CHANNEL_INVALID_CONFIGURATION
   eng "Cannot start replication channel '%s' because %s."
+
+ER_CANNOT_EXECUTE_IN_PRIMARY
+   eng "'%s' is not supported"
+
+ER_TOO_MANY_GROUP_BY_MODIFIER_BRANCHES
+   eng "'%s' is supported with maximum %d elements in the GROUP BY list"
+
 #
 #  End of 8.1+ error messages (server-to-client).
 #  Do NOT add messages intended for the error log above!

sql/aggregate_check.cc

@@ -362,7 +362,7 @@ bool Group_check::is_fd_on_source(Item *item) {
     }
   }
 
-  if (select->olap != UNSPECIFIED_OLAP_TYPE) {
+  if (select->is_non_primitive_grouped()) {
     /*
       - the syntactical transformation of ROLLUP is to make a union of
       queries, and in each such query, some group column references are
@@ -616,7 +616,7 @@ void Group_check::add_to_source_of_mat_table(Item_field *item_field,
   Query_block *const mat_query_block =
       mat_query_expression->first_query_block();
   if (mat_query_expression->is_set_operation() ||
-      mat_query_block->olap != UNSPECIFIED_OLAP_TYPE)
+      mat_query_block->is_non_primitive_grouped())
     return;  // If UNION, EXCEPT, INTERSECT or ROLLUP, no FD
   // Grab Group_check for this subquery.
   Group_check *mat_gc = nullptr;

sql/item.h

@@ -3396,13 +3396,20 @@ class Item : public Parse_tree_node {
   void set_wf() { m_accum_properties |= PROP_WINDOW_FUNCTION; }
 
   /**
-    @return true if this item or any of its descendants within the same query
-    has a reference to a ROLLUP expression
-  */
-  bool has_rollup_expr() const { return m_accum_properties & PROP_ROLLUP_EXPR; }
+     @return true if this item or any of its descendants within the same query
+     has a reference to a GROUP BY modifier (such as ROLLUP)
+   */
+  bool has_grouping_set_dep() const {
+    return (m_accum_properties & PROP_HAS_GROUPING_SET_DEP);
+  }
 
-  /// Set the property: this item (tree) contains a reference to a ROLLUP expr
-  void set_rollup_expr() { m_accum_properties |= PROP_ROLLUP_EXPR; }
+  /**
+    Set the property: this item (tree) contains a reference to a GROUP BY
+    modifier (such as ROLLUP)
+  */
+  void set_group_by_modifier() {
+    m_accum_properties |= PROP_HAS_GROUPING_SET_DEP;
+  }
 
   /**
     @return true if this item or any of underlying items is a GROUPING function
@@ -3660,14 +3667,15 @@ class Item : public Parse_tree_node {
   static constexpr uint8 PROP_WINDOW_FUNCTION = 0x08;
   /**
     Set if the item or one or more of the underlying items contains a
-    ROLLUP expression. The rolled up expression itself is not so marked.
+    GROUP BY modifier (such as ROLLUP).
   */
-  static constexpr uint8 PROP_ROLLUP_EXPR = 0x10;
+  static constexpr uint8 PROP_HAS_GROUPING_SET_DEP = 0x10;
   /**
     Set if the item or one or more of the underlying items is a GROUPING
     function.
   */
   static constexpr uint8 PROP_GROUPING_FUNC = 0x20;
+
   uint8 m_accum_properties;
 
  public:
@@ -5962,16 +5970,16 @@ class Item_ref : public Item_ident {
     const table_map map = ref_item()->used_tables();
     if (map != 0) return map;
     // rollup constant: ensure it is non-constant by returning RAND_TABLE_BIT
-    if (has_rollup_expr()) return RAND_TABLE_BIT;
+    if (has_grouping_set_dep()) return RAND_TABLE_BIT;
     return 0;
   }
   void update_used_tables() override {
     if (depended_from == nullptr) ref_item()->update_used_tables();
     /*
-      Reset all flags except rollup, since we do not mark the rollup expression
-      itself.
+      Reset all flags except GROUP BY modifier, since we do not mark the rollup
+      expression itself.
     */
-    m_accum_properties &= PROP_ROLLUP_EXPR;
+    m_accum_properties &= PROP_HAS_GROUPING_SET_DEP;
     add_accum_properties(ref_item());
   }
 

sql/item_func.cc

@@ -723,7 +723,8 @@ bool Item_func::split_sum_func(THD *thd, Ref_item_array ref_item_array,
 void Item_func::update_used_tables() {
   used_tables_cache = get_initial_pseudo_tables();
   not_null_tables_cache = 0;
-  m_accum_properties = 0;
+  // Reset all flags except Grouping Set dependency
+  m_accum_properties &= PROP_HAS_GROUPING_SET_DEP;
 
   for (uint i = 0; i < arg_count; i++) {
     args[i]->update_used_tables();
@@ -7784,7 +7785,7 @@ double Item_func_match::val_real() {
   // MATCH only knows how to get the score for base columns. Other types of
   // expressions (such as function calls or rollup columns) should have been
   // rejected during resolving.
-  assert(!has_rollup_expr());
+  assert(!has_grouping_set_dep());
   assert(std::all_of(args, args + arg_count, [](const Item *item) {
     return item->real_item()->type() == FIELD_ITEM;
   }));

sql/item_func.h

@@ -1649,7 +1649,7 @@ class Item_rollup_group_item final : public Item_func {
     // with all the other copying done here.)
     hidden = inner_item->hidden;
     set_nullable(true);
-    set_rollup_expr();
+    set_group_by_modifier();
   }
   double val_real() override;
   longlong val_int() override;
@@ -1670,7 +1670,7 @@ class Item_rollup_group_item final : public Item_func {
   }
   void update_used_tables() override {
     Item_func::update_used_tables();
-    set_rollup_expr();
+    set_group_by_modifier();
   }
   Item_result result_type() const override { return args[0]->result_type(); }
   bool resolve_type(THD *) override {

sql/item_row.cc

@@ -142,7 +142,8 @@ bool Item_row::split_sum_func(THD *thd, Ref_item_array ref_item_array,
 
 void Item_row::update_used_tables() {
   used_tables_cache = 0;
-  m_accum_properties = 0;
+  // Reset all flags except Grouping Set dependency
+  m_accum_properties &= PROP_HAS_GROUPING_SET_DEP;
   not_null_tables_cache = 0;
   for (uint i = 0; i < arg_count; i++) {
     items[i]->update_used_tables();

sql/item_sum.cc

@@ -776,7 +776,7 @@ void Item_sum::update_used_tables() {
   used_tables_cache = 0;
   // Re-accumulate all properties except three
   m_accum_properties &=
-      (PROP_AGGREGATION | PROP_WINDOW_FUNCTION | PROP_ROLLUP_EXPR);
+      (PROP_AGGREGATION | PROP_WINDOW_FUNCTION | PROP_HAS_GROUPING_SET_DEP);
 
   for (uint i = 0; i < arg_count; i++) {
     args[i]->update_used_tables();
@@ -6239,7 +6239,7 @@ bool Item_func_grouping::fix_fields(THD *thd, Item **ref) {
   */
   Query_block *select = thd->lex->current_query_block();
 
-  if (select->olap == UNSPECIFIED_OLAP_TYPE ||
+  if (!select->is_non_primitive_grouped() ||
       select->resolve_place == Query_block::RESOLVE_JOIN_NEST ||
       select->resolve_place == Query_block::RESOLVE_CONDITION) {
     my_error(ER_INVALID_GROUP_FUNC_USE, MYF(0));
@@ -6327,7 +6327,7 @@ bool Item_func_grouping::aggregate_check_group(uchar *arg) {
 void Item_func_grouping::update_used_tables() {
   Item_int_func::update_used_tables();
   set_grouping_func();
-  set_rollup_expr();
+  set_group_by_modifier();
   /*
     GROUPING function can never be a constant item. It's
     result always depends on ROLLUP result.

sql/join_optimizer/access_path.cc

@@ -955,7 +955,7 @@ unique_ptr_destroy_only<RowIterator> CreateIteratorFromAccessPath(
             TableCollection(tables, /*store_rowids=*/false,
                             /*tables_to_get_rowid_for=*/0,
                             GetNullableEqRefTables(param.child)),
-            param.rollup);
+            param.olap == ROLLUP_TYPE);
         break;
       }
       case AccessPath::TEMPTABLE_AGGREGATE: {

sql/join_optimizer/access_path.h

@@ -38,6 +38,7 @@
 #include "sql/join_optimizer/relational_expression.h"
 #include "sql/join_type.h"
 #include "sql/mem_root_array.h"
+#include "sql/olap.h"
 #include "sql/sql_array.h"
 #include "sql/sql_class.h"
 #include "sql/table.h"
@@ -1155,7 +1156,7 @@ struct AccessPath {
     } sort;
     struct {
       AccessPath *child;
-      bool rollup;
+      olap_type olap;
     } aggregate;
     struct {
       AccessPath *subquery_path;
@@ -1461,11 +1462,11 @@ AccessPath *NewSortAccessPath(THD *thd, AccessPath *child, Filesort *filesort,
                               ORDER *order, bool count_examined_rows);
 
 inline AccessPath *NewAggregateAccessPath(THD *thd, AccessPath *child,
-                                          bool rollup) {
+                                          olap_type olap) {
   AccessPath *path = new (thd->mem_root) AccessPath;
   path->type = AccessPath::AGGREGATE;
   path->aggregate().child = child;
-  path->aggregate().rollup = rollup;
+  path->aggregate().olap = olap;
   return path;
 }
 

sql/join_optimizer/cost_model.cc

@@ -854,7 +854,7 @@ void EstimateAggregateCost(AccessPath *path, const Query_block *query_block,
   const AccessPath *child = path->aggregate().child;
   if (path->num_output_rows() == kUnknownRowCount) {
     path->set_num_output_rows(EstimateAggregateRows(
-        child, query_block, path->aggregate().rollup, trace));
+        child, query_block, path->aggregate().olap == ROLLUP_TYPE, trace));
   }
 
   path->set_init_cost(child->init_cost());

sql/join_optimizer/explain_access_path.cc

@@ -1409,9 +1409,12 @@ static std::unique_ptr<Json_object> SetObjectMembers(
         error |= AddMemberToObject<Json_boolean>(obj, "group_by", true);
         if (*join->sum_funcs == nullptr) {
           description = "Group (no aggregates)";
-        } else if (path->aggregate().rollup) {
+        } else if (path->aggregate().olap == ROLLUP_TYPE) {
           error |= AddMemberToObject<Json_boolean>(obj, "rollup", true);
           description = "Group aggregate with rollup: ";
+        } else if (path->aggregate().olap == CUBE_TYPE) {
+          error |= AddMemberToObject<Json_boolean>(obj, "cube", true);
+          description = "Group aggregate with cube: ";
         } else {
           description = "Group aggregate: ";
         }
@@ -1428,9 +1431,9 @@ static std::unique_ptr<Json_object> SetObjectMembers(
         } else {
           description += ", ";
         }
-        string func =
-            (path->aggregate().rollup ? ItemToString((*item)->unwrap_sum())
-                                      : ItemToString(*item));
+        string func = (path->aggregate().olap == ROLLUP_TYPE
+                           ? ItemToString((*item)->unwrap_sum())
+                           : ItemToString(*item));
         description += func;
         error |= AddElementToArray<Json_string>(funcs, func);
       }

sql/join_optimizer/finalize_plan.cc

@@ -97,7 +97,7 @@ static void ReplaceUpdateValuesWithTempTableFields(
   Collects the set of items in the item tree that satisfy the following:
 
   1) Neither the item itself nor any of its descendants have a reference to a
-     ROLLUP expression (item->has_rollup_expr() evaluates to false).
+     ROLLUP expression (item->has_grouping_set_dep() evaluates to false).
   2) The item is either the root item or its parent item does not satisfy 1).
 
   In other words, we do not collect _every_ item without rollup in the tree.
@@ -113,7 +113,7 @@ static void CollectItemsWithoutRollup(Item *root,
   CompileItem(
       root,
       [items](Item *item) {
-        if (item->has_rollup_expr()) {
+        if (item->has_grouping_set_dep()) {
           // Skip the item and continue searching down the item tree.
           return true;
         } else {
@@ -155,13 +155,14 @@ static TABLE *CreateTemporaryTableFromSelectList(
   // the temporary table and the replacement logic depends on base fields being
   // included.
   if (!after_aggregation &&
-      std::any_of(items_to_materialize->cbegin(), items_to_materialize->cend(),
-                  [](const Item *item) { return item->has_rollup_expr(); })) {
+      std::any_of(
+          items_to_materialize->cbegin(), items_to_materialize->cend(),
+          [](const Item *item) { return item->has_grouping_set_dep(); })) {
     items_to_materialize =
         new (thd->mem_root) mem_root_deque<Item *>(thd->mem_root);
     for (Item *item : *join->fields) {
       items_to_materialize->push_back(item);
-      if (item->has_rollup_expr()) {
+      if (item->has_grouping_set_dep()) {
         CollectItemsWithoutRollup(item, items_to_materialize);
       }
     }
@@ -221,10 +222,11 @@ static TABLE *CreateTemporaryTableFromSelectList(
     //
     // TODO(sgunders): Consider removing the rollup group items on the inner
     // levels, similar to what change_to_use_tmp_fields_except_sums() does.
-    auto new_end = std::remove_if(
-        temp_table_param->items_to_copy->begin(),
-        temp_table_param->items_to_copy->end(),
-        [](const Func_ptr &func) { return func.func()->has_rollup_expr(); });
+    auto *new_end = std::remove_if(temp_table_param->items_to_copy->begin(),
+                                   temp_table_param->items_to_copy->end(),
+                                   [](const Func_ptr &func) {
+                                     return func.func()->has_grouping_set_dep();
+                                   });
     temp_table_param->items_to_copy->erase(
         new_end, temp_table_param->items_to_copy->end());
   }