database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-30 16:24:05 +03:00
Code Activity

Merge mysql.com:/nfsdisk1/lars/bkroot/mysql-5.0-rpl

Browse Source 
into  mysql.com:/nfsdisk1/lars/MERGE/mysql-5.0-merge
This commit is contained in:
lars/lthalmann@mysql.com/dl145j.mysql.com
2007-02-25 00:10:51 +01:00
parent 8f4fef291d ae99be75a6
commit 1a09fb81fc
21 changed files with 644 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
mysql-test/r/ctype_cp932.result
View File

@ -11353,3 +11353,15 @@ a
a a
a a
drop table t1; 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;

4
mysql-test/r/innodb-replace.result
View File

@ -2,11 +2,11 @@ drop table if exists t1;
create table t1 (c1 char(5) unique not null, c2 int, stamp timestamp) engine=innodb; create table t1 (c1 char(5) unique not null, c2 int, stamp timestamp) engine=innodb;
select * from t1; select * from t1;
c1 c2 stamp 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 ERROR HY000: Table storage engine for 't1' doesn't have this option
select * from t1; select * from t1;
c1 c2 stamp 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 ERROR HY000: Table storage engine for 't1' doesn't have this option
select * from t1; select * from t1;
c1 c2 stamp c1 c2 stamp

31
mysql-test/r/rpl_insert_delayed.result Normal file
View File

@ -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;

58
mysql-test/r/rpl_insert_id.result
View File

@ -234,6 +234,64 @@ n b
2 100 2 100
3 350 3 350
drop table t1; 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 PROCEDURE IF EXISTS p1;
DROP TABLE IF EXISTS t1, t2; DROP TABLE IF EXISTS t1, t2;
SELECT LAST_INSERT_ID(0); SELECT LAST_INSERT_ID(0);

133
mysql-test/r/rpl_known_bugs_detection.result Normal file
View File

@ -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;

11
mysql-test/t/ctype_cp932.test
View File

@ -413,3 +413,14 @@ select * from t1;
insert into t1 values ('abc'); insert into t1 values ('abc');
select * from t1; select * from t1;
drop table 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;

1
mysql-test/t/disabled.def
View File

@ -13,4 +13,3 @@
im_daemon_life_cycle : Bug#24415 see note: [19 Dec 23:17] Trudy Pelzer im_daemon_life_cycle : Bug#24415 see note: [19 Dec 23:17] Trudy Pelzer
ndb_load : Bug#17233 ndb_load : Bug#17233
user_limits : Bug#23921 random failure of user_limits.test user_limits : Bug#23921 random failure of user_limits.test

4
mysql-test/t/innodb-replace.test
View File

@ -12,10 +12,10 @@ drop table if exists t1;
create table t1 (c1 char(5) unique not null, c2 int, stamp timestamp) engine=innodb; create table t1 (c1 char(5) unique not null, c2 int, stamp timestamp) engine=innodb;
select * from t1; select * from t1;
--error 1031 --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; select * from t1;
--error 1031 --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; select * from t1;
drop table t1; drop table t1;

67
mysql-test/t/rpl_insert_delayed.test Normal file
View File

@ -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;

53
mysql-test/t/rpl_insert_id.test
View File

@ -245,6 +245,59 @@ select * from t1 order by n;
connection master; connection master;
drop table t1; 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 # BUG#20339: stored procedure using LAST_INSERT_ID() does not
# replicate statement-based # replicate statement-based

1
mysql-test/t/rpl_known_bugs_detection-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-debug=d,pretend_version_50034_in_binlog

90
mysql-test/t/rpl_known_bugs_detection.test Normal file
View File

@ -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

2
sql/field.cc
View File

