log_event.h 142 KB
Newer Older
Sergei Golubchik's avatar
Sergei Golubchik committed
1
/* Copyright (c) 2000, 2013, Oracle and/or its affiliates.
2
   Copyright (c) 2009, 2013, Monty Program Ab.
unknown's avatar
unknown committed
3

unknown's avatar
unknown committed
4 5
   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
unknown's avatar
unknown committed
6
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
7

unknown's avatar
unknown 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.
unknown's avatar
unknown committed
12

unknown's avatar
unknown committed
13 14
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
15
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
unknown's avatar
unknown committed
16

17 18 19 20 21
/**
  @addtogroup Replication
  @{

  @file
22 23 24 25
  
  @brief Binary log event definitions.  This includes generic code
  common to all types of log events, as well as specific code for each
  type of log event.
26 27
*/

unknown's avatar
unknown committed
28

29 30
#ifndef _log_event_h
#define _log_event_h
unknown's avatar
unknown committed
31

32
#if defined(USE_PRAGMA_INTERFACE) && defined(MYSQL_SERVER)
unknown's avatar
unknown committed
33 34 35
#pragma interface			/* gcc class implementation */
#endif

36
#include <my_bitmap.h>
37
#include "rpl_constants.h"
38 39

#ifdef MYSQL_CLIENT
40
#include "sql_const.h"
41 42 43 44 45 46
#include "rpl_utility.h"
#include "hash.h"
#include "rpl_tblmap.h"
#include "rpl_tblmap.cc"
#endif

47
#ifdef MYSQL_SERVER
48 49
#include "rpl_record.h"
#include "rpl_reporting.h"
50
#include "sql_class.h"                          /* THD */
51
#endif
52

unknown's avatar
unknown committed
53 54
#include "rpl_gtid.h"

55 56 57
/* Forward declarations */
class String;

58
#define PREFIX_SQL_LOAD "SQL_LOAD-"
59
#define LONG_FIND_ROW_THRESHOLD 60 /* seconds */
60

61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
/**
   Either assert or return an error.

   In debug build, the condition will be checked, but in non-debug
   builds, the error code given will be returned instead.

   @param COND   Condition to check
   @param ERRNO  Error number to return in non-debug builds
*/
#ifdef DBUG_OFF
#define ASSERT_OR_RETURN_ERROR(COND, ERRNO) \
  do { if (!(COND)) return ERRNO; } while (0)
#else
#define ASSERT_OR_RETURN_ERROR(COND, ERRNO) \
  DBUG_ASSERT(COND)
#endif

unknown's avatar
unknown committed
78 79 80 81
#define LOG_READ_EOF    -1
#define LOG_READ_BOGUS  -2
#define LOG_READ_IO     -3
#define LOG_READ_MEM    -5
unknown's avatar
unknown committed
82
#define LOG_READ_TRUNC  -6
unknown's avatar
unknown committed
83
#define LOG_READ_TOO_LARGE -7
84
#define LOG_READ_CHECKSUM_FAILURE -8
unknown's avatar
unknown committed
85 86

#define LOG_EVENT_OFFSET 4
unknown's avatar
unknown committed
87 88

/*
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
   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 ?
unknown's avatar
unknown committed
111

112 113
   - Query and Load (Create or Execute) events may have a more precise
     timestamp (with microseconds), number of matched/affected/warnings rows
114 115
   and fields of session variables: SQL_MODE,
   FOREIGN_KEY_CHECKS, UNIQUE_CHECKS, SQL_AUTO_IS_NULL, the collations and
unknown's avatar
unknown committed
116
   charsets, the PASSWORD() version (old/new/...).
117 118
*/
#define BINLOG_VERSION    4
119

120 121 122
/*
 We could have used SERVER_VERSION_LENGTH, but this introduces an
 obscure dependency - if somebody decided to change SERVER_VERSION_LENGTH
123
 this would break the replication protocol
124 125 126
*/
#define ST_SERVER_VER_LEN 50

127 128 129 130 131
/*
  These are flags and structs to handle all the LOAD DATA INFILE options (LINES
  TERMINATED etc).
*/

132 133 134 135 136 137
/*
  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).
*/
138 139 140 141
#define DUMPFILE_FLAG		0x1
#define OPT_ENCLOSED_FLAG	0x2
#define REPLACE_FLAG		0x4
#define IGNORE_FLAG		0x8
142

143 144 145 146 147
#define FIELD_TERM_EMPTY	0x1
#define ENCLOSED_EMPTY		0x2
#define LINE_TERM_EMPTY		0x4
#define LINE_START_EMPTY	0x8
#define ESCAPED_EMPTY		0x10
148

149 150 151 152 153
/*****************************************************************************

  old_sql_ex struct

 ****************************************************************************/
154
struct old_sql_ex
155 156 157 158 159 160 161 162 163
{
  char field_term;
  char enclosed;
  char line_term;
  char line_start;
  char escaped;
  char opt_flags;
  char empty_flags;
};
164

unknown's avatar
unknown committed
165 166
#define NUM_LOAD_DELIM_STRS 5

167 168 169 170 171
/*****************************************************************************

  sql_ex_info struct

 ****************************************************************************/
172
struct sql_ex_info
173
{
174
  sql_ex_info() {}                            /* Remove gcc warning */
175 176 177 178 179
  const char* field_term;
  const char* enclosed;
  const char* line_term;
  const char* line_start;
  const char* escaped;
180 181
  int cached_new_format;
  uint8 field_term_len,enclosed_len,line_term_len,line_start_len, escaped_len;
unknown's avatar
unknown committed
182
  char opt_flags;
183
  char empty_flags;
unknown's avatar
unknown committed
184

185
  // store in new format even if old is possible
unknown's avatar
unknown committed
186
  void force_new_format() { cached_new_format = 1;}
187 188 189 190 191 192
  int data_size()
  {
    return (new_format() ?
	    field_term_len + enclosed_len + line_term_len +
	    line_start_len + escaped_len + 6 : 7);
  }
193
  bool write_data(IO_CACHE* file);
194
  const char* init(const char* buf, const char* buf_end, bool use_new_format);
195 196 197 198 199 200 201 202 203
  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)));
  }
};
204

205 206 207 208 209 210 211 212 213 214 215 216
/*****************************************************************************

  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.

unknown's avatar
unknown committed
217 218 219 220 221 222
  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).
223

224
 ****************************************************************************/
225

226 227
#define LOG_EVENT_HEADER_LEN 19     /* the fixed header length */
#define OLD_HEADER_LEN       13     /* the fixed header length in 3.23 */
unknown's avatar
unknown committed
228
/*
229 230 231 232 233 234
   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.
*/
unknown's avatar
unknown committed
235 236
#define LOG_EVENT_MINIMAL_HEADER_LEN 19

237
/* event-specific post-header sizes */
238 239 240
// 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.
unknown's avatar
unknown committed
241
#define QUERY_HEADER_LEN     (QUERY_HEADER_MINIMAL_LEN + 2)
242
#define STOP_HEADER_LEN      0
243
#define LOAD_HEADER_LEN      (4 + 4 + 4 + 1 +1 + 4)
244
#define SLAVE_HEADER_LEN     0
245 246
#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)
247
#define INTVAR_HEADER_LEN      0
248 249 250 251
#define CREATE_FILE_HEADER_LEN 4
#define APPEND_BLOCK_HEADER_LEN 4
#define EXEC_LOAD_HEADER_LEN   4
#define DELETE_FILE_HEADER_LEN 4
252 253 254
#define NEW_LOAD_HEADER_LEN    LOAD_HEADER_LEN
#define RAND_HEADER_LEN        0
#define USER_VAR_HEADER_LEN    0
255
#define FORMAT_DESCRIPTION_HEADER_LEN (START_V3_HEADER_LEN+1+LOG_EVENT_TYPES)
256 257
#define XID_HEADER_LEN         0
#define BEGIN_LOAD_QUERY_HEADER_LEN APPEND_BLOCK_HEADER_LEN
258 259
#define ROWS_HEADER_LEN        8
#define TABLE_MAP_HEADER_LEN   8
unknown's avatar
unknown committed
260 261
#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)
262
#define INCIDENT_HEADER_LEN    2
Andrei Elkin's avatar
Andrei Elkin committed
263
#define HEARTBEAT_HEADER_LEN   0
264
#define ANNOTATE_ROWS_HEADER_LEN  0
265
#define BINLOG_CHECKPOINT_HEADER_LEN 4
266 267
#define GTID_HEADER_LEN       19
#define GTID_LIST_HEADER_LEN   4
Sergei Golubchik's avatar
Sergei Golubchik committed
268

269 270
/* 
  Max number of possible extra bytes in a replication event compared to a
271 272
  packet (i.e. a query) sent from client to master;
  First, an auxiliary log_event status vars estimation:
273
*/
274 275 276 277 278 279 280 281
#define MAX_SIZE_LOG_EVENT_STATUS (1 + 4          /* type, flags2 */   + \
                                   1 + 8          /* type, sql_mode */ + \
                                   1 + 1 + 255    /* type, length, catalog */ + \
                                   1 + 4          /* type, auto_increment */ + \
                                   1 + 6          /* type, charset */ + \
                                   1 + 1 + 255    /* type, length, time_zone */ + \
                                   1 + 2          /* type, lc_time_names_number */ + \
                                   1 + 2          /* type, charset_database_number */ + \
282
                                   1 + 8          /* type, table_map_for_update */ + \
283
                                   1 + 4          /* type, master_data_written */ + \
284
                                   1 + 3          /* type, sec_part of NOW() */ + \
285
                                   1 + 16 + 1 + 60/* type, user_len, user, host_len, host */)
286 287 288 289 290 291
#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)
292

293 294 295 296 297 298 299
/*
  The new option is added to handle large packets that are sent from the master 
  to the slave. It is used to increase the thd(max_allowed) for both the
  DUMP thread on the master and the SQL/IO thread on the slave. 
*/
#define MAX_MAX_ALLOWED_PACKET 1024*1024*1024

300 301 302 303
/* 
   Event header offsets; 
   these point to places inside the fixed header.
*/
unknown's avatar
unknown committed
304

305
#define EVENT_TYPE_OFFSET    4
306 307
#define SERVER_ID_OFFSET     5
#define EVENT_LEN_OFFSET     9
308
#define LOG_POS_OFFSET       13
309 310
#define FLAGS_OFFSET         17

311
/* start event post-header (for v3 and v4) */
312 313 314 315

#define ST_BINLOG_VER_OFFSET  0
#define ST_SERVER_VER_OFFSET  2
#define ST_CREATED_OFFSET     (ST_SERVER_VER_OFFSET + ST_SERVER_VER_LEN)
316
#define ST_COMMON_HEADER_LEN_OFFSET (ST_CREATED_OFFSET + 4)
317

318
/* slave event post-header (this event is never written) */
319

unknown's avatar
unknown committed
320 321 322
#define SL_MASTER_PORT_OFFSET   8
#define SL_MASTER_POS_OFFSET    0
#define SL_MASTER_HOST_OFFSET   10
323 324 325

/* query event post-header */

326 327 328 329
#define Q_THREAD_ID_OFFSET	0
#define Q_EXEC_TIME_OFFSET	4
#define Q_DB_LEN_OFFSET		8
#define Q_ERR_CODE_OFFSET	9
330
#define Q_STATUS_VARS_LEN_OFFSET 11
331
#define Q_DATA_OFFSET		QUERY_HEADER_LEN
332 333 334
/* these are codes, not offsets; not more than 256 values (1 byte). */
#define Q_FLAGS2_CODE           0
#define Q_SQL_MODE_CODE         1
335 336
/*
  Q_CATALOG_CODE is catalog with end zero stored; it is used only by MySQL
337 338
  5.0.x where 0<=x<=3. We have to keep it to be able to replicate these
  old masters.
339
*/
340
#define Q_CATALOG_CODE          2
341
#define Q_AUTO_INCREMENT	3
342
#define Q_CHARSET_CODE          4
343
#define Q_TIME_ZONE_CODE        5
344 345 346 347 348 349 350 351
/*
  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
352

353 354
#define Q_LC_TIME_NAMES_CODE    7

355
#define Q_CHARSET_DATABASE_CODE 8
356 357

#define Q_TABLE_MAP_FOR_UPDATE_CODE 9
358

359 360
#define Q_MASTER_DATA_WRITTEN_CODE 10

361 362
#define Q_INVOKER 11

363 364
#define Q_HRNOW 128

365 366
/* Intvar event post-header */

367
/* Intvar event data */
368 369 370
#define I_TYPE_OFFSET        0
#define I_VAL_OFFSET         1

371
/* Rand event data */
unknown's avatar
unknown committed
372 373 374
#define RAND_SEED1_OFFSET 0
#define RAND_SEED2_OFFSET 8

375
/* User_var event data */
unknown's avatar
unknown committed
376 377 378 379 380 381
#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

382 383 384 385
/* Load event post-header */
#define L_THREAD_ID_OFFSET   0
#define L_EXEC_TIME_OFFSET   4
#define L_SKIP_LINES_OFFSET  8
unknown's avatar
unknown committed
386 387
#define L_TBL_LEN_OFFSET     12
#define L_DB_LEN_OFFSET      13
388
#define L_NUM_FIELDS_OFFSET  14
389
#define L_SQL_EX_OFFSET      18
390
#define L_DATA_OFFSET        LOAD_HEADER_LEN
391

392 393 394
/* Rotate event post-header */
#define R_POS_OFFSET       0
#define R_IDENT_OFFSET     8
395

396 397 398
/* CF to DF handle LOAD DATA INFILE */

/* CF = "Create File" */
399 400 401
#define CF_FILE_ID_OFFSET  0
#define CF_DATA_OFFSET     CREATE_FILE_HEADER_LEN

402
/* AB = "Append Block" */
403 404 405
#define AB_FILE_ID_OFFSET  0
#define AB_DATA_OFFSET     APPEND_BLOCK_HEADER_LEN

406
/* EL = "Execute Load" */
407 408
#define EL_FILE_ID_OFFSET  0

409
/* DF = "Delete File" */
410
#define DF_FILE_ID_OFFSET  0
411

412 413 414 415 416 417 418 419
/* 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

unknown's avatar
unknown committed
420 421 422 423 424 425
/* 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

426
/* 4 bytes which all binlogs should begin with */
Michael Widenius's avatar
Michael Widenius committed
427
#define BINLOG_MAGIC        (const uchar*) "\xfe\x62\x69\x6e"
428

429 430 431 432 433 434 435 436
/*
  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
unknown's avatar
unknown committed
437
  replacing flag when reading a Rotate event.
438 439 440
  I keep the defines here just to remember what they were.
*/
#ifdef TO_BE_REMOVED
unknown's avatar
unknown committed
441
#define LOG_EVENT_TIME_F            0x1
unknown's avatar
unknown committed
442
#define LOG_EVENT_FORCED_ROTATE_F   0x2
443
#endif
444 445

/*
446 447 448 449 450 451 452 453
   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).

454 455 456 457 458 459 460 461
   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.
462 463 464

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

467 468
#define LOG_EVENT_BINLOG_IN_USE_F       0x1

469 470 471 472 473 474 475
/**
  @def LOG_EVENT_THREAD_SPECIFIC_F

  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).
476
*/
unknown's avatar
unknown committed
477
#define LOG_EVENT_THREAD_SPECIFIC_F 0x4
478

479 480 481
/**
  @def LOG_EVENT_SUPPRESS_USE_F

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

494
/*
495 496 497
  Note: this is a place holder for the flag
  LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F (0x10), which is not used any
  more, please do not reused this value for other flags.
498 499
 */

500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
/**
   @def LOG_EVENT_ARTIFICIAL_F
   
   Artificial events are created arbitarily and not written to binary
   log

   These events should not update the master log position when slave
   SQL thread executes them.
*/
#define LOG_EVENT_ARTIFICIAL_F 0x20

/**
   @def LOG_EVENT_RELAY_LOG_F
   
   Events with this flag set are created by slave IO thread and written
   to relay log
*/
#define LOG_EVENT_RELAY_LOG_F 0x40

519
/**
520
   @def LOG_EVENT_SKIP_REPLICATION_F
521

522
   Flag set by application creating the event (with @@skip_replication); the
523
   slave will skip replication of such events if
524
   --replicate-events-marked-for-skip is not set to REPLICATE.
525 526 527 528

   This is a MariaDB flag; we allocate it from the end of the available
   values to reduce risk of conflict with new MySQL flags.
*/
529
#define LOG_EVENT_SKIP_REPLICATION_F 0x8000
530 531


532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
/**
  @def OPTIONS_WRITTEN_TO_BIN_LOG

  OPTIONS_WRITTEN_TO_BIN_LOG are the bits of thd->options which must
  be written to the binlog. OPTIONS_WRITTEN_TO_BIN_LOG 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.

  I (Guilhem) have read through every option's usage, and it looks
  like 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.
  OPTION_BIG_SELECTS is not needed (the slave thread runs with
  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).
unknown's avatar
unknown committed
552
*/
553 554 555
#define OPTIONS_WRITTEN_TO_BIN_LOG \
  (OPTION_AUTO_IS_NULL | OPTION_NO_FOREIGN_KEY_CHECKS |  \
   OPTION_RELAXED_UNIQUE_CHECKS | OPTION_NOT_AUTOCOMMIT)
556

557 558
/* Shouldn't be defined before */
#define EXPECTED_OPTIONS \
559
  ((1ULL << 14) | (1ULL << 26) | (1ULL << 27) | (1ULL << 19))
560

561
#if OPTIONS_WRITTEN_TO_BIN_LOG != EXPECTED_OPTIONS
unknown's avatar
unknown committed
562 563
#error OPTIONS_WRITTEN_TO_BIN_LOG must NOT change their values!
#endif
564
#undef EXPECTED_OPTIONS         /* You shouldn't use this one */
unknown's avatar
unknown committed
565

566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
enum enum_binlog_checksum_alg {
  BINLOG_CHECKSUM_ALG_OFF= 0,    // Events are without checksum though its generator
                                 // is checksum-capable New Master (NM).
  BINLOG_CHECKSUM_ALG_CRC32= 1,  // CRC32 of zlib algorithm.
  BINLOG_CHECKSUM_ALG_ENUM_END,  // the cut line: valid alg range is [1, 0x7f].
  BINLOG_CHECKSUM_ALG_UNDEF= 255 // special value to tag undetermined yet checksum
                                 // or events from checksum-unaware servers
};

#define CHECKSUM_CRC32_SIGNATURE_LEN 4
/**
   defined statically while there is just one alg implemented
*/
#define BINLOG_CHECKSUM_LEN CHECKSUM_CRC32_SIGNATURE_LEN
#define BINLOG_CHECKSUM_ALG_DESC_LEN 1  /* 1 byte checksum alg descriptor */

582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
/*
  These are capability numbers for MariaDB slave servers.

  Newer MariaDB slaves set this to inform the master about their capabilities.
  This allows the master to decide which events it can send to the slave
  without breaking replication on old slaves that maybe do not understand
  all events from newer masters.

  As new releases are backwards compatible, a given capability implies also
  all capabilities with smaller number.

  Older MariaDB slaves and other MySQL slave servers do not set this, so they
  are recorded with capability 0.
*/

