log_event.h 24.9 KB
Newer Older
unknown's avatar
unknown 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
unknown's avatar
unknown committed
20

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

unknown's avatar
unknown 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
unknown's avatar
unknown committed
33
#define LOG_READ_TRUNC  -6
unknown's avatar
unknown committed
34
#define LOG_READ_TOO_LARGE -7
unknown's avatar
unknown 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 58 59 60 61
/*****************************************************************************

  old_sql_ex struct

 ****************************************************************************/
62
struct old_sql_ex
63 64 65 66 67 68 69 70 71
{
  char field_term;
  char enclosed;
  char line_term;
  char line_start;
  char escaped;
  char opt_flags;
  char empty_flags;
};
72

unknown's avatar
unknown committed
73 74
#define NUM_LOAD_DELIM_STRS 5

75 76 77 78 79
/*****************************************************************************

  sql_ex_info struct

 ****************************************************************************/
80
struct sql_ex_info
81 82 83 84 85 86 87 88 89 90
{
  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;
91
    
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
  // 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)));
  }
};
111

112 113 114 115 116 117 118 119 120 121 122 123 124
/*****************************************************************************

  MySQL Binary Log

  This log consists of events.  Each event has a fixed-length header,
  possibly followed by a variable length data body.

  The data body consists of an optional fixed length segment (post-header)
  and  an optional variable length segment.

  See the #defines below for the format specifics.

 ****************************************************************************/
125

126 127
/* event-specific post-header sizes */
#define LOG_EVENT_HEADER_LEN 19
128
#define OLD_HEADER_LEN       13
129
#define QUERY_HEADER_LEN     (4 + 4 + 1 + 2)
130
#define LOAD_HEADER_LEN      (4 + 4 + 4 + 1 +1 + 4)
131
#define START_HEADER_LEN     (2 + ST_SERVER_VER_LEN + 4)
132
#define ROTATE_HEADER_LEN    8
133 134 135 136
#define CREATE_FILE_HEADER_LEN 4
#define APPEND_BLOCK_HEADER_LEN 4
#define EXEC_LOAD_HEADER_LEN   4
#define DELETE_FILE_HEADER_LEN 4
137 138

/* event header offsets */
unknown's avatar
unknown committed
139

140
#define EVENT_TYPE_OFFSET    4
141 142
#define SERVER_ID_OFFSET     5
#define EVENT_LEN_OFFSET     9
143
#define LOG_POS_OFFSET       13
144 145 146 147 148 149 150 151 152 153
#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 */

unknown's avatar
unknown committed
154 155 156
#define SL_MASTER_PORT_OFFSET   8
#define SL_MASTER_POS_OFFSET    0
#define SL_MASTER_HOST_OFFSET   10
157 158 159

/* query event post-header */

160 161 162 163 164
#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
165 166 167 168 169 170

/* Intvar event post-header */

#define I_TYPE_OFFSET        0
#define I_VAL_OFFSET         1

unknown's avatar
unknown committed
171 172 173 174 175
/* Rand event post-header */

#define RAND_SEED1_OFFSET 0
#define RAND_SEED2_OFFSET 8

unknown's avatar
unknown committed
176 177 178 179 180 181 182 183
/* User_var event post-header */

#define UV_VAL_LEN_SIZE        4
#define UV_VAL_IS_NULL         1
#define UV_VAL_TYPE_SIZE       1
#define UV_NAME_LEN_SIZE       4
#define UV_CHARSET_NUMBER_SIZE 4

184 185 186 187 188
/* Load event post-header */

#define L_THREAD_ID_OFFSET   0
#define L_EXEC_TIME_OFFSET   4
#define L_SKIP_LINES_OFFSET  8
unknown's avatar
unknown committed
189 190
#define L_TBL_LEN_OFFSET     12
#define L_DB_LEN_OFFSET      13
191
#define L_NUM_FIELDS_OFFSET  14
192
#define L_SQL_EX_OFFSET      18
193
#define L_DATA_OFFSET        LOAD_HEADER_LEN
194

