log_event.cc 212 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000-2004 MySQL AB
2

unknown's avatar
unknown committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
7

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

unknown's avatar
unknown committed
13 14 15 16 17 18
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


#ifndef MYSQL_CLIENT
unknown's avatar
unknown committed
19

20
#ifdef USE_PRAGMA_IMPLEMENTATION
unknown's avatar
unknown committed
21 22
#pragma implementation				// gcc: Class implementation
#endif
23

24
#include "mysql_priv.h"
25
#include "slave.h"
unknown's avatar
unknown committed
26
#include "rpl_filter.h"
27
#include <my_dir.h>
unknown's avatar
unknown committed
28
#endif /* MYSQL_CLIENT */
29 30
#include <base64.h>
#include <my_bitmap.h>
unknown's avatar
unknown committed
31

unknown's avatar
unknown committed
32
#define log_cs	&my_charset_latin1
33

unknown's avatar
unknown committed
34
/*
35
  pretty_print_str()
unknown's avatar
unknown committed
36
*/
37

38
#ifdef MYSQL_CLIENT
39
static void pretty_print_str(FILE* file, char* str, int len)
unknown's avatar
unknown committed
40
{
41
  char* end = str + len;
unknown's avatar
unknown committed
42
  fputc('\'', file);
43 44
  while (str < end)
  {
unknown's avatar
unknown committed
45
    char c;
46 47 48 49 50 51 52 53 54 55 56 57
    switch ((c=*str++)) {
    case '\n': fprintf(file, "\\n"); break;
    case '\r': fprintf(file, "\\r"); break;
    case '\\': fprintf(file, "\\\\"); break;
    case '\b': fprintf(file, "\\b"); break;
    case '\t': fprintf(file, "\\t"); break;
    case '\'': fprintf(file, "\\'"); break;
    case 0   : fprintf(file, "\\0"); break;
    default:
      fputc(c, file);
      break;
    }
58 59
  }
  fputc('\'', file);
unknown's avatar
unknown committed
60
}
unknown's avatar
unknown committed
61
#endif /* MYSQL_CLIENT */
unknown's avatar
unknown committed
62

unknown's avatar
unknown committed
63

unknown's avatar
unknown committed
64
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
unknown's avatar
unknown committed
65

66 67 68 69 70 71 72 73
static void clear_all_errors(THD *thd, struct st_relay_log_info *rli)
{
  thd->query_error = 0;
  thd->clear_error();
  *rli->last_slave_error = 0;
  rli->last_slave_errno = 0;
}

unknown's avatar
unknown committed
74

unknown's avatar
unknown committed
75
/*
unknown's avatar
unknown committed
76
  Ignore error code specified on command line
unknown's avatar
unknown committed
77
*/
78

79 80
inline int ignored_error_code(int err_code)
{
unknown's avatar
unknown committed
81 82 83 84 85 86 87 88 89 90 91 92 93 94
#ifdef HAVE_NDB_BINLOG
  /*
    The following error codes are hard-coded and will always be ignored.
  */
  switch (err_code)
  {
  case ER_DB_CREATE_EXISTS:
  case ER_DB_DROP_EXISTS:
    return 1;
  default:
    /* Nothing to do */
    break;
  }
#endif
unknown's avatar
unknown committed
95 96
  return ((err_code == ER_SLAVE_IGNORED_TABLE) ||
          (use_slave_mask && bitmap_is_set(&slave_error_mask, err_code)));
97
}
unknown's avatar
SCRUM  
unknown committed
98
#endif
99

unknown's avatar
unknown committed
100

unknown's avatar
unknown committed
101
/*
102
  pretty_print_str()
unknown's avatar
unknown committed
103
*/
unknown's avatar
unknown committed
104

unknown's avatar
unknown committed
105
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
unknown's avatar
unknown committed
106
static char *pretty_print_str(char *packet, char *str, int len)
unknown's avatar
unknown committed
107
{
unknown's avatar
unknown committed
108 109
  char *end= str + len;
  char *pos= packet;
110
  *pos++= '\'';
111 112 113
  while (str < end)
  {
    char c;
114
    switch ((c=*str++)) {
unknown's avatar
unknown committed
115 116 117 118 119 120 121
    case '\n': *pos++= '\\'; *pos++= 'n'; break;
    case '\r': *pos++= '\\'; *pos++= 'r'; break;
    case '\\': *pos++= '\\'; *pos++= '\\'; break;
    case '\b': *pos++= '\\'; *pos++= 'b'; break;
    case '\t': *pos++= '\\'; *pos++= 't'; break;
    case '\'': *pos++= '\\'; *pos++= '\''; break;
    case 0   : *pos++= '\\'; *pos++= '0'; break;
122
    default:
unknown's avatar
unknown committed
123
      *pos++= c;
124 125
      break;
    }
unknown's avatar
unknown committed
126
  }
127 128
  *pos++= '\'';
  return pos;
unknown's avatar
unknown committed
129
}
unknown's avatar
unknown committed
130
#endif /* !MYSQL_CLIENT */
131

unknown's avatar
unknown committed
132

unknown's avatar
unknown committed
133
/*
unknown's avatar
unknown committed
134 135 136 137 138 139 140 141 142 143 144
  Creates a temporary name for load data infile:

  SYNOPSIS
    slave_load_file_stem()
    buf		      Store new filename here
    file_id	      File_id (part of file name)
    event_server_id   Event_id (part of file name)
    ext		      Extension for file name

  RETURN
    Pointer to start of extension
unknown's avatar
unknown committed
145
*/
unknown's avatar
unknown committed
146

unknown's avatar
SCRUM  
unknown committed
147
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
unknown's avatar
unknown committed
148 149
static char *slave_load_file_stem(char *buf, uint file_id,
                                  int event_server_id, const char *ext)
150
{
unknown's avatar
unknown committed
151
  char *res;
152 153 154
  fn_format(buf,"SQL_LOAD-",slave_load_tmpdir, "", MY_UNPACK_FILENAME);
  to_unix_path(buf);

155 156 157 158 159
  buf = strend(buf);
  buf = int10_to_str(::server_id, buf, 10);
  *buf++ = '-';
  buf = int10_to_str(event_server_id, buf, 10);
  *buf++ = '-';
unknown's avatar
unknown committed
160 161 162
  res= int10_to_str(file_id, buf, 10);
  strmov(res, ext);                             // Add extension last
  return res;                                   // Pointer to extension
163
}
unknown's avatar
SCRUM  
unknown committed
164
#endif
165

unknown's avatar
unknown committed
166

unknown's avatar
unknown committed
167
/*
168 169
  Delete all temporary files used for SQL_LOAD.

unknown's avatar
unknown committed
170 171
  SYNOPSIS
    cleanup_load_tmpdir()
unknown's avatar
unknown committed
172
*/
173

unknown's avatar
SCRUM  
unknown committed
174
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
175 176 177 178 179
static void cleanup_load_tmpdir()
{
  MY_DIR *dirp;
  FILEINFO *file;
  uint i;
unknown's avatar
unknown committed
180
  char fname[FN_REFLEN], prefbuf[31], *p;
unknown's avatar
unknown committed
181

182 183 184
  if (!(dirp=my_dir(slave_load_tmpdir,MYF(MY_WME))))
    return;

185 186 187 188 189 190 191 192
  /* 
     When we are deleting temporary files, we should only remove
     the files associated with the server id of our server.
     We don't use event_server_id here because since we've disabled
     direct binlogging of Create_file/Append_file/Exec_load events
     we cannot meet Start_log event in the middle of events from one 
     LOAD DATA.
  */
193
  p= strmake(prefbuf, STRING_WITH_LEN("SQL_LOAD-"));
194 195 196 197
  p= int10_to_str(::server_id, p, 10);
  *(p++)= '-';
  *p= 0;

198 199 200
  for (i=0 ; i < (uint)dirp->number_off_files; i++)
  {
    file=dirp->dir_entry+i;
201
    if (is_prefix(file->name, prefbuf))
unknown's avatar
unknown committed
202 203 204 205
    {
      fn_format(fname,file->name,slave_load_tmpdir,"",MY_UNPACK_FILENAME);
      my_delete(fname, MYF(0));
    }
206 207 208 209
  }

  my_dirend(dirp);
}
unknown's avatar
SCRUM  
unknown committed
210
#endif
211 212


unknown's avatar
unknown committed
213
/*
214
  write_str()
unknown's avatar
unknown committed
215
*/
216

217
static bool write_str(IO_CACHE *file, char *str, uint length)
218
{
219 220 221 222
  byte tmp[1];
  tmp[0]= (byte) length;
  return (my_b_safe_write(file, tmp, sizeof(tmp)) ||
	  my_b_safe_write(file, (byte*) str, length));
223 224 225
}


unknown's avatar
unknown committed
226
/*
227
  read_str()
unknown's avatar
unknown committed
228
*/
229

230 231
static inline int read_str(char **buf, char *buf_end, char **str,
			   uint8 *len)
232
{
233
  if (*buf + ((uint) (uchar) **buf) >= buf_end)
234
    return 1;
235 236 237
  *len= (uint8) **buf;
  *str= (*buf)+1;
  (*buf)+= (uint) *len+1;
238 239 240
  return 0;
}

241

242 243 244
/*
  Transforms a string into "" or its expression in 0x... form.
*/
unknown's avatar
unknown committed
245

246
char *str_to_hex(char *to, const char *from, uint len)
247 248 249
{
  if (len)
  {
unknown's avatar
unknown committed
250 251 252
    *to++= '0';
    *to++= 'x';
    to= octet2hex(to, from, len);
253 254
  }
  else
unknown's avatar
unknown committed
255 256
    to= strmov(to, "\"\"");
  return to;                               // pointer to end 0 of 'to'
257 258
}

259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
/*
  Append a version of the 'from' string suitable for use in a query to
  the 'to' string.  To generate a correct escaping, the character set
  information in 'csinfo' is used.
 */
#ifndef MYSQL_CLIENT
int
append_query_string(CHARSET_INFO *csinfo,
                    String const *from, String *to)
{
  char *beg, *ptr;
  uint32 const orig_len= to->length();
  if (to->reserve(orig_len + from->length()*2+3))
    return 1;

  beg= to->c_ptr_quick() + to->length();
  ptr= beg;
  if (csinfo->escape_with_backslash_is_dangerous)
    ptr= str_to_hex(ptr, from->ptr(), from->length());
  else
  {
    *ptr++= '\'';
    ptr+= escape_string_for_mysql(from->charset(), ptr, 0,
                                  from->ptr(), from->length());
    *ptr++='\'';
  }
  to->length(orig_len + ptr - beg);
  return 0;
}
#endif

290 291 292 293 294
/*
  Prints a "session_var=value" string. Used by mysqlbinlog to print some SET
  commands just before it prints a query.
*/

295
#ifdef MYSQL_CLIENT
296 297 298 299 300 301 302
static void print_set_option(FILE* file, uint32 bits_changed, uint32 option,
                             uint32 flags, const char* name, bool* need_comma) 
{
  if (bits_changed & option)
  {
    if (*need_comma)
      fprintf(file,", ");
303
    fprintf(file,"%s=%d", name, test(flags & option));
304 305 306
    *need_comma= 1;
  }
}
307
#endif
308

unknown's avatar
unknown committed
309
/**************************************************************************
310
	Log_event methods (= the parent class of all events)
unknown's avatar
unknown committed
311
**************************************************************************/
312

unknown's avatar
unknown committed
313
/*
314
  Log_event::get_type_str()
unknown's avatar
unknown committed
315
*/
316

unknown's avatar
unknown committed
317 318
const char* Log_event::get_type_str()
{
319
  switch(get_type_code()) {
320
  case START_EVENT_V3:  return "Start_v3";
unknown's avatar
unknown committed
321 322 323 324 325
  case STOP_EVENT:   return "Stop";
  case QUERY_EVENT:  return "Query";
  case ROTATE_EVENT: return "Rotate";
  case INTVAR_EVENT: return "Intvar";
  case LOAD_EVENT:   return "Load";
326
  case NEW_LOAD_EVENT:   return "New_load";
unknown's avatar
unknown committed
327
  case SLAVE_EVENT:  return "Slave";
328 329 330 331
  case CREATE_FILE_EVENT: return "Create_file";
  case APPEND_BLOCK_EVENT: return "Append_block";
  case DELETE_FILE_EVENT: return "Delete_file";
  case EXEC_LOAD_EVENT: return "Exec_load";
332
  case RAND_EVENT: return "RAND";
333
  case XID_EVENT: return "Xid";
unknown's avatar
unknown committed
334
  case USER_VAR_EVENT: return "User var";
335
  case FORMAT_DESCRIPTION_EVENT: return "Format_desc";
336 337 338 339
  case TABLE_MAP_EVENT: return "Table_map";
  case WRITE_ROWS_EVENT: return "Write_rows";
  case UPDATE_ROWS_EVENT: return "Update_rows";
  case DELETE_ROWS_EVENT: return "Delete_rows";
unknown's avatar
unknown committed
340 341
  case BEGIN_LOAD_QUERY_EVENT: return "Begin_load_query";
  case EXECUTE_LOAD_QUERY_EVENT: return "Execute_load_query";
342
  default: return "Unknown";				/* impossible */
unknown's avatar
unknown committed
343 344 345
  }
}

346

unknown's avatar
unknown committed
347
/*
348
  Log_event::Log_event()
unknown's avatar
unknown committed
349
*/
350

unknown's avatar
unknown committed
351
#ifndef MYSQL_CLIENT
352
Log_event::Log_event(THD* thd_arg, uint16 flags_arg, bool using_trans)
353
  :log_pos(0), temp_buf(0), exec_time(0), flags(flags_arg), thd(thd_arg)
354
{
unknown's avatar
unknown committed
355 356
  server_id=	thd->server_id;
  when=		thd->start_time;
357
  cache_stmt=	using_trans;
358 359 360
}


unknown's avatar
unknown committed
361
/*
362 363 364 365
  This minimal constructor is for when you are not even sure that there
  is a valid THD. For example in the server when we are shutting down or
  flushing logs after receiving a SIGHUP (then we must write a Rotate to
  the binlog but we have no THD, so we need this minimal constructor).
unknown's avatar
unknown committed
366 367
*/

368
Log_event::Log_event()
369
  :temp_buf(0), exec_time(0), flags(0), cache_stmt(0),
370 371
   thd(0)
{
unknown's avatar
unknown committed
372 373 374
  server_id=	::server_id;
  when=		time(NULL);
  log_pos=	0;
375
}
unknown's avatar
unknown committed
376
#endif /* !MYSQL_CLIENT */
377 378


unknown's avatar
unknown committed
379
/*
380
  Log_event::Log_event()
381
*/
382

383
Log_event::Log_event(const char* buf,
unknown's avatar
unknown committed
384
                     const Format_description_log_event* description_event)
385
  :temp_buf(0), cache_stmt(0)
386
{
387 388
#ifndef MYSQL_CLIENT
  thd = 0;
unknown's avatar
unknown committed
389
#endif
390 391
  when = uint4korr(buf);
  server_id = uint4korr(buf + SERVER_ID_OFFSET);
392
  if (description_event->binlog_version==1)
393
  {
394 395 396
    log_pos= 0;
    flags= 0;
    return;
397
  }
398 399 400
  /* 4.0 or newer */
  log_pos= uint4korr(buf + LOG_POS_OFFSET);
  /*
401 402 403 404 405 406 407 408
    If the log is 4.0 (so here it can only be a 4.0 relay log read by
    the SQL thread or a 4.0 master binlog read by the I/O thread),
    log_pos is the beginning of the event: we transform it into the end
    of the event, which is more useful.
    But how do you know that the log is 4.0: you know it if
    description_event is version 3 *and* you are not reading a
    Format_desc (remember that mysqlbinlog starts by assuming that 5.0
    logs are in 4.0 format, until it finds a Format_desc).
409 410 411
  */
  if (description_event->binlog_version==3 &&
      buf[EVENT_TYPE_OFFSET]<FORMAT_DESCRIPTION_EVENT && log_pos)
412
  {
413 414 415
      /*
        If log_pos=0, don't change it. log_pos==0 is a marker to mean
        "don't change rli->group_master_log_pos" (see
416 417
        inc_group_relay_log_pos()). As it is unreal log_pos, adding the
        event len's is nonsense. For example, a fake Rotate event should
418
        not have its log_pos (which is 0) changed or it will modify
419 420 421 422
        Exec_master_log_pos in SHOW SLAVE STATUS, displaying a nonsense
        value of (a non-zero offset which does not exist in the master's
        binlog, so which will cause problems if the user uses this value
        in CHANGE MASTER).
423 424
      */
    log_pos+= uint4korr(buf + EVENT_LEN_OFFSET);
425
  }
426 427 428 429 430 431 432
  DBUG_PRINT("info", ("log_pos: %lu", (ulong) log_pos));

  flags= uint2korr(buf + FLAGS_OFFSET);
  if ((buf[EVENT_TYPE_OFFSET] == FORMAT_DESCRIPTION_EVENT) ||
      (buf[EVENT_TYPE_OFFSET] == ROTATE_EVENT))
  {
    /*
433 434
      These events always have a header which stops here (i.e. their
      header is FROZEN).
435 436
    */
    /*
437 438 439 440 441 442 443
      Initialization to zero of all other Log_event members as they're
      not specified. Currently there are no such members; in the future
      there will be an event UID (but Format_description and Rotate
      don't need this UID, as they are not propagated through
      --log-slave-updates (remember the UID is used to not play a query
      twice when you have two masters which are slaves of a 3rd master).
      Then we are done.
444 445 446 447
    */
    return;
  }
  /* otherwise, go on with reading the header from buf (nothing now) */
448 449 450
}

#ifndef MYSQL_CLIENT
unknown's avatar
SCRUM  
unknown committed
451
#ifdef HAVE_REPLICATION
452

unknown's avatar
unknown committed
453
/*
454
  Log_event::exec_event()
unknown's avatar
unknown committed
455
*/
456

457
int Log_event::exec_event(struct st_relay_log_info* rli)
458
{
unknown's avatar
unknown committed
459 460
  DBUG_ENTER("Log_event::exec_event");

461 462 463 464 465 466 467 468 469 470 471 472
  /*
    rli is null when (as far as I (Guilhem) know)
    the caller is
    Load_log_event::exec_event *and* that one is called from
    Execute_load_log_event::exec_event. 
    In this case, we don't do anything here ;
    Execute_load_log_event::exec_event will call Log_event::exec_event
    again later with the proper rli.
    Strictly speaking, if we were sure that rli is null
    only in the case discussed above, 'if (rli)' is useless here.
    But as we are not 100% sure, keep it for now.
  */
473
  if (rli)
474
  {
475
    /*
476 477 478 479
      If in a transaction, and if the slave supports transactions, just
      inc_event_relay_log_pos(). We only have to check for OPTION_BEGIN
      (not OPTION_NOT_AUTOCOMMIT) as transactions are logged with
      BEGIN/COMMIT, not with SET AUTOCOMMIT= .
480

481
      CAUTION: opt_using_transactions means
482
      innodb || bdb ; suppose the master supports InnoDB and BDB,
483
      but the slave supports only BDB, problems
484
      will arise:
485 486
      - suppose an InnoDB table is created on the master,
      - then it will be MyISAM on the slave
487 488 489 490 491 492 493 494 495 496 497 498
      - but as opt_using_transactions is true, the slave will believe he
      is transactional with the MyISAM table. And problems will come
      when one does START SLAVE; STOP SLAVE; START SLAVE; (the slave
      will resume at BEGIN whereas there has not been any rollback).
      This is the problem of using opt_using_transactions instead of a
      finer "does the slave support
      _the_transactional_handler_used_on_the_master_".

      More generally, we'll have problems when a query mixes a
      transactional handler and MyISAM and STOP SLAVE is issued in the
      middle of the "transaction". START SLAVE will resume at BEGIN
      while the MyISAM table has already been updated.
499 500
    */
    if ((thd->options & OPTION_BEGIN) && opt_using_transactions)
501
      rli->inc_event_relay_log_pos();
502 503
    else
    {
504
      rli->inc_group_relay_log_pos(log_pos);
505
      flush_relay_log_info(rli);
506
      /* 
507 508
         Note that Rotate_log_event::exec_event() does not call this
         function, so there is no chance that a fake rotate event resets
509
         last_master_timestamp.
510 511 512
         Note that we update without mutex (probably ok - except in some very
         rare cases, only consequence is that value may take some time to
         display in Seconds_Behind_Master - not critical).
513 514
      */
      rli->last_master_timestamp= when;
515
    }
516
  }
unknown's avatar
unknown committed
517
  DBUG_RETURN(0);
518
}
unknown's avatar
unknown committed
519

520

unknown's avatar
unknown committed
521
/*
522
  Log_event::pack_info()
unknown's avatar
unknown committed
523
*/
524

525
void Log_event::pack_info(Protocol *protocol)
unknown's avatar
unknown committed
526
{
527
  protocol->store("", &my_charset_bin);
unknown's avatar
unknown committed
528 529 530
}


unknown's avatar
unknown committed
531
/*
532
  Log_event::net_send()
unknown's avatar
unknown committed
533

534
  Only called by SHOW BINLOG EVENTS
unknown's avatar
unknown committed
535
*/
unknown's avatar
SCRUM  
unknown committed
536

537
int Log_event::net_send(Protocol *protocol, const char* log_name, my_off_t pos)
538
{
unknown's avatar
unknown committed
539 540
  const char *p= strrchr(log_name, FN_LIBCHAR);
  const char *event_type;
541 542 543
  if (p)
    log_name = p + 1;
  
544
  protocol->prepare_for_resend();
545
  protocol->store(log_name, &my_charset_bin);
546
  protocol->store((ulonglong) pos);
547
  event_type = get_type_str();
548
  protocol->store(event_type, strlen(event_type), &my_charset_bin);
549 550 551 552
  protocol->store((uint32) server_id);
  protocol->store((ulonglong) log_pos);
  pack_info(protocol);
  return protocol->write();
553
}
unknown's avatar
SCRUM  
unknown committed
554 555 556
#endif /* HAVE_REPLICATION */


unknown's avatar
unknown committed
557
/*
unknown's avatar
SCRUM  
unknown committed
558
  Log_event::init_show_field_list()
unknown's avatar
unknown committed
559
*/
unknown's avatar
SCRUM  
unknown committed
560 561 562 563 564 565 566 567 568

void Log_event::init_show_field_list(List<Item>* field_list)
{
  field_list->push_back(new Item_empty_string("Log_name", 20));
  field_list->push_back(new Item_return_int("Pos", 11,
					    MYSQL_TYPE_LONGLONG));
  field_list->push_back(new Item_empty_string("Event_type", 20));
  field_list->push_back(new Item_return_int("Server_id", 10,
					    MYSQL_TYPE_LONG));
569
  field_list->push_back(new Item_return_int("End_log_pos", 11,
unknown's avatar
SCRUM  
unknown committed
570 571 572 573
					    MYSQL_TYPE_LONGLONG));
  field_list->push_back(new Item_empty_string("Info", 20));
}

574

unknown's avatar
unknown committed
575
/*
576
  Log_event::write()
unknown's avatar
unknown committed
577
*/
578

579
bool Log_event::write_header(IO_CACHE* file, ulong event_data_length)
unknown's avatar
unknown committed
580
{
581 582
  byte header[LOG_EVENT_HEADER_LEN];
  DBUG_ENTER("Log_event::write_header");
unknown's avatar
unknown committed
583

584 585
  /* Store number of bytes that will be written by this event */
  data_written= event_data_length + sizeof(header);
586

587 588 589 590
  /*
    log_pos != 0 if this is relay-log event. In this case we should not
    change the position
  */
591

592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
  if (is_artificial_event())
  {
    /*
      We should not do any cleanup on slave when reading this. We
      mark this by setting log_pos to 0.  Start_log_event_v3() will
      detect this on reading and set artificial_event=1 for the event.
    */
    log_pos= 0;
  }
  else  if (!log_pos)
  {
    /*
      Calculate position of end of event

      Note that with a SEQ_READ_APPEND cache, my_b_tell() does not
      work well.  So this will give slightly wrong positions for the
      Format_desc/Rotate/Stop events which the slave writes to its
      relay log. For example, the initial Format_desc will have
      end_log_pos=91 instead of 95. Because after writing the first 4
      bytes of the relay log, my_b_tell() still reports 0. Because
      my_b_append() does not update the counter which my_b_tell()
      later uses (one should probably use my_b_append_tell() to work
      around this).  To get right positions even when writing to the
      relay log, we use the (new) my_b_safe_tell().

      Note that this raises a question on the correctness of all these
      DBUG_ASSERT(my_b_tell()=rli->event_relay_log_pos).

      If in a transaction, the log_pos which we calculate below is not
      very good (because then my_b_safe_tell() returns start position
      of the BEGIN, so it's like the statement was at the BEGIN's
      place), but it's not a very serious problem (as the slave, when
      it is in a transaction, does not take those end_log_pos into
      account (as it calls inc_event_relay_log_pos()). To be fixed
      later, so that it looks less strange. But not bug.
    */

    log_pos= my_b_safe_tell(file)+data_written;
  }

  /*
    Header will be of size LOG_EVENT_HEADER_LEN for all events, except for
    FORMAT_DESCRIPTION_EVENT and ROTATE_EVENT, where it will be
    LOG_EVENT_MINIMAL_HEADER_LEN (remember these 2 have a frozen header,
    because we read them before knowing the format).
  */

  int4store(header, (ulong) when);              // timestamp
  header[EVENT_TYPE_OFFSET]= get_type_code();
  int4store(header+ SERVER_ID_OFFSET, server_id);
  int4store(header+ EVENT_LEN_OFFSET, data_written);
  int4store(header+ LOG_POS_OFFSET, log_pos);
  int2store(header+ FLAGS_OFFSET, flags);

  DBUG_RETURN(my_b_safe_write(file, header, sizeof(header)) != 0);
unknown's avatar
unknown committed
647 648 649
}


unknown's avatar
unknown committed
650
/*
651
  Log_event::read_log_event()
652 653 654 655

  This needn't be format-tolerant, because we only read
  LOG_EVENT_MINIMAL_HEADER_LEN (we just want to read the event's length).

unknown's avatar
unknown committed
656
*/
657

658
int Log_event::read_log_event(IO_CACHE* file, String* packet,
659
			      pthread_mutex_t* log_lock)
unknown's avatar
unknown committed
660 661
{
  ulong data_len;
662
  int result=0;
663
  char buf[LOG_EVENT_MINIMAL_HEADER_LEN];
664
  DBUG_ENTER("read_log_event");
665

666
  if (log_lock)
667
    pthread_mutex_lock(log_lock);
668 669
  if (my_b_read(file, (byte*) buf, sizeof(buf)))
  {
670 671 672 673 674
    /*
      If the read hits eof, we must report it as eof so the caller
      will know it can go into cond_wait to be woken up on the next
      update to the log.
    */
675
    DBUG_PRINT("error",("file->error: %d", file->error));
676 677 678
    if (!file->error)
      result= LOG_READ_EOF;
    else
679
      result= (file->error > 0 ? LOG_READ_TRUNC : LOG_READ_IO);
680
    goto end;
681
  }
682
  data_len= uint4korr(buf + EVENT_LEN_OFFSET);
683
  if (data_len < LOG_EVENT_MINIMAL_HEADER_LEN ||
unknown's avatar
unknown committed
684
      data_len > current_thd->variables.max_allowed_packet)
685
  {
686
    DBUG_PRINT("error",("data_len: %ld", data_len));
687
    result= ((data_len < LOG_EVENT_MINIMAL_HEADER_LEN) ? LOG_READ_BOGUS :
688 689
	     LOG_READ_TOO_LARGE);
    goto end;
690
  }
unknown's avatar
unknown committed
691
  packet->append(buf, sizeof(buf));
692
  data_len-= LOG_EVENT_MINIMAL_HEADER_LEN;
693 694 695
  if (data_len)
  {
    if (packet->append(file, data_len))
696
    {
697
      /*
698 699
	Here if we hit EOF it's really an error: as data_len is >=0
        there's supposed to be more bytes available. 
700
	EOF means we are reading the event partially, which should
701
	never happen: either we read badly or the binlog is truncated.
702 703 704
      */
      result= file->error >= 0 ? LOG_READ_TRUNC: LOG_READ_IO;
      /* Implicit goto end; */
705
    }
706
  }
707 708 709 710

end:
  if (log_lock)
    pthread_mutex_unlock(log_lock);
711
  DBUG_RETURN(result);
unknown's avatar
unknown committed
712
}
unknown's avatar
unknown committed
713
#endif /* !MYSQL_CLIENT */
unknown's avatar
unknown committed
714

unknown's avatar
unknown committed
715
#ifndef MYSQL_CLIENT
unknown's avatar
unknown committed
716 717
#define UNLOCK_MUTEX if (log_lock) pthread_mutex_unlock(log_lock);
#define LOCK_MUTEX if (log_lock) pthread_mutex_lock(log_lock);
718
#else
719
#define UNLOCK_MUTEX
720 721 722
#define LOCK_MUTEX
#endif

unknown's avatar
unknown committed
723
/*
724 725
  Log_event::read_log_event()

unknown's avatar
unknown committed
726
  NOTE:
727
    Allocates memory;  The caller is responsible for clean-up.
unknown's avatar
unknown committed
728
*/
729

unknown's avatar
unknown committed
730
#ifndef MYSQL_CLIENT
731 732
Log_event* Log_event::read_log_event(IO_CACHE* file,
				     pthread_mutex_t* log_lock,
733
                                     const Format_description_log_event *description_event)
unknown's avatar
unknown committed
734
#else
735 736
Log_event* Log_event::read_log_event(IO_CACHE* file,
                                     const Format_description_log_event *description_event)
737
#endif
unknown's avatar
unknown committed
738
{
739
  DBUG_ENTER("Log_event::read_log_event(IO_CACHE *, Format_description_log_event *");
740
  DBUG_ASSERT(description_event != 0);
741 742 743 744 745
  char head[LOG_EVENT_MINIMAL_HEADER_LEN];
  /*
    First we only want to read at most LOG_EVENT_MINIMAL_HEADER_LEN, just to
    check the event for sanity and to know its length; no need to really parse
    it. We say "at most" because this could be a 3.23 master, which has header
746 747
    of 13 bytes, whereas LOG_EVENT_MINIMAL_HEADER_LEN is 19 bytes (it's
    "minimal" over the set {MySQL >=4.0}).
748 749 750
  */
  uint header_size= min(description_event->common_header_len,
                        LOG_EVENT_MINIMAL_HEADER_LEN);
751

752
  LOCK_MUTEX;
753
  DBUG_PRINT("info", ("my_b_tell=%lu", my_b_tell(file)));
754
  if (my_b_read(file, (byte *) head, header_size))
755
  {
756 757
    DBUG_PRINT("info", ("Log_event::read_log_event(IO_CACHE*,Format_desc*) \
failed my_b_read"));
unknown's avatar
unknown committed
758
    UNLOCK_MUTEX;
759
    /*
760 761 762
      No error here; it could be that we are at the file's end. However
      if the next my_b_read() fails (below), it will be an error as we
      were able to read the first bytes.
763
    */
764
    DBUG_RETURN(0);
765
  }
766
  uint data_len = uint4korr(head + EVENT_LEN_OFFSET);
767 768 769
  char *buf= 0;
  const char *error= 0;
  Log_event *res=  0;
770 771
#ifndef max_allowed_packet
  THD *thd=current_thd;
unknown's avatar
unknown committed
772
  uint max_allowed_packet= thd ? thd->variables.max_allowed_packet : ~(ulong)0;
773
#endif
unknown's avatar
unknown committed
774

775
  if (data_len > max_allowed_packet)
unknown's avatar
unknown committed
776
  {
777 778
    error = "Event too big";
    goto err;
unknown's avatar
unknown committed
779 780
  }

781
  if (data_len < header_size)
unknown's avatar
unknown committed
782
  {
783 784
    error = "Event too small";
    goto err;
unknown's avatar
unknown committed
785
  }
786 787 788

  // some events use the extra byte to null-terminate strings
  if (!(buf = my_malloc(data_len+1, MYF(MY_WME))))
789 790 791
  {
    error = "Out of memory";
    goto err;
unknown's avatar
unknown committed
792
  }
793
  buf[data_len] = 0;
794
  memcpy(buf, head, header_size);
795
  if (my_b_read(file, (byte*) buf + header_size, data_len - header_size))
796 797 798 799
  {
    error = "read error";
    goto err;
  }
800
  if ((res= read_log_event(buf, data_len, &error, description_event)))
801
    res->register_temp_buf(buf);
802

803
err:
unknown's avatar
unknown committed
804
  UNLOCK_MUTEX;
805
  if (!res)
806
  {
807
    DBUG_ASSERT(error != 0);
808 809
    sql_print_error("Error in Log_event::read_log_event(): "
                    "'%s', data_len: %d, event_type: %d",
810
		    error,data_len,head[EVENT_TYPE_OFFSET]);
811
    my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
812 813 814 815 816 817 818 819 820
    /*
      The SQL slave thread will check if file->error<0 to know
      if there was an I/O error. Even if there is no "low-level" I/O errors
      with 'file', any of the high-level above errors is worrying
      enough to stop the SQL thread now ; as we are skipping the current event,
      going on with reading and successfully executing other events can
      only corrupt the slave's databases. So stop.
    */
    file->error= -1;
821
  }
822
  DBUG_RETURN(res);
unknown's avatar
unknown committed
823 824
}

825

unknown's avatar
unknown committed
826
/*
827
  Log_event::read_log_event()
828 829
  Binlog format tolerance is in (buf, event_len, description_event)
  constructors.
unknown's avatar
unknown committed
830
*/
831

832 833 834
Log_event* Log_event::read_log_event(const char* buf, uint event_len,
				     const char **error,
                                     const Format_description_log_event *description_event)
