~drizzle-trunk/drizzle/development

/* Copyright (C) 2001-2004 MySQL 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; version 2 of the License.

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

/* 

   TODO: print the catalog (some USE catalog.db ????).

   Standalone program to read a MySQL binary log (or relay log);

   can read files produced by 3.23, 4.x, 5.0 servers. 

   Can read binlogs from 3.23/4.x/5.0 and relay logs from 4.x/5.0.

   Should be able to read any file of these categories, even with

   --start-position.

   An important fact: the Format_desc event of the log is at most the 3rd event

   of the log; if it is the 3rd then there is this combination:

   Format_desc_of_slave, Rotate_of_master, Format_desc_of_master.

*/

#define MYSQL_CLIENT

#undef MYSQL_SERVER

#include "client_priv.h"

#include <my_time.h>

/* That one is necessary for defines of OPTION_NO_FOREIGN_KEY_CHECKS etc */

#include "mysql_priv.h" 

#include "log_event.h"

#include "sql_common.h"

#define BIN_LOG_HEADER_SIZE	4

#define PROBE_HEADER_LEN	(EVENT_LEN_OFFSET+4)

#define CLIENT_CAPABILITIES	(CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_LOCAL_FILES)

char server_version[SERVER_VERSION_LENGTH];

ulong server_id = 0;

// needed by net_serv.c

ulong bytes_sent = 0L, bytes_received = 0L;

ulong mysqld_net_retry_count = 10L;

ulong open_files_limit;

uint test_flags = 0; 

static uint opt_protocol= 0;

static FILE *result_file;

#ifndef DBUG_OFF

static const char* default_dbug_option = "d:t:o,/tmp/mysqlbinlog.trace";

#endif

static const char *load_default_groups[]= { "mysqlbinlog","client",0 };

static void error(const char *format, ...) ATTRIBUTE_FORMAT(printf, 1, 2);

static void warning(const char *format, ...) ATTRIBUTE_FORMAT(printf, 1, 2);

static bool one_database=0, to_last_remote_log= 0, disable_log_bin= 0;

static bool opt_hexdump= 0;

const char *base64_output_mode_names[]= {"NEVER", "AUTO", "ALWAYS", NullS};

TYPELIB base64_output_mode_typelib=

  { array_elements(base64_output_mode_names) - 1, "",

    base64_output_mode_names, NULL };

static enum_base64_output_mode opt_base64_output_mode= BASE64_OUTPUT_UNSPEC;

static const char *opt_base64_output_mode_str= NullS;

static const char* database= 0;

static my_bool force_opt= 0, short_form= 0, remote_opt= 0;

static my_bool debug_info_flag, debug_check_flag;

static my_bool force_if_open_opt= 1;

static ulonglong offset = 0;

static const char* host = 0;

static int port= 0;

static uint my_end_arg;

static const char* sock= 0;

static const char* user = 0;

static char* pass = 0;

static char *charset= 0;

static ulonglong start_position, stop_position;

#define start_position_mot ((my_off_t)start_position)

#define stop_position_mot  ((my_off_t)stop_position)

static char *start_datetime_str, *stop_datetime_str;

static my_time_t start_datetime= 0, stop_datetime= MY_TIME_T_MAX;

static ulonglong rec_count= 0;

static short binlog_flags = 0; 

static MYSQL* mysql = NULL;

static const char* dirname_for_local_load= 0;

/**

  Pointer to the Format_description_log_event of the currently active binlog.

  This will be changed each time a new Format_description_log_event is

  found in the binlog. It is finally destroyed at program termination.

*/

static Format_description_log_event* glob_description_event= NULL;

/**

  Exit status for functions in this file.

*/

enum Exit_status {

  /** No error occurred and execution should continue. */

  OK_CONTINUE= 0,

  /** An error occurred and execution should stop. */

  ERROR_STOP,

  /** No error occurred but execution should stop. */

  OK_STOP

};