/* MySQL or old MariaDB slave with no announced capability. */
#define MARIA_SLAVE_CAPABILITY_UNKNOWN 0
/* MariaDB >= 5.3, which understands ANNOTATE_ROWS_EVENT. */
#define MARIA_SLAVE_CAPABILITY_ANNOTATE 1
/*
  MariaDB >= 5.5. This version has the capability to tolerate events omitted
  from the binlog stream without breaking replication (MySQL slaves fail
  because they mis-compute the offsets into the master's binlog).
*/
#define MARIA_SLAVE_CAPABILITY_TOLERATE_HOLES 2
607
/* MariaDB >= 10.0, which knows about binlog_checkpoint_log_event. */
608
#define MARIA_SLAVE_CAPABILITY_BINLOG_CHECKPOINT 3
609 610
/* MariaDB >= 10.0.1, which knows about global transaction id events. */
#define MARIA_SLAVE_CAPABILITY_GTID 4
611 612

/* Our capability. */
613
#define MARIA_SLAVE_CAPABILITY_MINE MARIA_SLAVE_CAPABILITY_GTID
614 615


616 617 618 619 620
/**
  @enum Log_event_type

  Enumeration type for the different types of log events.
*/
621 622
enum Log_event_type
{
623 624
  /*
    Every time you update this enum (when you add a type), you have to
unknown's avatar
unknown committed
625
    fix Format_description_log_event::Format_description_log_event().
626
  */
unknown's avatar
unknown committed
627 628 629 630 631 632 633 634 635 636 637
  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,
638
  DELETE_FILE_EVENT= 11,
639
  /*
unknown's avatar
unknown committed
640 641 642
    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)
643
  */
644
  NEW_LOAD_EVENT= 12,
unknown's avatar
unknown committed
645 646 647 648 649 650
  RAND_EVENT= 13,
  USER_VAR_EVENT= 14,
  FORMAT_DESCRIPTION_EVENT= 15,
  XID_EVENT= 16,
  BEGIN_LOAD_QUERY_EVENT= 17,
  EXECUTE_LOAD_QUERY_EVENT= 18,
651

652
  TABLE_MAP_EVENT = 19,
653 654 655 656 657 658 659 660 661 662 663 664 665 666 667

  /*
    These event numbers were used for 5.1.0 to 5.1.15 and are
    therefore obsolete.
   */
  PRE_GA_WRITE_ROWS_EVENT = 20,
  PRE_GA_UPDATE_ROWS_EVENT = 21,
  PRE_GA_DELETE_ROWS_EVENT = 22,

  /*
    These event numbers are used from 5.1.16 and forward
   */
  WRITE_ROWS_EVENT = 23,
  UPDATE_ROWS_EVENT = 24,
  DELETE_ROWS_EVENT = 25,
unknown's avatar
unknown committed
668

669 670 671
  /*
    Something out of the ordinary happened on the master
   */
unknown's avatar
unknown committed
672
  INCIDENT_EVENT= 26,
673

Andrei Elkin's avatar
Andrei Elkin committed
674 675 676 677 678 679
  /*
    Heartbeat event to be send by master at its idle time 
    to ensure master's online status to slave 
  */
  HEARTBEAT_LOG_EVENT= 27,
  
unknown's avatar
unknown committed
680
  /*
unknown's avatar
unknown committed
681
    Add new events here - right above this comment!
unknown's avatar
unknown committed
682
    Existing events (except ENUM_END_EVENT) should never change their numbers
unknown's avatar
unknown committed
683 684
  */

685 686 687 688 689 690
  /* New MySQL/Sun events are to be added right above this comment */
  MYSQL_EVENTS_END,

  MARIA_EVENTS_BEGIN= 160,
  /* New Maria event numbers start from here */
  ANNOTATE_ROWS_EVENT= 160,
691 692 693 694 695 696 697 698
  /*
    Binlog checkpoint event. Used for XA crash recovery on the master, not used
    in replication.
    A binlog checkpoint event specifies a binlog file such that XA crash
    recovery can start from that file - and it is guaranteed to find all XIDs
    that are prepared in storage engines but not yet committed.
  */
  BINLOG_CHECKPOINT_EVENT= 161,
699 700 701 702 703 704 705 706 707 708 709 710
  /*
    Gtid event. For global transaction ID, used to start a new event group,
    instead of the old BEGIN query event, and also to mark stand-alone
    events.
  */
  GTID_EVENT= 162,
  /*
    Gtid list event. Logged at the start of every binlog, to record the
    current replication state. This consists of the last GTID seen for
    each replication domain.
  */
  GTID_LIST_EVENT= 163,
711

Sergei Golubchik's avatar
Sergei Golubchik committed
712
  /* Add new MariaDB events here - right above this comment!  */
unknown's avatar
unknown committed
713

unknown's avatar
unknown committed
714
  ENUM_END_EVENT /* end marker */
715 716
};

unknown's avatar
unknown committed
717
/*
718 719 720 721 722 723
   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)

724 725 726 727 728
enum Int_event_type
{
  INVALID_INT_EVENT = 0, LAST_INSERT_ID_EVENT = 1, INSERT_ID_EVENT = 2
};

unknown's avatar
unknown committed
729

730
#ifdef MYSQL_SERVER
unknown's avatar
unknown committed
731
class String;
732
class MYSQL_BIN_LOG;
733
class THD;
unknown's avatar
unknown committed
734 735
#endif

736
class Format_description_log_event;
737
class Relay_log_info;
738

739
#ifdef MYSQL_CLIENT
740 741 742 743 744
enum enum_base64_output_mode {
  BASE64_OUTPUT_NEVER= 0,
  BASE64_OUTPUT_AUTO= 1,
  BASE64_OUTPUT_ALWAYS= 2,
  BASE64_OUTPUT_UNSPEC= 3,
745
  BASE64_OUTPUT_DECODE_ROWS= 4,
746 747 748 749
  /* insert new output modes here */
  BASE64_OUTPUT_MODE_COUNT
};

750
/*
unknown's avatar
unknown committed
751 752
  A structure for mysqlbinlog to know how to print events

unknown's avatar
unknown committed
753 754 755 756 757 758 759 760
  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.
761
*/
unknown's avatar
unknown committed
762
typedef struct st_print_event_info
763
{
unknown's avatar
unknown committed
764 765
  /*
    Settings for database, sql_mode etc that comes from the last event
766 767 768
    that was printed.  We cache these so that we don't have to print
    them if they are unchanged.
  */
769 770 771 772 773
  // 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;
774
  ulonglong sql_mode;		/* must be same as THD.variables.sql_mode */
775
  ulong auto_increment_increment, auto_increment_offset;
776 777
  bool charset_inited;
  char charset[6]; // 3 variables, each of them storable in 2 bytes
778
  char time_zone_str[MAX_TIME_ZONE_NAME_LENGTH];
779
  uint lc_time_names_number;
780
  uint charset_database_number;
781 782
  uint thread_id;
  bool thread_id_printed;
783 784 785 786 787
  uint32 server_id;
  bool server_id_printed;
  uint32 domain_id;
  bool domain_id_printed;

788
  /*
789
    Track when @@skip_replication changes so we need to output a SET
790 791
    statement for it.
  */
792
  int skip_replication;
793 794

  st_print_event_info();
unknown's avatar
unknown committed
795

796
  ~st_print_event_info() {
797 798
    close_cached_file(&head_cache);
    close_cached_file(&body_cache);
799
  }
800 801
  bool init_ok() /* tells if construction was successful */
    { return my_b_inited(&head_cache) && my_b_inited(&body_cache); }
802 803


unknown's avatar
unknown committed
804 805
  /* Settings on how to print the events */
  bool short_form;
806 807 808 809 810 811 812 813
  enum_base64_output_mode base64_output_mode;
  /*
    This is set whenever a Format_description_event is printed.
    Later, when an event is printed in base64, this flag is tested: if
    no Format_description_event has been seen, it is unsafe to print
    the base64 event, so an error message is generated.
  */
  bool printed_fd_event;
unknown's avatar
unknown committed
814 815
  my_off_t hexdump_from;
  uint8 common_header_len;
816
  char delimiter[16];
unknown's avatar
unknown committed
817

818 819
  uint verbose;
  table_mapping m_table_map;
820
  table_mapping m_table_map_ignored;
821

822 823 824 825 826 827 828
  /*
     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;
unknown's avatar
unknown committed
829
} PRINT_EVENT_INFO;
830 831
#endif

Andrei Elkin's avatar
Andrei Elkin committed
832 833 834 835 836 837 838 839 840
/**
  the struct aggregates two paramenters that identify an event
  uniquely in scope of communication of a particular master and slave couple.
  I.e there can not be 2 events from the same staying connected master which
  have the same coordinates.
  @note
  Such identifier is not yet unique generally as the event originating master
  is resetable. Also the crashed master can be replaced with some other.
*/
841
typedef struct event_coordinates
Andrei Elkin's avatar
Andrei Elkin committed
842 843 844
{
  char * file_name; // binlog file name (directories stripped)
  my_off_t  pos;       // event's position in the binlog file
845
} LOG_POS_COORD;
846

847 848
/**
  @class Log_event
849 850

  This is the abstract base class for binary log events.
851 852 853
  
  @section Log_event_binary_format Binary Format

854
  Any @c Log_event saved on disk consists of the following three
855 856
  components.

857 858 859
  - Common-Header
  - Post-Header
  - Body
860

861 862
  The Common-Header, documented in the table @ref Table_common_header
  "below", always has the same form and length within one version of
863 864 865 866 867 868
  MySQL.  Each event type specifies a format and length of the
  Post-Header.  The length of the Common-Header is the same for all
  events of the same type.  The Body may be of different format and
  length even for different events of the same type.  The binary
  formats of Post-Header and Body are documented separately in each
  subclass.  The binary format of Common-Header is as follows.
869 870 871 872 873 874

  <table>
  <caption>Common-Header</caption>

  <tr>
    <th>Name</th>
875
    <th>Format</th>
876 877 878 879 880 881
    <th>Description</th>
  </tr>

  <tr>
    <td>timestamp</td>
    <td>4 byte unsigned integer</td>
882
    <td>The time when the query started, in seconds since 1970.
883 884 885 886 887 888 889 890 891 892
    </td>
  </tr>

  <tr>
    <td>type</td>
    <td>1 byte enumeration</td>
    <td>See enum #Log_event_type.</td>
  </tr>

  <tr>
893 894
    <td>server_id</td>
    <td>4 byte unsigned integer</td>
895 896 897 898 899
    <td>Server ID of the server that created the event.</td>
  </tr>

  <tr>
    <td>total_size</td>
900
    <td>4 byte unsigned integer</td>
901 902 903 904 905 906 907
    <td>The total size of this event, in bytes.  In other words, this
    is the sum of the sizes of Common-Header, Post-Header, and Body.
    </td>
  </tr>

  <tr>
    <td>master_position</td>
908
    <td>4 byte unsigned integer</td>
909
    <td>The position of the next event in the master binary log, in
910 911 912 913
    bytes from the beginning of the file.  In a binlog that is not a
    relay log, this is just the position of the next event, in bytes
    from the beginning of the file.  In a relay log, this is
    the position of the next event in the master's binlog.
914 915 916 917 918 919 920 921 922 923 924 925 926
    </td>
  </tr>

  <tr>
    <td>flags</td>
    <td>2 byte bitfield</td>
    <td>See Log_event::flags.</td>
  </tr>
  </table>

  Summing up the numbers above, we see that the total size of the
  common header is 19 bytes.

927 928 929 930 931 932 933 934 935 936
  @subsection Log_event_format_of_atomic_primitives Format of Atomic Primitives

  - All numbers, whether they are 16-, 24-, 32-, or 64-bit numbers,
  are stored in little endian, i.e., the least significant byte first,
  unless otherwise specified.

  @anchor packed_integer
  - Some events use a special format for efficient representation of
  unsigned integers, called Packed Integer.  A Packed Integer has the
  capacity of storing up to 8-byte integers, while small integers
937 938
  still can use 1, 3, or 4 bytes.  The value of the first byte
  determines how to read the number, according to the following table:
939 940 941 942 943 944 945 946 947 948 949

  <table>
  <caption>Format of Packed Integer</caption>

  <tr>
    <th>First byte</th>
    <th>Format</th>
  </tr>

  <tr>
    <td>0-250</td>
950
    <td>The first byte is the number (in the range 0-250), and no more
951 952 953 954 955 956 957 958
    bytes are used.</td>
  </tr>

  <tr>
    <td>252</td>
    <td>Two more bytes are used.  The number is in the range
    251-0xffff.</td>
  </tr>
959

960 961 962 963 964
  <tr>
    <td>253</td>
    <td>Three more bytes are used.  The number is in the range
    0xffff-0xffffff.</td>
  </tr>
965

966 967 968 969 970 971 972 973 974 975
  <tr>
    <td>254</td>
    <td>Eight more bytes are used.  The number is in the range
    0xffffff-0xffffffffffffffff.</td>
  </tr>

  </table>

  - Strings are stored in various formats.  The format of each string
  is documented separately.
976
*/
unknown's avatar
unknown committed
977 978 979
class Log_event
{
public:
980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
  /**
     Enumeration of what kinds of skipping (and non-skipping) that can
     occur when the slave executes an event.

     @see shall_skip
     @see do_shall_skip
   */
  enum enum_skip_reason {
    /**
       Don't skip event.
    */
    EVENT_SKIP_NOT,

    /**
       Skip event by ignoring it.

       This means that the slave skip counter will not be changed.
    */
    EVENT_SKIP_IGNORE,

    /**
       Skip event and decrease skip counter.
    */
    EVENT_SKIP_COUNT
  };

1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
  enum enum_event_cache_type 
  {
    EVENT_INVALID_CACHE,
    /* 
      If possible the event should use a non-transactional cache before
      being flushed to the binary log. This means that it must be flushed
      right after its correspondent statement is completed.
    */
    EVENT_STMT_CACHE,
    /* 
      The event should use a transactional cache before being flushed to
      the binary log. This means that it must be flushed upon commit or 
      rollback. 
    */
    EVENT_TRANSACTIONAL_CACHE,
    /* 
      The event must be written directly to the binary log without going
      through a cache.
    */
    EVENT_NO_CACHE,
    /**
       If there is a need for different types, introduce them before this.
    */
    EVENT_CACHE_COUNT
  };
1031

1032 1033 1034 1035 1036 1037 1038
  /*
    The following type definition is to be used whenever data is placed 
    and manipulated in a common buffer. Use this typedef for buffers
    that contain data containing binary and character data.
  */
  typedef unsigned char Byte;

unknown's avatar
unknown committed
1039
  /*
1040 1041 1042 1043 1044 1045 1046 1047
    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.
1048
  */
1049
  my_off_t log_pos;
unknown's avatar
unknown committed
1050
  /*
1051 1052 1053
     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.
  */
unknown's avatar
unknown committed
1054
  char *temp_buf;
1055 1056 1057 1058 1059 1060 1061
  
  /*
    TRUE <=> this event 'owns' temp_buf and should call my_free() when done
    with it
  */
  bool event_owns_temp_buf;

1062
  /*
1063 1064 1065 1066 1067 1068
    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).
1069
  */
1070 1071
  my_time_t when;
  ulong     when_sec_part;
1072
  /* The number of seconds the query took to run on the master. */
unknown's avatar
unknown committed
1073
  ulong exec_time;
1074 1075 1076
  /* Number of bytes written by write() function */
  ulong data_written;

unknown's avatar
unknown committed
1077
  /*
1078 1079
    The master's server id (is preserved in the relay log; used to
    prevent from infinite loops in circular replication).
1080
  */
1081
  uint32 server_id;
1082

1083 1084
  /**
    Some 16 flags. See the definitions above for LOG_EVENT_TIME_F,
1085
    LOG_EVENT_FORCED_ROTATE_F, LOG_EVENT_THREAD_SPECIFIC_F,
1086
    LOG_EVENT_SUPPRESS_USE_F, and LOG_EVENT_SKIP_REPLICATION_F for notes.
1087
  */
1088
  uint16 flags;
1089

1090
  uint16 cache_type;
1091

1092 1093 1094 1095 1096 1097
  /**
    A storage to cache the global system variable's value.
    Handling of a separate event will be governed its member.
  */
  ulong slave_exec_mode;

1098 1099 1100 1101
  /**
    Placeholder for event checksum while writing to binlog.
   */
  ha_checksum crc;
Sergei Golubchik's avatar
Sergei Golubchik committed
1102

1103
#ifdef MYSQL_SERVER
1104
  THD* thd;
1105

1106
  Log_event();
1107
  Log_event(THD* thd_arg, uint16 flags_arg, bool is_transactional);
1108
  /*
1109 1110 1111 1112 1113 1114 1115 1116 1117
    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.
1118
  */
1119
  static Log_event* read_log_event(IO_CACHE* file,
Marc Alff's avatar
Marc Alff committed
1120
                                   mysql_mutex_t* log_lock,
1121
                                   const Format_description_log_event
1122 1123
                                   *description_event,
                                   my_bool crc_check);
1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147

  /**
    Reads an event from a binlog or relay log. Used by the dump thread
    this method reads the event into a raw buffer without parsing it.

    @Note If mutex is 0, the read will proceed without mutex.

    @Note If a log name is given than the method will check if the
    given binlog is still active.

    @param[in]  file                log file to be read
    @param[out] packet              packet to hold the event
    @param[in]  lock                the lock to be used upon read
    @param[in]  log_file_name_arg   the log's file name
    @param[out] is_binlog_active    is the current log still active

    @retval 0                   success
    @retval LOG_READ_EOF        end of file, nothing was read
    @retval LOG_READ_BOGUS      malformed event
    @retval LOG_READ_IO         io error while reading
    @retval LOG_READ_MEM        packet memory allocation failed
    @retval LOG_READ_TRUNC      only a partial event could be read
    @retval LOG_READ_TOO_LARGE  event too large
   */
1148
  static int read_log_event(IO_CACHE* file, String* packet,
1149
                            mysql_mutex_t* log_lock,
Sergei Golubchik's avatar
Sergei Golubchik committed
1150 1151 1152
                            uint8 checksum_alg_arg,
                            const char *log_file_name_arg = NULL,
                            bool* is_binlog_active = NULL);
1153
  /*
1154 1155 1156
    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.
1157
  */
1158
  static void init_show_field_list(List<Item>* field_list);
unknown's avatar
SCRUM  
unknown committed
1159
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
1160 1161
  int net_send(THD *thd, Protocol *protocol, const char* log_name,
               my_off_t pos);
1162

1163 1164 1165 1166
  /*
    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().
  */
1167

unknown's avatar
unknown committed
1168
  virtual void pack_info(THD *thd, Protocol *protocol);
1169

unknown's avatar
SCRUM  
unknown committed
1170
#endif /* HAVE_REPLICATION */
1171 1172 1173 1174 1175
  virtual const char* get_db()
  {
    return thd ? thd->db : 0;
  }
#else
Libing Song's avatar
Libing Song committed
1176
  Log_event() : temp_buf(0), flags(0) {}
1177
    /* avoid having to link mysqlbinlog against libpthread */
1178
  static Log_event* read_log_event(IO_CACHE* file,
1179
                                   const Format_description_log_event
1180
                                   *description_event, my_bool crc_check);
1181
  /* print*() functions are used by mysqlbinlog */
1182
  virtual void print(FILE* file, PRINT_EVENT_INFO* print_event_info) = 0;
1183 1184 1185 1186 1187
  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);
unknown's avatar
unknown committed
1188
#endif
1189 1190 1191 1192 1193 1194 1195 1196 1197
  /* 
     The value is set by caller of FD constructor and
     Log_event::write_header() for the rest.
     In the FD case it's propagated into the last byte 
     of post_header_len[] at FD::write().
     On the slave side the value is assigned from post_header_len[last] 
     of the last seen FD event.
  */
  uint8 checksum_alg;
unknown's avatar
unknown committed
1198

1199 1200 1201 1202
  static void *operator new(size_t size)
  {
    return (void*) my_malloc((uint)size, MYF(MY_WME|MY_FAE));
  }
1203

1204
  static void operator delete(void *ptr, size_t)
1205
  {
1206
    my_free(ptr);
1207
  }
unknown's avatar
unknown committed
1208

1209 1210 1211
  /* Placement version of the above operators */
  static void *operator new(size_t, void* ptr) { return ptr; }
  static void operator delete(void*, void*) { }
1212
  bool wrapper_my_b_safe_write(IO_CACHE* file, const uchar* buf, ulong data_length);
1213

1214
#ifdef MYSQL_SERVER
1215
  bool write_header(IO_CACHE* file, ulong data_length);
1216 1217 1218
  bool write_footer(IO_CACHE* file);
  my_bool need_checksum();

1219 1220
  virtual bool write(IO_CACHE* file)
  {
1221 1222 1223 1224
    return(write_header(file, get_data_size()) ||
	   write_data_header(file) ||
	   write_data_body(file) ||
	   write_footer(file));
1225 1226
  }
  virtual bool write_data_header(IO_CACHE* file)
1227
  { return 0; }
1228
  virtual bool write_data_body(IO_CACHE* file __attribute__((unused)))
1229
  { return 0; }
1230
  inline my_time_t get_time()
1231 1232 1233
  {
    THD *tmp_thd;
    if (when)
unknown's avatar
unknown committed
1234
      return when;
1235
    if (thd)
1236 1237 1238 1239 1240
    {
      when= thd->start_time;
      when_sec_part= thd->start_time_sec_part;
      return when;
    }
Sergei Golubchik's avatar
Sergei Golubchik committed
1241
    /* thd will only be 0 here at time of log creation */
1242
    if ((tmp_thd= current_thd))
1243 1244 1245 1246 1247 1248
    {
      when= tmp_thd->start_time;
      when_sec_part= tmp_thd->start_time_sec_part;
      return when;
    }
    my_hrtime_t hrtime= my_hrtime();
1249
    when= hrtime_to_my_time(hrtime);
1250 1251
    when_sec_part= hrtime_sec_part(hrtime);
    return when;
1252
  }
1253
#endif
unknown's avatar
unknown committed
1254
  virtual Log_event_type get_type_code() = 0;
unknown's avatar
unknown committed
1255
  virtual bool is_valid() const = 0;
1256 1257 1258 1259
  void set_artificial_event() { flags |= LOG_EVENT_ARTIFICIAL_F; }
  void set_relay_log_event() { flags |= LOG_EVENT_RELAY_LOG_F; }
  bool is_artificial_event() const { return flags & LOG_EVENT_ARTIFICIAL_F; }
  bool is_relay_log_event() const { return flags & LOG_EVENT_RELAY_LOG_F; }
1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
  inline bool use_trans_cache() const
  { 
    return (cache_type == Log_event::EVENT_TRANSACTIONAL_CACHE);
  }
  inline void set_direct_logging()
  {
    cache_type = Log_event::EVENT_NO_CACHE;
  }
  inline bool use_direct_logging()
  {
    return (cache_type == Log_event::EVENT_NO_CACHE);
  }
1272 1273
  Log_event(const char* buf, const Format_description_log_event
            *description_event);
1274
  virtual ~Log_event() { free_temp_buf();}
1275 1276 1277 1278 1279
  void register_temp_buf(char* buf, bool must_free) 
  { 
    temp_buf= buf; 
    event_owns_temp_buf= must_free;
  }
1280
  void free_temp_buf()
1281 1282
  {
    if (temp_buf)
1283
    {
1284
      if (event_owns_temp_buf)
Sergei Golubchik's avatar
Sergei Golubchik committed
1285
        my_free(temp_buf);
1286
      temp_buf = 0;
1287
    }
1288
  }
1289 1290 1291 1292
  /*
    Get event length for simple events. For complicated events the length
    is calculated during write()
  */
1293
  virtual int get_data_size() { return 0;}
1294 1295 1296
  static Log_event* read_log_event(const char* buf, uint event_len,
				   const char **error,
                                   const Format_description_log_event
1297
                                   *description_event, my_bool crc_check);
1298 1299 1300 1301 1302 1303 1304
  /**
    Returns the human readable name of the given event type.
  */
  static const char* get_type_str(Log_event_type type);
  /**
    Returns the human readable name of this event's type.
  */
unknown's avatar
unknown committed
1305
  const char* get_type_str();
1306

1307 1308
  /* Return start of query time or current time */

1309
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
public:

  /**
     Apply the event to the database.

     This function represents the public interface for applying an
     event.

     @see do_apply_event
   */
1320
  int apply_event(struct rpl_group_info *rgi)
1321
  {
1322
    return do_apply_event(rgi);
1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
  }


  /**
     Update the relay log position.

     This function represents the public interface for "stepping over"
     the event and will update the relay log information.

     @see do_update_pos
   */
1334
  int update_pos(struct rpl_group_info *rgi)
1335
  {
1336
    return do_update_pos(rgi);
1337 1338 1339 1340 1341 1342 1343 1344
  }

  /**
     Decide if the event shall be skipped, and the reason for skipping
     it.

     @see do_shall_skip
   */
1345
  enum_skip_reason shall_skip(Relay_log_info *rli)
1346 1347 1348 1349
  {
    return do_shall_skip(rli);
  }

unknown's avatar
unknown committed
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378

  /*
    Check if an event is non-final part of a stand-alone event group,
    such as Intvar_log_event (such events should be processed as part
    of the following event group, not individually).
  */
  static bool is_part_of_group(enum Log_event_type ev_type)
  {
    switch (ev_type)
    {
    case GTID_EVENT:
    case INTVAR_EVENT:
    case RAND_EVENT:
    case USER_VAR_EVENT:
    case TABLE_MAP_EVENT:
    case ANNOTATE_ROWS_EVENT:
      return true;
    case DELETE_ROWS_EVENT:
    case UPDATE_ROWS_EVENT:
    case WRITE_ROWS_EVENT:
    /*
      ToDo: also check for non-final Rows_log_event (though such events
      are usually in a BEGIN-COMMIT group).
    */
    default:
      return false;
    }
  }

1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398
  static bool is_group_event(enum Log_event_type ev_type)
  {
    switch (ev_type)
    {
    case START_EVENT_V3:
    case STOP_EVENT:
    case ROTATE_EVENT:
    case SLAVE_EVENT:
    case FORMAT_DESCRIPTION_EVENT:
    case INCIDENT_EVENT:
    case HEARTBEAT_LOG_EVENT:
    case BINLOG_CHECKPOINT_EVENT:
    case GTID_LIST_EVENT:
      return false;

    default:
      return true;
    }
  }
  
1399
protected:
1400

1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419
  /**
     Helper function to ignore an event w.r.t. the slave skip counter.

     This function can be used inside do_shall_skip() for functions
     that cannot end a group. If the slave skip counter is 1 when
     seeing such an event, the event shall be ignored, the counter
     left intact, and processing continue with the next event.

     A typical usage is:
     @code
     enum_skip_reason do_shall_skip(Relay_log_info *rli) {
       return continue_group(rli);
     }
     @endcode

     @return Skip reason
   */
  enum_skip_reason continue_group(Relay_log_info *rli);

1420 1421 1422 1423 1424
  /**
    Primitive to apply an event to the database.

    This is where the change to the database is made.

1425 1426 1427 1428 1429
    @note The primitive is protected instead of private, since there
    is a hierarchy of actions to be performed in some cases.

    @see Format_description_log_event::do_apply_event()

1430 1431 1432 1433 1434
    @param rli Pointer to relay log info structure

    @retval 0     Event applied successfully
    @retval errno Error code if event application failed
  */
1435
  virtual int do_apply_event(struct rpl_group_info *rgi)
1436 1437 1438 1439
  {
    return 0;                /* Default implementation does nothing */
  }

1440 1441

  /**
1442 1443 1444 1445 1446 1447
     Advance relay log coordinates.

     This function is called to advance the relay log coordinates to
     just after the event.  It is essential that both the relay log
     coordinate and the group log position is updated correctly, since
     this function is used also for skipping events.
1448

1449 1450 1451 1452 1453 1454 1455
     Normally, each implementation of do_update_pos() shall:

     - Update the event position to refer to the position just after
       the event.

     - Update the group log position to refer to the position just
       after the event <em>if the event is last in a group</em>
1456 1457 1458 1459

     @param rli Pointer to relay log info structure

     @retval 0     Coordinates changed successfully
1460 1461 1462
     @retval errno Error code if advancing failed (usually just
                   1). Observe that handler errors are returned by the
                   do_apply_event() function, and not by this one.
1463
   */
1464
  virtual int do_update_pos(struct rpl_group_info *rgi);
1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495


  /**
     Decide if this event shall be skipped or not and the reason for
     skipping it.

     The default implementation decide that the event shall be skipped
     if either:

     - the server id of the event is the same as the server id of the
       server and <code>rli->replicate_same_server_id</code> is true,
       or

     - if <code>rli->slave_skip_counter</code> is greater than zero.

     @see do_apply_event
     @see do_update_pos

     @retval Log_event::EVENT_SKIP_NOT
     The event shall not be skipped and should be applied.

     @retval Log_event::EVENT_SKIP_IGNORE
     The event shall be skipped by just ignoring it, i.e., the slave
     skip counter shall not be changed. This happends if, for example,
     the originating server id of the event is the same as the server
     id of the slave.

     @retval Log_event::EVENT_SKIP_COUNT
     The event shall be skipped because the slave skip counter was
     non-zero. The caller shall decrease the counter by one.
   */
1496
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
1497
#endif
unknown's avatar
unknown committed
1498 1499
};

