Bug#35889990: Setting secondary_engine to OFF causes offload issues with executing queries from stored procedures Bug#35988564: CREATE TEMPORARY TABLE failure after Table_ref::restore_properties

The problem is that when reaching the function RapidOptimize(),
the value of LEX::using_hypergraph_optimizer is not consistent with
the value of the session variable use_old_optimizer.

The problem is a missing setting of LEX::using_hypergraph_optimizer
in the execution of a query. It was only synchronized with the
hypergraph optimizer setting in preparation of a query, which is
sufficient for regular statements which always perform both
preparation and execution, but not for stored procedures that have
separate preparation and execution. The solution is to add this setting.

But this revealed another problem: sometimes execution is out of sync
with the current preparation. An optimization with the hypergraph
optimizer requires that the preparation is also performed with
settings specific to the hypergraph optimizer. This may happen e.g if
the value of the session variable use_secondary_engine is switched from
"off" or "on" to "forced" either between a preparation and execution
(for prepared statements) or between two executions (for prepared
statements and stored procedure statements)

The solution to this is to track the current preparation state versus
the one desired (the optimizer switch setting). It is now checked
that the value of using_hypergraph_optimizer matches the current
optimizer switch setting just after opening tables and before optimizing
such statements, in which case we call ask_to_reprepare().
During optimization we set using_hypergraph_optimizer according to the
optimizer switch.

The test rapid.pfs_secondary has an increased reprepare count because we
now detect more often that an optimization requires a new preparation.

In addition, a test case was added to cover the problem described in
bug#35988564.

Change-Id: Ibf158576ec4cd1edde655d41f7c8bf2813e208ee

Author: roylyseng

mysql-test/r/hypergraph_bugs.result

@@ -1342,3 +1342,89 @@ EXPLAIN
     -> Single-row index lookup on t1 using PRIMARY (a=5)  (rows=1)
 
 DROP TABLE t1,t2;
+# Bug#5889990: Setting secondary_engine to OFF causes offload issues
+CREATE TABLE t(x INT, y INT);
+INSERT INTO t VALUES (1, 2), (2, 3);
+ANALYZE TABLE t;
+Table	Op	Msg_type	Msg_text
+test.t	analyze	status	OK
+SET optimizer_switch='hypergraph_optimizer=off';
+PREPARE ps FROM
+'SELECT *
+ FROM t AS t1 LEFT JOIN t AS t2 ON t1.x=t2.x AND t1.y IN (SELECT x FROM t)';
+EXECUTE ps;
+x	y	x	y
+1	2	1	2
+2	3	NULL	NULL
+SET optimizer_switch='hypergraph_optimizer=on';
+Warnings:
+Warning	1287	The hypergraph optimizer is highly experimental and is meant for testing only. Do not enable it unless you are a MySQL developer.
+EXECUTE ps;
+x	y	x	y
+1	2	1	2
+2	3	NULL	NULL
+SET optimizer_switch='hypergraph_optimizer=off';
+EXECUTE ps;
+x	y	x	y
+1	2	1	2
+2	3	NULL	NULL
+SET optimizer_switch='hypergraph_optimizer=on';
+Warnings:
+Warning	1287	The hypergraph optimizer is highly experimental and is meant for testing only. Do not enable it unless you are a MySQL developer.
+PREPARE ps FROM
+'SELECT *
+ FROM t AS t1 LEFT JOIN t AS t2 ON t1.x=t2.x AND t1.y IN (SELECT x FROM t)';
+EXECUTE ps;
+x	y	x	y
+1	2	1	2
+2	3	NULL	NULL
+SET optimizer_switch='hypergraph_optimizer=off';
+EXECUTE ps;
+x	y	x	y
+1	2	1	2
+2	3	NULL	NULL
+DROP TABLE t;
+CREATE TABLE t(x VARCHAR(100), FULLTEXT KEY (x));
+INSERT INTO t VALUES ('abc'), ('xyz'), ('abc abc');
+ANALYZE TABLE t;
+Table	Op	Msg_type	Msg_text
+test.t	analyze	status	OK
+SET optimizer_switch='hypergraph_optimizer=on';
+Warnings:
+Warning	1287	The hypergraph optimizer is highly experimental and is meant for testing only. Do not enable it unless you are a MySQL developer.
+PREPARE ps FROM
+'SELECT x, MATCH(x) AGAINST (''abc'') AS score FROM t
+ GROUP BY x HAVING MATCH(x) AGAINST(''abc'') > 0';
+EXECUTE ps;
+x	score
+abc	0.031008131802082062
+abc abc	0.062016263604164124
+SET optimizer_switch='hypergraph_optimizer=off';
+EXECUTE ps;
+x	score
+abc	0.031008131802082062
+abc abc	0.062016263604164124
+SET optimizer_switch='hypergraph_optimizer=on';
+Warnings:
+Warning	1287	The hypergraph optimizer is highly experimental and is meant for testing only. Do not enable it unless you are a MySQL developer.
+EXECUTE ps;
+x	score
+abc	0.031008131802082062
+abc abc	0.062016263604164124
+SET optimizer_switch='hypergraph_optimizer=off';
+PREPARE ps FROM
+'SELECT x, MATCH(x) AGAINST (''abc'') AS score FROM t
+ GROUP BY x HAVING MATCH(x) AGAINST(''abc'') > 0';
+EXECUTE ps;
+x	score
+abc	0.031008131802082062
+abc abc	0.062016263604164124
+SET optimizer_switch='hypergraph_optimizer=on';
+Warnings:
+Warning	1287	The hypergraph optimizer is highly experimental and is meant for testing only. Do not enable it unless you are a MySQL developer.
+EXECUTE ps;
+x	score
+abc	0.031008131802082062
+abc abc	0.062016263604164124
+DROP TABLE t;
+SET optimizer_switch='hypergraph_optimizer=default';