static Exit_status dump_local_log_entries(PRINT_EVENT_INFO *print_event_info,

                                          const char* logname);

static Exit_status dump_remote_log_entries(PRINT_EVENT_INFO *print_event_info,

                                           const char* logname);

static Exit_status dump_log_entries(const char* logname);

static Exit_status safe_connect();

class Load_log_processor

{

  char target_dir_name[FN_REFLEN];

  int target_dir_name_len;

  /*

    When we see first event corresponding to some LOAD DATA statement in

    binlog, we create temporary file to store data to be loaded.

    We add name of this file to file_names array using its file_id as index.

    If we have Create_file event (i.e. we have binary log in pre-5.0.3

    format) we also store save event object to be able which is needed to

    emit LOAD DATA statement when we will meet Exec_load_data event.

    If we have Begin_load_query event we simply store 0 in

    File_name_record::event field.

  */

  struct File_name_record

  {

    char *fname;

    Create_file_log_event *event;

  };

  /*

    @todo Should be a map (e.g., a hash map), not an array.  With the

    present implementation, the number of elements in this array is

    about the number of files loaded since the server started, which

    may be big after a few years.  We should be able to use existing

    library data structures for this. /Sven

  */

  DYNAMIC_ARRAY file_names;

  /**

    Looks for a non-existing filename by adding a numerical suffix to

    the given base name, creates the generated file, and returns the

    filename by modifying the filename argument.

    @param[in,out] filename Base filename

    @param[in,out] file_name_end Pointer to last character of

    filename.  The numerical suffix will be written to this position.

    Note that there must be a least five bytes of allocated memory

    after file_name_end.

    @retval -1 Error (can't find new filename).

    @retval >=0 Found file.

  */

  File create_unique_file(char *filename, char *file_name_end)

    {

      File res;

      /* If we have to try more than 1000 times, something is seriously wrong */

      for (uint version= 0; version<1000; version++)

      {

	sprintf(file_name_end,"-%x",version);

	if ((res= my_create(filename,0,

			    O_CREAT|O_EXCL|O_BINARY|O_WRONLY,MYF(0)))!=-1)

	  return res;

      }

      return -1;

    }

public:

  Load_log_processor() {}

  ~Load_log_processor() {}

  int init()

  {

    return init_dynamic_array(&file_names, sizeof(File_name_record),

			      100,100 CALLER_INFO);

  }

  void init_by_dir_name(const char *dir)

    {

      target_dir_name_len= (convert_dirname(target_dir_name, dir, NullS) -

			    target_dir_name);

    }

  void init_by_cur_dir()

    {

      if (my_getwd(target_dir_name,sizeof(target_dir_name),MYF(MY_WME)))

	exit(1);

      target_dir_name_len= strlen(target_dir_name);

    }

  void destroy()

  {

    File_name_record *ptr= (File_name_record *)file_names.buffer;

    File_name_record *end= ptr + file_names.elements;

    for (; ptr < end; ptr++)

    {

      if (ptr->fname)

      {

        my_free(ptr->fname, MYF(MY_WME));

        delete ptr->event;

        bzero((char *)ptr, sizeof(File_name_record));

      }

    }

    delete_dynamic(&file_names);

  }

  /**

    Obtain Create_file event for LOAD DATA statement by its file_id

    and remove it from this Load_log_processor's list of events.

    Checks whether we have already seen a Create_file_log_event with

    the given file_id.  If yes, returns a pointer to the event and

    removes the event from array describing active temporary files.

    From this moment, the caller is responsible for freeing the memory

    occupied by the event.

    @param[in] file_id File id identifying LOAD DATA statement.

    @return Pointer to Create_file_log_event, or NULL if we have not

    seen any Create_file_log_event with this file_id.

  */

  Create_file_log_event *grab_event(uint file_id)

    {

      File_name_record *ptr;

      Create_file_log_event *res;

      if (file_id >= file_names.elements)

        return 0;

      ptr= dynamic_element(&file_names, file_id, File_name_record*);

      if ((res= ptr->event))

        bzero((char *)ptr, sizeof(File_name_record));

      return res;

    }

