mysqlbinlog now prints "# Number of rows" and stops on errors

Main problem was that no log-event print function checked for disk
full error on the IO_CACHE.
All changes in this patch only affects mysqlbinlog, not the server!

- Changed all log-event print functions to return 1 on error
- Fixed memory usage when not using --flashback.
- Added printing of number of rows in row events. Can be disabled with
  --print-row-count=0
- Print annotated rows when using mysqlbinlog --short-form
- Fixed that mysqlbinlog --debug works
- Fixed create_drop_binlog.test test failure
- Reorganized fields in PRINT_EVENT_INFO to be according to size to
  optimize storage
- Don't change print_row_event_position or print_row_counts if set by user
- Remove some testing of argument to my_free is 0
- base64-output=never is now supported and works in all context
- Updated help information for --base64-output and --short-form
- print_row_count is now on by default. Reset automatically if --short-form
  is used
- Removed obsolote warning for mysql 5.6.0
- More DBUG_PRINT for mysqltest.cc
- my_b_write_byte() now checks for flush failures. This fixed a memory
  overrun on disk full
- my_b_printf() now returns 1 on failure, 0 on ok.  This simplifies code
  and no old code was using the old return value of my_b_printf().
- my_b_Write_backtick_quote() now returns 1 on failure and 0 on ok
- Fixed some error conditions in log printing that was not previously
  handled.
- Slave_rows_error_report() can now handle longlong positions
- Write_on_release_cache() rewritten so that we can detect errors
  on flush. Not depending on automatic release anymore.
- Changed types for Pos and End_log_pos to 64 bit in SHOW BINLOG EVENTS
- Fixed that copy_event_cache_to_string_and_reinit() works with strings
  longer than 4G (Changed to use LEX_STRING instead of String)
- Restricted binlog_rows_event_max_size to UINT32_MAX-1 as String's are
  anyway restricted to UINT32_MAX
- Fixed bug in rpl_binlog_state::write_to_iocache() which hide write
  failures (duplicate variable name)
- Fixed bug in String::append if original string was not allocated
- Stop mysqlbinlog output at once if there is an error.
- Before printing error message, flush result file. This ensures that
  the error message is printed last. (Easier to find)

8 files changed, 1257 insertions, 682 deletions

diff --git a/sql/log.cc b/sql/log.cc
index 34533b23ac5..36239cfa055 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -2992,7 +2992,6 @@ bool MYSQL_QUERY_LOG::write(THD *thd, time_t current_time,
   mysql_mutex_lock(&LOCK_log);
   if (is_open())
   {						// Safety agains reopen
-    int tmp_errno= 0;
     char buff[80], *end;
     char query_time_buff[22+7], lock_time_buff[22+7];
     size_t buff_len;
@@ -3014,16 +3013,13 @@ bool MYSQL_QUERY_LOG::write(THD *thd, time_t current_time,
 
         /* Note that my_b_write() assumes it knows the length for this */
         if (my_b_write(&log_file, (uchar*) buff, buff_len))
-          tmp_errno= errno;
+          goto err;
       }
       const uchar uh[]= "# User@Host: ";
-      if (my_b_write(&log_file, uh, sizeof(uh) - 1))
-        tmp_errno= errno;
-      if (my_b_write(&log_file, (uchar*) user_host, user_host_len))
-        tmp_errno= errno;
-      if (my_b_write(&log_file, (uchar*) "\n", 1))
-        tmp_errno= errno;
-    }
+      if (my_b_write(&log_file, uh, sizeof(uh) - 1) ||
+          my_b_write(&log_file, (uchar*) user_host, user_host_len) ||
+          my_b_write(&log_file, (uchar*) "\n", 1))
+        goto err;
     
     /* For slow query log */
     sprintf(query_time_buff, "%.6f", ulonglong2double(query_utime)/1000000.0);
@@ -3039,9 +3035,9 @@ bool MYSQL_QUERY_LOG::write(THD *thd, time_t current_time,
                     (ulong) thd->get_examined_row_count(),
                     thd->get_stmt_da()->is_ok() ?
                     (ulong) thd->get_stmt_da()->affected_rows() :
-                    0) == (size_t) -1)
-      tmp_errno= errno;
-     if ((thd->variables.log_slow_verbosity & LOG_SLOW_VERBOSITY_QUERY_PLAN) &&
+                    0))
+      goto err;
+    if ((thd->variables.log_slow_verbosity & LOG_SLOW_VERBOSITY_QUERY_PLAN) &&
          (thd->query_plan_flags &
           (QPLAN_FULL_SCAN | QPLAN_FULL_JOIN | QPLAN_TMP_TABLE |
            QPLAN_TMP_DISK | QPLAN_FILESORT | QPLAN_FILESORT_DISK)) &&
@@ -3060,21 +3056,22 @@ bool MYSQL_QUERY_LOG::write(THD *thd, time_t current_time,
                      thd->query_plan_fsort_passes,
                      ((thd->query_plan_flags & QPLAN_FILESORT_PRIORITY_QUEUE) ? 
                        "Yes" : "No")
-                     ) == (size_t) -1)
-       tmp_errno= errno;
+                     ))
+      goto err;
     if (thd->variables.log_slow_verbosity & LOG_SLOW_VERBOSITY_EXPLAIN &&
         thd->lex->explain)
     {
       StringBuffer<128> buf;
       DBUG_ASSERT(!thd->free_list);
       if (!print_explain_for_slow_log(thd->lex, thd, &buf))
-        my_b_printf(&log_file, "%s", buf.c_ptr_safe());
+        if (my_b_printf(&log_file, "%s", buf.c_ptr_safe()))
+          goto err;
       thd->free_items();
     }
     if (thd->db && strcmp(thd->db, db))
     {						// Database changed
-      if (my_b_printf(&log_file,"use %s;\n",thd->db) == (size_t) -1)
-        tmp_errno= errno;
+      if (my_b_printf(&log_file,"use %s;\n",thd->db))
+        goto err;
       strmov(db,thd->db);
     }
     if (thd->stmt_depends_on_first_successful_insert_id_in_prev_stmt)
@@ -3110,7 +3107,7 @@ bool MYSQL_QUERY_LOG::write(THD *thd, time_t current_time,
       *end='\n';
       if (my_b_write(&log_file, (uchar*) "SET ", 4) ||
           my_b_write(&log_file, (uchar*) buff + 1, (uint) (end-buff)))
-        tmp_errno= errno;
+        goto err;
     }
     if (is_command)
     {
@@ -3119,24 +3116,27 @@ bool MYSQL_QUERY_LOG::write(THD *thd, time_t current_time,
       DBUG_EXECUTE_IF("simulate_slow_log_write_error",
                       {DBUG_SET("+d,simulate_file_write_error");});
       if(my_b_write(&log_file, (uchar*) buff, buff_len))
-        tmp_errno= errno;
+        goto err;
     }
     if (my_b_write(&log_file, (uchar*) sql_text, sql_text_len) ||
         my_b_write(&log_file, (uchar*) ";\n",2) ||
         flush_io_cache(&log_file))
-      tmp_errno= errno;
-    if (tmp_errno)
-    {
-      error= 1;
-      if (! write_error)
-      {
-        write_error= 1;
-        sql_print_error(ER_THD(thd, ER_ERROR_ON_WRITE), name, tmp_errno);
-      }
+      goto err;
+
     }
   }
+end:
   mysql_mutex_unlock(&LOCK_log);
   DBUG_RETURN(error);
+
+err:
+  error= 1;
+  if (! write_error)
+  {
+    write_error= 1;
+    sql_print_error(ER_THD(thd, ER_ERROR_ON_WRITE), name, errno);
+  }
+  goto end;
 }
 
 
diff --git a/sql/log_event.cc b/sql/log_event.cc
index ebcfe98521a..ab8c1a1acad 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -216,7 +216,7 @@ is_parallel_retry_error(rpl_group_info *rgi, int err)
 static void inline slave_rows_error_report(enum loglevel level, int ha_error,
                                            rpl_group_info *rgi, THD *thd,
                                            TABLE *table, const char * type,
-                                           const char *log_name, ulong pos)
+                                           const char *log_name, my_off_t pos)
 {
   const char *handler_error= (ha_error ? HA_ERR(ha_error) : NULL);
   char buff[MAX_SLAVE_ERRMSG], *slider;
@@ -250,14 +250,14 @@ static void inline slave_rows_error_report(enum loglevel level, int ha_error,
     rli->report(level, errcode, rgi->gtid_info(),
                 "Could not execute %s event on table %s.%s;"
                 "%s handler error %s; "
-                "the event's master log %s, end_log_pos %lu",
+                "the event's master log %s, end_log_pos %llu",
                 type, table->s->db.str, table->s->table_name.str,
                 buff, handler_error == NULL ? "<unknown>" : handler_error,
                 log_name, pos);
   else
     rli->report(level, errcode, rgi->gtid_info(),
                 "Could not execute %s event on table %s.%s;"
-                "%s the event's master log %s, end_log_pos %lu",
+                "%s the event's master log %s, end_log_pos %llu",
                 type, table->s->db.str, table->s->table_name.str,
                 buff, log_name, pos);
 }
@@ -290,10 +290,9 @@ public:
       flags  Flags for the cache
 
     DESCRIPTION
-
-      Class used to guarantee copy of cache to file before exiting the
-      current block.  On successful copy of the cache, the cache will
-      be reinited as a WRITE_CACHE.
+      Cache common parameters and ensure common flush_data() code
+      on successful copy of the cache, the cache will be reinited as a
+      WRITE_CACHE.
 
       Currently, a pointer to the cache is provided in the
       constructor, but it would be possible to create a subclass
@@ -305,28 +304,35 @@ public:
     reinit_io_cache(m_cache, WRITE_CACHE, 0L, FALSE, TRUE);
   }
 
-  ~Write_on_release_cache()
+  ~Write_on_release_cache() {}
+
+  bool flush_data()
   {
 #ifdef MYSQL_CLIENT
-    if(m_ev == NULL)
+    if (m_ev == NULL)
     {
-      copy_event_cache_to_file_and_reinit(m_cache, m_file);
-      if (m_flags & FLUSH_F)
-        fflush(m_file);
+      if (copy_event_cache_to_file_and_reinit(m_cache, m_file))
+        return 1;
+      if ((m_flags & FLUSH_F) && fflush(m_file))
+        return 1;
     }
     else // if m_ev<>NULL, then storing the output in output_buf
     {
       LEX_STRING tmp_str;
+      bool res;
       if (copy_event_cache_to_string_and_reinit(m_cache, &tmp_str))
-        exit(1);
-      m_ev->output_buf.append(tmp_str.str, tmp_str.length);
+        return 1;
+      res= m_ev->output_buf.append(tmp_str.str, tmp_str.length) != 0;
       my_free(tmp_str.str);
+      return res ? res : 0;
     }
 #else /* MySQL_SERVER */
-    copy_event_cache_to_file_and_reinit(m_cache, m_file);
-    if (m_flags & FLUSH_F)
-      fflush(m_file);
+    if (copy_event_cache_to_file_and_reinit(m_cache, m_file))
+      return 1;
+    if ((m_flags & FLUSH_F) && fflush(m_file))
+      return 1;
 #endif
+    return 0;
   }
 
   /*
@@ -364,27 +370,36 @@ private:
 */
 
 #ifdef MYSQL_CLIENT
-static void pretty_print_str(IO_CACHE* cache, const char* str, int len)
+static bool pretty_print_str(IO_CACHE* cache, const char* str, int len)
 {
   const char* end = str + len;
-  my_b_write_byte(cache, '\'');
+  if (my_b_write_byte(cache, '\''))
+    goto err;
+
   while (str < end)
   {
     char c;
+    int error;
+
     switch ((c=*str++)) {
-    case '\n': my_b_write(cache, (uchar*)"\\n", 2); break;
-    case '\r': my_b_write(cache, (uchar*)"\\r", 2); break;
-    case '\\': my_b_write(cache, (uchar*)"\\\\", 2); break;
-    case '\b': my_b_write(cache, (uchar*)"\\b", 2); break;
-    case '\t': my_b_write(cache, (uchar*)"\\t", 2); break;
-    case '\'': my_b_write(cache, (uchar*)"\\'", 2); break;
-    case 0   : my_b_write(cache, (uchar*)"\\0", 2); break;
+    case '\n': error= my_b_write(cache, (uchar*)"\\n", 2); break;
+    case '\r': error= my_b_write(cache, (uchar*)"\\r", 2); break;
+    case '\\': error= my_b_write(cache, (uchar*)"\\\\", 2); break;
+    case '\b': error= my_b_write(cache, (uchar*)"\\b", 2); break;
+    case '\t': error= my_b_write(cache, (uchar*)"\\t", 2); break;
+    case '\'': error= my_b_write(cache, (uchar*)"\\'", 2); break;
+    case 0   : error= my_b_write(cache, (uchar*)"\\0", 2); break;
     default:
-      my_b_write_byte(cache, c);
+      error= my_b_write_byte(cache, c);
       break;
     }
+    if (error)
+      goto err;
   }
-  my_b_write_byte(cache, '\'');
+  return my_b_write_byte(cache, '\'');
+
+err:
+  return 1;
 }
 #endif /* MYSQL_CLIENT */
 
