log_event.h 52.2 KB
Newer Older
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
2

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3 4 5 6
   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.
7

bk@work.mysql.com's avatar
bk@work.mysql.com committed
8 9 10 11
   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.
12

bk@work.mysql.com's avatar
bk@work.mysql.com committed
13 14 15 16 17
   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

25
#if defined(USE_PRAGMA_INTERFACE) && !defined(MYSQL_CLIENT)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
26 27 28 29 30 31 32
#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 38

/*
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
   3 is MySQL 4.x; 4 is MySQL 5.0.0.
   Compared to version 3, version 4 has:
   - a different Start_log_event, which includes info about the binary log
   (sizes of headers); this info is included for better compatibility if the
   master's MySQL version is different from the slave's.
   - all events have a unique ID (the triplet (server_id, timestamp at server
   start, other) to be sure an event is not executed more than once in a
   multimaster setup, example:
                M1
              /   \
             v     v
             M2    M3
             \     /
              v   v
                S
   if a query is run on M1, it will arrive twice on S, so we need that S
   remembers the last unique ID it has processed, to compare and know if the
   event should be skipped or not. Example of ID: we already have the server id
   (4 bytes), plus:
   timestamp_when_the_master_started (4 bytes), a counter (a sequence number
   which increments every time we write an event to the binlog) (3 bytes).
   Q: how do we handle when the counter is overflowed and restarts from 0 ?
61

62
   - Query and Load (Create or Execute) events may have a more precise timestamp
63
   (with microseconds), number of matched/affected/warnings rows
64 65
   and fields of session variables: SQL_MODE,
   FOREIGN_KEY_CHECKS, UNIQUE_CHECKS, SQL_AUTO_IS_NULL, the collations and
66
   charsets, the PASSWORD() version (old/new/...).
67 68
*/
#define BINLOG_VERSION    4
69

70 71 72
/*
 We could have used SERVER_VERSION_LENGTH, but this introduces an
 obscure dependency - if somebody decided to change SERVER_VERSION_LENGTH
73
 this would break the replication protocol
74 75 76
*/
#define ST_SERVER_VER_LEN 50

77 78 79 80 81
/*
  These are flags and structs to handle all the LOAD DATA INFILE options (LINES
  TERMINATED etc).
*/

82 83 84 85 86 87
/*
  These are flags and structs to handle all the LOAD DATA INFILE options (LINES
  TERMINATED etc).
  DUMPFILE_FLAG is probably useless (DUMPFILE is a clause of SELECT, not of LOAD
  DATA).
*/
88 89 90 91
#define DUMPFILE_FLAG		0x1
#define OPT_ENCLOSED_FLAG	0x2
#define REPLACE_FLAG		0x4
#define IGNORE_FLAG		0x8
92

93 94 95 96 97
#define FIELD_TERM_EMPTY	0x1
#define ENCLOSED_EMPTY		0x2
#define LINE_TERM_EMPTY		0x4
#define LINE_START_EMPTY	0x8
#define ESCAPED_EMPTY		0x10
98

99 100 101 102 103
/*****************************************************************************

  old_sql_ex struct

 ****************************************************************************/
104
struct old_sql_ex
105 106 107 108 109 110 111 112 113
{
  char field_term;
  char enclosed;
  char line_term;
  char line_start;
  char escaped;
  char opt_flags;
  char empty_flags;
};
114

115 116
#define NUM_LOAD_DELIM_STRS 5

117 118 119 120 121
/*****************************************************************************

  sql_ex_info struct

 ****************************************************************************/
122
struct sql_ex_info
123 124 125 126 127 128 129 130
{
  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;
131
  char opt_flags;
132
  char empty_flags;
133

134
  // store in new format even if old is possible
135
  void force_new_format() { cached_new_format = 1;}
136 137 138 139 140 141
  int data_size()
  {
    return (new_format() ?
	    field_term_len + enclosed_len + line_term_len +
	    line_start_len + escaped_len + 6 : 7);
  }
142
  bool write_data(IO_CACHE* file);
143 144 145 146 147 148 149 150 151 152
  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)));
  }
};
153

154 155 156 157 158 159 160 161 162 163 164 165
/*****************************************************************************

  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.

166 167 168 169 170 171
  The events which really update data are Query_log_event,
  Execute_load_query_log_event and old Load_log_event and
  Execute_load_log_event events (Execute_load_query is used together with
  Begin_load_query and Append_block events to replicate LOAD DATA INFILE.
  Create_file/Append_block/Execute_load (which includes Load_log_event)
  were used to replicate LOAD DATA before the 5.0.3).
172

173
 ****************************************************************************/
174

175 176
#define LOG_EVENT_HEADER_LEN 19     /* the fixed header length */
#define OLD_HEADER_LEN       13     /* the fixed header length in 3.23 */
177
/*
178 179 180 181 182 183
   Fixed header length, where 4.x and 5.0 agree. That is, 5.0 may have a longer
   header (it will for sure when we have the unique event's ID), but at least
   the first 19 bytes are the same in 4.x and 5.0. So when we have the unique
   event's ID, LOG_EVENT_HEADER_LEN will be something like 26, but
   LOG_EVENT_MINIMAL_HEADER_LEN will remain 19.
*/
184 185
#define LOG_EVENT_MINIMAL_HEADER_LEN 19

186
/* event-specific post-header sizes */
187 188 189
// where 3.23, 4.x and 5.0 agree
#define QUERY_HEADER_MINIMAL_LEN     (4 + 4 + 1 + 2)
// where 5.0 differs: 2 for len of N-bytes vars.
190
#define QUERY_HEADER_LEN     (QUERY_HEADER_MINIMAL_LEN + 2)
191
#define LOAD_HEADER_LEN      (4 + 4 + 4 + 1 +1 + 4)
192 193
#define START_V3_HEADER_LEN     (2 + ST_SERVER_VER_LEN + 4)
#define ROTATE_HEADER_LEN    8 // this is FROZEN (the Rotate post-header is frozen)
194 195 196 197
#define CREATE_FILE_HEADER_LEN 4
#define APPEND_BLOCK_HEADER_LEN 4
#define EXEC_LOAD_HEADER_LEN   4
#define DELETE_FILE_HEADER_LEN 4
198
#define FORMAT_DESCRIPTION_HEADER_LEN (START_V3_HEADER_LEN+1+LOG_EVENT_TYPES)
199 200
#define EXECUTE_LOAD_QUERY_EXTRA_HEADER_LEN (4 + 4 + 4 + 1)
#define EXECUTE_LOAD_QUERY_HEADER_LEN  (QUERY_HEADER_LEN + EXECUTE_LOAD_QUERY_EXTRA_HEADER_LEN)
201

202 203
/*
   Event header offsets;
204 205
   these point to places inside the fixed header.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
206

207
#define EVENT_TYPE_OFFSET    4
208 209
#define SERVER_ID_OFFSET     5
#define EVENT_LEN_OFFSET     9
210
#define LOG_POS_OFFSET       13
211 212
#define FLAGS_OFFSET         17

213
/* start event post-header (for v3 and v4) */
214 215 216 217

#define ST_BINLOG_VER_OFFSET  0
#define ST_SERVER_VER_OFFSET  2
#define ST_CREATED_OFFSET     (ST_SERVER_VER_OFFSET + ST_SERVER_VER_LEN)
218
#define ST_COMMON_HEADER_LEN_OFFSET (ST_CREATED_OFFSET + 4)
219

220
/* slave event post-header (this event is never written) */
221

222 223 224
#define SL_MASTER_PORT_OFFSET   8
#define SL_MASTER_POS_OFFSET    0
#define SL_MASTER_HOST_OFFSET   10
225 226 227