  /**

    Obtain file name of temporary file for LOAD DATA statement by its

    file_id and remove it from this Load_log_processor's list of events.

    @param[in] file_id Identifier for the LOAD DATA statement.

    Checks whether we have already seen Begin_load_query event for

    this file_id. If yes, returns the file name of the corresponding

    temporary file and removes the filename from the array of active

    temporary files.  From this moment, the caller is responsible for

    freeing the memory occupied by this name.

    @return String with the name of the temporary file, or NULL if we

    have not seen any Begin_load_query_event with this file_id.

  */

  char *grab_fname(uint file_id)

    {

      File_name_record *ptr;

      char *res= 0;

      if (file_id >= file_names.elements)

        return 0;

      ptr= dynamic_element(&file_names, file_id, File_name_record*);

      if (!ptr->event)

      {

        res= ptr->fname;

        bzero((char *)ptr, sizeof(File_name_record));

      }

      return res;

    }

  Exit_status process(Create_file_log_event *ce);

  Exit_status process(Begin_load_query_log_event *ce);

  Exit_status process(Append_block_log_event *ae);

  File prepare_new_file_for_old_format(Load_log_event *le, char *filename);

  Exit_status load_old_format_file(NET* net, const char *server_fname,

                                   uint server_fname_len, File file);

  Exit_status process_first_event(const char *bname, uint blen,

                                  const uchar *block,

                                  uint block_len, uint file_id,

                                  Create_file_log_event *ce);

};

/**

  Creates and opens a new temporary file in the directory specified by previous call to init_by_dir_name() or init_by_cur_dir().

  @param[in] le The basename of the created file will start with the

  basename of the file pointed to by this Load_log_event.

  @param[out] filename Buffer to save the filename in.

  @return File handle >= 0 on success, -1 on error.

*/

File Load_log_processor::prepare_new_file_for_old_format(Load_log_event *le,

							 char *filename)

{

  uint len;

  char *tail;

  File file;

  fn_format(filename, le->fname, target_dir_name, "", MY_REPLACE_DIR);

  len= strlen(filename);

  tail= filename + len;

  if ((file= create_unique_file(filename,tail)) < 0)

  {

    error("Could not construct local filename %s.",filename);

    return -1;

  }

  le->set_fname_outside_temp_buf(filename,len+strlen(tail));

  return file;

}

/**

  Reads a file from a server and saves it locally.

  @param[in,out] net The server to read from.

  @param[in] server_fname The name of the file that the server should

  read.

  @param[in] server_fname_len The length of server_fname.

  @param[in,out] file The file to write to.

  @retval ERROR_STOP An error occurred - the program should terminate.

  @retval OK_CONTINUE No error, the program should continue.

*/

Exit_status Load_log_processor::load_old_format_file(NET* net,

                                                     const char*server_fname,

                                                     uint server_fname_len,

                                                     File file)

{

  uchar buf[FN_REFLEN+1];

  buf[0] = 0;

  memcpy(buf + 1, server_fname, server_fname_len + 1);

  if (my_net_write(net, buf, server_fname_len +2) || net_flush(net))

  {

    error("Failed requesting the remote dump of %s.", server_fname);

    return ERROR_STOP;

  }

  for (;;)

  {

    ulong packet_len = my_net_read(net);

    if (packet_len == 0)

    {

      if (my_net_write(net, (uchar*) "", 0) || net_flush(net))

      {

        error("Failed sending the ack packet.");

        return ERROR_STOP;

      }

      /*

	we just need to send something, as the server will read but

	not examine the packet - this is because mysql_load() sends 

	an OK when it is done

      */

      break;

    }

    else if (packet_len == packet_error)

    {

      error("Failed reading a packet during the dump of %s.", server_fname);

      return ERROR_STOP;

    }

    if (packet_len > UINT_MAX)

    {

      error("Illegal length of packet read from net.");

      return ERROR_STOP;

    }

    if (my_write(file, (uchar*) net->read_pos, 

		 (uint) packet_len, MYF(MY_WME|MY_NABP)))

      return ERROR_STOP;

  }

  return OK_CONTINUE;

}

