log_event.cc 231 KB
Newer Older
monty@mysql.com's avatar
monty@mysql.com committed
1
/* Copyright (C) 2000-2004 MySQL AB
2

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
8 9 10 11
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
12

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

20
#ifdef USE_PRAGMA_IMPLEMENTATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
21 22
#pragma implementation				// gcc: Class implementation
#endif
23

24
#include "mysql_priv.h"
25
#include "slave.h"
lars@mysql.com's avatar
lars@mysql.com committed
26
#include "rpl_filter.h"
27
#include "rpl_utility.h"
28
#include <my_dir.h>
bk@work.mysql.com's avatar
bk@work.mysql.com committed
29
#endif /* MYSQL_CLIENT */
30 31
#include <base64.h>
#include <my_bitmap.h>
bk@work.mysql.com's avatar
bk@work.mysql.com committed
32

33
#define log_cs	&my_charset_latin1
34

35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
/*
  Cache that will automatically be written to a dedicated file on
  destruction.

  DESCRIPTION

 */
class Write_on_release_cache
{
public:
  enum flag
  {
    FLUSH_F
  };

  typedef unsigned short flag_set;

  /*
    Constructor.

    SYNOPSIS
      Write_on_release_cache
      cache  Pointer to cache to use
      file   File to write cache to upon destruction
      flags  Flags for the cache

    DESCRIPTION

      Class used to guarantee copy of cache to file before exiting the
      current block.  On successful copy of the cache, the cache will
      be reinited as a WRITE_CACHE.

      Currently, a pointer to the cache is provided in the
      constructor, but it would be possible to create a subclass
      holding the IO_CACHE itself.
   */
  Write_on_release_cache(IO_CACHE *cache, FILE *file, flag_set flags = 0)
    : m_cache(cache), m_file(file), m_flags(flags)
  {
    reinit_io_cache(m_cache, WRITE_CACHE, 0L, FALSE, TRUE);
  }

  ~Write_on_release_cache()
  {
    if (!my_b_copy_to_file(m_cache, m_file))
      reinit_io_cache(m_cache, WRITE_CACHE, 0L, FALSE, TRUE);
    if (m_flags | FLUSH_F)
      fflush(m_file);
  }

  /*
    Return a pointer to the internal IO_CACHE.

    SYNOPSIS
      operator&()

    DESCRIPTION
      Function to return a pointer to the internal, so that the object
      can be treated as a IO_CACHE and used with the my_b_* IO_CACHE
      functions

    RETURN VALUE
      A pointer to the internal IO_CACHE.
   */
  IO_CACHE *operator&()
  {
    return m_cache;
  }

private:
  // Hidden, to prevent usage.
  Write_on_release_cache(Write_on_release_cache const&);

  IO_CACHE *m_cache;
  FILE *m_file;
  flag_set m_flags;
};


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
114
/*
115
  pretty_print_str()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
116
*/
117

118
#ifdef MYSQL_CLIENT
119
static void pretty_print_str(IO_CACHE* cache, char* str, int len)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
120
{
121
  char* end = str + len;
122
  my_b_printf(cache, "\'");
123 124
  while (str < end)
  {
125
    char c;
126
    switch ((c=*str++)) {
127 128 129 130 131 132 133
    case '\n': my_b_printf(cache, "\\n"); break;
    case '\r': my_b_printf(cache, "\\r"); break;
    case '\\': my_b_printf(cache, "\\\\"); break;
    case '\b': my_b_printf(cache, "\\b"); break;
    case '\t': my_b_printf(cache, "\\t"); break;
    case '\'': my_b_printf(cache, "\\'"); break;
    case 0   : my_b_printf(cache, "\\0"); break;
134
    default:
135
      my_b_printf(cache, "%c", c);
136 137
      break;
    }
138
  }
139
  my_b_printf(cache, "\'");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
140
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
141
#endif /* MYSQL_CLIENT */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
142

143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
#ifdef HAVE_purify
static void
valgrind_check_mem(void *ptr, size_t len)
{
  static volatile uchar dummy;
  for (volatile uchar *p= (uchar*) ptr ; p != (uchar*) ptr + len ; ++p)
  {
    int const c = *p;
    if (c < 128)
      dummy= c + 1;
    else
      dummy = c - 1;
  }
}
#endif
158

monty@mysql.com's avatar
monty@mysql.com committed
159
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
160

161 162 163 164 165 166 167 168
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;
}

monty@mysql.com's avatar
monty@mysql.com committed
169

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
170
/*
monty@mysql.com's avatar
monty@mysql.com committed
171
  Ignore error code specified on command line
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
172
*/
173

