log_event.h
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:33k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16. #ifndef _log_event_h
  17. #define _log_event_h
  18. #ifdef __EMX__
  19. #undef write  // remove pthread.h macro definition, conflict with write() class member
  20. #endif
  21. #if defined(USE_PRAGMA_INTERFACE) && !defined(MYSQL_CLIENT)
  22. #pragma interface /* gcc class implementation */
  23. #endif
  24. #define LOG_READ_EOF    -1
  25. #define LOG_READ_BOGUS  -2
  26. #define LOG_READ_IO     -3
  27. #define LOG_READ_MEM    -5
  28. #define LOG_READ_TRUNC  -6
  29. #define LOG_READ_TOO_LARGE -7
  30. #define LOG_EVENT_OFFSET 4
  31. #define BINLOG_VERSION    3
  32. /*
  33.  We could have used SERVER_VERSION_LENGTH, but this introduces an
  34.  obscure dependency - if somebody decided to change SERVER_VERSION_LENGTH
  35.  this would have broken the replication protocol
  36. */
  37. #define ST_SERVER_VER_LEN 50
  38. /*
  39.   These are flags and structs to handle all the LOAD DATA INFILE options (LINES
  40.   TERMINATED etc).
  41. */
  42. #define DUMPFILE_FLAG 0x1
  43. #define OPT_ENCLOSED_FLAG 0x2
  44. #define REPLACE_FLAG 0x4
  45. #define IGNORE_FLAG 0x8
  46. #define FIELD_TERM_EMPTY 0x1
  47. #define ENCLOSED_EMPTY 0x2
  48. #define LINE_TERM_EMPTY 0x4
  49. #define LINE_START_EMPTY 0x8
  50. #define ESCAPED_EMPTY 0x10
  51. /*****************************************************************************
  52.   old_sql_ex struct
  53.  ****************************************************************************/
  54. struct old_sql_ex
  55. {
  56.   char field_term;
  57.   char enclosed;
  58.   char line_term;
  59.   char line_start;
  60.   char escaped;
  61.   char opt_flags;
  62.   char empty_flags;
  63. };
  64. #define NUM_LOAD_DELIM_STRS 5
  65. /*****************************************************************************
  66.   sql_ex_info struct
  67.  ****************************************************************************/
  68. struct sql_ex_info
  69. {
  70.   char* field_term;
  71.   char* enclosed;
  72.   char* line_term;
  73.   char* line_start;
  74.   char* escaped;
  75.   int cached_new_format;
  76.   uint8 field_term_len,enclosed_len,line_term_len,line_start_len, escaped_len;
  77.   char opt_flags; 
  78.   char empty_flags;
  79.     
  80.   // store in new format even if old is possible
  81.   void force_new_format() { cached_new_format = 1;} 
  82.   int data_size()
  83.   {
  84.     return (new_format() ?
  85.     field_term_len + enclosed_len + line_term_len +
  86.     line_start_len + escaped_len + 6 : 7);
  87.   }
  88.   int write_data(IO_CACHE* file);
  89.   char* init(char* buf,char* buf_end,bool use_new_format);
  90.   bool new_format()
  91.   {
  92.     return ((cached_new_format != -1) ? cached_new_format :
  93.     (cached_new_format=(field_term_len > 1 ||
  94. enclosed_len > 1 ||
  95. line_term_len > 1 || line_start_len > 1 ||
  96. escaped_len > 1)));
  97.   }
  98. };
  99. /*****************************************************************************
  100.   MySQL Binary Log
  101.   This log consists of events.  Each event has a fixed-length header,
  102.   possibly followed by a variable length data body.
  103.   The data body consists of an optional fixed length segment (post-header)
  104.   and  an optional variable length segment.
  105.   See the #defines below for the format specifics.
  106.   The events which really update data are Query_log_event and
  107.   Load_log_event/Create_file_log_event/Execute_load_log_event (these 3 act
  108.   together to replicate LOAD DATA INFILE, with the help of
  109.   Append_block_log_event which prepares temporary files to load into the table).
  110.  ****************************************************************************/
  111. #define LOG_EVENT_HEADER_LEN 19     /* the fixed header length */
  112. #define OLD_HEADER_LEN       13     /* the fixed header length in 3.23 */
  113. /* event-specific post-header sizes */
  114. #define QUERY_HEADER_LEN     (4 + 4 + 1 + 2)
  115. #define LOAD_HEADER_LEN      (4 + 4 + 4 + 1 +1 + 4)
  116. #define START_HEADER_LEN     (2 + ST_SERVER_VER_LEN + 4)
  117. #define ROTATE_HEADER_LEN    8
  118. #define CREATE_FILE_HEADER_LEN 4
  119. #define APPEND_BLOCK_HEADER_LEN 4
  120. #define EXEC_LOAD_HEADER_LEN   4
  121. #define DELETE_FILE_HEADER_LEN 4
  122. /* 
  123.    Event header offsets; 
  124.    these point to places inside the fixed header.
  125. */
  126. #define EVENT_TYPE_OFFSET    4
  127. #define SERVER_ID_OFFSET     5
  128. #define EVENT_LEN_OFFSET     9
  129. #define LOG_POS_OFFSET       13
  130. #define FLAGS_OFFSET         17
  131. /* start event post-header */
  132. #define ST_BINLOG_VER_OFFSET  0
  133. #define ST_SERVER_VER_OFFSET  2
  134. #define ST_CREATED_OFFSET     (ST_SERVER_VER_OFFSET + ST_SERVER_VER_LEN)
  135. /* slave event post-header (this event is never written) */
  136. #define SL_MASTER_PORT_OFFSET   8
  137. #define SL_MASTER_POS_OFFSET    0
  138. #define SL_MASTER_HOST_OFFSET   10
  139. /* query event post-header */
  140. #define Q_THREAD_ID_OFFSET 0
  141. #define Q_EXEC_TIME_OFFSET 4
  142. #define Q_DB_LEN_OFFSET 8
  143. #define Q_ERR_CODE_OFFSET 9
  144. #define Q_DATA_OFFSET QUERY_HEADER_LEN
  145. /* Intvar event post-header */
  146. #define I_TYPE_OFFSET        0
  147. #define I_VAL_OFFSET         1
  148. /* Rand event post-header */
  149. #define RAND_SEED1_OFFSET 0
  150. #define RAND_SEED2_OFFSET 8
  151. /* User_var event post-header */
  152. #define UV_VAL_LEN_SIZE        4
  153. #define UV_VAL_IS_NULL         1
  154. #define UV_VAL_TYPE_SIZE       1
  155. #define UV_NAME_LEN_SIZE       4
  156. #define UV_CHARSET_NUMBER_SIZE 4
  157. /* Load event post-header */
  158. #define L_THREAD_ID_OFFSET   0
  159. #define L_EXEC_TIME_OFFSET   4
  160. #define L_SKIP_LINES_OFFSET  8
  161. #define L_TBL_LEN_OFFSET     12
  162. #define L_DB_LEN_OFFSET      13
  163. #define L_NUM_FIELDS_OFFSET  14
  164. #define L_SQL_EX_OFFSET      18
  165. #define L_DATA_OFFSET        LOAD_HEADER_LEN
  166. /* Rotate event post-header */
  167. #define R_POS_OFFSET       0
  168. #define R_IDENT_OFFSET     8
  169. /* CF to DF handle LOAD DATA INFILE */
  170. /* CF = "Create File" */
  171. #define CF_FILE_ID_OFFSET  0
  172. #define CF_DATA_OFFSET     CREATE_FILE_HEADER_LEN
  173. /* AB = "Append Block" */
  174. #define AB_FILE_ID_OFFSET  0
  175. #define AB_DATA_OFFSET     APPEND_BLOCK_HEADER_LEN
  176. /* EL = "Execute Load" */
  177. #define EL_FILE_ID_OFFSET  0
  178. /* DF = "Delete File" */
  179. #define DF_FILE_ID_OFFSET  0
  180. #define QUERY_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+QUERY_HEADER_LEN)
  181. #define QUERY_DATA_OFFSET (LOG_EVENT_HEADER_LEN+QUERY_HEADER_LEN)
  182. #define ROTATE_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+ROTATE_HEADER_LEN)
  183. #define LOAD_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+LOAD_HEADER_LEN)
  184. #define CREATE_FILE_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+
  185.  +LOAD_HEADER_LEN+CREATE_FILE_HEADER_LEN)
  186. #define DELETE_FILE_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+DELETE_FILE_HEADER_LEN)
  187. #define EXEC_LOAD_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+EXEC_LOAD_HEADER_LEN)
  188. #define APPEND_BLOCK_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+APPEND_BLOCK_HEADER_LEN)
  189. /* 4 bytes which all binlogs should begin with */
  190. #define BINLOG_MAGIC        "xfex62x69x6e"
  191. /*
  192.   The 2 flags below were useless :
  193.   - the first one was never set
  194.   - the second one was set in all Rotate events on the master, but not used for
  195.   anything useful.
  196.   So they are now removed and their place may later be reused for other
  197.   flags. Then one must remember that Rotate events in 4.x have
  198.   LOG_EVENT_FORCED_ROTATE_F set, so one should not rely on the value of the
  199.   replacing flag when reading a Rotate event. 
  200.   I keep the defines here just to remember what they were.
  201. */
  202. #ifdef TO_BE_REMOVED
  203. #define LOG_EVENT_TIME_F            0x1
  204. #define LOG_EVENT_FORCED_ROTATE_F   0x2 
  205. #endif
  206. /* 
  207.    If the query depends on the thread (for example: TEMPORARY TABLE).
  208.    Currently this is used by mysqlbinlog to know it must print
  209.    SET @@PSEUDO_THREAD_ID=xx; before the query (it would not hurt to print it
  210.    for every query but this would be slow).
  211. */
  212. #define LOG_EVENT_THREAD_SPECIFIC_F 0x4 
  213. /*
  214.   Suppress the generation of 'USE' statements before the actual
  215.   statement. This flag should be set for any events that does not need
  216.   the current database set to function correctly. Most notable cases
  217.   are 'CREATE DATABASE' and 'DROP DATABASE'.
  218.   This flags should only be used in exceptional circumstances, since
  219.   it introduce a significant change in behaviour regarding the
  220.   replication logic together with the flags --binlog-do-db and
  221.   --replicated-do-db.
  222.  */
  223. #define LOG_EVENT_SUPPRESS_USE_F    0x8
  224. enum Log_event_type
  225. {
  226.   UNKNOWN_EVENT= 0, START_EVENT= 1, QUERY_EVENT= 2, STOP_EVENT= 3,
  227.   ROTATE_EVENT= 4, INTVAR_EVENT= 5, LOAD_EVENT=6, SLAVE_EVENT= 7, 
  228.   CREATE_FILE_EVENT= 8, APPEND_BLOCK_EVENT= 9, EXEC_LOAD_EVENT= 10,
  229.   DELETE_FILE_EVENT= 11, NEW_LOAD_EVENT= 12, RAND_EVENT= 13,
  230.   USER_VAR_EVENT= 14
  231. };
  232. enum Int_event_type
  233. {
  234.   INVALID_INT_EVENT = 0, LAST_INSERT_ID_EVENT = 1, INSERT_ID_EVENT = 2
  235. };
  236. #ifndef MYSQL_CLIENT
  237. class String;
  238. class MYSQL_LOG;
  239. class THD;
  240. #endif
  241. struct st_relay_log_info;
  242. /*****************************************************************************
  243.   Log_event class
  244.   This is the abstract base class for binary log events.
  245.  ****************************************************************************/
  246. class Log_event
  247. {
  248. public:
  249.   /* 
  250.      The offset in the log where this event originally appeared (it is preserved
  251.      in relay logs, making SHOW SLAVE STATUS able to print coordinates of the
  252.      event in the master's binlog). Note: when a transaction is written by the
  253.      master to its binlog (wrapped in BEGIN/COMMIT) the log_pos of all the
  254.      queries it contains is the one of the BEGIN (this way, when one does SHOW
  255.      SLAVE STATUS it sees the offset of the BEGIN, which is logical as rollback
  256.      may occur), except the COMMIT query which has its real offset.
  257.   */
  258.   my_off_t log_pos;
  259.   /* 
  260.      A temp buffer for read_log_event; it is later analysed according to the
  261.      event's type, and its content is distributed in the event-specific fields.
  262.   */
  263.   char *temp_buf; 
  264.   /*
  265.     Timestamp on the master(for debugging and replication of NOW()/TIMESTAMP). 
  266.     It is important for queries and LOAD DATA INFILE. This is set at the event's
  267.     creation time, except for Query and Load (et al.) events where this is set
  268.     at the query's execution time, which guarantees good replication (otherwise,
  269.     we could have a query and its event with different timestamps).
  270.   */
  271.   time_t when;
  272.   /* The number of seconds the query took to run on the master. */
  273.   ulong exec_time;
  274.   /* 
  275.      The master's server id (is preserved in the relay log; used to prevent from
  276.      infinite loops in circular replication). 
  277.   */
  278.   uint32 server_id;
  279.   uint cached_event_len;
  280.   /*
  281.     Some 16 flags. Only one is really used now; look above for
  282.     LOG_EVENT_TIME_F, LOG_EVENT_FORCED_ROTATE_F,
  283.     LOG_EVENT_THREAD_SPECIFIC_F, and LOG_EVENT_SUPPRESS_USE_F for
  284.     notes.
  285.   */
  286.   uint16 flags;
  287.   bool cache_stmt;
  288. #ifndef MYSQL_CLIENT
  289.   THD* thd;
  290.   Log_event(THD* thd_arg, uint16 flags_arg, bool cache_stmt);
  291.   Log_event();
  292.   /*
  293.     read_log_event() functions read an event from a binlog or relay log; used by
  294.     SHOW BINLOG EVENTS, the binlog_dump thread on the master (reads master's
  295.     binlog), the slave IO thread (reads the event sent by binlog_dump), the
  296.     slave SQL thread (reads the event from the relay log).
  297.   */
  298.   // if mutex is 0, the read will proceed without mutex
  299.   static Log_event* read_log_event(IO_CACHE* file,
  300.    pthread_mutex_t* log_lock,
  301.    bool old_format);
  302.   static int read_log_event(IO_CACHE* file, String* packet,
  303.     pthread_mutex_t* log_lock);
  304.   /* set_log_pos() is used to fill log_pos with tell(log). */
  305.   void set_log_pos(MYSQL_LOG* log);
  306.   /*
  307.     init_show_field_list() prepares the column names and types for the output of
  308.     SHOW BINLOG EVENTS; it is used only by SHOW BINLOG EVENTS.
  309.   */
  310.   static void init_show_field_list(List<Item>* field_list);
  311. #ifdef HAVE_REPLICATION
  312.   int net_send(Protocol *protocol, const char* log_name, my_off_t pos);
  313.   /*
  314.     pack_info() is used by SHOW BINLOG EVENTS; as print() it prepares and sends
  315.     a string to display to the user, so it resembles print().
  316.   */
  317.   virtual void pack_info(Protocol *protocol);
  318.   /*
  319.     The SQL slave thread calls exec_event() to execute the event; this is where
  320.     the slave's data is modified.
  321.   */
  322.   virtual int exec_event(struct st_relay_log_info* rli);
  323. #endif /* HAVE_REPLICATION */
  324.   virtual const char* get_db()
  325.   {
  326.     return thd ? thd->db : 0;
  327.   }
  328. #else
  329.  // avoid having to link mysqlbinlog against libpthread
  330.   static Log_event* read_log_event(IO_CACHE* file, bool old_format);
  331.   /* print*() functions are used by mysqlbinlog */
  332.   virtual void print(FILE* file, bool short_form = 0, char* last_db = 0) = 0;
  333.   void print_timestamp(FILE* file, time_t *ts = 0);
  334.   void print_header(FILE* file);
  335. #endif  
  336.   static void *operator new(size_t size)
  337.   {
  338.     return (void*) my_malloc((uint)size, MYF(MY_WME|MY_FAE));
  339.   }
  340.   static void operator delete(void *ptr, size_t size)
  341.   {
  342.     my_free((gptr) ptr, MYF(MY_WME|MY_ALLOW_ZERO_PTR));
  343.   }
  344.   
  345.   int write(IO_CACHE* file);
  346.   int write_header(IO_CACHE* file);
  347.   virtual int write_data(IO_CACHE* file)
  348.   { return write_data_header(file) || write_data_body(file); }
  349.   virtual int write_data_header(IO_CACHE* file __attribute__((unused)))
  350.   { return 0; }
  351.   virtual int write_data_body(IO_CACHE* file __attribute__((unused)))
  352.   { return 0; }
  353.   virtual Log_event_type get_type_code() = 0;
  354.   virtual bool is_valid() = 0;
  355.   inline bool get_cache_stmt() { return cache_stmt; }
  356.   Log_event(const char* buf, bool old_format);
  357.   virtual ~Log_event() { free_temp_buf();}
  358.   void register_temp_buf(char* buf) { temp_buf = buf; }
  359.   void free_temp_buf()
  360.   {
  361.     if (temp_buf)
  362.     {
  363.       my_free(temp_buf, MYF(0));
  364.       temp_buf = 0;
  365.     }
  366.   }
  367.   virtual int get_data_size() { return 0;}
  368.   virtual int get_data_body_offset() { return 0; }
  369.   virtual int get_event_len()
  370.   {
  371.     return (cached_event_len ? cached_event_len :
  372.     (cached_event_len = LOG_EVENT_HEADER_LEN + get_data_size()));
  373.   }
  374.   static Log_event* read_log_event(const char* buf, int event_len,
  375.    const char **error, bool old_format);
  376.   /* returns the human readable name of the event's type */
  377.   const char* get_type_str();
  378. };
  379. /*****************************************************************************
  380.   Query Log Event class
  381.   Logs SQL queries
  382.  ****************************************************************************/
  383. class Query_log_event: public Log_event
  384. {
  385. protected:
  386.   char* data_buf;
  387. public:
  388.   const char* query;
  389.   const char* db;
  390.   /*
  391.     If we already know the length of the query string
  392.     we pass it with q_len, so we would not have to call strlen()
  393.     otherwise, set it to 0, in which case, we compute it with strlen()
  394.   */
  395.   uint32 q_len;
  396.   uint32 db_len;
  397.   uint16 error_code;
  398.   ulong thread_id;
  399.   /* 
  400.      For events created by Query_log_event::exec_event (and
  401.      Load_log_event::exec_event()) we need the *original* thread id, to be able
  402.      to log the event with the original (=master's) thread id (fix for
  403.      BUG#1686).
  404.   */
  405.   ulong slave_proxy_id;
  406. #ifndef MYSQL_CLIENT
  407.   Query_log_event(THD* thd_arg, const char* query_arg, ulong query_length,
  408.   bool using_trans, bool suppress_use);
  409.   const char* get_db() { return db; }
  410. #ifdef HAVE_REPLICATION
  411.   void pack_info(Protocol* protocol);
  412.   int exec_event(struct st_relay_log_info* rli);
  413. #endif /* HAVE_REPLICATION */
  414. #else
  415.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  416. #endif
  417.   Query_log_event(const char* buf, int event_len, bool old_format);
  418.   ~Query_log_event()
  419.   {
  420.     if (data_buf)
  421.     {
  422.       my_free((gptr) data_buf, MYF(0));
  423.     }
  424.   }
  425.   Log_event_type get_type_code() { return QUERY_EVENT; }
  426.   int write(IO_CACHE* file);
  427.   int write_data(IO_CACHE* file); // returns 0 on success, -1 on error
  428.   bool is_valid() { return query != 0; }
  429.   int get_data_size()
  430.   {
  431.     return (q_len + db_len + 2
  432.     + 4 // thread_id
  433.     + 4 // exec_time
  434.     + 2 // error_code
  435.     );
  436.   }
  437. };
  438. #ifdef HAVE_REPLICATION
  439. /*****************************************************************************
  440.   Slave Log Event class
  441.   Note that this class is currently not used at all; no code writes a
  442.   Slave_log_event (though some code in repl_failsafe.cc reads Slave_log_event).
  443.  ****************************************************************************/
  444. class Slave_log_event: public Log_event
  445. {
  446. protected:
  447.   char* mem_pool;
  448.   void init_from_mem_pool(int data_size);
  449. public:
  450.   my_off_t master_pos;
  451.   char* master_host;
  452.   char* master_log;
  453.   int master_host_len;
  454.   int master_log_len;
  455.   uint16 master_port;
  456. #ifndef MYSQL_CLIENT  
  457.   Slave_log_event(THD* thd_arg, struct st_relay_log_info* rli);
  458.   void pack_info(Protocol* protocol);
  459.   int exec_event(struct st_relay_log_info* rli);
  460. #else
  461.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  462. #endif  
  463.   Slave_log_event(const char* buf, int event_len);
  464.   ~Slave_log_event();
  465.   int get_data_size();
  466.   bool is_valid() { return master_host != 0; }
  467.   Log_event_type get_type_code() { return SLAVE_EVENT; }
  468.   int write_data(IO_CACHE* file );
  469. };
  470. #endif /* HAVE_REPLICATION */
  471. /*****************************************************************************
  472.   Load Log Event class
  473.  ****************************************************************************/
  474. class Load_log_event: public Log_event
  475. {
  476. protected:
  477.   int copy_log_event(const char *buf, ulong event_len, bool old_format);
  478. public:
  479.   ulong thread_id;
  480.   ulong slave_proxy_id;
  481.   uint32 table_name_len;
  482.   uint32 db_len;
  483.   uint32 fname_len;
  484.   uint32 num_fields;
  485.   const char* fields;
  486.   const uchar* field_lens;
  487.   uint32 field_block_len;
  488.   const char* table_name;
  489.   const char* db;
  490.   const char* fname;
  491.   uint32 skip_lines;
  492.   sql_ex_info sql_ex;
  493.   bool local_fname;
  494.   /* fname doesn't point to memory inside Log_event::temp_buf  */
  495.   void set_fname_outside_temp_buf(const char *afname, uint alen)
  496.   {
  497.     fname= afname;
  498.     fname_len= alen;
  499.     local_fname= TRUE;
  500.   }
  501.   /* fname doesn't point to memory inside Log_event::temp_buf  */
  502.   int  check_fname_outside_temp_buf()
  503.   {
  504.     return local_fname;
  505.   }
  506. #ifndef MYSQL_CLIENT
  507.   String field_lens_buf;
  508.   String fields_buf;
  509.   
  510.   Load_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
  511.  const char* table_name_arg,
  512.  List<Item>& fields_arg, enum enum_duplicates handle_dup, bool ignore,
  513.  bool using_trans);
  514.   void set_fields(const char* db, List<Item> &fields_arg);
  515.   const char* get_db() { return db; }
  516. #ifdef HAVE_REPLICATION
  517.   void pack_info(Protocol* protocol);
  518.   int exec_event(struct st_relay_log_info* rli)
  519.   {
  520.     return exec_event(thd->slave_net,rli,0);
  521.   }
  522.   int exec_event(NET* net, struct st_relay_log_info* rli, 
  523.  bool use_rli_only_for_errors);
  524. #endif /* HAVE_REPLICATION */
  525. #else
  526.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  527.   void print(FILE* file, bool short_form, char* last_db, bool commented);
  528. #endif
  529.   Load_log_event(const char* buf, int event_len, bool old_format);
  530.   ~Load_log_event()
  531.   {}
  532.   Log_event_type get_type_code()
  533.   {
  534.     return sql_ex.new_format() ? NEW_LOAD_EVENT: LOAD_EVENT;
  535.   }
  536.   int write_data_header(IO_CACHE* file); 
  537.   int write_data_body(IO_CACHE* file); 
  538.   bool is_valid() { return table_name != 0; }
  539.   int get_data_size()
  540.   {
  541.     return (table_name_len + 2 + db_len + 2 + fname_len
  542.     + 4 // thread_id
  543.     + 4 // exec_time
  544.     + 4 // skip_lines
  545.     + 4 // field block len
  546.     + sql_ex.data_size() + field_block_len + num_fields);
  547.   }
  548.   int get_data_body_offset() { return LOAD_EVENT_OVERHEAD; }
  549. };
  550. extern char server_version[SERVER_VERSION_LENGTH];
  551. /*****************************************************************************
  552.   Start Log Event class
  553.  ****************************************************************************/
  554. class Start_log_event: public Log_event
  555. {
  556. public:
  557.   /* 
  558.      If this event is at the start of the first binary log since server startup
  559.      'created' should be the timestamp when the event (and the binary log) was
  560.      created. 
  561.      In the other case (i.e. this event is at the start of a binary log created
  562.      by FLUSH LOGS or automatic rotation), 'created' should be 0.
  563.      This "trick" is used by MySQL >=4.0.14 slaves to know if they must drop the
  564.      stale temporary tables or not.
  565.      Note that when 'created'!=0, it is always equal to the event's timestamp;
  566.      indeed Start_log_event is written only in log.cc where the first
  567.      constructor below is called, in which 'created' is set to 'when'. 
  568.      So in fact 'created' is a useless variable. When it is 0
  569.      we can read the actual value from timestamp ('when') and when it is
  570.      non-zero we can read the same value from timestamp ('when'). Conclusion:
  571.      - we use timestamp to print when the binlog was created.
  572.      - we use 'created' only to know if this is a first binlog or not.
  573.      In 3.23.57 we did not pay attention to this identity, so mysqlbinlog in
  574.      3.23.57 does not print 'created the_date' if created was zero. This is now
  575.      fixed.
  576.   */
  577.   time_t created;
  578.   uint16 binlog_version;
  579.   char server_version[ST_SERVER_VER_LEN];
  580. #ifndef MYSQL_CLIENT
  581.   Start_log_event() :Log_event(), binlog_version(BINLOG_VERSION)
  582.   {
  583.     created = (time_t) when;
  584.     memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
  585.   }
  586. #ifdef HAVE_REPLICATION
  587.   void pack_info(Protocol* protocol);
  588.   int exec_event(struct st_relay_log_info* rli);
  589. #endif /* HAVE_REPLICATION */
  590. #else
  591.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  592. #endif  
  593.   Start_log_event(const char* buf, bool old_format);
  594.   ~Start_log_event() {}
  595.   Log_event_type get_type_code() { return START_EVENT;}
  596.   int write_data(IO_CACHE* file);
  597.   bool is_valid() { return 1; }
  598.   int get_data_size()
  599.   {
  600.     return START_HEADER_LEN;
  601.   }
  602. };
  603. /*****************************************************************************
  604.   Intvar Log Event class
  605.   Logs special variables such as auto_increment values
  606.  ****************************************************************************/
  607. class Intvar_log_event: public Log_event
  608. {
  609. public:
  610.   ulonglong val;
  611.   uchar type;
  612. #ifndef MYSQL_CLIENT  
  613.   Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg)
  614.     :Log_event(thd_arg,0,0),val(val_arg),type(type_arg)
  615.   {}
  616. #ifdef HAVE_REPLICATION
  617.   void pack_info(Protocol* protocol);
  618.   int exec_event(struct st_relay_log_info* rli);
  619. #endif /* HAVE_REPLICATION */
  620. #else
  621.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  622. #endif  
  623.   Intvar_log_event(const char* buf, bool old_format);
  624.   ~Intvar_log_event() {}
  625.   Log_event_type get_type_code() { return INTVAR_EVENT;}
  626.   const char* get_var_type_name();
  627.   int get_data_size() { return  9; /* sizeof(type) + sizeof(val) */;}
  628.   int write_data(IO_CACHE* file);
  629.   bool is_valid() { return 1; }
  630. };
  631. /*****************************************************************************
  632.   Rand Log Event class
  633.   Logs random seed used by the next RAND(), and by PASSWORD() in 4.1.
  634.  ****************************************************************************/
  635. class Rand_log_event: public Log_event
  636. {
  637.  public:
  638.   ulonglong seed1;
  639.   ulonglong seed2;
  640. #ifndef MYSQL_CLIENT
  641.   Rand_log_event(THD* thd_arg, ulonglong seed1_arg, ulonglong seed2_arg)
  642.     :Log_event(thd_arg,0,0),seed1(seed1_arg),seed2(seed2_arg)
  643.   {}
  644. #ifdef HAVE_REPLICATION
  645.   void pack_info(Protocol* protocol);
  646.   int exec_event(struct st_relay_log_info* rli);
  647. #endif /* HAVE_REPLICATION */
  648. #else
  649.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  650. #endif
  651.   Rand_log_event(const char* buf, bool old_format);
  652.   ~Rand_log_event() {}
  653.   Log_event_type get_type_code() { return RAND_EVENT;}
  654.   int get_data_size() { return 16; /* sizeof(ulonglong) * 2*/ }
  655.   int write_data(IO_CACHE* file);
  656.   bool is_valid() { return 1; }
  657. };
  658. /*****************************************************************************
  659.   User var Log Event class
  660.   Every time a query uses the value of a user variable, a User_var_log_event is
  661.   written before the Query_log_event, to set the user variable.
  662.  ****************************************************************************/
  663. class User_var_log_event: public Log_event
  664. {
  665. public:
  666.   char *name;
  667.   uint name_len;
  668.   char *val;
  669.   ulong val_len;
  670.   Item_result type;
  671.   uint charset_number;
  672.   bool is_null;
  673. #ifndef MYSQL_CLIENT
  674.   User_var_log_event(THD* thd_arg, char *name_arg, uint name_len_arg,
  675.                      char *val_arg, ulong val_len_arg, Item_result type_arg,
  676.      uint charset_number_arg)
  677.     :Log_event(), name(name_arg), name_len(name_len_arg), val(val_arg),
  678.     val_len(val_len_arg), type(type_arg), charset_number(charset_number_arg)
  679.     { is_null= !val; }
  680.   void pack_info(Protocol* protocol);
  681.   int exec_event(struct st_relay_log_info* rli);
  682. #else
  683.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  684. #endif
  685.   User_var_log_event(const char* buf, bool old_format);
  686.   ~User_var_log_event() {}
  687.   Log_event_type get_type_code() { return USER_VAR_EVENT;}
  688.   int get_data_size()
  689.     {
  690.       return (is_null ? UV_NAME_LEN_SIZE + name_len + UV_VAL_IS_NULL :
  691. UV_NAME_LEN_SIZE + name_len + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE +
  692. UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE + val_len);
  693.     }
  694.   int write_data(IO_CACHE* file);
  695.   bool is_valid() { return 1; }
  696. };
  697. /*****************************************************************************
  698.   Stop Log Event class
  699.  ****************************************************************************/
  700. #ifdef HAVE_REPLICATION
  701. class Stop_log_event: public Log_event
  702. {
  703. public:
  704. #ifndef MYSQL_CLIENT
  705.   Stop_log_event() :Log_event()
  706.   {}
  707.   int exec_event(struct st_relay_log_info* rli);
  708. #else
  709.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  710. #endif  
  711.   Stop_log_event(const char* buf, bool old_format):
  712.     Log_event(buf, old_format)
  713.   {}
  714.   ~Stop_log_event() {}
  715.   Log_event_type get_type_code() { return STOP_EVENT;}
  716.   bool is_valid() { return 1; }
  717. };
  718. #endif /* HAVE_REPLICATION */
  719. /*****************************************************************************
  720.   Rotate Log Event class
  721.   This will be depricated when we move to using sequence ids.
  722.  ****************************************************************************/
  723. class Rotate_log_event: public Log_event
  724. {
  725. public:
  726.   enum {
  727.     ZERO_LEN= 1, // if event should report 0 as its length
  728.     DUP_NAME= 2 // if constructor should dup the string argument
  729.   };
  730.   const char* new_log_ident;
  731.   ulonglong pos;
  732.   uint ident_len;
  733.   uint flags;
  734. #ifndef MYSQL_CLIENT  
  735.   Rotate_log_event(THD* thd_arg, const char* new_log_ident_arg,
  736.    uint ident_len_arg,
  737.    ulonglong pos_arg, uint flags);
  738. #ifdef HAVE_REPLICATION
  739.   void pack_info(Protocol* protocol);
  740.   int exec_event(struct st_relay_log_info* rli);
  741. #endif /* HAVE_REPLICATION */
  742. #else
  743.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  744. #endif
  745.   Rotate_log_event(const char* buf, int event_len, bool old_format);
  746.   ~Rotate_log_event()
  747.   {
  748.     if (flags & DUP_NAME)
  749.       my_free((gptr) new_log_ident, MYF(MY_ALLOW_ZERO_PTR));
  750.   }
  751.   Log_event_type get_type_code() { return ROTATE_EVENT;}
  752.   virtual int get_event_len()
  753.   {
  754.     if (flags & ZERO_LEN)
  755.       return 0;
  756.     if (cached_event_len == 0)
  757.       cached_event_len= LOG_EVENT_HEADER_LEN + get_data_size();
  758.     return cached_event_len;
  759.   }
  760.   int get_data_size() { return  ident_len + ROTATE_HEADER_LEN;}
  761.   bool is_valid() { return new_log_ident != 0; }
  762.   int write_data(IO_CACHE* file);
  763. };
  764. /* the classes below are for the new LOAD DATA INFILE logging */
  765. /*****************************************************************************
  766.   Create File Log Event class
  767.  ****************************************************************************/
  768. class Create_file_log_event: public Load_log_event
  769. {
  770. protected:
  771.   /*
  772.     Pretend we are Load event, so we can write out just
  773.     our Load part - used on the slave when writing event out to
  774.     SQL_LOAD-*.info file
  775.   */
  776.   bool fake_base; 
  777. public:
  778.   char* block;
  779.   const char *event_buf;
  780.   uint block_len;
  781.   uint file_id;
  782.   bool inited_from_old;
  783. #ifndef MYSQL_CLIENT
  784.   Create_file_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
  785. const char* table_name_arg,
  786. List<Item>& fields_arg,
  787. enum enum_duplicates handle_dup, bool ignore,
  788. char* block_arg, uint block_len_arg,
  789. bool using_trans);
  790. #ifdef HAVE_REPLICATION
  791.   void pack_info(Protocol* protocol);
  792.   int exec_event(struct st_relay_log_info* rli);
  793. #endif /* HAVE_REPLICATION */
  794. #else
  795.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  796.   void print(FILE* file, bool short_form, char* last_db, bool enable_local);
  797. #endif  
  798.   
  799.   Create_file_log_event(const char* buf, int event_len, bool old_format);
  800.   ~Create_file_log_event()
  801.   {
  802.     my_free((char*) event_buf, MYF(MY_ALLOW_ZERO_PTR));
  803.   }
  804.   Log_event_type get_type_code()
  805.   {
  806.     return fake_base ? Load_log_event::get_type_code() : CREATE_FILE_EVENT;
  807.   }
  808.   int get_data_size()
  809.   {
  810.     return (fake_base ? Load_log_event::get_data_size() :
  811.     Load_log_event::get_data_size() +
  812.     4 + 1 + block_len);
  813.   }
  814.   int get_data_body_offset()
  815.   {
  816.     return (fake_base ? LOAD_EVENT_OVERHEAD:
  817.     LOAD_EVENT_OVERHEAD + CREATE_FILE_HEADER_LEN);
  818.   }
  819.   bool is_valid() { return inited_from_old || block != 0; }
  820.   int write_data_header(IO_CACHE* file);
  821.   int write_data_body(IO_CACHE* file);
  822.   /*
  823.     Cut out Create_file extentions and
  824.     write it as Load event - used on the slave
  825.   */
  826.   int write_base(IO_CACHE* file);
  827. };
  828. /*****************************************************************************
  829.   Append Block Log Event class
  830.  ****************************************************************************/
  831. class Append_block_log_event: public Log_event
  832. {
  833. public:
  834.   char* block;
  835.   uint block_len;
  836.   uint file_id;
  837.   /*
  838.     'db' is filled when the event is created in mysql_load() (the event needs to
  839.     have a 'db' member to be well filtered by binlog-*-db rules). 'db' is not
  840.     written to the binlog (it's not used by Append_block_log_event::write()), so
  841.     it can't be read in the Append_block_log_event(const char* buf, int
  842.     event_len) constructor.
  843.     In other words, 'db' is used only for filtering by binlog-*-db rules.
  844.     Create_file_log_event is different: its 'db' (which is inherited from
  845.     Load_log_event) is written to the binlog and can be re-read.
  846.   */
  847.   const char* db;
  848. #ifndef MYSQL_CLIENT
  849.   Append_block_log_event(THD* thd, const char* db_arg, char* block_arg,
  850.  uint block_len_arg, bool using_trans);
  851. #ifdef HAVE_REPLICATION
  852.   int exec_event(struct st_relay_log_info* rli);
  853.   void pack_info(Protocol* protocol);
  854. #endif /* HAVE_REPLICATION */
  855. #else
  856.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  857. #endif
  858.   
  859.   Append_block_log_event(const char* buf, int event_len);
  860.   ~Append_block_log_event() {}
  861.   Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;}
  862.   int get_data_size() { return  block_len + APPEND_BLOCK_HEADER_LEN ;}
  863.   bool is_valid() { return block != 0; }
  864.   int write_data(IO_CACHE* file);
  865.   const char* get_db() { return db; }
  866. };
  867. /*****************************************************************************
  868.   Delete File Log Event class
  869.  ****************************************************************************/
  870. class Delete_file_log_event: public Log_event
  871. {
  872. public:
  873.   uint file_id;
  874.   const char* db; /* see comment in Append_block_log_event */
  875.   
  876. #ifndef MYSQL_CLIENT
  877.   Delete_file_log_event(THD* thd, const char* db_arg, bool using_trans);
  878. #ifdef HAVE_REPLICATION
  879.   void pack_info(Protocol* protocol);
  880.   int exec_event(struct st_relay_log_info* rli);
  881. #endif /* HAVE_REPLICATION */
  882. #else
  883.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  884.   void print(FILE* file, bool short_form, char* last_db, bool enable_local);
  885. #endif  
  886.   
  887.   Delete_file_log_event(const char* buf, int event_len);
  888.   ~Delete_file_log_event() {}
  889.   Log_event_type get_type_code() { return DELETE_FILE_EVENT;}
  890.   int get_data_size() { return DELETE_FILE_HEADER_LEN ;}
  891.   bool is_valid() { return file_id != 0; }
  892.   int write_data(IO_CACHE* file);
  893.   const char* get_db() { return db; }
  894. };
  895. /*****************************************************************************
  896.   Execute Load Log Event class
  897.  ****************************************************************************/
  898. class Execute_load_log_event: public Log_event
  899. {
  900. public:
  901.   uint file_id;
  902.   const char* db; /* see comment in Append_block_log_event */ 
  903. #ifndef MYSQL_CLIENT
  904.   Execute_load_log_event(THD* thd, const char* db_arg, bool using_trans);
  905. #ifdef HAVE_REPLICATION
  906.   void pack_info(Protocol* protocol);
  907.   int exec_event(struct st_relay_log_info* rli);
  908. #endif /* HAVE_REPLICATION */
  909. #else
  910.   void print(FILE* file, bool short_form = 0, char* last_db = 0);
  911. #endif  
  912.   
  913.   Execute_load_log_event(const char* buf, int event_len);
  914.   ~Execute_load_log_event() {}
  915.   Log_event_type get_type_code() { return EXEC_LOAD_EVENT;}
  916.   int get_data_size() { return  EXEC_LOAD_HEADER_LEN ;}
  917.   bool is_valid() { return file_id != 0; }
  918.   int write_data(IO_CACHE* file);
  919.   const char* get_db() { return db; }
  920. };
  921. #ifdef MYSQL_CLIENT
  922. class Unknown_log_event: public Log_event
  923. {
  924. public:
  925.   Unknown_log_event(const char* buf, bool old_format):
  926.     Log_event(buf, old_format)
  927.   {}
  928.   ~Unknown_log_event() {}
  929.   void print(FILE* file, bool short_form= 0, char* last_db= 0);
  930.   Log_event_type get_type_code() { return UNKNOWN_EVENT;}
  931.   bool is_valid() { return 1; }
  932. };
  933. #endif  
  934. char *str_to_hex(char *to, const char *from, uint len);
  935. #endif /* _log_event_h */