log_event.h 70.1 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
#if defined(USE_PRAGMA_INTERFACE) && !defined(MYSQL_CLIENT)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
22 23 24
#pragma interface			/* gcc class implementation */
#endif

25 26
#include <my_bitmap.h>

bk@work.mysql.com's avatar
bk@work.mysql.com committed
27 28 29 30
#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
31
#define LOG_READ_TRUNC  -6
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
32
#define LOG_READ_TOO_LARGE -7
bk@work.mysql.com's avatar
bk@work.mysql.com committed
33 34

#define LOG_EVENT_OFFSET 4
35 36

/*
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
   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 ?
59

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

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

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

80 81 82 83 84 85
/*
  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).
*/
86 87 88 89
#define DUMPFILE_FLAG		0x1
#define OPT_ENCLOSED_FLAG	0x2
#define REPLACE_FLAG		0x4
#define IGNORE_FLAG		0x8
90

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

97 98 99 100 101
/*****************************************************************************

  old_sql_ex struct

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

113 114
#define NUM_LOAD_DELIM_STRS 5

115 116 117 118 119
/*****************************************************************************

  sql_ex_info struct

 ****************************************************************************/
120
struct sql_ex_info
121
{
122
  sql_ex_info() {}                            /* Remove gcc warning */
123 124 125 126 127 128 129
  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;
130
  char opt_flags;
131
  char empty_flags;
132

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

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

  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.

165 166 167 168 169 170
  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).
171

172
 ****************************************************************************/
173

174 175
#define LOG_EVENT_HEADER_LEN 19     /* the fixed header length */
#define OLD_HEADER_LEN       13     /* the fixed header length in 3.23 */
176
/*
177 178 179 180 181 182
   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.
*/
183 184
#define LOG_EVENT_MINIMAL_HEADER_LEN 19

185
/* event-specific post-header sizes */
186 187 188
// 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.
189
#define QUERY_HEADER_LEN     (QUERY_HEADER_MINIMAL_LEN + 2)
190
#define LOAD_HEADER_LEN      (4 + 4 + 4 + 1 +1 + 4)
191 192
#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)
193 194 195 196
#define CREATE_FILE_HEADER_LEN 4
#define APPEND_BLOCK_HEADER_LEN 4
#define EXEC_LOAD_HEADER_LEN   4
#define DELETE_FILE_HEADER_LEN 4
197
#define FORMAT_DESCRIPTION_HEADER_LEN (START_V3_HEADER_LEN+1+LOG_EVENT_TYPES)
198 199
#define ROWS_HEADER_LEN        8
#define TABLE_MAP_HEADER_LEN   8
200 201
#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)
202

203 204
/* 
  Max number of possible extra bytes in a replication event compared to a
205 206
  packet (i.e. a query) sent from client to master;
  First, an auxiliary log_event status vars estimation:
207
*/
208 209 210 211 212 213 214 215 216 217 218 219
#define MAX_SIZE_LOG_EVENT_STATUS (4 /* flags2 */   + \
                                   8 /* sql mode */ + \
                                   1 + 1 + 255 /* catalog */ + \
                                   4 /* autoinc */ + \
                                   6 /* charset */ + \
                                   MAX_TIME_ZONE_NAME_LENGTH)
#define MAX_LOG_EVENT_HEADER   ( /* in order of Query_log_event::write */ \
  LOG_EVENT_HEADER_LEN + /* write_header */ \
  QUERY_HEADER_LEN     + /* write_data */   \
  EXECUTE_LOAD_QUERY_EXTRA_HEADER_LEN + /*write_post_header_for_derived */ \
  MAX_SIZE_LOG_EVENT_STATUS + /* status */ \
  NAME_LEN + 1)
220

221 222 223 224
/* 
   Event header offsets; 
   these point to places inside the fixed header.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
225

226
#define EVENT_TYPE_OFFSET    4
227 228
#define SERVER_ID_OFFSET     5
#define EVENT_LEN_OFFSET     9
229
#define LOG_POS_OFFSET       13
230 231
#define FLAGS_OFFSET         17

232
/* start event post-header (for v3 and v4) */
233 234 235 236

#define ST_BINLOG_VER_OFFSET  0
#define ST_SERVER_VER_OFFSET  2
#define ST_CREATED_OFFSET     (ST_SERVER_VER_OFFSET + ST_SERVER_VER_LEN)
237
#define ST_COMMON_HEADER_LEN_OFFSET (ST_CREATED_OFFSET + 4)
238

239
/* slave event post-header (this event is never written) */
240

241 242 243
#define SL_MASTER_PORT_OFFSET   8
#define SL_MASTER_POS_OFFSET    0
#define SL_MASTER_HOST_OFFSET   10
244 245 246

/* query event post-header */

247 248 249 250
#define Q_THREAD_ID_OFFSET	0
#define Q_EXEC_TIME_OFFSET	4
#define Q_DB_LEN_OFFSET		8
#define Q_ERR_CODE_OFFSET	9
251
#define Q_STATUS_VARS_LEN_OFFSET 11
252
#define Q_DATA_OFFSET		QUERY_HEADER_LEN
253 254 255
/* these are codes, not offsets; not more than 256 values (1 byte). */
#define Q_FLAGS2_CODE           0
#define Q_SQL_MODE_CODE         1
256 257
/*
  Q_CATALOG_CODE is catalog with end zero stored; it is used only by MySQL
258 259
  5.0.x where 0<=x<=3. We have to keep it to be able to replicate these
  old masters.
260
*/
261
#define Q_CATALOG_CODE          2
262
#define Q_AUTO_INCREMENT	3
263
#define Q_CHARSET_CODE          4
264
#define Q_TIME_ZONE_CODE        5
265 266 267 268 269 270 271 272
/*
  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
273 274 275 276 277 278

/* Intvar event post-header */

#define I_TYPE_OFFSET        0
#define I_VAL_OFFSET         1

nick@mysql.com's avatar
nick@mysql.com committed
279 280 281 282 283
/* Rand event post-header */

#define RAND_SEED1_OFFSET 0
#define RAND_SEED2_OFFSET 8

284 285 286 287 288 289 290 291
/* 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

292 293 294 295 296
/* Load event post-header */

#define L_THREAD_ID_OFFSET   0
#define L_EXEC_TIME_OFFSET   4
#define L_SKIP_LINES_OFFSET  8
297 298
#define L_TBL_LEN_OFFSET     12
#define L_DB_LEN_OFFSET      13
299
#define L_NUM_FIELDS_OFFSET  14
300
#define L_SQL_EX_OFFSET      18
301
#define L_DATA_OFFSET        LOAD_HEADER_LEN
302

303 304 305 306
/* Rotate event post-header */

#define R_POS_OFFSET       0
#define R_IDENT_OFFSET     8
307

308 309 310
/* CF to DF handle LOAD DATA INFILE */

/* CF = "Create File" */
311 312 313
#define CF_FILE_ID_OFFSET  0
#define CF_DATA_OFFSET     CREATE_FILE_HEADER_LEN

