This will be pushed only after I fix the testsuite.

This is the main commit for Worklog tasks:
 * A more dynamic binlog format which allows small changes (1064)
 * Log session variables in Query_log_event (1063)
Below 5.0 means 5.0.0.
MySQL 5.0 is able to replicate FOREIGN_KEY_CHECKS, UNIQUE_KEY_CHECKS (for speed),
SQL_AUTO_IS_NULL, SQL_MODE. Not charsets (WL#1062), not some vars (I can only think
of SQL_SELECT_LIMIT, which deserves a special treatment). Note that this
works for queries, except LOAD DATA INFILE (for this it would have to wait
for Dmitri's push of WL#874, which in turns waits for the present push, so...
the deadlock must be broken!). Note that when Dmitri pushes WL#874 in 5.0.1,
5.0.0 won't be able to replicate a LOAD DATA INFILE from 5.0.1.
Apart from that, the new binlog format is designed so that it can tolerate
a little variation in the events (so that a 5.0.0 slave could replicate a
5.0.1 master, except for LOAD DATA INFILE unfortunately); that is, when I
later add replication of charsets it should break nothing. And when I later
add a UID to every event, it should break nothing.
The main change brought by this patch is a new type of event, Format_description_log_event,
which describes some lengthes in other event types. This event is needed for
the master/slave/mysqlbinlog to understand a 5.0 log. Thanks to this event,
we can later add more bytes to the header of every event without breaking compatibility.
Inside Query_log_event, we have some additional dynamic format, as every Query_log_event
can have a different number of status variables, stored as pairs (code, value); that's
how SQL_MODE and session variables and catalog are stored. Like this, we can later
add count of affected rows, charsets... and we can have options --don't-log-count-affected-rows
if we want.
MySQL 5.0 is able to run on 4.x relay logs, 4.x binlogs.
Upgrading a 4.x master to 5.0 is ok (no need to delete binlogs),
upgrading a 4.x slave to 5.0 is ok (no need to delete relay logs);
so both can be "hot" upgrades.
Upgrading a 3.23 master to 5.0 requires as much as upgrading it to 4.0.
3.23 and 4.x can't be slaves of 5.0.
So downgrading from 5.0 to 4.x may be complicated.
Log_event::log_pos is now the position of the end of the event, which is
more useful than the position of the beginning. We take care about compatibility
with <5.0 (in which log_pos is the beginning).
I added a short test for replication of SQL_MODE and some other variables.
TODO:
- after committing this, merge the latest 5.0 into it
- fix all tests
- update the manual with upgrade notes.


client/Makefile.am:
  mysqlbinlog.cc depends slightly on sql/mysql_priv.h
client/mysqlbinlog.cc:
  Make mysqlbinlog able to read the new binlog format,
  by seeking to the start and reading the first few events, to
  detect the format of the binlog.
include/my_sys.h:
  a correct tell() for SEQ_READ_APPEND caches.
mysys/mf_iocache2.c:
  a correct tell() for SEQ_READ_APPEND caches
  (my_b_tell() is not working for such caches).
sql/ha_innodb.cc:
  we are getting rid of event lengthes here and there, which is good.
