log_event.cc 62 KB
Newer Older
unknown's avatar
unknown 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>
unknown's avatar
unknown committed
25 26
#endif /* MYSQL_CLIENT */

27 28
#include <assert.h>

unknown's avatar
unknown 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
unknown's avatar
unknown committed
37
  */
38
  if (file->type == SEQ_READ_APPEND)
unknown's avatar
unknown 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)
unknown's avatar
unknown committed
45
{
46
  char* end = str + len;
unknown's avatar
unknown committed
47
  fputc('\'', file);
48 49
  while (str < end)
  {
unknown's avatar
unknown committed
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);
unknown's avatar
unknown committed
65
}
66
#endif
unknown's avatar
unknown committed
67

unknown's avatar
unknown committed
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);
}

unknown's avatar
unknown committed
75

76
static void pretty_print_str(String* packet, char* str, int len)
unknown's avatar
unknown committed
77
{
78
  char* end = str + len;
unknown's avatar
unknown committed
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;
    }
unknown's avatar
unknown committed
95 96 97 98
  }
  packet->append('\'');
}

unknown's avatar
unknown committed
99

100 101 102
static inline char* slave_load_file_stem(char*buf, uint file_id,
					 int event_server_id)
{
unknown's avatar
unknown committed
103
  fn_format(buf,"SQL_LOAD-",slave_load_tmpdir, "", MY_UNPACK_FILENAME);
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);
}

unknown's avatar
unknown committed
112 113 114 115
#endif

const char* Log_event::get_type_str()
{
116
  switch(get_type_code()) {
unknown's avatar
unknown committed
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";
unknown's avatar
unknown committed
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";
unknown's avatar
unknown committed
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
static void cleanup_load_tmpdir()
{
  MY_DIR *dirp;
  FILEINFO *file;
  uint i;
  if (!(dirp=my_dir(slave_load_tmpdir,MYF(MY_WME))))
    return;
171
  char fname[FN_REFLEN];
unknown's avatar
unknown committed
172
  for (i=0 ; i < (uint)dirp->number_off_files; i++)
173 174
  {
    file=dirp->dir_entry+i;
unknown's avatar
unknown committed
175
    if (is_prefix(file->name,"SQL_LOAD-"))
176
    {
unknown's avatar
unknown committed
177
      fn_format(fname,file->name,slave_load_tmpdir,"",MY_UNPACK_FILENAME);
178 179
      my_delete(fname, MYF(0));
    }
180 181 182 183
  }

  my_dirend(dirp);
}
184 185
#endif

unknown's avatar
unknown committed
186

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


#ifndef MYSQL_CLIENT

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

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

void Query_log_event::pack_info(String* packet)
{
244 245 246
  char buf[256];
  String tmp(buf, sizeof(buf));
  tmp.length(0);
247
  if (db && db_len)
unknown's avatar
unknown committed
248 249 250 251 252 253
  {
   tmp.append("use ");
   tmp.append(db, db_len);
   tmp.append("; ", 2);
  }

254
  if (query && q_len)
unknown's avatar
unknown committed
255 256 257 258 259 260
    tmp.append(query, q_len);
  net_store_data(packet, (char*)tmp.ptr(), tmp.length());
}

void Start_log_event::pack_info(String* packet)
{
261 262 263
  char buf1[256];
  String tmp(buf1, sizeof(buf1));
  tmp.length(0);
unknown's avatar
unknown committed
264 265 266 267 268 269 270 271 272 273 274
  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)
{
275 276 277
  char buf[256];
  String tmp(buf, sizeof(buf));
  tmp.length(0);
unknown's avatar
unknown committed
278
  if (db && db_len)
unknown's avatar
unknown committed
279 280 281 282 283 284 285
  {
   tmp.append("use ");
   tmp.append(db, db_len);
   tmp.append("; ", 2);
  }

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

301
  if (sql_ex.enclosed_len)
unknown's avatar
unknown committed
302
  {
unknown's avatar
unknown committed
303
    if (sql_ex.opt_flags & OPT_ENCLOSED_FLAG )
unknown's avatar
unknown committed
304 305
      tmp.append(" OPTIONALLY ");
    tmp.append( " ENCLOSED BY ");
306
    pretty_print_str(&tmp, sql_ex.enclosed, sql_ex.enclosed_len);
unknown's avatar
unknown committed
307 308
  }
     
309
  if (sql_ex.escaped_len)
unknown's avatar
unknown committed
310 311
  {
    tmp.append( " ESCAPED BY ");
312
    pretty_print_str(&tmp, sql_ex.escaped, sql_ex.escaped_len);
unknown's avatar
unknown committed
313 314
  }
     
unknown's avatar
unknown committed
315
  bool line_lexem_added= false;
316
  if (sql_ex.line_term_len)
unknown's avatar
unknown committed
317 318
  {
    tmp.append(" LINES TERMINATED BY ");
319
    pretty_print_str(&tmp, sql_ex.line_term, sql_ex.line_term_len);
unknown's avatar
unknown committed
320
    line_lexem_added= true;
unknown's avatar
unknown committed
321 322
  }

323
  if (sql_ex.line_start_len)
unknown's avatar
unknown committed
324
  {
unknown's avatar
unknown committed
325 326 327
    if (!line_lexem_added)
      tmp.append(" LINES");
    tmp.append(" STARTING BY ");
328
    pretty_print_str(&tmp, sql_ex.line_start, sql_ex.line_start_len);
unknown's avatar
unknown committed
329 330 331 332 333 334 335 336 337 338
  }
     
  if ((int)skip_lines > 0)
    tmp.append( " IGNORE %ld LINES ", (long) skip_lines);

  if (num_fields)
  {
    uint i;
    const char* field = fields;
    tmp.append(" (");
339
    for (i = 0; i < num_fields; i++)
unknown's avatar
unknown committed
340
    {
unknown's avatar
unknown committed
341
      if (i)
unknown's avatar
unknown committed
342 343 344 345 346 347 348 349 350 351 352 353 354
	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)
{
355
  char buf1[256], buf[22];
356 357
  String tmp(buf1, sizeof(buf1));
  tmp.length(0);
358
  tmp.append(new_log_ident, ident_len);
359 360
  tmp.append(";pos=");
  tmp.append(llstr(pos,buf));
unknown's avatar
unknown committed
361
  if (flags & LOG_EVENT_FORCED_ROTATE_F)
362 363
    tmp.append("; forced by master");
  net_store_data(packet, tmp.ptr(), tmp.length());
unknown's avatar
unknown committed
364 365 366 367
}

void Intvar_log_event::pack_info(String* packet)
{
368
  char buf1[256], buf[22];
369 370
  String tmp(buf1, sizeof(buf1));
  tmp.length(0);
unknown's avatar
unknown committed
371 372 373 374 375 376
  tmp.append(get_var_type_name());
  tmp.append('=');
  tmp.append(llstr(val, buf));
  net_store_data(packet, tmp.ptr(), tmp.length());
}

unknown's avatar
unknown committed
377 378
void Rand_log_event::pack_info(String* packet)
{
379 380 381 382 383 384
  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));
unknown's avatar
unknown committed
385 386
}

unknown's avatar
unknown committed
387 388
void Slave_log_event::pack_info(String* packet)
{
389
  char buf1[256], buf[22], *end;
390 391
  String tmp(buf1, sizeof(buf1));
  tmp.length(0);
unknown's avatar
unknown committed
392 393 394
  tmp.append("host=");
  tmp.append(master_host);
  tmp.append(",port=");
395 396
  end= int10_to_str((long) master_port, buf, 10);
  tmp.append(buf, (uint32) (end-buf));
unknown's avatar
unknown committed
397 398 399 400 401
  tmp.append(",log=");
  tmp.append(master_log);
  tmp.append(",pos=");
  tmp.append(llstr(master_pos,buf));
  net_store_data(packet, tmp.ptr(), tmp.length());
unknown's avatar
unknown committed
402 403 404 405 406 407 408 409 410
}


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));
411
  field_list->push_back(new Item_empty_string("Orig_log_pos", 20));
unknown's avatar
unknown committed
412 413 414
  field_list->push_back(new Item_empty_string("Info", 20));
}

unknown's avatar
unknown committed
415 416 417
/*
 * only called by SHOW BINLOG EVENTS
 */
418
int Log_event::net_send(THD* thd_arg, const char* log_name, my_off_t pos)
unknown's avatar
unknown committed
419
{
420
  String* packet = &thd_arg->packet;
unknown's avatar
unknown committed
421 422 423 424 425 426 427
  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));
unknown's avatar
unknown committed
428
  net_store_data(packet, (longlong) pos);
unknown's avatar
unknown committed
429 430 431
  event_type = get_type_str();
  net_store_data(packet, event_type, strlen(event_type));
  net_store_data(packet, server_id);
unknown's avatar
unknown committed
432
  net_store_data(packet, (longlong) log_pos);
unknown's avatar
unknown committed
433
  pack_info(packet);
434
  return my_net_write(&thd_arg->net, (char*) packet->ptr(), packet->length());
unknown's avatar
unknown committed
435 436
}

437 438
#endif /* MYSQL_CLIENT */

unknown's avatar
unknown committed
439

440
int Query_log_event::write(IO_CACHE* file)
unknown's avatar
unknown committed
441 442 443 444
{
  return query ? Log_event::write(file) : -1; 
}

445

446
int Log_event::write(IO_CACHE* file)
unknown's avatar
unknown committed
447
{
448
  return (write_header(file) || write_data(file)) ? -1 : 0;
unknown's avatar
unknown committed
449 450
}