1500

unknown's avatar
unknown committed
1501
/*
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512
   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.
*/
unknown's avatar
unknown committed
1513

1514 1515 1516
/**
  @class Query_log_event
   
1517 1518
  A @c Query_log_event is created for each query that modifies the
  database, unless the query is logged row-based.
1519 1520 1521

  @section Query_log_event_binary_format Binary format

1522 1523 1524 1525
  See @ref Log_event_binary_format "Binary format for log events" for
  a general discussion and introduction to the binary format of binlog
  events.

1526 1527 1528 1529 1530 1531 1532
  The Post-Header has five components:

  <table>
  <caption>Post-Header for Query_log_event</caption>

  <tr>
    <th>Name</th>
1533
    <th>Format</th>
1534 1535 1536 1537 1538 1539
    <th>Description</th>
  </tr>

  <tr>
    <td>slave_proxy_id</td>
    <td>4 byte unsigned integer</td>
1540 1541 1542 1543 1544 1545
    <td>An integer identifying the client thread that issued the
    query.  The id is unique per server.  (Note, however, that two
    threads on different servers may have the same slave_proxy_id.)
    This is used when a client thread creates a temporary table local
    to the client.  The slave_proxy_id is used to distinguish
    temporary tables that belong to different clients.
1546 1547 1548 1549 1550
    </td>
  </tr>

  <tr>
    <td>exec_time</td>
1551 1552 1553
    <td>4 byte unsigned integer</td>
    <td>The time from when the query started to when it was logged in
    the binlog, in seconds.</td>
1554 1555 1556 1557 1558
  </tr>

  <tr>
    <td>db_len</td>
    <td>1 byte integer</td>
1559
    <td>The length of the name of the currently selected database.</td>
1560 1561 1562 1563
  </tr>

  <tr>
    <td>error_code</td>
1564
    <td>2 byte unsigned integer</td>
1565 1566
    <td>Error code generated by the master.  If the master fails, the
    slave will fail with the same error code, except for the error
1567
    codes ER_DB_CREATE_EXISTS == 1007 and ER_DB_DROP_EXISTS == 1008.
1568 1569 1570 1571 1572
    </td>
  </tr>

  <tr>
    <td>status_vars_len</td>
1573
    <td>2 byte unsigned integer</td>
1574
    <td>The length of the status_vars block of the Body, in bytes. See
1575
    @ref query_log_event_status_vars "below".
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
    </td>
  </tr>
  </table>

  The Body has the following components:

  <table>
  <caption>Body for Query_log_event</caption>

  <tr>
    <th>Name</th>
1587
    <th>Format</th>
1588 1589 1590 1591
    <th>Description</th>
  </tr>

  <tr>
1592 1593
    <td>@anchor query_log_event_status_vars status_vars</td>
    <td>status_vars_len bytes</td>
1594 1595 1596
    <td>Zero or more status variables.  Each status variable consists
    of one byte identifying the variable stored, followed by the value
    of the variable.  The possible variables are listed separately in
1597 1598 1599
    the table @ref Table_query_log_event_status_vars "below".  MySQL
    always writes events in the order defined below; however, it is
    capable of reading them in any order.  </td>
1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624
  </tr>

  <tr>
    <td>db</td>
    <td>db_len+1</td>
    <td>The currently selected database, as a null-terminated string.

    (The trailing zero is redundant since the length is already known;
    it is db_len from Post-Header.)
    </td>
  </tr>

  <tr>
    <td>query</td>
    <td>variable length string without trailing zero, extending to the
    end of the event (determined by the length field of the
    Common-Header)
    </td>
    <td>The SQL query.</td>
  </tr>
  </table>

  The following table lists the status variables that may appear in
  the status_vars field.

1625
  @anchor Table_query_log_event_status_vars
1626 1627 1628 1629 1630
  <table>
  <caption>Status variables for Query_log_event</caption>

  <tr>
    <th>Status variable</th>
1631 1632
    <th>1 byte identifier</th>
    <th>Format</th>
1633 1634 1635 1636 1637 1638 1639
    <th>Description</th>
  </tr>

  <tr>
    <td>flags2</td>
    <td>Q_FLAGS2_CODE == 0</td>
    <td>4 byte bitfield</td>
1640 1641 1642 1643 1644 1645 1646
    <td>The flags in @c thd->options, binary AND-ed with @c
    OPTIONS_WRITTEN_TO_BIN_LOG.  The @c thd->options bitfield contains
    options for "SELECT".  @c OPTIONS_WRITTEN identifies those options
    that need to be written to the binlog (not all do).  Specifically,
    @c OPTIONS_WRITTEN_TO_BIN_LOG equals (@c OPTION_AUTO_IS_NULL | @c
    OPTION_NO_FOREIGN_KEY_CHECKS | @c OPTION_RELAXED_UNIQUE_CHECKS |
    @c OPTION_NOT_AUTOCOMMIT), or 0x0c084000 in hex.
1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659

    These flags correspond to the SQL variables SQL_AUTO_IS_NULL,
    FOREIGN_KEY_CHECKS, UNIQUE_CHECKS, and AUTOCOMMIT, documented in
    the "SET Syntax" section of the MySQL Manual.

    This field is always written to the binlog in version >= 5.0, and
    never written in version < 5.0.
    </td>
  </tr>

  <tr>
    <td>sql_mode</td>
    <td>Q_SQL_MODE_CODE == 1</td>
1660 1661
    <td>8 byte bitfield</td>
    <td>The @c sql_mode variable.  See the section "SQL Modes" in the
1662
    MySQL manual, and see sql_priv.h for a list of the possible
1663 1664 1665 1666 1667 1668
    flags. Currently (2007-10-04), the following flags are available:
    <pre>
    MODE_REAL_AS_FLOAT==0x1
    MODE_PIPES_AS_CONCAT==0x2
    MODE_ANSI_QUOTES==0x4
    MODE_IGNORE_SPACE==0x8
1669
    MODE_IGNORE_BAD_TABLE_OPTIONS==0x10
1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698
    MODE_ONLY_FULL_GROUP_BY==0x20
    MODE_NO_UNSIGNED_SUBTRACTION==0x40
    MODE_NO_DIR_IN_CREATE==0x80
    MODE_POSTGRESQL==0x100
    MODE_ORACLE==0x200
    MODE_MSSQL==0x400
    MODE_DB2==0x800
    MODE_MAXDB==0x1000
    MODE_NO_KEY_OPTIONS==0x2000
    MODE_NO_TABLE_OPTIONS==0x4000
    MODE_NO_FIELD_OPTIONS==0x8000
    MODE_MYSQL323==0x10000
    MODE_MYSQL323==0x20000
    MODE_MYSQL40==0x40000
    MODE_ANSI==0x80000
    MODE_NO_AUTO_VALUE_ON_ZERO==0x100000
    MODE_NO_BACKSLASH_ESCAPES==0x200000
    MODE_STRICT_TRANS_TABLES==0x400000
    MODE_STRICT_ALL_TABLES==0x800000
    MODE_NO_ZERO_IN_DATE==0x1000000
    MODE_NO_ZERO_DATE==0x2000000
    MODE_INVALID_DATES==0x4000000
    MODE_ERROR_FOR_DIVISION_BY_ZERO==0x8000000
    MODE_TRADITIONAL==0x10000000
    MODE_NO_AUTO_CREATE_USER==0x20000000
    MODE_HIGH_NOT_PRECEDENCE==0x40000000
    MODE_PAD_CHAR_TO_FULL_LENGTH==0x80000000
    </pre>
    All these flags are replicated from the server.  However, all
1699 1700 1701 1702
    flags except @c MODE_NO_DIR_IN_CREATE are honored by the slave;
    the slave always preserves its old value of @c
    MODE_NO_DIR_IN_CREATE.  For a rationale, see comment in
    @c Query_log_event::do_apply_event in @c log_event.cc.
1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715

    This field is always written to the binlog.
    </td>
  </tr>

  <tr>
    <td>catalog</td>
    <td>Q_CATALOG_NZ_CODE == 6</td>
    <td>Variable-length string: the length in bytes (1 byte) followed
    by the characters (at most 255 bytes)
    </td>
    <td>Stores the client's current catalog.  Every database belongs
    to a catalog, the same way that every table belongs to a
1716
    database.  Currently, there is only one catalog, "std".
1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731

    This field is written if the length of the catalog is > 0;
    otherwise it is not written.
    </td>
  </tr>

  <tr>
    <td>auto_increment</td>
    <td>Q_AUTO_INCREMENT == 3</td>
    <td>two 2 byte unsigned integers, totally 2+2=4 bytes</td>

    <td>The two variables auto_increment_increment and
    auto_increment_offset, in that order.  For more information, see
    "System variables" in the MySQL manual.

1732
    This field is written if auto_increment > 1.  Otherwise, it is not
1733 1734 1735 1736 1737 1738 1739
    written.
    </td>
  </tr>

  <tr>
    <td>charset</td>
    <td>Q_CHARSET_CODE == 4</td>
1740
    <td>three 2 byte unsigned integers, totally 2+2+2=6 bytes</td>
1741 1742
    <td>The three variables character_set_client,
    collation_connection, and collation_server, in that order.
1743
    character_set_client is a code identifying the character set and
1744
    collation used by the client to encode the query.
1745
    collation_connection identifies the character set and collation
1746
    that the master converts the query to when it receives it; this is
1747
    useful when comparing literal strings.  collation_server is the
1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758
    default character set and collation used when a new database is
    created.

    See also "Connection Character Sets and Collations" in the MySQL
    5.1 manual.

    All three variables are codes identifying a (character set,
    collation) pair.  To see which codes map to which pairs, run the
    query "SELECT id, character_set_name, collation_name FROM
    COLLATIONS".

1759
    Cf. Q_CHARSET_DATABASE_CODE below.
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

    This field is always written.
    </td>
  </tr>

  <tr>
    <td>time_zone</td>
    <td>Q_TIME_ZONE_CODE == 5</td>
    <td>Variable-length string: the length in bytes (1 byte) followed
    by the characters (at most 255 bytes).
    <td>The time_zone of the master.

    See also "System Variables" and "MySQL Server Time Zone Support"
    in the MySQL manual.

    This field is written if the length of the time zone string is >
    0; otherwise, it is not written.
    </td>
  </tr>

  <tr>
    <td>lc_time_names_number</td>
    <td>Q_LC_TIME_NAMES_CODE == 7</td>
    <td>2 byte integer</td>
    <td>A code identifying a table of month and day names.  The
1785
    mapping from codes to languages is defined in @c sql_locale.cc.
1786

1787
    This field is written if it is not 0, i.e., if the locale is not
1788 1789 1790 1791 1792 1793
    en_US.
    </td>
  </tr>

  <tr>
    <td>charset_database_number</td>
1794
    <td>Q_CHARSET_DATABASE_CODE == 8</td>
1795 1796 1797
    <td>2 byte integer</td>

    <td>The value of the collation_database system variable (in the
1798
    source code stored in @c thd->variables.collation_database), which
1799 1800 1801
    holds the code for a (character set, collation) pair as described
    above (see Q_CHARSET_CODE).

1802 1803 1804 1805
    collation_database was used in old versions (???WHEN).  Its value
    was loaded when issuing a "use db" query and could be changed by
    issuing a "SET collation_database=xxx" query.  It used to affect
    the "LOAD DATA INFILE" and "CREATE TABLE" commands.
1806 1807 1808

    In newer versions, "CREATE TABLE" has been changed to take the
    character set from the database of the created table, rather than
1809 1810 1811 1812 1813
    the character set of the current database.  This makes a
    difference when creating a table in another database than the
    current one.  "LOAD DATA INFILE" has not yet changed to do this,
    but there are plans to eventually do it, and to make
    collation_database read-only.
1814 1815 1816 1817

    This field is written if it is not 0.
    </td>
  </tr>
1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833
  <tr>
    <td>table_map_for_update</td>
    <td>Q_TABLE_MAP_FOR_UPDATE_CODE == 9</td>
    <td>8 byte integer</td>

    <td>The value of the table map that is to be updated by the
    multi-table update query statement. Every bit of this variable
    represents a table, and is set to 1 if the corresponding table is
    to be updated by this statement.

    The value of this variable is set when executing a multi-table update
    statement and used by slave to apply filter rules without opening
    all the tables on slave. This is required because some tables may
    not exist on slave because of the filter rules.
    </td>
  </tr>
1834 1835 1836 1837
  </table>

  @subsection Query_log_event_notes_on_previous_versions Notes on Previous Versions

1838
  * Status vars were introduced in version 5.0.  To read earlier
1839 1840
  versions correctly, check the length of the Post-Header.

1841
  * The status variable Q_CATALOG_CODE == 2 existed in MySQL 5.0.x,
1842 1843 1844 1845 1846 1847
  where 0<=x<=3.  It was identical to Q_CATALOG_CODE, except that the
  string had a trailing '\0'.  The '\0' was removed in 5.0.4 since it
  was redundant (the string length is stored before the string).  The
  Q_CATALOG_CODE will never be written by a new master, but can still
  be understood by a new slave.

1848
  * See Q_CHARSET_DATABASE_CODE in the table above.
1849

1850 1851 1852
  * When adding new status vars, please don't forget to update the
  MAX_SIZE_LOG_EVENT_STATUS, and update function code_name

1853
*/
unknown's avatar
unknown committed
1854 1855
class Query_log_event: public Log_event
{
1856 1857
  LEX_STRING user;
  LEX_STRING host;
unknown's avatar
unknown committed
1858
protected:
1859
  Log_event::Byte* data_buf;
unknown's avatar
unknown committed
1860 1861
public:
  const char* query;
1862
  const char* catalog;
unknown's avatar
unknown committed
1863
  const char* db;
1864 1865 1866 1867 1868 1869
  /*
    If we already know the length of the query string
    we pass it with q_len, so we would not have to call strlen()
    otherwise, set it to 0, in which case, we compute it with strlen()
  */
  uint32 q_len;
unknown's avatar
unknown committed
1870
  uint32 db_len;
1871
  uint16 error_code;
1872
  ulong thread_id;
unknown's avatar
unknown committed
1873
  /*
1874 1875
    For events created by Query_log_event::do_apply_event (and
    Load_log_event::do_apply_event()) we need the *original* thread
1876 1877
    id, to be able to log the event with the original (=master's)
    thread id (fix for BUG#1686).
unknown's avatar
unknown committed
1878 1879
  */
  ulong slave_proxy_id;
unknown's avatar
unknown committed
1880 1881