/* query event post-header */

228 229 230 231
#define Q_THREAD_ID_OFFSET	0
#define Q_EXEC_TIME_OFFSET	4
#define Q_DB_LEN_OFFSET		8
#define Q_ERR_CODE_OFFSET	9
232
#define Q_STATUS_VARS_LEN_OFFSET 11
233
#define Q_DATA_OFFSET		QUERY_HEADER_LEN
234 235 236
/* these are codes, not offsets; not more than 256 values (1 byte). */
#define Q_FLAGS2_CODE           0
#define Q_SQL_MODE_CODE         1
237 238
/*
  Q_CATALOG_CODE is catalog with end zero stored; it is used only by MySQL
239 240
  5.0.x where 0<=x<=3. We have to keep it to be able to replicate these
  old masters.
241
*/
242
#define Q_CATALOG_CODE          2
243
#define Q_AUTO_INCREMENT	3
244
#define Q_CHARSET_CODE          4
245
#define Q_TIME_ZONE_CODE        5
246 247 248 249 250 251 252 253
/*
  Q_CATALOG_NZ_CODE is catalog withOUT end zero stored; it is used by MySQL
  5.0.x where x>=4. Saves one byte in every Query_log_event in binlog,
  compared to Q_CATALOG_CODE. The reason we didn't simply re-use
  Q_CATALOG_CODE is that then a 5.0.3 slave of this 5.0.x (x>=4) master would
  crash (segfault etc) because it would expect a 0 when there is none.
*/
#define Q_CATALOG_NZ_CODE       6
254 255 256 257 258 259

/* Intvar event post-header */

#define I_TYPE_OFFSET        0
#define I_VAL_OFFSET         1

nick@mysql.com's avatar
nick@mysql.com committed
260 261 262 263 264
/* Rand event post-header */

#define RAND_SEED1_OFFSET 0
#define RAND_SEED2_OFFSET 8

265 266 267 268 269 270 271 272
/* 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

273 274 275 276 277
/* Load event post-header */

#define L_THREAD_ID_OFFSET   0
#define L_EXEC_TIME_OFFSET   4
#define L_SKIP_LINES_OFFSET  8
278 279
#define L_TBL_LEN_OFFSET     12
#define L_DB_LEN_OFFSET      13
280
#define L_NUM_FIELDS_OFFSET  14
281
#define L_SQL_EX_OFFSET      18
282
#define L_DATA_OFFSET        LOAD_HEADER_LEN
283

284 285 286 287
/* Rotate event post-header */

#define R_POS_OFFSET       0
#define R_IDENT_OFFSET     8
288

289 290 291
/* CF to DF handle LOAD DATA INFILE */

/* CF = "Create File" */
292 293 294
#define CF_FILE_ID_OFFSET  0
#define CF_DATA_OFFSET     CREATE_FILE_HEADER_LEN

295
/* AB = "Append Block" */
296 297 298
#define AB_FILE_ID_OFFSET  0
#define AB_DATA_OFFSET     APPEND_BLOCK_HEADER_LEN

299
/* EL = "Execute Load" */
300 301
#define EL_FILE_ID_OFFSET  0

302
/* DF = "Delete File" */
303
#define DF_FILE_ID_OFFSET  0
304

305 306 307 308 309 310
/* ELQ = "Execute Load Query" */
#define ELQ_FILE_ID_OFFSET QUERY_HEADER_LEN
#define ELQ_FN_POS_START_OFFSET ELQ_FILE_ID_OFFSET + 4
#define ELQ_FN_POS_END_OFFSET ELQ_FILE_ID_OFFSET + 8
#define ELQ_DUP_HANDLING_OFFSET ELQ_FILE_ID_OFFSET + 12

311
/* 4 bytes which all binlogs should begin with */
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
312
#define BINLOG_MAGIC        "\xfe\x62\x69\x6e"
313

314 315 316 317 318 319 320 321
/*
  The 2 flags below were useless :
  - the first one was never set
  - the second one was set in all Rotate events on the master, but not used for
  anything useful.
  So they are now removed and their place may later be reused for other
  flags. Then one must remember that Rotate events in 4.x have
  LOG_EVENT_FORCED_ROTATE_F set, so one should not rely on the value of the
322
  replacing flag when reading a Rotate event.
323 324 325
  I keep the defines here just to remember what they were.
*/
#ifdef TO_BE_REMOVED
326
#define LOG_EVENT_TIME_F            0x1
327
#define LOG_EVENT_FORCED_ROTATE_F   0x2
328
#endif
329 330

/*
331 332 333 334 335 336 337 338
   This flag only makes sense for Format_description_log_event. It is set
   when the event is written, and *reset* when a binlog file is
   closed (yes, it's the only case when MySQL modifies already written
   part of binlog).  Thus it is a reliable indicator that binlog was
   closed correctly.  (Stop_log_event is not enough, there's always a
   small chance that mysqld crashes in the middle of insert and end of
   the binlog would look like a Stop_log_event).

339 340 341 342 343 344 345 346
   This flag is used to detect a restart after a crash, and to provide
   "unbreakable" binlog. The problem is that on a crash storage engines
   rollback automatically, while binlog does not.  To solve this we use this
   flag and automatically append ROLLBACK to every non-closed binlog (append
   virtually, on reading, file itself is not changed). If this flag is found,
   mysqlbinlog simply prints "ROLLBACK" Replication master does not abort on
   binlog corruption, but takes it as EOF, and replication slave forces a
   rollback in this case.
347 348 349

   Note, that old binlogs does not have this flag set, so we get a
   a backward-compatible behaviour.
350 351
*/

352 353
#define LOG_EVENT_BINLOG_IN_USE_F       0x1

354
/*
355 356 357 358 359
   If the query depends on the thread (for example: TEMPORARY TABLE).
   Currently this is used by mysqlbinlog to know it must print
   SET @@PSEUDO_THREAD_ID=xx; before the query (it would not hurt to print it
   for every query but this would be slow).
*/
360
#define LOG_EVENT_THREAD_SPECIFIC_F 0x4
361

362 363 364 365 366 367 368 369 370 371 372 373 374
/*
  Suppress the generation of 'USE' statements before the actual
  statement. This flag should be set for any events that does not need
  the current database set to function correctly. Most notable cases
  are 'CREATE DATABASE' and 'DROP DATABASE'.

  This flags should only be used in exceptional circumstances, since
  it introduce a significant change in behaviour regarding the
  replication logic together with the flags --binlog-do-db and
  --replicated-do-db.
 */
#define LOG_EVENT_SUPPRESS_USE_F    0x8

375
/*
376 377 378 379 380 381 382
   OPTIONS_WRITTEN_TO_BIN_LOG are the bits of thd->options which must be
   written to the binlog. OPTIONS_WRITTEN_TO_BINLOG could be written
   into the Format_description_log_event, so that if later we don't want
   to replicate a variable we did replicate, or the contrary, it's
   doable. But it should not be too hard to decide once for all of what
   we replicate and what we don't, among the fixed 32 bits of
   thd->options.
383
   I (Guilhem) have read through every option's usage, and it looks like
384 385 386 387
   OPTION_AUTO_IS_NULL and OPTION_NO_FOREIGN_KEYS are the only ones
   which alter how the query modifies the table. It's good to replicate
   OPTION_RELAXED_UNIQUE_CHECKS too because otherwise, the slave may
   insert data slower than the master, in InnoDB.
388
   OPTION_BIG_SELECTS is not needed (the slave thread runs with
389 390 391
   max_join_size=HA_POS_ERROR) and OPTION_BIG_TABLES is not needed
   either, as the manual says (because a too big in-memory temp table is
   automatically written to disk).
392
*/
393 394 395
#define OPTIONS_WRITTEN_TO_BIN_LOG (OPTION_AUTO_IS_NULL | \
OPTION_NO_FOREIGN_KEY_CHECKS | OPTION_RELAXED_UNIQUE_CHECKS)