174 175
inline int ignored_error_code(int err_code)
{
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
176 177 178 179 180 181 182 183 184 185 186 187 188 189
#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
guilhem@mysql.com's avatar
guilhem@mysql.com committed
190 191
  return ((err_code == ER_SLAVE_IGNORED_TABLE) ||
          (use_slave_mask && bitmap_is_set(&slave_error_mask, err_code)));
192
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
193
#endif
194

195

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
196
/*
197
  pretty_print_str()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
198
*/
199

200
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
201
static char *pretty_print_str(char *packet, char *str, int len)
202
{
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
203 204
  char *end= str + len;
  char *pos= packet;
205
  *pos++= '\'';
206 207 208
  while (str < end)
  {
    char c;
209
    switch ((c=*str++)) {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
210 211 212 213 214 215 216
    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;
217
    default:
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
218
      *pos++= c;
219 220
      break;
    }
221
  }
222 223
  *pos++= '\'';
  return pos;
224
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
225
#endif /* !MYSQL_CLIENT */
226

227

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
228
/*
229 230 231 232 233 234 235 236 237 238 239
  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
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
240
*/
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
241

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
242
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
243 244
static char *slave_load_file_stem(char *buf, uint file_id,
                                  int event_server_id, const char *ext)
245
{
246
  char *res;
247 248 249
  fn_format(buf,"SQL_LOAD-",slave_load_tmpdir, "", MY_UNPACK_FILENAME);
  to_unix_path(buf);

250 251 252 253 254
  buf = strend(buf);
  buf = int10_to_str(::server_id, buf, 10);
  *buf++ = '-';
  buf = int10_to_str(event_server_id, buf, 10);
  *buf++ = '-';
255 256 257
  res= int10_to_str(file_id, buf, 10);
  strmov(res, ext);                             // Add extension last
  return res;                                   // Pointer to extension
258
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
259
#endif
260

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
261

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
262
/*
263 264
  Delete all temporary files used for SQL_LOAD.

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
265 266
  SYNOPSIS
    cleanup_load_tmpdir()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
267
*/
268

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
269
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
270 271 272 273 274
static void cleanup_load_tmpdir()
{
  MY_DIR *dirp;
  FILEINFO *file;
  uint i;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
275
  char fname[FN_REFLEN], prefbuf[31], *p;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
276

277 278 279
  if (!(dirp=my_dir(slave_load_tmpdir,MYF(MY_WME))))
    return;

280 281 282 283 284 285 286 287
  /* 
     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.
  */
288
  p= strmake(prefbuf, STRING_WITH_LEN("SQL_LOAD-"));
289 290 291 292
  p= int10_to_str(::server_id, p, 10);
  *(p++)= '-';
  *p= 0;

293 294 295
  for (i=0 ; i < (uint)dirp->number_off_files; i++)
  {
    file=dirp->dir_entry+i;
296
    if (is_prefix(file->name, prefbuf))
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
297 298 299 300
    {
      fn_format(fname,file->name,slave_load_tmpdir,"",MY_UNPACK_FILENAME);
      my_delete(fname, MYF(0));
    }
301 302 303 304
  }

  my_dirend(dirp);
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
305
#endif
306 307


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
308
/*
309
  write_str()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
310
*/
311

312
static bool write_str(IO_CACHE *file, char *str, uint length)
313
{
314 315 316 317
  byte tmp[1];
  tmp[0]= (byte) length;
  return (my_b_safe_write(file, tmp, sizeof(tmp)) ||
	  my_b_safe_write(file, (byte*) str, length));
318 319 320
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
321
/*
322
  read_str()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
323
*/
324

325 326
static inline int read_str(char **buf, char *buf_end, char **str,
			   uint8 *len)
327
{
328
  if (*buf + ((uint) (uchar) **buf) >= buf_end)
329
    return 1;
330 331 332
  *len= (uint8) **buf;
  *str= (*buf)+1;
  (*buf)+= (uint) *len+1;
333 334 335
  return 0;
}

336

337 338 339
/*
  Transforms a string into "" or its expression in 0x... form.
*/
monty@mysql.com's avatar
monty@mysql.com committed
340

341
char *str_to_hex(char *to, const char *from, uint len)
342 343 344
{
  if (len)
  {
monty@mysql.com's avatar
monty@mysql.com committed
345 346 347
    *to++= '0';
    *to++= 'x';
    to= octet2hex(to, from, len);
348 349
  }
  else
monty@mysql.com's avatar
monty@mysql.com committed
350 351
    to= strmov(to, "\"\"");
  return to;                               // pointer to end 0 of 'to'
352 353
}

354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
/*
  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++= '\'';
376
    ptr+= escape_string_for_mysql(csinfo, ptr, 0,
377 378 379 380 381 382 383 384
                                  from->ptr(), from->length());
    *ptr++='\'';
  }
  to->length(orig_len + ptr - beg);
  return 0;
}
#endif

385 386 387 388 389
/*
  Prints a "session_var=value" string. Used by mysqlbinlog to print some SET
  commands just before it prints a query.
*/

390
#ifdef MYSQL_CLIENT
391 392 393
static void print_set_option(IO_CACHE* file, uint32 bits_changed,
                             uint32 option, uint32 flags, const char* name,
                             bool* need_comma)
394 395 396 397
{
  if (bits_changed & option)
  {
    if (*need_comma)
398 399
      my_b_printf(file,", ");
    my_b_printf(file,"%s=%d", name, test(flags & option));
400 401 402
    *need_comma= 1;
  }
}
403
#endif
404

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
405
/**************************************************************************
406
	Log_event methods (= the parent class of all events)
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
407
**************************************************************************/
408

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
409
/*
410
  Log_event::get_type_str()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
411
*/
412

413 414
const char* Log_event::get_type_str()
{
415
  switch(get_type_code()) {
416
  case START_EVENT_V3:  return "Start_v3";
417 418 419 420 421
  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";
422
  case NEW_LOAD_EVENT:   return "New_load";
423
  case SLAVE_EVENT:  return "Slave";
424 425 426 427
  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";
428
  case RAND_EVENT: return "RAND";
429
  case XID_EVENT: return "Xid";
430
  case USER_VAR_EVENT: return "User var";
431
  case FORMAT_DESCRIPTION_EVENT: return "Format_desc";
432 433 434 435
  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";
436 437
  case BEGIN_LOAD_QUERY_EVENT: return "Begin_load_query";
  case EXECUTE_LOAD_QUERY_EVENT: return "Execute_load_query";
438
  default: return "Unknown";				/* impossible */
439 440 441
  }
}

442

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
443
/*
444
  Log_event::Log_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
445
*/
446

447
#ifndef MYSQL_CLIENT
448
Log_event::Log_event(THD* thd_arg, uint16 flags_arg, bool using_trans)
449
  :log_pos(0), temp_buf(0), exec_time(0), flags(flags_arg), thd(thd_arg)
450
{
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
451 452
  server_id=	thd->server_id;
  when=		thd->start_time;
453
  cache_stmt=	using_trans;
454 455 456
}


monty@mysql.com's avatar
monty@mysql.com committed
457
/*
458 459 460 461
  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).
monty@mysql.com's avatar
monty@mysql.com committed
462 463
*/

464
Log_event::Log_event()
465
  :temp_buf(0), exec_time(0), flags(0), cache_stmt(0),
466 467
   thd(0)
{
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
468 469 470
  server_id=	::server_id;
  when=		time(NULL);
  log_pos=	0;
471
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
472
#endif /* !MYSQL_CLIENT */
473 474


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
475
/*
476
  Log_event::Log_event()
477
*/
478

479
Log_event::Log_event(const char* buf,
480
                     const Format_description_log_event* description_event)
481
  :temp_buf(0), cache_stmt(0)
482
{
483 484
#ifndef MYSQL_CLIENT
  thd = 0;
485
#endif
486 487
  when = uint4korr(buf);
  server_id = uint4korr(buf + SERVER_ID_OFFSET);
488
  if (description_event->binlog_version==1)
489
  {
490 491 492
    log_pos= 0;
    flags= 0;
    return;
493
  }
494 495 496
  /* 4.0 or newer */
  log_pos= uint4korr(buf + LOG_POS_OFFSET);
  /*
497 498 499 500 501 502 503 504
    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).
505 506 507
  */
  if (description_event->binlog_version==3 &&
      buf[EVENT_TYPE_OFFSET]<FORMAT_DESCRIPTION_EVENT && log_pos)
508
  {
509 510 511
      /*
        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
512 513
        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
514
        not have its log_pos (which is 0) changed or it will modify
515 516 517 518
        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).
519 520
      */
    log_pos+= uint4korr(buf + EVENT_LEN_OFFSET);
521
  }
522 523 524 525 526 527 528
  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))
  {
    /*
529 530
      These events always have a header which stops here (i.e. their
      header is FROZEN).
531 532
    */
    /*
533 534 535 536 537 538 539
      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.
540 541 542 543
    */
    return;
  }
  /* otherwise, go on with reading the header from buf (nothing now) */
544 545 546
}

#ifndef MYSQL_CLIENT
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
547
#ifdef HAVE_REPLICATION
548

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
549
/*
550
  Log_event::exec_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
551
*/
552

553
int Log_event::exec_event(struct st_relay_log_info* rli)
554
{
monty@mysql.com's avatar
monty@mysql.com committed
555 556
  DBUG_ENTER("Log_event::exec_event");

557 558 559 560 561 562 563 564 565 566 567 568
  /*
    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.
  */
569
  if (rli)
570
  {
571
    /*
572 573 574 575
      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= .
576

577
      CAUTION: opt_using_transactions means
578
      innodb || bdb ; suppose the master supports InnoDB and BDB,
579
      but the slave supports only BDB, problems
580
      will arise:
581 582
      - suppose an InnoDB table is created on the master,
      - then it will be MyISAM on the slave
583 584 585 586 587 588 589 590 591 592 593 594
      - 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.
595 596
    */
    if ((thd->options & OPTION_BEGIN) && opt_using_transactions)
597
      rli->inc_event_relay_log_pos();
598 599
    else
    {
600
      rli->inc_group_relay_log_pos(log_pos);
601
      flush_relay_log_info(rli);
602
      /* 
603 604
         Note that Rotate_log_event::exec_event() does not call this
         function, so there is no chance that a fake rotate event resets
605
         last_master_timestamp.
606 607 608
         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).
609 610
      */
      rli->last_master_timestamp= when;
611
    }
612
  }
monty@mysql.com's avatar
monty@mysql.com committed
613
  DBUG_RETURN(0);
614
}
615

616

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
617
/*
618
  Log_event::pack_info()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
619
*/
620

621
void Log_event::pack_info(Protocol *protocol)
622
{
623
  protocol->store("", &my_charset_bin);
624 625 626
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
627
/*
628
  Log_event::net_send()
629

630
  Only called by SHOW BINLOG EVENTS
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
631
*/
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
632

633
int Log_event::net_send(Protocol *protocol, const char* log_name, my_off_t pos)
634
{
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
635 636
  const char *p= strrchr(log_name, FN_LIBCHAR);
  const char *event_type;
637 638 639
  if (p)
    log_name = p + 1;
  
640
  protocol->prepare_for_resend();
641
  protocol->store(log_name, &my_charset_bin);
642
  protocol->store((ulonglong) pos);
643
  event_type = get_type_str();
644
  protocol->store(event_type, strlen(event_type), &my_charset_bin);
645 646 647 648
  protocol->store((uint32) server_id);
  protocol->store((ulonglong) log_pos);
  pack_info(protocol);
  return protocol->write();
649
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
650 651 652
#endif /* HAVE_REPLICATION */


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
653
/*
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
654
  Log_event::init_show_field_list()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
655
*/
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
656 657 658 659 660 661 662 663 664

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));
665
  field_list->push_back(new Item_return_int("End_log_pos", 11,
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
666 667 668 669
					    MYSQL_TYPE_LONGLONG));
  field_list->push_back(new Item_empty_string("Info", 20));
}

670

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
671
/*
672
  Log_event::write()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
673
*/
674

675
bool Log_event::write_header(IO_CACHE* file, ulong event_data_length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
676
{
677 678
  byte header[LOG_EVENT_HEADER_LEN];
  DBUG_ENTER("Log_event::write_header");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
679

680 681
  /* Store number of bytes that will be written by this event */
  data_written= event_data_length + sizeof(header);
682

683 684 685 686
  /*
    log_pos != 0 if this is relay-log event. In this case we should not
    change the position
  */
687

688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
  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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
743 744 745
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
746
/*
747
  Log_event::read_log_event()
748 749 750 751

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

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
752
*/
753

754
int Log_event::read_log_event(IO_CACHE* file, String* packet,
755
			      pthread_mutex_t* log_lock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
756 757
{
  ulong data_len;
758
  int result=0;
759
  char buf[LOG_EVENT_MINIMAL_HEADER_LEN];
760
  DBUG_ENTER("read_log_event");
761

762
  if (log_lock)
763
    pthread_mutex_lock(log_lock);
764 765
  if (my_b_read(file, (byte*) buf, sizeof(buf)))
  {
766 767 768 769 770
    /*
      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.
    */
771
    DBUG_PRINT("error",("file->error: %d", file->error));
772 773 774
    if (!file->error)
      result= LOG_READ_EOF;
    else
775
      result= (file->error > 0 ? LOG_READ_TRUNC : LOG_READ_IO);
776
    goto end;
777
  }
778
  data_len= uint4korr(buf + EVENT_LEN_OFFSET);
779
  if (data_len < LOG_EVENT_MINIMAL_HEADER_LEN ||
780
      data_len > current_thd->variables.max_allowed_packet)
781
  {
782
    DBUG_PRINT("error",("data_len: %ld", data_len));
783
    result= ((data_len < LOG_EVENT_MINIMAL_HEADER_LEN) ? LOG_READ_BOGUS :
784 785
	     LOG_READ_TOO_LARGE);
    goto end;
786
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
787
  packet->append(buf, sizeof(buf));
788
  data_len-= LOG_EVENT_MINIMAL_HEADER_LEN;
789 790 791
  if (data_len)
  {
    if (packet->append(file, data_len))
792
    {
793
      /*
794 795
	Here if we hit EOF it's really an error: as data_len is >=0
        there's supposed to be more bytes available. 
796
	EOF means we are reading the event partially, which should
797
	never happen: either we read badly or the binlog is truncated.
798 799 800
      */
      result= file->error >= 0 ? LOG_READ_TRUNC: LOG_READ_IO;
      /* Implicit goto end; */
801
    }
802
  }
803 804 805 806

end:
  if (log_lock)
    pthread_mutex_unlock(log_lock);
807
  DBUG_RETURN(result);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
808
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
809
#endif /* !MYSQL_CLIENT */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
810

811
#ifndef MYSQL_CLIENT
812 813
#define UNLOCK_MUTEX if (log_lock) pthread_mutex_unlock(log_lock);
#define LOCK_MUTEX if (log_lock) pthread_mutex_lock(log_lock);
814
#else
815
#define UNLOCK_MUTEX
816 817 818
#define LOCK_MUTEX
#endif

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
819
/*
820 821
  Log_event::read_log_event()

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
822
  NOTE:
823
    Allocates memory;  The caller is responsible for clean-up.
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
824
*/
825

826
#ifndef MYSQL_CLIENT
827 828
Log_event* Log_event::read_log_event(IO_CACHE* file,
				     pthread_mutex_t* log_lock,
829
                                     const Format_description_log_event *description_event)
830
#else
831 832
Log_event* Log_event::read_log_event(IO_CACHE* file,
                                     const Format_description_log_event *description_event)
833
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
834
{
835
  DBUG_ENTER("Log_event::read_log_event(IO_CACHE *, Format_description_log_event *");
836
  DBUG_ASSERT(description_event != 0);
837 838 839 840 841
  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
842 843
    of 13 bytes, whereas LOG_EVENT_MINIMAL_HEADER_LEN is 19 bytes (it's
    "minimal" over the set {MySQL >=4.0}).
844 845 846
  */
  uint header_size= min(description_event->common_header_len,
                        LOG_EVENT_MINIMAL_HEADER_LEN);
847

848
  LOCK_MUTEX;
849
  DBUG_PRINT("info", ("my_b_tell: %lu", (ulong) my_b_tell(file)));
850
  if (my_b_read(file, (byte *) head, header_size))
851
  {
852 853
    DBUG_PRINT("info", ("Log_event::read_log_event(IO_CACHE*,Format_desc*) \
failed my_b_read"));
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
854
    UNLOCK_MUTEX;
855
    /*
856 857 858
      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.
859
    */
860
    DBUG_RETURN(0);
861
  }
862
  uint data_len = uint4korr(head + EVENT_LEN_OFFSET);
863 864 865
  char *buf= 0;
  const char *error= 0;
  Log_event *res=  0;
866 867
#ifndef max_allowed_packet
  THD *thd=current_thd;
868
  uint max_allowed_packet= thd ? thd->variables.max_allowed_packet : ~(ulong)0;
869
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
870

871
  if (data_len > max_allowed_packet)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
872
  {
873 874
    error = "Event too big";
    goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
875 876
  }

877
  if (data_len < header_size)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
878
  {
879 880
    error = "Event too small";
    goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
881
  }
882 883 884

  // some events use the extra byte to null-terminate strings
  if (!(buf = my_malloc(data_len+1, MYF(MY_WME))))
885 886 887
  {
    error = "Out of memory";
    goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
888
  }
889
  buf[data_len] = 0;
890
  memcpy(buf, head, header_size);
891
  if (my_b_read(file, (byte*) buf + header_size, data_len - header_size))
892 893 894 895
  {
    error = "read error";
    goto err;
  }
896
  if ((res= read_log_event(buf, data_len, &error, description_event)))
897
    res->register_temp_buf(buf);
898

899
err:
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
900
  UNLOCK_MUTEX;
901
  if (!res)
902
  {
903
    DBUG_ASSERT(error != 0);
904 905
    sql_print_error("Error in Log_event::read_log_event(): "
                    "'%s', data_len: %d, event_type: %d",
906
		    error,data_len,head[EVENT_TYPE_OFFSET]);
907
    my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
908 909 910 911 912 913 914 915 916
    /*
      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;
917
  }
918
  DBUG_RETURN(res);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
919 920
}

921

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
922
/*
923
  Log_event::read_log_event()
924 925
  Binlog format tolerance is in (buf, event_len, description_event)
  constructors.
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
926
*/
927

928 929 930
Log_event* Log_event::read_log_event(const char* buf, uint event_len,
				     const char **error,
                                     const Format_description_log_event *description_event)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
931
{
932 933
  Log_event* ev;
  DBUG_ENTER("Log_event::read_log_event(char*,...)");
934
  DBUG_ASSERT(description_event != 0);
935
  DBUG_PRINT("info", ("binlog_version: %d", description_event->binlog_version));
936
  if (event_len < EVENT_LEN_OFFSET ||
937 938 939
      (uint) event_len != uint4korr(buf+EVENT_LEN_OFFSET))
  {
    *error="Sanity check failed";		// Needed to free buffer
monty@mysql.com's avatar
monty@mysql.com committed
940
    DBUG_RETURN(NULL); // general sanity check - will fail on a partial read
941
  }
942

943 944 945
  /* To check the integrity of the Log_event_type enumeration */
  DBUG_ASSERT(buf[EVENT_TYPE_OFFSET] < ENUM_END_EVENT);

946
  switch(buf[EVENT_TYPE_OFFSET]) {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
947
  case QUERY_EVENT:
948
    ev  = new Query_log_event(buf, event_len, description_event, QUERY_EVENT);
949
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
950
  case LOAD_EVENT:
951
    ev = new Load_log_event(buf, event_len, description_event);
952
    break;
953
  case NEW_LOAD_EVENT:
954
    ev = new Load_log_event(buf, event_len, description_event);
955
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
956
  case ROTATE_EVENT:
957
    ev = new Rotate_log_event(buf, event_len, description_event);
958
    break;
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
959
#ifdef HAVE_REPLICATION
960
  case SLAVE_EVENT: /* can never happen (unused event) */
961 962
    ev = new Slave_log_event(buf, event_len);
    break;
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
963
#endif /* HAVE_REPLICATION */
964
  case CREATE_FILE_EVENT:
965
    ev = new Create_file_log_event(buf, event_len, description_event);
966 967
    break;
  case APPEND_BLOCK_EVENT:
968
    ev = new Append_block_log_event(buf, event_len, description_event);
969 970
    break;
  case DELETE_FILE_EVENT:
971
    ev = new Delete_file_log_event(buf, event_len, description_event);
972 973
    break;
  case EXEC_LOAD_EVENT:
974
    ev = new Execute_load_log_event(buf, event_len, description_event);
975
    break;
976 977
  case START_EVENT_V3: /* this is sent only by MySQL <=4.x */
    ev = new Start_log_event_v3(buf, description_event);
978 979
    break;
  case STOP_EVENT:
980
    ev = new Stop_log_event(buf, description_event);
981 982
    break;
  case INTVAR_EVENT:
983
    ev = new Intvar_log_event(buf, description_event);
984
    break;
985 986 987
  case XID_EVENT:
    ev = new Xid_log_event(buf, description_event);
    break;
nick@mysql.com's avatar
nick@mysql.com committed
988
  case RAND_EVENT:
989
    ev = new Rand_log_event(buf, description_event);
nick@mysql.com's avatar
nick@mysql.com committed
990
    break;
991
  case USER_VAR_EVENT:
992 993 994 995
    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); 
996
    break;
997
#if defined(HAVE_REPLICATION) 
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
  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
1011 1012 1013 1014 1015 1016
  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;
1017
  default:
1018 1019
    DBUG_PRINT("error",("Unknown evernt code: %d",(int) buf[EVENT_TYPE_OFFSET]));
    ev= NULL;
1020
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1021
  }
1022

1023
  /*
1024 1025 1026 1027 1028 1029 1030
    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'.
1031
  */
1032
  if (!ev || !ev->is_valid())
1033
  {
1034 1035
    DBUG_PRINT("error",("Found invalid event in binary log"));

1036
    delete ev;
1037
#ifdef MYSQL_CLIENT
1038
    if (!force_opt) /* then mysqlbinlog dies */
1039 1040
    {
      *error= "Found invalid event in binary log";
monty@mysql.com's avatar
monty@mysql.com committed
1041
      DBUG_RETURN(0);
1042
    }
1043
    ev= new Unknown_log_event(buf, description_event);
1044 1045
#else
    *error= "Found invalid event in binary log";
monty@mysql.com's avatar
monty@mysql.com committed
1046
    DBUG_RETURN(0);
1047
#endif
1048
  }
monty@mysql.com's avatar
monty@mysql.com committed
1049
  DBUG_RETURN(ev);  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1050 1051
}

1052
#ifdef MYSQL_CLIENT
1053

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1054
/*
1055
  Log_event::print_header()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1056
*/
1057

1058 1059 1060
void Log_event::print_header(IO_CACHE* file,
                             PRINT_EVENT_INFO* print_event_info,
                             bool is_more __attribute__((unused)))
1061
{
1062
  char llbuff[22];
1063
  my_off_t hexdump_from= print_event_info->hexdump_from;
1064
  DBUG_ENTER("Log_event::print_header");
lars@mysql.com's avatar
lars@mysql.com committed
1065

1066
  my_b_printf(file, "#");
1067
  print_timestamp(file);
1068 1069
  my_b_printf(file, " server id %d  end_log_pos %s ", server_id,
              llstr(log_pos,llbuff));
1070

1071
  /* mysqlbinlog --hexdump */
1072
  if (print_event_info->hexdump_from)
1073
  {
1074
    my_b_printf(file, "\n");
1075 1076 1077
    uchar *ptr= (uchar*)temp_buf;
    my_off_t size=
      uint4korr(ptr + EVENT_LEN_OFFSET) - LOG_EVENT_MINIMAL_HEADER_LEN;
1078 1079
    my_off_t i;

1080 1081 1082 1083
    /* 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};

lars@mysql.com's avatar
lars@mysql.com committed
1084
    /* Pretty-print event common header if header is exactly 19 bytes */
1085
    if (print_event_info->common_header_len == LOG_EVENT_MINIMAL_HEADER_LEN)
lars@mysql.com's avatar
lars@mysql.com committed
1086
    {
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
      char emit_buf[256];               // Enough for storing one line
      my_b_printf(file, "# Position  Timestamp   Type   Master ID        "
                  "Size      Master Pos    Flags \n");
      int const bytes_written=
        my_snprintf(emit_buf, sizeof(emit_buf),
                    "# %8.8lx %02x %02x %02x %02x   %02x   "
                    "%02x %02x %02x %02x   %02x %02x %02x %02x   "
                    "%02x %02x %02x %02x   %02x %02x\n",
                    (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]);
      DBUG_ASSERT(bytes_written >= 0);
      DBUG_ASSERT(static_cast<my_size_t>(bytes_written) < sizeof(emit_buf));
1101
      my_b_write(file, (byte*) emit_buf, bytes_written);
lars@mysql.com's avatar
lars@mysql.com committed
1102 1103 1104
      ptr += LOG_EVENT_MINIMAL_HEADER_LEN;
      hexdump_from += LOG_EVENT_MINIMAL_HEADER_LEN;
    }
1105 1106 1107 1108 1109

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

1114
      *c++= my_isalnum(&my_charset_bin, *ptr) ? *ptr : '.';
1115 1116 1117

      if (i % 16 == 15)
      {
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
        /*
          my_b_printf() does not support full printf() formats, so we
          have to do it this way.

          TODO: Rewrite my_b_printf() to support full printf() syntax.
         */
        char emit_buf[256];
        int const bytes_written=
          my_snprintf(emit_buf, sizeof(emit_buf),
                      "# %8.8lx %-48.48s |%16s|\n",
                      (unsigned long) (hexdump_from + (i & 0xfffffff0)),
                      hex_string, char_string);
        DBUG_ASSERT(bytes_written >= 0);
        DBUG_ASSERT(static_cast<my_size_t>(bytes_written) < sizeof(emit_buf));
1132
	my_b_write(file, (byte*) emit_buf, bytes_written);
1133 1134 1135 1136
	hex_string[0]= 0;
	char_string[0]= 0;
	c= char_string;
	h= hex_string;
1137
      }
1138
      else if (i % 8 == 7) *h++ = ' ';
1139
    }
1140
    *c= '\0';
1141

1142
    /* Non-full last line */
1143
    if (hex_string[0])
1144 1145 1146 1147 1148 1149 1150 1151 1152
    {
      char emit_buf[256];
      int const bytes_written=
        my_snprintf(emit_buf, sizeof(emit_buf),
                    "# %8.8lx %-48.48s |%s|\n# ",
                    (unsigned long) (hexdump_from + (i & 0xfffffff0)),
                    hex_string, char_string);
      DBUG_ASSERT(bytes_written >= 0);
      DBUG_ASSERT(static_cast<my_size_t>(bytes_written) < sizeof(emit_buf));
1153
      my_b_write(file, (byte*) emit_buf, bytes_written);
1154
    }
1155
  }
1156
  DBUG_VOID_RETURN;
1157 1158
}

1159

1160 1161 1162
void Log_event::print_base64(IO_CACHE* file,
                             PRINT_EVENT_INFO* print_event_info,
                             bool more)
1163
{
1164
  const uchar *ptr= (const uchar *)temp_buf;
1165
  uint32 size= uint4korr(ptr + EVENT_LEN_OFFSET);
1166

1167 1168
  DBUG_ENTER("Log_event::print_base64");

1169
  size_t const tmp_str_sz= base64_needed_encoded_length((int) size);
1170
  char *const tmp_str= (char *) my_malloc(tmp_str_sz, MYF(MY_WME));
1171 1172 1173
  if (!tmp_str) {
    fprintf(stderr, "\nError: Out of memory. "
            "Could not print correct binlog event.\n");
1174
    DBUG_VOID_RETURN;
1175
  }
1176

1177
  int const res= base64_encode(ptr, (size_t) size, tmp_str);
1178 1179 1180 1181 1182 1183 1184 1185
  DBUG_ASSERT(res == 0);

  if (my_b_tell(file) == 0)
    my_b_printf(file, "\nBINLOG '\n");

  my_b_printf(file, "%s\n", tmp_str);

  if (!more)
1186
    my_b_printf(file, "'%s\n", print_event_info->delimiter);
1187

1188
  my_free(tmp_str, MYF(0));
1189
  DBUG_VOID_RETURN;
1190 1191 1192
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1193
/*
1194
  Log_event::print_timestamp()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1195
*/
1196

1197
void Log_event::print_timestamp(IO_CACHE* file, time_t* ts)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1198
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1199
  struct tm *res;
1200
  DBUG_ENTER("Log_event::print_timestamp");
1201 1202
  if (!ts)
    ts = &when;
1203 1204
#ifdef MYSQL_SERVER				// This is always false
  struct tm tm_tmp;
monty@work.mysql.com's avatar
monty@work.mysql.com committed
1205
  localtime_r(ts,(res= &tm_tmp));
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1206
#else
1207
  res=localtime(ts);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1208
#endif
1209

1210 1211 1212 1213 1214 1215 1216 1217
  my_b_printf(file,"%02d%02d%02d %2d:%02d:%02d",
              res->tm_year % 100,
              res->tm_mon+1,
              res->tm_mday,
              res->tm_hour,
              res->tm_min,
              res->tm_sec);
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1218 1219
}

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1220
#endif /* MYSQL_CLIENT */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1221 1222


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1223
/**************************************************************************
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1224
	Query_log_event methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1225
**************************************************************************/
1226

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1227
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
1228

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1229
/*
1230
  Query_log_event::pack_info()
1231 1232 1233 1234
  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).
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1235
*/
1236

1237
void Query_log_event::pack_info(Protocol *protocol)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1238
{
1239
  // TODO: show the catalog ??
1240 1241 1242
  char *buf, *pos;
  if (!(buf= my_malloc(9 + db_len + q_len, MYF(MY_WME))))
    return;
1243 1244
  pos= buf;
  if (!(flags & LOG_EVENT_SUPPRESS_USE_F)
1245
      && db && db_len)
1246
  {
1247 1248
    pos= strmov(buf, "use `");
    memcpy(pos, db, db_len);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1249
    pos= strmov(pos+db_len, "`; ");
1250
  }
1251
  if (query && q_len)
1252 1253 1254 1255
  {
    memcpy(pos, query, q_len);
    pos+= q_len;
  }
1256
  protocol->store(buf, pos-buf, &my_charset_bin);
1257
  my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
1258
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1259
#endif
1260

1261
#ifndef MYSQL_CLIENT
1262

1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274
/* 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;
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1275
/*
1276
  Query_log_event::write()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1277

1278 1279 1280 1281
  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!
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1282
*/
1283

1284
bool Query_log_event::write(IO_CACHE* file)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1285
{
1286 1287 1288 1289 1290
  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
1291
            1+6+           // code of charset and charset
1292
            1+1+MAX_TIME_ZONE_NAME_LENGTH+ // code of tz and tz length and tz name
1293
            1+2            // code of lc_time_names and lc_time_names_number
1294
            ], *start, *start_of_status;
1295
  ulong event_length;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1296

1297
  if (!query)
1298 1299
    return 1;                                   // Something wrong with event

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1300 1301 1302 1303 1304
  /*
    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.
1305
    Now imagine we (write()) are called by the slave SQL thread (we are
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
    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);
1338 1339 1340 1341
  int4store(buf + Q_EXEC_TIME_OFFSET, exec_time);
  buf[Q_DB_LEN_OFFSET] = (char) db_len;
  int2store(buf + Q_ERR_CODE_OFFSET, error_code);

1342 1343 1344 1345 1346 1347 1348 1349
  /*
    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)
  {
1350
    *start++= Q_FLAGS2_CODE;
1351 1352 1353 1354 1355
    int4store(start, flags2);
    start+= 4;
  }
  if (sql_mode_inited)
  {
1356
    *start++= Q_SQL_MODE_CODE;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1357
    int8store(start, (ulonglong)sql_mode);
1358 1359
    start+= 8;
  }
1360
  if (catalog_len) // i.e. this var is inited (false for 4.0 events)
1361
  {
1362 1363
    write_str_with_code_and_len((char **)(&start),
                                catalog, catalog_len, Q_CATALOG_NZ_CODE);
1364
    /*
1365 1366 1367 1368 1369 1370
      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
1371 1372 1373 1374 1375
      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
1376 1377
      Q_AUTO_INCREMENT*, Q_CHARSET and so replication will fail silently in
      various ways. Documented that you should not mix alpha/beta versions if
1378 1379 1380
      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.
1381 1382 1383 1384 1385 1386 1387 1388 1389
    */
  }
  if (auto_increment_increment != 1)
  {
    *start++= Q_AUTO_INCREMENT;
    int2store(start, auto_increment_increment);
    int2store(start+2, auto_increment_offset);
    start+= 4;
  }
1390 1391
  if (charset_inited)
  {
1392
    *start++= Q_CHARSET_CODE;
1393 1394 1395
    memcpy(start, charset, 6);
    start+= 6;
  }
1396 1397 1398 1399 1400 1401 1402 1403 1404
  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;
  }
1405 1406 1407 1408 1409 1410 1411
  if (lc_time_names_number)
  {
    DBUG_ASSERT(lc_time_names_number <= 0xFFFF);
    *start++= Q_LC_TIME_NAMES_CODE;
    int2store(start, lc_time_names_number);
    start+= 2;
  }
1412 1413
  /*
    Here there could be code like
1414
    if (command-line-option-which-says-"log_this_variable" && inited)
1415
    {
1416
    *start++= Q_THIS_VARIABLE_CODE;
1417 1418 1419 1420 1421 1422 1423
    int4store(start, this_variable);
    start+= 4;
    }
  */
  
  /* Store length of status variables */
  status_vars_len= (uint) (start-start_of_status);
1424
  DBUG_ASSERT(status_vars_len <= MAX_SIZE_LOG_EVENT_STATUS);
1425 1426 1427 1428 1429 1430
  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
  */
1431
  event_length= (uint) (start-buf) + get_post_header_size_for_derived() + db_len + 1 + q_len;
1432 1433

  return (write_header(file, event_length) ||
1434 1435 1436 1437
          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)) ||
1438 1439
          my_b_safe_write(file, (db) ? (byte*) db : (byte*)"", db_len + 1) ||
          my_b_safe_write(file, (byte*) query, q_len)) ? 1 : 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1440 1441
}

1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
/*
  Query_log_event::Query_log_event()
 
  The simplest constructor that could possibly work.  This is used for
  creating static objects that have a special meaning and are invisible
  to the log.  
*/
Query_log_event::Query_log_event()
  :Log_event(), data_buf(0)
{
}

1454

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1455
/*
1456
  Query_log_event::Query_log_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1457
*/
1458
Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
1459 1460
				 ulong query_length, bool using_trans,
				 bool suppress_use)
1461
  :Log_event(thd_arg,
1462 1463 1464
	     ((thd_arg->tmp_table_used ? LOG_EVENT_THREAD_SPECIFIC_F : 0)
	      | (suppress_use          ? LOG_EVENT_SUPPRESS_USE_F    : 0)),
	     using_trans),
1465
   data_buf(0), query(query_arg), catalog(thd_arg->catalog),
1466
   db(thd_arg->db), q_len((uint32) query_length),
1467
   error_code((thd_arg->killed != THD::NOT_KILLED) ?
1468
              ((thd_arg->system_thread & SYSTEM_THREAD_DELAYED_INSERT) ?
1469
               0 : thd->killed_errno()) : thd_arg->net.last_errno),
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1470 1471
   thread_id(thd_arg->thread_id),
   /* save the original thread id; we already know the server id */
1472
   slave_proxy_id(thd_arg->variables.pseudo_thread_id),
1473
   flags2_inited(1), sql_mode_inited(1), charset_inited(1),
1474 1475
   sql_mode(thd_arg->variables.sql_mode),
   auto_increment_increment(thd_arg->variables.auto_increment_increment),
1476 1477
   auto_increment_offset(thd_arg->variables.auto_increment_offset),
   lc_time_names_number(thd_arg->variables.lc_time_names->number)
1478 1479 1480 1481
{
  time_t end_time;
  time(&end_time);
  exec_time = (ulong) (end_time  - thd->start_time);
1482
  catalog_len = (catalog) ? (uint32) strlen(catalog) : 0;
1483
  /* status_vars_len is set just before writing the event */
1484
  db_len = (db) ? (uint32) strlen(db) : 0;
1485 1486 1487 1488 1489 1490 1491
  /*
    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 &.
  */
1492
  flags2= (uint32) (thd_arg->options & OPTIONS_WRITTEN_TO_BIN_LOG);
1493 1494 1495 1496 1497 1498
  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);
1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
  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;
1511 1512
  DBUG_PRINT("info",("Query_log_event has flags2: %lu  sql_mode: %lu",
                     (ulong) flags2, sql_mode));
1513
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1514
#endif /* MYSQL_CLIENT */
1515

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1516

1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535
/* 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;
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1536
/*
1537
  Query_log_event::Query_log_event()
1538
  This is used by the SQL slave thread to prepare the event before execution.
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1539
*/
1540

1541
Query_log_event::Query_log_event(const char* buf, uint event_len,
1542 1543
                                 const Format_description_log_event *description_event,
                                 Log_event_type event_type)
1544
  :Log_event(buf, description_event), data_buf(0), query(NullS),
1545
   db(NullS), catalog_len(0), status_vars_len(0),
1546
   flags2_inited(0), sql_mode_inited(0), charset_inited(0),
1547
   auto_increment_increment(1), auto_increment_offset(1),
1548
   time_zone_len(0), lc_time_names_number(0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1549 1550
{
  ulong data_len;
1551 1552
  uint32 tmp;
  uint8 common_header_len, post_header_len;
1553 1554
  char *start;
  const char *end;
1555
  bool catalog_nz= 1;
1556 1557 1558
  DBUG_ENTER("Query_log_event::Query_log_event(char*,...)");

  common_header_len= description_event->common_header_len;
1559
  post_header_len= description_event->post_header_len[event_type-1];
1560
  DBUG_PRINT("info",("event_len: %u  common_header_len: %d  post_header_len: %d",
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574
                     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);
1575
  db_len = (uint)buf[Q_DB_LEN_OFFSET]; // TODO: add a check of all *_len vars
1576 1577 1578 1579 1580 1581 1582 1583 1584
  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)
1585
  {
1586 1587 1588 1589 1590
    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;
1591
  }
1592 1593 1594 1595 1596 1597
  /*
    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...)
  */

1598 1599 1600
  /* variable-part: the status vars; only in MySQL 5.0  */
  
  start= (char*) (buf+post_header_len);
1601
  end= (const char*) (start+status_vars_len);
1602
  for (const uchar* pos= (const uchar*) start; pos < (const uchar*) end;)
1603
  {
1604 1605 1606 1607
    switch (*pos++) {
    case Q_FLAGS2_CODE:
      flags2_inited= 1;
      flags2= uint4korr(pos);
1608
      DBUG_PRINT("info",("In Query_log_event, read flags2: %lu", (ulong) flags2));
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622
      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;
    }
1623
    case Q_CATALOG_NZ_CODE:
1624
      get_str_len_and_pointer(&catalog, (const char **)(&pos), &catalog_len);
1625 1626 1627 1628 1629 1630
      break;
    case Q_AUTO_INCREMENT:
      auto_increment_increment= uint2korr(pos);
      auto_increment_offset=    uint2korr(pos+2);
      pos+= 4;
      break;
1631 1632 1633 1634 1635 1636 1637
    case Q_CHARSET_CODE:
    {
      charset_inited= 1;
      memcpy(charset, pos, 6);
      pos+= 6;
      break;
    }
1638 1639
    case Q_TIME_ZONE_CODE:
    {
1640
      get_str_len_and_pointer(&time_zone_str, (const char **)(&pos), &time_zone_len);
1641 1642
      break;
    }
1643 1644 1645 1646 1647 1648
    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;
1649 1650 1651 1652
    case Q_LC_TIME_NAMES_CODE:
      lc_time_names_number= uint2korr(pos);
      pos+= 2;
      break;
1653 1654 1655 1656
    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)));
1657
      pos= (const uchar*) end;                         // Break loop
1658
    }
1659
  }
1660
  
1661
#if !defined(MYSQL_CLIENT) && defined(HAVE_QUERY_CACHE)
1662 1663
  if (!(start= data_buf = (char*) my_malloc(catalog_len + 1 +
                                            time_zone_len + 1 +
1664 1665 1666 1667 1668 1669 1670 1671 1672
                                            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))))
1673
#endif
1674
      DBUG_VOID_RETURN;
1675
  if (catalog_len)                                  // If catalog is given
1676
  {
1677
    if (likely(catalog_nz)) // true except if event comes from 5.0.0|1|2|3.
1678
      copy_str_and_move(&start, &catalog, catalog_len);
1679 1680 1681 1682 1683 1684
    else
    {
      memcpy(start, catalog, catalog_len+1); // copy end 0
      catalog= start;
      start+= catalog_len+1;
    }
1685
  }
1686
  if (time_zone_len)
1687 1688
    copy_str_and_move(&start, &time_zone_str, time_zone_len);

1689
  /* A 2nd variable part; this is common to all versions */ 
1690
  memcpy((char*) start, end, data_len);          // Copy db and query
1691
  start[data_len]= '\0';              // End query with \0 (For safetly)
1692 1693 1694 1695
  db= start;
  query= start + db_len + 1;
  q_len= data_len - db_len -1;
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1696 1697
}

1698

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1699
/*
1700
  Query_log_event::print()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1701
*/
1702

1703
#ifdef MYSQL_CLIENT
1704
void Query_log_event::print_query_header(IO_CACHE* file,
1705
					 PRINT_EVENT_INFO* print_event_info)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1706
{
1707
  // TODO: print the catalog ??
1708
  char buff[40],*end;				// Enough for SET TIMESTAMP
1709 1710 1711
  bool different_db= 1;
  uint32 tmp;

1712
  if (!print_event_info->short_form)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1713
  {
1714 1715 1716 1717
    print_header(file, print_event_info, FALSE);
    my_b_printf(file, "\t%s\tthread_id=%lu\texec_time=%lu\terror_code=%d\n",
                get_type_str(), (ulong) thread_id, (ulong) exec_time,
                error_code);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1718 1719
  }

monty@mysql.com's avatar
monty@mysql.com committed
1720
  if (!(flags & LOG_EVENT_SUPPRESS_USE_F) && db)
1721
  {
1722 1723
    if (different_db= memcmp(print_event_info->db, db, db_len + 1))
      memcpy(print_event_info->db, db, db_len + 1);
monty@mysql.com's avatar
monty@mysql.com committed
1724
    if (db[0] && different_db) 
1725
      my_b_printf(file, "use %s%s\n", db, print_event_info->delimiter);
1726
  }
1727

1728
  end=int10_to_str((long) when, strmov(buff,"SET TIMESTAMP="),10);
1729
  end= strmov(end, print_event_info->delimiter);
1730
  *end++='\n';
1731
  my_b_write(file, (byte*) buff, (uint) (end-buff));
1732
  if (flags & LOG_EVENT_THREAD_SPECIFIC_F)
1733 1734
    my_b_printf(file,"SET @@session.pseudo_thread_id=%lu%s\n",
                (ulong)thread_id, print_event_info->delimiter);
1735

1736
  /*
1737 1738 1739
    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).
1740 1741 1742 1743
  */
  if (likely(flags2_inited)) /* likely as this will mainly read 5.0 logs */
  {
    /* tmp is a bitmask of bits which have changed. */
1744
    if (likely(print_event_info->flags2_inited)) 
1745
      /* All bits which have changed */
1746
      tmp= (print_event_info->flags2) ^ flags2;
1747 1748
    else /* that's the first Query event we read */
    {
1749
      print_event_info->flags2_inited= 1;
1750 1751 1752 1753 1754 1755
      tmp= ~((uint32)0); /* all bits have changed */
    }

    if (unlikely(tmp)) /* some bits have changed */
    {
      bool need_comma= 0;
1756
      my_b_printf(file, "SET ");
1757 1758 1759 1760 1761 1762
      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);
1763
      my_b_printf(file,"%s\n", print_event_info->delimiter);
1764
      print_event_info->flags2= flags2;
1765 1766 1767 1768
    }
  }

  /*
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
    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.
1779 1780 1781 1782
  */

  if (likely(sql_mode_inited))
  {
1783
    if (unlikely(!print_event_info->sql_mode_inited)) /* first Query event */
1784
    {
1785
      print_event_info->sql_mode_inited= 1;
1786
      /* force a difference to force write */
1787
      print_event_info->sql_mode= ~sql_mode;
1788
    }
1789
    if (unlikely(print_event_info->sql_mode != sql_mode))
1790
    {
1791 1792
      my_b_printf(file,"SET @@session.sql_mode=%lu%s\n",
                  (ulong)sql_mode, print_event_info->delimiter);
1793
      print_event_info->sql_mode= sql_mode;
1794 1795
    }
  }