195 196 197 198
/* Rotate event post-header */

#define R_POS_OFFSET       0
#define R_IDENT_OFFSET     8
199

200 201 202 203 204 205 206 207 208
#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
209

210 211 212 213
#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)
214 215 216 217 218 219
#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)

220

unknown's avatar
unknown committed
221
#define BINLOG_MAGIC        "\xfe\x62\x69\x6e"
222

unknown's avatar
unknown committed
223 224 225 226
#define LOG_EVENT_TIME_F            0x1
#define LOG_EVENT_FORCED_ROTATE_F   0x2
#define LOG_EVENT_THREAD_SPECIFIC_F 0x4 /* query depends on thread  
                                           (for example: TEMPORARY TABLE) */
227

228 229 230 231 232
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,
unknown's avatar
unknown committed
233
  NEW_LOAD_EVENT=12, RAND_EVENT=13, USER_VAR_EVENT=14
234 235 236 237 238 239 240
};

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

unknown's avatar
unknown committed
241 242 243

#ifndef MYSQL_CLIENT
class String;
244 245
class MYSQL_LOG;
class THD;
unknown's avatar
unknown committed
246 247
#endif

248
struct st_relay_log_info;
249

250 251 252 253 254 255 256
/*****************************************************************************

  Log_event class

  This is the abstract base class for binary log events.

 ****************************************************************************/
unknown's avatar
unknown committed
257 258 259
class Log_event
{
public:
260 261
  my_off_t log_pos;
  char *temp_buf;
unknown's avatar
unknown committed
262 263
  time_t when;
  ulong exec_time;
264
  uint32 server_id;
265
  uint cached_event_len;
266
  uint16 flags;
267
  bool cache_stmt;
268
#ifndef MYSQL_CLIENT
269
  THD* thd;
270

271 272
  Log_event(THD* thd_arg, uint16 flags_arg, bool cache_stmt);
  Log_event();
273 274 275 276 277 278 279 280
  // 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);
  static void init_show_field_list(List<Item>* field_list);
unknown's avatar
SCRUM  
unknown committed
281
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
282 283
  int net_send(Protocol *protocol, const char* log_name, my_off_t pos);
  virtual void pack_info(Protocol *protocol);
284
  virtual int exec_event(struct st_relay_log_info* rli);
unknown's avatar
SCRUM  
unknown committed
285
#endif /* HAVE_REPLICATION */
286 287 288 289 290 291 292 293 294 295
  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);
296
#endif  
unknown's avatar
unknown committed
297

298 299 300 301 302 303
  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)
  {
304
    my_free((gptr) ptr, MYF(MY_WME|MY_ALLOW_ZERO_PTR));
305 306
  }
  
307 308
  int write(IO_CACHE* file);
  int write_header(IO_CACHE* file);
309
  virtual int write_data(IO_CACHE* file)
310
  { return write_data_header(file) || write_data_body(file); }
311
  virtual int write_data_header(IO_CACHE* file __attribute__((unused)))
312
  { return 0; }
313
  virtual int write_data_body(IO_CACHE* file __attribute__((unused)))
314
  { return 0; }
unknown's avatar
unknown committed
315
  virtual Log_event_type get_type_code() = 0;
316
  virtual bool is_valid() = 0;
317
  inline bool get_cache_stmt() { return cache_stmt; }
318
  Log_event(const char* buf, bool old_format);
319 320 321
  virtual ~Log_event() { free_temp_buf();}
  void register_temp_buf(char* buf) { temp_buf = buf; }
  void free_temp_buf()
322 323
  {
    if (temp_buf)
324
    {
325 326
      my_free(temp_buf, MYF(0));
      temp_buf = 0;
327
    }
328
  }
unknown's avatar
unknown committed
329
  virtual int get_data_size() { return 0;}
330
  virtual int get_data_body_offset() { return 0; }