unknown's avatar
unknown committed
835
{
836 837
  Log_event* ev;
  DBUG_ENTER("Log_event::read_log_event(char*,...)");
838
  DBUG_ASSERT(description_event != 0);
839
  DBUG_PRINT("info", ("binlog_version: %d", description_event->binlog_version));
840
  if (event_len < EVENT_LEN_OFFSET ||
841 842 843
      (uint) event_len != uint4korr(buf+EVENT_LEN_OFFSET))
  {
    *error="Sanity check failed";		// Needed to free buffer
unknown's avatar
unknown committed
844
    DBUG_RETURN(NULL); // general sanity check - will fail on a partial read
845
  }
846

847 848 849
  /* To check the integrity of the Log_event_type enumeration */
  DBUG_ASSERT(buf[EVENT_TYPE_OFFSET] < ENUM_END_EVENT);

850
  switch(buf[EVENT_TYPE_OFFSET]) {
unknown's avatar
unknown committed
851
  case QUERY_EVENT:
unknown's avatar
unknown committed
852
    ev  = new Query_log_event(buf, event_len, description_event, QUERY_EVENT);
853
    break;
unknown's avatar
unknown committed
854
  case LOAD_EVENT:
unknown's avatar
unknown committed
855
    ev = new Load_log_event(buf, event_len, description_event);
unknown's avatar
unknown committed
856
    break;
857
  case NEW_LOAD_EVENT:
858
    ev = new Load_log_event(buf, event_len, description_event);
859
    break;
unknown's avatar
unknown committed
860
  case ROTATE_EVENT:
861
    ev = new Rotate_log_event(buf, event_len, description_event);
862
    break;
unknown's avatar
SCRUM  
unknown committed
863
#ifdef HAVE_REPLICATION
864
  case SLAVE_EVENT: /* can never happen (unused event) */
865 866
    ev = new Slave_log_event(buf, event_len);
    break;
unknown's avatar
SCRUM  
unknown committed
867
#endif /* HAVE_REPLICATION */
868
  case CREATE_FILE_EVENT:
869
    ev = new Create_file_log_event(buf, event_len, description_event);
870 871
    break;
  case APPEND_BLOCK_EVENT:
872
    ev = new Append_block_log_event(buf, event_len, description_event);
873 874
    break;
  case DELETE_FILE_EVENT:
875
    ev = new Delete_file_log_event(buf, event_len, description_event);
876 877
    break;
  case EXEC_LOAD_EVENT:
878
    ev = new Execute_load_log_event(buf, event_len, description_event);
879
    break;
880 881
  case START_EVENT_V3: /* this is sent only by MySQL <=4.x */
    ev = new Start_log_event_v3(buf, description_event);
882 883
    break;
  case STOP_EVENT:
884
    ev = new Stop_log_event(buf, description_event);
885 886
    break;
  case INTVAR_EVENT:
887
    ev = new Intvar_log_event(buf, description_event);
888
    break;
889 890 891
  case XID_EVENT:
    ev = new Xid_log_event(buf, description_event);
    break;
unknown's avatar
unknown committed
892
  case RAND_EVENT:
893
    ev = new Rand_log_event(buf, description_event);
unknown's avatar
unknown committed
894
    break;
unknown's avatar
unknown committed
895
  case USER_VAR_EVENT:
896 897 898 899
    ev = new User_var_log_event(buf, description_event);
    break;
  case FORMAT_DESCRIPTION_EVENT:
    ev = new Format_description_log_event(buf, event_len, description_event); 
unknown's avatar
unknown committed
900
    break;
901 902 903 904 905 906 907 908 909 910 911 912 913 914
#if defined(HAVE_REPLICATION) && defined(HAVE_ROW_BASED_REPLICATION)
  case WRITE_ROWS_EVENT:
    ev = new Write_rows_log_event(buf, event_len, description_event);
    break;
  case UPDATE_ROWS_EVENT:
    ev = new Update_rows_log_event(buf, event_len, description_event);
    break;
  case DELETE_ROWS_EVENT:
    ev = new Delete_rows_log_event(buf, event_len, description_event);
    break;
  case TABLE_MAP_EVENT:
    ev = new Table_map_log_event(buf, event_len, description_event);
    break;
#endif
unknown's avatar
unknown committed
915 916 917 918 919 920
  case BEGIN_LOAD_QUERY_EVENT:
    ev = new Begin_load_query_log_event(buf, event_len, description_event);
    break;
  case EXECUTE_LOAD_QUERY_EVENT:
    ev = new Execute_load_query_log_event(buf, event_len, description_event);
    break;
921
  default:
922 923
    DBUG_PRINT("error",("Unknown evernt code: %d",(int) buf[EVENT_TYPE_OFFSET]));
    ev= NULL;
924
    break;
unknown's avatar
unknown committed
925
  }
926

927
  /*
928 929 930 931 932 933 934
    is_valid() are small event-specific sanity tests which are
    important; for example there are some my_malloc() in constructors
    (e.g. Query_log_event::Query_log_event(char*...)); when these
    my_malloc() fail we can't return an error out of the constructor
    (because constructor is "void") ; so instead we leave the pointer we
    wanted to allocate (e.g. 'query') to 0 and we test it in is_valid().
    Same for Format_description_log_event, member 'post_header_len'.
935
  */
936
  if (!ev || !ev->is_valid())
937
  {
938 939
    DBUG_PRINT("error",("Found invalid event in binary log"));

940
    delete ev;
941
#ifdef MYSQL_CLIENT
942
    if (!force_opt) /* then mysqlbinlog dies */
943 944
    {
      *error= "Found invalid event in binary log";
unknown's avatar
unknown committed
945
      DBUG_RETURN(0);
946
    }
947
    ev= new Unknown_log_event(buf, description_event);
948 949
#else
    *error= "Found invalid event in binary log";
unknown's avatar
unknown committed
950
    DBUG_RETURN(0);
951
#endif
952
  }
unknown's avatar
unknown committed
953
  DBUG_RETURN(ev);  
unknown's avatar
unknown committed
954 955
}

956
#ifdef MYSQL_CLIENT
957

unknown's avatar
unknown committed
958
/*
959
  Log_event::print_header()
unknown's avatar
unknown committed
960
*/
961

unknown's avatar
unknown committed
962
void Log_event::print_header(FILE* file, PRINT_EVENT_INFO* print_event_info)
963
{
964
  char llbuff[22];
unknown's avatar
unknown committed
965
  my_off_t hexdump_from= print_event_info->hexdump_from;
unknown's avatar
unknown committed
966

967 968
  fputc('#', file);
  print_timestamp(file);
969
  fprintf(file, " server id %d  end_log_pos %s ", server_id,
970
	  llstr(log_pos,llbuff));
971

972
  /* mysqlbinlog --hexdump */
unknown's avatar
unknown committed
973
  if (print_event_info->hexdump_from)
974 975
  {
    fprintf(file, "\n");
976 977 978
    uchar *ptr= (uchar*)temp_buf;
    my_off_t size=
      uint4korr(ptr + EVENT_LEN_OFFSET) - LOG_EVENT_MINIMAL_HEADER_LEN;
979 980
    my_off_t i;

981 982 983 984
    /* Header len * 4 >= header len * (2 chars + space + extra space) */
    char *h, hex_string[LOG_EVENT_MINIMAL_HEADER_LEN*4]= {0};
    char *c, char_string[16+1]= {0};

unknown's avatar
unknown committed
985
    /* Pretty-print event common header if header is exactly 19 bytes */
unknown's avatar
unknown committed
986
    if (print_event_info->common_header_len == LOG_EVENT_MINIMAL_HEADER_LEN)
unknown's avatar
unknown committed
987 988 989 990 991 992
    {
      fprintf(file, "# Position  Timestamp   Type   Master ID        "
	      "Size      Master Pos    Flags \n");
      fprintf(file, "# %8.8lx %02x %02x %02x %02x   %02x   "
	      "%02x %02x %02x %02x   %02x %02x %02x %02x   "
	      "%02x %02x %02x %02x   %02x %02x\n",
993 994 995 996
	      (unsigned long) hexdump_from,
              ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6],
              ptr[7], ptr[8], ptr[9], ptr[10], ptr[11], ptr[12], ptr[13],
              ptr[14], ptr[15], ptr[16], ptr[17], ptr[18]);
unknown's avatar
unknown committed
997 998 999
      ptr += LOG_EVENT_MINIMAL_HEADER_LEN;
      hexdump_from += LOG_EVENT_MINIMAL_HEADER_LEN;
    }
1000 1001 1002 1003 1004

    /* Rest of event (without common header) */
    for (i= 0, c= char_string, h=hex_string;
	 i < size;
	 i++, ptr++)
1005
    {
1006 1007
      my_snprintf(h, 4, "%02x ", *ptr);
      h += 3;
1008

1009
      *c++= my_isalnum(&my_charset_bin, *ptr) ? *ptr : '.';
1010 1011 1012

      if (i % 16 == 15)
      {
1013
	fprintf(file, "# %8.8lx %-48.48s |%16s|\n",
1014 1015
		(unsigned long) (hexdump_from + (i & 0xfffffff0)),
                hex_string, char_string);
1016 1017 1018 1019
	hex_string[0]= 0;
	char_string[0]= 0;
	c= char_string;
	h= hex_string;
1020
      }
1021
      else if (i % 8 == 7) *h++ = ' ';
1022
    }
1023
    *c= '\0';
1024

1025
    /* Non-full last line */
unknown's avatar
unknown committed
1026
    if (hex_string[0])
1027 1028 1029
      fprintf(file, "# %8.8lx %-48.48s |%s|\n# ",
	     (unsigned long) (hexdump_from + (i & 0xfffffff0)),
             hex_string, char_string);
1030
  }
1031 1032
}

1033

1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
void Log_event::print_base64(FILE* file, PRINT_EVENT_INFO* print_event_info)
{
  uchar *ptr= (uchar*)temp_buf;
  my_off_t size= uint4korr(ptr + EVENT_LEN_OFFSET);

  char *tmp_str=
    (char *) my_malloc(base64_needed_encoded_length(size), MYF(MY_WME));
  if (!tmp_str) {
    fprintf(stderr, "\nError: Out of memory. "
            "Could not print correct binlog event.\n");
    return;
  }
  int res= base64_encode(ptr, size, tmp_str);
  fprintf(file, "\nBINLOG '\n%s\n';\n", tmp_str);
  my_free(tmp_str, MYF(0));
}


unknown's avatar
unknown committed
1052
/*
1053
  Log_event::print_timestamp()
unknown's avatar
unknown committed
1054
*/
1055

1056
void Log_event::print_timestamp(FILE* file, time_t* ts)
unknown's avatar
unknown committed
1057
{
unknown's avatar
unknown committed
1058
  struct tm *res;
1059 1060
  if (!ts)
    ts = &when;
1061 1062
#ifdef MYSQL_SERVER				// This is always false
  struct tm tm_tmp;
unknown's avatar
unknown committed
1063
  localtime_r(ts,(res= &tm_tmp));
unknown's avatar
unknown committed
1064
#else
1065
  res=localtime(ts);
unknown's avatar
unknown committed
1066
#endif
1067 1068

  fprintf(file,"%02d%02d%02d %2d:%02d:%02d",
1069 1070 1071 1072 1073 1074
	  res->tm_year % 100,
	  res->tm_mon+1,
	  res->tm_mday,
	  res->tm_hour,
	  res->tm_min,
	  res->tm_sec);
unknown's avatar
unknown committed
1075 1076
}

unknown's avatar
unknown committed
1077
#endif /* MYSQL_CLIENT */
unknown's avatar
unknown committed
1078 1079


unknown's avatar
unknown committed
1080
/**************************************************************************
unknown's avatar
unknown committed
1081
	Query_log_event methods
unknown's avatar
unknown committed
1082
**************************************************************************/
1083

unknown's avatar
SCRUM  
unknown committed
1084
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
1085

unknown's avatar
unknown committed
1086
/*
1087
  Query_log_event::pack_info()
1088 1089 1090 1091
  This (which is used only for SHOW BINLOG EVENTS) could be updated to
  print SET @@session_var=. But this is not urgent, as SHOW BINLOG EVENTS is
  only an information, it does not produce suitable queries to replay (for
  example it does not print LOAD DATA INFILE).
unknown's avatar
unknown committed
1092
*/
1093

1094
void Query_log_event::pack_info(Protocol *protocol)
unknown's avatar
unknown committed
1095
{
1096
  // TODO: show the catalog ??
1097 1098 1099
  char *buf, *pos;
  if (!(buf= my_malloc(9 + db_len + q_len, MYF(MY_WME))))
    return;
1100 1101
  pos= buf;
  if (!(flags & LOG_EVENT_SUPPRESS_USE_F)
1102
      && db && db_len)
1103
  {
1104 1105
    pos= strmov(buf, "use `");
    memcpy(pos, db, db_len);
unknown's avatar
unknown committed
1106
    pos= strmov(pos+db_len, "`; ");
1107
  }
1108
  if (query && q_len)
1109 1110 1111 1112
  {
    memcpy(pos, query, q_len);
    pos+= q_len;
  }
1113
  protocol->store(buf, pos-buf, &my_charset_bin);
1114
  my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
1115
}
unknown's avatar
SCRUM  
unknown committed
1116
#endif
1117

1118
#ifndef MYSQL_CLIENT
1119

1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
/* Utility function for the next method */
static void write_str_with_code_and_len(char **dst, const char *src,
                                        int len, uint code)
{
  DBUG_ASSERT(src);
  *((*dst)++)= code;
  *((*dst)++)= (uchar) len;
  bmove(*dst, src, len);
  (*dst)+= len;
}


unknown's avatar
unknown committed
1132
/*
1133
  Query_log_event::write()
unknown's avatar
unknown committed
1134

1135 1136 1137 1138
  NOTES:
    In this event we have to modify the header to have the correct
    EVENT_LEN_OFFSET as we don't yet know how many status variables we
    will print!
unknown's avatar
unknown committed
1139
*/
1140

1141
bool Query_log_event::write(IO_CACHE* file)
unknown's avatar
unknown committed
1142
{
1143 1144 1145 1146 1147
  uchar buf[QUERY_HEADER_LEN+
            1+4+           // code of flags2 and flags2
            1+8+           // code of sql_mode and sql_mode
            1+1+FN_REFLEN+ // code of catalog and catalog length and catalog
            1+4+           // code of autoinc and the 2 autoinc variables
1148 1149
            1+6+           // code of charset and charset
            1+1+MAX_TIME_ZONE_NAME_LENGTH // code of tz and tz length and tz name
1150
            ], *start, *start_of_status;
1151
  ulong event_length;
unknown's avatar
unknown committed
1152

1153
  if (!query)
1154 1155
    return 1;                                   // Something wrong with event

unknown's avatar
unknown committed
1156 1157 1158 1159 1160
  /*
    We want to store the thread id:
    (- as an information for the user when he reads the binlog)
    - if the query uses temporary table: for the slave SQL thread to know to
    which master connection the temp table belongs.
1161
    Now imagine we (write()) are called by the slave SQL thread (we are
unknown's avatar
unknown committed
1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
    logging a query executed by this thread; the slave runs with
    --log-slave-updates). Then this query will be logged with
    thread_id=the_thread_id_of_the_SQL_thread. Imagine that 2 temp tables of
    the same name were created simultaneously on the master (in the master
    binlog you have
    CREATE TEMPORARY TABLE t; (thread 1)
    CREATE TEMPORARY TABLE t; (thread 2)
    ...)
    then in the slave's binlog there will be
    CREATE TEMPORARY TABLE t; (thread_id_of_the_slave_SQL_thread)
    CREATE TEMPORARY TABLE t; (thread_id_of_the_slave_SQL_thread)
    which is bad (same thread id!).

    To avoid this, we log the thread's thread id EXCEPT for the SQL
    slave thread for which we log the original (master's) thread id.
    Now this moves the bug: what happens if the thread id on the
    master was 10 and when the slave replicates the query, a
    connection number 10 is opened by a normal client on the slave,
    and updates a temp table of the same name? We get a problem
    again. To avoid this, in the handling of temp tables (sql_base.cc)
    we use thread_id AND server_id.  TODO when this is merged into
    4.1: in 4.1, slave_proxy_id has been renamed to pseudo_thread_id
    and is a session variable: that's to make mysqlbinlog work with
    temp tables. We probably need to introduce

    SET PSEUDO_SERVER_ID
    for mysqlbinlog in 4.1. mysqlbinlog would print:
    SET PSEUDO_SERVER_ID=
    SET PSEUDO_THREAD_ID=
    for each query using temp tables.
  */
  int4store(buf + Q_THREAD_ID_OFFSET, slave_proxy_id);
1194 1195 1196 1197
  int4store(buf + Q_EXEC_TIME_OFFSET, exec_time);
  buf[Q_DB_LEN_OFFSET] = (char) db_len;
  int2store(buf + Q_ERR_CODE_OFFSET, error_code);

1198 1199 1200 1201 1202 1203 1204 1205
  /*
    You MUST always write status vars in increasing order of code. This
    guarantees that a slightly older slave will be able to parse those he
    knows.
  */
  start_of_status= start= buf+QUERY_HEADER_LEN;
  if (flags2_inited)
  {
1206
    *start++= Q_FLAGS2_CODE;
1207 1208 1209 1210 1211
    int4store(start, flags2);
    start+= 4;
  }
  if (sql_mode_inited)
  {
1212
    *start++= Q_SQL_MODE_CODE;
unknown's avatar
unknown committed
1213
    int8store(start, (ulonglong)sql_mode);
1214 1215
    start+= 8;
  }
1216
  if (catalog_len) // i.e. this var is inited (false for 4.0 events)
1217
  {
1218 1219
    write_str_with_code_and_len((char **)(&start),
                                catalog, catalog_len, Q_CATALOG_NZ_CODE);
1220
    /*
1221 1222 1223 1224 1225 1226
      In 5.0.x where x<4 masters we used to store the end zero here. This was
      a waste of one byte so we don't do it in x>=4 masters. We change code to
      Q_CATALOG_NZ_CODE, because re-using the old code would make x<4 slaves
      of this x>=4 master segfault (expecting a zero when there is
      none). Remaining compatibility problems are: the older slave will not
      find the catalog; but it is will not crash, and it's not an issue
1227 1228 1229 1230 1231
      that it does not find the catalog as catalogs were not used in these
      older MySQL versions (we store it in binlog and read it from relay log
      but do nothing useful with it). What is an issue is that the older slave
      will stop processing the Q_* blocks (and jumps to the db/query) as soon
      as it sees unknown Q_CATALOG_NZ_CODE; so it will not be able to read
1232 1233
      Q_AUTO_INCREMENT*, Q_CHARSET and so replication will fail silently in
      various ways. Documented that you should not mix alpha/beta versions if
1234 1235 1236
      they are not exactly the same version, with example of 5.0.3->5.0.2 and
      5.0.4->5.0.3. If replication is from older to new, the new will
      recognize Q_CATALOG_CODE and have no problem.
1237 1238 1239 1240 1241 1242 1243 1244 1245
    */
  }
  if (auto_increment_increment != 1)
  {
    *start++= Q_AUTO_INCREMENT;
    int2store(start, auto_increment_increment);
    int2store(start+2, auto_increment_offset);
    start+= 4;
  }
1246 1247
  if (charset_inited)
  {
1248
    *start++= Q_CHARSET_CODE;
1249 1250 1251
    memcpy(start, charset, 6);
    start+= 6;
  }
1252 1253 1254 1255 1256 1257 1258 1259 1260
  if (time_zone_len)
  {
    /* In the TZ sys table, column Name is of length 64 so this should be ok */
    DBUG_ASSERT(time_zone_len <= MAX_TIME_ZONE_NAME_LENGTH);
    *start++= Q_TIME_ZONE_CODE;
    *start++= time_zone_len;
    memcpy(start, time_zone_str, time_zone_len);
    start+= time_zone_len;
  }
1261 1262
  /*
    Here there could be code like
1263
    if (command-line-option-which-says-"log_this_variable" && inited)
1264
    {
1265
    *start++= Q_THIS_VARIABLE_CODE;
1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278
    int4store(start, this_variable);
    start+= 4;
    }
  */
  
  /* Store length of status variables */
  status_vars_len= (uint) (start-start_of_status);
  int2store(buf + Q_STATUS_VARS_LEN_OFFSET, status_vars_len);

  /*
    Calculate length of whole event
    The "1" below is the \0 in the db's length
  */
unknown's avatar
unknown committed
1279
  event_length= (uint) (start-buf) + get_post_header_size_for_derived() + db_len + 1 + q_len;
1280 1281

  return (write_header(file, event_length) ||
unknown's avatar
unknown committed
1282 1283 1284 1285
          my_b_safe_write(file, (byte*) buf, QUERY_HEADER_LEN) ||
          write_post_header_for_derived(file) ||
          my_b_safe_write(file, (byte*) start_of_status,
                          (uint) (start-start_of_status)) ||
1286 1287
          my_b_safe_write(file, (db) ? (byte*) db : (byte*)"", db_len + 1) ||
          my_b_safe_write(file, (byte*) query, q_len)) ? 1 : 0;
unknown's avatar
unknown committed
1288 1289
}

1290

unknown's avatar
unknown committed
1291
/*
1292
  Query_log_event::Query_log_event()
unknown's avatar
unknown committed
1293
*/
1294
Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
1295 1296
				 ulong query_length, bool using_trans,
				 bool suppress_use)
1297
  :Log_event(thd_arg,
1298 1299 1300
	     ((thd_arg->tmp_table_used ? LOG_EVENT_THREAD_SPECIFIC_F : 0)
	      | (suppress_use          ? LOG_EVENT_SUPPRESS_USE_F    : 0)),
	     using_trans),
1301
   data_buf(0), query(query_arg), catalog(thd_arg->catalog),
1302
   db(thd_arg->db), q_len((uint32) query_length),
1303
   error_code((thd_arg->killed != THD::NOT_KILLED) ?
1304
              ((thd_arg->system_thread & SYSTEM_THREAD_DELAYED_INSERT) ?
1305
               0 : thd->killed_errno()) : thd_arg->net.last_errno),
unknown's avatar
unknown committed
1306 1307
   thread_id(thd_arg->thread_id),
   /* save the original thread id; we already know the server id */
1308
   slave_proxy_id(thd_arg->variables.pseudo_thread_id),
1309
   flags2_inited(1), sql_mode_inited(1), charset_inited(1),
1310 1311 1312
   sql_mode(thd_arg->variables.sql_mode),
   auto_increment_increment(thd_arg->variables.auto_increment_increment),
   auto_increment_offset(thd_arg->variables.auto_increment_offset)
1313 1314 1315 1316
{
  time_t end_time;
  time(&end_time);
  exec_time = (ulong) (end_time  - thd->start_time);
1317
  catalog_len = (catalog) ? (uint32) strlen(catalog) : 0;
1318
  /* status_vars_len is set just before writing the event */
1319
  db_len = (db) ? (uint32) strlen(db) : 0;
1320 1321 1322 1323 1324 1325 1326
  /*
    If we don't use flags2 for anything else than options contained in
    thd->options, it would be more efficient to flags2=thd_arg->options
    (OPTIONS_WRITTEN_TO_BINLOG would be used only at reading time).
    But it's likely that we don't want to use 32 bits for 3 bits; in the future
    we will probably want to reclaim the 29 bits. So we need the &.
  */
unknown's avatar
unknown committed
1327
  flags2= (uint32) (thd_arg->options & OPTIONS_WRITTEN_TO_BIN_LOG);
1328 1329 1330 1331 1332 1333
  DBUG_ASSERT(thd->variables.character_set_client->number < 256*256);
  DBUG_ASSERT(thd->variables.collation_connection->number < 256*256);
  DBUG_ASSERT(thd->variables.collation_server->number < 256*256);
  int2store(charset, thd_arg->variables.character_set_client->number);
  int2store(charset+2, thd_arg->variables.collation_connection->number);
  int2store(charset+4, thd_arg->variables.collation_server->number);
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345
  if (thd_arg->time_zone_used)
  {
    /*
      Note that our event becomes dependent on the Time_zone object
      representing the time zone. Fortunately such objects are never deleted
      or changed during mysqld's lifetime.
    */
    time_zone_len= thd_arg->variables.time_zone->get_name()->length();
    time_zone_str= thd_arg->variables.time_zone->get_name()->ptr();
  }
  else
    time_zone_len= 0;
1346
  DBUG_PRINT("info",("Query_log_event has flags2=%lu sql_mode=%lu",flags2,sql_mode));
1347
}
unknown's avatar
unknown committed
1348
#endif /* MYSQL_CLIENT */
1349

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
/* 2 utility functions for the next method */

static void get_str_len_and_pointer(const char **dst, const char **src, uint *len)
{
  if ((*len= **src))
    *dst= *src + 1;                          // Will be copied later
  (*src)+= *len+1;
}


static void copy_str_and_move(char **dst, const char **src, uint len)
{
  memcpy(*dst, *src, len);
  *src= *dst;
  (*dst)+= len;
  *(*dst)++= 0;
}


unknown's avatar
unknown committed
1370
/*
1371
  Query_log_event::Query_log_event()
1372
  This is used by the SQL slave thread to prepare the event before execution.
unknown's avatar
unknown committed
1373
*/
1374

1375
Query_log_event::Query_log_event(const char* buf, uint event_len,
unknown's avatar
unknown committed
1376 1377
                                 const Format_description_log_event *description_event,
                                 Log_event_type event_type)
1378
  :Log_event(buf, description_event), data_buf(0), query(NullS),
1379
   db(NullS), catalog_len(0), status_vars_len(0),
1380
   flags2_inited(0), sql_mode_inited(0), charset_inited(0),
1381 1382
   auto_increment_increment(1), auto_increment_offset(1),
   time_zone_len(0)
unknown's avatar
unknown committed
1383 1384
{
  ulong data_len;
1385 1386
  uint32 tmp;
  uint8 common_header_len, post_header_len;
1387 1388
  char *start;
  const char *end;
1389
  bool catalog_nz= 1;
1390 1391 1392
  DBUG_ENTER("Query_log_event::Query_log_event(char*,...)");

  common_header_len= description_event->common_header_len;
unknown's avatar
unknown committed
1393
  post_header_len= description_event->post_header_len[event_type-1];
1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408
  DBUG_PRINT("info",("event_len=%ld, common_header_len=%d, post_header_len=%d",
                     event_len, common_header_len, post_header_len));
  
  /*
    We test if the event's length is sensible, and if so we compute data_len.
    We cannot rely on QUERY_HEADER_LEN here as it would not be format-tolerant.
    We use QUERY_HEADER_MINIMAL_LEN which is the same for 3.23, 4.0 & 5.0.
  */
  if (event_len < (uint)(common_header_len + post_header_len))
    DBUG_VOID_RETURN;				
  data_len = event_len - (common_header_len + post_header_len);
  buf+= common_header_len;
  
  slave_proxy_id= thread_id = uint4korr(buf + Q_THREAD_ID_OFFSET);
  exec_time = uint4korr(buf + Q_EXEC_TIME_OFFSET);
1409
  db_len = (uint)buf[Q_DB_LEN_OFFSET]; // TODO: add a check of all *_len vars
1410 1411 1412 1413 1414 1415 1416 1417 1418
  error_code = uint2korr(buf + Q_ERR_CODE_OFFSET);

  /*
    5.0 format starts here.
    Depending on the format, we may or not have affected/warnings etc
    The remnent post-header to be parsed has length:
  */
  tmp= post_header_len - QUERY_HEADER_MINIMAL_LEN; 
  if (tmp)
1419
  {
1420 1421 1422 1423 1424
    status_vars_len= uint2korr(buf + Q_STATUS_VARS_LEN_OFFSET);
    data_len-= status_vars_len;
    DBUG_PRINT("info", ("Query_log_event has status_vars_len: %u",
                        (uint) status_vars_len));
    tmp-= 2;
1425
  }
unknown's avatar
unknown committed
1426 1427 1428 1429 1430 1431
  /*
    We have parsed everything we know in the post header for QUERY_EVENT,
    the rest of post header is either comes from older version MySQL or
    dedicated to derived events (e.g. Execute_load_query...)
  */

1432 1433 1434
  /* variable-part: the status vars; only in MySQL 5.0  */
  
  start= (char*) (buf+post_header_len);
1435
  end= (const char*) (start+status_vars_len);
1436
  for (const uchar* pos= (const uchar*) start; pos < (const uchar*) end;)
1437
  {
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456
    switch (*pos++) {
    case Q_FLAGS2_CODE:
      flags2_inited= 1;
      flags2= uint4korr(pos);
      DBUG_PRINT("info",("In Query_log_event, read flags2: %lu", flags2));
      pos+= 4;
      break;
    case Q_SQL_MODE_CODE:
    {
#ifndef DBUG_OFF
      char buff[22];
#endif
      sql_mode_inited= 1;
      sql_mode= (ulong) uint8korr(pos); // QQ: Fix when sql_mode is ulonglong
      DBUG_PRINT("info",("In Query_log_event, read sql_mode: %s",
			 llstr(sql_mode, buff)));
      pos+= 8;
      break;
    }
1457
    case Q_CATALOG_NZ_CODE:
1458
      get_str_len_and_pointer(&catalog, (const char **)(&pos), &catalog_len);
1459 1460 1461 1462 1463 1464
      break;
    case Q_AUTO_INCREMENT:
      auto_increment_increment= uint2korr(pos);
      auto_increment_offset=    uint2korr(pos+2);
      pos+= 4;
      break;
1465 1466 1467 1468 1469 1470 1471
    case Q_CHARSET_CODE:
    {
      charset_inited= 1;
      memcpy(charset, pos, 6);
      pos+= 6;
      break;
    }
1472 1473
    case Q_TIME_ZONE_CODE:
    {
1474
      get_str_len_and_pointer(&time_zone_str, (const char **)(&pos), &time_zone_len);
1475 1476
      break;
    }
1477 1478 1479 1480 1481 1482
    case Q_CATALOG_CODE: /* for 5.0.x where 0<=x<=3 masters */
      if ((catalog_len= *pos))
        catalog= (char*) pos+1;                           // Will be copied later
      pos+= catalog_len+2; // leap over end 0
      catalog_nz= 0; // catalog has end 0 in event
      break;
1483 1484 1485 1486
    default:
      /* That's why you must write status vars in growing order of code */
      DBUG_PRINT("info",("Query_log_event has unknown status vars (first has\
 code: %u), skipping the rest of them", (uint) *(pos-1)));
1487
      pos= (const uchar*) end;                         // Break loop
1488
    }
1489
  }
1490
  
1491
#if !defined(MYSQL_CLIENT) && defined(HAVE_QUERY_CACHE)
1492 1493
  if (!(start= data_buf = (char*) my_malloc(catalog_len + 1 +
                                            time_zone_len + 1 +
1494 1495 1496 1497 1498 1499 1500 1501 1502
                                            data_len + 1 +
					    QUERY_CACHE_FLAGS_SIZE +
					    db_len + 1,
					    MYF(MY_WME))))
#else
  if (!(start= data_buf = (char*) my_malloc(catalog_len + 1 +
                                            time_zone_len + 1 +
                                            data_len + 1,
					    MYF(MY_WME))))
1503
#endif
unknown's avatar
unknown committed
1504
      DBUG_VOID_RETURN;
1505
  if (catalog_len)                                  // If catalog is given
1506
  {
1507
    if (likely(catalog_nz)) // true except if event comes from 5.0.0|1|2|3.
1508
      copy_str_and_move(&start, &catalog, catalog_len);
1509 1510 1511 1512 1513 1514
    else
    {
      memcpy(start, catalog, catalog_len+1); // copy end 0
      catalog= start;
      start+= catalog_len+1;
    }
1515
  }
1516
  if (time_zone_len)
1517 1518
    copy_str_and_move(&start, &time_zone_str, time_zone_len);

1519
  /* A 2nd variable part; this is common to all versions */ 
1520
  memcpy((char*) start, end, data_len);          // Copy db and query
1521
  start[data_len]= '\0';              // End query with \0 (For safetly)
1522 1523 1524 1525
  db= start;
  query= start + db_len + 1;
  q_len= data_len - db_len -1;
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1526 1527
}

1528

unknown's avatar
unknown committed
1529
/*
1530
  Query_log_event::print()
unknown's avatar
unknown committed
1531
*/
1532

1533
#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
1534
void Query_log_event::print_query_header(FILE* file,
unknown's avatar
unknown committed
1535
					 PRINT_EVENT_INFO* print_event_info)
unknown's avatar
unknown committed
1536
{
1537
  // TODO: print the catalog ??
1538
  char buff[40],*end;				// Enough for SET TIMESTAMP
1539 1540 1541
  bool different_db= 1;
  uint32 tmp;

unknown's avatar
unknown committed
1542
  if (!print_event_info->short_form)
unknown's avatar
unknown committed
1543
  {
unknown's avatar
unknown committed
1544
    print_header(file, print_event_info);
unknown's avatar
unknown committed
1545 1546
    fprintf(file, "\t%s\tthread_id=%lu\texec_time=%lu\terror_code=%d\n",
	    get_type_str(), (ulong) thread_id, (ulong) exec_time, error_code);
unknown's avatar
unknown committed
1547 1548
  }

unknown's avatar
unknown committed
1549
  if (!(flags & LOG_EVENT_SUPPRESS_USE_F) && db)
1550
  {
unknown's avatar
unknown committed
1551 1552
    if (different_db= memcmp(print_event_info->db, db, db_len + 1))
      memcpy(print_event_info->db, db, db_len + 1);
unknown's avatar
unknown committed
1553
    if (db[0] && different_db) 
1554
      fprintf(file, "use %s;\n", db);
1555
  }
1556

1557 1558 1559 1560
  end=int10_to_str((long) when, strmov(buff,"SET TIMESTAMP="),10);
  *end++=';';
  *end++='\n';
  my_fwrite(file, (byte*) buff, (uint) (end-buff),MYF(MY_NABP | MY_WME));
unknown's avatar
unknown committed
1561 1562
  if (flags & LOG_EVENT_THREAD_SPECIFIC_F)
    fprintf(file,"SET @@session.pseudo_thread_id=%lu;\n",(ulong)thread_id);
1563

1564
  /*
1565 1566 1567
    If flags2_inited==0, this is an event from 3.23 or 4.0; nothing to
    print (remember we don't produce mixed relay logs so there cannot be
    5.0 events before that one so there is nothing to reset).
1568 1569 1570 1571
  */
  if (likely(flags2_inited)) /* likely as this will mainly read 5.0 logs */
  {
    /* tmp is a bitmask of bits which have changed. */
unknown's avatar
unknown committed
1572
    if (likely(print_event_info->flags2_inited)) 
1573
      /* All bits which have changed */
unknown's avatar
unknown committed
1574
      tmp= (print_event_info->flags2) ^ flags2;
1575 1576
    else /* that's the first Query event we read */
    {
unknown's avatar
unknown committed
1577
      print_event_info->flags2_inited= 1;
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
      tmp= ~((uint32)0); /* all bits have changed */
    }

    if (unlikely(tmp)) /* some bits have changed */
    {
      bool need_comma= 0;
      fprintf(file, "SET ");
      print_set_option(file, tmp, OPTION_NO_FOREIGN_KEY_CHECKS, ~flags2,
                   "@@session.foreign_key_checks", &need_comma);
      print_set_option(file, tmp, OPTION_AUTO_IS_NULL, flags2,
                   "@@session.sql_auto_is_null", &need_comma);
      print_set_option(file, tmp, OPTION_RELAXED_UNIQUE_CHECKS, ~flags2,
                   "@@session.unique_checks", &need_comma);
      fprintf(file,";\n");
unknown's avatar
unknown committed
1592
      print_event_info->flags2= flags2;
1593 1594 1595 1596
    }
  }

  /*
1597 1598 1599 1600 1601 1602 1603 1604 1605 1606
    Now the session variables;
    it's more efficient to pass SQL_MODE as a number instead of a
    comma-separated list.
    FOREIGN_KEY_CHECKS, SQL_AUTO_IS_NULL, UNIQUE_CHECKS are session-only
    variables (they have no global version; they're not listed in
    sql_class.h), The tests below work for pure binlogs or pure relay
    logs. Won't work for mixed relay logs but we don't create mixed
    relay logs (that is, there is no relay log with a format change
    except within the 3 first events, which mysqlbinlog handles
    gracefully). So this code should always be good.
1607 1608 1609 1610
  */

  if (likely(sql_mode_inited))
  {
unknown's avatar
unknown committed
1611
    if (unlikely(!print_event_info->sql_mode_inited)) /* first Query event */
1612
    {
unknown's avatar
unknown committed
1613
      print_event_info->sql_mode_inited= 1;
1614
      /* force a difference to force write */
unknown's avatar
unknown committed
1615
      print_event_info->sql_mode= ~sql_mode;
1616
    }
unknown's avatar
unknown committed
1617
    if (unlikely(print_event_info->sql_mode != sql_mode))
1618 1619
    {
      fprintf(file,"SET @@session.sql_mode=%lu;\n",(ulong)sql_mode);
unknown's avatar
unknown committed
1620
      print_event_info->sql_mode= sql_mode;
1621 1622
    }
  }
unknown's avatar
unknown committed
1623 1624
  if (print_event_info->auto_increment_increment != auto_increment_increment ||
      print_event_info->auto_increment_offset != auto_increment_offset)
1625 1626 1627
  {
    fprintf(file,"SET @@session.auto_increment_increment=%lu, @@session.auto_increment_offset=%lu;\n",
            auto_increment_increment,auto_increment_offset);
unknown's avatar
unknown committed
1628 1629
    print_event_info->auto_increment_increment= auto_increment_increment;
    print_event_info->auto_increment_offset=    auto_increment_offset;
1630 1631
  }

1632 1633
  /* TODO: print the catalog when we feature SET CATALOG */

1634 1635
  if (likely(charset_inited))
  {
unknown's avatar
unknown committed
1636
    if (unlikely(!print_event_info->charset_inited)) /* first Query event */
1637
    {
unknown's avatar
unknown committed
1638 1639
      print_event_info->charset_inited= 1;
      print_event_info->charset[0]= ~charset[0]; // force a difference to force write
1640
    }
unknown's avatar
unknown committed
1641
    if (unlikely(bcmp(print_event_info->charset, charset, 6)))
1642
    {
1643 1644 1645 1646 1647
      CHARSET_INFO *cs_info= get_charset(uint2korr(charset), MYF(MY_WME));
      if (cs_info)
      {
        fprintf(file, "/*!\\C %s */;\n", cs_info->csname); /* for mysql client */
      }
1648 1649 1650 1651 1652 1653 1654 1655
      fprintf(file,"SET "
              "@@session.character_set_client=%d,"
              "@@session.collation_connection=%d,"
              "@@session.collation_server=%d"
              ";\n",
              uint2korr(charset),
              uint2korr(charset+2),
              uint2korr(charset+4));
unknown's avatar
unknown committed
1656
      memcpy(print_event_info->charset, charset, 6);
1657 1658
    }
  }
1659 1660
  if (time_zone_len)
  {
unknown's avatar
unknown committed
1661
    if (bcmp(print_event_info->time_zone_str, time_zone_str, time_zone_len+1))
1662 1663
    {
      fprintf(file,"SET @@session.time_zone='%s';\n", time_zone_str);
unknown's avatar
unknown committed
1664
      memcpy(print_event_info->time_zone_str, time_zone_str, time_zone_len+1);
1665 1666
    }
  }
unknown's avatar
unknown committed
1667 1668
}

