Manual merge from 5.0-rpl, of fixes for:

1)
  BUG#25507 "multi-row insert delayed + auto increment causes
  duplicate key entries on slave" (two concurrrent connections doing
  multi-row INSERT DELAYED to insert into an auto_increment column,
  caused replication slave to stop with "duplicate key error" (and
  binlog was wrong), and BUG#26116 "If multi-row INSERT
  DELAYED has errors, statement-based binlogging breaks" (the binlog
  was not accounting for all rows inserted, or slave could stop).
  The fix is that: in statement-based binlogging, a multi-row INSERT
  DELAYED is silently converted to a non-delayed INSERT.
  This is supposed to not affect many 5.1 users as in 5.1, the default
  binlog format is "mixed", which does not have the bug (the bug is
  only with binlog_format=STATEMENT).
  We should document how the system delayed_insert thread decides of
  its binlog format (which is not modified by this patch):
  this decision is taken when the thread is created
  and holds until it is terminated (is not affected by any later change
  via SET GLOBAL BINLOG_FORMAT). It is also not affected by the binlog
  format of the connection which issues INSERT DELAYED (this binlog
  format does not affect how the row will be binlogged).
  If one wants to change the binlog format of its server with SET
  GLOBAL BINLOG_FORMAT, it should do FLUSH TABLES to be sure all
  delayed_insert threads terminate and thus new threads are created,
  taking into account the new format.
2)
  BUG#24432
  "INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values".
  When in an INSERT ON DUPLICATE KEY UPDATE, using
  an autoincrement column, we inserted some autogenerated values and
  also updated some rows, some autogenerated values were not used
  (for example, even if 10 was the largest autoinc value in the table
  at the start of the statement, 12 could be the first autogenerated
  value inserted by the statement, instead of 11). One autogenerated
  value was lost per updated row. Led to exhausting the range of the
  autoincrement column faster.
  Bug introduced by fix of BUG#20188; present since 5.0.24 and 5.1.12.
  This bug breaks replication from a pre-5.0.24/pre-5.1.12 master.
  But the present bugfix, as it makes INSERT ON DUP KEY UPDATE
  behave like pre-5.0.24/pre-5.1.12, breaks replication from a
  [5.0.24,5.0.34]/[5.1.12,5.1.15]
  master to a fixed (5.0.36/5.1.16) slave! To warn users against this when
  they upgrade their slave, as agreed with the support team, we add
  code for a fixed slave to detect that it is connected to a buggy
  master in a situation (INSERT ON DUP KEY UPDATE into autoinc column)
  likely to break replication, in which case it cannot replicate so
  stops and prints a message to the slave's error log and to SHOW SLAVE
  STATUS.
  For 5.0.36->[5.0.24,5.0.34] replication or 5.1.16->[5.1.12,5.1.15]
  replication we cannot warn as master
  does not know the slave's version (but we always recommended to users
  to have slave at least as new as master).
  As agreed with support, I have asked for an alert to be put into
  the MySQL Network Monitoring and Advisory Service.
3) note that I'll re-enable rpl_insert_id as soon as 5.1-rpl gets
  the changes from the main 5.1.


BitKeeper/deleted/.del-rpl_insert_delayed.result:
  Delete: mysql-test/r/rpl_insert_delayed.result
mysql-test/extra/rpl_tests/rpl_insert_delayed.test:
  tests for BUG#25507 (lauch many concurrent INSERT DELAYED into an auto_inc
  column and see if they cause duplicates) and BUG#26116 (see if one error
  at first row on master makes the slave's data incorrect).
  It is then incorporated into a statement-based and mixed binlogging
  test, and into a row-based test.
  It is in fact mysql-test/t/rpl_insert_delayed.test from 5.0, renamed
  and extended to test BUG#25507.
mysql-test/extra/rpl_tests/rpl_insert_id.test:
  manual merge of test for BUG#24432
  "INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values"
  from 5.0
mysql-test/r/rpl_insert_id.result:
  result update (it automerged from 5.0, contrary to the test file)
mysql-test/r/rpl_known_bugs_detection.result:
  result update (binlog event sizes differ from 5.0)
mysql-test/t/disabled.def:
  rpl_insert_id tests statement-based replication of INSERT ON
  DUPLICATE KEY UPDATE. This type of INSERT had BUG#24432, which is
  fixed in 5.1.16; we made the slave detect if it is connected to a
  <5.1.16 master and if so refuse to replicate.
  The problem is that this 5.1-rpl tree, even though it will produce
  the 5.1.16 release, still has a 5.1.15 version in configure.in.
  Thus rpl_insert_id fails. So I disable it. As soon as the 5.1-rpl
  tree gets the changesets from the main 5.1, its version will change
  to 5.1.16 and so I'll be able to re-enable the test.
mysql-test/t/rpl_known_bugs_detection.test:
  only in statement-based; row-based has no bug so test would fail.
