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

MDEV-6593 : domain_id based replication filters

Browse Source 
Implementation for domain ID based filtering of replication events.
This commit is contained in:
Nirbhay Choubey
2014-12-03 22:30:48 -05:00
parent 7bf4f9f7f6
commit a50ddebb5c
24 changed files with 2889 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

261
mysql-test/suite/rpl/r/rpl_domain_id_filter.result Normal file
View File

@ -0,0 +1,261 @@
include/master-slave.inc
[connection master]
# On slave
call mtr.add_suppression("Both DO_DOMAIN_IDS & IGNORE_DOMAIN_IDS lists can't be non-empty at the same time");
call mtr.add_suppression("DO_DOMAIN_IDS or IGNORE_DOMAIN_IDS lists can't be non-empty in non-GTID mode.*");
# On master
SET @@session.gtid_domain_id= 1;
SELECT @@session.gtid_domain_id;
@@session.gtid_domain_id
1
CREATE TABLE t1(i INT) ENGINE=INNODB;
INSERT INTO t1 VALUES(1);
SELECT * FROM t1;
i
1
# On slave
SELECT * FROM t1;
i
1
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO DO_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) : 1
IGNORE_DOMAIN_IDS (AFTER) :
# On master
SET @@session.gtid_domain_id= 2;
INSERT INTO t1 VALUES(2);
SET @@session.gtid_domain_id= 1;
INSERT INTO t1 VALUES(3);
SELECT * FROM t1;
i
1
2
3
# On slave
SELECT * FROM t1;
i
1
3
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) : 1
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 1
# On master
SELECT @@session.gtid_domain_id;
@@session.gtid_domain_id
1
INSERT INTO t1 VALUES(4);
SET @@session.gtid_domain_id= 2;
INSERT INTO t1 VALUES(5);
SELECT * FROM t1;
i
1
2
3
4
5
# On slave
SELECT * FROM t1;
i
1
3
5
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) : 1
CHANGE MASTER TO DO_DOMAIN_IDS=(1), IGNORE_DOMAIN_IDS=(2), MASTER_USE_GTID=slave_pos;
ERROR HY000: Could not initialize master info structure for ''; more error messages can be found in the MariaDB error log
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 1
include/stop_slave.inc
Warnings:
Note 1255 Slave already has been stopped
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) : 1
CHANGE MASTER TO DO_DOMAIN_IDS=(4,4,5,1,7,7,7,1,1,2,6,8,1,4,5,5,9,3), IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) : 1, 2, 3, 4, 5, 6, 7, 8, 9
IGNORE_DOMAIN_IDS (AFTER) :
# On master
SELECT @@session.gtid_domain_id;
@@session.gtid_domain_id
2
INSERT INTO t1 VALUES(8);
SET @@session.gtid_domain_id= 7;
INSERT INTO t1 VALUES(9);
SET @@session.gtid_domain_id= 10;
INSERT INTO t1 VALUES(10);
INSERT INTO t1 VALUES(11);
START TRANSACTION;
INSERT INTO t1 VALUES(12);
INSERT INTO t1 VALUES(13);
COMMIT;
INSERT INTO t1 VALUES(14);
INSERT INTO t1 VALUES(15);
# On slave
SELECT * FROM t1;
i
1
3
5
8
9
# On slave
# Seconds_Behind_Master should be zero here because the slave is fully caught up and idle.
Seconds_Behind_Master = '0'
# On slave
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) : 1, 2, 3, 4, 5, 6, 7, 8, 9
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 1
# On master
SET @@session.gtid_domain_id=2;
CREATE TABLE t2(i int) ENGINE=MYISAM;
CREATE TABLE t3(i int) ENGINE=INNODB;
SET @@session.gtid_domain_id=1;
BEGIN;
INSERT INTO t2 VALUES(1);
INSERT INTO t3 VALUES(1);
# On slave
include/stop_slave.inc
include/wait_for_slave_to_stop.inc
# On master
INSERT INTO t2 VALUES(2);
INSERT INTO t3 VALUES(2);
COMMIT;
# On slave
include/start_slave.inc
SELECT * FROM t2;
i
SELECT * FROM t3;
i
# On master
SET @@session.gtid_domain_id=1;
BEGIN;
INSERT INTO t2 VALUES(3);
INSERT INTO t3 VALUES(3);
# On slave
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) : 1
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) :
# On master
INSERT INTO t2 VALUES(4);
INSERT INTO t3 VALUES(4);
COMMIT;
# On slave
SELECT * FROM t2;
i
4
SELECT * FROM t3;
i
3
4
# On master
SET @@session.gtid_domain_id=1;
BEGIN;
INSERT INTO t2 VALUES(5);
INSERT INTO t3 VALUES(5);
# On slave
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 1
# On master
INSERT INTO t2 VALUES(6);
INSERT INTO t3 VALUES(6);
COMMIT;
# On slave
SELECT * FROM t2;
i
4
5
SELECT * FROM t3;
i
3
4
# On slave
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) : 1
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(2), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 2
# On master
SET @@session.gtid_domain_id=2;
BEGIN;
INSERT INTO t2 VALUES(7);
INSERT INTO t3 VALUES(7);
COMMIT;
# On slave
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) : 2
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) :
# On master
SET @@session.gtid_domain_id=2;
BEGIN;
INSERT INTO t2 VALUES(8);
INSERT INTO t3 VALUES(8);
COMMIT;
SELECT * FROM t2;
i
4
5
8
SELECT * FROM t3;
i
3
4
8
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO DO_DOMAIN_IDS=(1), IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=SLAVE_POS;
ERROR HY000: Could not initialize master info structure for ''; more error messages can be found in the MariaDB error log
CHANGE MASTER TO DO_DOMAIN_IDS=(1), MASTER_USE_GTID=SLAVE_POS;
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=SLAVE_POS;
ERROR HY000: Could not initialize master info structure for ''; more error messages can be found in the MariaDB error log
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=SLAVE_POS;
CHANGE MASTER TO DO_DOMAIN_IDS=(1), MASTER_USE_GTID=SLAVE_POS;
ERROR HY000: Could not initialize master info structure for ''; more error messages can be found in the MariaDB error log
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) : 1
CHANGE MASTER TO MASTER_USE_GTID=NO;
ERROR HY000: Could not initialize master info structure for ''; more error messages can be found in the MariaDB error log
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=NO;
CHANGE MASTER TO DO_DOMAIN_IDS=(1), MASTER_USE_GTID=NO;
ERROR HY000: Could not initialize master info structure for ''; more error messages can be found in the MariaDB error log
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=NO;
ERROR HY000: Could not initialize master info structure for ''; more error messages can be found in the MariaDB error log
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) :
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), DO_DOMAIN_IDS=(), MASTER_USE_GTID=SLAVE_POS;
include/start_slave.inc
# On master
SET @@session.gtid_domain_id=2;
DROP TABLE t1, t2, t3;
# On slave
include/stop_slave.inc
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=();
include/start_slave.inc
include/rpl_end.inc