@@ -1144,19 +1159,25 @@ int append_query_string(CHARSET_INFO *csinfo, String *to,
 
 #ifdef MYSQL_CLIENT
 
-static void print_set_option(IO_CACHE* file, uint32 bits_changed,
+static bool print_set_option(IO_CACHE* file, uint32 bits_changed,
                              uint32 option, uint32 flags, const char* name,
                              bool* need_comma)
 {
   if (bits_changed & option)
   {
     if (*need_comma)
-      my_b_write(file, (uchar*)", ", 2);
-    my_b_printf(file, "%s=%d", name, MY_TEST(flags & option));
+      if (my_b_write(file, (uchar*)", ", 2))
+        goto err;
+    if (my_b_printf(file, "%s=%d", name, MY_TEST(flags & option)))
+      goto err;
     *need_comma= 1;
   }
+  return 0;
+err:
+  return 1;
 }
 #endif
+
 /**************************************************************************
 	Log_event methods (= the parent class of all events)
 **************************************************************************/
@@ -1327,7 +1348,7 @@ Log_event::Log_event(const char* buf,
       */
     log_pos+= data_written; /* purecov: inspected */
   }
-  DBUG_PRINT("info", ("log_pos: %lu", (ulong) log_pos));
+  DBUG_PRINT("info", ("log_pos: %llu", log_pos));
 
   flags= uint2korr(buf + FLAGS_OFFSET);
   if (((uchar)buf[EVENT_TYPE_OFFSET] == FORMAT_DESCRIPTION_EVENT) ||
@@ -1456,7 +1477,7 @@ void Log_event::init_show_field_list(THD *thd, List<Item>* field_list)
                         mem_root);
   field_list->push_back(new (mem_root)
                         Item_return_int(thd, "Pos",
-                                        MY_INT32_NUM_DECIMAL_DIGITS,
+                                        MY_INT64_NUM_DECIMAL_DIGITS,
                                         MYSQL_TYPE_LONGLONG),
                         mem_root);
   field_list->push_back(new (mem_root)
@@ -1468,7 +1489,7 @@ void Log_event::init_show_field_list(THD *thd, List<Item>* field_list)
                         mem_root);
   field_list->push_back(new (mem_root)
                         Item_return_int(thd, "End_log_pos",
-                                        MY_INT32_NUM_DECIMAL_DIGITS,
+                                        MY_INT64_NUM_DECIMAL_DIGITS,
                                         MYSQL_TYPE_LONGLONG),
                         mem_root);
   field_list->push_back(new (mem_root) Item_empty_string(thd, "Info", 20),
@@ -2246,7 +2267,7 @@ Log_event* Log_event::read_log_event(const char* buf, uint event_len,
 
 #ifdef MYSQL_CLIENT
 
-static void hexdump_minimal_header_to_io_cache(IO_CACHE *file,
+static bool hexdump_minimal_header_to_io_cache(IO_CACHE *file,
                                                my_off_t offset,
                                                uchar *ptr)
 {
@@ -2259,15 +2280,18 @@ static void hexdump_minimal_header_to_io_cache(IO_CACHE *file,
     more headers (which must be printed by other methods, if desired).
   */
   char emit_buf[120];               // Enough for storing one line
-  my_b_printf(file,
-              "#           "
-              "|Timestamp   "
-              "|Type "
-              "|Master ID   "
-              "|Size        "
-              "|Master Pos  "
-              "|Flags\n");
-  size_t const emit_buf_written=
+  size_t emit_buf_written;
+
+  if (my_b_printf(file,
+                  "#           "
+                  "|Timestamp   "
+                  "|Type "
+                  "|Master ID   "
+                  "|Size        "
+                  "|Master Pos  "
+                  "|Flags\n"))
+    goto err;
+  emit_buf_written=
     my_snprintf(emit_buf, sizeof(emit_buf),
                 "# %8llx  "                         /* Position */
                 "|%02x %02x %02x %02x "             /* Timestamp */
@@ -2285,8 +2309,13 @@ static void hexdump_minimal_header_to_io_cache(IO_CACHE *file,
                 ptr[17], ptr[18]);                  /* Flags */
 
   DBUG_ASSERT(static_cast<size_t>(emit_buf_written) < sizeof(emit_buf));
-  my_b_write(file, reinterpret_cast<uchar*>(emit_buf), emit_buf_written);
-  my_b_write(file, (uchar*)"#\n", 2);
+  if (my_b_write(file, reinterpret_cast<uchar*>(emit_buf), emit_buf_written) ||
+      my_b_write(file, (uchar*)"#\n", 2))
+    goto err;
+
+  return 0;
+err:
+  return 1;
 }
 
 
@@ -2311,7 +2340,7 @@ static void format_hex_line(char *emit_buff)
     HEXDUMP_BYTES_PER_LINE + 2]= '\0';
 }
 
-static void hexdump_data_to_io_cache(IO_CACHE *file,
+static bool hexdump_data_to_io_cache(IO_CACHE *file,
                                      my_off_t offset,
                                      uchar *ptr,
                                      my_off_t size)
@@ -2333,7 +2362,7 @@ static void hexdump_data_to_io_cache(IO_CACHE *file,
   my_off_t i;
 
   if (size == 0)
-    return;
+    return 0;                                   // ok, nothing to do
 
   format_hex_line(emit_buffer);
   /*
@@ -2363,8 +2392,9 @@ static void hexdump_data_to_io_cache(IO_CACHE *file,
                                                  (ulonglong) starting_offset);
       /* remove \0 left after printing address */
       emit_buffer[2 + emit_buf_written]= ' ';
-      my_b_write(file, reinterpret_cast<uchar*>(emit_buffer),
-                 sizeof(emit_buffer) - 1);
+      if (my_b_write(file, reinterpret_cast<uchar*>(emit_buffer),
+                     sizeof(emit_buffer) - 1))
+        goto err;
       c= emit_buffer + 2 + 8 + 2 + (HEXDUMP_BYTES_PER_LINE * 3 + 1) + 2;
       h= emit_buffer + 2 + 8 + 2;
       format_hex_line(emit_buffer);
@@ -2399,17 +2429,23 @@ static void hexdump_data_to_io_cache(IO_CACHE *file,
     /* pad unprinted area */
     memset(h, ' ',
            (HEXDUMP_BYTES_PER_LINE * 3 + 1) - (h - (emit_buffer + 2 + 8 + 2)));
-    my_b_write(file, reinterpret_cast<uchar*>(emit_buffer),
-               c - emit_buffer);
+    if (my_b_write(file, reinterpret_cast<uchar*>(emit_buffer),
+                   c - emit_buffer))
+      goto err;
   }
-  my_b_write(file, (uchar*)"#\n", 2);
+  if (my_b_write(file, (uchar*)"#\n", 2))
+    goto err;
+
+  return 0;
+err:
+  return 1;
 }
 
 /*
   Log_event::print_header()
 */
 
-void Log_event::print_header(IO_CACHE* file,
+bool Log_event::print_header(IO_CACHE* file,
                              PRINT_EVENT_INFO* print_event_info,
                              bool is_more __attribute__((unused)))
 {
@@ -2417,10 +2453,11 @@ void Log_event::print_header(IO_CACHE* file,
   my_off_t hexdump_from= print_event_info->hexdump_from;
   DBUG_ENTER("Log_event::print_header");
 
-  my_b_write_byte(file, '#');
-  print_timestamp(file);
-  my_b_printf(file, " server id %lu  end_log_pos %s ", (ulong) server_id,
-              llstr(log_pos,llbuff));
+  if (my_b_write_byte(file, '#') ||
+      print_timestamp(file) ||
+      my_b_printf(file, " server id %lu  end_log_pos %s ", (ulong) server_id,
+                  llstr(log_pos,llbuff)))
+    goto err;
 
   /* print the checksum */
 
@@ -2430,8 +2467,10 @@ void Log_event::print_header(IO_CACHE* file,
     char checksum_buf[BINLOG_CHECKSUM_LEN * 2 + 4]; // to fit to "%p "
     size_t const bytes_written=
       my_snprintf(checksum_buf, sizeof(checksum_buf), "0x%08x ", crc);
-    my_b_printf(file, "%s ", get_type(&binlog_checksum_typelib, checksum_alg));
-    my_b_printf(file, checksum_buf, bytes_written);
+    if (my_b_printf(file, "%s ", get_type(&binlog_checksum_typelib,
+                                          checksum_alg)) ||
+        my_b_printf(file, checksum_buf, bytes_written))
+      goto err;
   }
 
   /* mysqlbinlog --hexdump */
@@ -2444,24 +2483,32 @@ void Log_event::print_header(IO_CACHE* file,
 
     size-= hdr_len;
 
-    my_b_printf(file, "# Position\n");
+    if (my_b_printf(file, "# Position\n"))
+      goto err;
 
     /* Write the header, nicely formatted by field. */
-    hexdump_minimal_header_to_io_cache(file, hexdump_from, ptr);
+    if (hexdump_minimal_header_to_io_cache(file, hexdump_from, ptr))
+      goto err;
 
     ptr+= hdr_len;
     hexdump_from+= hdr_len;
 
     /* Print the rest of the data, mimicking "hexdump -C" output. */
-    hexdump_data_to_io_cache(file, hexdump_from, ptr, size);
+    if (hexdump_data_to_io_cache(file, hexdump_from, ptr, size))
+      goto err;
 
     /*
       Prefix the next line so that the output from print_helper()
       will appear as a comment.
     */
-    my_b_write(file, (uchar*)"# Event: ", 9);
+    if (my_b_write(file, (uchar*)"# Event: ", 9))
+      goto err;
   }
-  DBUG_VOID_RETURN;
+
+  DBUG_RETURN(0);
+
+err:
+  DBUG_RETURN(1);
 }
 
 
@@ -2469,7 +2516,7 @@ void Log_event::print_header(IO_CACHE* file,
   Prints a quoted string to io cache.
   Control characters are displayed as hex sequence, e.g. \x00
   Single-quote and backslash characters are escaped with a \
-  
+
   @param[in] file              IO cache
   @param[in] prt               Pointer to string
   @param[in] length            String length
@@ -2556,12 +2603,14 @@ my_b_write_quoted_with_length(IO_CACHE *file, const uchar *ptr, uint length)
   @param[in] sl                Signed number
   @param[in] ul                Unsigned number
 */
-static void
+static bool
 my_b_write_sint32_and_uint32(IO_CACHE *file, int32 si, uint32 ui)
 {
-  my_b_printf(file, "%d", si);
+  bool res= my_b_printf(file, "%d", si);
   if (si < 0)
-    my_b_printf(file, " (%u)", ui);
+    if (my_b_printf(file, " (%u)", ui))
+      res= 1;
+  return res;
 }
 
 
@@ -2580,8 +2629,8 @@ my_b_write_sint32_and_uint32(IO_CACHE *file, int32 si, uint32 ui)
 */
 
 static size_t
-log_event_print_value(IO_CACHE *file, const uchar *ptr,
-                      uint type, uint meta,
+log_event_print_value(IO_CACHE *file, PRINT_EVENT_INFO *print_event_info,
+                      const uchar *ptr, uint type, uint meta,
                       char *typestr, size_t typestr_length)
 {
   uint32 length= 0;
@@ -2964,19 +3013,15 @@ log_event_print_value(IO_CACHE *file, const uchar *ptr,
     return my_b_write_quoted_with_length(file, ptr, length);
 
   case MYSQL_TYPE_DECIMAL:
-    my_b_printf(file,
-                "!! Old DECIMAL (mysql-4.1 or earlier). "
-                "Not enough metadata to display the value. ");
+    print_event_info->flush_for_error();
+    fprintf(stderr, "\nError: Found Old DECIMAL (mysql-4.1 or earlier). "
+            "Not enough metadata to display the value.\n");
     break;
-
   default:
-    {
-      char tmp[5];
-      my_snprintf(tmp, sizeof(tmp), "%04x", meta);
-      my_b_printf(file,
-                  "!! Don't know how to handle column type=%d meta=%d (%s)",
-                  type, meta, tmp);
-    }
+    print_event_info->flush_for_error();
+    fprintf(stderr,
+            "\nError: Don't know how to handle column type: %d meta: %d (%04x)\n",
+            type, meta, meta);
     break;
   }
   *typestr= 0;
@@ -2997,7 +3042,8 @@ return_null:
   @param[in] value             Pointer to packed row
   @param[in] prefix            Row's SQL clause ("SET", "WHERE", etc)
   
-  @retval   - number of bytes scanned.
+  @retval   0 error
+            # number of bytes scanned.
 */
 
 
@@ -3027,7 +3073,8 @@ Rows_log_event::print_verbose_one_row(IO_CACHE *file, table_def *td,
   value+= (bitmap_bits_set(cols_bitmap) + 7) / 8;
 
   if (!no_fill_output)
-    my_b_printf(file, "%s", prefix);
+    if (my_b_printf(file, "%s", prefix))
+      goto err;
 
   for (size_t i= 0; i < td->size(); i ++)
   {
@@ -3039,7 +3086,8 @@ Rows_log_event::print_verbose_one_row(IO_CACHE *file, table_def *td,
       continue;
 
     if (!no_fill_output)
-      my_b_printf(file, "###   @%d=", static_cast<int>(i + 1));
+      if (my_b_printf(file, "###   @%d=", static_cast<int>(i + 1)))
+        goto err;
 
     if (!is_null)
     {
@@ -3047,8 +3095,9 @@ Rows_log_event::print_verbose_one_row(IO_CACHE *file, table_def *td,
       if (value + fsize > m_rows_end)
       {
         if (!no_fill_output)
-          my_b_printf(file, "***Corrupted replication event was detected."
-                      " Not printing the value***\n");
+          if (my_b_printf(file, "***Corrupted replication event was detected."
+                          " Not printing the value***\n"))
+            goto err;
         value+= fsize;
         return 0;
       }
@@ -3056,7 +3105,7 @@ Rows_log_event::print_verbose_one_row(IO_CACHE *file, table_def *td,
 
     if (!no_fill_output)
     {
-      size= log_event_print_value(file,is_null? NULL: value,
+      size= log_event_print_value(file, print_event_info, is_null? NULL: value,
                                   td->type(i), td->field_metadata(i),
                                   typestr, sizeof(typestr));
 #ifdef WHEN_FLASHBACK_REVIEW_READY
@@ -3067,12 +3116,14 @@ Rows_log_event::print_verbose_one_row(IO_CACHE *file, table_def *td,
 
         // Using a tmp IO_CACHE to get the value output
         open_cached_file(&tmp_cache, NULL, NULL, 0, MYF(MY_WME | MY_NABP));
-        size= log_event_print_value(&tmp_cache, is_null? NULL: value,
+        size= log_event_print_value(&tmp_cache, print_event_info,
+                                    is_null ? NULL: value,
                                     td->type(i), td->field_metadata(i),
                                     typestr, sizeof(typestr));
-        if (copy_event_cache_to_string_and_reinit(&tmp_cache, &review_str))
-          exit(1);
+        error= copy_event_cache_to_string_and_reinit(&tmp_cache, &review_str);
         close_cached_file(&tmp_cache);
+        if (error)
+          return 0;
 
         switch (td->type(i)) // Converting a string to HEX format
         {
@@ -3090,12 +3141,14 @@ Rows_log_event::print_verbose_one_row(IO_CACHE *file, table_def *td,
               exit(1);
             }
             octet2hex((char*) hex_str.ptr(), tmp_str.ptr(), tmp_str.length());
-            my_b_printf(review_sql, ", UNHEX('%s')", hex_str.ptr());
+            if (my_b_printf(review_sql, ", UNHEX('%s')", hex_str.ptr()))
+              goto err;
             break;
           default:
             tmp_str.free();
-            tmp_str.append(review_str.str, review_str.length);
-            my_b_printf(review_sql, ", %s", tmp_str.ptr());
+            if (tmp_str.append(review_str.str, review_str.length) ||
+                my_b_printf(review_sql, ", %s", tmp_str.ptr()))
+              goto err;
             break;
         }
         my_free(revieww_str.str);
@@ -3106,36 +3159,40 @@ Rows_log_event::print_verbose_one_row(IO_CACHE *file, table_def *td,
     {
       IO_CACHE tmp_cache;
       open_cached_file(&tmp_cache, NULL, NULL, 0, MYF(MY_WME | MY_NABP));
-      size= log_event_print_value(&tmp_cache,is_null? NULL: value,
+      size= log_event_print_value(&tmp_cache, print_event_info,
+                                  is_null ? NULL: value,
                                   td->type(i), td->field_metadata(i),
                                   typestr, sizeof(typestr));
       close_cached_file(&tmp_cache);
     }
 
     if (!size)
-      return 0;
+      goto err;
 
     if (!is_null)
       value+= size;
 
     if (print_event_info->verbose > 1 && !no_fill_output)
     {
-      my_b_write(file, (uchar*)" /* ", 4);
-
-      my_b_printf(file, "%s ", typestr);
-
-      my_b_printf(file, "meta=%d nullable=%d is_null=%d ",
-                  td->field_metadata(i),
-                  td->maybe_null(i), is_null);
-      my_b_write(file, (uchar*)"*/", 2);
+      if (my_b_write(file, (uchar*)" /* ", 4) ||
+          my_b_printf(file, "%s ", typestr) ||
+          my_b_printf(file, "meta=%d nullable=%d is_null=%d ",
+                      td->field_metadata(i),
+                      td->maybe_null(i), is_null) ||
+          my_b_write(file, (uchar*)"*/", 2))
+        goto err;
     }
 
     if (!no_fill_output)
-      my_b_write_byte(file, '\n');
+      if (my_b_write_byte(file, '\n'))
+        goto err;
 
     null_bit_index++;
   }
   return value - value0;
+
+err:
+  return 0;
 }
 
 
@@ -3174,10 +3231,10 @@ void Rows_log_event::change_to_flashback_event(PRINT_EVENT_INFO *print_event_inf
     if (!(length1= print_verbose_one_row(NULL, td, print_event_info,
                                          &m_cols, value,
                                          (const uchar*) "", TRUE)))
-      {
-        fprintf(stderr, "\nError row length: %zu\n", length1);
-        exit(1);
-      }
+    {
+      fprintf(stderr, "\nError row length: %zu\n", length1);
+      exit(1);
+    }
     value+= length1;
 
     swap_buff1= (uchar *) my_malloc(length1, MYF(0));
@@ -3256,14 +3313,221 @@ end:
   delete td;
 }
 
+/**
+  Calc length of a packed value of the given SQL type
+
+  @param[in] ptr               Pointer to string
+  @param[in] type              Column type
+  @param[in] meta              Column meta information
+
+  @retval   - number of bytes scanned from ptr.
+              Except in case of NULL, in which case we return 1 to indicate ok
+*/
+
+static size_t calc_field_event_length(const uchar *ptr, uint type, uint meta)
+{
+  uint32 length= 0;
+
+  if (type == MYSQL_TYPE_STRING)
+  {
+    if (meta >= 256)
+    {
+      uint byte0= meta >> 8;
+      uint byte1= meta & 0xFF;
+
+      if ((byte0 & 0x30) != 0x30)
+      {
+        /* a long CHAR() field: see #37426 */
+        length= byte1 | (((byte0 & 0x30) ^ 0x30) << 4);
+        type= byte0 | 0x30;
+      }
+      else
+        length = meta & 0xFF;
+    }
+    else
+      length= meta;
+  }
+
+  switch (type) {
+  case MYSQL_TYPE_LONG:
+  case MYSQL_TYPE_TIMESTAMP:
+    return 4;
+  case MYSQL_TYPE_TINY:
+  case MYSQL_TYPE_YEAR:
+    return 1;
+  case MYSQL_TYPE_SHORT:
+    return 2;
+  case MYSQL_TYPE_INT24:
+  case MYSQL_TYPE_TIME:
+  case MYSQL_TYPE_NEWDATE:
+  case MYSQL_TYPE_DATE:
+      return 3;
+  case MYSQL_TYPE_LONGLONG:
+  case MYSQL_TYPE_DATETIME:
+    return 8;
+  case MYSQL_TYPE_NEWDECIMAL:
+  {
+    uint precision= meta >> 8;
+    uint decimals= meta & 0xFF;
+    uint bin_size= my_decimal_get_binary_size(precision, decimals);
+    return bin_size;
+  }
+  case MYSQL_TYPE_FLOAT:
+    return 4;
+  case MYSQL_TYPE_DOUBLE:
+    return 8;
+  case MYSQL_TYPE_BIT:
+  {
+    /* Meta-data: bit_len, bytes_in_rec, 2 bytes */
+    uint nbits= ((meta >> 8) * 8) + (meta & 0xFF);
+    length= (nbits + 7) / 8;
+    return length;
+  }
+  case MYSQL_TYPE_TIMESTAMP2:
+    return my_timestamp_binary_length(meta);
+  case MYSQL_TYPE_DATETIME2:
+    return my_datetime_binary_length(meta);
+  case MYSQL_TYPE_TIME2:
+    return my_time_binary_length(meta);
+  case MYSQL_TYPE_ENUM:
+    switch (meta & 0xFF) {
+    case 1:
+    case 2:
+      return (meta & 0xFF);
+    default:
+      /* Unknown ENUM packlen=%d", meta & 0xFF */
+      return 0;
+    }
+    break;
+  case MYSQL_TYPE_SET:
+    return meta & 0xFF;
+  case MYSQL_TYPE_BLOB:
+    return (meta <= 4 ? meta : 0);
+  case MYSQL_TYPE_VARCHAR:
+  case MYSQL_TYPE_VAR_STRING:
+  case MYSQL_TYPE_STRING:
+    length= meta;
+    return length < 256 ? length + 1 : length + 2;
+  case MYSQL_TYPE_DECIMAL:
+    break;
+  default:
+    break;
+  }
+  return 0;
+}
+
+
+size_t
+Rows_log_event::calc_row_event_length(table_def *td,
+                                      PRINT_EVENT_INFO *print_event_info,
+                                      MY_BITMAP *cols_bitmap,
+                                      const uchar *value)
+{
+  const uchar *value0= value;
+  const uchar *null_bits= value;
+  uint null_bit_index= 0;
+
+  /*
+    Skip metadata bytes which gives the information about nullabity of master
+    columns. Master writes one bit for each affected column.
+   */
+
+  value+= (bitmap_bits_set(cols_bitmap) + 7) / 8;
+
+  for (size_t i= 0; i < td->size(); i ++)
+  {
+    int is_null;
+    is_null= (null_bits[null_bit_index / 8] >> (null_bit_index % 8)) & 0x01;
+
+    if (bitmap_is_set(cols_bitmap, i) == 0)
+      continue;
+
+    if (!is_null)
+    {
+      size_t size;
+      size_t fsize= td->calc_field_size((uint)i, (uchar*) value);
+      if (value + fsize > m_rows_end)
+      {
+        /* Corrupted replication event was detected, skipping entry */
+        return 0;
+      }
+      if (!(size= calc_field_event_length(value, td->type(i),
+                                          td->field_metadata(i))))
+        return 0;
+      value+= size;
+    }
+    null_bit_index++;
+  }
+  return value - value0;
+}
+
+
+/**
+   Calculate how many rows there are in the event
+
+  @param[in] file              IO cache
+  @param[in] print_event_into  Print parameters
+*/
+
+void Rows_log_event::count_row_events(PRINT_EVENT_INFO *print_event_info)
+{
+  Table_map_log_event *map;
+  table_def *td;
+  uint row_events;
+  Log_event_type general_type_code= get_general_type_code();
+
+  switch (general_type_code) {
+  case WRITE_ROWS_EVENT:
+  case DELETE_ROWS_EVENT:
+    row_events= 1;
+    break;
+  case UPDATE_ROWS_EVENT:
+    row_events= 2;
+    break;
+  default:
+    DBUG_ASSERT(0); /* Not possible */
+    return;
+  }
+
+  if (!(map= print_event_info->m_table_map.get_table(m_table_id)) ||
+      !(td= map->create_table_def()))
+  {
+    /* Row event for unknown table */
+    return;
+  }
+
+  for (const uchar *value= m_rows_buf; value < m_rows_end; )
+  {
+    size_t length;
+    print_event_info->row_events++;
+
+    /* Print the first image */
+    if (!(length= calc_row_event_length(td, print_event_info,
+                                        &m_cols, value)))
+      break;
+    value+= length;
+
+    /* Print the second image (for UPDATE only) */
+    if (row_events == 2)
+    {
+      if (!(length= calc_row_event_length(td, print_event_info,
+                                          &m_cols_ai, value)))
+        break;
+      value+= length;
+    }
+  }
+  delete td;
+}
+
 
 /**
   Print a row event into IO cache in human readable form (in SQL format)
-  
+
   @param[in] file              IO cache
   @param[in] print_event_into  Print parameters
 */
-void Rows_log_event::print_verbose(IO_CACHE *file,
+
+bool Rows_log_event::print_verbose(IO_CACHE *file,
                                    PRINT_EVENT_INFO *print_event_info)
 {
   Table_map_log_event *map;
@@ -3281,9 +3545,10 @@ void Rows_log_event::print_verbose(IO_CACHE *file,
     uint8 extra_payload_len= extra_data_len - EXTRA_ROW_INFO_HDR_BYTES;
     assert(extra_data_len >= EXTRA_ROW_INFO_HDR_BYTES);
 
-    my_b_printf(file, "### Extra row data format: %u, len: %u :",
-                m_extra_row_data[EXTRA_ROW_INFO_FORMAT_OFFSET],
-                extra_payload_len);
+    if (my_b_printf(file, "### Extra row data format: %u, len: %u :",
+                    m_extra_row_data[EXTRA_ROW_INFO_FORMAT_OFFSET],
+                    extra_payload_len))
+      goto err;
     if (extra_payload_len)
     {
       /*
@@ -3294,9 +3559,11 @@ void Rows_log_event::print_verbose(IO_CACHE *file,
       char buff[buff_len];
       str_to_hex(buff, (const char*) &m_extra_row_data[EXTRA_ROW_INFO_HDR_BYTES],
                  extra_payload_len);
-      my_b_printf(file, "%s", buff);
+      if (my_b_printf(file, "%s", buff))
+        goto err;
     }
-    my_b_printf(file, "\n");
+    if (my_b_printf(file, "\n"))
+      goto err;
   }
 
   switch (general_type_code) {
@@ -3323,41 +3590,45 @@ void Rows_log_event::print_verbose(IO_CACHE *file,
     sql_command_short= "";
     DBUG_ASSERT(0); /* Not possible */
   }
-  
+
   if (!(map= print_event_info->m_table_map.get_table(m_table_id)) ||
       !(td= map->create_table_def()))
   {
-    my_b_printf(file, "### Row event for unknown table #%lu",
-                (ulong) m_table_id);
-    return;
+    return (my_b_printf(file, "### Row event for unknown table #%lu",
+                        (ulong) m_table_id));
   }
 
   /* If the write rows event contained no values for the AI */
   if (((general_type_code == WRITE_ROWS_EVENT) && (m_rows_buf==m_rows_end)))
   {
-    my_b_printf(file, "### INSERT INTO %`s.%`s VALUES ()\n", 
-                      map->get_db_name(), map->get_table_name());
+    if (my_b_printf(file, "### INSERT INTO %`s.%`s VALUES ()\n",
+                    map->get_db_name(), map->get_table_name()))
+      goto err;
     goto end;
   }
 
   for (const uchar *value= m_rows_buf; value < m_rows_end; )
   {
     size_t length;
-    my_b_printf(file, "### %s %`s.%`s\n",
-                      sql_command,
-                      map->get_db_name(), map->get_table_name());
+    print_event_info->row_events++;
 
+    if (my_b_printf(file, "### %s %`s.%`s\n",
+                    sql_command,
+                    map->get_db_name(), map->get_table_name()))
+      goto err;
 #ifdef WHEN_FLASHBACK_REVIEW_READY
     if (need_flashback_review)
-      my_b_printf(review_sql, "\nINSERT INTO `%s`.`%s` VALUES ('%s'",
-                  map->get_review_dbname(), map->get_review_tablename(), sql_command_short);
+      if (my_b_printf(review_sql, "\nINSERT INTO `%s`.`%s` VALUES ('%s'",
+                      map->get_review_dbname(), map->get_review_tablename(),
+                      sql_command_short))
+        goto err;
 #endif
 
     /* Print the first image */
     if (!(length= print_verbose_one_row(file, td, print_event_info,
                                   &m_cols, value,
                                   (const uchar*) sql_clause1)))
-      goto end;
+      goto err;
     value+= length;
 
     /* Print the second image (for UPDATE only) */
@@ -3366,7 +3637,7 @@ void Rows_log_event::print_verbose(IO_CACHE *file,
       if (!(length= print_verbose_one_row(file, td, print_event_info,
                                       &m_cols_ai, value,
                                       (const uchar*) sql_clause2)))
-        goto end;
+        goto err;
       value+= length;
     }
 #ifdef WHEN_FLASHBACK_REVIEW_READY
@@ -3374,16 +3645,22 @@ void Rows_log_event::print_verbose(IO_CACHE *file,
     {
       if (need_flashback_review)
         for (size_t i= 0; i < td->size(); i ++)
-          my_b_printf(review_sql, ", NULL");
+          if (my_b_printf(review_sql, ", NULL"))
+            goto err;
     }
 
     if (need_flashback_review)
-      my_b_printf(review_sql, ")%s\n", print_event_info->delimiter);
+      if (my_b_printf(review_sql, ")%s\n", print_event_info->delimiter))
+        goto err;
 #endif
   }
 
 end:
   delete td;
+  return 0;
+err:
+  delete td;
+  return 1;
 }
 
 void free_table_map_log_event(Table_map_log_event *event)
@@ -3391,7 +3668,7 @@ void free_table_map_log_event(Table_map_log_event *event)
   delete event;
 }
 
-void Log_event::print_base64(IO_CACHE* file,
+bool Log_event::print_base64(IO_CACHE* file,
                              PRINT_EVENT_INFO* print_event_info,
                              bool more)
 {
@@ -3399,14 +3676,6 @@ void Log_event::print_base64(IO_CACHE* file,
   uint32 size= uint4korr(ptr + EVENT_LEN_OFFSET);
   DBUG_ENTER("Log_event::print_base64");
 
-  size_t const tmp_str_sz= my_base64_needed_encoded_length((int) size);
-  char *const tmp_str= (char *) my_malloc(tmp_str_sz, MYF(MY_WME));
-  if (!tmp_str) {
-    fprintf(stderr, "\nError: Out of memory. "
-            "Could not print correct binlog event.\n");
-    DBUG_VOID_RETURN;
-  }
-
   if (is_flashback)
   {
     uint tmp_size= size;
@@ -3452,27 +3721,41 @@ void Log_event::print_base64(IO_CACHE* file,
     delete ev;
   }
 
-  if (my_base64_encode(ptr, (size_t) size, tmp_str))
-  {
-    DBUG_ASSERT(0);
-  }
-
-  if (print_event_info->base64_output_mode != BASE64_OUTPUT_DECODE_ROWS)
+  if (print_event_info->base64_output_mode != BASE64_OUTPUT_NEVER &&
+      print_event_info->base64_output_mode != BASE64_OUTPUT_DECODE_ROWS &&
+      ! print_event_info->short_form)
   {
-    if (my_b_tell(file) == 0)
-      my_b_write_string(file, "\nBINLOG '\n");
+    size_t const tmp_str_sz= my_base64_needed_encoded_length((int) size);
+    bool error= 0;
+    char *tmp_str;
+    if (!(tmp_str= (char *) my_malloc(tmp_str_sz, MYF(MY_WME))))
+      goto err;
 
-    my_b_printf(file, "%s\n", tmp_str);
+    if (my_base64_encode(ptr, (size_t) size, tmp_str))
+    {
+      DBUG_ASSERT(0);
+    }
 
-    if (!more)
-      my_b_printf(file, "'%s\n", print_event_info->delimiter);
+    if (my_b_tell(file) == 0)
+      if (my_b_write_string(file, "\nBINLOG '\n"))
+        error= 1;
+    if (!error && my_b_printf(file, "%s\n", tmp_str))
+      error= 1;
+    if (!more && !error)
+      if (my_b_printf(file, "'%s\n", print_event_info->delimiter))
+        error= 1;
+    my_free(tmp_str);
+    if (error)
+      goto err;
   }
 
 #ifdef WHEN_FLASHBACK_REVIEW_READY
-  if (print_event_info->verbose || need_flashback_review)
+  if (print_event_info->verbose || print_event_info->print_row_count ||
+      need_flashback_review)
 #else
   // Flashback need the table_map to parse the event
-  if (print_event_info->verbose || is_flashback)
+  if (print_event_info->verbose || print_event_info->print_row_count ||
+      is_flashback)
 #endif
   {
     Rows_log_event *ev= NULL;
@@ -3547,27 +3830,49 @@ void Log_event::print_base64(IO_CACHE* file,
 
     if (ev)
     {
+      bool error= 0;
+
 #ifdef WHEN_FLASHBACK_REVIEW_READY
       ev->need_flashback_review= need_flashback_review;
       if (print_event_info->verbose)
-        ev->print_verbose(file, print_event_info);
+      {
+        if (ev->print_verbose(file, print_event_info))
+          goto err;
+      }
       else
       {
         IO_CACHE tmp_cache;
-        open_cached_file(&tmp_cache, NULL, NULL, 0, MYF(MY_WME | MY_NABP));
-        ev->print_verbose(&tmp_cache, print_event_info);
+
+        if (open_cached_file(&tmp_cache, NULL, NULL, 0,
+                              MYF(MY_WME | MY_NABP)))
+        {
+          delete ev;
+          goto err;
+        }
+
+        error= ev->print_verbose(&tmp_cache, print_event_info);
         close_cached_file(&tmp_cache);
+        if (error)
+        {
+          delete ev;
+          goto err;
+        }
       }
 #else
       if (print_event_info->verbose)
-        ev->print_verbose(file, print_event_info);
+        error= ev->print_verbose(file, print_event_info);
+      else
+        ev->count_row_events(print_event_info);
 #endif
       delete ev;
+      if (error)
+        goto err;
     }
   }
+  DBUG_RETURN(0);
 
-  my_free(tmp_str);
-  DBUG_VOID_RETURN;
+err:
+  DBUG_RETURN(1);
 }
 
 
@@ -3575,7 +3880,7 @@ void Log_event::print_base64(IO_CACHE* file,
   Log_event::print_timestamp()
 */
 
-void Log_event::print_timestamp(IO_CACHE* file, time_t* ts)
+bool Log_event::print_timestamp(IO_CACHE* file, time_t* ts)
 {
   struct tm *res;
   time_t my_when= when;
@@ -3584,14 +3889,13 @@ void Log_event::print_timestamp(IO_CACHE* file, time_t* ts)
     ts = &my_when;
   res=localtime(ts);
 
-  my_b_printf(file,"%02d%02d%02d %2d:%02d:%02d",
-              res->tm_year % 100,
-              res->tm_mon+1,
-              res->tm_mday,
-              res->tm_hour,
-              res->tm_min,
-              res->tm_sec);
-  DBUG_VOID_RETURN;
+  DBUG_RETURN(my_b_printf(file,"%02d%02d%02d %2d:%02d:%02d",
+                          res->tm_year % 100,
+                          res->tm_mon+1,
+                          res->tm_mday,
+                          res->tm_hour,
+                          res->tm_min,
+                          res->tm_sec));
 }
 
 #endif /* MYSQL_CLIENT */
@@ -4750,7 +5054,7 @@ Query_log_event::begin_event(String *packet, ulong ev_offset,
   @todo
     print the catalog ??
 */
-void Query_log_event::print_query_header(IO_CACHE* file,
+bool Query_log_event::print_query_header(IO_CACHE* file,
 					 PRINT_EVENT_INFO* print_event_info)
 {
   // TODO: print the catalog ??
@@ -4760,10 +5064,12 @@ void Query_log_event::print_query_header(IO_CACHE* file,
 
   if (!print_event_info->short_form)
   {
-    print_header(file, print_event_info, FALSE);
-    my_b_printf(file, "\t%s\tthread_id=%lu\texec_time=%lu\terror_code=%d\n",
-                get_type_str(), (ulong) thread_id, (ulong) exec_time,
-                error_code);
+    if (print_header(file, print_event_info, FALSE) ||
+        my_b_printf(file,
+                    "\t%s\tthread_id=%lu\texec_time=%lu\terror_code=%d\n",
+                    get_type_str(), (ulong) thread_id, (ulong) exec_time,
+                    error_code))
+      goto err;
   }
 
   if ((flags & LOG_EVENT_SUPPRESS_USE_F))
@@ -4777,7 +5083,8 @@ void Query_log_event::print_query_header(IO_CACHE* file,
     if (different_db)
       memcpy(print_event_info->db, db, db_len + 1);
     if (db[0] && different_db) 
-      my_b_printf(file, "use %`s%s\n", db, print_event_info->delimiter);
+      if (my_b_printf(file, "use %`s%s\n", db, print_event_info->delimiter))
+        goto err;
   }
 
   end=int10_to_str((long) when, strmov(buff,"SET TIMESTAMP="),10);
@@ -4788,15 +5095,17 @@ void Query_log_event::print_query_header(IO_CACHE* file,
   }
   end= strmov(end, print_event_info->delimiter);
   *end++='\n';
-  my_b_write(file, (uchar*) buff, (uint) (end-buff));
+  if (my_b_write(file, (uchar*) buff, (uint) (end-buff)))
+    goto err;
   if ((!print_event_info->thread_id_printed ||
        ((flags & LOG_EVENT_THREAD_SPECIFIC_F) &&
         thread_id != print_event_info->thread_id)))
   {
     // If --short-form, print deterministic value instead of pseudo_thread_id.
-    my_b_printf(file,"SET @@session.pseudo_thread_id=%lu%s\n",
-                short_form ? 999999999 : (ulong)thread_id,
-                print_event_info->delimiter);
+    if (my_b_printf(file,"SET @@session.pseudo_thread_id=%lu%s\n",
+                    short_form ? 999999999 : (ulong)thread_id,
+                    print_event_info->delimiter))
+      goto err;
     print_event_info->thread_id= thread_id;
     print_event_info->thread_id_printed= 1;
   }
@@ -4821,18 +5130,20 @@ void Query_log_event::print_query_header(IO_CACHE* file,
     if (unlikely(tmp)) /* some bits have changed */
     {
       bool need_comma= 0;
-      my_b_write_string(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);
-      print_set_option(file, tmp, OPTION_NOT_AUTOCOMMIT, ~flags2,
-                       "@@session.autocommit", &need_comma);
-      print_set_option(file, tmp, OPTION_NO_CHECK_CONSTRAINT_CHECKS, ~flags2,
-                       "@@session.check_constraint_checks", &need_comma);
-      my_b_printf(file,"%s\n", print_event_info->delimiter);
+      if (my_b_write_string(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) ||
+          print_set_option(file, tmp, OPTION_NOT_AUTOCOMMIT, ~flags2,
+                           "@@session.autocommit", &need_comma) ||
+          print_set_option(file, tmp, OPTION_NO_CHECK_CONSTRAINT_CHECKS,
+                           ~flags2,
+                           "@@session.check_constraint_checks", &need_comma) ||
+          my_b_printf(file,"%s\n", print_event_info->delimiter))
+        goto err;
       print_event_info->flags2= flags2;
     }
   }
@@ -4855,17 +5166,19 @@ void Query_log_event::print_query_header(IO_CACHE* file,
                 !print_event_info->sql_mode_inited)))
   {
     char llbuff[22];
-    my_b_printf(file,"SET @@session.sql_mode=%s%s\n",
-                ullstr(sql_mode, llbuff), print_event_info->delimiter);
+    if (my_b_printf(file,"SET @@session.sql_mode=%s%s\n",
+                    ullstr(sql_mode, llbuff), print_event_info->delimiter))
+      goto err;
     print_event_info->sql_mode= sql_mode;
     print_event_info->sql_mode_inited= 1;
   }
   if (print_event_info->auto_increment_increment != auto_increment_increment ||
       print_event_info->auto_increment_offset != auto_increment_offset)
   {
-    my_b_printf(file,"SET @@session.auto_increment_increment=%lu, @@session.auto_increment_offset=%lu%s\n",
-                auto_increment_increment,auto_increment_offset,
-                print_event_info->delimiter);
+    if (my_b_printf(file,"SET @@session.auto_increment_increment=%lu, @@session.auto_increment_offset=%lu%s\n",
+                    auto_increment_increment,auto_increment_offset,
+                    print_event_info->delimiter))
+      goto err;
     print_event_info->auto_increment_increment= auto_increment_increment;
     print_event_info->auto_increment_offset=    auto_increment_offset;
   }
@@ -4880,18 +5193,20 @@ void Query_log_event::print_query_header(IO_CACHE* file,
     if (cs_info)
     {
       /* for mysql client */
-      my_b_printf(file, "/*!\\C %s */%s\n",
-                  cs_info->csname, print_event_info->delimiter);
-    }
-    my_b_printf(file,"SET "
-                "@@session.character_set_client=%d,"
-                "@@session.collation_connection=%d,"
-                "@@session.collation_server=%d"
-                "%s\n",
-                uint2korr(charset),
-                uint2korr(charset+2),
-                uint2korr(charset+4),
-                print_event_info->delimiter);
+      if (my_b_printf(file, "/*!\\C %s */%s\n",
+                      cs_info->csname, print_event_info->delimiter))
+        goto err;
+    }
+    if (my_b_printf(file,"SET "
+                    "@@session.character_set_client=%d,"
+                    "@@session.collation_connection=%d,"
+                    "@@session.collation_server=%d"
+                    "%s\n",
+                    uint2korr(charset),
+                    uint2korr(charset+2),
+                    uint2korr(charset+4),
+                    print_event_info->delimiter))
+      goto err;
     memcpy(print_event_info->charset, charset, 6);
     print_event_info->charset_inited= 1;
   }
@@ -4900,31 +5215,40 @@ void Query_log_event::print_query_header(IO_CACHE* file,
     if (memcmp(print_event_info->time_zone_str,
                time_zone_str, time_zone_len+1))
     {
-      my_b_printf(file,"SET @@session.time_zone='%s'%s\n",
-                  time_zone_str, print_event_info->delimiter);
+      if (my_b_printf(file,"SET @@session.time_zone='%s'%s\n",
+                      time_zone_str, print_event_info->delimiter))
+        goto err;
       memcpy(print_event_info->time_zone_str, time_zone_str, time_zone_len+1);
     }
   }
   if (lc_time_names_number != print_event_info->lc_time_names_number)
   {
-    my_b_printf(file, "SET @@session.lc_time_names=%d%s\n",
-                lc_time_names_number, print_event_info->delimiter);
+    if (my_b_printf(file, "SET @@session.lc_time_names=%d%s\n",
+                    lc_time_names_number, print_event_info->delimiter))
+      goto err;
     print_event_info->lc_time_names_number= lc_time_names_number;
   }
   if (charset_database_number != print_event_info->charset_database_number)
   {
     if (charset_database_number)
-      my_b_printf(file, "SET @@session.collation_database=%d%s\n",
-                  charset_database_number, print_event_info->delimiter);
-    else
-      my_b_printf(file, "SET @@session.collation_database=DEFAULT%s\n",
-                  print_event_info->delimiter);
+    {
+      if (my_b_printf(file, "SET @@session.collation_database=%d%s\n",
+                      charset_database_number, print_event_info->delimiter))
+        goto err;
+    }
+    else if (my_b_printf(file, "SET @@session.collation_database=DEFAULT%s\n",
+                         print_event_info->delimiter))
+      goto err;
     print_event_info->charset_database_number= charset_database_number;
   }
+  return 0;
+
+err:
+  return 1;
 }
 
 
-void Query_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
+bool Query_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
 {
   Write_on_release_cache cache(&print_event_info->head_cache, file, 0, this);
 
@@ -4934,25 +5258,32 @@ void Query_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
    */
   DBUG_EXECUTE_IF ("simulate_file_write_error",
                    {(&cache)->write_pos= (&cache)->write_end- 500;});
-  print_query_header(&cache, print_event_info);
+  if (print_query_header(&cache, print_event_info))
+    goto err;
   if (!is_flashback)
   {
-    my_b_write(&cache, (uchar*) query, q_len);
-    my_b_printf(&cache, "\n%s\n", print_event_info->delimiter);
+    if (my_b_write(&cache, (uchar*) query, q_len) ||
+        my_b_printf(&cache, "\n%s\n", print_event_info->delimiter))
+      goto err;
   }
   else // is_flashback == 1
   {
     if (strcmp("BEGIN", query) == 0)
     {
-      my_b_write(&cache, (uchar*) "COMMIT", 6);
-      my_b_printf(&cache, "\n%s\n", print_event_info->delimiter);
+      if (my_b_write(&cache, (uchar*) "COMMIT", 6) ||
+          my_b_printf(&cache, "\n%s\n", print_event_info->delimiter))
+        goto err;
     }
     else if (strcmp("COMMIT", query) == 0)
     {
-      my_b_write(&cache, (uchar*) "BEGIN", 5);
-      my_b_printf(&cache, "\n%s\n", print_event_info->delimiter);
+      if (my_b_write(&cache, (uchar*) "BEGIN", 5) ||
+          my_b_printf(&cache, "\n%s\n", print_event_info->delimiter))
+        goto err;
     }
   }
+  return cache.flush_data();
+err:
+  return 1;
 }
 #endif /* MYSQL_CLIENT */
 
@@ -5561,7 +5892,7 @@ void Start_log_event_v3::pack_info(Protocol *protocol)
 */
 
 #ifdef MYSQL_CLIENT
-void Start_log_event_v3::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
+bool Start_log_event_v3::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
 {
   DBUG_ENTER("Start_log_event_v3::print");
 
@@ -5570,16 +5901,21 @@ void Start_log_event_v3::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
 
   if (!print_event_info->short_form)
   {
-    print_header(&cache, print_event_info, FALSE);
-    my_b_printf(&cache, "\tStart: binlog v %d, server v %s created ",
-                binlog_version, server_version);
-    print_timestamp(&cache);
+    if (print_header(&cache, print_event_info, FALSE) ||
+        my_b_printf(&cache, "\tStart: binlog v %d, server v %s created ",
+                    binlog_version, server_version) ||
+        print_timestamp(&cache))
+      goto err;
     if (created)
-      my_b_printf(&cache," at startup");
-    my_b_printf(&cache, "\n");
+      if (my_b_printf(&cache," at startup"))
+        goto err;
+    if (my_b_printf(&cache, "\n"))
+      goto err;
     if (flags & LOG_EVENT_BINLOG_IN_USE_F)
-      my_b_printf(&cache, "# Warning: this binlog is either in use or was not "
-                  "closed properly.\n");
+      if (my_b_printf(&cache,
+                      "# Warning: this binlog is either in use or was not "
+                      "closed properly.\n"))
+        goto err;
   }
   if (!is_artificial_event() && created)
   {
@@ -5590,9 +5926,12 @@ void Start_log_event_v3::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
       and rollback unfinished transaction.
       Probably this can be done with RESET CONNECTION (syntax to be defined).
     */
-    my_b_printf(&cache,"RESET CONNECTION%s\n", print_event_info->delimiter);
+    if (my_b_printf(&cache,"RESET CONNECTION%s\n",
+                    print_event_info->delimiter))
+      goto err;
 #else
-    my_b_printf(&cache,"ROLLBACK%s\n", print_event_info->delimiter);
+    if (my_b_printf(&cache,"ROLLBACK%s\n", print_event_info->delimiter))
+      goto err;
 #endif
   }
   if (temp_buf &&
@@ -5600,11 +5939,15 @@ void Start_log_event_v3::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
       !print_event_info->short_form)
   {
     if (print_event_info->base64_output_mode != BASE64_OUTPUT_DECODE_ROWS)
-      my_b_printf(&cache, "BINLOG '\n");
-    print_base64(&cache, print_event_info, FALSE);
+      if (my_b_printf(&cache, "BINLOG '\n"))
+        goto err;
+    if (print_base64(&cache, print_event_info, FALSE))
+      goto err;
     print_event_info->printed_fd_event= TRUE;
   }
-  DBUG_VOID_RETURN;
+  DBUG_RETURN(cache.flush_data());
+err:
+  DBUG_RETURN(1);
 }
 #endif /* MYSQL_CLIENT */
 
@@ -6287,7 +6630,7 @@ int Start_encryption_log_event::do_update_pos(rpl_group_info *rgi)
 #endif
 
 #ifndef MYSQL_SERVER
-void Start_encryption_log_event::print(FILE* file,
+bool Start_encryption_log_event::print(FILE* file,
                                        PRINT_EVENT_INFO* print_event_info)
 {
     Write_on_release_cache cache(&print_event_info->head_cache, file);
@@ -6299,7 +6642,9 @@ void Start_encryption_log_event::print(FILE* file,
     buf.append(STRING_WITH_LEN(", nonce: "));
     buf.append_hex(nonce, BINLOG_NONCE_LENGTH);
     buf.append(STRING_WITH_LEN("\n# The rest of the binlog is encrypted!\n"));
-    my_b_write(&cache, (uchar*)buf.ptr(), buf.length());
+    if (my_b_write(&cache, (uchar*)buf.ptr(), buf.length()))
+      return 1;
+    return (cache.flush_data());
 }
 #endif
   /**************************************************************************
@@ -6324,7 +6669,7 @@ void Start_encryption_log_event::print(FILE* file,
 */
 
 #if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
-void Load_log_event::print_query(THD *thd, bool need_db, const char *cs,
+bool Load_log_event::print_query(THD *thd, bool need_db, const char *cs,
                                  String *buf, my_off_t *fn_start,
                                  my_off_t *fn_end, const char *qualify_db)
 {
@@ -6420,6 +6765,7 @@ void Load_log_event::print_query(THD *thd, bool need_db, const char *cs,
     }
     buf->append(STRING_WITH_LEN(")"));
   }
+  return 0;
 }
 
 
@@ -6663,26 +7009,27 @@ err:
 */
 
 #ifdef MYSQL_CLIENT
-void Load_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
+bool Load_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
 {
-  print(file, print_event_info, 0);
+  return print(file, print_event_info, 0);
 }
 
 
-void Load_log_event::print(FILE* file_arg, PRINT_EVENT_INFO* print_event_info,
+bool Load_log_event::print(FILE* file_arg, PRINT_EVENT_INFO* print_event_info,
 			   bool commented)
 {
   Write_on_release_cache cache(&print_event_info->head_cache, file_arg);
-
+  bool different_db= 1;
   DBUG_ENTER("Load_log_event::print");
+
   if (!print_event_info->short_form)
   {
-    print_header(&cache, print_event_info, FALSE);
-    my_b_printf(&cache, "\tQuery\tthread_id=%ld\texec_time=%ld\n",
-                thread_id, exec_time);
+    if (print_header(&cache, print_event_info, FALSE) ||
+        my_b_printf(&cache, "\tQuery\tthread_id=%ld\texec_time=%ld\n",
+                    thread_id, exec_time))
+      goto err;
   }
 
-  bool different_db= 1;
   if (db)
   {
     /*
@@ -6695,69 +7042,86 @@ void Load_log_event::print(FILE* file_arg, PRINT_EVENT_INFO* print_event_info,
         !commented)
       memcpy(print_event_info->db, db, db_len + 1);
   }
-  
+
   if (db && db[0] && different_db)
-    my_b_printf(&cache, "%suse %`s%s\n",
-            commented ? "# " : "",
-            db, print_event_info->delimiter);
+    if (my_b_printf(&cache, "%suse %`s%s\n",
+                    commented ? "# " : "",
+                    db, print_event_info->delimiter))
+      goto err;
 
   if (flags & LOG_EVENT_THREAD_SPECIFIC_F)
-    my_b_printf(&cache,"%sSET @@session.pseudo_thread_id=%lu%s\n",
-            commented ? "# " : "", (ulong)thread_id,
-            print_event_info->delimiter);
-  my_b_printf(&cache, "%sLOAD DATA ",
-              commented ? "# " : "");
+    if (my_b_printf(&cache,"%sSET @@session.pseudo_thread_id=%lu%s\n",
+                    commented ? "# " : "", (ulong)thread_id,
+                    print_event_info->delimiter))
+      goto err;
+  if (my_b_printf(&cache, "%sLOAD DATA ",
+                  commented ? "# " : ""))
+    goto err;
   if (check_fname_outside_temp_buf())
-    my_b_write_string(&cache, "LOCAL ");
-  my_b_printf(&cache, "INFILE '%-*s' ", fname_len, fname);
+    if (my_b_write_string(&cache, "LOCAL "))
+      goto err;
+  if (my_b_printf(&cache, "INFILE '%-*s' ", fname_len, fname))
+    goto err;
 
   if (sql_ex.opt_flags & REPLACE_FLAG)
-    my_b_write_string(&cache, "REPLACE ");
+  {
+    if (my_b_write_string(&cache, "REPLACE "))
+      goto err;
+  }
   else if (sql_ex.opt_flags & IGNORE_FLAG)
-    my_b_write_string(&cache, "IGNORE ");
-  
-  my_b_printf(&cache, "INTO TABLE `%s`", table_name);
-  my_b_write_string(&cache, " FIELDS TERMINATED BY ");
-  pretty_print_str(&cache, sql_ex.field_term, sql_ex.field_term_len);
+    if (my_b_write_string(&cache, "IGNORE "))
+      goto err;
 
-  if (sql_ex.opt_flags & OPT_ENCLOSED_FLAG)
-    my_b_write_string(&cache, " OPTIONALLY ");
-  my_b_write_string(&cache, " ENCLOSED BY ");
-  pretty_print_str(&cache, sql_ex.enclosed, sql_ex.enclosed_len);
-     
-  my_b_write_string(&cache, " ESCAPED BY ");
-  pretty_print_str(&cache, sql_ex.escaped, sql_ex.escaped_len);
-     
-  my_b_write_string(&cache, " LINES TERMINATED BY ");
-  pretty_print_str(&cache, sql_ex.line_term, sql_ex.line_term_len);
+  if (my_b_printf(&cache, "INTO TABLE `%s`", table_name) ||
+      my_b_write_string(&cache, " FIELDS TERMINATED BY ") ||
+      pretty_print_str(&cache, sql_ex.field_term, sql_ex.field_term_len))
+    goto err;
 
+  if (sql_ex.opt_flags & OPT_ENCLOSED_FLAG)
+    if (my_b_write_string(&cache, " OPTIONALLY "))
+      goto err;
+  if (my_b_write_string(&cache, " ENCLOSED BY ") ||
+      pretty_print_str(&cache, sql_ex.enclosed, sql_ex.enclosed_len) ||
+      my_b_write_string(&cache, " ESCAPED BY ") ||
+      pretty_print_str(&cache, sql_ex.escaped, sql_ex.escaped_len) ||
+      my_b_write_string(&cache, " LINES TERMINATED BY ") ||
+      pretty_print_str(&cache, sql_ex.line_term, sql_ex.line_term_len))
+    goto err;
 
   if (sql_ex.line_start)
   {
-    my_b_write_string(&cache," STARTING BY ");
-    pretty_print_str(&cache, sql_ex.line_start, sql_ex.line_start_len);
+    if (my_b_write_string(&cache," STARTING BY ") ||
+        pretty_print_str(&cache, sql_ex.line_start, sql_ex.line_start_len))
+      goto err;
   }
   if ((long) skip_lines > 0)
-    my_b_printf(&cache, " IGNORE %ld LINES", (long) skip_lines);
+    if (my_b_printf(&cache, " IGNORE %ld LINES", (long) skip_lines))
+      goto err;
 
   if (num_fields)
   {
     uint i;
     const char* field = fields;
-    my_b_write_string(&cache, " (");
+    if (my_b_write_string(&cache, " ("))
+      goto err;
     for (i = 0; i < num_fields; i++)
     {
       if (i)
-        my_b_write_byte(&cache, ',');
-      my_b_printf(&cache, "%`s", field);
-
+        if (my_b_write_byte(&cache, ','))
+          goto err;
+      if (my_b_printf(&cache, "%`s", field))
+        goto err;
       field += field_lens[i]  + 1;
     }
-    my_b_write_byte(&cache, ')');
+    if (my_b_write_byte(&cache, ')'))
+      goto err;
   }
 
-  my_b_printf(&cache, "%s\n", print_event_info->delimiter);
-  DBUG_VOID_RETURN;
+  if (my_b_printf(&cache, "%s\n", print_event_info->delimiter))
+    goto err;
+  DBUG_RETURN(cache.flush_data());
+err:
+  DBUG_RETURN(1);
 }
 #endif /* MYSQL_CLIENT */
 
@@ -7116,19 +7480,25 @@ void Rotate_log_event::pack_info(Protocol *protocol)
 */
 
 #ifdef MYSQL_CLIENT
-void Rotate_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
+bool Rotate_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
 {
+  if (print_event_info->short_form)
+    return 0;
+
   char buf[22];
   Write_on_release_cache cache(&print_event_info->head_cache, file,
                                Write_on_release_cache::FLUSH_F);
-
-  if (print_event_info->short_form)
-    return;
-  print_header(&cache, print_event_info, FALSE);
-  my_b_write_string(&cache, "\tRotate to ");
+  if (print_header(&cache, print_event_info, FALSE) ||
+      my_b_write_string(&cache, "\tRotate to "))
+    goto err;
   if (new_log_ident)
-    my_b_write(&cache, (uchar*) new_log_ident, (uint)ident_len);
-  my_b_printf(&cache, "  pos: %s\n", llstr(pos, buf));
+    if (my_b_write(&cache, (uchar*) new_log_ident, (uint)ident_len))
+      goto err;
+  if (my_b_printf(&cache, "  pos: %s\n", llstr(pos, buf)))
+    goto err;
+  return cache.flush_data();
+err:
+  return 1;
 }
 #endif /* MYSQL_CLIENT */
 
@@ -7333,18 +7703,21 @@ Binlog_checkpoint_log_event::do_shall_skip(rpl_group_info *rgi)
 
 
 #ifdef MYSQL_CLIENT
-void Binlog_checkpoint_log_event::print(FILE *file,
+bool Binlog_checkpoint_log_event::print(FILE *file,
                                         PRINT_EVENT_INFO *print_event_info)
 {
+  if (print_event_info->short_form)
+    return 0;
+
   Write_on_release_cache cache(&print_event_info->head_cache, file,
                                Write_on_release_cache::FLUSH_F);
 
-  if (print_event_info->short_form)
-    return;
-  print_header(&cache, print_event_info, FALSE);
-  my_b_write_string(&cache, "\tBinlog checkpoint ");
-  my_b_write(&cache, (uchar*)binlog_file_name, binlog_file_len);
-  my_b_write_byte(&cache, '\n');
+  if (print_header(&cache, print_event_info, FALSE) ||
+      my_b_write_string(&cache, "\tBinlog checkpoint ") ||
+      my_b_write(&cache, (uchar*)binlog_file_name, binlog_file_len) ||
+      my_b_write_byte(&cache, '\n'))
+    return 1;
+  return cache.flush_data();
 }
 #endif  /* MYSQL_CLIENT */
 
@@ -7662,7 +8035,7 @@ Gtid_log_event::do_shall_skip(rpl_group_info *rgi)
 
 #else  /* !MYSQL_SERVER */
 
-void
+bool
 Gtid_log_event::print(FILE *file, PRINT_EVENT_INFO *print_event_info)
 {
   Write_on_release_cache cache(&print_event_info->head_cache, file,
@@ -7674,26 +8047,34 @@ Gtid_log_event::print(FILE *file, PRINT_EVENT_INFO *print_event_info)
   {
     print_header(&cache, print_event_info, FALSE);
     longlong10_to_str(seq_no, buf, 10);
-    my_b_printf(&cache, "\tGTID %u-%u-%s", domain_id, server_id, buf);
+    if (my_b_printf(&cache, "\tGTID %u-%u-%s", domain_id, server_id, buf))
+      goto err;
     if (flags2 & FL_GROUP_COMMIT_ID)
     {
       longlong10_to_str(commit_id, buf2, 10);
-      my_b_printf(&cache, " cid=%s", buf2);
+      if (my_b_printf(&cache, " cid=%s", buf2))
+        goto err;
     }
     if (flags2 & FL_DDL)
-      my_b_write_string(&cache, " ddl");
+      if (my_b_write_string(&cache, " ddl"))
+        goto err;
     if (flags2 & FL_TRANSACTIONAL)
-      my_b_write_string(&cache, " trans");
+      if (my_b_write_string(&cache, " trans"))
+        goto err;
     if (flags2 & FL_WAITED)
-      my_b_write_string(&cache, " waited");
-    my_b_printf(&cache, "\n");
+      if (my_b_write_string(&cache, " waited"))
+        goto err;
+    if (my_b_printf(&cache, "\n"))
+      goto err;
 
     if (!print_event_info->allow_parallel_printed ||
         print_event_info->allow_parallel != !!(flags2 & FL_ALLOW_PARALLEL))
     {
-      my_b_printf(&cache,
+      if (my_b_printf(&cache,
                   "/*!100101 SET @@session.skip_parallel_replication=%u*/%s\n",
-                  !(flags2 & FL_ALLOW_PARALLEL), print_event_info->delimiter);
+                      !(flags2 & FL_ALLOW_PARALLEL),
+                      print_event_info->delimiter))
+        goto err;
       print_event_info->allow_parallel= !!(flags2 & FL_ALLOW_PARALLEL);
       print_event_info->allow_parallel_printed= true;
     }
@@ -7701,8 +8082,10 @@ Gtid_log_event::print(FILE *file, PRINT_EVENT_INFO *print_event_info)
     if (!print_event_info->domain_id_printed ||
         print_event_info->domain_id != domain_id)
     {
-      my_b_printf(&cache, "/*!100001 SET @@session.gtid_domain_id=%u*/%s\n",
-                  domain_id, print_event_info->delimiter);
+      if (my_b_printf(&cache,
+                      "/*!100001 SET @@session.gtid_domain_id=%u*/%s\n",
+                      domain_id, print_event_info->delimiter))
+        goto err;
       print_event_info->domain_id= domain_id;
       print_event_info->domain_id_printed= true;
     }
@@ -7710,18 +8093,25 @@ Gtid_log_event::print(FILE *file, PRINT_EVENT_INFO *print_event_info)
     if (!print_event_info->server_id_printed ||
         print_event_info->server_id != server_id)
     {
-      my_b_printf(&cache, "/*!100001 SET @@session.server_id=%u*/%s\n",
-                  server_id, print_event_info->delimiter);
+      if (my_b_printf(&cache, "/*!100001 SET @@session.server_id=%u*/%s\n",
+                      server_id, print_event_info->delimiter))
+        goto err;
       print_event_info->server_id= server_id;
       print_event_info->server_id_printed= true;
     }
 
     if (!is_flashback)
-      my_b_printf(&cache, "/*!100001 SET @@session.gtid_seq_no=%s*/%s\n",
-                  buf, print_event_info->delimiter);
+      if (my_b_printf(&cache, "/*!100001 SET @@session.gtid_seq_no=%s*/%s\n",
+                      buf, print_event_info->delimiter))
+        goto err;
   }
   if (!(flags2 & FL_STANDALONE))
-    my_b_printf(&cache, is_flashback ? "COMMIT\n%s\n" : "BEGIN\n%s\n", print_event_info->delimiter);
+    if (my_b_printf(&cache, is_flashback ? "COMMIT\n%s\n" : "BEGIN\n%s\n", print_event_info->delimiter))
+      goto err;
+
+  return cache.flush_data();
+err:
+  return 1;
 }
 
 #endif  /* MYSQL_SERVER */
@@ -7957,28 +8347,37 @@ Gtid_list_log_event::pack_info(Protocol *protocol)
 
 #else  /* !MYSQL_SERVER */
 
-void
+bool
 Gtid_list_log_event::print(FILE *file, PRINT_EVENT_INFO *print_event_info)
 {
-  if (!print_event_info->short_form)
-  {
-    Write_on_release_cache cache(&print_event_info->head_cache, file,
-                                 Write_on_release_cache::FLUSH_F);
-    char buf[21];
-    uint32 i;
+  if (print_event_info->short_form)
+    return 0;
 
-    print_header(&cache, print_event_info, FALSE);
-    my_b_printf(&cache, "\tGtid list [");
-    for (i= 0; i < count; ++i)
-    {
-      longlong10_to_str(list[i].seq_no, buf, 10);
-      my_b_printf(&cache, "%u-%u-%s", list[i].domain_id,
-                  list[i].server_id, buf);
-      if (i < count-1)
-        my_b_printf(&cache, ",\n# ");
-    }
-    my_b_printf(&cache, "]\n");
+  Write_on_release_cache cache(&print_event_info->head_cache, file,
+                               Write_on_release_cache::FLUSH_F);
+  char buf[21];
+  uint32 i;
+
+  if (print_header(&cache, print_event_info, FALSE) ||
+      my_b_printf(&cache, "\tGtid list ["))
+    goto err;
+
+  for (i= 0; i < count; ++i)
+  {
+    longlong10_to_str(list[i].seq_no, buf, 10);
+    if (my_b_printf(&cache, "%u-%u-%s", list[i].domain_id,
+                    list[i].server_id, buf))
+      goto err;
+    if (i < count-1)
+      if (my_b_printf(&cache, ",\n# "))
+        goto err;
   }
+  if (my_b_printf(&cache, "]\n"))
+    goto err;
+
+  return cache.flush_data();
+err:
+  return 1;
 }
 
 #endif  /* MYSQL_SERVER */
@@ -8110,7 +8509,7 @@ bool Intvar_log_event::write()
 */
 
 #ifdef MYSQL_CLIENT
-void Intvar_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
+bool Intvar_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
 {
   char llbuff[22];
   const char *UNINIT_VAR(msg);
@@ -8119,11 +8518,13 @@ void Intvar_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
 
   if (!print_event_info->short_form)
   {
-    print_header(&cache, print_event_info, FALSE);
-    my_b_write_string(&cache, "\tIntvar\n");
+    if (print_header(&cache, print_event_info, FALSE) ||
+        my_b_write_string(&cache, "\tIntvar\n"))
+      goto err;
   }
 
-  my_b_printf(&cache, "SET ");
+  if (my_b_printf(&cache, "SET "))
+    goto err;
   switch (type) {
   case LAST_INSERT_ID_EVENT:
     msg="LAST_INSERT_ID";
@@ -8136,8 +8537,13 @@ void Intvar_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
     msg="INVALID_INT";
     break;
   }
-  my_b_printf(&cache, "%s=%s%s\n",
-              msg, llstr(val,llbuff), print_event_info->delimiter);
+  if (my_b_printf(&cache, "%s=%s%s\n",
+                  msg, llstr(val,llbuff), print_event_info->delimiter))
+    goto err;
+
+  return cache.flush_data();
+err:
+  return 1;
 }
 #endif
 
@@ -8236,7 +8642,7 @@ bool Rand_log_event::write()
 
 
 #ifdef MYSQL_CLIENT
-void Rand_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
+bool Rand_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
 {
   Write_on_release_cache cache(&print_event_info->head_cache, file,
                                Write_on_release_cache::FLUSH_F);
@@ -8244,12 +8650,18 @@ void Rand_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
   char llbuff[22],llbuff2[22];
   if (!print_event_info->short_form)
   {
-    print_header(&cache, print_event_info, FALSE);
-    my_b_write_string(&cache, "\tRand\n");
+    if (print_header(&cache, print_event_info, FALSE) ||
+        my_b_write_string(&cache, "\tRand\n"))
+      goto err;
   }
-  my_b_printf(&cache, "SET @@RAND_SEED1=%s, @@RAND_SEED2=%s%s\n",
-              llstr(seed1, llbuff),llstr(seed2, llbuff2),
-              print_event_info->delimiter);
+  if (my_b_printf(&cache, "SET @@RAND_SEED1=%s, @@RAND_SEED2=%s%s\n",
+                  llstr(seed1, llbuff),llstr(seed2, llbuff2),
+                  print_event_info->delimiter))
+    goto err;
+
+  return cache.flush_data();
+err:
+  return 1;
 }
 #endif /* MYSQL_CLIENT */
 
@@ -8361,7 +8773,7 @@ bool Xid_log_event::write()
 
 
 #ifdef MYSQL_CLIENT
-void Xid_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
+bool Xid_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
 {
   Write_on_release_cache cache(&print_event_info->head_cache, file,
                                Write_on_release_cache::FLUSH_F, this);
@@ -8371,10 +8783,17 @@ void Xid_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
     char buf[64];
     longlong10_to_str(xid, buf, 10);
 
-    print_header(&cache, print_event_info, FALSE);
-    my_b_printf(&cache, "\tXid = %s\n", buf);
+    if (print_header(&cache, print_event_info, FALSE) ||
+        my_b_printf(&cache, "\tXid = %s\n", buf))
+      goto err;
   }
-  my_b_printf(&cache, is_flashback ? "BEGIN%s\n" : "COMMIT%s\n", print_event_info->delimiter);
+  if (my_b_printf(&cache, is_flashback ? "BEGIN%s\n" : "COMMIT%s\n",
+                  print_event_info->delimiter))
+    goto err;
+
+  return cache.flush_data();
+err:
+  return 1;
 }
 #endif /* MYSQL_CLIENT */
 
@@ -8762,23 +9181,26 @@ bool User_var_log_event::write()
 */
 
 #ifdef MYSQL_CLIENT
-void User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
+bool User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
 {
   Write_on_release_cache cache(&print_event_info->head_cache, file,
                                Write_on_release_cache::FLUSH_F);
 
   if (!print_event_info->short_form)
   {
-    print_header(&cache, print_event_info, FALSE);
-    my_b_write_string(&cache, "\tUser_var\n");
+    if (print_header(&cache, print_event_info, FALSE) ||
+        my_b_write_string(&cache, "\tUser_var\n"))
+      goto err;
   }
 
-  my_b_write_string(&cache, "SET @");
-  my_b_write_backtick_quote(&cache, name, name_len);
+  if (my_b_write_string(&cache, "SET @") ||
+      my_b_write_backtick_quote(&cache, name, name_len))
+    goto err;
 
   if (is_null)
   {
-    my_b_printf(&cache, ":=NULL%s\n", print_event_info->delimiter);
+    if (my_b_printf(&cache, ":=NULL%s\n", print_event_info->delimiter))
+      goto err;
   }
   else
   {
@@ -8788,13 +9210,17 @@ void User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
       char real_buf[FMT_G_BUFSIZE(14)];
       float8get(real_val, val);
       sprintf(real_buf, "%.14g", real_val);
-      my_b_printf(&cache, ":=%s%s\n", real_buf, print_event_info->delimiter);
+      if (my_b_printf(&cache, ":=%s%s\n", real_buf,
+                      print_event_info->delimiter))
+        goto err;
       break;
     case INT_RESULT:
       char int_buf[22];
       longlong10_to_str(uint8korr(val), int_buf, 
                         ((flags & User_var_log_event::UNSIGNED_F) ? 10 : -10));
-      my_b_printf(&cache, ":=%s%s\n", int_buf, print_event_info->delimiter);
+      if (my_b_printf(&cache, ":=%s%s\n", int_buf,
+                      print_event_info->delimiter))
+        goto err;
       break;
     case DECIMAL_RESULT:
     {
@@ -8810,7 +9236,9 @@ void User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
       bin2decimal((uchar*) val+2, &dec, precision, scale);
       decimal2string(&dec, str_buf, &str_len, 0, 0, 0);
       str_buf[str_len]= 0;
-      my_b_printf(&cache, ":=%s%s\n", str_buf, print_event_info->delimiter);
+      if (my_b_printf(&cache, ":=%s%s\n", str_buf,
+                      print_event_info->delimiter))
+        goto err;
       break;
     }
     case STRING_RESULT:
@@ -8831,11 +9259,12 @@ void User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
       */
       char *hex_str;
       CHARSET_INFO *cs;
+      bool error;
 
       // 2 hex digits / byte
       hex_str= (char *) my_malloc(2 * val_len + 1 + 3, MYF(MY_WME));
       if (!hex_str)
-        return;
+        goto err;
       str_to_hex(hex_str, val, val_len);
       /*
         For proper behaviour when mysqlbinlog|mysql, we need to explicitly
@@ -8844,24 +9273,31 @@ void User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
         character set. But there's not much to do about this and it's unlikely.
       */
       if (!(cs= get_charset(charset_number, MYF(0))))
-        /*
+      {        /*
           Generate an unusable command (=> syntax error) is probably the best
           thing we can do here.
         */
-        my_b_printf(&cache, ":=???%s\n", print_event_info->delimiter);
+        error= my_b_printf(&cache, ":=???%s\n", print_event_info->delimiter);
+      }
       else
-        my_b_printf(&cache, ":=_%s %s COLLATE `%s`%s\n",
-                    cs->csname, hex_str, cs->name,
-                    print_event_info->delimiter);
+        error= my_b_printf(&cache, ":=_%s %s COLLATE `%s`%s\n",
+                           cs->csname, hex_str, cs->name,
+                           print_event_info->delimiter);
       my_free(hex_str);
-    }
+      if (error)
+        goto err;
       break;
+    }
     case ROW_RESULT:
     default:
       DBUG_ASSERT(0);
-      return;
+      break;
     }
   }
+
+  return cache.flush_data();
+err:
+  return 1;
 }
 #endif
 
@@ -8984,19 +9420,25 @@ User_var_log_event::do_shall_skip(rpl_group_info *rgi)
 
 #ifdef HAVE_REPLICATION
 #ifdef MYSQL_CLIENT
-void Unknown_log_event::print(FILE* file_arg, PRINT_EVENT_INFO* print_event_info)
+bool Unknown_log_event::print(FILE* file_arg, PRINT_EVENT_INFO* print_event_info)
 {
+  if (print_event_info->short_form)
+    return 0;
+
   Write_on_release_cache cache(&print_event_info->head_cache, file_arg);
 
-  if (print_event_info->short_form)
-    return;
   if (what != ENCRYPTED)
   {
-    print_header(&cache, print_event_info, FALSE);
-    my_b_printf(&cache, "\n# Unknown event\n");
+    if (print_header(&cache, print_event_info, FALSE) ||
+        my_b_printf(&cache, "\n# Unknown event\n"))
+      goto err;
   }
-  else
-    my_b_printf(&cache, "# Encrypted event\n");
+  else if (my_b_printf(&cache, "# Encrypted event\n"))
+    goto err;
+
+  return cache.flush_data();
+err:
+  return 1;
 }
 #endif  
 
@@ -9009,16 +9451,18 @@ void Unknown_log_event::print(FILE* file_arg, PRINT_EVENT_INFO* print_event_info
 */
 
 #ifdef MYSQL_CLIENT
-void Stop_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
+bool Stop_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
 {
+  if (print_event_info->short_form)
+    return 0;
+
   Write_on_release_cache cache(&print_event_info->head_cache, file,
                                Write_on_release_cache::FLUSH_F, this);
 
-  if (print_event_info->short_form)
-    return;
-
-  print_header(&cache, print_event_info, FALSE);
-  my_b_write_string(&cache, "\tStop\n");
+  if (print_header(&cache, print_event_info, FALSE) ||
+      my_b_write_string(&cache, "\tStop\n"))
+    return 1;
+  return cache.flush_data();
 }
 #endif /* MYSQL_CLIENT */
 
@@ -9200,22 +9644,25 @@ Create_file_log_event::Create_file_log_event(const char* buf, uint len,
 */
 
 #ifdef MYSQL_CLIENT
-void Create_file_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info,
+bool Create_file_log_event::print(FILE* file,
+                                  PRINT_EVENT_INFO* print_event_info,
 				  bool enable_local)
 {
-  Write_on_release_cache cache(&print_event_info->head_cache, file);
-
   if (print_event_info->short_form)
   {
     if (enable_local && check_fname_outside_temp_buf())
-      Load_log_event::print(file, print_event_info);
-    return;
+      return Load_log_event::print(file, print_event_info);
+    return 0;
   }
 
+  Write_on_release_cache cache(&print_event_info->head_cache, file);
+
   if (enable_local)
   {
-    Load_log_event::print(file, print_event_info,
-			  !check_fname_outside_temp_buf());
+    if (Load_log_event::print(file, print_event_info,
+                              !check_fname_outside_temp_buf()))
+      goto err;
+
     /**
       reduce the size of io cache so that the write function is called
       for every call to my_b_printf().
@@ -9227,16 +9674,24 @@ void Create_file_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info
       That one is for "file_id: etc" below: in mysqlbinlog we want the #, in
       SHOW BINLOG EVENTS we don't.
      */
-    my_b_write_byte(&cache, '#');
+    if (my_b_write_byte(&cache, '#'))
+      goto err;
   }
 
-  my_b_printf(&cache, " file_id: %d  block_len: %d\n", file_id, block_len);
+  if (my_b_printf(&cache, " file_id: %d  block_len: %d\n", file_id, block_len))
+    goto err;
+
+  return cache.flush_data();
+err:
+  return 1;
+
 }
 
 
-void Create_file_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
+bool Create_file_log_event::print(FILE* file,
+                                  PRINT_EVENT_INFO* print_event_info)
 {
-  print(file, print_event_info, 0);
+  return print(file, print_event_info, 0);
 }
 #endif /* MYSQL_CLIENT */
 
@@ -9302,7 +9757,7 @@ int Create_file_log_event::do_apply_event(rpl_group_info *rgi)
                 fname_buf);
     goto err;
   }
-  
+
   // a trick to avoid allocating another buffer
   fname= fname_buf;
   fname_len= (uint) (strmov(ext, ".data") - fname);
@@ -9317,7 +9772,7 @@ int Create_file_log_event::do_apply_event(rpl_group_info *rgi)
   }
   end_io_cache(&file);
   mysql_file_close(fd, MYF(0));
-  
+
   // fname_buf now already has .data, not .info, because we did our trick
   /* old copy may exist already */
   mysql_file_delete(key_file_log_event_data, fname_buf, MYF(0));
@@ -9415,16 +9870,22 @@ bool Append_block_log_event::write()
 */
 
 #ifdef MYSQL_CLIENT  
-void Append_block_log_event::print(FILE* file,
+bool Append_block_log_event::print(FILE* file,
 				   PRINT_EVENT_INFO* print_event_info)
 {
+  if (print_event_info->short_form)
+    return 0;
+
   Write_on_release_cache cache(&print_event_info->head_cache, file);
 
-  if (print_event_info->short_form)
-    return;
-  print_header(&cache, print_event_info, FALSE);
-  my_b_printf(&cache, "\n#%s: file_id: %d  block_len: %d\n",
-              get_type_str(), file_id, block_len);
+  if (print_header(&cache, print_event_info, FALSE) ||
+      my_b_printf(&cache, "\n#%s: file_id: %d  block_len: %d\n",
+                  get_type_str(), file_id, block_len))
+    goto err;
+
+  return cache.flush_data();
+err:
+  return 1;
 }
 #endif /* MYSQL_CLIENT */
 
@@ -9574,15 +10035,19 @@ bool Delete_file_log_event::write()
 */
 
 #ifdef MYSQL_CLIENT  
-void Delete_file_log_event::print(FILE* file,
+bool Delete_file_log_event::print(FILE* file,
 				  PRINT_EVENT_INFO* print_event_info)
 {
+  if (print_event_info->short_form)
+    return 0;
+
   Write_on_release_cache cache(&print_event_info->head_cache, file);
 
-  if (print_event_info->short_form)
-    return;
-  print_header(&cache, print_event_info, FALSE);
-  my_b_printf(&cache, "\n#Delete_file: file_id=%u\n", file_id);
+  if (print_header(&cache, print_event_info, FALSE) ||
+      my_b_printf(&cache, "\n#Delete_file: file_id=%u\n", file_id))
+    return 1;
+
+  return cache.flush_data();
 }
 #endif /* MYSQL_CLIENT */
 
@@ -9674,16 +10139,20 @@ bool Execute_load_log_event::write()
 */
 
 #ifdef MYSQL_CLIENT  
-void Execute_load_log_event::print(FILE* file,
+bool Execute_load_log_event::print(FILE* file,
 				   PRINT_EVENT_INFO* print_event_info)
 {
+  if (print_event_info->short_form)
+    return 0;
+
   Write_on_release_cache cache(&print_event_info->head_cache, file);
 
-  if (print_event_info->short_form)
-    return;
-  print_header(&cache, print_event_info, FALSE);
-  my_b_printf(&cache, "\n#Exec_load: file_id=%d\n",
-              file_id);
+  if (print_header(&cache, print_event_info, FALSE) ||
+      my_b_printf(&cache, "\n#Exec_load: file_id=%d\n",
+                  file_id))
+    return 1;
+
+  return cache.flush_data();
 }
 #endif
 
@@ -9906,22 +10375,24 @@ Execute_load_query_log_event::write_post_header_for_derived()
 
 
 #ifdef MYSQL_CLIENT
-void Execute_load_query_log_event::print(FILE* file,
+bool Execute_load_query_log_event::print(FILE* file,
                                          PRINT_EVENT_INFO* print_event_info)
 {
-  print(file, print_event_info, 0);
+  return print(file, print_event_info, 0);
 }
 
 /**
   Prints the query as LOAD DATA LOCAL and with rewritten filename.
 */
-void Execute_load_query_log_event::print(FILE* file,
+bool Execute_load_query_log_event::print(FILE* file,
                                          PRINT_EVENT_INFO* print_event_info,
                                          const char *local_fname)
 {
   Write_on_release_cache cache(&print_event_info->head_cache, file);
 
-  print_query_header(&cache, print_event_info);
+  if (print_query_header(&cache, print_event_info))
+    goto err;
+
   /**
     reduce the size of io cache so that the write function is called
     for every call to my_b_printf().
@@ -9932,24 +10403,33 @@ void Execute_load_query_log_event::print(FILE* file,
 
   if (local_fname)
   {
-    my_b_write(&cache, (uchar*) query, fn_pos_start);
-    my_b_write_string(&cache, " LOCAL INFILE ");
-    pretty_print_str(&cache, local_fname, strlen(local_fname));
+    if (my_b_write(&cache, (uchar*) query, fn_pos_start) ||
+        my_b_write_string(&cache, " LOCAL INFILE ") ||
+        pretty_print_str(&cache, local_fname, strlen(local_fname)))
+      goto err;
 
     if (dup_handling == LOAD_DUP_REPLACE)
-      my_b_write_string(&cache, " REPLACE");
-    my_b_write_string(&cache, " INTO");
-    my_b_write(&cache, (uchar*) query + fn_pos_end, q_len-fn_pos_end);
-    my_b_printf(&cache, "\n%s\n", print_event_info->delimiter);
+      if (my_b_write_string(&cache, " REPLACE"))
+        goto err;
+
+    if (my_b_write_string(&cache, " INTO") ||
+        my_b_write(&cache, (uchar*) query + fn_pos_end, q_len-fn_pos_end) ||
+        my_b_printf(&cache, "\n%s\n", print_event_info->delimiter))
+      goto err;
   }
   else
   {
-    my_b_write(&cache, (uchar*) query, q_len);
-    my_b_printf(&cache, "\n%s\n", print_event_info->delimiter);
+    if (my_b_write(&cache, (uchar*) query, q_len) ||
+        my_b_printf(&cache, "\n%s\n", print_event_info->delimiter))
+      goto err;
   }
 
   if (!print_event_info->short_form)
     my_b_printf(&cache, "# file_id: %d \n", file_id);
+
+  return cache.flush_data();
+err:
+  return 1;
 }
 #endif
 
@@ -10929,7 +11409,7 @@ int Rows_log_event::do_apply_event(rpl_group_info *rgi)
           if (global_system_variables.log_warnings)
             slave_rows_error_report(WARNING_LEVEL, error, rgi, thd, table,
                                     get_type_str(),
-                                    RPL_LOG_NAME, (ulong) log_pos);
+                                    RPL_LOG_NAME, log_pos);
           thd->clear_error(1);
           error= 0;
           if (idempotent_error == 0)
@@ -10981,7 +11461,7 @@ int Rows_log_event::do_apply_event(rpl_group_info *rgi)
       if (global_system_variables.log_warnings)
         slave_rows_error_report(WARNING_LEVEL, error, rgi, thd, table,
                                 get_type_str(),
-                                RPL_LOG_NAME, (ulong) log_pos);
+                                RPL_LOG_NAME, log_pos);
       thd->clear_error(1);
       error= 0;
     }
@@ -10992,7 +11472,7 @@ int Rows_log_event::do_apply_event(rpl_group_info *rgi)
   {
     slave_rows_error_report(ERROR_LEVEL, error, rgi, thd, table,
                              get_type_str(),
-                             RPL_LOG_NAME, (ulong) log_pos);
+                             RPL_LOG_NAME, log_pos);
     /*
       @todo We should probably not call
       reset_current_stmt_binlog_format_row() from here.
@@ -11022,7 +11502,7 @@ int Rows_log_event::do_apply_event(rpl_group_info *rgi)
                             thd->is_error() ? 0 : error,
                             rgi, thd, table,
                             get_type_str(),
-                            RPL_LOG_NAME, (ulong) log_pos);
+                            RPL_LOG_NAME, log_pos);
   DBUG_RETURN(error);
 
 err:
@@ -11262,7 +11742,7 @@ void Rows_log_event::pack_info(Protocol *protocol)
 #endif
 
 #ifdef MYSQL_CLIENT
-void Rows_log_event::print_helper(FILE *file,
+bool Rows_log_event::print_helper(FILE *file,
                                   PRINT_EVENT_INFO *print_event_info,
                                   char const *const name)
 {
@@ -11271,33 +11751,51 @@ void Rows_log_event::print_helper(FILE *file,
 #ifdef WHEN_FLASHBACK_REVIEW_READY
   IO_CACHE *const sql= &print_event_info->review_sql_cache;
 #endif
+  bool const last_stmt_event= get_flags(STMT_END_F);
 
   if (!print_event_info->short_form)
   {
-    bool const last_stmt_event= get_flags(STMT_END_F);
     print_header(head, print_event_info, !last_stmt_event);
-    my_b_printf(head, "\t%s: table id %lu%s\n",
-                name, m_table_id,
-                last_stmt_event ? " flags: STMT_END_F" : "");
-    print_base64(body, print_event_info, !last_stmt_event);
+    if (my_b_printf(head, "\t%s: table id %lu%s\n",
+                    name, m_table_id,
+                    last_stmt_event ? " flags: STMT_END_F" : ""))
+      goto err;
   }
+  if (!print_event_info->short_form || print_event_info->print_row_count)
+    if (print_base64(body, print_event_info, !last_stmt_event))
+      goto err;
 
-  if (get_flags(STMT_END_F))
+  if (last_stmt_event)
   {
-    LEX_STRING tmp_str;
-
-    copy_event_cache_to_string_and_reinit(head, &tmp_str);
-    output_buf.append(&tmp_str);
-    my_free(tmp_str.str);
-    copy_event_cache_to_string_and_reinit(body, &tmp_str);
-    output_buf.append(&tmp_str);
-    my_free(tmp_str.str);
+    if (!is_flashback)
+    {
+      if (copy_event_cache_to_file_and_reinit(head, file) ||
+          copy_event_cache_to_file_and_reinit(body, file))
+        goto err;
+    }
+    else
+    {
+      LEX_STRING tmp_str;
+      if (copy_event_cache_to_string_and_reinit(head, &tmp_str))
+        return 1;
+      output_buf.append(&tmp_str);
+      my_free(tmp_str.str);
+      if (copy_event_cache_to_string_and_reinit(body, &tmp_str))
+        return 1;
+      output_buf.append(&tmp_str);
+      my_free(tmp_str.str);
 #ifdef WHEN_FLASHBACK_REVIEW_READY
-    copy_event_cache_to_string_and_reinit(sql, &tmp_str);
-    output_buf.append(&tmp_str);
-    my_free(tmp_str.str);
+      if (copy_event_cache_to_string_and_reinit(sql, &tmp_str))
+        return 1;
+      output_buf.append(&tmp_str);
+      my_free(tmp_str.str);
 #endif
+    }
   }
+
+  return 0;
+err:
+  return 1;
 }
 #endif
 
@@ -11385,25 +11883,28 @@ void Annotate_rows_log_event::pack_info(Protocol* protocol)
 #endif
 
 #ifdef MYSQL_CLIENT
-void Annotate_rows_log_event::print(FILE *file, PRINT_EVENT_INFO *pinfo)
+bool Annotate_rows_log_event::print(FILE *file, PRINT_EVENT_INFO *pinfo)
 {
-  if (pinfo->short_form)
-    return;
-
-  print_header(&pinfo->head_cache, pinfo, TRUE);
-  my_b_printf(&pinfo->head_cache, "\tAnnotate_rows:\n");
-
   char *pbeg;   // beginning of the next line
   char *pend;   // end of the next line
   uint cnt= 0;  // characters counter
 
+  if (!pinfo->short_form)
+  {
+    if (print_header(&pinfo->head_cache, pinfo, TRUE) ||
+        my_b_printf(&pinfo->head_cache, "\tAnnotate_rows:\n"))
+      goto err;
+  }
+  else if (my_b_printf(&pinfo->head_cache, "# Annotate_rows:\n"))
+    goto err;
+
   for (pbeg= m_query_txt; ; pbeg= pend)
   {
     // skip all \r's and \n's at the beginning of the next line
     for (;; pbeg++)
     {
       if (++cnt > m_query_len)
-        return;
+        return 0;
 
       if (*pbeg != '\r' && *pbeg != '\n')
         break;
@@ -11416,10 +11917,15 @@ void Annotate_rows_log_event::print(FILE *file, PRINT_EVENT_INFO *pinfo)
       ;
 
     // print next line
-    my_b_write(&pinfo->head_cache, (const uchar*) "#Q> ", 4);
-    my_b_write(&pinfo->head_cache, (const uchar*) pbeg, pend - pbeg);
-    my_b_write(&pinfo->head_cache, (const uchar*) "\n", 1);
+    if (my_b_write(&pinfo->head_cache, (const uchar*) "#Q> ", 4) ||
+        my_b_write(&pinfo->head_cache, (const uchar*) pbeg, pend - pbeg) ||
+        my_b_write(&pinfo->head_cache, (const uchar*) "\n", 1))
+      goto err;
   }
+
+  return 0;
+err:
+  return 1;
 }
 #endif
 
@@ -11716,7 +12222,7 @@ Table_map_log_event::Table_map_log_event(const char *buf, uint event_len,
 
     ptr_after_colcnt= ptr_after_colcnt + m_colcnt;
     bytes_read= (uint) (ptr_after_colcnt - (uchar *)buf);
-    DBUG_PRINT("info", ("Bytes read: %d.\n", bytes_read));
+    DBUG_PRINT("info", ("Bytes read: %d", bytes_read));
     if (bytes_read < event_len)
     {
       m_field_metadata_size= net_field_length(&ptr_after_colcnt);
@@ -12154,19 +12660,29 @@ void Table_map_log_event::pack_info(Protocol *protocol)
 
 
 #ifdef MYSQL_CLIENT
-void Table_map_log_event::print(FILE *file, PRINT_EVENT_INFO *print_event_info)
+bool Table_map_log_event::print(FILE *file, PRINT_EVENT_INFO *print_event_info)
 {
   if (!print_event_info->short_form)
   {
     print_header(&print_event_info->head_cache, print_event_info, TRUE);
-    my_b_printf(&print_event_info->head_cache,
-                "\tTable_map: %`s.%`s mapped to number %lu%s\n",
-                m_dbnam, m_tblnam, m_table_id,
-                ((m_flags & TM_BIT_HAS_TRIGGERS_F) ?
-                 " (has triggers)" : ""));
-    print_base64(&print_event_info->body_cache, print_event_info, TRUE);
-    copy_event_cache_to_file_and_reinit(&print_event_info->head_cache, file);
+    if (my_b_printf(&print_event_info->head_cache,
+                    "\tTable_map: %`s.%`s mapped to number %lu%s\n",
+                    m_dbnam, m_tblnam, m_table_id,
+                    ((m_flags & TM_BIT_HAS_TRIGGERS_F) ?
+                     " (has triggers)" : "")))
+      goto err;
+  }
+  if (!print_event_info->short_form || print_event_info->print_row_count)
+  {
+    if (print_base64(&print_event_info->body_cache, print_event_info, TRUE) ||
+        copy_event_cache_to_file_and_reinit(&print_event_info->head_cache,
+                                            file))
+      goto err;
   }
+
+  return 0;
+err:
+  return 1;
 }
 #endif
 
@@ -12736,14 +13252,14 @@ Write_rows_log_event::do_exec_row(rpl_group_info *rgi)
 #endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
 
 #ifdef MYSQL_CLIENT
-void Write_rows_log_event::print(FILE *file, PRINT_EVENT_INFO* print_event_info)
+bool Write_rows_log_event::print(FILE *file, PRINT_EVENT_INFO* print_event_info)
 {
   DBUG_EXECUTE_IF("simulate_cache_read_error",
                   {DBUG_SET("+d,simulate_my_b_fill_error");});
-  Rows_log_event::print_helper(file, print_event_info, is_flashback ? "Delete_rows" : "Write_rows");
+  return Rows_log_event::print_helper(file, print_event_info, is_flashback ? "Delete_rows" : "Write_rows");
 }
 
-void Write_rows_compressed_log_event::print(FILE *file,
+bool Write_rows_compressed_log_event::print(FILE *file,
                                             PRINT_EVENT_INFO* print_event_info)
 {
   char *new_buf;
@@ -12755,14 +13271,20 @@ void Write_rows_compressed_log_event::print(FILE *file,
   {
     free_temp_buf();
     register_temp_buf(new_buf, true);
-    Rows_log_event::print_helper(file, print_event_info,
-                                 "Write_compressed_rows");
+    if (Rows_log_event::print_helper(file, print_event_info,
+                                     "Write_compressed_rows"))
+      goto err;
   }
   else
   {
-    my_b_printf(&print_event_info->head_cache,
-                "ERROR: uncompress write_compressed_rows failed\n");
+    if (my_b_printf(&print_event_info->head_cache,
+                    "ERROR: uncompress write_compressed_rows failed\n"))
+      goto err;
   }
+
+  return 0;
+err:
+  return 1;
 }
 #endif
 
@@ -13411,13 +13933,13 @@ int Delete_rows_log_event::do_exec_row(rpl_group_info *rgi)
 #endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
 
 #ifdef MYSQL_CLIENT
-void Delete_rows_log_event::print(FILE *file,
+bool Delete_rows_log_event::print(FILE *file,
                                   PRINT_EVENT_INFO* print_event_info)
 {
-  Rows_log_event::print_helper(file, print_event_info, is_flashback ? "Write_rows" : "Delete_rows");
+  return Rows_log_event::print_helper(file, print_event_info, is_flashback ? "Write_rows" : "Delete_rows");
 }
 
-void Delete_rows_compressed_log_event::print(FILE *file,
+bool Delete_rows_compressed_log_event::print(FILE *file,
                                              PRINT_EVENT_INFO* print_event_info)
 {
   char *new_buf;
@@ -13429,14 +13951,20 @@ void Delete_rows_compressed_log_event::print(FILE *file,
   {
     free_temp_buf();
     register_temp_buf(new_buf, true);
-    Rows_log_event::print_helper(file, print_event_info,
-                                 "Delete_compressed_rows");
+    if (Rows_log_event::print_helper(file, print_event_info,
+                                     "Delete_compressed_rows"))
+      goto err;
   }
   else
   {
-    my_b_printf(&print_event_info->head_cache,
-                "ERROR: uncompress delete_compressed_rows failed\n");
+    if (my_b_printf(&print_event_info->head_cache,
+                    "ERROR: uncompress delete_compressed_rows failed\n"))
+      goto err;
   }
+
+  return 0;
+err:
+  return 1;
 }
 #endif
 
@@ -13672,13 +14200,15 @@ err:
 #endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
 
 #ifdef MYSQL_CLIENT
-void Update_rows_log_event::print(FILE *file,
+bool Update_rows_log_event::print(FILE *file,
 				  PRINT_EVENT_INFO* print_event_info)
 {
-  Rows_log_event::print_helper(file, print_event_info, "Update_rows");
+  return Rows_log_event::print_helper(file, print_event_info, "Update_rows");
 }
 
-void Update_rows_compressed_log_event::print(FILE *file, PRINT_EVENT_INFO *print_event_info)
+bool
+Update_rows_compressed_log_event::print(FILE *file,
+                                        PRINT_EVENT_INFO *print_event_info)
 {
   char *new_buf;
   ulong len;
@@ -13689,14 +14219,20 @@ void Update_rows_compressed_log_event::print(FILE *file, PRINT_EVENT_INFO *print
   {
     free_temp_buf();
     register_temp_buf(new_buf, true);
-    Rows_log_event::print_helper(file, print_event_info,
-                                 "Update_compressed_rows");
+    if (Rows_log_event::print_helper(file, print_event_info,
+                                     "Update_compressed_rows"))
+      goto err;
   }
   else
   {
-    my_b_printf(&print_event_info->head_cache,
-                "ERROR: uncompress update_compressed_rows failed\n");
+    if (my_b_printf(&print_event_info->head_cache,
+                    "ERROR: uncompress update_compressed_rows failed\n"))
+      goto err;
   }
+
+  return 0;
+err:
+  return 1;
 }
 #endif
 
@@ -13835,16 +14371,18 @@ err:
 
 
 #ifdef MYSQL_CLIENT
-void
-Incident_log_event::print(FILE *file,
-                          PRINT_EVENT_INFO *print_event_info)
+bool Incident_log_event::print(FILE *file,
+                               PRINT_EVENT_INFO *print_event_info)
 {
   if (print_event_info->short_form)
-    return;
+    return 0;
 
   Write_on_release_cache cache(&print_event_info->head_cache, file);
-  print_header(&cache, print_event_info, FALSE);
-  my_b_printf(&cache, "\n# Incident: %s\nRELOAD DATABASE; # Shall generate syntax error\n", description());
+
+  if (print_header(&cache, print_event_info, FALSE) ||
+      my_b_printf(&cache, "\n# Incident: %s\nRELOAD DATABASE; # Shall generate syntax error\n", description()))
+    return 1;
+  return cache.flush_data();
 }
 #endif
 
@@ -13920,19 +14458,20 @@ void Ignorable_log_event::pack_info(Protocol *protocol)
 
 #ifdef MYSQL_CLIENT
 /* Print for its unrecognized ignorable event */
-void
-Ignorable_log_event::print(FILE *file,
-                           PRINT_EVENT_INFO *print_event_info)
+bool Ignorable_log_event::print(FILE *file,
+                                PRINT_EVENT_INFO *print_event_info)
 {
   if (print_event_info->short_form)
-    return;
+    return 0;
 
-  print_header(&print_event_info->head_cache, print_event_info, FALSE);
-  my_b_printf(&print_event_info->head_cache, "\tIgnorable\n");
-  my_b_printf(&print_event_info->head_cache,
-              "# Ignorable event type %d (%s)\n", number, description);
-  copy_event_cache_to_file_and_reinit(&print_event_info->head_cache,
-                                      file);
+  if (print_header(&print_event_info->head_cache, print_event_info, FALSE) ||
+      my_b_printf(&print_event_info->head_cache, "\tIgnorable\n") ||
+      my_b_printf(&print_event_info->head_cache,
+                  "# Ignorable event type %d (%s)\n", number, description) ||
+      copy_event_cache_to_file_and_reinit(&print_event_info->head_cache,
+                                          file))
+    return 1;
+  return 0;
 }
 #endif
 
@@ -13944,15 +14483,8 @@ Ignorable_log_event::print(FILE *file,
   they will always be printed for the first event.
 */
 st_print_event_info::st_print_event_info()
-  :flags2_inited(0), sql_mode_inited(0), sql_mode(0),
-   auto_increment_increment(0),auto_increment_offset(0), charset_inited(0),
-   lc_time_names_number(~0),
-   charset_database_number(ILLEGAL_CHARSET_INFO_NUMBER),
-   thread_id(0), thread_id_printed(false), server_id(0),
-   server_id_printed(false), domain_id(0), domain_id_printed(false),
-   allow_parallel(true), allow_parallel_printed(false), skip_replication(0),
-   base64_output_mode(BASE64_OUTPUT_UNSPEC), printed_fd_event(FALSE)
 {
+  myf const flags = MYF(MY_WME | MY_NABP);
   /*
     Currently we only use static PRINT_EVENT_INFO objects, so zeroed at
     program's startup, but these explicit bzero() is for the day someone
@@ -13963,14 +14495,67 @@ st_print_event_info::st_print_event_info()
   bzero(time_zone_str, sizeof(time_zone_str));
   delimiter[0]= ';';
   delimiter[1]= 0;
-  myf const flags = MYF(MY_WME | MY_NABP);
+  flags2_inited= 0;
+  sql_mode_inited= 0;
+  row_events= 0;
+  sql_mode= 0;
+  auto_increment_increment= 0;
+  auto_increment_offset= 0;
+  charset_inited= 0;
+  lc_time_names_number= ~0;
+  charset_database_number= ILLEGAL_CHARSET_INFO_NUMBER;
+  thread_id= 0;
+  server_id= 0;
+  domain_id= 0;
+  thread_id_printed= false;
+  server_id_printed= false;
+  domain_id_printed= false;
+  allow_parallel= true;
+  allow_parallel_printed= false;
+  found_row_event= false;
+  print_row_count= false;
+  short_form= false;
+  skip_replication= 0;
+  printed_fd_event=FALSE;
+  file= 0;
+  base64_output_mode=BASE64_OUTPUT_UNSPEC;
   open_cached_file(&head_cache, NULL, NULL, 0, flags);
   open_cached_file(&body_cache, NULL, NULL, 0, flags);
 #ifdef WHEN_FLASHBACK_REVIEW_READY
   open_cached_file(&review_sql_cache, NULL, NULL, 0, flags);
 #endif
 }
-#endif
+
+
+bool copy_event_cache_to_string_and_reinit(IO_CACHE *cache, LEX_STRING *to)
+{
+  reinit_io_cache(cache, READ_CACHE, 0L, FALSE, FALSE);
+  if (!(to->str= (char*) my_malloc((to->length= cache->end_of_file), MYF(0))))
+  {
+    perror("Out of memory: can't allocate memory in copy_event_cache_to_string_and_reinit().");
+    goto err;
+  }
+  if (my_b_read(cache, (uchar*) to->str, to->length))
+  {
+    my_free(to->str);
+    perror("Can't read data from IO_CACHE");
+    return true;
+  }
+  reinit_io_cache(cache, WRITE_CACHE, 0, FALSE, TRUE);
+  return false;
+
+err:
+  to->str= 0;
+  to->length= 0;
+  return true;
+}
+#endif /* MYSQL_CLIENT */
+
+bool copy_event_cache_to_file_and_reinit(IO_CACHE *cache, FILE *file)
+{
+  return (my_b_copy_to_file(cache, file) ||
+          reinit_io_cache(cache, WRITE_CACHE, 0, FALSE, TRUE));
+}
 
 #if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
 Heartbeat_log_event::Heartbeat_log_event(const char* buf, uint event_len,
@@ -14045,4 +14630,4 @@ bool event_that_should_be_ignored(const char *buf)
     return 1;
   return 0;
 }
-#endif
+#endif /* MYSQL_SERVER */
diff --git a/sql/log_event.h b/sql/log_event.h
index 428616fcb0d..6b43dcaa763 100644
--- a/sql/log_event.h
+++ b/sql/log_event.h
@@ -802,6 +802,8 @@ class Format_description_log_event;
 class Relay_log_info;
 class binlog_cache_data;
 
+bool copy_event_cache_to_file_and_reinit(IO_CACHE *cache, FILE *file);
+
 #ifdef MYSQL_CLIENT
 enum enum_base64_output_mode {
   BASE64_OUTPUT_NEVER= 0,
@@ -813,6 +815,8 @@ enum enum_base64_output_mode {
   BASE64_OUTPUT_MODE_COUNT
 };
 
+bool copy_event_cache_to_string_and_reinit(IO_CACHE *cache, LEX_STRING *to);
+
 /*
   A structure for mysqlbinlog to know how to print events
 
@@ -832,53 +836,38 @@ typedef struct st_print_event_info
     that was printed.  We cache these so that we don't have to print
     them if they are unchanged.
   */
-  // TODO: have the last catalog here ??
   char db[FN_REFLEN+1]; // TODO: make this a LEX_STRING when thd->db is
-  bool flags2_inited;
-  uint32 flags2;
-  bool sql_mode_inited;
-  sql_mode_t sql_mode;		/* must be same as THD.variables.sql_mode */
-  ulong auto_increment_increment, auto_increment_offset;
-  bool charset_inited;
   char charset[6]; // 3 variables, each of them storable in 2 bytes
   char time_zone_str[MAX_TIME_ZONE_NAME_LENGTH];
+  char delimiter[16];
+  sql_mode_t sql_mode;		/* must be same as THD.variables.sql_mode */
+  my_thread_id thread_id;
+  ulonglong row_events;
+  ulong auto_increment_increment, auto_increment_offset;
   uint lc_time_names_number;
   uint charset_database_number;
-  my_thread_id thread_id;
-  bool thread_id_printed;
+  uint verbose;
+  uint32 flags2;
   uint32 server_id;
-  bool server_id_printed;
   uint32 domain_id;
+  uint8 common_header_len;
+  enum_base64_output_mode base64_output_mode;
+  my_off_t hexdump_from;
+
+  table_mapping m_table_map;
+  table_mapping m_table_map_ignored;
+  bool flags2_inited;
+  bool sql_mode_inited;
+  bool charset_inited;
+  bool thread_id_printed;
+  bool server_id_printed;
   bool domain_id_printed;
   bool allow_parallel;
   bool allow_parallel_printed;
-
-  /*
-    Track when @@skip_replication changes so we need to output a SET
-    statement for it.
-  */
-  int skip_replication;
-
-  st_print_event_info();
-
-  ~st_print_event_info() {
-    close_cached_file(&head_cache);
-    close_cached_file(&body_cache);
-#ifdef WHEN_FLASHBACK_REVIEW_READY
-    close_cached_file(&review_sql_cache);
-#endif
-  }
-  bool init_ok() /* tells if construction was successful */
-    { return my_b_inited(&head_cache) && my_b_inited(&body_cache)
-#ifdef WHEN_FLASHBACK_REVIEW_READY
-      && my_b_inited(&review_sql_cache)
-#endif
-    ; }
-
-
+  bool found_row_event;
+  bool print_row_count;
   /* Settings on how to print the events */
   bool short_form;
-  enum_base64_output_mode base64_output_mode;
   /*
     This is set whenever a Format_description_event is printed.
     Later, when an event is printed in base64, this flag is tested: if
@@ -886,13 +875,11 @@ typedef struct st_print_event_info
     the base64 event, so an error message is generated.
   */
   bool printed_fd_event;
-  my_off_t hexdump_from;
-  uint8 common_header_len;
-  char delimiter[16];
-
-  uint verbose;
-  table_mapping m_table_map;
-  table_mapping m_table_map_ignored;
+  /*
+    Track when @@skip_replication changes so we need to output a SET
+    statement for it.
+  */
+  bool skip_replication;
 
   /*
      These two caches are used by the row-based replication events to
@@ -905,6 +892,28 @@ typedef struct st_print_event_info
   /* Storing the SQL for reviewing */
   IO_CACHE review_sql_cache;
 #endif
+  FILE *file;
+  st_print_event_info();
+
+  ~st_print_event_info() {
+    close_cached_file(&head_cache);
+    close_cached_file(&body_cache);
+#ifdef WHEN_FLASHBACK_REVIEW_READY
+    close_cached_file(&review_sql_cache);
+#endif
+  }
+  bool init_ok() /* tells if construction was successful */
+    { return my_b_inited(&head_cache) && my_b_inited(&body_cache)
+#ifdef WHEN_FLASHBACK_REVIEW_READY
+      && my_b_inited(&review_sql_cache)
+#endif
+    ; }
+  void flush_for_error()
+  {
+    if (!copy_event_cache_to_file_and_reinit(&head_cache, file))
+      copy_event_cache_to_file_and_reinit(&body_cache, file);
+    fflush(file);
+  }
 } PRINT_EVENT_INFO;
 #endif
 
@@ -1250,11 +1259,11 @@ public:
   Log_event() : temp_buf(0), when(0), flags(0) {}
   ha_checksum crc;
   /* print*() functions are used by mysqlbinlog */
-  virtual void print(FILE* file, PRINT_EVENT_INFO* print_event_info) = 0;
-  void print_timestamp(IO_CACHE* file, time_t *ts = 0);
-  void print_header(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info,
+  virtual bool print(FILE* file, PRINT_EVENT_INFO* print_event_info) = 0;
+  bool print_timestamp(IO_CACHE* file, time_t *ts = 0);
+  bool print_header(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info,
                     bool is_more);
-  void print_base64(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info,
+  bool print_base64(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info,
                     bool is_more);
 #endif /* MYSQL_SERVER */
 
@@ -2113,8 +2122,8 @@ public:
   void pack_info(Protocol* protocol);
 #endif /* HAVE_REPLICATION */
 #else
-  void print_query_header(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info);
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print_query_header(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
   Query_log_event();
@@ -2453,7 +2462,7 @@ protected:
                      const Format_description_log_event* description_event);
 
 public:
-  void print_query(THD *thd, bool need_db, const char *cs, String *buf,
+  bool print_query(THD *thd, bool need_db, const char *cs, String *buf,
                    my_off_t *fn_start, my_off_t *fn_end,
                    const char *qualify_db);
   my_thread_id thread_id;
@@ -2519,8 +2528,8 @@ public:
   void pack_info(Protocol* protocol);
 #endif /* HAVE_REPLICATION */
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool commented);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool commented);
 #endif
 
   /*
@@ -2617,7 +2626,7 @@ public:
 #endif /* HAVE_REPLICATION */
 #else
   Start_log_event_v3() {}
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
   Start_log_event_v3(const char* buf, uint event_len,
@@ -2686,7 +2695,7 @@ public:
            write_data(nonce, BINLOG_NONCE_LENGTH);
   }
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
   Start_encryption_log_event(
@@ -2874,7 +2883,7 @@ Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg,
   void pack_info(Protocol* protocol);
 #endif /* HAVE_REPLICATION */
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
   Intvar_log_event(const char* buf,
@@ -2955,7 +2964,7 @@ class Rand_log_event: public Log_event
   void pack_info(Protocol* protocol);
 #endif /* HAVE_REPLICATION */
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
   Rand_log_event(const char* buf,
@@ -3005,7 +3014,7 @@ class Xid_log_event: public Log_event
   void pack_info(Protocol* protocol);
 #endif /* HAVE_REPLICATION */
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
   Xid_log_event(const char* buf,
@@ -3067,7 +3076,7 @@ public:
     }
   void pack_info(Protocol* protocol);
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
   User_var_log_event(const char* buf, uint event_len,
@@ -3115,7 +3124,7 @@ public:
   Stop_log_event() :Log_event()
   {}
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
   Stop_log_event(const char* buf,
@@ -3211,7 +3220,7 @@ public:
   void pack_info(Protocol* protocol);
 #endif /* HAVE_REPLICATION */
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
   Rotate_log_event(const char* buf, uint event_len,
@@ -3251,7 +3260,7 @@ public:
   void pack_info(Protocol *protocol);
 #endif
 #else
-  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
   Binlog_checkpoint_log_event(const char *buf, uint event_len,
              const Format_description_log_event *description_event);
@@ -3376,7 +3385,7 @@ public:
   virtual enum_skip_reason do_shall_skip(rpl_group_info *rgi);
 #endif
 #else
-  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
   Gtid_log_event(const char *buf, uint event_len,
                  const Format_description_log_event *description_event);
@@ -3490,7 +3499,7 @@ public:
   void pack_info(Protocol *protocol);
 #endif
 #else
-  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
   Gtid_list_log_event(const char *buf, uint event_len,
                       const Format_description_log_event *description_event);
@@ -3554,8 +3563,8 @@ public:
   void pack_info(Protocol* protocol);
 #endif /* HAVE_REPLICATION */
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info,
              bool enable_local);
 #endif
 
@@ -3627,7 +3636,7 @@ public:
   virtual int get_create_or_append() const;
 #endif /* HAVE_REPLICATION */
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
   Append_block_log_event(const char* buf, uint event_len,
@@ -3667,8 +3676,8 @@ public:
   void pack_info(Protocol* protocol);
 #endif /* HAVE_REPLICATION */
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info,
              bool enable_local);
 #endif
 
@@ -3708,7 +3717,7 @@ public:
   void pack_info(Protocol* protocol);
 #endif /* HAVE_REPLICATION */
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
   Execute_load_log_event(const char* buf, uint event_len,
@@ -3804,9 +3813,9 @@ public:
   void pack_info(Protocol* protocol);
 #endif /* HAVE_REPLICATION */
 #else
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
   /* Prints the query as LOAD DATA LOCAL and with rewritten filename */
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info,
 	     const char *local_fname);
 #endif
   Execute_load_query_log_event(const char* buf, uint event_len,
@@ -3851,7 +3860,7 @@ public:
   /* constructor for hopelessly corrupted events */
   Unknown_log_event(): Log_event(), what(ENCRYPTED) {}
   ~Unknown_log_event() {}
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
+  bool print(FILE* file, PRINT_EVENT_INFO* print_event_info);
   Log_event_type get_type_code() { return UNKNOWN_EVENT;}
   bool is_valid() const { return 1; }
 };
@@ -3896,7 +3905,7 @@ public:
 #endif
 
 #ifdef MYSQL_CLIENT
-  virtual void print(FILE*, PRINT_EVENT_INFO*);
+  virtual bool print(FILE*, PRINT_EVENT_INFO*);
 #endif
 
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
@@ -4316,7 +4325,7 @@ public:
 #endif
 
 #ifdef MYSQL_CLIENT
-  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  virtual bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
 
 
@@ -4437,15 +4446,21 @@ public:
 
 #ifdef MYSQL_CLIENT
   /* not for direct call, each derived has its own ::print() */
-  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info)= 0;
+  virtual bool print(FILE *file, PRINT_EVENT_INFO *print_event_info)= 0;
   void change_to_flashback_event(PRINT_EVENT_INFO *print_event_info, uchar *rows_buff, Log_event_type ev_type);
-  void print_verbose(IO_CACHE *file,
+  bool print_verbose(IO_CACHE *file,
                      PRINT_EVENT_INFO *print_event_info);
   size_t print_verbose_one_row(IO_CACHE *file, table_def *td,
                                PRINT_EVENT_INFO *print_event_info,
                                MY_BITMAP *cols_bitmap,
                                const uchar *ptr, const uchar *prefix,
                                const my_bool no_fill_output= 0); // if no_fill_output=1, then print result is unnecessary
+  size_t calc_row_event_length(table_def *td,
+                               PRINT_EVENT_INFO *print_event_info,
+                               MY_BITMAP *cols_bitmap,
+                               const uchar *value);
+  void count_row_events(PRINT_EVENT_INFO *print_event_info);
+
 #endif
 
 #ifdef MYSQL_SERVER
@@ -4552,7 +4567,7 @@ protected:
   void uncompress_buf();
 
 #ifdef MYSQL_CLIENT
-  void print_helper(FILE *, PRINT_EVENT_INFO *, char const *const name);
+  bool print_helper(FILE *, PRINT_EVENT_INFO *, char const *const name);
 #endif
 
 #ifdef MYSQL_SERVER
@@ -4756,7 +4771,7 @@ private:
   virtual Log_event_type get_general_type_code() { return (Log_event_type)TYPE_CODE; }
 
 #ifdef MYSQL_CLIENT
-  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
 
 #if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
@@ -4780,7 +4795,7 @@ public:
 #endif
 private:
 #if defined(MYSQL_CLIENT)
-  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
 };
 
@@ -4843,7 +4858,7 @@ protected:
   virtual Log_event_type get_general_type_code() { return (Log_event_type)TYPE_CODE; }
 
 #ifdef MYSQL_CLIENT
-  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
 
 #if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
@@ -4867,7 +4882,7 @@ public:
 #endif
 private:
 #if defined(MYSQL_CLIENT)
-  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
 };
 
@@ -4927,7 +4942,7 @@ protected:
   virtual Log_event_type get_general_type_code() { return (Log_event_type)TYPE_CODE; }
 
 #ifdef MYSQL_CLIENT
-  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
 
 #if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
@@ -4950,7 +4965,7 @@ public:
 #endif
 private:
 #if defined(MYSQL_CLIENT)
-  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
 };
 
@@ -5044,7 +5059,7 @@ public:
   virtual ~Incident_log_event();
 
 #ifdef MYSQL_CLIENT
-  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  virtual bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
 
 #if defined(MYSQL_SERVER) && defined(HAVE_REPLICATION)
@@ -5111,7 +5126,7 @@ public:
 #endif
 
 #ifdef MYSQL_CLIENT
-  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  virtual bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
 
   virtual Log_event_type get_type_code() { return IGNORABLE_LOG_EVENT; }
@@ -5121,38 +5136,6 @@ public:
   virtual int get_data_size() { return IGNORABLE_HEADER_LEN; }
 };
 
-
-static inline bool copy_event_cache_to_string_and_reinit(IO_CACHE *cache, LEX_STRING *to)
-{
-  String tmp;
-
-  reinit_io_cache(cache, READ_CACHE, 0L, FALSE, FALSE);
-  if (tmp.append(cache, (uint32)cache->end_of_file))
-    goto err;
-  reinit_io_cache(cache, WRITE_CACHE, 0, FALSE, TRUE);
-
-  /*
-    Can't change the order, because the String::release() will clear the
-    length.
-  */
-  to->length= tmp.length();
-  to->str=    tmp.release();
-
-  return false;
-
-err:
-  perror("Out of memory: can't allocate memory in copy_event_cache_to_string_and_reinit().");
-  return true;
-}
-
-static inline bool copy_event_cache_to_file_and_reinit(IO_CACHE *cache,
-                                                       FILE *file)
-{
-  return         
-    my_b_copy_to_file(cache, file) ||
-    reinit_io_cache(cache, WRITE_CACHE, 0, FALSE, TRUE);
-}
-
 #ifdef MYSQL_SERVER
 /*****************************************************************************
 
diff --git a/sql/log_event_old.cc b/sql/log_event_old.cc
index 68ffa32fafe..bda9a345790 100644
--- a/sql/log_event_old.cc
+++ b/sql/log_event_old.cc
@@ -1845,7 +1845,7 @@ void Old_rows_log_event::pack_info(Protocol *protocol)
 
 
 #ifdef MYSQL_CLIENT
-void Old_rows_log_event::print_helper(FILE *file,
+bool Old_rows_log_event::print_helper(FILE *file,
                                       PRINT_EVENT_INFO *print_event_info,
                                       char const *const name)
 {
@@ -1854,18 +1854,23 @@ void Old_rows_log_event::print_helper(FILE *file,
   if (!print_event_info->short_form)
   {
     bool const last_stmt_event= get_flags(STMT_END_F);
-    print_header(head, print_event_info, !last_stmt_event);
-    my_b_printf(head, "\t%s: table id %lu%s\n",
-                name, m_table_id,
-                last_stmt_event ? " flags: STMT_END_F" : "");
-    print_base64(body, print_event_info, !last_stmt_event);
+    if (print_header(head, print_event_info, !last_stmt_event) ||
+        my_b_printf(head, "\t%s: table id %lu%s\n",
+                    name, m_table_id,
+                    last_stmt_event ? " flags: STMT_END_F" : "") ||
+        print_base64(body, print_event_info, !last_stmt_event))
+      goto err;
   }
 
   if (get_flags(STMT_END_F))
   {
-    copy_event_cache_to_file_and_reinit(head, file);
-    copy_event_cache_to_file_and_reinit(body, file);
+    if (copy_event_cache_to_file_and_reinit(head, file) ||
+        copy_event_cache_to_file_and_reinit(body, file))
+      goto err;
   }
+  return 0;
+err:
+  return 1;
 }
 #endif
 
@@ -2491,10 +2496,11 @@ Write_rows_log_event_old::do_exec_row(rpl_group_info *rgi)
 
 
 #ifdef MYSQL_CLIENT
-void Write_rows_log_event_old::print(FILE *file,
+bool Write_rows_log_event_old::print(FILE *file,
                                      PRINT_EVENT_INFO* print_event_info)
 {
-  Old_rows_log_event::print_helper(file, print_event_info, "Write_rows_old");
+  return Old_rows_log_event::print_helper(file, print_event_info,
+                                          "Write_rows_old");
 }
 #endif
 
@@ -2598,10 +2604,11 @@ int Delete_rows_log_event_old::do_exec_row(rpl_group_info *rgi)
 
 
 #ifdef MYSQL_CLIENT
-void Delete_rows_log_event_old::print(FILE *file,
+bool Delete_rows_log_event_old::print(FILE *file,
                                       PRINT_EVENT_INFO* print_event_info)
 {
-  Old_rows_log_event::print_helper(file, print_event_info, "Delete_rows_old");
+  return Old_rows_log_event::print_helper(file, print_event_info,
+                                          "Delete_rows_old");
 }
 #endif
 
@@ -2736,9 +2743,10 @@ Update_rows_log_event_old::do_exec_row(rpl_group_info *rgi)
 
 
 #ifdef MYSQL_CLIENT
-void Update_rows_log_event_old::print(FILE *file,
+bool Update_rows_log_event_old::print(FILE *file,
                                       PRINT_EVENT_INFO* print_event_info)
 {
-  Old_rows_log_event::print_helper(file, print_event_info, "Update_rows_old");
+  return Old_rows_log_event::print_helper(file, print_event_info,
+                                          "Update_rows_old");
 }
 #endif
diff --git a/sql/log_event_old.h b/sql/log_event_old.h
index 40e01d37318..d18c980bdfe 100644
--- a/sql/log_event_old.h
+++ b/sql/log_event_old.h
@@ -116,7 +116,7 @@ public:
 
 #ifdef MYSQL_CLIENT
   /* not for direct call, each derived has its own ::print() */
-  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info)= 0;
+  virtual bool print(FILE *file, PRINT_EVENT_INFO *print_event_info)= 0;
 #endif
 
 #ifndef MYSQL_CLIENT
@@ -166,7 +166,7 @@ protected:
                      const Format_description_log_event *description_event);
 
 #ifdef MYSQL_CLIENT
-  void print_helper(FILE *, PRINT_EVENT_INFO *, char const *const name);
+  bool print_helper(FILE *, PRINT_EVENT_INFO *, char const *const name);
 #endif
 
 #ifndef MYSQL_CLIENT
@@ -379,7 +379,7 @@ public:
 
 private:
 #ifdef MYSQL_CLIENT
-  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
 
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
@@ -455,7 +455,7 @@ public:
 
 protected:
 #ifdef MYSQL_CLIENT
-  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
 
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
@@ -529,7 +529,7 @@ public:
   
 protected:
 #ifdef MYSQL_CLIENT
-  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+  bool print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 #endif
 
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index c1e14974c35..320771a859b 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -7259,7 +7259,7 @@ struct my_option my_long_options[]=
    "The value has to be a multiple of 256.",
    &opt_binlog_rows_event_max_size, &opt_binlog_rows_event_max_size,
    0, GET_ULONG, REQUIRED_ARG,
-   /* def_value */ 8192, /* min_value */  256, /* max_value */ ULONG_MAX,
+   /* def_value */ 8192, /* min_value */  256, /* max_value */ UINT32_MAX-1,
    /* sub_size */     0, /* block_size */ 256,
    /* app_type */ 0
   },
diff --git a/sql/rpl_gtid.cc b/sql/rpl_gtid.cc
index 7f7e53c79e4..edd93143048 100644
--- a/sql/rpl_gtid.cc
+++ b/sql/rpl_gtid.cc
@@ -1460,7 +1460,6 @@ rpl_binlog_state::write_to_iocache(IO_CACHE *dest)
   mysql_mutex_lock(&LOCK_binlog_state);
   for (i= 0; i < hash.records; ++i)
   {
-    size_t res;
     element *e= (element *)my_hash_element(&hash, i);
     if (!e->last_gtid)
     {
@@ -1480,8 +1479,8 @@ rpl_binlog_state::write_to_iocache(IO_CACHE *dest)
         gtid= e->last_gtid;
 
       longlong10_to_str(gtid->seq_no, buf, 10);
-      res= my_b_printf(dest, "%u-%u-%s\n", gtid->domain_id, gtid->server_id, buf);
-      if (res == (size_t) -1)
+      if (my_b_printf(dest, "%u-%u-%s\n", gtid->domain_id, gtid->server_id,
+                      buf))
       {
         res= 1;
         goto end;
diff --git a/sql/sql_string.cc b/sql/sql_string.cc
index e07a1cd6820..a24eaaa6fde 100644
--- a/sql/sql_string.cc
+++ b/sql/sql_string.cc
@@ -607,7 +607,7 @@ bool String::append(IO_CACHE* file, uint32 arg_length)
     return TRUE;
   if (my_b_read(file, (uchar*) Ptr + str_length, arg_length))
   {
-    shrink(str_length);
+    shrink(str_length ? str_length : 1);
     return TRUE;
   }
   str_length+=arg_length;