sql/log.cc:
  Start events will have created==0 if generated by rotation (like in 3.23).
  In 5.0 we always write a Format_description_log_event at the beginning of
  every master's binary log and of every slave's relay log.
  We also add Rotate and Stop to relay logs (like there already was in
  master's binary logs).
  When we rotate a relay log, we write the previous relay log's Start event
  (the one which was sent from the master) to the beginning of the new log,
  so that we don't need the previous relay log to understand the new one;
  that's the purpose of MYSQL_LOG::description_event_for_queue.
  Removed logging of SET FOREIGN_KEY_CHECKS, because we handle it as flags
  in the Query event now.
sql/log_event.cc:
  New event type: Format_description_log_event, to describe the log's format.
  read_log_event() needs to be passed this event to be able to read 5.0 events.
  Query_log_event has new members flags2 and sql_mode for replication of session
  variables (except charsets which are WL#1062) and SQL_MODE.
  flags2 is in fact a kind of copy of thd->options (&'d with a mask).
  Now with this replication of FOREIGN_KEY_CHECKS, SQL_AUTO_IS_NULL, UNIQUE_CHECKS
  and SQL_MODE work; with mysqlbinlog too.
sql/log_event.h:
  Binlog version is changed to 4.
  New classes (details in sql/log_event.cc).
  Removing some useless #defines.
sql/mysql_priv.h:
  Definition of SELECT_DISTINCT and others must be visible in client/mysqlbinlog.cc,
  so adding #ifdefs.
sql/mysqld.cc:
  update for prototype change
sql/slave.cc:
  When the slave opens a relay log, it reads the first few events to know the format.
  When slave I/O thread receives a Rotate from the master, it rotates its relay log
  (to avoid mixed format in the relay log).
sql/slave.h:
  in the slave we avoid lengthes and rely on absolute positions instead;
  hence the introduction of future_group_master_log_pos and future_event_relay_log_pos
  (explained in code).
sql/sql_class.cc:
  catalog in THD
sql/sql_class.h:
  catalog, and new members in MYSQL_LOG
sql/sql_repl.cc:
  When the master starts sending binlog to slave, it must
  first read the first few events to detect the binlog's format.
  Same for SHOW BINLOG EVENTS.

1 files changed, 974 insertions, 258 deletions

diff --git a/sql/log_event.cc b/sql/log_event.cc
index 8c93a22cf6e..018366507e6 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -192,9 +192,25 @@ static inline int read_str(char * &buf, char *buf_end, char * &str,
   return 0;
 }
 
+/*
+  Prints a "session_var=value" string. Used by mysqlbinlog to print some SET
+  commands just before it prints a query.
+*/
+
+static void print_set_option(FILE* file, uint32 bits_changed, uint32 option,
+                             uint32 flags, const char* name, bool* need_comma) 
+{
+  if (bits_changed & option)
+  {
+    if (*need_comma)
+      fprintf(file,", ");
+    fprintf(file,"%s=%d", name, (bool)(flags & option));
+    *need_comma= 1;
+  }
+}
 
 /**************************************************************************
-	Log_event methods
+	Log_event methods (= the parent class of all events)
 **************************************************************************/
 
 /*
@@ -204,7 +220,7 @@ static inline int read_str(char * &buf, char *buf_end, char * &str,
 const char* Log_event::get_type_str()
 {
   switch(get_type_code()) {
-  case START_EVENT:  return "Start";
+  case START_EVENT_V3:  return "Start_v3";
   case STOP_EVENT:   return "Stop";
   case QUERY_EVENT:  return "Query";
   case ROTATE_EVENT: return "Rotate";
@@ -218,6 +234,7 @@ const char* Log_event::get_type_str()
   case EXEC_LOAD_EVENT: return "Exec_load";
   case RAND_EVENT: return "RAND";
   case USER_VAR_EVENT: return "User var";
+  case FORMAT_DESCRIPTION_EVENT: return "Format_desc";
   default: return "Unknown";				/* impossible */ 
   }
 }
@@ -254,24 +271,66 @@ Log_event::Log_event()
   Log_event::Log_event()
 */
 
-Log_event::Log_event(const char* buf, bool old_format)
+Log_event::Log_event(const char* buf,
+                     const Format_description_log_event* description_event) 
   :temp_buf(0), cached_event_len(0), cache_stmt(0)
 {
+#ifndef MYSQL_CLIENT
+  thd = 0;
+#endif  
   when = uint4korr(buf);
   server_id = uint4korr(buf + SERVER_ID_OFFSET);
-  if (old_format)
+  if (description_event->binlog_version==1)
   {
-    log_pos=0;
-    flags=0;
+    log_pos= 0;
+    flags= 0;
+    return;
   }
-  else
+  /* 4.0 or newer */
+  log_pos= uint4korr(buf + LOG_POS_OFFSET);
+  /*
+    If the log is 4.0 (so here it can only be a 4.0 relay log read by the SQL
+    thread or a 4.0 master binlog read by the I/O thread), log_pos is the
+    beginning of the event: we transform it into the end of the event, which is
+    more useful.
+    But how do you know that the log is 4.0: you know it if description_event is
+    version 3 *and* you are not reading a Format_desc (remember that mysqlbinlog
+    starts by assuming that 5.0 logs are in 4.0 format, until it finds a
+    Format_desc).
+  */
+  if (description_event->binlog_version==3 &&
+      buf[EVENT_TYPE_OFFSET]<FORMAT_DESCRIPTION_EVENT &&
+      /*
+        If log_pos=0, don't change it. log_pos==0 is a marker to mean
+        "don't change rli->group_master_log_pos" (see
+        inc_group_relay_log_pos()). As it is unreal log_pos, adding the event
+        len's is nonsense. For example, a fake Rotate event should 
+        not have its log_pos (which is 0) changed or it will modify
+        Exec_master_log_pos in SHOW SLAVE STATUS, displaying a nonsense value of
+        (a non-zero offset which does not exist in the master's binlog, so which
+        will cause problems if the user uses this value in CHANGE MASTER).
+      */
+      log_pos)
+    log_pos+= uint4korr(buf + EVENT_LEN_OFFSET);
+  flags= uint2korr(buf + FLAGS_OFFSET);
+  if ((buf[EVENT_TYPE_OFFSET] == FORMAT_DESCRIPTION_EVENT) ||
+      (buf[EVENT_TYPE_OFFSET] == ROTATE_EVENT))
   {
-    log_pos = uint4korr(buf + LOG_POS_OFFSET);
-    flags = uint2korr(buf + FLAGS_OFFSET);
+    /*
+      These events always have a header which stops here (i.e. their header is
+      FROZEN).
+    */
+    /*
+      Initialization to zero of all other Log_event members as they're not
+      specified. Currently there are no such members; in the future there will
+      be an event UID (but Format_description and Rotate don't need this UID, as
+      they are not propagated through --log-slave-updates (remember the UID is
+      used to not play a query twice when you have two masters which are slaves
+      of a 3rd master). Then we are done.
+    */
+    return;
   }
-#ifndef MYSQL_CLIENT
-  thd = 0;
-#endif  
+  /* otherwise, go on with reading the header from buf (nothing now) */
 }
 
 #ifndef MYSQL_CLIENT
@@ -322,10 +381,10 @@ int Log_event::exec_event(struct st_relay_log_info* rli)
       has already been updated.
     */
     if ((thd->options & OPTION_BEGIN) && opt_using_transactions)
-      rli->inc_event_relay_log_pos(get_event_len());
+      rli->inc_event_relay_log_pos();
     else
     {
-      rli->inc_group_relay_log_pos(get_event_len(),log_pos);
+      rli->inc_group_relay_log_pos(log_pos);
       flush_relay_log_info(rli);
       /* 
          Note that Rotate_log_event::exec_event() does not call this function,
@@ -387,7 +446,7 @@ void Log_event::init_show_field_list(List<Item>* field_list)
   field_list->push_back(new Item_empty_string("Event_type", 20));
   field_list->push_back(new Item_return_int("Server_id", 10,
 					    MYSQL_TYPE_LONG));
-  field_list->push_back(new Item_return_int("Orig_log_pos", 11,
+  field_list->push_back(new Item_return_int("End_log_pos", 11,
 					    MYSQL_TYPE_LONGLONG));
   field_list->push_back(new Item_empty_string("Info", 20));
 }
@@ -410,6 +469,12 @@ int Log_event::write(IO_CACHE* file)
 
 int Log_event::write_header(IO_CACHE* file)
 {
+  /*
+    Header will be of size LOG_EVENT_HEADER_LEN for all events, except for
+    FORMAT_DESCRIPTION_EVENT and ROTATE_EVENT, where it will be
+    LOG_EVENT_MINIMAL_HEADER_LEN (remember these 2 have a frozen header, because
+    we read them before knowing the format).
+  */
   char buf[LOG_EVENT_HEADER_LEN];
   char* pos = buf;
   int4store(pos, (ulong) when); // timestamp
@@ -417,19 +482,45 @@ int Log_event::write_header(IO_CACHE* file)
   *pos++ = get_type_code(); // event type code
   int4store(pos, server_id);
   pos += 4;
-  long tmp=get_data_size() + LOG_EVENT_HEADER_LEN;
+  long tmp; // total length of the event
+  switch (get_type_code())
+    {
+    case FORMAT_DESCRIPTION_EVENT:
+    case ROTATE_EVENT:
+      tmp= get_data_size() + LOG_EVENT_MINIMAL_HEADER_LEN;
+      break;
+    default:
+      tmp= get_data_size() + LOG_EVENT_HEADER_LEN;
+      break;
+    }
   int4store(pos, tmp);
   pos += 4;
   int4store(pos, log_pos);
   pos += 4;
   int2store(pos, flags);
   pos += 2;
+  switch (get_type_code())
+    {
+    case FORMAT_DESCRIPTION_EVENT:
+    case ROTATE_EVENT:
+      break;
+    default:
+      /*
+        Other data to print in the header (nothing now); in that case increment
+        pos.
+      */
+      break;
+    }
   return (my_b_safe_write(file, (byte*) buf, (uint) (pos - buf)));
 }
 
 
 /*
   Log_event::read_log_event()
+
+  This needn't be format-tolerant, because we only read
+  LOG_EVENT_MINIMAL_HEADER_LEN (we just want to read the event's length).
+
 */
 
 #ifndef MYSQL_CLIENT
@@ -438,7 +529,7 @@ int Log_event::read_log_event(IO_CACHE* file, String* packet,
 {
   ulong data_len;
   int result=0;
-  char buf[LOG_EVENT_HEADER_LEN];
+  char buf[LOG_EVENT_MINIMAL_HEADER_LEN];
   DBUG_ENTER("read_log_event");
 
   if (log_lock)
@@ -458,24 +549,25 @@ int Log_event::read_log_event(IO_CACHE* file, String* packet,
     goto end;
   }
   data_len= uint4korr(buf + EVENT_LEN_OFFSET);
-  if (data_len < LOG_EVENT_HEADER_LEN ||
+  if (data_len < LOG_EVENT_MINIMAL_HEADER_LEN ||
       data_len > current_thd->variables.max_allowed_packet)
   {
     DBUG_PRINT("error",("data_len: %ld", data_len));
-    result= ((data_len < LOG_EVENT_HEADER_LEN) ? LOG_READ_BOGUS :
+    result= ((data_len < LOG_EVENT_MINIMAL_HEADER_LEN) ? LOG_READ_BOGUS :
 	     LOG_READ_TOO_LARGE);
     goto end;
   }
   packet->append(buf, sizeof(buf));
-  data_len-= LOG_EVENT_HEADER_LEN;
+  data_len-= LOG_EVENT_MINIMAL_HEADER_LEN;
   if (data_len)
   {
     if (packet->append(file, data_len))
     {
       /*
-	Here we should never hit EOF in a non-error condition.
+	Here if we hit EOF it's really an error: as data_len is >=0
+        there's supposed to be more bytes available. 
 	EOF means we are reading the event partially, which should
-	never happen.
+	never happen: either we read badly or the binlog is truncated.
       */
       result= file->error >= 0 ? LOG_READ_TRUNC: LOG_READ_IO;
       /* Implicit goto end; */
@@ -502,24 +594,42 @@ end:
   Log_event::read_log_event()
 
   NOTE:
-    Allocates memory;  The caller is responsible for clean-up
+    Allocates memory;  The caller is responsible for clean-up.
 */
 
 #ifndef MYSQL_CLIENT
 Log_event* Log_event::read_log_event(IO_CACHE* file,
 				     pthread_mutex_t* log_lock,
-				     bool old_format)
+                                     const Format_description_log_event *description_event)
 #else
-Log_event* Log_event::read_log_event(IO_CACHE* file, bool old_format)
+Log_event* Log_event::read_log_event(IO_CACHE* file,
+                                     const Format_description_log_event *description_event)
 #endif  
 {
-  char head[LOG_EVENT_HEADER_LEN];
-  uint header_size= old_format ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
+  DBUG_ASSERT(description_event);
+  char head[LOG_EVENT_MINIMAL_HEADER_LEN];
+  /*
+    First we only want to read at most LOG_EVENT_MINIMAL_HEADER_LEN, just to
+    check the event for sanity and to know its length; no need to really parse
+    it. We say "at most" because this could be a 3.23 master, which has header
+    of 13 bytes, whereas LOG_EVENT_MINIMAL_HEADER_LEN is 19 bytes (it's "minimal"
+    over the set {MySQL >=4.0}).
+  */
+  uint header_size= min(description_event->common_header_len,
+                        LOG_EVENT_MINIMAL_HEADER_LEN);
 
   LOCK_MUTEX;
+  DBUG_PRINT("info", ("my_b_tell=%lu", my_b_tell(file)));
   if (my_b_read(file, (byte *) head, header_size))
   {
+    DBUG_PRINT("info", ("Log_event::read_log_event(IO_CACHE*,Format_desc*) \
+failed my_b_read"));
     UNLOCK_MUTEX;
+    /*
+      No error here; it could be that we are at the file's end. However if the
+      next my_b_read() fails (below), it will be an error as we were able to
+      read the first bytes.
+    */
     return 0;
   }
 
@@ -553,7 +663,8 @@ Log_event* Log_event::read_log_event(IO_CACHE* file, bool old_format)
     error = "read error";
     goto err;
   }
-  if ((res = read_log_event(buf, data_len, &error, old_format)))
+  if ((res= read_log_event(buf, data_len, &error,
+                           description_event))) 
     res->register_temp_buf(buf);
 
 err:
@@ -580,87 +691,105 @@ Error in Log_event::read_log_event(): '%s', data_len: %d, event_type: %d",
 
 /*
   Log_event::read_log_event()
+  Binlog format tolerance is in (buf, event_len, description_event)
+  constructors.
 */
 
-Log_event* Log_event::read_log_event(const char* buf, int event_len,
-				     const char **error, bool old_format)
+Log_event* Log_event::read_log_event(const char* buf, uint event_len,
+				     const char **error,
+                                     const Format_description_log_event *description_event)
 {
+  DBUG_ENTER("Log_event::read_log_event(char*,...)");
+  DBUG_ASSERT(description_event);
+  DBUG_PRINT("info", ("binlog_version=%d", description_event->binlog_version));
   if (event_len < EVENT_LEN_OFFSET ||
       (uint) event_len != uint4korr(buf+EVENT_LEN_OFFSET))
   {
     *error="Sanity check failed";		// Needed to free buffer
-    return NULL; // general sanity check - will fail on a partial read
+    DBUG_RETURN(NULL); // general sanity check - will fail on a partial read
   }
   
   Log_event* ev = NULL;
   
   switch(buf[EVENT_TYPE_OFFSET]) {
   case QUERY_EVENT:
-    ev  = new Query_log_event(buf, event_len, old_format);
+    ev  = new Query_log_event(buf, event_len, description_event);
     break;
   case LOAD_EVENT:
-    ev = new Create_file_log_event(buf, event_len, old_format);
+    ev = new Create_file_log_event(buf, event_len, description_event);
     break;
   case NEW_LOAD_EVENT:
-    ev = new Load_log_event(buf, event_len, old_format);
+    ev = new Load_log_event(buf, event_len, description_event);
     break;
   case ROTATE_EVENT:
-    ev = new Rotate_log_event(buf, event_len, old_format);
+    ev = new Rotate_log_event(buf, event_len, description_event);
     break;
 #ifdef HAVE_REPLICATION
-  case SLAVE_EVENT:
+  case SLAVE_EVENT: /* can never happen (unused event) */
     ev = new Slave_log_event(buf, event_len);
     break;
 #endif /* HAVE_REPLICATION */
   case CREATE_FILE_EVENT:
-    ev = new Create_file_log_event(buf, event_len, old_format);
+    ev = new Create_file_log_event(buf, event_len, description_event);
     break;
   case APPEND_BLOCK_EVENT:
-    ev = new Append_block_log_event(buf, event_len);
+    ev = new Append_block_log_event(buf, event_len, description_event);
     break;
   case DELETE_FILE_EVENT:
-    ev = new Delete_file_log_event(buf, event_len);
+    ev = new Delete_file_log_event(buf, event_len, description_event);
     break;
   case EXEC_LOAD_EVENT:
-    ev = new Execute_load_log_event(buf, event_len);
+    ev = new Execute_load_log_event(buf, event_len, description_event);
     break;
-  case START_EVENT:
-    ev = new Start_log_event(buf, old_format);
+  case START_EVENT_V3: /* this is sent only by MySQL <=4.x */
+    ev = new Start_log_event_v3(buf, description_event);
     break;
 #ifdef HAVE_REPLICATION
   case STOP_EVENT:
-    ev = new Stop_log_event(buf, old_format);
+    ev = new Stop_log_event(buf, description_event);
     break;
 #endif /* HAVE_REPLICATION */
   case INTVAR_EVENT:
-    ev = new Intvar_log_event(buf, old_format);
+    ev = new Intvar_log_event(buf, description_event);
     break;
   case RAND_EVENT:
-    ev = new Rand_log_event(buf, old_format);
+    ev = new Rand_log_event(buf, description_event);
     break;
   case USER_VAR_EVENT:
-    ev = new User_var_log_event(buf, old_format);
+    ev = new User_var_log_event(buf, description_event);
+    break;
+  case FORMAT_DESCRIPTION_EVENT:
+    ev = new Format_description_log_event(buf, event_len, description_event); 
     break;
   default:
     break;
   }
+  /*
+    is_valid() are small event-specific sanity tests which are important; for
+    example there are some my_malloc() in constructors
+    (e.g. Query_log_event::Query_log_event(char*...)); when these my_malloc()
+    fail we can't return an error out of the constructor (because constructor is
+    "void") ; so instead we leave the pointer we wanted to allocate
+    (e.g. 'query') to 0 and we test it in is_valid(). Same for
+    Format_description_log_event, member 'post_header_len'. 
+  */
   if (!ev || !ev->is_valid())
   {
     delete ev;
 #ifdef MYSQL_CLIENT
-    if (!force_opt)
+    if (!force_opt) /* then mysqlbinlog dies */
     {
       *error= "Found invalid event in binary log";
-      return 0;
+      DBUG_RETURN(0);
     }
-    ev= new Unknown_log_event(buf, old_format);
+    ev= new Unknown_log_event(buf, description_event);
 #else
     *error= "Found invalid event in binary log";
-    return 0;
+    DBUG_RETURN(0);
 #endif
   }
   ev->cached_event_len = event_len;
-  return ev;  
+  DBUG_RETURN(ev);  
 }
 
 #ifdef MYSQL_CLIENT
@@ -674,7 +803,7 @@ void Log_event::print_header(FILE* file)
   char llbuff[22];
   fputc('#', file);
   print_timestamp(file);
-  fprintf(file, " server id %d  log_pos %s ", server_id,
+  fprintf(file, " server id %d  end_log_pos %s ", server_id,
 	  llstr(log_pos,llbuff)); 
 }
 
@@ -708,13 +837,30 @@ void Log_event::print_timestamp(FILE* file, time_t* ts)
 
 /*
   Log_event::set_log_pos()
+  Only used when we are writing an event which we created, to the BINlog. That
+  is, when we have parsed and executed a query; we then want to set the event's
+  log_pos to what it is going to be in the binlog after we write it. Note that
+  this is the position of the END of the event.
 */
 
 #ifndef MYSQL_CLIENT
 void Log_event::set_log_pos(MYSQL_LOG* log)
 {
+  /*
+    Note that with a SEQ_READ_APPEND cache, my_b_tell() does not work well.
+    So this will give slightly wrong positions for the Format_desc/Rotate/Stop
+    events which the slave writes to its relay log. For example, the initial
+    Format_desc will have end_log_pos=91 instead of 95. Because after writing
+    the first 4 bytes of the relay log, my_b_tell() still reports 0. Because
+    my_b_append() does not update the counter which my_b_tell() later uses (one
+    should probably use my_b_append_tell() to work around this).
+    To get right positions even when writing to the relay log, we use the (new)
+    my_b_safe_tell().
+    Note that this raises a question on the correctness of all these
+    DBUG_ASSERT(my_b_tell()=rli->event_relay_log_pos).
+  */
   if (!log_pos)
-    log_pos = my_b_tell(&log->log_file);
+    log_pos = my_b_safe_tell(&log->log_file)+get_event_len();
 }
 #endif /* !MYSQL_CLIENT */
 
@@ -727,10 +873,15 @@ void Log_event::set_log_pos(MYSQL_LOG* log)
 
 /*
   Query_log_event::pack_info()
+  This (which is used only for SHOW BINLOG EVENTS) could be updated to
+  print SET @@session_var=. But this is not urgent, as SHOW BINLOG EVENTS is
+  only an information, it does not produce suitable queries to replay (for
+  example it does not print LOAD DATA INFILE).
 */
 
 void Query_log_event::pack_info(Protocol *protocol)
 {
+  // TODO: show the catalog ??
   char *buf, *pos;
   if (!(buf= my_malloc(9 + db_len + q_len, MYF(MY_WME))))
     return;
@@ -768,7 +919,7 @@ int Query_log_event::write(IO_CACHE* file)
 
 int Query_log_event::write_data(IO_CACHE* file)
 {
-  char buf[QUERY_HEADER_LEN]; 
+  char buf[QUERY_HEADER_LEN+1+4+1+8+1+1+catalog_len]; 
 
   if (!query)
     return -1;
@@ -814,10 +965,46 @@ int Query_log_event::write_data(IO_CACHE* file)
   int4store(buf + Q_EXEC_TIME_OFFSET, exec_time);
   buf[Q_DB_LEN_OFFSET] = (char) db_len;
   int2store(buf + Q_ERR_CODE_OFFSET, error_code);
+  int2store(buf + Q_STATUS_VARS_LEN_OFFSET, status_vars_len);
 
-  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;
+  /*
+    You MUST always write status vars in increasing order of code. This
+    guarantees that a slightly older slave will be able to parse those he
+    knows.
+  */
+  char* start= buf+QUERY_HEADER_LEN;
+  if (flags2_inited)
+  {
+    *(start++)= Q_FLAGS2_CODE;
+    int4store(start, flags2);
+    start+= 4;
+  }
+  if (sql_mode_inited)
+  {
+    *(start++)= Q_SQL_MODE_CODE;
+    int8store(start, sql_mode);
+    start+= 8;
+  }
+  if (catalog)
+  {
+    *(start++)= Q_CATALOG_CODE;
+    *(start++)= catalog_len;
+    bmove(start, catalog, catalog_len);
+    start+= catalog_len;
+  }
+  /*
+    Here there could be code like
+    if (command-line-option-which-says-"log_this_variable")
+    {
+    *(start++)= Q_THIS_VARIABLE_CODE;
+    int4store(start, this_variable);
+    start+= 4;
+    }
+  */
+  
+  return (my_b_safe_write(file, (byte*) buf, (start-buf)) ||
+  	  my_b_safe_write(file, (db) ? (byte*) db : (byte*)"", db_len + 1) ||
+  	  my_b_safe_write(file, (byte*) query, q_len)) ? -1 : 0;
 }
 
 
@@ -830,68 +1017,177 @@ Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
 				 ulong query_length, bool using_trans)
   :Log_event(thd_arg, !thd_arg->tmp_table_used ?
 	     0 : LOG_EVENT_THREAD_SPECIFIC_F, using_trans),
-   data_buf(0), query(query_arg),
+   data_buf(0), query(query_arg), catalog(thd_arg->catalog),
    db(thd_arg->db), q_len((uint32) query_length),
-  error_code(thd_arg->killed != THD::NOT_KILLED ? thd->killed_errno() : thd_arg->net.last_errno),
+   error_code(thd_arg->killed != THD::NOT_KILLED ? thd->killed_errno() : thd_arg->net.last_errno),
    thread_id(thd_arg->thread_id),
    /* save the original thread id; we already know the server id */
-   slave_proxy_id(thd_arg->variables.pseudo_thread_id)
+   slave_proxy_id(thd_arg->variables.pseudo_thread_id),
+   flags2_inited(1), sql_mode_inited(1), flags2(0), sql_mode(0)
 {
   time_t end_time;
   time(&end_time);
   exec_time = (ulong) (end_time  - thd->start_time);
+  catalog_len = (catalog) ? (uint32) strlen(catalog) : 0;
+  status_vars_len= 1+4+1+8+1+1+catalog_len;
   db_len = (db) ? (uint32) strlen(db) : 0;
+  /*
+    If we don't use flags2 for anything else than options contained in
+    thd->options, it would be more efficient to flags2=thd_arg->options
+    (OPTIONS_WRITTEN_TO_BINLOG would be used only at reading time).
+    But it's likely that we don't want to use 32 bits for 3 bits; in the future
+    we will probably want to reclaim the 29 bits. So we need the &.
+  */
+  flags2= thd_arg->options & OPTIONS_WRITTEN_TO_BIN_LOG;
+  sql_mode= thd_arg->variables.sql_mode;
+  DBUG_PRINT("info",("Query_log_event has flags2=%lu sql_mode=%lu",flags2,sql_mode));
 }
 #endif /* MYSQL_CLIENT */
 
 
 /*
   Query_log_event::Query_log_event()
+  This is used by the SQL slave thread to prepare the event before execution.
 */
 
-Query_log_event::Query_log_event(const char* buf, int event_len,
-				 bool old_format)
-  :Log_event(buf, old_format),data_buf(0), query(NULL), db(NULL)
+Query_log_event::Query_log_event(const char* buf, uint event_len,
+                                 const Format_description_log_event *description_event)
+  :Log_event(buf, description_event), data_buf(0), query(NULL),
+   catalog(NULL), db(NULL), catalog_len(0), status_vars_len(0),
+   flags2_inited(0), sql_mode_inited(0)
 {
   ulong data_len;
-  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;
-  }
-
+  uint8 common_header_len, post_header_len;
+  DBUG_ENTER("Query_log_event::Query_log_event(char*,...)");
+  common_header_len= description_event->common_header_len;
+  post_header_len= description_event->post_header_len[QUERY_EVENT-1]; 
+  DBUG_PRINT("info",("event_len=%ld, common_header_len=%d, post_header_len=%d",
+                     event_len, common_header_len, post_header_len));
+  
+  /*
+    We test if the event's length is sensible, and if so we compute data_len.
+    We cannot rely on QUERY_HEADER_LEN here as it would not be format-tolerant.
+    We use QUERY_HEADER_MINIMAL_LEN which is the same for 3.23, 4.0 & 5.0.
+  */
+  if (event_len < (uint)(common_header_len + post_header_len))
+    return;				
+  data_len = event_len - (common_header_len + post_header_len);
+  buf+= common_header_len;
+  
+  slave_proxy_id= thread_id = uint4korr(buf + Q_THREAD_ID_OFFSET);
   exec_time = uint4korr(buf + Q_EXEC_TIME_OFFSET);
+  db_len = (uint)buf[Q_DB_LEN_OFFSET];
   error_code = uint2korr(buf + Q_ERR_CODE_OFFSET);
 
-  if (!(data_buf = (char*) my_malloc(data_len + 1, MYF(MY_WME))))
+  /*
+    5.0 format starts here.
+    Depending on the format, we may or not have affected/warnings etc
+    The remnent post-header to be parsed has length:
+  */
+  uint32 tmp= post_header_len - QUERY_HEADER_MINIMAL_LEN; 
+  if (tmp)
+  {
+    status_vars_len= uint2korr(buf + Q_STATUS_VARS_LEN_OFFSET);
+    DBUG_PRINT("info", ("Query_log_event has status_vars_len=%d",
+                        status_vars_len));
+    tmp-= 2;
+  }
+  /* we have parsed everything we know in the post header */
+#ifndef DBUG_OFF
+  if (tmp) /* this is probably a master newer than us */
+    DBUG_PRINT("info", ("Query_log_event has longer post header than we know\
+  (%d more bytes)", tmp));
+#endif
+  
+  /*
+    Suppose you have a 4.0 master with --ansi and a 5.0 slave with --ansi.
+    The slave sets flags2 to 0 (because that's a 4.0 event);  if we simply use
+    this value of 0, we will cancel --ansi on the slave, which is
+    unwanted. In this example 0 means "unset", not really "set to 0".
+    Fortunately we have flags2_inited==0 to distinguish between "unset" and
+    "set to 0". See below.
+  */
+  
+  /* variable-part: the status vars; only in MySQL 5.0  */
+  
+  const char* start= buf+post_header_len;
+  const char* end= start+status_vars_len;
+  /*
+    The place from which we will start string duplication.
+  */
+  const char* start_dup= end;
+  
+  for (const char* pos=start;pos<end;)
+  {
+    switch (*pos)
+    {
+    case Q_FLAGS2_CODE:
+      flags2_inited= 1;
+      flags2= uint4korr(++pos);
+      DBUG_PRINT("info",("In Query_log_event, read flags2=%lu", flags2));
+      pos+= 4;
+      break;
+    case Q_SQL_MODE_CODE:
+      sql_mode_inited= 1;
+      sql_mode= uint8korr(++pos);
+      DBUG_PRINT("info",("In Query_log_event, read sql_mode=%lu", sql_mode));
+      pos+= 8;
+      break;
+    case Q_CATALOG_CODE:
+      catalog_len= *(++pos);
+      /*
+        Now 'pos' points to beginning of catalog - 1.
+        The catalog must be included in the string which we will duplicate
+        later. If string status vars having a smaller code had been seen before
+        and so marked to-be-duplicated, start_dup would be != end and we would
+        not need (and want) to change start_dup (because this would cut the
+        previously marked status vars).
+      */
+      if (start_dup==end)
+        start_dup= ++pos;
+      pos+= catalog_len;
+      break;
+    default:
+      /* That's why you must write status vars in growing order of code */
+      DBUG_PRINT("info",("Query_log_event has unknown status vars (first has\
+ code=%d), skipping the rest of them", *pos));
+      pos= end;
+    }
+  }
+  
+  /* A 2nd variable part; this is common to all versions */ 
+  
+  data_len-= start_dup-start; /* cut not-to-be-duplicated head */
+  if (!(data_buf = (char*) my_strdup_with_length(start_dup,
+                                                 data_len,
+                                                 MYF(MY_WME))))
     return;
-
-  memcpy(data_buf, buf + Q_DATA_OFFSET, data_len);
-  slave_proxy_id= thread_id= uint4korr(buf + Q_THREAD_ID_OFFSET);
-  db = data_buf;
-  db_len = (uint)buf[Q_DB_LEN_OFFSET];
-  query=data_buf + db_len + 1;
-  q_len = data_len - 1 - db_len;
-  *((char*)query+q_len) = 0;
+  
+  const char* tmp_buf= data_buf;
+  /* Now set event's pointers to point to bits of the new string */
+  if (catalog_len)
+  {
+    catalog= tmp_buf;
+    tmp_buf+= end-start_dup; /* "seek" to db */
+  }
+  db= tmp_buf;
+  query= tmp_buf + db_len + 1;
+  q_len = data_buf + data_len - query;
+  /* This is used to detect wrong parsing. Could be removed in the future. */
+  DBUG_PRINT("info", ("catalog_len=%d catalog='%s' db='%s' q_len=%d",
+                      catalog_len, catalog, db, q_len));
+  DBUG_VOID_RETURN;
 }
 
-
 /*
   Query_log_event::print()
 */
 
 #ifdef MYSQL_CLIENT
-void Query_log_event::print(FILE* file, bool short_form, char* last_db)
+void Query_log_event::print(FILE* file, bool short_form,
+                            LAST_EVENT_INFO* last_event_info)
 {
+  // TODO: print the catalog ??
   char buff[40],*end;				// Enough for SET TIMESTAMP
   if (!short_form)
   {
@@ -902,10 +1198,10 @@ void Query_log_event::print(FILE* file, bool short_form, char* last_db)
 
   bool same_db = 0;
 
-  if (db && last_db)
+  if (db && last_event_info->db)
   {
-    if (!(same_db = !memcmp(last_db, db, db_len + 1)))
-      memcpy(last_db, db, db_len + 1);
+    if (!(same_db = !memcmp(last_event_info->db, db, db_len + 1)))
+      memcpy(last_event_info->db, db, db_len + 1);
   }
   
   if (db && db[0] && !same_db)
@@ -916,6 +1212,67 @@ void Query_log_event::print(FILE* file, bool short_form, char* last_db)
   my_fwrite(file, (byte*) buff, (uint) (end-buff),MYF(MY_NABP | MY_WME));
   if (flags & LOG_EVENT_THREAD_SPECIFIC_F)
     fprintf(file,"SET @@session.pseudo_thread_id=%lu;\n",(ulong)thread_id);
+  /*
+    Now the session variables;
+    it's more efficient to pass SQL_MODE as a number instead of a
+    comma-separated list.
+    FOREIGN_KEY_CHECKS, SQL_AUTO_IS_NULL, UNIQUE_CHECKS are session-only
+    variables (they have no global version; they're not listed in sql_class.h),
+    The tests below work for pure binlogs or pure relay logs. Won't work for
+    mixed relay logs but we don't create mixed relay logs (that is, there is no
+    relay log with a format change except within the 3 first events, which
+    mysqlbinlog handles gracefully). So this code should always be good.
+  */
+
+  uint32 tmp;
+
+  if (likely(flags2_inited)) /* likely as this will mainly read 5.0 logs */
+  {
+    /* tmp is a bitmask of bits which have changed. */
+    if (likely(last_event_info->flags2_inited)) 
+      /* All bits which have changed */
+      tmp= (last_event_info->flags2) ^ flags2;
+    else /* that's the first Query event we read */
+    {
+      last_event_info->flags2_inited= 1;
+      tmp= ~((uint32)0); /* all bits have changed */
+    }
+
+    if (unlikely(tmp)) /* some bits have changed */
+    {
+      bool need_comma= 0;
+      fprintf(file, "SET ");
+      print_set_option(file, tmp, OPTION_NO_FOREIGN_KEY_CHECKS, ~flags2,
+                   "@@session.foreign_key_checks", &need_comma);
+      print_set_option(file, tmp, OPTION_AUTO_IS_NULL, flags2,
+                   "@@session.sql_auto_is_null", &need_comma);
+      print_set_option(file, tmp, OPTION_RELAXED_UNIQUE_CHECKS, ~flags2,
+                   "@@session.unique_checks", &need_comma);
+      fprintf(file,";\n");
+      last_event_info->flags2= flags2;
+    }
+  }
+
+  /*
+    If flags2_inited==0, this is an event from 3.23 or 4.0; nothing to print
+    (remember we don't produce mixed relay logs so there cannot be 5.0 events
+    before that one so there is nothing to reset).
+  */
+
+  if (likely(sql_mode_inited))
+  {
+    if (unlikely(!last_event_info->sql_mode_inited)) /* first Query event */
+    {
+      last_event_info->sql_mode_inited= 1;
+      last_event_info->sql_mode= ~sql_mode; // force a difference to force write
+    }
+    if (unlikely(last_event_info->sql_mode != sql_mode))
+    {
+      fprintf(file,"SET @@session.sql_mode=%lu;\n",(ulong)sql_mode);
+      last_event_info->sql_mode= sql_mode;
+    }
+  }
+
   my_fwrite(file, (byte*) query, q_len, MYF(MY_NABP | MY_WME));
   fprintf(file, ";\n");
 }
@@ -930,6 +1287,13 @@ void Query_log_event::print(FILE* file, bool short_form, char* last_db)
 int Query_log_event::exec_event(struct st_relay_log_info* rli)
 {
   int expected_error,actual_error= 0;
+  /*
+    Colleagues: please never free(thd->catalog) in MySQL. This would lead to
+    bugs as here thd->catalog is a part of an alloced block, not an entire
+    alloced block (see Query_log_event::exec_event()). Same for thd->db.
+    Thank you.
+  */
+  thd->catalog= (char*) catalog;
   thd->db= (char*) rewrite_db(db);
 
   /*
@@ -938,10 +1302,11 @@ int Query_log_event::exec_event(struct st_relay_log_info* rli)
     When InnoDB will want to store, the positions in rli won't have
     been updated yet, so group_master_log_* will point to old BEGIN
     and event_master_log* will point to the beginning of current COMMIT.
-    So the position to store is event_master_log_pos + event_len
-    since we must store the pos of the END of the current log event (COMMIT).
+    But log_pos of the COMMIT Query event is what we want, i.e. the pos of the
+    END of the current log event (COMMIT). We save it in rli so that InnoDB can
+    access it.
   */
-  rli->event_len= get_event_len();
+  rli->future_group_master_log_pos= log_pos;
 
   if (db_ok(thd->db, replicate_do_db, replicate_ignore_db))
   {
@@ -955,9 +1320,34 @@ int Query_log_event::exec_event(struct st_relay_log_info* rli)
     thd->clear_error();
     thd->variables.pseudo_thread_id= thread_id;		// for temp tables
 
+    if (flags2_inited)
+      /*
+        all bits of thd->options which are 1 in OPTIONS_WRITTEN_TO_BIN_LOG must
+        take their value from flags2.
+      */
+      thd->options= flags2|(thd->options & ~(ulong)OPTIONS_WRITTEN_TO_BIN_LOG);
+    /*
+      else, we are in a 3.23/4.0 binlog; we previously received a
+      Rotate_log_event which reset thd->options and sql_mode, so nothing to do.
+    */
+    
+    /*
+      We do not replicate IGNORE_DIR_IN_CREATE. That is, if the master is a
+      slave which runs with SQL_MODE=IGNORE_DIR_IN_CREATE, this should not
+      force us to ignore the dir too. Imagine you are a ring of machines, and
+      one has a disk problem so that you temporarily need IGNORE_DIR_IN_CREATE
+      on this machine; you don't want it to propagate elsewhere (you don't want
+      all slaves to start ignoring the dirs).
+    */
+    if (sql_mode_inited)
+      thd->variables.sql_mode= (thd->variables.sql_mode&MODE_NO_DIR_IN_CREATE)|
+        (sql_mode & ~(uint32)MODE_NO_DIR_IN_CREATE);
+    
     /*
       Sanity check to make sure the master did not get a really bad
-      error on the query.
+      error on the query (for example, if the query on the master was killed, we
+      don't want to play it on the slave, because we don't know how much of it
+      we have to play).
     */
     if (ignored_error_code((expected_error = error_code)) ||
 	!check_expected_error(thd,rli,expected_error))
@@ -1014,12 +1404,33 @@ Default database: '%s'",
                           print_slave_db_safe(db));
         thd->query_error= 1;
       }
+      /*
+        TODO: compare the values of "affected rows" around here. Something
+        like:
+        if ((uint32) affected_in_event != (uint32) affected_on_slave)
+        {
+        sql_print_error("Slave: did not get the expected number of affected \
+        rows running query from master - expected %d, got %d (this numbers \
+        should have matched modulo 4294967296).", 0, ...);
+        thd->query_error = 1;
+        }
+        We may also want an option to tell the slave to ignore "affected"
+        mismatch. This mismatch could be implemented with a new ER_ code, and
+        to ignore it you would use --slave-skip-errors...
+        
+        To do the comparison we need to know the value of "affected" which the
+        above mysql_parse() computed. And we need to know the value of
+        "affected" in the master's binlog. Both will be implemented later. The
+        important thing is that we now have the format ready to log the values
+        of "affected" in the binlog. So we can release 5.0.0 before effectively
+        logging "affected" and effectively comparing it.
+      */
     } 
-    /* 
-       End of sanity check. If the test was wrong, the query got a really bad
-       error on the master, which could be inconsistent, abort and tell DBA to
-       check/fix it. check_expected_error() already printed the message to
-       stderr and rli, and set thd->query_error to 1.
+    /*
+      End of sanity check. If the test was false, the query got a really bad
+      error on the master, which could be inconsistent. check_expected_error()
+      already printed the message to stderr and rli, to tell the DBA to fix
+      things, and it has set thd->query_error to 1.
     */
   } /* End of if (db_ok(... */
 
@@ -1039,15 +1450,23 @@ Default database: '%s'",
 
 
 /**************************************************************************
-	Start_log_event methods
+	Start_log_event_v3 methods
 **************************************************************************/
 
+#ifndef MYSQL_CLIENT
+Start_log_event_v3::Start_log_event_v3() :Log_event(), binlog_version(BINLOG_VERSION)
+{
+  created= when;
+  memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
+}
+#endif
+
 /*
-  Start_log_event::pack_info()
+  Start_log_event_v3::pack_info()
 */
 
 #if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
-void Start_log_event::pack_info(Protocol *protocol)
+void Start_log_event_v3::pack_info(Protocol *protocol)
 {
   char buf[12 + ST_SERVER_VER_LEN + 14 + 22], *pos;
   pos= strmov(buf, "Server ver: ");
@@ -1060,35 +1479,43 @@ void Start_log_event::pack_info(Protocol *protocol)
 
 
 /*
-  Start_log_event::print()
+  Start_log_event_v3::print()
 */
 
 #ifdef MYSQL_CLIENT
-void Start_log_event::print(FILE* file, bool short_form, char* last_db)
+void Start_log_event_v3::print(FILE* file, bool short_form, LAST_EVENT_INFO* last_event_info)
 {
-  if (short_form)
-    return;
-
-  print_header(file);
-  fprintf(file, "\tStart: binlog v %d, server v %s created ", binlog_version,
-	  server_version);
-  print_timestamp(file);
-  if (created)
-    fprintf(file," at startup");
-  fputc('\n', file);
+  if (!short_form)
+  {
+    print_header(file);
+    fprintf(file, "\tStart: binlog v %d, server v %s created ", binlog_version,
+            server_version);
+    print_timestamp(file);
+    if (created)
+      fprintf(file," at startup");
+    fputc('\n', file);
+  }
+#ifdef WHEN_WE_HAVE_THE_RESET_CONNECTION_SQL_COMMAND
+  /*
+    This is for mysqlbinlog: like in replication, we want to delete the stale
+    tmp files left by an unclean shutdown of mysqld (temporary tables). Probably
+    this can be done with RESET CONNECTION (syntax to be defined).
+  */
+  fprintf(file,"RESET CONNECTION;\n");
+#endif
   fflush(file);
 }
 #endif /* MYSQL_CLIENT */
 
 /*
-  Start_log_event::Start_log_event()
+  Start_log_event_v3::Start_log_event_v3()
 */
 
-Start_log_event::Start_log_event(const char* buf,
-				 bool old_format)
-  :Log_event(buf, old_format)
+Start_log_event_v3::Start_log_event_v3(const char* buf,
+                                       const Format_description_log_event* description_event)
+  :Log_event(buf, description_event)
 {
-  buf += (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
+  buf += description_event->common_header_len;
   binlog_version = uint2korr(buf+ST_BINLOG_VER_OFFSET);
   memcpy(server_version, buf+ST_SERVER_VER_OFFSET,
 	 ST_SERVER_VER_LEN);
@@ -1097,12 +1524,12 @@ Start_log_event::Start_log_event(const char* buf,
 
 
 /*
-  Start_log_event::write_data()
+  Start_log_event_v3::write_data()
 */
 
-int Start_log_event::write_data(IO_CACHE* file)
+int Start_log_event_v3::write_data(IO_CACHE* file)
 {
-  char buff[START_HEADER_LEN];
+  char buff[START_V3_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);
@@ -1110,7 +1537,7 @@ int Start_log_event::write_data(IO_CACHE* file)
 }
 
 /*
-  Start_log_event::exec_event()
+  Start_log_event_v3::exec_event()
 
   The master started
 
@@ -1129,18 +1556,24 @@ int Start_log_event::write_data(IO_CACHE* file)
 */
 
 #if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
-int Start_log_event::exec_event(struct st_relay_log_info* rli)
+int Start_log_event_v3::exec_event(struct st_relay_log_info* rli)
 {
-  DBUG_ENTER("Start_log_event::exec_event");
-
-  switch (rli->mi->old_format) {
-  case BINLOG_FORMAT_CURRENT:
-    /* 
-       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.
+  DBUG_ENTER("Start_log_event_v3::exec_event");
+  switch (rli->relay_log.description_event_for_exec->binlog_version)
+  {
+  case 3:
+  case 4:
+    /*
+      This can either be 4.x (then a Start_log_event_v3 is only at master
+      startup so we are sure the master has restarted and cleared his temp
+      tables; the event always has 'created'>0) or 5.0 (then we have to test
+      'created').
     */
-    close_temporary_tables(thd);
-    cleanup_load_tmpdir();
+    if (created)
+    {
+      close_temporary_tables(thd);
+      cleanup_load_tmpdir();
+    }
     /*
       As a transaction NEVER spans on 2 or more binlogs:
       if we have an active transaction at this point, the master died while
@@ -1163,33 +1596,264 @@ binary log.");
        Now the older formats; in that case load_tmpdir is cleaned up by the I/O
        thread.
     */
-  case BINLOG_FORMAT_323_LESS_57:
+  case 1:
+    if (strncmp(rli->relay_log.description_event_for_exec->server_version, 
+                "3.23.57",7) >= 0 && created)
+    {
+      /*
+        Can distinguish, based on the value of 'created': this event was
+        generated at master startup.
+      */
+      close_temporary_tables(thd);
+    }
     /*
-      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.
+      Otherwise, can't distinguish a Start_log_event generated at master startup
+      and one generated by master FLUSH LOGS, so cannot be sure temp tables have
+      to be dropped. So do nothing.
     */
     break;
-  case BINLOG_FORMAT_323_GEQ_57:
-    /*
-      Can distinguish, based on the value of 'created',
-      which was generated at master startup.
-    */
-    if (created)
-      close_temporary_tables(thd);
-    break;
   default:
     /* this case is impossible */
-    return 1;
+    DBUG_RETURN(1);
   }
-
   DBUG_RETURN(Log_event::exec_event(rli));
 }
 #endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
 
-/**************************************************************************
-	Load_log_event methods
-**************************************************************************/
+/***************************************************************************
+       Format_description_log_event methods
+****************************************************************************/
+
+/*
+  Format_description_log_event 1st ctor.
+
+  SYNOPSIS
+    Format_description_log_event::Format_description_log_event
+      binlog_version          	  the binlog version for which we want to build
+                                  an event. Can be 1 (=MySQL 3.23), 3 (=4.0.x
+                                  x>=2 and 4.1) or 4 (MySQL 5.0). Note that the
+                                  old 4.0 (binlog version 2) is not supported;
+                                  it should not be used for replication with
+                                  5.0.
+
+  DESCRIPTION
+    Ctor. Can be used to create the event to write to the binary log (when the
+    server starts or when FLUSH LOGS), or to create artificial events to parse
+    binlogs from MySQL 3.23 or 4.x.
+    When in a client, only the 2nd use is possible.
+
+  TODO
+    Update this code with the new event for LOAD DATA, once they are pushed (in
+    4.1 or 5.0). If it's in 5.0, only the "case 4" block should be updated.
+
+*/
+
+Format_description_log_event::Format_description_log_event(uint8 binlog_ver,
+                                                           const char* server_ver) 
+  : Start_log_event_v3()
+{
+  created= when;
+  binlog_version= binlog_ver;
+  switch(binlog_ver)
+  {
+  case 4: /* MySQL 5.0 */
+    memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
+    common_header_len= LOG_EVENT_HEADER_LEN;
+    number_of_event_types= LOG_EVENT_TYPES;
+    /* we'll catch my_malloc() error in is_valid() */
+    post_header_len=(uint8*) my_malloc(number_of_event_types*sizeof(uint8),
+                                       MYF(0)); 
+    /*
+      This long list of assignments is not beautiful, but I see no way to
+      make it nicer, as the right members are #defines, not array members, so
+      it's impossible to write a loop.
+    */
+    if (post_header_len)
+    {
+      post_header_len[START_EVENT_V3-1]= START_V3_HEADER_LEN;
+      post_header_len[QUERY_EVENT-1]= QUERY_HEADER_LEN;
+      post_header_len[STOP_EVENT-1]= 0;
+      post_header_len[ROTATE_EVENT-1]= ROTATE_HEADER_LEN;
+      post_header_len[INTVAR_EVENT-1]= 0;
+      post_header_len[LOAD_EVENT-1]= LOAD_HEADER_LEN;
+      post_header_len[SLAVE_EVENT-1]= 0;
+      post_header_len[CREATE_FILE_EVENT-1]= CREATE_FILE_HEADER_LEN;
+      post_header_len[APPEND_BLOCK_EVENT-1]= APPEND_BLOCK_HEADER_LEN;
+      post_header_len[EXEC_LOAD_EVENT-1]= EXEC_LOAD_HEADER_LEN;
+      post_header_len[DELETE_FILE_EVENT-1]= DELETE_FILE_HEADER_LEN;
+      post_header_len[NEW_LOAD_EVENT-1]= post_header_len[LOAD_EVENT-1];
+      post_header_len[RAND_EVENT-1]= 0;
+      post_header_len[USER_VAR_EVENT-1]= 0;
+      post_header_len[FORMAT_DESCRIPTION_EVENT-1]= FORMAT_DESCRIPTION_HEADER_LEN;
+    }
+    break;
+
+  case 1: /* 3.23 */
+  case 3: /* 4.0.x x>=2 */
+    /*
+      We build an artificial (i.e. not sent by the master) event, which
+      describes what those old master versions send.
+    */
+    if (binlog_ver==1)
+      strmov(server_version, server_ver ? server_ver : "3.23");
+    else
+      strmov(server_version, server_ver ? server_ver : "4.0");
+    common_header_len= binlog_ver==1 ? OLD_HEADER_LEN :
+      LOG_EVENT_MINIMAL_HEADER_LEN;  
+    /*
+      The first new event in binlog version 4 is Format_desc. So any event type
+      after that does not exist in older versions. We use the events known by
+      version 3, even if version 1 had only a subset of them (this is not a
+      problem: it uses a few bytes for nothing but unifies code; it does not
+      make the slave detect less corruptions).
+    */
+    number_of_event_types= FORMAT_DESCRIPTION_EVENT - 1;
+    post_header_len=(uint8*) my_malloc(number_of_event_types*sizeof(uint8),
+                                       MYF(0)); 
+    if (post_header_len)
+    {
+      post_header_len[START_EVENT_V3-1]= START_V3_HEADER_LEN;
+      post_header_len[QUERY_EVENT-1]= QUERY_HEADER_MINIMAL_LEN;
+      post_header_len[STOP_EVENT-1]= 0;
+      post_header_len[ROTATE_EVENT-1]= (binlog_ver==1) ? 0 : ROTATE_HEADER_LEN;
+      post_header_len[INTVAR_EVENT-1]= 0;
+      post_header_len[LOAD_EVENT-1]= LOAD_HEADER_LEN;
+      post_header_len[SLAVE_EVENT-1]= 0;
+      post_header_len[CREATE_FILE_EVENT-1]= CREATE_FILE_HEADER_LEN;
+      post_header_len[APPEND_BLOCK_EVENT-1]= APPEND_BLOCK_HEADER_LEN;
+      post_header_len[EXEC_LOAD_EVENT-1]= EXEC_LOAD_HEADER_LEN;
+      post_header_len[DELETE_FILE_EVENT-1]= DELETE_FILE_HEADER_LEN;
+      post_header_len[NEW_LOAD_EVENT-1]= post_header_len[LOAD_EVENT-1];
+      post_header_len[RAND_EVENT-1]= 0;
+      post_header_len[USER_VAR_EVENT-1]= 0;
+    }
+    break;
+  default: /* Includes binlog version 2 i.e. 4.0.x x<=1 */
+    post_header_len= 0; /* will make is_valid() fail */
+    break;
+  }
+}
+
+Format_description_log_event::Format_description_log_event(const char* buf,
+                                                           uint event_len,
+                                                           const
+                                                           Format_description_log_event*
+                                                           description_event) 
+  /*
+    The problem with this constructor is that the fixed header may have a length
+    different from this version, but we don't know this length as we have not 
+    read the Format_description_log_event which says it, yet. This length is in
+    the post-header of the event, but we don't know where the post-header
+    starts. 
+    So this type of event HAS to:
+    - either have the header's length at the beginning (in the header, at a
+    fixed position which will never be changed), not in the post-header. That
+    would make the header be "shifted" compared to other events.
+    - or have a header of size LOG_EVENT_MINIMAL_HEADER_LEN (19), in all future
+    versions, so that we know for sure.
+    I (Guilhem) chose the 2nd solution. Rotate has the same constraint (because
+    it is sent before Format_description_log_event).
+  */
+ 
+  :Start_log_event_v3(buf, description_event)
+{
+  DBUG_ENTER("Format_description_log_event::Format_description_log_event(char*,...)");
+  buf+= LOG_EVENT_MINIMAL_HEADER_LEN;
+  if ((common_header_len=buf[ST_COMMON_HEADER_LEN_OFFSET]) < OLD_HEADER_LEN)
+    DBUG_VOID_RETURN; /* sanity check */
+  number_of_event_types=
+    event_len-(LOG_EVENT_MINIMAL_HEADER_LEN+ST_COMMON_HEADER_LEN_OFFSET+1);
+  DBUG_PRINT("info", ("common_header_len=%d number_of_event_types=%d",
+                      common_header_len, number_of_event_types)); 
+  /* If alloc fails, we'll detect it in is_valid() */
+  post_header_len= (uint8*) my_memdup(buf+ST_COMMON_HEADER_LEN_OFFSET+1,
+                                      number_of_event_types*
+                                      sizeof(*post_header_len),
+                                      MYF(0));  
+  DBUG_VOID_RETURN;
+}
+
+int Format_description_log_event::write_data(IO_CACHE* file)
+{
+  /*
+    We don't call Start_log_event_v3::write_data() because this would make 2
+    my_b_safe_write().
+  */
+  char buff[FORMAT_DESCRIPTION_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);
+  buff[ST_COMMON_HEADER_LEN_OFFSET]= LOG_EVENT_HEADER_LEN;    
+  memcpy(buff+ST_COMMON_HEADER_LEN_OFFSET+1, (byte*) post_header_len,
+         LOG_EVENT_TYPES);
+  return (my_b_safe_write(file, (byte*) buff, sizeof(buff)) ? -1 : 0);
+}
+  
+/*
+  SYNOPSIS
+    Format_description_log_event::exec_event()
+  
+  IMPLEMENTATION
+    Save the information which describes the binlog's format, to be able to
+    read all coming events.
+    Call Start_log_event_v3::exec_event().
+*/
+
+#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
+int Format_description_log_event::exec_event(struct st_relay_log_info* rli)
+{
+  DBUG_ENTER("Format_description_log_event::exec_event");
+  
+  /* save the information describing this binlog */  
+  delete rli->relay_log.description_event_for_exec;
+  rli->relay_log.description_event_for_exec= this;
+
+  /*
+    If this event comes from ourselves, there is no cleaning task to perform,
+    we don't call Start_log_event_v3::exec_event() (this was just to update the
+    log's description event).
+  */
+  if (server_id == (uint32) ::server_id)
+  {
+    /*
+      Do not modify rli->group_master_log_pos, as this event did not exist on
+      the master. That is, just update the *relay log* coordinates; this is done
+      by passing log_pos=0 to inc_group_relay_log_pos, like we do in
+      Stop_log_event::exec_event().
+    */
+    rli->inc_group_relay_log_pos(0);
+    flush_relay_log_info(rli);
+    DBUG_RETURN(0);
+  }
+
+  /*
+    If the event was not requested by the slave i.e. the master sent it while
+    the slave asked for a position >4, the event will make
+    rli->group_master_log_pos advance. Say that the slave asked for position
+    1000, and the Format_desc event's end is 95. Then in the beginning of
+    replication rli->group_master_log_pos will be 0, then 95, then jump to first
+    really asked event (which is >95). So this is ok.
+  */
+  DBUG_RETURN(Start_log_event_v3::exec_event(rli));
+}
+#endif
+
+  /**************************************************************************
+  	Load_log_event methods
+   General note about Load_log_event: the binlogging of LOAD DATA INFILE is
+   going to be changed in 5.0 (or maybe in 4.1; not decided yet).
+   However, the 5.0 slave could still have to read such events (from a 4.x
+   master), convert them (which just means maybe expand the header, when 5.0
+   servers have a UID in events) (remember that whatever is after the header
+   will be like in 4.x, as this event's format is not modified in 5.0 as we
+   will use new types of events to log the new LOAD DATA INFILE features).
+   To be able to read/convert, we just need to not assume that the common
+   header is of length LOG_EVENT_HEADER_LEN (we must use the description
+   event).
+   Note that I (Guilhem) manually tested replication of a big LOAD DATA INFILE
+   between 3.23 and 5.0, and between 4.0 and 5.0, and it works fine (and the
+   positions displayed in SHOW SLAVE STATUS then are fine too).
+  **************************************************************************/
 
 /*
   Load_log_event::pack_info()
@@ -1441,15 +2105,24 @@ Load_log_event::Load_log_event(THD *thd_arg, sql_exchange *ex,
     constructed event.
 */
 
-Load_log_event::Load_log_event(const char *buf, int event_len,
-			       bool old_format)
-  :Log_event(buf, old_format),num_fields(0),fields(0),
+Load_log_event::Load_log_event(const char *buf, uint event_len,
+                               const Format_description_log_event *description_event)
+  :Log_event(buf, description_event),num_fields(0),fields(0),
    field_lens(0),field_block_len(0),
    table_name(0),db(0),fname(0)
 {
   if (!event_len) // derived class, will call copy_log_event() itself
     return;
-  copy_log_event(buf, event_len, old_format);
+  /*
+    I (Guilhem) manually tested replication of LOAD DATA INFILE for 3.23->5.0,
+    4.0->5.0 and 5.0->5.0 and it works.
+  */
+  copy_log_event(buf, event_len,
+                 ((buf[EVENT_TYPE_OFFSET] == LOAD_EVENT) ?
+                  LOAD_HEADER_LEN + 
+                  description_event->common_header_len :
+                  LOAD_HEADER_LEN + LOG_EVENT_HEADER_LEN),
+                 description_event);
 }
 
 
@@ -1458,12 +2131,13 @@ Load_log_event::Load_log_event(const char *buf, int event_len,
 */
 
 int Load_log_event::copy_log_event(const char *buf, ulong event_len,
-				   bool old_format)
+                                   int body_offset,
+                                   const Format_description_log_event *description_event)
 {
   uint data_len;
   char* buf_end = (char*)buf + event_len;
-  uint header_len= old_format ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
-  const char* data_head = buf + header_len;
+  /* this is the beginning of the post-header */
+  const char* data_head = buf + description_event->common_header_len;
   slave_proxy_id= 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);
@@ -1471,10 +2145,6 @@ int Load_log_event::copy_log_event(const char *buf, ulong event_len,
   db_len = (uint)data_head[L_DB_LEN_OFFSET];
   num_fields = uint4korr(data_head + L_NUM_FIELDS_OFFSET);
 	  
-  int body_offset = ((buf[EVENT_TYPE_OFFSET] == LOAD_EVENT) ?
-		     LOAD_HEADER_LEN + header_len :
-		     get_data_body_offset());
-  
   if ((int) event_len < body_offset)
     return 1;
   /*
@@ -1498,6 +2168,12 @@ int Load_log_event::copy_log_event(const char *buf, ulong event_len,
   fname = db + db_len + 1;
   fname_len = strlen(fname);
   // null termination is accomplished by the caller doing buf[event_len]=0
+
+  /*
+    In 5.0 this event will have the same format, as we are planning to log LOAD
+    DATA INFILE in a completely different way (as a plain-text query) since 4.1
+    or 5.0 (Dmitri's WL#874)
+  */
   return 0;
 }
 
@@ -1507,13 +2183,13 @@ int Load_log_event::copy_log_event(const char *buf, ulong event_len,
 */
 
 #ifdef MYSQL_CLIENT
-void Load_log_event::print(FILE* file, bool short_form, char* last_db)
+void Load_log_event::print(FILE* file, bool short_form, LAST_EVENT_INFO* last_event_info)
 {
-  print(file, short_form, last_db, 0);
+  print(file, short_form, last_event_info, 0);
 }
 
 
-void Load_log_event::print(FILE* file, bool short_form, char* last_db,
+void Load_log_event::print(FILE* file, bool short_form, LAST_EVENT_INFO* last_event_info,
 			   bool commented)
 {
   if (!short_form)
@@ -1524,10 +2200,10 @@ void Load_log_event::print(FILE* file, bool short_form, char* last_db,
   }
 
   bool same_db = 0;
-  if (db && last_db)
+  if (db && last_event_info->db)
   {
-    if (!(same_db = !memcmp(last_db, db, db_len + 1)))
-      memcpy(last_db, db, db_len + 1);
+    if (!(same_db = !memcmp(last_event_info->db, db, db_len + 1)))
+      memcpy(last_event_info->db, db, db_len + 1);
   }
   
   if (db && db[0] && !same_db)
@@ -1839,17 +2515,17 @@ void Rotate_log_event::pack_info(Protocol *protocol)
 */
 
 #ifdef MYSQL_CLIENT
-void Rotate_log_event::print(FILE* file, bool short_form, char* last_db)
+void Rotate_log_event::print(FILE* file, bool short_form, LAST_EVENT_INFO* last_event_info)
 {
   char buf[22];
+
   if (short_form)
     return;
-
   print_header(file);
   fprintf(file, "\tRotate to ");
   if (new_log_ident)
     my_fwrite(file, (byte*) new_log_ident, (uint)ident_len, 
-	      MYF(MY_NABP | MY_WME));
+              MYF(MY_NABP | MY_WME));
   fprintf(file, "  pos: %s", llstr(pos, buf));
   fputc('\n', file);
   fflush(file);
@@ -1861,28 +2537,21 @@ void Rotate_log_event::print(FILE* file, bool short_form, char* last_db)
   Rotate_log_event::Rotate_log_event()
 */
 
-Rotate_log_event::Rotate_log_event(const char* buf, int event_len,
-				   bool old_format)
-  :Log_event(buf, old_format),new_log_ident(NULL),alloced(0)
+Rotate_log_event::Rotate_log_event(const char* buf, uint event_len,
+                                   const Format_description_log_event* description_event)
+  :Log_event(buf, description_event) ,new_log_ident(NULL),alloced(0)
 {
   // The caller will ensure that event_len is what we have at EVENT_LEN_OFFSET
-  int header_size = (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
+  uint8 header_size= description_event->common_header_len;
+  uint8 post_header_len= description_event->post_header_len[ROTATE_EVENT-1];
   uint ident_offset;
   if (event_len < header_size)
     return;
   buf += header_size;
-  if (old_format)
-  {
-    ident_len = (uint)(event_len - OLD_HEADER_LEN);
-    pos = 4;
-    ident_offset = 0;
-  }
-  else
-  {
-    ident_len = (uint)(event_len - ROTATE_EVENT_OVERHEAD);
-    pos = uint8korr(buf + R_POS_OFFSET);
-    ident_offset = ROTATE_HEADER_LEN;
-  }
+  pos = post_header_len ? uint8korr(buf + R_POS_OFFSET) : 4;
+  ident_len = (uint)(event_len -
+                     (header_size+post_header_len)); 
+  ident_offset = post_header_len; 
   set_if_smaller(ident_len,FN_REFLEN-1);
   if (!(new_log_ident= my_strdup_with_length((byte*) buf +
 					     ident_offset,
@@ -1909,14 +2578,15 @@ int Rotate_log_event::write_data(IO_CACHE* file)
 /*
   Rotate_log_event::exec_event()
 
-  Got a rotate log even from the master
+  Got a rotate log event from the master
 
   IMPLEMENTATION
     This is mainly used so that we can later figure out the logname and
     position for the master.
 
-    We can't rotate the slave as this will cause infinitive rotations
+    We can't rotate the slave's BINlog as this will cause infinitive rotations
     in a A -> B -> A setup.
+    The NOTES below is a wrong comment which will disappear when 4.1 is merged.
 
   RETURN VALUES
     0	ok
@@ -1928,7 +2598,7 @@ int Rotate_log_event::exec_event(struct st_relay_log_info* rli)
   DBUG_ENTER("Rotate_log_event::exec_event");
 
   pthread_mutex_lock(&rli->data_lock);
-  rli->event_relay_log_pos += get_event_len();
+  rli->event_relay_log_pos= my_b_tell(rli->cur_log);
   /*
     If we are in a transaction: the only normal case is when the I/O thread was
     copying a big transaction, then it was stopped and restarted: we have this
@@ -1945,10 +2615,21 @@ int Rotate_log_event::exec_event(struct st_relay_log_info* rli)
   {
     memcpy(rli->group_master_log_name, new_log_ident, ident_len+1);
     rli->notify_group_master_log_name_update();
-    rli->group_master_log_pos = pos;
-    rli->group_relay_log_pos = rli->event_relay_log_pos;
-    DBUG_PRINT("info", ("group_master_log_pos: %lu",
+    rli->group_master_log_pos= pos;
+    rli->group_relay_log_pos= rli->event_relay_log_pos;
+    DBUG_PRINT("info", ("group_master_log_name: '%s' group_master_log_pos:\
+%lu",
+                        rli->group_master_log_name,
                         (ulong) rli->group_master_log_pos));
+    /*
+      Reset thd->options and sql_mode, because this could be the signal of a
+      master's downgrade from 5.0 to 4.0.
+      However, no need to reset description_event_for_exec: indeed, if the next
+      master is 5.0 (even 5.0.1) we will soon get a Format_desc; if the next
+      master is 4.0 then the events are in the slave's format (conversion).
+    */
+    set_slave_thread_options(thd);
+    thd->variables.sql_mode= global_system_variables.sql_mode;
   }
   pthread_mutex_unlock(&rli->data_lock);
   pthread_cond_broadcast(&rli->data_cond);
@@ -1982,12 +2663,13 @@ void Intvar_log_event::pack_info(Protocol *protocol)
   Intvar_log_event::Intvar_log_event()
 */
 
-Intvar_log_event::Intvar_log_event(const char* buf, bool old_format)
-  :Log_event(buf, old_format)
+Intvar_log_event::Intvar_log_event(const char* buf,
+                                   const Format_description_log_event* description_event)
+  :Log_event(buf, description_event)
 {
-  buf += (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
-  type = buf[I_TYPE_OFFSET];
-  val = uint8korr(buf+I_VAL_OFFSET);
+  buf+= description_event->common_header_len;
+  type= buf[I_TYPE_OFFSET];
+  val= uint8korr(buf+I_VAL_OFFSET);
 }
 
 
@@ -2023,7 +2705,7 @@ int Intvar_log_event::write_data(IO_CACHE* file)
 */
 
 #ifdef MYSQL_CLIENT
-void Intvar_log_event::print(FILE* file, bool short_form, char* last_db)
+void Intvar_log_event::print(FILE* file, bool short_form, LAST_EVENT_INFO* last_event_info)
 {
   char llbuff[22];
   const char *msg;
@@ -2066,7 +2748,7 @@ int Intvar_log_event::exec_event(struct st_relay_log_info* rli)
     thd->next_insert_id = val;
     break;
   }
-  rli->inc_event_relay_log_pos(get_event_len());
+  rli->inc_event_relay_log_pos();
   return 0;
 }
 #endif
@@ -2089,12 +2771,13 @@ void Rand_log_event::pack_info(Protocol *protocol)
 #endif
 
 
-Rand_log_event::Rand_log_event(const char* buf, bool old_format)
-  :Log_event(buf, old_format)
+Rand_log_event::Rand_log_event(const char* buf,
+                               const Format_description_log_event* description_event)
+  :Log_event(buf, description_event)
 {
-  buf += (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
-  seed1 = uint8korr(buf+RAND_SEED1_OFFSET);
-  seed2 = uint8korr(buf+RAND_SEED2_OFFSET);
+  buf+= description_event->common_header_len;
+  seed1= uint8korr(buf+RAND_SEED1_OFFSET);
+  seed2= uint8korr(buf+RAND_SEED2_OFFSET);
 }
 
 
@@ -2108,7 +2791,7 @@ int Rand_log_event::write_data(IO_CACHE* file)
 
 
 #ifdef MYSQL_CLIENT
-void Rand_log_event::print(FILE* file, bool short_form, char* last_db)
+void Rand_log_event::print(FILE* file, bool short_form, LAST_EVENT_INFO* last_event_info)
 {
   char llbuff[22],llbuff2[22];
   if (!short_form)
@@ -2128,7 +2811,7 @@ int Rand_log_event::exec_event(struct st_relay_log_info* rli)
 {
   thd->rand.seed1= (ulong) seed1;
   thd->rand.seed2= (ulong) seed2;
-  rli->inc_event_relay_log_pos(get_event_len());
+  rli->inc_event_relay_log_pos();
   return 0;
 }
 #endif /* !MYSQL_CLIENT */
@@ -2192,10 +2875,11 @@ void User_var_log_event::pack_info(Protocol* protocol)
 #endif /* !MYSQL_CLIENT */
 
 
-User_var_log_event::User_var_log_event(const char* buf, bool old_format)
-  :Log_event(buf, old_format)
+User_var_log_event::User_var_log_event(const char* buf,
+                                       const Format_description_log_event* description_event)
+  :Log_event(buf, description_event)
 {
-  buf+= (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
+  buf+= description_event->common_header_len;
   name_len= uint4korr(buf);
   name= (char *) buf + UV_NAME_LEN_SIZE;
   buf+= UV_NAME_LEN_SIZE + name_len;
@@ -2269,7 +2953,7 @@ int User_var_log_event::write_data(IO_CACHE* file)
 */
 
 #ifdef MYSQL_CLIENT
-void User_var_log_event::print(FILE* file, bool short_form, char* last_db)
+void User_var_log_event::print(FILE* file, bool short_form, LAST_EVENT_INFO* last_event_info)
 {
   if (!short_form)
   {
@@ -2359,7 +3043,7 @@ int User_var_log_event::exec_event(struct st_relay_log_info* rli)
   e.update_hash(val, val_len, type, charset, DERIVATION_NONE);
   free_root(&thd->mem_root,0);
 
-  rli->inc_event_relay_log_pos(get_event_len());
+  rli->inc_event_relay_log_pos();
   return 0;
 }
 #endif /* !MYSQL_CLIENT */
@@ -2371,7 +3055,7 @@ int User_var_log_event::exec_event(struct st_relay_log_info* rli)
 
 #ifdef HAVE_REPLICATION
 #ifdef MYSQL_CLIENT
-void Unknown_log_event::print(FILE* file, bool short_form, char* last_db)
+void Unknown_log_event::print(FILE* file, bool short_form, LAST_EVENT_INFO* last_event_info)
 {
   if (short_form)
     return;
@@ -2401,7 +3085,7 @@ void Slave_log_event::pack_info(Protocol *protocol)
 #ifndef MYSQL_CLIENT
 Slave_log_event::Slave_log_event(THD* thd_arg,
 				 struct st_relay_log_info* rli)
-  :Log_event(thd_arg, 0, 0), mem_pool(0), master_host(0)
+  :Log_event(thd_arg, 0, 0) , mem_pool(0), master_host(0)
 {
   DBUG_ENTER("Slave_log_event");
   if (!rli->inited)				// QQ When can this happen ?
@@ -2442,7 +3126,7 @@ Slave_log_event::~Slave_log_event()
 
 
 #ifdef MYSQL_CLIENT
-void Slave_log_event::print(FILE* file, bool short_form, char* last_db)
+void Slave_log_event::print(FILE* file, bool short_form, LAST_EVENT_INFO* last_event_info)
 {
   char llbuff[22];
   if (short_form)
@@ -2488,12 +3172,13 @@ void Slave_log_event::init_from_mem_pool(int data_size)
 }
 
 
-Slave_log_event::Slave_log_event(const char* buf, int event_len)
-  :Log_event(buf,0),mem_pool(0),master_host(0)
+/* This code is not used, so has not been updated to be format-tolerant */
+Slave_log_event::Slave_log_event(const char* buf, uint event_len)
+  :Log_event(buf,0) /*unused event*/ ,mem_pool(0),master_host(0)
 {
-  event_len -= LOG_EVENT_HEADER_LEN;
-  if (event_len < 0)
+  if (event_len < LOG_EVENT_HEADER_LEN)
     return;
+  event_len -= LOG_EVENT_HEADER_LEN;
   if (!(mem_pool = (char*) my_malloc(event_len + 1, MYF(MY_WME))))
     return;
   memcpy(mem_pool, buf + LOG_EVENT_HEADER_LEN, event_len);
@@ -2521,7 +3206,7 @@ int Slave_log_event::exec_event(struct st_relay_log_info* rli)
 */
 
 #ifdef MYSQL_CLIENT
-void Stop_log_event::print(FILE* file, bool short_form, char* last_db)
+void Stop_log_event::print(FILE* file, bool short_form, LAST_EVENT_INFO* last_event_info)
 {
   if (short_form)
     return;
@@ -2543,7 +3228,7 @@ void Stop_log_event::print(FILE* file, bool short_form, char* last_db)
   We used to clean up slave_load_tmpdir, but this is useless as it has been
   cleared at the end of LOAD DATA INFILE.
   So we have nothing to do here.
-  The place were we must do this cleaning is in Start_log_event::exec_event(),
+  The place were we must do this cleaning is in Start_log_event_v3::exec_event(),
   not here. Because if we come here, the master was sane.
 */
 
@@ -2557,7 +3242,7 @@ int Stop_log_event::exec_event(struct st_relay_log_info* rli)
     could give false triggers in MASTER_POS_WAIT() that we have reached
     the target position when in fact we have not.
   */
-  rli->inc_group_relay_log_pos(get_event_len(), 0);
+  rli->inc_group_relay_log_pos(0);
   flush_relay_log_info(rli);
   return 0;
 }
@@ -2636,20 +3321,40 @@ int Create_file_log_event::write_base(IO_CACHE* file)
   Create_file_log_event ctor
 */
 
-Create_file_log_event::Create_file_log_event(const char* buf, int len,
-					     bool old_format)
-  :Load_log_event(buf,0,old_format),fake_base(0),block(0),inited_from_old(0)
-{
-  int block_offset;
-  if (copy_log_event(buf,len,old_format))
+Create_file_log_event::Create_file_log_event(const char* buf, uint len,
+                                             const Format_description_log_event* description_event)
+  :Load_log_event(buf,0,description_event),fake_base(0),block(0),inited_from_old(0)
+{
+  uint block_offset;
+  uint header_len= description_event->common_header_len;
+  uint8 load_header_len= description_event->post_header_len[LOAD_EVENT-1];
+  uint8 create_file_header_len= description_event->post_header_len[CREATE_FILE_EVENT-1];
+  if (copy_log_event(buf,len,
+                     ((buf[EVENT_TYPE_OFFSET] == LOAD_EVENT) ?
+                      load_header_len + header_len :
+                      (fake_base ? (header_len+load_header_len) :
+                       (header_len+load_header_len) +
+                       create_file_header_len)),
+                     description_event))
     return;
-  if (!old_format)
+  if (description_event->binlog_version!=1)
   {
-    file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN +
-			+ LOAD_HEADER_LEN + CF_FILE_ID_OFFSET);
+    file_id= uint4korr(buf + 
+                       header_len +
+		       load_header_len + CF_FILE_ID_OFFSET);
     // + 1 for \0 terminating fname  
-    block_offset = (LOG_EVENT_HEADER_LEN + Load_log_event::get_data_size() +
-		    CREATE_FILE_HEADER_LEN + 1);
+    /*
+      Note that it's ok to use get_data_size() below, because it is computed
+      with values we have already read from this event (because we called
+      copy_log_event()); we are not using slave's format info to decode master's
+      format, we are really using master's format info.
+      Anyway, both formats should be identical (except the common_header_len) as
+      these Load events are not changed between 4.0 and 5.0 (as logging of LOAD
+      DATA INFILE does not use Load_log_event in 5.0).
+    */
+    block_offset= description_event->common_header_len +
+      Load_log_event::get_data_size() +
+      create_file_header_len + 1;
     if (len < block_offset)
       return;
     block = (char*)buf + block_offset;
@@ -2669,18 +3374,18 @@ Create_file_log_event::Create_file_log_event(const char* buf, int len,
 
 #ifdef MYSQL_CLIENT
 void Create_file_log_event::print(FILE* file, bool short_form, 
-				  char* last_db, bool enable_local)
+				  LAST_EVENT_INFO* last_event_info, bool enable_local)
 {
   if (short_form)
   {
     if (enable_local && check_fname_outside_temp_buf())
-      Load_log_event::print(file, 1, last_db);
+      Load_log_event::print(file, 1, last_event_info);
     return;
   }
 
   if (enable_local)
   {
-    Load_log_event::print(file, 1, last_db, !check_fname_outside_temp_buf());
+    Load_log_event::print(file, 1, last_event_info, !check_fname_outside_temp_buf());
     /* 
        That one is for "file_id: etc" below: in mysqlbinlog we want the #, in
        SHOW BINLOG EVENTS we don't.
@@ -2693,9 +3398,9 @@ void Create_file_log_event::print(FILE* file, bool short_form,
 
 
 void Create_file_log_event::print(FILE* file, bool short_form,
-				  char* last_db)
+				  LAST_EVENT_INFO* last_event_info)
 {
-  print(file,short_form,last_db,0);
+  print(file,short_form,last_event_info,0);
 }
 #endif /* MYSQL_CLIENT */
 
@@ -2809,14 +3514,19 @@ Append_block_log_event::Append_block_log_event(THD* thd_arg, const char* db_arg,
   Append_block_log_event ctor
 */
 
-Append_block_log_event::Append_block_log_event(const char* buf, int len)
-  :Log_event(buf, 0),block(0)
+Append_block_log_event::Append_block_log_event(const char* buf, uint len,
+                                               const Format_description_log_event* description_event)
+  :Log_event(buf, description_event),block(0)
 {
-  if ((uint)len < APPEND_BLOCK_EVENT_OVERHEAD)
+  uint8 common_header_len= description_event->common_header_len; 
+  uint8 append_block_header_len=
+    description_event->post_header_len[APPEND_BLOCK_EVENT-1];
+  uint total_header_len= common_header_len+append_block_header_len;
+  if (len < total_header_len)
     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;
+  file_id= uint4korr(buf + common_header_len + AB_FILE_ID_OFFSET);
+  block= (char*)buf + total_header_len;
+  block_len= len - total_header_len;
 }
 
 
@@ -2839,7 +3549,7 @@ int Append_block_log_event::write_data(IO_CACHE* file)
 
 #ifdef MYSQL_CLIENT  
 void Append_block_log_event::print(FILE* file, bool short_form,
-				   char* last_db)
+				   LAST_EVENT_INFO* last_event_info)
 {
   if (short_form)
     return;
@@ -2921,12 +3631,15 @@ Delete_file_log_event::Delete_file_log_event(THD *thd_arg, const char* db_arg,
   Delete_file_log_event ctor
 */
 
-Delete_file_log_event::Delete_file_log_event(const char* buf, int len)
-  :Log_event(buf, 0),file_id(0)
+Delete_file_log_event::Delete_file_log_event(const char* buf, uint len,
+                                             const Format_description_log_event* description_event)
+  :Log_event(buf, description_event),file_id(0)
 {
-  if ((uint)len < DELETE_FILE_EVENT_OVERHEAD)
+  uint8 common_header_len= description_event->common_header_len;
+  uint8 delete_file_header_len= description_event->post_header_len[DELETE_FILE_EVENT-1];
+  if (len < (uint)(common_header_len + delete_file_header_len))
     return;
-  file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + AB_FILE_ID_OFFSET);
+  file_id= uint4korr(buf + common_header_len + DF_FILE_ID_OFFSET);
 }
 
 
@@ -2948,7 +3661,7 @@ int Delete_file_log_event::write_data(IO_CACHE* file)
 
 #ifdef MYSQL_CLIENT  
 void Delete_file_log_event::print(FILE* file, bool short_form,
-				  char* last_db)
+				  LAST_EVENT_INFO* last_event_info)
 {
   if (short_form)
     return;
@@ -3011,12 +3724,15 @@ Execute_load_log_event::Execute_load_log_event(THD *thd_arg, const char* db_arg,
   Execute_load_log_event ctor
 */
 
-Execute_load_log_event::Execute_load_log_event(const char* buf, int len)
-  :Log_event(buf, 0), file_id(0)
+Execute_load_log_event::Execute_load_log_event(const char* buf, uint len,
+                                               const Format_description_log_event* description_event)
+  :Log_event(buf, description_event), file_id(0)
 {
-  if ((uint)len < EXEC_LOAD_EVENT_OVERHEAD)
+  uint8 common_header_len= description_event->common_header_len;
+  uint8 exec_load_header_len= description_event->post_header_len[EXEC_LOAD_EVENT-1];
+  if (len < (uint)(common_header_len+exec_load_header_len))
     return;
-  file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + EL_FILE_ID_OFFSET);
+  file_id= uint4korr(buf + common_header_len + EL_FILE_ID_OFFSET);
 }
 
 
@@ -3038,7 +3754,7 @@ int Execute_load_log_event::write_data(IO_CACHE* file)
 
 #ifdef MYSQL_CLIENT  
 void Execute_load_log_event::print(FILE* file, bool short_form,
-				   char* last_db)
+				   LAST_EVENT_INFO* last_event_info)
 {
   if (short_form)
     return;
@@ -3085,8 +3801,8 @@ int Execute_load_log_event::exec_event(struct st_relay_log_info* rli)
     goto err;
   }
   if (!(lev = (Load_log_event*)Log_event::read_log_event(&file,
-							 (pthread_mutex_t*)0,
-							 (bool)0)) ||
+                                                         (pthread_mutex_t*)0,
+                                                         rli->relay_log.description_event_for_exec)) ||
       lev->get_type_code() != NEW_LOAD_EVENT)
   {
     slave_print_error(rli,0, "Error in Exec_load event: file '%s' appears corrupted", fname);