415
mysql-test/suite/rpl/r/rpl_domain_id_filter_io_crash.result Normal file
View File

@ -0,0 +1,415 @@
include/master-slave.inc
[connection master]
# On master
SET @@session.gtid_domain_id= 1;
SELECT @@session.gtid_domain_id;
@@session.gtid_domain_id
1
CREATE TABLE t1(i INT) ENGINE=INNODB;
INSERT INTO t1 VALUES(1);
SELECT * FROM t1;
i
1
# On slave
call mtr.add_suppression("Slave I/O: Relay log write failure: could not queue event from master.*");
# Case 0 : Start slave with IGNORE_DOMAIN_IDS=(), then restart
# replication with IGNORE_DOMAIN_IDS=() after IO thread is
# killed due to DBUG_EXECUTE_IF("+d,kill_slave_io_before_commit").
SELECT * FROM t1;
i
1
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) :
SET @@global.debug_dbug="+d,kill_slave_io_before_commit";
# On master
START TRANSACTION;
INSERT INTO t1 VALUES(2);
INSERT INTO t1 VALUES(3);
COMMIT;
SELECT * FROM t1;
i
1
2
3
# On slave
include/wait_for_slave_io_error.inc [errno=1595]
SELECT * FROM t1;
i
1
SET @@global.debug_dbug="-d";
START SLAVE io_thread;
include/wait_for_slave_io_to_start.inc
SELECT * FROM t1;
i
1
2
3
# Case 1 : Start slave with IGNORE_DOMAIN_IDS=(1), then restart
# replication with IGNORE_DOMAIN_IDS=(1) after IO thread is
# killed due to DBUG_EXECUTE_IF("+d,kill_slave_io_before_commit").
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 1
SET @@global.debug_dbug="+d,kill_slave_io_before_commit";
# On master
START TRANSACTION;
INSERT INTO t1 VALUES(4);
INSERT INTO t1 VALUES(5);
COMMIT;
SELECT * FROM t1;
i
1
2
3
4
5
# On slave
include/wait_for_slave_io_error.inc [errno=1595]
SELECT * FROM t1;
i
1
2
3
SET @@global.debug_dbug="-d";
START SLAVE io_thread;
include/wait_for_slave_io_to_start.inc
SELECT * FROM t1;
i
1
2
3
# Case 2 : Start slave with IGNORE_DOMAIN_IDS=(), then restart
# replication with IGNORE_DOMAIN_IDS=(1) after IO thread is
# killed due to DBUG_EXECUTE_IF("+d,kill_slave_io_before_commit").
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) : 1
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) :
SET @@global.debug_dbug="+d,kill_slave_io_before_commit";
# On master
START TRANSACTION;
INSERT INTO t1 VALUES(6);
INSERT INTO t1 VALUES(7);
COMMIT;
START TRANSACTION;
INSERT INTO t1 VALUES(8);
INSERT INTO t1 VALUES(9);
COMMIT;
SET @@session.gtid_domain_id= 2;
START TRANSACTION;
INSERT INTO t1 VALUES(10);
INSERT INTO t1 VALUES(11);
COMMIT;
SELECT * FROM t1;
i
1
2
3
4
5
6
7
8
9
10
11
# On slave
include/wait_for_slave_io_error.inc [errno=1595]
SELECT * FROM t1;
i
1
2
3
SET @@global.debug_dbug="-d";
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 1
SELECT * FROM t1;
i
1
2
3
10
11
# Case 3 : Start slave with IGNORE_DOMAIN_IDS=(1), then restart
# replication with IGNORE_DOMAIN_IDS=() after IO thread is
# killed due to DBUG_EXECUTE_IF("+d,kill_slave_io_before_commit").
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) : 1
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 1
SET @@global.debug_dbug="+d,kill_slave_io_before_commit";
# On master
SET @@session.gtid_domain_id= 1;
START TRANSACTION;
INSERT INTO t1 VALUES(12);
INSERT INTO t1 VALUES(13);
COMMIT;
START TRANSACTION;
INSERT INTO t1 VALUES(14);
INSERT INTO t1 VALUES(15);
COMMIT;
SET @@session.gtid_domain_id= 2;
START TRANSACTION;
INSERT INTO t1 VALUES(16);
INSERT INTO t1 VALUES(17);
COMMIT;
SELECT * FROM t1;
i
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# On slave
include/wait_for_slave_io_error.inc [errno=1595]
SELECT * FROM t1;
i
1
2
3
10
11
SET @@global.debug_dbug="-d";
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) : 1
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) :
SELECT * FROM t1;
i
1
2
3
10
11
14
15
16
17
# Case 4 : Start slave with IGNORE_DOMAIN_IDS=(1), then restart
# replication with IGNORE_DOMAIN_IDS=() after IO thread is
# killed due to DBUG_EXECUTE_IF("+d,kill_slave_io_after_2_events").
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 1
SET @@global.debug_dbug="+d,kill_slave_io_after_2_events";
# On master
SET @@session.gtid_domain_id= 1;
START TRANSACTION;
INSERT INTO t1 VALUES(18);
INSERT INTO t1 VALUES(19);
COMMIT;
START TRANSACTION;
INSERT INTO t1 VALUES(20);
INSERT INTO t1 VALUES(21);
COMMIT;
SET @@session.gtid_domain_id= 2;
START TRANSACTION;
INSERT INTO t1 VALUES(22);
INSERT INTO t1 VALUES(23);
COMMIT;
SELECT * FROM t1;
i
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# On slave
include/wait_for_slave_io_error.inc [errno=1595]
SELECT * FROM t1;
i
1
2
3
10
11
14
15
16
17
SET @@global.debug_dbug="-d";
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) : 1
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) :
SELECT * FROM t1;
i
1
2
3
10
11
14
15
16
17
20
21
22
23
# Case 5 : Start slave with IGNORE_DOMAIN_IDS=(), then restart
# replication with IGNORE_DOMAIN_IDS=(1) after IO thread is
# killed due to DBUG_EXECUTE_IF("+d,kill_slave_io_after_2_events").
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) :
SET @@global.debug_dbug="+d,kill_slave_io_after_2_events";
# On master
SET @@session.gtid_domain_id= 1;
START TRANSACTION;
INSERT INTO t1 VALUES(24);
INSERT INTO t1 VALUES(25);
COMMIT;
START TRANSACTION;
INSERT INTO t1 VALUES(26);
INSERT INTO t1 VALUES(27);
COMMIT;
SET @@session.gtid_domain_id= 2;
START TRANSACTION;
INSERT INTO t1 VALUES(28);
INSERT INTO t1 VALUES(29);
COMMIT;
SELECT * FROM t1;
i
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# On slave
include/wait_for_slave_io_error.inc [errno=1595]
SELECT * FROM t1;
i
1
2
3
10
11
14
15
16
17
20
21
22
23
SET @@global.debug_dbug="-d";
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 1
SELECT * FROM t1;
i
1
2
3
10
11
14
15
16
17
20
21
22
23
28
29
# On master
DROP TABLE t1;
# On slave
include/stop_slave.inc
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=();
include/start_slave.inc
include/rpl_end.inc