serg@serg.mylan's avatar
serg@serg.mylan committed
396 397 398 399
#if OPTIONS_WRITTEN_TO_BIN_LOG != ((1L << 14) | (1L << 26) | (1L << 27))
#error OPTIONS_WRITTEN_TO_BIN_LOG must NOT change their values!
#endif

400 401
enum Log_event_type
{
402 403
  /*
    Every time you update this enum (when you add a type), you have to
404
    fix Format_description_log_event::Format_description_log_event().
405 406 407 408 409
  */
  UNKNOWN_EVENT= 0, START_EVENT_V3, QUERY_EVENT, STOP_EVENT, ROTATE_EVENT,
  INTVAR_EVENT, LOAD_EVENT, SLAVE_EVENT, CREATE_FILE_EVENT,
  APPEND_BLOCK_EVENT, EXEC_LOAD_EVENT, DELETE_FILE_EVENT,
  /*
410 411 412
    NEW_LOAD_EVENT is like LOAD_EVENT except that it has a longer
    sql_ex, allowing multibyte TERMINATED BY etc; both types share the
    same class (Load_log_event)
413
  */
414
  NEW_LOAD_EVENT,
415
  RAND_EVENT, USER_VAR_EVENT,
416
  FORMAT_DESCRIPTION_EVENT,
417
  XID_EVENT,
418 419
  BEGIN_LOAD_QUERY_EVENT,
  EXECUTE_LOAD_QUERY_EVENT,
420 421 422 423 424 425

  /*
    add new events here - right above this comment!
    existing events should never change their numbers
  */

426
  ENUM_END_EVENT /* end marker */
427 428
};

429
/*
430 431 432 433 434 435
   The number of types we handle in Format_description_log_event (UNKNOWN_EVENT
   is not to be handled, it does not exist in binlogs, it does not have a
   format).
*/
#define LOG_EVENT_TYPES (ENUM_END_EVENT-1)

436 437 438 439 440
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
441 442 443

#ifndef MYSQL_CLIENT
class String;
444 445
class MYSQL_LOG;
class THD;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
446 447
#endif

448 449
class Format_description_log_event;

450
struct st_relay_log_info;
451

452 453
#ifdef MYSQL_CLIENT
/*
lars@mysql.com's avatar
lars@mysql.com committed
454 455 456 457 458 459 460 461
  A structure for mysqlbinlog to know how to print events

  This structure is passed to the event's print() methods so that only
  the necessary USE and SET commands are printed.  Last db, flags2,
  sql_mode etc are stored here.

  The structure also contain other information on how to print the
  events, e.g. short_form, hexdump_from.
462 463 464
*/
typedef struct st_last_event_info
{
lars@mysql.com's avatar
lars@mysql.com committed
465
  /* Old settings for database, sql_mode etc */
466 467 468 469 470
  // TODO: have the last catalog here ??
  char db[FN_REFLEN+1]; // TODO: make this a LEX_STRING when thd->db is
  bool flags2_inited;
  uint32 flags2;
  bool sql_mode_inited;
monty@mysql.com's avatar
monty@mysql.com committed
471
  ulong sql_mode;		/* must be same as THD.variables.sql_mode */
472
  ulong auto_increment_increment, auto_increment_offset;
473 474
  bool charset_inited;
  char charset[6]; // 3 variables, each of them storable in 2 bytes
475
  char time_zone_str[MAX_TIME_ZONE_NAME_LENGTH];
476
  st_last_event_info()
477 478
    :flags2_inited(0), sql_mode_inited(0),
     auto_increment_increment(1),auto_increment_offset(1), charset_inited(0)
479
    {
480 481 482 483 484 485 486
      /*
        Currently we only use static LAST_EVENT_INFO objects, so zeroed at
        program's startup, but these explicit bzero() is for the day someone
        creates dynamic instances.
      */
      bzero(db, sizeof(db));
      bzero(charset, sizeof(charset));
487
      bzero(time_zone_str, sizeof(time_zone_str));
488
    }
lars@mysql.com's avatar
lars@mysql.com committed
489 490 491 492 493 494

  /* Settings on how to print the events */
  bool short_form;
  my_off_t hexdump_from;
  uint8 common_header_len;

495 496 497 498
} LAST_EVENT_INFO;
#endif


499 500 501 502 503 504 505
/*****************************************************************************

  Log_event class

  This is the abstract base class for binary log events.

 ****************************************************************************/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
506 507 508
class Log_event
{
public:
509
  /*
510 511 512 513 514 515 516 517
    The offset in the log where this event originally appeared (it is
    preserved in relay logs, making SHOW SLAVE STATUS able to print
    coordinates of the event in the master's binlog). Note: when a
    transaction is written by the master to its binlog (wrapped in
    BEGIN/COMMIT) the log_pos of all the queries it contains is the
    one of the BEGIN (this way, when one does SHOW SLAVE STATUS it
    sees the offset of the BEGIN, which is logical as rollback may
    occur), except the COMMIT query which has its real offset.
518
  */
519
  my_off_t log_pos;
520
  /*
521 522 523
     A temp buffer for read_log_event; it is later analysed according to the
     event's type, and its content is distributed in the event-specific fields.
  */
524
  char *temp_buf;
525
  /*
526 527 528 529 530 531
    Timestamp on the master(for debugging and replication of
    NOW()/TIMESTAMP).  It is important for queries and LOAD DATA
    INFILE. This is set at the event's creation time, except for Query
    and Load (et al.) events where this is set at the query's
    execution time, which guarantees good replication (otherwise, we
    could have a query and its event with different timestamps).
532
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
533
  time_t when;
534
  /* The number of seconds the query took to run on the master. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
535
  ulong exec_time;
536 537 538
  /* Number of bytes written by write() function */
  ulong data_written;

539
  /*
540 541
    The master's server id (is preserved in the relay log; used to
    prevent from infinite loops in circular replication).
542
  */
543
  uint32 server_id;
544 545