1796 1797
  if (print_event_info->auto_increment_increment != auto_increment_increment ||
      print_event_info->auto_increment_offset != auto_increment_offset)
1798
  {
1799 1800 1801
    my_b_printf(file,"SET @@session.auto_increment_increment=%lu, @@session.auto_increment_offset=%lu%s\n",
                auto_increment_increment,auto_increment_offset,
                print_event_info->delimiter);
1802 1803
    print_event_info->auto_increment_increment= auto_increment_increment;
    print_event_info->auto_increment_offset=    auto_increment_offset;
1804 1805
  }

1806 1807
  /* TODO: print the catalog when we feature SET CATALOG */

1808 1809
  if (likely(charset_inited))
  {
1810
    if (unlikely(!print_event_info->charset_inited)) /* first Query event */
1811
    {
1812 1813
      print_event_info->charset_inited= 1;
      print_event_info->charset[0]= ~charset[0]; // force a difference to force write
1814
    }
1815
    if (unlikely(bcmp(print_event_info->charset, charset, 6)))
1816
    {
1817 1818 1819
      CHARSET_INFO *cs_info= get_charset(uint2korr(charset), MYF(MY_WME));
      if (cs_info)
      {
1820
        /* for mysql client */
1821 1822
        my_b_printf(file, "/*!\\C %s */%s\n",
                    cs_info->csname, print_event_info->delimiter);
1823
      }
1824 1825 1826 1827
      my_b_printf(file,"SET "
                  "@@session.character_set_client=%d,"
                  "@@session.collation_connection=%d,"
                  "@@session.collation_server=%d"
1828
                  "%s\n",
1829 1830
                  uint2korr(charset),
                  uint2korr(charset+2),
1831 1832
                  uint2korr(charset+4),
                  print_event_info->delimiter);
1833
      memcpy(print_event_info->charset, charset, 6);
1834 1835
    }
  }
1836 1837
  if (time_zone_len)
  {
1838
    if (bcmp(print_event_info->time_zone_str, time_zone_str, time_zone_len+1))
1839
    {
1840 1841
      my_b_printf(file,"SET @@session.time_zone='%s'%s\n",
                  time_zone_str, print_event_info->delimiter);
1842
      memcpy(print_event_info->time_zone_str, time_zone_str, time_zone_len+1);
1843 1844
    }
  }
1845 1846 1847 1848 1849
  if (lc_time_names_number != print_event_info->lc_time_names_number)
  {
    fprintf(file, "SET @@session.lc_time_names=%d;\n", lc_time_names_number);
    print_event_info->lc_time_names_number= lc_time_names_number;
  }
1850 1851
}

1852

1853
void Query_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
1854
{
1855 1856 1857 1858
  Write_on_release_cache cache(&print_event_info->head_cache, file);

  print_query_header(&cache, print_event_info);
  my_b_write(&cache, (byte*) query, q_len);
1859
  my_b_printf(&cache, "%s\n", print_event_info->delimiter);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1860
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1861
#endif /* MYSQL_CLIENT */
1862

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1863

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1864
/*
1865
  Query_log_event::exec_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1866
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1867

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1868
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
1869

1870
int Query_log_event::exec_event(struct st_relay_log_info* rli)
1871 1872 1873 1874 1875
{
  return exec_event(rli, query, q_len);
}


1876 1877
int Query_log_event::exec_event(struct st_relay_log_info* rli,
                                const char *query_arg, uint32 q_len_arg)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1878
{
1879
  LEX_STRING new_db;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1880
  int expected_error,actual_error= 0;
1881 1882 1883 1884 1885 1886
  /*
    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.
  */
1887
  thd->catalog= catalog_len ? (char *) catalog : (char *)"";
1888 1889 1890
  new_db.length= db_len;
  new_db.str= (char *) rpl_filter->get_rewrite_db(db, &new_db.length);
  thd->set_db(new_db.str, new_db.length);       /* allocates a copy of 'db' */
1891 1892
  thd->variables.auto_increment_increment= auto_increment_increment;
  thd->variables.auto_increment_offset=    auto_increment_offset;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1893

1894
  /*
1895 1896 1897 1898 1899 1900 1901 1902
    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.
1903
  */
monty@mysql.com's avatar
monty@mysql.com committed
1904
  rli->future_group_master_log_pos= log_pos;
1905 1906
  DBUG_PRINT("info", ("log_pos: %lu", (ulong) log_pos));

monty@mysql.com's avatar
monty@mysql.com committed
1907
  clear_all_errors(thd, rli);
1908
  rli->clear_tables_to_lock();
1909

lars@mysql.com's avatar
lars@mysql.com committed
1910 1911 1912 1913 1914 1915 1916 1917 1918 1919
  /*
    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().
  */
1920
  if (rpl_filter->db_ok(thd->db))
1921 1922
  {
    thd->set_time((time_t)when);
1923 1924
    thd->query_length= q_len_arg;
    thd->query= (char*)query_arg;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1925
    VOID(pthread_mutex_lock(&LOCK_thread_count));
1926
    thd->query_id = next_query_id();
1927
    VOID(pthread_mutex_unlock(&LOCK_thread_count));
1928
    thd->variables.pseudo_thread_id= thread_id;		// for temp tables
monty@mysql.com's avatar
monty@mysql.com committed
1929
    DBUG_PRINT("query",("%s",thd->query));
1930

monty@mysql.com's avatar
monty@mysql.com committed
1931
    if (ignored_error_code((expected_error= error_code)) ||
1932
	!check_expected_error(thd,rli,expected_error))
1933 1934 1935
    {
      if (flags2_inited)
        /*
1936 1937
          all bits of thd->options which are 1 in OPTIONS_WRITTEN_TO_BIN_LOG
          must take their value from flags2.
1938
        */
1939
        thd->options= flags2|(thd->options & ~OPTIONS_WRITTEN_TO_BIN_LOG);
1940 1941
      /*
        else, we are in a 3.23/4.0 binlog; we previously received a
1942 1943
        Rotate_log_event which reset thd->options and sql_mode etc, so
        nothing to do.
1944 1945 1946 1947 1948
      */
      /*
        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
1949 1950 1951
        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).
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969
      */
      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))))
          {
            /*
1970 1971 1972 1973
              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).
1974
            */
1975
            set_slave_thread_default_charset(thd, rli);
1976 1977 1978 1979 1980
            goto compare_errors;
          }
          thd->update_charset(); // for the charset change to take effect
        }
      }
1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991
      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;
        }
      }
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
      if (lc_time_names_number)
      {
        if (!(thd->variables.lc_time_names=
              my_locale_by_number(lc_time_names_number)))
        {
          my_printf_error(ER_UNKNOWN_ERROR,
                      "Unknown locale: '%d'", MYF(0), lc_time_names_number);
          thd->variables.lc_time_names= &my_locale_en_US;
          goto compare_errors;
        }
      }
      else
        thd->variables.lc_time_names= &my_locale_en_US;
2005 2006

      /* Execute the query (note that we bypass dispatch_command()) */
2007
      mysql_parse(thd, thd->query, thd->query_length);
2008 2009

    }
monty@mysql.com's avatar
monty@mysql.com committed
2010 2011
    else
    {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2012
      /*
monty@mysql.com's avatar
monty@mysql.com committed
2013 2014 2015 2016 2017
        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.
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2018
      */
2019
      if (mysql_test_parse_for_slave(thd, thd->query, thd->query_length))
monty@mysql.com's avatar
monty@mysql.com committed
2020 2021
        clear_all_errors(thd, rli);        /* Can ignore query */
      else
2022
      {
2023
        slave_print_msg(ERROR_LEVEL, rli, expected_error, 
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2024
                          "\
monty@mysql.com's avatar
monty@mysql.com committed
2025
Query partially completed on the master (error on master: %d) \
monty@mysql.com's avatar
monty@mysql.com committed
2026 2027 2028
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; \
monty@mysql.com's avatar
monty@mysql.com committed
2029
START SLAVE; . Query: '%s'", expected_error, thd->query);
monty@mysql.com's avatar
monty@mysql.com committed
2030 2031 2032 2033
        thd->query_error= 1;
      }
      goto end;
    }
2034

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

2039
compare_errors:
lars@mysql.com's avatar
lars@mysql.com committed
2040 2041

     /*
monty@mysql.com's avatar
monty@mysql.com committed
2042 2043 2044 2045
      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",
2046
 		       expected_error, thd->net.last_errno));
monty@mysql.com's avatar
monty@mysql.com committed
2047
    if ((expected_error != (actual_error= thd->net.last_errno)) &&
2048 2049 2050
 	expected_error &&
 	!ignored_error_code(actual_error) &&
 	!ignored_error_code(expected_error))
monty@mysql.com's avatar
monty@mysql.com committed
2051
    {
2052 2053 2054
      slave_print_msg(ERROR_LEVEL, rli, 0,
                      "\
Query caused different errors on master and slave.     \
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2055
Error on master: '%s' (%d), Error on slave: '%s' (%d). \
monty@mysql.com's avatar
monty@mysql.com committed
2056
Default database: '%s'. Query: '%s'",
2057 2058 2059 2060 2061
                      ER_SAFE(expected_error),
                      expected_error,
                      actual_error ? thd->net.last_error: "no error",
                      actual_error,
                      print_slave_db_safe(db), query_arg);
monty@mysql.com's avatar
monty@mysql.com committed
2062 2063 2064 2065 2066 2067
      thd->query_error= 1;
    }
    /*
      If we get the same error code as expected, or they should be ignored. 
    */
    else if (expected_error == actual_error ||
2068
 	     ignored_error_code(actual_error))
monty@mysql.com's avatar
monty@mysql.com committed
2069 2070 2071 2072 2073 2074
    {
      DBUG_PRINT("info",("error ignored"));
      clear_all_errors(thd, rli);
    }
    /*
      Other cases: mostly we expected no error and get one.
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2075
    */
monty@mysql.com's avatar
monty@mysql.com committed
2076 2077
    else if (thd->query_error || thd->is_fatal_error)
    {
2078 2079 2080 2081 2082
      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);
monty@mysql.com's avatar
monty@mysql.com committed
2083 2084
      thd->query_error= 1;
    }
2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098

    /*
      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...
2099

2100 2101 2102 2103 2104 2105 2106
      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.
    */
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2107 2108
  } /* End of if (db_ok(... */

monty@mysql.com's avatar
monty@mysql.com committed
2109
end:
2110
  VOID(pthread_mutex_lock(&LOCK_thread_count));
2111 2112 2113 2114 2115 2116
  /*
    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
2117 2118 2119
    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.
2120
  */
2121
  thd->catalog= 0;
2122
  thd->set_db(NULL, 0);                 /* will free the current database */
2123
  thd->query= 0;			// just to be sure
2124
  thd->query_length= 0;
2125
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2126
  close_thread_tables(thd);      
2127 2128 2129 2130 2131 2132 2133 2134 2135 2136
  /*
    As a disk space optimization, future masters will not log an event for
    LAST_INSERT_ID() if that function returned 0 (and thus they will be able
    to replace the THD::stmt_depends_on_first_successful_insert_id_in_prev_stmt
    variable by (THD->first_successful_insert_id_in_prev_stmt > 0) ; with the
    resetting below we are ready to support that.
  */
  thd->first_successful_insert_id_in_prev_stmt_for_binlog= 0;
  thd->first_successful_insert_id_in_prev_stmt= 0;
  thd->stmt_depends_on_first_successful_insert_id_in_prev_stmt= 0;
2137
  free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
2138 2139 2140 2141 2142 2143 2144
  /*
    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 : 
2145
          (thd->one_shot_set ? (rli->inc_event_relay_log_pos(),0) :
2146
           Log_event::exec_event(rli))); 
2147
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
2148
#endif
2149

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2150

2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165
/**************************************************************************
	Muted_query_log_event methods
**************************************************************************/

#ifndef MYSQL_CLIENT
/*
  Muted_query_log_event::Muted_query_log_event()
*/
Muted_query_log_event::Muted_query_log_event()
  :Query_log_event()
{
}
#endif


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2166
/**************************************************************************
2167
	Start_log_event_v3 methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2168
**************************************************************************/
2169

2170 2171 2172 2173 2174 2175 2176 2177
#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

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2178
/*
2179
  Start_log_event_v3::pack_info()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2180
*/
2181

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
2182
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
2183
void Start_log_event_v3::pack_info(Protocol *protocol)
nick@mysql.com's avatar
nick@mysql.com committed
2184
{
2185 2186 2187 2188
  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: ");
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2189 2190
  pos= int10_to_str(binlog_version, pos, 10);
  protocol->store(buf, (uint) (pos-buf), &my_charset_bin);
nick@mysql.com's avatar
nick@mysql.com committed
2191
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
2192
#endif
2193 2194


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2195
/*
2196
  Start_log_event_v3::print()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2197
*/
nick@mysql.com's avatar
nick@mysql.com committed
2198 2199

#ifdef MYSQL_CLIENT
2200
void Start_log_event_v3::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
nick@mysql.com's avatar
nick@mysql.com committed
2201
{
2202 2203 2204 2205 2206
  DBUG_ENTER("Start_log_event_v3::print");

  Write_on_release_cache cache(&print_event_info->head_cache, file,
                               Write_on_release_cache::FLUSH_F);

2207
  if (!print_event_info->short_form)
2208
  {
2209 2210 2211 2212
    print_header(&cache, print_event_info, FALSE);
    my_b_printf(&cache, "\tStart: binlog v %d, server v %s created ",
                binlog_version, server_version);
    print_timestamp(&cache);
2213
    if (created)
2214 2215
      my_b_printf(&cache," at startup");
    my_b_printf(&cache, "\n");
2216
    if (flags & LOG_EVENT_BINLOG_IN_USE_F)
2217 2218
      my_b_printf(&cache, "# Warning: this binlog was not closed properly. "
                  "Most probably mysqld crashed writing it.\n");
2219
  }
2220 2221
  if (!artificial_event && created)
  {
2222
#ifdef WHEN_WE_HAVE_THE_RESET_CONNECTION_SQL_COMMAND
2223 2224 2225 2226 2227 2228
    /*
      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).
    */
2229
    my_b_printf(&cache,"RESET CONNECTION%s\n", print_event_info->delimiter);
2230
#else
2231
    my_b_printf(&cache,"ROLLBACK%s\n", print_event_info->delimiter);
2232
#endif
2233
  }
2234
  DBUG_VOID_RETURN;
nick@mysql.com's avatar
nick@mysql.com committed
2235
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2236
#endif /* MYSQL_CLIENT */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2237

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2238
/*
2239
  Start_log_event_v3::Start_log_event_v3()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2240
*/
2241

2242 2243 2244
Start_log_event_v3::Start_log_event_v3(const char* buf,
                                       const Format_description_log_event* description_event)
  :Log_event(buf, description_event)
2245
{
2246 2247
  buf+= description_event->common_header_len;
  binlog_version= uint2korr(buf+ST_BINLOG_VER_OFFSET);
2248 2249
  memcpy(server_version, buf+ST_SERVER_VER_OFFSET,
	 ST_SERVER_VER_LEN);
2250 2251 2252
  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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2253 2254
}

2255

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2256
/*
2257
  Start_log_event_v3::write()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2258
*/
2259

2260
#ifndef MYSQL_CLIENT
2261
bool Start_log_event_v3::write(IO_CACHE* file)
2262
{
2263
  char buff[START_V3_HEADER_LEN];
2264 2265 2266
  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);
2267 2268
  return (write_header(file, sizeof(buff)) ||
          my_b_safe_write(file, (byte*) buff, sizeof(buff)));
2269
}
2270
#endif
2271

2272

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2273
/*
2274
  Start_log_event_v3::exec_event()
2275 2276 2277 2278

  The master started

  IMPLEMENTATION
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2279 2280 2281 2282
    - 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).
2283 2284

  TODO
2285 2286 2287 2288 2289
    - 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.
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2290 2291
*/

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
2292
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
2293
int Start_log_event_v3::exec_event(struct st_relay_log_info* rli)
2294
{
2295
  DBUG_ENTER("Start_log_event_v3::exec_event");
2296
  switch (binlog_version)
2297 2298 2299 2300 2301 2302 2303 2304
  {
  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').
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2305
    */
2306 2307 2308 2309 2310
    if (created)
    {
      close_temporary_tables(thd);
      cleanup_load_tmpdir();
    }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2311 2312
    break;

2313
    /*
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2314 2315
       Now the older formats; in that case load_tmpdir is cleaned up by the I/O
       thread.
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2316
    */
2317
  case 1:
2318
    if (strncmp(rli->relay_log.description_event_for_exec->server_version,
2319 2320 2321 2322 2323 2324 2325 2326
                "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);
    }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2327
    /*
2328 2329 2330
      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.
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2331 2332 2333 2334
    */
    break;
  default:
    /* this case is impossible */
2335
    DBUG_RETURN(1);
nick@mysql.com's avatar
nick@mysql.com committed
2336
  }
2337
  DBUG_RETURN(Log_event::exec_event(rli));
2338
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2339
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
2340

2341 2342 2343 2344 2345 2346 2347 2348 2349
/***************************************************************************
       Format_description_log_event methods
****************************************************************************/

/*
  Format_description_log_event 1st ctor.

  SYNOPSIS
    Format_description_log_event::Format_description_log_event
2350
      binlog_version              the binlog version for which we want to build
2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364
                                  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::
2365
Format_description_log_event(uint8 binlog_ver, const char* server_ver)
2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376
  :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),
2377
                                       MYF(MY_ZEROFILL));
2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394
    /*
      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;
2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413
      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;);
2414 2415
      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;
2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429
    }
    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 :
2430
      LOG_EVENT_MINIMAL_HEADER_LEN;
2431 2432 2433 2434 2435 2436 2437 2438 2439
    /*
      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),
2440
                                       MYF(0));
2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470
    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
2471
  post-header starts.
2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486
  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*
2487
                             description_event)
2488 2489 2490 2491 2492 2493 2494 2495 2496
  :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",
2497
                      common_header_len, number_of_event_types));
2498 2499 2500
  /* 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*
2501
                                      sizeof(*post_header_len), MYF(0));
2502 2503 2504
  DBUG_VOID_RETURN;
}

2505
#ifndef MYSQL_CLIENT
2506 2507 2508 2509 2510 2511 2512 2513 2514 2515
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);
2516
  buff[ST_COMMON_HEADER_LEN_OFFSET]= LOG_EVENT_HEADER_LEN;
2517 2518 2519 2520 2521
  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)));
}
2522
#endif
2523

2524 2525 2526
/*
  SYNOPSIS
    Format_description_log_event::exec_event()
2527

2528 2529 2530 2531 2532 2533 2534 2535 2536 2537
  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");
2538 2539

  /* save the information describing this binlog */
2540 2541 2542
  delete rli->relay_log.description_event_for_exec;
  rli->relay_log.description_event_for_exec= this;

serg@serg.mylan's avatar
serg@serg.mylan committed
2543
#ifdef USING_TRANSACTIONS
2544 2545 2546 2547
  /*
    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
2548 2549
    flushing the binlog cache to the binlog. XA guarantees that master has
    rolled back. So we roll back.
2550 2551 2552 2553 2554 2555 2556
    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)
  {
2557 2558 2559 2560 2561 2562 2563
    /* 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);
2564
  }
serg@serg.mylan's avatar
serg@serg.mylan committed
2565
#endif
2566 2567 2568 2569 2570 2571 2572 2573
  /*
    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)
  {
    /*
2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586
      We only increase the relay log position if we are skipping
      events and do not touch any group_* variables, nor flush the
      relay log info.  If there is a crash, we will have to re-skip
      the events again, but that is a minor issue.

      If we do not skip stepping the group log position (and the
      server id was changed when restarting the server), it might well
      be that we start executing at a position that is invalid, e.g.,
      at a Rows_log_event or a Query_log_event preceeded by a
      Intvar_log_event instead of starting at a Table_map_log_event or
      the Intvar_log_event respectively.
     */
    rli->inc_event_relay_log_pos();
2587 2588 2589 2590 2591 2592 2593
    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
2594 2595 2596
    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.
2597 2598 2599 2600 2601 2602
  */
  DBUG_RETURN(Start_log_event_v3::exec_event(rli));
}
#endif

  /**************************************************************************
2603
        Load_log_event methods
2604
   General note about Load_log_event: the binlogging of LOAD DATA INFILE is
2605
   going to be changed in 5.0 (or maybe in 5.1; not decided yet).
2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617
   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).
  **************************************************************************/
2618

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2619
/*
2620
  Load_log_event::pack_info()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2621
*/
2622

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
2623
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
2624
uint Load_log_event::get_query_buffer_length()
2625
{
2626
  return
2627 2628
    5 + db_len + 3 +                        // "use DB; "
    18 + fname_len + 2 +                    // "LOAD DATA INFILE 'file''"
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2629
    7 +					    // LOCAL
2630
    9 +                                     // " REPLACE or IGNORE "
2631
    13 + table_name_len*2 +                 // "INTO TABLE `table`"
2632 2633 2634 2635
    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'"
2636 2637
    19 + sql_ex.line_start_len*4 + 2 +      // " LINES STARTING BY 'str'"
    15 + 22 +                               // " IGNORE xxx  LINES"
2638
    3 + (num_fields-1)*2 + field_block_len; // " (field1, field2, ...)"
2639
}
2640

2641 2642 2643 2644 2645 2646 2647

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)
2648
  {
2649 2650
    pos= strmov(pos, "use `");
    memcpy(pos, db, db_len);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2651
    pos= strmov(pos+db_len, "`; ");
2652
  }
2653

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2654
  pos= strmov(pos, "LOAD DATA ");
2655 2656 2657 2658

  if (fn_start)
    *fn_start= pos;

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2659 2660 2661
  if (check_fname_outside_temp_buf())
    pos= strmov(pos, "LOCAL ");
  pos= strmov(pos, "INFILE '");
2662
  memcpy(pos, fname, fname_len);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2663
  pos= strmov(pos+fname_len, "' ");
2664

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2665
  if (sql_ex.opt_flags & REPLACE_FLAG)
2666
    pos= strmov(pos, " REPLACE ");
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2667
  else if (sql_ex.opt_flags & IGNORE_FLAG)
2668 2669
    pos= strmov(pos, " IGNORE ");

2670 2671 2672 2673 2674 2675
  pos= strmov(pos ,"INTO");

  if (fn_end)
    *fn_end= pos;

  pos= strmov(pos ," TABLE `");
2676 2677 2678
  memcpy(pos, table_name, table_name_len);
  pos+= table_name_len;

monty@mysql.com's avatar
monty@mysql.com committed
2679
  /* We have to create all optinal fields as the default is not empty */
2680
  pos= strmov(pos, "` FIELDS TERMINATED BY ");
monty@mysql.com's avatar
monty@mysql.com committed
2681 2682 2683 2684 2685
  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);