59
mysql-test/suite/rpl/r/rpl_domain_id_filter_master_crash.result Normal file
View File

@ -0,0 +1,59 @@
include/master-slave.inc
[connection master]
# On master
call mtr.add_suppression("mysqld: Table './mysql/gtid_slave_pos' is marked as crashed and should be repaired");
call mtr.add_suppression("Checking table: './mysql/gtid_slave_pos'");
call mtr.add_suppression("mysql.gtid_slave_pos: 1 client is using or hasn't closed the table properly");
SET @@session.gtid_domain_id= 0;
create table ti (a int auto_increment primary key) engine=innodb;
create table tm (a int auto_increment primary key) engine=myisam;
insert into ti set a=null;
insert into tm set a=null;
# On slave
include/stop_slave.inc
select * from ti;
a
1
select * from tm;
a
1
# On master
SET @@session.gtid_domain_id= 1;
begin;
insert into ti set a=null;
insert into tm set a=null;
commit;
SET @@session.gtid_domain_id= 0;
insert into ti set a=null;
insert into tm set a=null;
set @@global.debug_dbug="+d,crash_before_send_xid";
# On slave
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 1
# On master
include/rpl_start_server.inc [server_number=1]
# Master has restarted successfully
set @@global.debug_dbug="-d";
# On slave
include/stop_slave.inc
include/start_slave.inc
select * from ti;
a
1
3
select * from tm;
a
1
3
# On master
drop table ti;
drop table tm;
# On slave
include/stop_slave.inc
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=NO;
include/start_slave.inc
include/rpl_end.inc

177
mysql-test/suite/rpl/r/rpl_domain_id_filter_parallel.result Normal file
View File

@ -0,0 +1,177 @@
include/rpl_init.inc [topology=1->2]
# On slave
SET @old_parallel_threads=@@GLOBAL.slave_parallel_threads;
include/stop_slave.inc
SET GLOBAL slave_parallel_threads=10;
# On slave
CHANGE MASTER TO master_use_gtid=slave_pos, DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=();
include/start_slave.inc
# On master
SELECT @@session.gtid_domain_id;
@@session.gtid_domain_id
0
ALTER TABLE mysql.gtid_slave_pos ENGINE=InnoDB;
CREATE TABLE t1 (a int PRIMARY KEY) ENGINE=MyISAM;
CREATE TABLE t2 (a int PRIMARY KEY) ENGINE=InnoDB;
INSERT INTO t1 VALUES (1);
INSERT INTO t2 VALUES (1);
# On slave
# New connection 'con_temp1'
LOCK TABLE t1 WRITE;
# On master
SET @@session.gtid_domain_id=1;
INSERT INTO t1 VALUES (2);
SET @@session.gtid_domain_id=0;
INSERT INTO t2 VALUES (2);
INSERT INTO t2 VALUES (3);
BEGIN;
INSERT INTO t2 VALUES (4);
INSERT INTO t2 VALUES (5);
COMMIT;
INSERT INTO t2 VALUES (6);
# On slave
SELECT * FROM t2 ORDER by a;
a
1
2
3
4
5
6
# On con_temp1
SELECT * FROM t1;
a
1
UNLOCK TABLES;
# On slave
SELECT * FROM t1 ORDER BY a;
a
1
2
# On slave
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO DO_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) : 1
IGNORE_DOMAIN_IDS (AFTER) :
# On slave
# On con_temp1
LOCK TABLE t1 WRITE;
# On master
SET @@session.gtid_domain_id=0;
INSERT INTO t1 VALUES (3);
SET @@session.gtid_domain_id=1;
INSERT INTO t2 VALUES (7);
INSERT INTO t2 VALUES (8);
BEGIN;
INSERT INTO t2 VALUES (9);
INSERT INTO t2 VALUES (10);
COMMIT;
INSERT INTO t2 VALUES (11);
# On slave
SELECT * FROM t2 ORDER by a;
a
1
2
3
4
5
6
7
8
9
10
11
# On con_temp1
SELECT * FROM t1;
a
1
2
UNLOCK TABLES;
# On slave
SELECT * FROM t1 ORDER BY a;
a
1
2
# On slave
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) : 1
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 1
# On slave
# On con_temp1
LOCK TABLE t1 WRITE;
# On master
SET @@session.gtid_domain_id=1;
INSERT INTO t1 VALUES (4);
SET @@session.gtid_domain_id=0;
INSERT INTO t2 VALUES (12);
INSERT INTO t2 VALUES (13);
BEGIN;
INSERT INTO t2 VALUES (14);
INSERT INTO t2 VALUES (15);
COMMIT;
INSERT INTO t2 VALUES (16);
# On slave
SELECT * FROM t2 ORDER by a;
a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# On con_temp1
SELECT * FROM t1;
a
1
2
UNLOCK TABLES;
# On slave
SELECT * FROM t1 ORDER BY a;
a
1
2
SELECT * FROM t2;
a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Restore original settings.
# On master
SET @@session.gtid_domain_id=0;
DROP TABLE t1, t2;
# On slave
include/stop_slave.inc
SET GLOBAL slave_parallel_threads= @old_parallel_threads;
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=();
include/start_slave.inc
include/rpl_end.inc

