log_event.h 19.1 KB
Newer Older
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


18 19
#ifndef _log_event_h
#define _log_event_h
bk@work.mysql.com's avatar
bk@work.mysql.com committed
20

21 22 23 24
#ifdef __EMX__
#undef write  // remove pthread.h macro definition, conflict with write() class member
#endif

bk@work.mysql.com's avatar
bk@work.mysql.com committed
25 26 27 28 29 30 31 32
#if defined(__GNUC__) && !defined(MYSQL_CLIENT)
#pragma interface			/* gcc class implementation */
#endif

#define LOG_READ_EOF    -1
#define LOG_READ_BOGUS  -2
#define LOG_READ_IO     -3
#define LOG_READ_MEM    -5
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
33
#define LOG_READ_TRUNC  -6
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
34
#define LOG_READ_TOO_LARGE -7
bk@work.mysql.com's avatar
bk@work.mysql.com committed
35 36

#define LOG_EVENT_OFFSET 4
37
#define BINLOG_VERSION    3
38

39 40 41 42
/*
 We could have used SERVER_VERSION_LENGTH, but this introduces an
 obscure dependency - if somebody decided to change SERVER_VERSION_LENGTH
 this would have broke the replication protocol
43 44 45
*/
#define ST_SERVER_VER_LEN 50

46 47 48 49
#define DUMPFILE_FLAG		0x1
#define OPT_ENCLOSED_FLAG	0x2
#define REPLACE_FLAG		0x4
#define IGNORE_FLAG		0x8
50

51 52 53 54 55
#define FIELD_TERM_EMPTY	0x1
#define ENCLOSED_EMPTY		0x2
#define LINE_TERM_EMPTY		0x4
#define LINE_START_EMPTY	0x8
#define ESCAPED_EMPTY		0x10
56

57
struct old_sql_ex
58 59 60 61 62 63 64 65 66
{
  char field_term;
  char enclosed;
  char line_term;
  char line_start;
  char escaped;
  char opt_flags;
  char empty_flags;
};
67

68 69
#define NUM_LOAD_DELIM_STRS 5

70
struct sql_ex_info
71 72 73 74 75 76 77 78 79 80
{
  char* field_term;
  char* enclosed;
  char* line_term;
  char* line_start;
  char* escaped;
  int cached_new_format;
  uint8 field_term_len,enclosed_len,line_term_len,line_start_len, escaped_len;
  char opt_flags; 
  char empty_flags;
81
    
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
  // store in new format even if old is possible
  void force_new_format() { cached_new_format = 1;} 
  int data_size()
  {
    return (new_format() ?
	    field_term_len + enclosed_len + line_term_len +
	    line_start_len + escaped_len + 6 : 7);
  }
  int write_data(IO_CACHE* file);
  char* init(char* buf,char* buf_end,bool use_new_format);
  bool new_format()
  {
    return ((cached_new_format != -1) ? cached_new_format :
	    (cached_new_format=(field_term_len > 1 ||
				enclosed_len > 1 ||
				line_term_len > 1 || line_start_len > 1 ||
				escaped_len > 1)));
  }
};
101

102 103 104 105 106 107 108
/*
  Binary log consists of events. Each event has a fixed length header,
  followed by possibly variable ( depending on the type of event) length
  data body. The data body consists of an optional fixed length segment
  (post-header), and an optional variable length segment. See #defines and
  comments below for the format specifics
*/
109

110 111
/* event-specific post-header sizes */
#define LOG_EVENT_HEADER_LEN 19
112
#define OLD_HEADER_LEN       13
113
#define QUERY_HEADER_LEN     (4 + 4 + 1 + 2)
114
#define LOAD_HEADER_LEN      (4 + 4 + 4 + 1 +1 + 4)
115
#define START_HEADER_LEN     (2 + ST_SERVER_VER_LEN + 4)
116
#define ROTATE_HEADER_LEN    8
117 118 119 120
#define CREATE_FILE_HEADER_LEN 4
#define APPEND_BLOCK_HEADER_LEN 4
#define EXEC_LOAD_HEADER_LEN   4
#define DELETE_FILE_HEADER_LEN 4
121 122

/* event header offsets */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
123

124
#define EVENT_TYPE_OFFSET    4
125 126
#define SERVER_ID_OFFSET     5
#define EVENT_LEN_OFFSET     9
127
#define LOG_POS_OFFSET       13
128 129 130 131 132 133 134 135 136 137
#define FLAGS_OFFSET         17