sql/slave.cc:
  slave_print_msg(ERROR_LEVEL) calls my_error(ER_UNKNOWN_ERROR);
  so, for our my_printf_error(), which has a nicer message than this
  my_error(), to have any effect, it must be 
  called before slave_print_msg()
sql/sql_insert.cc:
  manual merge from 5.0 of a piece of the fixes for
  BUG#24432 "INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values"
  BUG#25507 "multi-row insert delayed + auto increment causes
  duplicate key entries on slave"
  BUG#26116 "If multi-row INSERT DELAYED has errors, statement-based
  binlogging breaks".
  The other pieces (e.g. log_event.cc) automerged from 5.0.
mysql-test/r/rpl_row_insert_delayed.result:
  result
mysql-test/r/rpl_stm_insert_delayed.result:
  result. Note how "mixed" and "statement" insert different data in
  the table.
mysql-test/t/rpl_row_insert_delayed.test:
  wrapper to test INSERT DELAYED binlogging in row-based mode
mysql-test/t/rpl_stm_insert_delayed.test:
  wrapper to test INSERT DELAYED binlogging in statement-based and mixed
  mode

1 files changed, 49 insertions, 1 deletions

diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index 989b78f3517..ecb2d450d30 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -59,6 +59,7 @@
 #include "sql_trigger.h"
 #include "sql_select.h"
 #include "sql_show.h"
+#include "slave.h"
 
 static int check_null_fields(THD *thd,TABLE *entry);
 #ifndef EMBEDDED_LIBRARY
@@ -341,6 +342,36 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
       (duplic == DUP_UPDATE))
     lock_type=TL_WRITE;
 #endif
+  if ((lock_type == TL_WRITE_DELAYED) &&
+      (global_system_variables.binlog_format == BINLOG_FORMAT_STMT) &&
+      log_on && mysql_bin_log.is_open() &&
+      (values_list.elements > 1))
+  {
+    /*
+      Statement-based binary logging does not work in this case, because:
+      a) two concurrent statements may have their rows intermixed in the
+      queue, leading to autoincrement replication problems on slave (because
+      the values generated used for one statement don't depend only on the
+      value generated for the first row of this statement, so are not
+      replicable)
+      b) if first row of the statement has an error the full statement is
+      not binlogged, while next rows of the statement may be inserted.
+      c) if first row succeeds, statement is binlogged immediately with a
+      zero error code (i.e. "no error"), if then second row fails, query
+      will fail on slave too and slave will stop (wrongly believing that the
+      master got no error).
+      So we fallback to non-delayed INSERT.
+      Note that to be fully correct, we should test the "binlog format which
+      the delayed thread is going to use for this row". But in the common case
+      where the global binlog format is not changed and the session binlog
+      format may be changed, that is equal to the global binlog format.
+      We test it without mutex for speed reasons (condition rarely true), and
+      in the common case (global not changed) it is as good as without mutex;
+      if global value is changed, anyway there is uncertainty as the delayed
+      thread may be old and use the before-the-change value.
+    */
+    lock_type= TL_WRITE;
+  }
   table_list->lock_type= lock_type;
 
 #ifndef EMBEDDED_LIBRARY
@@ -454,6 +485,14 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
   thd->cuted_fields = 0L;
   table->next_number_field=table->found_next_number_field;
 
+#ifdef HAVE_REPLICATION
+  if (thd->slave_thread &&
+      (info.handle_duplicates == DUP_UPDATE) &&
+      (table->next_number_field != NULL) &&
+      rpl_master_has_bug(&active_mi->rli, 24432))
+    goto abort;
+#endif
+
   error=0;
   thd->proc_info="update";
   if (duplic != DUP_ERROR || ignore)
@@ -1146,13 +1185,13 @@ int write_record(THD *thd, TABLE *table,COPY_INFO *info)
         if (res == VIEW_CHECK_ERROR)
           goto before_trg_err;
 
+        table->file->restore_auto_increment(prev_insert_id);
         if ((error=table->file->ha_update_row(table->record[1],
                                               table->record[0])))
 	{
           if (info->ignore &&
               !table->file->is_fatal_error(error, HA_CHECK_DUP_KEY))
           {
-            table->file->restore_auto_increment(prev_insert_id);
             goto ok_or_after_trg_err;
           }
           goto err;
@@ -2489,6 +2528,15 @@ select_insert::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
   }
   restore_record(table,s->default_values);		// Get empty record
   table->next_number_field=table->found_next_number_field;
+
+#ifdef HAVE_REPLICATION
+  if (thd->slave_thread &&
+      (info.handle_duplicates == DUP_UPDATE) &&
+      (table->next_number_field != NULL) &&
+      rpl_master_has_bug(&active_mi->rli, 24432))
+    DBUG_RETURN(1);
+#endif
+
   thd->cuted_fields=0;
   if (info.ignore || info.handle_duplicates != DUP_ERROR)
     table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);