451

452
int Log_event::write_header(IO_CACHE* file)
unknown's avatar
unknown committed
453
{
454
  char buf[LOG_EVENT_HEADER_LEN];
unknown's avatar
unknown committed
455
  char* pos = buf;
unknown's avatar
unknown committed
456
  int4store(pos, (ulong) when); // timestamp
unknown's avatar
unknown committed
457 458
  pos += 4;
  *pos++ = get_type_code(); // event type code
459 460
  int4store(pos, server_id);
  pos += 4;
461 462
  long tmp=get_data_size() + LOG_EVENT_HEADER_LEN;
  int4store(pos, tmp);
unknown's avatar
unknown committed
463
  pos += 4;
464
  int4store(pos, log_pos);
465 466 467
  pos += 4;
  int2store(pos, flags);
  pos += 2;
468
  return (my_b_safe_write(file, (byte*) buf, (uint) (pos - buf)));
unknown's avatar
unknown committed
469 470 471 472
}

#ifndef MYSQL_CLIENT

473
int Log_event::read_log_event(IO_CACHE* file, String* packet,
474
			      pthread_mutex_t* log_lock)
unknown's avatar
unknown committed
475 476
{
  ulong data_len;
477
  int result=0;
unknown's avatar
unknown committed
478
  char buf[LOG_EVENT_HEADER_LEN];
479
  DBUG_ENTER("read_log_event");
480

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

end:
  if (log_lock)
    pthread_mutex_unlock(log_lock);
525
  DBUG_RETURN(result);
unknown's avatar
unknown committed
526 527 528 529
}

#endif // MYSQL_CLIENT

unknown's avatar
unknown committed
530
#ifndef MYSQL_CLIENT
unknown's avatar
unknown committed
531 532
#define UNLOCK_MUTEX if (log_lock) pthread_mutex_unlock(log_lock);
#define LOCK_MUTEX if (log_lock) pthread_mutex_lock(log_lock);
unknown's avatar
unknown committed
533
#define max_allowed_packet current_thd->variables.max_allowed_packet
534
#else
535
#define UNLOCK_MUTEX
536 537 538
#define LOCK_MUTEX
#endif

unknown's avatar
unknown committed
539 540
// allocates memory - the caller is responsible for clean-up
#ifndef MYSQL_CLIENT
541 542 543
Log_event* Log_event::read_log_event(IO_CACHE* file,
				     pthread_mutex_t* log_lock,
				     bool old_format)
unknown's avatar
unknown committed
544
#else
545
Log_event* Log_event::read_log_event(IO_CACHE* file, bool old_format)
unknown's avatar
unknown committed
546
#endif  
unknown's avatar
unknown committed
547
{
548
  char head[LOG_EVENT_HEADER_LEN];
549 550
  uint header_size= old_format ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;

551
  LOCK_MUTEX;
552
  if (my_b_read(file, (byte *) head, header_size))
553
  {
unknown's avatar
unknown committed
554
    UNLOCK_MUTEX;
555
    return 0;
556
  }
unknown's avatar
unknown committed
557

558
  uint data_len = uint4korr(head + EVENT_LEN_OFFSET);
559 560 561
  char *buf= 0;
  const char *error= 0;
  Log_event *res=  0;
unknown's avatar
unknown committed
562

563
  if (data_len > max_allowed_packet)
unknown's avatar
unknown committed
564
  {
565 566
    error = "Event too big";
    goto err;
unknown's avatar
unknown committed
567 568
  }

569
  if (data_len < header_size)
unknown's avatar
unknown committed
570
  {
571 572
    error = "Event too small";
    goto err;
unknown's avatar
unknown committed
573
  }
574 575 576

  // some events use the extra byte to null-terminate strings
  if (!(buf = my_malloc(data_len+1, MYF(MY_WME))))
577 578 579
  {
    error = "Out of memory";
    goto err;
unknown's avatar
unknown committed
580
  }
581
  buf[data_len] = 0;
582
  memcpy(buf, head, header_size);
583
  if (my_b_read(file, (byte*) buf + header_size, data_len - header_size))
584 585 586 587
  {
    error = "read error";
    goto err;
  }
588
  if ((res = read_log_event(buf, data_len, &error, old_format)))
589
    res->register_temp_buf(buf);
590

591
err:
unknown's avatar
unknown committed
592
  UNLOCK_MUTEX;
593
  if (error)
594
  {
595 596
    sql_print_error("Error in Log_event::read_log_event(): '%s', \
data_len=%d,event_type=%d",error,data_len,head[EVENT_TYPE_OFFSET]);
597
    my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
598 599 600 601 602 603 604 605 606
    /*
      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;
607
  }
608
  return res;
unknown's avatar
unknown committed
609 610
}

611

612
Log_event* Log_event::read_log_event(const char* buf, int event_len,
613
				     const char **error, bool old_format)
unknown's avatar
unknown committed
614
{
615
  if (event_len < EVENT_LEN_OFFSET ||
616 617 618
      (uint) event_len != uint4korr(buf+EVENT_LEN_OFFSET))
  {
    *error="Sanity check failed";		// Needed to free buffer
619
    return NULL; // general sanity check - will fail on a partial read
620
  }
621
  
622 623
  Log_event* ev = NULL;
  
624
  switch(buf[EVENT_TYPE_OFFSET]) {
unknown's avatar
unknown committed
625
  case QUERY_EVENT:
626
    ev  = new Query_log_event(buf, event_len, old_format);
627
    break;
unknown's avatar
unknown committed
628
  case LOAD_EVENT:
unknown's avatar
unknown committed
629 630
    ev = new Create_file_log_event(buf, event_len, old_format);
    break;
631
  case NEW_LOAD_EVENT:
632
    ev = new Load_log_event(buf, event_len, old_format);
633
    break;
unknown's avatar
unknown committed
634
  case ROTATE_EVENT:
635
    ev = new Rotate_log_event(buf, event_len, old_format);
636
    break;
unknown's avatar
unknown committed
637
  case SLAVE_EVENT:
638 639 640
    ev = new Slave_log_event(buf, event_len);
    break;
  case CREATE_FILE_EVENT:
unknown's avatar
unknown committed
641
    ev = new Create_file_log_event(buf, event_len, old_format);
642 643 644 645 646 647 648 649 650 651 652
    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:
653
    ev = new Start_log_event(buf, old_format);
654 655
    break;
  case STOP_EVENT:
656
    ev = new Stop_log_event(buf, old_format);
657 658
    break;
  case INTVAR_EVENT:
659
    ev = new Intvar_log_event(buf, old_format);
660
    break;
unknown's avatar
unknown committed
661 662 663
  case RAND_EVENT:
    ev = new Rand_log_event(buf, old_format);
    break;
664 665
  default:
    break;
unknown's avatar
unknown committed
666
  }
667
  if (!ev || !ev->is_valid())
668 669
  {
    delete ev;
670 671 672 673 674 675 676 677 678
#ifdef MYSQL_CLIENT
    if (!force_opt)
    {
      *error= "Found invalid event in binary log";
      return 0;
    }
    ev= new Unknown_log_event(buf, old_format);
#else
    *error= "Found invalid event in binary log";
679
    return 0;
680
#endif
681 682 683
  }
  ev->cached_event_len = event_len;
  return ev;  
unknown's avatar
unknown committed
684 685
}

686

687
#ifdef MYSQL_CLIENT
688 689
void Log_event::print_header(FILE* file)
{
690
  char llbuff[22];
691 692
  fputc('#', file);
  print_timestamp(file);
693
  fprintf(file, " server id %d  log_pos %s ", server_id,
694
	  llstr(log_pos,llbuff)); 
695 696
}

697
void Log_event::print_timestamp(FILE* file, time_t* ts)
unknown's avatar
unknown committed
698
{
unknown's avatar
unknown committed
699
  struct tm *res;
700 701
  if (!ts)
    ts = &when;
702 703
#ifdef MYSQL_SERVER				// This is always false
  struct tm tm_tmp;
unknown's avatar
unknown committed
704
  localtime_r(ts,(res= &tm_tmp));
unknown's avatar
unknown committed
705
#else
706
  res=localtime(ts);
unknown's avatar
unknown committed
707
#endif
708 709

  fprintf(file,"%02d%02d%02d %2d:%02d:%02d",
710 711 712 713 714 715
	  res->tm_year % 100,
	  res->tm_mon+1,
	  res->tm_mday,
	  res->tm_hour,
	  res->tm_min,
	  res->tm_sec);
unknown's avatar
unknown committed
716 717 718
}


719
void Start_log_event::print(FILE* file, bool short_form, char* last_db)
unknown's avatar
unknown committed
720 721 722 723
{
  if (short_form)
    return;

724 725 726
  print_header(file);
  fprintf(file, "\tStart: binlog v %d, server v %s created ", binlog_version,
	  server_version);
727
  print_timestamp(file);
728
  if (created)
729
    fprintf(file," at startup");
730
  fputc('\n', file);
unknown's avatar
unknown committed
731 732 733
  fflush(file);
}

734
void Stop_log_event::print(FILE* file, bool short_form, char* last_db)
unknown's avatar
unknown committed
735 736 737 738
{
  if (short_form)
    return;

739
  print_header(file);
unknown's avatar
unknown committed
740 741 742 743
  fprintf(file, "\tStop\n");
  fflush(file);
}

744
void Rotate_log_event::print(FILE* file, bool short_form, char* last_db)
unknown's avatar
unknown committed
745
{
746
  char buf[22];
unknown's avatar
unknown committed
747 748 749
  if (short_form)
    return;

750
  print_header(file);
unknown's avatar
unknown committed
751 752 753 754
  fprintf(file, "\tRotate to ");
  if (new_log_ident)
    my_fwrite(file, (byte*) new_log_ident, (uint)ident_len, 
	      MYF(MY_NABP | MY_WME));
unknown's avatar
unknown committed
755 756 757 758
  fprintf(file, "  pos: %s", llstr(pos, buf));
  if (flags & LOG_EVENT_FORCED_ROTATE_F)
    fprintf(file,"  forced by master");
  fputc('\n', file);
unknown's avatar
unknown committed
759 760 761
  fflush(file);
}

762 763
#endif /* #ifdef MYSQL_CLIENT */

764

765
Start_log_event::Start_log_event(const char* buf,
766 767
				 bool old_format)
  :Log_event(buf, old_format)
768
{
769 770 771
  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,
772
	 ST_SERVER_VER_LEN);
773
  created = uint4korr(buf+ST_CREATED_OFFSET);
774 775
}

776 777
int Start_log_event::write_data(IO_CACHE* file)
{
778 779 780 781
  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);
782
  return (my_b_safe_write(file, (byte*) buff, sizeof(buff)) ? -1 : 0);
783 784
}