2686

monty@mysql.com's avatar
monty@mysql.com committed
2687 2688
  pos= strmov(pos, " ESCAPED BY ");
  pos= pretty_print_str(pos, sql_ex.escaped, sql_ex.escaped_len);
2689

monty@mysql.com's avatar
monty@mysql.com committed
2690 2691
  pos= strmov(pos, " LINES TERMINATED BY ");
  pos= pretty_print_str(pos, sql_ex.line_term, sql_ex.line_term_len);
2692 2693
  if (sql_ex.line_start_len)
  {
2694
    pos= strmov(pos, " STARTING BY ");
2695
    pos= pretty_print_str(pos, sql_ex.line_start, sql_ex.line_start_len);
2696
  }
2697

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2698
  if ((long) skip_lines > 0)
2699 2700
  {
    pos= strmov(pos, " IGNORE ");
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2701
    pos= longlong10_to_str((longlong) skip_lines, pos, 10);
2702 2703
    pos= strmov(pos," LINES ");    
  }
2704 2705 2706 2707

  if (num_fields)
  {
    uint i;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2708
    const char *field= fields;
2709
    pos= strmov(pos, " (");
2710 2711 2712
    for (i = 0; i < num_fields; i++)
    {
      if (i)
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2713 2714 2715 2716
      {
        *pos++= ' ';
        *pos++= ',';
      }
2717
      memcpy(pos, field, field_lens[i]);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2718 2719
      pos+=   field_lens[i];
      field+= field_lens[i]  + 1;
2720
    }
2721
    *pos++= ')';
2722
  }
2723

2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735
  *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);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2736
  my_free(buf, MYF(0));
2737
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2738
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
2739

2740

2741 2742
#ifndef MYSQL_CLIENT

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2743
/*
2744
  Load_log_event::write_data_header()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2745
*/
2746

2747
bool Load_log_event::write_data_header(IO_CACHE* file)
2748
{
2749
  char buf[LOAD_HEADER_LEN];
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2750
  int4store(buf + L_THREAD_ID_OFFSET, slave_proxy_id);
2751 2752 2753 2754 2755
  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);
2756
  return my_b_safe_write(file, (byte*)buf, LOAD_HEADER_LEN) != 0;
2757
}
2758

2759

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2760
/*
2761
  Load_log_event::write_data_body()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2762
*/
2763

2764
bool Load_log_event::write_data_body(IO_CACHE* file)
2765
{
2766 2767 2768
  if (sql_ex.write_data(file))
    return 1;
  if (num_fields && fields && field_lens)
2769
  {
2770 2771 2772
    if (my_b_safe_write(file, (byte*)field_lens, num_fields) ||
	my_b_safe_write(file, (byte*)fields, field_block_len))
      return 1;
2773
  }
2774 2775 2776
  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));
2777 2778
}

2779

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2780
/*
2781
  Load_log_event::Load_log_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2782
*/
2783

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2784 2785 2786
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,
2787
			       enum enum_duplicates handle_dup,
2788
			       bool ignore, bool using_trans)
2789 2790 2791
  :Log_event(thd_arg, !thd_arg->tmp_table_used ?
	     0 : LOG_EVENT_THREAD_SPECIFIC_F, using_trans),
   thread_id(thd_arg->thread_id),
2792
   slave_proxy_id(thd_arg->variables.pseudo_thread_id),
guilhem@mysql.com's avatar
guilhem@mysql.com committed
2793 2794
   num_fields(0),fields(0),
   field_lens(0),field_block_len(0),
2795
   table_name(table_name_arg ? table_name_arg : ""),
2796
   db(db_arg), fname(ex->file_name), local_fname(FALSE)
2797 2798 2799
{
  time_t end_time;
  time(&end_time);
2800
  exec_time = (ulong) (end_time  - thd_arg->start_time);
2801 2802 2803
  /* db can never be a zero pointer in 4.0 */
  db_len = (uint32) strlen(db);
  table_name_len = (uint32) strlen(table_name);
2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816
  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;
2817
    
2818
  if (ex->dumpfile)
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2819
    sql_ex.opt_flags|= DUMPFILE_FLAG;
2820
  if (ex->opt_enclosed)
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2821
    sql_ex.opt_flags|= OPT_ENCLOSED_FLAG;
2822

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2823
  sql_ex.empty_flags= 0;
2824

2825
  switch (handle_dup) {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2826
  case DUP_REPLACE:
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2827
    sql_ex.opt_flags|= REPLACE_FLAG;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2828 2829 2830 2831
    break;
  case DUP_UPDATE:				// Impossible here
  case DUP_ERROR:
    break;	
2832
  }
2833 2834
  if (ignore)
    sql_ex.opt_flags|= IGNORE_FLAG;
2835

2836 2837 2838 2839 2840 2841 2842 2843 2844 2845
  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;
2846
    
2847
  skip_lines = ex->skip_lines;
2848

2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859
  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);
2860 2861
  }

2862 2863 2864
  field_lens = (const uchar*)field_lens_buf.ptr();
  fields = fields_buf.ptr();
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2865
#endif /* !MYSQL_CLIENT */
2866

2867

2868
/*
2869
  Load_log_event::Load_log_event()
2870

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2871 2872 2873
  NOTE
    The caller must do buf[event_len] = 0 before he starts using the
    constructed event.
2874 2875
*/