46
mysql-test/suite/rpl/r/rpl_domain_id_filter_restart.result Normal file
View File

@ -0,0 +1,46 @@
include/master-slave.inc
[connection master]
# On slave
include/stop_slave.inc
DO_DOMAIN_IDS (BEFORE) :
IGNORE_DOMAIN_IDS (BEFORE) :
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) : 1
# On master
SET @@session.gtid_domain_id= 0;
CREATE TABLE t1(i INT);
CREATE TABLE t2(i INT);
INSERT INTO t1 VALUES(1);
SELECT * FROM t1;
i
1
SET @@session.gtid_domain_id= 1;
INSERT INTO t2 VALUES(1);
SELECT * FROM t2;
i
1
# On slave
SELECT * FROM t1;
i
1
SELECT * FROM t2;
i
include/rpl_restart_server.inc [server_number=2]
# On slave
DO_DOMAIN_IDS (AFTER RESTART) :
IGNORE_DOMAIN_IDS (AFTER RESTART) : 1
CHANGE MASTER TO IGNORE_DOMAIN_IDS=();
include/start_slave.inc
DO_DOMAIN_IDS (AFTER) :
IGNORE_DOMAIN_IDS (AFTER) :
SELECT * FROM t1;
i
1
SELECT * FROM t2;
i
# On master
SET @@session.gtid_domain_id= 0;
DROP TABLE t1, t2;
include/rpl_end.inc

431
mysql-test/suite/rpl/t/rpl_domain_id_filter.test Normal file
View File