@ -7014,7 +7014,7 @@ int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
cannot_convert_error_pos, from + length)) cannot_convert_error_pos, from + length))
return 2; return 2;
if (copy_length < length) if (from_end_pos < from + length)
{ {
report_data_too_long(this); report_data_too_long(this);
return 2; return 2;

2
sql/log.cc
View File

@ -2524,7 +2524,7 @@ int TC_LOG_MMAP::open(const char *opt_name)
goto err; goto err;
if (using_heuristic_recover()) if (using_heuristic_recover())
return 1; 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; goto err;
inited=1; inited=1;
file_length= opt_tc_log_size; file_length= opt_tc_log_size;

37
sql/log_event.cc
View File

@ -2051,6 +2051,8 @@ Start_log_event_v3::Start_log_event_v3(const char* buf,
binlog_version= uint2korr(buf+ST_BINLOG_VER_OFFSET); binlog_version= uint2korr(buf+ST_BINLOG_VER_OFFSET);
memcpy(server_version, buf+ST_SERVER_VER_OFFSET, memcpy(server_version, buf+ST_SERVER_VER_OFFSET,
ST_SERVER_VER_LEN); 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); created= uint4korr(buf+ST_CREATED_OFFSET);
/* We use log_pos to mark if this was an artificial event or not */ /* We use log_pos to mark if this was an artificial event or not */
artificial_event= (log_pos == 0); artificial_event= (log_pos == 0);
@ -2174,6 +2176,8 @@ Format_description_log_event(uint8 binlog_ver, const char* server_ver)
switch (binlog_ver) { switch (binlog_ver) {
case 4: /* MySQL 5.0 */ case 4: /* MySQL 5.0 */
memcpy(server_version, ::server_version, ST_SERVER_VER_LEN); 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; common_header_len= LOG_EVENT_HEADER_LEN;
number_of_event_types= LOG_EVENT_TYPES; number_of_event_types= LOG_EVENT_TYPES;
/* we'll catch my_malloc() error in is_valid() */ /* we'll catch my_malloc() error in is_valid() */
@ -2245,6 +2249,7 @@ Format_description_log_event(uint8 binlog_ver, const char* server_ver)
post_header_len= 0; /* will make is_valid() fail */ post_header_len= 0; /* will make is_valid() fail */
break; break;
} }
calc_server_version_split();
} }
@ -2284,6 +2289,7 @@ Format_description_log_event(const char* buf,
post_header_len= (uint8*) my_memdup((byte*)buf+ST_COMMON_HEADER_LEN_OFFSET+1, post_header_len= (uint8*) my_memdup((byte*)buf+ST_COMMON_HEADER_LEN_OFFSET+1,
number_of_event_types* number_of_event_types*
sizeof(*post_header_len), MYF(0)); sizeof(*post_header_len), MYF(0));
calc_server_version_split();
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -2384,6 +2390,37 @@ int Format_description_log_event::exec_event(struct st_relay_log_info* rli)
} }
#endif #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 Load_log_event methods
General note about Load_log_event: the binlogging of LOAD DATA INFILE is General note about Load_log_event: the binlogging of LOAD DATA INFILE is

2
sql/log_event.h
View File

@ -1104,6 +1104,7 @@ public:
uint8 number_of_event_types; uint8 number_of_event_types;
/* The list of post-headers' lengthes */ /* The list of post-headers' lengthes */
uint8 *post_header_len; uint8 *post_header_len;
uchar server_version_split[3];
Format_description_log_event(uint8 binlog_ver, const char* server_ver=0); Format_description_log_event(uint8 binlog_ver, const char* server_ver=0);
@ -1135,6 +1136,7 @@ public:
*/ */
return FORMAT_DESCRIPTION_HEADER_LEN; return FORMAT_DESCRIPTION_HEADER_LEN;
} }
void calc_server_version_split();
}; };

12
sql/mysql_priv.h
View File

@ -97,6 +97,18 @@ void net_set_read_timeout(NET *net, uint timeout);
#define PREV_BITS(type,A) ((type) (((type) 1 << (A)) -1)) #define PREV_BITS(type,A) ((type) (((type) 1 << (A)) -1))
#define all_bits_set(A,B) ((A) & (B) != (B)) #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 *system_charset_info, *files_charset_info ;
extern CHARSET_INFO *national_charset_info, *table_alias_charset; extern CHARSET_INFO *national_charset_info, *table_alias_charset;

27
sql/mysqld.cc
View File

