WL#6599 - New Data Dictionary and I_S integration.

Post-push patch fixing POINT_SELECT performance regression fix.

The patch does following improvement in open_tables() call flow,

1 We were invoking dd::Dictionary::is_system_view_name() several
  times for a table. E.g., SELECT_LEX::add_table_to_list() would
  already know that if a TABLE_LIST is a system view. We were not
  setting TABLE_LIST->is_system_view here.  This patch sets this in
  SELECT_LEX::add_table_to_list() and avoids calls to
  dd::Dictionary::is_system_view_name() function call which goes
  throw all the system view names within the open_tables() call flow.

2 We also avoid call to dd::Dictionary::is_dd_table_name().
  Basically there are two possibilities of open_tables() call seeing
  a DD tables.

  a) DD table being opened as part of DD operations invoking
     dd::Open_dictionary_tables_ctx::open_tables().

  b) DD table being opened as part of I_S system view execution.

  During open_table(), we need to know if a TABLE_LIST belongs to a
  DD table for several checks. Currently we do that by invoking
  dd::Dictionary::is_dd_table_name() which is a looking in a list.
  We can avoid that as described below.

  When open_table() is opening a DD table in case of a), the
  table_list used there is nothing but dd::Raw_table::m_table_list.
  And we are sure that this belongs to only DD tables. So, this
  patch adds a member TABLE_LIST->is_dd_table, which is set only by
  dd::Raw_table.  So the open_table() call now uses it.

  For b), we know that TABLE_LIST->is_system_view is marked for all
  the I_S system views. And
  TABLE_LIST->referencing_view->is_system_view would tell us that
  the TABLE_LIST is refering to a DD table. So, this avoids calls
  to dd::Dictionary::is_system_view_name().

3 The function TABLE_SHARE::get_table_ref_version() is invoking
  both dd::Dictionary::is_dd_table_name() and
  dd::Dictionary::is_system_view_name().  This is a overhead.  This
  patch adds a TABLE_SHARE->table_category called
  TABLE_CATEGORY_DICTIONARY. This helps us avoid call to
  is_dd_table_name(). And use TABLE_SHARE->view_object->type() ==
  dd::enum_table_type::SYSTEM_VIEW to check if that is a system view.

4 The patch does following change, that is not necessarily to
  improve the permformance. Basically the revno 56eaef86 sets
  MYSQL_OPEN_IGNORE_FLUSH flag while opening DD tables in
  Open_dictionary_tables_ctx::open_tables().  And later the revno
  11eeb00a removes this flag, expecting open_table() to set it for
  DD tables. Conceptually it looks correct to set this flag for all
  DD table at Open_dictionary_tables_ctx::open_tables() so this
  patch retain setting of this flag as done by revno 56eaef86.
  These revno are from mysql-trunk-wl6599-1 branch.

Author: gopshank

sql/dd/dictionary.h

@@ -114,8 +114,8 @@ class Dictionary
     @returns true -  If given table name is a system view.
     @returns false - If table name is not a system view.
   */
-  virtual bool is_system_view_name(const std::string &schema_name,
-                                   const std::string &table_name) const = 0;
+  virtual bool is_system_view_name(const char *schema_name,
+                                   const char *table_name) const = 0;
 
 public:
   // Destructor to cleanup data dictionary instance upon server shutdown.

sql/dd/impl/dictionary_impl.cc