@ -0,0 +1,431 @@
--source include/have_innodb.inc
--source include/master-slave.inc
#
# Test for DO_DOMAIN_IDS=(M1, M2, ..) and IGNORE_DOMAIN_IDS=(N1, N2, ..)
#
--echo # On slave
connection slave;
call mtr.add_suppression("Both DO_DOMAIN_IDS & IGNORE_DOMAIN_IDS lists can't be non-empty at the same time");
call mtr.add_suppression("DO_DOMAIN_IDS or IGNORE_DOMAIN_IDS lists can't be non-empty in non-GTID mode.*");
--echo # On master
connection master;
SET @@session.gtid_domain_id= 1;
SELECT @@session.gtid_domain_id;
CREATE TABLE t1(i INT) ENGINE=INNODB;
INSERT INTO t1 VALUES(1);
SELECT * FROM t1;
sync_slave_with_master;
--echo # On slave
connection slave;
##### Case 0 : When both DO_DOMAIN_IDS and IGNORE_DOMAIN_IDS are empty.
SELECT * FROM t1;
##### Case 1: When DO_DOMAIN_IDS is non-empty.
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# Replicate events belonging to "domain_id 1".
CHANGE MASTER TO DO_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
--echo # On master
connection master;
# Lets change the session domain_id to 2(not in DO_DOMAIN_IDS).
SET @@session.gtid_domain_id= 2;
# Should get filtered out on slave.
INSERT INTO t1 VALUES(2);
# Change it back to 1 (in DO_DOMAIN_IDS).
SET @@session.gtid_domain_id= 1;
# Should get applied on slave.
INSERT INTO t1 VALUES(3);
SELECT * FROM t1;
sync_slave_with_master;
--echo # On slave
connection slave;
SELECT * FROM t1;
##### Case 2: When IGNORE_DOMAIN_IDS is non-empty.
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# Ignore events belonging to "domain_id 1".
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
--echo # On master
connection master;
# @@session.gtid_domain_id = 1 (in IGNORE_DOMAIN_IDS)
SELECT @@session.gtid_domain_id;
# Should get filtered out on slave.
INSERT INTO t1 VALUES(4);
# Change it to 2 (not in IGNORE_DOMAIN_IDS).
SET @@session.gtid_domain_id= 2;
# Should get applied on slave.
INSERT INTO t1 VALUES(5);
SELECT * FROM t1;
sync_slave_with_master;
--echo # On slave
connection slave;
SELECT * FROM t1;
##### Case 3: When both DO_DOMAIN_IDS and IGNORE_DOMAIN_IDS are non-empty
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
--error ER_MASTER_INFO
CHANGE MASTER TO DO_DOMAIN_IDS=(1), IGNORE_DOMAIN_IDS=(2), MASTER_USE_GTID=slave_pos;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
##### Case 4: Multiple domain ids.
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# Replicate events belonging to "domain_id 1".
CHANGE MASTER TO DO_DOMAIN_IDS=(4,4,5,1,7,7,7,1,1,2,6,8,1,4,5,5,9,3), IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
--echo # On master
connection master;
# @@session.gtid_domain_id = 1 (in DO_DOMAIN_IDS)
SELECT @@session.gtid_domain_id;
# Should get applied on slave.
INSERT INTO t1 VALUES(8);
# Change it to 7 (in DO_DOMAIN_IDS).
SET @@session.gtid_domain_id= 7;
# Should get applied on slave.
INSERT INTO t1 VALUES(9);
# Change it to 10 (no in DO_DOMAIN_IDS).
SET @@session.gtid_domain_id= 10;
# Following should get filtered out on slave.
INSERT INTO t1 VALUES(10);
INSERT INTO t1 VALUES(11);
START TRANSACTION;
INSERT INTO t1 VALUES(12);
INSERT INTO t1 VALUES(13);
COMMIT;
INSERT INTO t1 VALUES(14);
INSERT INTO t1 VALUES(15);
sync_slave_with_master;
--echo # On slave
connection slave;
SELECT * FROM t1;
##### Case 5: Seconds_Behind_Master
--echo # On slave
connection slave;
--echo # Seconds_Behind_Master should be zero here because the slave is fully caught up and idle.
--let $status_items= Seconds_Behind_Master
--source include/show_slave_status.inc
##### Case 6: Stop slave before a transaction (involving MyISAM and InnoDB
# table) being filtered commits.
--echo # On slave
connection slave;
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# IGNORE_DOMAIN_IDS=(1)
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
--echo # On master
connection master;
# following statements should not get filtered.
SET @@session.gtid_domain_id=2;
CREATE TABLE t2(i int) ENGINE=MYISAM;
CREATE TABLE t3(i int) ENGINE=INNODB;
SET @@session.gtid_domain_id=1;
BEGIN;
INSERT INTO t2 VALUES(1);
INSERT INTO t3 VALUES(1);
sync_slave_with_master;
# Now switch to slave to stop replication.
--echo # On slave
connection slave;
--source include/stop_slave.inc
--source include/wait_for_slave_to_stop.inc
# Back to master to finish the transaction.
--echo # On master
connection master;
INSERT INTO t2 VALUES(2);
INSERT INTO t3 VALUES(2);
COMMIT;
save_master_pos;
# On slave to start replication.
--echo # On slave
connection slave;
--source include/start_slave.inc
sync_with_master;
SELECT * FROM t2;
SELECT * FROM t3;
##### Case 7: Stop slave before a transaction (involving MyISAM and InnoDB
# table) being filtered commits and start it back with filtering
# disabled.
--echo # On master
connection master;
SET @@session.gtid_domain_id=1;
BEGIN;
INSERT INTO t2 VALUES(3);
INSERT INTO t3 VALUES(3);
sync_slave_with_master;
--echo # On slave
connection slave;
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# Clear IGNORE_DOMAIN_IDS
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
--echo # On master
connection master;
INSERT INTO t2 VALUES(4);
INSERT INTO t3 VALUES(4);
COMMIT;
sync_slave_with_master;
--echo # On slave
connection slave;
SELECT * FROM t2;
SELECT * FROM t3;
##### Case 8: Stop slave into the middle of a transaction and start it back
# with filtering enabled.
--echo # On master
connection master;
SET @@session.gtid_domain_id=1;
BEGIN;
INSERT INTO t2 VALUES(5);
INSERT INTO t3 VALUES(5);
sync_slave_with_master;
--echo # On slave
connection slave;
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# IGNORE_DOMAIN_IDS(1)
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
--echo # On master
connection master;
INSERT INTO t2 VALUES(6);
INSERT INTO t3 VALUES(6);
COMMIT;
sync_slave_with_master;
--echo # On slave
connection slave;
SELECT * FROM t2;
SELECT * FROM t3;
##### Case 9: Initially filter out events belonging to domain_id=2 and then
# remove the rule to check if event are not being filtered out.
--echo # On slave
connection slave;
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# IGNORE_DOMAIN_IDS(2)
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(2), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
--echo # On master
connection master;
SET @@session.gtid_domain_id=2;
BEGIN;
INSERT INTO t2 VALUES(7);
INSERT INTO t3 VALUES(7);
COMMIT;
sync_slave_with_master;
# Clear the filter
--echo # On slave
connection slave;
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# IGNORE_DOMAIN_IDS()
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
--echo # On master
connection master;
SET @@session.gtid_domain_id=2;
BEGIN;
INSERT INTO t2 VALUES(8);
INSERT INTO t3 VALUES(8);
COMMIT;
sync_slave_with_master;
# On slave
connection slave;
SELECT * FROM t2;
SELECT * FROM t3;
##### Case 10: Test CHANGE MASTER with various "incompatible" combinations.
# On slave
connection slave;
--source include/stop_slave.inc
# 10a: Both DO_DOMAIN_IDS & IGNORE_DOMAIN_IDS can't be non-empty at the same
# time.
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
--error ER_MASTER_INFO
CHANGE MASTER TO DO_DOMAIN_IDS=(1), IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=SLAVE_POS;
CHANGE MASTER TO DO_DOMAIN_IDS=(1), MASTER_USE_GTID=SLAVE_POS;
--error ER_MASTER_INFO
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=SLAVE_POS;
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=SLAVE_POS;
--error ER_MASTER_INFO
CHANGE MASTER TO DO_DOMAIN_IDS=(1), MASTER_USE_GTID=SLAVE_POS;
# 10b: Neither DO_DOMAIN_IDS nor IGNORE_DOMAIN_IDS can be set when
# MASTER_USE_GTID=NO
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# MASTER_USE_GTID can't be set to NO when either of IGNORE_DOMAIN_IDS or
# DO_DOMAIN_IDS is non-empty.
--error ER_MASTER_INFO
CHANGE MASTER TO MASTER_USE_GTID=NO;
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=NO;
--error ER_MASTER_INFO
CHANGE MASTER TO DO_DOMAIN_IDS=(1), MASTER_USE_GTID=NO;
--error ER_MASTER_INFO
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=NO;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), DO_DOMAIN_IDS=(), MASTER_USE_GTID=SLAVE_POS;
--source include/start_slave.inc
sync_with_master;
# Cleanup
--echo # On master
connection master;
SET @@session.gtid_domain_id=2;
DROP TABLE t1, t2, t3;
sync_slave_with_master;
--echo # On slave
connection slave;
--source include/stop_slave.inc
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=();
--source include/start_slave.inc
--source include/rpl_end.inc

399
mysql-test/suite/rpl/t/rpl_domain_id_filter_io_crash.test Normal file
View File