/**

  Process the first event in the sequence of events representing a

  LOAD DATA statement.

  Creates a temporary file to be used in LOAD DATA and writes first

  block of data to it. Registers its file name (and optional

  Create_file event) in the array of active temporary files.

  @param bname Base name for temporary file to be created.

  @param blen Base name length.

  @param block First block of data to be loaded.

  @param block_len First block length.

  @param file_id Identifies the LOAD DATA statement.

  @param ce Pointer to Create_file event object if we are processing

  this type of event.

  @retval ERROR_STOP An error occurred - the program should terminate.

  @retval OK_CONTINUE No error, the program should continue.

*/

Exit_status Load_log_processor::process_first_event(const char *bname,

                                                    uint blen,

                                                    const uchar *block,

                                                    uint block_len,

                                                    uint file_id,

                                                    Create_file_log_event *ce)

{

  uint full_len= target_dir_name_len + blen + 9 + 9 + 1;

  Exit_status retval= OK_CONTINUE;

  char *fname, *ptr;

  File file;

  File_name_record rec;

  DBUG_ENTER("Load_log_processor::process_first_event");

  if (!(fname= (char*) my_malloc(full_len,MYF(MY_WME))))

  {

    error("Out of memory.");

    delete ce;

    DBUG_RETURN(ERROR_STOP);

  }

  memcpy(fname, target_dir_name, target_dir_name_len);

  ptr= fname + target_dir_name_len;

  memcpy(ptr,bname,blen);

  ptr+= blen;

  ptr+= my_sprintf(ptr, (ptr, "-%x", file_id));

  if ((file= create_unique_file(fname,ptr)) < 0)

  {

    error("Could not construct local filename %s%s.",

          target_dir_name,bname);

    delete ce;

    DBUG_RETURN(ERROR_STOP);

  }

  rec.fname= fname;

  rec.event= ce;

  if (set_dynamic(&file_names, (uchar*)&rec, file_id))

  {

    error("Out of memory.");

    delete ce;

    DBUG_RETURN(ERROR_STOP);

  }

  if (ce)

    ce->set_fname_outside_temp_buf(fname, strlen(fname));

  if (my_write(file, (uchar*)block, block_len, MYF(MY_WME|MY_NABP)))

  {

    error("Failed writing to file.");

    retval= ERROR_STOP;

  }

  if (my_close(file, MYF(MY_WME)))

  {

    error("Failed closing file.");

    retval= ERROR_STOP;

  }

  DBUG_RETURN(retval);

}

/**

  Process the given Create_file_log_event.

  @see Load_log_processor::process_first_event(const char*,uint,const char*,uint,uint,Create_file_log_event*)

  @param ce Create_file_log_event to process.

  @retval ERROR_STOP An error occurred - the program should terminate.

  @retval OK_CONTINUE No error, the program should continue.

*/

Exit_status  Load_log_processor::process(Create_file_log_event *ce)

{

  const char *bname= ce->fname + dirname_length(ce->fname);

  uint blen= ce->fname_len - (bname-ce->fname);

  return process_first_event(bname, blen, ce->block, ce->block_len,

                             ce->file_id, ce);

}

/**

  Process the given Begin_load_query_log_event.

  @see Load_log_processor::process_first_event(const char*,uint,const char*,uint,uint,Create_file_log_event*)

  @param ce Begin_load_query_log_event to process.

  @retval ERROR_STOP An error occurred - the program should terminate.

  @retval OK_CONTINUE No error, the program should continue.

*/

Exit_status Load_log_processor::process(Begin_load_query_log_event *blqe)

{

  return process_first_event("SQL_LOAD_MB", 11, blqe->block, blqe->block_len,

                             blqe->file_id, 0);

}