785

786
Rotate_log_event::Rotate_log_event(const char* buf, int event_len,
787 788
				   bool old_format)
  :Log_event(buf, old_format),new_log_ident(NULL),alloced(0)
unknown's avatar
unknown committed
789
{
unknown's avatar
unknown committed
790
  // The caller will ensure that event_len is what we have at EVENT_LEN_OFFSET
791 792
  int header_size = (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
  uint ident_offset;
unknown's avatar
unknown committed
793
  if (event_len < header_size)
unknown's avatar
unknown committed
794
    return;
795 796 797
  buf += header_size;
  if (old_format)
  {
unknown's avatar
unknown committed
798
    ident_len = (uint)(event_len - OLD_HEADER_LEN);
799 800 801 802 803
    pos = 4;
    ident_offset = 0;
  }
  else
  {
unknown's avatar
unknown committed
804
    ident_len = (uint)(event_len - ROTATE_EVENT_OVERHEAD);
805 806 807
    pos = uint8korr(buf + R_POS_OFFSET);
    ident_offset = ROTATE_HEADER_LEN;
  }
unknown's avatar
unknown committed
808
  set_if_smaller(ident_len,FN_REFLEN-1);
809 810 811 812
  if (!(new_log_ident= my_strdup_with_length((byte*) buf +
					     ident_offset,
					     (uint) ident_len,
					     MYF(MY_WME))))
unknown's avatar
unknown committed
813 814 815 816
    return;
  alloced = 1;
}

817

818
int Rotate_log_event::write_data(IO_CACHE* file)
unknown's avatar
unknown committed
819
{
820
  char buf[ROTATE_HEADER_LEN];
821
  int8store(buf + R_POS_OFFSET, pos);
822 823
  return (my_b_safe_write(file, (byte*)buf, ROTATE_HEADER_LEN) ||
	  my_b_safe_write(file, (byte*)new_log_ident, (uint) ident_len));
unknown's avatar
unknown committed
824 825
}

826

827 828
#ifndef MYSQL_CLIENT
Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
829
				 ulong query_length, bool using_trans)
830 831
  :Log_event(thd_arg, 0, using_trans), data_buf(0), query(query_arg),
   db(thd_arg->db), q_len((uint32) query_length),
832
  error_code(thd_arg->killed ? ER_SERVER_SHUTDOWN: thd_arg->net.last_errno),
833
  thread_id(thd_arg->thread_id)
834 835 836 837 838 839
{
  time_t end_time;
  time(&end_time);
  exec_time = (ulong) (end_time  - thd->start_time);
  db_len = (db) ? (uint32) strlen(db) : 0;
}
840 841
#endif

842
Query_log_event::Query_log_event(const char* buf, int event_len,
unknown's avatar
unknown committed
843 844
				 bool old_format)
  :Log_event(buf, old_format),data_buf(0), query(NULL), db(NULL)
unknown's avatar
unknown committed
845 846
{
  ulong data_len;
847 848 849 850 851 852 853 854 855 856 857 858 859 860
  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;
  }
unknown's avatar
unknown committed
861

862 863
  exec_time = uint4korr(buf + Q_EXEC_TIME_OFFSET);
  error_code = uint2korr(buf + Q_ERR_CODE_OFFSET);
unknown's avatar
unknown committed
864

865
  if (!(data_buf = (char*) my_malloc(data_len + 1, MYF(MY_WME))))
unknown's avatar
unknown committed
866 867
    return;

868 869
  memcpy(data_buf, buf + Q_DATA_OFFSET, data_len);
  thread_id = uint4korr(buf + Q_THREAD_ID_OFFSET);
unknown's avatar
unknown committed
870
  db = data_buf;
871
  db_len = (uint)buf[Q_DB_LEN_OFFSET];
unknown's avatar
unknown committed
872 873 874 875 876
  query=data_buf + db_len + 1;
  q_len = data_len - 1 - db_len;
  *((char*)query+q_len) = 0;
}

877

878 879
#ifdef MYSQL_CLIENT

880
void Query_log_event::print(FILE* file, bool short_form, char* last_db)
unknown's avatar
unknown committed
881
{
882
  char buff[40],*end;				// Enough for SET TIMESTAMP
unknown's avatar
unknown committed
883 884
  if (!short_form)
  {
885
    print_header(file);
886 887
    fprintf(file, "\tQuery\tthread_id=%lu\texec_time=%lu\terror_code=%d\n",
	    (ulong) thread_id, (ulong) exec_time, error_code);
unknown's avatar
unknown committed
888 889
  }

890 891
  bool same_db = 0;

unknown's avatar
unknown committed
892
  if (db && last_db)
893 894 895 896
  {
    if (!(same_db = !memcmp(last_db, db, db_len + 1)))
      memcpy(last_db, db, db_len + 1);
  }
897 898
  
  if (db && db[0] && !same_db)
unknown's avatar
unknown committed
899
    fprintf(file, "use %s;\n", db);
900 901 902 903
  end=int10_to_str((long) when, strmov(buff,"SET TIMESTAMP="),10);
  *end++=';';
  *end++='\n';
  my_fwrite(file, (byte*) buff, (uint) (end-buff),MYF(MY_NABP | MY_WME));
unknown's avatar
unknown committed
904 905 906
  my_fwrite(file, (byte*) query, q_len, MYF(MY_NABP | MY_WME));
  fprintf(file, ";\n");
}
907 908
#endif

909

910
int Query_log_event::write_data(IO_CACHE* file)
unknown's avatar
unknown committed
911
{
912 913
  if (!query)
    return -1;
unknown's avatar
unknown committed
914 915
  
  char buf[QUERY_HEADER_LEN]; 
916 917
  int4store(buf + Q_THREAD_ID_OFFSET, thread_id);
  int4store(buf + Q_EXEC_TIME_OFFSET, exec_time);
918
  buf[Q_DB_LEN_OFFSET] = (char) db_len;
919
  int2store(buf + Q_ERR_CODE_OFFSET, error_code);
unknown's avatar
unknown committed
920

921 922 923
  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;
unknown's avatar
unknown committed
924 925
}

926 927
Intvar_log_event::Intvar_log_event(const char* buf, bool old_format)
  :Log_event(buf, old_format)