@@ -185,23 +185,29 @@ bool Dictionary_impl::is_dd_table_access_allowed(
 
 ///////////////////////////////////////////////////////////////////////////
 
-bool Dictionary_impl::is_system_view_name(const std::string &schema_name,
-                                          const std::string &table_name) const
+bool Dictionary_impl::is_system_view_name(const char *schema_name,
+                                          const char *table_name) const
 {
-  // The System_views registry stores the view name in lowercase.
-  // So convert the input to lowercase before search.
-  char sch_name_buf[NAME_LEN + 1];
-  my_stpcpy(sch_name_buf, schema_name.c_str());
-  my_casedn_str(&my_charset_utf8_tolower_ci, sch_name_buf);
-
-  if (strcmp(sch_name_buf,INFORMATION_SCHEMA_NAME.str) != 0)
+  /*
+    TODO One possible improvement here could be to try and use the variant
+    of is_infoschema_db() that takes length as a parameter. Then, if the
+    schema name length is different, this can quickly be used to conclude
+    that this is indeed not a system view, without having to do a strcmp at
+    all.
+  */
+  if (schema_name == nullptr ||
+      table_name == nullptr ||
+      is_infoschema_db(schema_name) == false)
     return false;
 
+  // The System_views registry stores the view name in lowercase.
+  // So convert the input to lowercase before search.
   char tab_name_buf[NAME_LEN + 1];
-  my_stpcpy(tab_name_buf, table_name.c_str());
-  my_caseup_str(&my_charset_utf8_tolower_ci, tab_name_buf);
+  my_stpcpy(tab_name_buf, table_name);
+  my_caseup_str(system_charset_info, tab_name_buf);
 
-  return (System_views::instance()->find(sch_name_buf, tab_name_buf) != NULL);
+  return (System_views::instance()->find(INFORMATION_SCHEMA_NAME.str,
+                                         tab_name_buf) != NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////

sql/dd/impl/dictionary_impl.h

@@ -93,8 +93,8 @@ class Dictionary_impl : public Dictionary
                                           size_t schema_length,
                                           const char *table_name) const;
 
-  virtual bool is_system_view_name(const std::string &schema_name,
-                                   const std::string &table_name) const;
+  virtual bool is_system_view_name(const char *schema_name,
+                                   const char *table_name) const;
 
 public:
   static Object_id default_catalog_id()

sql/dd/impl/raw/raw_table.cc

@@ -32,6 +32,7 @@ Raw_table::Raw_table(thr_lock_type lock_type,
                               name.length(),
                               name.c_str(),
                               lock_type);
+  m_table_list.is_dd_ctx_table= true;
 }
 
 ///////////////////////////////////////////////////////////////////////////

sql/dd/impl/transaction_impl.cc

@@ -92,6 +92,7 @@ bool Open_dictionary_tables_ctx::open_tables()
 
   const uint flags= (MYSQL_LOCK_IGNORE_TIMEOUT |
                      MYSQL_OPEN_IGNORE_KILLED |
+                     MYSQL_OPEN_IGNORE_FLUSH |
                      m_ignore_global_read_lock ?
                        MYSQL_OPEN_IGNORE_GLOBAL_READ_LOCK : 0);
   uint counter;

sql/sp_head.cc

@@ -3518,6 +3518,8 @@ void sp_head::add_used_tables_to_table_list(THD *thd,
                             stab->table_name_length + 1,
                             stab->lock_type, mdl_lock_type);
 
+      table->is_system_view=
+        dd::get_dictionary()->is_system_view_name(table->db, table->table_name);
       table->cacheable_table= 1;
       table->prelocking_placeholder= 1;
       table->belong_to_view= belong_to_view;

sql/sql_base.cc

@@ -1374,11 +1374,26 @@ static inline bool in_LTM(THD *thd)
           thd->locked_tables_mode == LTM_PRELOCKED_UNDER_LOCK_TABLES);
 }
 
-// Check if the given db.table belongs to a IS view or a DD table.
-bool belongs_to_system_view(const char *db, const char *table_name)
+
+/**
+  Check if the given TABLE_LIST belongs to a a DD table.
+
+  The function checks whether the table is a DD table being used in the
+  context of a DD transaction, or whether it is referred by a system view.
+  Then, it implies that if either of these two conditions hold, then this
+  is a DD table. If in case this is a DD table being used in some other
+  situation, then this function does not return 'true'. We do not know if
+  there is such a situation right now.
+
+  @param    tl             TABLE_LIST point to the table.
+
+  @retval   true           If table belongs to a DD table.
+  @retval   false          If table does not.
+*/
+static bool belongs_to_dd_table(const TABLE_LIST *tl)
 {
-  return (dd::get_dictionary()->is_dd_table_name(db, table_name) ||
-          dd::get_dictionary()->is_system_view_name(db, table_name));
+  return (tl->is_dd_ctx_table ||
+          (tl->referencing_view && tl->referencing_view->is_system_view));
 }
 
 