@ -355,6 +355,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_show_slave_auth_info, opt_sql_bin_update = 0;
my_bool opt_log_slave_updates= 0; my_bool opt_log_slave_updates= 0;
my_bool opt_innodb; my_bool opt_innodb;
bool slave_warning_issued = false;
#ifdef HAVE_NDBCLUSTER_DB #ifdef HAVE_NDBCLUSTER_DB
const char *opt_ndbcluster_connectstring= 0; const char *opt_ndbcluster_connectstring= 0;
const char *opt_ndb_connectstring= 0; const char *opt_ndb_connectstring= 0;
@ -3198,7 +3200,7 @@ server.");
(TC_LOG *) &tc_log_mmap) : (TC_LOG *) &tc_log_mmap) :
(TC_LOG *) &tc_log_dummy); (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"); sql_print_error("Can't init tc log");
unireg_abort(1); unireg_abort(1);
@ -6936,6 +6938,29 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
case (int) OPT_STANDALONE: /* Dummy option for NT */ case (int) OPT_STANDALONE: /* Dummy option for NT */
break; break;
#endif #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: case OPT_CONSOLE:
if (opt_console) if (opt_console)
opt_error_log= 0; // Force logs to stdout opt_error_log= 0; // Force logs to stdout

64
sql/slave.cc
View File

@ -5174,6 +5174,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, 38 } },
{24432, { 5, 1, 12 }, { 5, 1, 17 } }
};
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 #ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
template class I_List_iterator<i_string>; template class I_List_iterator<i_string>;
template class I_List_iterator<i_string_pair>; template class I_List_iterator<i_string_pair>;

1
sql/slave.h
View File

@ -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); void table_rule_ent_dynamic_array_to_str(String* s, DYNAMIC_ARRAY* a);
bool show_master_info(THD* thd, MASTER_INFO* mi); bool show_master_info(THD* thd, MASTER_INFO* mi);
bool show_binlog_info(THD* thd); 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 */ /* See if the query uses any tables that should not be replicated */
bool tables_ok(THD* thd, TABLE_LIST* tables); bool tables_ok(THD* thd, TABLE_LIST* tables);

41
sql/sql_insert.cc
View File

@ -58,6 +58,7 @@
#include "sp_head.h" #include "sp_head.h"
#include "sql_trigger.h" #include "sql_trigger.h"
#include "sql_select.h" #include "sql_select.h"
#include "slave.h"
#ifndef EMBEDDED_LIBRARY #ifndef EMBEDDED_LIBRARY
static TABLE *delayed_get_table(THD *thd,TABLE_LIST *table_list); static TABLE *delayed_get_table(THD *thd,TABLE_LIST *table_list);
@ -405,6 +406,27 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
(duplic == DUP_UPDATE)) (duplic == DUP_UPDATE))
lock_type=TL_WRITE; lock_type=TL_WRITE;
#endif #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; table_list->lock_type= lock_type;
#ifndef EMBEDDED_LIBRARY #ifndef EMBEDDED_LIBRARY
@ -519,6 +541,14 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
thd->cuted_fields = 0L; thd->cuted_fields = 0L;
table->next_number_field=table->found_next_number_field; 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; error=0;
id=0; id=0;
thd->proc_info="update"; thd->proc_info="update";
@ -1184,11 +1214,11 @@ int write_record(THD *thd, TABLE *table,COPY_INFO *info)
if (res == VIEW_CHECK_ERROR) if (res == VIEW_CHECK_ERROR)
goto before_trg_err; goto before_trg_err;
table->file->restore_auto_increment();
if ((error=table->file->update_row(table->record[1],table->record[0]))) if ((error=table->file->update_row(table->record[1],table->record[0])))
{ {
if ((error == HA_ERR_FOUND_DUPP_KEY) && info->ignore) if ((error == HA_ERR_FOUND_DUPP_KEY) && info->ignore)
{ {
table->file->restore_auto_increment();
goto ok_or_after_trg_err; goto ok_or_after_trg_err;
} }
goto err; goto err;
@ -2427,6 +2457,15 @@ select_insert::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
} }
restore_record(table,s->default_values); // Get empty record restore_record(table,s->default_values); // Get empty record
table->next_number_field=table->found_next_number_field; 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; thd->cuted_fields=0;
if (info.ignore || info.handle_duplicates != DUP_ERROR) if (info.ignore || info.handle_duplicates != DUP_ERROR)
table->file->extra(HA_EXTRA_IGNORE_DUP_KEY); table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);