/* start event post-header */

#define ST_BINLOG_VER_OFFSET  0
#define ST_SERVER_VER_OFFSET  2
#define ST_CREATED_OFFSET     (ST_SERVER_VER_OFFSET + ST_SERVER_VER_LEN)

/* slave event post-header */

138 139 140
#define SL_MASTER_PORT_OFFSET   8
#define SL_MASTER_POS_OFFSET    0
#define SL_MASTER_HOST_OFFSET   10
141 142 143

/* query event post-header */

144 145 146 147 148
#define Q_THREAD_ID_OFFSET	0
#define Q_EXEC_TIME_OFFSET	4
#define Q_DB_LEN_OFFSET		8
#define Q_ERR_CODE_OFFSET	9
#define Q_DATA_OFFSET		QUERY_HEADER_LEN
149 150 151 152 153 154

/* Intvar event post-header */

#define I_TYPE_OFFSET        0
#define I_VAL_OFFSET         1

nick@mysql.com's avatar
nick@mysql.com committed
155 156 157 158 159
/* Rand event post-header */

#define RAND_SEED1_OFFSET 0
#define RAND_SEED2_OFFSET 8

160 161 162 163 164
/* Load event post-header */

#define L_THREAD_ID_OFFSET   0
#define L_EXEC_TIME_OFFSET   4
#define L_SKIP_LINES_OFFSET  8
165 166
#define L_TBL_LEN_OFFSET     12
#define L_DB_LEN_OFFSET      13
167
#define L_NUM_FIELDS_OFFSET  14
168
#define L_SQL_EX_OFFSET      18
169
#define L_DATA_OFFSET        LOAD_HEADER_LEN
170

171 172 173 174
/* Rotate event post-header */

#define R_POS_OFFSET       0
#define R_IDENT_OFFSET     8
175

176 177 178 179 180 181 182 183 184
#define CF_FILE_ID_OFFSET  0
#define CF_DATA_OFFSET     CREATE_FILE_HEADER_LEN

#define AB_FILE_ID_OFFSET  0
#define AB_DATA_OFFSET     APPEND_BLOCK_HEADER_LEN

#define EL_FILE_ID_OFFSET  0

#define DF_FILE_ID_OFFSET  0
185

186 187 188 189
#define QUERY_EVENT_OVERHEAD	(LOG_EVENT_HEADER_LEN+QUERY_HEADER_LEN)
#define QUERY_DATA_OFFSET	(LOG_EVENT_HEADER_LEN+QUERY_HEADER_LEN)
#define ROTATE_EVENT_OVERHEAD	(LOG_EVENT_HEADER_LEN+ROTATE_HEADER_LEN)
#define LOAD_EVENT_OVERHEAD	(LOG_EVENT_HEADER_LEN+LOAD_HEADER_LEN)
190 191 192 193 194 195
#define CREATE_FILE_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+\
 +LOAD_HEADER_LEN+CREATE_FILE_HEADER_LEN)
#define DELETE_FILE_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+DELETE_FILE_HEADER_LEN)
#define EXEC_LOAD_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+EXEC_LOAD_HEADER_LEN)
#define APPEND_BLOCK_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+APPEND_BLOCK_HEADER_LEN)

196

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
197
#define BINLOG_MAGIC        "\xfe\x62\x69\x6e"
198

199
#define LOG_EVENT_TIME_F           0x1
200
#define LOG_EVENT_FORCED_ROTATE_F  0x2
201

202 203 204 205 206
enum Log_event_type
{
  START_EVENT = 1, QUERY_EVENT =2, STOP_EVENT=3, ROTATE_EVENT = 4,
  INTVAR_EVENT=5, LOAD_EVENT=6, SLAVE_EVENT=7, CREATE_FILE_EVENT=8,
  APPEND_BLOCK_EVENT=9, EXEC_LOAD_EVENT=10, DELETE_FILE_EVENT=11,
nick@mysql.com's avatar
nick@mysql.com committed
207
  NEW_LOAD_EVENT=12, RAND_EVENT=13
208 209 210 211 212 213 214
};

enum Int_event_type
{
  INVALID_INT_EVENT = 0, LAST_INSERT_ID_EVENT = 1, INSERT_ID_EVENT = 2
};

bk@work.mysql.com's avatar
bk@work.mysql.com committed
215 216 217