  /*
1882 1883
    Binlog format 3 and 4 start to differ (as far as class members are
    concerned) from here.
1884
  */
unknown's avatar
unknown committed
1885

1886
  uint catalog_len;			// <= 255 char; 0 means uninited
unknown's avatar
unknown committed
1887

1888 1889
  /*
    We want to be able to store a variable number of N-bit status vars:
1890 1891 1892
    (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.
1893 1894 1895 1896 1897
    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
1898 1899
    '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:
1900
    flags2 - sql_mode - catalog - autoinc - charset
1901 1902 1903 1904 1905 1906 1907 1908
    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;
unknown's avatar
unknown committed
1909

1910 1911 1912
  /*
    '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
1913
    (OPTIONS_WRITTEN_TO_BIN_LOG).
1914 1915 1916 1917 1918
    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).
  */
unknown's avatar
unknown committed
1919
  bool flags2_inited;
1920
  bool sql_mode_inited;
1921
  bool charset_inited;
unknown's avatar
unknown committed
1922 1923

  uint32 flags2;
1924
  /* In connections sql_mode is 32 bits now but will be 64 bits soon */
1925
  ulonglong sql_mode;
1926
  ulong auto_increment_increment, auto_increment_offset;
1927
  char charset[6];
1928 1929
  uint time_zone_len; /* 0 means uninited */
  const char *time_zone_str;
1930
  uint lc_time_names_number; /* 0 means en_US */
1931
  uint charset_database_number;
1932 1933 1934 1935 1936
  /*
    map for tables that will be updated for a multi-table update query
    statement, for other query statements, this will be zero.
  */
  ulonglong table_map_for_update;
1937 1938 1939 1940 1941 1942
  /*
    Holds the original length of a Query_log_event that comes from a
    master of version < 5.0 (i.e., binlog_version < 4). When the IO
    thread writes the relay log, it augments the Query_log_event with a
    Q_MASTER_DATA_WRITTEN_CODE status_var that holds the original event
    length. This field is initialized to non-zero in the SQL thread when
Andrei Elkin's avatar
Andrei Elkin committed
1943 1944
    it reads this augmented event. SQL thread does not write 
    Q_MASTER_DATA_WRITTEN_CODE to the slave's server binlog.
1945 1946
  */
  uint32 master_data_written;
unknown's avatar
unknown committed
1947

1948
#ifdef MYSQL_SERVER
1949

1950
  Query_log_event(THD* thd_arg, const char* query_arg, ulong query_length,
1951
                  bool using_trans, bool direct, bool suppress_use, int error);
1952
  const char* get_db() { return db; }
unknown's avatar
SCRUM  
unknown committed
1953
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
1954
  void pack_info(THD *thd, Protocol* protocol);
unknown's avatar
SCRUM  
unknown committed
1955
#endif /* HAVE_REPLICATION */
1956
#else
1957
  void print_query_header(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info);
1958
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
unknown's avatar
unknown committed
1959 1960
#endif

1961
  Query_log_event();
1962
  Query_log_event(const char* buf, uint event_len,
unknown's avatar
unknown committed
1963 1964
                  const Format_description_log_event *description_event,
                  Log_event_type event_type);
unknown's avatar
unknown committed
1965 1966 1967
  ~Query_log_event()
  {
    if (data_buf)
1968
      my_free(data_buf);
unknown's avatar
unknown committed
1969 1970
  }
  Log_event_type get_type_code() { return QUERY_EVENT; }
1971
  static int dummy_event(String *packet, ulong ev_offset, uint8 checksum_alg);
1972
  static int begin_event(String *packet, ulong ev_offset, uint8 checksum_alg);
1973
#ifdef MYSQL_SERVER
1974
  bool write(IO_CACHE* file);
1975 1976
  virtual bool write_post_header_for_derived(IO_CACHE* file) { return FALSE; }
#endif
unknown's avatar
unknown committed
1977
  bool is_valid() const { return query != 0; }
unknown's avatar
unknown committed
1978 1979 1980 1981 1982 1983 1984

  /*
    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. */
1985 1986

public:        /* !!! Public in this patch to allow old usage */
1987
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
1988
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
1989
  virtual int do_apply_event(struct rpl_group_info *rgi);
1990
  virtual int do_update_pos(struct rpl_group_info *rgi);
1991

1992
  int do_apply_event(struct rpl_group_info *rgi,
1993 1994
                       const char *query_arg,
                       uint32 q_len_arg);
unknown's avatar
unknown committed
1995
  static bool peek_is_commit_rollback(const char *event_start,
1996
                                      size_t event_len, uint8 checksum_alg);
1997
#endif /* HAVE_REPLICATION */
1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
  /*
    If true, the event always be applied by slave SQL thread or be printed by
    mysqlbinlog
   */
  bool is_trans_keyword()
  {
    /*
      Before the patch for bug#50407, The 'SAVEPOINT and ROLLBACK TO'
      queries input by user was written into log events directly.
      So the keywords can be written in both upper case and lower case
      together, strncasecmp is used to check both cases. they also could be
      binlogged with comments in the front of these keywords. for examples:
        / * bla bla * / SAVEPOINT a;
        / * bla bla * / ROLLBACK TO a;
      but we don't handle these cases and after the patch, both quiries are
      binlogged in upper case with no comments.
     */
    return !strncmp(query, "BEGIN", q_len) ||
      !strncmp(query, "COMMIT", q_len) ||
      !strncasecmp(query, "SAVEPOINT", 9) ||
      !strncasecmp(query, "ROLLBACK", 8);
  }
unknown's avatar
unknown committed
2020 2021
};

2022

unknown's avatar
SCRUM  
unknown committed
2023
#ifdef HAVE_REPLICATION
2024

2025 2026
/**
  @class Slave_log_event
2027

2028
  Note that this class is currently not used at all; no code writes a
2029
  @c Slave_log_event (though some code in @c repl_failsafe.cc reads @c
2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042
  Slave_log_event).  So it's not a problem if this code is not
  maintained.

  @section Slave_log_event_binary_format Binary Format

  This event type has no Post-Header. The Body has the following
  four components.

  <table>
  <caption>Body for Slave_log_event</caption>

  <tr>
    <th>Name</th>
2043
    <th>Format</th>
2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072
    <th>Description</th>
  </tr>

  <tr>
    <td>master_pos</td>
    <td>8 byte integer</td>
    <td>???TODO
    </td>
  </tr>

  <tr>
    <td>master_port</td>
    <td>2 byte integer</td>
    <td>???TODO</td>
  </tr>

  <tr>
    <td>master_host</td>
    <td>null-terminated string</td>
    <td>???TODO</td>
  </tr>

  <tr>
    <td>master_log</td>
    <td>null-terminated string</td>
    <td>???TODO</td>
  </tr>
  </table>
*/
2073 2074 2075 2076 2077 2078
class Slave_log_event: public Log_event
{
protected:
  char* mem_pool;
  void init_from_mem_pool(int data_size);
public:
unknown's avatar
unknown committed
2079
  my_off_t master_pos;
2080 2081
  char* master_host;
  char* master_log;
unknown's avatar
unknown committed
2082
  int master_host_len;
2083
  int master_log_len;
unknown's avatar
unknown committed
2084
  uint16 master_port;
2085

2086
#ifdef MYSQL_SERVER
2087
  Slave_log_event(THD* thd_arg, Relay_log_info* rli);
unknown's avatar
unknown committed
2088
  void pack_info(THD *thd, Protocol* protocol);
2089
#else
2090
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
unknown's avatar
unknown committed
2091
#endif
2092

2093 2094 2095
  Slave_log_event(const char* buf,
                  uint event_len,
                  const Format_description_log_event *description_event);
2096 2097
  ~Slave_log_event();
  int get_data_size();
unknown's avatar
unknown committed
2098
  bool is_valid() const { return master_host != 0; }
2099
  Log_event_type get_type_code() { return SLAVE_EVENT; }
2100
#ifdef MYSQL_SERVER
2101
  bool write(IO_CACHE* file);
2102
#endif
2103 2104

private:
2105
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
2106
  virtual int do_apply_event(struct rpl_group_info *rgi);
2107
#endif
2108 2109
};

unknown's avatar
SCRUM  
unknown committed
2110
#endif /* HAVE_REPLICATION */
2111

2112

2113 2114 2115 2116 2117 2118 2119 2120
/**
  @class Load_log_event

  This log event corresponds to a "LOAD DATA INFILE" SQL query on the
  following form:

  @verbatim
   (1)    USE db;
2121
   (2)    LOAD DATA [CONCURRENT] [LOCAL] INFILE 'file_name'
2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144
   (3)    [REPLACE | IGNORE]
   (4)    INTO TABLE 'table_name'
   (5)    [FIELDS
   (6)      [TERMINATED BY 'field_term']
   (7)      [[OPTIONALLY] ENCLOSED BY 'enclosed']
   (8)      [ESCAPED BY 'escaped']
   (9)    ]
  (10)    [LINES
  (11)      [TERMINATED BY 'line_term']
  (12)      [LINES STARTING BY 'line_start']
  (13)    ]
  (14)    [IGNORE skip_lines LINES]
  (15)    (field_1, field_2, ..., field_n)@endverbatim

  @section Load_log_event_binary_format Binary Format

  The Post-Header consists of the following six components.

  <table>
  <caption>Post-Header for Load_log_event</caption>

  <tr>
    <th>Name</th>
2145
    <th>Format</th>
2146 2147 2148 2149 2150 2151
    <th>Description</th>
  </tr>

  <tr>
    <td>slave_proxy_id</td>
    <td>4 byte unsigned integer</td>
2152 2153 2154 2155 2156 2157
    <td>An integer identifying the client thread that issued the
    query.  The id is unique per server.  (Note, however, that two
    threads on different servers may have the same slave_proxy_id.)
    This is used when a client thread creates a temporary table local
    to the client.  The slave_proxy_id is used to distinguish
    temporary tables that belong to different clients.
2158 2159 2160 2161 2162 2163
    </td>
  </tr>

  <tr>
    <td>exec_time</td>
    <td>4 byte unsigned integer</td>
2164 2165
    <td>The time from when the query started to when it was logged in
    the binlog, in seconds.</td>
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201
  </tr>

  <tr>
    <td>skip_lines</td>
    <td>4 byte unsigned integer</td>
    <td>The number on line (14) above, if present, or 0 if line (14)
    is left out.
    </td>
  </tr>

  <tr>
    <td>table_name_len</td>
    <td>1 byte unsigned integer</td>
    <td>The length of 'table_name' on line (4) above.</td>
  </tr>

  <tr>
    <td>db_len</td>
    <td>1 byte unsigned integer</td>
    <td>The length of 'db' on line (1) above.</td>
  </tr>

  <tr>
    <td>num_fields</td>
    <td>4 byte unsigned integer</td>
    <td>The number n of fields on line (15) above.</td>
  </tr>
  </table>    

  The Body contains the following components.

  <table>
  <caption>Body of Load_log_event</caption>

  <tr>
    <th>Name</th>
2202
    <th>Format</th>
2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241
    <th>Description</th>
  </tr>

  <tr>
    <td>sql_ex</td>
    <td>variable length</td>

    <td>Describes the part of the query on lines (3) and
    (5)&ndash;(13) above.  More precisely, it stores the five strings
    (on lines) field_term (6), enclosed (7), escaped (8), line_term
    (11), and line_start (12); as well as a bitfield indicating the
    presence of the keywords REPLACE (3), IGNORE (3), and OPTIONALLY
    (7).

    The data is stored in one of two formats, called "old" and "new".
    The type field of Common-Header determines which of these two
    formats is used: type LOAD_EVENT means that the old format is
    used, and type NEW_LOAD_EVENT means that the new format is used.
    When MySQL writes a Load_log_event, it uses the new format if at
    least one of the five strings is two or more bytes long.
    Otherwise (i.e., if all strings are 0 or 1 bytes long), the old
    format is used.

    The new and old format differ in the way the five strings are
    stored.

    <ul>
    <li> In the new format, the strings are stored in the order
    field_term, enclosed, escaped, line_term, line_start. Each string
    consists of a length (1 byte), followed by a sequence of
    characters (0-255 bytes).  Finally, a boolean combination of the
    following flags is stored in 1 byte: REPLACE_FLAG==0x4,
    IGNORE_FLAG==0x8, and OPT_ENCLOSED_FLAG==0x2.  If a flag is set,
    it indicates the presence of the corresponding keyword in the SQL
    query.

    <li> In the old format, we know that each string has length 0 or
    1.  Therefore, only the first byte of each string is stored.  The
    order of the strings is the same as in the new format.  These five
2242
    bytes are followed by the same 1 byte bitfield as in the new
2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259
    format.  Finally, a 1 byte bitfield called empty_flags is stored.
    The low 5 bits of empty_flags indicate which of the five strings
    have length 0.  For each of the following flags that is set, the
    corresponding string has length 0; for the flags that are not set,
    the string has length 1: FIELD_TERM_EMPTY==0x1,
    ENCLOSED_EMPTY==0x2, LINE_TERM_EMPTY==0x4, LINE_START_EMPTY==0x8,
    ESCAPED_EMPTY==0x10.
    </ul>

    Thus, the size of the new format is 6 bytes + the sum of the sizes
    of the five strings.  The size of the old format is always 7
    bytes.
    </td>
  </tr>

  <tr>
    <td>field_lens</td>
2260
    <td>num_fields 1 byte unsigned integers</td>
2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307
    <td>An array of num_fields integers representing the length of
    each field in the query.  (num_fields is from the Post-Header).
    </td>
  </tr>

  <tr>
    <td>fields</td>
    <td>num_fields null-terminated strings</td>
    <td>An array of num_fields null-terminated strings, each
    representing a field in the query.  (The trailing zero is
    redundant, since the length are stored in the num_fields array.)
    The total length of all strings equals to the sum of all
    field_lens, plus num_fields bytes for all the trailing zeros.
    </td>
  </tr>

  <tr>
    <td>table_name</td>
    <td>null-terminated string of length table_len+1 bytes</td>
    <td>The 'table_name' from the query, as a null-terminated string.
    (The trailing zero is actually redundant since the table_len is
    known from Post-Header.)
    </td>
  </tr>

  <tr>
    <td>db</td>
    <td>null-terminated string of length db_len+1 bytes</td>
    <td>The 'db' from the query, as a null-terminated string.
    (The trailing zero is actually redundant since the db_len is known
    from Post-Header.)
    </td>
  </tr>

  <tr>
    <td>file_name</td>
    <td>variable length string without trailing zero, extending to the
    end of the event (determined by the length field of the
    Common-Header)
    </td>
    <td>The 'file_name' from the query.
    </td>
  </tr>

  </table>

  @subsection Load_log_event_notes_on_previous_versions Notes on Previous Versions
2308

2309 2310
  This event type is understood by current versions, but only
  generated by MySQL 3.23 and earlier.
2311
*/
unknown's avatar
unknown committed
2312 2313
class Load_log_event: public Log_event
{
unknown's avatar
unknown committed
2314
private:
unknown's avatar
unknown committed
2315
protected:
unknown's avatar
unknown committed
2316
  int copy_log_event(const char *buf, ulong event_len,
2317 2318
                     int body_offset,
                     const Format_description_log_event* description_event);
2319

unknown's avatar
unknown committed
2320
public:
unknown's avatar
unknown committed
2321 2322 2323
  void print_query(THD *thd, bool need_db, const char *cs, String *buf,
                   my_off_t *fn_start, my_off_t *fn_end,
                   const char *qualify_db);
2324
  ulong thread_id;
unknown's avatar
unknown committed
2325
  ulong slave_proxy_id;
unknown's avatar
unknown committed
2326
  uint32 table_name_len;
2327 2328 2329 2330 2331
  /*
    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).
  */
unknown's avatar
unknown committed
2332 2333 2334
  uint32 db_len;
  uint32 fname_len;
  uint32 num_fields;
unknown's avatar
unknown committed
2335 2336
  const char* fields;
  const uchar* field_lens;
unknown's avatar
unknown committed
2337
  uint32 field_block_len;
unknown's avatar
unknown committed
2338 2339 2340 2341