1669

unknown's avatar
unknown committed
1670
void Query_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
unknown's avatar
unknown committed
1671
{
unknown's avatar
unknown committed
1672
  print_query_header(file, print_event_info);
unknown's avatar
unknown committed
1673
  my_fwrite(file, (byte*) query, q_len, MYF(MY_NABP | MY_WME));
1674
  fputs(";\n", file);
unknown's avatar
unknown committed
1675
}
unknown's avatar
unknown committed
1676
#endif /* MYSQL_CLIENT */
1677

unknown's avatar
unknown committed
1678

unknown's avatar
unknown committed
1679
/*
1680
  Query_log_event::exec_event()
unknown's avatar
unknown committed
1681
*/
unknown's avatar
unknown committed
1682

unknown's avatar
SCRUM  
unknown committed
1683
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
1684
int Query_log_event::exec_event(struct st_relay_log_info* rli)
unknown's avatar
unknown committed
1685 1686 1687 1688 1689 1690
{
  return exec_event(rli, query, q_len);
}


int Query_log_event::exec_event(struct st_relay_log_info* rli, const char *query_arg, uint32 q_len_arg)
unknown's avatar
unknown committed
1691
{
unknown's avatar
unknown committed
1692
  int expected_error,actual_error= 0;
1693 1694 1695 1696 1697 1698
  /*
    Colleagues: please never free(thd->catalog) in MySQL. This would lead to
    bugs as here thd->catalog is a part of an alloced block, not an entire
    alloced block (see Query_log_event::exec_event()). Same for thd->db.
    Thank you.
  */
1699
  thd->catalog= catalog_len ? (char *) catalog : (char *)"";
unknown's avatar
unknown committed
1700
  thd->db_length= db_len;
1701
  thd->db= (char *) rpl_filter->get_rewrite_db(db, &thd->db_length);
1702 1703
  thd->variables.auto_increment_increment= auto_increment_increment;
  thd->variables.auto_increment_offset=    auto_increment_offset;
unknown's avatar
unknown committed
1704

1705
  /*
1706 1707 1708 1709 1710 1711 1712 1713
    InnoDB internally stores the master log position it has executed so far,
    i.e. the position just after the COMMIT event.
    When InnoDB will want to store, the positions in rli won't have
    been updated yet, so group_master_log_* will point to old BEGIN
    and event_master_log* will point to the beginning of current COMMIT.
    But log_pos of the COMMIT Query event is what we want, i.e. the pos of the
    END of the current log event (COMMIT). We save it in rli so that InnoDB can
    access it.
1714
  */
unknown's avatar
unknown committed
1715
  rli->future_group_master_log_pos= log_pos;
1716 1717
  DBUG_PRINT("info", ("log_pos: %lu", (ulong) log_pos));

unknown's avatar
unknown committed
1718
  clear_all_errors(thd, rli);
1719
  rli->clear_tables_to_lock();
1720

unknown's avatar
unknown committed
1721 1722 1723 1724 1725 1726 1727 1728 1729 1730
  /*
    Note:   We do not need to execute reset_one_shot_variables() if this
            db_ok() test fails.
    Reason: The db stored in binlog events is the same for SET and for
            its companion query.  If the SET is ignored because of
            db_ok(), the companion query will also be ignored, and if
            the companion query is ignored in the db_ok() test of
            ::exec_event(), then the companion SET also have so we
            don't need to reset_one_shot_variables().
  */
1731
  if (rpl_filter->db_ok(thd->db))
1732 1733
  {
    thd->set_time((time_t)when);
unknown's avatar
unknown committed
1734 1735
    thd->query_length= q_len_arg;
    thd->query= (char*)query_arg;
unknown's avatar
unknown committed
1736
    VOID(pthread_mutex_lock(&LOCK_thread_count));
1737
    thd->query_id = next_query_id();
1738
    VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1739
    thd->variables.pseudo_thread_id= thread_id;		// for temp tables
unknown's avatar
unknown committed
1740
    DBUG_PRINT("query",("%s",thd->query));
1741

unknown's avatar
unknown committed
1742
    if (ignored_error_code((expected_error= error_code)) ||
1743
	!check_expected_error(thd,rli,expected_error))
1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
    {
      if (flags2_inited)
        /*
          all bits of thd->options which are 1 in OPTIONS_WRITTEN_TO_BIN_LOG must
          take their value from flags2.
        */
        thd->options= flags2|(thd->options & ~(ulong)OPTIONS_WRITTEN_TO_BIN_LOG);
      /*
        else, we are in a 3.23/4.0 binlog; we previously received a
        Rotate_log_event which reset thd->options and sql_mode etc, so nothing to do.
      */
      /*
        We do not replicate IGNORE_DIR_IN_CREATE. That is, if the master is a
        slave which runs with SQL_MODE=IGNORE_DIR_IN_CREATE, this should not
        force us to ignore the dir too. Imagine you are a ring of machines, and
        one has a disk problem so that you temporarily need IGNORE_DIR_IN_CREATE
        on this machine; you don't want it to propagate elsewhere (you don't want
        all slaves to start ignoring the dirs).
      */
      if (sql_mode_inited)
        thd->variables.sql_mode=
          (ulong) ((thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE) |
                   (sql_mode & ~(ulong) MODE_NO_DIR_IN_CREATE));
      if (charset_inited)
      {
        if (rli->cached_charset_compare(charset))
        {
          /* Verify that we support the charsets found in the event. */
          if (!(thd->variables.character_set_client=
                get_charset(uint2korr(charset), MYF(MY_WME))) ||
              !(thd->variables.collation_connection=
                get_charset(uint2korr(charset+2), MYF(MY_WME))) ||
              !(thd->variables.collation_server=
                get_charset(uint2korr(charset+4), MYF(MY_WME))))
          {
            /*
1780 1781 1782 1783
              We updated the thd->variables with nonsensical values (0). Let's
              set them to something safe (i.e. which avoids crash), and we'll
              stop with EE_UNKNOWN_CHARSET in compare_errors (unless set to
              ignore this error).
1784
            */
1785
            set_slave_thread_default_charset(thd, rli);
1786 1787 1788 1789 1790
            goto compare_errors;
          }
          thd->update_charset(); // for the charset change to take effect
        }
      }
1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801
      if (time_zone_len)
      {
        String tmp(time_zone_str, time_zone_len, &my_charset_bin);
        if (!(thd->variables.time_zone=
              my_tz_find_with_opening_tz_tables(thd, &tmp)))
        {
          my_error(ER_UNKNOWN_TIME_ZONE, MYF(0), tmp.c_ptr());
          thd->variables.time_zone= global_system_variables.time_zone;
          goto compare_errors;
        }
      }
1802 1803

      /* Execute the query (note that we bypass dispatch_command()) */
unknown's avatar
unknown committed
1804
      mysql_parse(thd, thd->query, thd->query_length);
1805 1806

    }
unknown's avatar
unknown committed
1807 1808
    else
    {
unknown's avatar
unknown committed
1809
      /*
unknown's avatar
unknown committed
1810 1811 1812 1813 1814
        The query got a really bad error on the master (thread killed etc),
        which could be inconsistent. Parse it to test the table names: if the
        replicate-*-do|ignore-table rules say "this query must be ignored" then
        we exit gracefully; otherwise we warn about the bad error and tell DBA
        to check/fix it.
unknown's avatar
unknown committed
1815
      */
unknown's avatar
unknown committed
1816
      if (mysql_test_parse_for_slave(thd, thd->query, thd->query_length))
unknown's avatar
unknown committed
1817 1818
        clear_all_errors(thd, rli);        /* Can ignore query */
      else
1819
      {
1820
        slave_print_msg(ERROR_LEVEL, rli, expected_error, 
unknown's avatar
unknown committed
1821
                          "\
unknown's avatar
unknown committed
1822
Query partially completed on the master (error on master: %d) \
unknown's avatar
unknown committed
1823 1824 1825
and was aborted. There is a chance that your master is inconsistent at this \
point. If you are sure that your master is ok, run this query manually on the \
slave and then restart the slave with SET GLOBAL SQL_SLAVE_SKIP_COUNTER=1; \
unknown's avatar
unknown committed
1826
START SLAVE; . Query: '%s'", expected_error, thd->query);
unknown's avatar
unknown committed
1827 1828 1829 1830
        thd->query_error= 1;
      }
      goto end;
    }
1831

1832 1833
    /* If the query was not ignored, it is printed to the general log */
    if (thd->net.last_errno != ER_SLAVE_IGNORED_TABLE)
1834
      general_log_print(thd, COM_QUERY, "%s", thd->query);
1835

1836
compare_errors:
unknown's avatar
unknown committed
1837 1838

     /*
unknown's avatar
unknown committed
1839 1840 1841 1842
      If we expected a non-zero error code, and we don't get the same error
      code, and none of them should be ignored.
    */
    DBUG_PRINT("info",("expected_error: %d  last_errno: %d",
1843
 		       expected_error, thd->net.last_errno));
unknown's avatar
unknown committed
1844
    if ((expected_error != (actual_error= thd->net.last_errno)) &&
1845 1846 1847
 	expected_error &&
 	!ignored_error_code(actual_error) &&
 	!ignored_error_code(expected_error))
unknown's avatar
unknown committed
1848
    {
1849 1850 1851
      slave_print_msg(ERROR_LEVEL, rli, 0,
                      "\
Query caused different errors on master and slave.     \
unknown's avatar
unknown committed
1852
Error on master: '%s' (%d), Error on slave: '%s' (%d). \
unknown's avatar
unknown committed
1853
Default database: '%s'. Query: '%s'",
1854 1855 1856 1857 1858
                      ER_SAFE(expected_error),
                      expected_error,
                      actual_error ? thd->net.last_error: "no error",
                      actual_error,
                      print_slave_db_safe(db), query_arg);
unknown's avatar
unknown committed
1859 1860 1861 1862 1863 1864
      thd->query_error= 1;
    }
    /*
      If we get the same error code as expected, or they should be ignored. 
    */
    else if (expected_error == actual_error ||
1865
 	     ignored_error_code(actual_error))
unknown's avatar
unknown committed
1866 1867 1868 1869 1870 1871
    {
      DBUG_PRINT("info",("error ignored"));
      clear_all_errors(thd, rli);
    }
    /*
      Other cases: mostly we expected no error and get one.
unknown's avatar
unknown committed
1872
    */
unknown's avatar
unknown committed
1873 1874
    else if (thd->query_error || thd->is_fatal_error)
    {
1875 1876 1877 1878 1879
      slave_print_msg(ERROR_LEVEL, rli, actual_error,
                      "Error '%s' on query. Default database: '%s'. Query: '%s'",
                      (actual_error ? thd->net.last_error :
                       "unexpected success or fatal error"),
                      print_slave_db_safe(thd->db), query_arg);
unknown's avatar
unknown committed
1880 1881
      thd->query_error= 1;
    }
1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895

    /*
      TODO: compare the values of "affected rows" around here. Something
      like:
      if ((uint32) affected_in_event != (uint32) affected_on_slave)
      {
      sql_print_error("Slave: did not get the expected number of affected \
      rows running query from master - expected %d, got %d (this numbers \
      should have matched modulo 4294967296).", 0, ...);
      thd->query_error = 1;
      }
      We may also want an option to tell the slave to ignore "affected"
      mismatch. This mismatch could be implemented with a new ER_ code, and
      to ignore it you would use --slave-skip-errors...
1896

1897 1898 1899 1900 1901 1902 1903
      To do the comparison we need to know the value of "affected" which the
      above mysql_parse() computed. And we need to know the value of
      "affected" in the master's binlog. Both will be implemented later. The
      important thing is that we now have the format ready to log the values
      of "affected" in the binlog. So we can release 5.0.0 before effectively
      logging "affected" and effectively comparing it.
    */
unknown's avatar
unknown committed
1904 1905
  } /* End of if (db_ok(... */

unknown's avatar
unknown committed
1906
end:
1907
  VOID(pthread_mutex_lock(&LOCK_thread_count));
1908 1909 1910 1911 1912 1913
  /*
    Probably we have set thd->query, thd->db, thd->catalog to point to places
    in the data_buf of this event. Now the event is going to be deleted
    probably, so data_buf will be freed, so the thd->... listed above will be
    pointers to freed memory. 
    So we must set them to 0, so that those bad pointers values are not later
1914 1915 1916
    used. Note that "cleanup" queries like automatic DROP TEMPORARY TABLE
    don't suffer from these assignments to 0 as DROP TEMPORARY
    TABLE uses the db.table syntax.
1917 1918
  */
  thd->db= thd->catalog= 0;	        // prevent db from being freed
1919
  thd->query= 0;			// just to be sure
unknown's avatar
unknown committed
1920
  thd->query_length= thd->db_length =0;
1921
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1922
  close_thread_tables(thd);      
unknown's avatar
unknown committed
1923
  free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
1924 1925 1926 1927 1928 1929 1930
  /*
    If there was an error we stop. Otherwise we increment positions. Note that
    we will not increment group* positions if we are just after a SET
    ONE_SHOT, because SET ONE_SHOT should not be separated from its following
    updating query.
  */
  return (thd->query_error ? thd->query_error : 
1931
          (thd->one_shot_set ? (rli->inc_event_relay_log_pos(),0) :
1932
           Log_event::exec_event(rli))); 
unknown's avatar
unknown committed
1933
}
unknown's avatar
SCRUM  
unknown committed
1934
#endif
unknown's avatar
unknown committed
1935

unknown's avatar
unknown committed
1936

unknown's avatar
unknown committed
1937
/**************************************************************************
1938
	Start_log_event_v3 methods
unknown's avatar
unknown committed
1939
**************************************************************************/
1940

1941 1942 1943 1944 1945 1946 1947 1948
#ifndef MYSQL_CLIENT
Start_log_event_v3::Start_log_event_v3() :Log_event(), binlog_version(BINLOG_VERSION), artificial_event(0)
{
  created= when;
  memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
}
#endif

unknown's avatar
unknown committed
1949
/*
1950
  Start_log_event_v3::pack_info()
unknown's avatar
unknown committed
1951
*/
1952

unknown's avatar
SCRUM  
unknown committed
1953
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
1954
void Start_log_event_v3::pack_info(Protocol *protocol)
unknown's avatar
unknown committed
1955
{
1956 1957 1958 1959
  char buf[12 + ST_SERVER_VER_LEN + 14 + 22], *pos;
  pos= strmov(buf, "Server ver: ");
  pos= strmov(pos, server_version);
  pos= strmov(pos, ", Binlog ver: ");
unknown's avatar
unknown committed
1960 1961
  pos= int10_to_str(binlog_version, pos, 10);
  protocol->store(buf, (uint) (pos-buf), &my_charset_bin);
unknown's avatar
unknown committed
1962
}
unknown's avatar
SCRUM  
unknown committed
1963
#endif
1964 1965


unknown's avatar
unknown committed
1966
/*
1967
  Start_log_event_v3::print()
unknown's avatar
unknown committed
1968
*/
unknown's avatar
unknown committed
1969 1970

#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
1971
void Start_log_event_v3::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
unknown's avatar
unknown committed
1972
{
unknown's avatar
unknown committed
1973
  if (!print_event_info->short_form)
1974
  {
unknown's avatar
unknown committed
1975
    print_header(file, print_event_info);
1976 1977 1978 1979 1980 1981
    fprintf(file, "\tStart: binlog v %d, server v %s created ", binlog_version,
            server_version);
    print_timestamp(file);
    if (created)
      fprintf(file," at startup");
    fputc('\n', file);
1982 1983 1984
    if (flags & LOG_EVENT_BINLOG_IN_USE_F)
      fprintf(file, "# Warning: this binlog was not closed properly. "
              "Most probably mysqld crashed writing it.\n");
1985
  }
1986 1987
  if (!artificial_event && created)
  {
1988
#ifdef WHEN_WE_HAVE_THE_RESET_CONNECTION_SQL_COMMAND
1989 1990 1991 1992 1993 1994 1995 1996 1997
    /*
      This is for mysqlbinlog: like in replication, we want to delete the stale
      tmp files left by an unclean shutdown of mysqld (temporary tables)
      and rollback unfinished transaction.
      Probably this can be done with RESET CONNECTION (syntax to be defined).
    */
    fprintf(file,"RESET CONNECTION;\n");
#else
    fprintf(file,"ROLLBACK;\n");
1998
#endif
1999
  }
unknown's avatar
unknown committed
2000 2001
  fflush(file);
}
unknown's avatar
unknown committed
2002
#endif /* MYSQL_CLIENT */
unknown's avatar
unknown committed
2003

unknown's avatar
unknown committed
2004
/*
2005
  Start_log_event_v3::Start_log_event_v3()
unknown's avatar
unknown committed
2006
*/
2007

2008 2009 2010
Start_log_event_v3::Start_log_event_v3(const char* buf,
                                       const Format_description_log_event* description_event)
  :Log_event(buf, description_event)
2011
{
2012 2013
  buf+= description_event->common_header_len;
  binlog_version= uint2korr(buf+ST_BINLOG_VER_OFFSET);
2014 2015
  memcpy(server_version, buf+ST_SERVER_VER_OFFSET,
	 ST_SERVER_VER_LEN);
2016 2017 2018
  created= uint4korr(buf+ST_CREATED_OFFSET);
  /* We use log_pos to mark if this was an artificial event or not */
  artificial_event= (log_pos == 0);
unknown's avatar
unknown committed
2019 2020
}

2021

unknown's avatar
unknown committed
2022
/*
2023
  Start_log_event_v3::write()
unknown's avatar
unknown committed
2024
*/
2025

2026
#ifndef MYSQL_CLIENT
2027
bool Start_log_event_v3::write(IO_CACHE* file)
2028
{
2029
  char buff[START_V3_HEADER_LEN];
2030 2031 2032
  int2store(buff + ST_BINLOG_VER_OFFSET,binlog_version);
  memcpy(buff + ST_SERVER_VER_OFFSET,server_version,ST_SERVER_VER_LEN);
  int4store(buff + ST_CREATED_OFFSET,created);
2033 2034
  return (write_header(file, sizeof(buff)) ||
          my_b_safe_write(file, (byte*) buff, sizeof(buff)));
2035
}
2036
#endif
2037

2038

unknown's avatar
unknown committed
2039
/*
2040
  Start_log_event_v3::exec_event()
2041 2042 2043 2044

  The master started

  IMPLEMENTATION
unknown's avatar
unknown committed
2045 2046 2047 2048
    - To handle the case where the master died without having time to write
      DROP TEMPORARY TABLE, DO RELEASE_LOCK (prepared statements' deletion is
      TODO), we clean up all temporary tables that we got, if we are sure we
      can (see below).
2049 2050

  TODO
2051 2052 2053 2054 2055
    - Remove all active user locks.
      Guilhem 2003-06: this is true but not urgent: the worst it can cause is
      the use of a bit of memory for a user lock which will not be used
      anymore. If the user lock is later used, the old one will be released. In
      other words, no deadlock problem.
unknown's avatar
unknown committed
2056 2057
*/

unknown's avatar
SCRUM  
unknown committed
2058
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
2059
int Start_log_event_v3::exec_event(struct st_relay_log_info* rli)
2060
{
2061
  DBUG_ENTER("Start_log_event_v3::exec_event");
2062
  switch (binlog_version)
2063 2064 2065 2066 2067 2068 2069 2070
  {
  case 3:
  case 4:
    /*
      This can either be 4.x (then a Start_log_event_v3 is only at master
      startup so we are sure the master has restarted and cleared his temp
      tables; the event always has 'created'>0) or 5.0 (then we have to test
      'created').
unknown's avatar
unknown committed
2071
    */
2072 2073 2074 2075 2076
    if (created)
    {
      close_temporary_tables(thd);
      cleanup_load_tmpdir();
    }
unknown's avatar
unknown committed
2077 2078
    break;

2079
    /*
unknown's avatar
unknown committed
2080 2081
       Now the older formats; in that case load_tmpdir is cleaned up by the I/O
       thread.
unknown's avatar
unknown committed
2082
    */
2083
  case 1:
2084
    if (strncmp(rli->relay_log.description_event_for_exec->server_version,
2085 2086 2087 2088 2089 2090 2091 2092
                "3.23.57",7) >= 0 && created)
    {
      /*
        Can distinguish, based on the value of 'created': this event was
        generated at master startup.
      */
      close_temporary_tables(thd);
    }
unknown's avatar
unknown committed
2093
    /*
2094 2095 2096
      Otherwise, can't distinguish a Start_log_event generated at
      master startup and one generated by master FLUSH LOGS, so cannot
      be sure temp tables have to be dropped. So do nothing.
unknown's avatar
unknown committed
2097 2098 2099 2100
    */
    break;
  default:
    /* this case is impossible */
2101
    DBUG_RETURN(1);
unknown's avatar
unknown committed
2102
  }
2103
  DBUG_RETURN(Log_event::exec_event(rli));
2104
}
unknown's avatar
unknown committed
2105
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
2106

2107 2108 2109 2110 2111 2112 2113 2114 2115
/***************************************************************************
       Format_description_log_event methods
****************************************************************************/

/*
  Format_description_log_event 1st ctor.

  SYNOPSIS
    Format_description_log_event::Format_description_log_event
2116
      binlog_version              the binlog version for which we want to build
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130
                                  an event. Can be 1 (=MySQL 3.23), 3 (=4.0.x
                                  x>=2 and 4.1) or 4 (MySQL 5.0). Note that the
                                  old 4.0 (binlog version 2) is not supported;
                                  it should not be used for replication with
                                  5.0.

  DESCRIPTION
    Ctor. Can be used to create the event to write to the binary log (when the
    server starts or when FLUSH LOGS), or to create artificial events to parse
    binlogs from MySQL 3.23 or 4.x.
    When in a client, only the 2nd use is possible.
*/

Format_description_log_event::
2131
Format_description_log_event(uint8 binlog_ver, const char* server_ver)
2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142
  :Start_log_event_v3()
{
  created= when;
  binlog_version= binlog_ver;
  switch (binlog_ver) {
  case 4: /* MySQL 5.0 */
    memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
    common_header_len= LOG_EVENT_HEADER_LEN;
    number_of_event_types= LOG_EVENT_TYPES;
    /* we'll catch my_malloc() error in is_valid() */
    post_header_len=(uint8*) my_malloc(number_of_event_types*sizeof(uint8),
2143
                                       MYF(MY_ZEROFILL));
2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160
    /*
      This long list of assignments is not beautiful, but I see no way to
      make it nicer, as the right members are #defines, not array members, so
      it's impossible to write a loop.
    */
    if (post_header_len)
    {
      post_header_len[START_EVENT_V3-1]= START_V3_HEADER_LEN;
      post_header_len[QUERY_EVENT-1]= QUERY_HEADER_LEN;
      post_header_len[ROTATE_EVENT-1]= ROTATE_HEADER_LEN;
      post_header_len[LOAD_EVENT-1]= LOAD_HEADER_LEN;
      post_header_len[CREATE_FILE_EVENT-1]= CREATE_FILE_HEADER_LEN;
      post_header_len[APPEND_BLOCK_EVENT-1]= APPEND_BLOCK_HEADER_LEN;
      post_header_len[EXEC_LOAD_EVENT-1]= EXEC_LOAD_HEADER_LEN;
      post_header_len[DELETE_FILE_EVENT-1]= DELETE_FILE_HEADER_LEN;
      post_header_len[NEW_LOAD_EVENT-1]= post_header_len[LOAD_EVENT-1];
      post_header_len[FORMAT_DESCRIPTION_EVENT-1]= FORMAT_DESCRIPTION_HEADER_LEN;
2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179
      post_header_len[TABLE_MAP_EVENT-1]=    TABLE_MAP_HEADER_LEN;
      post_header_len[WRITE_ROWS_EVENT-1]=   ROWS_HEADER_LEN;
      post_header_len[UPDATE_ROWS_EVENT-1]=  ROWS_HEADER_LEN;
      post_header_len[DELETE_ROWS_EVENT-1]=  ROWS_HEADER_LEN;
      /*
        We here have the possibility to simulate a master of before we changed
        the table map id to be stored in 6 bytes: when it was stored in 4
        bytes (=> post_header_len was 6). This is used to test backward
        compatibility.
        This code can be removed after a few months (today is Dec 21st 2005),
        when we know that the 4-byte masters are not deployed anymore (check
        with Tomas Ulin first!), and the accompanying test (rpl_row_4_bytes)
        too.
      */
      DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master",
                      post_header_len[TABLE_MAP_EVENT-1]=
                      post_header_len[WRITE_ROWS_EVENT-1]=
                      post_header_len[UPDATE_ROWS_EVENT-1]=
                      post_header_len[DELETE_ROWS_EVENT-1]= 6;);
unknown's avatar
unknown committed
2180 2181
      post_header_len[BEGIN_LOAD_QUERY_EVENT-1]= post_header_len[APPEND_BLOCK_EVENT-1];
      post_header_len[EXECUTE_LOAD_QUERY_EVENT-1]= EXECUTE_LOAD_QUERY_HEADER_LEN;
2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195
    }
    break;

  case 1: /* 3.23 */
  case 3: /* 4.0.x x>=2 */
    /*
      We build an artificial (i.e. not sent by the master) event, which
      describes what those old master versions send.
    */
    if (binlog_ver==1)
      strmov(server_version, server_ver ? server_ver : "3.23");
    else
      strmov(server_version, server_ver ? server_ver : "4.0");
    common_header_len= binlog_ver==1 ? OLD_HEADER_LEN :
2196
      LOG_EVENT_MINIMAL_HEADER_LEN;
2197 2198 2199 2200 2201 2202 2203 2204 2205
    /*
      The first new event in binlog version 4 is Format_desc. So any event type
      after that does not exist in older versions. We use the events known by
      version 3, even if version 1 had only a subset of them (this is not a
      problem: it uses a few bytes for nothing but unifies code; it does not
      make the slave detect less corruptions).
    */
    number_of_event_types= FORMAT_DESCRIPTION_EVENT - 1;
    post_header_len=(uint8*) my_malloc(number_of_event_types*sizeof(uint8),
2206
                                       MYF(0));
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
    if (post_header_len)
    {
      post_header_len[START_EVENT_V3-1]= START_V3_HEADER_LEN;
      post_header_len[QUERY_EVENT-1]= QUERY_HEADER_MINIMAL_LEN;
      post_header_len[STOP_EVENT-1]= 0;
      post_header_len[ROTATE_EVENT-1]= (binlog_ver==1) ? 0 : ROTATE_HEADER_LEN;
      post_header_len[INTVAR_EVENT-1]= 0;
      post_header_len[LOAD_EVENT-1]= LOAD_HEADER_LEN;
      post_header_len[SLAVE_EVENT-1]= 0;
      post_header_len[CREATE_FILE_EVENT-1]= CREATE_FILE_HEADER_LEN;
      post_header_len[APPEND_BLOCK_EVENT-1]= APPEND_BLOCK_HEADER_LEN;
      post_header_len[EXEC_LOAD_EVENT-1]= EXEC_LOAD_HEADER_LEN;
      post_header_len[DELETE_FILE_EVENT-1]= DELETE_FILE_HEADER_LEN;
      post_header_len[NEW_LOAD_EVENT-1]= post_header_len[LOAD_EVENT-1];
      post_header_len[RAND_EVENT-1]= 0;
      post_header_len[USER_VAR_EVENT-1]= 0;
    }
    break;
  default: /* Includes binlog version 2 i.e. 4.0.x x<=1 */
    post_header_len= 0; /* will make is_valid() fail */
    break;
  }
}


/*
  The problem with this constructor is that the fixed header may have a
  length different from this version, but we don't know this length as we
  have not read the Format_description_log_event which says it, yet. This
  length is in the post-header of the event, but we don't know where the
2237
  post-header starts.
2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252
  So this type of event HAS to:
  - either have the header's length at the beginning (in the header, at a
  fixed position which will never be changed), not in the post-header. That
  would make the header be "shifted" compared to other events.
  - or have a header of size LOG_EVENT_MINIMAL_HEADER_LEN (19), in all future
  versions, so that we know for sure.
  I (Guilhem) chose the 2nd solution. Rotate has the same constraint (because
  it is sent before Format_description_log_event).
*/

Format_description_log_event::
Format_description_log_event(const char* buf,
                             uint event_len,
                             const
                             Format_description_log_event*
2253
                             description_event)
2254 2255 2256 2257 2258 2259 2260 2261 2262
  :Start_log_event_v3(buf, description_event)
{
  DBUG_ENTER("Format_description_log_event::Format_description_log_event(char*,...)");
  buf+= LOG_EVENT_MINIMAL_HEADER_LEN;
  if ((common_header_len=buf[ST_COMMON_HEADER_LEN_OFFSET]) < OLD_HEADER_LEN)
    DBUG_VOID_RETURN; /* sanity check */
  number_of_event_types=
    event_len-(LOG_EVENT_MINIMAL_HEADER_LEN+ST_COMMON_HEADER_LEN_OFFSET+1);
  DBUG_PRINT("info", ("common_header_len=%d number_of_event_types=%d",
2263
                      common_header_len, number_of_event_types));
2264 2265 2266
  /* If alloc fails, we'll detect it in is_valid() */
  post_header_len= (uint8*) my_memdup((byte*)buf+ST_COMMON_HEADER_LEN_OFFSET+1,
                                      number_of_event_types*
2267
                                      sizeof(*post_header_len), MYF(0));
2268 2269 2270
  DBUG_VOID_RETURN;
}

2271
#ifndef MYSQL_CLIENT
2272 2273 2274 2275 2276 2277 2278 2279 2280 2281
bool Format_description_log_event::write(IO_CACHE* file)
{
  /*
    We don't call Start_log_event_v3::write() because this would make 2
    my_b_safe_write().
  */
  byte buff[FORMAT_DESCRIPTION_HEADER_LEN];
  int2store(buff + ST_BINLOG_VER_OFFSET,binlog_version);
  memcpy((char*) buff + ST_SERVER_VER_OFFSET,server_version,ST_SERVER_VER_LEN);
  int4store(buff + ST_CREATED_OFFSET,created);
2282
  buff[ST_COMMON_HEADER_LEN_OFFSET]= LOG_EVENT_HEADER_LEN;
2283 2284 2285 2286 2287
  memcpy((char*) buff+ST_COMMON_HEADER_LEN_OFFSET+1, (byte*) post_header_len,
         LOG_EVENT_TYPES);
  return (write_header(file, sizeof(buff)) ||
          my_b_safe_write(file, buff, sizeof(buff)));
}
2288
#endif
2289

2290 2291 2292
/*
  SYNOPSIS
    Format_description_log_event::exec_event()
2293

2294 2295 2296 2297 2298 2299 2300 2301 2302 2303
  IMPLEMENTATION
    Save the information which describes the binlog's format, to be able to
    read all coming events.
    Call Start_log_event_v3::exec_event().
*/

#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
int Format_description_log_event::exec_event(struct st_relay_log_info* rli)
{
  DBUG_ENTER("Format_description_log_event::exec_event");
2304 2305

  /* save the information describing this binlog */
2306 2307 2308
  delete rli->relay_log.description_event_for_exec;
  rli->relay_log.description_event_for_exec= this;

unknown's avatar
unknown committed
2309
#ifdef USING_TRANSACTIONS
2310 2311 2312 2313
  /*
    As a transaction NEVER spans on 2 or more binlogs:
    if we have an active transaction at this point, the master died
    while writing the transaction to the binary log, i.e. while
2314 2315
    flushing the binlog cache to the binlog. XA guarantees that master has
    rolled back. So we roll back.
2316 2317 2318 2319 2320 2321 2322
    Note: this event could be sent by the master to inform us of the
    format of its binlog; in other words maybe it is not at its
    original place when it comes to us; we'll know this by checking
    log_pos ("artificial" events have log_pos == 0).
  */
  if (!artificial_event && created && thd->transaction.all.nht)
  {
2323 2324 2325 2326 2327 2328 2329
    /* This is not an error (XA is safe), just an information */
    slave_print_msg(INFORMATION_LEVEL, rli, 0,
                    "Rolling back unfinished transaction (no COMMIT "
                    "or ROLLBACK in relay log). A probable cause is that "
                    "the master died while writing the transaction to "
                    "its binary log, thus rolled back too."); 
    rli->cleanup_context(thd, 1);
2330
  }
unknown's avatar
unknown committed
2331
#endif
2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359
  /*
    If this event comes from ourselves, there is no cleaning task to perform,
    we don't call Start_log_event_v3::exec_event() (this was just to update the
    log's description event).
  */
  if (server_id == (uint32) ::server_id)
  {
    /*
      Do not modify rli->group_master_log_pos, as this event did not exist on
      the master. That is, just update the *relay log* coordinates; this is
      done by passing log_pos=0 to inc_group_relay_log_pos, like we do in
      Stop_log_event::exec_event().
      If in a transaction, don't touch group_* coordinates.
    */
    if (thd->options & OPTION_BEGIN)
      rli->inc_event_relay_log_pos();
    else
    {
      rli->inc_group_relay_log_pos(0);
      flush_relay_log_info(rli);
    }
    DBUG_RETURN(0);
  }

  /*
    If the event was not requested by the slave i.e. the master sent it while
    the slave asked for a position >4, the event will make
    rli->group_master_log_pos advance. Say that the slave asked for position
2360 2361 2362
    1000, and the Format_desc event's end is 96. Then in the beginning of
    replication rli->group_master_log_pos will be 0, then 96, then jump to
    first really asked event (which is >96). So this is ok.
2363 2364 2365 2366 2367 2368
  */
  DBUG_RETURN(Start_log_event_v3::exec_event(rli));
}
#endif

  /**************************************************************************
2369
        Load_log_event methods
2370
   General note about Load_log_event: the binlogging of LOAD DATA INFILE is
2371
   going to be changed in 5.0 (or maybe in 5.1; not decided yet).
2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383
   However, the 5.0 slave could still have to read such events (from a 4.x
   master), convert them (which just means maybe expand the header, when 5.0
   servers have a UID in events) (remember that whatever is after the header
   will be like in 4.x, as this event's format is not modified in 5.0 as we
   will use new types of events to log the new LOAD DATA INFILE features).
   To be able to read/convert, we just need to not assume that the common
   header is of length LOG_EVENT_HEADER_LEN (we must use the description
   event).
   Note that I (Guilhem) manually tested replication of a big LOAD DATA INFILE
   between 3.23 and 5.0, and between 4.0 and 5.0, and it works fine (and the
   positions displayed in SHOW SLAVE STATUS then are fine too).
  **************************************************************************/
2384

unknown's avatar
unknown committed
2385
/*
2386
  Load_log_event::pack_info()
unknown's avatar
unknown committed
2387
*/
2388

unknown's avatar
SCRUM  
unknown committed
2389
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
unknown's avatar
unknown committed
2390
uint Load_log_event::get_query_buffer_length()
2391
{
unknown's avatar
unknown committed
2392
  return
2393 2394
    5 + db_len + 3 +                        // "use DB; "
    18 + fname_len + 2 +                    // "LOAD DATA INFILE 'file''"
unknown's avatar
unknown committed
2395
    7 +					    // LOCAL
2396
    9 +                                     // " REPLACE or IGNORE "
2397
    13 + table_name_len*2 +                 // "INTO TABLE `table`"
2398 2399 2400 2401
    21 + sql_ex.field_term_len*4 + 2 +      // " FIELDS TERMINATED BY 'str'"
    23 + sql_ex.enclosed_len*4 + 2 +        // " OPTIONALLY ENCLOSED BY 'str'"
    12 + sql_ex.escaped_len*4 + 2 +         // " ESCAPED BY 'str'"
    21 + sql_ex.line_term_len*4 + 2 +       // " FIELDS TERMINATED BY 'str'"
2402 2403
    19 + sql_ex.line_start_len*4 + 2 +      // " LINES STARTING BY 'str'"
    15 + 22 +                               // " IGNORE xxx  LINES"
2404
    3 + (num_fields-1)*2 + field_block_len; // " (field1, field2, ...)"
unknown's avatar
unknown committed
2405
}
2406

unknown's avatar
unknown committed
2407 2408 2409 2410 2411 2412 2413