/**

  Process the given Append_block_log_event.

  Appends the chunk of the file contents specified by the event to the

  file created by a previous Begin_load_query_log_event or

  Create_file_log_event.

  If the file_id for the event does not correspond to any file

  previously registered through a Begin_load_query_log_event or

  Create_file_log_event, this member function will print a warning and

  return OK_CONTINUE.  It is safe to return OK_CONTINUE, because no

  query will be written for this event.  We should not print an error

  and fail, since the missing file_id could be because a (valid)

  --start-position has been specified after the Begin/Create event but

  before this Append event.

  @param ae Append_block_log_event to process.

  @retval ERROR_STOP An error occurred - the program should terminate.

  @retval OK_CONTINUE No error, the program should continue.

*/

Exit_status Load_log_processor::process(Append_block_log_event *ae)

{

  DBUG_ENTER("Load_log_processor::process");

  const char* fname= ((ae->file_id < file_names.elements) ?

                       dynamic_element(&file_names, ae->file_id,

                                       File_name_record*)->fname : 0);

  if (fname)

  {

    File file;

    Exit_status retval= OK_CONTINUE;

    if (((file= my_open(fname,

			O_APPEND|O_BINARY|O_WRONLY,MYF(MY_WME))) < 0))

    {

      error("Failed opening file %s", fname);

      DBUG_RETURN(ERROR_STOP);

    }

    if (my_write(file,(uchar*)ae->block,ae->block_len,MYF(MY_WME|MY_NABP)))

    {

      error("Failed writing to file %s", fname);

      retval= ERROR_STOP;

    }

    if (my_close(file,MYF(MY_WME)))

    {

      error("Failed closing file %s", fname);

      retval= ERROR_STOP;

    }

    DBUG_RETURN(retval);

  }

  /*

    There is no Create_file event (a bad binlog or a big

    --start-position). Assuming it's a big --start-position, we just do

    nothing and print a warning.

  */

  warning("Ignoring Append_block as there is no "

          "Create_file event for file_id: %u", ae->file_id);

  DBUG_RETURN(OK_CONTINUE);

}

static Load_log_processor load_processor;

/**

  Replace windows-style backslashes by forward slashes so it can be

  consumed by the mysql client, which requires Unix path.

  @todo This is only useful under windows, so may be ifdef'ed out on

  other systems.  /Sven

  @todo If a Create_file_log_event contains a filename with a

  backslash (valid under unix), then we have problems under windows.

  /Sven

  @param[in,out] fname Filename to modify. The filename is modified

  in-place.

*/

static void convert_path_to_forward_slashes(char *fname)

{

  while (*fname)

  {

    if (*fname == '\\')

      *fname= '/';

    fname++;

  }

}

/**

  Indicates whether the given database should be filtered out,

  according to the --database=X option.

  @param log_dbname Name of database.

  @return nonzero if the database with the given name should be

  filtered out, 0 otherwise.

*/

static bool shall_skip_database(const char *log_dbname)

{

  return one_database &&

         (log_dbname != NULL) &&

         strcmp(log_dbname, database);

}

/**

  Prints the given event in base64 format.

  The header is printed to the head cache and the body is printed to

  the body cache of the print_event_info structure.  This allows all

  base64 events corresponding to the same statement to be joined into

  one BINLOG statement.

  @param[in] ev Log_event to print.

  @param[in,out] result_file FILE to which the output will be written.

  @param[in,out] print_event_info Parameters and context state

  determining how to print.

  @retval ERROR_STOP An error occurred - the program should terminate.

  @retval OK_CONTINUE No error, the program should continue.

*/

static Exit_status

write_event_header_and_base64(Log_event *ev, FILE *result_file,

                              PRINT_EVENT_INFO *print_event_info)

