Bug#36076513: Refactor LEX to use getter/setter instead of public member

kahatlen · dahlerlend · commit 3c15b14d7912 · 2023-12-08T08:40:40.000+01:00
Add a getter and a setter to better encapsulate
LEX::using_hypergraph_optimizer.

Change-Id: I56467ccedbe929fa18961cc37d7990febd77bdc9
diff --git a/sql/item.cc b/sql/item.cc
@@ -5635,7 +5635,7 @@ bool is_null_on_empty_table(THD *thd, Item_field *i) {
            qsl->group_list.elements == 0;
   else
     return (sl->resolve_place == Query_block::RESOLVE_SELECT_LIST ||
-            (thd->lex->using_hypergraph_optimizer && sl->is_ordered())) &&
+            (thd->lex->using_hypergraph_optimizer() && sl->is_ordered())) &&
            sl->with_sum_func && sl->group_list.elements == 0 &&
            thd->lex->in_sum_func == nullptr;
 }
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
@@ -524,7 +524,7 @@ AccessPath *Item_in_subselect::root_access_path() const {
     // the query to the log for debugging, it isn't fully optimized
     // yet and might not yet have an iterator. Thus, return nullptr instead of
     // assert-failing.
-    assert(current_thd->lex->using_hypergraph_optimizer);
+    assert(current_thd->lex->using_hypergraph_optimizer());
     return nullptr;
   }
 }
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
@@ -4779,7 +4779,7 @@ void Item_rank::update_after_wf_arguments_changed(THD *thd) {
     // on them. This is called only during resolving with ROLLUP in case
     // of old optimizer.
     Item **item_to_be_changed;
-    if (!thd->lex->using_hypergraph_optimizer) {
+    if (!thd->lex->using_hypergraph_optimizer()) {
       Item_ref *item_ref = down_cast<Item_ref *>(m_previous[i]->get_item());
       item_to_be_changed = item_ref->ref_pointer();
     } else {
diff --git a/sql/iterators/composite_iterators.cc b/sql/iterators/composite_iterators.cc
@@ -219,7 +219,7 @@ bool AggregateIterator::Init() {
   // This is a hack. It would be good to get rid of the slice system altogether
   // (the hypergraph join optimizer does not use it).
   if (!(m_join->implicit_grouping || m_join->group_optimized_away) &&
-      !thd()->lex->using_hypergraph_optimizer) {
+      !thd()->lex->using_hypergraph_optimizer()) {
     m_output_slice = m_join->get_ref_item_slice();
   }
 
diff --git a/sql/iterators/ref_row_iterators.cc b/sql/iterators/ref_row_iterators.cc
@@ -607,7 +607,7 @@ FullTextSearchIterator::FullTextSearchIterator(THD *thd, TABLE *table,
   // hand, maintains alternative plans with and without index scans throughout
   // the planning, and doesn't determine whether it should use the indexed or
   // non-indexed plan until the full query plan has been constructed.
-  if (thd->lex->using_hypergraph_optimizer) {
+  if (thd->lex->using_hypergraph_optimizer()) {
     // Should not already be enabled.
     assert(!ft_func->score_from_index_scan);
     // Should operate on the main object.
diff --git a/sql/join_optimizer/access_path.cc b/sql/join_optimizer/access_path.cc
@@ -810,7 +810,7 @@ unique_ptr_destroy_only<RowIterator> CreateIteratorFromAccessPath(
         // path instead of being computed here? We do make the same checks in
         // the cost model, so perhaps it should set the flag as well.
         uint64_t *hash_table_generation =
-            (thd->lex->using_hypergraph_optimizer &&
+            (thd->lex->using_hypergraph_optimizer() &&
              path->parameter_tables == 0)
                 ? &join->hash_table_generation
                 : nullptr;
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
@@ -4955,6 +4955,7 @@ int init_common_variables() {
     }
   }
   update_parser_max_mem_size();
+  update_optimizer_switch();
 
   if (set_default_auth_plugin(default_auth_plugin,
                               strlen(default_auth_plugin))) {
diff --git a/sql/opt_explain.cc b/sql/opt_explain.cc
@@ -1911,7 +1911,7 @@ bool explain_single_table_modification(THD *explain_thd, const THD *query_thd,
     return ExplainIterator(explain_thd, query_thd, nullptr);
   }
 
-  if (query_thd->lex->using_hypergraph_optimizer) {
+  if (query_thd->lex->using_hypergraph_optimizer()) {
     my_error(ER_HYPERGRAPH_NOT_SUPPORTED_YET, MYF(0),
              "EXPLAIN with TRADITIONAL format");
     return true;
@@ -2267,10 +2267,10 @@ bool explain_query(THD *explain_thd, const THD *query_thd,
   // offloaded to a secondary engine, so we return a fake plan with that
   // information.
   const bool fake_explain_for_secondary_engine =
-      query_thd->lex->using_hypergraph_optimizer && secondary_engine &&
+      query_thd->lex->using_hypergraph_optimizer() && secondary_engine &&
       !lex->explain_format->is_hierarchical();
 
-  if (query_thd->lex->using_hypergraph_optimizer &&
+  if (query_thd->lex->using_hypergraph_optimizer() &&
       !fake_explain_for_secondary_engine) {
     // With hypergraph, JSON is iterator-based. So it must be TRADITIONAL.
     my_error(ER_HYPERGRAPH_NOT_SUPPORTED_YET, MYF(0),
diff --git a/sql/set_var.cc b/sql/set_var.cc
@@ -1419,8 +1419,8 @@ int sql_set_variables(THD *thd, List<set_var_base> *var_list, bool opened) {
   LEX *lex = thd->lex;
   set_var_base *var;
   if (!thd->lex->unit->is_prepared()) {
-    lex->using_hypergraph_optimizer =
-        thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER);
+    lex->set_using_hypergraph_optimizer(
+        thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER));
 
     Prepared_stmt_arena_holder ps_arena_holder(thd);
     while ((var = it++)) {
diff --git a/sql/set_var.h b/sql/set_var.h
@@ -1110,7 +1110,6 @@ bool sql_mode_string_representation(THD *thd, sql_mode_t sql_mode,
                                     LEX_STRING *ls);
 bool sql_mode_quoted_string_representation(THD *thd, sql_mode_t sql_mode,
                                            LEX_STRING *ls);
-void update_parser_max_mem_size();
 
 extern sys_var *Sys_autocommit_ptr;
 extern sys_var *Sys_gtid_next_ptr;
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
@@ -10306,7 +10306,7 @@ bool init_ftfuncs(THD *thd, Query_block *query_block) {
   DBUG_PRINT("info", ("Performing FULLTEXT search"));
   THD_STAGE_INFO(thd, stage_fulltext_initialization);
 
-  if (thd->lex->using_hypergraph_optimizer) {
+  if (thd->lex->using_hypergraph_optimizer()) {
     // Set the no_ranking hint if ranking of the results is not required. The
     // old optimizer does this when it determines which scan to use. The
     // hypergraph optimizer doesn't know until the full plan is built, so do it
diff --git a/sql/sql_cmd_ddl_table.cc b/sql/sql_cmd_ddl_table.cc
@@ -367,8 +367,8 @@ bool Sql_cmd_create_table::execute(THD *thd) {
       }
 
       // Use the hypergraph optimizer for the SELECT statement, if enabled.
-      lex->using_hypergraph_optimizer =
-          thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER);
+      lex->set_using_hypergraph_optimizer(
+          thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER));
 
       if (query_expression->prepare(thd, result, nullptr, SELECT_NO_UNLOCK,
                                     0)) {
diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc
@@ -772,7 +772,7 @@ bool Sql_cmd_delete::prepare_inner(THD *thd) {
   // enables it to perform optimizations like sort avoidance and semi-join
   // flattening even if features specific to single-table DELETE (that is, ORDER
   // BY and LIMIT) are used.
-  if (lex->using_hypergraph_optimizer) {
+  if (lex->using_hypergraph_optimizer()) {
     multitable = true;
   }
 
@@ -921,7 +921,7 @@ DeleteRowsIterator::DeleteRowsIterator(
       m_tables_to_delete_from(tables_to_delete_from),
       m_immediate_tables(immediate_tables),
       // The old optimizer does not use hash join in DELETE statements.
-      m_hash_join_tables(thd->lex->using_hypergraph_optimizer
+      m_hash_join_tables(thd->lex->using_hypergraph_optimizer()
                              ? GetHashJoinTables(join->root_access_path())
                              : 0),
       m_tempfiles(thd->mem_root),
@@ -1262,7 +1262,7 @@ table_map GetImmediateDeleteTables(const JOIN *join, table_map delete_tables) {
   // using the hypergraph optimizer is when there is an impossible WHERE clause,
   // in which case join order optimization is short-circuited. See
   // JOIN::create_access_paths_for_zero_rows().
-  if (join->thd->lex->using_hypergraph_optimizer) {
+  if (join->thd->lex->using_hypergraph_optimizer()) {
     assert(join->root_access_path()->type == AccessPath::ZERO_ROWS);
     return 0;
   }
diff --git a/sql/sql_derived.cc b/sql/sql_derived.cc
@@ -1600,7 +1600,7 @@ bool Table_ref::optimize_derived(THD *thd) {
   // doesn't care about const tables, though, so it prefers to do this
   // at execution time (in fact, it will get confused and crash if it has
   // already been materialized).
-  if (!thd->lex->using_hypergraph_optimizer) {
+  if (!thd->lex->using_hypergraph_optimizer()) {
     if (materializable_is_const() &&
         (create_materialized_table(thd) || materialize_derived(thd)))
       return true;
diff --git a/sql/sql_executor.cc b/sql/sql_executor.cc
@@ -3307,7 +3307,7 @@ AccessPath *JOIN::attach_access_paths_for_having_and_limit(AccessPath *path) {
     AccessPath *old_path = path;
     path = NewFilterAccessPath(thd, path, having_cond);
     CopyBasicProperties(*old_path, path);
-    if (thd->lex->using_hypergraph_optimizer) {
+    if (thd->lex->using_hypergraph_optimizer()) {
       // We cannot call EstimateFilterCost() in the pre-hypergraph optimizer,
       // as on repeated execution of a prepared query, the condition may contain
       // references to subqueries that are destroyed and not re-optimized yet.
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
@@ -1694,7 +1694,7 @@ bool Sql_cmd_insert_base::resolve_update_expressions(THD *thd) {
 
   lex->in_update_value_clause = false;
 
-  if (select_insert && !lex->using_hypergraph_optimizer) {
+  if (select_insert && !lex->using_hypergraph_optimizer()) {
     /*
       Traverse the update values list and substitute fields from the
       select for references (Item_ref objects) to them. This is done in
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
@@ -470,7 +470,7 @@ void LEX::reset() {
   server_options.reset();
   explain_format = nullptr;
   is_explain_analyze = false;
-  using_hypergraph_optimizer = false;
+  set_using_hypergraph_optimizer(false);
   is_lex_started = true;
   reset_slave_info.all = false;
   mi.channel = nullptr;
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
@@ -3734,14 +3734,26 @@ struct LEX : public Query_tables_list {
   /// @return true if this is an EXPLAIN statement
   bool is_explain() const { return explain_format != nullptr; }
   bool is_explain_analyze = false;
+
   /**
     Whether the currently-running query should be (attempted) executed in
     the hypergraph optimizer. This will not change after the query is
     done parsing, so you can use it in any query phase to e.g. figure out
     whether to inhibit some transformation that the hypergraph optimizer
     does not properly understand yet.
    */
-  bool using_hypergraph_optimizer = false;
+  bool using_hypergraph_optimizer() const {
+    return m_using_hypergraph_optimizer;
+  }
+
+  void set_using_hypergraph_optimizer(bool use_hypergraph) {
+    m_using_hypergraph_optimizer = use_hypergraph;
+  }
+
+ private:
+  bool m_using_hypergraph_optimizer{false};
+
+ public:
   LEX_STRING name;
   char *help_arg;
   char *to_log; /* For PURGE MASTER LOGS TO */
diff --git a/sql/sql_load.cc b/sql/sql_load.cc
@@ -2141,8 +2141,8 @@ bool Sql_cmd_load_table::execute(THD *thd) {
   else if (thd->is_strict_mode())
     thd->push_internal_handler(&strict_handler);
 
-  lex->using_hypergraph_optimizer =
-      thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER);
+  lex->set_using_hypergraph_optimizer(
+      thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER));
 
   bool res = execute_inner(thd, lex->duplicates);
 
diff --git a/sql/sql_optimizer.cc b/sql/sql_optimizer.cc
@@ -252,7 +252,7 @@ static void SaveCondEqualLists(COND_EQUAL *cond_equal) {
 
 bool JOIN::check_access_path_with_fts() const {
   // Only relevant to the old optimizer.
-  assert(!thd->lex->using_hypergraph_optimizer);
+  assert(!thd->lex->using_hypergraph_optimizer());
 
   assert(query_block->has_ft_funcs());
   assert(rollup_state != RollupState::NONE);
@@ -417,7 +417,7 @@ bool JOIN::optimize(bool finalize_access_paths) {
     }
   }
 
-  if (thd->lex->using_hypergraph_optimizer) {
+  if (thd->lex->using_hypergraph_optimizer()) {
     // The hypergraph optimizer also wants all subselect items to be optimized,
     // so that it has cost information to attach to filter nodes.
     for (Query_expression *unit = query_block->first_inner_query_expression();
@@ -605,7 +605,7 @@ bool JOIN::optimize(bool finalize_access_paths) {
   // Ensure there are no errors prior making query plan
   if (thd->is_error()) return true;
 
-  if (thd->lex->using_hypergraph_optimizer) {
+  if (thd->lex->using_hypergraph_optimizer()) {
     // Get the WHERE and HAVING clauses with the IN-to-EXISTS predicates
     // removed, so that we can plan both with and without the IN-to-EXISTS
     // conversion.
@@ -680,7 +680,7 @@ bool JOIN::optimize(bool finalize_access_paths) {
   //       All of this is never called for the hypergraph join optimizer!
   // ----------------------------------------------------------------------------
 
-  assert(!thd->lex->using_hypergraph_optimizer);
+  assert(!thd->lex->using_hypergraph_optimizer());
   // Don't expect to get here if the hypergraph optimizer is enabled via an
   // optimizer switch. We only check it for regular statements. Prepared
   // statements and stored programs use the optimizer that was active when the
@@ -10804,7 +10804,7 @@ bool JOIN::optimize_fts_query() {
   assert(query_block->has_ft_funcs());
 
   // Only used by the old optimizer.
-  assert(!thd->lex->using_hypergraph_optimizer);
+  assert(!thd->lex->using_hypergraph_optimizer());
 
   for (uint i = const_tables; i < tables; i++) {
     JOIN_TAB *tab = best_ref[i];
@@ -11552,7 +11552,7 @@ double EstimateRowAccesses(const AccessPath *path, double num_evaluations,
           // may be too low. Get the cardinality from the handler's statistics
           // instead.
           if (subpath->type == AccessPath::INDEX_SCAN &&
-              !current_thd->lex->using_hypergraph_optimizer) {
+              !current_thd->lex->using_hypergraph_optimizer()) {
             num_output_rows = table->file->stats.records;
           }
 
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
@@ -3911,8 +3911,8 @@ int mysql_execute_command(THD *thd, bool first_level) {
         }
 
         // Use the hypergraph optimizer if it's enabled.
-        lex->using_hypergraph_optimizer =
-            thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER);
+        lex->set_using_hypergraph_optimizer(
+            thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER));
 
         res = sp_process_definer(thd);
         if (res) break;
diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc
@@ -1052,8 +1052,8 @@ static bool mysql_test_set_fields(THD *thd,
   DBUG_TRACE;
   assert(stmt->m_arena.is_stmt_prepare());
 
-  thd->lex->using_hypergraph_optimizer =
-      thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER);
+  thd->lex->set_using_hypergraph_optimizer(
+      thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER));
 
   if (tables &&
       check_table_access(thd, SELECT_ACL, tables, false, UINT_MAX, false))
@@ -1131,8 +1131,8 @@ bool Sql_cmd_create_table::prepare(THD *thd) {
     query_block->context.resolve_in_select_list = true;
 
     // Use the hypergraph optimizer for the SELECT statement, if enabled.
-    lex->using_hypergraph_optimizer =
-        thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER);
+    lex->set_using_hypergraph_optimizer(
+        thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER));
 
     Prepared_stmt_arena_holder ps_arena_holder(thd);
 
diff --git a/sql/sql_resolver.cc b/sql/sql_resolver.cc
@@ -1498,7 +1498,7 @@ bool Query_block::resolve_subquery(THD *thd) {
       no_aggregates &&                                             // 3,3x,4,5
       (outer->resolve_place == Query_block::RESOLVE_CONDITION ||   // 6a
        (outer->resolve_place == Query_block::RESOLVE_JOIN_NEST &&  // 6a
-        (!thd->lex->using_hypergraph_optimizer ||
+        (!thd->lex->using_hypergraph_optimizer() ||
          (thd->secondary_engine_optimization() ==
               Secondary_engine_optimization::SECONDARY &&
           !Overlaps(
@@ -7824,7 +7824,7 @@ bool Query_block::lift_fulltext_from_having_to_select_list(THD *thd) {
                      // results from a temporary table instead of evaluating the
                      // expressions if they have been materialized. So we wrap
                      // these items in an Item_ref later.
-                     if (!thd->lex->using_hypergraph_optimizer) {
+                     if (!thd->lex->using_hypergraph_optimizer()) {
                        return refs_to_fulltext.push_back(ref);
                      }
                      return false;
@@ -7834,7 +7834,7 @@ bool Query_block::lift_fulltext_from_having_to_select_list(THD *thd) {
 
   // Add Item_ref indirection in the old optimizer.
   for (Item **item_to_replace : refs_to_fulltext) {
-    assert(!thd->lex->using_hypergraph_optimizer);
+    assert(!thd->lex->using_hypergraph_optimizer());
     having_cond = TransformItem(having_cond, [&](Item *sub_item) -> Item * {
       if (sub_item == *item_to_replace) {
         return new (thd->mem_root)
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
@@ -551,8 +551,8 @@ bool Sql_cmd_dml::prepare(THD *thd) {
   if (sql_command_code() == SQLCOM_SELECT) DEBUG_SYNC(thd, "after_table_open");
 #endif
 
-  lex->using_hypergraph_optimizer =
-      thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER);
+  lex->set_using_hypergraph_optimizer(
+      thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER));
 
   if (lex->set_var_list.elements && resolve_var_assignments(thd, lex))
     goto err; /* purecov: inspected */
@@ -1893,7 +1893,7 @@ void JOIN::destroy() {
       }
       qep_tab[i].cleanup();
     }
-  } else if (thd->lex->using_hypergraph_optimizer) {
+  } else if (thd->lex->using_hypergraph_optimizer()) {
     // Same, for hypergraph queries.
     for (Table_ref *tl = query_block->leaf_tables; tl; tl = tl->next_leaf) {
       TABLE *table = tl->table;
@@ -3711,7 +3711,7 @@ void JOIN::cleanup() {
       if (!table) continue;
       cleanup_table(table);
     }
-  } else if (thd->lex->using_hypergraph_optimizer) {
+  } else if (thd->lex->using_hypergraph_optimizer()) {
     for (Table_ref *tl = query_block->leaf_tables; tl; tl = tl->next_leaf) {
       cleanup_table(tl->table);
     }
diff --git a/sql/sql_union.cc b/sql/sql_union.cc
@@ -881,7 +881,7 @@ bool Query_expression::prepare(THD *thd, Query_result *sel_result,
 /// have been created.
 static bool finalize_full_text_functions(THD *thd,
                                          Query_expression *query_expression) {
-  assert(thd->lex->using_hypergraph_optimizer);
+  assert(thd->lex->using_hypergraph_optimizer());
   for (Query_expression *qe = query_expression; qe != nullptr;
        qe = qe->next_query_expression()) {
     for (Query_block *qb = qe->first_query_block(); qb != nullptr;
@@ -1127,7 +1127,7 @@ bool Query_expression::optimize(THD *thd, TABLE *materialize_destination,
       return true;
     }
 
-    if (thd->lex->using_hypergraph_optimizer) {
+    if (thd->lex->using_hypergraph_optimizer()) {
       if (finalize_full_text_functions(thd, this)) {
         return true;
       }
@@ -1181,7 +1181,7 @@ bool Query_expression::force_create_iterators(THD *thd) {
 
   if (m_root_iterator == nullptr) return true;
 
-  if (thd->lex->using_hypergraph_optimizer) {
+  if (thd->lex->using_hypergraph_optimizer()) {
     if (finalize_full_text_functions(thd, this)) {
       return true;
     }
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
diff --git a/sql/sys_vars.cc b/sql/sys_vars.cc
diff --git a/sql/sys_vars.h b/sql/sys_vars.h
diff --git a/storage/ndb/plugin/ha_ndbcluster_push.cc b/storage/ndb/plugin/ha_ndbcluster_push.cc
diff --git a/storage/secondary_engine_mock/ha_mock.cc b/storage/secondary_engine_mock/ha_mock.cc
diff --git a/unittest/gunit/hypergraph_optimizer-t.cc b/unittest/gunit/hypergraph_optimizer-t.cc

Original file line number	Diff line number	Diff line change
`@@ -5635,7 +5635,7 @@ bool is_null_on_empty_table(THD thd, Item_field i) {`
`5635`	`5635`	`qsl->group_list.elements == 0;`
`5636`	`5636`	`else`
`5637`	`5637`	`return (sl->resolve_place == Query_block::RESOLVE_SELECT_LIST \|\|`
`5638`		`- (thd->lex->using_hypergraph_optimizer && sl->is_ordered())) &&`
	`5638`	`+ (thd->lex->using_hypergraph_optimizer() && sl->is_ordered())) &&`
`5639`	`5639`	`sl->with_sum_func && sl->group_list.elements == 0 &&`
`5640`	`5640`	`thd->lex->in_sum_func == nullptr;`
`5641`	`5641`	`}`
Original file line number	Diff line number	Diff line change
`@@ -524,7 +524,7 @@ AccessPath *Item_in_subselect::root_access_path() const {`
`524`	`524`	`// the query to the log for debugging, it isn't fully optimized`
`525`	`525`	`// yet and might not yet have an iterator. Thus, return nullptr instead of`
`526`	`526`	`// assert-failing.`
`527`		`- assert(current_thd->lex->using_hypergraph_optimizer);`
	`527`	`+ assert(current_thd->lex->using_hypergraph_optimizer());`
`528`	`528`	`return nullptr;`
`529`	`529`	`}`
`530`	`530`	`}`
Original file line number	Diff line number	Diff line change
`@@ -219,7 +219,7 @@ bool AggregateIterator::Init() {`
`219`	`219`	`// This is a hack. It would be good to get rid of the slice system altogether`
`220`	`220`	`// (the hypergraph join optimizer does not use it).`
`221`	`221`	`if (!(m_join->implicit_grouping \|\| m_join->group_optimized_away) &&`
`222`		`- !thd()->lex->using_hypergraph_optimizer) {`
	`222`	`+ !thd()->lex->using_hypergraph_optimizer()) {`
`223`	`223`	`m_output_slice = m_join->get_ref_item_slice();`
`224`	`224`	`}`
`225`	`225`
Original file line number	Diff line number	Diff line change
`@@ -4955,6 +4955,7 @@ int init_common_variables() {`
`4955`	`4955`	`}`
`4956`	`4956`	`}`
`4957`	`4957`	`update_parser_max_mem_size();`
	`4958`	`+ update_optimizer_switch();`
`4958`	`4959`
`4959`	`4960`	`if (set_default_auth_plugin(default_auth_plugin,`
`4960`	`4961`	`strlen(default_auth_plugin))) {`