unknown's avatar
unknown committed
928
{
929
  buf += (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
930 931
  type = buf[I_TYPE_OFFSET];
  val = uint8korr(buf+I_VAL_OFFSET);
unknown's avatar
unknown committed
932 933
}

unknown's avatar
unknown committed
934 935
const char* Intvar_log_event::get_var_type_name()
{
936
  switch(type) {
unknown's avatar
unknown committed
937 938 939 940 941 942
  case LAST_INSERT_ID_EVENT: return "LAST_INSERT_ID";
  case INSERT_ID_EVENT: return "INSERT_ID";
  default: /* impossible */ return "UNKNOWN";
  }
}

943
int Intvar_log_event::write_data(IO_CACHE* file)
unknown's avatar
unknown committed
944 945
{
  char buf[9];
946 947
  buf[I_TYPE_OFFSET] = type;
  int8store(buf + I_VAL_OFFSET, val);
948
  return my_b_safe_write(file, (byte*) buf, sizeof(buf));
unknown's avatar
unknown committed
949 950
}

951
#ifdef MYSQL_CLIENT
952
void Intvar_log_event::print(FILE* file, bool short_form, char* last_db)
unknown's avatar
unknown committed
953 954
{
  char llbuff[22];
955 956 957
  const char *msg;
  LINT_INIT(msg);

unknown's avatar
unknown committed
958
  if (!short_form)
unknown's avatar
unknown committed
959
  {
960
    print_header(file);
unknown's avatar
unknown committed
961 962 963 964
    fprintf(file, "\tIntvar\n");
  }

  fprintf(file, "SET ");
965
  switch (type) {
unknown's avatar
unknown committed
966
  case LAST_INSERT_ID_EVENT:
967
    msg="LAST_INSERT_ID";
unknown's avatar
unknown committed
968 969
    break;
  case INSERT_ID_EVENT:
970
    msg="INSERT_ID";
unknown's avatar
unknown committed
971 972
    break;
  }
973
  fprintf(file, "%s=%s;\n", msg, llstr(val,llbuff));
unknown's avatar
unknown committed
974 975
  fflush(file);
}
976
#endif
unknown's avatar
unknown committed
977

unknown's avatar
unknown committed
978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001
/*****************************************************************************
 *
 *  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)
{
1002
  char llbuff[22],llbuff2[22];
unknown's avatar
unknown committed
1003 1004 1005 1006 1007
  if (!short_form)
  {
    print_header(file);
    fprintf(file, "\tRand\n");
  }
1008
  fprintf(file, "SET @@RAND_SEED1=%s, @@RAND_SEED2=%s;\n",
1009
	  llstr(seed1, llbuff),llstr(seed2, llbuff2));
unknown's avatar
unknown committed
1010 1011 1012
  fflush(file);
}
#endif
1013

1014
int Load_log_event::write_data_header(IO_CACHE* file)
unknown's avatar
unknown committed
1015 1016
{
  char buf[LOAD_HEADER_LEN];
1017 1018 1019 1020 1021 1022
  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);
1023
  return my_b_safe_write(file, (byte*)buf, LOAD_HEADER_LEN);
1024
}
unknown's avatar
unknown committed
1025

1026 1027
int Load_log_event::write_data_body(IO_CACHE* file)
{
1028 1029
  if (sql_ex.write_data(file))
    return 1;
1030 1031
  if (num_fields && fields && field_lens)
  {
1032 1033
    if (my_b_safe_write(file, (byte*)field_lens, num_fields) ||
	my_b_safe_write(file, (byte*)fields, field_block_len))
1034 1035
      return 1;
  }
1036 1037 1038
  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));
unknown's avatar
unknown committed
1039 1040
}

1041

1042

1043 1044
static bool write_str(IO_CACHE *file, char *str, byte length)
{
1045 1046
  return (my_b_safe_write(file, &length, 1) ||
	  my_b_safe_write(file, (byte*) str, (int) length));
1047
}
1048

1049

1050 1051 1052 1053
int sql_ex_info::write_data(IO_CACHE* file)
{
  if (new_format())
  {
1054 1055 1056 1057 1058
    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) ||
1059
	    my_b_safe_write(file,(byte*) &opt_flags,1));
1060 1061 1062 1063
  }
  else
  {
    old_sql_ex old_ex;
1064 1065 1066 1067 1068 1069 1070
    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;
1071
    return my_b_safe_write(file, (byte*) &old_ex, sizeof(old_ex));
1072 1073 1074
  }
}

1075

1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
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;
}
1086

1087

1088 1089 1090 1091 1092
char* sql_ex_info::init(char* buf,char* buf_end,bool use_new_format)
{
  cached_new_format = use_new_format;
  if (use_new_format)
  {
1093
    empty_flags=0;
unknown's avatar
unknown committed
1094 1095 1096 1097 1098 1099
    /*
      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.
unknown's avatar
unknown committed
1100
    */
1101 1102 1103 1104 1105 1106
    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;
1107 1108 1109 1110
    opt_flags = *buf++;
  }
  else
  {
1111
    field_term_len= enclosed_len= line_term_len= line_start_len= escaped_len=1;
1112 1113 1114 1115 1116 1117 1118
    field_term = buf++;			// Use first byte in string
    enclosed=	 buf++;
    line_term=   buf++;
    line_start=  buf++;
    escaped=     buf++;
    opt_flags =  *buf++;
    empty_flags= *buf++;
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
    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;
1129 1130 1131 1132 1133
  }
  return buf;
}


1134
#ifndef MYSQL_CLIENT
1135
Load_log_event::Load_log_event(THD* thd_arg, sql_exchange* ex,
1136
			       const char* db_arg, const char* table_name_arg,
1137
			       List<Item>& fields_arg,
1138 1139
			       enum enum_duplicates handle_dup,
			       bool using_trans)
unknown's avatar
merge  
unknown committed
1140
  :Log_event(thd_arg, 0, using_trans),thread_id(thd_arg->thread_id),
1141
  num_fields(0),fields(0),
1142 1143
  field_lens(0),field_block_len(0),
  table_name(table_name_arg ? table_name_arg : ""),
1144
  db(db_arg), fname(ex->file_name)
unknown's avatar
unknown committed
1145 1146 1147
{
  time_t end_time;
  time(&end_time);
1148
  exec_time = (ulong) (end_time  - thd_arg->start_time);
1149 1150 1151
  /* db can never be a zero pointer in 4.0 */
  db_len = (uint32) strlen(db);
  table_name_len = (uint32) strlen(table_name);
unknown's avatar
unknown committed
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
  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;
1165
    
unknown's avatar
unknown committed
1166
  if (ex->dumpfile)
unknown's avatar
unknown committed
1167
    sql_ex.opt_flags|= DUMPFILE_FLAG;
unknown's avatar
unknown committed
1168
  if (ex->opt_enclosed)
unknown's avatar
unknown committed
1169
    sql_ex.opt_flags|= OPT_ENCLOSED_FLAG;
1170

unknown's avatar
unknown committed
1171
  sql_ex.empty_flags = 0;
1172

1173
  switch (handle_dup) {
unknown's avatar
unknown committed
1174 1175
  case DUP_IGNORE: sql_ex.opt_flags|= IGNORE_FLAG; break;
  case DUP_REPLACE: sql_ex.opt_flags|= REPLACE_FLAG; break;
unknown's avatar
unknown committed
1176 1177
  case DUP_ERROR: break;	
  }
1178

unknown's avatar
unknown committed
1179
  if (!ex->field_term->length())
unknown's avatar
unknown committed
1180
    sql_ex.empty_flags|= FIELD_TERM_EMPTY;
unknown's avatar
unknown committed
1181
  if (!ex->enclosed->length())
unknown's avatar
unknown committed
1182
    sql_ex.empty_flags|= ENCLOSED_EMPTY;
unknown's avatar
unknown committed
1183
  if (!ex->line_term->length())
unknown's avatar
unknown committed
1184
    sql_ex.empty_flags|= LINE_TERM_EMPTY;
unknown's avatar
unknown committed
1185
  if (!ex->line_start->length())
unknown's avatar
unknown committed
1186
    sql_ex.empty_flags|= LINE_START_EMPTY;
unknown's avatar
unknown committed
1187
  if (!ex->escaped->length())
unknown's avatar
unknown committed
1188
    sql_ex.empty_flags|= ESCAPED_EMPTY;
1189
    
unknown's avatar
unknown committed
1190
  skip_lines = ex->skip_lines;
1191

unknown's avatar
unknown committed
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
  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);
1203 1204
  }

unknown's avatar
unknown committed
1205 1206 1207 1208
  field_lens = (const uchar*)field_lens_buf.ptr();
  fields = fields_buf.ptr();
}

1209 1210
#endif

1211 1212 1213 1214 1215
/*
  The caller must do buf[event_len] = 0 before he starts using the
  constructed event.
*/

1216
Load_log_event::Load_log_event(const char* buf, int event_len,
1217 1218
			       bool old_format)
  :Log_event(buf, old_format),num_fields(0),fields(0),
1219
  field_lens(0),field_block_len(0),
1220
  table_name(0),db(0),fname(0)
unknown's avatar
unknown committed
1221
{
1222
  if (!event_len) // derived class, will call copy_log_event() itself
1223
    return;
1224
  copy_log_event(buf, event_len, old_format);
1225 1226
}

1227 1228
int Load_log_event::copy_log_event(const char *buf, ulong event_len,
				   bool old_format)
1229
{
1230
  uint data_len;
1231
  char* buf_end = (char*)buf + event_len;
1232 1233
  uint header_len= old_format ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
  const char* data_head = buf + header_len;
1234 1235 1236 1237 1238 1239
  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);
unknown's avatar
unknown committed
1240
	  
1241
  int body_offset = ((buf[EVENT_TYPE_OFFSET] == LOAD_EVENT) ?
1242
		     LOAD_HEADER_LEN + header_len :
1243
		     get_data_body_offset());
unknown's avatar
unknown committed
1244
  
unknown's avatar
unknown committed
1245
  if ((int) event_len < body_offset)
1246
    return 1;
1247 1248 1249 1250
  /*
    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.
  */
1251 1252 1253 1254 1255 1256
  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;
1257
  if (num_fields > data_len) // simple sanity check against corruption
1258
    return 1;
1259
  for (uint i = 0; i < num_fields; i++)
1260
    field_block_len += (uint)field_lens[i] + 1;
1261

unknown's avatar
unknown committed
1262 1263 1264 1265
  fields = (char*)field_lens + num_fields;
  table_name  = fields + field_block_len;
  db = table_name + table_name_len + 1;
  fname = db + db_len + 1;
1266 1267
  fname_len = strlen(fname);
  // null termination is accomplished by the caller doing buf[event_len]=0
1268
  return 0;
unknown's avatar
unknown committed
1269 1270
}

1271
#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
1272