2876 2877 2878 2879
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),
monty@mysql.com's avatar
monty@mysql.com committed
2880
   table_name(0), db(0), fname(0), local_fname(FALSE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2881
{
monty@mysql.com's avatar
monty@mysql.com committed
2882
  DBUG_ENTER("Load_log_event");
2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894
  /*
    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 */
monty@mysql.com's avatar
monty@mysql.com committed
2895
  DBUG_VOID_RETURN;
2896 2897
}

2898

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2899
/*
2900
  Load_log_event::copy_log_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2901
*/
2902

2903
int Load_log_event::copy_log_event(const char *buf, ulong event_len,
2904 2905
                                   int body_offset,
                                   const Format_description_log_event *description_event)
2906
{
2907
  DBUG_ENTER("Load_log_event::copy_log_event");
2908
  uint data_len;
2909
  char* buf_end = (char*)buf + event_len;
2910 2911
  /* this is the beginning of the post-header */
  const char* data_head = buf + description_event->common_header_len;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
2912
  slave_proxy_id= thread_id= uint4korr(data_head + L_THREAD_ID_OFFSET);
2913 2914 2915 2916 2917
  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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2918
	  
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2919
  if ((int) event_len < body_offset)
monty@mysql.com's avatar
monty@mysql.com committed
2920
    DBUG_RETURN(1);
2921 2922 2923 2924
  /*
    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.
  */
2925 2926 2927
  if (!(field_lens= (uchar*)sql_ex.init((char*)buf + body_offset,
                                        buf_end,
                                        buf[EVENT_TYPE_OFFSET] != LOAD_EVENT)))
monty@mysql.com's avatar
monty@mysql.com committed
2928
    DBUG_RETURN(1);
2929
  
2930
  data_len = event_len - body_offset;
2931
  if (num_fields > data_len) // simple sanity check against corruption
monty@mysql.com's avatar
monty@mysql.com committed
2932
    DBUG_RETURN(1);
2933
  for (uint i = 0; i < num_fields; i++)
2934
    field_block_len += (uint)field_lens[i] + 1;
2935

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2936 2937 2938 2939
  fields = (char*)field_lens + num_fields;
  table_name  = fields + field_block_len;
  db = table_name + table_name_len + 1;
  fname = db + db_len + 1;
2940 2941
  fname_len = strlen(fname);
  // null termination is accomplished by the caller doing buf[event_len]=0
2942

monty@mysql.com's avatar
monty@mysql.com committed
2943
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2944 2945 2946
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2947
/*
2948
  Load_log_event::print()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2949
*/
2950 2951

#ifdef MYSQL_CLIENT
2952
void Load_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
2953
{
2954
  print(file, print_event_info, 0);
2955 2956
}

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2957

2958
void Load_log_event::print(FILE* file_arg, PRINT_EVENT_INFO* print_event_info,
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2959
			   bool commented)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2960
{
2961 2962
  Write_on_release_cache cache(&print_event_info->head_cache, file_arg);

monty@mysql.com's avatar
monty@mysql.com committed
2963
  DBUG_ENTER("Load_log_event::print");
2964
  if (!print_event_info->short_form)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2965
  {
2966 2967 2968
    print_header(&cache, print_event_info, FALSE);
    my_b_printf(&cache, "\tQuery\tthread_id=%ld\texec_time=%ld\n",
                thread_id, exec_time);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2969 2970
  }

2971
  bool different_db= 1;
2972
  if (db)
2973
  {
2974 2975 2976 2977 2978 2979
    /*
      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.
    */
2980
    if ((different_db= memcmp(print_event_info->db, db, db_len + 1)) &&
2981
        !commented)
2982
      memcpy(print_event_info->db, db, db_len + 1);
2983
  }
2984
  
2985
  if (db && db[0] && different_db)
2986
    my_b_printf(&cache, "%suse %s%s\n", 
2987
            commented ? "# " : "",
2988
            db, print_event_info->delimiter);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2989

2990
  if (flags & LOG_EVENT_THREAD_SPECIFIC_F)
2991
    my_b_printf(&cache,"%sSET @@session.pseudo_thread_id=%lu%s\n",
2992 2993
            commented ? "# " : "", (ulong)thread_id,
            print_event_info->delimiter);
2994
  my_b_printf(&cache, "%sLOAD DATA ",
2995
              commented ? "# " : "");
2996
  if (check_fname_outside_temp_buf())
2997 2998
    my_b_printf(&cache, "LOCAL ");
  my_b_printf(&cache, "INFILE '%-*s' ", fname_len, fname);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2999

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3000
  if (sql_ex.opt_flags & REPLACE_FLAG)
3001
    my_b_printf(&cache," REPLACE ");
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3002
  else if (sql_ex.opt_flags & IGNORE_FLAG)
3003
    my_b_printf(&cache," IGNORE ");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3004
  
3005 3006 3007
  my_b_printf(&cache, "INTO TABLE `%s`", table_name);
  my_b_printf(&cache, " FIELDS TERMINATED BY ");
  pretty_print_str(&cache, sql_ex.field_term, sql_ex.field_term_len);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3008

monty@mysql.com's avatar
monty@mysql.com committed
3009
  if (sql_ex.opt_flags & OPT_ENCLOSED_FLAG)
3010 3011 3012
    my_b_printf(&cache," OPTIONALLY ");
  my_b_printf(&cache, " ENCLOSED BY ");
  pretty_print_str(&cache, sql_ex.enclosed, sql_ex.enclosed_len);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3013
     
3014 3015
  my_b_printf(&cache, " ESCAPED BY ");
  pretty_print_str(&cache, sql_ex.escaped, sql_ex.escaped_len);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3016
     
3017 3018
  my_b_printf(&cache," LINES TERMINATED BY ");
  pretty_print_str(&cache, sql_ex.line_term, sql_ex.line_term_len);
monty@mysql.com's avatar
monty@mysql.com committed
3019

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3020

3021
  if (sql_ex.line_start)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3022
  {
3023 3024
    my_b_printf(&cache," STARTING BY ");
    pretty_print_str(&cache, sql_ex.line_start, sql_ex.line_start_len);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3025
  }
3026
  if ((long) skip_lines > 0)
3027
    my_b_printf(&cache, " IGNORE %ld LINES", (long) skip_lines);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3028

3029 3030 3031 3032
  if (num_fields)
  {
    uint i;
    const char* field = fields;
3033
    my_b_printf(&cache, " (");
3034
    for (i = 0; i < num_fields; i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3035
    {
3036
      if (i)
3037 3038
	my_b_printf(&cache, ",");
      my_b_printf(&cache, field);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3039
	  
3040
      field += field_lens[i]  + 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3041
    }
3042
    my_b_printf(&cache, ")");
3043
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3044

3045
  my_b_printf(&cache, "%s\n", print_event_info->delimiter);
monty@mysql.com's avatar
monty@mysql.com committed
3046
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3047
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3048
#endif /* MYSQL_CLIENT */
3049

3050

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3051
/*
3052
  Load_log_event::set_fields()
lars@mysql.com's avatar
lars@mysql.com committed
3053 3054 3055 3056 3057

  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.
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3058
*/
3059

3060
#ifndef MYSQL_CLIENT
lars@mysql.com's avatar
lars@mysql.com committed
3061
void Load_log_event::set_fields(const char* affected_db, 
3062 3063
				List<Item> &field_list,
                                Name_resolution_context *context)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3064 3065
{
  uint i;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3066
  const char* field = fields;
3067
  for (i= 0; i < num_fields; i++)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3068
  {
3069 3070
    field_list.push_back(new Item_field(context,
                                        affected_db, table_name, field));
3071
    field+= field_lens[i]  + 1;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3072
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3073
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3074
#endif /* !MYSQL_CLIENT */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3075 3076


hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3077
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3078 3079
/*
  Does the data loading job when executing a LOAD DATA on the slave
3080

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094
  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.
3095

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3096 3097 3098 3099 3100 3101 3102
  DESCRIPTION
    Does the data loading job when executing a LOAD DATA on the slave
 
  RETURN VALUE
    0           Success                                                 
    1    	Failure
*/
3103

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3104 3105
int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli, 
			       bool use_rli_only_for_errors)
3106
{
3107 3108 3109 3110
  LEX_STRING new_db;
  new_db.length= db_len;
  new_db.str= (char *) rpl_filter->get_rewrite_db(db, &new_db.length);
  thd->set_db(new_db.str, new_db.length);
3111
  DBUG_ASSERT(thd->query == 0);
monty@mysql.com's avatar
monty@mysql.com committed
3112
  thd->query_length= 0;                         // Should not be needed
monty@mysql.com's avatar
monty@mysql.com committed
3113
  thd->query_error= 0;
monty@mysql.com's avatar
monty@mysql.com committed
3114
  clear_all_errors(thd, rli);
3115 3116 3117

  /* see Query_log_event::exec_event() and BUG#13360 */
  DBUG_ASSERT(!rli->m_table_map.count());
3118 3119 3120 3121
  /*
    Usually mysql_init_query() is called by mysql_parse(), but we need it here
    as the present method does not call mysql_parse().
  */
3122
  mysql_init_query(thd, 0, 0);
monty@mysql.com's avatar
monty@mysql.com committed
3123
  if (!use_rli_only_for_errors)
3124
  {
3125
    /* Saved for InnoDB, see comment in Query_log_event::exec_event() */
monty@mysql.com's avatar
monty@mysql.com committed
3126
    rli->future_group_master_log_pos= log_pos;
3127
    DBUG_PRINT("info", ("log_pos: %lu", (ulong) log_pos));
3128
  }
3129 3130
 
   /*
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3131 3132 3133 3134 3135 3136 3137 3138 3139 3140
    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).
lars@mysql.com's avatar
lars@mysql.com committed
3141 3142 3143 3144 3145 3146 3147 3148 3149 3150


    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().
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3151
  */
3152
  if (rpl_filter->db_ok(thd->db))
3153
  {
3154 3155
    thd->set_time((time_t)when);
    VOID(pthread_mutex_lock(&LOCK_thread_count));
3156
    thd->query_id = next_query_id();
3157
    VOID(pthread_mutex_unlock(&LOCK_thread_count));
3158 3159 3160 3161 3162 3163
    /*
      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.
    */
monty@mysql.com's avatar
monty@mysql.com committed
3164
    mysql_reset_errors(thd, 0);
3165 3166 3167

    TABLE_LIST tables;
    bzero((char*) &tables,sizeof(tables));
3168
    tables.db= thd->strmake(thd->db, thd->db_length);
3169
    tables.alias = tables.table_name = (char*) table_name;
3170
    tables.lock_type = TL_WRITE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3171
    tables.updating= 1;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3172

3173
    // the table will be opened in mysql_load    
3174
    if (rpl_filter->is_on() && !rpl_filter->tables_ok(thd->db, &tables))
3175 3176 3177 3178 3179 3180 3181 3182
    {
      // 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];
3183
      char *end;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3184
      enum enum_duplicates handle_dup;
3185
      bool ignore= 0;
3186 3187
      char *load_data_query;

3188
      /*
3189 3190
        Forge LOAD DATA INFILE query which will be used in SHOW PROCESS LIST
        and written to slave's binlog if binlogging is on.
3191
      */
3192
      if (!(load_data_query= (char *)thd->alloc(get_query_buffer_length() + 1)))
3193
      {
3194 3195 3196 3197 3198
        /*
          This will set thd->fatal_error in case of OOM. So we surely will notice
          that something is wrong.
        */
        goto error;
3199
      }
3200 3201 3202 3203 3204 3205 3206

      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;

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3207
      if (sql_ex.opt_flags & REPLACE_FLAG)
3208
      {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3209
	handle_dup= DUP_REPLACE;
3210
      }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3211
      else if (sql_ex.opt_flags & IGNORE_FLAG)
3212 3213 3214 3215
      {
        ignore= 1;
        handle_dup= DUP_ERROR;
      }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3216
      else
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3217
      {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3218
        /*
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3219
	  When replication is running fine, if it was DUP_ERROR on the
3220
          master then we could choose IGNORE here, because if DUP_ERROR
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3221
          suceeded on master, and data is identical on the master and slave,
3222
          then there should be no uniqueness errors on slave, so IGNORE is
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3223
          the same as DUP_ERROR. But in the unlikely case of uniqueness errors
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3224 3225 3226
          (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.
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3227 3228

          If reading from net (a 3.23 master), mysql_load() will change this
3229
          to IGNORE.
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3230 3231
        */
        handle_dup= DUP_ERROR;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3232
      }
3233 3234 3235 3236 3237 3238 3239 3240 3241 3242
      /*
        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;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3243

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3244
      sql_exchange ex((char*)fname, sql_ex.opt_flags & DUMPFILE_FLAG);
3245 3246 3247 3248 3249
      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);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3250 3251 3252 3253 3254
      ex.field_term= &field_term;
      ex.enclosed= &enclosed;
      ex.line_term= &line_term;
      ex.line_start= &line_start;
      ex.escaped= &escaped;
3255 3256 3257 3258 3259 3260

      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;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3261
      List<Item> field_list;
3262
      thd->main_lex.select_lex.context.resolve_in_table_list_only(&tables);
3263
      set_fields(tables.db, field_list, &thd->main_lex.select_lex.context);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3264
      thd->variables.pseudo_thread_id= thread_id;
3265
      List<Item> set_fields;
3266 3267 3268 3269 3270 3271 3272 3273 3274
      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;
      }
3275 3276 3277 3278 3279
      /*
        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,
3280
                     handle_dup, ignore, net != 0))
3281
        thd->query_error= 1;
3282
      if (thd->cuted_fields)
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3283
      {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3284
	/* log_pos is the position of the LOAD event in the master log */
lars@mysql.com's avatar
lars@mysql.com committed
3285 3286 3287 3288 3289 3290 3291
        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));
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3292
      }
3293 3294 3295
      if (net)
        net->pkt_nr= thd->net.pkt_nr;
    }
3296 3297
  }
  else
3298 3299 3300 3301 3302 3303 3304 3305 3306
  {
    /*
      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);
  }
3307 3308

error:
3309
  thd->net.vio = 0; 
3310
  const char *remember_db= thd->db;
3311
  VOID(pthread_mutex_lock(&LOCK_thread_count));
3312
  thd->catalog= 0;
3313
  thd->set_db(NULL, 0);                   /* will free the current database */
3314
  thd->query= 0;
3315
  thd->query_length= 0;
3316
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
3317 3318 3319
  close_thread_tables(thd);
  if (thd->query_error)
  {
3320
    /* this err/sql_errno code is copy-paste from net_send_error() */
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3321 3322 3323 3324 3325 3326 3327 3328 3329
    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);       
    }
3330
    slave_print_msg(ERROR_LEVEL, rli, sql_errno,"\
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3331
Error '%s' running LOAD DATA INFILE on table '%s'. Default database: '%s'",
3332
                    err, (char*)table_name, print_slave_db_safe(remember_db));
3333
    free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
3334 3335
    return 1;
  }
3336
  free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
3337
	    
3338
  if (thd->is_fatal_error)
3339
  {
3340
    slave_print_msg(ERROR_LEVEL, rli, ER_UNKNOWN_ERROR, "\
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3341
Fatal error running LOAD DATA INFILE on table '%s'. Default database: '%s'",
3342
                    (char*)table_name, print_slave_db_safe(remember_db));
3343 3344 3345
    return 1;
  }

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3346
  return ( use_rli_only_for_errors ? 0 : Log_event::exec_event(rli) ); 
3347
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3348
#endif
3349 3350


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3351
/**************************************************************************
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3352
  Rotate_log_event methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3353
**************************************************************************/
3354

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3355
/*
3356
  Rotate_log_event::pack_info()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3357
*/
3358

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3359
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3360
void Rotate_log_event::pack_info(Protocol *protocol)
3361
{
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3362
  char buf1[256], buf[22];
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3363
  String tmp(buf1, sizeof(buf1), log_cs);
3364
  tmp.length(0);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3365
  tmp.append(new_log_ident, ident_len);
3366
  tmp.append(STRING_WITH_LEN(";pos="));
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3367 3368
  tmp.append(llstr(pos,buf));
  protocol->store(tmp.ptr(), tmp.length(), &my_charset_bin);
3369
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3370
#endif
3371

3372

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3373
/*
3374
  Rotate_log_event::print()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3375
*/
3376 3377

#ifdef MYSQL_CLIENT
3378
void Rotate_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3379
{
3380
  char buf[22];
3381 3382
  Write_on_release_cache cache(&print_event_info->head_cache, file,
                               Write_on_release_cache::FLUSH_F);
3383

3384
  if (print_event_info->short_form)
3385
    return;
3386 3387
  print_header(&cache, print_event_info, FALSE);
  my_b_printf(&cache, "\tRotate to ");
3388
  if (new_log_ident)
3389 3390
    my_b_write(&cache, (byte*) new_log_ident, (uint)ident_len);
  my_b_printf(&cache, "  pos: %s\n", llstr(pos, buf));
3391
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3392
#endif /* MYSQL_CLIENT */
3393 3394


3395

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3396
/*
3397
  Rotate_log_event::Rotate_log_event() (2 constructors)
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3398
*/
3399

3400 3401

#ifndef MYSQL_CLIENT
3402
Rotate_log_event::Rotate_log_event(const char* new_log_ident_arg,
3403 3404 3405 3406 3407 3408 3409 3410
                                   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];
3411
  DBUG_ENTER("Rotate_log_event::Rotate_log_event(...,flags)");
3412 3413
  DBUG_PRINT("enter",("new_log_ident: %s  pos: %s  flags: %lu", new_log_ident_arg,
                      llstr(pos_arg, buff), (ulong) flags));
3414 3415
#endif
  if (flags & DUP_NAME)
3416
    new_log_ident= my_strndup(new_log_ident_arg, ident_len, MYF(MY_WME));
3417 3418 3419 3420 3421
  DBUG_VOID_RETURN;
}
#endif


3422 3423
Rotate_log_event::Rotate_log_event(const char* buf, uint event_len,
                                   const Format_description_log_event* description_event)
3424
  :Log_event(buf, description_event) ,new_log_ident(0), flags(DUP_NAME)
3425
{
3426
  DBUG_ENTER("Rotate_log_event::Rotate_log_event(char*,...)");
3427
  // The caller will ensure that event_len is what we have at EVENT_LEN_OFFSET
3428 3429
  uint8 header_size= description_event->common_header_len;
  uint8 post_header_len= description_event->post_header_len[ROTATE_EVENT-1];
3430 3431
  uint ident_offset;
  if (event_len < header_size)
monty@mysql.com's avatar
monty@mysql.com committed
3432
    DBUG_VOID_RETURN;
3433
  buf += header_size;
3434 3435 3436 3437
  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; 
3438
  set_if_smaller(ident_len,FN_REFLEN-1);
3439
  new_log_ident= my_strndup(buf + ident_offset, (uint) ident_len, MYF(MY_WME));
monty@mysql.com's avatar
monty@mysql.com committed
3440
  DBUG_VOID_RETURN;
3441
}
3442 3443


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3444
/*
3445
  Rotate_log_event::write()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3446
*/
3447

3448
#ifndef MYSQL_CLIENT
3449
bool Rotate_log_event::write(IO_CACHE* file)
3450
{
3451
  char buf[ROTATE_HEADER_LEN];
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3452
  int8store(buf + R_POS_OFFSET, pos);
3453 3454 3455
  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));
3456
}
3457
#endif
3458

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3459
/*
3460 3461
  Rotate_log_event::exec_event()

3462
  Got a rotate log event from the master
3463

3464 3465 3466
  IMPLEMENTATION
    This is mainly used so that we can later figure out the logname and
    position for the master.
3467

3468
    We can't rotate the slave's BINlog as this will cause infinitive rotations
3469
    in a A -> B -> A setup.
3470
    The NOTES below is a wrong comment which will disappear when 4.1 is merged.
3471 3472 3473

  RETURN VALUES
    0	ok
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3474
*/
3475

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3476
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3477
int Rotate_log_event::exec_event(struct st_relay_log_info* rli)
3478
{
3479 3480 3481
  DBUG_ENTER("Rotate_log_event::exec_event");

  pthread_mutex_lock(&rli->data_lock);
3482
  rli->event_relay_log_pos= my_b_tell(rli->cur_log);
guilhem@gbichot2's avatar
guilhem@gbichot2 committed
3483 3484 3485 3486 3487 3488 3489 3490 3491
  /*
    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
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3492 3493
    In that case, we don't want to touch the coordinates which correspond to
    the beginning of the transaction.
3494 3495
    Starting from 5.0.0, there also are some rotates from the slave itself, in
    the relay log.
guilhem@gbichot2's avatar
guilhem@gbichot2 committed
3496
  */
3497
  if (!(thd->options & OPTION_BEGIN))
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3498
  {
3499 3500
    memcpy(rli->group_master_log_name, new_log_ident, ident_len+1);
    rli->notify_group_master_log_name_update();
3501 3502
    rli->group_master_log_pos= pos;
    rli->group_relay_log_pos= rli->event_relay_log_pos;
3503 3504
    DBUG_PRINT("info", ("group_master_log_name: '%s'  "
                        "group_master_log_pos: %lu",
3505
                        rli->group_master_log_name,
3506
                        (ulong) rli->group_master_log_pos));
3507
    /*
3508 3509
      Reset thd->options and sql_mode etc, because this could be the signal of
      a master's downgrade from 5.0 to 4.0.
3510 3511 3512 3513 3514
      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);
3515
    set_slave_thread_default_charset(thd, rli);
3516
    thd->variables.sql_mode= global_system_variables.sql_mode;
3517 3518
    thd->variables.auto_increment_increment=
      thd->variables.auto_increment_offset= 1;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3519
  }
3520 3521 3522 3523
  pthread_mutex_unlock(&rli->data_lock);
  pthread_cond_broadcast(&rli->data_cond);
  flush_relay_log_info(rli);
  DBUG_RETURN(0);
3524
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3525
#endif
3526 3527


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3528
/**************************************************************************
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3529
	Intvar_log_event methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3530
**************************************************************************/
3531

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3532
/*
3533
  Intvar_log_event::pack_info()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3534
*/
3535

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3536
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3537
void Intvar_log_event::pack_info(Protocol *protocol)
3538
{
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3539 3540
  char buf[256], *pos;
  pos= strmake(buf, get_var_type_name(), sizeof(buf)-23);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3541
  *pos++= '=';
3542
  pos= longlong10_to_str(val, pos, -10);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3543
  protocol->store(buf, (uint) (pos-buf), &my_charset_bin);
3544
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3545
#endif
3546

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3547

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3548
/*
3549
  Intvar_log_event::Intvar_log_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3550
*/
3551

3552 3553 3554
Intvar_log_event::Intvar_log_event(const char* buf,
                                   const Format_description_log_event* description_event)
  :Log_event(buf, description_event)
3555
{
3556 3557 3558
  buf+= description_event->common_header_len;
  type= buf[I_TYPE_OFFSET];
  val= uint8korr(buf+I_VAL_OFFSET);
3559 3560
}

3561

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3562
/*
3563
  Intvar_log_event::get_var_type_name()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3564
*/
3565 3566

const char* Intvar_log_event::get_var_type_name()
3567
{
3568 3569 3570 3571 3572
  switch(type) {
  case LAST_INSERT_ID_EVENT: return "LAST_INSERT_ID";
  case INSERT_ID_EVENT: return "INSERT_ID";
  default: /* impossible */ return "UNKNOWN";
  }
3573 3574
}

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3575

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3576
/*
3577
  Intvar_log_event::write()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3578
*/
3579

3580
#ifndef MYSQL_CLIENT
3581
bool Intvar_log_event::write(IO_CACHE* file)
3582
{
3583 3584
  byte buf[9];
  buf[I_TYPE_OFFSET]= (byte) type;
3585
  int8store(buf + I_VAL_OFFSET, val);
3586 3587
  return (write_header(file, sizeof(buf)) ||
          my_b_safe_write(file, buf, sizeof(buf)));
3588
}
3589
#endif
3590

3591

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3592
/*
3593
  Intvar_log_event::print()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3594
*/
3595 3596

#ifdef MYSQL_CLIENT
3597
void Intvar_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3598
{
3599 3600 3601
  char llbuff[22];
  const char *msg;
  LINT_INIT(msg);
3602 3603
  Write_on_release_cache cache(&print_event_info->head_cache, file,
                               Write_on_release_cache::FLUSH_F);
3604

3605
  if (!print_event_info->short_form)
3606
  {
3607 3608
    print_header(&cache, print_event_info, FALSE);
    my_b_printf(&cache, "\tIntvar\n");
3609
  }
3610

3611
  my_b_printf(&cache, "SET ");
3612 3613 3614 3615 3616 3617 3618
  switch (type) {
  case LAST_INSERT_ID_EVENT:
    msg="LAST_INSERT_ID";
    break;
  case INSERT_ID_EVENT:
    msg="INSERT_ID";
    break;
3619 3620 3621 3622
  case INVALID_INT_EVENT:
  default: // cannot happen
    msg="INVALID_INT";
    break;
3623
  }
3624 3625
  my_b_printf(&cache, "%s=%s%s\n",
              msg, llstr(val,llbuff), print_event_info->delimiter);
3626
}
3627
#endif
3628

3629

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3630
/*
3631
  Intvar_log_event::exec_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3632
*/
3633

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3634
#if defined(HAVE_REPLICATION)&& !defined(MYSQL_CLIENT)
3635
int Intvar_log_event::exec_event(struct st_relay_log_info* rli)
3636
{
3637 3638
  switch (type) {
  case LAST_INSERT_ID_EVENT:
3639 3640
    thd->stmt_depends_on_first_successful_insert_id_in_prev_stmt= 1;
    thd->first_successful_insert_id_in_prev_stmt= val;
3641 3642
    break;
  case INSERT_ID_EVENT:
3643
    thd->force_one_auto_inc_interval(val);
3644 3645
    break;
  }
3646
  rli->inc_event_relay_log_pos();
3647
  return 0;
3648
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3649
#endif
3650

3651

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3652
/**************************************************************************
3653
  Rand_log_event methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3654
**************************************************************************/
3655

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3656
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3657
void Rand_log_event::pack_info(Protocol *protocol)
3658
{
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3659 3660 3661 3662 3663
  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);
3664
  protocol->store(buf1, (uint) (pos-buf1), &my_charset_bin);
3665
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3666
#endif
3667 3668


3669 3670 3671
Rand_log_event::Rand_log_event(const char* buf,
                               const Format_description_log_event* description_event)
  :Log_event(buf, description_event)
3672
{
3673 3674 3675
  buf+= description_event->common_header_len;
  seed1= uint8korr(buf+RAND_SEED1_OFFSET);
  seed2= uint8korr(buf+RAND_SEED2_OFFSET);
3676 3677
}

3678

3679
#ifndef MYSQL_CLIENT
3680
bool Rand_log_event::write(IO_CACHE* file)
3681
{
3682
  byte buf[16];
3683 3684
  int8store(buf + RAND_SEED1_OFFSET, seed1);
  int8store(buf + RAND_SEED2_OFFSET, seed2);
3685 3686
  return (write_header(file, sizeof(buf)) ||
          my_b_safe_write(file, buf, sizeof(buf)));
3687
}
3688
#endif
3689

3690 3691

#ifdef MYSQL_CLIENT
3692
void Rand_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3693
{
3694 3695 3696
  Write_on_release_cache cache(&print_event_info->head_cache, file,
                               Write_on_release_cache::FLUSH_F);

3697
  char llbuff[22],llbuff2[22];
3698
  if (!print_event_info->short_form)
3699
  {
3700 3701
    print_header(&cache, print_event_info, FALSE);
    my_b_printf(&cache, "\tRand\n");
3702
  }
3703 3704 3705
  my_b_printf(&cache, "SET @@RAND_SEED1=%s, @@RAND_SEED2=%s%s\n",
              llstr(seed1, llbuff),llstr(seed2, llbuff2),
              print_event_info->delimiter);
3706
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3707
#endif /* MYSQL_CLIENT */
3708

3709

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
3710
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3711
int Rand_log_event::exec_event(struct st_relay_log_info* rli)
3712
{
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3713 3714
  thd->rand.seed1= (ulong) seed1;
  thd->rand.seed2= (ulong) seed2;
3715
  rli->inc_event_relay_log_pos();
3716 3717
  return 0;
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3718
#endif /* !MYSQL_CLIENT */
3719

3720

3721 3722 3723 3724 3725 3726 3727
/**************************************************************************
  Xid_log_event methods
**************************************************************************/

#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
void Xid_log_event::pack_info(Protocol *protocol)
{
3728 3729
  char buf[128], *pos;
  pos= strmov(buf, "COMMIT /* xid=");
3730
  pos= longlong10_to_str(xid, pos, 10);
3731
  pos= strmov(pos, " */");
3732 3733 3734 3735
  protocol->store(buf, (uint) (pos-buf), &my_charset_bin);
}
#endif

3736 3737 3738 3739 3740 3741 3742 3743
/*
  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
*/
3744 3745 3746 3747

Xid_log_event::
Xid_log_event(const char* buf,
              const Format_description_log_event *description_event)
3748 3749 3750
  :Log_event(buf, description_event)
{
  buf+= description_event->common_header_len;
3751
  memcpy((char*) &xid, buf, sizeof(xid));
3752 3753 3754
}


3755
#ifndef MYSQL_CLIENT
3756 3757 3758 3759 3760
bool Xid_log_event::write(IO_CACHE* file)
{
  return write_header(file, sizeof(xid)) ||
         my_b_safe_write(file, (byte*) &xid, sizeof(xid));
}
3761
#endif
3762 3763 3764


#ifdef MYSQL_CLIENT
3765
void Xid_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3766
{
3767 3768 3769
  Write_on_release_cache cache(&print_event_info->head_cache, file,
                               Write_on_release_cache::FLUSH_F);

3770
  if (!print_event_info->short_form)
3771
  {
3772 3773 3774
    char buf[64];
    longlong10_to_str(xid, buf, 10);

3775 3776
    print_header(&cache, print_event_info, FALSE);
    my_b_printf(&cache, "\tXid = %s\n", buf);
3777
  }
3778
  my_b_printf(&cache, "COMMIT%s\n", print_event_info->delimiter);
3779 3780 3781 3782 3783 3784 3785
}
#endif /* MYSQL_CLIENT */


#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
int Xid_log_event::exec_event(struct st_relay_log_info* rli)
{
3786
  /* For a slave Xid_log_event is COMMIT */
3787 3788
  general_log_print(thd, COM_QUERY,
                    "COMMIT /* implicit, from Xid_log_event */");
3789
  return end_trans(thd, COMMIT) || Log_event::exec_event(rli);
3790 3791 3792 3793
}
#endif /* !MYSQL_CLIENT */


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3794
/**************************************************************************
3795
  User_var_log_event methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3796
**************************************************************************/
3797

3798
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3799 3800 3801
void User_var_log_event::pack_info(Protocol* protocol)
{
  char *buf= 0;
3802
  uint val_offset= 4 + name_len;
3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817
  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));
3818 3819
      event_len+= my_sprintf(buf + val_offset,
			     (buf + val_offset, "%.14g", real_val));
3820 3821 3822 3823 3824
      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;
3825 3826 3827 3828 3829 3830 3831 3832 3833 3834
    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;
    } 
3835
    case STRING_RESULT:
3836 3837 3838 3839 3840 3841 3842 3843 3844 3845
      /* 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
      {
3846 3847 3848
        char *p= strxmov(buf + val_offset, "_", cs->csname, " ", NullS);
        p= str_to_hex(p, val, val_len);
        p= strxmov(p, " COLLATE ", cs->name, NullS);
3849 3850
        event_len= p-buf;
      }
3851
      break;
3852
    case ROW_RESULT:
3853
    default:
3854 3855 3856 3857 3858
      DBUG_ASSERT(1);
      return;
    }
  }
  buf[0]= '@';
3859 3860 3861 3862
  buf[1]= '`';
  buf[2+name_len]= '`';
  buf[3+name_len]= '=';
  memcpy(buf+2, name, name_len);
3863
  protocol->store(buf, event_len, &my_charset_bin);
3864 3865
  my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3866
#endif /* !MYSQL_CLIENT */
3867 3868


3869 3870 3871 3872
User_var_log_event::
User_var_log_event(const char* buf,
                   const Format_description_log_event* description_event)
  :Log_event(buf, description_event)
3873
{
3874
  buf+= description_event->common_header_len;
3875 3876
  name_len= uint4korr(buf);
  name= (char *) buf + UV_NAME_LEN_SIZE;
3877 3878
  buf+= UV_NAME_LEN_SIZE + name_len;
  is_null= (bool) *buf;
3879 3880 3881
  if (is_null)
  {
    type= STRING_RESULT;
3882
    charset_number= my_charset_bin.number;
3883 3884 3885 3886 3887
    val_len= 0;
    val= 0;  
  }
  else
  {
3888 3889 3890
    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 + 
3891
		       UV_CHARSET_NUMBER_SIZE);
3892 3893
    val= (char *) (buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE +
		   UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE);
3894 3895 3896 3897
  }
}


3898
#ifndef MYSQL_CLIENT
3899
bool User_var_log_event::write(IO_CACHE* file)
3900 3901 3902 3903
{
  char buf[UV_NAME_LEN_SIZE];
  char buf1[UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE + 
	    UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE];
3904
  char buf2[max(8, DECIMAL_MAX_FIELD_SIZE + 2)], *pos= buf2;
3905
  uint buf1_length;
3906
  ulong event_length;
3907

3908
  int4store(buf, name_len);
3909 3910 3911 3912 3913 3914 3915
  
  if ((buf1[0]= is_null))
  {
    buf1_length= 1;
    val_len= 0;
  }    
  else
3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926
  {
    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;
3927 3928 3929 3930 3931 3932
    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;
3933
      decimal2bin((decimal_t*)val, buf2+2, buf2[0], buf2[1]);
3934 3935 3936
      val_len= decimal_bin_size(buf2[0], buf2[1]) + 2;
      break;
    }
3937 3938 3939
    case STRING_RESULT:
      pos= val;
      break;
3940
    case ROW_RESULT:
3941
    default:
3942 3943 3944
      DBUG_ASSERT(1);
      return 0;
    }
3945 3946
    int4store(buf1 + 2 + UV_CHARSET_NUMBER_SIZE, val_len);
    buf1_length= 10;
3947
  }
3948 3949 3950 3951 3952 3953

  /* 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))   ||
3954 3955 3956
	  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));
3957
}
3958
#endif
3959

3960

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3961
/*
3962
  User_var_log_event::print()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3963
*/
3964 3965

#ifdef MYSQL_CLIENT
3966
void User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3967
{
3968 3969 3970
  Write_on_release_cache cache(&print_event_info->head_cache, file,
                               Write_on_release_cache::FLUSH_F);

3971
  if (!print_event_info->short_form)
3972
  {
3973 3974
    print_header(&cache, print_event_info, FALSE);
    my_b_printf(&cache, "\tUser_var\n");
3975 3976
  }

3977 3978 3979
  my_b_printf(&cache, "SET @`");
  my_b_write(&cache, (byte*) name, (uint) (name_len));
  my_b_printf(&cache, "`");
3980 3981 3982

  if (is_null)
  {
3983
    my_b_printf(&cache, ":=NULL%s\n", print_event_info->delimiter);
3984 3985 3986 3987 3988 3989 3990
  }
  else
  {
    switch (type) {
    case REAL_RESULT:
      double real_val;
      float8get(real_val, val);
3991
      my_b_printf(&cache, ":=%.14g%s\n", real_val, print_event_info->delimiter);
3992 3993 3994 3995
      break;
    case INT_RESULT:
      char int_buf[22];
      longlong10_to_str(uint8korr(val), int_buf, -10);
3996
      my_b_printf(&cache, ":=%s%s\n", int_buf, print_event_info->delimiter);
3997
      break;
3998 3999 4000 4001 4002 4003
    case DECIMAL_RESULT:
    {
      char str_buf[200];
      int str_len= sizeof(str_buf) - 1;
      int precision= (int)val[0];
      int scale= (int)val[1];
4004 4005
      decimal_digit_t dec_buf[10];
      decimal_t dec;
4006 4007 4008 4009 4010 4011
      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;
4012
      my_b_printf(&cache, ":=%s%s\n", str_buf, print_event_info->delimiter);
4013 4014
      break;
    }
4015
    case STRING_RESULT:
4016
    {
4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030
      /*
        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.
      */
4031 4032 4033 4034
      char *hex_str;
      CHARSET_INFO *cs;

      if (!(hex_str= (char *)my_alloca(2*val_len+1+2))) // 2 hex digits / byte
4035
        break; // no error, as we are 'void'
4036
      str_to_hex(hex_str, val, val_len);
4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047
      /*
        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.
        */
4048
        my_b_printf(&cache, ":=???%s\n", print_event_info->delimiter);
4049
      else
4050 4051 4052
        my_b_printf(&cache, ":=_%s %s COLLATE `%s`%s\n",
                    cs->csname, hex_str, cs->name,
                    print_event_info->delimiter);
4053
      my_afree(hex_str);
4054
    }
4055
      break;
4056
    case ROW_RESULT:
4057
    default:
4058
      DBUG_ASSERT(1);
4059 4060 4061 4062
      return;
    }
  }
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
4063
#endif
4064

4065

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4066
/*
4067
  User_var_log_event::exec_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4068
*/
4069

4070
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4071 4072 4073
int User_var_log_event::exec_event(struct st_relay_log_info* rli)
{
  Item *it= 0;
4074 4075 4076
  CHARSET_INFO *charset;
  if (!(charset= get_charset(charset_number, MYF(MY_WME))))
    return 1;
4077 4078 4079
  LEX_STRING user_var_name;
  user_var_name.str= name;
  user_var_name.length= name_len;
4080 4081
  double real_val;
  longlong int_val;
4082 4083 4084 4085 4086 4087 4088 4089 4090 4091

  if (is_null)
  {
    it= new Item_null();
  }
  else
  {
    switch (type) {
    case REAL_RESULT:
      float8get(real_val, val);
4092
      it= new Item_float(real_val);
4093
      val= (char*) &real_val;		// Pointer to value in native format
4094
      val_len= 8;
4095 4096
      break;
    case INT_RESULT:
4097 4098 4099
      int_val= (longlong) uint8korr(val);
      it= new Item_int(int_val);
      val= (char*) &int_val;		// Pointer to value in native format
4100
      val_len= 8;
4101
      break;
4102 4103 4104 4105 4106 4107 4108 4109
    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;
    }
4110 4111 4112
    case STRING_RESULT:
      it= new Item_string(val, val_len, charset);
      break;
4113
    case ROW_RESULT:
4114
    default:
4115 4116 4117 4118 4119
      DBUG_ASSERT(1);
      return 0;
    }
  }
  Item_func_set_user_var e(user_var_name, it);
4120 4121 4122 4123
  /*
    Item_func_set_user_var can't substitute something else on its place =>
    0 can be passed as last argument (reference on item)
  */
4124
  e.fix_fields(thd, 0);
4125 4126 4127 4128 4129
  /*
    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.
   */
kaa@polly.local's avatar
kaa@polly.local committed
4130
  e.update_hash(val, val_len, type, charset, DERIVATION_IMPLICIT, 0);
4131
  free_root(thd->mem_root,0);
4132

4133
  rli->inc_event_relay_log_pos();
4134 4135
  return 0;
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4136
#endif /* !MYSQL_CLIENT */
4137 4138


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4139
/**************************************************************************
4140
  Slave_log_event methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4141
**************************************************************************/
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4142

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
4143
#ifdef HAVE_REPLICATION
4144
#ifdef MYSQL_CLIENT
4145
void Unknown_log_event::print(FILE* file_arg, PRINT_EVENT_INFO* print_event_info)
4146
{
4147 4148
  Write_on_release_cache cache(&print_event_info->head_cache, file_arg);

4149
  if (print_event_info->short_form)
4150
    return;
4151 4152
  print_header(&cache, print_event_info, FALSE);
  my_b_printf(&cache, "\n# %s", "Unknown event\n");
4153 4154
}
#endif  
4155

4156
#ifndef MYSQL_CLIENT
4157
void Slave_log_event::pack_info(Protocol *protocol)
4158
{
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4159
  char buf[256+HOSTNAME_LENGTH], *pos;
4160 4161 4162 4163 4164 4165 4166
  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=");
4167
  pos= longlong10_to_str(master_pos, pos, 10);
4168
  protocol->store(buf, pos-buf, &my_charset_bin);
4169
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4170
#endif /* !MYSQL_CLIENT */
4171 4172 4173 4174


#ifndef MYSQL_CLIENT
Slave_log_event::Slave_log_event(THD* thd_arg,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4175
				 struct st_relay_log_info* rli)
4176
  :Log_event(thd_arg, 0, 0) , mem_pool(0), master_host(0)
4177 4178 4179 4180
{
  DBUG_ENTER("Slave_log_event");
  if (!rli->inited)				// QQ When can this happen ?
    DBUG_VOID_RETURN;
4181

4182 4183 4184 4185 4186
  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);
4187
  master_log_len = strlen(rli->group_master_log_name);
4188 4189 4190
  // 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))))
4191
  {
4192 4193 4194
    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;
4195
    memcpy(master_log, rli->group_master_log_name, master_log_len + 1);
4196
    master_port = mi->port;
4197
    master_pos = rli->group_master_log_pos;
4198
    DBUG_PRINT("info", ("master_log: %s  pos: %lu", master_log,
4199
			(ulong) master_pos));
4200
  }
4201 4202 4203 4204 4205 4206
  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;
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4207
#endif /* !MYSQL_CLIENT */
4208 4209 4210 4211 4212 4213 4214 4215 4216


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


#ifdef MYSQL_CLIENT
4217
void Slave_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
4218
{
4219 4220
  Write_on_release_cache cache(&print_event_info->head_cache, file);

4221
  char llbuff[22];
4222
  if (print_event_info->short_form)
4223
    return;
4224 4225
  print_header(&cache, print_event_info, FALSE);
  my_b_printf(&cache, "\n\
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4226
Slave: master_host: '%s'  master_port: %d  master_log: '%s'  master_pos: %s\n",
4227 4228
	  master_host, master_port, master_log, llstr(master_pos, llbuff));
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4229
#endif /* MYSQL_CLIENT */
4230 4231 4232 4233 4234 4235 4236 4237


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


4238
#ifndef MYSQL_CLIENT
4239
bool Slave_log_event::write(IO_CACHE* file)
4240
{
4241
  ulong event_length= get_data_size();
4242 4243 4244
  int8store(mem_pool + SL_MASTER_POS_OFFSET, master_pos);
  int2store(mem_pool + SL_MASTER_PORT_OFFSET, master_port);
  // log and host are already there
4245 4246 4247

  return (write_header(file, event_length) ||
          my_b_safe_write(file, (byte*) mem_pool, event_length));
4248
}
4249
#endif
4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260


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)
4261
  {
4262 4263
    master_host = 0;
    return;
4264
  }
4265 4266
  master_log_len = strlen(master_log);
}
4267

4268

4269 4270 4271
/* 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)
4272
{
4273
  if (event_len < LOG_EVENT_HEADER_LEN)
4274
    return;
4275
  event_len -= LOG_EVENT_HEADER_LEN;
4276 4277 4278 4279 4280
  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);
4281 4282
}

4283

4284 4285 4286 4287 4288 4289 4290
#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);
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4291
#endif /* !MYSQL_CLIENT */
4292 4293


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4294
/**************************************************************************
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4295
	Stop_log_event methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4296
**************************************************************************/
4297

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4298
/*
4299
  Stop_log_event::print()
4300
*/
4301 4302

#ifdef MYSQL_CLIENT
4303
void Stop_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
4304
{
4305 4306 4307
  Write_on_release_cache cache(&print_event_info->head_cache, file,
                               Write_on_release_cache::FLUSH_F);

4308
  if (print_event_info->short_form)
4309 4310
    return;

4311 4312
  print_header(&cache, print_event_info, FALSE);
  my_b_printf(&cache, "\tStop\n");
4313
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4314
#endif /* MYSQL_CLIENT */
4315

4316

4317
/*
4318
  Stop_log_event::exec_event()
4319

4320
  The master stopped.
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4321
  We used to clean up all temporary tables but this is useless as, as the
4322 4323
  master has shut down properly, it has written all DROP TEMPORARY TABLE
  (prepared statements' deletion is TODO only when we binlog prep stmts).
4324 4325 4326
  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.
4327
  The place were we must do this cleaning is in Start_log_event_v3::exec_event(),
4328
  not here. Because if we come here, the master was sane.
4329 4330
*/

4331
#ifndef MYSQL_CLIENT
4332
int Stop_log_event::exec_event(struct st_relay_log_info* rli)
4333
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4334 4335
  /*
    We do not want to update master_log pos because we get a rotate event
4336
    before stop, so by now group_master_log_name is set to the next log.
4337
    If we updated it, we will have incorrect master coordinates and this
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4338
    could give false triggers in MASTER_POS_WAIT() that we have reached
4339
    the target position when in fact we have not.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4340
  */
4341 4342 4343 4344 4345 4346 4347
  if (thd->options & OPTION_BEGIN)
    rli->inc_event_relay_log_pos();
  else
  {
    rli->inc_group_relay_log_pos(0);
    flush_relay_log_info(rli);
  }
4348 4349
  return 0;
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4350
#endif /* !MYSQL_CLIENT */
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
4351
#endif /* HAVE_REPLICATION */
4352

4353

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4354
/**************************************************************************
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4355
	Create_file_log_event methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4356
**************************************************************************/
4357 4358

/*
4359
  Create_file_log_event ctor
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4360
*/
4361 4362

#ifndef MYSQL_CLIENT
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4363 4364 4365 4366
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,
4367
                      bool ignore,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4368
		      char* block_arg, uint block_len_arg, bool using_trans)
4369
  :Load_log_event(thd_arg,ex,db_arg,table_name_arg,fields_arg,handle_dup, ignore,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4370
		  using_trans),
4371
   fake_base(0), block(block_arg), event_buf(0), block_len(block_len_arg),
4372
   file_id(thd_arg->file_id = mysql_bin_log.next_file_id())
4373
{
monty@mysql.com's avatar
monty@mysql.com committed
4374
  DBUG_ENTER("Create_file_log_event");
4375
  sql_ex.force_new_format();
monty@mysql.com's avatar
monty@mysql.com committed
4376
  DBUG_VOID_RETURN;
4377
}
4378

4379

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4380
/*
4381
  Create_file_log_event::write_data_body()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4382
*/
4383

4384
bool Create_file_log_event::write_data_body(IO_CACHE* file)
4385
{
4386 4387
  bool res;
  if ((res= Load_log_event::write_data_body(file)) || fake_base)
4388 4389
    return res;
  return (my_b_safe_write(file, (byte*) "", 1) ||
4390
          my_b_safe_write(file, (byte*) block, block_len));
4391 4392
}

4393

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4394
/*
4395
  Create_file_log_event::write_data_header()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4396
*/
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4397

4398
bool Create_file_log_event::write_data_header(IO_CACHE* file)
4399
{
4400
  bool res;
4401
  byte buf[CREATE_FILE_HEADER_LEN];
4402 4403
  if ((res= Load_log_event::write_data_header(file)) || fake_base)
    return res;
4404
  int4store(buf + CF_FILE_ID_OFFSET, file_id);
4405
  return my_b_safe_write(file, buf, CREATE_FILE_HEADER_LEN) != 0;
4406 4407 4408
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4409
/*
4410
  Create_file_log_event::write_base()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4411
*/
4412

4413
bool Create_file_log_event::write_base(IO_CACHE* file)
4414
{
4415 4416 4417 4418
  bool res;
  fake_base= 1;                                 // pretend we are Load event
  res= write(file);
  fake_base= 0;
4419 4420 4421
  return res;
}

4422
#endif /* !MYSQL_CLIENT */
4423

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4424
/*
4425
  Create_file_log_event ctor
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4426
*/
4427

4428 4429 4430
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)
4431
{
4432 4433 4434 4435 4436
  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];
monty@mysql.com's avatar
monty@mysql.com committed
4437
  if (!(event_buf= my_memdup((byte*) buf, len, MYF(MY_WME))) ||
4438 4439 4440 4441 4442 4443 4444
      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))
monty@mysql.com's avatar
monty@mysql.com committed
4445
    DBUG_VOID_RETURN;
4446
  if (description_event->binlog_version!=1)
4447
  {
4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464
    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);
4465 4466 4467 4468 4469 4470 4471 4472 4473
    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;
4474
  }
monty@mysql.com's avatar
monty@mysql.com committed
4475
  DBUG_VOID_RETURN;
4476 4477
}

4478

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4479
/*
4480
  Create_file_log_event::print()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4481
*/
4482 4483

#ifdef MYSQL_CLIENT
4484
void Create_file_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info,
lars@mysql.com's avatar
lars@mysql.com committed
4485
				  bool enable_local)
nick@mysql.com's avatar
nick@mysql.com committed
4486
{
4487 4488
  Write_on_release_cache cache(&print_event_info->head_cache, file);

4489
  if (print_event_info->short_form)
4490 4491
  {
    if (enable_local && check_fname_outside_temp_buf())
4492
      Load_log_event::print(file, print_event_info);
4493
    return;
4494 4495 4496 4497
  }

  if (enable_local)
  {
4498
    Load_log_event::print(file, print_event_info,
4499
			  !check_fname_outside_temp_buf());
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4500 4501 4502 4503
    /* 
       That one is for "file_id: etc" below: in mysqlbinlog we want the #, in
       SHOW BINLOG EVENTS we don't.
    */
4504
    my_b_printf(&cache, "#"); 
4505 4506
  }

4507
  my_b_printf(&cache, " file_id: %d  block_len: %d\n", file_id, block_len);
nick@mysql.com's avatar
nick@mysql.com committed
4508
}
4509

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4510

4511
void Create_file_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
4512
{
4513
  print(file, print_event_info, 0);
4514
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4515
#endif /* MYSQL_CLIENT */
nick@mysql.com's avatar
nick@mysql.com committed
4516

4517

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4518
/*
4519
  Create_file_log_event::pack_info()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4520
*/
4521

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
4522
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4523
void Create_file_log_event::pack_info(Protocol *protocol)
4524
{
4525 4526 4527
  char buf[NAME_LEN*2 + 30 + 21*2], *pos;
  pos= strmov(buf, "db=");
  memcpy(pos, db, db_len);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4528
  pos= strmov(pos + db_len, ";table=");
4529
  memcpy(pos, table_name, table_name_len);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4530
  pos= strmov(pos + table_name_len, ";file_id=");
4531 4532 4533
  pos= int10_to_str((long) file_id, pos, 10);
  pos= strmov(pos, ";block_len=");
  pos= int10_to_str((long) block_len, pos, 10);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4534
  protocol->store(buf, (uint) (pos-buf), &my_charset_bin);
4535
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4536
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
4537 4538


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4539
/*
4540
  Create_file_log_event::exec_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4541
*/
4542

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
4543
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4544
int Create_file_log_event::exec_event(struct st_relay_log_info* rli)
4545
{
4546 4547
  char proc_info[17+FN_REFLEN+10], *fname_buf;
  char *ext;
4548 4549 4550
  int fd = -1;
  IO_CACHE file;
  int error = 1;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4551

4552
  bzero((char*)&file, sizeof(file));
4553 4554
  fname_buf= strmov(proc_info, "Making temp file ");
  ext= slave_load_file_stem(fname_buf, file_id, server_id, ".info");
4555
  thd->proc_info= proc_info;
4556 4557 4558 4559
  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 ||
4560 4561 4562
      init_io_cache(&file, fd, IO_SIZE, WRITE_CACHE, (my_off_t)0, 0,
		    MYF(MY_WME|MY_NABP)))
  {
4563 4564
    slave_print_msg(ERROR_LEVEL, rli, my_errno, "Error in Create_file event: "
                    "could not open file '%s'", fname_buf);
4565 4566 4567 4568
    goto err;
  }
  
  // a trick to avoid allocating another buffer
4569 4570
  fname= fname_buf;
  fname_len= (uint) (strmov(ext, ".data") - fname);
4571 4572
  if (write_base(&file))
  {
4573
    strmov(ext, ".info"); // to have it right in the error message
4574 4575 4576
    slave_print_msg(ERROR_LEVEL, rli, my_errno,
                    "Error in Create_file event: could not write to file '%s'",
                    fname_buf);
4577 4578 4579 4580 4581 4582
    goto err;
  }
  end_io_cache(&file);
  my_close(fd, MYF(0));
  
  // fname_buf now already has .data, not .info, because we did our trick
4583 4584 4585 4586
  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)
4587
  {
4588 4589
    slave_print_msg(ERROR_LEVEL, rli, my_errno, "Error in Create_file event: "
                    "could not open file '%s'", fname_buf);
4590 4591
    goto err;
  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4592
  if (my_write(fd, (byte*) block, block_len, MYF(MY_WME+MY_NABP)))
4593
  {
4594 4595
    slave_print_msg(ERROR_LEVEL, rli, my_errno, "Error in Create_file event: "
                    "write to '%s' failed", fname_buf);
4596 4597
    goto err;
  }
4598 4599
  error=0;					// Everything is ok

4600 4601 4602 4603 4604
err:
  if (error)
    end_io_cache(&file);
  if (fd >= 0)
    my_close(fd, MYF(0));
4605
  thd->proc_info= 0;
4606
  return error ? 1 : Log_event::exec_event(rli);
4607
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4608
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
4609

4610

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4611
/**************************************************************************
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4612
	Append_block_log_event methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4613
**************************************************************************/
4614

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4615
/*
4616
  Append_block_log_event ctor
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4617
*/
4618 4619

#ifndef MYSQL_CLIENT  
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4620 4621
Append_block_log_event::Append_block_log_event(THD* thd_arg, const char* db_arg,
					       char* block_arg,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4622 4623 4624
					       uint block_len_arg,
					       bool using_trans)
  :Log_event(thd_arg,0, using_trans), block(block_arg),
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4625
   block_len(block_len_arg), file_id(thd_arg->file_id), db(db_arg)
4626 4627
{
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4628
#endif
4629 4630


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4631
/*
4632
  Append_block_log_event ctor
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4633
*/
4634

4635 4636 4637
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)
4638
{
4639 4640 4641 4642 4643 4644
  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)
monty@mysql.com's avatar
monty@mysql.com committed
4645
    DBUG_VOID_RETURN;
4646 4647 4648
  file_id= uint4korr(buf + common_header_len + AB_FILE_ID_OFFSET);
  block= (char*)buf + total_header_len;
  block_len= len - total_header_len;
monty@mysql.com's avatar
monty@mysql.com committed
4649
  DBUG_VOID_RETURN;
4650 4651 4652
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4653
/*
4654
  Append_block_log_event::write()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4655
*/
4656

4657
#ifndef MYSQL_CLIENT
4658
bool Append_block_log_event::write(IO_CACHE* file)
4659 4660 4661
{
  byte buf[APPEND_BLOCK_HEADER_LEN];
  int4store(buf + AB_FILE_ID_OFFSET, file_id);
4662 4663
  return (write_header(file, APPEND_BLOCK_HEADER_LEN + block_len) ||
          my_b_safe_write(file, buf, APPEND_BLOCK_HEADER_LEN) ||
4664 4665
	  my_b_safe_write(file, (byte*) block, block_len));
}
4666
#endif
4667 4668


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4669
/*
4670
  Append_block_log_event::print()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4671
*/
4672 4673

#ifdef MYSQL_CLIENT  
lars@mysql.com's avatar
lars@mysql.com committed
4674
void Append_block_log_event::print(FILE* file,
4675
				   PRINT_EVENT_INFO* print_event_info)
4676
{
4677 4678
  Write_on_release_cache cache(&print_event_info->head_cache, file);

4679
  if (print_event_info->short_form)
4680
    return;
4681 4682 4683
  print_header(&cache, print_event_info, FALSE);
  my_b_printf(&cache, "\n#%s: file_id: %d  block_len: %d\n",
              get_type_str(), file_id, block_len);
4684
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4685
#endif /* MYSQL_CLIENT */
4686 4687


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4688
/*
4689
  Append_block_log_event::pack_info()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4690
*/
4691

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
4692
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4693
void Append_block_log_event::pack_info(Protocol *protocol)
4694 4695 4696 4697 4698 4699
{
  char buf[256];
  uint length;
  length= (uint) my_sprintf(buf,
			    (buf, ";file_id=%u;block_len=%u", file_id,
			     block_len));
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4700
  protocol->store(buf, length, &my_charset_bin);
4701 4702 4703
}


4704
/*
4705
  Append_block_log_event::get_create_or_append()
4706 4707
*/

4708
int Append_block_log_event::get_create_or_append() const
4709
{
4710
  return 0; /* append to the file, fail if not exists */
4711 4712
}

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4713
/*
4714
  Append_block_log_event::exec_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4715
*/
4716

4717
int Append_block_log_event::exec_event(struct st_relay_log_info* rli)
4718
{
4719
  char proc_info[17+FN_REFLEN+10], *fname= proc_info+17;
4720
  int fd;
4721
  int error = 1;
monty@mysql.com's avatar
monty@mysql.com committed
4722
  DBUG_ENTER("Append_block_log_event::exec_event");
4723

4724 4725
  fname= strmov(proc_info, "Making temp file ");
  slave_load_file_stem(fname, file_id, server_id, ".data");
4726
  thd->proc_info= proc_info;
4727 4728 4729 4730 4731 4732 4733
  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)
    {
4734 4735 4736
      slave_print_msg(ERROR_LEVEL, rli, my_errno,
                      "Error in %s event: could not create file '%s'",
                      get_type_str(), fname);
4737 4738 4739
      goto err;
    }
  }
4740 4741
  else if ((fd = my_open(fname, O_WRONLY | O_APPEND | O_BINARY | O_NOFOLLOW,
                         MYF(MY_WME))) < 0)
4742
  {
4743 4744 4745
    slave_print_msg(ERROR_LEVEL, rli, my_errno,
                    "Error in %s event: could not open file '%s'",
                    get_type_str(), fname);
4746 4747
    goto err;
  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4748
  if (my_write(fd, (byte*) block, block_len, MYF(MY_WME+MY_NABP)))
4749
  {
4750 4751 4752
    slave_print_msg(ERROR_LEVEL, rli, my_errno,
                    "Error in %s event: write to '%s' failed",
                    get_type_str(), fname);
4753 4754 4755
    goto err;
  }
  error=0;
4756

4757 4758 4759
err:
  if (fd >= 0)
    my_close(fd, MYF(0));
4760
  thd->proc_info= 0;
monty@mysql.com's avatar
monty@mysql.com committed
4761
  DBUG_RETURN(error ? error : Log_event::exec_event(rli));
4762
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
4763
#endif
4764 4765


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4766
/**************************************************************************
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4767
	Delete_file_log_event methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4768
**************************************************************************/
4769

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4770
/*
4771
  Delete_file_log_event ctor
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4772
*/
4773 4774

#ifndef MYSQL_CLIENT
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4775 4776 4777
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)
4778 4779
{
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4780
#endif
4781

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4782
/*
4783
  Delete_file_log_event ctor
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4784
*/
4785

4786 4787 4788
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)
4789
{
4790 4791 4792
  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))
4793
    return;
4794
  file_id= uint4korr(buf + common_header_len + DF_FILE_ID_OFFSET);
4795 4796 4797
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4798
/*
4799
  Delete_file_log_event::write()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4800
*/
4801

4802
#ifndef MYSQL_CLIENT
4803
bool Delete_file_log_event::write(IO_CACHE* file)
4804 4805 4806
{
 byte buf[DELETE_FILE_HEADER_LEN];
 int4store(buf + DF_FILE_ID_OFFSET, file_id);
4807 4808
 return (write_header(file, sizeof(buf)) ||
         my_b_safe_write(file, buf, sizeof(buf)));
4809
}
4810
#endif
4811 4812


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4813
/*
4814
  Delete_file_log_event::print()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4815
*/
4816 4817

#ifdef MYSQL_CLIENT  
lars@mysql.com's avatar
lars@mysql.com committed
4818
void Delete_file_log_event::print(FILE* file,
4819
				  PRINT_EVENT_INFO* print_event_info)
4820
{
4821 4822
  Write_on_release_cache cache(&print_event_info->head_cache, file);

4823
  if (print_event_info->short_form)
4824
    return;
4825 4826
  print_header(&cache, print_event_info, FALSE);
  my_b_printf(&cache, "\n#Delete_file: file_id=%u\n", file_id);
4827
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4828
#endif /* MYSQL_CLIENT */
4829

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4830
/*
4831
  Delete_file_log_event::pack_info()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4832
*/
4833

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
4834
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4835
void Delete_file_log_event::pack_info(Protocol *protocol)
4836 4837 4838 4839
{
  char buf[64];
  uint length;
  length= (uint) my_sprintf(buf, (buf, ";file_id=%u", (uint) file_id));
4840
  protocol->store(buf, (int32) length, &my_charset_bin);
4841
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
4842
#endif
4843

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4844
/*
4845
  Delete_file_log_event::exec_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4846
*/
4847

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
4848
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4849 4850 4851
int Delete_file_log_event::exec_event(struct st_relay_log_info* rli)
{
  char fname[FN_REFLEN+10];
4852
  char *ext= slave_load_file_stem(fname, file_id, server_id, ".data");
4853
  (void) my_delete(fname, MYF(MY_WME));
4854
  strmov(ext, ".info");
4855 4856 4857
  (void) my_delete(fname, MYF(MY_WME));
  return Log_event::exec_event(rli);
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4858
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
4859 4860


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4861
/**************************************************************************
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4862
	Execute_load_log_event methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4863
**************************************************************************/
4864

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4865
/*
4866
  Execute_load_log_event ctor
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4867
*/
4868 4869

#ifndef MYSQL_CLIENT  
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4870 4871 4872
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)
4873 4874
{
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4875
#endif
4876 4877
  

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4878
/*
4879
  Execute_load_log_event ctor
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4880
*/
4881

4882 4883 4884
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)
4885
{
4886 4887 4888
  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))
4889
    return;
4890
  file_id= uint4korr(buf + common_header_len + EL_FILE_ID_OFFSET);
4891 4892 4893
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4894
/*
4895
  Execute_load_log_event::write()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4896
*/
4897

4898
#ifndef MYSQL_CLIENT
4899
bool Execute_load_log_event::write(IO_CACHE* file)
4900 4901 4902
{
  byte buf[EXEC_LOAD_HEADER_LEN];
  int4store(buf + EL_FILE_ID_OFFSET, file_id);
4903 4904
  return (write_header(file, sizeof(buf)) || 
          my_b_safe_write(file, buf, sizeof(buf)));
4905
}
4906
#endif
4907 4908


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4909
/*
4910
  Execute_load_log_event::print()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4911
*/
4912 4913

#ifdef MYSQL_CLIENT  
lars@mysql.com's avatar
lars@mysql.com committed
4914
void Execute_load_log_event::print(FILE* file,
4915
				   PRINT_EVENT_INFO* print_event_info)
4916
{
4917 4918
  Write_on_release_cache cache(&print_event_info->head_cache, file);

4919
  if (print_event_info->short_form)
4920
    return;
4921 4922 4923
  print_header(&cache, print_event_info, FALSE);
  my_b_printf(&cache, "\n#Exec_load: file_id=%d\n",
              file_id);
4924
}
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4925
#endif
4926

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4927
/*
4928
  Execute_load_log_event::pack_info()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4929
*/
4930

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
4931
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4932
void Execute_load_log_event::pack_info(Protocol *protocol)
4933 4934 4935 4936
{
  char buf[64];
  uint length;
  length= (uint) my_sprintf(buf, (buf, ";file_id=%u", (uint) file_id));
4937
  protocol->store(buf, (int32) length, &my_charset_bin);
4938 4939 4940
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4941
/*
4942
  Execute_load_log_event::exec_event()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4943
*/
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
4944

4945
int Execute_load_log_event::exec_event(struct st_relay_log_info* rli)
4946 4947
{
  char fname[FN_REFLEN+10];
4948
  char *ext;
4949
  int fd;
4950
  int error= 1;
4951
  IO_CACHE file;
4952
  Load_log_event *lev= 0;
4953

4954
  ext= slave_load_file_stem(fname, file_id, server_id, ".info");
4955 4956
  if ((fd = my_open(fname, O_RDONLY | O_BINARY | O_NOFOLLOW,
                    MYF(MY_WME))) < 0 ||
4957 4958 4959
      init_io_cache(&file, fd, IO_SIZE, READ_CACHE, (my_off_t)0, 0,
		    MYF(MY_WME|MY_NABP)))
  {
4960 4961
    slave_print_msg(ERROR_LEVEL, rli, my_errno, "Error in Exec_load event: "
                    "could not open file '%s'", fname);
4962 4963
    goto err;
  }
4964
  if (!(lev = (Load_log_event*)Log_event::read_log_event(&file,
4965 4966
                                                         (pthread_mutex_t*)0,
                                                         rli->relay_log.description_event_for_exec)) ||
4967
      lev->get_type_code() != NEW_LOAD_EVENT)
4968
  {
4969 4970
    slave_print_msg(ERROR_LEVEL, rli, 0, "Error in Exec_load event: "
                    "file '%s' appears corrupted", fname);
4971 4972
    goto err;
  }
4973

4974
  lev->thd = thd;
4975 4976
  /*
    lev->exec_event should use rli only for errors
4977 4978 4979
    i.e. should not advance rli's position.
    lev->exec_event is the place where the table is loaded (it calls
    mysql_load()).
4980
  */
guilhem@mysql.com's avatar
guilhem@mysql.com committed
4981

4982
  rli->future_group_master_log_pos= log_pos;
4983
  if (lev->exec_event(0,rli,1)) 
4984
  {
4985 4986 4987 4988 4989 4990 4991 4992 4993
    /*
      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));
4994 4995
    if (tmp)
    {
4996 4997 4998 4999
      slave_print_msg(ERROR_LEVEL, rli,
                      rli->last_slave_errno, /* ok to re-use error code */
                      "%s. Failed executing load from '%s'", 
                      tmp, fname);
5000 5001
      my_free(tmp,MYF(0));
    }
5002 5003
    goto err;
  }
guilhem@mysql.com's avatar
guilhem@mysql.com committed
5004 5005 5006 5007 5008 5009 5010 5011 5012 5013
  /*
    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;
  }
5014
  (void) my_delete(fname, MYF(MY_WME));
5015
  memcpy(ext, ".data", 6);
5016
  (void) my_delete(fname, MYF(MY_WME));
5017
  error = 0;
5018

5019 5020 5021
err:
  delete lev;
  if (fd >= 0)
5022
  {
5023
    my_close(fd, MYF(0));
5024 5025
    end_io_cache(&file);
  }
5026
  return error ? error : Log_event::exec_event(rli);
5027
}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5028

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5029
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
5030 5031


5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056
/**************************************************************************
	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)
5057
int Begin_load_query_log_event::get_create_or_append() const
5058
{
5059
  return 1; /* create the file */
5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113
}
#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;
}


5114
#ifndef MYSQL_CLIENT
5115 5116 5117 5118 5119 5120 5121 5122 5123 5124
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);
}
5125
#endif
5126 5127 5128


#ifdef MYSQL_CLIENT
lars@mysql.com's avatar
lars@mysql.com committed
5129
void Execute_load_query_log_event::print(FILE* file,
5130
                                         PRINT_EVENT_INFO* print_event_info)
5131
{
5132
  print(file, print_event_info, 0);
5133 5134 5135
}


lars@mysql.com's avatar
lars@mysql.com committed
5136
void Execute_load_query_log_event::print(FILE* file,
5137
                                         PRINT_EVENT_INFO* print_event_info,
5138 5139
                                         const char *local_fname)
{
5140 5141 5142
  Write_on_release_cache cache(&print_event_info->head_cache, file);

  print_query_header(&cache, print_event_info);
5143 5144 5145

  if (local_fname)
  {
5146 5147 5148 5149
    my_b_write(&cache, (byte*) query, fn_pos_start);
    my_b_printf(&cache, " LOCAL INFILE \'");
    my_b_printf(&cache, local_fname);
    my_b_printf(&cache, "\'");
5150
    if (dup_handling == LOAD_DUP_REPLACE)
5151 5152 5153
      my_b_printf(&cache, " REPLACE");
    my_b_printf(&cache, " INTO");
    my_b_write(&cache, (byte*) query + fn_pos_end, q_len-fn_pos_end);
5154
    my_b_printf(&cache, "%s\n", print_event_info->delimiter);
5155 5156 5157
  }
  else
  {
5158
    my_b_write(&cache, (byte*) query, q_len);
5159
    my_b_printf(&cache, "%s\n", print_event_info->delimiter);
5160 5161
  }

5162
  if (!print_event_info->short_form)
5163
    my_b_printf(&cache, "# file_id: %d \n", file_id);
5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205
}
#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))))
  {
5206
    slave_print_msg(ERROR_LEVEL, rli, my_errno, "Not enough memory");
5207 5208 5209 5210 5211 5212
    return 1;
  }

  p= buf;
  memcpy(p, query, fn_pos_start);
  p+= fn_pos_start;
5213
  fname= (p= strmake(p, STRING_WITH_LEN(" INFILE \'")));
5214 5215
  p= slave_load_file_stem(p, file_id, server_id, ".data");
  fname_end= p= strend(p);                      // Safer than p=p+5
5216
  *(p++)='\'';
5217
  switch (dup_handling) {
5218
  case LOAD_DUP_IGNORE:
5219
    p= strmake(p, STRING_WITH_LEN(" IGNORE"));
5220 5221
    break;
  case LOAD_DUP_REPLACE:
5222
    p= strmake(p, STRING_WITH_LEN(" REPLACE"));
5223 5224 5225 5226 5227
    break;
  default:
    /* Ordinary load data */
    break;
  }
5228
  p= strmake(p, STRING_WITH_LEN(" INTO"));
5229 5230 5231 5232 5233 5234 5235
  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;

5236 5237 5238 5239 5240 5241
  /*
    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));
5242 5243 5244 5245 5246 5247 5248

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


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5249
/**************************************************************************
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5250
	sql_ex_info methods
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5251
**************************************************************************/
5252

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5253
/*
5254
  sql_ex_info::write_data()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5255
*/
5256

5257
bool sql_ex_info::write_data(IO_CACHE* file)
5258 5259 5260
{
  if (new_format())
  {
5261 5262 5263 5264 5265
    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) ||
5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277
	    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;
5278
    return my_b_safe_write(file, (byte*) &old_ex, sizeof(old_ex)) != 0;
5279 5280 5281 5282
  }
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5283
/*
5284
  sql_ex_info::init()
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5285
*/
5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299

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.
    */
5300 5301 5302 5303 5304
    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))
5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330
      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;
}
5331 5332 5333 5334 5335 5336 5337 5338 5339 5340


/**************************************************************************
	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),
5341
    m_row_count(0),
5342 5343
    m_table(tbl_arg),
    m_table_id(tid),
5344 5345
    m_width(tbl_arg ? tbl_arg->s->fields : 1),
    m_rows_buf(0), m_rows_cur(0), m_rows_end(0),
5346 5347
    m_flags(0)
{
5348 5349
  /*
    We allow a special form of dummy event when the table, and cols
5350
    are null and the table id is ~0UL.  This is a temporary
5351 5352
    solution, to be able to terminate a started statement in the
    binary log: the extreneous events will be removed in the future.
5353
   */
5354 5355
  DBUG_ASSERT(tbl_arg && tbl_arg->s && tid != ~0UL ||
              !tbl_arg && !cols && tid == ~0UL);
5356 5357 5358 5359 5360 5361 5362 5363 5364 5365

  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)))
5366 5367 5368 5369 5370
  {
    /* 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));
  }
5371 5372 5373 5374 5375 5376 5377 5378 5379 5380
  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),
5381
    m_row_count(0),
5382 5383 5384 5385 5386 5387
    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];

5388 5389
  DBUG_PRINT("enter",("event_len: %u  common_header_len: %d  "
		      "post_header_len: %d",
5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402
		      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
  {
5403
    m_table_id= (ulong) uint6korr(post_start);
5404 5405 5406 5407 5408
    post_start+= RW_FLAGS_OFFSET;
  }

  m_flags= uint2korr(post_start);

5409 5410
  byte const *const var_start= (const byte *)buf + common_header_len + 
    post_header_len;
5411
  byte const *const ptr_width= var_start;
5412 5413
  uchar *ptr_after_width= (uchar*) ptr_width;
  m_width = net_field_length(&ptr_after_width);
5414 5415

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

5418
  my_size_t const data_size= event_len - (ptr_rows_data - (const byte *) buf);
5419
  DBUG_PRINT("info",("m_table_id: %lu  m_flags: %d  m_width: %lu  data_size: %lu",
5420 5421
                     m_table_id, m_flags, m_width, data_size));

5422
  m_rows_buf= (byte*)my_malloc(data_size, MYF(MY_WME));
5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445
  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().
5446
  my_free((gptr)m_rows_buf, MYF(MY_ALLOW_ZERO_PTR));
5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457
}

#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
  */
5458
  DBUG_ENTER("Rows_log_event::do_add_row_data");
5459 5460
  DBUG_PRINT("enter", ("row_data: 0x%lx  length: %lu", (ulong) row_data,
                       (ulong) length));
5461 5462 5463 5464 5465
  /*
    Don't print debug messages when running valgrind since they can
    trigger false warnings.
   */
#ifndef HAVE_purify
5466
  DBUG_DUMP("row_data", (const char*)row_data, min(length, 32));
5467
#endif
5468 5469

  DBUG_ASSERT(m_rows_buf <= m_rows_cur);
5470
  DBUG_ASSERT(!m_rows_buf || m_rows_end && m_rows_buf < m_rows_end);
5471 5472 5473 5474 5475 5476 5477 5478
  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;
5479 5480
    my_ptrdiff_t const new_alloc= 
        block_size * ((cur_size + length) / block_size + block_size - 1);
5481

5482 5483
    byte* const new_buf= (byte*)my_realloc((gptr)m_rows_buf, new_alloc,
                                           MYF(MY_ALLOW_ZERO_PTR|MY_WME));
5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503
    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;
5504
  m_row_count++;
5505 5506 5507 5508 5509 5510
  DBUG_RETURN(0);
}
#endif

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
/*
5511
  Unpack a row into table->record[0].
5512
  
5513 5514 5515 5516 5517 5518 5519 5520 5521 5522
  SYNOPSIS
    unpack_row()
    rli     Relay log info
    table   Table to unpack into
    colcnt  Number of columns to read from record
    row     Packed row data
    cols    Pointer to columns data to fill in
    row_end Pointer to variable that will hold the value of the
            one-after-end position for the row
    master_reclength
5523
            Pointer to variable that will be set to the length of the
5524 5525 5526 5527 5528 5529
            record on the master side
    rw_set  Pointer to bitmap that holds either the read_set or the
            write_set of the table

  DESCRIPTION

5530 5531 5532 5533 5534
      The function will always unpack into the table->record[0]
      record.  This is because there are too many dependencies on
      where the various member functions of Field and subclasses
      expect to write.

5535 5536 5537
      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.
5538

5539 5540
      At most 'colcnt' columns are read: if the table is larger than
      that, the remaining fields are not filled in.
5541 5542 5543 5544 5545 5546 5547 5548 5549

  RETURN VALUE

      Error code, or zero if no error. The following error codes can
      be returned:

      ER_NO_DEFAULT_FOR_FIELD
        Returned if one of the fields existing on the slave but not on
        the master does not have a default value (and isn't nullable)
5550
 */
5551 5552
static int
unpack_row(RELAY_LOG_INFO *rli,
5553
           TABLE *table, uint const colcnt,
5554
           char const *row, MY_BITMAP const *cols,
5555
           char const **row_end, ulong *master_reclength,
5556
           MY_BITMAP* const rw_set, Log_event_type const event_type)
5557
{
5558
  byte *const record= table->record[0];
5559
  DBUG_ENTER("unpack_row");
5560
  DBUG_ASSERT(record && row);
5561
  DBUG_PRINT("enter", ("row: 0x%lx  table->record[0]: 0x%lx", (long) row, (long) record));
5562
  my_size_t master_null_bytes= table->s->null_bytes;
5563

5564 5565 5566 5567 5568
  if (colcnt != table->s->fields)
  {
    Field **fptr= &table->field[colcnt-1];
    do
      master_null_bytes= (*fptr)->last_null_byte();
5569 5570 5571 5572 5573 5574 5575 5576
    while (master_null_bytes == Field::LAST_NULL_BYTE_UNDEF &&
           fptr-- > table->field);

    /*
      If master_null_bytes is LAST_NULL_BYTE_UNDEF (0) at this time,
      there were no nullable fields nor BIT fields at all in the
      columns that are common to the master and the slave. In that
      case, there is only one null byte holding the X bit.
5577

5578 5579 5580 5581 5582
      OBSERVE! There might still be nullable columns following the
      common columns, so table->s->null_bytes might be greater than 1.
     */
    if (master_null_bytes == Field::LAST_NULL_BYTE_UNDEF)
      master_null_bytes= 1;
5583 5584 5585 5586
  }

  DBUG_ASSERT(master_null_bytes <= table->s->null_bytes);
  memcpy(record, row, master_null_bytes);            // [1]
5587
  int error= 0;
5588

5589
  bitmap_set_all(rw_set);
5590 5591

  Field **const begin_ptr = table->field;
5592
  Field **field_ptr;
5593 5594 5595
  char const *ptr= row + master_null_bytes;
  Field **const end_ptr= begin_ptr + colcnt;
  for (field_ptr= begin_ptr ; field_ptr < end_ptr ; ++field_ptr)
5596 5597 5598
  {
    Field *const f= *field_ptr;

5599
    if (bitmap_is_set(cols, field_ptr -  begin_ptr))
5600
    {
5601
      DBUG_ASSERT((char *)table->record[0] <= f->ptr);
5602 5603
      DBUG_ASSERT(f->ptr < (char *)table->record[0] + table->s->reclength + 
                           (f->pack_length_in_rec() == 0));
5604 5605
      DBUG_PRINT("info", ("unpacking column '%s' to 0x%lx", f->field_name,
                          (long) f->ptr));
5606
      ptr= f->unpack(f->ptr, ptr);
5607 5608
      /* Field...::unpack() cannot return 0 */
      DBUG_ASSERT(ptr != NULL);
5609 5610
    }
    else
5611
      bitmap_clear_bit(rw_set, field_ptr - begin_ptr);
5612
  }
5613 5614 5615 5616 5617 5618 5619 5620

  *row_end = ptr;
  if (master_reclength)
  {
    if (*field_ptr)
      *master_reclength = (*field_ptr)->ptr - (char*) table->record[0];
    else
      *master_reclength = table->s->reclength;
5621
  }
5622

5623 5624 5625 5626 5627 5628
  /*
    Set properties for remaining columns, if there are any. We let the
    corresponding bit in the write_set be set, to write the value if
    it was not there already. We iterate over all remaining columns,
    even if there were an error, to get as many error messages as
    possible.  We are still able to return a pointer to the next row,
5629 5630 5631 5632
    so redo that.

    This generation of error messages is only relevant when inserting
    new rows.
5633 5634 5635
   */
  for ( ; *field_ptr ; ++field_ptr)
  {
5636
    uint32 const mask= NOT_NULL_FLAG | NO_DEFAULT_VALUE_FLAG;
5637
    Field *const f= *field_ptr;
5638

5639 5640
    DBUG_PRINT("info", ("processing column '%s' @ 0x%lx", f->field_name,
                        (long) f->ptr));
5641
    if (event_type == WRITE_ROWS_EVENT && (f->flags & mask) == mask)
5642
    {
5643
      slave_print_msg(ERROR_LEVEL, rli, ER_NO_DEFAULT_FOR_FIELD,
5644 5645
                      "Field `%s` of table `%s`.`%s` "
                      "has no default value and cannot be NULL",
5646
                      (*field_ptr)->field_name, table->s->db.str,
5647 5648
                      table->s->table_name.str);
      error = ER_NO_DEFAULT_FOR_FIELD;
5649 5650
    }
    else
5651
      f->set_default();
5652
  }
5653

5654
  DBUG_RETURN(error);
5655 5656 5657 5658 5659 5660
}

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;
5661
  char const *row_start= (char const *)m_rows_buf;
5662 5663

  /*
5664
    If m_table_id == ~0UL, then we have a dummy event that does
5665
    not contain any data.  In that case, we just remove all tables in
5666 5667
    the tables_to_lock list, close the thread tables, step the relay
    log position, and return with success.
5668
   */
5669
  if (m_table_id == ~0UL)
5670 5671 5672 5673 5674 5675 5676 5677
  {
    /*
       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();
5678
    close_thread_tables(thd);
5679 5680 5681 5682
    thd->clear_error();
    rli->inc_event_relay_log_pos();
    DBUG_RETURN(0);
  }
5683 5684 5685 5686 5687 5688 5689 5690

  /*
    '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);

  /*
5691 5692 5693 5694
    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.
5695
  */
5696
  if (!thd->lock)
5697
  {
5698 5699
    bool need_reopen= 1; /* To execute the first lap of the loop below */

5700
    /*
5701
      lock_tables() reads the contents of thd->lex, so they must be
5702 5703
      initialized. Contrary to in Table_map_log_event::exec_event() we don't
      call mysql_init_query() as that may reset the binlog format.
5704
    */
5705
    lex_start(thd, NULL, 0);
5706

5707 5708 5709
    while ((error= lock_tables(thd, rli->tables_to_lock,
                               rli->tables_to_lock_count, &need_reopen)))
    {
5710 5711 5712
      if (!need_reopen)
      {
        slave_print_msg(ERROR_LEVEL, rli, error,
5713 5714
                        "Error in %s event: when locking tables",
                        get_type_str());
5715
        rli->clear_tables_to_lock();
5716 5717
        DBUG_RETURN(error);
      }
5718

5719
      /*
5720
        So we need to reopen the tables.
5721

5722 5723
        We need to flush the pending RBR event, since it keeps a
        pointer to an open table.
5724

5725 5726 5727
        ALTERNATIVE SOLUTION (not implemented): Extract a pointer to
        the pending RBR event and reset the table pointer after the
        tables has been reopened.
5728

5729 5730
        NOTE: For this new scheme there should be no pending event:
        need to add code to assert that is the case.
5731 5732
       */
      thd->binlog_flush_pending_rows_event(false);
5733
      close_tables_for_reopen(thd, &rli->tables_to_lock);
5734

5735 5736
      if ((error= open_tables(thd, &rli->tables_to_lock,
                              &rli->tables_to_lock_count, 0)))
5737 5738 5739 5740 5741 5742 5743 5744 5745
      {
        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,
5746
                          "Error '%s' on reopening tables",
5747
                          (actual_error ? thd->net.last_error :
5748
                           "unexpected success or fatal error"));
5749 5750
          thd->query_error= 1;
        }
5751
        rli->clear_tables_to_lock();
5752
        DBUG_RETURN(error);
5753
      }
5754
    }
5755 5756 5757
    /*
      When the open and locking succeeded, we add all the tables to
      the table map and remove them from tables to lock.
5758 5759 5760

      We also invalidate the query cache for all the tables, since
      they will now be changed.
5761
     */
5762 5763
    TABLE_LIST *ptr;
    for (ptr= rli->tables_to_lock ; ptr ; ptr= ptr->next_global)
5764 5765
    {
      rli->m_table_map.set_table(ptr->table_id, ptr->table);
5766
    }
5767 5768 5769
#ifdef HAVE_QUERY_CACHE
    query_cache.invalidate_locked_for_write(rli->tables_to_lock);
#endif
5770
    rli->clear_tables_to_lock();
5771 5772
  }

5773 5774
  DBUG_ASSERT(rli->tables_to_lock == NULL && rli->tables_to_lock_count == 0);

5775 5776 5777 5778 5779 5780 5781 5782 5783
  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).
    */
5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811

    /*
      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);
5812 5813
    while (error == 0 && row_start < (const char*) m_rows_end)
    {
5814 5815
      char const *row_end= NULL;
      if ((error= do_prepare_row(thd, rli, table, row_start, &row_end)))
5816 5817
        break; // We should perform the after-row operation even in
               // the case of error
5818

5819
      DBUG_ASSERT(row_end != NULL); // cannot happen
5820
      DBUG_ASSERT(row_end <= (const char*)m_rows_end);
5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851

      /* 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)
5852 5853 5854 5855
    {
      DBUG_PRINT("info", ("Marked that we need to keep log"));
      thd->options|= OPTION_KEEP_LOG;
    }
5856 5857 5858 5859
  }

  if (error)
  {                     /* error has occured during the transaction */
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
5860 5861 5862 5863 5864 5865
    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);
     /*
5866 5867 5868 5869 5870 5871 5872 5873
      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.
5874
      rollback at the caller along with sbr.
5875
    */
5876
    thd->reset_current_stmt_binlog_row_based();
5877
    rli->cleanup_context(thd, 0);  /* rollback at caller in step with sbr */
5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 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
    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.
    */

5920
    thd->reset_current_stmt_binlog_row_based();
5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940
    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`",
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
5941 5942
                      get_type_str(), table->s->db.str, 
                      table->s->table_name.str);
5943 5944 5945
    DBUG_RETURN(error);
  }

5946
  if (table && (table->s->primary_key == MAX_KEY) && !cache_stmt)
5947 5948
  {
    /*
5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962
      ------------ 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.
5963
    */
5964
    rli->unsafe_to_stop_at= time(0);
5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978
  }

  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
5979
  DBUG_ASSERT(m_table_id != ~0UL);
5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996
  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.
  */
knielsen@mysql.com's avatar
knielsen@mysql.com committed
5997
  char sbuf[sizeof(m_width)];
5998 5999
  my_ptrdiff_t const data_size= m_rows_cur - m_rows_buf;

kent@mysql.com's avatar
kent@mysql.com committed
6000
  char *const sbuf_end= net_store_length((char*) sbuf, (uint) m_width);
knielsen@mysql.com's avatar
knielsen@mysql.com committed
6001
  DBUG_ASSERT(static_cast<my_size_t>(sbuf_end - sbuf) <= sizeof(sbuf));
6002

knielsen@mysql.com's avatar
knielsen@mysql.com committed
6003 6004
  return (my_b_safe_write(file, reinterpret_cast<byte*>(sbuf),
                          sbuf_end - sbuf) ||
6005 6006 6007 6008 6009 6010
          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

6011
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
6012 6013
void Rows_log_event::pack_info(Protocol *protocol)
{
6014 6015 6016
  char buf[256];
  char const *const flagstr=
    get_flags(STMT_END_F) ? " flags: STMT_END_F" : "";
6017 6018
  my_size_t bytes= my_snprintf(buf, sizeof(buf),
                               "table_id: %lu%s", m_table_id, flagstr);
6019
  protocol->store(buf, bytes, &my_charset_bin);
6020 6021 6022
}
#endif

6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047
#ifdef MYSQL_CLIENT
void Rows_log_event::print_helper(FILE *file,
                                  PRINT_EVENT_INFO *print_event_info,
                                  char const *const name)
{
  IO_CACHE *const head= &print_event_info->head_cache;
  IO_CACHE *const body= &print_event_info->body_cache;
  if (!print_event_info->short_form)
  {
    bool const last_stmt_event= get_flags(STMT_END_F);
    print_header(head, print_event_info, !last_stmt_event);
    my_b_printf(head, "\t%s: table id %lu", name, m_table_id);
    print_base64(body, print_event_info, !last_stmt_event);
  }

  if (get_flags(STMT_END_F))
  {
    my_b_copy_to_file(head, file);
    my_b_copy_to_file(body, file);
    reinit_io_cache(head, WRITE_CACHE, 0, FALSE, TRUE);
    reinit_io_cache(body, WRITE_CACHE, 0, FALSE, TRUE);
  }
}
#endif

6048
/**************************************************************************
6049
	Table_map_log_event member functions and support functions
6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069
**************************************************************************/

/*
  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)
{
6070
  DBUG_ASSERT(m_table_id != ~0UL);
6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082
  /*
    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;
serg@serg.mylan's avatar
serg@serg.mylan committed
6083
  DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master", m_data_size= 6;);
6084 6085 6086 6087 6088 6089 6090
  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))))
  {
monty@mysql.com's avatar
monty@mysql.com committed
6091
    m_coltype= reinterpret_cast<uchar*>(m_memory);
6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115
    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];
6116
  DBUG_PRINT("info",("event_len: %u  common_header_len: %d  post_header_len: %d",
6117 6118
                     event_len, common_header_len, post_header_len));

6119 6120 6121 6122 6123
  /*
    Don't print debug messages when running valgrind since they can
    trigger false warnings.
   */
#ifndef HAVE_purify
6124
  DBUG_DUMP("event buffer", buf, event_len);
6125
#endif
6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139

  /* 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);
6140
    m_table_id= (ulong) uint6korr(post_start);
6141 6142 6143
    post_start+= TM_FLAGS_OFFSET;
  }

6144
  DBUG_ASSERT(m_table_id != ~0UL);
6145 6146 6147 6148 6149 6150 6151

  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 */
6152
  byte const* const ptr_dblen= (byte const*)vpart + 0;
monty@mysql.com's avatar
monty@mysql.com committed
6153
  m_dblen= *(uchar*) ptr_dblen;
6154 6155 6156

  /* Length of database name + counter + terminating null */
  byte const* const ptr_tbllen= ptr_dblen + m_dblen + 2;
monty@mysql.com's avatar
monty@mysql.com committed
6157
  m_tbllen= *(uchar*) ptr_tbllen;
6158 6159 6160

  /* Length of table name + counter + terminating null */
  byte const* const ptr_colcnt= ptr_tbllen + m_tbllen + 2;
6161 6162
  uchar *ptr_after_colcnt= (uchar*) ptr_colcnt;
  m_colcnt= net_field_length(&ptr_after_colcnt);
6163

6164
  DBUG_PRINT("info",("m_dblen: %lu  off: %ld  m_tbllen: %lu  off: %ld  m_colcnt: %lu  off: %ld",
6165 6166 6167
                     m_dblen, (long) (ptr_dblen-(const byte*)vpart), 
                     m_tbllen, (long) (ptr_tbllen-(const byte*)vpart),
                     m_colcnt, (long) (ptr_colcnt-(const byte*)vpart)));
6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178

  /* 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 */
6179 6180
    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);
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
    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);

6216 6217 6218 6219 6220 6221 6222 6223 6224
  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);

6225 6226
  if (memory == NULL)
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6227

6228
  uint dummy_len;
6229 6230 6231 6232 6233 6234 6235 6236 6237
  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);
6238 6239 6240

  int error= 0;

6241 6242 6243 6244 6245 6246
  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
6247
  {
6248 6249 6250 6251 6252 6253
    /*
      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);
6254
    /*
6255 6256 6257
      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.
6258
    */
6259 6260
    if (!thd->current_stmt_binlog_row_based &&
        mysql_bin_log.is_open() && (thd->options & OPTION_BIN_LOG))
6261
    {
6262
      thd->set_current_stmt_binlog_row_based();
6263 6264 6265 6266
    }

    /*
      Open the table if it is not already open and add the table to table map.
6267
      Note that for any table that should not be replicated, a filter is needed.
6268 6269
    */
    uint count;
6270
    if ((error= open_tables(thd, &table_list, &count, 0)))
6271
    {
6272
      if (thd->query_error || thd->is_fatal_error)
6273
      {
6274 6275 6276 6277 6278
        /*
          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;
6279 6280 6281 6282 6283 6284
        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;
6285
      }
6286
      goto err;
6287 6288
    }

6289
    m_table= table_list->table;
6290 6291 6292 6293 6294 6295 6296

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

6297 6298
    table_def const def(m_coltype, m_colcnt);
    if (def.compatible_with(rli, m_table))
6299 6300
    {
      thd->query_error= 1;
6301 6302
      error= ERR_BAD_TABLE_DEF;
      goto err;
6303
      /* purecov: end */
6304 6305 6306
    }

    /*
6307
      We record in the slave's information that the table should be
mats@romeo.(none)'s avatar
mats@romeo.(none) committed
6308
      locked by linking the table into the list of tables to lock.
6309
    */
6310 6311 6312 6313
    table_list->next_global= table_list->next_local= rli->tables_to_lock;
    rli->tables_to_lock= table_list;
    rli->tables_to_lock_count++;
    /* 'memory' is freed in clear_tables_to_lock */
6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327
  }

  /*
    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();
6328
  DBUG_RETURN(error);
6329

6330 6331
err:
  my_free((gptr) memory, MYF(MY_WME));
6332 6333 6334 6335 6336 6337 6338
  DBUG_RETURN(error);
}
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */

#ifndef MYSQL_CLIENT
bool Table_map_log_event::write_data_header(IO_CACHE *file)
{
6339
  DBUG_ASSERT(m_table_id != ~0UL);
6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362
  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 };

knielsen@mysql.com's avatar
knielsen@mysql.com committed
6363
  char cbuf[sizeof(m_colcnt)];
kent@mysql.com's avatar
kent@mysql.com committed
6364
  char *const cbuf_end= net_store_length((char*) cbuf, (uint) m_colcnt);
knielsen@mysql.com's avatar
knielsen@mysql.com committed
6365
  DBUG_ASSERT(static_cast<my_size_t>(cbuf_end - cbuf) <= sizeof(cbuf));
6366

6367
  return (my_b_safe_write(file, dbuf,      sizeof(dbuf)) ||
6368
          my_b_safe_write(file, (const byte*)m_dbnam,   m_dblen+1) ||
6369
          my_b_safe_write(file, tbuf,      sizeof(tbuf)) ||
6370
          my_b_safe_write(file, (const byte*)m_tblnam,  m_tbllen+1) ||
knielsen@mysql.com's avatar
knielsen@mysql.com committed
6371
          my_b_safe_write(file, reinterpret_cast<byte*>(cbuf),
kent@mysql.com's avatar
Merge  
kent@mysql.com committed
6372
                          cbuf_end - (char*) cbuf) ||
6373
          my_b_safe_write(file, reinterpret_cast<byte*>(m_coltype), m_colcnt));
6374 6375 6376 6377 6378 6379 6380 6381 6382 6383
 }
#endif

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

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

6384
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
6385 6386 6387
void Table_map_log_event::pack_info(Protocol *protocol)
{
    char buf[256];
6388 6389
    my_size_t bytes= my_snprintf(buf, sizeof(buf),
                                 "table_id: %lu (%s.%s)",
6390
                              m_table_id, m_dbnam, m_tblnam);
6391 6392
    protocol->store(buf, bytes, &my_charset_bin);
}
6393 6394
#endif

6395 6396 6397 6398 6399 6400 6401 6402 6403

#endif


#ifdef MYSQL_CLIENT
void Table_map_log_event::print(FILE *file, PRINT_EVENT_INFO *print_event_info)
{
  if (!print_event_info->short_form)
  {
6404 6405 6406 6407 6408
    print_header(&print_event_info->head_cache, print_event_info, TRUE);
    my_b_printf(&print_event_info->head_cache,
                "\tTable_map: `%s`.`%s` mapped to number %lu\n",
                m_dbnam, m_tblnam, m_table_id);
    print_base64(&print_event_info->body_cache, print_event_info, TRUE);
6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462
  }
}
#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;

tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
6463
  table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);  // Needed for ndbcluster
6464
  table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);  // Needed for ndbcluster
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
6465
  table->file->extra(HA_EXTRA_IGNORE_NO_KEY);   // Needed for ndbcluster
6466 6467 6468 6469 6470
  /*
    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.
  */
6471
  table->file->ha_start_bulk_insert(0);
6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493
  /*
    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)
6494
    error= table->file->ha_end_bulk_insert();
6495 6496 6497
  return error;
}

6498 6499
int Write_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO *rli,
                                         TABLE *table,
6500 6501
                                         char const *const row_start,
                                         char const **const row_end)
6502 6503
{
  DBUG_ASSERT(table != NULL);
6504 6505 6506
  DBUG_ASSERT(row_start && row_end);

  int error;
6507 6508
  error= unpack_row(rli, table, m_width, row_start, &m_cols, row_end,
                    &m_master_reclength, table->write_set, WRITE_ROWS_EVENT);
6509
  bitmap_copy(table->read_set, table->write_set);
6510
  return error;
6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555
}

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

}


6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568
/*
  Copy "extra" columns from record[1] to record[0].

  Copy the extra fields that are not present on the master but are
  present on the slave from record[1] to record[0].  This is used
  after fetching a record that are to be updated, either inside
  replace_record() or as part of executing an update_row().
 */
static int
copy_extra_record_fields(TABLE *table,
                         my_size_t master_reclength,
                         my_ptrdiff_t master_fields)
{
6569
  DBUG_PRINT("info", ("Copying to 0x%lx "
6570
                      "from field %lu at offset %lu "
6571 6572
                      "to field %d at offset %lu",
                      (long) table->record[0],
6573
                      (ulong) master_fields, (ulong) master_reclength,
6574
                      table->s->fields, table->s->reclength));
6575 6576 6577 6578 6579
  /*
    Copying the extra fields of the slave that does not exist on
    master into record[0] (which are basically the default values).
  */
  DBUG_ASSERT(master_reclength <= table->s->reclength);
6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624
  if (master_reclength < table->s->reclength)
    bmove_align(table->record[0] + master_reclength,
                table->record[1] + master_reclength,
                table->s->reclength - master_reclength);
    
  /*
    Bit columns are special.  We iterate over all the remaining
    columns and copy the "extra" bits to the new record.  This is
    not a very good solution: it should be refactored on
    opportunity.

    REFACTORING SUGGESTION (Matz).  Introduce a member function
    similar to move_field_offset() called copy_field_offset() to
    copy field values and implement it for all Field subclasses. Use
    this function to copy data from the found record to the record
    that are going to be inserted.

    The copy_field_offset() function need to be a virtual function,
    which in this case will prevent copying an entire range of
    fields efficiently.
  */
  {
    Field **field_ptr= table->field + master_fields;
    for ( ; *field_ptr ; ++field_ptr)
    {
      /*
        Set the null bit according to the values in record[1]
       */
      if ((*field_ptr)->maybe_null() &&
          (*field_ptr)->is_null_in_record(reinterpret_cast<uchar*>(table->record[1])))
        (*field_ptr)->set_null();
      else
        (*field_ptr)->set_notnull();

      /*
        Do the extra work for special columns.
       */
      switch ((*field_ptr)->real_type())
      {
      default:
        /* Nothing to do */
        break;

      case FIELD_TYPE_BIT:
        Field_bit *f= static_cast<Field_bit*>(*field_ptr);
6625 6626 6627 6628 6629 6630 6631
        if (f->bit_len > 0)
        {
          my_ptrdiff_t const offset= table->record[1] - table->record[0];
          uchar const bits=
            get_rec_bits(f->bit_ptr + offset, f->bit_ofs, f->bit_len);
          set_rec_bits(bits, f->bit_ptr, f->bit_ofs, f->bit_len);
        }
6632 6633 6634 6635 6636 6637 6638
        break;
      }
    }
  }
  return 0;                                     // All OK
}

6639 6640 6641
/*
  Replace the provided record in the database.

6642 6643 6644 6645 6646 6647 6648 6649
  SYNOPSIS
      replace_record()
      thd    Thread context for writing the record.
      table  Table to which record should be written.
      master_reclength
             Offset to first column that is not present on the master,
             alternatively the length of the record on the master
             side.
6650

6651 6652
  RETURN VALUE
      Error code on failure, 0 on success.
6653

6654 6655 6656 6657
  DESCRIPTION
      Similar to how it is done in mysql_insert(), we first try to do
      a ha_write_row() and of that fails due to duplicated keys (or
      indices), we do an ha_update_row() or a ha_delete_row() instead.
6658 6659
 */
static int
6660 6661 6662
replace_record(THD *thd, TABLE *table,
               ulong const master_reclength,
               uint const master_fields)
6663
{
6664
  DBUG_ENTER("replace_record");
6665 6666 6667 6668 6669 6670 6671 6672
  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])))
  {
6673 6674 6675 6676 6677
    if (error == HA_ERR_LOCK_DEADLOCK || error == HA_ERR_LOCK_WAIT_TIMEOUT)
    {
      table->file->print_error(error, MYF(0)); /* to check at exec_relay_log_event */
      DBUG_RETURN(error);
    }
6678 6679 6680
    if ((keynum= table->file->get_dup_key(error)) < 0)
    {
      /* We failed to retrieve the duplicate key */
6681
      DBUG_RETURN(HA_ERR_FOUND_DUPP_KEY);
6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693
    }

    /*
       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.
     */
6694
    if (table->file->ha_table_flags() & HA_DUPLICATE_POS)
6695
    {
6696
      error= table->file->rnd_pos(table->record[1], table->file->dup_ref);
6697
      if (error)
6698
        DBUG_RETURN(error);
6699 6700 6701 6702 6703
    }
    else
    {
      if (table->file->extra(HA_EXTRA_FLUSH_CACHE))
      {
6704
        DBUG_RETURN(my_errno);
6705 6706 6707 6708 6709 6710
      }

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

6714 6715 6716
      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(),
6717 6718 6719
                                         table->key_info[keynum].key_length,
                                         HA_READ_KEY_EXACT);
      if (error)
6720
        DBUG_RETURN(error);
6721 6722 6723 6724 6725 6726 6727
    }

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

6728 6729 6730
       First we copy the columns into table->record[0] that are not
       present on the master from table->record[1], if there are any.
    */
6731
    copy_extra_record_fields(table, master_reclength, master_fields);
6732

6733
    /*
6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752
       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]);
6753
      DBUG_RETURN(error);
6754 6755 6756 6757
    }
    else
    {
      if ((error= table->file->ha_delete_row(table->record[1])))
6758
        DBUG_RETURN(error);
6759 6760 6761
      /* Will retry ha_write_row() with the offending row removed. */
    }
  }
6762
  DBUG_RETURN(error);
6763 6764 6765 6766 6767
}

int Write_rows_log_event::do_exec_row(TABLE *table)
{
  DBUG_ASSERT(table != NULL);
6768
  int error= replace_record(thd, table, m_master_reclength, m_width);
6769 6770 6771 6772 6773 6774 6775
  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)
{
6776
  Rows_log_event::print_helper(file, print_event_info, "Write_rows");
6777 6778 6779 6780 6781 6782 6783 6784
}
#endif

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

#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
6785 6786 6787 6788 6789 6790
/*
  Compares table->record[0] and table->record[1]

  Returns TRUE if different.
*/
static bool record_compare(TABLE *table)
6791
{
6792 6793 6794 6795 6796 6797 6798 6799 6800
  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++)
6801
  {
6802 6803
    if ((*ptr)->cmp_binary_offset(table->s->rec_buff_length))
      return TRUE;
6804
  }
6805
  return FALSE;
6806 6807 6808 6809 6810
}


/*
  Find the row given by 'key', if the table has keys, or else use a table scan
6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830
  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.

  @param table Pointer to table to search
  @param key   Pointer to key to use for search, if table has key

  @pre <code>table->record[0]</code> shall contain the row to locate
  and <code>key</code> shall contain a key to use for searching, if
  the engine has a key.

  @post If the return value is zero, <code>table->record[1]</code>
  will contain the fetched row and the internal "cursor" will refer to
  the row. If the return value is non-zero,
  <code>table->record[1]</code> is undefined.  In either case,
  <code>table->record[0]</code> is undefined.

  @return Zero if the row was successfully fetched into
  <code>table->record[1]</code>, error code otherwise.
6831
 */
6832

6833
static int find_and_fetch_row(TABLE *table, byte *key)
6834 6835
{
  DBUG_ENTER("find_and_fetch_row(TABLE *table, byte *key, byte *record)");
6836 6837
  DBUG_PRINT("enter", ("table: 0x%lx, key: 0x%lx  record: 0x%lx",
		       (long) table, (long) key, (long) table->record[1]));
6838 6839 6840

  DBUG_ASSERT(table->in_use != NULL);

6841 6842
  if ((table->file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_POSITION) &&
      table->s->primary_key < MAX_KEY)
6843 6844 6845 6846 6847 6848
  {
    /*
      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
6849
      the "cursor" (i.e., record[0] in this case) at the correct row.
6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860

      TODO: Add a check that the correct record has been fetched by
      comparing with the original record. Take into account that the
      record on the master and slave can be of different
      length. Something along these lines should work:

      ADD>>>  store_record(table,record[1]);
              int error= table->file->rnd_pos(table->record[0], table->file->ref);
      ADD>>>  DBUG_ASSERT(memcmp(table->record[1], table->record[0],
                                 table->s->reclength) == 0);

6861 6862
    */
    table->file->position(table->record[0]);
6863 6864 6865 6866 6867 6868 6869
    int error= table->file->rnd_pos(table->record[0], table->file->ref);
    /*
      rnd_pos() returns the record in table->record[0], so we have to
      move it to table->record[1].
     */
    bmove_align(table->record[1], table->record[0], table->s->reclength);
    DBUG_RETURN(error);
6870 6871
  }

tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
6872
  /* We need to retrieve all fields */
6873 6874
  /* TODO: Move this out from this function to main loop */
  table->use_all_columns();
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
6875

6876 6877 6878
  if (table->s->keys > 0)
  {
    int error;
6879
    /* We have a key: search the table using the index */
6880
    if (!table->file->inited && (error= table->file->ha_index_init(0, FALSE)))
6881
      DBUG_RETURN(error);
6882

6883 6884 6885 6886 6887
  /*
    Don't print debug messages when running valgrind since they can
    trigger false warnings.
   */
#ifndef HAVE_purify
6888 6889
    DBUG_DUMP("table->record[0]", (char *)table->record[0], table->s->reclength);
    DBUG_DUMP("table->record[1]", (char *)table->record[1], table->s->reclength);
6890 6891
#endif

6892 6893 6894 6895 6896 6897
    /*
      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.
    */
6898 6899 6900
    my_ptrdiff_t const pos=
      table->s->null_bytes > 0 ? table->s->null_bytes - 1 : 0;
    table->record[1][pos]= 0xFF;
6901 6902 6903
    if ((error= table->file->index_read(table->record[1], key,
                                        table->key_info->key_length,
                                        HA_READ_KEY_EXACT)))
6904 6905
    {
      table->file->print_error(error, MYF(0));
6906
      table->file->ha_index_end();
6907 6908 6909
      DBUG_RETURN(error);
    }

6910 6911 6912 6913 6914
  /*
    Don't print debug messages when running valgrind since they can
    trigger false warnings.
   */
#ifndef HAVE_purify
6915 6916
    DBUG_DUMP("table->record[0]", (char *)table->record[0], table->s->reclength);
    DBUG_DUMP("table->record[1]", (char *)table->record[1], table->s->reclength);
6917
#endif
6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930
    /*
      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.
6931
    */
6932
    if (table->key_info->flags & HA_NOSAME)
6933 6934
    {
      table->file->ha_index_end();
6935
      DBUG_RETURN(0);
6936
    }
6937

6938
    while (record_compare(table))
6939 6940
    {
      int error;
6941 6942 6943 6944 6945 6946
      /*
        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.
      */
6947 6948 6949
      my_ptrdiff_t const pos=
        table->s->null_bytes > 0 ? table->s->null_bytes - 1 : 0;
      table->record[1][pos]= 0xFF;
6950
      if ((error= table->file->index_next(table->record[1])))
6951 6952
      {
	table->file->print_error(error, MYF(0));
6953
        table->file->ha_index_end();
6954 6955 6956
	DBUG_RETURN(error);
      }
    }
6957 6958 6959 6960 6961

    /*
      Have to restart the scan to be able to fetch the next row.
    */
    table->file->ha_index_end();
6962 6963 6964 6965
  }
  else
  {
    int restart_count= 0; // Number of times scanning has restarted from top
6966 6967 6968 6969 6970 6971 6972
    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 */
6973 6974
    do
    {
6975 6976 6977 6978 6979 6980
      /*
        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.
      */
6981 6982 6983
      my_ptrdiff_t const pos=
        table->s->null_bytes > 0 ? table->s->null_bytes - 1 : 0;
      table->record[1][pos]= 0xFF;
6984
      error= table->file->rnd_next(table->record[1]);
6985

6986 6987 6988 6989 6990 6991 6992 6993 6994 6995 6996 6997 6998
      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));
6999
        table->file->ha_rnd_end();
7000 7001 7002
	DBUG_RETURN(error);
      }
    }
7003
    while (restart_count < 2 && record_compare(table));
7004

7005 7006 7007 7008 7009
    /*
      Have to restart the scan to be able to fetch the next row.
    */
    table->file->ha_rnd_end();

7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027
    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
7028
  ,m_memory(NULL), m_key(NULL), m_after_image(NULL)
7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044
#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),
7045
    m_memory(NULL), m_key(NULL), m_after_image(NULL)
7046 7047 7048 7049 7050 7051 7052 7053 7054 7055
#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);

7056
  if ((table->file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_POSITION) &&
7057 7058 7059
      table->s->primary_key < MAX_KEY)
  {
    /*
7060
      We don't need to allocate any memory for m_after_image and
7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071
      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),
7072
		      &m_after_image, table->s->reclength,
7073 7074 7075 7076 7077
		      &m_key, table->key_info->key_length,
		      NULL);
  }
  else
  {
7078 7079
    m_after_image= (byte*)my_malloc(table->s->reclength, MYF(MY_WME));
    m_memory= (gptr)m_after_image;
7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092
    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
7093
  m_memory= NULL;
7094
  m_after_image= NULL;
7095
  m_key= NULL;
7096 7097 7098 7099

  return error;
}

7100 7101
int Delete_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO *rli,
                                          TABLE *table,
7102 7103
                                          char const *const row_start,
                                          char const **const row_end)
7104
{
7105 7106
  int error;
  DBUG_ASSERT(row_start && row_end);
7107 7108 7109 7110 7111 7112
  /*
    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);

7113 7114
  error= unpack_row(rli, table, m_width, row_start, &m_cols, row_end,
                    &m_master_reclength, table->read_set, DELETE_ROWS_EVENT);
7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125
  /*
    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);
  }

7126
  return error;
7127 7128 7129 7130
}

int Delete_rows_log_event::do_exec_row(TABLE *table)
{
7131
  int error;
7132 7133
  DBUG_ASSERT(table != NULL);

7134 7135 7136 7137 7138 7139 7140 7141
  if (!(error= find_and_fetch_row(table, m_key)))
  { 
    /*
      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]);
7142
  }
7143 7144 7145 7146 7147 7148 7149 7150 7151
  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)
{
7152
  Rows_log_event::print_helper(file, print_event_info, "Delete_rows");
7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204
}
#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),
7205
		      &m_after_image, table->s->reclength,
7206 7207 7208 7209 7210
		      &m_key, table->key_info->key_length,
		      NULL);
  }
  else
  {
7211 7212
    m_after_image= (byte*)my_malloc(table->s->reclength, MYF(MY_WME));
    m_memory= (gptr)m_after_image;
7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227
    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));
7228
  m_memory= NULL;
7229
  m_after_image= NULL;
7230
  m_key= NULL;
7231 7232 7233 7234

  return error;
}

7235 7236
int Update_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO *rli,
                                          TABLE *table,
7237 7238
                                          char const *const row_start,
                                          char const **const row_end)
7239
{
7240 7241
  int error;
  DBUG_ASSERT(row_start && row_end);
7242 7243 7244 7245 7246 7247
  /*
    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);

7248 7249 7250 7251 7252 7253
  /*
    We need to perform some juggling below since unpack_row() always
    unpacks into table->record[0]. For more information, see the
    comments for unpack_row().
  */

7254
  /* record[0] is the before image for the update */
7255 7256 7257
  error= unpack_row(rli, table, m_width, row_start, &m_cols, row_end,
                    &m_master_reclength, table->read_set, UPDATE_ROWS_EVENT);
  store_record(table, record[1]);
7258
  char const *next_start = *row_end;
7259
  /* m_after_image is the after image for the update */
7260 7261 7262 7263
  error= unpack_row(rli, table, m_width, next_start, &m_cols, row_end,
                    &m_master_reclength, table->write_set, UPDATE_ROWS_EVENT);
  bmove_align(m_after_image, table->record[0], table->s->reclength);
  restore_record(table, record[1]);
7264

7265 7266 7267 7268 7269
  /*
    Don't print debug messages when running valgrind since they can
    trigger false warnings.
   */
#ifndef HAVE_purify
7270 7271
  DBUG_DUMP("record[0]", (const char *)table->record[0], table->s->reclength);
  DBUG_DUMP("m_after_image", (const char *)m_after_image, table->s->reclength);
7272
#endif
7273

7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284
  /*
    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);
  }

7285
  return error;
7286 7287 7288 7289 7290 7291
}

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

7292
  int error= find_and_fetch_row(table, m_key);
7293 7294 7295
  if (error)
    return error;

7296
  /*
7297 7298 7299 7300 7301 7302
    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
7303 7304 7305 7306 7307
    record) in record[1], we can keep it there. We put the new record
    (i.e., the after image) into record[0], and copy the fields that
    are on the slave (i.e., in record[1]) into record[0], effectively
    overwriting the default values that where put there by the
    unpack_row() function.
7308
  */
7309
  bmove_align(table->record[0], m_after_image, table->s->reclength);
7310
  copy_extra_record_fields(table, m_master_reclength, m_width);
7311

7312
  /*
7313 7314 7315 7316
    Now we have the right row to update.  The old row (the one we're
    looking for) is in record[1] and the new row has is in record[0].
    We also have copied the original values already in the slave's
    database into the after image delivered from the master.
7317
  */
7318
  error= table->file->ha_update_row(table->record[1], table->record[0]);
7319 7320 7321 7322 7323 7324 7325 7326 7327

  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)
{
7328
  Rows_log_event::print_helper(file, print_event_info, "Update_rows");
7329 7330 7331
}
#endif