  /*
546 547 548
    Some 16 flags. Look above for LOG_EVENT_TIME_F,
    LOG_EVENT_FORCED_ROTATE_F, LOG_EVENT_THREAD_SPECIFIC_F, and
    LOG_EVENT_SUPPRESS_USE_F for notes.
549
  */
550
  uint16 flags;
551

552
  bool cache_stmt;
553

554
#ifndef MYSQL_CLIENT
555
  THD* thd;
556

557
  Log_event();
558
  Log_event(THD* thd_arg, uint16 flags_arg, bool cache_stmt);
559
  /*
560 561 562 563 564 565 566 567 568
    read_log_event() functions read an event from a binlog or relay
    log; used by SHOW BINLOG EVENTS, the binlog_dump thread on the
    master (reads master's binlog), the slave IO thread (reads the
    event sent by binlog_dump), the slave SQL thread (reads the event
    from the relay log).  If mutex is 0, the read will proceed without
    mutex.  We need the description_event to be able to parse the
    event (to know the post-header's size); in fact in read_log_event
    we detect the event's type, then call the specific event's
    constructor and pass description_event as an argument.
569
  */
570 571
  static Log_event* read_log_event(IO_CACHE* file,
				   pthread_mutex_t* log_lock,
572
                                   const Format_description_log_event *description_event);
573 574
  static int read_log_event(IO_CACHE* file, String* packet,
			    pthread_mutex_t* log_lock);
575
  /*
576 577 578
    init_show_field_list() prepares the column names and types for the
    output of SHOW BINLOG EVENTS; it is used only by SHOW BINLOG
    EVENTS.
579
  */
580
  static void init_show_field_list(List<Item>* field_list);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
581
#ifdef HAVE_REPLICATION
hf@deer.mysql.r18.ru's avatar
hf@deer.mysql.r18.ru committed
582
  int net_send(Protocol *protocol, const char* log_name, my_off_t pos);
583 584 585 586
  /*
    pack_info() is used by SHOW BINLOG EVENTS; as print() it prepares and sends
    a string to display to the user, so it resembles print().
  */
hf@deer.mysql.r18.ru's avatar
hf@deer.mysql.r18.ru committed
587
  virtual void pack_info(Protocol *protocol);
588 589 590 591
  /*
    The SQL slave thread calls exec_event() to execute the event; this is where
    the slave's data is modified.
  */
592
  virtual int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
593
#endif /* HAVE_REPLICATION */
594 595 596 597 598
  virtual const char* get_db()
  {
    return thd ? thd->db : 0;
  }
#else
599
  Log_event() : temp_buf(0) {}
600
    /* avoid having to link mysqlbinlog against libpthread */
601 602
  static Log_event* read_log_event(IO_CACHE* file,
                                   const Format_description_log_event *description_event);
603
  /* print*() functions are used by mysqlbinlog */
lars@mysql.com's avatar
lars@mysql.com committed
604
  virtual void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0) = 0;
605
  void print_timestamp(FILE* file, time_t *ts = 0);
lars@mysql.com's avatar
lars@mysql.com committed
606
  void print_header(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
607
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
608

609 610 611 612 613 614
  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)
  {
615
    my_free((gptr) ptr, MYF(MY_WME|MY_ALLOW_ZERO_PTR));
616
  }
617

618
#ifndef MYSQL_CLIENT
619 620 621 622 623 624 625 626
  bool write_header(IO_CACHE* file, ulong data_length);
  virtual bool write(IO_CACHE* file)
  {
    return (write_header(file, get_data_size()) ||
            write_data_header(file) ||
            write_data_body(file));
  }
  virtual bool write_data_header(IO_CACHE* file)
627
  { return 0; }
628
  virtual bool write_data_body(IO_CACHE* file __attribute__((unused)))
629
  { return 0; }
630
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
631
  virtual Log_event_type get_type_code() = 0;
632
  virtual bool is_valid() const = 0;
633
  virtual bool is_artificial_event() { return 0; }
634
  inline bool get_cache_stmt() { return cache_stmt; }
635
  Log_event(const char* buf, const Format_description_log_event* description_event);
636 637 638
  virtual ~Log_event() { free_temp_buf();}
  void register_temp_buf(char* buf) { temp_buf = buf; }
  void free_temp_buf()
639 640
  {
    if (temp_buf)
641
    {
642 643
      my_free(temp_buf, MYF(0));
      temp_buf = 0;
644
    }
645
  }
646 647 648 649
  /*
    Get event length for simple events. For complicated events the length
    is calculated during write()
  */
650
  virtual int get_data_size() { return 0;}
651 652 653
  static Log_event* read_log_event(const char* buf, uint event_len,
				   const char **error,
                                   const Format_description_log_event
654
                                   *description_event);
655
  /* returns the human readable name of the event's type */
656
  const char* get_type_str();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
657 658
};

659
/*
660 661 662 663 664 665 666 667 668 669 670
   One class for each type of event.
   Two constructors for each class:
   - one to create the event for logging (when the server acts as a master),
   called after an update to the database is done,
   which accepts parameters like the query, the database, the options for LOAD
   DATA INFILE...
   - one to create the event from a packet (when the server acts as a slave),
   called before reproducing the update, which accepts parameters (like a
   buffer). Used to read from the master, from the relay log, and in
   mysqlbinlog. This constructor must be format-tolerant.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
671

672 673 674 675 676 677 678
/*****************************************************************************

  Query Log Event class

  Logs SQL queries

 ****************************************************************************/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
679 680 681 682 683 684
class Query_log_event: public Log_event
{
protected:
  char* data_buf;
public:
  const char* query;
685
  const char* catalog;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
686
  const char* db;
687 688 689 690 691 692
  /*
    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
693
  uint32 db_len;
694
  uint16 error_code;
695
  ulong thread_id;
696
  /*
697 698 699 700
    For events created by Query_log_event::exec_event (and
    Load_log_event::exec_event()) we need the *original* thread id, to be able
    to log the event with the original (=master's) thread id (fix for
    BUG#1686).
guilhem@mysql.com's avatar
guilhem@mysql.com committed
701 702
  */
  ulong slave_proxy_id;
703 704

  /*
705 706
    Binlog format 3 and 4 start to differ (as far as class members are
    concerned) from here.
707
  */
708

709
  uint catalog_len;			// <= 255 char; 0 means uninited
710

711 712
  /*
    We want to be able to store a variable number of N-bit status vars:
713 714 715
    (generally N=32; but N=64 for SQL_MODE) a user may want to log the number
    of affected rows (for debugging) while another does not want to lose 4
    bytes in this.
716 717 718 719 720
    The storage on disk is the following:
    status_vars_len is part of the post-header,
    status_vars are in the variable-length part, after the post-header, before
    the db & query.
    status_vars on disk is a sequence of pairs (code, value) where 'code' means
721 722
    'sql_mode', 'affected' etc. Sometimes 'value' must be a short string, so
    its first byte is its length. For now the order of status vars is:
723
    flags2 - sql_mode - catalog - autoinc - charset
724 725 726 727 728 729 730 731
    We should add the same thing to Load_log_event, but in fact
    LOAD DATA INFILE is going to be logged with a new type of event (logging of
    the plain text query), so Load_log_event would be frozen, so no need. The
    new way of logging LOAD DATA INFILE would use a derived class of
    Query_log_event, so automatically benefit from the work already done for
    status variables in Query_log_event.
 */
  uint16 status_vars_len;
732

733 734 735 736 737 738 739 740 741
  /*
    'flags2' is a second set of flags (on top of those in Log_event), for
    session variables. These are thd->options which is & against a mask
    (OPTIONS_WRITTEN_TO_BINLOG).
    flags2_inited helps make a difference between flags2==0 (3.23 or 4.x
    master, we don't know flags2, so use the slave server's global options) and
    flags2==0 (5.0 master, we know this has a meaning of flags all down which
    must influence the query).
  */
742
  bool flags2_inited;
743
  bool sql_mode_inited;
744
  bool charset_inited;
745 746