1273
void Load_log_event::print(FILE* file, bool short_form, char* last_db)
unknown's avatar
unknown committed
1274 1275 1276
{
  if (!short_form)
  {
1277
    print_header(file);
1278
    fprintf(file, "\tQuery\tthread_id=%ld\texec_time=%ld\n",
unknown's avatar
unknown committed
1279 1280 1281
	    thread_id, exec_time);
  }

1282
  bool same_db = 0;
unknown's avatar
unknown committed
1283 1284 1285 1286 1287
  if (db && last_db)
  {
    if (!(same_db = !memcmp(last_db, db, db_len + 1)))
      memcpy(last_db, db, db_len + 1);
  }
1288
  
unknown's avatar
unknown committed
1289
  if (db && db[0] && !same_db)
unknown's avatar
unknown committed
1290 1291
    fprintf(file, "use %s;\n", db);

unknown's avatar
unknown committed
1292 1293 1294 1295
  fprintf(file, "LOAD DATA ");
  if (check_fname_outside_temp_buf())
    fprintf(file, "LOCAL ");
  fprintf(file, "INFILE '%-*s' ", fname_len, fname);
unknown's avatar
unknown committed
1296

unknown's avatar
unknown committed
1297
  if (sql_ex.opt_flags & REPLACE_FLAG )
unknown's avatar
unknown committed
1298
    fprintf(file," REPLACE ");
unknown's avatar
unknown committed
1299
  else if (sql_ex.opt_flags & IGNORE_FLAG )
unknown's avatar
unknown committed
1300 1301 1302
    fprintf(file," IGNORE ");
  
  fprintf(file, "INTO TABLE %s ", table_name);
unknown's avatar
unknown committed
1303
  if (sql_ex.field_term)
unknown's avatar
unknown committed
1304 1305
  {
    fprintf(file, " FIELDS TERMINATED BY ");
1306
    pretty_print_str(file, sql_ex.field_term, sql_ex.field_term_len);
unknown's avatar
unknown committed
1307 1308
  }

unknown's avatar
unknown committed
1309
  if (sql_ex.enclosed)
unknown's avatar
unknown committed
1310
  {
unknown's avatar
unknown committed
1311
    if (sql_ex.opt_flags & OPT_ENCLOSED_FLAG )
unknown's avatar
unknown committed
1312 1313
      fprintf(file," OPTIONALLY ");
    fprintf(file, " ENCLOSED BY ");
1314
    pretty_print_str(file, sql_ex.enclosed, sql_ex.enclosed_len);
unknown's avatar
unknown committed
1315 1316
  }
     
1317
  if (sql_ex.escaped)
unknown's avatar
unknown committed
1318 1319
  {
    fprintf(file, " ESCAPED BY ");
1320
    pretty_print_str(file, sql_ex.escaped, sql_ex.escaped_len);
unknown's avatar
unknown committed
1321 1322
  }
     
unknown's avatar
unknown committed
1323
  bool line_lexem_added= false;
1324
  if (sql_ex.line_term)
unknown's avatar
unknown committed
1325 1326
  {
    fprintf(file," LINES TERMINATED BY ");
1327
    pretty_print_str(file, sql_ex.line_term, sql_ex.line_term_len);
unknown's avatar
unknown committed
1328
    line_lexem_added= true;
unknown's avatar
unknown committed
1329 1330
  }

1331
  if (sql_ex.line_start)
unknown's avatar
unknown committed
1332
  {
unknown's avatar
unknown committed
1333 1334 1335
    if (!line_lexem_added)
      fprintf(file," LINES");
    fprintf(file," STARTING BY ");
1336
    pretty_print_str(file, sql_ex.line_start, sql_ex.line_start_len);
unknown's avatar
unknown committed
1337 1338
  }
     
unknown's avatar
unknown committed
1339
  if ((int)skip_lines > 0)
unknown's avatar
unknown committed
1340
    fprintf(file, " IGNORE %ld LINES ", (long) skip_lines);
unknown's avatar
unknown committed
1341

1342 1343 1344 1345
  if (num_fields)
  {
    uint i;
    const char* field = fields;
1346 1347
    fprintf(file, " (");
    for (i = 0; i < num_fields; i++)
unknown's avatar
unknown committed
1348
    {
unknown's avatar
unknown committed
1349
      if (i)
1350 1351
	fputc(',', file);
      fprintf(file, field);
unknown's avatar
unknown committed
1352
	  
1353
      field += field_lens[i]  + 1;
unknown's avatar
unknown committed
1354
    }
1355 1356
    fputc(')', file);
  }
unknown's avatar
unknown committed
1357 1358 1359 1360

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

1361 1362
#endif /* #ifdef MYSQL_CLIENT */

unknown's avatar
unknown committed
1363 1364
#ifndef MYSQL_CLIENT

1365
void Log_event::set_log_pos(MYSQL_LOG* log)
1366 1367 1368 1369 1370
{
  if (!log_pos)
    log_pos = my_b_tell(&log->log_file);
}

1371

1372
void Load_log_event::set_fields(List<Item> &field_list)
unknown's avatar
unknown committed
1373 1374
{
  uint i;
1375 1376
  const char *field= fields;
  for (i= 0; i < num_fields; i++)
unknown's avatar
unknown committed
1377
  {
1378 1379
    field_list.push_back(new Item_field(db, table_name, field));	  
    field+= field_lens[i]  + 1;
unknown's avatar
unknown committed
1380
  }
unknown's avatar
unknown committed
1381 1382
}

unknown's avatar
unknown committed
1383

1384 1385
Slave_log_event::Slave_log_event(THD* thd_arg,
				 struct st_relay_log_info* rli):
1386
  Log_event(thd_arg,0,0),mem_pool(0),master_host(0)
1387
{
1388
  DBUG_ENTER("Slave_log_event");
1389
  if (!rli->inited)				// QQ When can this happen ?
1390
    DBUG_VOID_RETURN;
1391 1392
  
  MASTER_INFO* mi = rli->mi;
unknown's avatar
unknown committed
1393
  // TODO: re-write this better without holding both locks at the same time
1394 1395
  pthread_mutex_lock(&mi->data_lock);
  pthread_mutex_lock(&rli->data_lock);
1396
  master_host_len = strlen(mi->host);
1397
  master_log_len = strlen(rli->master_log_name);
1398
  // on OOM, just do not initialize the structure and print the error
unknown's avatar
unknown committed
1399 1400
  if ((mem_pool = (char*)my_malloc(get_data_size() + 1,
				   MYF(MY_WME))))
1401
  {
unknown's avatar
unknown committed
1402
    master_host = mem_pool + SL_MASTER_HOST_OFFSET ;
1403 1404
    memcpy(master_host, mi->host, master_host_len + 1);
    master_log = master_host + master_host_len + 1;
1405
    memcpy(master_log, rli->master_log_name, master_log_len + 1);
1406
    master_port = mi->port;
1407
    master_pos = rli->master_log_pos;
1408 1409
    DBUG_PRINT("info", ("master_log: %s  pos: %d", master_log,
			(ulong) master_pos));
1410 1411 1412
  }
  else
    sql_print_error("Out of memory while recording slave event");
1413 1414
  pthread_mutex_unlock(&rli->data_lock);
  pthread_mutex_unlock(&mi->data_lock);
1415
  DBUG_VOID_RETURN;
1416 1417
}

1418
#endif /* ! MYSQL_CLIENT */
1419 1420 1421 1422 1423 1424 1425


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

1426 1427
#ifdef MYSQL_CLIENT

1428
void Slave_log_event::print(FILE* file, bool short_form, char* last_db)
1429 1430
{
  char llbuff[22];
unknown's avatar
unknown committed
1431
  if (short_form)
1432 1433 1434
    return;
  print_header(file);
  fputc('\n', file);
1435 1436
  fprintf(file, "Slave: master_host: '%s'  master_port: %d  \
master_log: '%s'  master_pos: %s\n",
unknown's avatar
unknown committed
1437
	  master_host, master_port, master_log, llstr(master_pos, llbuff));
1438 1439
}

1440
#endif /* MYSQL_CLIENT */
1441

1442 1443
int Slave_log_event::get_data_size()
{
unknown's avatar
unknown committed
1444
  return master_host_len + master_log_len + 1 + SL_MASTER_HOST_OFFSET;
1445 1446 1447 1448
}

int Slave_log_event::write_data(IO_CACHE* file)
{
1449 1450
  int8store(mem_pool + SL_MASTER_POS_OFFSET, master_pos);
  int2store(mem_pool + SL_MASTER_PORT_OFFSET, master_port);
1451
  // log and host are already there
1452
  return my_b_safe_write(file, (byte*)mem_pool, get_data_size());
1453 1454
}

1455

1456 1457
void Slave_log_event::init_from_mem_pool(int data_size)
{
1458 1459 1460
  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;
1461 1462
  master_host_len = strlen(master_host);
  // safety
unknown's avatar
unknown committed
1463
  master_log = master_host + master_host_len + 1;
unknown's avatar
unknown committed
1464
  if (master_log > mem_pool + data_size)
1465 1466 1467 1468 1469 1470 1471
  {
    master_host = 0;
    return;
  }
  master_log_len = strlen(master_log);
}

1472 1473
Slave_log_event::Slave_log_event(const char* buf, int event_len)
  :Log_event(buf,0),mem_pool(0),master_host(0)
1474
{
unknown's avatar
unknown committed
1475
  event_len -= LOG_EVENT_HEADER_LEN;
unknown's avatar
unknown committed
1476
  if (event_len < 0)
unknown's avatar
unknown committed
1477
    return;
1478
  if (!(mem_pool = (char*) my_malloc(event_len + 1, MYF(MY_WME))))
1479
    return;
unknown's avatar
unknown committed
1480
  memcpy(mem_pool, buf + LOG_EVENT_HEADER_LEN, event_len);
1481 1482 1483
  mem_pool[event_len] = 0;
  init_from_mem_pool(event_len);
}
1484 1485

#ifndef MYSQL_CLIENT
1486 1487 1488 1489 1490 1491 1492
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),
1493 1494
   fake_base(0),block(block_arg),block_len(block_len_arg),
   file_id(thd_arg->file_id = mysql_bin_log.next_file_id())
1495
{
1496
  sql_ex.force_new_format();
1497 1498 1499
}
#endif

1500 1501 1502 1503 1504
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;
1505 1506
  return (my_b_safe_write(file, (byte*) "", 1) ||
	  my_b_safe_write(file, (byte*) block, block_len));