void Load_log_event::print_query(bool need_db, char *buf,
                                 char **end, char **fn_start, char **fn_end)
{
  char *pos= buf;

  if (need_db && db && db_len)
2414
  {
2415 2416
    pos= strmov(pos, "use `");
    memcpy(pos, db, db_len);
unknown's avatar
unknown committed
2417
    pos= strmov(pos+db_len, "`; ");
2418
  }
2419

unknown's avatar
unknown committed
2420
  pos= strmov(pos, "LOAD DATA ");
unknown's avatar
unknown committed
2421 2422 2423 2424

  if (fn_start)
    *fn_start= pos;

unknown's avatar
unknown committed
2425 2426 2427
  if (check_fname_outside_temp_buf())
    pos= strmov(pos, "LOCAL ");
  pos= strmov(pos, "INFILE '");
2428
  memcpy(pos, fname, fname_len);
unknown's avatar
unknown committed
2429
  pos= strmov(pos+fname_len, "' ");
2430

unknown's avatar
unknown committed
2431
  if (sql_ex.opt_flags & REPLACE_FLAG)
2432
    pos= strmov(pos, " REPLACE ");
unknown's avatar
unknown committed
2433
  else if (sql_ex.opt_flags & IGNORE_FLAG)
2434 2435
    pos= strmov(pos, " IGNORE ");

unknown's avatar
unknown committed
2436 2437 2438 2439 2440 2441
  pos= strmov(pos ,"INTO");

  if (fn_end)
    *fn_end= pos;

  pos= strmov(pos ," TABLE `");
2442 2443 2444
  memcpy(pos, table_name, table_name_len);
  pos+= table_name_len;

unknown's avatar
unknown committed
2445
  /* We have to create all optinal fields as the default is not empty */
2446
  pos= strmov(pos, "` FIELDS TERMINATED BY ");
unknown's avatar
unknown committed
2447 2448 2449 2450 2451
  pos= pretty_print_str(pos, sql_ex.field_term, sql_ex.field_term_len);
  if (sql_ex.opt_flags & OPT_ENCLOSED_FLAG)
    pos= strmov(pos, " OPTIONALLY ");
  pos= strmov(pos, " ENCLOSED BY ");
  pos= pretty_print_str(pos, sql_ex.enclosed, sql_ex.enclosed_len);
2452

unknown's avatar
unknown committed
2453 2454
  pos= strmov(pos, " ESCAPED BY ");
  pos= pretty_print_str(pos, sql_ex.escaped, sql_ex.escaped_len);
2455

unknown's avatar
unknown committed
2456 2457
  pos= strmov(pos, " LINES TERMINATED BY ");
  pos= pretty_print_str(pos, sql_ex.line_term, sql_ex.line_term_len);
2458 2459
  if (sql_ex.line_start_len)
  {
2460
    pos= strmov(pos, " STARTING BY ");
2461
    pos= pretty_print_str(pos, sql_ex.line_start, sql_ex.line_start_len);
2462
  }
2463

unknown's avatar
unknown committed
2464
  if ((long) skip_lines > 0)
2465 2466
  {
    pos= strmov(pos, " IGNORE ");
unknown's avatar
unknown committed
2467
    pos= longlong10_to_str((longlong) skip_lines, pos, 10);
2468 2469
    pos= strmov(pos," LINES ");    
  }
2470 2471 2472 2473

  if (num_fields)
  {
    uint i;
unknown's avatar
unknown committed
2474
    const char *field= fields;
2475
    pos= strmov(pos, " (");
2476 2477 2478
    for (i = 0; i < num_fields; i++)
    {
      if (i)
unknown's avatar
unknown committed
2479 2480 2481 2482
      {
        *pos++= ' ';
        *pos++= ',';
      }
2483
      memcpy(pos, field, field_lens[i]);
unknown's avatar
unknown committed
2484 2485
      pos+=   field_lens[i];
      field+= field_lens[i]  + 1;
2486
    }
2487
    *pos++= ')';
2488
  }
2489

unknown's avatar
unknown committed
2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501
  *end= pos;
}


void Load_log_event::pack_info(Protocol *protocol)
{
  char *buf, *end;

  if (!(buf= my_malloc(get_query_buffer_length(), MYF(MY_WME))))
    return;
  print_query(TRUE, buf, &end, 0, 0);
  protocol->store(buf, end-buf, &my_charset_bin);
unknown's avatar
unknown committed
2502
  my_free(buf, MYF(0));
2503
}
unknown's avatar
unknown committed
2504
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
2505

2506

2507 2508
#ifndef MYSQL_CLIENT

unknown's avatar
unknown committed
2509
/*
2510
  Load_log_event::write_data_header()
unknown's avatar
unknown committed
2511
*/
2512

2513
bool Load_log_event::write_data_header(IO_CACHE* file)
2514
{
2515
  char buf[LOAD_HEADER_LEN];
unknown's avatar
unknown committed
2516
  int4store(buf + L_THREAD_ID_OFFSET, slave_proxy_id);
2517 2518 2519 2520 2521
  int4store(buf + L_EXEC_TIME_OFFSET, exec_time);
  int4store(buf + L_SKIP_LINES_OFFSET, skip_lines);
  buf[L_TBL_LEN_OFFSET] = (char)table_name_len;
  buf[L_DB_LEN_OFFSET] = (char)db_len;
  int4store(buf + L_NUM_FIELDS_OFFSET, num_fields);
2522
  return my_b_safe_write(file, (byte*)buf, LOAD_HEADER_LEN) != 0;
2523
}
2524

2525

unknown's avatar
unknown committed
2526
/*
2527
  Load_log_event::write_data_body()
unknown's avatar
unknown committed
2528
*/
2529

2530
bool Load_log_event::write_data_body(IO_CACHE* file)
2531
{
2532 2533 2534
  if (sql_ex.write_data(file))
    return 1;
  if (num_fields && fields && field_lens)
2535
  {
2536 2537 2538
    if (my_b_safe_write(file, (byte*)field_lens, num_fields) ||
	my_b_safe_write(file, (byte*)fields, field_block_len))
      return 1;
2539
  }
2540 2541 2542
  return (my_b_safe_write(file, (byte*)table_name, table_name_len + 1) ||
	  my_b_safe_write(file, (byte*)db, db_len + 1) ||
	  my_b_safe_write(file, (byte*)fname, fname_len));
2543 2544
}

2545

unknown's avatar
unknown committed
2546
/*
2547
  Load_log_event::Load_log_event()
unknown's avatar
unknown committed
2548
*/
2549

unknown's avatar
unknown committed
2550 2551 2552
Load_log_event::Load_log_event(THD *thd_arg, sql_exchange *ex,
			       const char *db_arg, const char *table_name_arg,
			       List<Item> &fields_arg,
unknown's avatar
unknown committed
2553
			       enum enum_duplicates handle_dup,
2554
			       bool ignore, bool using_trans)
2555 2556 2557
  :Log_event(thd_arg, !thd_arg->tmp_table_used ?
	     0 : LOG_EVENT_THREAD_SPECIFIC_F, using_trans),
   thread_id(thd_arg->thread_id),
2558
   slave_proxy_id(thd_arg->variables.pseudo_thread_id),
unknown's avatar
unknown committed
2559 2560
   num_fields(0),fields(0),
   field_lens(0),field_block_len(0),
unknown's avatar
unknown committed
2561
   table_name(table_name_arg ? table_name_arg : ""),
2562
   db(db_arg), fname(ex->file_name), local_fname(FALSE)
unknown's avatar
unknown committed
2563 2564 2565
{
  time_t end_time;
  time(&end_time);
2566
  exec_time = (ulong) (end_time  - thd_arg->start_time);
2567 2568 2569
  /* db can never be a zero pointer in 4.0 */
  db_len = (uint32) strlen(db);
  table_name_len = (uint32) strlen(table_name);
unknown's avatar
unknown committed
2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582
  fname_len = (fname) ? (uint) strlen(fname) : 0;
  sql_ex.field_term = (char*) ex->field_term->ptr();
  sql_ex.field_term_len = (uint8) ex->field_term->length();
  sql_ex.enclosed = (char*) ex->enclosed->ptr();
  sql_ex.enclosed_len = (uint8) ex->enclosed->length();
  sql_ex.line_term = (char*) ex->line_term->ptr();
  sql_ex.line_term_len = (uint8) ex->line_term->length();
  sql_ex.line_start = (char*) ex->line_start->ptr();
  sql_ex.line_start_len = (uint8) ex->line_start->length();
  sql_ex.escaped = (char*) ex->escaped->ptr();
  sql_ex.escaped_len = (uint8) ex->escaped->length();
  sql_ex.opt_flags = 0;
  sql_ex.cached_new_format = -1;
2583
    
unknown's avatar
unknown committed
2584
  if (ex->dumpfile)
unknown's avatar
unknown committed
2585
    sql_ex.opt_flags|= DUMPFILE_FLAG;
unknown's avatar
unknown committed
2586
  if (ex->opt_enclosed)
unknown's avatar
unknown committed
2587
    sql_ex.opt_flags|= OPT_ENCLOSED_FLAG;
2588

unknown's avatar
unknown committed
2589
  sql_ex.empty_flags= 0;
2590

2591
  switch (handle_dup) {
unknown's avatar
unknown committed
2592
  case DUP_REPLACE:
unknown's avatar
unknown committed
2593
    sql_ex.opt_flags|= REPLACE_FLAG;
unknown's avatar
unknown committed
2594 2595 2596 2597
    break;
  case DUP_UPDATE:				// Impossible here
  case DUP_ERROR:
    break;	
unknown's avatar
unknown committed
2598
  }
2599 2600
  if (ignore)
    sql_ex.opt_flags|= IGNORE_FLAG;
2601

unknown's avatar
unknown committed
2602 2603 2604 2605 2606 2607 2608 2609 2610 2611
  if (!ex->field_term->length())
    sql_ex.empty_flags |= FIELD_TERM_EMPTY;
  if (!ex->enclosed->length())
    sql_ex.empty_flags |= ENCLOSED_EMPTY;
  if (!ex->line_term->length())
    sql_ex.empty_flags |= LINE_TERM_EMPTY;
  if (!ex->line_start->length())
    sql_ex.empty_flags |= LINE_START_EMPTY;
  if (!ex->escaped->length())
    sql_ex.empty_flags |= ESCAPED_EMPTY;
2612
    
unknown's avatar
unknown committed
2613
  skip_lines = ex->skip_lines;
2614

unknown's avatar
unknown committed
2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625
  List_iterator<Item> li(fields_arg);
  field_lens_buf.length(0);
  fields_buf.length(0);
  Item* item;
  while ((item = li++))
  {
    num_fields++;
    uchar len = (uchar) strlen(item->name);
    field_block_len += len + 1;
    fields_buf.append(item->name, len + 1);
    field_lens_buf.append((char*)&len, 1);
2626 2627
  }

unknown's avatar
unknown committed
2628 2629 2630
  field_lens = (const uchar*)field_lens_buf.ptr();
  fields = fields_buf.ptr();
}
unknown's avatar
unknown committed
2631
#endif /* !MYSQL_CLIENT */
2632

2633

2634
/*
2635
  Load_log_event::Load_log_event()
2636

unknown's avatar
unknown committed
2637 2638 2639
  NOTE
    The caller must do buf[event_len] = 0 before he starts using the
    constructed event.
2640 2641
*/

2642 2643 2644 2645
Load_log_event::Load_log_event(const char *buf, uint event_len,
                               const Format_description_log_event *description_event)
  :Log_event(buf, description_event), num_fields(0), fields(0),
   field_lens(0),field_block_len(0),
unknown's avatar
unknown committed
2646
   table_name(0), db(0), fname(0), local_fname(FALSE)
unknown's avatar
unknown committed
2647
{
unknown's avatar
unknown committed
2648
  DBUG_ENTER("Load_log_event");
2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660
  /*
    I (Guilhem) manually tested replication of LOAD DATA INFILE for 3.23->5.0,
    4.0->5.0 and 5.0->5.0 and it works.
  */
  if (event_len)
    copy_log_event(buf, event_len,
                   ((buf[EVENT_TYPE_OFFSET] == LOAD_EVENT) ?
                    LOAD_HEADER_LEN + 
                    description_event->common_header_len :
                    LOAD_HEADER_LEN + LOG_EVENT_HEADER_LEN),
                   description_event);
  /* otherwise it's a derived class, will call copy_log_event() itself */
unknown's avatar
unknown committed
2661
  DBUG_VOID_RETURN;
2662 2663
}

2664

unknown's avatar
unknown committed
2665
/*
2666
  Load_log_event::copy_log_event()
unknown's avatar
unknown committed
2667
*/
2668

2669
int Load_log_event::copy_log_event(const char *buf, ulong event_len,
2670 2671
                                   int body_offset,
                                   const Format_description_log_event *description_event)
2672
{
2673
  DBUG_ENTER("Load_log_event::copy_log_event");
2674
  uint data_len;
2675
  char* buf_end = (char*)buf + event_len;
2676 2677
  /* this is the beginning of the post-header */
  const char* data_head = buf + description_event->common_header_len;
unknown's avatar
unknown committed
2678
  slave_proxy_id= thread_id= uint4korr(data_head + L_THREAD_ID_OFFSET);
2679 2680 2681 2682 2683
  exec_time = uint4korr(data_head + L_EXEC_TIME_OFFSET);
  skip_lines = uint4korr(data_head + L_SKIP_LINES_OFFSET);
  table_name_len = (uint)data_head[L_TBL_LEN_OFFSET];
  db_len = (uint)data_head[L_DB_LEN_OFFSET];
  num_fields = uint4korr(data_head + L_NUM_FIELDS_OFFSET);
unknown's avatar
unknown committed
2684
	  
unknown's avatar
unknown committed
2685
  if ((int) event_len < body_offset)
unknown's avatar
unknown committed
2686
    DBUG_RETURN(1);
2687 2688 2689 2690
  /*
    Sql_ex.init() on success returns the pointer to the first byte after
    the sql_ex structure, which is the start of field lengths array.
  */
2691 2692 2693
  if (!(field_lens= (uchar*)sql_ex.init((char*)buf + body_offset,
                                        buf_end,
                                        buf[EVENT_TYPE_OFFSET] != LOAD_EVENT)))
unknown's avatar
unknown committed
2694
    DBUG_RETURN(1);
2695
  
2696
  data_len = event_len - body_offset;
2697
  if (num_fields > data_len) // simple sanity check against corruption
unknown's avatar
unknown committed
2698
    DBUG_RETURN(1);
2699
  for (uint i = 0; i < num_fields; i++)
2700
    field_block_len += (uint)field_lens[i] + 1;
2701

unknown's avatar
unknown committed
2702 2703 2704 2705
  fields = (char*)field_lens + num_fields;
  table_name  = fields + field_block_len;
  db = table_name + table_name_len + 1;
  fname = db + db_len + 1;
2706 2707
  fname_len = strlen(fname);
  // null termination is accomplished by the caller doing buf[event_len]=0
2708

unknown's avatar
unknown committed
2709
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2710 2711 2712
}


unknown's avatar
unknown committed
2713
/*
2714
  Load_log_event::print()
unknown's avatar
unknown committed
2715
*/
2716 2717

#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
2718
void Load_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
unknown's avatar
unknown committed
2719
{
unknown's avatar
unknown committed
2720
  print(file, print_event_info, 0);
unknown's avatar
unknown committed
2721 2722
}

unknown's avatar
unknown committed
2723

unknown's avatar
unknown committed
2724
void Load_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info,
unknown's avatar
unknown committed
2725
			   bool commented)
unknown's avatar
unknown committed
2726
{
unknown's avatar
unknown committed
2727
  DBUG_ENTER("Load_log_event::print");
unknown's avatar
unknown committed
2728
  if (!print_event_info->short_form)
unknown's avatar
unknown committed
2729
  {
unknown's avatar
unknown committed
2730
    print_header(file, print_event_info);
2731
    fprintf(file, "\tQuery\tthread_id=%ld\texec_time=%ld\n",
unknown's avatar
unknown committed
2732 2733 2734
	    thread_id, exec_time);
  }

2735
  bool different_db= 1;
2736
  if (db)
unknown's avatar
unknown committed
2737
  {
2738 2739 2740 2741 2742 2743
    /*
      If the database is different from the one of the previous statement, we
      need to print the "use" command, and we update the last_db.
      But if commented, the "use" is going to be commented so we should not
      update the last_db.
    */
unknown's avatar
unknown committed
2744
    if ((different_db= memcmp(print_event_info->db, db, db_len + 1)) &&
2745
        !commented)
unknown's avatar
unknown committed
2746
      memcpy(print_event_info->db, db, db_len + 1);
unknown's avatar
unknown committed
2747
  }
2748
  
2749
  if (db && db[0] && different_db)
unknown's avatar
unknown committed
2750 2751 2752
    fprintf(file, "%suse %s;\n", 
            commented ? "# " : "",
            db);
unknown's avatar
unknown committed
2753

2754 2755 2756
  if (flags & LOG_EVENT_THREAD_SPECIFIC_F)
    fprintf(file,"%sSET @@session.pseudo_thread_id=%lu;\n",
            commented ? "# " : "", (ulong)thread_id);
unknown's avatar
unknown committed
2757 2758
  fprintf(file, "%sLOAD DATA ",
          commented ? "# " : "");
2759 2760
  if (check_fname_outside_temp_buf())
    fprintf(file, "LOCAL ");
2761
  fprintf(file, "INFILE '%-*s' ", fname_len, fname);
unknown's avatar
unknown committed
2762

unknown's avatar
unknown committed
2763
  if (sql_ex.opt_flags & REPLACE_FLAG)
unknown's avatar
unknown committed
2764
    fprintf(file," REPLACE ");
unknown's avatar
unknown committed
2765
  else if (sql_ex.opt_flags & IGNORE_FLAG)
unknown's avatar
unknown committed
2766 2767
    fprintf(file," IGNORE ");
  
2768
  fprintf(file, "INTO TABLE `%s`", table_name);
unknown's avatar
unknown committed
2769 2770
  fprintf(file, " FIELDS TERMINATED BY ");
  pretty_print_str(file, sql_ex.field_term, sql_ex.field_term_len);
unknown's avatar
unknown committed
2771

unknown's avatar
unknown committed
2772 2773 2774 2775
  if (sql_ex.opt_flags & OPT_ENCLOSED_FLAG)
    fprintf(file," OPTIONALLY ");
  fprintf(file, " ENCLOSED BY ");
  pretty_print_str(file, sql_ex.enclosed, sql_ex.enclosed_len);
unknown's avatar
unknown committed
2776
     
unknown's avatar
unknown committed
2777 2778
  fprintf(file, " ESCAPED BY ");
  pretty_print_str(file, sql_ex.escaped, sql_ex.escaped_len);
unknown's avatar
unknown committed
2779
     
unknown's avatar
unknown committed
2780 2781 2782
  fprintf(file," LINES TERMINATED BY ");
  pretty_print_str(file, sql_ex.line_term, sql_ex.line_term_len);

unknown's avatar
unknown committed
2783

2784
  if (sql_ex.line_start)
unknown's avatar
unknown committed
2785
  {
2786
    fprintf(file," STARTING BY ");
2787
    pretty_print_str(file, sql_ex.line_start, sql_ex.line_start_len);
unknown's avatar
unknown committed
2788
  }
2789 2790
  if ((long) skip_lines > 0)
    fprintf(file, " IGNORE %ld LINES", (long) skip_lines);
unknown's avatar
unknown committed
2791

2792 2793 2794 2795
  if (num_fields)
  {
    uint i;
    const char* field = fields;
2796 2797
    fprintf(file, " (");
    for (i = 0; i < num_fields; i++)
unknown's avatar
unknown committed
2798
    {
unknown's avatar
unknown committed
2799
      if (i)
2800 2801
	fputc(',', file);
      fprintf(file, field);
unknown's avatar
unknown committed
2802
	  
2803
      field += field_lens[i]  + 1;
unknown's avatar
unknown committed
2804
    }
2805 2806
    fputc(')', file);
  }
unknown's avatar
unknown committed
2807 2808

  fprintf(file, ";\n");
unknown's avatar
unknown committed
2809
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2810
}
unknown's avatar
unknown committed
2811
#endif /* MYSQL_CLIENT */
2812

2813

unknown's avatar
unknown committed
2814
/*
2815
  Load_log_event::set_fields()
unknown's avatar
unknown committed
2816 2817 2818 2819 2820

  Note that this function can not use the member variable 
  for the database, since LOAD DATA INFILE on the slave
  can be for a different database than the current one.
  This is the reason for the affected_db argument to this method.
unknown's avatar
unknown committed
2821
*/
2822

2823
#ifndef MYSQL_CLIENT
unknown's avatar
unknown committed
2824
void Load_log_event::set_fields(const char* affected_db, 
2825 2826
				List<Item> &field_list,
                                Name_resolution_context *context)
unknown's avatar
unknown committed
2827 2828
{
  uint i;
unknown's avatar
unknown committed
2829
  const char* field = fields;
2830
  for (i= 0; i < num_fields; i++)
unknown's avatar
unknown committed
2831
  {
2832 2833
    field_list.push_back(new Item_field(context,
                                        affected_db, table_name, field));
2834
    field+= field_lens[i]  + 1;
unknown's avatar
unknown committed
2835
  }
unknown's avatar
unknown committed
2836
}
unknown's avatar
unknown committed
2837
#endif /* !MYSQL_CLIENT */
unknown's avatar
unknown committed
2838 2839


unknown's avatar
SCRUM  
unknown committed
2840
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
unknown's avatar
unknown committed
2841 2842
/*
  Does the data loading job when executing a LOAD DATA on the slave
2843

unknown's avatar
unknown committed
2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857
  SYNOPSIS
    Load_log_event::exec_event
      net  
      rli                             
      use_rli_only_for_errors	  - if set to 1, rli is provided to 
                                  Load_log_event::exec_event only for this 
				  function to have RPL_LOG_NAME and 
				  rli->last_slave_error, both being used by 
				  error reports. rli's position advancing
				  is skipped (done by the caller which is
				  Execute_load_log_event::exec_event).
				  - if set to 0, rli is provided for full use,
				  i.e. for error reports and position
				  advancing.
2858

unknown's avatar
unknown committed
2859 2860 2861 2862 2863 2864 2865
  DESCRIPTION
    Does the data loading job when executing a LOAD DATA on the slave
 
  RETURN VALUE
    0           Success                                                 
    1    	Failure
*/
2866

unknown's avatar
unknown committed
2867 2868
int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli, 
			       bool use_rli_only_for_errors)
2869
{
2870
  thd->db_length= db_len;
2871
  thd->db= (char *) rpl_filter->get_rewrite_db(db, &thd->db_length);
2872
  DBUG_ASSERT(thd->query == 0);
unknown's avatar
unknown committed
2873
  thd->query_length= 0;                         // Should not be needed
unknown's avatar
unknown committed
2874
  thd->query_error= 0;
unknown's avatar
unknown committed
2875
  clear_all_errors(thd, rli);
2876 2877 2878

  /* see Query_log_event::exec_event() and BUG#13360 */
  DBUG_ASSERT(!rli->m_table_map.count());
2879 2880 2881 2882
  /*
    Usually mysql_init_query() is called by mysql_parse(), but we need it here
    as the present method does not call mysql_parse().
  */
unknown's avatar
unknown committed
2883
  mysql_init_query(thd, 0, 0);
unknown's avatar
unknown committed
2884
  if (!use_rli_only_for_errors)
2885
  {
2886
    /* Saved for InnoDB, see comment in Query_log_event::exec_event() */
unknown's avatar
unknown committed
2887
    rli->future_group_master_log_pos= log_pos;
2888
    DBUG_PRINT("info", ("log_pos: %lu", (ulong) log_pos));
2889
  }
2890 2891
 
   /*
unknown's avatar
unknown committed
2892 2893 2894 2895 2896 2897 2898 2899 2900 2901
    We test replicate_*_db rules. Note that we have already prepared the file
    to load, even if we are going to ignore and delete it now. So it is
    possible that we did a lot of disk writes for nothing. In other words, a
    big LOAD DATA INFILE on the master will still consume a lot of space on
    the slave (space in the relay log + space of temp files: twice the space
    of the file to load...) even if it will finally be ignored.
    TODO: fix this; this can be done by testing rules in
    Create_file_log_event::exec_event() and then discarding Append_block and
    al. Another way is do the filtering in the I/O thread (more efficient: no
    disk writes at all).
unknown's avatar
unknown committed
2902 2903 2904 2905 2906 2907 2908 2909 2910 2911


    Note:   We do not need to execute reset_one_shot_variables() if this
            db_ok() test fails.
    Reason: The db stored in binlog events is the same for SET and for
            its companion query.  If the SET is ignored because of
            db_ok(), the companion query will also be ignored, and if
            the companion query is ignored in the db_ok() test of
            ::exec_event(), then the companion SET also have so we
            don't need to reset_one_shot_variables().
unknown's avatar
unknown committed
2912
  */
2913
  if (rpl_filter->db_ok(thd->db))
2914
  {
2915 2916
    thd->set_time((time_t)when);
    VOID(pthread_mutex_lock(&LOCK_thread_count));
2917
    thd->query_id = next_query_id();
2918
    VOID(pthread_mutex_unlock(&LOCK_thread_count));
2919 2920 2921 2922 2923 2924
    /*
      Initing thd->row_count is not necessary in theory as this variable has no
      influence in the case of the slave SQL thread (it is used to generate a
      "data truncated" warning but which is absorbed and never gets to the
      error log); still we init it to avoid a Valgrind message.
    */
unknown's avatar
unknown committed
2925
    mysql_reset_errors(thd, 0);
2926 2927 2928 2929

    TABLE_LIST tables;
    bzero((char*) &tables,sizeof(tables));
    tables.db = thd->db;
2930
    tables.alias = tables.table_name = (char*) table_name;
2931
    tables.lock_type = TL_WRITE;
unknown's avatar
unknown committed
2932
    tables.updating= 1;
unknown's avatar
unknown committed
2933

2934
    // the table will be opened in mysql_load    
2935
    if (rpl_filter->is_on() && !rpl_filter->tables_ok(thd->db, &tables))
2936 2937 2938 2939 2940 2941 2942 2943
    {
      // TODO: this is a bug - this needs to be moved to the I/O thread
      if (net)
        skip_load_data_infile(net);
    }
    else
    {
      char llbuff[22];
unknown's avatar
unknown committed
2944
      char *end;
unknown's avatar
unknown committed
2945
      enum enum_duplicates handle_dup;
2946
      bool ignore= 0;
unknown's avatar
unknown committed
2947 2948
      char *load_data_query;

unknown's avatar
unknown committed
2949
      /*
unknown's avatar
unknown committed
2950 2951
        Forge LOAD DATA INFILE query which will be used in SHOW PROCESS LIST
        and written to slave's binlog if binlogging is on.
unknown's avatar
unknown committed
2952
      */
unknown's avatar
unknown committed
2953
      if (!(load_data_query= (char *)thd->alloc(get_query_buffer_length() + 1)))
unknown's avatar
unknown committed
2954
      {
unknown's avatar
unknown committed
2955 2956 2957 2958 2959
        /*
          This will set thd->fatal_error in case of OOM. So we surely will notice
          that something is wrong.
        */
        goto error;
unknown's avatar
unknown committed
2960
      }
unknown's avatar
unknown committed
2961 2962 2963 2964 2965 2966 2967

      print_query(FALSE, load_data_query, &end, (char **)&thd->lex->fname_start,
                  (char **)&thd->lex->fname_end);
      *end= 0;
      thd->query_length= end - load_data_query;
      thd->query= load_data_query;

unknown's avatar
unknown committed
2968
      if (sql_ex.opt_flags & REPLACE_FLAG)
2969
      {
unknown's avatar
unknown committed
2970
	handle_dup= DUP_REPLACE;
2971
      }
unknown's avatar
unknown committed
2972
      else if (sql_ex.opt_flags & IGNORE_FLAG)
2973 2974 2975 2976
      {
        ignore= 1;
        handle_dup= DUP_ERROR;
      }
unknown's avatar
unknown committed
2977
      else
unknown's avatar
unknown committed
2978
      {
unknown's avatar
unknown committed
2979
        /*
unknown's avatar
unknown committed
2980
	  When replication is running fine, if it was DUP_ERROR on the
2981
          master then we could choose IGNORE here, because if DUP_ERROR
unknown's avatar
unknown committed
2982
          suceeded on master, and data is identical on the master and slave,
2983
          then there should be no uniqueness errors on slave, so IGNORE is
unknown's avatar
unknown committed
2984
          the same as DUP_ERROR. But in the unlikely case of uniqueness errors
unknown's avatar
unknown committed
2985 2986 2987
          (because the data on the master and slave happen to be different
	  (user error or bug), we want LOAD DATA to print an error message on
	  the slave to discover the problem.
unknown's avatar
unknown committed
2988 2989

          If reading from net (a 3.23 master), mysql_load() will change this
2990
          to IGNORE.
unknown's avatar
unknown committed
2991 2992
        */
        handle_dup= DUP_ERROR;
unknown's avatar
unknown committed
2993
      }
2994 2995 2996 2997 2998 2999 3000 3001 3002 3003
      /*
        We need to set thd->lex->sql_command and thd->lex->duplicates
        since InnoDB tests these variables to decide if this is a LOAD
        DATA ... REPLACE INTO ... statement even though mysql_parse()
        is not called.  This is not needed in 5.0 since there the LOAD
        DATA ... statement is replicated using mysql_parse(), which
        sets the thd->lex fields correctly.
      */
      thd->lex->sql_command= SQLCOM_LOAD;
      thd->lex->duplicates= handle_dup;
unknown's avatar
unknown committed
3004

unknown's avatar
unknown committed
3005
      sql_exchange ex((char*)fname, sql_ex.opt_flags & DUMPFILE_FLAG);
3006 3007 3008 3009 3010
      String field_term(sql_ex.field_term,sql_ex.field_term_len,log_cs);
      String enclosed(sql_ex.enclosed,sql_ex.enclosed_len,log_cs);
      String line_term(sql_ex.line_term,sql_ex.line_term_len,log_cs);
      String line_start(sql_ex.line_start,sql_ex.line_start_len,log_cs);
      String escaped(sql_ex.escaped,sql_ex.escaped_len, log_cs);
unknown's avatar
unknown committed
3011 3012 3013 3014 3015
      ex.field_term= &field_term;
      ex.enclosed= &enclosed;
      ex.line_term= &line_term;
      ex.line_start= &line_start;
      ex.escaped= &escaped;
3016 3017 3018 3019 3020 3021

      ex.opt_enclosed = (sql_ex.opt_flags & OPT_ENCLOSED_FLAG);
      if (sql_ex.empty_flags & FIELD_TERM_EMPTY)
	ex.field_term->length(0);

      ex.skip_lines = skip_lines;
unknown's avatar
unknown committed
3022
      List<Item> field_list;
3023 3024
      thd->main_lex.select_lex.context.resolve_in_table_list_only(&tables);
      set_fields(thd->db, field_list, &thd->main_lex.select_lex.context);
unknown's avatar
unknown committed
3025
      thd->variables.pseudo_thread_id= thread_id;
unknown's avatar
unknown committed
3026
      List<Item> set_fields;
3027 3028 3029 3030 3031 3032 3033 3034 3035
      if (net)
      {
	// mysql_load will use thd->net to read the file
	thd->net.vio = net->vio;
	/*
	  Make sure the client does not get confused about the packet sequence
	*/
	thd->net.pkt_nr = net->pkt_nr;
      }
unknown's avatar
unknown committed
3036 3037 3038 3039 3040
      /*
        It is safe to use set_fields twice because we are not going to
        update it inside mysql_load().
      */
      if (mysql_load(thd, &ex, &tables, field_list, set_fields, set_fields,
3041
                     handle_dup, ignore, net != 0))
unknown's avatar
unknown committed
3042
        thd->query_error= 1;
3043
      if (thd->cuted_fields)
unknown's avatar
unknown committed
3044
      {
unknown's avatar
unknown committed
3045
	/* log_pos is the position of the LOAD event in the master log */
unknown's avatar
unknown committed
3046 3047 3048 3049 3050 3051 3052
        sql_print_warning("Slave: load data infile on table '%s' at "
                          "log position %s in log '%s' produced %ld "
                          "warning(s). Default database: '%s'",
                          (char*) table_name,
                          llstr(log_pos,llbuff), RPL_LOG_NAME, 
                          (ulong) thd->cuted_fields,
                          print_slave_db_safe(thd->db));
unknown's avatar
unknown committed
3053
      }
3054 3055 3056
      if (net)
        net->pkt_nr= thd->net.pkt_nr;
    }
3057 3058
  }
  else
3059 3060 3061 3062 3063 3064 3065 3066 3067
  {
    /*
      We will just ask the master to send us /dev/null if we do not
      want to load the data.
      TODO: this a bug - needs to be done in I/O thread
    */
    if (net)
      skip_load_data_infile(net);
  }
unknown's avatar
unknown committed
3068 3069

error:
3070
  thd->net.vio = 0; 
3071
  char *save_db= thd->db;
unknown's avatar
unknown committed
3072
  VOID(pthread_mutex_lock(&LOCK_thread_count));
3073
  thd->db= thd->catalog= 0;
unknown's avatar
unknown committed
3074
  thd->query= 0;
unknown's avatar
unknown committed
3075
  thd->query_length= thd->db_length= 0;
unknown's avatar
unknown committed
3076
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
3077 3078 3079
  close_thread_tables(thd);
  if (thd->query_error)
  {
3080
    /* this err/sql_errno code is copy-paste from net_send_error() */
unknown's avatar
unknown committed
3081 3082 3083 3084 3085 3086 3087 3088 3089
    const char *err;
    int sql_errno;
    if ((err=thd->net.last_error)[0])
      sql_errno=thd->net.last_errno;
    else
    {
      sql_errno=ER_UNKNOWN_ERROR;
      err=ER(sql_errno);       
    }
3090
    slave_print_msg(ERROR_LEVEL, rli, sql_errno,"\
unknown's avatar
unknown committed
3091
Error '%s' running LOAD DATA INFILE on table '%s'. Default database: '%s'",
3092
                    err, (char*)table_name, print_slave_db_safe(save_db));
unknown's avatar
unknown committed
3093
    free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
3094 3095
    return 1;
  }
unknown's avatar
unknown committed
3096
  free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
3097
	    
3098
  if (thd->is_fatal_error)
3099
  {
3100
    slave_print_msg(ERROR_LEVEL, rli, ER_UNKNOWN_ERROR, "\
unknown's avatar
unknown committed
3101
Fatal error running LOAD DATA INFILE on table '%s'. Default database: '%s'",
3102
                    (char*)table_name, print_slave_db_safe(save_db));
3103 3104 3105
    return 1;
  }

unknown's avatar
unknown committed
3106
  return ( use_rli_only_for_errors ? 0 : Log_event::exec_event(rli) ); 
3107
}
unknown's avatar
SCRUM  
unknown committed
3108
#endif
3109 3110


unknown's avatar
unknown committed
3111
/**************************************************************************
unknown's avatar
unknown committed
3112
  Rotate_log_event methods
unknown's avatar
unknown committed
3113
**************************************************************************/
3114

unknown's avatar
unknown committed
3115
/*
3116
  Rotate_log_event::pack_info()
unknown's avatar
unknown committed
3117
*/
3118

unknown's avatar
SCRUM  
unknown committed
3119
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3120
void Rotate_log_event::pack_info(Protocol *protocol)
3121
{
unknown's avatar
unknown committed
3122
  char buf1[256], buf[22];
unknown's avatar
unknown committed
3123
  String tmp(buf1, sizeof(buf1), log_cs);
3124
  tmp.length(0);
unknown's avatar
unknown committed
3125
  tmp.append(new_log_ident, ident_len);
3126
  tmp.append(STRING_WITH_LEN(";pos="));
unknown's avatar
unknown committed
3127 3128
  tmp.append(llstr(pos,buf));
  protocol->store(tmp.ptr(), tmp.length(), &my_charset_bin);
3129
}
unknown's avatar
SCRUM  
unknown committed
3130
#endif
3131

3132

unknown's avatar
unknown committed
3133
/*
3134
  Rotate_log_event::print()
unknown's avatar
unknown committed
3135
*/
3136 3137