@ -0,0 +1,399 @@
--source include/have_debug.inc
--source include/have_innodb.inc
--source include/master-slave.inc
--echo # On master
connection master;
SET @@session.gtid_domain_id= 1;
SELECT @@session.gtid_domain_id;
CREATE TABLE t1(i INT) ENGINE=INNODB;
INSERT INTO t1 VALUES(1);
SELECT * FROM t1;
sync_slave_with_master;
--echo # On slave
connection slave;
call mtr.add_suppression("Slave I/O: Relay log write failure: could not queue event from master.*");
--echo # Case 0 : Start slave with IGNORE_DOMAIN_IDS=(), then restart
--echo # replication with IGNORE_DOMAIN_IDS=() after IO thread is
--echo # killed due to DBUG_EXECUTE_IF("+d,kill_slave_io_before_commit").
SELECT * FROM t1;
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
SET @@global.debug_dbug="+d,kill_slave_io_before_commit";
--echo # On master
connection master;
START TRANSACTION;
INSERT INTO t1 VALUES(2);
INSERT INTO t1 VALUES(3);
COMMIT;
save_master_pos;
SELECT * FROM t1;
--echo # On slave
connection slave;
--let $slave_io_errno= 1595
--source include/wait_for_slave_io_error.inc
SELECT * FROM t1;
SET @@global.debug_dbug="-d";
START SLAVE io_thread;
--source include/wait_for_slave_io_to_start.inc
sync_with_master;
SELECT * FROM t1;
--echo # Case 1 : Start slave with IGNORE_DOMAIN_IDS=(1), then restart
--echo # replication with IGNORE_DOMAIN_IDS=(1) after IO thread is
--echo # killed due to DBUG_EXECUTE_IF("+d,kill_slave_io_before_commit").
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
SET @@global.debug_dbug="+d,kill_slave_io_before_commit";
--echo # On master
connection master;
START TRANSACTION;
INSERT INTO t1 VALUES(4);
INSERT INTO t1 VALUES(5);
COMMIT;
save_master_pos;
SELECT * FROM t1;
--echo # On slave
connection slave;
--let $slave_io_errno= 1595
--source include/wait_for_slave_io_error.inc
SELECT * FROM t1;
SET @@global.debug_dbug="-d";
START SLAVE io_thread;
--source include/wait_for_slave_io_to_start.inc
sync_with_master;
SELECT * FROM t1;
--echo # Case 2 : Start slave with IGNORE_DOMAIN_IDS=(), then restart
--echo # replication with IGNORE_DOMAIN_IDS=(1) after IO thread is
--echo # killed due to DBUG_EXECUTE_IF("+d,kill_slave_io_before_commit").
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
SET @@global.debug_dbug="+d,kill_slave_io_before_commit";
--echo # On master
connection master;
START TRANSACTION;
INSERT INTO t1 VALUES(6);
INSERT INTO t1 VALUES(7);
COMMIT; # IO thread gets killed here.
START TRANSACTION;
INSERT INTO t1 VALUES(8);
INSERT INTO t1 VALUES(9);
COMMIT;
SET @@session.gtid_domain_id= 2;
START TRANSACTION;
INSERT INTO t1 VALUES(10);
INSERT INTO t1 VALUES(11);
COMMIT;
save_master_pos;
SELECT * FROM t1;
--echo # On slave
connection slave;
--let $slave_io_errno= 1595
--source include/wait_for_slave_io_error.inc
SELECT * FROM t1;
SET @@global.debug_dbug="-d";
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
SELECT * FROM t1;
--echo # Case 3 : Start slave with IGNORE_DOMAIN_IDS=(1), then restart
--echo # replication with IGNORE_DOMAIN_IDS=() after IO thread is
--echo # killed due to DBUG_EXECUTE_IF("+d,kill_slave_io_before_commit").
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
SET @@global.debug_dbug="+d,kill_slave_io_before_commit";
--echo # On master
connection master;
SET @@session.gtid_domain_id= 1;
START TRANSACTION;
INSERT INTO t1 VALUES(12);
INSERT INTO t1 VALUES(13);
COMMIT; # IO thread gets killed here.
START TRANSACTION;
INSERT INTO t1 VALUES(14);
INSERT INTO t1 VALUES(15);
COMMIT;
SET @@session.gtid_domain_id= 2;
START TRANSACTION;
INSERT INTO t1 VALUES(16);
INSERT INTO t1 VALUES(17);
COMMIT;
save_master_pos;
SELECT * FROM t1;
--echo # On slave
connection slave;
--let $slave_io_errno= 1595
--source include/wait_for_slave_io_error.inc
SELECT * FROM t1;
SET @@global.debug_dbug="-d";
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
SELECT * FROM t1;
--echo # Case 4 : Start slave with IGNORE_DOMAIN_IDS=(1), then restart
--echo # replication with IGNORE_DOMAIN_IDS=() after IO thread is
--echo # killed due to DBUG_EXECUTE_IF("+d,kill_slave_io_after_2_events").
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
SET @@global.debug_dbug="+d,kill_slave_io_after_2_events";
--echo # On master
connection master;
SET @@session.gtid_domain_id= 1;
START TRANSACTION;
INSERT INTO t1 VALUES(18);
INSERT INTO t1 VALUES(19); # IO thread gets killed here.
COMMIT;
START TRANSACTION;
INSERT INTO t1 VALUES(20);
INSERT INTO t1 VALUES(21);
COMMIT;
SET @@session.gtid_domain_id= 2;
START TRANSACTION;
INSERT INTO t1 VALUES(22);
INSERT INTO t1 VALUES(23);
COMMIT;
save_master_pos;
SELECT * FROM t1;
--echo # On slave
connection slave;
--let $slave_io_errno= 1595
--source include/wait_for_slave_io_error.inc
SELECT * FROM t1;
SET @@global.debug_dbug="-d";
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
SELECT * FROM t1;
--echo # Case 5 : Start slave with IGNORE_DOMAIN_IDS=(), then restart
--echo # replication with IGNORE_DOMAIN_IDS=(1) after IO thread is
--echo # killed due to DBUG_EXECUTE_IF("+d,kill_slave_io_after_2_events").
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
SET @@global.debug_dbug="+d,kill_slave_io_after_2_events";
--echo # On master
connection master;
SET @@session.gtid_domain_id= 1;
START TRANSACTION;
INSERT INTO t1 VALUES(24);
INSERT INTO t1 VALUES(25); # IO thread gets killed here.
COMMIT;
START TRANSACTION;
INSERT INTO t1 VALUES(26);
INSERT INTO t1 VALUES(27);
COMMIT;
SET @@session.gtid_domain_id= 2;
START TRANSACTION;
INSERT INTO t1 VALUES(28);
INSERT INTO t1 VALUES(29);
COMMIT;
save_master_pos;
SELECT * FROM t1;
--echo # On slave
connection slave;
--let $slave_io_errno= 1595
--source include/wait_for_slave_io_error.inc
SELECT * FROM t1;
SET @@global.debug_dbug="-d";
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
SELECT * FROM t1;
# Cleanup
--echo # On master
connection master;
DROP TABLE t1;
sync_slave_with_master;
--echo # On slave
connection slave;
--source include/stop_slave.inc
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=();
--source include/start_slave.inc
--source include/rpl_end.inc