  const char* table_name;
  const char* db;
  const char* fname;
unknown's avatar
unknown committed
2342
  uint32 skip_lines;
unknown's avatar
unknown committed
2343
  sql_ex_info sql_ex;
2344
  bool local_fname;
2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355
  /**
    Indicates that this event corresponds to LOAD DATA CONCURRENT,

    @note Since Load_log_event event coming from the binary log
          lacks information whether LOAD DATA on master was concurrent
          or not, this flag is only set to TRUE for an auxiliary
          Load_log_event object which is used in mysql_load() to
          re-construct LOAD DATA statement from function parameters,
          for logging.
  */
  bool is_concurrent;
2356

2357 2358
  /* fname doesn't point to memory inside Log_event::temp_buf  */
  void set_fname_outside_temp_buf(const char *afname, uint alen)
unknown's avatar
unknown committed
2359 2360 2361
  {
    fname= afname;
    fname_len= alen;
unknown's avatar
unknown committed
2362
    local_fname= TRUE;
unknown's avatar
unknown committed
2363
  }
2364 2365
  /* fname doesn't point to memory inside Log_event::temp_buf  */
  int  check_fname_outside_temp_buf()
unknown's avatar
unknown committed
2366
  {
2367
    return local_fname;
unknown's avatar
unknown committed
2368
  }
2369

2370
#ifdef MYSQL_SERVER
unknown's avatar
unknown committed
2371 2372
  String field_lens_buf;
  String fields_buf;
unknown's avatar
unknown committed
2373

2374
  Load_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
2375
		 const char* table_name_arg,
2376 2377 2378
		 List<Item>& fields_arg,
                 bool is_concurrent_arg,
                 enum enum_duplicates handle_dup, bool ignore,
2379
		 bool using_trans);
2380 2381
  void set_fields(const char* db, List<Item> &fields_arg,
                  Name_resolution_context *context);
2382
  const char* get_db() { return db; }
unknown's avatar
SCRUM  
unknown committed
2383
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2384
  void pack_info(THD *thd, Protocol* protocol);
unknown's avatar
SCRUM  
unknown committed
2385
#endif /* HAVE_REPLICATION */
2386
#else
2387
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
unknown's avatar
unknown committed
2388
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool commented);
unknown's avatar
unknown committed
2389 2390
#endif

2391 2392 2393 2394 2395 2396 2397
  /*
    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,
unknown's avatar
unknown committed
2398
                 const Format_description_log_event* description_event);
unknown's avatar
unknown committed
2399
  ~Load_log_event()
2400
  {}
2401 2402 2403 2404
  Log_event_type get_type_code()
  {
    return sql_ex.new_format() ? NEW_LOAD_EVENT: LOAD_EVENT;
  }
2405
#ifdef MYSQL_SERVER
2406 2407
  bool write_data_header(IO_CACHE* file);
  bool write_data_body(IO_CACHE* file);
2408
#endif
unknown's avatar
unknown committed
2409
  bool is_valid() const { return table_name != 0; }
unknown's avatar
unknown committed
2410 2411
  int get_data_size()
  {
2412 2413
    return (table_name_len + db_len + 2 + fname_len
	    + LOAD_HEADER_LEN
2414
	    + sql_ex.data_size() + field_block_len + num_fields);
unknown's avatar
unknown committed
2415
  }
2416 2417

public:        /* !!! Public in this patch to allow old usage */
2418
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
2419
  virtual int do_apply_event(struct rpl_group_info *rgi)
2420
  {
2421
    return do_apply_event(thd->slave_net,rgi,0);
2422 2423
  }

2424
  int do_apply_event(NET *net, struct rpl_group_info *rgi,
2425
                     bool use_rli_only_for_errors);
2426
#endif
unknown's avatar
unknown committed
2427 2428
};

2429 2430
/**
  @class Start_log_event_v3
2431

2432 2433
  Start_log_event_v3 is the Start_log_event of binlog format 3 (MySQL 3.23 and
  4.x).
2434 2435 2436 2437 2438 2439 2440

  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' Common-Header/Post-Header
  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).
unknown's avatar
unknown committed
2441

2442 2443
  @section Start_log_event_v3_binary_format Binary Format
*/
2444
class Start_log_event_v3: public Log_event
unknown's avatar
unknown committed
2445 2446
{
public:
unknown's avatar
unknown committed
2447
  /*
2448 2449 2450 2451 2452
    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
2453 2454
    >=4.0.14 slaves to know whether they must drop stale temporary
    tables and whether they should abort unfinished transaction.
2455 2456 2457 2458 2459 2460 2461 2462

    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:
2463 2464 2465 2466 2467
     - 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.
2468
  */
2469
  time_t created;
2470
  uint16 binlog_version;
2471
  char server_version[ST_SERVER_VER_LEN];
2472 2473 2474 2475 2476
  /*
    We set this to 1 if we don't want to have the created time in the log,
    which is the case when we rollover to a new log.
  */
  bool dont_set_created;
2477

2478
#ifdef MYSQL_SERVER
2479
  Start_log_event_v3();
unknown's avatar
SCRUM  
unknown committed
2480
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2481
  void pack_info(THD *thd, Protocol* protocol);
unknown's avatar
SCRUM  
unknown committed
2482
#endif /* HAVE_REPLICATION */
2483
#else
2484
  Start_log_event_v3() {}
2485
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
unknown's avatar
unknown committed
2486
#endif
2487

2488 2489 2490 2491
  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;}
2492
#ifdef MYSQL_SERVER
2493
  bool write(IO_CACHE* file);
2494
#endif
unknown's avatar
unknown committed
2495
  bool is_valid() const { return 1; }
2496 2497
  int get_data_size()
  {
2498 2499
    return START_V3_HEADER_LEN; //no variable-sized part
  }
2500

2501
protected:
2502
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
2503
  virtual int do_apply_event(struct rpl_group_info *rgi);
2504
  virtual enum_skip_reason do_shall_skip(Relay_log_info*)
2505 2506 2507 2508 2509
  {
    /*
      Events from ourself should be skipped, but they should not
      decrease the slave skip counter.
     */
2510
    if (this->server_id == global_system_variables.server_id)
2511 2512 2513 2514
      return Log_event::EVENT_SKIP_IGNORE;
    else
      return Log_event::EVENT_SKIP_NOT;
  }
2515
#endif
2516 2517
};

2518

2519 2520 2521 2522 2523 2524 2525 2526
/**
  @class Format_description_log_event

  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).

  @section Format_description_log_event_binary_format Binary Format
2527 2528 2529 2530 2531
*/

class Format_description_log_event: public Start_log_event_v3
{
public:
unknown's avatar
unknown committed
2532
  /*
2533 2534 2535 2536 2537 2538 2539
     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;
2540 2541 2542 2543
  /* 
     The list of post-headers' lengths followed 
     by the checksum alg decription byte
  */
2544
  uint8 *post_header_len;
2545 2546 2547 2548 2549 2550
  struct master_version_split {
    enum {KIND_MYSQL, KIND_MARIADB};
    int kind;
    uchar ver[3];
  };
  master_version_split server_version_split;
2551
  const uint8 *event_type_permutation;
2552 2553 2554

  Format_description_log_event(uint8 binlog_ver, const char* server_ver=0);
  Format_description_log_event(const char* buf, uint event_len,
2555 2556
                               const Format_description_log_event
                               *description_event);
2557 2558
  ~Format_description_log_event()
  {
2559
    my_free(post_header_len);
2560
  }
2561
  Log_event_type get_type_code() { return FORMAT_DESCRIPTION_EVENT;}
2562
#ifdef MYSQL_SERVER
2563
  bool write(IO_CACHE* file);
2564
#endif
Libing Song's avatar
Libing Song committed
2565
  bool header_is_valid() const
2566
  {
2567 2568 2569
    return ((common_header_len >= ((binlog_version==1) ? OLD_HEADER_LEN :
                                   LOG_EVENT_MINIMAL_HEADER_LEN)) &&
            (post_header_len != NULL));
2570
  }
Libing Song's avatar
Libing Song committed
2571 2572 2573 2574

  bool version_is_valid() const
  {
    /* It is invalid only when all version numbers are 0 */
2575 2576 2577
    return !(server_version_split.ver[0] == 0 &&
             server_version_split.ver[1] == 0 &&
             server_version_split.ver[2] == 0);
Libing Song's avatar
Libing Song committed
2578 2579 2580 2581 2582 2583 2584
  }

  bool is_valid() const
  {
    return header_is_valid() && version_is_valid();
  }

2585 2586 2587 2588 2589 2590 2591 2592
  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;
2593
  }
2594

unknown's avatar
unknown committed
2595
  void calc_server_version_split();
Sergei Golubchik's avatar
Sergei Golubchik committed
2596
  static bool is_version_before_checksum(const master_version_split *version_split);
2597
protected:
2598
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
2599
  virtual int do_apply_event(struct rpl_group_info *rgi);
2600
  virtual int do_update_pos(struct rpl_group_info *rgi);
2601
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
2602
#endif
unknown's avatar
unknown committed
2603 2604
};

2605

2606 2607
/**
  @class Intvar_log_event
2608

2609 2610 2611
  An Intvar_log_event will be created just before a Query_log_event,
  if the query uses one of the variables LAST_INSERT_ID or INSERT_ID.
  Each Intvar_log_event holds the value of one of these variables.
2612

2613
  @section Intvar_log_event_binary_format Binary Format
2614

2615 2616
  The Post-Header for this event type is empty.  The Body has two
  components:
2617 2618

  <table>
2619
  <caption>Body for Intvar_log_event</caption>
2620 2621 2622

  <tr>
    <th>Name</th>
2623
    <th>Format</th>
2624 2625 2626 2627
    <th>Description</th>
  </tr>

  <tr>
2628
    <td>type</td>
2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643
    <td>1 byte enumeration</td>
    <td>One byte identifying the type of variable stored.  Currently,
    two identifiers are supported:  LAST_INSERT_ID_EVENT==1 and
    INSERT_ID_EVENT==2.
    </td>
  </tr>

  <tr>
    <td>value</td>
    <td>8 byte unsigned integer</td>
    <td>The value of the variable.</td>
  </tr>

  </table>
*/
unknown's avatar
unknown committed
2644 2645 2646 2647 2648
class Intvar_log_event: public Log_event
{
public:
  ulonglong val;
  uchar type;
2649

2650
#ifdef MYSQL_SERVER
unknown's avatar
unknown committed
2651 2652 2653 2654 2655 2656 2657
Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg,
                 bool using_trans, bool direct)
    :Log_event(thd_arg,0,using_trans),val(val_arg),type(type_arg)
  {
    if (direct)
      cache_type= Log_event::EVENT_NO_CACHE;
  }
unknown's avatar
SCRUM  
unknown committed
2658
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2659
  void pack_info(THD *thd, Protocol* protocol);
unknown's avatar
SCRUM  
unknown committed
2660
#endif /* HAVE_REPLICATION */
2661
#else
2662
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
unknown's avatar
unknown committed
2663
#endif
2664

2665 2666
  Intvar_log_event(const char* buf,
                   const Format_description_log_event *description_event);
unknown's avatar
unknown committed
2667 2668
  ~Intvar_log_event() {}
  Log_event_type get_type_code() { return INTVAR_EVENT;}
unknown's avatar
unknown committed
2669
  const char* get_var_type_name();
2670
  int get_data_size() { return  9; /* sizeof(type) + sizeof(val) */;}
2671
#ifdef MYSQL_SERVER
2672
  bool write(IO_CACHE* file);
2673
#endif
unknown's avatar
unknown committed
2674
  bool is_valid() const { return 1; }
2675 2676

private:
2677
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
2678
  virtual int do_apply_event(struct rpl_group_info *rgi);
2679
  virtual int do_update_pos(struct rpl_group_info *rgi);
2680
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
2681
#endif
unknown's avatar
unknown committed
2682 2683
};

2684

2685 2686
/**
  @class Rand_log_event
2687

unknown's avatar
unknown committed
2688
  Logs random seed used by the next RAND(), and by PASSWORD() in 4.1.0.
2689 2690 2691
  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).
2692

2693 2694 2695
  The state of the random number generation consists of 128 bits,
  which are stored internally as two 64-bit numbers.

2696
  @section Rand_log_event_binary_format Binary Format  
2697 2698 2699

  The Post-Header for this event type is empty.  The Body has two
  components:
2700

2701
  <table>
2702
  <caption>Body for Rand_log_event</caption>
2703

2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721
  <tr>
    <th>Name</th>
    <th>Format</th>
    <th>Description</th>
  </tr>

  <tr>
    <td>seed1</td>
    <td>8 byte unsigned integer</td>
    <td>64 bit random seed1.</td>
  </tr>

  <tr>
    <td>seed2</td>
    <td>8 byte unsigned integer</td>
    <td>64 bit random seed2.</td>
  </tr>
  </table>
2722
*/
2723

unknown's avatar
unknown committed
2724 2725 2726 2727 2728 2729
class Rand_log_event: public Log_event
{
 public:
  ulonglong seed1;
  ulonglong seed2;

2730
#ifdef MYSQL_SERVER
unknown's avatar
unknown committed
2731 2732 2733 2734 2735 2736 2737
  Rand_log_event(THD* thd_arg, ulonglong seed1_arg, ulonglong seed2_arg,
                 bool using_trans, bool direct)
    :Log_event(thd_arg,0,using_trans),seed1(seed1_arg),seed2(seed2_arg)
  {
    if (direct)
      cache_type= Log_event::EVENT_NO_CACHE;
  }
unknown's avatar
SCRUM  
unknown committed
2738
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2739
  void pack_info(THD *thd, Protocol* protocol);
unknown's avatar
SCRUM  
unknown committed
2740
#endif /* HAVE_REPLICATION */
unknown's avatar
unknown committed
2741
#else
2742
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
unknown's avatar
unknown committed
2743 2744
#endif

2745 2746
  Rand_log_event(const char* buf,
                 const Format_description_log_event *description_event);
unknown's avatar
unknown committed
2747 2748
  ~Rand_log_event() {}
  Log_event_type get_type_code() { return RAND_EVENT;}
2749
  int get_data_size() { return 16; /* sizeof(ulonglong) * 2*/ }
2750
#ifdef MYSQL_SERVER
2751
  bool write(IO_CACHE* file);
2752
#endif
unknown's avatar
unknown committed
2753
  bool is_valid() const { return 1; }
2754 2755

private:
2756
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
2757
  virtual int do_apply_event(struct rpl_group_info *rgi);
2758
  virtual int do_update_pos(struct rpl_group_info *rgi);
2759
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
2760
#endif
unknown's avatar
unknown committed
2761 2762
};

2763 2764
/**
  @class Xid_log_event
2765 2766 2767 2768

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

2769 2770
  @section Xid_log_event_binary_format Binary Format  
*/
2771
#ifdef MYSQL_CLIENT
2772
typedef ulonglong my_xid; // this line is the same as in handler.h
2773 2774 2775 2776 2777 2778 2779
#endif

class Xid_log_event: public Log_event
{
 public:
   my_xid xid;

2780
#ifdef MYSQL_SERVER
Sergei Golubchik's avatar
Sergei Golubchik committed
2781 2782 2783 2784 2785 2786
  Xid_log_event(THD* thd_arg, my_xid x, bool direct):
   Log_event(thd_arg, 0, TRUE), xid(x)
   {
     if (direct)
       cache_type= Log_event::EVENT_NO_CACHE;
   }
2787
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2788
  void pack_info(THD *thd, Protocol* protocol);
2789 2790
#endif /* HAVE_REPLICATION */
#else
2791
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
2792 2793
#endif

2794 2795
  Xid_log_event(const char* buf,
                const Format_description_log_event *description_event);
2796 2797 2798
  ~Xid_log_event() {}
  Log_event_type get_type_code() { return XID_EVENT;}
  int get_data_size() { return sizeof(xid); }
2799
#ifdef MYSQL_SERVER
2800
  bool write(IO_CACHE* file);
2801
#endif
2802
  bool is_valid() const { return 1; }
2803 2804

private:
2805
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
2806
  virtual int do_apply_event(struct rpl_group_info *rgi);
2807
  enum_skip_reason do_shall_skip(Relay_log_info *rli);
2808
#endif
2809
};
2810

2811 2812
/**
  @class User_var_log_event
unknown's avatar
unknown committed
2813

2814 2815 2816
  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.

2817 2818
  @section User_var_log_event_binary_format Binary Format  
*/
2819

unknown's avatar
unknown committed
2820 2821 2822
class User_var_log_event: public Log_event
{
public:
2823 2824 2825 2826
  enum {
    UNDEF_F= 0,
    UNSIGNED_F= 1
  };
unknown's avatar
unknown committed
2827 2828 2829 2830 2831 2832
  char *name;
  uint name_len;
  char *val;
  ulong val_len;
  Item_result type;
  uint charset_number;
2833
  bool is_null;
2834
  uchar flags;
2835
#ifdef MYSQL_SERVER
Andrei Elkin's avatar
Andrei Elkin committed
2836
  bool deferred;
unknown's avatar
unknown committed
2837 2838
  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,
unknown's avatar
unknown committed
2839 2840 2841 2842
		     uint charset_number_arg, uchar flags_arg,
                     bool using_trans, bool direct)
    :Log_event(thd_arg, 0, using_trans),
    name(name_arg), name_len(name_len_arg), val(val_arg),
