WL#16235 - offload secondary-engine queries that insert into tables with

triggers - MySQL server part

This patch adds a new member to Query_tables_list, has_stored_functions.
This variable is used instead of uses_stored_routines() check in
all the places that check offloads for the secondary engine.

To streamline updating this variable, an additional stored-routine
type argument is added to sp_add_used_routine.

As a consequence, we now don't block offload of select queries from
insert into select statements to secondary engine even when the
destination table has a defined trigger.

Change-Id: I59662ab8e87a893a50de8d25b76108322a244b6e

Author: Mia Primorac

sql/sp.cc

@@ -1695,6 +1695,8 @@ bool sp_exist_routines(THD *thd, Table_ref *routines, bool is_proc) {
   @param name_length     Length of the routine name.
   @param belong_to_view  Uppermost view which uses this routine
                          (0 if routine is not used by view)
+  @param type            Routine type (one of FUNCTION/PROCEDURE/
+                                                     TRIGGER ...)
 
   @note
     Will also add element to end of 'Query_tables_list::sroutines_list' list.
@@ -1716,7 +1718,8 @@ static bool sp_add_used_routine(Query_tables_list *prelocking_ctx,
                                 Query_arena *arena, const uchar *key,
                                 size_t key_length, size_t db_length,
                                 const char *name, size_t name_length,
-                                Table_ref *belong_to_view) {
+                                Table_ref *belong_to_view,
+                                Sroutine_hash_entry::entry_type type) {
   if (prelocking_ctx->sroutines == nullptr) {
     prelocking_ctx->sroutines.reset(
         new malloc_unordered_map<std::string, Sroutine_hash_entry *>(
@@ -1746,6 +1749,9 @@ static bool sp_add_used_routine(Query_tables_list *prelocking_ctx,
     prelocking_ctx->sroutines_list.link_in_list(rn, &rn->next);
     rn->belong_to_view = belong_to_view;
     rn->m_cache_version = 0;
+    if (type == Sroutine_hash_entry::entry_type::FUNCTION) {
+      prelocking_ctx->has_stored_functions = true;
+    }
     return true;
   }
   return false;
@@ -1810,8 +1816,9 @@ bool sp_add_used_routine(Query_tables_list *prelocking_ctx, Query_arena *arena,
     */
     key_length +=
         my_casedn_str(system_charset_info, (char *)(key) + key_length) + 1;
-  } else
+  } else {
     key_length += db_length + 1;
+  }
 
   switch (name_normalize_type) {
     case Sp_name_normalize_type::LEAVE_AS_IS:
@@ -1860,7 +1867,7 @@ bool sp_add_used_routine(Query_tables_list *prelocking_ctx, Query_arena *arena,
   }
 
   if (sp_add_used_routine(prelocking_ctx, arena, key, key_length, db_length,
-                          name, name_length, belong_to_view)) {
+                          name, name_length, belong_to_view, type)) {
     if (own_routine) {
       prelocking_ctx->sroutines_list_own_last =
           prelocking_ctx->sroutines_list.next;
@@ -1922,7 +1929,7 @@ void sp_update_stmt_used_routines(
     (void)sp_add_used_routine(prelocking_ctx, thd->stmt_arena,
                               pointer_cast<const uchar *>(rt->m_key),
                               rt->m_key_length, rt->m_db_length, rt->name(),
-                              rt->name_length(), belong_to_view);
+                              rt->name_length(), belong_to_view, rt->type());
   }
 }
 
@@ -1947,7 +1954,7 @@ void sp_update_stmt_used_routines(THD *thd, Query_tables_list *prelocking_ctx,
     (void)sp_add_used_routine(prelocking_ctx, thd->stmt_arena,
                               pointer_cast<const uchar *>(rt->m_key),
                               rt->m_key_length, rt->m_db_length, rt->name(),
-                              rt->name_length(), belong_to_view);
+                              rt->name_length(), belong_to_view, rt->type());
 }
 
 /**

sql/sql_base.cc

@@ -6892,18 +6892,25 @@ static bool open_secondary_engine_tables(THD *thd, uint flags) {
 
   // Replace the TABLE objects in the Table_ref with secondary tables.
   Open_table_context ot_ctx(thd, flags | MYSQL_OPEN_SECONDARY_ENGINE);
-  Table_ref *tl = lex->query_tables;
+  Table_ref *tr = lex->query_tables;
   // For INSERT INTO SELECT and CTAS statements, the table to insert into does
   // not have to have a secondary engine. This table is always first in the list
   if ((lex->sql_command == SQLCOM_INSERT_SELECT ||
        lex->sql_command == SQLCOM_CREATE_TABLE) &&
-      tl != nullptr)
-    tl = tl->next_global;
-  for (; tl != nullptr; tl = tl->next_global) {
-    if (tl->is_placeholder()) continue;
-    TABLE *primary_table = tl->table;
-    tl->table = nullptr;
-    if (open_table(thd, tl, &ot_ctx)) {
+      tr != nullptr) {
+    tr = tr->next_global;
+  }
+  // Re-open the tables belonging to the query, but not those belonging to
+  // associated triggers (query_tables_own_last will point to the boundary).
+  for (; tr != nullptr && (lex->query_tables_own_last == nullptr ||
+                           tr != lex->query_tables_own_last[0]);
+       tr = tr->next_global) {
+    if (tr->is_placeholder()) {
+      continue;
+    }
+    TABLE *primary_table = tr->table;
+    tr->table = nullptr;
+    if (open_table(thd, tr, &ot_ctx)) {
       if (!thd->is_error()) {
         /*
           open_table() has not registered any error, implying that we can
@@ -6916,8 +6923,8 @@ static bool open_secondary_engine_tables(THD *thd, uint flags) {
       }
       return true;
     }
-    assert(tl->table->s->is_secondary_engine());
-    tl->table->file->ha_set_primary_handler(primary_table->file);
+    assert(tr->table->s->is_secondary_engine());
+    tr->table->file->ha_set_primary_handler(primary_table->file);
   }
 
   // Prepare the secondary engine for executing the statement.

sql/sql_lex.cc

@@ -3657,6 +3657,7 @@ void Query_tables_list::reset_query_tables_list(bool init) {
   sroutines_list.clear();
   sroutines_list_own_last = sroutines_list.next;
   sroutines_list_own_elements = 0;
+  has_stored_functions = false;
   binlog_stmt_flags = 0;
   stmt_accessed_table_flag = 0;
   lock_tables_state = LTS_NOT_LOCKED;

sql/sql_lex.h

@@ -2660,6 +2660,11 @@ class Query_tables_list {
   Sroutine_hash_entry **sroutines_list_own_last;
   uint sroutines_list_own_elements;
 
+  /**
+   Does this LEX context have any stored functions
+  */
+  bool has_stored_functions;
+
   /**
     Locking state of tables in this particular statement.
 
@@ -3185,7 +3190,7 @@ class Query_tables_list {
   }
 
   /**
-    true if the parsed tree contains references to stored procedures
+    true if the parsed tree contains references to stored procedures, triggers
     or functions, false otherwise
   */
   bool uses_stored_routines() const { return sroutines_list.elements != 0; }

sql/sql_select.cc

@@ -313,8 +313,8 @@ static bool equal_engines(const LEX_CSTRING &engine1,
 // engine.
 const MYSQL_LEX_CSTRING *get_eligible_secondary_engine_from(const LEX *lex) {
   // Don't use secondary storage engines for statements that call stored
-  // routines.
-  if (lex->uses_stored_routines()) return nullptr;
+  // functions.
+  if (lex->has_stored_functions) return nullptr;
   // Now check if the opened tables are available in a secondary
   // storage engine. Only use the secondary tables if all the tables
   // have a secondary tables, and they are all in the same secondary
@@ -430,11 +430,9 @@ void find_and_set_offload_fail_reason(const LEX *lex) {
   // check known unsupported features and raise a specific offload error.
   std::string err_msg{};
   const Table_ref *tref = nullptr;
-  if (lex->uses_stored_routines() ||
-      (lex->m_sql_cmd != nullptr && lex->m_sql_cmd->is_part_of_sp()) ||
-      lex->thd->sp_runtime_ctx != nullptr) {
+  if (lex->has_stored_functions) {
     // We don't support secondary storage engine execution,
-    // if the query has statements that call stored routines.
+    // if the query has statements that call stored functions.
     err_msg =
         "Statements that reference stored functions are not supported in "
         "secondary engines.";

sql/trigger.cc

@@ -394,6 +394,12 @@ bool Trigger::execute(THD *thd) {
 
   thd->reset_sub_statement_state(&statement_state, SUB_STMT_TRIGGER);
 
+  Secondary_engine_optimization saved_state =
+      thd->secondary_engine_optimization();
+
+  thd->set_secondary_engine_optimization(
+      Secondary_engine_optimization::PRIMARY_TENTATIVELY);
+
   /*
     Reset current_query_block before call execute_trigger() and
     restore it after return from one. This way error is set
@@ -407,6 +413,8 @@ bool Trigger::execute(THD *thd) {
 
   thd->restore_sub_statement_state(&statement_state);
 
+  thd->set_secondary_engine_optimization(saved_state);
+
   return err_status;
 }