WL#15575: Fixes for propagating error to lakehouse [Bug#35282626].

* Propagate the error in MySQL even if we come from secondary engine
  optimization and the table refers to an external engine.
* Mark the table as external in the case where the prepare statement
  fails too.

- Added more test cases to increase coverage of the non-offloaded
  queries implementation.

Change-Id: Ifad0b7cf44a2c77d0fdd7624aab44d7817ae31c1

Author: Stella Giannakopoulou

sql/sql_select.cc

@@ -372,10 +372,9 @@ static void set_external_engine_fail_reason(const LEX *lex,
       reason != nullptr) {
     for (Table_ref *ref = lex->query_tables; ref != nullptr;
          ref = ref->next_global) {
-      if (ref->table != nullptr && ref->table->file != nullptr &&
-          (ref->table->file->ht->flags & HTON_SUPPORTS_EXTERNAL_SOURCE) != 0 &&
-          ref->table->s->has_secondary_engine()) {
-        ref->table->file->set_external_table_offload_error(reason);
+      if (ref->is_external()) {
+        ref->table->get_primary_handler()->set_external_table_offload_error(
+            reason);
         break;
       }
     }
@@ -385,10 +384,8 @@ static void set_external_engine_fail_reason(const LEX *lex,
 static void external_engine_fail_reason(const LEX *lex) {
   for (Table_ref *ref = lex->query_tables; ref != nullptr;
        ref = ref->next_global) {
-    if (ref->table != nullptr && ref->table->file != nullptr &&
-        (ref->table->file->ht->flags & HTON_SUPPORTS_EXTERNAL_SOURCE) != 0 &&
-        ref->table->s->has_secondary_engine()) {
-      ref->table->file->external_table_offload_error();
+    if (ref->is_external()) {
+      ref->table->get_primary_handler()->external_table_offload_error();
       return;
     }
   }
@@ -665,9 +662,7 @@ bool Sql_cmd_select::prepare_inner(THD *thd) {
 
 static bool has_external_table(Table_ref *query_tables) {
   for (Table_ref *ref = query_tables; ref != nullptr; ref = ref->next_global) {
-    if (ref->table != nullptr && ref->table->file != nullptr &&
-        (ref->table->file->ht->flags & HTON_SUPPORTS_EXTERNAL_SOURCE) != 0 &&
-        ref->table->s->has_secondary_engine()) {
+    if (ref->is_external()) {
       return true;
     }
   }
@@ -684,8 +679,6 @@ bool Sql_cmd_dml::execute(THD *thd) {
   bool statement_timer_armed = false;
   bool error_handler_active = false;
 
-  // flag to denote if the query refers to an external table
-  bool is_external_table = false;
   // flag to determine if execution was not offloaded to the secondary engine
   // and ended up in the external engine in which case we throw an error.
   bool external_table_not_offloaded = false;
@@ -747,18 +740,18 @@ bool Sql_cmd_dml::execute(THD *thd) {
     }
   }
 
-  is_external_table = has_external_table(lex->query_tables);
-  if (lex->thd->variables.use_secondary_engine == SECONDARY_ENGINE_OFF &&
-      is_external_table) {
-    my_error(ER_SECONDARY_ENGINE_PLUGIN, MYF(0),
-             "Query could not be offloaded to the secondary engine");
-    external_table_not_offloaded = true;
-    goto err;  // NOLINT
+  if (lex->thd->variables.use_secondary_engine == SECONDARY_ENGINE_OFF) {
+    if (has_external_table(lex->query_tables)) {
+      my_error(ER_SECONDARY_ENGINE_PLUGIN, MYF(0),
+               "Query could not be offloaded to the secondary engine");
+      external_table_not_offloaded = true;
+      goto err;  // NOLINT
+    }
   } else if ((thd->secondary_engine_optimization() ==
                   Secondary_engine_optimization::PRIMARY_ONLY &&
               lex->thd->variables.use_secondary_engine !=
                   SECONDARY_ENGINE_FORCED) &&
-             is_external_table) {
+             has_external_table(lex->query_tables)) {
     // throw the propagated error from the external engine in case there is an
     // external table
     external_engine_fail_reason(lex);
@@ -855,9 +848,10 @@ 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 (is_external_table)
+        if (has_external_table(lex->query_tables)) {
           set_external_engine_fail_reason(lex,
                                           thd->get_stmt_da()->message_text());
+        }
         set_secondary_engine_fail_reason(lex,
                                          thd->get_stmt_da()->message_text());
       }

sql/table.cc

@@ -7263,6 +7263,13 @@ void TABLE::column_bitmaps_set(MY_BITMAP *read_set_arg,
   if (file && created) file->column_bitmaps_signal();
 }
 
+handler *TABLE::get_primary_handler() const {
+  if (s->is_primary_engine()) {
+    return file;
+  }
+  return file->ha_get_primary_handler();
+}
+
 bool Table_ref::set_recursive_reference() {
   if (query_block->recursive_reference != nullptr) return true;
   query_block->recursive_reference = this;
@@ -7280,6 +7287,18 @@ uint Table_ref::get_hidden_field_count_for_derived() const {
   return derived_result->get_hidden_field_count();
 }
 
+bool Table_ref::is_external() const {
+  if (m_table_ref_type == TABLE_REF_BASE_TABLE && table != nullptr &&
+      table->file != nullptr) {
+    handler *primary_handler = table->get_primary_handler();
+    return primary_handler != nullptr &&
+           Overlaps(primary_handler->ht->flags,
+                    HTON_SUPPORTS_EXTERNAL_SOURCE) &&
+           primary_handler->get_table_share()->has_secondary_engine();
+  }
+  return false;
+}
+
 void LEX_MFA::copy(LEX_MFA *m, MEM_ROOT *alloc) {
   nth_factor = m->nth_factor;
   uses_identified_by_clause = m->uses_identified_by_clause;

sql/table.h

@@ -2147,6 +2147,12 @@ struct TABLE {
   void update_covering_prefix_keys(Field *field, uint16 key_read_length,
                                    Key_map *covering_prefix_keys);
 
+  /**
+    Returns the primary engine handler for the table.
+    If none exist, nullptr is returned.
+  */
+  handler *get_primary_handler() const;
+
  private:
   /**
     Bitmap that tells which columns are eligible for partial update in an
@@ -3157,6 +3163,9 @@ class Table_ref {
   /// Returns true if a MATCH function references this table.
   bool is_fulltext_searched() const { return m_fulltext_searched; }
 
+  /// Is this table only available in an external storage engine?
+  bool is_external() const;
+
   /**
     Set table as readonly, ie it is neither updatable, insertable nor
     deletable during this statement.