1507 1508 1509
}

int Create_file_log_event::write_data_header(IO_CACHE* file)
1510
{
1511 1512 1513
  int res;
  if ((res = Load_log_event::write_data_header(file)) || fake_base)
    return res;
unknown's avatar
unknown committed
1514
  byte buf[CREATE_FILE_HEADER_LEN];
1515
  int4store(buf + CF_FILE_ID_OFFSET, file_id);
1516
  return my_b_safe_write(file, buf, CREATE_FILE_HEADER_LEN);
1517 1518 1519 1520 1521 1522 1523 1524 1525
}

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;
1526 1527
}

unknown's avatar
unknown committed
1528
Create_file_log_event::Create_file_log_event(const char* buf, int len,
1529 1530
					     bool old_format)
  :Load_log_event(buf,0,old_format),fake_base(0),block(0),inited_from_old(0)
1531
{
1532
  int block_offset;
unknown's avatar
unknown committed
1533
  if (copy_log_event(buf,len,old_format))
1534
    return;
unknown's avatar
unknown committed
1535 1536 1537 1538
  if (!old_format)
  {
    file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN +
			+ LOAD_HEADER_LEN + CF_FILE_ID_OFFSET);
1539 1540 1541
    // + 1 for \0 terminating fname  
    block_offset = (LOG_EVENT_HEADER_LEN + Load_log_event::get_data_size() +
		    CREATE_FILE_HEADER_LEN + 1);
unknown's avatar
unknown committed
1542 1543 1544 1545 1546 1547 1548 1549 1550 1551
    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;
  }
1552
}
1553 1554


1555
#ifdef MYSQL_CLIENT
unknown's avatar
unknown committed
1556 1557
void Create_file_log_event::print(FILE* file, bool short_form, 
				  char* last_db, bool enable_local)
1558
{
1559
  if (short_form)
unknown's avatar
unknown committed
1560 1561 1562
  {
    if (enable_local && check_fname_outside_temp_buf())
      Load_log_event::print(file, 1, last_db);
1563
    return;
unknown's avatar
unknown committed
1564 1565 1566 1567 1568 1569 1570 1571 1572 1573
  }

  if (enable_local)
  {
    if (!check_fname_outside_temp_buf())
      fprintf(file, "#");
    Load_log_event::print(file, 1, last_db);
    fprintf(file, "#");
  }

unknown's avatar
unknown committed
1574
  fprintf(file, " file_id: %d  block_len: %d\n", file_id, block_len);
1575
}
unknown's avatar
unknown committed
1576 1577 1578 1579 1580 1581

void Create_file_log_event::print(FILE* file, bool short_form,
				  char* last_db)
{
  print(file,short_form,last_db,0);
}
1582 1583 1584 1585 1586
#endif

#ifndef MYSQL_CLIENT
void Create_file_log_event::pack_info(String* packet)
{
1587
  char buf1[256],buf[22], *end;
1588 1589 1590 1591 1592
  String tmp(buf1, sizeof(buf1));
  tmp.length(0);
  tmp.append("db=");
  tmp.append(db, db_len);
  tmp.append(";table=");
1593
  tmp.append(table_name, table_name_len);
1594
  tmp.append(";file_id=");
1595 1596
  end= int10_to_str((long) file_id, buf, 10);
  tmp.append(buf, (uint32) (end-buf));
1597
  tmp.append(";block_len=");
1598 1599 1600
  end= int10_to_str((long) block_len, buf, 10);
  tmp.append(buf, (uint32) (end-buf));
  net_store_data(packet, (char*) tmp.ptr(), tmp.length());
1601 1602 1603 1604 1605
}
#endif  

#ifndef MYSQL_CLIENT  
Append_block_log_event::Append_block_log_event(THD* thd_arg, char* block_arg,
1606 1607 1608 1609
					       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)
1610 1611 1612 1613
{
}
#endif  
  
1614 1615
Append_block_log_event::Append_block_log_event(const char* buf, int len)
  :Log_event(buf, 0),block(0)
1616
{
unknown's avatar
unknown committed
1617
  if ((uint)len < APPEND_BLOCK_EVENT_OVERHEAD)
1618 1619 1620 1621 1622 1623 1624 1625
    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)
{
unknown's avatar
unknown committed
1626
  byte buf[APPEND_BLOCK_HEADER_LEN];
1627
  int4store(buf + AB_FILE_ID_OFFSET, file_id);
1628 1629
  return (my_b_safe_write(file, buf, APPEND_BLOCK_HEADER_LEN) ||
	  my_b_safe_write(file, (byte*) block, block_len));
1630 1631 1632
}

#ifdef MYSQL_CLIENT  
1633 1634
void Append_block_log_event::print(FILE* file, bool short_form,
				   char* last_db)
1635 1636 1637 1638 1639
{
  if (short_form)
    return;
  print_header(file);
  fputc('\n', file);
unknown's avatar
unknown committed
1640
  fprintf(file, "#Append_block: file_id: %d  block_len: %d\n",
1641 1642 1643
	  file_id, block_len);
}
#endif  
1644

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

1653 1654
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)
1655 1656 1657 1658
{
}
#endif  

1659 1660 1661

Delete_file_log_event::Delete_file_log_event(const char* buf, int len)
  :Log_event(buf, 0),file_id(0)
1662
{
unknown's avatar
unknown committed
1663
  if ((uint)len < DELETE_FILE_EVENT_OVERHEAD)
1664 1665 1666 1667
    return;
  file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + AB_FILE_ID_OFFSET);
}

1668

1669 1670
int Delete_file_log_event::write_data(IO_CACHE* file)
{
unknown's avatar
unknown committed
1671
 byte buf[DELETE_FILE_HEADER_LEN];
1672
 int4store(buf + DF_FILE_ID_OFFSET, file_id);
1673
 return my_b_safe_write(file, buf, DELETE_FILE_HEADER_LEN);
1674 1675 1676
}

#ifdef MYSQL_CLIENT  
1677 1678
void Delete_file_log_event::print(FILE* file, bool short_form,
				  char* last_db)
1679 1680 1681 1682 1683
{
  if (short_form)
    return;
  print_header(file);
  fputc('\n', file);
1684
  fprintf(file, "#Delete_file: file_id=%u\n", file_id);
1685 1686
}
#endif  
1687

1688 1689 1690
#ifndef MYSQL_CLIENT
void Delete_file_log_event::pack_info(String* packet)
{
1691 1692 1693
  char buf1[64];
  sprintf(buf1, ";file_id=%u", (uint) file_id);
  net_store_data(packet, buf1);
1694 1695 1696
}
#endif  

1697

1698
#ifndef MYSQL_CLIENT  
1699 1700
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)
1701 1702 1703 1704
{
}
#endif  
  
1705 1706
Execute_load_log_event::Execute_load_log_event(const char* buf, int len)
  :Log_event(buf, 0), file_id(0)
1707
{
unknown's avatar
unknown committed
1708
  if ((uint)len < EXEC_LOAD_EVENT_OVERHEAD)
1709 1710 1711 1712 1713 1714
    return;
  file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + EL_FILE_ID_OFFSET);
}

int Execute_load_log_event::write_data(IO_CACHE* file)
{
unknown's avatar
unknown committed
1715 1716
  byte buf[EXEC_LOAD_HEADER_LEN];
  int4store(buf + EL_FILE_ID_OFFSET, file_id);
1717
  return my_b_safe_write(file, buf, EXEC_LOAD_HEADER_LEN);
1718 1719 1720
}

#ifdef MYSQL_CLIENT  
1721 1722
void Execute_load_log_event::print(FILE* file, bool short_form,
				   char* last_db)
1723 1724 1725 1726 1727 1728 1729
{
  if (short_form)
    return;
  print_header(file);
  fputc('\n', file);
  fprintf(file, "#Exec_load: file_id=%d\n",
	  file_id);
1730 1731
}
#endif  
1732 1733 1734
#ifndef MYSQL_CLIENT
void Execute_load_log_event::pack_info(String* packet)
{
1735 1736 1737
  char buf[64];
  sprintf(buf, ";file_id=%u", (uint) file_id);
  net_store_data(packet, buf);
1738 1739 1740
}
#endif

1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751
#ifdef MYSQL_CLIENT
void Unknown_log_event::print(FILE* file, bool short_form, char* last_db)
{
  if (short_form)
    return;
  print_header(file);
  fputc('\n', file);
  fprintf(file, "# %s", "Unknown event\n");
}
#endif  