314
/* AB = "Append Block" */
315 316 317
#define AB_FILE_ID_OFFSET  0
#define AB_DATA_OFFSET     APPEND_BLOCK_HEADER_LEN

318
/* EL = "Execute Load" */
319 320
#define EL_FILE_ID_OFFSET  0

321
/* DF = "Delete File" */
322
#define DF_FILE_ID_OFFSET  0
323

324 325 326 327 328 329 330 331
/* TM = "Table Map" */
#define TM_MAPID_OFFSET    0
#define TM_FLAGS_OFFSET    6

/* RW = "RoWs" */
#define RW_MAPID_OFFSET    0
#define RW_FLAGS_OFFSET    6

332 333 334 335 336 337
/* 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

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

341 342 343 344 345 346 347 348
/*
  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
349
  replacing flag when reading a Rotate event.
350 351 352
  I keep the defines here just to remember what they were.
*/
#ifdef TO_BE_REMOVED
353
#define LOG_EVENT_TIME_F            0x1
354
#define LOG_EVENT_FORCED_ROTATE_F   0x2
355
#endif
356 357

/*
358 359 360 361 362 363 364 365
   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).

366 367 368 369 370 371 372 373
   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.
374 375 376

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

379 380
#define LOG_EVENT_BINLOG_IN_USE_F       0x1

381
/*
382 383 384 385 386
   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).
*/
387
#define LOG_EVENT_THREAD_SPECIFIC_F 0x4
388

389 390 391 392 393 394 395 396 397 398 399 400 401
/*
  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

402 403 404 405 406 407
/*
  The table map version internal to the log should be increased after
  the event has been written to the binary log.
 */
#define LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F 0x10

408
/*
409 410 411 412 413 414 415
   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.
416
   I (Guilhem) have read through every option's usage, and it looks like
417 418 419 420
   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.
421
   OPTION_BIG_SELECTS is not needed (the slave thread runs with
422 423 424
   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).
425
*/
426 427 428
#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
429 430 431 432
#if OPTIONS_WRITTEN_TO_BIN_LOG != ((1L << 14) | (1L << 26) | (1L << 27))
#error OPTIONS_WRITTEN_TO_BIN_LOG must NOT change their values!
#endif

433 434
enum Log_event_type
{
435 436
  /*
    Every time you update this enum (when you add a type), you have to
437
    fix Format_description_log_event::Format_description_log_event().
438
  */
439 440 441 442 443 444 445 446 447 448 449
  UNKNOWN_EVENT= 0,
  START_EVENT_V3= 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,
450
  DELETE_FILE_EVENT= 11,
451
  /*
452 453 454
    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)
455
  */
456
  NEW_LOAD_EVENT= 12,
457 458 459 460 461 462
  RAND_EVENT= 13,
  USER_VAR_EVENT= 14,
  FORMAT_DESCRIPTION_EVENT= 15,
  XID_EVENT= 16,
  BEGIN_LOAD_QUERY_EVENT= 17,
  EXECUTE_LOAD_QUERY_EVENT= 18,
463 464 465 466
  TABLE_MAP_EVENT = 19,
  WRITE_ROWS_EVENT = 20,
  UPDATE_ROWS_EVENT = 21,
  DELETE_ROWS_EVENT = 22,
467 468

  /*
469
    Add new events here - right above this comment!
470
    Existing events (except ENUM_END_EVENT) should never change their numbers
471 472
  */

473
  ENUM_END_EVENT /* end marker */
474 475
};

476
/*
477 478 479 480 481 482
   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)

483 484 485 486 487
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
488 489 490

#ifndef MYSQL_CLIENT
class String;
491
class MYSQL_BIN_LOG;
492
class THD;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
493 494
#endif

495 496
class Format_description_log_event;

497
struct st_relay_log_info;
498

499 500
#ifdef MYSQL_CLIENT
/*
lars@mysql.com's avatar
lars@mysql.com committed
501 502
  A structure for mysqlbinlog to know how to print events

503 504 505 506 507 508 509 510
  This structure is passed to the event's print() methods,

  There are two types of settings stored here:
  1. Last db, flags2, sql_mode etc comes from the last printed event.
     They are stored so that only the necessary USE and SET commands
     are printed.
  2. Other information on how to print the events, e.g. short_form,
     hexdump_from.  These are not dependent on the last event.
511
*/
512
typedef struct st_print_event_info
513
{
514 515 516 517
  /*
    Settings for database, sql_mode etc that comes from the last event
    that was printed.
   */
518 519 520 521 522
  // 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
523
  ulong sql_mode;		/* must be same as THD.variables.sql_mode */
524
  ulong auto_increment_increment, auto_increment_offset;
525 526
  bool charset_inited;
  char charset[6]; // 3 variables, each of them storable in 2 bytes
527
  char time_zone_str[MAX_TIME_ZONE_NAME_LENGTH];
528
  st_print_event_info()
529 530
    :flags2_inited(0), sql_mode_inited(0),
     auto_increment_increment(1),auto_increment_offset(1), charset_inited(0)
531
    {
532
      /*
533
        Currently we only use static PRINT_EVENT_INFO objects, so zeroed at
534 535 536 537 538
        program's startup, but these explicit bzero() is for the day someone
        creates dynamic instances.
      */
      bzero(db, sizeof(db));
      bzero(charset, sizeof(charset));
539
      bzero(time_zone_str, sizeof(time_zone_str));
540
      strcpy(delimiter, ";");
541 542 543
      uint const flags = MYF(MY_WME | MY_NABP);
      init_io_cache(&head_cache, -1, 0, WRITE_CACHE, 0L, FALSE, flags);
      init_io_cache(&body_cache, -1, 0, WRITE_CACHE, 0L, FALSE, flags);
544
    }
lars@mysql.com's avatar
lars@mysql.com committed
545

546 547 548 549 550 551
  ~st_print_event_info() {
    end_io_cache(&head_cache);
    end_io_cache(&body_cache);
  }


lars@mysql.com's avatar
lars@mysql.com committed
552 553
  /* Settings on how to print the events */
  bool short_form;
554
  bool base64_output;
lars@mysql.com's avatar
lars@mysql.com committed
555 556
  my_off_t hexdump_from;
  uint8 common_header_len;
557
  char delimiter[16];
lars@mysql.com's avatar
lars@mysql.com committed
558

559 560 561 562 563 564 565
  /*
     These two caches are used by the row-based replication events to
     collect the header information and the main body of the events
     making up a statement.
   */
  IO_CACHE head_cache;
  IO_CACHE body_cache;
566
} PRINT_EVENT_INFO;
567 568 569
#endif


570 571 572 573 574 575 576
/*****************************************************************************

  Log_event class

  This is the abstract base class for binary log events.

 ****************************************************************************/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
