Renaming RELAY_LOG_INFO and st_relay_log_info to follow coding standards

(and be more friendly to Doxygen by removing unnecessary typedefs).


sql/log.cc:
  Renaming struct st_relay_log_info to class Relay_log_info.
sql/log.h:
  Renaming struct st_relay_log_info to class Relay_log_info.
sql/log_event.cc:
  Renaming RELAY_LOG_INFO to Relay_log_info.
sql/log_event.h:
  Renaming struct st_relay_log_info to class Relay_log_info.
  Renaming RELAY_LOG_INFO to Relay_log_info.
  Removing typedef RELAY_LOG_INFO.
sql/log_event_old.cc:
  Renaming RELAY_LOG_INFO to Relay_log_info.
sql/log_event_old.h:
  Renaming RELAY_LOG_INFO to Relay_log_info.
sql/rpl_mi.h:
  Renaming RELAY_LOG_INFO to Relay_log_info.
sql/rpl_record.cc:
  Renaming RELAY_LOG_INFO to Relay_log_info.
sql/rpl_record.h:
  Renaming RELAY_LOG_INFO to Relay_log_info.
sql/rpl_record_old.cc:
  Renaming RELAY_LOG_INFO to Relay_log_info.
sql/rpl_record_old.h:
  Renaming RELAY_LOG_INFO to Relay_log_info.
sql/rpl_rli.cc:
  Renaming struct st_relay_log_info to class Relay_log_info.
  Renaming RELAY_LOG_INFO to Relay_log_info.
sql/rpl_rli.h:
  Renaming struct st_relay_log_info to class Relay_log_info.
  Renaming RELAY_LOG_INFO to Relay_log_info.
  Removing typedef RELAY_LOG_INFO.
sql/rpl_utility.cc:
  Renaming RELAY_LOG_INFO to Relay_log_info.
sql/rpl_utility.h:
  Renaming struct st_relay_log_info to class Relay_log_info.
  Renaming RELAY_LOG_INFO to Relay_log_info.
  Removing typedef RELAY_LOG_INFO.
sql/slave.cc:
  Renaming RELAY_LOG_INFO to Relay_log_info.
sql/slave.h:
  Renaming struct st_relay_log_info to class Relay_log_info.
  Renaming RELAY_LOG_INFO to Relay_log_info.
  Removing typedef RELAY_LOG_INFO.
sql/sql_binlog.cc:
  Renaming RELAY_LOG_INFO to Relay_log_info.
sql/sql_class.h:
  Renaming struct st_relay_log_info to class Relay_log_info.
  Renaming RELAY_LOG_INFO to Relay_log_info.
  Removing typedef RELAY_LOG_INFO.
sql/sql_repl.cc:
  Renaming RELAY_LOG_INFO to Relay_log_info.

sql/log.cc

@@ -2745,7 +2745,7 @@ bool MYSQL_BIN_LOG::reset_logs(THD* thd)
 
 #ifdef HAVE_REPLICATION
 