2843
    val_len(val_len_arg), type(type_arg), charset_number(charset_number_arg),
2844
    flags(flags_arg), deferred(false)
unknown's avatar
unknown committed
2845 2846 2847 2848 2849
    {
      is_null= !val;
      if (direct)
        cache_type= Log_event::EVENT_NO_CACHE;
    }
unknown's avatar
unknown committed
2850
  void pack_info(THD *thd, Protocol* protocol);
unknown's avatar
unknown committed
2851
#else
2852
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
unknown's avatar
unknown committed
2853 2854
#endif

2855
  User_var_log_event(const char* buf, uint event_len,
2856
                     const Format_description_log_event *description_event);
unknown's avatar
unknown committed
2857 2858
  ~User_var_log_event() {}
  Log_event_type get_type_code() { return USER_VAR_EVENT;}
2859
#ifdef MYSQL_SERVER
2860
  bool write(IO_CACHE* file);
Andrei Elkin's avatar
Andrei Elkin committed
2861 2862 2863 2864 2865 2866
  /* 
     Getter and setter for deferred User-event. 
     Returns true if the event is not applied directly 
     and which case the applier adjusts execution path.
  */
  bool is_deferred() { return deferred; }
2867
  void set_deferred() { deferred= true; }
2868
#endif
2869
  bool is_valid() const { return name != 0; }
2870 2871

private:
2872
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
2873
  virtual int do_apply_event(struct rpl_group_info *rgi);
2874
  virtual int do_update_pos(struct rpl_group_info *rgi);
2875
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
2876
#endif
unknown's avatar
unknown committed
2877
};
2878

2879

2880 2881
/**
  @class Stop_log_event
2882

2883
  @section Stop_log_event_binary_format Binary Format
2884

2885 2886 2887
  The Post-Header and Body for this event type are empty; it only has
  the Common-Header.
*/
unknown's avatar
unknown committed
2888 2889 2890
class Stop_log_event: public Log_event
{
public:
2891
#ifdef MYSQL_SERVER
2892
  Stop_log_event() :Log_event()
unknown's avatar
unknown committed
2893
  {}
2894
#else
2895
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
unknown's avatar
unknown committed
2896
#endif
2897

2898 2899
  Stop_log_event(const char* buf,
                 const Format_description_log_event *description_event):
2900
    Log_event(buf, description_event)
2901
  {}
unknown's avatar
unknown committed
2902 2903
  ~Stop_log_event() {}
  Log_event_type get_type_code() { return STOP_EVENT;}
unknown's avatar
unknown committed
2904
  bool is_valid() const { return 1; }
2905 2906

private:
2907
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
2908
  virtual int do_update_pos(struct rpl_group_info *rgi);
2909
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli)
2910 2911 2912 2913 2914
  {
    /*
      Events from ourself should be skipped, but they should not
      decrease the slave skip counter.
     */
2915
    if (this->server_id == global_system_variables.server_id)
2916 2917 2918 2919
      return Log_event::EVENT_SKIP_IGNORE;
    else
      return Log_event::EVENT_SKIP_NOT;
  }
2920
#endif
unknown's avatar
unknown committed
2921 2922
};

2923 2924
/**
  @class Rotate_log_event
2925

2926
  This will be deprecated when we move to using sequence ids.
2927

2928 2929 2930 2931 2932 2933 2934 2935 2936
  @section Rotate_log_event_binary_format Binary Format

  The Post-Header has one component:

  <table>
  <caption>Post-Header for Rotate_log_event</caption>

  <tr>
    <th>Name</th>
2937
    <th>Format</th>
2938 2939 2940 2941
    <th>Description</th>
  </tr>

  <tr>
2942
    <td>position</td>
2943
    <td>8 byte integer</td>
2944
    <td>The position within the binlog to rotate to.</td>
2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955
  </tr>

  </table>

  The Body has one component:

  <table>
  <caption>Body for Rotate_log_event</caption>

  <tr>
    <th>Name</th>
2956
    <th>Format</th>
2957 2958 2959 2960
    <th>Description</th>
  </tr>

  <tr>
2961
    <td>new_log</td>
2962 2963 2964 2965
    <td>variable length string without trailing zero, extending to the
    end of the event (determined by the length field of the
    Common-Header)
    </td>
2966
    <td>Name of the binlog to rotate to.</td>
2967 2968 2969 2970
  </tr>

  </table>
*/
2971

unknown's avatar
unknown committed
2972 2973 2974
class Rotate_log_event: public Log_event
{
public:
2975
  enum {
2976 2977
    DUP_NAME= 2, // if constructor should dup the string argument
    RELAY_LOG=4  // rotate event for relay log
2978
  };
unknown's avatar
unknown committed
2979
  const char* new_log_ident;
2980
  ulonglong pos;
unknown's avatar
unknown committed
2981
  uint ident_len;
2982
  uint flags;
2983
#ifdef MYSQL_SERVER
2984
  Rotate_log_event(const char* new_log_ident_arg,
2985 2986
		   uint ident_len_arg,
		   ulonglong pos_arg, uint flags);
unknown's avatar
SCRUM  
unknown committed
2987
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2988
  void pack_info(THD *thd, Protocol* protocol);
unknown's avatar
SCRUM  
unknown committed
2989
#endif /* HAVE_REPLICATION */
2990
#else
2991
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
2992 2993
#endif

2994 2995
  Rotate_log_event(const char* buf, uint event_len,
                   const Format_description_log_event* description_event);
unknown's avatar
unknown committed
2996 2997
  ~Rotate_log_event()
  {
2998
    if (flags & DUP_NAME)
2999
      my_free((void*) new_log_ident);
unknown's avatar
unknown committed
3000 3001
  }
  Log_event_type get_type_code() { return ROTATE_EVENT;}
3002
  int get_data_size() { return  ident_len + ROTATE_HEADER_LEN;}
unknown's avatar
unknown committed
3003
  bool is_valid() const { return new_log_ident != 0; }
3004
#ifdef MYSQL_SERVER
3005
  bool write(IO_CACHE* file);
3006
#endif
3007 3008

private:
3009
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
3010
  virtual int do_update_pos(struct rpl_group_info *rgi);
3011
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
3012
#endif
3013 3014
};

3015

3016 3017 3018 3019 3020 3021 3022 3023 3024 3025
class Binlog_checkpoint_log_event: public Log_event
{
public:
  char *binlog_file_name;
  uint binlog_file_len;

#ifdef MYSQL_SERVER
  Binlog_checkpoint_log_event(const char *binlog_file_name_arg,
                              uint binlog_file_len_arg);
#ifdef HAVE_REPLICATION
3026
  void pack_info(THD *thd, Protocol *protocol);
3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041
#endif
#else
  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
#endif
  Binlog_checkpoint_log_event(const char *buf, uint event_len,
             const Format_description_log_event *description_event);
  ~Binlog_checkpoint_log_event() { my_free(binlog_file_name); }
  Log_event_type get_type_code() { return BINLOG_CHECKPOINT_EVENT;}
  int get_data_size() { return  binlog_file_len + BINLOG_CHECKPOINT_HEADER_LEN;}
  bool is_valid() const { return binlog_file_name != 0; }
#ifdef MYSQL_SERVER
  bool write(IO_CACHE* file);
#endif
};

3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102

/**
  @class Gtid_log_event

  This event is logged as part of every event group to give the global
  transaction id (GTID) of that group.

  It replaces the BEGIN query event used in earlier versions to begin most
  event groups, but is also used for events that used to be stand-alone.

  @section Gtid_log_event_binary_format Binary Format

  The binary format for Gtid_log_event has 6 extra reserved bytes to make the
  length a total of 19 byte (+ 19 bytes of header in common with all events).
  This is just the minimal size for a BEGIN query event, which makes it easy
  to replace this event with such BEGIN event to remain compatible with old
  slave servers.

  <table>
  <caption>Post-Header</caption>

  <tr>
    <th>Name</th>
    <th>Format</th>
    <th>Description</th>
  </tr>

  <tr>
    <td>seq_no</td>
    <td>8 byte unsigned integer</td>
    <td>increasing id within one server_id. Starts at 1, holes in the sequence
        may occur</td>
  </tr>

  <tr>
    <td>domain_id</td>
    <td>4 byte unsigned integer</td>
    <td>Replication domain id, identifying independent replication streams></td>
  </tr>

  <tr>
    <td>flags</td>
    <td>1 byte bitfield</td>
    <td>Bit 0 set indicates stand-alone event (no terminating COMMIT)</td>
  </tr>

  <tr>
    <td>Reserved</td>
    <td>6 bytes</td>
    <td>Reserved bytes, set to 0. Maybe be used for future expansion.</td>
  </tr>
  </table>

  The Body of Gtid_log_event is empty. The total event size is 19 bytes +
  the normal 19 bytes common-header.
*/

class Gtid_log_event: public Log_event
{
public:
  uint64 seq_no;
3103
  uint64 commit_id;
3104 3105 3106 3107 3108 3109 3110
  uint32 domain_id;
  uchar flags2;

  /* Flags2. */

  /* FL_STANDALONE is set when there is no terminating COMMIT event. */
  static const uchar FL_STANDALONE= 1;
3111 3112 3113 3114 3115
  /*
    FL_GROUP_COMMIT_ID is set when event group is part of a group commit on the
    master. Groups with same commit_id are part of the same group commit.
  */
  static const uchar FL_GROUP_COMMIT_ID= 2;
3116 3117 3118

#ifdef MYSQL_SERVER
  Gtid_log_event(THD *thd_arg, uint64 seq_no, uint32 domain_id, bool standalone,
3119
                 uint16 flags, bool is_transactional, uint64 commit_id);
3120 3121
#ifdef HAVE_REPLICATION
  void pack_info(THD *thd, Protocol *protocol);
3122
  virtual int do_apply_event(struct rpl_group_info *rgi);
3123
  virtual int do_update_pos(struct rpl_group_info *rgi);
3124 3125 3126 3127 3128 3129 3130 3131 3132
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
#endif
#else
  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
#endif
  Gtid_log_event(const char *buf, uint event_len,
                 const Format_description_log_event *description_event);
  ~Gtid_log_event() { }
  Log_event_type get_type_code() { return GTID_EVENT; }
3133 3134 3135 3136
  int get_data_size()
  {
    return GTID_HEADER_LEN + ((flags2 & FL_GROUP_COMMIT_ID) ? 2 : 0);
  }
3137 3138 3139 3140 3141
  bool is_valid() const { return seq_no != 0; }
#ifdef MYSQL_SERVER
  bool write(IO_CACHE *file);
  static int make_compatible_event(String *packet, bool *need_dummy_event,
                                    ulong ev_offset, uint8 checksum_alg);
3142
  static bool peek(const char *event_start, size_t event_len,
3143
                   uint8 checksum_alg,
3144 3145
                   uint32 *domain_id, uint32 *server_id, uint64 *seq_no,
                   uchar *flags2);
3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174
#endif
};


/**
  @class Gtid_list_log_event

  This event is logged at the start of every binlog file to record the
  current replication state: the last global transaction id (GTID) applied
  on the server within each replication domain.

  It consists of a list of GTIDs, one for each replication domain ever seen
  on the server.

  @section Gtid_list_log_event_binary_format Binary Format

  <table>
  <caption>Post-Header</caption>

  <tr>
    <th>Name</th>
    <th>Format</th>
    <th>Description</th>
  </tr>

  <tr>
    <td>count</td>
    <td>4 byte unsigned integer</td>
    <td>The lower 28 bits are the number of GTIDs. The upper 4 bits are
unknown's avatar
unknown committed
3175
        flags bits.</td>
3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207
  </tr>
  </table>

  <table>
  <caption>Body</caption>

  <tr>
    <th>Name</th>
    <th>Format</th>
    <th>Description</th>
  </tr>

  <tr>
    <td>domain_id</td>
    <td>4 byte unsigned integer</td>
    <td>Replication domain id of one GTID</td>
  </tr>

  <tr>
    <td>server_id</td>
    <td>4 byte unsigned integer</td>
    <td>Server id of one GTID</td>
  </tr>

  <tr>
    <td>seq_no</td>
    <td>8 byte unsigned integer</td>
    <td>sequence number of one GTID</td>
  </tr>
  </table>

  The three elements in the body repeat COUNT times to form the GTID list.
unknown's avatar
unknown committed
3208 3209 3210 3211 3212 3213 3214 3215

  At the time of writing, only one flag bit is in use.

  Bit 28 of `count' is used for flag FLAG_UNTIL_REACHED, which is sent in a
  Gtid_list event from the master to the slave to indicate that the START
  SLAVE UNTIL master_gtid_pos=xxx condition has been reached. (This flag is
  only sent in "fake" events generated on the fly, it is not written into
  the binlog).
3216 3217 3218 3219 3220 3221
*/

class Gtid_list_log_event: public Log_event
{
public:
  uint32 count;
unknown's avatar
unknown committed
3222
  uint32 gl_flags;
3223 3224 3225
  struct rpl_gtid *list;

  static const uint element_size= 4+4+8;
unknown's avatar
unknown committed
3226
  static const uint32 FLAG_UNTIL_REACHED= (1<<28);
3227 3228

#ifdef MYSQL_SERVER
unknown's avatar
unknown committed
3229
  Gtid_list_log_event(rpl_binlog_state *gtid_set, uint32 gl_flags);
3230 3231 3232 3233 3234 3235 3236 3237 3238 3239
#ifdef HAVE_REPLICATION
  void pack_info(THD *thd, Protocol *protocol);
#endif
#else
  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
#endif
  Gtid_list_log_event(const char *buf, uint event_len,
                      const Format_description_log_event *description_event);
  ~Gtid_list_log_event() { my_free(list); }
  Log_event_type get_type_code() { return GTID_LIST_EVENT; }
3240 3241 3242 3243 3244 3245 3246 3247
  int get_data_size() {
    /*
      Replacing with dummy event, needed for older slaves, requires a minimum
      of 6 bytes in the body.
    */
    return (count==0 ?
            GTID_LIST_HEADER_LEN+2 : GTID_LIST_HEADER_LEN+count*element_size);
  }
3248
  bool is_valid() const { return list != NULL; }
unknown's avatar
unknown committed
3249 3250
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
  bool to_packet(String *packet);
3251
  bool write(IO_CACHE *file);
3252
  virtual int do_apply_event(struct rpl_group_info *rgi);
3253
#endif
unknown's avatar
unknown committed
3254
  static bool peek(const char *event_start, uint32 event_len,
unknown's avatar
unknown committed
3255
                   uint8 checksum_alg,
unknown's avatar
unknown committed
3256
                   rpl_gtid **out_gtid_list, uint32 *out_list_len);
3257 3258 3259
};


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

3262 3263 3264 3265 3266
/**
  @class Create_file_log_event

  @section Create_file_log_event_binary_format Binary Format
*/
3267

3268
class Create_file_log_event: public Load_log_event
3269
{
3270
protected:
3271 3272 3273 3274 3275
  /*
    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
  */
unknown's avatar
unknown committed
3276
  bool fake_base;
3277
public:
unknown's avatar
unknown committed
3278
  uchar* block;
3279
  const char *event_buf;
3280 3281
  uint block_len;
  uint file_id;
unknown's avatar
unknown committed
3282
  bool inited_from_old;
3283

3284
#ifdef MYSQL_SERVER
3285
  Create_file_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
3286 3287
			const char* table_name_arg,
			List<Item>& fields_arg,
3288
                        bool is_concurrent_arg,
3289
			enum enum_duplicates handle_dup, bool ignore,
unknown's avatar
unknown committed
3290
			uchar* block_arg, uint block_len_arg,
3291
			bool using_trans);
unknown's avatar
SCRUM  
unknown committed
3292
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3293
  void pack_info(THD *thd, Protocol* protocol);
unknown's avatar
SCRUM  
unknown committed
3294
#endif /* HAVE_REPLICATION */
3295
#else
3296
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
3297 3298
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
             bool enable_local);
unknown's avatar
unknown committed
3299 3300
#endif

3301 3302
  Create_file_log_event(const char* buf, uint event_len,
                        const Format_description_log_event* description_event);
3303 3304
  ~Create_file_log_event()
  {
3305
    my_free((void*) event_buf);
3306
  }
3307 3308

  Log_event_type get_type_code()
3309
  {
3310 3311 3312 3313 3314 3315 3316 3317
    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);
  }
unknown's avatar
unknown committed
3318
  bool is_valid() const { return inited_from_old || block != 0; }
3319
#ifdef MYSQL_SERVER
3320 3321
  bool write_data_header(IO_CACHE* file);
  bool write_data_body(IO_CACHE* file);
3322 3323 3324 3325
  /*
    Cut out Create_file extentions and
    write it as Load event - used on the slave
  */
3326
  bool write_base(IO_CACHE* file);
3327
#endif
3328 3329

private:
3330
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
3331
  virtual int do_apply_event(struct rpl_group_info *rgi);
3332
#endif
3333 3334
};

3335

3336 3337
/**
  @class Append_block_log_event
3338

3339 3340
  @section Append_block_log_event_binary_format Binary Format
*/
3341

3342 3343 3344
class Append_block_log_event: public Log_event
{
public:
unknown's avatar
unknown committed
3345
  uchar* block;
3346 3347
  uint block_len;
  uint file_id;
unknown's avatar
unknown committed
3348
  /*
3349 3350 3351 3352 3353 3354 3355 3356 3357
    '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.
unknown's avatar
unknown committed
3358 3359 3360
  */
  const char* db;

3361
#ifdef MYSQL_SERVER
unknown's avatar
unknown committed
3362
  Append_block_log_event(THD* thd, const char* db_arg, uchar* block_arg,
3363
			 uint block_len_arg, bool using_trans);
unknown's avatar
SCRUM  
unknown committed
3364
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3365
  void pack_info(THD *thd, Protocol* protocol);
3366
  virtual int get_create_or_append() const;
unknown's avatar
SCRUM  
unknown committed
3367
#endif /* HAVE_REPLICATION */
3368
#else
3369
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
3370
#endif
unknown's avatar
unknown committed
3371 3372

  Append_block_log_event(const char* buf, uint event_len,
3373 3374
                         const Format_description_log_event
                         *description_event);
3375
  ~Append_block_log_event() {}
3376 3377
  Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;}
  int get_data_size() { return  block_len + APPEND_BLOCK_HEADER_LEN ;}
unknown's avatar
unknown committed
3378
  bool is_valid() const { return block != 0; }
3379
#ifdef MYSQL_SERVER
3380
  bool write(IO_CACHE* file);
unknown's avatar
unknown committed
3381
  const char* get_db() { return db; }
3382
#endif
3383 3384

private:
3385
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
3386
  virtual int do_apply_event(struct rpl_group_info *rgi);
3387
#endif
3388 3389
};

3390

3391 3392
/**
  @class Delete_file_log_event
3393

3394 3395
  @section Delete_file_log_event_binary_format Binary Format
*/
3396

3397 3398 3399 3400
class Delete_file_log_event: public Log_event
{
public:
  uint file_id;
unknown's avatar
unknown committed
3401
  const char* db; /* see comment in Append_block_log_event */
unknown's avatar
unknown committed
3402

3403
#ifdef MYSQL_SERVER
unknown's avatar
unknown committed
3404
  Delete_file_log_event(THD* thd, const char* db_arg, bool using_trans);
unknown's avatar
SCRUM  
unknown committed
3405
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3406
  void pack_info(THD *thd, Protocol* protocol);
unknown's avatar
SCRUM  
unknown committed
3407
#endif /* HAVE_REPLICATION */
3408
#else
3409
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
3410 3411
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
             bool enable_local);