331 332 333 334 335
  int get_event_len()
  {
    return (cached_event_len ? cached_event_len :
	    (cached_event_len = LOG_EVENT_HEADER_LEN + get_data_size()));
  }
336
  static Log_event* read_log_event(const char* buf, int event_len,
337
				   const char **error, bool old_format);
unknown's avatar
unknown committed
338
  const char* get_type_str();
unknown's avatar
unknown committed
339 340 341
};


342 343 344 345 346 347 348
/*****************************************************************************

  Query Log Event class

  Logs SQL queries

 ****************************************************************************/
unknown's avatar
unknown committed
349 350 351 352 353 354 355
class Query_log_event: public Log_event
{
protected:
  char* data_buf;
public:
  const char* query;
  const char* db;
356 357 358 359 360 361
  /*
    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;
unknown's avatar
unknown committed
362
  uint32 db_len;
363
  uint16 error_code;
364
  ulong thread_id;
365
#ifndef MYSQL_CLIENT
366

367
  Query_log_event(THD* thd_arg, const char* query_arg, ulong query_length,
368
		  bool using_trans);
369
  const char* get_db() { return db; }
unknown's avatar
SCRUM  
unknown committed
370
#ifdef HAVE_REPLICATION
371
  void pack_info(Protocol* protocol);
372
  int exec_event(struct st_relay_log_info* rli);
unknown's avatar
SCRUM  
unknown committed
373
#endif /* HAVE_REPLICATION */
374 375
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
unknown's avatar
unknown committed
376 377
#endif

378
  Query_log_event(const char* buf, int event_len, bool old_format);
unknown's avatar
unknown committed
379 380 381 382
  ~Query_log_event()
  {
    if (data_buf)
    {
383
      my_free((gptr) data_buf, MYF(0));
unknown's avatar
unknown committed
384 385 386
    }
  }
  Log_event_type get_type_code() { return QUERY_EVENT; }
387 388
  int write(IO_CACHE* file);
  int write_data(IO_CACHE* file); // returns 0 on success, -1 on error
389
  bool is_valid() { return query != 0; }
unknown's avatar
unknown committed
390 391
  int get_data_size()
  {
392 393 394 395 396
    return (q_len + db_len + 2
	    + 4	// thread_id
	    + 4	// exec_time
	    + 2	// error_code
	    );
unknown's avatar
unknown committed
397 398 399
  }
};

unknown's avatar
SCRUM  
unknown committed
400
#ifdef HAVE_REPLICATION
401

402 403 404 405 406
/*****************************************************************************

  Slave Log Event class

 ****************************************************************************/
407 408 409 410 411 412
class Slave_log_event: public Log_event
{
protected:
  char* mem_pool;
  void init_from_mem_pool(int data_size);
public:
unknown's avatar
unknown committed
413
  my_off_t master_pos;
414 415
  char* master_host;
  char* master_log;
unknown's avatar
unknown committed
416
  int master_host_len;
417
  int master_log_len;
unknown's avatar
unknown committed
418
  uint16 master_port;
419 420

#ifndef MYSQL_CLIENT  
421
  Slave_log_event(THD* thd_arg, struct st_relay_log_info* rli);
422
  void pack_info(Protocol* protocol);
423
  int exec_event(struct st_relay_log_info* rli);
424 425 426 427
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif  

428 429 430
  Slave_log_event(const char* buf, int event_len);
  ~Slave_log_event();
  int get_data_size();
431
  bool is_valid() { return master_host != 0; }
432 433 434 435
  Log_event_type get_type_code() { return SLAVE_EVENT; }
  int write_data(IO_CACHE* file );
};

unknown's avatar
SCRUM  
unknown committed
436
#endif /* HAVE_REPLICATION */
437

438 439 440 441 442 443

/*****************************************************************************

  Load Log Event class

 ****************************************************************************/