577 578 579
class Log_event
{
public:
580
  /*
581 582 583 584 585 586 587 588
    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.
589
  */
590
  my_off_t log_pos;
591
  /*
592 593 594
     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.
  */
595
  char *temp_buf;
596
  /*
597 598 599 600 601 602
    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).
603
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
604
  time_t when;
605
  /* The number of seconds the query took to run on the master. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
606
  ulong exec_time;
607 608 609
  /* Number of bytes written by write() function */
  ulong data_written;

610
  /*
611 612
    The master's server id (is preserved in the relay log; used to
    prevent from infinite loops in circular replication).
613
  */
614
  uint32 server_id;
615 616

  /*
617 618 619
    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.
620
  */
621
  uint16 flags;
622

623
  bool cache_stmt;
624

625
#ifndef MYSQL_CLIENT
626
  THD* thd;
627

628
  Log_event();
629
  Log_event(THD* thd_arg, uint16 flags_arg, bool cache_stmt);
630
  /*
631 632 633 634 635 636 637 638 639
    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.
640
  */
641 642
  static Log_event* read_log_event(IO_CACHE* file,
				   pthread_mutex_t* log_lock,
643
                                   const Format_description_log_event *description_event);
644 645
  static int read_log_event(IO_CACHE* file, String* packet,
			    pthread_mutex_t* log_lock);
646
  /*
647 648 649
    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.
650
  */
651
  static void init_show_field_list(List<Item>* field_list);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
652
#ifdef HAVE_REPLICATION
hf@deer.mysql.r18.ru's avatar
hf@deer.mysql.r18.ru committed
653
  int net_send(Protocol *protocol, const char* log_name, my_off_t pos);
654 655 656 657
  /*
    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
658
  virtual void pack_info(Protocol *protocol);
659 660 661 662
  /*
    The SQL slave thread calls exec_event() to execute the event; this is where
    the slave's data is modified.
  */
663
  virtual int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
664
#endif /* HAVE_REPLICATION */
665 666 667 668 669
  virtual const char* get_db()
  {
    return thd ? thd->db : 0;
  }
#else
670
  Log_event() : temp_buf(0) {}
671
    /* avoid having to link mysqlbinlog against libpthread */
672 673
  static Log_event* read_log_event(IO_CACHE* file,
                                   const Format_description_log_event *description_event);
674
  /* print*() functions are used by mysqlbinlog */
675
  virtual void print(FILE* file, PRINT_EVENT_INFO* print_event_info) = 0;
676 677 678 679 680
  void print_timestamp(IO_CACHE* file, time_t *ts = 0);
  void print_header(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info,
                    bool is_more);
  void print_base64(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info,
                    bool is_more);
681
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
682

683 684 685 686
  static void *operator new(size_t size)
  {
    return (void*) my_malloc((uint)size, MYF(MY_WME|MY_FAE));
  }
687

688 689
  static void operator delete(void *ptr, size_t size)
  {
690
    my_free((gptr) ptr, MYF(MY_WME|MY_ALLOW_ZERO_PTR));
691
  }
692

693 694 695 696
  /* Placement version of the above operators */
  static void *operator new(size_t, void* ptr) { return ptr; }
  static void operator delete(void*, void*) { }

697
#ifndef MYSQL_CLIENT
698 699 700 701 702 703 704 705
  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)
706
  { return 0; }
707
  virtual bool write_data_body(IO_CACHE* file __attribute__((unused)))
708
  { return 0; }
709
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
710
  virtual Log_event_type get_type_code() = 0;
711
  virtual bool is_valid() const = 0;
712
  virtual bool is_artificial_event() { return 0; }
713
  inline bool get_cache_stmt() const { return cache_stmt; }
714
  Log_event(const char* buf, const Format_description_log_event* description_event);
715 716 717
  virtual ~Log_event() { free_temp_buf();}
  void register_temp_buf(char* buf) { temp_buf = buf; }
  void free_temp_buf()
718 719
  {
    if (temp_buf)
720
    {
721 722
      my_free(temp_buf, MYF(0));
      temp_buf = 0;
723
    }
724
  }
725 726 727 728
  /*
    Get event length for simple events. For complicated events the length
    is calculated during write()
  */
729
  virtual int get_data_size() { return 0;}
730 731 732
  static Log_event* read_log_event(const char* buf, uint event_len,
				   const char **error,
                                   const Format_description_log_event
733
                                   *description_event);
734
  /* returns the human readable name of the event's type */
735
  const char* get_type_str();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
736 737
};

738
/*
739 740 741 742 743 744 745 746 747 748 749
   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
750

751 752 753 754 755 756 757
/*****************************************************************************

  Query Log Event class

  Logs SQL queries

 ****************************************************************************/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
758 759 760 761 762 763
class Query_log_event: public Log_event
{
protected:
  char* data_buf;
public:
  const char* query;
764
  const char* catalog;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
765
  const char* db;
766 767 768 769 770 771
  /*
    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
772
  uint32 db_len;
773
  uint16 error_code;
774
  ulong thread_id;
775
  /*
776 777 778 779
    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
780 781
  */
  ulong slave_proxy_id;
782 783

  /*
784 785
    Binlog format 3 and 4 start to differ (as far as class members are
    concerned) from here.
786
  */
787

788
  uint catalog_len;			// <= 255 char; 0 means uninited
789

790 791
  /*
    We want to be able to store a variable number of N-bit status vars:
792 793 794
    (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.
795 796 797 798 799
    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
800 801
    '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:
802
    flags2 - sql_mode - catalog - autoinc - charset
803 804 805 806 807 808 809 810
    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;
811

812 813 814 815 816 817 818 819 820
  /*
    '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).
  */
821
  bool flags2_inited;
822
  bool sql_mode_inited;
823
  bool charset_inited;
824 825