  uint32 flags2;
747
  /* In connections sql_mode is 32 bits now but will be 64 bits soon */
monty@mysql.com's avatar
monty@mysql.com committed
748
  ulong sql_mode;
749
  ulong auto_increment_increment, auto_increment_offset;
750
  char charset[6];
751 752
  uint time_zone_len; /* 0 means uninited */
  const char *time_zone_str;
753

754
#ifndef MYSQL_CLIENT
755

756
  Query_log_event(THD* thd_arg, const char* query_arg, ulong query_length,
757
		  bool using_trans, bool suppress_use);
758
  const char* get_db() { return db; }
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
759
#ifdef HAVE_REPLICATION
760
  void pack_info(Protocol* protocol);
761
  int exec_event(struct st_relay_log_info* rli);
762 763
  int exec_event(struct st_relay_log_info* rli, const char *query_arg,
                 uint32 q_len_arg);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
764
#endif /* HAVE_REPLICATION */
765
#else
lars@mysql.com's avatar
lars@mysql.com committed
766 767
  void print_query_header(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
768 769
#endif

770
  Query_log_event(const char* buf, uint event_len,
771 772
                  const Format_description_log_event *description_event,
                  Log_event_type event_type);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
773 774 775
  ~Query_log_event()
  {
    if (data_buf)
776
      my_free((gptr) data_buf, MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
777 778
  }
  Log_event_type get_type_code() { return QUERY_EVENT; }
779
#ifndef MYSQL_CLIENT
780
  bool write(IO_CACHE* file);
781 782
  virtual bool write_post_header_for_derived(IO_CACHE* file) { return FALSE; }
#endif
783
  bool is_valid() const { return query != 0; }
784 785 786 787 788 789 790

  /*
    Returns number of bytes additionaly written to post header by derived
    events (so far it is only Execute_load_query event).
  */
  virtual ulong get_post_header_size_for_derived() { return 0; }
  /* Writes derived event-specific part of post header. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
791 792
};

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
793
#ifdef HAVE_REPLICATION
794

795 796 797
/*****************************************************************************

  Slave Log Event class
798 799
  Note that this class is currently not used at all; no code writes a
  Slave_log_event (though some code in repl_failsafe.cc reads Slave_log_event).
800
  So it's not a problem if this code is not maintained.
801 802

 ****************************************************************************/
803 804 805 806 807 808
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
809
  my_off_t master_pos;
810 811
  char* master_host;
  char* master_log;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
812
  int master_host_len;
813
  int master_log_len;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
814
  uint16 master_port;
815

816
#ifndef MYSQL_CLIENT
817
  Slave_log_event(THD* thd_arg, struct st_relay_log_info* rli);
818
  void pack_info(Protocol* protocol);
819
  int exec_event(struct st_relay_log_info* rli);
820
#else
lars@mysql.com's avatar
lars@mysql.com committed
821
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
822
#endif
823

824
  Slave_log_event(const char* buf, uint event_len);
825 826
  ~Slave_log_event();
  int get_data_size();
827
  bool is_valid() const { return master_host != 0; }
828
  Log_event_type get_type_code() { return SLAVE_EVENT; }
829
#ifndef MYSQL_CLIENT
830
  bool write(IO_CACHE* file);
831
#endif
832 833
};

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
834
#endif /* HAVE_REPLICATION */
835

836 837 838 839 840 841

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

  Load Log Event class

 ****************************************************************************/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
842 843
class Load_log_event: public Log_event
{
844 845 846 847
private:
  uint get_query_buffer_length();
  void print_query(bool need_db, char *buf, char **end,
                   char **fn_start, char **fn_end);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
848
protected:
849
  int copy_log_event(const char *buf, ulong event_len,
850
                     int body_offset, const Format_description_log_event* description_event);
851

bk@work.mysql.com's avatar
bk@work.mysql.com committed
852
public:
853
  ulong thread_id;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
854
  ulong slave_proxy_id;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
855
  uint32 table_name_len;
856 857 858 859 860
  /*
    No need to have a catalog, as these events can only come from 4.x.
    TODO: this may become false if Dmitri pushes his new LOAD DATA INFILE in
    5.0 only (not in 4.x).
  */
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
861 862 863
  uint32 db_len;
  uint32 fname_len;
  uint32 num_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
864 865
  const char* fields;
  const uchar* field_lens;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
866
  uint32 field_block_len;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
867 868 869 870

  const char* table_name;
  const char* db;
  const char* fname;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
871
  uint32 skip_lines;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
872
  sql_ex_info sql_ex;
873
  bool local_fname;
874

875 876
  /* fname doesn't point to memory inside Log_event::temp_buf  */
  void set_fname_outside_temp_buf(const char *afname, uint alen)
877 878 879
  {
    fname= afname;
    fname_len= alen;
880
    local_fname= TRUE;
881
  }
882 883
  /* fname doesn't point to memory inside Log_event::temp_buf  */
  int  check_fname_outside_temp_buf()
884
  {
885
    return local_fname;
886
  }
887

888
#ifndef MYSQL_CLIENT
bk@work.mysql.com's avatar
bk@work.mysql.com committed
889 890
  String field_lens_buf;
  String fields_buf;
891

892
  Load_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
893
		 const char* table_name_arg,
894
		 List<Item>& fields_arg, enum enum_duplicates handle_dup, bool ignore,
895
		 bool using_trans);
896 897
  void set_fields(const char* db, List<Item> &fields_arg,
                  Name_resolution_context *context);
898
  const char* get_db() { return db; }
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
899
#ifdef HAVE_REPLICATION
hf@deer.mysql.r18.ru's avatar
hf@deer.mysql.r18.ru committed
900
  void pack_info(Protocol* protocol);
901
  int exec_event(struct st_relay_log_info* rli)
902
  {
903
    return exec_event(thd->slave_net,rli,0);
904
  }
905
  int exec_event(NET* net, struct st_relay_log_info* rli,
906
		 bool use_rli_only_for_errors);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
907
#endif /* HAVE_REPLICATION */
908
#else
lars@mysql.com's avatar
lars@mysql.com committed
909 910
  void print(FILE* file, LAST_EVENT_INFO* last_event_info = 0);
  void print(FILE* file, LAST_EVENT_INFO* last_event_info, bool commented);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
911 912
#endif

913 914 915 916 917 918 919
  /*
    Note that for all the events related to LOAD DATA (Load_log_event,
    Create_file/Append/Exec/Delete, we pass description_event; however as
    logging of LOAD DATA is going to be changed in 4.1 or 5.0, this is only used
    for the common_header_len (post_header_len will not be changed).
  */
  Load_log_event(const char* buf, uint event_len,
920
                 const Format_description_log_event* description_event);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
921
  ~Load_log_event()
922
  {}
923 924 925 926
  Log_event_type get_type_code()
  {
    return sql_ex.new_format() ? NEW_LOAD_EVENT: LOAD_EVENT;
  }
927
#ifndef MYSQL_CLIENT
928 929
  bool write_data_header(IO_CACHE* file);
  bool write_data_body(IO_CACHE* file);
930
#endif
931
  bool is_valid() const { return table_name != 0; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
932 933
  int get_data_size()
  {
934 935
    return (table_name_len + db_len + 2 + fname_len
	    + LOAD_HEADER_LEN
936
	    + sql_ex.data_size() + field_block_len + num_fields);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
937 938 939
  }
};

940
extern char server_version[SERVER_VERSION_LENGTH];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
941

942 943
/*****************************************************************************

944
  Start Log Event_v3 class
945

946 947 948 949 950 951 952
  Start_log_event_v3 is the Start_log_event of binlog format 3 (MySQL 3.23 and
  4.x).
  Format_description_log_event derives from Start_log_event_v3; it is the
  Start_log_event of binlog format 4 (MySQL 5.0), that is, the event that
  describes the other events' header/postheader lengths. This event is sent by
  MySQL 5.0 whenever it starts sending a new binlog if the requested position
  is >4 (otherwise if ==4 the event will be sent naturally).
953

954
 ****************************************************************************/
955

956
class Start_log_event_v3: public Log_event
bk@work.mysql.com's avatar
bk@work.mysql.com committed
957 958
{
public:
959
  /*
960 961 962 963 964
    If this event is at the start of the first binary log since server
    startup 'created' should be the timestamp when the event (and the
    binary log) was created.  In the other case (i.e. this event is at
    the start of a binary log created by FLUSH LOGS or automatic
    rotation), 'created' should be 0.  This "trick" is used by MySQL
965 966
    >=4.0.14 slaves to know whether they must drop stale temporary
    tables and whether they should abort unfinished transaction.
967 968 969 970 971 972 973 974

    Note that when 'created'!=0, it is always equal to the event's
    timestamp; indeed Start_log_event is written only in log.cc where
    the first constructor below is called, in which 'created' is set
    to 'when'.  So in fact 'created' is a useless variable. When it is
    0 we can read the actual value from timestamp ('when') and when it
    is non-zero we can read the same value from timestamp
    ('when'). Conclusion:
975 976 977 978 979
     - we use timestamp to print when the binlog was created.
     - we use 'created' only to know if this is a first binlog or not.
     In 3.23.57 we did not pay attention to this identity, so mysqlbinlog in
     3.23.57 does not print 'created the_date' if created was zero. This is now
     fixed.
980
  */
981
  time_t created;
982
  uint16 binlog_version;
983
  char server_version[ST_SERVER_VER_LEN];
984 985 986 987 988 989
  /*
    artifical_event is 1 in the case where this is a generated event that
    should not case any cleanup actions. We handle this in the log by
    setting log_event == 0 (for now).
  */
  bool artificial_event;
990 991

#ifndef MYSQL_CLIENT
992
  Start_log_event_v3();
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
993
#ifdef HAVE_REPLICATION
994
  void pack_info(Protocol* protocol);
995
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
996
#endif /* HAVE_REPLICATION */
997
#else
998
  Start_log_event_v3() {}
lars@mysql.com's avatar
lars@mysql.com committed
999
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
1000
#endif
1001

1002 1003 1004 1005
  Start_log_event_v3(const char* buf,
                     const Format_description_log_event* description_event);
  ~Start_log_event_v3() {}
  Log_event_type get_type_code() { return START_EVENT_V3;}
1006
#ifndef MYSQL_CLIENT
1007
  bool write(IO_CACHE* file);
1008
#endif
1009
  bool is_valid() const { return 1; }
1010 1011
  int get_data_size()
  {
1012 1013
    return START_V3_HEADER_LEN; //no variable-sized part
  }
1014
  virtual bool is_artificial_event() { return artificial_event; }
1015 1016
};

1017

1018
/*
1019 1020 1021 1022 1023 1024 1025 1026
   For binlog version 4.
   This event is saved by threads which read it, as they need it for future
   use (to decode the ordinary events).
*/

class Format_description_log_event: public Start_log_event_v3
{
public:
1027
  /*
1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
     The size of the fixed header which _all_ events have
     (for binlogs written by this version, this is equal to
     LOG_EVENT_HEADER_LEN), except FORMAT_DESCRIPTION_EVENT and ROTATE_EVENT
     (those have a header of size LOG_EVENT_MINIMAL_HEADER_LEN).
  */
  uint8 common_header_len;
  uint8 number_of_event_types;
  /* The list of post-headers' lengthes */
  uint8 *post_header_len;

  Format_description_log_event(uint8 binlog_ver, const char* server_ver=0);

#ifndef MYSQL_CLIENT
#ifdef HAVE_REPLICATION
  int exec_event(struct st_relay_log_info* rli);
#endif /* HAVE_REPLICATION */
1044 1045
#endif

1046 1047 1048 1049
  Format_description_log_event(const char* buf, uint event_len,
                               const Format_description_log_event* description_event);
  ~Format_description_log_event() { my_free((gptr)post_header_len, MYF(0)); }
  Log_event_type get_type_code() { return FORMAT_DESCRIPTION_EVENT;}
1050
#ifndef MYSQL_CLIENT
1051
  bool write(IO_CACHE* file);
1052
#endif
1053
  bool is_valid() const
1054
  {
1055 1056 1057
    return ((common_header_len >= ((binlog_version==1) ? OLD_HEADER_LEN :
                                   LOG_EVENT_MINIMAL_HEADER_LEN)) &&
            (post_header_len != NULL));
1058 1059 1060 1061 1062 1063 1064 1065 1066
  }
  int get_data_size()
  {
    /*
      The vector of post-header lengths is considered as part of the
      post-header, because in a given version it never changes (contrary to the
      query in a Query_log_event).
    */
    return FORMAT_DESCRIPTION_HEADER_LEN;
1067
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1068 1069
};

1070

1071 1072 1073 1074 1075 1076 1077
/*****************************************************************************

  Intvar Log Event class

  Logs special variables such as auto_increment values

 ****************************************************************************/
1078

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1079 1080 1081 1082 1083
class Intvar_log_event: public Log_event
{
public:
  ulonglong val;
  uchar type;
1084

1085
#ifndef MYSQL_CLIENT
1086
  Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg)
1087
    :Log_event(thd_arg,0,0),val(val_arg),type(type_arg)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1088
  {}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1089
#ifdef HAVE_REPLICATION
1090
  void pack_info(Protocol* protocol);
1091
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1092
#endif /* HAVE_REPLICATION */
1093
#else
lars@mysql.com's avatar
lars@mysql.com committed
1094
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
1095
#endif
1096

1097
  Intvar_log_event(const char* buf, const Format_description_log_event* description_event);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1098 1099
  ~Intvar_log_event() {}
  Log_event_type get_type_code() { return INTVAR_EVENT;}
1100
  const char* get_var_type_name();
1101
  int get_data_size() { return  9; /* sizeof(type) + sizeof(val) */;}
1102
#ifndef MYSQL_CLIENT
1103
  bool write(IO_CACHE* file);
1104
#endif
1105
  bool is_valid() const { return 1; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1106 1107
};

1108

nick@mysql.com's avatar
nick@mysql.com committed
1109
/*****************************************************************************
1110 1111 1112

  Rand Log Event class

1113
  Logs random seed used by the next RAND(), and by PASSWORD() in 4.1.0.
1114 1115 1116
  4.1.1 does not need it (it's repeatable again) so this event needn't be
  written in 4.1.1 for PASSWORD() (but the fact that it is written is just a
  waste, it does not cause bugs).
1117

nick@mysql.com's avatar
nick@mysql.com committed
1118
 ****************************************************************************/
1119

nick@mysql.com's avatar
nick@mysql.com committed
1120 1121 1122 1123 1124 1125 1126 1127
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)
1128
    :Log_event(thd_arg,0,0),seed1(seed1_arg),seed2(seed2_arg)
nick@mysql.com's avatar
nick@mysql.com committed
1129
  {}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1130
#ifdef HAVE_REPLICATION
1131
  void pack_info(Protocol* protocol);
nick@mysql.com's avatar
nick@mysql.com committed
1132
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1133
#endif /* HAVE_REPLICATION */
nick@mysql.com's avatar
nick@mysql.com committed
1134
#else
lars@mysql.com's avatar
lars@mysql.com committed
1135
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
nick@mysql.com's avatar
nick@mysql.com committed
1136 1137
#endif

1138
  Rand_log_event(const char* buf, const Format_description_log_event* description_event);
nick@mysql.com's avatar
nick@mysql.com committed
1139 1140
  ~Rand_log_event() {}
  Log_event_type get_type_code() { return RAND_EVENT;}
1141
  int get_data_size() { return 16; /* sizeof(ulonglong) * 2*/ }
1142
#ifndef MYSQL_CLIENT
1143
  bool write(IO_CACHE* file);
1144
#endif
1145
  bool is_valid() const { return 1; }
nick@mysql.com's avatar
nick@mysql.com committed
1146 1147
};

1148 1149 1150 1151 1152 1153 1154 1155 1156
/*****************************************************************************

  Xid Log Event class

  Logs xid of the transaction-to-be-committed in the 2pc protocol.
  Has no meaning in replication, slaves ignore it.

 ****************************************************************************/
#ifdef MYSQL_CLIENT
1157
typedef ulonglong my_xid; // this line is the same as in handler.h
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
#endif

class Xid_log_event: public Log_event
{
 public:
   my_xid xid;

#ifndef MYSQL_CLIENT
  Xid_log_event(THD* thd_arg, my_xid x): Log_event(thd_arg,0,0), xid(x) {}
#ifdef HAVE_REPLICATION
  void pack_info(Protocol* protocol);
  int exec_event(struct st_relay_log_info* rli);
#endif /* HAVE_REPLICATION */
#else
lars@mysql.com's avatar
lars@mysql.com committed
1172
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
1173 1174 1175 1176 1177 1178
#endif