unknown's avatar
unknown committed
444 445 446
class Load_log_event: public Log_event
{
protected:
447
  int copy_log_event(const char *buf, ulong event_len, bool old_format);
448

unknown's avatar
unknown committed
449
public:
450
  ulong thread_id;
unknown's avatar
unknown committed
451 452 453 454
  uint32 table_name_len;
  uint32 db_len;
  uint32 fname_len;
  uint32 num_fields;
unknown's avatar
unknown committed
455 456
  const char* fields;
  const uchar* field_lens;
unknown's avatar
unknown committed
457
  uint32 field_block_len;
unknown's avatar
unknown committed
458 459 460 461

  const char* table_name;
  const char* db;
  const char* fname;
unknown's avatar
unknown committed
462
  uint32 skip_lines;
unknown's avatar
unknown committed
463
  sql_ex_info sql_ex;
464

465 466 467 468 469 470 471
  /* fname doesn't point to memory inside Log_event::temp_buf  */
  void set_fname_outside_temp_buf(const char *afname, uint alen)
    {fname=afname;fname_len=alen;}
  /* fname doesn't point to memory inside Log_event::temp_buf  */
  int  check_fname_outside_temp_buf()
    {return fname<temp_buf || fname>temp_buf+cached_event_len;}

472
#ifndef MYSQL_CLIENT
unknown's avatar
unknown committed
473 474
  String field_lens_buf;
  String fields_buf;
475 476
  
  Load_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
477
		 const char* table_name_arg,
478 479
		 List<Item>& fields_arg, enum enum_duplicates handle_dup,
		 bool using_trans);
unknown's avatar
unknown committed
480
  void set_fields(List<Item> &fields_arg);
481
  const char* get_db() { return db; }
unknown's avatar
SCRUM  
unknown committed
482
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
483
  void pack_info(Protocol* protocol);
484
  int exec_event(struct st_relay_log_info* rli)
485
  {
486
    return exec_event(thd->slave_net,rli,0);
487
  }
488 489
  int exec_event(NET* net, struct st_relay_log_info* rli, 
		 bool use_rli_only_for_errors);
unknown's avatar
SCRUM  
unknown committed
490
#endif /* HAVE_REPLICATION */
491 492
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
unknown's avatar
unknown committed
493 494
#endif

495
  Load_log_event(const char* buf, int event_len, bool old_format);
unknown's avatar
unknown committed
496
  ~Load_log_event()
497
  {}
498 499 500 501
  Log_event_type get_type_code()
  {
    return sql_ex.new_format() ? NEW_LOAD_EVENT: LOAD_EVENT;
  }
502 503 504
  int write_data_header(IO_CACHE* file); 
  int write_data_body(IO_CACHE* file); 
  bool is_valid() { return table_name != 0; }
unknown's avatar
unknown committed
505 506
  int get_data_size()
  {
507 508 509 510 511 512
    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);
unknown's avatar
unknown committed
513
  }
514
  int get_data_body_offset() { return LOAD_EVENT_OVERHEAD; }
unknown's avatar
unknown committed
515 516
};

unknown's avatar
unknown committed
517
extern char server_version[SERVER_VERSION_LENGTH];
unknown's avatar
unknown committed
518

519 520 521 522 523
/*****************************************************************************

  Start Log Event class

 ****************************************************************************/
unknown's avatar
unknown committed
524 525 526
class Start_log_event: public Log_event
{
public:
527
  uint32 created;
528
  uint16 binlog_version;
529
  char server_version[ST_SERVER_VER_LEN];
530 531

#ifndef MYSQL_CLIENT
532
  Start_log_event() :Log_event(), binlog_version(BINLOG_VERSION)
unknown's avatar
unknown committed
533
  {
534
    created = (uint32) when;
535
    memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
unknown's avatar
unknown committed
536
  }
unknown's avatar
SCRUM  
unknown committed
537
#ifdef HAVE_REPLICATION
538
  void pack_info(Protocol* protocol);
539
  int exec_event(struct st_relay_log_info* rli);
unknown's avatar
SCRUM  
unknown committed
540
#endif /* HAVE_REPLICATION */
541 542
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
543
#endif  
544

545
  Start_log_event(const char* buf, bool old_format);
unknown's avatar
unknown committed
546 547
  ~Start_log_event() {}
  Log_event_type get_type_code() { return START_EVENT;}
548
  int write_data(IO_CACHE* file);
549
  bool is_valid() { return 1; }
550 551
  int get_data_size()
  {
552
    return START_HEADER_LEN;
553
  }
unknown's avatar
unknown committed
554 555
};

