log_event.cc 59.5 KB
Newer Older
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
   
   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.
   
   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.
   
   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
#ifdef __GNUC__
#pragma implementation				// gcc: Class implementation
#endif
#include  "mysql_priv.h"
23
#include "slave.h"
24
#include <my_dir.h>
bk@work.mysql.com's avatar
bk@work.mysql.com committed
25 26
#endif /* MYSQL_CLIENT */

27 28
#include <assert.h>

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
29 30 31 32 33
inline int my_b_safe_write(IO_CACHE* file, const byte *buf,
			   int len)
{
  /*
    Sasha: We are not writing this with the ? operator to avoid hitting
34 35 36
    a possible compiler bug. At least gcc 2.95 cannot deal with 
    several layers of ternary operators that evaluated comma(,) operator
    expressions inside - I do have a test case if somebody wants it
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
37
  */
38
  if (file->type == SEQ_READ_APPEND)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
39 40 41
    return my_b_append(file, buf,len);
  return my_b_write(file, buf,len);
}
42

43
#ifdef MYSQL_CLIENT
44
static void pretty_print_str(FILE* file, char* str, int len)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
45
{
46
  char* end = str + len;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
47
  fputc('\'', file);
48 49
  while (str < end)
  {
50
    char c;
51 52 53 54 55 56 57 58 59 60 61 62
    switch ((c=*str++)) {
    case '\n': fprintf(file, "\\n"); break;
    case '\r': fprintf(file, "\\r"); break;
    case '\\': fprintf(file, "\\\\"); break;
    case '\b': fprintf(file, "\\b"); break;
    case '\t': fprintf(file, "\\t"); break;
    case '\'': fprintf(file, "\\'"); break;
    case 0   : fprintf(file, "\\0"); break;
    default:
      fputc(c, file);
      break;
    }
63 64
  }
  fputc('\'', file);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
65
}
66
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
67

68 69
#ifndef MYSQL_CLIENT

70 71 72 73 74
inline int ignored_error_code(int err_code)
{
  return use_slave_mask && bitmap_is_set(&slave_error_mask, err_code);
}

75

76
static void pretty_print_str(String* packet, char* str, int len)
77
{
78
  char* end = str + len;
79
  packet->append('\'');
80 81 82
  while (str < end)
  {
    char c;
83
    switch ((c=*str++)) {
84 85 86 87 88 89 90 91 92 93 94
    case '\n': packet->append( "\\n"); break;
    case '\r': packet->append( "\\r"); break;
    case '\\': packet->append( "\\\\"); break;
    case '\b': packet->append( "\\b"); break;
    case '\t': packet->append( "\\t"); break;
    case '\'': packet->append( "\\'"); break;
    case 0   : packet->append( "\\0"); break;
    default:
      packet->append((char)c);
      break;
    }
95 96 97 98
  }
  packet->append('\'');
}

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
99

100 101 102
static inline char* slave_load_file_stem(char*buf, uint file_id,
					 int event_server_id)
{
103
  fn_format(buf,"SQL_LOAD-",slave_load_tmpdir,"",0); /* 4+32); */
104 105 106 107 108 109 110 111
  buf = strend(buf);
  buf = int10_to_str(::server_id, buf, 10);
  *buf++ = '-';
  buf = int10_to_str(event_server_id, buf, 10);
  *buf++ = '-';
  return int10_to_str(file_id, buf, 10);
}

112 113 114 115
#endif

const char* Log_event::get_type_str()
{
116
  switch(get_type_code()) {
117 118 119 120 121 122
  case START_EVENT:  return "Start";
  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";
123
  case NEW_LOAD_EVENT:   return "New_load";
124
  case SLAVE_EVENT:  return "Slave";
125 126 127 128
  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";
129 130 131 132 133
  default: /* impossible */ return "Unknown";
  }
}

#ifndef MYSQL_CLIENT
134 135 136
Log_event::Log_event(THD* thd_arg, uint16 flags_arg, bool using_trans)
  :temp_buf(0), exec_time(0), cached_event_len(0), flags(flags_arg), 
   thd(thd_arg)
137
{
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
  server_id = thd->server_id;
  when = thd->start_time;
  log_pos = thd->log_pos;
  cache_stmt= (using_trans &&
	       (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)));
}


Log_event::Log_event()
  :temp_buf(0), exec_time(0), cached_event_len(0), flags(0), cache_stmt(0),
   thd(0)
{
  server_id = ::server_id;
  when = time(NULL);
  log_pos=0;
153
}
154

155 156 157 158 159 160 161 162
/*
  Delete all temporary files used for SQL_LOAD.

  TODO
  - When we get a 'server start' event, we should only remove
    the files associated with the server id that just started.
    Easily fixable by adding server_id as a prefix to the log files.
*/
163

164 165 166 167 168 169 170 171
static void cleanup_load_tmpdir()
{
  MY_DIR *dirp;
  FILEINFO *file;
  uint i;
  if (!(dirp=my_dir(slave_load_tmpdir,MYF(MY_WME))))
    return;

172
  for (i=0 ; i < (uint)dirp->number_off_files; i++)
173 174
  {
    file=dirp->dir_entry+i;
175
    if (is_prefix(file->name,"SQL_LOAD-"))
176
      my_delete(file->name, MYF(0));
177 178 179 180 181
  }

  my_dirend(dirp);
}

182 183
#endif

184
Log_event::Log_event(const char* buf, bool old_format)
185
  :temp_buf(0), cached_event_len(0), cache_stmt(0)
186 187 188
{
  when = uint4korr(buf);
  server_id = uint4korr(buf + SERVER_ID_OFFSET);
189 190
  if (old_format)
  {
191
    log_pos=0;
192 193 194 195
    flags=0;
  }
  else
  {
196
    log_pos = uint4korr(buf + LOG_POS_OFFSET);
197 198
    flags = uint2korr(buf + FLAGS_OFFSET);
  }
199 200 201 202 203 204 205 206
#ifndef MYSQL_CLIENT
  thd = 0;
#endif  
}


#ifndef MYSQL_CLIENT

207
int Log_event::exec_event(struct st_relay_log_info* rli)
208
{
209 210 211 212 213 214 215 216 217 218 219 220 221
  /*
    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.
  */
  if (rli)  
222
  {
223 224 225 226 227 228 229
    if (rli->inside_transaction)
      rli->inc_pending(get_event_len());
    else
    {
      rli->inc_pos(get_event_len(),log_pos);
      flush_relay_log_info(rli);
    }
230 231 232
  }
  return 0;
}
233 234 235 236 237 238 239 240

void Log_event::pack_info(String* packet)
{
  net_store_data(packet, "", 0);
}

void Query_log_event::pack_info(String* packet)
{
241 242 243
  char buf[256];
  String tmp(buf, sizeof(buf));
  tmp.length(0);
244
  if (db && db_len)
245 246 247 248 249 250
  {
   tmp.append("use ");
   tmp.append(db, db_len);
   tmp.append("; ", 2);
  }

251
  if (query && q_len)
252 253 254 255 256 257
    tmp.append(query, q_len);
  net_store_data(packet, (char*)tmp.ptr(), tmp.length());
}

void Start_log_event::pack_info(String* packet)
{
258 259 260
  char buf1[256];
  String tmp(buf1, sizeof(buf1));
  tmp.length(0);
261 262 263 264 265 266 267 268 269 270 271
  char buf[22];

  tmp.append("Server ver: ");
  tmp.append(server_version);
  tmp.append(", Binlog ver: ");
  tmp.append(llstr(binlog_version, buf));
  net_store_data(packet, tmp.ptr(), tmp.length());
}

void Load_log_event::pack_info(String* packet)
{
272 273 274
  char buf[256];
  String tmp(buf, sizeof(buf));
  tmp.length(0);
275
  if (db && db_len)
276 277 278 279 280 281 282
  {
   tmp.append("use ");
   tmp.append(db, db_len);
   tmp.append("; ", 2);
  }

  tmp.append("LOAD DATA INFILE '");
283
  tmp.append(fname, fname_len);
284
  tmp.append("' ", 2);
285
  if (sql_ex.opt_flags & REPLACE_FLAG)
286
    tmp.append(" REPLACE ");
287
  else if (sql_ex.opt_flags & IGNORE_FLAG)
288 289 290 291
    tmp.append(" IGNORE ");
  
  tmp.append("INTO TABLE ");
  tmp.append(table_name);
292
  if (sql_ex.field_term_len)
293 294
  {
    tmp.append(" FIELDS TERMINATED BY ");
295
    pretty_print_str(&tmp, sql_ex.field_term, sql_ex.field_term_len);
296 297
  }

298
  if (sql_ex.enclosed_len)
299
  {
300
    if (sql_ex.opt_flags & OPT_ENCLOSED_FLAG )
301 302
      tmp.append(" OPTIONALLY ");
    tmp.append( " ENCLOSED BY ");
303
    pretty_print_str(&tmp, sql_ex.enclosed, sql_ex.enclosed_len);
304 305
  }
     
306
  if (sql_ex.escaped_len)
307 308
  {
    tmp.append( " ESCAPED BY ");
309
    pretty_print_str(&tmp, sql_ex.escaped, sql_ex.escaped_len);
310 311
  }
     
312
  if (sql_ex.line_term_len)
313 314
  {
    tmp.append(" LINES TERMINATED BY ");
315
    pretty_print_str(&tmp, sql_ex.line_term, sql_ex.line_term_len);
316 317
  }

318
  if (sql_ex.line_start_len)
319 320
  {
    tmp.append(" LINES STARTING BY ");
321
    pretty_print_str(&tmp, sql_ex.line_start, sql_ex.line_start_len);
322 323 324 325 326 327 328 329 330 331
  }
     
  if ((int)skip_lines > 0)
    tmp.append( " IGNORE %ld LINES ", (long) skip_lines);

  if (num_fields)
  {
    uint i;
    const char* field = fields;
    tmp.append(" (");
332
    for (i = 0; i < num_fields; i++)
333
    {
334
      if (i)
335 336 337 338 339 340 341 342 343 344 345 346 347
	tmp.append(" ,");
      tmp.append( field);
	  
      field += field_lens[i]  + 1;
    }
    tmp.append(')');
  }

  net_store_data(packet, tmp.ptr(), tmp.length());
}

