merge develop to main (mysql#95)

to enable ART index .
---------
Co-authored-by: RingsC <[email protected]>

Author: ShannonBase

sql/handler.h

@@ -4498,7 +4498,7 @@ class handler {
     of the current range.
   */
   enum enum_range_scan_direction { RANGE_SCAN_ASC, RANGE_SCAN_DESC };
-
+  int get_key_comp_result() { return key_compare_result_on_equal; }
  private:
   Record_buffer *m_record_buffer = nullptr;  ///< Buffer for multi-row reads.
   /*
@@ -4649,7 +4649,9 @@ class handler {
     if (rc) end_psi_batch_mode();
     return rc;
   }
-
+  enum_range_scan_direction get_range_scan_direction() {
+    return range_scan_direction;
+  }
  private:
   /**
     The lock type set by when calling::ha_external_lock(). This is

sql/sql_base.cc

@@ -6680,21 +6680,63 @@ 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);
 
+  // If use of primary engine is requested, set state accordingly
+  if (thd->variables.use_secondary_engine == SECONDARY_ENGINE_OFF) {
+    if (lex->can_execute_only_in_secondary_engine()) {
+      my_error(ER_SECONDARY_ENGINE_PLUGIN, MYF(0),
+               lex->get_not_supported_in_primary_reason());
+      return true;
+    }
+
+    thd->set_secondary_engine_optimization(
+        Secondary_engine_optimization::PRIMARY_ONLY);
+    return false;
+  }
   // 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())
+  // Statements without Sql_cmd representations are for primary engine only:
+  if (sql_cmd == nullptr) {
+    thd->set_secondary_engine_optimization(
+        Secondary_engine_optimization::PRIMARY_ONLY);
     return false;
-
+  }
+  /*
+    Only some SQL commands can be offloaded to secondary table offload.
+    Note that table-less queries are always executed in primary engine.
+  */
+  const bool offload_possible =
+      (lex->sql_command == SQLCOM_SELECT && lex->table_count > 0) ||
+      ((lex->sql_command == SQLCOM_INSERT_SELECT ||
+        lex->sql_command == SQLCOM_CREATE_TABLE) &&
+       lex->table_count > 1);
+  /*
+    If query can only execute in secondary engine, effectively set it as
+    a forced secondary execution.
+  */
+  if (lex->can_execute_only_in_secondary_engine()) {
+    thd->set_secondary_engine_forced(true);
+  }
   // If the user has requested the use of a secondary storage engine
   // for this statement, skip past the initial optimization for the
   // primary storage engine and go straight to the secondary engine.
   if (thd->secondary_engine_optimization() ==
           Secondary_engine_optimization::PRIMARY_TENTATIVELY &&
       thd->variables.use_secondary_engine == SECONDARY_ENGINE_FORCED) {
-    thd->set_secondary_engine_optimization(
-        Secondary_engine_optimization::SECONDARY);
-    mysql_thread_set_secondary_engine(true);
-    mysql_statement_set_secondary_engine(thd->m_statement_psi, true);
+    if (offload_possible) {
+      thd->set_secondary_engine_optimization(
+          Secondary_engine_optimization::SECONDARY);
+      mysql_thread_set_secondary_engine(true);
+      mysql_statement_set_secondary_engine(thd->m_statement_psi, true);
+    } else {
+      // Table-less queries cannot be executed in secondary engine
+      if (lex->can_execute_only_in_secondary_engine()) {
+        my_error(ER_SECONDARY_ENGINE_PLUGIN, MYF(0),
+                 lex->get_not_supported_in_primary_reason());
+        return true;
+      }
+      thd->set_secondary_engine_optimization(
+          Secondary_engine_optimization::PRIMARY_ONLY);
+    }
   }
 
   // Only open secondary engine tables if use of a secondary engine

sql/sql_class.h

@@ -4630,6 +4630,12 @@ class THD : public MDL_context_owner,
   */
   bool is_secondary_storage_engine_eligible() const;
 
+  /// Indicate whether secondary storage engine is forced for this execution
+  void set_secondary_engine_forced(bool forced) {
+    m_secondary_engine_forced = forced;
+  }
+
+  bool is_secondary_engine_forced() const { return m_secondary_engine_forced; }
  private:
   /**
     This flag tells if a secondary storage engine can be used to
@@ -4638,6 +4644,13 @@ class THD : public MDL_context_owner,
   Secondary_engine_optimization m_secondary_engine_optimization =
       Secondary_engine_optimization::PRIMARY_ONLY;
 
+  /**
+    Flag that tells whether secondary storage engine is forced for execution.
+    Notice that use_secondary_engine is not reliable because it may be restored
+    early.
+  */
+  bool m_secondary_engine_forced{false};
+
   void cleanup_after_parse_error();
   /**
     Flag that indicates if the user of current session has SYSTEM_USER privilege

sql/sql_lex.h

@@ -3663,6 +3663,12 @@ class LEX_GRANT_AS {
   List<LEX_USER> *role_list;
 };
 
+/*
+  Some queries can be executed only using the secondary engine. The enum
+  "execute_only_in_secondary_reasons" retains the explanations for queries that
+  cannot be executed using the primary engine.
+*/
+enum execute_only_in_secondary_reasons { SUPPORTED_IN_PRIMARY, CUBE };
 /**
   The LEX object currently serves three different purposes:
 
@@ -3726,6 +3732,9 @@ struct LEX : public Query_tables_list {
   /* current Query_block in parsing */
   Query_block *m_current_query_block;
 
+  bool m_can_execute_only_in_secondary_engine = false;
+  execute_only_in_secondary_reasons m_execute_only_in_secondary_engine_reason{
+      SUPPORTED_IN_PRIMARY};
  public:
   inline Query_block *current_query_block() const {
     return m_current_query_block;
@@ -3848,7 +3857,28 @@ struct LEX : public Query_tables_list {
   std::map<Item_field *, Field *>::iterator end_values_map() {
     return insert_update_values_map->end();
   }
+  bool can_execute_only_in_secondary_engine() const {
+    return m_can_execute_only_in_secondary_engine;
+  }
+  void set_execute_only_in_secondary_engine(
+      const bool execute_only_in_secondary_engine_param,
+      execute_only_in_secondary_reasons reason) {
+    m_can_execute_only_in_secondary_engine =
+        execute_only_in_secondary_engine_param;
+    m_execute_only_in_secondary_engine_reason = reason;
+    assert(m_can_execute_only_in_secondary_engine ||
+           reason == SUPPORTED_IN_PRIMARY);
+  }
 
+  const char *get_not_supported_in_primary_reason() {
+    assert(can_execute_only_in_secondary_engine());
+    switch (m_execute_only_in_secondary_engine_reason) {
+      case CUBE:
+        return "CUBE";
+      default:
+        return "UNDEFINED";
+    }
+  }
  private:
   /*
     With Visual Studio, an std::map will always allocate two small objects

sql/sql_table.cc

@@ -200,6 +200,8 @@
 #include "typelib.h"
 
 #include "storage/rapid_engine/include/rapid_stats.h" //meta_rpd_columns_infos
+#include "storage/rapid_engine/imcs/imcs.h"
+#include "storage/rapid_engine/imcs/cu.h"
 namespace dd {
 class View;
 }  // namespace dd
@@ -2732,10 +2734,16 @@ static bool secondary_engine_load_table(THD *thd, const TABLE &table) {
     row_rpd_columns.table_id = static_cast<uint>(table.s->table_map_id.id());
     row_rpd_columns.column_id = field_ptr->field_index();
     strncpy(row_rpd_columns.column_name, field_ptr->field_name,
-            strlen(row_rpd_columns.column_name));
+            strlen(field_ptr->field_name));
     strncpy(row_rpd_columns.table_name, table.s->table_name.str,
-            strlen(row_rpd_columns.table_name));
-    row_rpd_columns.data_dict_bytes = 0;
+            strlen(table.s->table_name.str));
+    std::string key_name (table.s->db.str);
+    key_name += table.s->table_name.str;
+    key_name += field_ptr->field_name;
+    ShannonBase::Compress::Dictionary* dict =
+      ShannonBase::Imcs::Imcs::get_instance()->get_cu(key_name)->get_header()->m_local_dict.get();
+    if (dict)
+      row_rpd_columns.data_dict_bytes = dict->content_size();
     row_rpd_columns.data_placement_index = 0;
 
     std::string comment (field_ptr->comment.str);

storage/innobase/handler/ha_innodb.h

@@ -472,6 +472,7 @@ class ha_innobase : public handler {
   bool check_if_incompatible_data(HA_CREATE_INFO *info,
                                   uint table_changes) override;
 
+  virtual dict_index_t *innobase_get_index(uint keynr);
  private:
   /** @name Multi Range Read interface
   @{ */
@@ -504,7 +505,6 @@ class ha_innobase : public handler {
   @return idx_cond if pushed; NULL if not pushed */
   Item *idx_cond_push(uint keyno, Item *idx_cond) override;
   /** @} */
-
  private:
   void update_thd();
 
@@ -555,9 +555,7 @@ class ha_innobase : public handler {
   void update_thd(THD *thd);
 
   int general_fetch(uchar *buf, uint direction, uint match_mode);
-
-  virtual dict_index_t *innobase_get_index(uint keynr);
-
+  
   /** Builds a 'template' to the m_prebuilt struct. The template is used in fast
   retrieval of just those column values MySQL needs in its processing.
   @param[in] whole_row true if access is needed to a whole row, false if

storage/perfschema/pfs_engine_table.cc

@@ -120,6 +120,9 @@
 #include "storage/perfschema/table_replication_applier_status_by_worker.h"
 #include "storage/perfschema/table_rpd_column_id.h"  // rpd_column_id
 #include "storage/perfschema/table_rpd_columns.h"    // rpd_columns
+#include "storage/perfschema/table_rpd_preload_stats.h"    // rpd_preload_stats
+#include "storage/perfschema/table_rpd_table_id.h"    // rpd_table_id
+#include "storage/perfschema/table_rpd_tables.h"    // rpd_tables
 /* For replication related perfschema tables. */
 #include "storage/perfschema/table_log_status.h"
 #include "storage/perfschema/table_replication_asynchronous_connection_failover.h"
@@ -585,6 +588,10 @@ static PFS_engine_table_share *all_shares[] = {
     &table_rpl_async_connection_failover_managed::m_share,
     &table_rpd_column_id::m_share,
     &table_rpd_columns::m_share,
+    &table_rpd_table_id::m_share,
+    &table_rpd_tables::m_share,
+    &table_rpd_preload_stats::m_share,
+
     &table_log_status::m_share,
 
     &table_prepared_stmt_instances::m_share,

storage/perfschema/table_rpd_column_id.cc

@@ -137,8 +137,9 @@ int table_rpd_column_id::make_row(uint index[[maybe_unused]]) {
   } else {
     m_row.column_id = ShannonBase::meta_rpd_columns_infos[index].column_id;
     m_row.table_id = ShannonBase::meta_rpd_columns_infos[index].table_id;
+
     strncpy(m_row.column_name, ShannonBase::meta_rpd_columns_infos[index].column_name,
-            strlen(m_row.column_name));
+            strlen(ShannonBase::meta_rpd_columns_infos[index].column_name));
     m_row.column_name_length = strlen(ShannonBase::meta_rpd_columns_infos[index].column_name);
   }
   return 0;

storage/perfschema/table_rpd_columns.cc

@@ -149,7 +149,7 @@ int table_rpd_columns::make_row(uint index[[maybe_unused]]) {
     m_row.ndv = ShannonBase::meta_rpd_columns_infos[index].ndv;
     memset(m_row.encoding, 0x0, NAME_LEN);
     strncpy(m_row.encoding, ShannonBase::meta_rpd_columns_infos[index].encoding,
-            strlen(m_row.encoding));
+            strlen(ShannonBase::meta_rpd_columns_infos[index].encoding));
   }
   return 0;
 }