556

557 558 559 560 561 562 563
/*****************************************************************************

  Intvar Log Event class

  Logs special variables such as auto_increment values

 ****************************************************************************/
unknown's avatar
unknown committed
564 565 566 567 568
class Intvar_log_event: public Log_event
{
public:
  ulonglong val;
  uchar type;
569

570 571
#ifndef MYSQL_CLIENT  
  Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg)
572
    :Log_event(),val(val_arg),type(type_arg)
unknown's avatar
unknown committed
573
  {}
unknown's avatar
SCRUM  
unknown committed
574
#ifdef HAVE_REPLICATION
575
  void pack_info(Protocol* protocol);
576
  int exec_event(struct st_relay_log_info* rli);
unknown's avatar
SCRUM  
unknown committed
577
#endif /* HAVE_REPLICATION */
578 579 580 581
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif  

582
  Intvar_log_event(const char* buf, bool old_format);
unknown's avatar
unknown committed
583 584
  ~Intvar_log_event() {}
  Log_event_type get_type_code() { return INTVAR_EVENT;}
unknown's avatar
unknown committed
585
  const char* get_var_type_name();
unknown's avatar
unknown committed
586
  int get_data_size() { return  sizeof(type) + sizeof(val);}
587
  int write_data(IO_CACHE* file);
588
  bool is_valid() { return 1; }
unknown's avatar
unknown committed
589 590
};

unknown's avatar
unknown committed
591
/*****************************************************************************
592 593 594 595 596

  Rand Log Event class

  Logs random seed used by the next RAND()

unknown's avatar
unknown committed
597 598 599 600 601 602 603 604 605
 ****************************************************************************/
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)
606
    :Log_event(thd_arg,0,0),seed1(seed1_arg),seed2(seed2_arg)
unknown's avatar
unknown committed
607
  {}
unknown's avatar
SCRUM  
unknown committed
608
#ifdef HAVE_REPLICATION
609
  void pack_info(Protocol* protocol);
unknown's avatar
unknown committed
610
  int exec_event(struct st_relay_log_info* rli);
unknown's avatar
SCRUM  
unknown committed
611
#endif /* HAVE_REPLICATION */
unknown's avatar
unknown committed
612 613 614 615 616 617 618 619 620 621 622 623
#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; }
};

unknown's avatar
unknown committed
624 625 626 627 628 629 630 631 632 633 634 635 636 637
/*****************************************************************************

  User var Log Event class

 ****************************************************************************/
class User_var_log_event: public Log_event
{
public:
  char *name;
  uint name_len;
  char *val;
  ulong val_len;
  Item_result type;
  uint charset_number;
638
  bool is_null;
unknown's avatar
unknown committed
639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
#ifndef MYSQL_CLIENT
  User_var_log_event(THD* thd_arg, char *name_arg, uint name_len_arg,
                     char *val_arg, ulong val_len_arg, Item_result type_arg,
		     uint charset_number_arg)
    :Log_event(), name(name_arg), name_len(name_len_arg), val(val_arg),
    val_len(val_len_arg), type(type_arg), charset_number(charset_number_arg)
    { is_null= !val; }
  void pack_info(Protocol* protocol);
  int exec_event(struct st_relay_log_info* rli);
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif

  User_var_log_event(const char* buf, bool old_format);
  ~User_var_log_event() {}
  Log_event_type get_type_code() { return USER_VAR_EVENT;}
  int get_data_size()
    {
      return (is_null ? UV_NAME_LEN_SIZE + name_len + UV_VAL_IS_NULL :
	UV_NAME_LEN_SIZE + name_len + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE +
	UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE + val_len);
    }
  int write_data(IO_CACHE* file);
  bool is_valid() { return 1; }
};
664 665 666 667 668 669

/*****************************************************************************

  Stop Log Event class

 ****************************************************************************/
unknown's avatar
SCRUM  
unknown committed
670
#ifdef HAVE_REPLICATION
671

unknown's avatar
unknown committed
672 673 674
class Stop_log_event: public Log_event
{
public:
unknown's avatar
unknown committed
675
#ifndef MYSQL_CLIENT
676
  Stop_log_event() :Log_event()
unknown's avatar
unknown committed
677
  {}
678 679 680
  int exec_event(struct st_relay_log_info* rli);
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
681
#endif  
682 683 684 685

  Stop_log_event(const char* buf, bool old_format):
    Log_event(buf, old_format)
  {}
unknown's avatar
unknown committed
686 687
  ~Stop_log_event() {}
  Log_event_type get_type_code() { return STOP_EVENT;}
688
  bool is_valid() { return 1; }
unknown's avatar
unknown committed
689 690
};

unknown's avatar
SCRUM  
unknown committed
691
#endif /* HAVE_REPLICATION */
692

693

694 695 696 697 698 699 700
/*****************************************************************************

  Rotate Log Event class

  This will be depricated when we move to using sequence ids.

 ****************************************************************************/
unknown's avatar
unknown committed
701 702 703 704
class Rotate_log_event: public Log_event
{
public:
  const char* new_log_ident;
705
  ulonglong pos;
unknown's avatar
unknown committed
706
  uint ident_len;
unknown's avatar
unknown committed
707
  bool alloced;
708 709
#ifndef MYSQL_CLIENT  
  Rotate_log_event(THD* thd_arg, const char* new_log_ident_arg,
710 711 712
		   uint ident_len_arg = 0,
		   ulonglong pos_arg = LOG_EVENT_OFFSET)
    :Log_event(thd_arg,0,0), new_log_ident(new_log_ident_arg),
unknown's avatar
unknown committed
713 714
    pos(pos_arg),ident_len(ident_len_arg ? ident_len_arg :
			   (uint) strlen(new_log_ident_arg)), alloced(0)
unknown's avatar
unknown committed
715
  {}
unknown's avatar
SCRUM  
unknown committed
716
#ifdef HAVE_REPLICATION
717
  void pack_info(Protocol* protocol);
718
  int exec_event(struct st_relay_log_info* rli);
unknown's avatar
SCRUM  
unknown committed
719
#endif /* HAVE_REPLICATION */
720 721 722 723
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif

724
  Rotate_log_event(const char* buf, int event_len, bool old_format);
unknown's avatar
unknown committed
725 726 727 728 729 730
  ~Rotate_log_event()
  {
    if (alloced)
      my_free((gptr) new_log_ident, MYF(0));
  }
  Log_event_type get_type_code() { return ROTATE_EVENT;}
731
  int get_data_size() { return  ident_len + ROTATE_HEADER_LEN;}
732
  bool is_valid() { return new_log_ident != 0; }
733
  int write_data(IO_CACHE* file);
734 735 736 737
};

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

738 739 740 741 742
/*****************************************************************************

  Create File Log Event class

 ****************************************************************************/
743
class Create_file_log_event: public Load_log_event
744
{
745
protected:
746 747 748 749 750
  /*
    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
  */
751
  bool fake_base; 
752 753 754 755
public:
  char* block;
  uint block_len;
  uint file_id;
unknown's avatar
unknown committed
756
  bool inited_from_old;
757

758 759
#ifndef MYSQL_CLIENT
  Create_file_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
760 761 762
			const char* table_name_arg,
			List<Item>& fields_arg,
			enum enum_duplicates handle_dup,
763 764
			char* block_arg, uint block_len_arg,
			bool using_trans);