#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
3138
void Rotate_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3139
{
3140
  char buf[22];
3141

unknown's avatar
unknown committed
3142
  if (print_event_info->short_form)
3143
    return;
unknown's avatar
unknown committed
3144
  print_header(file, print_event_info);
3145 3146 3147
  fprintf(file, "\tRotate to ");
  if (new_log_ident)
    my_fwrite(file, (byte*) new_log_ident, (uint)ident_len, 
3148
              MYF(MY_NABP | MY_WME));
3149
  fprintf(file, "  pos: %s", llstr(pos, buf));
3150
  fputc('\n', file);
3151
  fflush(file);
3152
}
unknown's avatar
unknown committed
3153
#endif /* MYSQL_CLIENT */
3154 3155


3156

unknown's avatar
unknown committed
3157
/*
3158
  Rotate_log_event::Rotate_log_event() (2 constructors)
unknown's avatar
unknown committed
3159
*/
3160

3161 3162

#ifndef MYSQL_CLIENT
3163
Rotate_log_event::Rotate_log_event(const char* new_log_ident_arg,
3164 3165 3166 3167 3168 3169 3170 3171
                                   uint ident_len_arg, ulonglong pos_arg,
                                   uint flags_arg)
  :Log_event(), new_log_ident(new_log_ident_arg),
   pos(pos_arg),ident_len(ident_len_arg ? ident_len_arg :
                          (uint) strlen(new_log_ident_arg)), flags(flags_arg)
{
#ifndef DBUG_OFF
  char buff[22];
3172
  DBUG_ENTER("Rotate_log_event::Rotate_log_event(...,flags)");
3173 3174 3175 3176
  DBUG_PRINT("enter",("new_log_ident %s pos %s flags %lu", new_log_ident_arg,
                      llstr(pos_arg, buff), flags));
#endif
  if (flags & DUP_NAME)
3177
    new_log_ident= my_strndup((const byte*) new_log_ident_arg,
unknown's avatar
unknown committed
3178
                                         ident_len, MYF(MY_WME));
3179 3180 3181 3182 3183
  DBUG_VOID_RETURN;
}
#endif


3184 3185
Rotate_log_event::Rotate_log_event(const char* buf, uint event_len,
                                   const Format_description_log_event* description_event)
unknown's avatar
unknown committed
3186
  :Log_event(buf, description_event) ,new_log_ident(0), flags(DUP_NAME)
3187
{
3188
  DBUG_ENTER("Rotate_log_event::Rotate_log_event(char*,...)");
3189
  // The caller will ensure that event_len is what we have at EVENT_LEN_OFFSET
3190 3191
  uint8 header_size= description_event->common_header_len;
  uint8 post_header_len= description_event->post_header_len[ROTATE_EVENT-1];
3192 3193
  uint ident_offset;
  if (event_len < header_size)
unknown's avatar
unknown committed
3194
    DBUG_VOID_RETURN;
3195
  buf += header_size;
3196 3197 3198 3199
  pos = post_header_len ? uint8korr(buf + R_POS_OFFSET) : 4;
  ident_len = (uint)(event_len -
                     (header_size+post_header_len)); 
  ident_offset = post_header_len; 
3200
  set_if_smaller(ident_len,FN_REFLEN-1);
3201
  new_log_ident= my_strndup((byte*) buf + ident_offset,
3202 3203
                                       (uint) ident_len,
                                       MYF(MY_WME));
unknown's avatar
unknown committed
3204
  DBUG_VOID_RETURN;
3205
}
3206 3207


unknown's avatar
unknown committed
3208
/*
3209
  Rotate_log_event::write()
unknown's avatar
unknown committed
3210
*/
3211

3212
#ifndef MYSQL_CLIENT
3213
bool Rotate_log_event::write(IO_CACHE* file)
3214
{
3215
  char buf[ROTATE_HEADER_LEN];
unknown's avatar
unknown committed
3216
  int8store(buf + R_POS_OFFSET, pos);
3217 3218 3219
  return (write_header(file, ROTATE_HEADER_LEN + ident_len) ||
          my_b_safe_write(file, (byte*)buf, ROTATE_HEADER_LEN) ||
          my_b_safe_write(file, (byte*)new_log_ident, (uint) ident_len));
3220
}
3221
#endif
3222

unknown's avatar
unknown committed
3223
/*
3224 3225
  Rotate_log_event::exec_event()

3226
  Got a rotate log event from the master
3227

3228 3229 3230
  IMPLEMENTATION
    This is mainly used so that we can later figure out the logname and
    position for the master.
3231

3232
    We can't rotate the slave's BINlog as this will cause infinitive rotations
3233
    in a A -> B -> A setup.
3234
    The NOTES below is a wrong comment which will disappear when 4.1 is merged.
3235 3236 3237

  RETURN VALUES
    0	ok
unknown's avatar
unknown committed
3238
*/
3239

unknown's avatar
SCRUM  
unknown committed
3240
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3241
int Rotate_log_event::exec_event(struct st_relay_log_info* rli)
3242
{
3243 3244 3245
  DBUG_ENTER("Rotate_log_event::exec_event");

  pthread_mutex_lock(&rli->data_lock);
3246
  rli->event_relay_log_pos= my_b_tell(rli->cur_log);
unknown's avatar
unknown committed
3247 3248 3249 3250 3251 3252 3253 3254 3255
  /*
    If we are in a transaction: the only normal case is when the I/O thread was
    copying a big transaction, then it was stopped and restarted: we have this
    in the relay log:
    BEGIN
    ...
    ROTATE (a fake one)
    ...
    COMMIT or ROLLBACK
unknown's avatar
unknown committed
3256 3257
    In that case, we don't want to touch the coordinates which correspond to
    the beginning of the transaction.
3258 3259
    Starting from 5.0.0, there also are some rotates from the slave itself, in
    the relay log.
unknown's avatar
unknown committed
3260
  */
unknown's avatar
unknown committed
3261
  if (!(thd->options & OPTION_BEGIN))
unknown's avatar
unknown committed
3262
  {
unknown's avatar
unknown committed
3263 3264
    memcpy(rli->group_master_log_name, new_log_ident, ident_len+1);
    rli->notify_group_master_log_name_update();
3265 3266 3267 3268 3269
    rli->group_master_log_pos= pos;
    rli->group_relay_log_pos= rli->event_relay_log_pos;
    DBUG_PRINT("info", ("group_master_log_name: '%s' group_master_log_pos:\
%lu",
                        rli->group_master_log_name,
unknown's avatar
unknown committed
3270
                        (ulong) rli->group_master_log_pos));
3271
    /*
3272 3273
      Reset thd->options and sql_mode etc, because this could be the signal of
      a master's downgrade from 5.0 to 4.0.
3274 3275 3276 3277 3278
      However, no need to reset description_event_for_exec: indeed, if the next
      master is 5.0 (even 5.0.1) we will soon get a Format_desc; if the next
      master is 4.0 then the events are in the slave's format (conversion).
    */
    set_slave_thread_options(thd);
3279
    set_slave_thread_default_charset(thd, rli);
3280
    thd->variables.sql_mode= global_system_variables.sql_mode;
3281 3282
    thd->variables.auto_increment_increment=
      thd->variables.auto_increment_offset= 1;
unknown's avatar
unknown committed
3283
  }
3284 3285 3286 3287
  pthread_mutex_unlock(&rli->data_lock);
  pthread_cond_broadcast(&rli->data_cond);
  flush_relay_log_info(rli);
  DBUG_RETURN(0);
3288
}
unknown's avatar
SCRUM  
unknown committed
3289
#endif
3290 3291


unknown's avatar
unknown committed
3292
/**************************************************************************
unknown's avatar
unknown committed
3293
	Intvar_log_event methods
unknown's avatar
unknown committed
3294
**************************************************************************/
3295

unknown's avatar
unknown committed
3296
/*
3297
  Intvar_log_event::pack_info()
unknown's avatar
unknown committed
3298
*/
3299

unknown's avatar
SCRUM  
unknown committed
3300
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3301
void Intvar_log_event::pack_info(Protocol *protocol)
3302
{
unknown's avatar
unknown committed
3303 3304
  char buf[256], *pos;
  pos= strmake(buf, get_var_type_name(), sizeof(buf)-23);
unknown's avatar
unknown committed
3305
  *pos++= '=';
unknown's avatar
unknown committed
3306
  pos= longlong10_to_str(val, pos, -10);
unknown's avatar
unknown committed
3307
  protocol->store(buf, (uint) (pos-buf), &my_charset_bin);
3308
}
unknown's avatar
SCRUM  
unknown committed
3309
#endif
3310

unknown's avatar
unknown committed
3311

unknown's avatar
unknown committed
3312
/*
3313
  Intvar_log_event::Intvar_log_event()
unknown's avatar
unknown committed
3314
*/
3315

3316 3317 3318
Intvar_log_event::Intvar_log_event(const char* buf,
                                   const Format_description_log_event* description_event)
  :Log_event(buf, description_event)
3319
{
3320 3321 3322
  buf+= description_event->common_header_len;
  type= buf[I_TYPE_OFFSET];
  val= uint8korr(buf+I_VAL_OFFSET);
3323 3324
}

3325

unknown's avatar
unknown committed
3326
/*
3327
  Intvar_log_event::get_var_type_name()
unknown's avatar
unknown committed
3328
*/
3329 3330

const char* Intvar_log_event::get_var_type_name()
3331
{
3332 3333 3334 3335 3336
  switch(type) {
  case LAST_INSERT_ID_EVENT: return "LAST_INSERT_ID";
  case INSERT_ID_EVENT: return "INSERT_ID";
  default: /* impossible */ return "UNKNOWN";
  }
3337 3338
}

unknown's avatar
unknown committed
3339

unknown's avatar
unknown committed
3340
/*
3341
  Intvar_log_event::write()
unknown's avatar
unknown committed
3342
*/
3343

3344
#ifndef MYSQL_CLIENT
3345
bool Intvar_log_event::write(IO_CACHE* file)
3346
{
3347 3348
  byte buf[9];
  buf[I_TYPE_OFFSET]= (byte) type;
3349
  int8store(buf + I_VAL_OFFSET, val);
3350 3351
  return (write_header(file, sizeof(buf)) ||
          my_b_safe_write(file, buf, sizeof(buf)));
3352
}
3353
#endif
3354

3355

unknown's avatar
unknown committed
3356
/*
3357
  Intvar_log_event::print()
unknown's avatar
unknown committed
3358
*/
3359 3360

#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
3361
void Intvar_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3362
{
3363 3364 3365
  char llbuff[22];
  const char *msg;
  LINT_INIT(msg);
3366

unknown's avatar
unknown committed
3367
  if (!print_event_info->short_form)
3368
  {
unknown's avatar
unknown committed
3369
    print_header(file, print_event_info);
3370 3371
    fprintf(file, "\tIntvar\n");
  }
3372

3373 3374 3375 3376 3377 3378 3379 3380
  fprintf(file, "SET ");
  switch (type) {
  case LAST_INSERT_ID_EVENT:
    msg="LAST_INSERT_ID";
    break;
  case INSERT_ID_EVENT:
    msg="INSERT_ID";
    break;
3381 3382 3383 3384
  case INVALID_INT_EVENT:
  default: // cannot happen
    msg="INVALID_INT";
    break;
3385 3386 3387
  }
  fprintf(file, "%s=%s;\n", msg, llstr(val,llbuff));
  fflush(file);
3388
}
3389
#endif
3390

3391

unknown's avatar
unknown committed
3392
/*
3393
  Intvar_log_event::exec_event()
unknown's avatar
unknown committed
3394
*/
3395

unknown's avatar
SCRUM  
unknown committed
3396
#if defined(HAVE_REPLICATION)&& !defined(MYSQL_CLIENT)
3397
int Intvar_log_event::exec_event(struct st_relay_log_info* rli)
3398
{
3399 3400 3401 3402 3403 3404 3405 3406 3407
  switch (type) {
  case LAST_INSERT_ID_EVENT:
    thd->last_insert_id_used = 1;
    thd->last_insert_id = val;
    break;
  case INSERT_ID_EVENT:
    thd->next_insert_id = val;
    break;
  }
3408
  rli->inc_event_relay_log_pos();
3409
  return 0;
3410
}
unknown's avatar
SCRUM  
unknown committed
3411
#endif
3412

3413

unknown's avatar
unknown committed
3414
/**************************************************************************
3415
  Rand_log_event methods
unknown's avatar
unknown committed
3416
**************************************************************************/
3417

unknown's avatar
SCRUM  
unknown committed
3418
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3419
void Rand_log_event::pack_info(Protocol *protocol)
3420
{
unknown's avatar
unknown committed
3421 3422 3423 3424 3425
  char buf1[256], *pos;
  pos= strmov(buf1,"rand_seed1=");
  pos= int10_to_str((long) seed1, pos, 10);
  pos= strmov(pos, ",rand_seed2=");
  pos= int10_to_str((long) seed2, pos, 10);
3426
  protocol->store(buf1, (uint) (pos-buf1), &my_charset_bin);
3427
}
unknown's avatar
SCRUM  
unknown committed
3428
#endif
3429 3430


3431 3432 3433
Rand_log_event::Rand_log_event(const char* buf,
                               const Format_description_log_event* description_event)
  :Log_event(buf, description_event)
3434
{
3435 3436 3437
  buf+= description_event->common_header_len;
  seed1= uint8korr(buf+RAND_SEED1_OFFSET);
  seed2= uint8korr(buf+RAND_SEED2_OFFSET);
3438 3439
}

3440

3441
#ifndef MYSQL_CLIENT
3442
bool Rand_log_event::write(IO_CACHE* file)
3443
{
3444
  byte buf[16];
3445 3446
  int8store(buf + RAND_SEED1_OFFSET, seed1);
  int8store(buf + RAND_SEED2_OFFSET, seed2);
3447 3448
  return (write_header(file, sizeof(buf)) ||
          my_b_safe_write(file, buf, sizeof(buf)));
3449
}
3450
#endif
3451

3452 3453

#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
3454
void Rand_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3455
{
unknown's avatar
unknown committed
3456
  char llbuff[22],llbuff2[22];
unknown's avatar
unknown committed
3457
  if (!print_event_info->short_form)
3458
  {
unknown's avatar
unknown committed
3459
    print_header(file, print_event_info);
3460
    fprintf(file, "\tRand\n");
3461
  }
unknown's avatar
unknown committed
3462
  fprintf(file, "SET @@RAND_SEED1=%s, @@RAND_SEED2=%s;\n",
unknown's avatar
unknown committed
3463
	  llstr(seed1, llbuff),llstr(seed2, llbuff2));
3464
  fflush(file);
3465
}
unknown's avatar
unknown committed
3466
#endif /* MYSQL_CLIENT */
3467

3468

unknown's avatar
SCRUM  
unknown committed
3469
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3470
int Rand_log_event::exec_event(struct st_relay_log_info* rli)
3471
{
unknown's avatar
unknown committed
3472 3473
  thd->rand.seed1= (ulong) seed1;
  thd->rand.seed2= (ulong) seed2;
3474
  rli->inc_event_relay_log_pos();
3475 3476
  return 0;
}
unknown's avatar
unknown committed
3477
#endif /* !MYSQL_CLIENT */
3478

unknown's avatar
unknown committed
3479

3480 3481 3482 3483 3484 3485 3486
/**************************************************************************
  Xid_log_event methods
**************************************************************************/

#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
void Xid_log_event::pack_info(Protocol *protocol)
{
3487 3488
  char buf[128], *pos;
  pos= strmov(buf, "COMMIT /* xid=");
3489
  pos= longlong10_to_str(xid, pos, 10);
3490
  pos= strmov(pos, " */");
3491 3492 3493 3494
  protocol->store(buf, (uint) (pos-buf), &my_charset_bin);
}
#endif

unknown's avatar
unknown committed
3495 3496 3497 3498 3499 3500 3501 3502
/*
  NOTE it's ok not to use int8store here,
  as long as xid_t::set(ulonglong) and
  xid_t::get_my_xid doesn't do it either

  we don't care about actual values of xids as long as
  identical numbers compare identically
*/
3503 3504 3505 3506

Xid_log_event::
Xid_log_event(const char* buf,
              const Format_description_log_event *description_event)
3507 3508 3509
  :Log_event(buf, description_event)
{
  buf+= description_event->common_header_len;
3510
  memcpy((char*) &xid, buf, sizeof(xid));
3511 3512 3513
}


3514
#ifndef MYSQL_CLIENT
3515 3516 3517 3518 3519
bool Xid_log_event::write(IO_CACHE* file)
{
  return write_header(file, sizeof(xid)) ||
         my_b_safe_write(file, (byte*) &xid, sizeof(xid));
}
3520
#endif
3521 3522 3523


#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
3524
void Xid_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3525
{
unknown's avatar
unknown committed
3526
  if (!print_event_info->short_form)
3527
  {
unknown's avatar
unknown committed
3528 3529 3530
    char buf[64];
    longlong10_to_str(xid, buf, 10);

unknown's avatar
unknown committed
3531
    print_header(file, print_event_info);
unknown's avatar
unknown committed
3532 3533
    fprintf(file, "\tXid = %s\n", buf);
    fflush(file);
3534
  }
3535
  fprintf(file, "COMMIT;\n");
3536 3537 3538 3539 3540 3541 3542
}
#endif /* MYSQL_CLIENT */


#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
int Xid_log_event::exec_event(struct st_relay_log_info* rli)
{
3543
  /* For a slave Xid_log_event is COMMIT */
3544 3545
  general_log_print(thd, COM_QUERY,
                    "COMMIT /* implicit, from Xid_log_event */");
3546
  return end_trans(thd, COMMIT) || Log_event::exec_event(rli);
3547 3548 3549 3550
}
#endif /* !MYSQL_CLIENT */


unknown's avatar
unknown committed
3551
/**************************************************************************
3552
  User_var_log_event methods
unknown's avatar
unknown committed
3553
**************************************************************************/
unknown's avatar
unknown committed
3554

unknown's avatar
unknown committed
3555
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
unknown's avatar
unknown committed
3556 3557 3558
void User_var_log_event::pack_info(Protocol* protocol)
{
  char *buf= 0;
3559
  uint val_offset= 4 + name_len;
unknown's avatar
unknown committed
3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574
  uint event_len= val_offset;

  if (is_null)
  {
    buf= my_malloc(val_offset + 5, MYF(MY_WME));
    strmov(buf + val_offset, "NULL");
    event_len= val_offset + 4;
  }
  else
  {
    switch (type) {
    case REAL_RESULT:
      double real_val;
      float8get(real_val, val);
      buf= my_malloc(val_offset + FLOATING_POINT_BUFFER, MYF(MY_WME));
3575 3576
      event_len+= my_sprintf(buf + val_offset,
			     (buf + val_offset, "%.14g", real_val));
unknown's avatar
unknown committed
3577 3578 3579 3580 3581
      break;
    case INT_RESULT:
      buf= my_malloc(val_offset + 22, MYF(MY_WME));
      event_len= longlong10_to_str(uint8korr(val), buf + val_offset,-10)-buf;
      break;
unknown's avatar
unknown committed
3582 3583 3584 3585 3586 3587 3588 3589 3590 3591
    case DECIMAL_RESULT:
    {
      buf= my_malloc(val_offset + DECIMAL_MAX_STR_LENGTH, MYF(MY_WME));
      String str(buf+val_offset, DECIMAL_MAX_STR_LENGTH, &my_charset_bin);
      my_decimal dec;
      binary2my_decimal(E_DEC_FATAL_ERROR, val+2, &dec, val[0], val[1]);
      my_decimal2string(E_DEC_FATAL_ERROR, &dec, 0, 0, 0, &str);
      event_len= str.length() + val_offset;
      break;
    } 
unknown's avatar
unknown committed
3592
    case STRING_RESULT:
3593 3594 3595 3596 3597 3598 3599 3600 3601 3602
      /* 15 is for 'COLLATE' and other chars */
      buf= my_malloc(event_len+val_len*2+1+2*MY_CS_NAME_SIZE+15, MYF(MY_WME));
      CHARSET_INFO *cs;
      if (!(cs= get_charset(charset_number, MYF(0))))
      {
        strmov(buf+val_offset, "???");
        event_len+= 3;
      }
      else
      {
3603 3604 3605
        char *p= strxmov(buf + val_offset, "_", cs->csname, " ", NullS);
        p= str_to_hex(p, val, val_len);
        p= strxmov(p, " COLLATE ", cs->name, NullS);
3606 3607
        event_len= p-buf;
      }
unknown's avatar
unknown committed
3608
      break;
3609
    case ROW_RESULT:
unknown's avatar
unknown committed
3610
    default:
unknown's avatar
unknown committed
3611 3612 3613 3614 3615
      DBUG_ASSERT(1);
      return;
    }
  }
  buf[0]= '@';
3616 3617 3618 3619
  buf[1]= '`';
  buf[2+name_len]= '`';
  buf[3+name_len]= '=';
  memcpy(buf+2, name, name_len);
3620
  protocol->store(buf, event_len, &my_charset_bin);
unknown's avatar
unknown committed
3621 3622
  my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
}
unknown's avatar
unknown committed
3623
#endif /* !MYSQL_CLIENT */
unknown's avatar
unknown committed
3624 3625


3626 3627 3628 3629
User_var_log_event::
User_var_log_event(const char* buf,
                   const Format_description_log_event* description_event)
  :Log_event(buf, description_event)
unknown's avatar
unknown committed
3630
{
3631
  buf+= description_event->common_header_len;
unknown's avatar
unknown committed
3632 3633
  name_len= uint4korr(buf);
  name= (char *) buf + UV_NAME_LEN_SIZE;
3634 3635
  buf+= UV_NAME_LEN_SIZE + name_len;
  is_null= (bool) *buf;
unknown's avatar
unknown committed
3636 3637 3638
  if (is_null)
  {
    type= STRING_RESULT;
3639
    charset_number= my_charset_bin.number;
unknown's avatar
unknown committed
3640 3641 3642 3643 3644
    val_len= 0;
    val= 0;  
  }
  else
  {
3645 3646 3647
    type= (Item_result) buf[UV_VAL_IS_NULL];
    charset_number= uint4korr(buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE);
    val_len= uint4korr(buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE + 
unknown's avatar
unknown committed
3648
		       UV_CHARSET_NUMBER_SIZE);
3649 3650
    val= (char *) (buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE +
		   UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE);
unknown's avatar
unknown committed
3651 3652 3653 3654
  }
}


3655
#ifndef MYSQL_CLIENT
3656
bool User_var_log_event::write(IO_CACHE* file)
unknown's avatar
unknown committed
3657 3658 3659 3660
{
  char buf[UV_NAME_LEN_SIZE];
  char buf1[UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE + 
	    UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE];
unknown's avatar
unknown committed
3661
  char buf2[max(8, DECIMAL_MAX_FIELD_SIZE + 2)], *pos= buf2;
3662
  uint buf1_length;
3663
  ulong event_length;
3664

unknown's avatar
unknown committed
3665
  int4store(buf, name_len);
3666 3667 3668 3669 3670 3671 3672
  
  if ((buf1[0]= is_null))
  {
    buf1_length= 1;
    val_len= 0;
  }    
  else
unknown's avatar
unknown committed
3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683
  {
    buf1[1]= type;
    int4store(buf1 + 2, charset_number);

    switch (type) {
    case REAL_RESULT:
      float8store(buf2, *(double*) val);
      break;
    case INT_RESULT:
      int8store(buf2, *(longlong*) val);
      break;
unknown's avatar
unknown committed
3684 3685 3686 3687 3688 3689
    case DECIMAL_RESULT:
    {
      my_decimal *dec= (my_decimal *)val;
      dec->fix_buffer_pointer();
      buf2[0]= (char)(dec->intg + dec->frac);
      buf2[1]= (char)dec->frac;
3690
      decimal2bin((decimal_t*)val, buf2+2, buf2[0], buf2[1]);
unknown's avatar
unknown committed
3691 3692 3693
      val_len= decimal_bin_size(buf2[0], buf2[1]) + 2;
      break;
    }
unknown's avatar
unknown committed
3694 3695 3696
    case STRING_RESULT:
      pos= val;
      break;
3697
    case ROW_RESULT:
unknown's avatar
unknown committed
3698
    default:
unknown's avatar
unknown committed
3699 3700 3701
      DBUG_ASSERT(1);
      return 0;
    }
unknown's avatar
unknown committed
3702 3703
    int4store(buf1 + 2 + UV_CHARSET_NUMBER_SIZE, val_len);
    buf1_length= 10;
unknown's avatar
unknown committed
3704
  }
3705 3706 3707 3708 3709 3710

  /* Length of the whole event */
  event_length= sizeof(buf)+ name_len + buf1_length + val_len;

  return (write_header(file, event_length) ||
          my_b_safe_write(file, (byte*) buf, sizeof(buf))   ||
3711 3712 3713
	  my_b_safe_write(file, (byte*) name, name_len)     ||
	  my_b_safe_write(file, (byte*) buf1, buf1_length) ||
	  my_b_safe_write(file, (byte*) pos, val_len));
unknown's avatar
unknown committed
3714
}
3715
#endif
unknown's avatar
unknown committed
3716

3717

unknown's avatar
unknown committed
3718
/*
unknown's avatar
unknown committed
3719
  User_var_log_event::print()
unknown's avatar
unknown committed
3720
*/
unknown's avatar
unknown committed
3721 3722

#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
3723
void User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
unknown's avatar
unknown committed
3724
{
unknown's avatar
unknown committed
3725
  if (!print_event_info->short_form)
unknown's avatar
unknown committed
3726
  {
unknown's avatar
unknown committed
3727
    print_header(file, print_event_info);
unknown's avatar
unknown committed
3728 3729 3730
    fprintf(file, "\tUser_var\n");
  }

3731
  fprintf(file, "SET @`");
unknown's avatar
unknown committed
3732
  my_fwrite(file, (byte*) name, (uint) (name_len), MYF(MY_NABP | MY_WME));
3733
  fprintf(file, "`");
unknown's avatar
unknown committed
3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751

  if (is_null)
  {
    fprintf(file, ":=NULL;\n");
  }
  else
  {
    switch (type) {
    case REAL_RESULT:
      double real_val;
      float8get(real_val, val);
      fprintf(file, ":=%.14g;\n", real_val);
      break;
    case INT_RESULT:
      char int_buf[22];
      longlong10_to_str(uint8korr(val), int_buf, -10);
      fprintf(file, ":=%s;\n", int_buf);
      break;
unknown's avatar
unknown committed
3752 3753 3754 3755 3756 3757
    case DECIMAL_RESULT:
    {
      char str_buf[200];
      int str_len= sizeof(str_buf) - 1;
      int precision= (int)val[0];
      int scale= (int)val[1];
3758 3759
      decimal_digit_t dec_buf[10];
      decimal_t dec;
unknown's avatar
unknown committed
3760 3761 3762 3763 3764 3765
      dec.len= 10;
      dec.buf= dec_buf;

      bin2decimal(val+2, &dec, precision, scale);
      decimal2string(&dec, str_buf, &str_len, 0, 0, 0);
      str_buf[str_len]= 0;
3766
      fprintf(file, ":=%s;\n",str_buf);
unknown's avatar
unknown committed
3767 3768
      break;
    }
unknown's avatar
unknown committed
3769
    case STRING_RESULT:
3770
    {
3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784
      /*
        Let's express the string in hex. That's the most robust way. If we
        print it in character form instead, we need to escape it with
        character_set_client which we don't know (we will know it in 5.0, but
        in 4.1 we don't know it easily when we are printing
        User_var_log_event). Explanation why we would need to bother with
        character_set_client (quoting Bar):
        > Note, the parser doesn't switch to another unescaping mode after
        > it has met a character set introducer.
        > For example, if an SJIS client says something like:
        > SET @a= _ucs2 \0a\0b'
        > the string constant is still unescaped according to SJIS, not
        > according to UCS2.
      */
3785 3786 3787 3788
      char *hex_str;
      CHARSET_INFO *cs;

      if (!(hex_str= (char *)my_alloca(2*val_len+1+2))) // 2 hex digits / byte
3789
        break; // no error, as we are 'void'
3790
      str_to_hex(hex_str, val, val_len);
3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803
      /*
        For proper behaviour when mysqlbinlog|mysql, we need to explicitely
        specify the variable's collation. It will however cause problems when
        people want to mysqlbinlog|mysql into another server not supporting the
        character set. But there's not much to do about this and it's unlikely.
      */
      if (!(cs= get_charset(charset_number, MYF(0))))
        /*
          Generate an unusable command (=> syntax error) is probably the best
          thing we can do here.
        */
        fprintf(file, ":=???;\n");
      else
3804
        fprintf(file, ":=_%s %s COLLATE `%s`;\n", cs->csname, hex_str, cs->name);
3805
      my_afree(hex_str);
3806
    }
unknown's avatar
unknown committed
3807
      break;
3808
    case ROW_RESULT:
unknown's avatar
unknown committed
3809
    default:
unknown's avatar
unknown committed
3810
      DBUG_ASSERT(1);
unknown's avatar
unknown committed
3811 3812 3813 3814 3815
      return;
    }
  }
  fflush(file);
}
unknown's avatar
SCRUM  
unknown committed
3816
#endif
3817

unknown's avatar
unknown committed
3818

unknown's avatar
unknown committed
3819
/*
unknown's avatar
unknown committed
3820
  User_var_log_event::exec_event()
unknown's avatar
unknown committed
3821
*/
unknown's avatar
unknown committed
3822

unknown's avatar
unknown committed
3823
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
unknown's avatar
unknown committed
3824 3825 3826
int User_var_log_event::exec_event(struct st_relay_log_info* rli)
{
  Item *it= 0;
3827 3828 3829
  CHARSET_INFO *charset;
  if (!(charset= get_charset(charset_number, MYF(MY_WME))))
    return 1;
unknown's avatar
unknown committed
3830 3831 3832
  LEX_STRING user_var_name;
  user_var_name.str= name;
  user_var_name.length= name_len;
3833 3834
  double real_val;
  longlong int_val;
unknown's avatar
unknown committed
3835 3836 3837 3838 3839 3840 3841 3842 3843 3844

  if (is_null)
  {
    it= new Item_null();
  }
  else
  {
    switch (type) {
    case REAL_RESULT:
      float8get(real_val, val);
unknown's avatar
unknown committed
3845
      it= new Item_float(real_val);
3846
      val= (char*) &real_val;		// Pointer to value in native format
3847
      val_len= 8;
unknown's avatar
unknown committed
3848 3849
      break;
    case INT_RESULT:
3850 3851 3852
      int_val= (longlong) uint8korr(val);
      it= new Item_int(int_val);
      val= (char*) &int_val;		// Pointer to value in native format
3853
      val_len= 8;
unknown's avatar
unknown committed
3854
      break;
unknown's avatar
unknown committed
3855 3856 3857 3858 3859 3860 3861 3862
    case DECIMAL_RESULT:
    {
      Item_decimal *dec= new Item_decimal(val+2, val[0], val[1]);
      it= dec;
      val= (char *)dec->val_decimal(NULL);
      val_len= sizeof(my_decimal);
      break;
    }
unknown's avatar
unknown committed
3863 3864 3865
    case STRING_RESULT:
      it= new Item_string(val, val_len, charset);
      break;
3866
    case ROW_RESULT:
unknown's avatar
unknown committed
3867
    default:
unknown's avatar
unknown committed
3868 3869 3870 3871 3872
      DBUG_ASSERT(1);
      return 0;
    }
  }
  Item_func_set_user_var e(user_var_name, it);
3873 3874 3875 3876
  /*
    Item_func_set_user_var can't substitute something else on its place =>
    0 can be passed as last argument (reference on item)
  */
3877
  e.fix_fields(thd, 0);
3878 3879 3880 3881 3882
  /*
    A variable can just be considered as a table with
    a single record and with a single column. Thus, like
    a column value, it could always have IMPLICIT derivation.
   */
3883
  e.update_hash(val, val_len, type, charset, DERIVATION_IMPLICIT);
unknown's avatar
unknown committed
3884
  free_root(thd->mem_root,0);
unknown's avatar
unknown committed
3885

3886
  rli->inc_event_relay_log_pos();
unknown's avatar
unknown committed
3887 3888
  return 0;
}
unknown's avatar
unknown committed
3889
#endif /* !MYSQL_CLIENT */
3890 3891


unknown's avatar
unknown committed
3892
/**************************************************************************
3893
  Slave_log_event methods
unknown's avatar
unknown committed
3894
**************************************************************************/
unknown's avatar
unknown committed
3895

unknown's avatar
SCRUM  
unknown committed
3896
#ifdef HAVE_REPLICATION
3897
#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
3898
void Unknown_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3899
{
unknown's avatar
unknown committed
3900
  if (print_event_info->short_form)
3901
    return;
unknown's avatar
unknown committed
3902
  print_header(file, print_event_info);
3903 3904 3905 3906
  fputc('\n', file);
  fprintf(file, "# %s", "Unknown event\n");
}
#endif  
3907

3908
#ifndef MYSQL_CLIENT
3909
void Slave_log_event::pack_info(Protocol *protocol)
3910
{
unknown's avatar
unknown committed
3911
  char buf[256+HOSTNAME_LENGTH], *pos;
3912 3913 3914 3915 3916 3917 3918
  pos= strmov(buf, "host=");
  pos= strnmov(pos, master_host, HOSTNAME_LENGTH);
  pos= strmov(pos, ",port=");
  pos= int10_to_str((long) master_port, pos, 10);
  pos= strmov(pos, ",log=");
  pos= strmov(pos, master_log);
  pos= strmov(pos, ",pos=");
unknown's avatar
unknown committed
3919
  pos= longlong10_to_str(master_pos, pos, 10);
3920
  protocol->store(buf, pos-buf, &my_charset_bin);
3921
}
unknown's avatar
unknown committed
3922
#endif /* !MYSQL_CLIENT */
3923 3924 3925 3926


#ifndef MYSQL_CLIENT
Slave_log_event::Slave_log_event(THD* thd_arg,
unknown's avatar
unknown committed
3927
				 struct st_relay_log_info* rli)
3928
  :Log_event(thd_arg, 0, 0) , mem_pool(0), master_host(0)
3929 3930 3931 3932
{
  DBUG_ENTER("Slave_log_event");
  if (!rli->inited)				// QQ When can this happen ?
    DBUG_VOID_RETURN;
3933

3934 3935 3936 3937 3938
  MASTER_INFO* mi = rli->mi;
  // TODO: re-write this better without holding both locks at the same time
  pthread_mutex_lock(&mi->data_lock);
  pthread_mutex_lock(&rli->data_lock);
  master_host_len = strlen(mi->host);
3939
  master_log_len = strlen(rli->group_master_log_name);
3940 3941 3942
  // on OOM, just do not initialize the structure and print the error
  if ((mem_pool = (char*)my_malloc(get_data_size() + 1,
				   MYF(MY_WME))))
3943
  {
3944 3945 3946
    master_host = mem_pool + SL_MASTER_HOST_OFFSET ;
    memcpy(master_host, mi->host, master_host_len + 1);
    master_log = master_host + master_host_len + 1;
3947
    memcpy(master_log, rli->group_master_log_name, master_log_len + 1);
3948
    master_port = mi->port;
3949
    master_pos = rli->group_master_log_pos;
3950 3951
    DBUG_PRINT("info", ("master_log: %s  pos: %d", master_log,
			(ulong) master_pos));
3952
  }
3953 3954 3955 3956 3957 3958
  else
    sql_print_error("Out of memory while recording slave event");
  pthread_mutex_unlock(&rli->data_lock);
  pthread_mutex_unlock(&mi->data_lock);
  DBUG_VOID_RETURN;
}
unknown's avatar
unknown committed
3959
#endif /* !MYSQL_CLIENT */
3960 3961 3962 3963 3964 3965 3966 3967 3968


Slave_log_event::~Slave_log_event()
{
  my_free(mem_pool, MYF(MY_ALLOW_ZERO_PTR));
}


#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
3969
void Slave_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3970 3971
{
  char llbuff[22];
unknown's avatar
unknown committed
3972
  if (print_event_info->short_form)
3973
    return;
unknown's avatar
unknown committed
3974
  print_header(file, print_event_info);
3975
  fputc('\n', file);
unknown's avatar
unknown committed
3976 3977
  fprintf(file, "\
Slave: master_host: '%s'  master_port: %d  master_log: '%s'  master_pos: %s\n",
3978 3979
	  master_host, master_port, master_log, llstr(master_pos, llbuff));
}
unknown's avatar
unknown committed
3980
#endif /* MYSQL_CLIENT */
3981 3982 3983 3984 3985 3986 3987 3988