98
mysql-test/suite/rpl/t/rpl_domain_id_filter_master_crash.test Normal file
View File

@ -0,0 +1,98 @@
--source include/have_innodb.inc
--source include/have_debug.inc
# Valgrind does not work well with test that crashes the server
--source include/not_valgrind.inc
--source include/master-slave.inc
--echo # On master
connection master;
call mtr.add_suppression("mysqld: Table './mysql/gtid_slave_pos' is marked as crashed and should be repaired");
call mtr.add_suppression("Checking table: './mysql/gtid_slave_pos'");
call mtr.add_suppression("mysql.gtid_slave_pos: 1 client is using or hasn't closed the table properly");
SET @@session.gtid_domain_id= 0;
create table ti (a int auto_increment primary key) engine=innodb;
create table tm (a int auto_increment primary key) engine=myisam;
insert into ti set a=null;
insert into tm set a=null;
save_master_pos;
--echo # On slave
connection slave;
sync_with_master;
--source include/stop_slave.inc
select * from ti;
select * from tm;
--echo # On master
connection master;
SET @@session.gtid_domain_id= 1;
begin;
insert into ti set a=null;
insert into tm set a=null;
commit;
SET @@session.gtid_domain_id= 0;
insert into ti set a=null;
insert into tm set a=null;
set @@global.debug_dbug="+d,crash_before_send_xid";
--exec echo "wait" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
--echo # On slave
connection slave;
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# IGNORE_DOMAIN_IDS=(1)
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
--echo # On master
connection master;
--source include/wait_until_disconnected.inc
--enable_reconnect
--let $rpl_server_number=1
--source include/rpl_start_server.inc
#--exec echo "restart" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
--source include/wait_until_connected_again.inc
--echo # Master has restarted successfully
set @@global.debug_dbug="-d";
save_master_pos;
--echo # On slave
--connection slave
--source include/stop_slave.inc
--source include/start_slave.inc
sync_with_master;
select * from ti;
select * from tm;
# Cleanup
--echo # On master
--connection master
drop table ti;
drop table tm;
sync_slave_with_master;
--echo # On slave
--connection slave
--source include/stop_slave.inc
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(), MASTER_USE_GTID=NO;
--source include/start_slave.inc
--source include/rpl_end.inc

221
mysql-test/suite/rpl/t/rpl_domain_id_filter_parallel.test Normal file
View File