void Rotate_log_event::pack_info(String* packet)
{
348
  char buf1[256], buf[22];
349 350
  String tmp(buf1, sizeof(buf1));
  tmp.length(0);
351
  tmp.append(new_log_ident, ident_len);
352 353
  tmp.append(";pos=");
  tmp.append(llstr(pos,buf));
354
  if (flags & LOG_EVENT_FORCED_ROTATE_F)
355 356
    tmp.append("; forced by master");
  net_store_data(packet, tmp.ptr(), tmp.length());
357 358 359 360
}

void Intvar_log_event::pack_info(String* packet)
{
361
  char buf1[256], buf[22];
362 363
  String tmp(buf1, sizeof(buf1));
  tmp.length(0);
364 365 366 367 368 369
  tmp.append(get_var_type_name());
  tmp.append('=');
  tmp.append(llstr(val, buf));
  net_store_data(packet, tmp.ptr(), tmp.length());
}

nick@mysql.com's avatar
nick@mysql.com committed
370 371
void Rand_log_event::pack_info(String* packet)
{
372 373 374 375 376 377
  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);
  net_store_data(packet, buf1, (uint) (pos-buf1));
nick@mysql.com's avatar
nick@mysql.com committed
378 379
}

380 381
void Slave_log_event::pack_info(String* packet)
{
382
  char buf1[256], buf[22], *end;
383 384
  String tmp(buf1, sizeof(buf1));
  tmp.length(0);
385 386 387
  tmp.append("host=");
  tmp.append(master_host);
  tmp.append(",port=");
388 389
  end= int10_to_str((long) master_port, buf, 10);
  tmp.append(buf, (uint32) (end-buf));
390 391 392 393 394
  tmp.append(",log=");
  tmp.append(master_log);
  tmp.append(",pos=");
  tmp.append(llstr(master_pos,buf));
  net_store_data(packet, tmp.ptr(), tmp.length());
395 396 397 398 399 400 401 402 403
}


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_empty_string("Pos", 20));
  field_list->push_back(new Item_empty_string("Event_type", 20));
  field_list->push_back(new Item_empty_string("Server_id", 20));
404
  field_list->push_back(new Item_empty_string("Orig_log_pos", 20));
405 406 407
  field_list->push_back(new Item_empty_string("Info", 20));
}

nick@mysql.com's avatar
nick@mysql.com committed
408 409 410
/*
 * only called by SHOW BINLOG EVENTS
 */
411
int Log_event::net_send(THD* thd_arg, const char* log_name, my_off_t pos)
412
{
413
  String* packet = &thd_arg->packet;
414 415 416 417 418 419 420
  const char* p = strrchr(log_name, FN_LIBCHAR);
  const char* event_type;
  if (p)
    log_name = p + 1;
  
  packet->length(0);
  net_store_data(packet, log_name, strlen(log_name));
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
421
  net_store_data(packet, (longlong) pos);
422 423 424
  event_type = get_type_str();
  net_store_data(packet, event_type, strlen(event_type));
  net_store_data(packet, server_id);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
425
  net_store_data(packet, (longlong) log_pos);
426
  pack_info(packet);
427
  return my_net_write(&thd_arg->net, (char*) packet->ptr(), packet->length());
428 429
}

430 431
#endif /* MYSQL_CLIENT */

432

433
int Query_log_event::write(IO_CACHE* file)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
434 435 436 437
{
  return query ? Log_event::write(file) : -1; 
}

438

439
int Log_event::write(IO_CACHE* file)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
440
{
441
  return (write_header(file) || write_data(file)) ? -1 : 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
442 443
}

444

445
int Log_event::write_header(IO_CACHE* file)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
446
{
447
  char buf[LOG_EVENT_HEADER_LEN];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
448
  char* pos = buf;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
449
  int4store(pos, (ulong) when); // timestamp
bk@work.mysql.com's avatar
bk@work.mysql.com committed
450 451
  pos += 4;
  *pos++ = get_type_code(); // event type code
452 453
  int4store(pos, server_id);
  pos += 4;
454 455
  long tmp=get_data_size() + LOG_EVENT_HEADER_LEN;
  int4store(pos, tmp);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
456
  pos += 4;
457
  int4store(pos, log_pos);
458 459 460
  pos += 4;
  int2store(pos, flags);
  pos += 2;
461
  return (my_b_safe_write(file, (byte*) buf, (uint) (pos - buf)));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
462 463 464 465
}

#ifndef MYSQL_CLIENT