unknown's avatar
unknown committed
3412 3413
#endif

3414 3415
  Delete_file_log_event(const char* buf, uint event_len,
                        const Format_description_log_event* description_event);
3416
  ~Delete_file_log_event() {}
3417 3418
  Log_event_type get_type_code() { return DELETE_FILE_EVENT;}
  int get_data_size() { return DELETE_FILE_HEADER_LEN ;}
unknown's avatar
unknown committed
3419
  bool is_valid() const { return file_id != 0; }
3420
#ifdef MYSQL_SERVER
3421
  bool write(IO_CACHE* file);
unknown's avatar
unknown committed
3422
  const char* get_db() { return db; }
3423
#endif
3424 3425

private:
3426
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
3427
  virtual int do_apply_event(struct rpl_group_info *rgi);
3428
#endif
3429 3430
};

3431

3432 3433
/**
  @class Execute_load_log_event
3434

3435 3436
  @section Delete_file_log_event_binary_format Binary Format
*/
3437

3438 3439 3440 3441
class Execute_load_log_event: public Log_event
{
public:
  uint file_id;
unknown's avatar
unknown committed
3442
  const char* db; /* see comment in Append_block_log_event */
unknown's avatar
unknown committed
3443

3444
#ifdef MYSQL_SERVER
unknown's avatar
unknown committed
3445
  Execute_load_log_event(THD* thd, const char* db_arg, bool using_trans);
unknown's avatar
SCRUM  
unknown committed
3446
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3447
  void pack_info(THD *thd, Protocol* protocol);
unknown's avatar
SCRUM  
unknown committed
3448
#endif /* HAVE_REPLICATION */
3449
#else
3450
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
unknown's avatar
unknown committed
3451 3452 3453
#endif

  Execute_load_log_event(const char* buf, uint event_len,
3454 3455
                         const Format_description_log_event
                         *description_event);
3456
  ~Execute_load_log_event() {}
3457 3458
  Log_event_type get_type_code() { return EXEC_LOAD_EVENT;}
  int get_data_size() { return  EXEC_LOAD_HEADER_LEN ;}
unknown's avatar
unknown committed
3459
  bool is_valid() const { return file_id != 0; }
3460
#ifdef MYSQL_SERVER
3461
  bool write(IO_CACHE* file);
unknown's avatar
unknown committed
3462
  const char* get_db() { return db; }
3463
#endif
3464 3465

private:
3466
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
3467
  virtual int do_apply_event(struct rpl_group_info *rgi);
3468
#endif
unknown's avatar
unknown committed
3469 3470
};

3471

3472 3473
/**
  @class Begin_load_query_log_event
unknown's avatar
unknown committed
3474 3475 3476 3477 3478

  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.

3479 3480
  @section Begin_load_query_log_event_binary_format Binary Format
*/
unknown's avatar
unknown committed
3481 3482 3483
class Begin_load_query_log_event: public Append_block_log_event
{
public:
3484
#ifdef MYSQL_SERVER
unknown's avatar
unknown committed
3485
  Begin_load_query_log_event(THD* thd_arg, const char *db_arg,
unknown's avatar
unknown committed
3486
                             uchar* block_arg, uint block_len_arg,
unknown's avatar
unknown committed
3487 3488 3489
                             bool using_trans);
#ifdef HAVE_REPLICATION
  Begin_load_query_log_event(THD* thd);
3490
  int get_create_or_append() const;
unknown's avatar
unknown committed
3491 3492 3493
#endif /* HAVE_REPLICATION */
#endif
  Begin_load_query_log_event(const char* buf, uint event_len,
3494 3495
                             const Format_description_log_event
                             *description_event);
unknown's avatar
unknown committed
3496 3497
  ~Begin_load_query_log_event() {}
  Log_event_type get_type_code() { return BEGIN_LOAD_QUERY_EVENT; }
3498
private:
3499
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
3500 3501
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
#endif
unknown's avatar
unknown committed
3502 3503 3504 3505 3506 3507 3508 3509 3510
};


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

3511 3512
/**
  @class Execute_load_query_log_event
unknown's avatar
unknown committed
3513 3514 3515 3516 3517

  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.

3518 3519
  @section Execute_load_query_log_event_binary_format Binary Format
*/
unknown's avatar
unknown committed
3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534
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;

3535
#ifdef MYSQL_SERVER
unknown's avatar
unknown committed
3536
  Execute_load_query_log_event(THD* thd, const char* query_arg,
3537 3538 3539
                               ulong query_length, uint fn_pos_start_arg,
                               uint fn_pos_end_arg,
                               enum_load_dup_handling dup_handling_arg,
3540 3541
                               bool using_trans, bool direct,
                               bool suppress_use, int errcode);
unknown's avatar
unknown committed
3542
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3543
  void pack_info(THD *thd, Protocol* protocol);
unknown's avatar
unknown committed
3544 3545
#endif /* HAVE_REPLICATION */
#else
3546
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
unknown's avatar
unknown committed
3547
  /* Prints the query as LOAD DATA LOCAL and with rewritten filename */
unknown's avatar
unknown committed
3548
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
unknown's avatar
unknown committed
3549
	     const char *local_fname);
unknown's avatar
unknown committed
3550 3551
#endif
  Execute_load_query_log_event(const char* buf, uint event_len,
3552 3553
                               const Format_description_log_event
                               *description_event);
unknown's avatar
unknown committed
3554 3555 3556 3557 3558 3559
  ~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();
3560
#ifdef MYSQL_SERVER
unknown's avatar
unknown committed
3561
  bool write_post_header_for_derived(IO_CACHE* file);
3562
#endif
3563 3564

private:
3565
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
3566
  virtual int do_apply_event(struct rpl_group_info *rgi);
3567 3568
#endif
};
unknown's avatar
unknown committed
3569 3570


3571
#ifdef MYSQL_CLIENT
3572 3573 3574 3575 3576
/**
  @class Unknown_log_event

  @section Unknown_log_event_binary_format Binary Format
*/
3577 3578 3579
class Unknown_log_event: public Log_event
{
public:
3580 3581 3582 3583 3584
  /*
    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).
  */
3585 3586
  Unknown_log_event(const char* buf,
                    const Format_description_log_event *description_event):
3587
    Log_event(buf, description_event)
3588 3589
  {}
  ~Unknown_log_event() {}
3590
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
3591
  Log_event_type get_type_code() { return UNKNOWN_EVENT;}
unknown's avatar
unknown committed
3592
  bool is_valid() const { return 1; }
3593
};
unknown's avatar
unknown committed
3594
#endif
3595
char *str_to_hex(char *to, const char *from, uint len);
3596

3597 3598 3599
/**
  @class Annotate_rows_log_event

3600
  In row-based mode, if binlog_annotate_row_events = ON, each group of
3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612
  Table_map_log_events is preceded by an Annotate_rows_log_event which
  contains the query which caused the subsequent rows operations.

  The Annotate_rows_log_event has no post-header and its body contains
  the corresponding query (without trailing zero). Note. The query length
  is to be calculated as a difference between the whole event length and
  the common header length.
*/
class Annotate_rows_log_event: public Log_event
{
public:
#ifndef MYSQL_CLIENT
unknown's avatar
unknown committed
3613
  Annotate_rows_log_event(THD*, bool using_trans, bool direct);
3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628
#endif
  Annotate_rows_log_event(const char *buf, uint event_len,
                          const Format_description_log_event*);
  ~Annotate_rows_log_event();

  virtual int get_data_size();
  virtual Log_event_type get_type_code();
  virtual bool is_valid() const;

#ifndef MYSQL_CLIENT
  virtual bool write_data_header(IO_CACHE*);
  virtual bool write_data_body(IO_CACHE*);
#endif

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
unknown's avatar
unknown committed
3629
  virtual void pack_info(THD *thd, Protocol*);
3630 3631 3632 3633 3634 3635 3636 3637
#endif

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

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
private:
3638
  virtual int do_apply_event(struct rpl_group_info *rgi);
3639
  virtual int do_update_pos(struct rpl_group_info *rgi);
3640 3641 3642 3643 3644 3645 3646 3647 3648 3649
  virtual enum_skip_reason do_shall_skip(Relay_log_info*);
#endif

private:
  char *m_query_txt;
  uint  m_query_len;
  char *m_save_thd_query_txt;
  uint  m_save_thd_query_len;
};

3650 3651
/**
  @class Table_map_log_event
3652

3653 3654 3655 3656
  In row-based mode, every row operation event is preceded by a
  Table_map_log_event which maps a table definition to a number.  The
  table definition consists of database name, table name, and column
  definitions.
3657

3658
  @section Table_map_log_event_binary_format Binary Format
3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962

  The Post-Header has the following components:

  <table>
  <caption>Post-Header for Table_map_log_event</caption>

  <tr>
    <th>Name</th>
    <th>Format</th>
    <th>Description</th>
  </tr>

  <tr>
    <td>table_id</td>
    <td>6 bytes unsigned integer</td>
    <td>The number that identifies the table.</td>
  </tr>

  <tr>
    <td>flags</td>
    <td>2 byte bitfield</td>
    <td>Reserved for future use; currently always 0.</td>
  </tr>

  </table>

  The Body has the following components:

  <table>
  <caption>Body for Table_map_log_event</caption>

  <tr>
    <th>Name</th>
    <th>Format</th>
    <th>Description</th>
  </tr>

  <tr>
    <td>database_name</td>
    <td>one byte string length, followed by null-terminated string</td>
    <td>The name of the database in which the table resides.  The name
    is represented as a one byte unsigned integer representing the
    number of bytes in the name, followed by length bytes containing
    the database name, followed by a terminating 0 byte.  (Note the
    redundancy in the representation of the length.)  </td>
  </tr>

  <tr>
    <td>table_name</td>
    <td>one byte string length, followed by null-terminated string</td>
    <td>The name of the table, encoded the same way as the database
    name above.</td>
  </tr>

  <tr>
    <td>column_count</td>
    <td>@ref packed_integer "Packed Integer"</td>
    <td>The number of columns in the table, represented as a packed
    variable-length integer.</td>
  </tr>

  <tr>
    <td>column_type</td>
    <td>List of column_count 1 byte enumeration values</td>
    <td>The type of each column in the table, listed from left to
    right.  Each byte is mapped to a column type according to the
    enumeration type enum_field_types defined in mysql_com.h.  The
    mapping of types to numbers is listed in the table @ref
    Table_table_map_log_event_column_types "below" (along with
    description of the associated metadata field).  </td>
  </tr>

  <tr>
    <td>metadata_length</td>
    <td>@ref packed_integer "Packed Integer"</td>
    <td>The length of the following metadata block</td>
  </tr>

  <tr>
    <td>metadata</td>
    <td>list of metadata for each column</td>
    <td>For each column from left to right, a chunk of data who's
    length and semantics depends on the type of the column.  The
    length and semantics for the metadata for each column are listed
    in the table @ref Table_table_map_log_event_column_types
    "below".</td>
  </tr>

  <tr>
    <td>null_bits</td>
    <td>column_count bits, rounded up to nearest byte</td>
    <td>For each column, a bit indicating whether data in the column
    can be NULL or not.  The number of bytes needed for this is
    int((column_count+7)/8).  The flag for the first column from the
    left is in the least-significant bit of the first byte, the second
    is in the second least significant bit of the first byte, the
    ninth is in the least significant bit of the second byte, and so
    on.  </td>
  </tr>

  </table>

  The table below lists all column types, along with the numerical
  identifier for it and the size and interpretation of meta-data used
  to describe the type.

  @anchor Table_table_map_log_event_column_types
  <table>
  <caption>Table_map_log_event column types: numerical identifier and
  metadata</caption>
  <tr>
    <th>Name</th>
    <th>Identifier</th>
    <th>Size of metadata in bytes</th>
    <th>Description of metadata</th>
  </tr>

  <tr>
    <td>MYSQL_TYPE_DECIMAL</td><td>0</td>
    <td>0</td>
    <td>No column metadata.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_TINY</td><td>1</td>
    <td>0</td>
    <td>No column metadata.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_SHORT</td><td>2</td>
    <td>0</td>
    <td>No column metadata.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_LONG</td><td>3</td>
    <td>0</td>
    <td>No column metadata.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_FLOAT</td><td>4</td>
    <td>1 byte</td>
    <td>1 byte unsigned integer, representing the "pack_length", which
    is equal to sizeof(float) on the server from which the event
    originates.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_DOUBLE</td><td>5</td>
    <td>1 byte</td>
    <td>1 byte unsigned integer, representing the "pack_length", which
    is equal to sizeof(double) on the server from which the event
    originates.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_NULL</td><td>6</td>
    <td>0</td>
    <td>No column metadata.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_TIMESTAMP</td><td>7</td>
    <td>0</td>
    <td>No column metadata.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_LONGLONG</td><td>8</td>
    <td>0</td>
    <td>No column metadata.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_INT24</td><td>9</td>
    <td>0</td>
    <td>No column metadata.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_DATE</td><td>10</td>
    <td>0</td>
    <td>No column metadata.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_TIME</td><td>11</td>
    <td>0</td>
    <td>No column metadata.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_DATETIME</td><td>12</td>
    <td>0</td>
    <td>No column metadata.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_YEAR</td><td>13</td>
    <td>0</td>
    <td>No column metadata.</td>
  </tr>

  <tr>
    <td><i>MYSQL_TYPE_NEWDATE</i></td><td><i>14</i></td>
    <td>&ndash;</td>
    <td><i>This enumeration value is only used internally and cannot
    exist in a binlog.</i></td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_VARCHAR</td><td>15</td>
    <td>2 bytes</td>
    <td>2 byte unsigned integer representing the maximum length of
    the string.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_BIT</td><td>16</td>
    <td>2 bytes</td>
    <td>A 1 byte unsigned int representing the length in bits of the
    bitfield (0 to 64), followed by a 1 byte unsigned int
    representing the number of bytes occupied by the bitfield.  The
    number of bytes is either int((length+7)/8) or int(length/8).</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_NEWDECIMAL</td><td>246</td>
    <td>2 bytes</td>
    <td>A 1 byte unsigned int representing the precision, followed
    by a 1 byte unsigned int representing the number of decimals.</td>
  </tr>

  <tr>
    <td><i>MYSQL_TYPE_ENUM</i></td><td><i>247</i></td>
    <td>&ndash;</td>
    <td><i>This enumeration value is only used internally and cannot
    exist in a binlog.</i></td>
  </tr>

  <tr>
    <td><i>MYSQL_TYPE_SET</i></td><td><i>248</i></td>
    <td>&ndash;</td>
    <td><i>This enumeration value is only used internally and cannot
    exist in a binlog.</i></td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_TINY_BLOB</td><td>249</td>
    <td>&ndash;</td>
    <td><i>This enumeration value is only used internally and cannot
    exist in a binlog.</i></td>
  </tr>

  <tr>
    <td><i>MYSQL_TYPE_MEDIUM_BLOB</i></td><td><i>250</i></td>
    <td>&ndash;</td>
    <td><i>This enumeration value is only used internally and cannot
    exist in a binlog.</i></td>
  </tr>

  <tr>
    <td><i>MYSQL_TYPE_LONG_BLOB</i></td><td><i>251</i></td>
    <td>&ndash;</td>
    <td><i>This enumeration value is only used internally and cannot
    exist in a binlog.</i></td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_BLOB</td><td>252</td>
    <td>1 byte</td>
    <td>The pack length, i.e., the number of bytes needed to represent
    the length of the blob: 1, 2, 3, or 4.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_VAR_STRING</td><td>253</td>
    <td>2 bytes</td>
    <td>This is used to store both strings and enumeration values.
    The first byte is a enumeration value storing the <i>real
    type</i>, which may be either MYSQL_TYPE_VAR_STRING or
    MYSQL_TYPE_ENUM.  The second byte is a 1 byte unsigned integer
    representing the field size, i.e., the number of bytes needed to
    store the length of the string.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_STRING</td><td>254</td>
    <td>2 bytes</td>
    <td>The first byte is always MYSQL_TYPE_VAR_STRING (i.e., 253).
    The second byte is the field size, i.e., the number of bytes in
    the representation of size of the string: 3 or 4.</td>
  </tr>

  <tr>
    <td>MYSQL_TYPE_GEOMETRY</td><td>255</td>
    <td>1 byte</td>
    <td>The pack length, i.e., the number of bytes needed to represent
    the length of the geometry: 1, 2, 3, or 4.</td>
  </tr>

  </table>
3963
*/
3964 3965 3966 3967 3968 3969 3970 3971 3972
class Table_map_log_event : public Log_event
{
public:
  /* Constants */
  enum
  {
    TYPE_CODE = TABLE_MAP_EVENT
  };

3973 3974 3975
  /**
     Enumeration of the errors that can be returned.
   */
3976 3977
  enum enum_error
  {
3978 3979 3980 3981 3982 3983
    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 */
3984 3985 3986 3987 3988 3989
  };

  enum enum_flag
  {
    /* 
       Nothing here right now, but the flags support is there in
unknown's avatar
unknown committed
3990 3991 3992
       preparation for changes that are coming.  Need to add a
       constant to make it compile under HP-UX: aCC does not like
       empty enumerations.
3993
    */
unknown's avatar
unknown committed
3994
    ENUM_FLAG_COUNT
3995 3996 3997 3998 3999 4000 4001
  };

  typedef uint16 flag_set;

  /* Special constants representing sets of flags */
  enum 
  {
4002 4003
    TM_NO_FLAGS = 0U,
    TM_BIT_LEN_EXACT_F = (1U << 0)
4004 4005 4006 4007
  };

  flag_set get_flags(flag_set flag) const { return m_flags & flag; }

4008
#ifdef MYSQL_SERVER
4009
  Table_map_log_event(THD *thd, TABLE *tbl, ulong tid, bool is_transactional);
4010 4011 4012 4013 4014 4015 4016 4017
#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();

4018 4019 4020 4021
#ifdef MYSQL_CLIENT
  table_def *create_table_def()
  {
    return new table_def(m_coltype, m_colcnt, m_field_metadata,
4022
                         m_field_metadata_size, m_null_bits, m_flags);
4023
  }
4024 4025
  int rewrite_db(const char* new_name, size_t new_name_len,
                 const Format_description_log_event*);
4026
#endif
4027 4028 4029 4030
  ulong get_table_id() const        { return m_table_id; }
  const char *get_table_name() const { return m_tblnam; }
  const char *get_db_name() const    { return m_dbnam; }

4031
  virtual Log_event_type get_type_code() { return TABLE_MAP_EVENT; }
4032
  virtual bool is_valid() const { return m_memory != NULL; /* we check malloc */ }
4033

4034
  virtual int get_data_size() { return (uint) m_data_size; } 
4035
#ifdef MYSQL_SERVER
4036
  virtual int save_field_metadata();
4037 4038 4039 4040 4041
  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

4042
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
unknown's avatar
unknown committed
4043
  virtual void pack_info(THD *thd, Protocol *protocol);
4044 4045 4046 4047 4048 4049 4050 4051
#endif

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


private:
4052
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
4053
  virtual int do_apply_event(struct rpl_group_info *rgi);
4054
  virtual int do_update_pos(struct rpl_group_info *rgi);
4055
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
4056 4057
#endif

4058
#ifdef MYSQL_SERVER
4059
  TABLE         *m_table;
4060 4061
#endif
  char const    *m_dbnam;
4062
  size_t         m_dblen;
4063
  char const    *m_tblnam;
4064
  size_t         m_tbllen;
4065
  ulong          m_colcnt;
4066
  uchar         *m_coltype;
4067

4068
  uchar         *m_memory;
4069 4070 4071
  ulong          m_table_id;
  flag_set       m_flags;

4072
  size_t         m_data_size;
4073 4074 4075