  uint32 flags2;
826
  /* In connections sql_mode is 32 bits now but will be 64 bits soon */
monty@mysql.com's avatar
monty@mysql.com committed
827
  ulong sql_mode;
828
  ulong auto_increment_increment, auto_increment_offset;
829
  char charset[6];
830 831
  uint time_zone_len; /* 0 means uninited */
  const char *time_zone_str;
832

833
#ifndef MYSQL_CLIENT
834

835
  Query_log_event(THD* thd_arg, const char* query_arg, ulong query_length,
836
		  bool using_trans, bool suppress_use);
837
  const char* get_db() { return db; }
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
838
#ifdef HAVE_REPLICATION
839
  void pack_info(Protocol* protocol);
840
  int exec_event(struct st_relay_log_info* rli);
841 842
  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
843
#endif /* HAVE_REPLICATION */
844
#else
845
  void print_query_header(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info);
846
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
847 848
#endif

849
  Query_log_event();
850
  Query_log_event(const char* buf, uint event_len,
851 852
                  const Format_description_log_event *description_event,
                  Log_event_type event_type);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
853 854 855
  ~Query_log_event()
  {
    if (data_buf)
856
      my_free((gptr) data_buf, MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
857 858
  }
  Log_event_type get_type_code() { return QUERY_EVENT; }
859
#ifndef MYSQL_CLIENT
860
  bool write(IO_CACHE* file);
861 862
  virtual bool write_post_header_for_derived(IO_CACHE* file) { return FALSE; }
#endif
863
  bool is_valid() const { return query != 0; }
864 865 866 867 868 869 870

  /*
    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
871 872
};

873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892

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

  Muted Query Log Event class

  Pretends to Log SQL queries, but doesn't actually do so.

 ****************************************************************************/
class Muted_query_log_event: public Query_log_event
{
public:
#ifndef MYSQL_CLIENT
  Muted_query_log_event();

  bool write(IO_CACHE* file) { return(false); };
  virtual bool write_post_header_for_derived(IO_CACHE* file) { return FALSE; }
#endif
};


hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
893
#ifdef HAVE_REPLICATION
894

895 896 897
/*****************************************************************************

  Slave Log Event class
898 899
  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).
900
  So it's not a problem if this code is not maintained.
901 902

 ****************************************************************************/
903 904 905 906 907 908
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
909
  my_off_t master_pos;
910 911
  char* master_host;
  char* master_log;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
912
  int master_host_len;
913
  int master_log_len;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
914
  uint16 master_port;
915

916
#ifndef MYSQL_CLIENT
917
  Slave_log_event(THD* thd_arg, struct st_relay_log_info* rli);
918
  void pack_info(Protocol* protocol);
919
  int exec_event(struct st_relay_log_info* rli);
920
#else
921
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
922
#endif
923

924
  Slave_log_event(const char* buf, uint event_len);
925 926
  ~Slave_log_event();
  int get_data_size();
927
  bool is_valid() const { return master_host != 0; }
928
  Log_event_type get_type_code() { return SLAVE_EVENT; }
929
#ifndef MYSQL_CLIENT
930
  bool write(IO_CACHE* file);
931
#endif
932 933
};

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

936 937 938 939 940 941

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

  Load Log Event class

 ****************************************************************************/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
942 943
class Load_log_event: public Log_event
{
944 945 946 947
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
948
protected:
949
  int copy_log_event(const char *buf, ulong event_len,
950
                     int body_offset, const Format_description_log_event* description_event);
951

bk@work.mysql.com's avatar
bk@work.mysql.com committed
952
public:
953
  ulong thread_id;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
954
  ulong slave_proxy_id;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
955
  uint32 table_name_len;
956 957 958 959 960
  /*
    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
961 962 963
  uint32 db_len;
  uint32 fname_len;
  uint32 num_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
964 965
  const char* fields;
  const uchar* field_lens;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
966
  uint32 field_block_len;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
967 968 969 970

  const char* table_name;
  const char* db;
  const char* fname;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
971
  uint32 skip_lines;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
972
  sql_ex_info sql_ex;
973
  bool local_fname;
974

975 976
  /* fname doesn't point to memory inside Log_event::temp_buf  */
  void set_fname_outside_temp_buf(const char *afname, uint alen)
977 978 979
  {
    fname= afname;
    fname_len= alen;
980
    local_fname= TRUE;
981
  }
982 983
  /* fname doesn't point to memory inside Log_event::temp_buf  */
  int  check_fname_outside_temp_buf()
984
  {
985
    return local_fname;
986
  }
987

988
#ifndef MYSQL_CLIENT
bk@work.mysql.com's avatar
bk@work.mysql.com committed
989 990
  String field_lens_buf;
  String fields_buf;
991

992
  Load_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
993
		 const char* table_name_arg,
994
		 List<Item>& fields_arg, enum enum_duplicates handle_dup, bool ignore,
995
		 bool using_trans);
996 997
  void set_fields(const char* db, List<Item> &fields_arg,
                  Name_resolution_context *context);
998
  const char* get_db() { return db; }
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
999
#ifdef HAVE_REPLICATION
hf@deer.mysql.r18.ru's avatar
hf@deer.mysql.r18.ru committed
1000
  void pack_info(Protocol* protocol);
1001
  int exec_event(struct st_relay_log_info* rli)
1002
  {
1003
    return exec_event(thd->slave_net,rli,0);
1004
  }
1005
  int exec_event(NET* net, struct st_relay_log_info* rli,
1006
		 bool use_rli_only_for_errors);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1007
#endif /* HAVE_REPLICATION */
1008
#else
1009
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1010
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool commented);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1011 1012
#endif

1013 1014 1015 1016 1017 1018 1019
  /*
    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,
1020
                 const Format_description_log_event* description_event);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1021
  ~Load_log_event()
1022
  {}
1023 1024 1025 1026
  Log_event_type get_type_code()
  {
    return sql_ex.new_format() ? NEW_LOAD_EVENT: LOAD_EVENT;
  }
1027
#ifndef MYSQL_CLIENT
1028 1029
  bool write_data_header(IO_CACHE* file);
  bool write_data_body(IO_CACHE* file);
1030
#endif
1031
  bool is_valid() const { return table_name != 0; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1032 1033
  int get_data_size()
  {
1034 1035
    return (table_name_len + db_len + 2 + fname_len
	    + LOAD_HEADER_LEN
1036
	    + sql_ex.data_size() + field_block_len + num_fields);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1037 1038 1039
  }
};

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

1042 1043
/*****************************************************************************

1044
  Start Log Event_v3 class
1045

1046 1047 1048 1049 1050 1051 1052
  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).
1053

1054
 ****************************************************************************/
1055

1056
class Start_log_event_v3: public Log_event
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1057 1058
{
public:
1059
  /*
1060 1061 1062 1063 1064
    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
1065 1066
    >=4.0.14 slaves to know whether they must drop stale temporary
    tables and whether they should abort unfinished transaction.
1067 1068 1069 1070 1071 1072 1073 1074

    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:
1075 1076 1077 1078 1079
     - 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.
1080
  */
1081
  time_t created;
1082
  uint16 binlog_version;
1083
  char server_version[ST_SERVER_VER_LEN];
1084 1085 1086 1087 1088 1089
  /*
    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;
1090 1091

#ifndef MYSQL_CLIENT
1092
  Start_log_event_v3();
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1093
#ifdef HAVE_REPLICATION
1094
  void pack_info(Protocol* protocol);
1095
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1096
#endif /* HAVE_REPLICATION */
1097
#else
1098
  Start_log_event_v3() {}
1099
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1100
#endif
1101

1102 1103 1104 1105
  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;}
1106
#ifndef MYSQL_CLIENT
1107
  bool write(IO_CACHE* file);
1108
#endif
1109
  bool is_valid() const { return 1; }
1110 1111
  int get_data_size()
  {
1112 1113
    return START_V3_HEADER_LEN; //no variable-sized part
  }
1114
  virtual bool is_artificial_event() { return artificial_event; }
1115 1116
};

1117

1118
/*
1119 1120 1121 1122 1123 1124 1125 1126
   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:
1127
  /*
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
     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 */
1144 1145
#endif

1146 1147 1148 1149
  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;}
1150
#ifndef MYSQL_CLIENT
1151
  bool write(IO_CACHE* file);
1152
#endif
1153
  bool is_valid() const