1752
#ifndef MYSQL_CLIENT
1753
int Query_log_event::exec_event(struct st_relay_log_info* rli)
1754 1755 1756 1757
{
  int expected_error,actual_error = 0;
  init_sql_alloc(&thd->mem_root, 8192,0);
  thd->db = rewrite_db((char*)db);
1758 1759 1760 1761 1762 1763 1764 1765

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

1766 1767 1768 1769
  if (db_ok(thd->db, replicate_do_db, replicate_ignore_db))
  {
    thd->set_time((time_t)when);
    thd->current_tablenr = 0;
1770
    thd->query_length= q_len;
1771
    VOID(pthread_mutex_lock(&LOCK_thread_count));
1772
    thd->query = (char*)query;
1773 1774 1775 1776 1777
    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;
1778
    thd->slave_proxy_id = thread_id;		// for temp tables
1779
	
1780 1781 1782 1783
    /*
      Sanity check to make sure the master did not get a really bad
      error on the query.
    */
1784 1785
    if (ignored_error_code((expected_error = error_code)) ||
	!check_expected_error(thd,rli,expected_error))
1786
    {
unknown's avatar
unknown committed
1787 1788
      mysql_log.write(thd,COM_QUERY,"%s",thd->query);
      DBUG_PRINT("query",("%s",thd->query));
1789
      mysql_parse(thd, thd->query, q_len);
1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802

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

1803 1804
      if ((expected_error != (actual_error = thd->net.last_errno)) &&
	  expected_error &&
unknown's avatar
unknown committed
1805 1806
	  !ignored_error_code(actual_error) &&
	  !ignored_error_code(expected_error))
1807 1808
      {
	const char* errmsg = "Slave: did not get the expected error\
unknown's avatar
unknown committed
1809
 running query from master - expected: '%s' (%d), got '%s' (%d)"; 
1810 1811
	sql_print_error(errmsg, ER_SAFE(expected_error),
			expected_error,
unknown's avatar
unknown committed
1812
			actual_error ? thd->net.last_error: "no error",
1813 1814 1815
			actual_error);
	thd->query_error = 1;
      }
1816 1817
      else if (expected_error == actual_error ||
	       ignored_error_code(actual_error))
1818 1819
      {
	thd->query_error = 0;
1820 1821
	*rli->last_slave_error = 0;
	rli->last_slave_errno = 0;
1822 1823 1824 1825 1826
      }
    }
    else
    {
      // master could be inconsistent, abort and tell DBA to check/fix it
1827
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1828
      thd->db = thd->query = 0;
1829
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1830
      thd->variables.convert_set = 0;
1831 1832 1833 1834 1835
      close_thread_tables(thd);
      free_root(&thd->mem_root,0);
      return 1;
    }
  }
1836
  thd->db= 0;				// prevent db from being freed
1837
  VOID(pthread_mutex_lock(&LOCK_thread_count));
1838
  thd->query= 0;			// just to be sure
1839
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
1840
  // assume no convert for next query unless set explictly
unknown's avatar
unknown committed
1841
  thd->variables.convert_set = 0;
1842 1843 1844 1845
  close_thread_tables(thd);
      
  if (thd->query_error || thd->fatal_error)
  {
1846
    slave_print_error(rli,actual_error, "error '%s' on query '%s'",
1847 1848
		      actual_error ? thd->net.last_error :
		      "unexpected success or fatal error", query);
1849 1850 1851 1852
    free_root(&thd->mem_root,0);
    return 1;
  }
  free_root(&thd->mem_root,0);
1853
  return Log_event::exec_event(rli); 
1854 1855
}

1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
/*
  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
*/
1881

1882 1883
int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli, 
			       bool use_rli_only_for_errors)
1884 1885 1886
{
  init_sql_alloc(&thd->mem_root, 8192,0);
  thd->db = rewrite_db((char*)db);
1887 1888
  DBUG_ASSERT(thd->query == 0);
  thd->query = 0;				// Should not be needed
1889 1890
  thd->query_error = 0;
	    
unknown's avatar
unknown committed
1891
  if (db_ok(thd->db, replicate_do_db, replicate_ignore_db))
1892 1893 1894 1895 1896 1897 1898 1899 1900 1901
  {
    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;
1902
    tables.alias = tables.real_name = (char*)table_name;
1903
    tables.lock_type = TL_WRITE;
1904
    tables.updating= 1;
1905
    // the table will be opened in mysql_load    
unknown's avatar
unknown committed
1906
    if (table_rules_on && !tables_ok(thd, &tables))
1907
    {
1908
      // TODO: this is a bug - this needs to be moved to the I/O thread
1909 1910 1911 1912 1913 1914
      if (net)
        skip_load_data_infile(net);
    }
    else
    {
      char llbuff[22];
1915
      enum enum_duplicates handle_dup;
unknown's avatar
unknown committed
1916
      if (sql_ex.opt_flags & REPLACE_FLAG)
unknown's avatar
unknown committed
1917
	handle_dup= DUP_REPLACE;
1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935
      else if (sql_ex.opt_flags & IGNORE_FLAG)
        handle_dup= DUP_IGNORE;
      else
        /*
          Note that when replication is running fine, if it was DUP_ERROR on the 
          master then we could choose DUP_IGNORE here, because if DUP_ERROR
          suceeded on master, and data is identical on the master and slave,
          then there should be no uniqueness errors on slave, so DUP_IGNORE is
          the same as DUP_ERROR. But in the unlikely case of uniqueness errors
          (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.

          If reading from net (a 3.23 master), mysql_load() will change this
          to DUP_IGNORE.
        */
        handle_dup= DUP_ERROR;

unknown's avatar
unknown committed
1936
      sql_exchange ex((char*)fname, sql_ex.opt_flags & DUMPFILE_FLAG);
1937 1938 1939 1940 1941
      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);
1942 1943 1944 1945 1946
      ex.field_term= &field_term;
      ex.enclosed= &enclosed;
      ex.line_term= &line_term;
      ex.line_start= &line_start;
      ex.escaped= &escaped;
1947 1948
	    
      ex.opt_enclosed = (sql_ex.opt_flags & OPT_ENCLOSED_FLAG);
1949
      if (sql_ex.empty_flags & FIELD_TERM_EMPTY)
1950
	ex.field_term->length(0);
1951

1952
      ex.skip_lines = skip_lines;
1953 1954
      List<Item> field_list;
      set_fields(field_list);
1955
      thd->slave_proxy_id = thread_id;
1956 1957 1958 1959
      if (net)
      {
	// mysql_load will use thd->net to read the file
	thd->net.vio = net->vio;
1960 1961 1962
	/*
	  Make sure the client does not get confused about the packet sequence
	*/
1963 1964
	thd->net.pkt_nr = net->pkt_nr;
      }
1965
      if (mysql_load(thd, &ex, &tables, field_list, handle_dup, net != 0,
1966
		     TL_WRITE))
1967
	thd->query_error = 1;
unknown's avatar
unknown committed
1968
      if (thd->cuted_fields)
1969 1970 1971 1972
	/* 
	   log_pos is the position of the LOAD
	   event in the master log
	*/
1973
	sql_print_error("Slave: load data infile at position %s in log \
1974
'%s' produced %d warning(s)", llstr(log_pos,llbuff), RPL_LOG_NAME, 
1975
			thd->cuted_fields );
unknown's avatar
unknown committed
1976
      if (net)
1977
        net->pkt_nr= thd->net.pkt_nr;
1978 1979 1980 1981
    }
  }
  else
  {
1982 1983 1984 1985 1986
    /*
      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
    */
1987 1988 1989 1990 1991
    if (net)
      skip_load_data_infile(net);
  }
	    
  thd->net.vio = 0; 
1992
  thd->db= 0;					// prevent db from being freed
1993
  close_thread_tables(thd);
unknown's avatar
unknown committed
1994
  if (thd->query_error)
1995
  {
1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006
    /* this err/sql_errno code is copy-paste from send_error() */
    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);       
    }
    slave_print_error(rli,sql_errno,
2007
		      "Error '%s' running load data infile",
2008
		      err);
2009 2010 2011 2012 2013
    free_root(&thd->mem_root,0);
    return 1;
  }
  free_root(&thd->mem_root,0);
	    
unknown's avatar
unknown committed
2014
  if (thd->fatal_error)
2015
  {
2016
    sql_print_error("Fatal error running LOAD DATA INFILE ");
2017 2018 2019
    return 1;
  }

2020
  return ( use_rli_only_for_errors ? 0 : Log_event::exec_event(rli) ); 
2021 2022
}

2023

2024 2025 2026 2027 2028
/*
  The master started

  IMPLEMENTATION
    - To handle the case where the master died without a stop event,
unknown's avatar
unknown committed
2029 2030
      we clean up all temporary tables that we got, if we are sure we
      can (see below).
2031 2032 2033 2034 2035 2036 2037 2038

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

2039
int Start_log_event::exec_event(struct st_relay_log_info* rli)
2040
{
unknown's avatar
unknown committed
2041 2042 2043

  switch (rli->mi->old_format) {
  case BINLOG_FORMAT_CURRENT : 
unknown's avatar
unknown committed
2044
    /* 
unknown's avatar
unknown committed
2045 2046
       This is 4.x, so a Start_log_event is only at master startup,
       so we are sure the master has restarted and cleared his temp tables.
unknown's avatar
unknown committed
2047 2048
    */
    close_temporary_tables(thd);
unknown's avatar
unknown committed
2049 2050 2051 2052 2053 2054 2055
    cleanup_load_tmpdir();
    break;
  /* 
     Now the older formats; in that case load_tmpdir is cleaned up by the I/O
     thread.
  */
  case BINLOG_FORMAT_323_LESS_57 :
unknown's avatar
unknown committed
2056
    /*
unknown's avatar
unknown committed
2057 2058 2059
      Cannot distinguish a Start_log_event generated at master startup and
      one generated by master FLUSH LOGS, so cannot be sure temp tables
      have to be dropped. So do nothing.
unknown's avatar
unknown committed
2060
    */
unknown's avatar
unknown committed
2061 2062 2063 2064 2065 2066 2067 2068 2069
    break;
 case BINLOG_FORMAT_323_GEQ_57 : 
    /* Can distinguish, based on the value of 'created' */
    if (created) /* this was generated at master startup*/
      close_temporary_tables(thd);
    break;
  default :
    /* this case is impossible */
    return 1;
unknown's avatar
unknown committed
2070
  }
unknown's avatar
unknown committed
2071

2072
  return Log_event::exec_event(rli);
2073 2074
}

2075