466
int Log_event::read_log_event(IO_CACHE* file, String* packet,
467
			      pthread_mutex_t* log_lock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
468 469
{
  ulong data_len;
470
  int result=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
471
  char buf[LOG_EVENT_HEADER_LEN];
472
  DBUG_ENTER("read_log_event");
473

474
  if (log_lock)
475
    pthread_mutex_lock(log_lock);
476 477
  if (my_b_read(file, (byte*) buf, sizeof(buf)))
  {
478 479 480 481 482
    /*
      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.
    */
483
    DBUG_PRINT("error",("file->error: %d", file->error));
484 485 486
    if (!file->error)
      result= LOG_READ_EOF;
    else
487
      result= (file->error > 0 ? LOG_READ_TRUNC : LOG_READ_IO);
488
    goto end;
489
  }
490
  data_len= uint4korr(buf + EVENT_LEN_OFFSET);
491 492
  if (data_len < LOG_EVENT_HEADER_LEN ||
      data_len > current_thd->variables.max_allowed_packet)
493
  {
494
    DBUG_PRINT("error",("data_len: %ld", data_len));
495 496 497
    result= ((data_len < LOG_EVENT_HEADER_LEN) ? LOG_READ_BOGUS :
	     LOG_READ_TOO_LARGE);
    goto end;
498
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
499
  packet->append(buf, sizeof(buf));
500
  data_len-= LOG_EVENT_HEADER_LEN;
501 502 503
  if (data_len)
  {
    if (packet->append(file, data_len))
504
    {
505
      /*
506 507
	Here we should never hit EOF in a non-error condition.
	EOF means we are reading the event partially, which should
508 509 510 511
	never happen.
      */
      result= file->error >= 0 ? LOG_READ_TRUNC: LOG_READ_IO;
      /* Implicit goto end; */
512
    }
513
  }
514 515 516 517

end:
  if (log_lock)
    pthread_mutex_unlock(log_lock);
518
  DBUG_RETURN(result);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
519 520 521 522
}

#endif // MYSQL_CLIENT

523
#ifndef MYSQL_CLIENT
524 525
#define UNLOCK_MUTEX if (log_lock) pthread_mutex_unlock(log_lock);
#define LOCK_MUTEX if (log_lock) pthread_mutex_lock(log_lock);
526
#define max_allowed_packet current_thd->variables.max_allowed_packet
527
#else
528
#define UNLOCK_MUTEX
529 530 531
#define LOCK_MUTEX
#endif

532 533
// allocates memory - the caller is responsible for clean-up
#ifndef MYSQL_CLIENT
534 535 536
Log_event* Log_event::read_log_event(IO_CACHE* file,
				     pthread_mutex_t* log_lock,
				     bool old_format)
537
#else
538
Log_event* Log_event::read_log_event(IO_CACHE* file, bool old_format)
539
#endif  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
540
{
541
  char head[LOG_EVENT_HEADER_LEN];
542 543
  uint header_size= old_format ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;

544
  LOCK_MUTEX;
545
  if (my_b_read(file, (byte *) head, header_size))
546
  {
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
547
    UNLOCK_MUTEX;
548
    return 0;
549
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
550

551
  uint data_len = uint4korr(head + EVENT_LEN_OFFSET);
552 553 554
  char *buf= 0;
  const char *error= 0;
  Log_event *res=  0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
555

556
  if (data_len > max_allowed_packet)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
557
  {
558 559
    error = "Event too big";
    goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
560 561
  }

562
  if (data_len < header_size)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
563
  {
564 565
    error = "Event too small";
    goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
566
  }
567 568 569

  // some events use the extra byte to null-terminate strings
  if (!(buf = my_malloc(data_len+1, MYF(MY_WME))))
570 571 572
  {
    error = "Out of memory";
    goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
573
  }
574
  buf[data_len] = 0;
575
  memcpy(buf, head, header_size);
576
  if (my_b_read(file, (byte*) buf + header_size, data_len - header_size))
577 578 579 580
  {
    error = "read error";
    goto err;
  }
581
  if ((res = read_log_event(buf, data_len, &error, old_format)))
582
    res->register_temp_buf(buf);
583

584
err:
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
585
  UNLOCK_MUTEX;
586
  if (error)
587
  {
588 589
    sql_print_error("Error in Log_event::read_log_event(): '%s', \
data_len=%d,event_type=%d",error,data_len,head[EVENT_TYPE_OFFSET]);
590
    my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
591 592 593 594 595 596 597 598 599
    /*
      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;
600
  }
601
  return res;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
602 603
}

604

605
Log_event* Log_event::read_log_event(const char* buf, int event_len,
606
				     const char **error, bool old_format)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
607
{
608
  if (event_len < EVENT_LEN_OFFSET ||
609 610 611
      (uint) event_len != uint4korr(buf+EVENT_LEN_OFFSET))
  {
    *error="Sanity check failed";		// Needed to free buffer
612
    return NULL; // general sanity check - will fail on a partial read
613
  }
614
  
615 616
  Log_event* ev = NULL;
  
617
  switch(buf[EVENT_TYPE_OFFSET]) {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
618
  case QUERY_EVENT:
619
    ev  = new Query_log_event(buf, event_len, old_format);
620
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
621
  case LOAD_EVENT:
622 623
    ev = new Create_file_log_event(buf, event_len, old_format);
    break;
624
  case NEW_LOAD_EVENT:
625
    ev = new Load_log_event(buf, event_len, old_format);
626
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
627
  case ROTATE_EVENT:
628
    ev = new Rotate_log_event(buf, event_len, old_format);
629
    break;
630
  case SLAVE_EVENT:
631 632 633
    ev = new Slave_log_event(buf, event_len);
    break;
  case CREATE_FILE_EVENT:
634
    ev = new Create_file_log_event(buf, event_len, old_format);
635 636 637 638 639 640 641 642 643 644 645
    break;
  case APPEND_BLOCK_EVENT:
    ev = new Append_block_log_event(buf, event_len);
    break;
  case DELETE_FILE_EVENT:
    ev = new Delete_file_log_event(buf, event_len);
    break;
  case EXEC_LOAD_EVENT:
    ev = new Execute_load_log_event(buf, event_len);
    break;
  case START_EVENT:
646
    ev = new Start_log_event(buf, old_format);
647 648
    break;
  case STOP_EVENT:
649
    ev = new Stop_log_event(buf, old_format);
650 651
    break;
  case INTVAR_EVENT:
652
    ev = new Intvar_log_event(buf, old_format);
653
    break;
nick@mysql.com's avatar
nick@mysql.com committed
654 655 656
  case RAND_EVENT:
    ev = new Rand_log_event(buf, old_format);
    break;
657 658
  default:
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
659
  }
660
  if (!ev || !ev->is_valid())
661
  {
662
    *error= "Found invalid event in binary log";
663 664 665 666 667
    delete ev;
    return 0;
  }
  ev->cached_event_len = event_len;
  return ev;  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
668 669
}

670

671
#ifdef MYSQL_CLIENT
672 673
void Log_event::print_header(FILE* file)
{
674
  char llbuff[22];
675 676
  fputc('#', file);
  print_timestamp(file);
677
  fprintf(file, " server id %d  log_pos %s ", server_id,
678
	  llstr(log_pos,llbuff)); 
679 680
}

681
void Log_event::print_timestamp(FILE* file, time_t* ts)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
682
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
683
  struct tm *res;
684 685
  if (!ts)
    ts = &when;
686 687
#ifdef MYSQL_SERVER				// This is always false
  struct tm tm_tmp;
monty@work.mysql.com's avatar
monty@work.mysql.com committed
688
  localtime_r(ts,(res= &tm_tmp));
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
689
#else
690
  res=localtime(ts);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
691
#endif
692 693

  fprintf(file,"%02d%02d%02d %2d:%02d:%02d",
694 695 696 697 698 699
	  res->tm_year % 100,
	  res->tm_mon+1,
	  res->tm_mday,
	  res->tm_hour,
	  res->tm_min,
	  res->tm_sec);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
700 701 702
}


703
void Start_log_event::print(FILE* file, bool short_form, char* last_db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
704 705 706 707
{
  if (short_form)
    return;

708 709 710 711 712
  print_header(file);
  fprintf(file, "\tStart: binlog v %d, server v %s created ", binlog_version,
	  server_version);
  print_timestamp(file, (time_t*)&created);
  fputc('\n', file);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
713 714 715
  fflush(file);
}

716
void Stop_log_event::print(FILE* file, bool short_form, char* last_db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
717 718 719 720
{
  if (short_form)
    return;

721
  print_header(file);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
722 723 724 725
  fprintf(file, "\tStop\n");
  fflush(file);
}

726
void Rotate_log_event::print(FILE* file, bool short_form, char* last_db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
727
{
728
  char buf[22];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
729 730 731
  if (short_form)
    return;

732
  print_header(file);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
733 734 735 736
  fprintf(file, "\tRotate to ");
  if (new_log_ident)
    my_fwrite(file, (byte*) new_log_ident, (uint)ident_len, 
	      MYF(MY_NABP | MY_WME));
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
737 738 739 740
  fprintf(file, "  pos: %s", llstr(pos, buf));
  if (flags & LOG_EVENT_FORCED_ROTATE_F)
    fprintf(file,"  forced by master");
  fputc('\n', file);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
741 742 743
  fflush(file);
}

744 745
#endif /* #ifdef MYSQL_CLIENT */

746

747
Start_log_event::Start_log_event(const char* buf,
748 749
				 bool old_format)
  :Log_event(buf, old_format)
750
{
751 752 753
  buf += (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
  binlog_version = uint2korr(buf+ST_BINLOG_VER_OFFSET);
  memcpy(server_version, buf+ST_SERVER_VER_OFFSET,
754
	 ST_SERVER_VER_LEN);
755
  created = uint4korr(buf+ST_CREATED_OFFSET);
756 757
}

758 759
int Start_log_event::write_data(IO_CACHE* file)
{
760 761 762 763
  char buff[START_HEADER_LEN];
  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);
764
  return (my_b_safe_write(file, (byte*) buff, sizeof(buff)) ? -1 : 0);
765 766
}

767

768
Rotate_log_event::Rotate_log_event(const char* buf, int event_len,
769 770
				   bool old_format)
  :Log_event(buf, old_format),new_log_ident(NULL),alloced(0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
771
{
772
  // The caller will ensure that event_len is what we have at EVENT_LEN_OFFSET
773 774
  int header_size = (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
  uint ident_offset;
775
  if (event_len < header_size)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
776
    return;
777 778 779
  buf += header_size;
  if (old_format)
  {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
780
    ident_len = (uint)(event_len - OLD_HEADER_LEN);
781 782 783 784 785
    pos = 4;
    ident_offset = 0;
  }
  else
  {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
786
    ident_len = (uint)(event_len - ROTATE_EVENT_OVERHEAD);
787 788 789
    pos = uint8korr(buf + R_POS_OFFSET);
    ident_offset = ROTATE_HEADER_LEN;
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
790
  set_if_smaller(ident_len,FN_REFLEN-1);
791 792 793 794
  if (!(new_log_ident= my_strdup_with_length((byte*) buf +
					     ident_offset,
					     (uint) ident_len,
					     MYF(MY_WME))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
795 796 797 798
    return;
  alloced = 1;
}

799

800
int Rotate_log_event::write_data(IO_CACHE* file)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
801
{
802 803
  char buf[ROTATE_HEADER_LEN];
  int8store(buf, pos + R_POS_OFFSET);
804 805
  return (my_b_safe_write(file, (byte*)buf, ROTATE_HEADER_LEN) ||
	  my_b_safe_write(file, (byte*)new_log_ident, (uint) ident_len));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
806 807
}

808

809 810
#ifndef MYSQL_CLIENT
Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
811
				 ulong query_length, bool using_trans)
812 813
  :Log_event(thd_arg, 0, using_trans), data_buf(0), query(query_arg),
   db(thd_arg->db), q_len((uint32) query_length),
814
  error_code(thd_arg->killed ? ER_SERVER_SHUTDOWN: thd_arg->net.last_errno),
815
  thread_id(thd_arg->thread_id)
816 817 818 819 820 821
{
  time_t end_time;
  time(&end_time);
  exec_time = (ulong) (end_time  - thd->start_time);
  db_len = (db) ? (uint32) strlen(db) : 0;
}
822 823
#endif

824
Query_log_event::Query_log_event(const char* buf, int event_len,
825 826
				 bool old_format)
  :Log_event(buf, old_format),data_buf(0), query(NULL), db(NULL)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
827 828
{
  ulong data_len;
829 830 831 832 833 834 835 836 837 838 839 840 841 842
  if (old_format)
  {
    if ((uint)event_len < OLD_HEADER_LEN + QUERY_HEADER_LEN)
      return;				
    data_len = event_len - (QUERY_HEADER_LEN + OLD_HEADER_LEN);
    buf += OLD_HEADER_LEN;
  }
  else
  {
    if ((uint)event_len < QUERY_EVENT_OVERHEAD)
      return;				
    data_len = event_len - QUERY_EVENT_OVERHEAD;
    buf += LOG_EVENT_HEADER_LEN;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
843

844 845
  exec_time = uint4korr(buf + Q_EXEC_TIME_OFFSET);
  error_code = uint2korr(buf + Q_ERR_CODE_OFFSET);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
846

847
  if (!(data_buf = (char*) my_malloc(data_len + 1, MYF(MY_WME))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
848 849
    return;

850 851
  memcpy(data_buf, buf + Q_DATA_OFFSET, data_len);
  thread_id = uint4korr(buf + Q_THREAD_ID_OFFSET);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
852
  db = data_buf;
853
  db_len = (uint)buf[Q_DB_LEN_OFFSET];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
854 855 856 857 858
  query=data_buf + db_len + 1;
  q_len = data_len - 1 - db_len;
  *((char*)query+q_len) = 0;
}

859

860 861
#ifdef MYSQL_CLIENT

862
void Query_log_event::print(FILE* file, bool short_form, char* last_db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
863
{
864
  char buff[40],*end;				// Enough for SET TIMESTAMP
bk@work.mysql.com's avatar
bk@work.mysql.com committed
865 866
  if (!short_form)
  {
867
    print_header(file);
868 869
    fprintf(file, "\tQuery\tthread_id=%lu\texec_time=%lu\terror_code=%d\n",
	    (ulong) thread_id, (ulong) exec_time, error_code);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
870 871
  }

872 873
  bool same_db = 0;

874
  if (db && last_db)
875 876 877 878
  {
    if (!(same_db = !memcmp(last_db, db, db_len + 1)))
      memcpy(last_db, db, db_len + 1);
  }
879 880
  
  if (db && db[0] && !same_db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
881
    fprintf(file, "use %s;\n", db);
882 883 884 885
  end=int10_to_str((long) when, strmov(buff,"SET TIMESTAMP="),10);
  *end++=';';
  *end++='\n';
  my_fwrite(file, (byte*) buff, (uint) (end-buff),MYF(MY_NABP | MY_WME));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
886 887 888
  my_fwrite(file, (byte*) query, q_len, MYF(MY_NABP | MY_WME));
  fprintf(file, ";\n");
}
889 890
#endif

891

892
int Query_log_event::write_data(IO_CACHE* file)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
893
{
894 895
  if (!query)
    return -1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
896 897
  
  char buf[QUERY_HEADER_LEN]; 
898 899
  int4store(buf + Q_THREAD_ID_OFFSET, thread_id);
  int4store(buf + Q_EXEC_TIME_OFFSET, exec_time);
900
  buf[Q_DB_LEN_OFFSET] = (char) db_len;
901
  int2store(buf + Q_ERR_CODE_OFFSET, error_code);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
902

903 904 905
  return (my_b_safe_write(file, (byte*) buf, QUERY_HEADER_LEN) ||
	  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
906 907
}

908 909
Intvar_log_event::Intvar_log_event(const char* buf, bool old_format)
  :Log_event(buf, old_format)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
910
{
911
  buf += (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
912 913
  type = buf[I_TYPE_OFFSET];
  val = uint8korr(buf+I_VAL_OFFSET);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
914 915
}

916 917
const char* Intvar_log_event::get_var_type_name()
{
918
  switch(type) {
919 920 921 922 923 924
  case LAST_INSERT_ID_EVENT: return "LAST_INSERT_ID";
  case INSERT_ID_EVENT: return "INSERT_ID";
  default: /* impossible */ return "UNKNOWN";
  }
}

925
int Intvar_log_event::write_data(IO_CACHE* file)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
926 927
{
  char buf[9];
928 929
  buf[I_TYPE_OFFSET] = type;
  int8store(buf + I_VAL_OFFSET, val);
930
  return my_b_safe_write(file, (byte*) buf, sizeof(buf));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
931 932
}

933
#ifdef MYSQL_CLIENT
934
void Intvar_log_event::print(FILE* file, bool short_form, char* last_db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
935 936
{
  char llbuff[22];
937 938 939
  const char *msg;
  LINT_INIT(msg);

940
  if (!short_form)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
941
  {
942
    print_header(file);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
943 944 945 946
    fprintf(file, "\tIntvar\n");
  }

  fprintf(file, "SET ");
947
  switch (type) {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
948
  case LAST_INSERT_ID_EVENT:
949
    msg="LAST_INSERT_ID";
bk@work.mysql.com's avatar
bk@work.mysql.com committed
950 951
    break;
  case INSERT_ID_EVENT:
952
    msg="INSERT_ID";
bk@work.mysql.com's avatar
bk@work.mysql.com committed
953 954
    break;
  }
955
  fprintf(file, "%s=%s;\n", msg, llstr(val,llbuff));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
956 957
  fflush(file);
}
958
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
959

nick@mysql.com's avatar
nick@mysql.com committed
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983
/*****************************************************************************
 *
 *  Rand log event
 *
 ****************************************************************************/
Rand_log_event::Rand_log_event(const char* buf, bool old_format)
  :Log_event(buf, old_format)
{
  buf += (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
  seed1 = uint8korr(buf+RAND_SEED1_OFFSET);
  seed2 = uint8korr(buf+RAND_SEED2_OFFSET);
}

int Rand_log_event::write_data(IO_CACHE* file)
{
  char buf[16];
  int8store(buf + RAND_SEED1_OFFSET, seed1);
  int8store(buf + RAND_SEED2_OFFSET, seed2);
  return my_b_safe_write(file, (byte*) buf, sizeof(buf));
}

#ifdef MYSQL_CLIENT
void Rand_log_event::print(FILE* file, bool short_form, char* last_db)
{
984
  char llbuff[22],llbuff2[22];
nick@mysql.com's avatar
nick@mysql.com committed
985 986 987 988 989
  if (!short_form)
  {
    print_header(file);
    fprintf(file, "\tRand\n");
  }
990
  fprintf(file, "SET @@RAND_SEED1=%s, @@RAND_SEED2=%s;\n",
991
	  llstr(seed1, llbuff),llstr(seed2, llbuff2));
nick@mysql.com's avatar
nick@mysql.com committed
992 993 994
  fflush(file);
}
#endif
995

996
int Load_log_event::write_data_header(IO_CACHE* file)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
997 998
{
  char buf[LOAD_HEADER_LEN];
999 1000 1001 1002 1003 1004
  int4store(buf + L_THREAD_ID_OFFSET, thread_id);
  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);
1005
  return my_b_safe_write(file, (byte*)buf, LOAD_HEADER_LEN);
1006
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1007

1008 1009
int Load_log_event::write_data_body(IO_CACHE* file)
{
1010 1011
  if (sql_ex.write_data(file))
    return 1;
1012 1013
  if (num_fields && fields && field_lens)
  {
1014 1015
    if (my_b_safe_write(file, (byte*)field_lens, num_fields) ||
	my_b_safe_write(file, (byte*)fields, field_block_len))
1016 1017
      return 1;
  }
1018 1019 1020
  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));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1021 1022
}

1023

1024

1025 1026
static bool write_str(IO_CACHE *file, char *str, byte length)
{
1027 1028
  return (my_b_safe_write(file, &length, 1) ||
	  my_b_safe_write(file, (byte*) str, (int) length));
1029
}
1030

1031

1032 1033 1034 1035
int sql_ex_info::write_data(IO_CACHE* file)
{
  if (new_format())
  {
1036 1037 1038 1039 1040
    return (write_str(file, field_term, field_term_len) ||
	    write_str(file, enclosed,   enclosed_len) ||
	    write_str(file, line_term,  line_term_len) ||
	    write_str(file, line_start, line_start_len) ||
	    write_str(file, escaped,    escaped_len) ||
1041
	    my_b_safe_write(file,(byte*) &opt_flags,1));
1042 1043 1044 1045
  }
  else
  {
    old_sql_ex old_ex;
1046 1047 1048 1049 1050 1051 1052
    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;
1053
    return my_b_safe_write(file, (byte*) &old_ex, sizeof(old_ex));
1054 1055 1056
  }
}

1057

1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
static inline int read_str(char * &buf, char *buf_end, char * &str,
			   uint8 &len)
{
  if (buf + (uint) (uchar) *buf >= buf_end)
    return 1;
  len = (uint8) *buf;
  str= buf+1;
  buf+= (uint) len+1;
  return 0;
}
1068

1069

1070 1071 1072 1073 1074
char* sql_ex_info::init(char* buf,char* buf_end,bool use_new_format)
{
  cached_new_format = use_new_format;
  if (use_new_format)
  {
1075
    empty_flags=0;
1076 1077 1078 1079 1080 1081
    /*
      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.
1082
    */
1083 1084 1085 1086 1087 1088
    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))
      return 0;
1089 1090 1091 1092
    opt_flags = *buf++;
  }
  else
  {
1093
    field_term_len= enclosed_len= line_term_len= line_start_len= escaped_len=1;
1094 1095 1096 1097 1098 1099 1100
    field_term = buf++;			// Use first byte in string
    enclosed=	 buf++;
    line_term=   buf++;
    line_start=  buf++;
    escaped=     buf++;
    opt_flags =  *buf++;
    empty_flags= *buf++;
1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
    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;
1111 1112 1113 1114 1115
  }
  return buf;
}


1116
#ifndef MYSQL_CLIENT
1117
Load_log_event::Load_log_event(THD* thd_arg, sql_exchange* ex,
1118
			       const char* db_arg, const char* table_name_arg,
1119
			       List<Item>& fields_arg,
1120 1121
			       enum enum_duplicates handle_dup,
			       bool using_trans)
monty@butch's avatar
merge  
monty@butch committed
1122
  :Log_event(thd_arg, 0, using_trans),thread_id(thd_arg->thread_id),
1123
  num_fields(0),fields(0),
1124 1125
  field_lens(0),field_block_len(0),
  table_name(table_name_arg ? table_name_arg : ""),
1126
  db(db_arg), fname(ex->file_name)
1127 1128 1129
{
  time_t end_time;
  time(&end_time);
1130
  exec_time = (ulong) (end_time  - thd_arg->start_time);
1131 1132 1133
  /* db can never be a zero pointer in 4.0 */
  db_len = (uint32) strlen(db);
  table_name_len = (uint32) strlen(table_name);
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
  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;
1147
    
1148
  if (ex->dumpfile)
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1149
    sql_ex.opt_flags|= DUMPFILE_FLAG;
1150
  if (ex->opt_enclosed)
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1151
    sql_ex.opt_flags|= OPT_ENCLOSED_FLAG;
1152

1153
  sql_ex.empty_flags = 0;
1154

1155
  switch (handle_dup) {
1156 1157
  case DUP_IGNORE: sql_ex.opt_flags|= IGNORE_FLAG; break;
  case DUP_REPLACE: sql_ex.opt_flags|= REPLACE_FLAG; break;
1158 1159
  case DUP_ERROR: break;	
  }
1160

1161
  if (!ex->field_term->length())
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1162
    sql_ex.empty_flags|= FIELD_TERM_EMPTY;
1163
  if (!ex->enclosed->length())
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1164
    sql_ex.empty_flags|= ENCLOSED_EMPTY;
1165
  if (!ex->line_term->length())
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1166
    sql_ex.empty_flags|= LINE_TERM_EMPTY;
1167
  if (!ex->line_start->length())
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1168
    sql_ex.empty_flags|= LINE_START_EMPTY;
1169
  if (!ex->escaped->length())
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1170
    sql_ex.empty_flags|= ESCAPED_EMPTY;
1171
    
1172
  skip_lines = ex->skip_lines;
1173

1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
  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);
1185 1186
  }

1187 1188 1189 1190
  field_lens = (const uchar*)field_lens_buf.ptr();
  fields = fields_buf.ptr();
}

1191 1192
#endif

1193 1194 1195 1196 1197
/*
  The caller must do buf[event_len] = 0 before he starts using the
  constructed event.
*/

1198
Load_log_event::Load_log_event(const char* buf, int event_len,
1199 1200
			       bool old_format)
  :Log_event(buf, old_format),num_fields(0),fields(0),
1201
  field_lens(0),field_block_len(0),
1202
  table_name(0),db(0),fname(0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1203
{
1204
  if (!event_len) // derived class, will call copy_log_event() itself
1205
    return;
1206
  copy_log_event(buf, event_len, old_format);
1207 1208
}

1209 1210
int Load_log_event::copy_log_event(const char *buf, ulong event_len,
				   bool old_format)
1211
{
1212
  uint data_len;
1213
  char* buf_end = (char*)buf + event_len;
1214 1215
  uint header_len= old_format ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
  const char* data_head = buf + header_len;
1216 1217 1218 1219 1220 1221
  thread_id = uint4korr(data_head + L_THREAD_ID_OFFSET);
  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
1222
	  
1223
  int body_offset = ((buf[EVENT_TYPE_OFFSET] == LOAD_EVENT) ?
1224
		     LOAD_HEADER_LEN + header_len :
1225
		     get_data_body_offset());
1226
  
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1227
  if ((int) event_len < body_offset)
1228
    return 1;
1229 1230 1231 1232
  /*
    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.
  */
1233 1234 1235 1236 1237 1238
  if (!(field_lens=(uchar*)sql_ex.init((char*)buf + body_offset,
		  buf_end,
		  buf[EVENT_TYPE_OFFSET] != LOAD_EVENT)))
    return 1;
  
  data_len = event_len - body_offset;
1239
  if (num_fields > data_len) // simple sanity check against corruption
1240
    return 1;
1241
  for (uint i = 0; i < num_fields; i++)
1242
    field_block_len += (uint)field_lens[i] + 1;
1243

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1244 1245 1246 1247
  fields = (char*)field_lens + num_fields;
  table_name  = fields + field_block_len;
  db = table_name + table_name_len + 1;
  fname = db + db_len + 1;
1248 1249
  fname_len = strlen(fname);
  // null termination is accomplished by the caller doing buf[event_len]=0
1250
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1251 1252
}

1253
#ifdef MYSQL_CLIENT
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1254

1255
void Load_log_event::print(FILE* file, bool short_form, char* last_db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1256 1257 1258
{
  if (!short_form)
  {
1259
    print_header(file);
1260
    fprintf(file, "\tQuery\tthread_id=%ld\texec_time=%ld\n",
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1261 1262 1263
	    thread_id, exec_time);
  }

1264
  bool same_db = 0;
1265 1266 1267 1268 1269
  if (db && last_db)
  {
    if (!(same_db = !memcmp(last_db, db, db_len + 1)))
      memcpy(last_db, db, db_len + 1);
  }
1270
  
1271
  if (db && db[0] && !same_db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1272 1273
    fprintf(file, "use %s;\n", db);

1274
  fprintf(file, "LOAD DATA INFILE '%-*s' ", fname_len, fname);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1275

1276
  if (sql_ex.opt_flags & REPLACE_FLAG )
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1277
    fprintf(file," REPLACE ");
1278
  else if (sql_ex.opt_flags & IGNORE_FLAG )
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1279 1280 1281
    fprintf(file," IGNORE ");
  
  fprintf(file, "INTO TABLE %s ", table_name);
1282
  if (sql_ex.field_term)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1283 1284
  {
    fprintf(file, " FIELDS TERMINATED BY ");
1285
    pretty_print_str(file, sql_ex.field_term, sql_ex.field_term_len);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1286 1287
  }

1288
  if (sql_ex.enclosed)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1289
  {
1290
    if (sql_ex.opt_flags & OPT_ENCLOSED_FLAG )
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1291 1292
      fprintf(file," OPTIONALLY ");
    fprintf(file, " ENCLOSED BY ");
1293
    pretty_print_str(file, sql_ex.enclosed, sql_ex.enclosed_len);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1294 1295
  }
     
1296
  if (sql_ex.escaped)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1297 1298
  {
    fprintf(file, " ESCAPED BY ");
1299
    pretty_print_str(file, sql_ex.escaped, sql_ex.escaped_len);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1300 1301
  }
     
1302
  if (sql_ex.line_term)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1303 1304
  {
    fprintf(file," LINES TERMINATED BY ");
1305
    pretty_print_str(file, sql_ex.line_term, sql_ex.line_term_len);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1306 1307
  }

1308
  if (sql_ex.line_start)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1309 1310
  {
    fprintf(file," LINES STARTING BY ");
1311
    pretty_print_str(file, sql_ex.line_start, sql_ex.line_start_len);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1312 1313
  }
     
1314
  if ((int)skip_lines > 0)
monty@donna.mysql.fi's avatar
monty@donna.mysql.fi committed
1315
    fprintf(file, " IGNORE %ld LINES ", (long) skip_lines);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1316

1317 1318 1319 1320
  if (num_fields)
  {
    uint i;
    const char* field = fields;
1321 1322
    fprintf(file, " (");
    for (i = 0; i < num_fields; i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1323
    {
1324
      if (i)
1325 1326
	fputc(',', file);
      fprintf(file, field);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1327
	  
1328
      field += field_lens[i]  + 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1329
    }
1330 1331
    fputc(')', file);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1332 1333 1334 1335

  fprintf(file, ";\n");
}

1336 1337
#endif /* #ifdef MYSQL_CLIENT */

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1338 1339
#ifndef MYSQL_CLIENT

1340
void Log_event::set_log_pos(MYSQL_LOG* log)
1341 1342 1343 1344 1345
{
  if (!log_pos)
    log_pos = my_b_tell(&log->log_file);
}

1346

1347
void Load_log_event::set_fields(List<Item> &field_list)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1348 1349
{
  uint i;
1350 1351
  const char *field= fields;
  for (i= 0; i < num_fields; i++)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1352
  {
1353 1354
    field_list.push_back(new Item_field(db, table_name, field));	  
    field+= field_lens[i]  + 1;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1355
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1356 1357
}

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1358

1359 1360
Slave_log_event::Slave_log_event(THD* thd_arg,
				 struct st_relay_log_info* rli):
1361
  Log_event(thd_arg,0,0),mem_pool(0),master_host(0)
1362
{
1363
  DBUG_ENTER("Slave_log_event");
1364
  if (!rli->inited)				// QQ When can this happen ?
1365
    DBUG_VOID_RETURN;
1366 1367
  
  MASTER_INFO* mi = rli->mi;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1368
  // TODO: re-write this better without holding both locks at the same time
1369 1370
  pthread_mutex_lock(&mi->data_lock);
  pthread_mutex_lock(&rli->data_lock);
1371
  master_host_len = strlen(mi->host);
1372
  master_log_len = strlen(rli->master_log_name);
1373
  // on OOM, just do not initialize the structure and print the error
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1374 1375
  if ((mem_pool = (char*)my_malloc(get_data_size() + 1,
				   MYF(MY_WME))))
1376
  {
1377
    master_host = mem_pool + SL_MASTER_HOST_OFFSET ;
1378 1379
    memcpy(master_host, mi->host, master_host_len + 1);
    master_log = master_host + master_host_len + 1;
1380
    memcpy(master_log, rli->master_log_name, master_log_len + 1);
1381
    master_port = mi->port;
1382
    master_pos = rli->master_log_pos;
1383 1384
    DBUG_PRINT("info", ("master_log: %s  pos: %d", master_log,
			(ulong) master_pos));
1385 1386 1387
  }
  else
    sql_print_error("Out of memory while recording slave event");
1388 1389
  pthread_mutex_unlock(&rli->data_lock);
  pthread_mutex_unlock(&mi->data_lock);
1390
  DBUG_VOID_RETURN;
1391 1392
}

1393
#endif /* ! MYSQL_CLIENT */
1394 1395 1396 1397 1398 1399 1400


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

1401 1402
#ifdef MYSQL_CLIENT

1403
void Slave_log_event::print(FILE* file, bool short_form, char* last_db)
1404 1405
{
  char llbuff[22];
1406
  if (short_form)
1407 1408 1409
    return;
  print_header(file);
  fputc('\n', file);
1410 1411
  fprintf(file, "Slave: master_host: '%s'  master_port: %d  \
master_log: '%s'  master_pos: %s\n",
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1412
	  master_host, master_port, master_log, llstr(master_pos, llbuff));
1413 1414
}

1415
#endif /* MYSQL_CLIENT */
1416

1417 1418
int Slave_log_event::get_data_size()
{
1419
  return master_host_len + master_log_len + 1 + SL_MASTER_HOST_OFFSET;
1420 1421 1422 1423
}

int Slave_log_event::write_data(IO_CACHE* file)
{
1424 1425
  int8store(mem_pool + SL_MASTER_POS_OFFSET, master_pos);
  int2store(mem_pool + SL_MASTER_PORT_OFFSET, master_port);
1426
  // log and host are already there
1427
  return my_b_safe_write(file, (byte*)mem_pool, get_data_size());
1428 1429
}

1430

1431 1432
void Slave_log_event::init_from_mem_pool(int data_size)
{
1433 1434 1435
  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;
1436 1437
  master_host_len = strlen(master_host);
  // safety
1438
  master_log = master_host + master_host_len + 1;
1439
  if (master_log > mem_pool + data_size)
1440 1441 1442 1443 1444 1445 1446
  {
    master_host = 0;
    return;
  }
  master_log_len = strlen(master_log);
}

1447 1448
Slave_log_event::Slave_log_event(const char* buf, int event_len)
  :Log_event(buf,0),mem_pool(0),master_host(0)
1449
{
1450
  event_len -= LOG_EVENT_HEADER_LEN;
1451
  if (event_len < 0)
1452
    return;
1453
  if (!(mem_pool = (char*) my_malloc(event_len + 1, MYF(MY_WME))))
1454
    return;
1455
  memcpy(mem_pool, buf + LOG_EVENT_HEADER_LEN, event_len);
1456 1457 1458
  mem_pool[event_len] = 0;
  init_from_mem_pool(event_len);
}
1459 1460

#ifndef MYSQL_CLIENT
1461 1462 1463 1464 1465 1466 1467
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,
		      char* block_arg, uint block_len_arg, bool using_trans)
  :Load_log_event(thd_arg,ex,db_arg,table_name_arg,fields_arg,handle_dup,
		  using_trans),
1468 1469
   fake_base(0),block(block_arg),block_len(block_len_arg),
   file_id(thd_arg->file_id = mysql_bin_log.next_file_id())
1470
{
1471
  sql_ex.force_new_format();
1472 1473 1474
}
#endif

1475 1476 1477 1478 1479
int Create_file_log_event::write_data_body(IO_CACHE* file)
{
  int res;
  if ((res = Load_log_event::write_data_body(file)) || fake_base)
    return res;
1480 1481
  return (my_b_safe_write(file, (byte*) "", 1) ||
	  my_b_safe_write(file, (byte*) block, block_len));
1482 1483 1484
}

int Create_file_log_event::write_data_header(IO_CACHE* file)
1485
{
1486 1487 1488
  int res;
  if ((res = Load_log_event::write_data_header(file)) || fake_base)
    return res;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1489
  byte buf[CREATE_FILE_HEADER_LEN];
1490
  int4store(buf + CF_FILE_ID_OFFSET, file_id);
1491
  return my_b_safe_write(file, buf, CREATE_FILE_HEADER_LEN);
1492 1493 1494 1495 1496 1497 1498 1499 1500
}

int Create_file_log_event::write_base(IO_CACHE* file)
{
  int res;
  fake_base = 1; // pretend we are Load event
  res = write(file);
  fake_base = 0;
  return res;
1501 1502
}

1503
Create_file_log_event::Create_file_log_event(const char* buf, int len,
1504 1505
					     bool old_format)
  :Load_log_event(buf,0,old_format),fake_base(0),block(0),inited_from_old(0)
1506
{
1507
  int block_offset;
1508
  if (copy_log_event(buf,len,old_format))
1509
    return;
1510 1511 1512 1513
  if (!old_format)
  {
    file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN +
			+ LOAD_HEADER_LEN + CF_FILE_ID_OFFSET);
1514 1515 1516
    // + 1 for \0 terminating fname  
    block_offset = (LOG_EVENT_HEADER_LEN + Load_log_event::get_data_size() +
		    CREATE_FILE_HEADER_LEN + 1);
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526
    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;
  }
1527
}
1528 1529


1530
#ifdef MYSQL_CLIENT
1531 1532
void Create_file_log_event::print(FILE* file, bool short_form,
				  char* last_db)
1533
{
1534 1535
  if (short_form)
    return;
1536
  Load_log_event::print(file, 1, last_db);
1537
  fprintf(file, " file_id: %d  block_len: %d\n", file_id, block_len);
1538 1539 1540 1541 1542 1543
}
#endif

#ifndef MYSQL_CLIENT
void Create_file_log_event::pack_info(String* packet)
{
1544
  char buf1[256],buf[22], *end;
1545 1546 1547 1548 1549
  String tmp(buf1, sizeof(buf1));
  tmp.length(0);
  tmp.append("db=");
  tmp.append(db, db_len);
  tmp.append(";table=");
1550
  tmp.append(table_name, table_name_len);
1551
  tmp.append(";file_id=");
1552 1553
  end= int10_to_str((long) file_id, buf, 10);
  tmp.append(buf, (uint32) (end-buf));
1554
  tmp.append(";block_len=");
1555 1556 1557
  end= int10_to_str((long) block_len, buf, 10);
  tmp.append(buf, (uint32) (end-buf));
  net_store_data(packet, (char*) tmp.ptr(), tmp.length());
1558 1559 1560 1561 1562
}
#endif  

#ifndef MYSQL_CLIENT  
Append_block_log_event::Append_block_log_event(THD* thd_arg, char* block_arg,
1563 1564 1565 1566
					       uint block_len_arg,
					       bool using_trans)
  :Log_event(thd_arg,0, using_trans), block(block_arg),
   block_len(block_len_arg), file_id(thd_arg->file_id)
1567 1568 1569 1570
{
}
#endif  
  
1571 1572
Append_block_log_event::Append_block_log_event(const char* buf, int len)
  :Log_event(buf, 0),block(0)
1573
{
1574
  if ((uint)len < APPEND_BLOCK_EVENT_OVERHEAD)
1575 1576 1577 1578 1579 1580 1581 1582
    return;
  file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + AB_FILE_ID_OFFSET);
  block = (char*)buf + APPEND_BLOCK_EVENT_OVERHEAD;
  block_len = len - APPEND_BLOCK_EVENT_OVERHEAD;
}

int Append_block_log_event::write_data(IO_CACHE* file)
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1583
  byte buf[APPEND_BLOCK_HEADER_LEN];
1584
  int4store(buf + AB_FILE_ID_OFFSET, file_id);
1585 1586
  return (my_b_safe_write(file, buf, APPEND_BLOCK_HEADER_LEN) ||
	  my_b_safe_write(file, (byte*) block, block_len));
1587 1588 1589
}

#ifdef MYSQL_CLIENT  
1590 1591
void Append_block_log_event::print(FILE* file, bool short_form,
				   char* last_db)
1592 1593 1594 1595 1596
{
  if (short_form)
    return;
  print_header(file);
  fputc('\n', file);
1597
  fprintf(file, "#Append_block: file_id: %d  block_len: %d\n",
1598 1599 1600
	  file_id, block_len);
}
#endif  
1601

1602 1603 1604 1605
#ifndef MYSQL_CLIENT
void Append_block_log_event::pack_info(String* packet)
{
  char buf1[256];
1606 1607
  sprintf(buf1, ";file_id=%u;block_len=%u", file_id, block_len);
  net_store_data(packet, buf1);
1608 1609
}

1610 1611
Delete_file_log_event::Delete_file_log_event(THD* thd_arg, bool using_trans)
  :Log_event(thd_arg, 0, using_trans), file_id(thd_arg->file_id)
1612 1613 1614 1615
{
}
#endif  

1616 1617 1618

Delete_file_log_event::Delete_file_log_event(const char* buf, int len)
  :Log_event(buf, 0),file_id(0)
1619
{
1620
  if ((uint)len < DELETE_FILE_EVENT_OVERHEAD)
1621 1622 1623 1624
    return;
  file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + AB_FILE_ID_OFFSET);
}

1625

1626 1627
int Delete_file_log_event::write_data(IO_CACHE* file)
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1628
 byte buf[DELETE_FILE_HEADER_LEN];
1629
 int4store(buf + DF_FILE_ID_OFFSET, file_id);
1630
 return my_b_safe_write(file, buf, DELETE_FILE_HEADER_LEN);
1631 1632 1633
}

#ifdef MYSQL_CLIENT  
1634 1635
void Delete_file_log_event::print(FILE* file, bool short_form,
				  char* last_db)
1636 1637 1638 1639 1640
{
  if (short_form)
    return;
  print_header(file);
  fputc('\n', file);
1641
  fprintf(file, "#Delete_file: file_id=%u\n", file_id);
1642 1643
}
#endif  
1644

1645 1646 1647
#ifndef MYSQL_CLIENT
void Delete_file_log_event::pack_info(String* packet)
{
1648 1649 1650
  char buf1[64];
  sprintf(buf1, ";file_id=%u", (uint) file_id);
  net_store_data(packet, buf1);
1651 1652 1653
}
#endif  

1654

1655
#ifndef MYSQL_CLIENT  
1656 1657
Execute_load_log_event::Execute_load_log_event(THD* thd_arg, bool using_trans)
  :Log_event(thd_arg, 0, using_trans), file_id(thd_arg->file_id)
1658 1659 1660 1661
{
}
#endif  
  
1662 1663
Execute_load_log_event::Execute_load_log_event(const char* buf, int len)
  :Log_event(buf, 0), file_id(0)
1664
{
1665
  if ((uint)len < EXEC_LOAD_EVENT_OVERHEAD)
1666 1667 1668 1669 1670 1671
    return;
  file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + EL_FILE_ID_OFFSET);
}

int Execute_load_log_event::write_data(IO_CACHE* file)
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1672 1673
  byte buf[EXEC_LOAD_HEADER_LEN];
  int4store(buf + EL_FILE_ID_OFFSET, file_id);
1674
  return my_b_safe_write(file, buf, EXEC_LOAD_HEADER_LEN);
1675 1676 1677
}

#ifdef MYSQL_CLIENT  
1678 1679
void Execute_load_log_event::print(FILE* file, bool short_form,
				   char* last_db)
1680 1681 1682 1683 1684 1685 1686
{
  if (short_form)
    return;
  print_header(file);
  fputc('\n', file);
  fprintf(file, "#Exec_load: file_id=%d\n",
	  file_id);
1687 1688
}
#endif  
1689 1690 1691
#ifndef MYSQL_CLIENT
void Execute_load_log_event::pack_info(String* packet)
{
1692 1693 1694
  char buf[64];
  sprintf(buf, ";file_id=%u", (uint) file_id);
  net_store_data(packet, buf);
1695 1696 1697 1698
}
#endif

#ifndef MYSQL_CLIENT
1699
int Query_log_event::exec_event(struct st_relay_log_info* rli)
1700 1701 1702 1703
{
  int expected_error,actual_error = 0;
  init_sql_alloc(&thd->mem_root, 8192,0);
  thd->db = rewrite_db((char*)db);
1704 1705 1706 1707 1708 1709 1710 1711

  /*
    InnoDB internally stores the master log position it has processed so far;
    position to store is really pos + pending + event_len
    since we must store the pos of the END of the current log event
  */
  rli->event_len= get_event_len();

1712 1713 1714 1715
  if (db_ok(thd->db, replicate_do_db, replicate_ignore_db))
  {
    thd->set_time((time_t)when);
    thd->current_tablenr = 0;
1716
    thd->query_length= q_len;
1717
    VOID(pthread_mutex_lock(&LOCK_thread_count));
1718
    thd->query = (char*)query;
1719 1720 1721 1722 1723
    thd->query_id = query_id++;
    VOID(pthread_mutex_unlock(&LOCK_thread_count));
    thd->query_error = 0;			// clear error
    thd->net.last_errno = 0;
    thd->net.last_error[0] = 0;
1724
    thd->slave_proxy_id = thread_id;		// for temp tables
1725
	
1726 1727 1728 1729
    /*
      Sanity check to make sure the master did not get a really bad
      error on the query.
    */
1730 1731
    if (ignored_error_code((expected_error = error_code)) ||
	!check_expected_error(thd,rli,expected_error))
1732
    {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1733 1734
      mysql_log.write(thd,COM_QUERY,"%s",thd->query);
      DBUG_PRINT("query",("%s",thd->query));
1735
      mysql_parse(thd, thd->query, q_len);
1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748

      /*
	Set a flag if we are inside an transaction so that we can restart
	the transaction from the start if we are killed

	This will only be done if we are supporting transactional tables
	in the slave.
      */
      if (!strcmp(thd->query,"BEGIN"))
	rli->inside_transaction= opt_using_transactions;
      else if (!strcmp(thd->query,"COMMIT"))
	rli->inside_transaction=0;

1749 1750
      if ((expected_error != (actual_error = thd->net.last_errno)) &&
	  expected_error &&
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1751 1752
	  !ignored_error_code(actual_error) &&
	  !ignored_error_code(expected_error))
1753 1754
      {
	const char* errmsg = "Slave: did not get the expected error\
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1755
 running query from master - expected: '%s' (%d), got '%s' (%d)"; 
1756 1757
	sql_print_error(errmsg, ER_SAFE(expected_error),
			expected_error,
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1758
			actual_error ? thd->net.last_error: "no error",
1759 1760 1761
			actual_error);
	thd->query_error = 1;
      }
1762 1763
      else if (expected_error == actual_error ||
	       ignored_error_code(actual_error))
1764 1765
      {
	thd->query_error = 0;
1766 1767
	*rli->last_slave_error = 0;
	rli->last_slave_errno = 0;
1768 1769 1770 1771 1772
      }
    }
    else
    {
      // master could be inconsistent, abort and tell DBA to check/fix it
1773
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1774
      thd->db = thd->query = 0;
1775
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
1776
      thd->variables.convert_set = 0;
1777 1778 1779 1780 1781
      close_thread_tables(thd);
      free_root(&thd->mem_root,0);
      return 1;
    }
  }
1782
  thd->db= 0;				// prevent db from being freed
1783
  VOID(pthread_mutex_lock(&LOCK_thread_count));
1784
  thd->query= 0;			// just to be sure
1785
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
1786
  // assume no convert for next query unless set explictly
1787
  thd->variables.convert_set = 0;
1788 1789 1790 1791
  close_thread_tables(thd);
      
  if (thd->query_error || thd->fatal_error)
  {
1792
    slave_print_error(rli,actual_error, "error '%s' on query '%s'",
1793 1794
		      actual_error ? thd->net.last_error :
		      "unexpected success or fatal error", query);
1795 1796 1797 1798
    free_root(&thd->mem_root,0);
    return 1;
  }
  free_root(&thd->mem_root,0);
1799
  return Log_event::exec_event(rli); 
1800 1801
}

1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
/*
  Does the data loading job when executing a LOAD DATA on the slave

  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.

  DESCRIPTION
    Does the data loading job when executing a LOAD DATA on the slave
 
  RETURN VALUE
    0           Success                                                 
    1    	Failure
*/
1827

1828 1829
int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli, 
			       bool use_rli_only_for_errors)
1830 1831 1832
{
  init_sql_alloc(&thd->mem_root, 8192,0);
  thd->db = rewrite_db((char*)db);
1833 1834
  DBUG_ASSERT(thd->query == 0);
  thd->query = 0;				// Should not be needed
1835 1836
  thd->query_error = 0;
	    
1837
  if (db_ok(thd->db, replicate_do_db, replicate_ignore_db))
1838 1839 1840 1841 1842 1843 1844 1845 1846 1847
  {
    thd->set_time((time_t)when);
    thd->current_tablenr = 0;
    VOID(pthread_mutex_lock(&LOCK_thread_count));
    thd->query_id = query_id++;
    VOID(pthread_mutex_unlock(&LOCK_thread_count));

    TABLE_LIST tables;
    bzero((char*) &tables,sizeof(tables));
    tables.db = thd->db;
1848
    tables.alias = tables.real_name = (char*)table_name;
1849
    tables.lock_type = TL_WRITE;
1850
    tables.updating= 1;
1851
    // the table will be opened in mysql_load    
1852
    if (table_rules_on && !tables_ok(thd, &tables))
1853
    {
1854
      // TODO: this is a bug - this needs to be moved to the I/O thread
1855 1856 1857 1858 1859 1860 1861
      if (net)
        skip_load_data_infile(net);
    }
    else
    {
      char llbuff[22];
      enum enum_duplicates handle_dup = DUP_IGNORE;
1862
      if (sql_ex.opt_flags & REPLACE_FLAG)
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1863 1864
	handle_dup= DUP_REPLACE;
      sql_exchange ex((char*)fname, sql_ex.opt_flags & DUMPFILE_FLAG);
1865 1866 1867 1868 1869
      String field_term(sql_ex.field_term,sql_ex.field_term_len);
      String enclosed(sql_ex.enclosed,sql_ex.enclosed_len);
      String line_term(sql_ex.line_term,sql_ex.line_term_len);
      String line_start(sql_ex.line_start,sql_ex.line_start_len);
      String escaped(sql_ex.escaped,sql_ex.escaped_len);
1870 1871 1872 1873 1874
      ex.field_term= &field_term;
      ex.enclosed= &enclosed;
      ex.line_term= &line_term;
      ex.line_start= &line_start;
      ex.escaped= &escaped;
1875 1876
	    
      ex.opt_enclosed = (sql_ex.opt_flags & OPT_ENCLOSED_FLAG);
1877
      if (sql_ex.empty_flags & FIELD_TERM_EMPTY)
1878
	ex.field_term->length(0);
1879

1880
      ex.skip_lines = skip_lines;
1881 1882
      List<Item> field_list;
      set_fields(field_list);
1883
      thd->slave_proxy_id = thread_id;
1884 1885 1886 1887
      if (net)
      {
	// mysql_load will use thd->net to read the file
	thd->net.vio = net->vio;
1888 1889 1890
	/*
	  Make sure the client does not get confused about the packet sequence
	*/
1891 1892
	thd->net.pkt_nr = net->pkt_nr;
      }
1893
      if (mysql_load(thd, &ex, &tables, field_list, handle_dup, net != 0,
1894
		     TL_WRITE))
1895
	thd->query_error = 1;
1896
      if (thd->cuted_fields)
1897 1898 1899 1900
	/* 
	   log_pos is the position of the LOAD
	   event in the master log
	*/
1901
	sql_print_error("Slave: load data infile at position %s in log \
1902
'%s' produced %d warning(s)", llstr(log_pos,llbuff), RPL_LOG_NAME, 
1903
			thd->cuted_fields );
1904
      if (net)
1905
        net->pkt_nr= thd->net.pkt_nr;
1906 1907 1908 1909
    }
  }
  else
  {
1910 1911 1912 1913 1914
    /*
      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
    */
1915 1916 1917 1918 1919
    if (net)
      skip_load_data_infile(net);
  }
	    
  thd->net.vio = 0; 
1920
  thd->db= 0;					// prevent db from being freed
1921
  close_thread_tables(thd);
1922
  if (thd->query_error)
1923
  {
1924
    int sql_error= thd->net.last_errno;
1925
    if (!sql_error)
1926
      sql_error= ER_UNKNOWN_ERROR;
1927
    slave_print_error(rli,sql_error,
1928 1929 1930
		      "Error '%s' running load data infile",
		      sql_error ? thd->net.last_error :
		      ER_SAFE(ER_UNKNOWN_ERROR));
1931 1932 1933 1934 1935
    free_root(&thd->mem_root,0);
    return 1;
  }
  free_root(&thd->mem_root,0);
	    
1936
  if (thd->fatal_error)
1937
  {
1938
    sql_print_error("Fatal error running LOAD DATA INFILE ");
1939 1940 1941
    return 1;
  }

1942
  return ( use_rli_only_for_errors ? 0 : Log_event::exec_event(rli) ); 
1943 1944
}

1945

1946 1947 1948 1949 1950 1951
/*
  The master started

  IMPLEMENTATION
    - To handle the case where the master died without a stop event,
      we clean up all temporary tables + locks that we got.
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1952 1953 1954 1955
      However, we don't clean temporary tables if the master was 3.23
      (this is because a 3.23 master writes a Start_log_event at every
      binlog rotation; if we were not careful we would remove temp tables
      on the slave when FLUSH LOGS is issued on the master). 
1956 1957 1958 1959 1960 1961 1962 1963

  TODO
    - Remove all active user locks
    - If we have an active transaction at this point, the master died
      in the middle while writing the transaction to the binary log.
      In this case we should stop the slave.
*/

1964
int Start_log_event::exec_event(struct st_relay_log_info* rli)
1965
{
1966
  if (!rli->mi->old_format)
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1967 1968 1969 1970 1971 1972 1973 1974 1975
  {
    /* 
       If 4.0 master, all temporary tables have been deleted on the master; 
       if 3.23 master, this is far from sure.
    */
    close_temporary_tables(thd);
    /*
      If we have old format, load_tmpdir is cleaned up by the I/O thread
    */
1976
    cleanup_load_tmpdir();
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1977
  }
1978
  return Log_event::exec_event(rli);
1979 1980
}

1981

1982 1983 1984 1985 1986 1987 1988 1989
/*
  The master stopped. Clean up all temporary tables + locks that the
  master may have set.

  TODO
    - Remove all active user locks
*/

1990
int Stop_log_event::exec_event(struct st_relay_log_info* rli)
1991
{
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1992 1993 1994 1995 1996 1997 1998 1999
  /*
    do not clean up immediately after rotate event;
    QQ: this should be a useless test: the only case when it is false is when
    shutdown occured just after FLUSH LOGS. It has nothing to do with Rotate?
    By the way, immediately after a Rotate
    the I/O thread does not write the Stop to the relay log,
    so we won't come here in that case.
  */
2000
  if (rli->master_log_pos > BIN_LOG_HEADER_SIZE) 
2001 2002
  {
    close_temporary_tables(thd);
2003
    cleanup_load_tmpdir();
2004
  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2005 2006
  /*
    We do not want to update master_log pos because we get a rotate event
2007 2008
    before stop, so by now master_log_name is set to the next log.
    If we updated it, we will have incorrect master coordinates and this
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2009
    could give false triggers in MASTER_POS_WAIT() that we have reached
2010
    the target position when in fact we have not.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2011
  */
2012 2013
  rli->inc_pos(get_event_len(), 0);  
  flush_relay_log_info(rli);
2014 2015 2016
  return 0;
}

2017 2018 2019 2020 2021

/*
  Got a rotate log even from the master

  IMPLEMENTATION
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2022 2023
    This is mainly used so that we can later figure out the logname and
    position for the master.
2024

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2025 2026
    We can't rotate the slave as this will cause infinitive rotations
    in a A -> B -> A setup.
2027 2028

  RETURN VALUES
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2029 2030
    0	ok
 */
2031 2032
  

2033
int Rotate_log_event::exec_event(struct st_relay_log_info* rli)
2034
{
2035
  char* log_name = rli->master_log_name;
2036 2037
  DBUG_ENTER("Rotate_log_event::exec_event");

2038
  pthread_mutex_lock(&rli->data_lock);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2039
  memcpy(log_name, new_log_ident, ident_len+1);
2040 2041
  rli->master_log_pos = pos;
  rli->relay_log_pos += get_event_len();
2042
  DBUG_PRINT("info", ("master_log_pos: %d", (ulong) rli->master_log_pos));
2043
  pthread_mutex_unlock(&rli->data_lock);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2044
  pthread_cond_broadcast(&rli->data_cond);
2045
  flush_relay_log_info(rli);
2046
  DBUG_RETURN(0);
2047 2048
}

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

2050
int Intvar_log_event::exec_event(struct st_relay_log_info* rli)
2051
{
2052
  switch (type) {
2053 2054 2055 2056 2057 2058 2059 2060
  case LAST_INSERT_ID_EVENT:
    thd->last_insert_id_used = 1;
    thd->last_insert_id = val;
    break;
  case INSERT_ID_EVENT:
    thd->next_insert_id = val;
    break;
  }
2061
  rli->inc_pending(get_event_len());
2062 2063 2064
  return 0;
}

nick@mysql.com's avatar
nick@mysql.com committed
2065 2066
int Rand_log_event::exec_event(struct st_relay_log_info* rli)
{
2067 2068
  thd->rand.seed1 = (ulong) seed1;
  thd->rand.seed2 = (ulong) seed2;
nick@mysql.com's avatar
nick@mysql.com committed
2069 2070 2071 2072
  rli->inc_pending(get_event_len());
  return 0;
}

2073
int Slave_log_event::exec_event(struct st_relay_log_info* rli)
2074
{
2075
  if (mysql_bin_log.is_open())
2076
    mysql_bin_log.write(this);
2077
  return Log_event::exec_event(rli);
2078 2079
}

2080
int Create_file_log_event::exec_event(struct st_relay_log_info* rli)
2081 2082
{
  char fname_buf[FN_REFLEN+10];
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2083
  char *p;
2084 2085 2086
  int fd = -1;
  IO_CACHE file;
  int error = 1;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2087

2088
  bzero((char*)&file, sizeof(file));
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2089 2090
  p = slave_load_file_stem(fname_buf, file_id, server_id);
  strmov(p, ".info");			// strmov takes less code than memcpy
2091 2092 2093 2094 2095
  if ((fd = my_open(fname_buf, O_WRONLY|O_CREAT|O_BINARY|O_TRUNC,
		    MYF(MY_WME))) < 0 ||
      init_io_cache(&file, fd, IO_SIZE, WRITE_CACHE, (my_off_t)0, 0,
		    MYF(MY_WME|MY_NABP)))
  {
2096
    slave_print_error(rli,my_errno, "Could not open file '%s'", fname_buf);
2097 2098 2099 2100
    goto err;
  }
  
  // a trick to avoid allocating another buffer
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2101
  strmov(p, ".data");
2102 2103 2104 2105
  fname = fname_buf;
  fname_len = (uint)(p-fname) + 5;
  if (write_base(&file))
  {
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2106
    strmov(p, ".info"); // to have it right in the error message
2107
    slave_print_error(rli,my_errno, "Could not write to file '%s'", fname_buf);
2108 2109 2110 2111 2112 2113 2114 2115 2116
    goto err;
  }
  end_io_cache(&file);
  my_close(fd, MYF(0));
  
  // fname_buf now already has .data, not .info, because we did our trick
  if ((fd = my_open(fname_buf, O_WRONLY|O_CREAT|O_BINARY|O_TRUNC,
		    MYF(MY_WME))) < 0)
  {
2117
    slave_print_error(rli,my_errno, "Could not open file '%s'", fname_buf);
2118 2119
    goto err;
  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2120
  if (my_write(fd, (byte*) block, block_len, MYF(MY_WME+MY_NABP)))
2121
  {
2122
    slave_print_error(rli,my_errno, "Write to '%s' failed", fname_buf);
2123 2124 2125 2126
    goto err;
  }
  if (mysql_bin_log.is_open())
    mysql_bin_log.write(this);
2127 2128
  error=0;					// Everything is ok

2129 2130 2131 2132 2133
err:
  if (error)
    end_io_cache(&file);
  if (fd >= 0)
    my_close(fd, MYF(0));
2134
  return error ? 1 : Log_event::exec_event(rli);
2135 2136
}

2137
int Delete_file_log_event::exec_event(struct st_relay_log_info* rli)
2138 2139
{
  char fname[FN_REFLEN+10];
2140
  char *p= slave_load_file_stem(fname, file_id, server_id);
2141
  memcpy(p, ".data", 6);
2142
  (void) my_delete(fname, MYF(MY_WME));
2143
  memcpy(p, ".info", 6);
2144
  (void) my_delete(fname, MYF(MY_WME));
2145 2146
  if (mysql_bin_log.is_open())
    mysql_bin_log.write(this);
2147
  return Log_event::exec_event(rli);
2148 2149
}

2150
int Append_block_log_event::exec_event(struct st_relay_log_info* rli)
2151 2152
{
  char fname[FN_REFLEN+10];
2153 2154
  char *p= slave_load_file_stem(fname, file_id, server_id);
  int fd;
2155
  int error = 1;
2156

2157 2158 2159
  memcpy(p, ".data", 6);
  if ((fd = my_open(fname, O_WRONLY|O_APPEND|O_BINARY, MYF(MY_WME))) < 0)
  {
2160
    slave_print_error(rli,my_errno, "Could not open file '%s'", fname);
2161 2162
    goto err;
  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2163
  if (my_write(fd, (byte*) block, block_len, MYF(MY_WME+MY_NABP)))
2164
  {
2165
    slave_print_error(rli,my_errno, "Write to '%s' failed", fname);
2166 2167 2168 2169 2170
    goto err;
  }
  if (mysql_bin_log.is_open())
    mysql_bin_log.write(this);
  error=0;
2171

2172 2173 2174
err:
  if (fd >= 0)
    my_close(fd, MYF(0));
2175
  return error ? error : Log_event::exec_event(rli);
2176 2177
}

2178
int Execute_load_log_event::exec_event(struct st_relay_log_info* rli)
2179 2180
{
  char fname[FN_REFLEN+10];
2181 2182
  char *p= slave_load_file_stem(fname, file_id, server_id);
  int fd;
2183
  int error = 1;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2184
  ulong save_options;
2185 2186
  IO_CACHE file;
  Load_log_event* lev = 0;
2187

2188 2189 2190 2191 2192
  memcpy(p, ".info", 6);
  if ((fd = my_open(fname, O_RDONLY|O_BINARY, MYF(MY_WME))) < 0 ||
      init_io_cache(&file, fd, IO_SIZE, READ_CACHE, (my_off_t)0, 0,
		    MYF(MY_WME|MY_NABP)))
  {
2193
    slave_print_error(rli,my_errno, "Could not open file '%s'", fname);
2194 2195
    goto err;
  }
2196 2197
  if (!(lev = (Load_log_event*)Log_event::read_log_event(&file,
							 (pthread_mutex_t*)0,
2198 2199
							 (bool)0)) ||
      lev->get_type_code() != NEW_LOAD_EVENT)
2200
  {
2201
    slave_print_error(rli,0, "File '%s' appears corrupted", fname);
2202 2203
    goto err;
  }
2204 2205 2206 2207 2208 2209
  /*
    We want to disable binary logging in slave thread because we need the file
    events to appear in the same order as they do on the master relative to
    other events, so that we can preserve ascending order of log sequence
    numbers - needed to handle failover .
  */
2210
  save_options = thd->options;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2211
  thd->options &= ~ (ulong) (OPTION_BIN_LOG);
2212
  lev->thd = thd;
2213 2214 2215 2216 2217
  /*
    lev->exec_event should use rli only for errors
    i.e. should not advance rli's position
  */
  if (lev->exec_event(0,rli,1)) 
2218
  {
2219
    slave_print_error(rli,my_errno, "Failed executing load from '%s'", fname);
2220 2221 2222 2223
    thd->options = save_options;
    goto err;
  }
  thd->options = save_options;
2224
  (void) my_delete(fname, MYF(MY_WME));
2225
  memcpy(p, ".data", 6);
2226
  (void) my_delete(fname, MYF(MY_WME));
2227 2228 2229
  if (mysql_bin_log.is_open())
    mysql_bin_log.write(this);
  error = 0;
2230

2231 2232 2233
err:
  delete lev;
  if (fd >= 0)
2234
  {
2235
    my_close(fd, MYF(0));
2236 2237
    end_io_cache(&file);
  }
2238
  return error ? error : Log_event::exec_event(rli);
2239 2240
}

2241
#endif /* !MYSQL_CLIENT */