#ifndef MYSQL_CLIENT
class String;
218 219
class MYSQL_LOG;
class THD;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
220 221
#endif

222
struct st_relay_log_info;
223

bk@work.mysql.com's avatar
bk@work.mysql.com committed
224 225 226 227 228
class Log_event
{
public:
  time_t when;
  ulong exec_time;
229
  uint32 server_id;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
230
  my_off_t log_pos;
231
  uint16 flags;
232 233
  int cached_event_len;
  char* temp_buf;
234 235

#ifndef MYSQL_CLIENT
236
  THD* thd;
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259

  Log_event(THD* thd_arg, uint16 flags_arg = 0);
  // if mutex is 0, the read will proceed without mutex
  static Log_event* read_log_event(IO_CACHE* file,
				   pthread_mutex_t* log_lock,
				   bool old_format);
  static int read_log_event(IO_CACHE* file, String* packet,
			    pthread_mutex_t* log_lock);
  void set_log_pos(MYSQL_LOG* log);
  virtual void pack_info(String* packet);
  int net_send(THD* thd, const char* log_name, my_off_t pos);
  static void init_show_field_list(List<Item>* field_list);
  virtual int exec_event(struct st_relay_log_info* rli);
  virtual const char* get_db()
  {
    return thd ? thd->db : 0;
  }
#else
 // avoid having to link mysqlbinlog against libpthread
  static Log_event* read_log_event(IO_CACHE* file, bool old_format);
  virtual void print(FILE* file, bool short_form = 0, char* last_db = 0) = 0;
  void print_timestamp(FILE* file, time_t *ts = 0);
  void print_header(FILE* file);
260
#endif  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
261

262 263 264 265 266 267
  static void *operator new(size_t size)
  {
    return (void*) my_malloc((uint)size, MYF(MY_WME|MY_FAE));
  }
  static void operator delete(void *ptr, size_t size)
  {
268
    my_free((gptr) ptr, MYF(MY_WME|MY_ALLOW_ZERO_PTR));
269 270
  }
  
271 272
  int write(IO_CACHE* file);
  int write_header(IO_CACHE* file);
273
  virtual int write_data(IO_CACHE* file)
274
  { return write_data_header(file) || write_data_body(file); }
275
  virtual int write_data_header(IO_CACHE* file __attribute__((unused)))
276
  { return 0; }
277
  virtual int write_data_body(IO_CACHE* file __attribute__((unused)))
278
  { return 0; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
279
  virtual Log_event_type get_type_code() = 0;
280
  virtual bool is_valid() = 0;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
281
  virtual bool get_cache_stmt() { return 0; }
282
  Log_event(const char* buf, bool old_format);
283 284 285
  virtual ~Log_event() { free_temp_buf();}
  void register_temp_buf(char* buf) { temp_buf = buf; }
  void free_temp_buf()
286 287
  {
    if (temp_buf)
288
    {
289 290
      my_free(temp_buf, MYF(0));
      temp_buf = 0;
291
    }
292
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
293
  virtual int get_data_size() { return 0;}
294
  virtual int get_data_body_offset() { return 0; }
295 296 297 298 299
  int get_event_len()
  {
    return (cached_event_len ? cached_event_len :
	    (cached_event_len = LOG_EVENT_HEADER_LEN + get_data_size()));
  }
300
  static Log_event* read_log_event(const char* buf, int event_len,
301
				   const char **error, bool old_format);
302
  const char* get_type_str();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
303 304 305 306 307 308 309 310 311 312
};


class Query_log_event: public Log_event
{
protected:
  char* data_buf;
public:
  const char* query;
  const char* db;
313 314 315 316 317 318
  /*
    If we already know the length of the query string
    we pass it with q_len, so we would not have to call strlen()
    otherwise, set it to 0, in which case, we compute it with strlen()
  */
  uint32 q_len;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
319
  uint32 db_len;
320
  uint16 error_code;
321
  ulong thread_id;
322
#ifndef MYSQL_CLIENT
323
  bool cache_stmt;
324

325 326
  Query_log_event(THD* thd_arg, const char* query_arg, ulong query_length,
		  bool using_trans=0);
327
  const char* get_db() { return db; }
328
  void pack_info(String* packet);
329
  int exec_event(struct st_relay_log_info* rli);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
330
  bool get_cache_stmt() { return cache_stmt; }
331 332
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
333 334
#endif

335
  Query_log_event(const char* buf, int event_len, bool old_format);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
336 337 338 339
  ~Query_log_event()
  {
    if (data_buf)
    {
340
      my_free((gptr) data_buf, MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
341 342 343
    }
  }
  Log_event_type get_type_code() { return QUERY_EVENT; }
344 345
  int write(IO_CACHE* file);
  int write_data(IO_CACHE* file); // returns 0 on success, -1 on error
346
  bool is_valid() { return query != 0; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
347 348
  int get_data_size()
  {
349 350 351 352 353
    return (q_len + db_len + 2
	    + 4	// thread_id
	    + 4	// exec_time
	    + 2	// error_code
	    );
bk@work.mysql.com's avatar
bk@work.mysql.com committed
354 355 356
  }
};

357

358 359 360 361 362 363
class Slave_log_event: public Log_event
{
protected:
  char* mem_pool;
  void init_from_mem_pool(int data_size);
public:
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
364
  my_off_t master_pos;
365 366
  char* master_host;
  char* master_log;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
367
  int master_host_len;
368
  int master_log_len;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
369
  uint16 master_port;
370 371

#ifndef MYSQL_CLIENT  
372
  Slave_log_event(THD* thd_arg, struct st_relay_log_info* rli);
373
  void pack_info(String* packet);
374
  int exec_event(struct st_relay_log_info* rli);
375 376 377 378
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif  

379 380 381
  Slave_log_event(const char* buf, int event_len);
  ~Slave_log_event();
  int get_data_size();
382
  bool is_valid() { return master_host != 0; }
383 384 385 386
  Log_event_type get_type_code() { return SLAVE_EVENT; }
  int write_data(IO_CACHE* file );
};

bk@work.mysql.com's avatar
bk@work.mysql.com committed
387 388 389
class Load_log_event: public Log_event
{
protected:
390
  int copy_log_event(const char *buf, ulong event_len, bool old_format);
391

bk@work.mysql.com's avatar
bk@work.mysql.com committed
392
public:
393
  ulong thread_id;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
394 395 396 397
  uint32 table_name_len;
  uint32 db_len;
  uint32 fname_len;
  uint32 num_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
398 399
  const char* fields;
  const uchar* field_lens;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
400
  uint32 field_block_len;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
401 402 403 404

  const char* table_name;
  const char* db;
  const char* fname;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
405
  uint32 skip_lines;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
406 407
  sql_ex_info sql_ex;
  
408
#ifndef MYSQL_CLIENT
bk@work.mysql.com's avatar
bk@work.mysql.com committed
409 410
  String field_lens_buf;
  String fields_buf;
411 412
  
  Load_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
413
		 const char* table_name_arg,
414
		 List<Item>& fields_arg, enum enum_duplicates handle_dup);
415
  void set_fields(List<Item> &fields_arg);
416
  void pack_info(String* packet);
417
  const char* get_db() { return db; }
418
  int exec_event(struct st_relay_log_info* rli)
419 420 421
  {
    return exec_event(thd->slave_net,rli);
  }
422
  int exec_event(NET* net, struct st_relay_log_info* rli);
423 424
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
425 426
#endif

427
  Load_log_event(const char* buf, int event_len, bool old_format);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
428
  ~Load_log_event()
429
  {}
430 431
  Log_event_type get_type_code() { return sql_ex.new_format() ?
				     NEW_LOAD_EVENT: LOAD_EVENT; }
432 433 434
  int write_data_header(IO_CACHE* file); 
  int write_data_body(IO_CACHE* file); 
  bool is_valid() { return table_name != 0; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
435 436
  int get_data_size()
  {
437 438 439 440 441 442
    return (table_name_len + 2 + db_len + 2 + fname_len
	    + 4 // thread_id
	    + 4 // exec_time
	    + 4 // skip_lines
	    + 4 // field block len
	    + sql_ex.data_size() + field_block_len + num_fields);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
443
  }
444
  int get_data_body_offset() { return LOAD_EVENT_OVERHEAD; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
445 446
};

447
extern char server_version[SERVER_VERSION_LENGTH];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
448 449 450 451

class Start_log_event: public Log_event
{
public:
452
  uint32 created;
453
  uint16 binlog_version;
454
  char server_version[ST_SERVER_VER_LEN];
455 456

#ifndef MYSQL_CLIENT
457
  Start_log_event() :Log_event((THD*)0),binlog_version(BINLOG_VERSION)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
458
  {
459
    created = (uint32) when;
460
    memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
461
  }
462 463 464 465
  void pack_info(String* packet);
  int exec_event(struct st_relay_log_info* rli);
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
466
#endif  
467

468
  Start_log_event(const char* buf, bool old_format);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
469 470
  ~Start_log_event() {}
  Log_event_type get_type_code() { return START_EVENT;}
471
  int write_data(IO_CACHE* file);
472
  bool is_valid() { return 1; }
473 474
  int get_data_size()
  {
475
    return START_HEADER_LEN;
476
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
477 478
};

479

bk@work.mysql.com's avatar
bk@work.mysql.com committed
480 481 482 483 484
class Intvar_log_event: public Log_event
{
public:
  ulonglong val;
  uchar type;
485

486 487 488
#ifndef MYSQL_CLIENT  
  Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg)
    :Log_event(thd_arg),val(val_arg),type(type_arg)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
489
  {}
490 491 492 493 494 495
  void pack_info(String* packet);
  int exec_event(struct st_relay_log_info* rli);
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif  

496
  Intvar_log_event(const char* buf, bool old_format);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
497 498
  ~Intvar_log_event() {}
  Log_event_type get_type_code() { return INTVAR_EVENT;}
499
  const char* get_var_type_name();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
500
  int get_data_size() { return  sizeof(type) + sizeof(val);}
501
  int write_data(IO_CACHE* file);
502
  bool is_valid() { return 1; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
503 504
};

nick@mysql.com's avatar
nick@mysql.com committed
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
/*****************************************************************************
 *
 *  Rand log event class
 *
 ****************************************************************************/
class Rand_log_event: public Log_event
{
 public:
  ulonglong seed1;
  ulonglong seed2;

#ifndef MYSQL_CLIENT
  Rand_log_event(THD* thd_arg, ulonglong seed1_arg, ulonglong seed2_arg)
    :Log_event(thd_arg),seed1(seed1_arg),seed2(seed2_arg)
  {}
  void pack_info(String* packet);
  int exec_event(struct st_relay_log_info* rli);
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif

  Rand_log_event(const char* buf, bool old_format);
  ~Rand_log_event() {}
  Log_event_type get_type_code() { return RAND_EVENT;}
  int get_data_size() { return sizeof(ulonglong) * 2; }
  int write_data(IO_CACHE* file);
  bool is_valid() { return 1; }
};

bk@work.mysql.com's avatar
bk@work.mysql.com committed
534 535 536
class Stop_log_event: public Log_event
{
public:
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
537
#ifndef MYSQL_CLIENT
538
  Stop_log_event() :Log_event((THD*)0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
539
  {}
540 541 542
  int exec_event(struct st_relay_log_info* rli);
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
543
#endif  
544 545 546 547

  Stop_log_event(const char* buf, bool old_format):
    Log_event(buf, old_format)
  {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
548 549
  ~Stop_log_event() {}
  Log_event_type get_type_code() { return STOP_EVENT;}
550
  bool is_valid() { return 1; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
551 552
};

553

bk@work.mysql.com's avatar
bk@work.mysql.com committed
554 555 556 557
class Rotate_log_event: public Log_event
{
public:
  const char* new_log_ident;
558
  ulonglong pos;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
559
  uint ident_len;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
560
  bool alloced;
561 562
#ifndef MYSQL_CLIENT  
  Rotate_log_event(THD* thd_arg, const char* new_log_ident_arg,
563 564
		   uint ident_len_arg = 0,ulonglong pos_arg = 4)
    : Log_event(thd_arg), new_log_ident(new_log_ident_arg),
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
565 566
    pos(pos_arg),ident_len(ident_len_arg ? ident_len_arg :
			   (uint) strlen(new_log_ident_arg)), alloced(0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
567
  {}
568 569 570 571 572 573
  void pack_info(String* packet);
  int exec_event(struct st_relay_log_info* rli);
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif

574
  Rotate_log_event(const char* buf, int event_len, bool old_format);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
575 576 577 578 579 580
  ~Rotate_log_event()
  {
    if (alloced)
      my_free((gptr) new_log_ident, MYF(0));
  }
  Log_event_type get_type_code() { return ROTATE_EVENT;}
581
  int get_data_size() { return  ident_len + ROTATE_HEADER_LEN;}
582
  bool is_valid() { return new_log_ident != 0; }
583
  int write_data(IO_CACHE* file);
584 585 586 587
};

/* the classes below are for the new LOAD DATA INFILE logging */

588
class Create_file_log_event: public Load_log_event
589
{
590
protected:
591 592 593 594 595
  /*
    Pretend we are Load event, so we can write out just
    our Load part - used on the slave when writing event out to
    SQL_LOAD-*.info file
  */
596
  bool fake_base; 
597 598 599 600
public:
  char* block;
  uint block_len;
  uint file_id;
601
  bool inited_from_old;
602

603 604
#ifndef MYSQL_CLIENT
  Create_file_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
605 606 607 608
			const char* table_name_arg,
			List<Item>& fields_arg,
			enum enum_duplicates handle_dup,
			char* block_arg, uint block_len_arg);
609 610 611 612
  void pack_info(String* packet);
  int exec_event(struct st_relay_log_info* rli);
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
613
#endif  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
614
  
615
  Create_file_log_event(const char* buf, int event_len, bool old_format);
616 617 618
  ~Create_file_log_event() {}

  Log_event_type get_type_code()
619
  {
620 621 622 623 624 625 626 627 628 629 630 631
    return fake_base ? Load_log_event::get_type_code() : CREATE_FILE_EVENT;
  }
  int get_data_size()
  {
    return (fake_base ? Load_log_event::get_data_size() :
	    Load_log_event::get_data_size() +
	    4 + 1 + block_len);
  }
  int get_data_body_offset()
  {
    return (fake_base ? LOAD_EVENT_OVERHEAD:
	    LOAD_EVENT_OVERHEAD + CREATE_FILE_HEADER_LEN);
632
  }
633
  bool is_valid() { return inited_from_old || block != 0; }
634 635
  int write_data_header(IO_CACHE* file);
  int write_data_body(IO_CACHE* file);
636 637 638 639 640
  /*
    Cut out Create_file extentions and
    write it as Load event - used on the slave
  */
  int write_base(IO_CACHE* file);
641 642
};

643

644 645 646 647 648 649 650 651 652
class Append_block_log_event: public Log_event
{
public:
  char* block;
  uint block_len;
  uint file_id;
  
#ifndef MYSQL_CLIENT
  Append_block_log_event(THD* thd, char* block_arg,
653
			 uint block_len_arg);
654
  int exec_event(struct st_relay_log_info* rli);
655 656 657 658
  void pack_info(String* packet);
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif
659 660
  
  Append_block_log_event(const char* buf, int event_len);
661
  ~Append_block_log_event() {}
662 663 664 665 666 667
  Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;}
  int get_data_size() { return  block_len + APPEND_BLOCK_HEADER_LEN ;}
  bool is_valid() { return block != 0; }
  int write_data(IO_CACHE* file);
};

668

669 670 671 672 673 674 675
class Delete_file_log_event: public Log_event
{
public:
  uint file_id;
  
#ifndef MYSQL_CLIENT
  Delete_file_log_event(THD* thd);
676 677 678 679
  void pack_info(String* packet);
  int exec_event(struct st_relay_log_info* rli);
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
680 681 682
#endif  
  
  Delete_file_log_event(const char* buf, int event_len);
683
  ~Delete_file_log_event() {}
684 685 686 687 688 689 690 691 692 693 694 695 696
  Log_event_type get_type_code() { return DELETE_FILE_EVENT;}
  int get_data_size() { return DELETE_FILE_HEADER_LEN ;}
  bool is_valid() { return file_id != 0; }
  int write_data(IO_CACHE* file);
};

class Execute_load_log_event: public Log_event
{
public:
  uint file_id;
  
#ifndef MYSQL_CLIENT
  Execute_load_log_event(THD* thd);
697 698 699 700
  void pack_info(String* packet);
  int exec_event(struct st_relay_log_info* rli);
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
701 702 703
#endif  
  
  Execute_load_log_event(const char* buf, int event_len);
704
  ~Execute_load_log_event() {}
705 706 707
  Log_event_type get_type_code() { return EXEC_LOAD_EVENT;}
  int get_data_size() { return  EXEC_LOAD_HEADER_LEN ;}
  bool is_valid() { return file_id != 0; }
708
  int write_data(IO_CACHE* file);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
709 710
};

711
#endif /* _log_event_h */