{

  IO_CACHE *head= &print_event_info->head_cache;

  IO_CACHE *body= &print_event_info->body_cache;

  DBUG_ENTER("write_event_header_and_base64");

  /* Write header and base64 output to cache */

  ev->print_header(head, print_event_info, FALSE);

  ev->print_base64(body, print_event_info, FALSE);

  /* Read data from cache and write to result file */

  if (copy_event_cache_to_file_and_reinit(head, result_file) ||

      copy_event_cache_to_file_and_reinit(body, result_file))

  {

    error("Error writing event to file.");

    DBUG_RETURN(ERROR_STOP);

  }

  DBUG_RETURN(OK_CONTINUE);

}

/**

  Print the given event, and either delete it or delegate the deletion

  to someone else.

  The deletion may be delegated in two cases: (1) the event is a

  Format_description_log_event, and is saved in

  glob_description_event; (2) the event is a Create_file_log_event,

  and is saved in load_processor.

  @param[in,out] print_event_info Parameters and context state

  determining how to print.

  @param[in] ev Log_event to process.

  @param[in] pos Offset from beginning of binlog file.

  @param[in] logname Name of input binlog.

  @retval ERROR_STOP An error occurred - the program should terminate.

  @retval OK_CONTINUE No error, the program should continue.

  @retval OK_STOP No error, but the end of the specified range of

  events to process has been reached and the program should terminate.

*/

Exit_status process_event(PRINT_EVENT_INFO *print_event_info, Log_event *ev,

                          my_off_t pos, const char *logname)