int Slave_log_event::get_data_size()
{
  return master_host_len + master_log_len + 1 + SL_MASTER_HOST_OFFSET;
}


3989
#ifndef MYSQL_CLIENT
3990
bool Slave_log_event::write(IO_CACHE* file)
3991
{
3992
  ulong event_length= get_data_size();
3993 3994 3995
  int8store(mem_pool + SL_MASTER_POS_OFFSET, master_pos);
  int2store(mem_pool + SL_MASTER_PORT_OFFSET, master_port);
  // log and host are already there
3996 3997 3998

  return (write_header(file, event_length) ||
          my_b_safe_write(file, (byte*) mem_pool, event_length));
3999
}
4000
#endif
4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011


void Slave_log_event::init_from_mem_pool(int data_size)
{
  master_pos = uint8korr(mem_pool + SL_MASTER_POS_OFFSET);
  master_port = uint2korr(mem_pool + SL_MASTER_PORT_OFFSET);
  master_host = mem_pool + SL_MASTER_HOST_OFFSET;
  master_host_len = strlen(master_host);
  // safety
  master_log = master_host + master_host_len + 1;
  if (master_log > mem_pool + data_size)
4012
  {
4013 4014
    master_host = 0;
    return;
4015
  }
4016 4017
  master_log_len = strlen(master_log);
}
4018

4019

4020 4021 4022
/* This code is not used, so has not been updated to be format-tolerant */
Slave_log_event::Slave_log_event(const char* buf, uint event_len)
  :Log_event(buf,0) /*unused event*/ ,mem_pool(0),master_host(0)
4023
{
4024
  if (event_len < LOG_EVENT_HEADER_LEN)
4025
    return;
4026
  event_len -= LOG_EVENT_HEADER_LEN;
4027 4028 4029 4030 4031
  if (!(mem_pool = (char*) my_malloc(event_len + 1, MYF(MY_WME))))
    return;
  memcpy(mem_pool, buf + LOG_EVENT_HEADER_LEN, event_len);
  mem_pool[event_len] = 0;
  init_from_mem_pool(event_len);
4032 4033
}

4034

4035 4036 4037 4038 4039 4040 4041
#ifndef MYSQL_CLIENT
int Slave_log_event::exec_event(struct st_relay_log_info* rli)
{
  if (mysql_bin_log.is_open())
    mysql_bin_log.write(this);
  return Log_event::exec_event(rli);
}
unknown's avatar
unknown committed
4042
#endif /* !MYSQL_CLIENT */
4043 4044


unknown's avatar
unknown committed
4045
/**************************************************************************
unknown's avatar
unknown committed
4046
	Stop_log_event methods
unknown's avatar
unknown committed
4047
**************************************************************************/
4048

unknown's avatar
unknown committed
4049
/*
4050
  Stop_log_event::print()
4051
*/
4052 4053

#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
4054
void Stop_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
4055
{
unknown's avatar
unknown committed
4056
  if (print_event_info->short_form)
4057 4058
    return;

unknown's avatar
unknown committed
4059
  print_header(file, print_event_info);
4060 4061
  fprintf(file, "\tStop\n");
  fflush(file);
4062
}
unknown's avatar
unknown committed
4063
#endif /* MYSQL_CLIENT */
4064

4065

4066
/*
4067
  Stop_log_event::exec_event()
4068

4069
  The master stopped.
unknown's avatar
unknown committed
4070
  We used to clean up all temporary tables but this is useless as, as the
4071 4072
  master has shut down properly, it has written all DROP TEMPORARY TABLE
  (prepared statements' deletion is TODO only when we binlog prep stmts).
4073 4074 4075
  We used to clean up slave_load_tmpdir, but this is useless as it has been
  cleared at the end of LOAD DATA INFILE.
  So we have nothing to do here.
4076
  The place were we must do this cleaning is in Start_log_event_v3::exec_event(),
4077
  not here. Because if we come here, the master was sane.
4078 4079
*/

4080
#ifndef MYSQL_CLIENT
4081
int Stop_log_event::exec_event(struct st_relay_log_info* rli)
4082
{
unknown's avatar
unknown committed
4083 4084
  /*
    We do not want to update master_log pos because we get a rotate event
4085
    before stop, so by now group_master_log_name is set to the next log.
4086
    If we updated it, we will have incorrect master coordinates and this
unknown's avatar
unknown committed
4087
    could give false triggers in MASTER_POS_WAIT() that we have reached
4088
    the target position when in fact we have not.
unknown's avatar
unknown committed
4089
  */
4090 4091 4092 4093 4094 4095 4096
  if (thd->options & OPTION_BEGIN)
    rli->inc_event_relay_log_pos();
  else
  {
    rli->inc_group_relay_log_pos(0);
    flush_relay_log_info(rli);
  }
4097 4098
  return 0;
}
unknown's avatar
unknown committed
4099
#endif /* !MYSQL_CLIENT */
unknown's avatar
SCRUM  
unknown committed
4100
#endif /* HAVE_REPLICATION */
4101

4102

unknown's avatar
unknown committed
4103
/**************************************************************************
unknown's avatar
unknown committed
4104
	Create_file_log_event methods
unknown's avatar
unknown committed
4105
**************************************************************************/
4106 4107

/*
4108
  Create_file_log_event ctor
unknown's avatar
unknown committed
4109
*/
4110 4111

#ifndef MYSQL_CLIENT
unknown's avatar
unknown committed
4112 4113 4114 4115
Create_file_log_event::
Create_file_log_event(THD* thd_arg, sql_exchange* ex,
		      const char* db_arg, const char* table_name_arg,
		      List<Item>& fields_arg, enum enum_duplicates handle_dup,
4116
                      bool ignore,
unknown's avatar
unknown committed
4117
		      char* block_arg, uint block_len_arg, bool using_trans)
4118
  :Load_log_event(thd_arg,ex,db_arg,table_name_arg,fields_arg,handle_dup, ignore,
unknown's avatar
unknown committed
4119
		  using_trans),
4120
   fake_base(0), block(block_arg), event_buf(0), block_len(block_len_arg),
4121
   file_id(thd_arg->file_id = mysql_bin_log.next_file_id())
4122
{
unknown's avatar
unknown committed
4123
  DBUG_ENTER("Create_file_log_event");
4124
  sql_ex.force_new_format();
unknown's avatar
unknown committed
4125
  DBUG_VOID_RETURN;
4126
}
4127

4128

unknown's avatar
unknown committed
4129
/*
4130
  Create_file_log_event::write_data_body()
unknown's avatar
unknown committed
4131
*/
4132

4133
bool Create_file_log_event::write_data_body(IO_CACHE* file)
4134
{
4135 4136
  bool res;
  if ((res= Load_log_event::write_data_body(file)) || fake_base)
4137 4138
    return res;
  return (my_b_safe_write(file, (byte*) "", 1) ||
4139
          my_b_safe_write(file, (byte*) block, block_len));
4140 4141
}

4142

unknown's avatar
unknown committed
4143
/*
4144
  Create_file_log_event::write_data_header()
unknown's avatar
unknown committed
4145
*/
unknown's avatar
unknown committed
4146

4147
bool Create_file_log_event::write_data_header(IO_CACHE* file)
4148
{
4149
  bool res;
4150
  byte buf[CREATE_FILE_HEADER_LEN];
4151 4152
  if ((res= Load_log_event::write_data_header(file)) || fake_base)
    return res;
4153
  int4store(buf + CF_FILE_ID_OFFSET, file_id);
4154
  return my_b_safe_write(file, buf, CREATE_FILE_HEADER_LEN) != 0;
4155 4156 4157
}


unknown's avatar
unknown committed
4158
/*
4159
  Create_file_log_event::write_base()
unknown's avatar
unknown committed
4160
*/
4161

4162
bool Create_file_log_event::write_base(IO_CACHE* file)
4163
{
4164 4165 4166 4167
  bool res;
  fake_base= 1;                                 // pretend we are Load event
  res= write(file);
  fake_base= 0;
4168 4169 4170
  return res;
}

4171
#endif /* !MYSQL_CLIENT */
4172

unknown's avatar
unknown committed
4173
/*
4174
  Create_file_log_event ctor
unknown's avatar
unknown committed
4175
*/
4176

4177 4178 4179
Create_file_log_event::Create_file_log_event(const char* buf, uint len,
                                             const Format_description_log_event* description_event)
  :Load_log_event(buf,0,description_event),fake_base(0),block(0),inited_from_old(0)
4180
{
4181 4182 4183 4184 4185
  DBUG_ENTER("Create_file_log_event::Create_file_log_event(char*,...)");
  uint block_offset;
  uint header_len= description_event->common_header_len;
  uint8 load_header_len= description_event->post_header_len[LOAD_EVENT-1];
  uint8 create_file_header_len= description_event->post_header_len[CREATE_FILE_EVENT-1];
unknown's avatar
unknown committed
4186
  if (!(event_buf= my_memdup((byte*) buf, len, MYF(MY_WME))) ||
4187 4188 4189 4190 4191 4192 4193
      copy_log_event(event_buf,len,
                     ((buf[EVENT_TYPE_OFFSET] == LOAD_EVENT) ?
                      load_header_len + header_len :
                      (fake_base ? (header_len+load_header_len) :
                       (header_len+load_header_len) +
                       create_file_header_len)),
                     description_event))
unknown's avatar
unknown committed
4194
    DBUG_VOID_RETURN;
4195
  if (description_event->binlog_version!=1)
4196
  {
4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213
    file_id= uint4korr(buf + 
                       header_len +
		       load_header_len + CF_FILE_ID_OFFSET);
    /*
      Note that it's ok to use get_data_size() below, because it is computed
      with values we have already read from this event (because we called
      copy_log_event()); we are not using slave's format info to decode
      master's format, we are really using master's format info.
      Anyway, both formats should be identical (except the common_header_len)
      as these Load events are not changed between 4.0 and 5.0 (as logging of
      LOAD DATA INFILE does not use Load_log_event in 5.0).

      The + 1 is for \0 terminating fname  
    */
    block_offset= (description_event->common_header_len +
                   Load_log_event::get_data_size() +
                   create_file_header_len + 1);
4214 4215 4216 4217 4218 4219 4220 4221 4222
    if (len < block_offset)
      return;
    block = (char*)buf + block_offset;
    block_len = len - block_offset;
  }
  else
  {
    sql_ex.force_new_format();
    inited_from_old = 1;
4223
  }
unknown's avatar
unknown committed
4224
  DBUG_VOID_RETURN;
4225 4226
}

4227

unknown's avatar
unknown committed
4228
/*
4229
  Create_file_log_event::print()
unknown's avatar
unknown committed
4230
*/
4231 4232

#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
4233
void Create_file_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info,
unknown's avatar
unknown committed
4234
				  bool enable_local)
unknown's avatar
unknown committed
4235
{
unknown's avatar
unknown committed
4236
  if (print_event_info->short_form)
4237 4238
  {
    if (enable_local && check_fname_outside_temp_buf())
unknown's avatar
unknown committed
4239
      Load_log_event::print(file, print_event_info);
4240
    return;
4241 4242 4243 4244
  }

  if (enable_local)
  {
unknown's avatar
unknown committed
4245
    Load_log_event::print(file, print_event_info,
4246
			  !check_fname_outside_temp_buf());
unknown's avatar
unknown committed
4247 4248 4249 4250 4251
    /* 
       That one is for "file_id: etc" below: in mysqlbinlog we want the #, in
       SHOW BINLOG EVENTS we don't.
    */
    fprintf(file, "#"); 
4252 4253
  }

4254
  fprintf(file, " file_id: %d  block_len: %d\n", file_id, block_len);
unknown's avatar
unknown committed
4255
}
4256

unknown's avatar
unknown committed
4257

unknown's avatar
unknown committed
4258
void Create_file_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
4259
{
unknown's avatar
unknown committed
4260
  print(file, print_event_info, 0);
4261
}
unknown's avatar
unknown committed
4262
#endif /* MYSQL_CLIENT */
unknown's avatar
unknown committed
4263

4264

unknown's avatar
unknown committed
4265
/*
4266
  Create_file_log_event::pack_info()
unknown's avatar
unknown committed
4267
*/
4268

unknown's avatar
SCRUM  
unknown committed
4269
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4270
void Create_file_log_event::pack_info(Protocol *protocol)
4271
{
4272 4273 4274
  char buf[NAME_LEN*2 + 30 + 21*2], *pos;
  pos= strmov(buf, "db=");
  memcpy(pos, db, db_len);
unknown's avatar
unknown committed
4275
  pos= strmov(pos + db_len, ";table=");
4276
  memcpy(pos, table_name, table_name_len);
unknown's avatar
unknown committed
4277
  pos= strmov(pos + table_name_len, ";file_id=");
4278 4279 4280
  pos= int10_to_str((long) file_id, pos, 10);
  pos= strmov(pos, ";block_len=");
  pos= int10_to_str((long) block_len, pos, 10);
unknown's avatar
unknown committed
4281
  protocol->store(buf, (uint) (pos-buf), &my_charset_bin);
4282
}
unknown's avatar
unknown committed
4283
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
4284 4285


unknown's avatar
unknown committed
4286
/*
4287
  Create_file_log_event::exec_event()
unknown's avatar
unknown committed
4288
*/
4289

unknown's avatar
SCRUM  
unknown committed
4290
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4291
int Create_file_log_event::exec_event(struct st_relay_log_info* rli)
4292
{
unknown's avatar
unknown committed
4293 4294
  char proc_info[17+FN_REFLEN+10], *fname_buf;
  char *ext;
4295 4296 4297
  int fd = -1;
  IO_CACHE file;
  int error = 1;
unknown's avatar
unknown committed
4298

4299
  bzero((char*)&file, sizeof(file));
unknown's avatar
unknown committed
4300 4301
  fname_buf= strmov(proc_info, "Making temp file ");
  ext= slave_load_file_stem(fname_buf, file_id, server_id, ".info");
4302
  thd->proc_info= proc_info;
4303 4304 4305 4306
  my_delete(fname_buf, MYF(0)); // old copy may exist already
  if ((fd= my_create(fname_buf, CREATE_MODE,
		     O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
		     MYF(MY_WME))) < 0 ||
4307 4308 4309
      init_io_cache(&file, fd, IO_SIZE, WRITE_CACHE, (my_off_t)0, 0,
		    MYF(MY_WME|MY_NABP)))
  {
4310 4311
    slave_print_msg(ERROR_LEVEL, rli, my_errno, "Error in Create_file event: "
                    "could not open file '%s'", fname_buf);
4312 4313 4314 4315
    goto err;
  }
  
  // a trick to avoid allocating another buffer
unknown's avatar
unknown committed
4316 4317
  fname= fname_buf;
  fname_len= (uint) (strmov(ext, ".data") - fname);
4318 4319
  if (write_base(&file))
  {
unknown's avatar
unknown committed
4320
    strmov(ext, ".info"); // to have it right in the error message
4321 4322 4323
    slave_print_msg(ERROR_LEVEL, rli, my_errno,
                    "Error in Create_file event: could not write to file '%s'",
                    fname_buf);
4324 4325 4326 4327 4328 4329
    goto err;
  }
  end_io_cache(&file);
  my_close(fd, MYF(0));
  
  // fname_buf now already has .data, not .info, because we did our trick
4330 4331 4332 4333
  my_delete(fname_buf, MYF(0)); // old copy may exist already
  if ((fd= my_create(fname_buf, CREATE_MODE,
		     O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
		     MYF(MY_WME))) < 0)
4334
  {
4335 4336
    slave_print_msg(ERROR_LEVEL, rli, my_errno, "Error in Create_file event: "
                    "could not open file '%s'", fname_buf);
4337 4338
    goto err;
  }
unknown's avatar
unknown committed
4339
  if (my_write(fd, (byte*) block, block_len, MYF(MY_WME+MY_NABP)))
4340
  {
4341 4342
    slave_print_msg(ERROR_LEVEL, rli, my_errno, "Error in Create_file event: "
                    "write to '%s' failed", fname_buf);
4343 4344
    goto err;
  }
4345 4346
  error=0;					// Everything is ok

4347 4348 4349 4350 4351
err:
  if (error)
    end_io_cache(&file);
  if (fd >= 0)
    my_close(fd, MYF(0));
unknown's avatar
unknown committed
4352
  thd->proc_info= 0;
4353
  return error ? 1 : Log_event::exec_event(rli);
4354
}
unknown's avatar
unknown committed
4355
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
4356

4357

unknown's avatar
unknown committed
4358
/**************************************************************************
unknown's avatar
unknown committed
4359
	Append_block_log_event methods
unknown's avatar
unknown committed
4360
**************************************************************************/
4361

unknown's avatar
unknown committed
4362
/*
4363
  Append_block_log_event ctor
unknown's avatar
unknown committed
4364
*/
4365 4366

#ifndef MYSQL_CLIENT  
unknown's avatar
unknown committed
4367 4368
Append_block_log_event::Append_block_log_event(THD* thd_arg, const char* db_arg,
					       char* block_arg,
unknown's avatar
unknown committed
4369 4370 4371
					       uint block_len_arg,
					       bool using_trans)
  :Log_event(thd_arg,0, using_trans), block(block_arg),
unknown's avatar
unknown committed
4372
   block_len(block_len_arg), file_id(thd_arg->file_id), db(db_arg)
4373 4374
{
}
unknown's avatar
unknown committed
4375
#endif
4376 4377


unknown's avatar
unknown committed
4378
/*
4379
  Append_block_log_event ctor
unknown's avatar
unknown committed
4380
*/
4381

4382 4383 4384
Append_block_log_event::Append_block_log_event(const char* buf, uint len,
                                               const Format_description_log_event* description_event)
  :Log_event(buf, description_event),block(0)
4385
{
4386 4387 4388 4389 4390 4391
  DBUG_ENTER("Append_block_log_event::Append_block_log_event(char*,...)");
  uint8 common_header_len= description_event->common_header_len; 
  uint8 append_block_header_len=
    description_event->post_header_len[APPEND_BLOCK_EVENT-1];
  uint total_header_len= common_header_len+append_block_header_len;
  if (len < total_header_len)
unknown's avatar
unknown committed
4392
    DBUG_VOID_RETURN;
4393 4394 4395
  file_id= uint4korr(buf + common_header_len + AB_FILE_ID_OFFSET);
  block= (char*)buf + total_header_len;
  block_len= len - total_header_len;
unknown's avatar
unknown committed
4396
  DBUG_VOID_RETURN;
4397 4398 4399
}


unknown's avatar
unknown committed
4400
/*
4401
  Append_block_log_event::write()
unknown's avatar
unknown committed
4402
*/
4403

4404
#ifndef MYSQL_CLIENT
4405
bool Append_block_log_event::write(IO_CACHE* file)
4406 4407 4408
{
  byte buf[APPEND_BLOCK_HEADER_LEN];
  int4store(buf + AB_FILE_ID_OFFSET, file_id);
4409 4410
  return (write_header(file, APPEND_BLOCK_HEADER_LEN + block_len) ||
          my_b_safe_write(file, buf, APPEND_BLOCK_HEADER_LEN) ||
4411 4412
	  my_b_safe_write(file, (byte*) block, block_len));
}
4413
#endif
4414 4415


unknown's avatar
unknown committed
4416
/*
4417
  Append_block_log_event::print()
unknown's avatar
unknown committed
4418
*/
4419 4420

#ifdef MYSQL_CLIENT  
unknown's avatar
unknown committed
4421
void Append_block_log_event::print(FILE* file,
unknown's avatar
unknown committed
4422
				   PRINT_EVENT_INFO* print_event_info)
4423
{
unknown's avatar
unknown committed
4424
  if (print_event_info->short_form)
4425
    return;
unknown's avatar
unknown committed
4426
  print_header(file, print_event_info);
4427
  fputc('\n', file);
unknown's avatar
unknown committed
4428 4429
  fprintf(file, "#%s: file_id: %d  block_len: %d\n",
	  get_type_str(), file_id, block_len);
4430
}
unknown's avatar
unknown committed
4431
#endif /* MYSQL_CLIENT */
4432 4433


unknown's avatar
unknown committed
4434
/*
4435
  Append_block_log_event::pack_info()
unknown's avatar
unknown committed
4436
*/
4437

unknown's avatar
SCRUM  
unknown committed
4438
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4439
void Append_block_log_event::pack_info(Protocol *protocol)
4440 4441 4442 4443 4444 4445
{
  char buf[256];
  uint length;
  length= (uint) my_sprintf(buf,
			    (buf, ";file_id=%u;block_len=%u", file_id,
			     block_len));
unknown's avatar
unknown committed
4446
  protocol->store(buf, length, &my_charset_bin);
4447 4448 4449
}


unknown's avatar
unknown committed
4450
/*
4451
  Append_block_log_event::get_create_or_append()
unknown's avatar
unknown committed
4452 4453
*/

4454
int Append_block_log_event::get_create_or_append() const
unknown's avatar
unknown committed
4455
{
4456
  return 0; /* append to the file, fail if not exists */
unknown's avatar
unknown committed
4457 4458
}

unknown's avatar
unknown committed
4459
/*
4460
  Append_block_log_event::exec_event()
unknown's avatar
unknown committed
4461
*/
4462

4463
int Append_block_log_event::exec_event(struct st_relay_log_info* rli)
4464
{
4465
  char proc_info[17+FN_REFLEN+10], *fname= proc_info+17;
4466
  int fd;
4467
  int error = 1;
unknown's avatar
unknown committed
4468
  DBUG_ENTER("Append_block_log_event::exec_event");
4469

unknown's avatar
unknown committed
4470 4471
  fname= strmov(proc_info, "Making temp file ");
  slave_load_file_stem(fname, file_id, server_id, ".data");
4472
  thd->proc_info= proc_info;
4473 4474 4475 4476 4477 4478 4479
  if (get_create_or_append())
  {
    my_delete(fname, MYF(0)); // old copy may exist already
    if ((fd= my_create(fname, CREATE_MODE,
		       O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
		       MYF(MY_WME))) < 0)
    {
4480 4481 4482
      slave_print_msg(ERROR_LEVEL, rli, my_errno,
                      "Error in %s event: could not create file '%s'",
                      get_type_str(), fname);
4483 4484 4485
      goto err;
    }
  }
4486 4487
  else if ((fd = my_open(fname, O_WRONLY | O_APPEND | O_BINARY | O_NOFOLLOW,
                         MYF(MY_WME))) < 0)
4488
  {
4489 4490 4491
    slave_print_msg(ERROR_LEVEL, rli, my_errno,
                    "Error in %s event: could not open file '%s'",
                    get_type_str(), fname);
4492 4493
    goto err;
  }
unknown's avatar
unknown committed
4494
  if (my_write(fd, (byte*) block, block_len, MYF(MY_WME+MY_NABP)))
4495
  {
4496 4497 4498
    slave_print_msg(ERROR_LEVEL, rli, my_errno,
                    "Error in %s event: write to '%s' failed",
                    get_type_str(), fname);
4499 4500 4501
    goto err;
  }
  error=0;
4502

4503 4504 4505
err:
  if (fd >= 0)
    my_close(fd, MYF(0));
4506
  thd->proc_info= 0;
unknown's avatar
unknown committed
4507
  DBUG_RETURN(error ? error : Log_event::exec_event(rli));
4508
}
unknown's avatar
SCRUM  
unknown committed
4509
#endif
4510 4511


unknown's avatar
unknown committed
4512
/**************************************************************************
unknown's avatar
unknown committed
4513
	Delete_file_log_event methods
unknown's avatar
unknown committed
4514
**************************************************************************/
4515

unknown's avatar
unknown committed
4516
/*
4517
  Delete_file_log_event ctor
unknown's avatar
unknown committed
4518
*/
4519 4520

#ifndef MYSQL_CLIENT
unknown's avatar
unknown committed
4521 4522 4523
Delete_file_log_event::Delete_file_log_event(THD *thd_arg, const char* db_arg,
					     bool using_trans)
  :Log_event(thd_arg, 0, using_trans), file_id(thd_arg->file_id), db(db_arg)
4524 4525
{
}
unknown's avatar
unknown committed
4526
#endif
4527

unknown's avatar
unknown committed
4528
/*
4529
  Delete_file_log_event ctor
unknown's avatar
unknown committed
4530
*/
4531

4532 4533 4534
Delete_file_log_event::Delete_file_log_event(const char* buf, uint len,
                                             const Format_description_log_event* description_event)
  :Log_event(buf, description_event),file_id(0)
4535
{
4536 4537 4538
  uint8 common_header_len= description_event->common_header_len;
  uint8 delete_file_header_len= description_event->post_header_len[DELETE_FILE_EVENT-1];
  if (len < (uint)(common_header_len + delete_file_header_len))
4539
    return;
4540
  file_id= uint4korr(buf + common_header_len + DF_FILE_ID_OFFSET);
4541 4542 4543
}


unknown's avatar
unknown committed
4544
/*
4545
  Delete_file_log_event::write()
unknown's avatar
unknown committed
4546
*/
4547

4548
#ifndef MYSQL_CLIENT
4549
bool Delete_file_log_event::write(IO_CACHE* file)
4550 4551 4552
{
 byte buf[DELETE_FILE_HEADER_LEN];
 int4store(buf + DF_FILE_ID_OFFSET, file_id);
4553 4554
 return (write_header(file, sizeof(buf)) ||
         my_b_safe_write(file, buf, sizeof(buf)));
4555
}
4556
#endif
4557 4558


unknown's avatar
unknown committed
4559
/*
4560
  Delete_file_log_event::print()
unknown's avatar
unknown committed
4561
*/
4562 4563

#ifdef MYSQL_CLIENT  
unknown's avatar
unknown committed
4564
void Delete_file_log_event::print(FILE* file,
unknown's avatar
unknown committed
4565
				  PRINT_EVENT_INFO* print_event_info)
4566
{
unknown's avatar
unknown committed
4567
  if (print_event_info->short_form)
4568
    return;
unknown's avatar
unknown committed
4569
  print_header(file, print_event_info);
4570 4571 4572
  fputc('\n', file);
  fprintf(file, "#Delete_file: file_id=%u\n", file_id);
}
unknown's avatar
unknown committed
4573
#endif /* MYSQL_CLIENT */
4574

unknown's avatar
unknown committed
4575
/*
4576
  Delete_file_log_event::pack_info()
unknown's avatar
unknown committed
4577
*/
4578

unknown's avatar
SCRUM  
unknown committed
4579
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4580
void Delete_file_log_event::pack_info(Protocol *protocol)
4581 4582 4583 4584
{
  char buf[64];
  uint length;
  length= (uint) my_sprintf(buf, (buf, ";file_id=%u", (uint) file_id));
4585
  protocol->store(buf, (int32) length, &my_charset_bin);
4586
}
unknown's avatar
SCRUM  
unknown committed
4587
#endif
4588

unknown's avatar
unknown committed
4589
/*
4590
  Delete_file_log_event::exec_event()
unknown's avatar
unknown committed
4591
*/
4592

unknown's avatar
SCRUM  
unknown committed
4593
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4594 4595 4596
int Delete_file_log_event::exec_event(struct st_relay_log_info* rli)
{
  char fname[FN_REFLEN+10];
unknown's avatar
unknown committed
4597
  char *ext= slave_load_file_stem(fname, file_id, server_id, ".data");
4598
  (void) my_delete(fname, MYF(MY_WME));
unknown's avatar
unknown committed
4599
  strmov(ext, ".info");
4600 4601 4602
  (void) my_delete(fname, MYF(MY_WME));
  return Log_event::exec_event(rli);
}
unknown's avatar
unknown committed
4603
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
4604 4605


unknown's avatar
unknown committed
4606
/**************************************************************************
unknown's avatar
unknown committed
4607
	Execute_load_log_event methods
unknown's avatar
unknown committed
4608
**************************************************************************/
4609

unknown's avatar
unknown committed
4610
/*
4611
  Execute_load_log_event ctor
unknown's avatar
unknown committed
4612
*/
4613 4614

#ifndef MYSQL_CLIENT  
unknown's avatar
unknown committed
4615 4616 4617
Execute_load_log_event::Execute_load_log_event(THD *thd_arg, const char* db_arg,
					       bool using_trans)
  :Log_event(thd_arg, 0, using_trans), file_id(thd_arg->file_id), db(db_arg)
4618 4619
{
}
unknown's avatar
unknown committed
4620
#endif
4621 4622
  

unknown's avatar
unknown committed
4623
/*
4624
  Execute_load_log_event ctor
unknown's avatar
unknown committed
4625
*/
4626

4627 4628 4629
Execute_load_log_event::Execute_load_log_event(const char* buf, uint len,
                                               const Format_description_log_event* description_event)
  :Log_event(buf, description_event), file_id(0)
4630
{
4631 4632 4633
  uint8 common_header_len= description_event->common_header_len;
  uint8 exec_load_header_len= description_event->post_header_len[EXEC_LOAD_EVENT-1];
  if (len < (uint)(common_header_len+exec_load_header_len))
4634
    return;
4635
  file_id= uint4korr(buf + common_header_len + EL_FILE_ID_OFFSET);
4636 4637 4638
}


unknown's avatar
unknown committed
4639
/*
4640
  Execute_load_log_event::write()
unknown's avatar
unknown committed
4641
*/
4642

4643
#ifndef MYSQL_CLIENT
4644
bool Execute_load_log_event::write(IO_CACHE* file)
4645 4646 4647
{
  byte buf[EXEC_LOAD_HEADER_LEN];
  int4store(buf + EL_FILE_ID_OFFSET, file_id);
4648 4649
  return (write_header(file, sizeof(buf)) || 
          my_b_safe_write(file, buf, sizeof(buf)));
4650
}
4651
#endif
4652 4653


unknown's avatar
unknown committed
4654
/*
4655
  Execute_load_log_event::print()
unknown's avatar
unknown committed
4656
*/
4657 4658

#ifdef MYSQL_CLIENT  
unknown's avatar
unknown committed
4659
void Execute_load_log_event::print(FILE* file,
unknown's avatar
unknown committed
4660
				   PRINT_EVENT_INFO* print_event_info)
4661
{
unknown's avatar
unknown committed
4662
  if (print_event_info->short_form)
4663
    return;
unknown's avatar
unknown committed
4664
  print_header(file, print_event_info);
4665 4666 4667 4668
  fputc('\n', file);
  fprintf(file, "#Exec_load: file_id=%d\n",
	  file_id);
}
unknown's avatar
unknown committed
4669
#endif
4670

unknown's avatar
unknown committed
4671
/*
4672
  Execute_load_log_event::pack_info()
unknown's avatar
unknown committed
4673
*/
4674

unknown's avatar
SCRUM  
unknown committed
4675
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4676
void Execute_load_log_event::pack_info(Protocol *protocol)
4677 4678 4679 4680
{
  char buf[64];
  uint length;
  length= (uint) my_sprintf(buf, (buf, ";file_id=%u", (uint) file_id));
4681
  protocol->store(buf, (int32) length, &my_charset_bin);
4682 4683 4684
}


unknown's avatar
unknown committed
4685
/*
4686
  Execute_load_log_event::exec_event()
unknown's avatar
unknown committed
4687
*/
unknown's avatar
SCRUM  
unknown committed
4688

4689
int Execute_load_log_event::exec_event(struct st_relay_log_info* rli)
4690 4691
{
  char fname[FN_REFLEN+10];
unknown's avatar
unknown committed
4692
  char *ext;
4693
  int fd;
unknown's avatar
unknown committed
4694
  int error= 1;
4695
  IO_CACHE file;
unknown's avatar
unknown committed
4696
  Load_log_event *lev= 0;
4697

unknown's avatar
unknown committed
4698
  ext= slave_load_file_stem(fname, file_id, server_id, ".info");
4699 4700
  if ((fd = my_open(fname, O_RDONLY | O_BINARY | O_NOFOLLOW,
                    MYF(MY_WME))) < 0 ||
4701 4702 4703
      init_io_cache(&file, fd, IO_SIZE, READ_CACHE, (my_off_t)0, 0,
		    MYF(MY_WME|MY_NABP)))
  {
4704 4705
    slave_print_msg(ERROR_LEVEL, rli, my_errno, "Error in Exec_load event: "
                    "could not open file '%s'", fname);
4706 4707
    goto err;
  }
4708
  if (!(lev = (Load_log_event*)Log_event::read_log_event(&file,
4709 4710
                                                         (pthread_mutex_t*)0,
                                                         rli->relay_log.description_event_for_exec)) ||
4711
      lev->get_type_code() != NEW_LOAD_EVENT)
4712
  {
4713 4714
    slave_print_msg(ERROR_LEVEL, rli, 0, "Error in Exec_load event: "
                    "file '%s' appears corrupted", fname);
4715 4716
    goto err;
  }
unknown's avatar
unknown committed
4717

4718
  lev->thd = thd;
4719 4720
  /*
    lev->exec_event should use rli only for errors
unknown's avatar
unknown committed
4721 4722 4723
    i.e. should not advance rli's position.
    lev->exec_event is the place where the table is loaded (it calls
    mysql_load()).
4724
  */
unknown's avatar
unknown committed
4725

4726
  rli->future_group_master_log_pos= log_pos;
4727
  if (lev->exec_event(0,rli,1)) 
4728
  {
4729 4730 4731 4732 4733 4734 4735 4736 4737
    /*
      We want to indicate the name of the file that could not be loaded
      (SQL_LOADxxx).
      But as we are here we are sure the error is in rli->last_slave_error and
      rli->last_slave_errno (example of error: duplicate entry for key), so we
      don't want to overwrite it with the filename.
      What we want instead is add the filename to the current error message.
    */
    char *tmp= my_strdup(rli->last_slave_error,MYF(MY_WME));
4738 4739
    if (tmp)
    {
4740 4741 4742 4743
      slave_print_msg(ERROR_LEVEL, rli,
                      rli->last_slave_errno, /* ok to re-use error code */
                      "%s. Failed executing load from '%s'", 
                      tmp, fname);
4744 4745
      my_free(tmp,MYF(0));
    }
4746 4747
    goto err;
  }
unknown's avatar
unknown committed
4748 4749 4750 4751 4752 4753 4754 4755 4756 4757
  /*
    We have an open file descriptor to the .info file; we need to close it
    or Windows will refuse to delete the file in my_delete().
  */
  if (fd >= 0)
  {
    my_close(fd, MYF(0));
    end_io_cache(&file);
    fd= -1;
  }
4758
  (void) my_delete(fname, MYF(MY_WME));
unknown's avatar
unknown committed
4759
  memcpy(ext, ".data", 6);
4760
  (void) my_delete(fname, MYF(MY_WME));
4761
  error = 0;
4762

4763 4764 4765
err:
  delete lev;
  if (fd >= 0)
4766
  {
4767
    my_close(fd, MYF(0));
4768 4769
    end_io_cache(&file);
  }
4770
  return error ? error : Log_event::exec_event(rli);
4771
}
unknown's avatar
SCRUM  
unknown committed
4772

unknown's avatar
unknown committed
4773
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
4774 4775


unknown's avatar
unknown committed
4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800
/**************************************************************************
	Begin_load_query_log_event methods
**************************************************************************/

#ifndef MYSQL_CLIENT
Begin_load_query_log_event::
Begin_load_query_log_event(THD* thd_arg, const char* db_arg, char* block_arg,
                           uint block_len_arg, bool using_trans)
  :Append_block_log_event(thd_arg, db_arg, block_arg, block_len_arg,
                          using_trans)
{
   file_id= thd_arg->file_id= mysql_bin_log.next_file_id();
}
#endif


Begin_load_query_log_event::
Begin_load_query_log_event(const char* buf, uint len,
                           const Format_description_log_event* desc_event)
  :Append_block_log_event(buf, len, desc_event)
{
}


#if defined( HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4801
int Begin_load_query_log_event::get_create_or_append() const
unknown's avatar
unknown committed
4802
{
4803
  return 1; /* create the file */
unknown's avatar
unknown committed
4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857
}
#endif /* defined( HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */


/**************************************************************************
	Execute_load_query_log_event methods
**************************************************************************/


#ifndef MYSQL_CLIENT
Execute_load_query_log_event::
Execute_load_query_log_event(THD* thd_arg, const char* query_arg,
                     ulong query_length_arg, uint fn_pos_start_arg,
                     uint fn_pos_end_arg,
                     enum_load_dup_handling dup_handling_arg,
                     bool using_trans, bool suppress_use):
  Query_log_event(thd_arg, query_arg, query_length_arg, using_trans,
                  suppress_use),
  file_id(thd_arg->file_id), fn_pos_start(fn_pos_start_arg),
  fn_pos_end(fn_pos_end_arg), dup_handling(dup_handling_arg)
{
}
#endif /* !MYSQL_CLIENT */


Execute_load_query_log_event::
Execute_load_query_log_event(const char* buf, uint event_len,
                             const Format_description_log_event* desc_event):
  Query_log_event(buf, event_len, desc_event, EXECUTE_LOAD_QUERY_EVENT),
  file_id(0), fn_pos_start(0), fn_pos_end(0)
{
  if (!Query_log_event::is_valid())
    return;

  buf+= desc_event->common_header_len;

  fn_pos_start= uint4korr(buf + ELQ_FN_POS_START_OFFSET);
  fn_pos_end= uint4korr(buf + ELQ_FN_POS_END_OFFSET);
  dup_handling= (enum_load_dup_handling)(*(buf + ELQ_DUP_HANDLING_OFFSET));

  if (fn_pos_start > q_len || fn_pos_end > q_len ||
      dup_handling > LOAD_DUP_REPLACE)
    return;

  file_id= uint4korr(buf + ELQ_FILE_ID_OFFSET);
}


ulong Execute_load_query_log_event::get_post_header_size_for_derived()
{
  return EXECUTE_LOAD_QUERY_EXTRA_HEADER_LEN;
}


4858
#ifndef MYSQL_CLIENT
unknown's avatar
unknown committed
4859 4860 4861 4862 4863 4864 4865 4866 4867 4868
bool
Execute_load_query_log_event::write_post_header_for_derived(IO_CACHE* file)
{
  char buf[EXECUTE_LOAD_QUERY_EXTRA_HEADER_LEN];
  int4store(buf, file_id);
  int4store(buf + 4, fn_pos_start);
  int4store(buf + 4 + 4, fn_pos_end);
  *(buf + 4 + 4 + 4)= (char)dup_handling;
  return my_b_safe_write(file, (byte*) buf, EXECUTE_LOAD_QUERY_EXTRA_HEADER_LEN);
}
4869
#endif
unknown's avatar
unknown committed
4870 4871 4872


#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
4873
void Execute_load_query_log_event::print(FILE* file,
unknown's avatar
unknown committed
4874
                                         PRINT_EVENT_INFO* print_event_info)
unknown's avatar
unknown committed
4875
{
unknown's avatar
unknown committed
4876
  print(file, print_event_info, 0);
unknown's avatar
unknown committed
4877 4878 4879
}


unknown's avatar
unknown committed
4880
void Execute_load_query_log_event::print(FILE* file,
unknown's avatar
unknown committed
4881
                                         PRINT_EVENT_INFO* print_event_info,
unknown's avatar
unknown committed
4882 4883
                                         const char *local_fname)
{
unknown's avatar
unknown committed
4884
  print_query_header(file, print_event_info);
unknown's avatar
unknown committed
4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904

  if (local_fname)
  {
    my_fwrite(file, (byte*) query, fn_pos_start, MYF(MY_NABP | MY_WME));
    fprintf(file, " LOCAL INFILE \'");
    fprintf(file, local_fname);
    fprintf(file, "\'");
    if (dup_handling == LOAD_DUP_REPLACE)
      fprintf(file, " REPLACE");
    fprintf(file, " INTO");
    my_fwrite(file, (byte*) query + fn_pos_end, q_len-fn_pos_end,
        MYF(MY_NABP | MY_WME));
    fprintf(file, ";\n");
  }
  else
  {
    my_fwrite(file, (byte*) query, q_len, MYF(MY_NABP | MY_WME));
    fprintf(file, ";\n");
  }

unknown's avatar
unknown committed
4905
  if (!print_event_info->short_form)
unknown's avatar
unknown committed
4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948
    fprintf(file, "# file_id: %d \n", file_id);
}
#endif


#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
void Execute_load_query_log_event::pack_info(Protocol *protocol)
{
  char *buf, *pos;
  if (!(buf= my_malloc(9 + db_len + q_len + 10 + 21, MYF(MY_WME))))
    return;
  pos= buf;
  if (db && db_len)
  {
    pos= strmov(buf, "use `");
    memcpy(pos, db, db_len);
    pos= strmov(pos+db_len, "`; ");
  }
  if (query && q_len)
  {
    memcpy(pos, query, q_len);
    pos+= q_len;
  }
  pos= strmov(pos, " ;file_id=");
  pos= int10_to_str((long) file_id, pos, 10);
  protocol->store(buf, pos-buf, &my_charset_bin);
  my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
}


int
Execute_load_query_log_event::exec_event(struct st_relay_log_info* rli)
{
  char *p;
  char *buf;
  char *fname;
  char *fname_end;
  int error;

  /* Replace filename and LOCAL keyword in query before executing it */
  if (!(buf = my_malloc(q_len + 1 - (fn_pos_end - fn_pos_start) +
                        (FN_REFLEN + 10) + 10 + 8 + 5, MYF(MY_WME))))
  {
4949
    slave_print_msg(ERROR_LEVEL, rli, my_errno, "Not enough memory");
unknown's avatar
unknown committed
4950 4951 4952 4953 4954 4955
    return 1;
  }

  p= buf;
  memcpy(p, query, fn_pos_start);
  p+= fn_pos_start;
4956
  fname= (p= strmake(p, STRING_WITH_LEN(" INFILE \'")));
unknown's avatar
unknown committed
4957 4958
  p= slave_load_file_stem(p, file_id, server_id, ".data");
  fname_end= p= strend(p);                      // Safer than p=p+5
unknown's avatar
unknown committed
4959
  *(p++)='\'';
unknown's avatar
unknown committed
4960
  switch (dup_handling) {
unknown's avatar
unknown committed
4961
  case LOAD_DUP_IGNORE:
4962
    p= strmake(p, STRING_WITH_LEN(" IGNORE"));
unknown's avatar
unknown committed
4963 4964
    break;
  case LOAD_DUP_REPLACE:
4965
    p= strmake(p, STRING_WITH_LEN(" REPLACE"));
unknown's avatar
unknown committed
4966 4967 4968 4969 4970
    break;
  default:
    /* Ordinary load data */
    break;
  }
4971
  p= strmake(p, STRING_WITH_LEN(" INTO"));
unknown's avatar
unknown committed
4972 4973 4974 4975 4976 4977 4978
  p= strmake(p, query+fn_pos_end, q_len-fn_pos_end);

  error= Query_log_event::exec_event(rli, buf, p-buf);

  /* Forging file name for deletion in same buffer */
  *fname_end= 0;

4979 4980 4981 4982 4983 4984
  /*
    If there was an error the slave is going to stop, leave the
    file so that we can re-execute this event at START SLAVE.
  */
  if (!error)
    (void) my_delete(fname, MYF(MY_WME));
unknown's avatar
unknown committed
4985 4986 4987 4988 4989 4990 4991

  my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
  return error;
}
#endif


unknown's avatar
unknown committed
4992
/**************************************************************************
unknown's avatar
unknown committed
4993
	sql_ex_info methods
unknown's avatar
unknown committed
4994
**************************************************************************/
4995

unknown's avatar
unknown committed
4996
/*
4997
  sql_ex_info::write_data()
unknown's avatar
unknown committed
4998
*/
4999

5000
bool sql_ex_info::write_data(IO_CACHE* file)
5001 5002 5003
{
  if (new_format())
  {
5004 5005 5006 5007 5008
    return (write_str(file, field_term, (uint) field_term_len) ||
	    write_str(file, enclosed,   (uint) enclosed_len) ||
	    write_str(file, line_term,  (uint) line_term_len) ||
	    write_str(file, line_start, (uint) line_start_len) ||
	    write_str(file, escaped,    (uint) escaped_len) ||
5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020
	    my_b_safe_write(file,(byte*) &opt_flags,1));
  }
  else
  {
    old_sql_ex old_ex;
    old_ex.field_term= *field_term;
    old_ex.enclosed=   *enclosed;
    old_ex.line_term=  *line_term;
    old_ex.line_start= *line_start;
    old_ex.escaped=    *escaped;
    old_ex.opt_flags=  opt_flags;
    old_ex.empty_flags=empty_flags;
5021
    return my_b_safe_write(file, (byte*) &old_ex, sizeof(old_ex)) != 0;
5022 5023 5024 5025
  }
}


unknown's avatar
unknown committed
5026
/*
5027
  sql_ex_info::init()
unknown's avatar
unknown committed
5028
*/
5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042

char* sql_ex_info::init(char* buf,char* buf_end,bool use_new_format)
{
  cached_new_format = use_new_format;
  if (use_new_format)
  {
    empty_flags=0;
    /*
      The code below assumes that buf will not disappear from
      under our feet during the lifetime of the event. This assumption
      holds true in the slave thread if the log is in new format, but is not
      the case when we have old format because we will be reusing net buffer
      to read the actual file before we write out the Create_file event.
    */
5043 5044 5045 5046 5047
    if (read_str(&buf, buf_end, &field_term, &field_term_len) ||
	read_str(&buf, buf_end, &enclosed,   &enclosed_len) ||
	read_str(&buf, buf_end, &line_term,  &line_term_len) ||
	read_str(&buf, buf_end, &line_start, &line_start_len) ||
	read_str(&buf, buf_end, &escaped,    &escaped_len))
5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073
      return 0;
    opt_flags = *buf++;
  }
  else
  {
    field_term_len= enclosed_len= line_term_len= line_start_len= escaped_len=1;
    field_term = buf++;			// Use first byte in string
    enclosed=	 buf++;
    line_term=   buf++;
    line_start=  buf++;
    escaped=     buf++;
    opt_flags =  *buf++;
    empty_flags= *buf++;
    if (empty_flags & FIELD_TERM_EMPTY)
      field_term_len=0;
    if (empty_flags & ENCLOSED_EMPTY)
      enclosed_len=0;
    if (empty_flags & LINE_TERM_EMPTY)
      line_term_len=0;
    if (empty_flags & LINE_START_EMPTY)
      line_start_len=0;
    if (empty_flags & ESCAPED_EMPTY)
      escaped_len=0;
  }
  return buf;
}
5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085


#ifdef HAVE_ROW_BASED_REPLICATION

/**************************************************************************
	Rows_log_event member functions
**************************************************************************/

#ifndef MYSQL_CLIENT
Rows_log_event::Rows_log_event(THD *thd_arg, TABLE *tbl_arg, ulong tid,
                               MY_BITMAP const *cols, bool is_transactional)
  : Log_event(thd_arg, 0, is_transactional),
5086
    m_row_count(0),
5087 5088
    m_table(tbl_arg),
    m_table_id(tid),
5089 5090
    m_width(tbl_arg ? tbl_arg->s->fields : 1),
    m_rows_buf(0), m_rows_cur(0), m_rows_end(0),
5091 5092
    m_flags(0)
{
5093 5094
  /*
    We allow a special form of dummy event when the table, and cols
5095
    are null and the table id is ~0UL.  This is a temporary
5096 5097
    solution, to be able to terminate a started statement in the
    binary log: the extreneous events will be removed in the future.
5098
   */
5099 5100
  DBUG_ASSERT(tbl_arg && tbl_arg->s && tid != ~0UL ||
              !tbl_arg && !cols && tid == ~0UL);
5101 5102 5103 5104 5105 5106 5107 5108 5109 5110

  if (thd_arg->options & OPTION_NO_FOREIGN_KEY_CHECKS)
      set_flags(NO_FOREIGN_KEY_CHECKS_F);
  if (thd_arg->options & OPTION_RELAXED_UNIQUE_CHECKS)
      set_flags(RELAXED_UNIQUE_CHECKS_F);
  /* if bitmap_init fails, catched in is_valid() */
  if (likely(!bitmap_init(&m_cols,
                          m_width <= sizeof(m_bitbuf)*8 ? m_bitbuf : NULL,
                          (m_width + 7) & ~7UL,
                          false)))
5111 5112 5113 5114 5115
  {
    /* Cols can be zero if this is a dummy binrows event */
    if (likely(cols != NULL))
      memcpy(m_cols.bitmap, cols->bitmap, no_bytes_in_map(cols));
  }
5116 5117 5118 5119 5120 5121 5122 5123 5124 5125
  else
    m_cols.bitmap= 0; // to not free it
}
#endif

Rows_log_event::Rows_log_event(const char *buf, uint event_len,
                               Log_event_type event_type,
                               const Format_description_log_event
                               *description_event)
  : Log_event(buf, description_event),
5126
    m_row_count(0),
5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153
    m_rows_buf(0), m_rows_cur(0), m_rows_end(0)
{
  DBUG_ENTER("Rows_log_event::Rows_log_event(const char*,...)");
  uint8 const common_header_len= description_event->common_header_len;
  uint8 const post_header_len= description_event->post_header_len[event_type-1];

  DBUG_PRINT("enter",("event_len=%ld, common_header_len=%d, "
		      "post_header_len=%d",
		      event_len, common_header_len,
		      post_header_len));

  const char *post_start= buf + common_header_len;
  post_start+= RW_MAPID_OFFSET;
  if (post_header_len == 6)
  {
    /* Master is of an intermediate source tree before 5.1.4. Id is 4 bytes */
    m_table_id= uint4korr(post_start);
    post_start+= 4;
  }
  else
  {
    m_table_id= uint6korr(post_start);
    post_start+= RW_FLAGS_OFFSET;
  }

  m_flags= uint2korr(post_start);

5154 5155
  byte const *const var_start= (const byte *)buf + common_header_len + 
    post_header_len;
5156
  byte const *const ptr_width= var_start;
5157 5158
  uchar *ptr_after_width= (uchar*) ptr_width;
  m_width = net_field_length(&ptr_after_width);
5159 5160

  const uint byte_count= (m_width + 7) / 8;
5161
  const byte* const ptr_rows_data= var_start + byte_count + 1;
5162

5163
  my_size_t const data_size= event_len - (ptr_rows_data - (const byte *) buf);
5164 5165 5166
  DBUG_PRINT("info",("m_table_id=%lu, m_flags=%d, m_width=%u, data_size=%lu",
                     m_table_id, m_flags, m_width, data_size));

5167
  m_rows_buf= (byte*)my_malloc(data_size, MYF(MY_WME));
5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190
  if (likely((bool)m_rows_buf))
  {
    /* if bitmap_init fails, catched in is_valid() */
    if (likely(!bitmap_init(&m_cols,
                            m_width <= sizeof(m_bitbuf)*8 ? m_bitbuf : NULL,
                            (m_width + 7) & ~7UL,
                            false)))
      memcpy(m_cols.bitmap, ptr_after_width, byte_count);
    m_rows_end= m_rows_buf + data_size;
    m_rows_cur= m_rows_end;
    memcpy(m_rows_buf, ptr_rows_data, data_size);
  }
  else
    m_cols.bitmap= 0; // to not free it

  DBUG_VOID_RETURN;
}

Rows_log_event::~Rows_log_event()
{
  if (m_cols.bitmap == m_bitbuf) // no my_malloc happened
    m_cols.bitmap= 0; // so no my_free in bitmap_free
  bitmap_free(&m_cols); // To pair with bitmap_init().
5191
  my_free((gptr)m_rows_buf, MYF(MY_ALLOW_ZERO_PTR));
5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204
}

#ifndef MYSQL_CLIENT
int Rows_log_event::do_add_row_data(byte *const row_data,
                                    my_size_t const length)
{
  /*
    When the table has a primary key, we would probably want, by default, to
    log only the primary key value instead of the entire "before image". This
    would save binlog space. TODO
  */
  DBUG_ENTER("Rows_log_event::do_add_row_data(byte *data, my_size_t length)");
  DBUG_PRINT("enter", ("row_data= %p, length= %lu", row_data, length));
5205
  DBUG_DUMP("row_data", (const char*)row_data, min(length, 32));
5206 5207

  DBUG_ASSERT(m_rows_buf <= m_rows_cur);
5208
  DBUG_ASSERT(!m_rows_buf || m_rows_end && m_rows_buf < m_rows_end);
5209 5210 5211 5212 5213 5214 5215 5216
  DBUG_ASSERT(m_rows_cur <= m_rows_end);

  /* The cast will always work since m_rows_cur <= m_rows_end */
  if (static_cast<my_size_t>(m_rows_end - m_rows_cur) < length)
  {
    my_size_t const block_size= 1024;
    my_ptrdiff_t const old_alloc= m_rows_end - m_rows_buf;
    my_ptrdiff_t const cur_size= m_rows_cur - m_rows_buf;
5217 5218
    my_ptrdiff_t const new_alloc= 
        block_size * ((cur_size + length) / block_size + block_size - 1);
5219

5220 5221
    byte* const new_buf= (byte*)my_realloc((gptr)m_rows_buf, new_alloc,
                                           MYF(MY_ALLOW_ZERO_PTR|MY_WME));
5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241
    if (unlikely(!new_buf))
      DBUG_RETURN(HA_ERR_OUT_OF_MEM);

    /* If the memory moved, we need to move the pointers */
    if (new_buf != m_rows_buf)
    {
      m_rows_buf= new_buf;
      m_rows_cur= m_rows_buf + cur_size;
    }

    /*
       The end pointer should always be changed to point to the end of
       the allocated memory.
    */
    m_rows_end= m_rows_buf + new_alloc;
  }

  DBUG_ASSERT(m_rows_cur + length < m_rows_end);
  memcpy(m_rows_cur, row_data, length);
  m_rows_cur+= length;
5242
  m_row_count++;
5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253
  DBUG_RETURN(0);
}
#endif

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
/*
  Unpack a row into a record. The row is assumed to only consist of the fields
  for which the bitset represented by 'arr' and 'bits'; the other parts of the
  record are left alone.
 */
static char const *unpack_row(TABLE *table,
5254
                              byte *record, char const *row,
5255 5256 5257 5258 5259 5260
                              MY_BITMAP const *cols)
{
  DBUG_ASSERT(record && row);

  MY_BITMAP *write_set= table->file->write_set;
  my_size_t const n_null_bytes= table->s->null_bytes;
5261
  my_ptrdiff_t const offset= record - (byte*) table->record[0];
5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286

  memcpy(record, row, n_null_bytes);
  char const *ptr= row + n_null_bytes;

  bitmap_set_all(write_set);
  Field **const begin_ptr = table->field;
  for (Field **field_ptr= begin_ptr ; *field_ptr ; ++field_ptr)
  {
    Field *const f= *field_ptr;

    if (bitmap_is_set(cols, field_ptr -  begin_ptr))
    {
      /* Field...::unpack() cannot return 0 */
      ptr= f->unpack(f->ptr + offset, ptr);
    }
    else
      bitmap_clear_bit(write_set, (field_ptr - begin_ptr) + 1);
  }
  return ptr;
}

int Rows_log_event::exec_event(st_relay_log_info *rli)
{
  DBUG_ENTER("Rows_log_event::exec_event(st_relay_log_info*)");
  int error= 0;
5287
  char const *row_start= (char const *)m_rows_buf;
5288 5289

  /*
5290
    If m_table_id == ~0UL, then we have a dummy event that does
5291
    not contain any data.  In that case, we just remove all tables in
5292 5293
    the tables_to_lock list, close the thread tables, step the relay
    log position, and return with success.
5294
   */
5295
  if (m_table_id == ~0UL)
5296 5297 5298 5299 5300 5301 5302 5303
  {
    /*
       This one is supposed to be set: just an extra check so that
       nothing strange has happened.
     */
    DBUG_ASSERT(get_flags(STMT_END_F));

    rli->clear_tables_to_lock();
5304
    close_thread_tables(thd);
5305 5306 5307 5308
    thd->clear_error();
    rli->inc_event_relay_log_pos();
    DBUG_RETURN(0);
  }
5309 5310 5311 5312 5313 5314 5315 5316

  /*
    'thd' has been set by exec_relay_log_event(), just before calling
    exec_event(). We still check here to prevent future coding errors.
  */
  DBUG_ASSERT(rli->sql_thd == thd);

  /*
5317 5318 5319 5320
    If there is no locks taken, this is the first binrow event seen
    after the table map events.  We should then lock all the tables
    used in the transaction and proceed with execution of the actual
    event.
5321
  */
5322
  if (!thd->lock)
5323
  {
5324 5325
    bool need_reopen= 1; /* To execute the first lap of the loop below */

5326
    /*
5327 5328 5329
      lock_tables() reads the contents of thd->lex, so they must be
      initialized, so we should call lex_start(); to be even safer, we
      call mysql_init_query() which does a more complete set of inits.
5330
    */
5331
    mysql_init_query(thd, NULL, 0);
5332

5333 5334 5335
    while ((error= lock_tables(thd, rli->tables_to_lock,
                               rli->tables_to_lock_count, &need_reopen)))
    {
5336 5337 5338
      if (!need_reopen)
      {
        slave_print_msg(ERROR_LEVEL, rli, error,
5339 5340
                        "Error in %s event: when locking tables",
                        get_type_str());
5341
        rli->clear_tables_to_lock();
5342 5343
        DBUG_RETURN(error);
      }
5344

5345
      /*
5346
        So we need to reopen the tables.
5347

5348 5349
        We need to flush the pending RBR event, since it keeps a
        pointer to an open table.
5350

5351 5352 5353
        ALTERNATIVE SOLUTION (not implemented): Extract a pointer to
        the pending RBR event and reset the table pointer after the
        tables has been reopened.
5354

5355 5356
        NOTE: For this new scheme there should be no pending event:
        need to add code to assert that is the case.
5357 5358
       */
      thd->binlog_flush_pending_rows_event(false);
5359
      close_tables_for_reopen(thd, &rli->tables_to_lock);
5360

5361 5362
      if ((error= open_tables(thd, &rli->tables_to_lock,
                              &rli->tables_to_lock_count, 0)))
5363 5364 5365 5366 5367 5368 5369 5370 5371
      {
        if (thd->query_error || thd->is_fatal_error)
        {
          /*
            Error reporting borrowed from Query_log_event with many excessive
            simplifications (we don't honour --slave-skip-errors)
          */
          uint actual_error= thd->net.last_errno;
          slave_print_msg(ERROR_LEVEL, rli, actual_error,
5372
                          "Error '%s' on reopening tables",
5373
                          (actual_error ? thd->net.last_error :
5374
                           "unexpected success or fatal error"));
5375 5376
          thd->query_error= 1;
        }
5377
        rli->clear_tables_to_lock();
5378
        DBUG_RETURN(error);
5379
      }
5380
    }
5381 5382 5383 5384 5385
    /*
      When the open and locking succeeded, we add all the tables to
      the table map and remove them from tables to lock.
     */
    
5386 5387
    TABLE_LIST *ptr;
    for (ptr= rli->tables_to_lock ; ptr ; ptr= ptr->next_global)
5388 5389 5390
    {
      rli->m_table_map.set_table(ptr->table_id, ptr->table);
      rli->touching_table(ptr->db, ptr->table_name, ptr->table_id);
5391
    }
5392
    rli->clear_tables_to_lock();
5393 5394
  }

5395 5396
  DBUG_ASSERT(rli->tables_to_lock == NULL && rli->tables_to_lock_count == 0);

5397 5398 5399 5400 5401 5402 5403 5404 5405
  TABLE* table= rli->m_table_map.get_table(m_table_id);

  if (table)
  {
    /*
      table == NULL means that this table should not be replicated
      (this was set up by Table_map_log_event::exec_event() which
      tested replicate-* rules).
    */
5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433

    /*
      It's not needed to set_time() but
      1) it continues the property that "Time" in SHOW PROCESSLIST shows how
      much slave is behind
      2) it will be needed when we allow replication from a table with no
      TIMESTAMP column to a table with one.
      So we call set_time(), like in SBR. Presently it changes nothing.
    */
    thd->set_time((time_t)when);
    /*
      There are a few flags that are replicated with each row event.
      Make sure to set/clear them before executing the main body of
      the event.
    */
    if (get_flags(NO_FOREIGN_KEY_CHECKS_F))
        thd->options|= OPTION_NO_FOREIGN_KEY_CHECKS;
    else
        thd->options&= ~OPTION_NO_FOREIGN_KEY_CHECKS;

    if (get_flags(RELAXED_UNIQUE_CHECKS_F))
        thd->options|= OPTION_RELAXED_UNIQUE_CHECKS;
    else
        thd->options&= ~OPTION_RELAXED_UNIQUE_CHECKS;
    /* A small test to verify that objects have consistent types */
    DBUG_ASSERT(sizeof(thd->options) == sizeof(OPTION_RELAXED_UNIQUE_CHECKS));

    error= do_before_row_operations(table);
5434
    while (error == 0 && row_start < (const char*)m_rows_end) {
5435 5436
      char const *row_end= do_prepare_row(thd, table, row_start);
      DBUG_ASSERT(row_end != NULL); // cannot happen
5437
      DBUG_ASSERT(row_end <= (const char*)m_rows_end);
5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474

      /* in_use can have been set to NULL in close_tables_for_reopen */
      THD* old_thd= table->in_use;
      if (!table->in_use)
        table->in_use= thd;
      error= do_exec_row(table);
      table->in_use = old_thd;
      switch (error)
      {
        /* Some recoverable errors */
      case HA_ERR_RECORD_CHANGED:
      case HA_ERR_KEY_NOT_FOUND:	/* Idempotency support: OK if
                                           tuple does not exist */
	error= 0;
      case 0:
	break;

      default:
	slave_print_msg(ERROR_LEVEL, rli, error,
                        "Error in %s event: row application failed",
                        get_type_str());
	thd->query_error= 1;
	break;
      }

      row_start= row_end;
    }
    DBUG_EXECUTE_IF("STOP_SLAVE_after_first_Rows_event",
                    rli->abort_slave=1;);
    error= do_after_row_operations(table, error);
    if (!cache_stmt)
      thd->options|= OPTION_STATUS_NO_TRANS_UPDATE;
    
  }

  if (error)
  {                     /* error has occured during the transaction */
unknown's avatar
unknown committed
5475 5476 5477 5478 5479 5480
    slave_print_msg(ERROR_LEVEL, rli, error,
                    "Error in %s event: error during transaction execution "
                    "on table %s.%s",
                    get_type_str(), table->s->db.str, 
                    table->s->table_name.str);
     /*
5481 5482 5483 5484 5485 5486 5487 5488 5489
      If one day we honour --skip-slave-errors in row-based replication, and
      the error should be skipped, then we would clear mappings, rollback,
      close tables, but the slave SQL thread would not stop and then may
      assume the mapping is still available, the tables are still open...
      So then we should clear mappings/rollback/close here only if this is a
      STMT_END_F.
      For now we code, knowing that error is not skippable and so slave SQL
      thread is certainly going to stop.
    */
unknown's avatar
unknown committed
5490
    thd->reset_current_stmt_binlog_row_based();
5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533
    rli->cleanup_context(thd, 1);
    thd->query_error= 1;
    DBUG_RETURN(error);
  }

  if (get_flags(STMT_END_F))
  {
    /*
      This is the end of a statement or transaction, so close (and
      unlock) the tables we opened when processing the
      Table_map_log_event starting the statement.

      OBSERVER.  This will clear *all* mappings, not only those that
      are open for the table. There is not good handle for on-close
      actions for tables.

      NOTE. Even if we have no table ('table' == 0) we still need to be
      here, so that we increase the group relay log position. If we didn't, we
      could have a group relay log position which lags behind "forever"
      (assume the last master's transaction is ignored by the slave because of
      replicate-ignore rules).
    */
    thd->binlog_flush_pending_rows_event(true);
    /*
      If this event is not in a transaction, the call below will, if some
      transactional storage engines are involved, commit the statement into
      them and flush the pending event to binlog.
      If this event is in a transaction, the call will do nothing, but a
      Xid_log_event will come next which will, if some transactional engines
      are involved, commit the transaction and flush the pending event to the
      binlog.
    */
    error= ha_autocommit_or_rollback(thd, 0);
    /*
      Now what if this is not a transactional engine? we still need to
      flush the pending event to the binlog; we did it with
      thd->binlog_flush_pending_rows_event(). Note that we imitate
      what is done for real queries: a call to
      ha_autocommit_or_rollback() (sometimes only if involves a
      transactional engine), and a call to be sure to have the pending
      event flushed.
    */

unknown's avatar
unknown committed
5534
    thd->reset_current_stmt_binlog_row_based();
5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554
    rli->cleanup_context(thd, 0);
    rli->transaction_end(thd);

    if (error == 0)
    {
      /*
        Clear any errors pushed in thd->net.last_err* if for example "no key
        found" (as this is allowed). This is a safety measure; apparently
        those errors (e.g. when executing a Delete_rows_log_event of a
        non-existing row, like in rpl_row_mystery22.test,
        thd->net.last_error = "Can't find record in 't1'" and last_errno=1032)
        do not become visible. We still prefer to wipe them out.
      */
      thd->clear_error();
      error= Log_event::exec_event(rli);
    }
    else
      slave_print_msg(ERROR_LEVEL, rli, error,
                      "Error in %s event: commit of row events failed, "
                      "table `%s`.`%s`",
unknown's avatar
unknown committed
5555 5556
                      get_type_str(), table->s->db.str, 
                      table->s->table_name.str);
5557 5558 5559
    DBUG_RETURN(error);
  }

5560
  if (table && (table->s->primary_key == MAX_KEY) && !cache_stmt)
5561 5562
  {
    /*
5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576
      ------------ Temporary fix until WL#2975 is implemented ---------

      This event is not the last one (no STMT_END_F). If we stop now
      (in case of terminate_slave_thread()), how will we restart? We
      have to restart from Table_map_log_event, but as this table is
      not transactional, the rows already inserted will still be
      present, and idempotency is not guaranteed (no PK) so we risk
      that repeating leads to double insert. So we desperately try to
      continue, hope we'll eventually leave this buggy situation (by
      executing the final Rows_log_event). If we are in a hopeless
      wait (reached end of last relay log and nothing gets appended
      there), we timeout after one minute, and notify DBA about the
      problem.  When WL#2975 is implemented, just remove the member
      st_relay_log_info::unsafe_to_stop_at and all its occurences.
5577
    */
5578
    rli->unsafe_to_stop_at= time(0);
5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609
  }

  DBUG_ASSERT(error == 0);
  thd->clear_error();
  rli->inc_event_relay_log_pos();
  
  DBUG_RETURN(0);
}
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */

#ifndef MYSQL_CLIENT
bool Rows_log_event::write_data_header(IO_CACHE *file)
{
  byte buf[ROWS_HEADER_LEN];	// No need to init the buffer
  DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master",
                  {
                    int4store(buf + 0, m_table_id);
                    int2store(buf + 4, m_flags);
                    return (my_b_safe_write(file, buf, 6));
                  });
  int6store(buf + RW_MAPID_OFFSET, (ulonglong)m_table_id);
  int2store(buf + RW_FLAGS_OFFSET, m_flags);
  return (my_b_safe_write(file, buf, ROWS_HEADER_LEN));
}

bool Rows_log_event::write_data_body(IO_CACHE*file)
{
  /*
     Note that this should be the number of *bits*, not the number of
     bytes.
  */
unknown's avatar
unknown committed
5610
  char sbuf[sizeof(m_width)];
5611 5612
  my_ptrdiff_t const data_size= m_rows_cur - m_rows_buf;

unknown's avatar
unknown committed
5613
  char *const sbuf_end= net_store_length((char*) sbuf, (uint) m_width);
unknown's avatar
unknown committed
5614
  DBUG_ASSERT(static_cast<my_size_t>(sbuf_end - sbuf) <= sizeof(sbuf));
5615

unknown's avatar
unknown committed
5616 5617
  return (my_b_safe_write(file, reinterpret_cast<byte*>(sbuf),
                          sbuf_end - sbuf) ||
5618 5619 5620 5621 5622 5623
          my_b_safe_write(file, reinterpret_cast<byte*>(m_cols.bitmap),
                          no_bytes_in_map(&m_cols)) ||
          my_b_safe_write(file, m_rows_buf, data_size));
}
#endif

5624
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
5625 5626
void Rows_log_event::pack_info(Protocol *protocol)
{
5627 5628 5629
  char buf[256];
  char const *const flagstr=
    get_flags(STMT_END_F) ? " flags: STMT_END_F" : "";
unknown's avatar
unknown committed
5630 5631
  my_size_t bytes= my_snprintf(buf, sizeof(buf),
                               "table_id: %lu%s", m_table_id, flagstr);
5632
  protocol->store(buf, bytes, &my_charset_bin);
5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657
}
#endif

/**************************************************************************
	Table_map_log_event member functions
**************************************************************************/

/*
  Constructor used to build an event for writing to the binary log.
  Mats says tbl->s lives longer than this event so it's ok to copy pointers
  (tbl->s->db etc) and not pointer content.
 */
#if !defined(MYSQL_CLIENT)
Table_map_log_event::Table_map_log_event(THD *thd, TABLE *tbl, ulong tid,
                                         bool is_transactional, uint16 flags)
  : Log_event(thd, 0, is_transactional),
    m_table(tbl),
    m_dbnam(tbl->s->db.str),
    m_dblen(m_dbnam ? tbl->s->db.length : 0),
    m_tblnam(tbl->s->table_name.str),
    m_tbllen(tbl->s->table_name.length),
    m_colcnt(tbl->s->fields), m_coltype(0),
    m_table_id(tid),
    m_flags(flags)
{
5658
  DBUG_ASSERT(m_table_id != ~0UL);
5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670
  /*
    In TABLE_SHARE, "db" and "table_name" are 0-terminated (see this comment in
    table.cc / alloc_table_share():
      Use the fact the key is db/0/table_name/0
    As we rely on this let's assert it.
  */
  DBUG_ASSERT((tbl->s->db.str == 0) ||
              (tbl->s->db.str[tbl->s->db.length] == 0));
  DBUG_ASSERT(tbl->s->table_name.str[tbl->s->table_name.length] == 0);


  m_data_size=  TABLE_MAP_HEADER_LEN;
unknown's avatar
unknown committed
5671
  DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master", m_data_size= 6;);
5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725
  m_data_size+= m_dblen + 2;	// Include length and terminating \0
  m_data_size+= m_tbllen + 2;	// Include length and terminating \0
  m_data_size+= 1 + m_colcnt;	// COLCNT and column types

  /* If malloc fails, catched in is_valid() */
  if ((m_memory= my_malloc(m_colcnt, MYF(MY_WME))))
  {
    m_coltype= reinterpret_cast<unsigned char*>(m_memory);
    for (unsigned int i= 0 ; i < m_table->s->fields ; ++i)
      m_coltype[i]= m_table->field[i]->type();
  }
}
#endif /* !defined(MYSQL_CLIENT) */

/*
  Constructor used by slave to read the event from the binary log.
 */
#if defined(HAVE_REPLICATION)
Table_map_log_event::Table_map_log_event(const char *buf, uint event_len,
                                         const Format_description_log_event
                                         *description_event)

  : Log_event(buf, description_event),
#ifndef MYSQL_CLIENT
  m_table(NULL),
#endif
  m_memory(NULL)
{
  DBUG_ENTER("Table_map_log_event::Table_map_log_event(const char*,uint,...)");

  uint8 common_header_len= description_event->common_header_len;
  uint8 post_header_len= description_event->post_header_len[TABLE_MAP_EVENT-1];
  DBUG_PRINT("info",("event_len=%ld, common_header_len=%d, post_header_len=%d",
                     event_len, common_header_len, post_header_len));

  DBUG_DUMP("event buffer", buf, event_len);

  /* Read the post-header */
  const char *post_start= buf + common_header_len;

  post_start+= TM_MAPID_OFFSET;
  if (post_header_len == 6)
  {
    /* Master is of an intermediate source tree before 5.1.4. Id is 4 bytes */
    m_table_id= uint4korr(post_start);
    post_start+= 4;
  }
  else
  {
    DBUG_ASSERT(post_header_len == TABLE_MAP_HEADER_LEN);
    m_table_id= uint6korr(post_start);
    post_start+= TM_FLAGS_OFFSET;
  }

5726
  DBUG_ASSERT(m_table_id != ~0UL);
5727 5728 5729 5730 5731 5732 5733

  m_flags= uint2korr(post_start);

  /* Read the variable part of the event */
  const char *const vpart= buf + common_header_len + post_header_len;

  /* Extract the length of the various parts from the buffer */
5734
  byte const* const ptr_dblen= (byte const*)vpart + 0;
5735 5736 5737 5738 5739 5740 5741 5742
  m_dblen= *(unsigned char*) ptr_dblen;

  /* Length of database name + counter + terminating null */
  byte const* const ptr_tbllen= ptr_dblen + m_dblen + 2;
  m_tbllen= *(unsigned char*) ptr_tbllen;

  /* Length of table name + counter + terminating null */
  byte const* const ptr_colcnt= ptr_tbllen + m_tbllen + 2;
5743 5744
  uchar *ptr_after_colcnt= (uchar*) ptr_colcnt;
  m_colcnt= net_field_length(&ptr_after_colcnt);
5745 5746

  DBUG_PRINT("info",("m_dblen=%d off=%d m_tbllen=%d off=%d m_colcnt=%d off=%d",
5747 5748 5749
                     m_dblen, ptr_dblen-(const byte*)vpart, 
                     m_tbllen, ptr_tbllen-(const byte*)vpart,
                     m_colcnt, ptr_colcnt-(const byte*)vpart));
5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760

  /* Allocate mem for all fields in one go. If fails, catched in is_valid() */
  m_memory= my_multi_malloc(MYF(MY_WME),
			    &m_dbnam, m_dblen + 1,
			    &m_tblnam, m_tbllen + 1,
			    &m_coltype, m_colcnt,
			    NULL);

  if (m_memory)
  {
    /* Copy the different parts into their memory */
5761 5762
    strncpy(const_cast<char*>(m_dbnam), (const char*)ptr_dblen  + 1, m_dblen + 1);
    strncpy(const_cast<char*>(m_tblnam), (const char*)ptr_tbllen + 1, m_tbllen + 1);
5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797
    memcpy(m_coltype, ptr_after_colcnt, m_colcnt);
  }

  DBUG_VOID_RETURN;
}
#endif