@@ -1526,8 +1541,7 @@ void close_thread_tables(THD *thd)
           */
           TABLE_LIST *tbl_list= table->pos_in_table_list;
           if (!thd->in_sub_stmt &&
-              (dd::get_dictionary()->is_dd_table_name(
-                     tbl_list->db, tbl_list->table_name) ||
+              (belongs_to_dd_table(tbl_list) ||
                belongs_to_p_s(table->pos_in_table_list)))
           {
             if (!table->s->tmp_table)
@@ -2931,7 +2945,8 @@ bool open_table(THD *thd, TABLE_LIST *table_list, Open_table_context *ot_ctx)
     FLUSH TABLES is ignored for DD, I_S and P_S tables/views.
     Hence setting MYSQL_OPEN_IGNORE_FLUSH flag.
   */
-  if (belongs_to_system_view(table_list->db, table_list->table_name) ||
+  if (table_list->is_system_view ||
+      belongs_to_dd_table(table_list) ||
       belongs_to_p_s(table_list))
     flags|= MYSQL_OPEN_IGNORE_FLUSH;
 
@@ -2964,7 +2979,8 @@ bool open_table(THD *thd, TABLE_LIST *table_list, Open_table_context *ot_ctx)
   if (thd->locked_tables_mode &&
       !(flags & MYSQL_OPEN_GET_NEW_TABLE) &&
       !(in_LTM(thd) &&
-        (belongs_to_system_view(table_list->db, table_list->table_name) ||
+        (table_list->is_system_view ||
+         belongs_to_dd_table(table_list) ||
          belongs_to_p_s(table_list))))
   {   // Using table locks
     TABLE *best_table= 0;
@@ -5450,8 +5466,7 @@ get_and_lock_tablespace_names(THD *thd,
         table->open_type != OT_TEMPORARY_ONLY                      &&
         !(table->open_type == OT_TEMPORARY_OR_BASE &&
           is_temporary_table(table)) &&
-        !dd::get_dictionary()->is_system_view_name(table->db,
-                                                   table->table_name))
+        !table->is_system_view)
     {
       // We have basically three situations here:
       //
@@ -6037,8 +6052,7 @@ bool open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags,
       by SE. Here, we request SE to use read lock for these implicitly opened
       DD tables using ha_external_lock().
     */
-    if (tbl && in_LTM(thd) &&
-        dd::get_dictionary()->is_dd_table_name(tables->db, tables->table_name))
+    if (tbl && in_LTM(thd) && belongs_to_dd_table(tables))
     {
       DBUG_ASSERT(tbl->file->get_lock_type() == F_UNLCK);
       tbl->file->init_table_handle_for_HANDLER();

sql/sql_base.h

@@ -349,19 +349,6 @@ TABLE_LIST *find_table_in_global_list(TABLE_LIST *table,
                                       const char *db_name,
                                       const char *table_name);
 
-/**
-  Check if the given db.table belongs to a IS view or a DD table.
-
-  @param    db             Database name.
-  @param    table_name     Table name.
-
-  @retval   true           If db.table belongs to a IS view or a DD table.
-  @retval   false          If db.table does not belongs to a IS view or a
-                           DD table.
-*/
-
-bool belongs_to_system_view(const char *db, const char *table_name);
-
 /**
   An abstract class for a strategy specifying how the prelocking
   algorithm should extend the prelocking set while processing

sql/sql_parse.cc

@@ -5571,23 +5571,23 @@ TABLE_LIST *SELECT_LEX::add_table_to_list(THD *thd,
                        const_cast<char*>(ptr->db),
                        const_cast<char*>(ptr->table_name));
 
-    bool is_system_view=
+    ptr->is_system_view=
       dd::get_dictionary()->is_system_view_name(ptr->db, ptr->table_name);
 
     ST_SCHEMA_TABLE *schema_table;
     if (ptr->updating &&
         /* Special cases which are processed by commands itself */
         lex->sql_command != SQLCOM_CHECK &&
         lex->sql_command != SQLCOM_CHECKSUM &&
-        !(lex->sql_command == SQLCOM_CREATE_VIEW && is_system_view))
+        !(lex->sql_command == SQLCOM_CREATE_VIEW && ptr->is_system_view))
     {
       my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
                thd->security_context()->priv_user().str,
                thd->security_context()->priv_host().str,
                INFORMATION_SCHEMA_NAME.str);
       DBUG_RETURN(0);
     }
-    if (is_system_view)
+    if (ptr->is_system_view)
     {
       /**
         Pick the right IS system view definition based on session

sql/table.cc

@@ -47,6 +47,8 @@
 #include "table_trigger_dispatcher.h"    // Table_trigger_dispatcher
 #include "template_utils.h"              // down_cast
 
+#include "dd/dd.h"                       // dd::get_dictionary
+#include "dd/dictionary.h"               // dd::Dictionary
 #include "dd/types/table.h"              // dd::Table
 #include "dd/types/view.h"               // dd::View
 
@@ -328,6 +330,9 @@ TABLE_CATEGORY get_table_category(const LEX_STRING &db,
                        name.str) == 0))
       return TABLE_CATEGORY_GTID;
 
+    if (dd::get_dictionary()->is_dd_table_name(MYSQL_SCHEMA_NAME.str,
+                                               name.str))
+      return TABLE_CATEGORY_DICTIONARY;
   }
 
   return TABLE_CATEGORY_USER;
@@ -2431,9 +2436,10 @@ bool TABLE_SHARE::wait_for_old_version(THD *thd, struct timespec *abstime,
 
 ulonglong TABLE_SHARE::get_table_ref_version() const
 {
-  if (belongs_to_system_view(static_cast<const char *>(db.str),
-                             static_cast<const char *>(table_name.str)) ||
-      (tmp_table == SYSTEM_TMP_TABLE))
+  if (table_category == TABLE_CATEGORY_DICTIONARY ||
+      tmp_table == SYSTEM_TMP_TABLE ||
+      (is_view && view_object &&
+       view_object->type() == dd::enum_table_type::SYSTEM_VIEW))
     return 0;
 
   return table_map_id.id();

sql/table.h

@@ -482,7 +482,15 @@ enum enum_table_category
     a GLOBAL READ LOCK or a GLOBAL READ_ONLY in effect.
     Gtid table is cached in the table cache.
   */
-  TABLE_CATEGORY_GTID=8
+  TABLE_CATEGORY_GTID=8,
+
+  /**
+    A data dictionary table.
+    Table's with this category will skip checking the
+    TABLE_SHARE versions because these table structures
+    are fixed upon server bootstrap.
+  */
+  TABLE_CATEGORY_DICTIONARY=9
 };
 typedef enum enum_table_category TABLE_CATEGORY;
 
@@ -2601,6 +2609,9 @@ struct TABLE_LIST
   // True, If this is a system view
   bool is_system_view;
 
+  // True, If this is a dictionary table.
+  bool is_dd_ctx_table;
+
   /* End of view definition context. */
 
   /* List of possible keys. Valid only for materialized derived tables/views. */