mysql-test/r/using_hypergraph_optimizer.result

@@ -75,7 +75,7 @@ COUNT(*)
 SELECT COUNT(*) FROM INFORMATION_SCHEMA.OPTIMIZER_TRACE
 WHERE TRACE LIKE '%Constructed hypergraph%';
 COUNT(*)
-1
+0
 # Case 2.a: Preparation: 'hypergraph_optimizer=off', execution: 'hypergraph_optimizer=on'
 SET optimizer_switch = 'hypergraph_optimizer=off';
 PREPARE ps_set FROM 'SET @x = (SELECT COUNT(*) FROM t)';
@@ -91,7 +91,7 @@ COUNT(*)
 SELECT COUNT(*) FROM INFORMATION_SCHEMA.OPTIMIZER_TRACE
 WHERE TRACE LIKE '%Constructed hypergraph%';
 COUNT(*)
-0
+1
 # Case 2.b: Preparation: 'hypergraph_optimizer=off', execution: 'hypergraph_optimizer=off'
 SET optimizer_switch = 'hypergraph_optimizer=off';
 EXECUTE ps_set;

mysql-test/t/hypergraph_bugs.test

@@ -1093,3 +1093,75 @@ EXPLAIN FORMAT=TREE SELECT * FROM t1 WHERE a IN
 EXPLAIN FORMAT=TREE SELECT * FROM t1 WHERE t1.a IN (SELECT 5 FROM t2);
 
 DROP TABLE t1,t2;
+
+--echo # Bug#5889990: Setting secondary_engine to OFF causes offload issues
+
+CREATE TABLE t(x INT, y INT);
+INSERT INTO t VALUES (1, 2), (2, 3);
+ANALYZE TABLE t;
+
+SET optimizer_switch='hypergraph_optimizer=off';
+
+PREPARE ps FROM
+'SELECT *
+ FROM t AS t1 LEFT JOIN t AS t2 ON t1.x=t2.x AND t1.y IN (SELECT x FROM t)';
+
+EXECUTE ps;
+
+SET optimizer_switch='hypergraph_optimizer=on';
+
+EXECUTE ps;
+
+SET optimizer_switch='hypergraph_optimizer=off';
+
+EXECUTE ps;
+
+SET optimizer_switch='hypergraph_optimizer=on';
+
+PREPARE ps FROM
+'SELECT *
+ FROM t AS t1 LEFT JOIN t AS t2 ON t1.x=t2.x AND t1.y IN (SELECT x FROM t)';
+
+EXECUTE ps;
+
+SET optimizer_switch='hypergraph_optimizer=off';
+
+EXECUTE ps;
+
+DROP TABLE t;
+
+CREATE TABLE t(x VARCHAR(100), FULLTEXT KEY (x));
+INSERT INTO t VALUES ('abc'), ('xyz'), ('abc abc');
+ANALYZE TABLE t;
+
+SET optimizer_switch='hypergraph_optimizer=on';
+
+PREPARE ps FROM
+'SELECT x, MATCH(x) AGAINST (''abc'') AS score FROM t
+ GROUP BY x HAVING MATCH(x) AGAINST(''abc'') > 0';
+
+EXECUTE ps;
+
+SET optimizer_switch='hypergraph_optimizer=off';
+
+EXECUTE ps;
+
+SET optimizer_switch='hypergraph_optimizer=on';
+
+EXECUTE ps;
+
+SET optimizer_switch='hypergraph_optimizer=off';
+
+PREPARE ps FROM
+'SELECT x, MATCH(x) AGAINST (''abc'') AS score FROM t
+ GROUP BY x HAVING MATCH(x) AGAINST(''abc'') > 0';
+
+EXECUTE ps;
+
+SET optimizer_switch='hypergraph_optimizer=on';
+
+EXECUTE ps;
+
+DROP TABLE t;
+
+SET optimizer_switch='hypergraph_optimizer=default';

