Bug#18410442 CREATE A BASE CLASS FOR GTID_TABLE_ACCESS_CONTEXT AND RPL_INFO_TABLE_ACCESS

Create a base class for Gtid_table_access_context and Rpl_info_table_access clases. ~

Author: Bill Qu

sql/rpl_gtid_persist.cc

@@ -17,7 +17,6 @@
 
 #include "log.h"
 #include "key.h"
-#include "sql_base.h"
 #include "sql_parse.h"
 #include "replication.h"
 #include "rpl_gtid_persist.h"
@@ -72,9 +71,8 @@ static void deinit_thd(THD *thd)
 
 THD *Gtid_table_access_context::create_thd()
 {
-  THD *thd= NULL;
-  thd= new THD;
-  init_thd(&thd);
+  THD *thd= Table_access::create_thd();
+  thd->system_thread= SYSTEM_THREAD_COMPRESS_GTID_TABLE;
   /*
     This is equivalent to a new "statement". For that reason, we call
     both lex_start() and mysql_reset_thd_for_next_command.
@@ -86,10 +84,18 @@ THD *Gtid_table_access_context::create_thd()
 }
 
 
-void Gtid_table_access_context::drop_thd(THD *thd)
+void Gtid_table_access_context::before_open(THD* thd)
 {
-  DBUG_ENTER("Gtid_table_access_context::drop_thd");
-  deinit_thd(thd);
+  DBUG_ENTER("Gtid_table_access_context::before_open");
+  /*
+    Allow to operate the gtid_executed table
+    while disconnecting the session.
+  */
+  m_flags= (MYSQL_OPEN_IGNORE_GLOBAL_READ_LOCK |
+            MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY |
+            MYSQL_OPEN_IGNORE_FLUSH |
+            MYSQL_LOCK_IGNORE_TIMEOUT |
+            MYSQL_OPEN_IGNORE_KILLED);
   DBUG_VOID_RETURN;
 }
 
@@ -107,7 +113,11 @@ bool Gtid_table_access_context::init(THD **thd, TABLE **table, bool is_write)
     m_tmp_disable_binlog__save_options= (*thd)->variables.option_bits;
     (*thd)->variables.option_bits&= ~OPTION_BIN_LOG;
   }
-  bool ret= this->open_table(*thd, m_is_write ? TL_WRITE : TL_READ, table);
+  (*thd)->is_operating_gtid_table= true;
+  bool ret= this->open_table(*thd, DB_NAME, TABLE_NAME,
+                             Gtid_table_persistor::number_fields,
+                             m_is_write ? TL_WRITE : TL_READ,
+                             table, &m_backup);
 
   DBUG_RETURN(ret);
 }