1154
  {
1155 1156 1157
    return ((common_header_len >= ((binlog_version==1) ? OLD_HEADER_LEN :
                                   LOG_EVENT_MINIMAL_HEADER_LEN)) &&
            (post_header_len != NULL));
1158 1159 1160 1161 1162 1163 1164 1165 1166
  }
  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;
1167
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1168 1169
};

1170

1171 1172 1173 1174 1175 1176 1177
/*****************************************************************************

  Intvar Log Event class

  Logs special variables such as auto_increment values

 ****************************************************************************/
1178

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1179 1180 1181 1182 1183
class Intvar_log_event: public Log_event
{
public:
  ulonglong val;
  uchar type;
1184

1185
#ifndef MYSQL_CLIENT
1186
  Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg)
1187
    :Log_event(thd_arg,0,0),val(val_arg),type(type_arg)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1188
  {}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1189
#ifdef HAVE_REPLICATION
1190
  void pack_info(Protocol* protocol);
1191
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1192
#endif /* HAVE_REPLICATION */
1193
#else
1194
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1195
#endif
1196

1197
  Intvar_log_event(const char* buf, const Format_description_log_event* description_event);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1198 1199
  ~Intvar_log_event() {}
  Log_event_type get_type_code() { return INTVAR_EVENT;}
1200
  const char* get_var_type_name();
1201
  int get_data_size() { return  9; /* sizeof(type) + sizeof(val) */;}
1202
#ifndef MYSQL_CLIENT
1203
  bool write(IO_CACHE* file);
1204
#endif
1205
  bool is_valid() const { return 1; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1206 1207
};

1208

nick@mysql.com's avatar
nick@mysql.com committed
1209
/*****************************************************************************
1210 1211 1212

  Rand Log Event class

1213
  Logs random seed used by the next RAND(), and by PASSWORD() in 4.1.0.
1214 1215 1216
  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).
1217

nick@mysql.com's avatar
nick@mysql.com committed
1218
 ****************************************************************************/
1219

nick@mysql.com's avatar
nick@mysql.com committed
1220 1221 1222 1223 1224 1225 1226 1227
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)
1228
    :Log_event(thd_arg,0,0),seed1(seed1_arg),seed2(seed2_arg)
nick@mysql.com's avatar
nick@mysql.com committed
1229
  {}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1230
#ifdef HAVE_REPLICATION
1231
  void pack_info(Protocol* protocol);
nick@mysql.com's avatar
nick@mysql.com committed
1232
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1233
#endif /* HAVE_REPLICATION */
nick@mysql.com's avatar
nick@mysql.com committed
1234
#else
1235
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
nick@mysql.com's avatar
nick@mysql.com committed
1236 1237
#endif

1238
  Rand_log_event(const char* buf, const Format_description_log_event* description_event);
nick@mysql.com's avatar
nick@mysql.com committed
1239 1240
  ~Rand_log_event() {}
  Log_event_type get_type_code() { return RAND_EVENT;}
1241
  int get_data_size() { return 16; /* sizeof(ulonglong) * 2*/ }
1242
#ifndef MYSQL_CLIENT
1243
  bool write(IO_CACHE* file);
1244
#endif
1245
  bool is_valid() const { return 1; }
nick@mysql.com's avatar
nick@mysql.com committed
1246 1247
};

1248 1249 1250 1251 1252 1253 1254 1255 1256
/*****************************************************************************

  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
1257
typedef ulonglong my_xid; // this line is the same as in handler.h
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
#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
1272
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1273 1274 1275 1276 1277 1278
#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); }
1279
#ifndef MYSQL_CLIENT
1280
  bool write(IO_CACHE* file);
1281
#endif
1282 1283
  bool is_valid() const { return 1; }
};
1284

1285 1286 1287 1288
/*****************************************************************************

  User var Log Event class

1289 1290 1291
  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.

1292
 ****************************************************************************/
1293

1294 1295 1296 1297 1298 1299 1300 1301 1302
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;
1303
  bool is_null;
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
#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
1314
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1315 1316
#endif

1317
  User_var_log_event(const char* buf, const Format_description_log_event* description_event);
1318 1319
  ~User_var_log_event() {}
  Log_event_type get_type_code() { return USER_VAR_EVENT;}
1320
#ifndef MYSQL_CLIENT
1321
  bool write(IO_CACHE* file);
1322
#endif
1323
  bool is_valid() const { return 1; }
1324
};
1325

1326

1327 1328 1329 1330 1331
/*****************************************************************************

  Stop Log Event class

 ****************************************************************************/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1332 1333 1334
class Stop_log_event: public Log_event
{
public:
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1335
#ifndef MYSQL_CLIENT
1336
  Stop_log_event() :Log_event()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1337
  {}
1338 1339
  int exec_event(struct st_relay_log_info* rli);
#else
1340
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1341
#endif
1342

1343 1344
  Stop_log_event(const char* buf, const Format_description_log_event* description_event):
    Log_event(buf, description_event)
1345
  {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1346 1347
  ~Stop_log_event() {}
  Log_event_type get_type_code() { return STOP_EVENT;}
1348
  bool is_valid() const { return 1; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1349 1350
};

1351 1352 1353 1354
/*****************************************************************************

  Rotate Log Event class

1355
  This will be deprecated when we move to using sequence ids.
1356 1357

 ****************************************************************************/
1358

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1359 1360 1361
class Rotate_log_event: public Log_event
{
public:
1362 1363 1364
  enum {
    DUP_NAME= 2 // if constructor should dup the string argument
  };
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1365
  const char* new_log_ident;
1366
  ulonglong pos;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1367
  uint ident_len;
1368
  uint flags;
1369
#ifndef MYSQL_CLIENT
1370
  Rotate_log_event(const char* new_log_ident_arg,
1371 1372
		   uint ident_len_arg,
		   ulonglong pos_arg, uint flags);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1373
#ifdef HAVE_REPLICATION
1374
  void pack_info(Protocol* protocol);
1375
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1376
#endif /* HAVE_REPLICATION */
1377
#else
1378
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1379 1380
#endif

1381 1382
  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
1383 1384
  ~Rotate_log_event()
  {
1385 1386
    if (flags & DUP_NAME)
      my_free((gptr) new_log_ident, MYF(MY_ALLOW_ZERO_PTR));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1387 1388
  }
  Log_event_type get_type_code() { return ROTATE_EVENT;}
1389
  int get_data_size() { return  ident_len + ROTATE_HEADER_LEN;}
1390
  bool is_valid() const { return new_log_ident != 0; }
1391
#ifndef MYSQL_CLIENT
1392
  bool write(IO_CACHE* file);
1393
#endif
1394 1395
};

1396

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

1399 1400 1401
/*****************************************************************************
  Create File Log Event class
 ****************************************************************************/
1402

1403
class Create_file_log_event: public Load_log_event
1404
{
1405
protected:
1406 1407 1408 1409 1410
  /*
    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
  */
1411
  bool fake_base;
1412 1413
public:
  char* block;
1414
  const char *event_buf;
1415 1416
  uint block_len;
  uint file_id;
1417
  bool inited_from_old;
1418

1419 1420
#ifndef MYSQL_CLIENT
  Create_file_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
1421 1422
			const char* table_name_arg,
			List<Item>& fields_arg,
1423
			enum enum_duplicates handle_dup, bool ignore,
1424 1425
			char* block_arg, uint block_len_arg,
			bool using_trans);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1426
#ifdef HAVE_REPLICATION
1427
  void pack_info(Protocol* protocol);
1428
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1429
#endif /* HAVE_REPLICATION */
1430
#else
1431
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1432
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool enable_local);
1433 1434
#endif

1435 1436
  Create_file_log_event(const char* buf, uint event_len,
                        const Format_description_log_event* description_event);
1437 1438 1439 1440
  ~Create_file_log_event()
  {
    my_free((char*) event_buf, MYF(MY_ALLOW_ZERO_PTR));
  }
1441 1442