  Xid_log_event(const char* buf, const Format_description_log_event* description_event);
  ~Xid_log_event() {}
  Log_event_type get_type_code() { return XID_EVENT;}
  int get_data_size() { return sizeof(xid); }
1179
#ifndef MYSQL_CLIENT
1180
  bool write(IO_CACHE* file);
1181
#endif
1182 1183
  bool is_valid() const { return 1; }
};
1184

1185 1186 1187 1188
/*****************************************************************************

  User var Log Event class

1189 1190 1191
  Every time a query uses the value of a user variable, a User_var_log_event is
  written before the Query_log_event, to set the user variable.

1192
 ****************************************************************************/
1193

1194 1195 1196 1197 1198 1199 1200 1201 1202
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;
1203
  bool is_null;
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
#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
lars@mysql.com's avatar
lars@mysql.com committed
1214
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
1215 1216
#endif

1217
  User_var_log_event(const char* buf, const Format_description_log_event* description_event);
1218 1219
  ~User_var_log_event() {}
  Log_event_type get_type_code() { return USER_VAR_EVENT;}
1220
#ifndef MYSQL_CLIENT
1221
  bool write(IO_CACHE* file);
1222
#endif
1223
  bool is_valid() const { return 1; }
1224
};
1225

1226

1227 1228 1229 1230 1231
/*****************************************************************************

  Stop Log Event class

 ****************************************************************************/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1232 1233 1234