  uchar          *m_field_metadata;        // buffer for field metadata
  /*
4076
    The size of field metadata buffer set by calling save_field_metadata()
4077 4078 4079 4080
  */
  ulong          m_field_metadata_size;   
  uchar         *m_null_bits;
  uchar         *m_meta_memory;
4081 4082 4083
};


4084 4085
/**
  @class Rows_log_event
4086

4087
 Common base class for all row-containing log events.
4088 4089 4090 4091 4092 4093 4094

 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.

4095 4096
  @section Rows_log_event_binary_format Binary Format
*/
4097

4098

4099 4100 4101
class Rows_log_event : public Log_event
{
public:
4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114
  /**
     Enumeration of the errors that can be returned.
   */
  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 */
  };

4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130
  /*
    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 */
4131 4132 4133 4134 4135 4136 4137
    RELAXED_UNIQUE_CHECKS_F = (1U << 2),

    /** 
      Indicates that rows in this event are complete, that is contain
      values for all columns of the table.
     */
    COMPLETE_ROWS_F = (1U << 3)
4138 4139 4140 4141 4142 4143 4144
  };

  typedef uint16 flag_set;

  /* Special constants representing sets of flags */
  enum 
  {
4145
      RLE_NO_FLAGS = 0U
4146 4147 4148 4149
  };

  virtual ~Rows_log_event();

4150 4151 4152
  void set_flags(flag_set flags_arg) { m_flags |= flags_arg; }
  void clear_flags(flag_set flags_arg) { m_flags &= ~flags_arg; }
  flag_set get_flags(flag_set flags_arg) const { return m_flags & flags_arg; }
4153

4154
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
unknown's avatar
unknown committed
4155
  virtual void pack_info(THD *thd, Protocol *protocol);
4156 4157 4158 4159 4160
#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;
4161 4162 4163 4164 4165 4166
  void print_verbose(IO_CACHE *file,
                     PRINT_EVENT_INFO *print_event_info);
  size_t print_verbose_one_row(IO_CACHE *file, table_def *td,
                               PRINT_EVENT_INFO *print_event_info,
                               MY_BITMAP *cols_bitmap,
                               const uchar *ptr, const uchar *prefix);
4167 4168
#endif

4169
#ifdef MYSQL_SERVER
4170
  int add_row_data(uchar *data, size_t length)
4171 4172 4173 4174 4175 4176
  {
    return do_add_row_data(data,length); 
  }
#endif

  /* Member functions to implement superclass interface */
4177
  virtual int get_data_size();
4178 4179

  MY_BITMAP const *get_cols() const { return &m_cols; }
4180
  size_t get_width() const          { return m_width; }
4181 4182
  ulong get_table_id() const        { return m_table_id; }

4183
#ifdef MYSQL_SERVER
4184 4185 4186 4187
  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
4188 4189 4190 4191 4192 4193
  /*
    Check that malloc() succeeded in allocating memory for the rows
    buffer and the COLS vector. Checking that an Update_rows_log_event
    is valid is done in the Update_rows_log_event::is_valid()
    function.
  */
4194 4195 4196 4197 4198
  virtual bool is_valid() const
  {
    return m_rows_buf && m_cols.bitmap;
  }

4199
  uint     m_row_count;         /* The number of rows added to the event */
4200 4201 4202 4203 4204 4205

protected:
  /* 
     The constructors are protected since you're supposed to inherit
     this class, not create instances of this class.
  */
4206
#ifdef MYSQL_SERVER
4207 4208 4209 4210 4211 4212 4213
  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);

4214 4215 4216 4217
#ifdef MYSQL_CLIENT
  void print_helper(FILE *, PRINT_EVENT_INFO *, char const *const name);
#endif

4218
#ifdef MYSQL_SERVER
4219
  virtual int do_add_row_data(uchar *data, size_t length);
4220 4221
#endif

4222
#ifdef MYSQL_SERVER
4223 4224 4225 4226 4227
  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 */
4228 4229 4230 4231 4232 4233 4234 4235 4236
  /*
    Bitmap for columns available in the after image, if present. These
    fields are only available for Update_rows events. Observe that the
    width of both the before image COLS vector and the after image
    COLS vector is the same: the number of columns of the table on the
    master.
  */
  MY_BITMAP   m_cols_ai;

4237
  ulong       m_master_reclength; /* Length of record on master side */
4238

4239
  /* Bit buffers in the same memory as the class */
4240
  uint32    m_bitbuf[128/(sizeof(uint32)*8)];
4241
  uint32    m_bitbuf_ai[128/(sizeof(uint32)*8)];
4242

4243 4244 4245
  uchar    *m_rows_buf;		/* The rows in packed format */
  uchar    *m_rows_cur;		/* One-after the end of the data */
  uchar    *m_rows_end;		/* One-after the end of the allocated space */
4246 4247

  flag_set m_flags;		/* Flags for row-level events */
4248 4249 4250

  /* helper functions */

4251
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
unknown's avatar
unknown committed
4252 4253 4254
  const uchar *m_curr_row;     /* Start of the row being processed */
  const uchar *m_curr_row_end; /* One-after the end of the current row */
  uchar    *m_key;      /* Buffer to keep key value during searches */
4255 4256
  KEY      *m_key_info; /* Pointer to KEY info for m_key_nr */
  uint      m_key_nr;   /* Key number */
unknown's avatar
unknown committed
4257

4258
  int find_key(); // Find a best key to use in find_row()
unknown's avatar
unknown committed
4259 4260
  int find_row(const Relay_log_info *const);
  int write_row(const Relay_log_info *const, const bool);
4261 4262

  // Unpack the current row into m_table->record[0]
4263 4264
  int unpack_current_row(const Relay_log_info *const rli)
  {
4265
    DBUG_ASSERT(m_table);
4266

4267
    ASSERT_OR_RETURN_ERROR(m_curr_row < m_rows_end, HA_ERR_CORRUPT_EVENT);
4268 4269
    int const result= ::unpack_row(rli, m_table, m_width, m_curr_row,
                                   m_rows_end, &m_cols,
4270
                                   &m_curr_row_end, &m_master_reclength);
4271 4272
    if (m_curr_row_end > m_rows_end)
      my_error(ER_SLAVE_CORRUPT_EVENT, MYF(0));
4273 4274
    ASSERT_OR_RETURN_ERROR(m_curr_row_end <= m_rows_end, HA_ERR_CORRUPT_EVENT);
    return result;
4275 4276
  }
#endif
4277 4278 4279

private:

4280
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
4281
  virtual int do_apply_event(struct rpl_group_info *rgi);
4282
  virtual int do_update_pos(struct rpl_group_info *rgi);
4283
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
4284

4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300
  /*
    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.
  */
4301 4302
  virtual 
  int do_before_row_operations(const Slave_reporting_capability *const log) = 0;
4303 4304 4305 4306 4307 4308 4309 4310 4311

  /*
    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.
4312 4313 4314 4315
      
      The error argument, if non-zero, indicates an error which happened during
      row processing before this function was called. In this case, even if 
      function is successful, it should return the error code given in the argument.
4316
  */
4317 4318 4319
  virtual 
  int do_after_row_operations(const Slave_reporting_capability *const log,
                              int error) = 0;
4320 4321 4322 4323 4324 4325

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

    DESCRIPTION
      The member function will do the actual execution needed to handle a row.
4326 4327 4328
      The row is located at m_curr_row. When the function returns, 
      m_curr_row_end should point at the next row (one byte after the end
      of the current row).    
4329 4330 4331 4332 4333

    RETURN VALUE
      0 if execution succeeded, 1 if execution failed.
      
  */
unknown's avatar
unknown committed
4334
  virtual int do_exec_row(const Relay_log_info *const rli) = 0;
4335
#endif /* defined(MYSQL_SERVER) && defined(HAVE_REPLICATION) */
4336

4337 4338
  friend class Old_rows_log_event;
};
4339

4340 4341
/**
  @class Write_rows_log_event
4342 4343 4344 4345 4346

  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.

4347 4348
  @section Write_rows_log_event_binary_format Binary Format
*/
4349 4350 4351 4352 4353 4354 4355 4356 4357
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
  };

4358
#if defined(MYSQL_SERVER)
4359 4360 4361 4362 4363 4364 4365
  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
4366
#if defined(MYSQL_SERVER) 
4367 4368 4369 4370
  static bool binlog_row_logging_function(THD *thd, TABLE *table,
                                          bool is_transactional,
                                          MY_BITMAP *cols,
                                          uint fields,
4371
                                          const uchar *before_record
4372
                                          __attribute__((unused)),
4373
                                          const uchar *after_record)
4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386
  {
    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

4387
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
4388 4389
  virtual int do_before_row_operations(const Slave_reporting_capability *const);
  virtual int do_after_row_operations(const Slave_reporting_capability *const,int);
unknown's avatar
unknown committed
4390
  virtual int do_exec_row(const Relay_log_info *const);
4391 4392 4393 4394
#endif
};


4395 4396
/**
  @class Update_rows_log_event
4397 4398 4399 4400 4401 4402 4403 4404

  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.

4405 4406
  @section Update_rows_log_event_binary_format Binary Format
*/
4407 4408 4409 4410 4411 4412 4413 4414 4415
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
  };

4416
#ifdef MYSQL_SERVER
4417 4418 4419 4420 4421 4422 4423 4424 4425 4426
  Update_rows_log_event(THD*, TABLE*, ulong table_id,
			MY_BITMAP const *cols_bi,
			MY_BITMAP const *cols_ai,
                        bool is_transactional);

  Update_rows_log_event(THD*, TABLE*, ulong table_id,
			MY_BITMAP const *cols,
                        bool is_transactional);

  void init(MY_BITMAP const *cols);
4427 4428
#endif

4429 4430
  virtual ~Update_rows_log_event();

4431 4432 4433 4434 4435
#ifdef HAVE_REPLICATION
  Update_rows_log_event(const char *buf, uint event_len, 
			const Format_description_log_event *description_event);
#endif

4436
#ifdef MYSQL_SERVER
4437 4438 4439 4440
  static bool binlog_row_logging_function(THD *thd, TABLE *table,
                                          bool is_transactional,
                                          MY_BITMAP *cols,
                                          uint fields,
4441 4442
                                          const uchar *before_record,
                                          const uchar *after_record)
4443 4444 4445 4446 4447 4448
  {
    return thd->binlog_update_row(table, is_transactional,
                                  cols, fields, before_record, after_record);
  }
#endif

4449 4450 4451 4452 4453
  virtual bool is_valid() const
  {
    return Rows_log_event::is_valid() && m_cols_ai.bitmap;
  }

4454
protected:
4455 4456 4457 4458 4459 4460
  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

4461
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
4462 4463
  virtual int do_before_row_operations(const Slave_reporting_capability *const);
  virtual int do_after_row_operations(const Slave_reporting_capability *const,int);
unknown's avatar
unknown committed
4464
  virtual int do_exec_row(const Relay_log_info *const);
4465
#endif /* defined(MYSQL_SERVER) && defined(HAVE_REPLICATION) */
4466 4467
};

4468 4469
/**
  @class Delete_rows_log_event
4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485

  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.

4486 4487
  @section Delete_rows_log_event_binary_format Binary Format
*/
4488 4489 4490 4491 4492 4493 4494 4495 4496
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
  };

4497
#ifdef MYSQL_SERVER
4498 4499 4500 4501 4502 4503 4504
  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
4505
#ifdef MYSQL_SERVER
4506 4507 4508 4509
  static bool binlog_row_logging_function(THD *thd, TABLE *table,
                                          bool is_transactional,
                                          MY_BITMAP *cols,
                                          uint fields,
4510 4511
                                          const uchar *before_record,
                                          const uchar *after_record
4512 4513 4514 4515 4516 4517 4518
                                          __attribute__((unused)))
  {
    return thd->binlog_delete_row(table, is_transactional,
                                  cols, fields, before_record);
  }
#endif
  
4519
protected:
4520 4521 4522 4523 4524 4525
  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

4526
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
4527 4528
  virtual int do_before_row_operations(const Slave_reporting_capability *const);
  virtual int do_after_row_operations(const Slave_reporting_capability *const,int);
unknown's avatar
unknown committed
4529
  virtual int do_exec_row(const Relay_log_info *const);
4530 4531 4532
#endif
};

4533

4534 4535
#include "log_event_old.h"

4536
/**
4537 4538
  @class Incident_log_event

4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549
   Class representing an incident, an occurance out of the ordinary,
   that happened on the master.

   The event is used to inform the slave that something out of the
   ordinary happened on the master that might cause the database to be
   in an inconsistent state.

   <table id="IncidentFormat">
   <caption>Incident event format</caption>
   <tr>
     <th>Symbol</th>
4550
     <th>Format</th>
4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568
     <th>Description</th>
   </tr>
   <tr>
     <td>INCIDENT</td>
     <td align="right">2</td>
     <td>Incident number as an unsigned integer</td>
   </tr>
   <tr>
     <td>MSGLEN</td>
     <td align="right">1</td>
     <td>Message length as an unsigned integer</td>
   </tr>
   <tr>
     <td>MESSAGE</td>
     <td align="right">MSGLEN</td>
     <td>The message, if present. Not null terminated.</td>
   </tr>
   </table>
4569 4570 4571

  @section Delete_rows_log_event_binary_format Binary Format
*/
4572 4573
class Incident_log_event : public Log_event {
public:
4574
#ifdef MYSQL_SERVER
4575 4576 4577 4578 4579 4580 4581
  Incident_log_event(THD *thd_arg, Incident incident)
    : Log_event(thd_arg, 0, FALSE), m_incident(incident)
  {
    DBUG_ENTER("Incident_log_event::Incident_log_event");
    DBUG_PRINT("enter", ("m_incident: %d", m_incident));
    m_message.str= NULL;                    /* Just as a precaution */
    m_message.length= 0;
4582
    set_direct_logging();
4583 4584
    /* Replicate the incident irregardless of @@skip_replication. */
    flags&= ~LOG_EVENT_SKIP_REPLICATION_F;
4585 4586 4587 4588 4589 4590 4591 4592 4593
    DBUG_VOID_RETURN;
  }

  Incident_log_event(THD *thd_arg, Incident incident, LEX_STRING const msg)
    : Log_event(thd_arg, 0, FALSE), m_incident(incident)
  {
    DBUG_ENTER("Incident_log_event::Incident_log_event");
    DBUG_PRINT("enter", ("m_incident: %d", m_incident));
    m_message= msg;
4594
    set_direct_logging();
4595 4596
    /* Replicate the incident irregardless of @@skip_replication. */
    flags&= ~LOG_EVENT_SKIP_REPLICATION_F;
4597 4598 4599 4600
    DBUG_VOID_RETURN;
  }
#endif

4601
#ifdef MYSQL_SERVER
unknown's avatar
unknown committed
4602
  void pack_info(THD *thd, Protocol*);
4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613
#endif

  Incident_log_event(const char *buf, uint event_len,
                     const Format_description_log_event *descr_event);

  virtual ~Incident_log_event();

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

4614
#if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
4615
  virtual int do_apply_event(struct rpl_group_info *rgi);
4616 4617 4618 4619 4620 4621 4622
#endif

  virtual bool write_data_header(IO_CACHE *file);
  virtual bool write_data_body(IO_CACHE *file);

  virtual Log_event_type get_type_code() { return INCIDENT_EVENT; }

4623 4624 4625 4626
  virtual bool is_valid() const
  {
    return m_incident > INCIDENT_NONE && m_incident < INCIDENT_COUNT;
  }
4627
  virtual int get_data_size() {
4628
    return INCIDENT_HEADER_LEN + 1 + (uint) m_message.length;
4629 4630 4631 4632 4633 4634 4635 4636 4637
  }

private:
  const char *description() const;

  Incident m_incident;
  LEX_STRING m_message;
};

4638 4639 4640 4641 4642 4643 4644 4645
static inline bool copy_event_cache_to_file_and_reinit(IO_CACHE *cache,
                                                       FILE *file)
{
  return         
    my_b_copy_to_file(cache, file) ||
    reinit_io_cache(cache, WRITE_CACHE, 0, FALSE, TRUE);
}

4646
#ifdef MYSQL_SERVER
Andrei Elkin's avatar
Andrei Elkin committed
4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679
/*****************************************************************************

  Heartbeat Log Event class

  Replication event to ensure to slave that master is alive.
  The event is originated by master's dump thread and sent straight to
  slave without being logged. Slave itself does not store it in relay log
  but rather uses a data for immediate checks and throws away the event.

  Two members of the class log_ident and Log_event::log_pos comprise 
  @see the event_coordinates instance. The coordinates that a heartbeat
  instance carries correspond to the last event master has sent from
  its binlog.

 ****************************************************************************/
class Heartbeat_log_event: public Log_event
{
public:
  Heartbeat_log_event(const char* buf, uint event_len,
                      const Format_description_log_event* description_event);
  Log_event_type get_type_code() { return HEARTBEAT_LOG_EVENT; }
  bool is_valid() const
    {
      return (log_ident != NULL &&
              log_pos >= BIN_LOG_HEADER_SIZE);
    }
  const char * get_log_ident() { return log_ident; }
  uint get_ident_len() { return ident_len; }
  
private:
  const char* log_ident;
  uint ident_len;
};
4680

4681 4682 4683 4684 4685 4686 4687
/**
   The function is called by slave applier in case there are
   active table filtering rules to force gathering events associated
   with Query-log-event into an array to execute
   them once the fate of the Query is determined for execution.
*/
bool slave_execute_deferred_events(THD *thd);
Andrei Elkin's avatar
Andrei Elkin committed
4688 4689
#endif

4690
int append_query_string(THD *thd, CHARSET_INFO *csinfo,
4691 4692
                        String const *from, String *to);

4693 4694 4695 4696
bool rpl_get_position_info(const char **log_file_name, ulonglong *log_pos,
                           const char **group_relay_log_name,
                           ulonglong *relay_log_pos);

4697 4698 4699 4700
bool event_checksum_test(uchar *buf, ulong event_len, uint8 alg);
uint8 get_checksum_alg(const char* buf, ulong len);
extern TYPELIB binlog_checksum_typelib;

4701 4702 4703 4704 4705 4706 4707 4708 4709 4710
#ifndef MYSQL_CLIENT
/**
   The function is called by slave applier in case there are
   active table filtering rules to force gathering events associated
   with Query-log-event into an array to execute
   them once the fate of the Query is determined for execution.
*/
bool slave_execute_deferred_events(THD *thd);
#endif

4711 4712 4713 4714
/**
  @} (end of group Replication)
*/

4715
#endif /* _log_event_h */