  Log_event_type get_type_code()
1443
  {
1444 1445 1446 1447 1448 1449 1450 1451
    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);
  }
1452
  bool is_valid() const { return inited_from_old || block != 0; }
1453
#ifndef MYSQL_CLIENT
1454 1455
  bool write_data_header(IO_CACHE* file);
  bool write_data_body(IO_CACHE* file);
1456 1457 1458 1459
  /*
    Cut out Create_file extentions and
    write it as Load event - used on the slave
  */
1460
  bool write_base(IO_CACHE* file);
1461
#endif
1462 1463
};

1464

1465 1466 1467 1468 1469
/*****************************************************************************

  Append Block Log Event class

 ****************************************************************************/
1470

1471 1472 1473 1474 1475 1476
class Append_block_log_event: public Log_event
{
public:
  char* block;
  uint block_len;
  uint file_id;
1477
  /*
1478 1479 1480 1481 1482 1483 1484 1485 1486
    '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.
1487 1488 1489
  */
  const char* db;

1490
#ifndef MYSQL_CLIENT
1491
  Append_block_log_event(THD* thd, const char* db_arg, char* block_arg,
1492
			 uint block_len_arg, bool using_trans);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1493
#ifdef HAVE_REPLICATION
1494
  int exec_event(struct st_relay_log_info* rli);
1495
  void pack_info(Protocol* protocol);
1496
  virtual int get_create_or_append() const;
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1497
#endif /* HAVE_REPLICATION */
1498
#else
1499
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1500
#endif
1501 1502

  Append_block_log_event(const char* buf, uint event_len,
1503
                         const Format_description_log_event* description_event);
1504
  ~Append_block_log_event() {}
1505 1506
  Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;}
  int get_data_size() { return  block_len + APPEND_BLOCK_HEADER_LEN ;}
1507
  bool is_valid() const { return block != 0; }
1508
#ifndef MYSQL_CLIENT
1509
  bool write(IO_CACHE* file);
1510
  const char* get_db() { return db; }
1511
#endif
1512 1513
};

1514

1515
/*****************************************************************************
1516

1517 1518 1519
  Delete File Log Event class

 ****************************************************************************/
1520

1521 1522 1523 1524
class Delete_file_log_event: public Log_event
{
public:
  uint file_id;
1525
  const char* db; /* see comment in Append_block_log_event */
1526

1527
#ifndef MYSQL_CLIENT
1528
  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
1529
#ifdef HAVE_REPLICATION
1530
  void pack_info(Protocol* protocol);
1531
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1532
#endif /* HAVE_REPLICATION */
1533
#else
1534
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1535
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool enable_local);
1536 1537
#endif

1538 1539
  Delete_file_log_event(const char* buf, uint event_len,
                        const Format_description_log_event* description_event);
1540
  ~Delete_file_log_event() {}
1541 1542
  Log_event_type get_type_code() { return DELETE_FILE_EVENT;}
  int get_data_size() { return DELETE_FILE_HEADER_LEN ;}
1543
  bool is_valid() const { return file_id != 0; }
1544
#ifndef MYSQL_CLIENT
1545
  bool write(IO_CACHE* file);
1546
  const char* get_db() { return db; }
1547
#endif
1548 1549
};

1550

1551 1552 1553 1554 1555
/*****************************************************************************

  Execute Load Log Event class

 ****************************************************************************/
1556

1557 1558 1559 1560
class Execute_load_log_event: public Log_event
{
public:
  uint file_id;
1561
  const char* db; /* see comment in Append_block_log_event */
1562

1563
#ifndef MYSQL_CLIENT
1564
  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
1565
#ifdef HAVE_REPLICATION
1566
  void pack_info(Protocol* protocol);
1567
  int exec_event(struct st_relay_log_info* rli);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1568
#endif /* HAVE_REPLICATION */
1569
#else
1570
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1571 1572 1573
#endif

  Execute_load_log_event(const char* buf, uint event_len,
1574
                         const Format_description_log_event* description_event);
1575
  ~Execute_load_log_event() {}
1576 1577
  Log_event_type get_type_code() { return EXEC_LOAD_EVENT;}
  int get_data_size() { return  EXEC_LOAD_HEADER_LEN ;}
1578
  bool is_valid() const { return file_id != 0; }
1579
#ifndef MYSQL_CLIENT
1580
  bool write(IO_CACHE* file);
1581
  const char* get_db() { return db; }
1582
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1583 1584
};

1585

1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603
/***************************************************************************

  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);
1604
  int get_create_or_append() const;
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
#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
1655
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1656
  /* Prints the query as LOAD DATA LOCAL and with rewritten filename */
1657
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
lars@mysql.com's avatar
lars@mysql.com committed
1658
	     const char *local_fname);
1659 1660 1661 1662 1663 1664 1665 1666 1667
#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();
1668
#ifndef MYSQL_CLIENT
1669
  bool write_post_header_for_derived(IO_CACHE* file);
1670
#endif
1671 1672 1673
 };


1674 1675 1676 1677
#ifdef MYSQL_CLIENT
class Unknown_log_event: public Log_event
{
public:
1678 1679 1680 1681 1682 1683 1684
  /*
    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)
1685 1686
  {}
  ~Unknown_log_event() {}
1687
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
1688
  Log_event_type get_type_code() { return UNKNOWN_EVENT;}
1689
  bool is_valid() const { return 1; }
1690
};
1691
#endif
1692
char *str_to_hex(char *to, const char *from, uint len);
1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724

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

  Table map log event class

  Create a mapping from a (database name, table name) couple to a table
  identifier (an integer number).

 ****************************************************************************/
class Table_map_log_event : public Log_event
{
public:
  /* Constants */
  enum
  {
    TYPE_CODE = TABLE_MAP_EVENT
  };

  enum enum_error
  {
    ERR_OPEN_FAILURE = -1,                 /* Failure to open table */
    ERR_OK = 0,                                  /* No error */
    ERR_TABLE_LIMIT_EXCEEDED = 1,        /* No more room for tables */
    ERR_OUT_OF_MEM = 2,                         /* Out of memory */
    ERR_BAD_TABLE_DEF = 3,       /* Table definition does not match */
    ERR_RBR_TO_SBR = 4    /* daisy-chanining RBR to SBR not allowed */
  };