class Stop_log_event: public Log_event
{
public:
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1235
#ifndef MYSQL_CLIENT
1236
  Stop_log_event() :Log_event()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1237
  {}
1238 1239
  int exec_event(struct st_relay_log_info* rli);
#else
lars@mysql.com's avatar
lars@mysql.com committed
1240
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
1241
#endif
1242

1243 1244
  Stop_log_event(const char* buf, const Format_description_log_event* description_event):
    Log_event(buf, description_event)
1245
  {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1246 1247
  ~Stop_log_event() {}
  Log_event_type get_type_code() { return STOP_EVENT;}
1248
  bool is_valid() const { return 1; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1249 1250
};

1251 1252 1253 1254
/*****************************************************************************

  Rotate Log Event class

1255
  This will be deprecated when we move to using sequence ids.
1256 1257

 ****************************************************************************/
1258

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1259 1260 1261 1262
class Rotate_log_event: public Log_event
{
public:
  const char* new_log_ident;
1263
  ulonglong pos;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1264
  uint ident_len;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1265
  bool alloced;
1266
#ifndef MYSQL_CLIENT
1267
  Rotate_log_event(THD* thd_arg, const char* new_log_ident_arg,
1268 1269
		   uint ident_len_arg = 0,
		   ulonglong pos_arg = LOG_EVENT_OFFSET)
1270
    :Log_event(), new_log_ident(new_log_ident_arg),
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1271 1272
    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
1273
  {}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1274
#ifdef HAVE_REPLICATION
1275
  void pack_info(Protocol* protocol);
1276
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1277
#endif /* HAVE_REPLICATION */
1278
#else
lars@mysql.com's avatar
lars@mysql.com committed
1279
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
1280 1281
#endif

1282 1283
  Rotate_log_event(const char* buf, uint event_len,
                   const Format_description_log_event* description_event);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1284 1285 1286 1287 1288 1289
  ~Rotate_log_event()
  {
    if (alloced)
      my_free((gptr) new_log_ident, MYF(0));
  }
  Log_event_type get_type_code() { return ROTATE_EVENT;}
1290
  int get_data_size() { return  ident_len + ROTATE_HEADER_LEN;}
1291
  bool is_valid() const { return new_log_ident != 0; }
1292
#ifndef MYSQL_CLIENT
1293
  bool write(IO_CACHE* file);
1294
#endif
1295 1296
};

1297

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

1300 1301 1302
/*****************************************************************************
  Create File Log Event class
 ****************************************************************************/
1303

1304
class Create_file_log_event: public Load_log_event
1305
{
1306
protected:
1307 1308 1309 1310 1311
  /*
    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
  */
1312
  bool fake_base;
1313 1314
public:
  char* block;
1315
  const char *event_buf;
1316 1317
  uint block_len;
  uint file_id;
1318
  bool inited_from_old;
1319

1320 1321
#ifndef MYSQL_CLIENT
  Create_file_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
1322 1323
			const char* table_name_arg,
			List<Item>& fields_arg,
1324
			enum enum_duplicates handle_dup, bool ignore,
1325 1326
			char* block_arg, uint block_len_arg,
			bool using_trans);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1327
#ifdef HAVE_REPLICATION
1328
  void pack_info(Protocol* protocol);
1329
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1330
#endif /* HAVE_REPLICATION */
1331
#else
lars@mysql.com's avatar
lars@mysql.com committed
1332 1333
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
  void print(FILE* file, LAST_EVENT_INFO* last_event_info, bool enable_local);
1334 1335
#endif

1336 1337
  Create_file_log_event(const char* buf, uint event_len,
                        const Format_description_log_event* description_event);
1338 1339 1340 1341
  ~Create_file_log_event()
  {
    my_free((char*) event_buf, MYF(MY_ALLOW_ZERO_PTR));
  }
1342 1343

  Log_event_type get_type_code()
1344
  {
1345 1346 1347 1348 1349 1350 1351 1352
    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);
  }
1353
  bool is_valid() const { return inited_from_old || block != 0; }
1354
#ifndef MYSQL_CLIENT
1355 1356
  bool write_data_header(IO_CACHE* file);
  bool write_data_body(IO_CACHE* file);
1357 1358 1359 1360
  /*
    Cut out Create_file extentions and
    write it as Load event - used on the slave
  */
1361
  bool write_base(IO_CACHE* file);
1362
#endif
1363 1364
};

1365

1366 1367 1368 1369 1370
/*****************************************************************************

  Append Block Log Event class

 ****************************************************************************/
1371

1372 1373 1374 1375 1376 1377
class Append_block_log_event: public Log_event
{
public:
  char* block;
  uint block_len;
  uint file_id;
1378
  /*
1379 1380 1381 1382 1383 1384 1385 1386 1387
    'db' is filled when the event is created in mysql_load() (the
    event needs to have a 'db' member to be well filtered by
    binlog-*-db rules). 'db' is not written to the binlog (it's not
    used by Append_block_log_event::write()), so it can't be read in
    the Append_block_log_event(const char* buf, int event_len)
    constructor.  In other words, 'db' is used only for filtering by
    binlog-*-db rules.  Create_file_log_event is different: it's 'db'
    (which is inherited from Load_log_event) is written to the binlog
    and can be re-read.
1388 1389 1390
  */
  const char* db;

1391
#ifndef MYSQL_CLIENT
1392
  Append_block_log_event(THD* thd, const char* db_arg, char* block_arg,
1393
			 uint block_len_arg, bool using_trans);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1394
#ifdef HAVE_REPLICATION
1395
  int exec_event(struct st_relay_log_info* rli);
1396
  void pack_info(Protocol* protocol);
1397
  virtual int get_create_or_append() const;
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1398
#endif /* HAVE_REPLICATION */
1399
#else
lars@mysql.com's avatar
lars@mysql.com committed
1400
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
1401
#endif
1402 1403