unknown's avatar
SCRUM  
unknown committed
765
#ifdef HAVE_REPLICATION
766
  void pack_info(Protocol* protocol);
767
  int exec_event(struct st_relay_log_info* rli);
unknown's avatar
SCRUM  
unknown committed
768
#endif /* HAVE_REPLICATION */
769 770
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
771
  void print(FILE* file, bool short_form, char* last_db, bool enable_local);
772
#endif  
unknown's avatar
unknown committed
773
  
unknown's avatar
unknown committed
774
  Create_file_log_event(const char* buf, int event_len, bool old_format);
775 776 777
  ~Create_file_log_event() {}

  Log_event_type get_type_code()
778
  {
779 780 781 782 783 784 785 786 787 788 789 790
    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);
791
  }
unknown's avatar
unknown committed
792
  bool is_valid() { return inited_from_old || block != 0; }
793 794
  int write_data_header(IO_CACHE* file);
  int write_data_body(IO_CACHE* file);
795 796 797 798 799
  /*
    Cut out Create_file extentions and
    write it as Load event - used on the slave
  */
  int write_base(IO_CACHE* file);
800 801
};

802

803 804 805 806 807
/*****************************************************************************

  Append Block Log Event class

 ****************************************************************************/
808 809 810 811 812 813 814 815 816
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,
817
			 uint block_len_arg, bool using_trans);
unknown's avatar
SCRUM  
unknown committed
818
#ifdef HAVE_REPLICATION
819
  int exec_event(struct st_relay_log_info* rli);
820
  void pack_info(Protocol* protocol);
unknown's avatar
SCRUM  
unknown committed
821
#endif /* HAVE_REPLICATION */
822 823 824
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif
825 826
  
  Append_block_log_event(const char* buf, int event_len);
827
  ~Append_block_log_event() {}
828 829 830 831 832 833
  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);
};

834
/*****************************************************************************
835

836 837 838
  Delete File Log Event class

 ****************************************************************************/
839 840 841 842 843 844
class Delete_file_log_event: public Log_event
{
public:
  uint file_id;
  
#ifndef MYSQL_CLIENT
845
  Delete_file_log_event(THD* thd, bool using_trans);
unknown's avatar
SCRUM  
unknown committed
846
#ifdef HAVE_REPLICATION
847
  void pack_info(Protocol* protocol);
848
  int exec_event(struct st_relay_log_info* rli);
unknown's avatar
SCRUM  
unknown committed
849
#endif /* HAVE_REPLICATION */
850 851
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
852 853 854
#endif  
  
  Delete_file_log_event(const char* buf, int event_len);
855
  ~Delete_file_log_event() {}
856 857 858 859 860 861
  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);
};

862 863 864 865 866
/*****************************************************************************

  Execute Load Log Event class

 ****************************************************************************/
867 868 869 870 871 872
class Execute_load_log_event: public Log_event
{
public:
  uint file_id;
  
#ifndef MYSQL_CLIENT
873
  Execute_load_log_event(THD* thd, bool using_trans);
unknown's avatar
SCRUM  
unknown committed
874
#ifdef HAVE_REPLICATION
875
  void pack_info(Protocol* protocol);
876
  int exec_event(struct st_relay_log_info* rli);
unknown's avatar
SCRUM  
unknown committed
877
#endif /* HAVE_REPLICATION */
878 879
#else
  void print(FILE* file, bool short_form = 0, char* last_db = 0);
880 881 882
#endif  
  
  Execute_load_log_event(const char* buf, int event_len);
883
  ~Execute_load_log_event() {}
884 885 886
  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; }
887
  int write_data(IO_CACHE* file);
unknown's avatar
unknown committed
888 889
};

890
#endif /* _log_event_h */