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

kahatlen · dahlerlend · commit 0241d96601df · 2023-12-08T17:16:10.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
@@ -5815,7 +5815,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_cmpfunc.cc b/sql/item_cmpfunc.cc
@@ -2610,7 +2610,7 @@ float Item_func_ne::get_filtering_effect(THD *thd, table_map filter_for_table,
       }
     };
 
-    if (!thd->lex->using_hypergraph_optimizer) {
+    if (!thd->lex->using_hypergraph_optimizer()) {
       return get_histogram_selectivity(
           thd, *fld->field, histograms::enum_operator::NOT_EQUALS_TO, *this);
 
@@ -2672,7 +2672,7 @@ static double GetEqualSelectivity(THD *thd, Item_eq_base *equal,
     // The index calculation might be useful for the original optimizer too,
     // but we are loth to change existing plans and therefore restrict
     // it to Hypergraph.
-    if (!thd->lex->using_hypergraph_optimizer) {
+    if (!thd->lex->using_hypergraph_optimizer()) {
       return get_histogram_selectivity(
           thd, *field.field, histograms::enum_operator::EQUALS_TO, *equal);
 
diff --git a/sql/item_func.cc b/sql/item_func.cc
@@ -909,7 +909,7 @@ const Item_field *Item_func::contributes_to_filter(
   // We are loth to change existing plans. Therefore we keep the existing
   // behavior for the original optimizer, which is to return nullptr if
   // any of PSEUDO_TABLE_BITS are set in used_tables().
-  const table_map remaining_tables = thd->lex->using_hypergraph_optimizer
+  const table_map remaining_tables = thd->lex->using_hypergraph_optimizer()
                                          ? (~read_tables & ~PSEUDO_TABLE_BITS)
                                          : ~read_tables;
 
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
@@ -583,7 +583,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;
   }
 }
@@ -1571,7 +1571,7 @@ bool Item_exists_subselect::is_semijoin_candidate(THD *thd) {
       !inner->has_windows() &&                                     // 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(
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
@@ -4809,7 +4809,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
@@ -231,7 +231,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
@@ -609,7 +609,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
@@ -877,7 +877,7 @@ unique_ptr_destroy_only<RowIterator> CreateIteratorFromAccessPath(
         }
         const Mem_root_array<Item *> *extra_conditions =
             GetExtraHashJoinConditions(
-                mem_root, thd->lex->using_hypergraph_optimizer, conditions,
+                mem_root, thd->lex->using_hypergraph_optimizer(), conditions,
                 join_predicate->expr->join_conditions);
         if (extra_conditions == nullptr) return nullptr;
         const bool probe_input_batch_mode =
@@ -931,7 +931,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;
@@ -949,7 +949,7 @@ unique_ptr_destroy_only<RowIterator> CreateIteratorFromAccessPath(
         // change existing behavior.) Note that we always try the probe input
         // first for left join and antijoin.
         const HashJoinInput first_input =
-            (thd->lex->using_hypergraph_optimizer &&
+            (thd->lex->using_hypergraph_optimizer() &&
              first_row_cost(*param.inner) > first_row_cost(*param.outer))
                 ? HashJoinInput::kProbe
                 : HashJoinInput::kBuild;
diff --git a/sql/join_optimizer/explain_access_path.cc b/sql/join_optimizer/explain_access_path.cc
@@ -1392,7 +1392,7 @@ static unique_ptr<Json_object> SetObjectMembers(
 
       const Mem_root_array<Item *> *extra_join_conditions =
           GetExtraHashJoinConditions(
-              thd->mem_root, thd->lex->using_hypergraph_optimizer,
+              thd->mem_root, thd->lex->using_hypergraph_optimizer(),
               equijoin_conditions, predicate->expr->join_conditions);
       if (extra_join_conditions == nullptr) return nullptr;
 
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
@@ -6768,6 +6768,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
@@ -1916,7 +1916,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;
@@ -2298,10 +2298,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
@@ -1425,8 +1425,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));
 
     const Prepared_stmt_arena_holder ps_arena_holder(thd);
     while ((var = it++)) {
diff --git a/sql/set_var.h b/sql/set_var.h
@@ -1117,7 +1117,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
@@ -10446,7 +10446,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_class.cc b/sql/sql_class.cc
@@ -3701,7 +3701,7 @@ void THD::init_cost_model() {
 }
 
 const Cost_model_server *THD::cost_model() const {
-  if (lex->using_hypergraph_optimizer) {
+  if (lex->using_hypergraph_optimizer()) {
     return &m_cost_model_hypergraph;
   } else {
     return &m_cost_model;
diff --git a/sql/sql_cmd_ddl_table.cc b/sql/sql_cmd_ddl_table.cc
@@ -325,6 +325,20 @@ bool Sql_cmd_create_table::execute(THD *thd) {
         [lex] { lex->set_secondary_engine_execution_context(nullptr); });
     if (open_tables_for_query(thd, lex->query_tables, false)) return true;
 
+    // Use the hypergraph optimizer for the SELECT statement, if enabled.
+    const bool need_hypergraph_optimizer =
+        thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER);
+
+    if (!query_expression->is_prepared()) {
+      // Use the desired optimizer during following preparation
+      lex->set_using_hypergraph_optimizer(need_hypergraph_optimizer);
+    }
+    if (need_hypergraph_optimizer != lex->using_hypergraph_optimizer() &&
+        ask_to_reprepare(thd)) {
+      return true;
+    }
+    assert(need_hypergraph_optimizer == lex->using_hypergraph_optimizer());
+
     /* The table already exists */
     if (create_table->table || create_table->is_view()) {
       if (create_info.options & HA_LEX_CREATE_IF_NOT_EXISTS) {
@@ -372,8 +386,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
@@ -776,7 +776,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;
   }
 
@@ -925,7 +925,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),
@@ -1266,7 +1266,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->zero_result_cause != nullptr);
     return 0;
   }
diff --git a/sql/sql_derived.cc b/sql/sql_derived.cc
@@ -1629,7 +1629,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
@@ -2991,7 +2991,7 @@ static AccessPath *add_filter_access_path(THD *thd, AccessPath *path,
                                           const Query_block *query_block) {
   AccessPath *filter_path = NewFilterAccessPath(thd, path, condition);
   CopyBasicProperties(*path, filter_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
@@ -1695,7 +1695,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
@@ -461,7 +461,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;
@@ -5224,7 +5224,7 @@ bool LEX::validate_use_in_old_optimizer() {
   if (sql_command == SQLCOM_CREATE_VIEW || sql_command == SQLCOM_SHOW_CREATE)
     return false;
   if (can_execute_only_in_hypergraph_optimizer() &&
-      !using_hypergraph_optimizer) {
+      !using_hypergraph_optimizer()) {
     // Certain queries cannot be executed in the old optimizer.
     my_error(ER_SUPPORTED_ONLY_WITH_HYPERGRAPH, MYF(0),
              get_only_supported_in_hypergraph_reason_str());
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
@@ -3835,14 +3835,27 @@ 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 BINARY LOGS TO */
diff --git a/sql/sql_load.cc b/sql/sql_load.cc
@@ -2604,8 +2604,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 = true;
 
diff --git a/sql/sql_optimizer.cc b/sql/sql_optimizer.cc
@@ -254,7 +254,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);
@@ -419,7 +419,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();
@@ -570,7 +570,7 @@ bool JOIN::optimize(bool finalize_access_paths) {
     }
   }
 
-  if (thd->lex->using_hypergraph_optimizer &&
+  if (thd->lex->using_hypergraph_optimizer() &&
       query_block->is_table_value_constructor) {
     // Let the hypergraph optimizer handle table value constructors, even though
     // they are table-less queries.
@@ -599,7 +599,7 @@ bool JOIN::optimize(bool finalize_access_paths) {
       }
   }
 
-  if (!thd->lex->using_hypergraph_optimizer) {
+  if (!thd->lex->using_hypergraph_optimizer()) {
     sort_by_table = get_sort_by_table(order.order, group_list.order,
                                       query_block->leaf_tables);
   }
@@ -614,7 +614,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.
@@ -689,7 +689,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
@@ -10827,7 +10827,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];
@@ -11575,7 +11575,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
diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc
diff --git a/sql/sql_resolver.cc b/sql/sql_resolver.cc
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
diff --git a/sql/sql_union.cc b/sql/sql_union.cc
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
`@@ -5815,7 +5815,7 @@ bool is_null_on_empty_table(THD thd, Item_field i) {`
`5815`	`5815`	`qsl->group_list.elements == 0;`
`5816`	`5816`	`else`
`5817`	`5817`	`return (sl->resolve_place == Query_block::RESOLVE_SELECT_LIST \|\|`
`5818`		`- (thd->lex->using_hypergraph_optimizer && sl->is_ordered())) &&`
	`5818`	`+ (thd->lex->using_hypergraph_optimizer() && sl->is_ordered())) &&`
`5819`	`5819`	`sl->with_sum_func && sl->group_list.elements == 0 &&`
`5820`	`5820`	`thd->lex->in_sum_func == nullptr;`
`5821`	`5821`	`}`
Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,7 @@ bool AggregateIterator::Init() {`
`231`	`231`	`// This is a hack. It would be good to get rid of the slice system altogether`
`232`	`232`	`// (the hypergraph join optimizer does not use it).`
`233`	`233`	`if (!(m_join->implicit_grouping \|\| m_join->group_optimized_away) &&`
`234`		`- !thd()->lex->using_hypergraph_optimizer) {`
	`234`	`+ !thd()->lex->using_hypergraph_optimizer()) {`
`235`	`235`	`m_output_slice = m_join->get_ref_item_slice();`
`236`	`236`	`}`
`237`	`237`
Original file line number	Diff line number	Diff line change
`@@ -6768,6 +6768,7 @@ int init_common_variables() {`
`6768`	`6768`	`}`
`6769`	`6769`	`}`
`6770`	`6770`	`update_parser_max_mem_size();`
	`6771`	`+ update_optimizer_switch();`
`6771`	`6772`
`6772`	`6773`	`if (set_default_auth_plugin(default_auth_plugin,`
`6773`	`6774`	`strlen(default_auth_plugin))) {`