  Append_block_log_event(const char* buf, uint event_len,
1404
                         const Format_description_log_event* description_event);
1405
  ~Append_block_log_event() {}
1406 1407
  Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;}
  int get_data_size() { return  block_len + APPEND_BLOCK_HEADER_LEN ;}
1408
  bool is_valid() const { return block != 0; }
1409
#ifndef MYSQL_CLIENT
1410
  bool write(IO_CACHE* file);
1411
#endif
1412
  const char* get_db() { return db; }
1413 1414
};

1415

1416
/*****************************************************************************
1417

1418 1419 1420
  Delete File Log Event class

 ****************************************************************************/
1421

1422 1423 1424 1425
class Delete_file_log_event: public Log_event
{
public:
  uint file_id;
1426
  const char* db; /* see comment in Append_block_log_event */
1427

1428
#ifndef MYSQL_CLIENT
1429
  Delete_file_log_event(THD* thd, const char* db_arg, bool using_trans);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1430
#ifdef HAVE_REPLICATION
1431
  void pack_info(Protocol* protocol);
1432
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1433
#endif /* HAVE_REPLICATION */
1434
#else
lars@mysql.com's avatar
lars@mysql.com committed
1435 1436
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
  void print(FILE* file, LAST_EVENT_INFO* last_event_info, bool enable_local);
1437 1438
#endif

1439 1440
  Delete_file_log_event(const char* buf, uint event_len,
                        const Format_description_log_event* description_event);
1441
  ~Delete_file_log_event() {}
1442 1443
  Log_event_type get_type_code() { return DELETE_FILE_EVENT;}
  int get_data_size() { return DELETE_FILE_HEADER_LEN ;}
1444
  bool is_valid() const { return file_id != 0; }
1445
#ifndef MYSQL_CLIENT
1446
  bool write(IO_CACHE* file);
1447
#endif
1448
  const char* get_db() { return db; }
1449 1450
};

1451

1452 1453 1454 1455 1456
/*****************************************************************************

  Execute Load Log Event class

 ****************************************************************************/
1457

1458 1459 1460 1461
class Execute_load_log_event: public Log_event
{
public:
  uint file_id;
1462
  const char* db; /* see comment in Append_block_log_event */
1463

1464
#ifndef MYSQL_CLIENT
1465
  Execute_load_log_event(THD* thd, const char* db_arg, bool using_trans);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1466
#ifdef HAVE_REPLICATION
1467
  void pack_info(Protocol* protocol);
1468
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1469
#endif /* HAVE_REPLICATION */
1470
#else
lars@mysql.com's avatar
lars@mysql.com committed
1471
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
1472 1473 1474
#endif

  Execute_load_log_event(const char* buf, uint event_len,
1475
                         const Format_description_log_event* description_event);
1476
  ~Execute_load_log_event() {}
1477 1478
  Log_event_type get_type_code() { return EXEC_LOAD_EVENT;}
  int get_data_size() { return  EXEC_LOAD_HEADER_LEN ;}
1479
  bool is_valid() const { return file_id != 0; }
1480
#ifndef MYSQL_CLIENT
1481
  bool write(IO_CACHE* file);
1482
#endif
1483
  const char* get_db() { return db; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1484 1485
};

1486

1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
/***************************************************************************

  Begin load query Log Event class

  Event for the first block of file to be loaded, its only difference from
  Append_block event is that this event creates or truncates existing file
  before writing data.

****************************************************************************/
class Begin_load_query_log_event: public Append_block_log_event
{
public:
#ifndef MYSQL_CLIENT
  Begin_load_query_log_event(THD* thd_arg, const char *db_arg,
                             char* block_arg, uint block_len_arg,
                             bool using_trans);
#ifdef HAVE_REPLICATION
  Begin_load_query_log_event(THD* thd);
1505
  int get_create_or_append() const;
1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
#endif /* HAVE_REPLICATION */
#endif
  Begin_load_query_log_event(const char* buf, uint event_len,
                             const Format_description_log_event* description_event);
  ~Begin_load_query_log_event() {}
  Log_event_type get_type_code() { return BEGIN_LOAD_QUERY_EVENT; }
};


/*
  Elements of this enum describe how LOAD DATA handles duplicates.
*/
enum enum_load_dup_handling { LOAD_DUP_ERROR= 0, LOAD_DUP_IGNORE,
                              LOAD_DUP_REPLACE };

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

  Execute load query Log Event class

  Event responsible for LOAD DATA execution, it similar to Query_log_event
  but before executing the query it substitutes original filename in LOAD DATA
  query with name of temporary file.

****************************************************************************/
class Execute_load_query_log_event: public Query_log_event
{
public:
  uint file_id;       // file_id of temporary file
  uint fn_pos_start;  // pointer to the part of the query that should
                      // be substituted
  uint fn_pos_end;    // pointer to the end of this part of query
  /*
    We have to store type of duplicate handling explicitly, because
    for LOAD DATA it also depends on LOCAL option. And this part
    of query will be rewritten during replication so this information
    may be lost...
  */
  enum_load_dup_handling dup_handling;

#ifndef MYSQL_CLIENT
  Execute_load_query_log_event(THD* thd, const char* query_arg,
                       ulong query_length, uint fn_pos_start_arg,
                       uint fn_pos_end_arg,
                       enum_load_dup_handling dup_handling_arg,
                       bool using_trans, bool suppress_use);
#ifdef HAVE_REPLICATION
  void pack_info(Protocol* protocol);
  int exec_event(struct st_relay_log_info* rli);
#endif /* HAVE_REPLICATION */
#else
lars@mysql.com's avatar
lars@mysql.com committed
1556
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
1557
  /* Prints the query as LOAD DATA LOCAL and with rewritten filename */
lars@mysql.com's avatar
lars@mysql.com committed
1558 1559
  void print(FILE* file, LAST_EVENT_INFO* last_event_info,
	     const char *local_fname);
1560 1561 1562 1563 1564 1565 1566 1567 1568
#endif
  Execute_load_query_log_event(const char* buf, uint event_len,
                               const Format_description_log_event *description_event);
  ~Execute_load_query_log_event() {}

  Log_event_type get_type_code() { return EXECUTE_LOAD_QUERY_EVENT; }
  bool is_valid() const { return Query_log_event::is_valid() && file_id != 0; }

  ulong get_post_header_size_for_derived();
1569
#ifndef MYSQL_CLIENT
1570
  bool write_post_header_for_derived(IO_CACHE* file);
1571
#endif
1572 1573 1574
 };


1575 1576 1577 1578
#ifdef MYSQL_CLIENT
class Unknown_log_event: public Log_event
{
public:
1579 1580 1581 1582 1583 1584 1585
  /*
    Even if this is an unknown event, we still pass description_event to
    Log_event's ctor, this way we can extract maximum information from the
    event's header (the unique ID for example).
  */
  Unknown_log_event(const char* buf, const Format_description_log_event* description_event):
    Log_event(buf, description_event)
1586 1587
  {}
  ~Unknown_log_event() {}
lars@mysql.com's avatar
lars@mysql.com committed
1588
  void print(FILE* file, LAST_EVENT_INFO* last_event_info= 0);
1589
  Log_event_type get_type_code() { return UNKNOWN_EVENT;}
1590
  bool is_valid() const { return 1; }
1591
};
1592
#endif
1593
char *str_to_hex(char *to, const char *from, uint len);
1594
#endif /* _log_event_h */