{

  char ll_buff[21];

  Log_event_type ev_type= ev->get_type_code();

  DBUG_ENTER("process_event");

  print_event_info->short_form= short_form;

  Exit_status retval= OK_CONTINUE;

  /*

    Format events are not concerned by --offset and such, we always need to

    read them to be able to process the wanted events.

  */

  if (((rec_count >= offset) && ((my_time_t)(ev->when) >= start_datetime)) || (ev_type == FORMAT_DESCRIPTION_EVENT))

  {

    if (ev_type != FORMAT_DESCRIPTION_EVENT)

    {

      /*

        We have found an event after start_datetime, from now on print

        everything (in case the binlog has timestamps increasing and

        decreasing, we do this to avoid cutting the middle).

      */

      start_datetime= 0;

      offset= 0; // print everything and protect against cycling rec_count

    }

    if (server_id && (server_id != ev->server_id))

      /* skip just this event, continue processing the log. */

      goto end;

    if (((my_time_t)(ev->when) >= stop_datetime)

        || (pos >= stop_position_mot))

    {

      /* end the program */

      retval= OK_STOP;

      goto end;

    }

    if (!short_form)

      fprintf(result_file, "# at %s\n",llstr(pos,ll_buff));

    if (!opt_hexdump)

      print_event_info->hexdump_from= 0; /* Disabled */

    else

      print_event_info->hexdump_from= pos;

    print_event_info->base64_output_mode= opt_base64_output_mode;

    DBUG_PRINT("debug", ("event_type: %s", ev->get_type_str()));

    switch (ev_type) {

    case QUERY_EVENT:

      if (shall_skip_database(((Query_log_event*)ev)->db))

        goto end;

      if (opt_base64_output_mode == BASE64_OUTPUT_ALWAYS)

      {

        if ((retval= write_event_header_and_base64(ev, result_file,

                                                   print_event_info)) !=

            OK_CONTINUE)

          goto end;

      }

      else

        ev->print(result_file, print_event_info);

      break;

    case CREATE_FILE_EVENT:

    {

      Create_file_log_event* ce= (Create_file_log_event*)ev;

      /*

        We test if this event has to be ignored. If yes, we don't save

        this event; this will have the good side-effect of ignoring all

        related Append_block and Exec_load.

        Note that Load event from 3.23 is not tested.

      */

      if (shall_skip_database(ce->db))

        goto end;                // Next event

      /*

	We print the event, but with a leading '#': this is just to inform 

	the user of the original command; the command we want to execute 

	will be a derivation of this original command (we will change the 

	filename and use LOCAL), prepared in the 'case EXEC_LOAD_EVENT' 

	below.

      */

      if (opt_base64_output_mode == BASE64_OUTPUT_ALWAYS)

      {

        if ((retval= write_event_header_and_base64(ce, result_file,

                                                   print_event_info)) !=

            OK_CONTINUE)

          goto end;

      }

      else

        ce->print(result_file, print_event_info, TRUE);

      // If this binlog is not 3.23 ; why this test??

      if (glob_description_event->binlog_version >= 3)

      {

        /*

          transfer the responsibility for destroying the event to

          load_processor

        */

        ev= NULL;

        if ((retval= load_processor.process(ce)) != OK_CONTINUE)

          goto end;

      }

      break;

    }

    case APPEND_BLOCK_EVENT:

      /*

        Append_block_log_events can safely print themselves even if

        the subsequent call load_processor.process fails, because the

        output of Append_block_log_event::print is only a comment.

      */

      ev->print(result_file, print_event_info);

      if ((retval= load_processor.process((Append_block_log_event*) ev)) !=

          OK_CONTINUE)

        goto end;

      break;

    case EXEC_LOAD_EVENT:

    {

      ev->print(result_file, print_event_info);

      Execute_load_log_event *exv= (Execute_load_log_event*)ev;

      Create_file_log_event *ce= load_processor.grab_event(exv->file_id);

      /*

	if ce is 0, it probably means that we have not seen the Create_file

	event (a bad binlog, or most probably --start-position is after the

	Create_file event). Print a warning comment.

      */

      if (ce)

      {

        /*

          We must not convert earlier, since the file is used by

          my_open() in Load_log_processor::append().

        */

        convert_path_to_forward_slashes((char*) ce->fname);

	ce->print(result_file, print_event_info, TRUE);

	my_free((char*)ce->fname,MYF(MY_WME));

	delete ce;

      }

      else

        warning("Ignoring Execute_load_log_event as there is no "

                "Create_file event for file_id: %u", exv->file_id);

      break;

    }

    case FORMAT_DESCRIPTION_EVENT:

      delete glob_description_event;

      glob_description_event= (Format_description_log_event*) ev;

      print_event_info->common_header_len=

        glob_description_event->common_header_len;

      ev->print(result_file, print_event_info);

      ev->temp_buf= 0; // as the event ref is zeroed

      /*

        We don't want this event to be deleted now, so let's hide it (I

        (Guilhem) should later see if this triggers a non-serious Valgrind

        error). Not serious error, because we will free description_event

        later.

      */

      ev= 0;

      if (!force_if_open_opt &&

          (glob_description_event->flags & LOG_EVENT_BINLOG_IN_USE_F))

      {

        error("Attempting to dump binlog '%s', which was not closed properly. "

              "Most probably, mysqld is still writing it, or it crashed. "

              "Rerun with --force-if-open to ignore this problem.", logname);

        DBUG_RETURN(ERROR_STOP);

      }

      break;

    case BEGIN_LOAD_QUERY_EVENT:

      ev->print(result_file, print_event_info);

      if ((retval= load_processor.process((Begin_load_query_log_event*) ev)) !=

          OK_CONTINUE)

        goto end;

      break;

    case EXECUTE_LOAD_QUERY_EVENT:

    {

      Execute_load_query_log_event *exlq= (Execute_load_query_log_event*)ev;

      char *fname= load_processor.grab_fname(exlq->file_id);

      if (!shall_skip_database(exlq->db))

      {

        if (fname)

        {

          convert_path_to_forward_slashes(fname);

          exlq->print(result_file, print_event_info, fname);

        }

        else

          warning("Ignoring Execute_load_query since there is no "

                  "Begin_load_query event for file_id: %u", exlq->file_id);

      }

      if (fname)

	my_free(fname, MYF(MY_WME));

      break;

    }

    case TABLE_MAP_EVENT:

    case WRITE_ROWS_EVENT:

    case DELETE_ROWS_EVENT:

    case UPDATE_ROWS_EVENT: