From fc0adebe0eb34e94eacc7a677a1d55b349131953 Mon Sep 17 00:00:00 2001
From: "cbell/Chuck@mysql_cab_desk." <>
Date: Thu, 18 Jan 2007 13:35:49 -0500
Subject: BUG#21490 - No warning issued for deprecated replication parameters
 This patch deprecates the replication startup options in the configuration
 file and on the command line. The options deprecated include:

MASTER_HOST, MASTER_USER, MASTER_PASSWORD, MASTER_PORT, MASTER_CONNECT_RETRY,
MASTER_SSL, MASTER_SSL_CA, MASTER_SSL_CAPATH, MASTER_SSL_CERT, MASTER_SSL_KEY,
and MASTER_SSL_CIPHER

The code is designed to print the warning message once.
---
 sql/mysql_priv.h | 12 ++++++++++++
 sql/mysqld.cc    | 25 +++++++++++++++++++++++++
 2 files changed, 37 insertions(+)

diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index cad42320db4..06a02978994 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -91,6 +91,18 @@ char* query_table_status(THD *thd,const char *db,const char *table_name);
 #define PREV_BITS(type,A)	((type) (((type) 1 << (A)) -1))
 #define all_bits_set(A,B) ((A) & (B) != (B))
 
+#define WARN_DEPRECATED(Thd,Ver,Old,New)                                             \
+  do {                                                                               \
+    DBUG_ASSERT(strncmp(Ver, MYSQL_SERVER_VERSION, sizeof(Ver)-1) > 0);              \
+    if (Thd != NULL)                                                                 \
+      push_warning_printf(((THD *)Thd), MYSQL_ERROR::WARN_LEVEL_WARN,                \
+                        ER_WARN_DEPRECATED_SYNTAX, ER(ER_WARN_DEPRECATED_SYNTAX),    \
+                        (Old), (Ver), (New));                                        \
+    else                                                                             \
+      sql_print_warning("The syntax %s is deprecated and will be removed "           \
+                        "in MySQL %s. Please use %s instead.", (Old), (Ver), (New)); \
+  } while(0)
+
 extern CHARSET_INFO *system_charset_info, *files_charset_info ;
 extern CHARSET_INFO *national_charset_info, *table_alias_charset;
 
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 488751eb015..a7dc8bede84 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -356,6 +356,8 @@ my_bool opt_safe_user_create = 0, opt_no_mix_types = 0;
 my_bool opt_show_slave_auth_info, opt_sql_bin_update = 0;
 my_bool opt_log_slave_updates= 0;
 my_bool	opt_innodb;
+bool slave_warning_issued = false; 
+
 #ifdef HAVE_NDBCLUSTER_DB
 const char *opt_ndbcluster_connectstring= 0;
 const char *opt_ndb_connectstring= 0;
@@ -6888,6 +6890,29 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
   case (int) OPT_STANDALONE:		/* Dummy option for NT */
     break;
 #endif
+  /*
+    The following change issues a deprecation warning if the slave
+    configuration is specified either in the my.cnf file or on
+    the command-line. See BUG#21490.
+  */
+  case OPT_MASTER_HOST:
+  case OPT_MASTER_USER:
+  case OPT_MASTER_PASSWORD:
+  case OPT_MASTER_PORT:
+  case OPT_MASTER_CONNECT_RETRY:
+  case OPT_MASTER_SSL:          
+  case OPT_MASTER_SSL_KEY:
+  case OPT_MASTER_SSL_CERT:       
+  case OPT_MASTER_SSL_CAPATH:
+  case OPT_MASTER_SSL_CIPHER:
+  case OPT_MASTER_SSL_CA:
+    if (!slave_warning_issued)                 //only show the warning once
+    {
+      slave_warning_issued = true;   
+      WARN_DEPRECATED(0, "5.2", "for replication startup options", 
+        "'CHANGE MASTER'");
+    }
+    break;
   case OPT_CONSOLE:
     if (opt_console)
       opt_error_log= 0;			// Force logs to stdout
-- 
cgit v1.2.1


From ffeaffc26fc27e3d068210966254d3189d4868c5 Mon Sep 17 00:00:00 2001
From: "bar@mysql.com" <>
Date: Wed, 24 Jan 2007 16:37:38 +0400
Subject: Bug#25815 Data truncated for column TEXT Problem: "Data truncated"
 warning was incorrectly generated when storing a Japanese character encoded
 in utf8 into a cp932 column. Reason: Incorrect wrong warning condition
 compared the original length of the character in bytes (which is 3 in utf8)
 to the converted length of the character in bytes (which is 2 in cp932). Fix:
 use "how many bytes were scanned from input" instead of "how many bytes were
 put to the column" in the condition.

---
 mysql-test/r/ctype_cp932.result | 12 ++++++++++++
 mysql-test/t/ctype_cp932.test   | 11 +++++++++++
 sql/field.cc                    |  2 +-
 3 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/mysql-test/r/ctype_cp932.result b/mysql-test/r/ctype_cp932.result
index ed57b87c1ba..10451686e2c 100755
--- a/mysql-test/r/ctype_cp932.result
+++ b/mysql-test/r/ctype_cp932.result
@@ -11353,3 +11353,15 @@ a
 a
 a
 drop table t1;
+set names utf8;
+create table t1 (a text) default character set cp932;
+insert into t1 values (_utf8 0xE38182);
+show warnings;
+Level	Code	Message
+select * from t1;
+a
+あ
+select hex(a) from t1;
+hex(a)
+82A0
+drop table t1;
diff --git a/mysql-test/t/ctype_cp932.test b/mysql-test/t/ctype_cp932.test
index 688d06c4dde..c6196b928b0 100644
--- a/mysql-test/t/ctype_cp932.test
+++ b/mysql-test/t/ctype_cp932.test
@@ -413,3 +413,14 @@ select * from t1;
 insert into t1 values ('abc');
 select * from t1;
 drop table t1;
+
+#
+# Bug#25815 Data truncated for column TEXT
+#
+set names utf8;
+create table t1 (a text) default character set cp932;
+insert into t1 values (_utf8 0xE38182);
+show warnings;
+select * from t1;
+select hex(a) from t1;
+drop table t1;
diff --git a/sql/field.cc b/sql/field.cc
index 257c7846468..61a687567fc 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -7024,7 +7024,7 @@ int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
                               cannot_convert_error_pos, from + length))
     return 2;
 
-  if (copy_length < length)
+  if (from_end_pos < from + length)
   {
     report_data_too_long(this);
     return 2;
-- 
cgit v1.2.1


From faf05bf314ce07697ca832a0a9b2ef092df74840 Mon Sep 17 00:00:00 2001
From: "bar@mysql.com" <>
Date: Thu, 1 Feb 2007 10:11:45 +0400
Subject: Additional fix for bug 25815 for test results when running with
 --binlog-format=row

---
 mysql-test/r/binlog_row_ctype_cp932.result | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/mysql-test/r/binlog_row_ctype_cp932.result b/mysql-test/r/binlog_row_ctype_cp932.result
index ed57b87c1ba..10451686e2c 100644
--- a/mysql-test/r/binlog_row_ctype_cp932.result
+++ b/mysql-test/r/binlog_row_ctype_cp932.result
@@ -11353,3 +11353,15 @@ a
 a
 a
 drop table t1;
+set names utf8;
+create table t1 (a text) default character set cp932;
+insert into t1 values (_utf8 0xE38182);
+show warnings;
+Level	Code	Message
+select * from t1;
+a
+あ
+select hex(a) from t1;
+hex(a)
+82A0
+drop table t1;
-- 
cgit v1.2.1


From b3a03dada994b5e257ce880c0d4f478b1fd989bf Mon Sep 17 00:00:00 2001
From: "guilhem@gbichot3.local" <>
Date: Thu, 8 Feb 2007 15:53:14 +0100
Subject: Fix for 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 master. But the present bugfix, as it makes INSERT ON DUP KEY
 UPDATE behave like pre-5.0.24, breaks replication from a [5.0.24,5.0.34]
 master to a fixed (5.0.36) 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 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'll also ask for an alert to be put into the MySQL Network
 Monitoring and Advisory Service.

---
 mysql-test/r/rpl_insert_id.result                |  58 ++++++++++
 mysql-test/r/rpl_known_bugs_detection.result     | 133 +++++++++++++++++++++++
 mysql-test/t/rpl_insert_id.test                  |  53 +++++++++
 mysql-test/t/rpl_known_bugs_detection-master.opt |   1 +
 mysql-test/t/rpl_known_bugs_detection.test       |  90 +++++++++++++++
 sql/log_event.cc                                 |  37 +++++++
 sql/log_event.h                                  |   2 +
 sql/slave.cc                                     |  64 +++++++++++
 sql/slave.h                                      |   1 +
 sql/sql_insert.cc                                |  20 +++-
 10 files changed, 458 insertions(+), 1 deletion(-)
 create mode 100644 mysql-test/r/rpl_known_bugs_detection.result
 create mode 100644 mysql-test/t/rpl_known_bugs_detection-master.opt
 create mode 100644 mysql-test/t/rpl_known_bugs_detection.test

diff --git a/mysql-test/r/rpl_insert_id.result b/mysql-test/r/rpl_insert_id.result
index d133a2ae8ed..a5c8e17f67e 100644
--- a/mysql-test/r/rpl_insert_id.result
+++ b/mysql-test/r/rpl_insert_id.result
@@ -234,6 +234,64 @@ n	b
 2	100
 3	350
 drop table t1;
+CREATE TABLE t1 (a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b INT,
+UNIQUE(b));
+INSERT INTO t1(b) VALUES(1),(1),(2) ON DUPLICATE KEY UPDATE t1.b=10;
+SELECT * FROM t1;
+a	b
+1	10
+2	2
+SELECT * FROM t1;
+a	b
+1	10
+2	2
+drop table t1;
+CREATE TABLE t1 (
+id bigint(20) unsigned NOT NULL auto_increment,
+field_1 int(10) unsigned NOT NULL,
+field_2 varchar(255) NOT NULL,
+field_3 varchar(255) NOT NULL,
+PRIMARY KEY (id),
+UNIQUE KEY field_1 (field_1, field_2)
+);
+CREATE TABLE t2 (
+field_a int(10) unsigned NOT NULL,
+field_b varchar(255) NOT NULL,
+field_c varchar(255) NOT NULL
+);
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (1, 'a', '1a');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (2, 'b', '2b');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (3, 'c', '3c');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (4, 'd', '4d');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (5, 'e', '5e');
+INSERT INTO t1 (field_1, field_2, field_3)
+SELECT t2.field_a, t2.field_b, t2.field_c
+FROM t2
+ON DUPLICATE KEY UPDATE
+t1.field_3 = t2.field_c;
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (6, 'f', '6f');
+INSERT INTO t1 (field_1, field_2, field_3)
+SELECT t2.field_a, t2.field_b, t2.field_c
+FROM t2
+ON DUPLICATE KEY UPDATE
+t1.field_3 = t2.field_c;
+SELECT * FROM t1;
+id	field_1	field_2	field_3
+1	1	a	1a
+2	2	b	2b
+3	3	c	3c
+4	4	d	4d
+5	5	e	5e
+6	6	f	6f
+SELECT * FROM t1;
+id	field_1	field_2	field_3
+1	1	a	1a
+2	2	b	2b
+3	3	c	3c
+4	4	d	4d
+5	5	e	5e
+6	6	f	6f
+drop table t1, t2;
 DROP PROCEDURE IF EXISTS p1;
 DROP TABLE IF EXISTS t1, t2;
 SELECT LAST_INSERT_ID(0);
diff --git a/mysql-test/r/rpl_known_bugs_detection.result b/mysql-test/r/rpl_known_bugs_detection.result
new file mode 100644
index 00000000000..c23586c6f61
--- /dev/null
+++ b/mysql-test/r/rpl_known_bugs_detection.result
@@ -0,0 +1,133 @@
+stop slave;
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+reset master;
+reset slave;
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+start slave;
+CREATE TABLE t1 (a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b INT,
+UNIQUE(b));
+INSERT INTO t1(b) VALUES(1),(1),(2) ON DUPLICATE KEY UPDATE t1.b=10;
+SELECT * FROM t1;
+a	b
+1	10
+2	2
+show slave status;;
+Slave_IO_State	#
+Master_Host	127.0.0.1
+Master_User	root
+Master_Port	#
+Connect_Retry	1
+Master_Log_File	master-bin.000001
+Read_Master_Log_Pos	#
+Relay_Log_File	#
+Relay_Log_Pos	#
+Relay_Master_Log_File	master-bin.000001
+Slave_IO_Running	Yes
+Slave_SQL_Running	No
+Replicate_Do_DB	
+Replicate_Ignore_DB	
+Replicate_Do_Table	
+Replicate_Ignore_Table	
+Replicate_Wild_Do_Table	
+Replicate_Wild_Ignore_Table	
+Last_Errno	1105
+Last_Error	Error 'master may suffer from http://bugs.mysql.com/bug.php?id=24432 so slave stops; check error log on slave for more info' on query. Default database: 'test'. Query: 'INSERT INTO t1(b) VALUES(1),(1),(2) ON DUPLICATE KEY UPDATE t1.b=10'
+Skip_Counter	0
+Exec_Master_Log_Pos	238
+Relay_Log_Space	#
+Until_Condition	None
+Until_Log_File	
+Until_Log_Pos	0
+Master_SSL_Allowed	No
+Master_SSL_CA_File	
+Master_SSL_CA_Path	
+Master_SSL_Cert	
+Master_SSL_Cipher	
+Master_SSL_Key	
+Seconds_Behind_Master	#
+SELECT * FROM t1;
+a	b
+stop slave;
+reset slave;
+reset master;
+drop table t1;
+start slave;
+CREATE TABLE t1 (
+id bigint(20) unsigned NOT NULL auto_increment,
+field_1 int(10) unsigned NOT NULL,
+field_2 varchar(255) NOT NULL,
+field_3 varchar(255) NOT NULL,
+PRIMARY KEY (id),
+UNIQUE KEY field_1 (field_1, field_2)
+);
+CREATE TABLE t2 (
+field_a int(10) unsigned NOT NULL,
+field_b varchar(255) NOT NULL,
+field_c varchar(255) NOT NULL
+);
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (1, 'a', '1a');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (2, 'b', '2b');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (3, 'c', '3c');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (4, 'd', '4d');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (5, 'e', '5e');
+INSERT INTO t1 (field_1, field_2, field_3)
+SELECT t2.field_a, t2.field_b, t2.field_c
+FROM t2
+ON DUPLICATE KEY UPDATE
+t1.field_3 = t2.field_c;
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (6, 'f', '6f');
+INSERT INTO t1 (field_1, field_2, field_3)
+SELECT t2.field_a, t2.field_b, t2.field_c
+FROM t2
+ON DUPLICATE KEY UPDATE
+t1.field_3 = t2.field_c;
+SELECT * FROM t1;
+id	field_1	field_2	field_3
+1	1	a	1a
+2	2	b	2b
+3	3	c	3c
+4	4	d	4d
+5	5	e	5e
+6	6	f	6f
+show slave status;;
+Slave_IO_State	#
+Master_Host	127.0.0.1
+Master_User	root
+Master_Port	#
+Connect_Retry	1
+Master_Log_File	master-bin.000001
+Read_Master_Log_Pos	#
+Relay_Log_File	#
+Relay_Log_Pos	#
+Relay_Master_Log_File	master-bin.000001
+Slave_IO_Running	Yes
+Slave_SQL_Running	No
+Replicate_Do_DB	
+Replicate_Ignore_DB	
+Replicate_Do_Table	
+Replicate_Ignore_Table	
+Replicate_Wild_Do_Table	
+Replicate_Wild_Ignore_Table	
+Last_Errno	1105
+Last_Error	Error 'master may suffer from http://bugs.mysql.com/bug.php?id=24432 so slave stops; check error log on slave for more info' on query. Default database: 'test'. Query: 'INSERT INTO t1 (field_1, field_2, field_3)
+SELECT t2.field_a, t2.field_b, t2.field_c
+FROM t2
+ON DUPLICATE KEY UPDATE
+t1.field_3 = t2.field_c'
+Skip_Counter	0
+Exec_Master_Log_Pos	1270
+Relay_Log_Space	#
+Until_Condition	None
+Until_Log_File	
+Until_Log_Pos	0
+Master_SSL_Allowed	No
+Master_SSL_CA_File	
+Master_SSL_CA_Path	
+Master_SSL_Cert	
+Master_SSL_Cipher	
+Master_SSL_Key	
+Seconds_Behind_Master	#
+SELECT * FROM t1;
+id	field_1	field_2	field_3
+drop table t1, t2;
+drop table t1, t2;
diff --git a/mysql-test/t/rpl_insert_id.test b/mysql-test/t/rpl_insert_id.test
index 331a913256c..be2948e9678 100644
--- a/mysql-test/t/rpl_insert_id.test
+++ b/mysql-test/t/rpl_insert_id.test
@@ -245,6 +245,59 @@ select * from t1 order by n;
 connection master;
 drop table t1;
 
+#
+# BUG#24432 "INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values"
+#
+
+# testcase with INSERT VALUES
+CREATE TABLE t1 (a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b INT,
+UNIQUE(b));
+INSERT INTO t1(b) VALUES(1),(1),(2) ON DUPLICATE KEY UPDATE t1.b=10;
+SELECT * FROM t1;
+sync_slave_with_master;
+SELECT * FROM t1;
+connection master;
+drop table t1;
+
+# tescase with INSERT SELECT
+CREATE TABLE t1 (
+  id bigint(20) unsigned NOT NULL auto_increment,
+  field_1 int(10) unsigned NOT NULL,
+  field_2 varchar(255) NOT NULL,
+  field_3 varchar(255) NOT NULL,
+  PRIMARY KEY (id),
+  UNIQUE KEY field_1 (field_1, field_2)
+);
+CREATE TABLE t2 (
+  field_a int(10) unsigned NOT NULL,
+  field_b varchar(255) NOT NULL,
+  field_c varchar(255) NOT NULL
+);
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (1, 'a', '1a');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (2, 'b', '2b');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (3, 'c', '3c');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (4, 'd', '4d');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (5, 'e', '5e');
+# Updating table t1 based on values from table t2
+INSERT INTO t1 (field_1, field_2, field_3)
+SELECT t2.field_a, t2.field_b, t2.field_c
+FROM t2
+ON DUPLICATE KEY UPDATE
+t1.field_3 = t2.field_c;
+# Inserting new record into t2
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (6, 'f', '6f');
+# Updating t1 again
+INSERT INTO t1 (field_1, field_2, field_3)
+SELECT t2.field_a, t2.field_b, t2.field_c
+FROM t2
+ON DUPLICATE KEY UPDATE
+t1.field_3 = t2.field_c;
+SELECT * FROM t1;
+sync_slave_with_master;
+SELECT * FROM t1;
+connection master;
+drop table t1, t2;
+
 #
 # BUG#20339: stored procedure using LAST_INSERT_ID() does not
 # replicate statement-based 
diff --git a/mysql-test/t/rpl_known_bugs_detection-master.opt b/mysql-test/t/rpl_known_bugs_detection-master.opt
new file mode 100644
index 00000000000..d4ba386a1a0
--- /dev/null
+++ b/mysql-test/t/rpl_known_bugs_detection-master.opt
@@ -0,0 +1 @@
+--loose-debug=d,pretend_version_50034_in_binlog
diff --git a/mysql-test/t/rpl_known_bugs_detection.test b/mysql-test/t/rpl_known_bugs_detection.test
new file mode 100644
index 00000000000..4719716d4a1
--- /dev/null
+++ b/mysql-test/t/rpl_known_bugs_detection.test
@@ -0,0 +1,90 @@
+# Test to see if slave can detect certain known bugs present
+# on the master, and appropriately decides to stop
+# (assuming the bug is fixed in the slave, slave cannot of course
+# imitate the bug, so it has to stop).
+
+source include/have_debug.inc;
+source include/master-slave.inc;
+
+#
+# This is to test that slave properly detects if
+# master may suffer from:
+# BUG#24432 "INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values"
+# (i.e. on master, INSERT ON DUPLICATE KEY UPDATE is used and manipulates
+# an auto_increment column, and is binlogged statement-based).
+#
+
+# testcase with INSERT VALUES
+CREATE TABLE t1 (a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b INT,
+UNIQUE(b));
+sync_slave_with_master;
+connection master;
+INSERT INTO t1(b) VALUES(1),(1),(2) ON DUPLICATE KEY UPDATE t1.b=10;
+SELECT * FROM t1;
+connection slave;
+wait_for_slave_to_stop;
+# show the error message
+--replace_column 1 # 4 # 7 # 8 # 9 # 23 # 33 #
+--query_vertical show slave status;
+# show that it was not replicated
+SELECT * FROM t1;
+
+# restart replication for the next testcase
+stop slave;
+reset slave;
+connection master;
+reset master;
+drop table t1;
+connection slave;
+start slave;
+
+# testcase with INSERT SELECT
+connection master;
+CREATE TABLE t1 (
+  id bigint(20) unsigned NOT NULL auto_increment,
+  field_1 int(10) unsigned NOT NULL,
+  field_2 varchar(255) NOT NULL,
+  field_3 varchar(255) NOT NULL,
+  PRIMARY KEY (id),
+  UNIQUE KEY field_1 (field_1, field_2)
+);
+CREATE TABLE t2 (
+  field_a int(10) unsigned NOT NULL,
+  field_b varchar(255) NOT NULL,
+  field_c varchar(255) NOT NULL
+);
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (1, 'a', '1a');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (2, 'b', '2b');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (3, 'c', '3c');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (4, 'd', '4d');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (5, 'e', '5e');
+sync_slave_with_master;
+connection master;
+# Updating table t1 based on values from table t2
+INSERT INTO t1 (field_1, field_2, field_3)
+SELECT t2.field_a, t2.field_b, t2.field_c
+FROM t2
+ON DUPLICATE KEY UPDATE
+t1.field_3 = t2.field_c;
+# Inserting new record into t2
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (6, 'f', '6f');
+# Updating t1 again
+INSERT INTO t1 (field_1, field_2, field_3)
+SELECT t2.field_a, t2.field_b, t2.field_c
+FROM t2
+ON DUPLICATE KEY UPDATE
+t1.field_3 = t2.field_c;
+SELECT * FROM t1;
+connection slave;
+wait_for_slave_to_stop;
+# show the error message
+--replace_column 1 # 4 # 7 # 8 # 9 # 23 # 33 #
+--query_vertical show slave status;
+# show that it was not replicated
+SELECT * FROM t1;
+connection master;
+drop table t1, t2;
+connection slave;
+drop table t1, t2;
+
+# End of 5.0 tests
diff --git a/sql/log_event.cc b/sql/log_event.cc
index 657fd510e78..a14cd79461d 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -2047,6 +2047,8 @@ Start_log_event_v3::Start_log_event_v3(const char* buf,
   binlog_version= uint2korr(buf+ST_BINLOG_VER_OFFSET);
   memcpy(server_version, buf+ST_SERVER_VER_OFFSET,
 	 ST_SERVER_VER_LEN);
+  // prevent overrun if log is corrupted on disk
+  server_version[ST_SERVER_VER_LEN-1]= 0;
   created= uint4korr(buf+ST_CREATED_OFFSET);
   /* We use log_pos to mark if this was an artificial event or not */
   artificial_event= (log_pos == 0);
@@ -2170,6 +2172,8 @@ Format_description_log_event(uint8 binlog_ver, const char* server_ver)
   switch (binlog_ver) {
   case 4: /* MySQL 5.0 */
     memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
+    DBUG_EXECUTE_IF("pretend_version_50034_in_binlog",
+                    strmov(server_version, "5.0.34"););
     common_header_len= LOG_EVENT_HEADER_LEN;
     number_of_event_types= LOG_EVENT_TYPES;
     /* we'll catch my_malloc() error in is_valid() */
@@ -2241,6 +2245,7 @@ Format_description_log_event(uint8 binlog_ver, const char* server_ver)
     post_header_len= 0; /* will make is_valid() fail */
     break;
   }
+  calc_server_version_split();
 }
 
 
@@ -2280,6 +2285,7 @@ Format_description_log_event(const char* buf,
   post_header_len= (uint8*) my_memdup((byte*)buf+ST_COMMON_HEADER_LEN_OFFSET+1,
                                       number_of_event_types*
                                       sizeof(*post_header_len), MYF(0));
+  calc_server_version_split();
   DBUG_VOID_RETURN;
 }
 
@@ -2380,6 +2386,37 @@ int Format_description_log_event::exec_event(struct st_relay_log_info* rli)
 }
 #endif
 
+
+/**
+   Splits the event's 'server_version' string into three numeric pieces stored
+   into 'server_version_split':
+   X.Y.Zabc (X,Y,Z numbers, a not a digit) -> {X,Y,Z}
+   X.Yabc -> {X,Y,0}
+   Xabc -> {X,0,0}
+   'server_version_split' is then used for lookups to find if the server which
+   created this event has some known bug.
+*/
+void Format_description_log_event::calc_server_version_split()
+{
+  char *p= server_version, *r;
+  ulong number;
+  for (uint i= 0; i<=2; i++)
+  {
+    number= strtoul(p, &r, 10);
+    server_version_split[i]= (uchar)number;
+    DBUG_ASSERT(number < 256); // fit in uchar
+    p= r;
+    DBUG_ASSERT(!((i == 0) && (*r != '.'))); // should be true in practice
+    if (*r == '.')
+      p++; // skip the dot
+  }
+  DBUG_PRINT("info",("Format_description_log_event::server_version_split:"
+                     " '%s' %d %d %d", server_version,
+                     server_version_split[0],
+                     server_version_split[1], server_version_split[2]));
+}
+
+
   /**************************************************************************
         Load_log_event methods
    General note about Load_log_event: the binlogging of LOAD DATA INFILE is
diff --git a/sql/log_event.h b/sql/log_event.h
index fd2a5e5fb63..d3ebe6860f5 100644
--- a/sql/log_event.h
+++ b/sql/log_event.h
@@ -1102,6 +1102,7 @@ public:
   uint8 number_of_event_types;
   /* The list of post-headers' lengthes */
   uint8 *post_header_len;
+  uchar server_version_split[3];
 
   Format_description_log_event(uint8 binlog_ver, const char* server_ver=0);
 
@@ -1133,6 +1134,7 @@ public:
     */
     return FORMAT_DESCRIPTION_HEADER_LEN;
   }
+  void calc_server_version_split();
 };
 
 
diff --git a/sql/slave.cc b/sql/slave.cc
index 8805f950d50..37c782a42c3 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -5165,6 +5165,70 @@ end:
 }
 
 
+/**
+   Detects, based on master's version (as found in the relay log), if master
+   has a certain bug.
+   @param rli RELAY_LOG_INFO which tells the master's version
+   @param bug_id Number of the bug as found in bugs.mysql.com
+   @return TRUE if master has the bug, FALSE if it does not.
+*/
+bool rpl_master_has_bug(RELAY_LOG_INFO *rli, uint bug_id)
+{
+  struct st_version_range_for_one_bug {
+    uint        bug_id;
+    const uchar introduced_in[3]; // first version with bug
+    const uchar fixed_in[3];      // first version with fix
+  };
+  static struct st_version_range_for_one_bug versions_for_all_bugs[]=
+  {
+    {24432, { 5, 0, 24 }, { 5, 0, 36 } },
+    {24432, { 5, 1, 12 }, { 5, 1, 16 } }
+  };
+  const uchar *master_ver=
+    rli->relay_log.description_event_for_exec->server_version_split;
+
+  DBUG_ASSERT(sizeof(rli->relay_log.description_event_for_exec->server_version_split) == 3);
+
+  for (uint i= 0;
+       i < sizeof(versions_for_all_bugs)/sizeof(*versions_for_all_bugs);i++)
+  {
+    const uchar *introduced_in= versions_for_all_bugs[i].introduced_in,
+      *fixed_in= versions_for_all_bugs[i].fixed_in;
+    if ((versions_for_all_bugs[i].bug_id == bug_id) &&
+        (memcmp(introduced_in, master_ver, 3) <= 0) &&
+        (memcmp(fixed_in,      master_ver, 3) >  0))
+    {
+      // a verbose message for the error log
+      slave_print_error(rli, ER_UNKNOWN_ERROR,
+                        "According to the master's version ('%s'),"
+                        " it is probable that master suffers from this bug:"
+                        " http://bugs.mysql.com/bug.php?id=%u"
+                        " and thus replicating the current binary log event"
+                        " may make the slave's data become different from the"
+                        " master's data."
+                        " To take no risk, slave refuses to replicate"
+                        " this event and stops."
+                        " We recommend that all updates be stopped on the"
+                        " master and slave, that the data of both be"
+                        " manually synchronized,"
+                        " that master's binary logs be deleted,"
+                        " that master be upgraded to a version at least"
+                        " equal to '%d.%d.%d'. Then replication can be"
+                        " restarted.",
+                        rli->relay_log.description_event_for_exec->server_version,
+                        bug_id,
+                        fixed_in[0], fixed_in[1], fixed_in[2]);
+      // a short message for SHOW SLAVE STATUS (message length constraints)
+      my_printf_error(ER_UNKNOWN_ERROR, "master may suffer from"
+                      " http://bugs.mysql.com/bug.php?id=%u"
+                      " so slave stops; check error log on slave"
+                      " for more info", MYF(0), bug_id);
+      return TRUE;
+    }
+  }
+  return FALSE;
+}
+
 #ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 template class I_List_iterator<i_string>;
 template class I_List_iterator<i_string_pair>;
diff --git a/sql/slave.h b/sql/slave.h
index bbf450bab75..e7d4456ccd9 100644
--- a/sql/slave.h
+++ b/sql/slave.h
@@ -533,6 +533,7 @@ void table_rule_ent_hash_to_str(String* s, HASH* h);
 void table_rule_ent_dynamic_array_to_str(String* s, DYNAMIC_ARRAY* a);
 bool show_master_info(THD* thd, MASTER_INFO* mi);
 bool show_binlog_info(THD* thd);
+bool rpl_master_has_bug(RELAY_LOG_INFO *rli, uint bug_id);
 
 /* See if the query uses any tables that should not be replicated */
 bool tables_ok(THD* thd, TABLE_LIST* tables);
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index c60d3c307d0..c5f1524c556 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -58,6 +58,7 @@
 #include "sp_head.h"
 #include "sql_trigger.h"
 #include "sql_select.h"
+#include "slave.h"
 
 static int check_null_fields(THD *thd,TABLE *entry);
 #ifndef EMBEDDED_LIBRARY
@@ -468,6 +469,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;
   id=0;
   thd->proc_info="update";
@@ -1133,11 +1142,11 @@ int write_record(THD *thd, TABLE *table,COPY_INFO *info)
         if (res == VIEW_CHECK_ERROR)
           goto before_trg_err;
 
+        table->file->restore_auto_increment();
         if ((error=table->file->update_row(table->record[1],table->record[0])))
 	{
 	  if ((error == HA_ERR_FOUND_DUPP_KEY) && info->ignore)
           {
-            table->file->restore_auto_increment();
             goto ok_or_after_trg_err;
           }
           goto err;
@@ -2369,6 +2378,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);
-- 
cgit v1.2.1


From 8b1609a63717227b8931bb3a7fdaf45a43b831c7 Mon Sep 17 00:00:00 2001
From: "guilhem@gbichot3.local" <>
Date: Thu, 15 Feb 2007 15:39:03 +0100
Subject: Fix for 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: if (statement-based) binlogging is on, a multi-row
 INSERT DELAYED is silently converted to a non-delayed INSERT. Note: it is not
 possible to test BUG#25507 in 5.0 (requires mysqlslap), so it is tested only
 in the changeset for 5.1. However, BUG#26116 is tested here, and the fix for
 BUG#25507 is the same code change.

---
 mysql-test/r/innodb-replace.result     |  4 +-
 mysql-test/r/rpl_insert_delayed.result | 31 ++++++++++++++++
 mysql-test/t/innodb-replace.test       |  4 +-
 mysql-test/t/rpl_insert_delayed.test   | 67 ++++++++++++++++++++++++++++++++++
 sql/sql_insert.cc                      | 21 +++++++++++
 5 files changed, 123 insertions(+), 4 deletions(-)
 create mode 100644 mysql-test/r/rpl_insert_delayed.result
 create mode 100644 mysql-test/t/rpl_insert_delayed.test

diff --git a/mysql-test/r/innodb-replace.result b/mysql-test/r/innodb-replace.result
index b7edcc49e56..77e0aeb38fd 100644
--- a/mysql-test/r/innodb-replace.result
+++ b/mysql-test/r/innodb-replace.result
@@ -2,11 +2,11 @@ drop table if exists t1;
 create table t1 (c1 char(5) unique not null, c2 int, stamp timestamp) engine=innodb;
 select * from t1;
 c1	c2	stamp
-replace delayed into t1 (c1, c2)  values ( "text1","11"),( "text2","12");
+replace delayed into t1 (c1, c2)  values ( "text1","11");
 ERROR HY000: Table storage engine for 't1' doesn't have this option
 select * from t1;
 c1	c2	stamp
-replace delayed into t1 (c1, c2)  values ( "text1","12"),( "text2","13"),( "text3","14", "a" ),( "text4","15", "b" );
+replace delayed into t1 (c1, c2)  values ( "text1","12");
 ERROR HY000: Table storage engine for 't1' doesn't have this option
 select * from t1;
 c1	c2	stamp
diff --git a/mysql-test/r/rpl_insert_delayed.result b/mysql-test/r/rpl_insert_delayed.result
new file mode 100644
index 00000000000..38e2cddd650
--- /dev/null
+++ b/mysql-test/r/rpl_insert_delayed.result
@@ -0,0 +1,31 @@
+stop slave;
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+reset master;
+reset slave;
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+start slave;
+CREATE TABLE t1 (id INT primary key auto_increment, name VARCHAR(64));
+truncate table t1;
+insert delayed into t1 values(10, "my name");
+insert delayed into t1 values(10, "is Bond"), (20, "James Bond");
+ERROR 23000: Duplicate entry '10' for key 1
+flush table t1;
+select * from t1;
+id	name
+10	my name
+select * from t1;
+id	name
+10	my name
+delete from t1 where id!=10;
+insert delayed into t1 values(20, "is Bond"), (10, "James Bond");
+ERROR 23000: Duplicate entry '10' for key 1
+flush table t1;
+select * from t1;
+id	name
+10	my name
+20	is Bond
+select * from t1;
+id	name
+10	my name
+20	is Bond
+drop table t1;
diff --git a/mysql-test/t/innodb-replace.test b/mysql-test/t/innodb-replace.test
index 51b70f34b65..d44ede65ce8 100644
--- a/mysql-test/t/innodb-replace.test
+++ b/mysql-test/t/innodb-replace.test
@@ -12,10 +12,10 @@ drop table if exists t1;
 create table t1 (c1 char(5) unique not null, c2 int, stamp timestamp) engine=innodb;
 select * from t1;
 --error 1031
-replace delayed into t1 (c1, c2)  values ( "text1","11"),( "text2","12");
+replace delayed into t1 (c1, c2)  values ( "text1","11");
 select * from t1;
 --error 1031
-replace delayed into t1 (c1, c2)  values ( "text1","12"),( "text2","13"),( "text3","14", "a" ),( "text4","15", "b" );
+replace delayed into t1 (c1, c2)  values ( "text1","12");
 select * from t1;
 drop table t1;
 
diff --git a/mysql-test/t/rpl_insert_delayed.test b/mysql-test/t/rpl_insert_delayed.test
new file mode 100644
index 00000000000..3f72f3a3625
--- /dev/null
+++ b/mysql-test/t/rpl_insert_delayed.test
@@ -0,0 +1,67 @@
+--source include/master-slave.inc
+--source include/not_embedded.inc
+--source include/not_windows.inc
+
+connection master;
+
+let $binlog_format_statement=1;
+
+CREATE TABLE t1 (id INT primary key auto_increment, name VARCHAR(64));
+
+sync_slave_with_master;
+
+#
+# BUG#26116 "If multi-row INSERT DELAYED has errors,
+# statement-based binlogging breaks";
+# happened only in statement-based binlogging.
+#
+
+connection master;
+truncate table t1;
+# first scenario: duplicate on first row
+insert delayed into t1 values(10, "my name");
+if ($binlog_format_statement)
+{
+  # statement below will be converted to non-delayed INSERT and so
+  # will stop at first error, guaranteeing replication.
+  --error ER_DUP_ENTRY
+  insert delayed into t1 values(10, "is Bond"), (20, "James Bond");
+}
+if (!$binlog_format_statement)
+{
+  insert delayed into t1 values(10, "is Bond"), (20, "James Bond");
+}
+flush table t1; # to wait for INSERT DELAYED to be done
+select * from t1;
+sync_slave_with_master;
+# when bug existed in statement-based binlogging, t1 on slave had
+# different content from on master
+select * from t1;
+
+# second scenario: duplicate on second row
+connection master;
+delete from t1 where id!=10;
+if ($binlog_format_statement)
+{
+  # statement below will be converted to non-delayed INSERT and so
+  # will be binlogged with its ER_DUP_ENTRY error code, guaranteeing
+  # replication (slave will hit the same error code and so be fine).
+  --error ER_DUP_ENTRY
+  insert delayed into t1 values(20, "is Bond"), (10, "James Bond");
+}
+if (!$binlog_format_statement)
+{
+  insert delayed into t1 values(20, "is Bond"), (10, "James Bond");
+}
+flush table t1; # to wait for INSERT DELAYED to be done
+select * from t1;
+sync_slave_with_master;
+# when bug existed in statement-based binlogging, query was binlogged
+# with error_code=0 so slave stopped
+select * from t1;
+
+# clean up
+connection master;
+drop table t1;
+sync_slave_with_master;
+connection master;
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index c5f1524c556..f0708ee548a 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -356,6 +356,27 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
       (duplic == DUP_UPDATE))
     lock_type=TL_WRITE;
 #endif
+  if ((lock_type == TL_WRITE_DELAYED) &&
+      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.
+    */
+    lock_type= TL_WRITE;
+  }
   table_list->lock_type= lock_type;
 
 #ifndef EMBEDDED_LIBRARY
-- 
cgit v1.2.1


From 2f75c9cd69412de5d3736e775dd302ebdbc1e36d Mon Sep 17 00:00:00 2001
From: "guilhem@gbichot3.local" <>
Date: Thu, 15 Feb 2007 15:50:56 +0100
Subject: Backport from the Falcon tree. When opening/creating the transaction
 coordinator's log, if binlog is used, the tc log is the binlog so we use the
 binlog's name; otherwise we use the mmap-based log, named after the mandatory
 argument of the --log-tc option (meant for that).

---
 sql/log.cc    | 2 +-
 sql/mysqld.cc | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/sql/log.cc b/sql/log.cc
index 1961a5b6f88..aef8e2eff2c 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -2523,7 +2523,7 @@ int TC_LOG_MMAP::open(const char *opt_name)
       goto err;
     if (using_heuristic_recover())
       return 1;
-    if ((fd= my_create(logname, O_RDWR, 0, MYF(MY_WME))) < 0)
+    if ((fd= my_create(logname, CREATE_MODE, O_RDWR, MYF(MY_WME))) < 0)
       goto err;
     inited=1;
     file_length= opt_tc_log_size;
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index d4f9791dade..672f585e721 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -3171,7 +3171,7 @@ server.");
                                (TC_LOG *) &tc_log_mmap) :
            (TC_LOG *) &tc_log_dummy);
 
-  if (tc_log->open(opt_bin_logname))
+  if (tc_log->open(opt_bin_log ? opt_bin_logname : opt_tc_log_file))
   {
     sql_print_error("Can't init tc log");
     unireg_abort(1);
-- 
cgit v1.2.1


From 39de08fddc0abfc86965d754671014c4482ab759 Mon Sep 17 00:00:00 2001
From: "guilhem@gbichot3.local" <>
Date: Thu, 15 Feb 2007 20:28:58 +0100
Subject: 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.

---
 mysql-test/extra/rpl_tests/rpl_insert_delayed.test | 86 +++++++++++++++++++++
 mysql-test/extra/rpl_tests/rpl_insert_id.test      | 55 +++++++++++++-
 mysql-test/r/rpl_insert_delayed.result             | 31 --------
 mysql-test/r/rpl_insert_id.result                  |  2 +-
 mysql-test/r/rpl_known_bugs_detection.result       |  4 +-
 mysql-test/r/rpl_row_insert_delayed.result         | 48 ++++++++++++
 mysql-test/r/rpl_stm_insert_delayed.result         | 88 ++++++++++++++++++++++
 mysql-test/t/disabled.def                          |  1 +
 mysql-test/t/rpl_insert_delayed.test               | 67 ----------------
 mysql-test/t/rpl_known_bugs_detection.test         |  3 +
 mysql-test/t/rpl_row_insert_delayed.test           | 14 ++++
 mysql-test/t/rpl_stm_insert_delayed.test           | 20 +++++
 sql/slave.cc                                       | 40 +++++-----
 sql/sql_insert.cc                                  | 50 +++++++++++-
 14 files changed, 386 insertions(+), 123 deletions(-)
 create mode 100644 mysql-test/extra/rpl_tests/rpl_insert_delayed.test
 delete mode 100644 mysql-test/r/rpl_insert_delayed.result
 create mode 100644 mysql-test/r/rpl_row_insert_delayed.result
 create mode 100644 mysql-test/r/rpl_stm_insert_delayed.result
 delete mode 100644 mysql-test/t/rpl_insert_delayed.test
 create mode 100644 mysql-test/t/rpl_row_insert_delayed.test
 create mode 100644 mysql-test/t/rpl_stm_insert_delayed.test

diff --git a/mysql-test/extra/rpl_tests/rpl_insert_delayed.test b/mysql-test/extra/rpl_tests/rpl_insert_delayed.test
new file mode 100644
index 00000000000..11856953959
--- /dev/null
+++ b/mysql-test/extra/rpl_tests/rpl_insert_delayed.test
@@ -0,0 +1,86 @@
+# The two bugs below (BUG#25507 and BUG#26116) existed only in
+# statement-based binlogging; we test that now they are fixed;
+# we also test that mixed and row-based binlogging work too,
+# for completeness.
+
+connection master;
+--disable_warnings
+CREATE SCHEMA IF NOT EXISTS mysqlslap;
+USE mysqlslap;
+--enable_warnings
+
+select @@global.binlog_format;
+
+#
+# BUG#25507 "multi-row insert delayed + auto increment causes
+# duplicate key entries on slave";
+# happened only in statement-based binlogging.
+#
+
+CREATE TABLE t1 (id INT primary key auto_increment, name VARCHAR(64));
+let $query = "INSERT DELAYED INTO t1 VALUES (null, 'Dr. No'), (null, 'From Russia With Love'), (null, 'Goldfinger'), (null, 'Thunderball'), (null, 'You Only Live Twice')";
+--exec $MYSQL_SLAP --silent --concurrency=5 --iterations=200 --query=$query --delimiter=";"
+
+FLUSH TABLE t1; # another way to be sure INSERT DELAYED has inserted
+SELECT COUNT(*) FROM t1;
+# when bug existed slave failed below ("duplicate key" error at random INSERT)
+sync_slave_with_master;
+use mysqlslap;
+SELECT COUNT(*) FROM t1;
+
+#
+# BUG#26116 "If multi-row INSERT DELAYED has errors,
+# statement-based binlogging breaks";
+# happened only in statement-based binlogging.
+#
+
+connection master;
+truncate table t1;
+# first scenario: duplicate on first row
+insert delayed into t1 values(10, "my name");
+if ($binlog_format_statement)
+{
+  # statement below will be converted to non-delayed INSERT and so
+  # will stop at first error, guaranteeing replication.
+  --error ER_DUP_ENTRY
+  insert delayed into t1 values(10, "is Bond"), (20, "James Bond");
+}
+if (!$binlog_format_statement)
+{
+  insert delayed into t1 values(10, "is Bond"), (20, "James Bond");
+}
+flush table t1; # to wait for INSERT DELAYED to be done
+select * from t1;
+sync_slave_with_master;
+# when bug existed in statement-based binlogging, t1 on slave had
+# different content from on master
+select * from t1;
+
+# second scenario: duplicate on second row
+connection master;
+delete from t1 where id!=10;
+if ($binlog_format_statement)
+{
+  # statement below will be converted to non-delayed INSERT and so
+  # will be binlogged with its ER_DUP_ENTRY error code, guaranteeing
+  # replication (slave will hit the same error code and so be fine).
+  --error ER_DUP_ENTRY
+  insert delayed into t1 values(20, "is Bond"), (10, "James Bond");
+}
+if (!$binlog_format_statement)
+{
+  insert delayed into t1 values(20, "is Bond"), (10, "James Bond");
+}
+flush table t1; # to wait for INSERT DELAYED to be done
+select * from t1;
+sync_slave_with_master;
+# when bug existed in statement-based binlogging, query was binlogged
+# with error_code=0 so slave stopped
+select * from t1;
+
+# clean up
+connection master;
+USE test;
+DROP SCHEMA mysqlslap;
+sync_slave_with_master;
+connection master;
diff --git a/mysql-test/extra/rpl_tests/rpl_insert_id.test b/mysql-test/extra/rpl_tests/rpl_insert_id.test
index 33194270d37..428de5f8b47 100644
--- a/mysql-test/extra/rpl_tests/rpl_insert_id.test
+++ b/mysql-test/extra/rpl_tests/rpl_insert_id.test
@@ -209,7 +209,7 @@ connection master;
 
 drop function bug15728;
 drop function bug15728_insert;
-drop table t1;
+drop table t1,t2;
 drop procedure foo;
 
 # test of BUG#20188 REPLACE or ON DUPLICATE KEY UPDATE in
@@ -276,6 +276,59 @@ connection master;
 drop table t1;
 sync_slave_with_master;
 
+#
+# BUG#24432 "INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values"
+#
+
+connection master;
+# testcase with INSERT VALUES
+CREATE TABLE t1 (a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b INT,
+UNIQUE(b));
+INSERT INTO t1(b) VALUES(1),(1),(2) ON DUPLICATE KEY UPDATE t1.b=10;
+SELECT * FROM t1;
+sync_slave_with_master;
+SELECT * FROM t1;
+connection master;
+drop table t1;
+
+# tescase with INSERT SELECT
+CREATE TABLE t1 (
+  id bigint(20) unsigned NOT NULL auto_increment,
+  field_1 int(10) unsigned NOT NULL,
+  field_2 varchar(255) NOT NULL,
+  field_3 varchar(255) NOT NULL,
+  PRIMARY KEY (id),
+  UNIQUE KEY field_1 (field_1, field_2)
+);
+CREATE TABLE t2 (
+  field_a int(10) unsigned NOT NULL,
+  field_b varchar(255) NOT NULL,
+  field_c varchar(255) NOT NULL
+);
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (1, 'a', '1a');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (2, 'b', '2b');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (3, 'c', '3c');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (4, 'd', '4d');
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (5, 'e', '5e');
+# Updating table t1 based on values from table t2
+INSERT INTO t1 (field_1, field_2, field_3)
+SELECT t2.field_a, t2.field_b, t2.field_c
+FROM t2
+ON DUPLICATE KEY UPDATE
+t1.field_3 = t2.field_c;
+# Inserting new record into t2
+INSERT INTO t2 (field_a, field_b, field_c) VALUES (6, 'f', '6f');
+# Updating t1 again
+INSERT INTO t1 (field_1, field_2, field_3)
+SELECT t2.field_a, t2.field_b, t2.field_c
+FROM t2
+ON DUPLICATE KEY UPDATE
+t1.field_3 = t2.field_c;
+SELECT * FROM t1;
+sync_slave_with_master;
+SELECT * FROM t1;
+connection master;
+drop table t1, t2;
 
 #
 # BUG#20339: stored procedure using LAST_INSERT_ID() does not
diff --git a/mysql-test/r/rpl_insert_delayed.result b/mysql-test/r/rpl_insert_delayed.result
deleted file mode 100644
index 38e2cddd650..00000000000
--- a/mysql-test/r/rpl_insert_delayed.result
+++ /dev/null
@@ -1,31 +0,0 @@
-stop slave;
-drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
-reset master;
-reset slave;
-drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
-start slave;
-CREATE TABLE t1 (id INT primary key auto_increment, name VARCHAR(64));
-truncate table t1;
-insert delayed into t1 values(10, "my name");
-insert delayed into t1 values(10, "is Bond"), (20, "James Bond");
-ERROR 23000: Duplicate entry '10' for key 1
-flush table t1;
-select * from t1;
-id	name
-10	my name
-select * from t1;
-id	name
-10	my name
-delete from t1 where id!=10;
-insert delayed into t1 values(20, "is Bond"), (10, "James Bond");
-ERROR 23000: Duplicate entry '10' for key 1
-flush table t1;
-select * from t1;
-id	name
-10	my name
-20	is Bond
-select * from t1;
-id	name
-10	my name
-20	is Bond
-drop table t1;
diff --git a/mysql-test/r/rpl_insert_id.result b/mysql-test/r/rpl_insert_id.result
index a88864b59c4..b0c1b6cfd73 100644
--- a/mysql-test/r/rpl_insert_id.result
+++ b/mysql-test/r/rpl_insert_id.result
@@ -196,7 +196,7 @@ id	last_id
 3	5
 drop function bug15728;
 drop function bug15728_insert;
-drop table t1;
+drop table t1,t2;
 drop procedure foo;
 create table t1 (n int primary key auto_increment not null,
 b int, unique(b));
diff --git a/mysql-test/r/rpl_known_bugs_detection.result b/mysql-test/r/rpl_known_bugs_detection.result
index c23586c6f61..eabc6185780 100644
--- a/mysql-test/r/rpl_known_bugs_detection.result
+++ b/mysql-test/r/rpl_known_bugs_detection.result
@@ -33,7 +33,7 @@ Replicate_Wild_Ignore_Table
 Last_Errno	1105
 Last_Error	Error 'master may suffer from http://bugs.mysql.com/bug.php?id=24432 so slave stops; check error log on slave for more info' on query. Default database: 'test'. Query: 'INSERT INTO t1(b) VALUES(1),(1),(2) ON DUPLICATE KEY UPDATE t1.b=10'
 Skip_Counter	0
-Exec_Master_Log_Pos	238
+Exec_Master_Log_Pos	242
 Relay_Log_Space	#
 Until_Condition	None
 Until_Log_File	
@@ -115,7 +115,7 @@ FROM t2
 ON DUPLICATE KEY UPDATE
 t1.field_3 = t2.field_c'
 Skip_Counter	0
-Exec_Master_Log_Pos	1270
+Exec_Master_Log_Pos	1274
 Relay_Log_Space	#
 Until_Condition	None
 Until_Log_File	
diff --git a/mysql-test/r/rpl_row_insert_delayed.result b/mysql-test/r/rpl_row_insert_delayed.result
new file mode 100644
index 00000000000..2044672f49d
--- /dev/null
+++ b/mysql-test/r/rpl_row_insert_delayed.result
@@ -0,0 +1,48 @@
+stop slave;
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+reset master;
+reset slave;
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+start slave;
+set @old_global_binlog_format = @@global.binlog_format;
+set @@global.binlog_format = row;
+CREATE SCHEMA IF NOT EXISTS mysqlslap;
+USE mysqlslap;
+select @@global.binlog_format;
+@@global.binlog_format
+ROW
+CREATE TABLE t1 (id INT primary key auto_increment, name VARCHAR(64));
+FLUSH TABLE t1;
+SELECT COUNT(*) FROM t1;
+COUNT(*)
+5000
+use mysqlslap;
+SELECT COUNT(*) FROM t1;
+COUNT(*)
+5000
+truncate table t1;
+insert delayed into t1 values(10, "my name");
+insert delayed into t1 values(10, "is Bond"), (20, "James Bond");
+flush table t1;
+select * from t1;
+id	name
+10	my name
+20	James Bond
+select * from t1;
+id	name
+10	my name
+20	James Bond
+delete from t1 where id!=10;
+insert delayed into t1 values(20, "is Bond"), (10, "James Bond");
+flush table t1;
+select * from t1;
+id	name
+10	my name
+20	is Bond
+select * from t1;
+id	name
+10	my name
+20	is Bond
+USE test;
+DROP SCHEMA mysqlslap;
+set @@global.binlog_format = @old_global_binlog_format;
diff --git a/mysql-test/r/rpl_stm_insert_delayed.result b/mysql-test/r/rpl_stm_insert_delayed.result
new file mode 100644
index 00000000000..1c003856eb9
--- /dev/null
+++ b/mysql-test/r/rpl_stm_insert_delayed.result
@@ -0,0 +1,88 @@
+stop slave;
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+reset master;
+reset slave;
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+start slave;
+set @old_global_binlog_format = @@global.binlog_format;
+set @@global.binlog_format = statement;
+CREATE SCHEMA IF NOT EXISTS mysqlslap;
+USE mysqlslap;
+select @@global.binlog_format;
+@@global.binlog_format
+STATEMENT
+CREATE TABLE t1 (id INT primary key auto_increment, name VARCHAR(64));
+FLUSH TABLE t1;
+SELECT COUNT(*) FROM t1;
+COUNT(*)
+5000
+use mysqlslap;
+SELECT COUNT(*) FROM t1;
+COUNT(*)
+5000
+truncate table t1;
+insert delayed into t1 values(10, "my name");
+insert delayed into t1 values(10, "is Bond"), (20, "James Bond");
+ERROR 23000: Duplicate entry '10' for key 'PRIMARY'
+flush table t1;
+select * from t1;
+id	name
+10	my name
+select * from t1;
+id	name
+10	my name
+delete from t1 where id!=10;
+insert delayed into t1 values(20, "is Bond"), (10, "James Bond");
+ERROR 23000: Duplicate entry '10' for key 'PRIMARY'
+flush table t1;
+select * from t1;
+id	name
+10	my name
+20	is Bond
+select * from t1;
+id	name
+10	my name
+20	is Bond
+USE test;
+DROP SCHEMA mysqlslap;
+set @@global.binlog_format = mixed;
+CREATE SCHEMA IF NOT EXISTS mysqlslap;
+USE mysqlslap;
+select @@global.binlog_format;
+@@global.binlog_format
+MIXED
+CREATE TABLE t1 (id INT primary key auto_increment, name VARCHAR(64));
+FLUSH TABLE t1;
+SELECT COUNT(*) FROM t1;
+COUNT(*)
+5000
+use mysqlslap;
+SELECT COUNT(*) FROM t1;
+COUNT(*)
+5000
+truncate table t1;
+insert delayed into t1 values(10, "my name");
+insert delayed into t1 values(10, "is Bond"), (20, "James Bond");
+flush table t1;
+select * from t1;
+id	name
+10	my name
+20	James Bond
+select * from t1;
+id	name
+10	my name
+20	James Bond
+delete from t1 where id!=10;
+insert delayed into t1 values(20, "is Bond"), (10, "James Bond");
+flush table t1;
+select * from t1;
+id	name
+10	my name
+20	is Bond
+select * from t1;
+id	name
+10	my name
+20	is Bond
+USE test;
+DROP SCHEMA mysqlslap;
+set @@global.binlog_format = @old_global_binlog_format;
diff --git a/mysql-test/t/disabled.def b/mysql-test/t/disabled.def
index ce7bb345aad..08448a6bb30 100644
--- a/mysql-test/t/disabled.def
+++ b/mysql-test/t/disabled.def
@@ -38,4 +38,5 @@ synchronization          : Bug#24529  	Test 'synchronization' fails on Mac pushb
 
 flush2                   : Bug#24805 Pushbuild can't handle test with --disable-log-bin
 mysql_upgrade            : Bug#25074 mysql_upgrade gives inconsisten results
+rpl_insert_id            : Guilhem will enable as soon as replication team tree has merged with main tree and so got version number 5.1.16
 
diff --git a/mysql-test/t/rpl_insert_delayed.test b/mysql-test/t/rpl_insert_delayed.test
deleted file mode 100644
index 3f72f3a3625..00000000000
--- a/mysql-test/t/rpl_insert_delayed.test
+++ /dev/null
@@ -1,67 +0,0 @@
---source include/master-slave.inc
---source include/not_embedded.inc
---source include/not_windows.inc
-
-connection master;
-
-let $binlog_format_statement=1;
-
-CREATE TABLE t1 (id INT primary key auto_increment, name VARCHAR(64));
-
-sync_slave_with_master;
-
-#
-# BUG#26116 "If multi-row INSERT DELAYED has errors,
-# statement-based binlogging breaks";
-# happened only in statement-based binlogging.
-#
-
-connection master;
-truncate table t1;
-# first scenario: duplicate on first row
-insert delayed into t1 values(10, "my name");
-if ($binlog_format_statement)
-{
-  # statement below will be converted to non-delayed INSERT and so
-  # will stop at first error, guaranteeing replication.
-  --error ER_DUP_ENTRY
-  insert delayed into t1 values(10, "is Bond"), (20, "James Bond");
-}
-if (!$binlog_format_statement)
-{
-  insert delayed into t1 values(10, "is Bond"), (20, "James Bond");
-}
-flush table t1; # to wait for INSERT DELAYED to be done
-select * from t1;
-sync_slave_with_master;
-# when bug existed in statement-based binlogging, t1 on slave had
-# different content from on master
-select * from t1;
-
-# second scenario: duplicate on second row
-connection master;
-delete from t1 where id!=10;
-if ($binlog_format_statement)
-{
-  # statement below will be converted to non-delayed INSERT and so
-  # will be binlogged with its ER_DUP_ENTRY error code, guaranteeing
-  # replication (slave will hit the same error code and so be fine).
-  --error ER_DUP_ENTRY
-  insert delayed into t1 values(20, "is Bond"), (10, "James Bond");
-}
-if (!$binlog_format_statement)
-{
-  insert delayed into t1 values(20, "is Bond"), (10, "James Bond");
-}
-flush table t1; # to wait for INSERT DELAYED to be done
-select * from t1;
-sync_slave_with_master;
-# when bug existed in statement-based binlogging, query was binlogged
-# with error_code=0 so slave stopped
-select * from t1;
-
-# clean up
-connection master;
-drop table t1;
-sync_slave_with_master;
-connection master;
diff --git a/mysql-test/t/rpl_known_bugs_detection.test b/mysql-test/t/rpl_known_bugs_detection.test
index 4719716d4a1..ce3debf3c5b 100644
--- a/mysql-test/t/rpl_known_bugs_detection.test
+++ b/mysql-test/t/rpl_known_bugs_detection.test
@@ -6,6 +6,9 @@
 source include/have_debug.inc;
 source include/master-slave.inc;
 
+# Currently only statement-based-specific bugs are here
+-- source include/have_binlog_format_mixed_or_statement.inc
+
 #
 # This is to test that slave properly detects if
 # master may suffer from:
diff --git a/mysql-test/t/rpl_row_insert_delayed.test b/mysql-test/t/rpl_row_insert_delayed.test
new file mode 100644
index 00000000000..9aeb57c4fa2
--- /dev/null
+++ b/mysql-test/t/rpl_row_insert_delayed.test
@@ -0,0 +1,14 @@
+--source include/have_binlog_format_row.inc
+--source include/master-slave.inc
+--source include/not_embedded.inc
+--source include/not_windows.inc
+
+connection master;
+set @old_global_binlog_format = @@global.binlog_format;
+
+let $binlog_format_statement=0;
+set @@global.binlog_format = row;
+--source extra/rpl_tests/rpl_insert_delayed.test
+
+connection master;
+set @@global.binlog_format = @old_global_binlog_format;
diff --git a/mysql-test/t/rpl_stm_insert_delayed.test b/mysql-test/t/rpl_stm_insert_delayed.test
new file mode 100644
index 00000000000..d55e3a4da2c
--- /dev/null
+++ b/mysql-test/t/rpl_stm_insert_delayed.test
@@ -0,0 +1,20 @@
+# we run first in statement-based then in mixed binlogging
+
+--source include/have_binlog_format_mixed_or_statement.inc
+--source include/master-slave.inc
+--source include/not_embedded.inc
+--source include/not_windows.inc
+
+connection master;
+set @old_global_binlog_format = @@global.binlog_format;
+
+let $binlog_format_statement=1;
+set @@global.binlog_format = statement;
+--source extra/rpl_tests/rpl_insert_delayed.test
+
+let $binlog_format_statement=0;
+set @@global.binlog_format = mixed;
+--source extra/rpl_tests/rpl_insert_delayed.test
+
+connection master;
+set @@global.binlog_format = @old_global_binlog_format;
diff --git a/sql/slave.cc b/sql/slave.cc
index 022647afcee..e51fca39fd8 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -3684,31 +3684,31 @@ bool rpl_master_has_bug(RELAY_LOG_INFO *rli, uint bug_id)
         (memcmp(introduced_in, master_ver, 3) <= 0) &&
         (memcmp(fixed_in,      master_ver, 3) >  0))
     {
-      // a verbose message for the error log
-      slave_print_error(rli, ER_UNKNOWN_ERROR,
-                        "According to the master's version ('%s'),"
-                        " it is probable that master suffers from this bug:"
-                        " http://bugs.mysql.com/bug.php?id=%u"
-                        " and thus replicating the current binary log event"
-                        " may make the slave's data become different from the"
-                        " master's data."
-                        " To take no risk, slave refuses to replicate"
-                        " this event and stops."
-                        " We recommend that all updates be stopped on the"
-                        " master and slave, that the data of both be"
-                        " manually synchronized,"
-                        " that master's binary logs be deleted,"
-                        " that master be upgraded to a version at least"
-                        " equal to '%d.%d.%d'. Then replication can be"
-                        " restarted.",
-                        rli->relay_log.description_event_for_exec->server_version,
-                        bug_id,
-                        fixed_in[0], fixed_in[1], fixed_in[2]);
       // a short message for SHOW SLAVE STATUS (message length constraints)
       my_printf_error(ER_UNKNOWN_ERROR, "master may suffer from"
                       " http://bugs.mysql.com/bug.php?id=%u"
                       " so slave stops; check error log on slave"
                       " for more info", MYF(0), bug_id);
+      // a verbose message for the error log
+      slave_print_msg(ERROR_LEVEL, rli, ER_UNKNOWN_ERROR,
+                      "According to the master's version ('%s'),"
+                      " it is probable that master suffers from this bug:"
+                      " http://bugs.mysql.com/bug.php?id=%u"
+                      " and thus replicating the current binary log event"
+                      " may make the slave's data become different from the"
+                      " master's data."
+                      " To take no risk, slave refuses to replicate"
+                      " this event and stops."
+                      " We recommend that all updates be stopped on the"
+                      " master and slave, that the data of both be"
+                      " manually synchronized,"
+                      " that master's binary logs be deleted,"
+                      " that master be upgraded to a version at least"
+                      " equal to '%d.%d.%d'. Then replication can be"
+                      " restarted.",
+                      rli->relay_log.description_event_for_exec->server_version,
+                      bug_id,
+                      fixed_in[0], fixed_in[1], fixed_in[2]);
       return TRUE;
     }
   }
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);
-- 
cgit v1.2.1