@@ -118,7 +128,8 @@ void Gtid_table_access_context::deinit(THD *thd, TABLE *table,
 {
   DBUG_ENTER("Gtid_table_access_context::deinit");
 
-  this->close_table(thd, table, 0 != error, need_commit);
+  this->close_table(thd, table, &m_backup, 0 != error, need_commit);
+  thd->is_operating_gtid_table= false;
   /* Reenable binlog */
   if (m_is_write)
     thd->variables.option_bits= m_tmp_disable_binlog__save_options;
@@ -129,130 +140,6 @@ void Gtid_table_access_context::deinit(THD *thd, TABLE *table,
 }
 
 
-void Gtid_table_access_context::close_table(THD *thd, TABLE *table,
-                                            bool error, bool need_commit)
-{
-  Query_tables_list query_tables_list_backup;
-
-  DBUG_ENTER("Gtid_table_access_context::close_table");
-
-  if (table)
-  {
-    if (error)
-      ha_rollback_trans(thd, false);
-    else
-    {
-      /*
-        To make the commit not to block with global read lock set
-        "ignore_global_read_lock" flag to true.
-      */
-      ha_commit_trans(thd, false, true);
-    }
-
-    if (need_commit)
-    {
-      if (error)
-        ha_rollback_trans(thd, true);
-      else
-      {
-        ha_commit_trans(thd, true, true);
-      }
-    }
-
-    /*
-      In order not to break execution of current statement we have to
-      backup/reset/restore Query_tables_list part of LEX, which is
-      accessed and updated in the process of closing tables.
-    */
-    thd->lex->reset_n_backup_query_tables_list(&query_tables_list_backup);
-    close_thread_tables(thd);
-    thd->lex->restore_backup_query_tables_list(&query_tables_list_backup);
-    thd->restore_backup_open_tables_state(&m_backup);
-  }
-  thd->is_operating_gtid_table= false;
-
-  DBUG_VOID_RETURN;
-}
-
-
-bool Gtid_table_access_context::open_table(THD *thd,
-                                           enum thr_lock_type lock_type,
-                                           TABLE **table)
-{
-  DBUG_ENTER("Gtid_table_access_context::open_table");
-
-  TABLE_LIST tables;
-  Query_tables_list query_tables_list_backup;
-
-  /*
-    Allow to operate the gtid_executed table
-    when disconnecting the session.
-  */
-  uint flags= (MYSQL_OPEN_IGNORE_GLOBAL_READ_LOCK |
-               MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY |
-               MYSQL_OPEN_IGNORE_FLUSH |
-               MYSQL_LOCK_IGNORE_TIMEOUT |
-               MYSQL_OPEN_IGNORE_KILLED);
-
-  /*
-    We need to use new Open_tables_state in order not to be affected
-    by LOCK TABLES/prelocked mode.
-    Also in order not to break execution of current statement we also
-    have to backup/reset/restore Query_tables_list part of LEX, which
-    is accessed and updated in the process of opening and locking
-    tables.
-  */
-  thd->lex->reset_n_backup_query_tables_list(&query_tables_list_backup);
-  thd->reset_n_backup_open_tables_state(&m_backup);
-
-  thd->is_operating_gtid_table= true;
-  tables.init_one_table(
-      DB_NAME.str, DB_NAME.length,
-      TABLE_NAME.str, TABLE_NAME.length,
-      TABLE_NAME.str, lock_type);
-
-  tables.open_strategy= TABLE_LIST::OPEN_IF_EXISTS;
-  /* Save value that is changed in mysql_lock_tables() */
-  ulonglong save_utime_after_lock= thd->utime_after_lock;
-  if (!open_n_lock_single_table(thd, &tables, tables.lock_type, flags))
-  {
-    close_thread_tables(thd);
-    thd->restore_backup_open_tables_state(&m_backup);
-    thd->lex->restore_backup_query_tables_list(&query_tables_list_backup);
-    thd->utime_after_lock= save_utime_after_lock;
-    sql_print_warning("Gtid table is not ready to be used. Table "
-                      "'%s.%s' cannot be opened.", DB_NAME.str,
-                      TABLE_NAME.str);
-    DBUG_RETURN(true);
-  }
-  thd->utime_after_lock= save_utime_after_lock;
-
-  DBUG_ASSERT(tables.table->s->table_category == TABLE_CATEGORY_GTID);
-
-  if (tables.table->s->fields < Gtid_table_persistor::number_fields)
-  {
-    /*
-      Safety: this can only happen if someone started the server and then
-      altered the table.
-    */
-    ha_rollback_trans(thd, false);
-    close_thread_tables(thd);
-    thd->restore_backup_open_tables_state(&m_backup);
-    thd->lex->restore_backup_query_tables_list(&query_tables_list_backup);
-    my_error(ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2, MYF(0),
-             tables.table->s->db.str, tables.table->s->table_name.str,
-             Gtid_table_persistor::number_fields, tables.table->s->fields);
-    DBUG_RETURN(true);
-  }
-
-  thd->lex->restore_backup_query_tables_list(&query_tables_list_backup);
-
-  *table= tables.table;
-  tables.table->use_all_columns();
-  DBUG_RETURN(false);
-}
-
-
 int Gtid_table_persistor::fill_fields(Field **fields, const char *sid,
                                       rpl_gno gno_start, rpl_gno gno_end)
 {

sql/rpl_gtid_persist.h

@@ -19,12 +19,13 @@
 #define RPL_GTID_PERSIST_H_
 
 #include <string>
+#include "sql_base.h"
 using std::string;
 
 class Open_tables_backup;
 
 
-class Gtid_table_access_context
+class Gtid_table_access_context : public Table_access
 {
 
 public:
@@ -61,6 +62,22 @@ class Gtid_table_access_context
     @param need_commit Need to commit current transaction if it is true
   */
   void deinit(THD *thd, TABLE *table, bool error, bool need_commit);
+  /**
+    Prepares before opening table.
+    - set flags
+
+    @param[in]  thd  Thread requesting to open the table
+  */
+  void before_open(THD* thd);
+  /**
+    Creates a new thread in the bootstrap process or in the mysqld startup,
+    a thread is created in order to be able to access a table. And reset a
+    new "statement".
+
+    @return
+      @retval THD* Pointer to thread structure
+  */
+  THD *create_thd();
 private:
   /* Pointer to new created THD. */
   THD *m_drop_thd_object;
@@ -70,65 +87,7 @@ class Gtid_table_access_context
   Open_tables_backup m_backup;
   /* Save binlog options. */
   ulonglong m_tmp_disable_binlog__save_options;
-  /**
-    Creates a new thread in the bootstrap process or in the mysqld startup,
-    a thread is created in order to be able to access a table.
-
-    @return
-      @retval THD* Pointer to thread structure
-  */
-  THD *create_thd();
-  /**
-    Destroys the created thread and restores the
-    system_thread information.
-
-    @param thd Thread requesting to be destroyed
-  */
-  void drop_thd(THD *thd);
-  /**
-    Opens and locks a table.
-
-    It's assumed that the caller knows what they are doing:
-    - whether it was necessary to reset-and-backup the open tables state
-    - whether the requested lock does not lead to a deadlock
-    - whether this open mode would work under LOCK TABLES, or inside a
-    stored function or trigger.
-
-    Note that if the table can't be locked successfully this operation will
-    close it. Therefore it provides guarantee that it either opens and locks
-    table or fails without leaving any tables open.
 
-    @param      thd           Thread requesting to open the table
-    @param      lock_type     How to lock the table
-    @param[out] table         We will store the open table here
-
-    @return
-      @retval TRUE open and lock failed - an error message is pushed into the
-                                          stack
-      @retval FALSE success
-  */
-  bool open_table(THD *thd, enum thr_lock_type lock_type, TABLE **table);
-  /**
-    Commits the changes, unlocks the table and closes it. This method
-    needs to be called even if the open_table fails, in order to ensure
-    the lock info is properly restored.
-
-    @param thd    Thread requesting to close the table
-    @param table  Table to be closed
-    @param error  If there was an error while updating
-                    the table
-    @param need_commit Need to commit current transaction if
-                       it is true.
-
-    If there is an error, rolls back the current statement. Otherwise,
-    commits it. However, if a new thread was created and there is an
-    error, the transaction must be rolled back. Otherwise, it must be
-    committed. In this case, the changes were not done on behalf of
-    any user transaction and if not finished, there would be pending
-    changes.
-
-  */
-  void close_table(THD *thd, TABLE *table, bool error, bool need_commit);
   /* Prevent user from invoking default assignment function. */
   Gtid_table_access_context &operator=(const Gtid_table_access_context &info);
   /* Prevent user from invoking default constructor function. */