Bug#36758378: Signal 11 in Table_ref::is_external

This solution is for MySQL 8.0.

The problem may occur when Sql_cmd_dml::execute() is called, and
we have certain error situations, and we check whether the query
involves an external table. The function has_external_table()
traverses the tables of the query and checks each whether it is
"external". But this involves inspecting the TABLE object, and we
may hit a null pointer since the TABLE pointer inside the Table_ref
object is set to NULL when the table is closed.

This patch makes checking for external tables foolproof:
Instead of traversing all tables whenever we need to know the value of
this property, the value of the property is stored in the LEX object
while opening the tables. We know that the information is valid at that
point in time, and we know the information is valid as long as the query
(and the LEX object) exists.

The test case is from bug#36725524.

Change-Id: Ie45672def3ea2297907d742c19f0f53c547fe9e3

Author: roylyseng

sql/sql_base.cc

@@ -6620,6 +6620,9 @@ static bool open_secondary_engine_tables(THD *thd, uint flags) {
   // The previous execution context should have been destroyed.
   assert(lex->secondary_engine_execution_context() == nullptr);
 
+  // Property of having external tables is always set in this function:
+  assert(!lex->has_external_tables());
+
   // If use of secondary engines has been disabled for the statement,
   // there is nothing to do.
   if (sql_cmd == nullptr || sql_cmd->secondary_storage_engine_disabled())
@@ -6700,6 +6703,9 @@ static bool open_secondary_engine_tables(THD *thd, uint flags) {
     }
     assert(tl->table->s->is_secondary_engine());
     tl->table->file->ha_set_primary_handler(primary_table->file);
+    if (tl->is_external()) {
+      lex->set_has_external_tables();
+    }
   }
 
   // Prepare the secondary engine for executing the statement.

sql/sql_lex.cc

@@ -496,6 +496,7 @@ void LEX::reset() {
 
   grant_if_exists = false;
   ignore_unknown_user = false;
+  m_has_external_tables = false;
   reset_rewrite_required();
 }
 

sql/sql_lex.h

@@ -4008,12 +4008,16 @@ struct LEX : public Query_tables_list {
   /// True if statement references UDF functions
   bool m_has_udf{false};
   bool ignore;
+  /// True if query has at least one external table
+  bool m_has_external_tables{false};
 
  public:
   bool is_ignore() const { return ignore; }
   void set_ignore(bool ignore_param) { ignore = ignore_param; }
   void set_has_udf() { m_has_udf = true; }
   bool has_udf() const { return m_has_udf; }
+  void set_has_external_tables() { m_has_external_tables = true; }
+  bool has_external_tables() const { return m_has_external_tables; }
   st_parsing_options parsing_options;
   Alter_info *alter_info;
   /* Prepared statements SQL syntax:*/

sql/sql_prepare.cc

@@ -3118,7 +3118,7 @@ bool Prepared_statement::execute_loop(THD *thd, String *expanded_query,
           thd->secondary_engine_optimization() ==
               Secondary_engine_optimization::SECONDARY &&
           !m_lex->unit->is_executed()) {
-        if (has_external_table(m_lex->query_tables)) {
+        if (m_lex->has_external_tables()) {
           set_external_engine_fail_reason(m_lex,
                                           thd->get_stmt_da()->message_text());
         }

sql/sql_select.cc

@@ -660,15 +660,6 @@ bool Sql_cmd_select::prepare_inner(THD *thd) {
   return false;
 }
 
-bool has_external_table(Table_ref *query_tables) {
-  for (Table_ref *ref = query_tables; ref != nullptr; ref = ref->next_global) {
-    if (ref->is_external()) {
-      return true;
-    }
-  }
-  return false;
-}
-
 bool Sql_cmd_dml::execute(THD *thd) {
   DBUG_TRACE;
 
@@ -741,7 +732,7 @@ bool Sql_cmd_dml::execute(THD *thd) {
   }
 
   if (lex->thd->variables.use_secondary_engine == SECONDARY_ENGINE_OFF) {
-    if (has_external_table(lex->query_tables)) {
+    if (lex->has_external_tables()) {
       my_error(ER_SECONDARY_ENGINE_PLUGIN, MYF(0),
                "Query could not be offloaded to the secondary engine");
       external_table_not_offloaded = true;
@@ -751,7 +742,7 @@ bool Sql_cmd_dml::execute(THD *thd) {
                   Secondary_engine_optimization::PRIMARY_ONLY &&
               lex->thd->variables.use_secondary_engine !=
                   SECONDARY_ENGINE_FORCED) &&
-             has_external_table(lex->query_tables)) {
+             lex->has_external_tables()) {
     // throw the propagated error from the external engine in case there is an
     // external table
     external_engine_fail_reason(lex);
@@ -848,7 +839,7 @@ bool Sql_cmd_dml::execute(THD *thd) {
         assert(thd->get_stmt_da() != nullptr);
         // here we check if there is any table in an external engine to set the
         // error there as well.
-        if (has_external_table(lex->query_tables)) {
+        if (lex->has_external_tables()) {
           set_external_engine_fail_reason(lex,
                                           thd->get_stmt_da()->message_text());
         }
@@ -943,7 +934,7 @@ static bool retry_with_secondary_engine(THD *thd) {
   // is higher than the specified cost threshold.
   // We allow any query to be executed in the secondary_engine when it involves
   // external tables.
-  if (!has_external_table(thd->lex->query_tables) &&
+  if (!thd->lex->has_external_tables() &&
       (thd->m_current_query_cost <=
        thd->variables.secondary_engine_cost_threshold)) {
     Opt_trace_context *const trace = &thd->opt_trace;

sql/sql_select.h

@@ -1059,14 +1059,6 @@ void accumulate_statement_cost(const LEX *lex);
 */
 const handlerton *get_secondary_engine_handlerton(const LEX *lex);
 
-/**
-  Checks if any of the tables referenced belong to an external engine.
-  If an external table is found, return true, false otherwise.
-
-  @param query_tables the referenced tables.
-*/
-bool has_external_table(Table_ref *query_tables);
-
 /**
   Sets the reason of failure for the statement to the external engine.