  enum enum_flag
  {
    /* 
       Nothing here right now, but the flags support is there in
1725 1726 1727
       preparation for changes that are coming.  Need to add a
       constant to make it compile under HP-UX: aCC does not like
       empty enumerations.
1728
    */
1729
    ENUM_FLAG_COUNT
1730 1731 1732 1733 1734 1735 1736
  };

  typedef uint16 flag_set;

  /* Special constants representing sets of flags */
  enum 
  {
mats@mysql.com's avatar
mats@mysql.com committed
1737
    TM_NO_FLAGS = 0U
1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755
  };

  void set_flags(flag_set flag) { m_flags |= flag; }
  void clear_flags(flag_set flag) { m_flags &= ~flag; }
  flag_set get_flags(flag_set flag) const { return m_flags & flag; }

#ifndef MYSQL_CLIENT
  Table_map_log_event(THD *thd, TABLE *tbl, ulong tid, 
		      bool is_transactional, uint16 flags);
#endif
#ifdef HAVE_REPLICATION
  Table_map_log_event(const char *buf, uint event_len, 
                      const Format_description_log_event *description_event);
#endif

  ~Table_map_log_event();

  virtual Log_event_type get_type_code() { return TABLE_MAP_EVENT; }
1756
  virtual bool is_valid() const { return m_memory != NULL; /* we check malloc */ }
1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807

  virtual int get_data_size() { return m_data_size; } 
#ifndef MYSQL_CLIENT
  virtual bool write_data_header(IO_CACHE *file);
  virtual bool write_data_body(IO_CACHE *file);
  virtual const char *get_db() { return m_dbnam; }
#endif

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
  virtual int exec_event(struct st_relay_log_info *rli);
  virtual void pack_info(Protocol *protocol);
#endif

#ifdef MYSQL_CLIENT
  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
#endif


private:
#ifndef MYSQL_CLIENT
  TABLE      *m_table;
#endif
  char const    *m_dbnam;
  my_size_t      m_dblen;
  char const    *m_tblnam;
  my_size_t      m_tbllen;
  ulong          m_colcnt;
  unsigned char *m_coltype;

  gptr           m_memory;
  ulong          m_table_id;
  flag_set       m_flags;

  my_size_t      m_data_size;
};


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

 Row level log event class.

 Common base class for all row-level log events.

 RESPONSIBILITIES

   Encode the common parts of all events containing rows, which are:
   - Write data header and data body to an IO_CACHE.
   - Provide an interface for adding an individual row to the event.

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

1808

1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836
class Rows_log_event : public Log_event
{
public:
  /*
    These definitions allow you to combine the flags into an
    appropriate flag set using the normal bitwise operators.  The
    implicit conversion from an enum-constant to an integer is
    accepted by the compiler, which is then used to set the real set
    of flags.
  */

  enum enum_flag
  {
    /* Last event of a statement */
    STMT_END_F = (1U << 0),

    /* Value of the OPTION_NO_FOREIGN_KEY_CHECKS flag in thd->options */
    NO_FOREIGN_KEY_CHECKS_F = (1U << 1),

    /* Value of the OPTION_RELAXED_UNIQUE_CHECKS flag in thd->options */
    RELAXED_UNIQUE_CHECKS_F = (1U << 2)
  };

  typedef uint16 flag_set;

  /* Special constants representing sets of flags */
  enum 
  {
1837
      RLE_NO_FLAGS = 0U
1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887
  };

  virtual ~Rows_log_event();

  void set_flags(flag_set flags) { m_flags |= flags; }
  void clear_flags(flag_set flags) { m_flags &= ~flags; }
  flag_set get_flags(flag_set flags) const { return m_flags & flags; }

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
  virtual int exec_event(struct st_relay_log_info *rli);
  virtual void pack_info(Protocol *protocol);
#endif

#ifdef MYSQL_CLIENT
  /* not for direct call, each derived has its own ::print() */
  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info)= 0;
#endif

#ifndef MYSQL_CLIENT
  int add_row_data(byte *data, my_size_t length)
  {
    return do_add_row_data(data,length); 
  }
#endif

  /* Member functions to implement superclass interface */
  virtual int get_data_size()
  { 
    DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master",
                    return 6 + 1 + no_bytes_in_map(&m_cols) + 
                    (m_rows_cur - m_rows_buf);); 
    return ROWS_HEADER_LEN + 1 + no_bytes_in_map(&m_cols) + 
      (m_rows_cur - m_rows_buf); 
  }

  MY_BITMAP const *get_cols() const { return &m_cols; }
  my_size_t get_width() const       { return m_width; }
  ulong get_table_id() const        { return m_table_id; }

#ifndef MYSQL_CLIENT
  virtual bool write_data_header(IO_CACHE *file);
  virtual bool write_data_body(IO_CACHE *file);
  virtual const char *get_db() { return m_table->s->db.str; }
#endif
  virtual bool is_valid() const
  {
    /* that's how we check malloc() succeeded */
    return m_rows_buf && m_cols.bitmap;
  }

1888
  uint     m_row_count;         /* The number of rows added to the event */
1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902

protected:
  /* 
     The constructors are protected since you're supposed to inherit
     this class, not create instances of this class.
  */
#ifndef MYSQL_CLIENT
  Rows_log_event(THD*, TABLE*, ulong table_id, 
		 MY_BITMAP const *cols, bool is_transactional);
#endif
  Rows_log_event(const char *row_data, uint event_len, 
		 Log_event_type event_type,
		 const Format_description_log_event *description_event);

1903 1904 1905 1906
#ifdef MYSQL_CLIENT
  void print_helper(FILE *, PRINT_EVENT_INFO *, char const *const name);
#endif

1907 1908 1909 1910 1911 1912 1913 1914 1915 1916
#ifndef MYSQL_CLIENT
  virtual int do_add_row_data(byte *data, my_size_t length);
#endif

#ifndef MYSQL_CLIENT
  TABLE *m_table;		/* The table the rows belong to */
#endif
  ulong       m_table_id;	/* Table ID */
  MY_BITMAP   m_cols;		/* Bitmap denoting columns available */
  ulong       m_width;          /* The width of the columns bitmap */
1917
  ulong       m_master_reclength; /* Length of record on master side */
1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973

  /* Bit buffer in the same memory as the class */
  uint32    m_bitbuf[128/(sizeof(uint32)*8)];

  byte    *m_rows_buf;		/* The rows in packed format */
  byte    *m_rows_cur;		/* One-after the end of the data */
  byte    *m_rows_end;		/* One-after the end of the allocated space */

  flag_set m_flags;		/* Flags for row-level events */