-int MYSQL_BIN_LOG::purge_first_log(struct st_relay_log_info* rli, bool included) 
+int MYSQL_BIN_LOG::purge_first_log(Relay_log_info* rli, bool included)
 {
   int error;
   DBUG_ENTER("purge_first_log");

sql/log.h

@@ -16,7 +16,7 @@
 #ifndef LOG_H
 #define LOG_H
 
-struct st_relay_log_info;
+class Relay_log_info;
 
 class Format_description_log_event;
 
@@ -121,7 +121,7 @@ extern TC_LOG_DUMMY tc_log_dummy;
 #define LOG_CLOSE_TO_BE_OPENED	2
 #define LOG_CLOSE_STOP_EVENT	4
 
-struct st_relay_log_info;
+class Relay_log_info;
 
 typedef struct st_log_info
 {
@@ -362,7 +362,7 @@ class MYSQL_BIN_LOG: public TC_LOG, private MYSQL_LOG
                  bool need_mutex, bool need_update_threads,
                  ulonglong *decrease_log_space);
   int purge_logs_before_date(time_t purge_time);
-  int purge_first_log(struct st_relay_log_info* rli, bool included);
+  int purge_first_log(Relay_log_info* rli, bool included);
   bool reset_logs(THD* thd);
   void close(uint exiting);
 

sql/log_event_old.cc

@@ -6,7 +6,7 @@
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 int
 Write_rows_log_event_old::do_prepare_row(THD *thd,
-                                         RELAY_LOG_INFO const *rli,
+                                         Relay_log_info const *rli,
                                          TABLE *table,
                                          uchar const *row_start,
                                          uchar const **row_end)
@@ -15,7 +15,7 @@ Write_rows_log_event_old::do_prepare_row(THD *thd,
   DBUG_ASSERT(row_start && row_end);
 
   int error;
-  error= unpack_row_old(const_cast<RELAY_LOG_INFO*>(rli),
+  error= unpack_row_old(const_cast<Relay_log_info*>(rli),
                         table, m_width, table->record[0],
                         row_start, &m_cols, row_end, &m_master_reclength,
                         table->write_set, PRE_GA_WRITE_ROWS_EVENT);
@@ -26,7 +26,7 @@ Write_rows_log_event_old::do_prepare_row(THD *thd,
 
 int
 Delete_rows_log_event_old::do_prepare_row(THD *thd,
-                                          RELAY_LOG_INFO const *rli,
+                                          Relay_log_info const *rli,
                                           TABLE *table,
                                           uchar const *row_start,
                                           uchar const **row_end)
@@ -39,7 +39,7 @@ Delete_rows_log_event_old::do_prepare_row(THD *thd,
   */
   DBUG_ASSERT(table->s->fields >= m_width);
 
-  error= unpack_row_old(const_cast<RELAY_LOG_INFO*>(rli),
+  error= unpack_row_old(const_cast<Relay_log_info*>(rli),
                         table, m_width, table->record[0],
                         row_start, &m_cols, row_end, &m_master_reclength,
                         table->read_set, PRE_GA_DELETE_ROWS_EVENT);
@@ -59,7 +59,7 @@ Delete_rows_log_event_old::do_prepare_row(THD *thd,
 
 
 int Update_rows_log_event_old::do_prepare_row(THD *thd,
-                                              RELAY_LOG_INFO const *rli,
+                                              Relay_log_info const *rli,
                                               TABLE *table,
                                               uchar const *row_start,
                                               uchar const **row_end)
@@ -73,13 +73,13 @@ int Update_rows_log_event_old::do_prepare_row(THD *thd,
   DBUG_ASSERT(table->s->fields >= m_width);
 
   /* record[0] is the before image for the update */
-  error= unpack_row_old(const_cast<RELAY_LOG_INFO*>(rli),
+  error= unpack_row_old(const_cast<Relay_log_info*>(rli),
                         table, m_width, table->record[0],
                         row_start, &m_cols, row_end, &m_master_reclength,
                         table->read_set, PRE_GA_UPDATE_ROWS_EVENT);
   row_start = *row_end;
   /* m_after_image is the after image for the update */
-  error= unpack_row_old(const_cast<RELAY_LOG_INFO*>(rli),
+  error= unpack_row_old(const_cast<Relay_log_info*>(rli),
                         table, m_width, m_after_image,
                         row_start, &m_cols, row_end, &m_master_reclength,
                         table->write_set, PRE_GA_UPDATE_ROWS_EVENT);

sql/log_event_old.h

@@ -49,7 +49,7 @@ class Write_rows_log_event_old : public Write_rows_log_event
   virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }
 
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
-  virtual int do_prepare_row(THD*, RELAY_LOG_INFO const*, TABLE*,
+  virtual int do_prepare_row(THD*, Relay_log_info const*, TABLE*,
                              uchar const *row_start, uchar const **row_end);
 #endif
 };
@@ -83,7 +83,7 @@ class Update_rows_log_event_old : public Update_rows_log_event
   virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }
 
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
-  virtual int do_prepare_row(THD*, RELAY_LOG_INFO const*, TABLE*,
+  virtual int do_prepare_row(THD*, Relay_log_info const*, TABLE*,
                              uchar const *row_start, uchar const **row_end);
 #endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
 };
@@ -117,7 +117,7 @@ class Delete_rows_log_event_old : public Delete_rows_log_event
   virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }
 
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
-  virtual int do_prepare_row(THD*, RELAY_LOG_INFO const*, TABLE*,
+  virtual int do_prepare_row(THD*, Relay_log_info const*, TABLE*,
                              uchar const *row_start, uchar const **row_end);
 #endif
 };

sql/rpl_mi.h

@@ -80,7 +80,7 @@ class MASTER_INFO : public Slave_reporting_capability
   THD *io_thd;
   MYSQL* mysql;
   uint32 file_id;				/* for 3.23 load data infile */
-  RELAY_LOG_INFO rli;
+  Relay_log_info rli;
   uint port;
   uint connect_retry;
 #ifndef DBUG_OFF

sql/rpl_record.cc

@@ -188,7 +188,7 @@ pack_row(TABLE *table, MY_BITMAP const* cols,
  */
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 int
-unpack_row(RELAY_LOG_INFO const *rli,
+unpack_row(Relay_log_info const *rli,
            TABLE *table, uint const colcnt,
            uchar const *const row_data, MY_BITMAP const *cols,
            uchar const **const row_end, ulong *const master_reclength,
@@ -217,7 +217,7 @@ unpack_row(RELAY_LOG_INFO const *rli,
   // The "current" null bits
   unsigned int null_bits= *null_ptr++;
   uint i= 0;
-  table_def *tabledef= ((RELAY_LOG_INFO*)rli)->get_tabledef(table);
+  table_def *tabledef= ((Relay_log_info*)rli)->get_tabledef(table);
   for (field_ptr= begin_ptr ; field_ptr < end_ptr && *field_ptr ; ++field_ptr)
   {
     Field *const f= *field_ptr;

sql/rpl_record.h

@@ -22,7 +22,7 @@ size_t pack_row(TABLE* table, MY_BITMAP const* cols,
 #endif
 
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
-int unpack_row(RELAY_LOG_INFO const *rli,
+int unpack_row(Relay_log_info const *rli,
                TABLE *table, uint const colcnt,
                uchar const *const row_data, MY_BITMAP const *cols,
                uchar const **const row_end, ulong *const master_reclength,

sql/rpl_record_old.cc

@@ -70,7 +70,7 @@ pack_row_old(TABLE *table, MY_BITMAP const* cols,
  */
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 int
-unpack_row_old(RELAY_LOG_INFO *rli,
+unpack_row_old(Relay_log_info *rli,
                TABLE *table, uint const colcnt, uchar *record,
                uchar const *row, MY_BITMAP const *cols,
                uchar const **row_end, ulong *master_reclength,

sql/rpl_record_old.h

@@ -21,7 +21,7 @@ size_t pack_row_old(TABLE *table, MY_BITMAP const* cols,
                     uchar *row_data, const uchar *record);
 
 #ifdef HAVE_REPLICATION
-int unpack_row_old(RELAY_LOG_INFO *rli,
+int unpack_row_old(Relay_log_info *rli,
                    TABLE *table, uint const colcnt, uchar *record,
                    uchar const *row, MY_BITMAP const *cols,
                    uchar const **row_end, ulong *master_reclength,

sql/rpl_rli.cc

@@ -21,7 +21,7 @@
 #include "sql_repl.h"  // For check_binlog_magic
 #include "rpl_utility.h"
 
-static int count_relay_log_space(RELAY_LOG_INFO* rli);
+static int count_relay_log_space(Relay_log_info* rli);
 
 // Defined in slave.cc
 int init_intvar_from_file(int* var, IO_CACHE* f, int default_val);
@@ -29,7 +29,7 @@ int init_strvar_from_file(char *var, int max_size, IO_CACHE *f,
 			  const char *default_val);
 
 
-st_relay_log_info::st_relay_log_info()
+Relay_log_info::Relay_log_info()
   :Slave_reporting_capability("SQL"),
    no_storage(FALSE), replicate_same_server_id(::replicate_same_server_id),
    info_fd(-1), cur_log_fd(-1), save_temporary_tables(0),
@@ -41,7 +41,7 @@ st_relay_log_info::st_relay_log_info()
    tables_to_lock(0), tables_to_lock_count(0),
    last_event_start_time(0), m_flags(0)
 {
-  DBUG_ENTER("st_relay_log_info::st_relay_log_info");
+  DBUG_ENTER("Relay_log_info::Relay_log_info");
 
   group_relay_log_name[0]= event_relay_log_name[0]=
     group_master_log_name[0]= 0;
@@ -61,9 +61,9 @@ st_relay_log_info::st_relay_log_info()
 }
 
 
-st_relay_log_info::~st_relay_log_info()
+Relay_log_info::~Relay_log_info()
 {
-  DBUG_ENTER("st_relay_log_info::~st_relay_log_info");
+  DBUG_ENTER("Relay_log_info::~Relay_log_info");
 
   pthread_mutex_destroy(&run_lock);
   pthread_mutex_destroy(&data_lock);
@@ -77,7 +77,7 @@ st_relay_log_info::~st_relay_log_info()
 }
 
 
-int init_relay_log_info(RELAY_LOG_INFO* rli,
+int init_relay_log_info(Relay_log_info* rli,
 			const char* info_fname)
 {
   char fname[FN_REFLEN+128];
@@ -294,7 +294,7 @@ Failed to open the existing relay log info file '%s' (errno %d)",
 }
 
 
-static inline int add_relay_log(RELAY_LOG_INFO* rli,LOG_INFO* linfo)
+static inline int add_relay_log(Relay_log_info* rli,LOG_INFO* linfo)
 {
   MY_STAT s;
   DBUG_ENTER("add_relay_log");
@@ -313,7 +313,7 @@ static inline int add_relay_log(RELAY_LOG_INFO* rli,LOG_INFO* linfo)
 }
 
 
-static int count_relay_log_space(RELAY_LOG_INFO* rli)
+static int count_relay_log_space(Relay_log_info* rli)
 {
   LOG_INFO linfo;
   DBUG_ENTER("count_relay_log_space");
@@ -339,18 +339,18 @@ static int count_relay_log_space(RELAY_LOG_INFO* rli)
 
 
 /*
-   Reset UNTIL condition for RELAY_LOG_INFO
+   Reset UNTIL condition for Relay_log_info
 
    SYNOPSYS
     clear_until_condition()
-      rli - RELAY_LOG_INFO structure where UNTIL condition should be reset
+      rli - Relay_log_info structure where UNTIL condition should be reset
  */
 
-void st_relay_log_info::clear_until_condition()
+void Relay_log_info::clear_until_condition()
 {
   DBUG_ENTER("clear_until_condition");
 
-  until_condition= RELAY_LOG_INFO::UNTIL_NONE;
+  until_condition= Relay_log_info::UNTIL_NONE;
   until_log_name[0]= 0;
   until_log_pos= 0;
   DBUG_VOID_RETURN;
@@ -389,7 +389,7 @@ void st_relay_log_info::clear_until_condition()
     1   error.  errmsg is set to point to the error message
 */
 
-int init_relay_log_pos(RELAY_LOG_INFO* rli,const char* log,
+int init_relay_log_pos(Relay_log_info* rli,const char* log,
                        ulonglong pos, bool need_data_lock,
                        const char** errmsg,
                        bool look_for_description_event)
@@ -599,7 +599,7 @@ int init_relay_log_pos(RELAY_LOG_INFO* rli,const char* log,
                 before reaching the desired log/position
  */
 
-int st_relay_log_info::wait_for_pos(THD* thd, String* log_name,
+int Relay_log_info::wait_for_pos(THD* thd, String* log_name,
                                     longlong log_pos,
                                     longlong timeout)
 {
@@ -608,7 +608,7 @@ int st_relay_log_info::wait_for_pos(THD* thd, String* log_name,
   int error=0;
   struct timespec abstime; // for timeout checking
   const char *msg;
-  DBUG_ENTER("st_relay_log_info::wait_for_pos");
+  DBUG_ENTER("Relay_log_info::wait_for_pos");
 
   if (!inited)
     DBUG_RETURN(-1);
@@ -779,10 +779,10 @@ improper_arguments: %d  timed_out: %d",
 }
 
 
-void st_relay_log_info::inc_group_relay_log_pos(ulonglong log_pos,
+void Relay_log_info::inc_group_relay_log_pos(ulonglong log_pos,
                                                 bool skip_lock)
 {
-  DBUG_ENTER("st_relay_log_info::inc_group_relay_log_pos");
+  DBUG_ENTER("Relay_log_info::inc_group_relay_log_pos");
 
   if (!skip_lock)
     pthread_mutex_lock(&data_lock);
@@ -836,10 +836,10 @@ void st_relay_log_info::inc_group_relay_log_pos(ulonglong log_pos,
 }
 
 
-void st_relay_log_info::close_temporary_tables()
+void Relay_log_info::close_temporary_tables()
 {
   TABLE *table,*next;
-  DBUG_ENTER("st_relay_log_info::close_temporary_tables");
+  DBUG_ENTER("Relay_log_info::close_temporary_tables");
 
   for (table=save_temporary_tables ; table ; table=next)
   {
@@ -863,7 +863,7 @@ void st_relay_log_info::close_temporary_tables()
     Assumes to have a run lock on rli and that no slave thread are running.
 */
 
-int purge_relay_logs(RELAY_LOG_INFO* rli, THD *thd, bool just_reset,
+int purge_relay_logs(Relay_log_info* rli, THD *thd, bool just_reset,
                      const char** errmsg)
 {
   int error=0;
@@ -950,12 +950,12 @@ int purge_relay_logs(RELAY_LOG_INFO* rli, THD *thd, bool just_reset,
 /*
      Check if condition stated in UNTIL clause of START SLAVE is reached.
    SYNOPSYS
-     st_relay_log_info::is_until_satisfied()
+     Relay_log_info::is_until_satisfied()
    DESCRIPTION
      Checks if UNTIL condition is reached. Uses caching result of last
      comparison of current log file name and target log file name. So cached
      value should be invalidated if current log file name changes
-     (see st_relay_log_info::notify_... functions).
+     (see Relay_log_info::notify_... functions).
 
      This caching is needed to avoid of expensive string comparisons and
      strtol() conversions needed for log names comparison. We don't need to
@@ -975,11 +975,11 @@ int purge_relay_logs(RELAY_LOG_INFO* rli, THD *thd, bool just_reset,
      false - condition not met
 */
 
-bool st_relay_log_info::is_until_satisfied()
+bool Relay_log_info::is_until_satisfied()
 {
   const char *log_name;
   ulonglong log_pos;
-  DBUG_ENTER("st_relay_log_info::is_until_satisfied");
+  DBUG_ENTER("Relay_log_info::is_until_satisfied");
 
   DBUG_ASSERT(until_condition != UNTIL_NONE);
 
@@ -1055,9 +1055,9 @@ bool st_relay_log_info::is_until_satisfied()
 }
 
 
-void st_relay_log_info::cached_charset_invalidate()
+void Relay_log_info::cached_charset_invalidate()
 {
-  DBUG_ENTER("st_relay_log_info::cached_charset_invalidate");
+  DBUG_ENTER("Relay_log_info::cached_charset_invalidate");
 
   /* Full of zeroes means uninitialized. */
   bzero(cached_charset, sizeof(cached_charset));
@@ -1065,9 +1065,9 @@ void st_relay_log_info::cached_charset_invalidate()
 }
 
 
-bool st_relay_log_info::cached_charset_compare(char *charset) const
+bool Relay_log_info::cached_charset_compare(char *charset) const
 {
-  DBUG_ENTER("st_relay_log_info::cached_charset_compare");
+  DBUG_ENTER("Relay_log_info::cached_charset_compare");
 
   if (bcmp((uchar*) cached_charset, (uchar*) charset,
            sizeof(cached_charset)))
@@ -1079,7 +1079,7 @@ bool st_relay_log_info::cached_charset_compare(char *charset) const
 }
 
 
-void st_relay_log_info::stmt_done(my_off_t event_master_log_pos,
+void Relay_log_info::stmt_done(my_off_t event_master_log_pos,
                                   time_t event_creation_time)
 {
   clear_flag(IN_STMT);
@@ -1126,9 +1126,9 @@ void st_relay_log_info::stmt_done(my_off_t event_master_log_pos,
 }
 
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
-void st_relay_log_info::cleanup_context(THD *thd, bool error)
+void Relay_log_info::cleanup_context(THD *thd, bool error)
 {
-  DBUG_ENTER("st_relay_log_info::cleanup_context");
+  DBUG_ENTER("Relay_log_info::cleanup_context");
 
   DBUG_ASSERT(sql_thd == thd);
   /*
@@ -1156,7 +1156,7 @@ void st_relay_log_info::cleanup_context(THD *thd, bool error)
   DBUG_VOID_RETURN;
 }
 
-void st_relay_log_info::clear_tables_to_lock()
+void Relay_log_info::clear_tables_to_lock()
 {
   while (tables_to_lock)
   {

sql/rpl_rli.h

@@ -27,16 +27,16 @@ struct RPL_TABLE_LIST;
 
   Replication SQL Thread
 
-  st_relay_log_info contains:
+  Relay_log_info contains:
     - the current relay log
     - the current relay log offset
     - master log name
     - master log sequence corresponding to the last update
     - misc information specific to the SQL thread
 
-  st_relay_log_info is initialized from the slave.info file if such exists.
-  Otherwise, data members are intialized with defaults. The initialization is
-  done with init_relay_log_info() call.
+  Relay_log_info is initialized from the slave.info file if such
+  exists.  Otherwise, data members are intialized with defaults. The
+  initialization is done with init_relay_log_info() call.
 
   The format of slave.info file:
 
@@ -49,8 +49,9 @@ struct RPL_TABLE_LIST;
 
 *****************************************************************************/
 
-typedef struct st_relay_log_info : public Slave_reporting_capability
+class Relay_log_info : public Slave_reporting_capability
 {
+public:
   /**
      Flags for the state of the replication.
    */
@@ -255,8 +256,8 @@ typedef struct st_relay_log_info : public Slave_reporting_capability
   char ign_master_log_name_end[FN_REFLEN];
   ulonglong ign_master_log_pos_end;
 
-  st_relay_log_info();
-  ~st_relay_log_info();
+  Relay_log_info();
+  ~Relay_log_info();
 
   /*
     Invalidate cached until_log_name and group_relay_log_name comparison 
@@ -391,11 +392,11 @@ typedef struct st_relay_log_info : public Slave_reporting_capability
 
 private:
   uint32 m_flags;
-} RELAY_LOG_INFO;
+};
 
 
 // Defined in rpl_rli.cc
-int init_relay_log_info(RELAY_LOG_INFO* rli, const char* info_fname);
+int init_relay_log_info(Relay_log_info* rli, const char* info_fname);
 
 
 #endif /* RPL_RLI_H */

sql/rpl_utility.cc

@@ -164,7 +164,7 @@ uint32 table_def::calc_field_size(uint col, uchar *master_data)
 
 */
 int
-table_def::compatible_with(RELAY_LOG_INFO const *rli_arg, TABLE *table)
+table_def::compatible_with(Relay_log_info const *rli_arg, TABLE *table)
   const
 {
   /*
@@ -172,7 +172,7 @@ table_def::compatible_with(RELAY_LOG_INFO const *rli_arg, TABLE *table)
   */
   uint const cols_to_check= min(table->s->fields, size());
   int error= 0;
-  RELAY_LOG_INFO const *rli= const_cast<RELAY_LOG_INFO*>(rli_arg);
+  Relay_log_info const *rli= const_cast<Relay_log_info*>(rli_arg);
 
   TABLE_SHARE const *const tsh= table->s;
 

sql/rpl_utility.h

@@ -22,8 +22,7 @@
 
 #include "mysql_priv.h"
 
-struct st_relay_log_info;
-typedef st_relay_log_info RELAY_LOG_INFO;
+class Relay_log_info;
 
 
 /**
@@ -237,7 +236,7 @@ class table_def
     @retval 1  if the table definition is not compatible with @c table
     @retval 0  if the table definition is compatible with @c table
   */
-  int compatible_with(RELAY_LOG_INFO const *rli, TABLE *table) const;
+  int compatible_with(Relay_log_info const *rli, TABLE *table) const;
 
 private:
   ulong m_size;           // Number of elements in the types array

sql/slave.cc

@@ -34,7 +34,7 @@
 #include "rpl_tblmap.h"
 
 int queue_event(MASTER_INFO* mi,const char* buf,ulong event_len);
-static Log_event* next_event(RELAY_LOG_INFO* rli);
+static Log_event* next_event(Relay_log_info* rli);
 
 
 #define FLAGSTR(V,F) ((V)&(F)?#F" ":"")
@@ -116,9 +116,9 @@ typedef enum { SLAVE_THD_IO, SLAVE_THD_SQL} SLAVE_THD_TYPE;
 
 static int process_io_rotate(MASTER_INFO* mi, Rotate_log_event* rev);
 static int process_io_create_file(MASTER_INFO* mi, Create_file_log_event* cev);
-static bool wait_for_relay_log_space(RELAY_LOG_INFO* rli);
+static bool wait_for_relay_log_space(Relay_log_info* rli);
 static inline bool io_slave_killed(THD* thd,MASTER_INFO* mi);
-static inline bool sql_slave_killed(THD* thd,RELAY_LOG_INFO* rli);
+static inline bool sql_slave_killed(THD* thd,Relay_log_info* rli);
 static int init_slave_thread(THD* thd, SLAVE_THD_TYPE thd_type);
 static int safe_connect(THD* thd, MYSQL* mysql, MASTER_INFO* mi);
 static int safe_reconnect(THD* thd, MYSQL* mysql, MASTER_INFO* mi,
@@ -131,7 +131,7 @@ static int request_table_dump(MYSQL* mysql, const char* db, const char* table);
 static int create_table_from_dump(THD* thd, MYSQL *mysql, const char* db,
                                   const char* table_name, bool overwrite);
 static int get_master_version_and_clock(MYSQL* mysql, MASTER_INFO* mi);
-static Log_event* next_event(RELAY_LOG_INFO* rli);
+static Log_event* next_event(Relay_log_info* rli);
 
 /*
   Find out which replications threads are running
@@ -559,7 +559,7 @@ static bool io_slave_killed(THD* thd, MASTER_INFO* mi)
 }
 
 
-static bool sql_slave_killed(THD* thd, RELAY_LOG_INFO* rli)
+static bool sql_slave_killed(THD* thd, Relay_log_info* rli)
 {
   DBUG_ENTER("sql_slave_killed");
 
@@ -1073,7 +1073,7 @@ int fetch_master_table(THD *thd, const char *db_name, const char *table_name,
 }
 
 
-static bool wait_for_relay_log_space(RELAY_LOG_INFO* rli)
+static bool wait_for_relay_log_space(Relay_log_info* rli)
 {
   bool slave_killed=0;
   MASTER_INFO* mi = rli->mi;
@@ -1110,7 +1110,7 @@ Waiting for the slave SQL thread to free enough relay log space");
  */
 static void write_ignored_events_info_to_relay_log(THD *thd, MASTER_INFO *mi)
 {
-  RELAY_LOG_INFO *rli= &mi->rli;
+  Relay_log_info *rli= &mi->rli;
   pthread_mutex_t *log_lock= rli->relay_log.get_log_lock();
   DBUG_ENTER("write_ignored_events_info_to_relay_log");
 
@@ -1322,8 +1322,8 @@ bool show_master_info(THD* thd, MASTER_INFO* mi)
     protocol->store((ulonglong) mi->rli.log_space_total);
 
     protocol->store(
-      mi->rli.until_condition==RELAY_LOG_INFO::UNTIL_NONE ? "None":
-        ( mi->rli.until_condition==RELAY_LOG_INFO::UNTIL_MASTER_POS? "Master":
+      mi->rli.until_condition==Relay_log_info::UNTIL_NONE ? "None":
+        ( mi->rli.until_condition==Relay_log_info::UNTIL_MASTER_POS? "Master":
           "Relay"), &my_charset_bin);
     protocol->store(mi->rli.until_log_name, &my_charset_bin);
     protocol->store((ulonglong) mi->rli.until_log_pos);
@@ -1419,7 +1419,7 @@ void set_slave_thread_options(THD* thd)
   DBUG_VOID_RETURN;
 }
 
-void set_slave_thread_default_charset(THD* thd, RELAY_LOG_INFO const *rli)
+void set_slave_thread_default_charset(THD* thd, Relay_log_info const *rli)
 {
   DBUG_ENTER("set_slave_thread_default_charset");
 
@@ -1437,7 +1437,7 @@ void set_slave_thread_default_charset(THD* thd, RELAY_LOG_INFO const *rli)
     the thread.  That the cache has to be invalidated is a secondary
     effect.
    */
-  const_cast<RELAY_LOG_INFO*>(rli)->cached_charset_invalidate();
+  const_cast<Relay_log_info*>(rli)->cached_charset_invalidate();
   DBUG_VOID_RETURN;
 }
 
@@ -1646,7 +1646,7 @@ static ulong read_event(MYSQL* mysql, MASTER_INFO *mi, bool* suppress_warnings)
 }
 
 
-int check_expected_error(THD* thd, RELAY_LOG_INFO const *rli,
+int check_expected_error(THD* thd, Relay_log_info const *rli,
                          int expected_error)
 {
   DBUG_ENTER("check_expected_error");
@@ -1708,7 +1708,7 @@ static int has_temporary_error(THD *thd)
   DBUG_RETURN(0);
 }
 
-static int exec_relay_log_event(THD* thd, RELAY_LOG_INFO* rli)
+static int exec_relay_log_event(THD* thd, Relay_log_info* rli)
 {
   DBUG_ENTER("exec_relay_log_event");
 
@@ -1726,7 +1726,7 @@ static int exec_relay_log_event(THD* thd, RELAY_LOG_INFO* rli)
     was an event ignored by the I/O thread just before (BUG#13861 to be
     fixed).
   */
-  if (rli->until_condition!=RELAY_LOG_INFO::UNTIL_NONE &&
+  if (rli->until_condition!=Relay_log_info::UNTIL_NONE &&
       rli->is_until_satisfied())
   {
     char buf[22];
@@ -2038,7 +2038,7 @@ pthread_handler_t handle_slave_io(void *arg)
   THD *thd; // needs to be first for thread_stack
   MYSQL *mysql;
   MASTER_INFO *mi = (MASTER_INFO*)arg;
-  RELAY_LOG_INFO *rli= &mi->rli;
+  Relay_log_info *rli= &mi->rli;
   char llbuff[22];
   uint retry_count;
   bool suppress_warnings;
@@ -2343,7 +2343,7 @@ pthread_handler_t handle_slave_sql(void *arg)
   THD *thd;                     /* needs to be first for thread_stack */
   char llbuff[22],llbuff1[22];
 
-  RELAY_LOG_INFO* rli = &((MASTER_INFO*)arg)->rli;
+  Relay_log_info* rli = &((MASTER_INFO*)arg)->rli;
   const char *errmsg;
 
   // needs to call my_thread_init(), otherwise we get a coredump in DBUG_ stuff
@@ -2794,7 +2794,7 @@ static int queue_binlog_ver_1_event(MASTER_INFO *mi, const char *buf,
   ulong inc_pos;
   bool ignore_event= 0;
   char *tmp_buf = 0;
-  RELAY_LOG_INFO *rli= &mi->rli;
+  Relay_log_info *rli= &mi->rli;
   DBUG_ENTER("queue_binlog_ver_1_event");
 
   /*
@@ -2911,7 +2911,7 @@ static int queue_binlog_ver_3_event(MASTER_INFO *mi, const char *buf,
   const char *errmsg = 0;
   ulong inc_pos;
   char *tmp_buf = 0;
-  RELAY_LOG_INFO *rli= &mi->rli;
+  Relay_log_info *rli= &mi->rli;
   DBUG_ENTER("queue_binlog_ver_3_event");
 
   /* read_log_event() will adjust log_pos to be end_log_pos */
@@ -3001,7 +3001,7 @@ int queue_event(MASTER_INFO* mi,const char* buf, ulong event_len)
 {
   int error= 0;
   ulong inc_pos;
-  RELAY_LOG_INFO *rli= &mi->rli;
+  Relay_log_info *rli= &mi->rli;
   pthread_mutex_t *log_lock= rli->relay_log.get_log_lock();
   DBUG_ENTER("queue_event");
 
@@ -3153,7 +3153,7 @@ int queue_event(MASTER_INFO* mi,const char* buf, ulong event_len)
 }
 
 
-void end_relay_log_info(RELAY_LOG_INFO* rli)
+void end_relay_log_info(Relay_log_info* rli)
 {
   DBUG_ENTER("end_relay_log_info");
 
@@ -3357,7 +3357,7 @@ static int safe_reconnect(THD* thd, MYSQL* mysql, MASTER_INFO* mi,
     1   write error
 */
 
-bool flush_relay_log_info(RELAY_LOG_INFO* rli)
+bool flush_relay_log_info(Relay_log_info* rli)
 {
   bool error=0;
   DBUG_ENTER("flush_relay_log_info");
@@ -3391,7 +3391,7 @@ bool flush_relay_log_info(RELAY_LOG_INFO* rli)
   Called when we notice that the current "hot" log got rotated under our feet.
 */
 
-static IO_CACHE *reopen_relay_log(RELAY_LOG_INFO *rli, const char **errmsg)
+static IO_CACHE *reopen_relay_log(Relay_log_info *rli, const char **errmsg)
 {
   DBUG_ENTER("reopen_relay_log");
   DBUG_ASSERT(rli->cur_log != &rli->cache_buf);
@@ -3412,7 +3412,7 @@ static IO_CACHE *reopen_relay_log(RELAY_LOG_INFO *rli, const char **errmsg)
 }
 
 
-static Log_event* next_event(RELAY_LOG_INFO* rli)
+static Log_event* next_event(Relay_log_info* rli)
 {
   Log_event* ev;
   IO_CACHE* cur_log = rli->cur_log;
@@ -3604,10 +3604,10 @@ static Log_event* next_event(RELAY_LOG_INFO* rli)
         // prevent the I/O thread from blocking next times
         rli->ignore_log_space_limit= 1;
         /*
-          If the I/O thread is blocked, unblock it.
-          Ok to broadcast after unlock, because the mutex is only destroyed in
-          ~st_relay_log_info(), i.e. when rli is destroyed, and rli will not be
-          destroyed before we exit the present function.
+          If the I/O thread is blocked, unblock it.  Ok to broadcast
+          after unlock, because the mutex is only destroyed in
+          ~Relay_log_info(), i.e. when rli is destroyed, and rli will
+          not be destroyed before we exit the present function.
         */
         pthread_mutex_unlock(&rli->log_space_lock);
         pthread_cond_broadcast(&rli->log_space_cond);
@@ -3767,7 +3767,7 @@ event(errno: %d  cur_log->error: %d)",
 void rotate_relay_log(MASTER_INFO* mi)
 {
   DBUG_ENTER("rotate_relay_log");
-  RELAY_LOG_INFO* rli= &mi->rli;
+  Relay_log_info* rli= &mi->rli;
 
   /* We don't lock rli->run_lock. This would lead to deadlocks. */
   pthread_mutex_lock(&mi->run_lock);
@@ -3808,11 +3808,11 @@ void rotate_relay_log(MASTER_INFO* mi)
 /**
    Detects, based on master's version (as found in the relay log), if master
    has a certain bug.
-   @param rli RELAY_LOG_INFO which tells the master's version
+   @param rli Relay_log_info which tells the master's version
    @param bug_id Number of the bug as found in bugs.mysql.com
    @return TRUE if master has the bug, FALSE if it does not.
 */
-bool rpl_master_has_bug(RELAY_LOG_INFO *rli, uint bug_id)
+bool rpl_master_has_bug(Relay_log_info *rli, uint bug_id)
 {
   struct st_version_range_for_one_bug {
     uint        bug_id;

sql/slave.h

@@ -29,11 +29,10 @@
 
 
 // Forward declarations
-struct st_relay_log_info;
-typedef st_relay_log_info RELAY_LOG_INFO;
-
+class Relay_log_info;
 class MASTER_INFO;
 
+
 /*****************************************************************************
 
   MySQL Replication
@@ -47,7 +46,7 @@ class MASTER_INFO;
                  represents each of these threads.
 
     SQL Thread - One of these threads is started and reads from the relay log
-                 file, executing each event.  A RELAY_LOG_INFO 
+                 file, executing each event.  A Relay_log_info 
                  represents this thread.
 
   Buffering in the relay log file makes it unnecessary to reread events from
@@ -80,7 +79,7 @@ class MASTER_INFO;
   data_lock protects some moving members of the struct: counters (log name,
   position) and relay log (MYSQL_BIN_LOG object).
 
-  In RELAY_LOG_INFO: run_lock, data_lock
+  In Relay_log_info: run_lock, data_lock
   see MASTER_INFO
   
   Order of acquisition: if you want to have LOCK_active_mi and a run_lock, you
@@ -103,11 +102,11 @@ extern ulonglong relay_log_space_limit;
 
 /*
   3 possible values for MASTER_INFO::slave_running and
-  RELAY_LOG_INFO::slave_running.
+  Relay_log_info::slave_running.
   The values 0,1,2 are very important: to keep the diff small, I didn't
   substitute places where we use 0/1 with the newly defined symbols. So don't change
   these values.
-  The same way, code is assuming that in RELAY_LOG_INFO we use only values
+  The same way, code is assuming that in Relay_log_info we use only values
   0/1.
   I started with using an enum, but
   enum_variable=1; is not legal so would have required many line changes.
@@ -129,7 +128,7 @@ extern ulonglong relay_log_space_limit;
 
 int init_slave();
 void init_slave_skip_errors(const char* arg);
-bool flush_relay_log_info(RELAY_LOG_INFO* rli);
+bool flush_relay_log_info(Relay_log_info* rli);
 int register_slave_on_master(MYSQL* mysql);
 int terminate_slave_threads(MASTER_INFO* mi, int thread_mask,
 			     bool skip_lock = 0);
@@ -164,27 +163,27 @@ int fetch_master_table(THD* thd, const char* db_name, const char* table_name,
 
 bool show_master_info(THD* thd, MASTER_INFO* mi);
 bool show_binlog_info(THD* thd);
-bool rpl_master_has_bug(RELAY_LOG_INFO *rli, uint bug_id);
+bool rpl_master_has_bug(Relay_log_info *rli, uint bug_id);
 
 const char *print_slave_db_safe(const char *db);
-int check_expected_error(THD* thd, RELAY_LOG_INFO const *rli, int error_code);
+int check_expected_error(THD* thd, Relay_log_info const *rli, int error_code);
 void skip_load_data_infile(NET* net);
 
 void end_slave(); /* clean up */
-void clear_until_condition(RELAY_LOG_INFO* rli);
-void clear_slave_error(RELAY_LOG_INFO* rli);
-void end_relay_log_info(RELAY_LOG_INFO* rli);
+void clear_until_condition(Relay_log_info* rli);
+void clear_slave_error(Relay_log_info* rli);
+void end_relay_log_info(Relay_log_info* rli);
 void lock_slave_threads(MASTER_INFO* mi);
 void unlock_slave_threads(MASTER_INFO* mi);
 void init_thread_mask(int* mask,MASTER_INFO* mi,bool inverse);
-int init_relay_log_pos(RELAY_LOG_INFO* rli,const char* log,ulonglong pos,
+int init_relay_log_pos(Relay_log_info* rli,const char* log,ulonglong pos,
 		       bool need_data_lock, const char** errmsg,
                        bool look_for_description_event);
 
-int purge_relay_logs(RELAY_LOG_INFO* rli, THD *thd, bool just_reset,
+int purge_relay_logs(Relay_log_info* rli, THD *thd, bool just_reset,
 		     const char** errmsg);
 void set_slave_thread_options(THD* thd);
-void set_slave_thread_default_charset(THD *thd, RELAY_LOG_INFO const *rli);
+void set_slave_thread_default_charset(THD *thd, Relay_log_info const *rli);
 void rotate_relay_log(MASTER_INFO* mi);
 
 pthread_handler_t handle_slave_io(void *arg);

sql/sql_binlog.cc

@@ -52,7 +52,7 @@ void mysql_client_binlog_statement(THD* thd)
     Allocation
   */
   if (!thd->rli_fake)
-    thd->rli_fake= new RELAY_LOG_INFO;
+    thd->rli_fake= new Relay_log_info;
 
   const Format_description_log_event *desc=
     new Format_description_log_event(4);

sql/sql_class.h

@@ -23,8 +23,7 @@
 #include "log.h"
 #include "rpl_tblmap.h"
 
-struct st_relay_log_info;
-typedef st_relay_log_info RELAY_LOG_INFO;
+class Relay_log_info;
 
 class Query_log_event;
 class Load_log_event;
@@ -967,7 +966,7 @@ class THD :public Statement,
 {
 public:
   /* Used to execute base64 coded binlog events in MySQL server */
-  RELAY_LOG_INFO* rli_fake;
+  Relay_log_info* rli_fake;
 
   /*
     Constant for THD::where initialization in the beginning of every query.

sql/sql_repl.cc

@@ -799,7 +799,7 @@ int start_slave(THD* thd , MASTER_INFO* mi,  bool net_report)
 
         if (thd->lex->mi.pos)
         {
-          mi->rli.until_condition= RELAY_LOG_INFO::UNTIL_MASTER_POS;
+          mi->rli.until_condition= Relay_log_info::UNTIL_MASTER_POS;
           mi->rli.until_log_pos= thd->lex->mi.pos;
           /*
              We don't check thd->lex->mi.log_file_name for NULL here
@@ -810,7 +810,7 @@ int start_slave(THD* thd , MASTER_INFO* mi,  bool net_report)
         }
         else if (thd->lex->mi.relay_log_pos)
         {
-          mi->rli.until_condition= RELAY_LOG_INFO::UNTIL_RELAY_POS;
+          mi->rli.until_condition= Relay_log_info::UNTIL_RELAY_POS;
           mi->rli.until_log_pos= thd->lex->mi.relay_log_pos;
           strmake(mi->rli.until_log_name, thd->lex->mi.relay_log_name,
                   sizeof(mi->rli.until_log_name)-1);
@@ -818,7 +818,7 @@ int start_slave(THD* thd , MASTER_INFO* mi,  bool net_report)
         else
           mi->rli.clear_until_condition();
 
-        if (mi->rli.until_condition != RELAY_LOG_INFO::UNTIL_NONE)
+        if (mi->rli.until_condition != Relay_log_info::UNTIL_NONE)
         {
           /* Preparing members for effective until condition checking */
           const char *p= fn_ext(mi->rli.until_log_name);
@@ -840,7 +840,7 @@ int start_slave(THD* thd , MASTER_INFO* mi,  bool net_report)
 
           /* mark the cached result of the UNTIL comparison as "undefined" */
           mi->rli.until_log_names_cmp_result=
-            RELAY_LOG_INFO::UNTIL_LOG_NAMES_CMP_UNKNOWN;
+            Relay_log_info::UNTIL_LOG_NAMES_CMP_UNKNOWN;
 
           /* Issuing warning then started without --skip-slave-start */
           if (!opt_skip_slave_start)