Table_map_log_event::~Table_map_log_event()
{
  my_free(m_memory, MYF(MY_ALLOW_ZERO_PTR));
}

/*
  Return value is an error code, one of:

      -1     Failure to open table   [from open_tables()]
       0     Success
       1     No room for more tables [from set_table()]
       2     Out of memory           [from set_table()]
       3     Wrong table definition
       4     Daisy-chaining RBR with SBR not possible
 */

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
int Table_map_log_event::exec_event(st_relay_log_info *rli)
{
  DBUG_ENTER("Table_map_log_event::exec_event(st_relay_log_info*)");

  DBUG_ASSERT(rli->sql_thd == thd);

  /* Step the query id to mark what columns that are actually used. */
  pthread_mutex_lock(&LOCK_thread_count);
  thd->query_id= next_query_id();
  pthread_mutex_unlock(&LOCK_thread_count);

5798 5799 5800 5801 5802 5803 5804 5805 5806
  TABLE_LIST *table_list;
  char *db_mem, *tname_mem;
  void *const memory=
    my_multi_malloc(MYF(MY_WME),
                    &table_list, sizeof(TABLE_LIST),
                    &db_mem, NAME_LEN + 1,
                    &tname_mem, NAME_LEN + 1,
                    NULL);

5807 5808
  if (memory == NULL)
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5809

5810
  uint32 dummy_len;
5811 5812 5813 5814 5815 5816 5817 5818 5819
  bzero(table_list, sizeof(*table_list));
  table_list->db = db_mem;
  table_list->alias= table_list->table_name = tname_mem;
  table_list->lock_type= TL_WRITE;
  table_list->next_global= table_list->next_local= 0;
  table_list->table_id= m_table_id;
  table_list->updating= 1;
  strmov(table_list->db, rpl_filter->get_rewrite_db(m_dbnam, &dummy_len));
  strmov(table_list->table_name, m_tblnam);
5820 5821 5822

  int error= 0;

5823 5824 5825 5826 5827 5828
  if (!rpl_filter->db_ok(table_list->db) ||
      (rpl_filter->is_on() && !rpl_filter->tables_ok("", table_list)))
  {
    my_free((gptr) memory, MYF(MY_WME));
  }
  else
5829
  {
5830
    /*
unknown's avatar
unknown committed
5831 5832 5833
      Check if the slave is set to use SBR.  If so, it should switch
      to using RBR until the end of the "statement", i.e., next
      STMT_END_F or next error.
5834
    */
unknown's avatar
unknown committed
5835 5836
    if (!thd->current_stmt_binlog_row_based &&
        mysql_bin_log.is_open() && (thd->options & OPTION_BIN_LOG))
5837
    {
unknown's avatar
unknown committed
5838
      thd->set_current_stmt_binlog_row_based();
5839 5840 5841 5842 5843 5844 5845 5846 5847
    }

    /*
      Open the table if it is not already open and add the table to table map.
      If the table should not be replicated, we don't bother to do anything.
      The table map will return NULL and the row-level event will effectively
      be a no-op.
    */
    uint count;
5848 5849 5850 5851 5852 5853 5854
    /*
      open_tables() reads the contents of thd->lex, so they must be
      initialized, so we should call lex_start(); to be even safer, we
      call mysql_init_query() which does a more complete set of inits.
    */
    mysql_init_query(thd, NULL, 0);
    if ((error= open_tables(thd, &table_list, &count, 0)))
5855
    {
5856
      if (thd->query_error || thd->is_fatal_error)
5857
      {
5858 5859 5860
        /*
          Error reporting borrowed from Query_log_event with many excessive
          simplifications (we don't honour --slave-skip-errors)
5861 5862 5863 5864 5865

          BUG: There can be extreneous table maps in the binary log,
          so in case we fail to open the table, we just generate a
          warning and do not add the table to the list of tables to
          open and lock.
5866 5867
        */
        uint actual_error= thd->net.last_errno;
5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888
        switch (actual_error)
        {
        case ER_NO_SUCH_TABLE:
          slave_print_msg(WARNING_LEVEL, rli, actual_error,
                          thd->net.last_error ?
                          thd->net.last_error :
                          "<no message>");
          clear_all_errors(thd, rli);
          rli->inc_event_relay_log_pos();       // Continue with next event
          error= 0;
          break;

        default:
          slave_print_msg(ERROR_LEVEL, rli, actual_error,
                          "Error '%s' on opening table `%s`.`%s`",
                          (actual_error ? thd->net.last_error :
                           "unexpected success or fatal error"),
                          table_list->db, table_list->table_name);
          thd->query_error= 1;
          break;
        }
5889
      }
5890
      DBUG_RETURN(error);
5891 5892
    }

5893
    m_table= table_list->table;
5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970

    /*
      This will fail later otherwise, the 'in_use' field should be
      set to the current thread.
    */
    DBUG_ASSERT(m_table->in_use);

    /*
      Check that the number of columns and the field types in the
      event match the number of columns and field types in the opened
      table.
     */
    uint col= m_table->s->fields;

    if (col == m_colcnt)
    {
      while (col-- > 0)
        if (m_table->field[col]->type() != m_coltype[col])
          break;
    }

    TABLE_SHARE const *const tsh= m_table->s;

    /*
      Check the following termination conditions:

      (col == m_table->s->fields)
          ==> (m_table->s->fields != m_colcnt)
      (0 <= col < m_table->s->fields)
          ==> (m_table->field[col]->type() != m_coltype[col])

      Logically, A ==> B is equivalent to !A || B

      Since col is unsigned, is suffices to check that col <=
      tsh->fields.  If col wrapped (by decreasing col when it is 0),
      the number will be UINT_MAX, which is greater than tsh->fields.
    */
    DBUG_ASSERT(!(col == tsh->fields) || tsh->fields != m_colcnt);
    DBUG_ASSERT(!(col < tsh->fields) ||
                (m_table->field[col]->type() != m_coltype[col]));

    if (col <= tsh->fields)
    {
      /*
        If we get here, the number of columns in the event didn't
        match the number of columns in the table on the slave, *or*
        there were a column in the table on the slave that did not
        have the same type as given in the event.

        If 'col' has the value that was assigned to it, it was a
        mismatch between the number of columns on the master and the
        slave.
       */
      if (col == tsh->fields)
      {
        DBUG_ASSERT(tsh->db.str && tsh->table_name.str);
        slave_print_msg(ERROR_LEVEL, rli, ER_BINLOG_ROW_WRONG_TABLE_DEF,
                        "Table width mismatch - "
                        "received %u columns, %s.%s has %u columns",
                        m_colcnt, tsh->db.str, tsh->table_name.str, tsh->fields);
      }
      else
      {
        DBUG_ASSERT(col < m_colcnt && col < tsh->fields);
        DBUG_ASSERT(tsh->db.str && tsh->table_name.str);
        slave_print_msg(ERROR_LEVEL, rli, ER_BINLOG_ROW_WRONG_TABLE_DEF,
                        "Column %d type mismatch - "
                        "received type %d, %s.%s has type %d",
                        col, m_coltype[col], tsh->db.str, tsh->table_name.str,
                        m_table->field[col]->type());
      }

      thd->query_error= 1;
      DBUG_RETURN(ERR_BAD_TABLE_DEF);
    }

    /*
5971 5972 5973
      We record in the slave's information that the table should be
      locked by linking the table into the list of tables to lock, and
      tell the RLI that we are touching a table.
5974 5975
    */
    if (!error)
5976 5977 5978 5979 5980
    {
      table_list->next_global= table_list->next_local= rli->tables_to_lock;
      rli->tables_to_lock= table_list;
      rli->tables_to_lock_count++;
    }
5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002
  }

  /*
    We explicitly do not call Log_event::exec_event() here since we do not
    want the relay log position to be flushed to disk. The flushing will be
    done by the last Rows_log_event that either ends a statement (outside a
    transaction) or a transaction.

    A table map event can *never* end a transaction or a statement, so we
    just step the relay log position.
  */

  if (likely(!error))
    rli->inc_event_relay_log_pos();

  DBUG_RETURN(error);
}
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */

#ifndef MYSQL_CLIENT
bool Table_map_log_event::write_data_header(IO_CACHE *file)
{
6003
  DBUG_ASSERT(m_table_id != ~0UL);
6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026
  byte buf[TABLE_MAP_HEADER_LEN];
  DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master",
                  {
                    int4store(buf + 0, m_table_id);
                    int2store(buf + 4, m_flags);
                    return (my_b_safe_write(file, buf, 6));
                  });
  int6store(buf + TM_MAPID_OFFSET, (ulonglong)m_table_id);
  int2store(buf + TM_FLAGS_OFFSET, m_flags);
  return (my_b_safe_write(file, buf, TABLE_MAP_HEADER_LEN));
}

bool Table_map_log_event::write_data_body(IO_CACHE *file)
{
  DBUG_ASSERT(m_dbnam != NULL);
  DBUG_ASSERT(m_tblnam != NULL);
  /* We use only one byte per length for storage in event: */
  DBUG_ASSERT(m_dblen < 128);
  DBUG_ASSERT(m_tbllen < 128);

  byte const dbuf[]= { m_dblen };
  byte const tbuf[]= { m_tbllen };

unknown's avatar
unknown committed
6027
  char cbuf[sizeof(m_colcnt)];
unknown's avatar
unknown committed
6028
  char *const cbuf_end= net_store_length((char*) cbuf, (uint) m_colcnt);
unknown's avatar
unknown committed
6029
  DBUG_ASSERT(static_cast<my_size_t>(cbuf_end - cbuf) <= sizeof(cbuf));
6030

6031
  return (my_b_safe_write(file, dbuf,      sizeof(dbuf)) ||
6032
          my_b_safe_write(file, (const byte*)m_dbnam,   m_dblen+1) ||
6033
          my_b_safe_write(file, tbuf,      sizeof(tbuf)) ||
6034
          my_b_safe_write(file, (const byte*)m_tblnam,  m_tbllen+1) ||
unknown's avatar
unknown committed
6035
          my_b_safe_write(file, reinterpret_cast<byte*>(cbuf),
unknown's avatar
Merge  
unknown committed
6036
                          cbuf_end - (char*) cbuf) ||
6037
          my_b_safe_write(file, reinterpret_cast<byte*>(m_coltype), m_colcnt));
6038 6039 6040 6041 6042 6043 6044 6045 6046 6047
 }
#endif

#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)

/*
  Print some useful information for the SHOW BINARY LOG information
  field.
 */

6048
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
6049 6050 6051
void Table_map_log_event::pack_info(Protocol *protocol)
{
    char buf[256];
unknown's avatar
unknown committed
6052 6053
    my_size_t bytes= my_snprintf(buf, sizeof(buf),
                                 "table_id: %lu (%s.%s)",
6054
                              m_table_id, m_dbnam, m_tblnam);
6055 6056
    protocol->store(buf, bytes, &my_charset_bin);
}
6057 6058
#endif

6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125

#endif


#ifdef MYSQL_CLIENT
void Table_map_log_event::print(FILE *file, PRINT_EVENT_INFO *print_event_info)
{
  if (!print_event_info->short_form)
  {
    print_header(file, print_event_info);
    fprintf(file, "\tTable_map: `%s`.`%s` mapped to number %lu\n",
            m_dbnam, m_tblnam, m_table_id);
    print_base64(file, print_event_info);
  }
}
#endif

/**************************************************************************
	Write_rows_log_event member functions
**************************************************************************/

/*
  Constructor used to build an event for writing to the binary log.
 */
#if !defined(MYSQL_CLIENT)
Write_rows_log_event::Write_rows_log_event(THD *thd_arg, TABLE *tbl_arg,
                                           ulong tid_arg,
                                           MY_BITMAP const *cols,
                                           bool is_transactional)
  : Rows_log_event(thd_arg, tbl_arg, tid_arg, cols, is_transactional)
{
}
#endif

/*
  Constructor used by slave to read the event from the binary log.
 */
#ifdef HAVE_REPLICATION
Write_rows_log_event::Write_rows_log_event(const char *buf, uint event_len,
                                           const Format_description_log_event
                                           *description_event)
: Rows_log_event(buf, event_len, WRITE_ROWS_EVENT, description_event)
{
}
#endif

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
int Write_rows_log_event::do_before_row_operations(TABLE *table)
{
  int error= 0;

  /*
    We are using REPLACE semantics and not INSERT IGNORE semantics
    when writing rows, that is: new rows replace old rows.  We need to
    inform the storage engine that it should use this behaviour.
  */

  /* Tell the storage engine that we are using REPLACE semantics. */
  thd->lex->duplicates= DUP_REPLACE;

  /*
    Pretend we're executing a REPLACE command: this is needed for
    InnoDB and NDB Cluster since they are not (properly) checking the
    lex->duplicates flag.
  */
  thd->lex->sql_command= SQLCOM_REPLACE;

unknown's avatar
unknown committed
6126 6127
  table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);  // Needed for ndbcluster
  table->file->extra(HA_EXTRA_IGNORE_NO_KEY);   // Needed for ndbcluster
6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170
  /*
    TODO: the cluster team (Tomas?) says that it's better if the engine knows
    how many rows are going to be inserted, then it can allocate needed memory
    from the start.
  */
  table->file->start_bulk_insert(0);
  /*
    We need TIMESTAMP_NO_AUTO_SET otherwise ha_write_row() will not use fill
    any TIMESTAMP column with data from the row but instead will use
    the event's current time.
    As we replicate from TIMESTAMP to TIMESTAMP and slave has no extra
    columns, we know that all TIMESTAMP columns on slave will receive explicit
    data from the row, so TIMESTAMP_NO_AUTO_SET is ok.
    When we allow a table without TIMESTAMP to be replicated to a table having
    more columns including a TIMESTAMP column, or when we allow a TIMESTAMP
    column to be replicated into a BIGINT column and the slave's table has a
    TIMESTAMP column, then the slave's TIMESTAMP column will take its value
    from set_time() which we called earlier (consistent with SBR). And then in
    some cases we won't want TIMESTAMP_NO_AUTO_SET (will require some code to
    analyze if explicit data is provided for slave's TIMESTAMP columns).
  */
  table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
  return error;
}

int Write_rows_log_event::do_after_row_operations(TABLE *table, int error)
{
  if (error == 0)
    error= table->file->end_bulk_insert();
  return error;
}

char const *Write_rows_log_event::do_prepare_row(THD *thd, TABLE *table,
                                                 char const *row_start)
{
  char const *ptr= row_start;
  DBUG_ASSERT(table != NULL);
  /*
    This assertion actually checks that there is at least as many
    columns on the slave as on the master.
  */
  DBUG_ASSERT(table->s->fields >= m_width);
  DBUG_ASSERT(ptr);
6171
  ptr= unpack_row(table, (byte*)table->record[0], ptr, &m_cols);
6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277
  return ptr;
}

/*
  Check if there are more UNIQUE keys after the given key.
*/
static int
last_uniq_key(TABLE *table, uint keyno)
{
  while (++keyno < table->s->keys)
    if (table->key_info[keyno].flags & HA_NOSAME)
      return 0;
  return 1;
}

/* Anonymous namespace for template functions/classes */
namespace {

  /*
    Smart pointer that will automatically call my_afree (a macro) when
    the pointer goes out of scope.  This is used so that I do not have
    to remember to call my_afree() before each return.  There is no
    overhead associated with this, since all functions are inline.

    I (Matz) would prefer to use the free function as a template
    parameter, but that is not possible when the "function" is a
    macro.
  */
  template <class Obj>
  class auto_afree_ptr
  {
    Obj* m_ptr;
  public:
    auto_afree_ptr(Obj* ptr) : m_ptr(ptr) { }
    ~auto_afree_ptr() { if (m_ptr) my_afree(m_ptr); }
    void assign(Obj* ptr) {
      /* Only to be called if it hasn't been given a value before. */
      DBUG_ASSERT(m_ptr == NULL);
      m_ptr= ptr;
    }
    Obj* get() { return m_ptr; }
  };

}


/*
  Replace the provided record in the database.

  Similar to how it is done in <code>mysql_insert()</code>, we first
  try to do a <code>ha_write_row()</code> and of that fails due to
  duplicated keys (or indices), we do an <code>ha_update_row()</code>
  or a <code>ha_delete_row()</code> instead.

  @param thd    Thread context for writing the record.
  @param table  Table to which record should be written.

  @return Error code on failure, 0 on success.
 */
static int
replace_record(THD *thd, TABLE *table)
{
  DBUG_ASSERT(table != NULL && thd != NULL);

  int error;
  int keynum;
  auto_afree_ptr<char> key(NULL);

  while ((error= table->file->ha_write_row(table->record[0])))
  {
    if ((keynum= table->file->get_dup_key(error)) < 0)
    {
      /* We failed to retrieve the duplicate key */
      return HA_ERR_FOUND_DUPP_KEY;
    }

    /*
       We need to retrieve the old row into record[1] to be able to
       either update or delete the offending record.  We either:

       - use rnd_pos() with a row-id (available as dupp_row) to the
         offending row, if that is possible (MyISAM and Blackhole), or else

       - use index_read_idx() with the key that is duplicated, to
         retrieve the offending row.
     */
    if (table->file->table_flags() & HA_DUPP_POS)
    {
      error= table->file->rnd_pos(table->record[1], table->file->dupp_ref);
      if (error)
        return error;
    }
    else
    {
      if (table->file->extra(HA_EXTRA_FLUSH_CACHE))
      {
        return my_errno;
      }

      if (key.get() == NULL)
      {
        key.assign(static_cast<char*>(my_alloca(table->s->max_unique_length)));
        if (key.get() == NULL)
          return ENOMEM;
      }

6278 6279 6280
      key_copy((byte*)key.get(), table->record[0], table->key_info + keynum, 0);
      error= table->file->index_read_idx(table->record[1], keynum, 
                                         (const byte*)key.get(),
6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347
                                         table->key_info[keynum].key_length,
                                         HA_READ_KEY_EXACT);
      if (error)
        return error;
    }

    /*
       Now, table->record[1] should contain the offending row.  That
       will enable us to update it or, alternatively, delete it (so
       that we can insert the new row afterwards).

       REPLACE is defined as either INSERT or DELETE + INSERT.  If
       possible, we can replace it with an UPDATE, but that will not
       work on InnoDB if FOREIGN KEY checks are necessary.

       I (Matz) am not sure of the reason for the last_uniq_key()
       check as, but I'm guessing that it's something along the
       following lines.

       Suppose that we got the duplicate key to be a key that is not
       the last unique key for the table and we perform an update:
       then there might be another key for which the unique check will
       fail, so we're better off just deleting the row and inserting
       the correct row.
     */
    if (last_uniq_key(table, keynum) &&
        !table->file->referenced_by_foreign_key())
    {
      error=table->file->ha_update_row(table->record[1],
                                       table->record[0]);
      return error;
    }
    else
    {
      if ((error= table->file->ha_delete_row(table->record[1])))
        return error;
      /* Will retry ha_write_row() with the offending row removed. */
    }
  }
  return error;
}

int Write_rows_log_event::do_exec_row(TABLE *table)
{
  DBUG_ASSERT(table != NULL);
  int error= replace_record(thd, table);
  return error;
}
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */

#ifdef MYSQL_CLIENT
void Write_rows_log_event::print(FILE *file, PRINT_EVENT_INFO* print_event_info)
{
  if (!print_event_info->short_form)
  {
    print_header(file, print_event_info);
    fprintf(file, "\tWrite_rows: table id %lu", m_table_id);
    print_base64(file, print_event_info);
  }
}
#endif

/**************************************************************************
	Delete_rows_log_event member functions
**************************************************************************/

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
6348 6349 6350 6351 6352 6353
/*
  Compares table->record[0] and table->record[1]

  Returns TRUE if different.
*/
static bool record_compare(TABLE *table)
6354
{
6355 6356 6357 6358 6359 6360 6361 6362 6363
  if (table->s->blob_fields + table->s->varchar_fields == 0)
    return cmp_record(table,record[1]);
  /* Compare null bits */
  if (memcmp(table->null_flags,
	     table->null_flags+table->s->rec_buff_length,
	     table->s->null_bytes))
    return TRUE;				// Diff in NULL value
  /* Compare updated fields */
  for (Field **ptr=table->field ; *ptr ; ptr++)
6364
  {
6365 6366
    if ((*ptr)->cmp_binary_offset(table->s->rec_buff_length))
      return TRUE;
6367
  }
6368
  return FALSE;
6369 6370 6371 6372 6373 6374 6375 6376
}


/*
  Find the row given by 'key', if the table has keys, or else use a table scan
  to find (and fetch) the row.  If the engine allows random access of the
  records, a combination of position() and rnd_pos() will be used.
 */
6377
static int find_and_fetch_row(TABLE *table, byte *key)
6378 6379 6380
{
  DBUG_ENTER("find_and_fetch_row(TABLE *table, byte *key, byte *record)");
  DBUG_PRINT("enter", ("table=%p, key=%p, record=%p",
6381
		       table, key, table->record[1]));
6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392

  DBUG_ASSERT(table->in_use != NULL);

  if ((table->file->table_flags() & HA_PRIMARY_KEY_ALLOW_RANDOM_ACCESS)
      && table->s->primary_key < MAX_KEY)
  {
    /*
      Use a more efficient method to fetch the record given by
      table->record[0] if the engine allows it.  We first compute a
      row reference using the position() member function (it will be
      stored in table->file->ref) and the use rnd_pos() to position
6393
      the "cursor" (i.e., record[0] in this case) at the correct row.
6394 6395 6396 6397 6398
    */
    table->file->position(table->record[0]);
    DBUG_RETURN(table->file->rnd_pos(table->record[0], table->file->ref));
  }

6399
  DBUG_ASSERT(table->record[1]);
6400

unknown's avatar
unknown committed
6401 6402 6403
  /* We need to retrieve all fields */
  table->file->ha_set_all_bits_in_read_set();

6404 6405 6406
  if (table->s->keys > 0)
  {
    int error;
6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417
    /* We have a key: search the table using the index */
    if (!table->file->inited)
      if ((error= table->file->ha_index_init(0, FALSE)))
        return error;
    
    /*
      We need to set the null bytes to ensure that the filler bit are
      all set when returning.  There are storage engines that just set
      the necessary bits on the bytes and don't set the filler bits
      correctly.
    */
6418 6419 6420
    my_ptrdiff_t const pos=
      table->s->null_bytes > 0 ? table->s->null_bytes - 1 : 0;
    table->record[1][pos]= 0xFF;
6421 6422 6423
    if ((error= table->file->index_read(table->record[1], key,
                                        table->key_info->key_length,
                                        HA_READ_KEY_EXACT)))
6424 6425
    {
      table->file->print_error(error, MYF(0));
6426
      table->file->ha_index_end();
6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444
      DBUG_RETURN(error);
    }

    /*
      Below is a minor "optimization".  If the key (i.e., key number
      0) has the HA_NOSAME flag set, we know that we have found the
      correct record (since there can be no duplicates); otherwise, we
      have to compare the record with the one found to see if it is
      the correct one.

      CAVEAT! This behaviour is essential for the replication of,
      e.g., the mysql.proc table since the correct record *shall* be
      found using the primary key *only*.  There shall be no
      comparison of non-PK columns to decide if the correct record is
      found.  I can see no scenario where it would be incorrect to
      chose the row to change only using a PK or an UNNI.
     */
    if (table->key_info->flags & HA_NOSAME)
6445 6446
    {
      table->file->ha_index_end();
6447
      DBUG_RETURN(0);
6448
    }
6449

6450
    while (record_compare(table))
6451 6452
    {
      int error;
6453 6454 6455 6456 6457 6458
      /*
        We need to set the null bytes to ensure that the filler bit
        are all set when returning.  There are storage engines that
        just set the necessary bits on the bytes and don't set the
        filler bits correctly.
      */
6459 6460 6461
      my_ptrdiff_t const pos=
        table->s->null_bytes > 0 ? table->s->null_bytes - 1 : 0;
      table->record[1][pos]= 0xFF;
6462
      if ((error= table->file->index_next(table->record[1])))
6463 6464
      {
	table->file->print_error(error, MYF(0));
6465
        table->file->ha_index_end();
6466 6467 6468
	DBUG_RETURN(error);
      }
    }
6469 6470 6471 6472 6473

    /*
      Have to restart the scan to be able to fetch the next row.
    */
    table->file->ha_index_end();
6474 6475 6476 6477
  }
  else
  {
    int restart_count= 0; // Number of times scanning has restarted from top
6478 6479 6480 6481 6482 6483 6484
    int error;

    /* We don't have a key: search the table using rnd_next() */
    if ((error= table->file->ha_rnd_init(1)))
      return error;

    /* Continue until we find the right record or have made a full loop */
6485 6486
    do
    {
6487 6488 6489 6490 6491 6492
      /*
        We need to set the null bytes to ensure that the filler bit
        are all set when returning.  There are storage engines that
        just set the necessary bits on the bytes and don't set the
        filler bits correctly.
      */
6493 6494 6495
      my_ptrdiff_t const pos=
        table->s->null_bytes > 0 ? table->s->null_bytes - 1 : 0;
      table->record[1][pos]= 0xFF;
6496
      error= table->file->rnd_next(table->record[1]);
6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507 6508 6509
      switch (error)
      {
      case 0:
      case HA_ERR_RECORD_DELETED:
	break;

      case HA_ERR_END_OF_FILE:
	if (++restart_count < 2)
	  table->file->ha_rnd_init(1);
	break;

      default:
	table->file->print_error(error, MYF(0));
6510
        table->file->ha_rnd_end();
6511 6512 6513
	DBUG_RETURN(error);
      }
    }
6514
    while (restart_count < 2 && record_compare(table));
6515

6516 6517 6518 6519 6520
    /*
      Have to restart the scan to be able to fetch the next row.
    */
    table->file->ha_rnd_end();

6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538
    DBUG_ASSERT(error == HA_ERR_END_OF_FILE || error == 0);
    DBUG_RETURN(error);
  }

  DBUG_RETURN(0);
}
#endif

/*
  Constructor used to build an event for writing to the binary log.
 */

#ifndef MYSQL_CLIENT
Delete_rows_log_event::Delete_rows_log_event(THD *thd_arg, TABLE *tbl_arg,
                                             ulong tid, MY_BITMAP const *cols,
                                             bool is_transactional)
  : Rows_log_event(thd_arg, tbl_arg, tid, cols, is_transactional)
#ifdef HAVE_REPLICATION
6539
  ,m_memory(NULL), m_key(NULL), m_after_image(NULL)
6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555
#endif
{
}
#endif /* #if !defined(MYSQL_CLIENT) */

/*
  Constructor used by slave to read the event from the binary log.
 */
#ifdef HAVE_REPLICATION
Delete_rows_log_event::Delete_rows_log_event(const char *buf, uint event_len,
                                             const Format_description_log_event
                                             *description_event)
#if defined(MYSQL_CLIENT)
  : Rows_log_event(buf, event_len, DELETE_ROWS_EVENT, description_event)
#else
  : Rows_log_event(buf, event_len, DELETE_ROWS_EVENT, description_event),
6556
    m_memory(NULL), m_key(NULL), m_after_image(NULL)
6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570
#endif
{
}
#endif

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
int Delete_rows_log_event::do_before_row_operations(TABLE *table)
{
  DBUG_ASSERT(m_memory == NULL);

  if ((table->file->table_flags() & HA_PRIMARY_KEY_ALLOW_RANDOM_ACCESS) &&
      table->s->primary_key < MAX_KEY)
  {
    /*
6571
      We don't need to allocate any memory for m_after_image and
6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582
      m_key since they are not used.
    */
    return 0;
  }

  int error= 0;

  if (table->s->keys > 0)
  {
    m_memory=
      my_multi_malloc(MYF(MY_WME),
6583
		      &m_after_image, table->s->reclength,
6584 6585 6586 6587 6588
		      &m_key, table->key_info->key_length,
		      NULL);
  }
  else
  {
6589 6590
    m_after_image= (byte*)my_malloc(table->s->reclength, MYF(MY_WME));
    m_memory= (gptr)m_after_image;
6591 6592 6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603
    m_key= NULL;
  }
  if (!m_memory)
    return HA_ERR_OUT_OF_MEM;

  return error;
}

int Delete_rows_log_event::do_after_row_operations(TABLE *table, int error)
{
  /*error= ToDo:find out what this should really be, this triggers close_scan in nbd, returning error?*/
  table->file->ha_index_or_rnd_end();
  my_free(m_memory, MYF(MY_ALLOW_ZERO_PTR)); // Free for multi_malloc
6604
  m_memory= NULL;
6605
  m_after_image= NULL;
6606
  m_key= NULL;
6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622

  return error;
}

char const *Delete_rows_log_event::do_prepare_row(THD *thd, TABLE *table,
                                                  char const *row_start)
{
  char const *ptr= row_start;
  DBUG_ASSERT(ptr);
  /*
    This assertion actually checks that there is at least as many
    columns on the slave as on the master.
  */
  DBUG_ASSERT(table->s->fields >= m_width);

  DBUG_ASSERT(ptr != NULL);
6623
  ptr= unpack_row(table, table->record[0], ptr, &m_cols);
6624 6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642

  /*
    If we will access rows using the random access method, m_key will
    be set to NULL, so we do not need to make a key copy in that case.
   */
  if (m_key)
  {
    KEY *const key_info= table->key_info;

    key_copy(m_key, table->record[0], key_info, 0);
  }

  return ptr;
}

int Delete_rows_log_event::do_exec_row(TABLE *table)
{
  DBUG_ASSERT(table != NULL);

6643
  int error= find_and_fetch_row(table, m_key);
6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720
  if (error)
    return error;

  /*
     Now we should have the right row to delete.  We are using
     record[0] since it is guaranteed to point to a record with the
     correct value.
  */
  error= table->file->ha_delete_row(table->record[0]);

  return error;
}

#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */

#ifdef MYSQL_CLIENT
void Delete_rows_log_event::print(FILE *file,
                                  PRINT_EVENT_INFO* print_event_info)
{
  if (!print_event_info->short_form)
  {
    print_header(file, print_event_info);
    fprintf(file, "\tDelete_rows: table id %lu", m_table_id);
    print_base64(file, print_event_info);
  }
}
#endif


/**************************************************************************
	Update_rows_log_event member functions
**************************************************************************/

/*
  Constructor used to build an event for writing to the binary log.
 */
#if !defined(MYSQL_CLIENT)
Update_rows_log_event::Update_rows_log_event(THD *thd_arg, TABLE *tbl_arg,
                                             ulong tid, MY_BITMAP const *cols,
                                             bool is_transactional)
: Rows_log_event(thd_arg, tbl_arg, tid, cols, is_transactional)
#ifdef HAVE_REPLICATION
  , m_memory(NULL), m_key(NULL)
#endif
{
}
#endif /* !defined(MYSQL_CLIENT) */

/*
  Constructor used by slave to read the event from the binary log.
 */
#ifdef HAVE_REPLICATION
Update_rows_log_event::Update_rows_log_event(const char *buf, uint event_len,
                                             const
                                             Format_description_log_event
                                             *description_event)
#if defined(MYSQL_CLIENT)
  : Rows_log_event(buf, event_len, UPDATE_ROWS_EVENT, description_event)
#else
  : Rows_log_event(buf, event_len, UPDATE_ROWS_EVENT, description_event),
    m_memory(NULL), m_key(NULL)
#endif
{
}
#endif

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
int Update_rows_log_event::do_before_row_operations(TABLE *table)
{
  DBUG_ASSERT(m_memory == NULL);

  int error= 0;

  if (table->s->keys > 0)
  {
    m_memory=
      my_multi_malloc(MYF(MY_WME),
6721
		      &m_after_image, table->s->reclength,
6722 6723 6724 6725 6726
		      &m_key, table->key_info->key_length,
		      NULL);
  }
  else
  {
6727 6728
    m_after_image= (byte*)my_malloc(table->s->reclength, MYF(MY_WME));
    m_memory= (gptr)m_after_image;
6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743
    m_key= NULL;
  }
  if (!m_memory)
    return HA_ERR_OUT_OF_MEM;

  table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;

  return error;
}

int Update_rows_log_event::do_after_row_operations(TABLE *table, int error)
{
  /*error= ToDo:find out what this should really be, this triggers close_scan in nbd, returning error?*/
  table->file->ha_index_or_rnd_end();
  my_free(m_memory, MYF(MY_ALLOW_ZERO_PTR));
6744
  m_memory= NULL;
6745
  m_after_image= NULL;
6746
  m_key= NULL;
6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762

  return error;
}

char const *Update_rows_log_event::do_prepare_row(THD *thd, TABLE *table,
                                                  char const *row_start)
{
  char const *ptr= row_start;
  DBUG_ASSERT(ptr);
  /*
    This assertion actually checks that there is at least as many
    columns on the slave as on the master.
  */
  DBUG_ASSERT(table->s->fields >= m_width);

  /* record[0] is the before image for the update */
6763
  ptr= unpack_row(table, table->record[0], ptr, &m_cols);
6764
  DBUG_ASSERT(ptr != NULL);
6765 6766
  /* m_after_image is the after image for the update */
  ptr= unpack_row(table, m_after_image, ptr, &m_cols);
6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785

  /*
    If we will access rows using the random access method, m_key will
    be set to NULL, so we do not need to make a key copy in that case.
   */
  if (m_key)
  {
    KEY *const key_info= table->key_info;

    key_copy(m_key, table->record[0], key_info, 0);
  }

  return ptr;
}

int Update_rows_log_event::do_exec_row(TABLE *table)
{
  DBUG_ASSERT(table != NULL);

6786
  int error= find_and_fetch_row(table, m_key);
6787 6788 6789
  if (error)
    return error;

6790
  /*
6791 6792 6793 6794 6795 6796 6797 6798 6799
    We have to ensure that the new record (i.e., the after image) is
    in record[0] and the old record (i.e., the before image) is in
    record[1].  This since some storage engines require this (for
    example, the partition engine).

    Since find_and_fetch_row() puts the fetched record (i.e., the old
    record) in record[0], we have to move it out of the way and into
    record[1]. After that, we can put the new record (i.e., the after
    image) into record[0].
6800
  */
6801 6802
  bmove_align(table->record[1], table->record[0], table->s->reclength);
  bmove_align(table->record[0], m_after_image, table->s->reclength);
6803

6804
  /*
6805 6806 6807
    Now we should have the right row to update.  The old row (the one
    we're looking for) has to be in record[1] and the new row has to
    be in record[0] for all storage engines to work correctly.
6808
  */
6809
  error= table->file->ha_update_row(table->record[1], table->record[0]);
6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828

  return error;
}
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */

#ifdef MYSQL_CLIENT
void Update_rows_log_event::print(FILE *file,
				  PRINT_EVENT_INFO* print_event_info)
{
  if (!print_event_info->short_form)
  {
    print_header(file, print_event_info);
    fprintf(file, "\tUpdate_rows: table id %lu", m_table_id);
    print_base64(file, print_event_info);
  }
}
#endif

#endif /* defined(HAVE_ROW_BASED_REPLICATION) */