2076 2077 2078 2079 2080 2081 2082 2083
/*
  The master stopped. Clean up all temporary tables + locks that the
  master may have set.

  TODO
    - Remove all active user locks
*/

2084
int Stop_log_event::exec_event(struct st_relay_log_info* rli)
2085
{
unknown's avatar
unknown committed
2086 2087 2088 2089 2090 2091 2092 2093
  /*
    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.
  */
2094
  if (rli->master_log_pos > BIN_LOG_HEADER_SIZE) 
2095 2096
  {
    close_temporary_tables(thd);
2097
    cleanup_load_tmpdir();
2098
  }
unknown's avatar
unknown committed
2099 2100
  /*
    We do not want to update master_log pos because we get a rotate event
2101 2102
    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
unknown's avatar
unknown committed
2103
    could give false triggers in MASTER_POS_WAIT() that we have reached
2104
    the target position when in fact we have not.
unknown's avatar
unknown committed
2105
  */
2106 2107
  rli->inc_pos(get_event_len(), 0);  
  flush_relay_log_info(rli);
2108 2109 2110
  return 0;
}

2111 2112 2113 2114 2115

/*
  Got a rotate log even from the master

  IMPLEMENTATION
unknown's avatar
unknown committed
2116 2117
    This is mainly used so that we can later figure out the logname and
    position for the master.
2118

unknown's avatar
unknown committed
2119 2120
    We can't rotate the slave as this will cause infinitive rotations
    in a A -> B -> A setup.
2121 2122

  RETURN VALUES
unknown's avatar
unknown committed
2123 2124
    0	ok
 */
2125 2126
  

2127
int Rotate_log_event::exec_event(struct st_relay_log_info* rli)
2128
{
2129
  char* log_name = rli->master_log_name;
2130 2131
  DBUG_ENTER("Rotate_log_event::exec_event");

2132
  pthread_mutex_lock(&rli->data_lock);
unknown's avatar
unknown committed
2133
  memcpy(log_name, new_log_ident, ident_len+1);
2134 2135
  rli->master_log_pos = pos;
  rli->relay_log_pos += get_event_len();
2136
  DBUG_PRINT("info", ("master_log_pos: %d", (ulong) rli->master_log_pos));
2137
  pthread_mutex_unlock(&rli->data_lock);
unknown's avatar
unknown committed
2138
  pthread_cond_broadcast(&rli->data_cond);
2139
  flush_relay_log_info(rli);
2140
  DBUG_RETURN(0);
2141 2142
}

unknown's avatar
unknown committed
2143

2144
int Intvar_log_event::exec_event(struct st_relay_log_info* rli)
2145
{
2146
  switch (type) {
2147 2148 2149 2150 2151 2152 2153 2154
  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;
  }
2155
  rli->inc_pending(get_event_len());
2156 2157 2158
  return 0;
}

unknown's avatar
unknown committed
2159 2160
int Rand_log_event::exec_event(struct st_relay_log_info* rli)
{
2161 2162
  thd->rand.seed1 = (ulong) seed1;
  thd->rand.seed2 = (ulong) seed2;
unknown's avatar
unknown committed
2163 2164 2165 2166
  rli->inc_pending(get_event_len());
  return 0;
}

2167
int Slave_log_event::exec_event(struct st_relay_log_info* rli)
2168
{
unknown's avatar
unknown committed
2169
  if (mysql_bin_log.is_open())
2170
    mysql_bin_log.write(this);
2171
  return Log_event::exec_event(rli);
2172 2173
}

2174
int Create_file_log_event::exec_event(struct st_relay_log_info* rli)
2175 2176
{
  char fname_buf[FN_REFLEN+10];
unknown's avatar
unknown committed
2177
  char *p;
2178 2179 2180
  int fd = -1;
  IO_CACHE file;
  int error = 1;
unknown's avatar
unknown committed
2181

2182
  bzero((char*)&file, sizeof(file));
unknown's avatar
unknown committed
2183 2184
  p = slave_load_file_stem(fname_buf, file_id, server_id);
  strmov(p, ".info");			// strmov takes less code than memcpy
2185 2186 2187 2188 2189
  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)))
  {
2190
    slave_print_error(rli,my_errno, "Could not open file '%s'", fname_buf);
2191 2192 2193 2194
    goto err;
  }
  
  // a trick to avoid allocating another buffer
unknown's avatar
unknown committed
2195
  strmov(p, ".data");
2196 2197 2198 2199
  fname = fname_buf;
  fname_len = (uint)(p-fname) + 5;
  if (write_base(&file))
  {
unknown's avatar
unknown committed
2200
    strmov(p, ".info"); // to have it right in the error message
2201
    slave_print_error(rli,my_errno, "Could not write to file '%s'", fname_buf);
2202 2203 2204 2205 2206 2207 2208 2209 2210
    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)
  {
2211
    slave_print_error(rli,my_errno, "Could not open file '%s'", fname_buf);
2212 2213
    goto err;
  }
unknown's avatar
unknown committed
2214
  if (my_write(fd, (byte*) block, block_len, MYF(MY_WME+MY_NABP)))
2215
  {
2216
    slave_print_error(rli,my_errno, "Write to '%s' failed", fname_buf);
2217 2218 2219 2220
    goto err;
  }
  if (mysql_bin_log.is_open())
    mysql_bin_log.write(this);
2221 2222
  error=0;					// Everything is ok

2223 2224 2225 2226 2227
err:
  if (error)
    end_io_cache(&file);
  if (fd >= 0)
    my_close(fd, MYF(0));
2228
  return error ? 1 : Log_event::exec_event(rli);
2229 2230
}

2231
int Delete_file_log_event::exec_event(struct st_relay_log_info* rli)
2232 2233
{
  char fname[FN_REFLEN+10];
2234
  char *p= slave_load_file_stem(fname, file_id, server_id);
2235
  memcpy(p, ".data", 6);
2236
  (void) my_delete(fname, MYF(MY_WME));
2237
  memcpy(p, ".info", 6);
2238
  (void) my_delete(fname, MYF(MY_WME));
2239 2240
  if (mysql_bin_log.is_open())
    mysql_bin_log.write(this);
2241
  return Log_event::exec_event(rli);
2242 2243
}

2244
int Append_block_log_event::exec_event(struct st_relay_log_info* rli)
2245 2246
{
  char fname[FN_REFLEN+10];
2247 2248
  char *p= slave_load_file_stem(fname, file_id, server_id);
  int fd;
2249
  int error = 1;
2250

2251 2252 2253
  memcpy(p, ".data", 6);
  if ((fd = my_open(fname, O_WRONLY|O_APPEND|O_BINARY, MYF(MY_WME))) < 0)
  {
2254
    slave_print_error(rli,my_errno, "Could not open file '%s'", fname);
2255 2256
    goto err;
  }
unknown's avatar
unknown committed
2257
  if (my_write(fd, (byte*) block, block_len, MYF(MY_WME+MY_NABP)))
2258
  {
2259
    slave_print_error(rli,my_errno, "Write to '%s' failed", fname);
2260 2261 2262 2263 2264
    goto err;
  }
  if (mysql_bin_log.is_open())
    mysql_bin_log.write(this);
  error=0;
2265

2266 2267 2268
err:
  if (fd >= 0)
    my_close(fd, MYF(0));
2269
  return error ? error : Log_event::exec_event(rli);
2270 2271
}

2272
int Execute_load_log_event::exec_event(struct st_relay_log_info* rli)
2273 2274
{
  char fname[FN_REFLEN+10];
2275 2276
  char *p= slave_load_file_stem(fname, file_id, server_id);
  int fd;
2277
  int error = 1;
unknown's avatar
unknown committed
2278
  ulong save_options;
2279 2280
  IO_CACHE file;
  Load_log_event* lev = 0;
2281

2282 2283 2284 2285 2286
  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)))
  {
2287
    slave_print_error(rli,my_errno, "Could not open file '%s'", fname);
2288 2289
    goto err;
  }
2290 2291
  if (!(lev = (Load_log_event*)Log_event::read_log_event(&file,
							 (pthread_mutex_t*)0,
2292 2293
							 (bool)0)) ||
      lev->get_type_code() != NEW_LOAD_EVENT)
2294
  {
2295
    slave_print_error(rli,0, "File '%s' appears corrupted", fname);
2296 2297
    goto err;
  }
unknown's avatar
unknown committed
2298 2299 2300 2301 2302 2303
  /*
    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 .
  */
2304
  save_options = thd->options;
unknown's avatar
unknown committed
2305
  thd->options &= ~ (ulong) (OPTION_BIN_LOG);
2306
  lev->thd = thd;
2307 2308 2309 2310 2311
  /*
    lev->exec_event should use rli only for errors
    i.e. should not advance rli's position
  */
  if (lev->exec_event(0,rli,1)) 
2312
  {
2313
    slave_print_error(rli,my_errno, "Failed executing load from '%s'", fname);
2314 2315 2316 2317
    thd->options = save_options;
    goto err;
  }
  thd->options = save_options;
2318
  (void) my_delete(fname, MYF(MY_WME));
2319
  memcpy(p, ".data", 6);
2320
  (void) my_delete(fname, MYF(MY_WME));
2321 2322 2323
  if (mysql_bin_log.is_open())
    mysql_bin_log.write(this);
  error = 0;
2324

2325 2326 2327
err:
  delete lev;
  if (fd >= 0)
2328
  {
2329
    my_close(fd, MYF(0));
2330 2331
    end_io_cache(&file);
  }
2332
  return error ? error : Log_event::exec_event(rli);
2333 2334
}

2335
#endif /* !MYSQL_CLIENT */