private:

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
  /*
    Primitive to prepare for a sequence of row executions.

    DESCRIPTION

      Before doing a sequence of do_prepare_row() and do_exec_row()
      calls, this member function should be called to prepare for the
      entire sequence. Typically, this member function will allocate
      space for any buffers that are needed for the two member
      functions mentioned above.

    RETURN VALUE

      The member function will return 0 if all went OK, or a non-zero
      error code otherwise.
  */
  virtual int do_before_row_operations(TABLE *table) = 0;

  /*
    Primitive to clean up after a sequence of row executions.

    DESCRIPTION
    
      After doing a sequence of do_prepare_row() and do_exec_row(),
      this member function should be called to clean up and release
      any allocated buffers.
  */
  virtual int do_after_row_operations(TABLE *table, int error) = 0;

  /*
    Primitive to prepare for handling one row in a row-level event.
    
    DESCRIPTION 

      The member function prepares for execution of operations needed for one
      row in a row-level event by reading up data from the buffer containing
      the row. No specific interpretation of the data is normally done here,
      since SQL thread specific data is not available: that data is made
      available for the do_exec function.

      A pointer to the start of the next row, or NULL if the preparation
      failed. Currently, preparation cannot fail, but don't rely on this
      behavior. 
1974 1975 1976

    RETURN VALUE
      Error code, if something went wrong, 0 otherwise.
1977
   */
1978 1979
  virtual int do_prepare_row(THD*, RELAY_LOG_INFO*, TABLE*,
                             char const *row_start, char const **row_end) = 0;
1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021

  /*
    Primitive to do the actual execution necessary for a row.

    DESCRIPTION
      The member function will do the actual execution needed to handle a row.

    RETURN VALUE
      0 if execution succeeded, 1 if execution failed.
      
  */
  virtual int do_exec_row(TABLE *table) = 0;
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
};


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

  Write row log event class

  Log row insertions and updates. The event contain several
  insert/update rows for a table. Note that each event contains only
  rows for one table.

 ****************************************************************************/
class Write_rows_log_event : public Rows_log_event
{
public:
  enum 
  {
    /* Support interface to THD::binlog_prepare_pending_rows_event */
    TYPE_CODE = WRITE_ROWS_EVENT
  };

#if !defined(MYSQL_CLIENT)
  Write_rows_log_event(THD*, TABLE*, ulong table_id, 
		       MY_BITMAP const *cols, bool is_transactional);
#endif
#ifdef HAVE_REPLICATION
  Write_rows_log_event(const char *buf, uint event_len, 
                       const Format_description_log_event *description_event);
#endif
2022
#if !defined(MYSQL_CLIENT) 
2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044
  static bool binlog_row_logging_function(THD *thd, TABLE *table,
                                          bool is_transactional,
                                          MY_BITMAP *cols,
                                          uint fields,
                                          const byte *before_record
                                          __attribute__((unused)),
                                          const byte *after_record)
  {
    return thd->binlog_write_row(table, is_transactional,
                                 cols, fields, after_record);
  }
#endif

private:
  virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }

#ifdef MYSQL_CLIENT
  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
#endif

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
  gptr  m_memory;
2045
  byte *m_after_image;
2046

2047 2048 2049 2050 2051
  virtual int do_before_row_operations(TABLE *table);
  virtual int do_after_row_operations(TABLE *table, int error);
  virtual int do_prepare_row(THD*, RELAY_LOG_INFO*, TABLE*,
                             char const *row_start, char const **row_end);
  virtual int do_exec_row(TABLE *table);
2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086
#endif
};


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

  Update rows log event class

  Log row updates with a before image. The event contain several
  update rows for a table. Note that each event contains only rows for
  one table.

  Also note that the row data consists of pairs of row data: one row
  for the old data and one row for the new data.

 ****************************************************************************/
class Update_rows_log_event : public Rows_log_event
{
public:
  enum 
  {
    /* Support interface to THD::binlog_prepare_pending_rows_event */
    TYPE_CODE = UPDATE_ROWS_EVENT
  };

#ifndef MYSQL_CLIENT
  Update_rows_log_event(THD*, TABLE*, ulong table_id, 
			MY_BITMAP const *cols, bool is_transactional);
#endif

#ifdef HAVE_REPLICATION
  Update_rows_log_event(const char *buf, uint event_len, 
			const Format_description_log_event *description_event);
#endif

2087
#if !defined(MYSQL_CLIENT) 
2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109
  static bool binlog_row_logging_function(THD *thd, TABLE *table,
                                          bool is_transactional,
                                          MY_BITMAP *cols,
                                          uint fields,
                                          const byte *before_record,
                                          const byte *after_record)
  {
    return thd->binlog_update_row(table, is_transactional,
                                  cols, fields, before_record, after_record);
  }
#endif

private:
  virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }

#ifdef MYSQL_CLIENT
  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
#endif

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
  gptr  m_memory;
  byte *m_key;
2110
  byte *m_after_image;
2111

2112 2113 2114 2115 2116
  virtual int do_before_row_operations(TABLE *table);
  virtual int do_after_row_operations(TABLE *table, int error);
  virtual int do_prepare_row(THD*, RELAY_LOG_INFO*, TABLE*,
                             char const *row_start, char const **row_end);
  virtual int do_exec_row(TABLE *table);
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
};

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

  Delete rows log event class.

  Log row deletions. The event contain several delete rows for a
  table. Note that each event contains only rows for one table.

  RESPONSIBILITIES

    - Act as a container for rows that has been deleted on the master
      and should be deleted on the slave. 

  COLLABORATION

    Row_writer
      Create the event and add rows to the event.
    Row_reader
      Extract the rows from the event.

 ****************************************************************************/
class Delete_rows_log_event : public Rows_log_event
{
public:
  enum 
  {
    /* Support interface to THD::binlog_prepare_pending_rows_event */
    TYPE_CODE = DELETE_ROWS_EVENT
  };

#ifndef MYSQL_CLIENT
  Delete_rows_log_event(THD*, TABLE*, ulong, 
			MY_BITMAP const *cols, bool is_transactional);
#endif
#ifdef HAVE_REPLICATION
  Delete_rows_log_event(const char *buf, uint event_len, 
			const Format_description_log_event *description_event);
#endif
2157
#if !defined(MYSQL_CLIENT) 
2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180
  static bool binlog_row_logging_function(THD *thd, TABLE *table,
                                          bool is_transactional,
                                          MY_BITMAP *cols,
                                          uint fields,
                                          const byte *before_record,
                                          const byte *after_record
                                          __attribute__((unused)))
  {
    return thd->binlog_delete_row(table, is_transactional,
                                  cols, fields, before_record);
  }
#endif
  
private:
  virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }

#ifdef MYSQL_CLIENT
  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
#endif

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
  gptr  m_memory;
  byte *m_key;
2181
  byte *m_after_image;
2182

2183 2184 2185 2186 2187
  virtual int do_before_row_operations(TABLE *table);
  virtual int do_after_row_operations(TABLE *table, int error);
  virtual int do_prepare_row(THD*, RELAY_LOG_INFO*, TABLE*,
                             char const *row_start, char const **row_end);
  virtual int do_exec_row(TABLE *table);
2188 2189 2190
#endif
};

2191
#endif /* _log_event_h */