@ -0,0 +1,221 @@
--source include/have_innodb.inc
--source include/have_debug.inc
--source include/have_debug_sync.inc
--let $rpl_topology=1->2
--source include/rpl_init.inc
--echo # On slave
--connection server_2
SET @old_parallel_threads=@@GLOBAL.slave_parallel_threads;
--source include/stop_slave.inc
SET GLOBAL slave_parallel_threads=10;
##### Case 0 : When both DO_DOMAIN_IDS and IGNORE_DOMAIN_IDS are empty.
--echo # On slave
--connection server_2
CHANGE MASTER TO master_use_gtid=slave_pos, DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=();
--source include/start_slave.inc
--echo # On master
--connection server_1
SELECT @@session.gtid_domain_id;
ALTER TABLE mysql.gtid_slave_pos ENGINE=InnoDB;
CREATE TABLE t1 (a int PRIMARY KEY) ENGINE=MyISAM;
CREATE TABLE t2 (a int PRIMARY KEY) ENGINE=InnoDB;
INSERT INTO t1 VALUES (1);
INSERT INTO t2 VALUES (1);
--save_master_pos
--echo # On slave
--connection server_2
--sync_with_master
--echo # New connection 'con_temp1'
# Block the table t1 to simulate a replicated query taking a long time.
--connect (con_temp1,127.0.0.1,root,,test,$SERVER_MYPORT_2,)
LOCK TABLE t1 WRITE;
--echo # On master
--connection server_1
SET @@session.gtid_domain_id=1;
# This query will be blocked on the slave until UNLOCK TABLES.
INSERT INTO t1 VALUES (2);
SET @@session.gtid_domain_id=0;
# These t2 queries can be replicated in parallel with the prior t1 query, as
# they are in a separate replication domain.
INSERT INTO t2 VALUES (2);
INSERT INTO t2 VALUES (3);
BEGIN;
INSERT INTO t2 VALUES (4);
INSERT INTO t2 VALUES (5);
COMMIT;
INSERT INTO t2 VALUES (6);
--echo # On slave
--connection server_2
--let $wait_condition= SELECT COUNT(*) = 6 FROM t2
--source include/wait_condition.inc
SELECT * FROM t2 ORDER by a;
--echo # On con_temp1
--connection con_temp1
SELECT * FROM t1;
UNLOCK TABLES;
--echo # On slave
--connection server_2
--let $wait_condition= SELECT COUNT(*) = 2 FROM t1
--source include/wait_condition.inc
SELECT * FROM t1 ORDER BY a;
##### Case 1 : When DO_DOMAIN_IDS=(1)
--echo # On slave
--connection server_2
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# Replicate events belonging to "domain_id 1".
CHANGE MASTER TO DO_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
--echo # On slave
--connection server_2
--sync_with_master
--echo # On con_temp1
# Block the table t1 to simulate a replicated query taking a long time.
--connection con_temp1
LOCK TABLE t1 WRITE;
--echo # On master
--connection server_1
SET @@session.gtid_domain_id=0;
# This query will be blocked on the slave until UNLOCK TABLES.
# But, since DO_DOMAIN_IDS=(1), it will be filtered out on slave.
INSERT INTO t1 VALUES (3);
SET @@session.gtid_domain_id=1;
# These t2 queries can be replicated in parallel with the prior t1 query, as
# they are in a separate replication domain.
INSERT INTO t2 VALUES (7);
INSERT INTO t2 VALUES (8);
BEGIN;
INSERT INTO t2 VALUES (9);
INSERT INTO t2 VALUES (10);
COMMIT;
INSERT INTO t2 VALUES (11);
--echo # On slave
--connection server_2
--let $wait_condition= SELECT COUNT(*) = 11 FROM t2
--source include/wait_condition.inc
SELECT * FROM t2 ORDER by a;
--echo # On con_temp1
--connection con_temp1
SELECT * FROM t1;
UNLOCK TABLES;
--echo # On slave
--connection server_2
--let $wait_condition= SELECT COUNT(*) = 2 FROM t1
--source include/wait_condition.inc
SELECT * FROM t1 ORDER BY a;
##### Case 2 : When IGNORE_DOMAIN_IDS=(1)
--echo # On slave
--connection server_2
--source include/stop_slave.inc
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# Replicate events belonging to "domain_id 1".
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
--source include/start_slave.inc
sync_with_master;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
--echo # On slave
--connection server_2
--sync_with_master
--echo # On con_temp1
# Block the table t1 to simulate a replicated query taking a long time.
--connection con_temp1
LOCK TABLE t1 WRITE;
--echo # On master
--connection server_1
SET @@session.gtid_domain_id=1;
# This query will be blocked on the slave until UNLOCK TABLES. However, since
# IGNORE_DOMAIN_IDS=(1), it will be filtered out on slave.
INSERT INTO t1 VALUES (4);
SET @@session.gtid_domain_id=0;
# These t2 queries can be replicated in parallel with the prior t1 query, as
# they are in a separate replication domain.
INSERT INTO t2 VALUES (12);
INSERT INTO t2 VALUES (13);
BEGIN;
INSERT INTO t2 VALUES (14);
INSERT INTO t2 VALUES (15);
COMMIT;
INSERT INTO t2 VALUES (16);
--echo # On slave
--connection server_2
--let $wait_condition= SELECT COUNT(*) = 16 FROM t2
--source include/wait_condition.inc
SELECT * FROM t2 ORDER by a;
--echo # On con_temp1
--connection con_temp1
SELECT * FROM t1;
UNLOCK TABLES;
--echo # On slave
--connection server_2
--let $wait_condition= SELECT COUNT(*) = 2 FROM t1
--source include/wait_condition.inc
SELECT * FROM t1 ORDER BY a;
SELECT * FROM t2;
--echo # Restore original settings.
--echo # On master
--connection server_1
SET @@session.gtid_domain_id=0;
DROP TABLE t1, t2;
--save_master_pos
--echo # On slave
--connection server_2
--sync_with_master
--source include/stop_slave.inc
SET GLOBAL slave_parallel_threads= @old_parallel_threads;
CHANGE MASTER TO DO_DOMAIN_IDS=(), IGNORE_DOMAIN_IDS=();
--source include/start_slave.inc
--source include/rpl_end.inc

79
mysql-test/suite/rpl/t/rpl_domain_id_filter_restart.test Normal file
View File

@ -0,0 +1,79 @@
--source include/master-slave.inc
#
# Test for domain-id based filter on slave restart in GTID-mode.
#
--echo # On slave
connection slave;
source include/stop_slave.inc;
let $do_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_before= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (BEFORE) : $do_domain_ids_before
--echo IGNORE_DOMAIN_IDS (BEFORE) : $ignore_domain_ids_before
# Ignore events belonging to "domain_id 1".
CHANGE MASTER TO IGNORE_DOMAIN_IDS=(1), MASTER_USE_GTID=slave_pos;
source include/start_slave.inc;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
--echo # On master
connection master;
SET @@session.gtid_domain_id= 0;
CREATE TABLE t1(i INT);
CREATE TABLE t2(i INT);
INSERT INTO t1 VALUES(1);
SELECT * FROM t1;
SET @@session.gtid_domain_id= 1;
# the following will get filtered out.
INSERT INTO t2 VALUES(1);
SELECT * FROM t2;
sync_slave_with_master;
--echo # On slave
connection slave;
SELECT * FROM t1;
SELECT * FROM t2;
# restart the slave
--let $rpl_server_number= 2
--source include/rpl_restart_server.inc
--echo # On slave
# Replicate_Do_Domain_Ids/Replicate_Ignore_Domain_Ids should reinitialize
# properly on restart.
connection slave;
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER RESTART) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER RESTART) : $ignore_domain_ids_after
# Now, lets clear IGNORE_DOMAIN_IDS.
CHANGE MASTER TO IGNORE_DOMAIN_IDS=();
--source include/start_slave.inc
let $do_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Do_Domain_Ids, 1);
let $ignore_domain_ids_after= query_get_value(SHOW SLAVE STATUS, Replicate_Ignore_Domain_Ids, 1);
--echo DO_DOMAIN_IDS (AFTER) : $do_domain_ids_after
--echo IGNORE_DOMAIN_IDS (AFTER) : $ignore_domain_ids_after
SELECT * FROM t1;
SELECT * FROM t2;
--echo # On master
connection master;
SET @@session.gtid_domain_id= 0;
DROP TABLE t1, t2;
sync_slave_with_master;
--source include/rpl_end.inc