mysql-test/t/using_hypergraph_optimizer.test

@@ -56,8 +56,8 @@ WHERE TRACE LIKE '%Constructed hypergraph%';
 SELECT @x;
 
 # Verify that prepared SET statements use the optimizer that was active
-# when PREPARE was called and that the behaviour is consistent with prepared
-# SELECT statements
+# when PREPARE was called. Prepared SELECT statements use the optimizer that
+# is active during execution.
 
 --echo # Case 1.a: Preparation: 'hypergraph_optimizer=on', execution: 'hypergraph_optimizer=on'
 PREPARE ps_set FROM 'SET @x = (SELECT COUNT(*) FROM t)';

sql/sp_instr.cc

@@ -870,6 +870,7 @@ void sp_lex_instr::free_lex() {
   m_lex->sphead = nullptr;
   lex_end(m_lex);
   if (m_lex->result != nullptr) ::destroy_at(m_lex->result);
+  m_lex->set_secondary_engine_execution_context(nullptr);
   m_lex->destroy();
   delete (st_lex_local *)m_lex;
 

sql/sql_cmd_ddl_table.cc

@@ -331,6 +331,7 @@ bool Sql_cmd_create_table::execute(THD *thd) {
 
     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() &&
@@ -349,7 +350,7 @@ bool Sql_cmd_create_table::execute(THD *thd) {
         return false;
       } else {
         my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_info.alias);
-        return false;
+        return true;
       }
     }
 

sql/sql_lex.cc

@@ -396,6 +396,7 @@ LEX::~LEX() {
   unit = nullptr;  // Created in mem_root - no destructor
   query_block = nullptr;
   m_current_query_block = nullptr;
+  assert(m_secondary_engine_context == nullptr);
 }
 
 /**

sql/sql_lex.h

@@ -3837,11 +3837,12 @@ struct LEX : public Query_tables_list {
   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 the currently-running statement should be prepared and executed
+    with the hypergraph optimizer. This will not change after the statement is
+    prepared, so you can use it in any optimization phase to e.g. figure out
     whether to inhibit some transformation that the hypergraph optimizer
-    does not properly understand yet.
+    does not properly understand yet. If a different optimizer is requested,
+    the statement must be re-prepared with the proper optimizer settings.
    */
 
   bool using_hypergraph_optimizer() const {

sql/sql_optimizer.cc

@@ -691,10 +691,7 @@ bool JOIN::optimize(bool finalize_access_paths) {
 
   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
-  // statement was prepared, and don't check the optimizer switch for each
-  // subsequent execution.
+  // optimizer switch. The "is_regular()" case is necessary for SET statements.
   assert(!thd->optimizer_switch_flag(OPTIMIZER_SWITCH_HYPERGRAPH_OPTIMIZER) ||
          !thd->stmt_arena->is_regular());
 

sql/sql_prepare.cc

@@ -1168,6 +1168,7 @@ bool Sql_cmd_create_table::prepare(THD *thd) {
   }
 
   set_prepared();
+
   return false;
 }
 
@@ -1908,7 +1909,6 @@ void mysqld_stmt_execute(THD *thd, Prepared_statement *stmt, bool has_new_types,
   // Initially, optimize the statement for the primary storage engine.
   // If an eligible secondary storage engine is found, the statement
   // may be reprepared for the secondary storage engine later.
-  const auto saved_secondary_engine = thd->secondary_engine_optimization();
   thd->set_secondary_engine_optimization(
       Secondary_engine_optimization::PRIMARY_TENTATIVELY);
 
@@ -1923,8 +1923,6 @@ void mysqld_stmt_execute(THD *thd, Prepared_statement *stmt, bool has_new_types,
     stmt->execute_loop(thd, &expanded_query, open_cursor);
   }
 
-  thd->set_secondary_engine_optimization(saved_secondary_engine);
-
   if (switch_protocol) thd->pop_protocol();
 
   sp_cache_enforce_limit(thd->sp_proc_cache, stored_program_cache_size);
@@ -3027,7 +3025,9 @@ bool Prepared_statement::execute_loop(THD *thd, String *expanded_query,
   bool general_log_temporarily_disabled = false;
 
   // Reprepare statement unconditionally if it contains UDF references
-  if (m_lex->has_udf() && reprepare(thd)) return true;
+  if (m_lex->has_udf() && reprepare(thd)) {
+    return true;
+  }
 
   // Reprepare statement if protocol has changed.
   // Note: this is not possible in current code base, hence the assert.