mirror of
https://github.com/MariaDB/server.git
synced 2025-04-12 10:15:31 +02:00
7af50e4df4
rpl_semi_sync_slave_enabled_consistent.test and the first part of
the commit message comes from Brandon Nesterenko.
A test to show how to induce the "Read semi-sync reply magic number
error" message on a primary. In short, if semi-sync is turned on
during the hand-shake process between a primary and replica, but
later a user negates the rpl_semi_sync_slave_enabled variable while
the replica's IO thread is running; if the io thread exits, the
replica can skip a necessary call to kill_connection() in
repl_semisync_slave.slave_stop() due to its reliance on a global
variable. Then, the replica will send a COM_QUIT packet to the
primary on an active semi-sync connection, causing the magic number
error.
The test in this patch exits the IO thread by forcing an error;
though note a call to STOP SLAVE could also do this, but it ends up
needing more synchronization. That is, the STOP SLAVE command also
tries to kill the VIO of the replica, which makes a race with the IO
thread to try and send the COM_QUIT before this happens (which would
need more debug_sync to get around). See THD::awake_no_mutex for
details as to the killing of the replica’s vio.
Notes:
- The MariaDB documentation does not make it clear that when one
enables semi-sync replication it does not matter if one enables
it first in the master or slave. Any order works.
Changes done:
- The rpl_semi_sync_slave_enabled variable is now a default value for
when semisync is started. The variable does not anymore affect
semisync if it is already running. This fixes the original reported
bug. Internally we now use repl_semisync_slave.get_slave_enabled()
instead of rpl_semi_sync_slave_enabled. To check if semisync is
active on should check the @@rpl_semi_sync_slave_status variable (as
before).
- The semisync protocol conflicts in the way that the original
MySQL/MariaDB client-server protocol was designed (client-server
send and reply packets are strictly ordered and includes a packet
number to allow one to check if a packet is lost). When using
semi-sync the master and slave can send packets at 'any time', so
packet numbering does not work. The 'solution' has been that each
communication starts with packet number 1, but in some cases there
is still a chance that the packet number check can fail. Fixed by
adding a flag (pkt_nr_can_be_reset) in the NET struct that one can
use to signal that packet number checking should not be done. This
is flag is set when semi-sync is used.
- Added Master_info::semi_sync_reply_enabled to allow one to configure
some slaves with semisync and other other slaves without semisync.
Removed global variable semi_sync_need_reply that would not work
with multi-master.
- Repl_semi_sync_master::report_reply_packet() can now recognize
the COM_QUIT packet from semisync slave and not give a
"Read semi-sync reply magic number error" error for this case.
The slave will be removed from the Ack listener.
- On Windows, don't stop semisync Ack listener just because one
slave connection is using socket_id > FD_SETSIZE.
- Removed busy loop in Ack_receiver::run() by using
"Self-pipe trick" to signal new slave and stop Ack_receiver.
- Changed some Repl_semi_sync_slave functions that always returns 0
from int to void.
- Added Repl_semi_sync_slave::slave_reconnect().
- Removed dummy_function Repl_semi_sync_slave::reset_slave().
- Removed some duplicate semisync notes from the error log.
- Add test of "if (get_slave_enabled() && semi_sync_need_reply)"
before calling Repl_semi_sync_slave::slave_reply().
(Speeds up the code as we can skip all initializations).
- If epl_semisync_slave.slave_reply() fails, we disable semisync
for that connection.
- We do not call semisync.switch_off() if there are no active slaves.
Instead we check in Repl_semi_sync_master::commit_trx() if there are
no active threads. This simplices the code.
- Changed assert() to DBUG_ASSERT() to ensure that the DBUG log is
flushed in case of asserts.
- Removed the internal rpl_semi_sync_slave_status as it is not needed
anymore. The @@rpl_semi_sync_slave_status status variable is now
mapped to rpl_semi_sync_enabled.
- Removed rpl_semi_sync_slave_enabled as it is not needed anymore.
Repl_semi_sync_slave::get_slave_enabled() contains the active status.
- Added checking that we do not add a slave twice with
Ack_receiver::add_slave(). This could happen with old code.
- Removed Repl_semi_sync_master::check_and_switch() as it is not
needed anymore.
- Ensure that when we call Ack_receiver::remove_slave() that the slave
is removed from the listener before function returns.
- Call listener.listen_on_sockets() outside of mutex for better
performance and less contested mutex.
- Ensure that listening is ignoring newly added slaves when checking for
responses.
- Fixed the master ack_receiver listener is not killed if there are no
connected slaves (and thus stop semisync handling of future
connections). This could happen if all slaves sockets where would be
marked as unreliable.
- Added unlink() to base_ilist_iterator and remove() to
I_List_iterator. This enables us to remove 'dead' slaves in
Ack_recever::run().
- kill_zombie_dump_threads() now does killing of dump threads properly.
- It can now kill several threads (should be impossible but could
happen if IO slaves reconnects very fast).
- We now wait until the dump thread is done before starting the
dump.
- Added an error if kill_zombie_dump_threads() fails.
- Set thd->variables.server_id before calling
kill_zombie_dump_threads(). This simplies the code.
- Added a lot of comments both in code and tests.
- Removed DBUG_EVALUATE_IF "failed_slave_start" as it is not used.
Test changes:
- rpl.rpl_session_var2 added which runs rpl.rpl_session_var test with
semisync enabled.
- Some timings changed slight with startup of slave which caused
rpl_binlog_dump_slave_gtid_state_info.text to fail as it checked the
error log file before the slave had started properly. Fixed by
adding wait_for_pattern_in_file.inc that allows waiting for the
pattern to appear in the log file.
- Tests have been updated so that we first set
rpl_semi_sync_master_enabled on the master and then set
rpl_semi_sync_slave_enabled on the slaves (this is according to how
the MariaDB documentation document how to setup semi-sync).
- Error text "Master server does not have semi-sync enabled" has been
replaced with "Master server does not support semi-sync" for the
case when the master supports semi-sync but semi-sync is not
enabled.
Other things:
- Some trivial cleanups in Repl_semi_sync_master::update_sync_header().
- We should in 11.3 changed the default value for
rpl-semi-sync-master-wait-no-slave from TRUE to FALSE as the TRUE
does not make much sense as default. The main difference with using
FALSE is that we do not wait for semisync Ack if there are no slave
threads. In the case of TRUE we wait once, which did not bring any
notable benefits except slower startup of master configured for
using semisync.
Co-author: Brandon Nesterenko <brandon.nesterenko@mariadb.com>
This solves the problem reported in MDEV-32960 where a new
slave may not be registered in time and the master disables
semi sync because of that.
430 lines
13 KiB
Text
430 lines
13 KiB
Text
# ==== Purpose ====
|
|
#
|
|
# Test the time-delayed replication feature, i.e.,
|
|
# CHANGE MASTER TO MASTER_DELAY=X:
|
|
#
|
|
# - Verify that slave has executed the events after but not before the
|
|
# delay timeout.
|
|
#
|
|
# - Verify that delay is correct when slave is already lagging
|
|
# due to slow queries.
|
|
#
|
|
# - Verify that Seconds_Behind_Master is greater than or equal to the
|
|
# delay if the slave still has unprocessed events in the relay log
|
|
# and more time than the delay has elapsed since the last event was
|
|
# executed on the master.
|
|
#
|
|
# - Verify that STOP SLAVE works instantly even during a delay, and
|
|
# that it does not cause the waited-for event to be executed too
|
|
# early on slave.
|
|
#
|
|
# - Verify that changing back to no delay works.
|
|
#
|
|
# - Verify that RESET SLAVE sets the delay to 0.
|
|
#
|
|
# - Verify that setting a bad value for the delay gives an error.
|
|
#
|
|
# ==== Implementation ====
|
|
#
|
|
# We run the slave with 10 seconds lag.
|
|
#
|
|
# In general, to test that a query has not been executed by the slave
|
|
# before this time, we wait until the slave IO thread has received the
|
|
# event, and then 5 seconds more, and check that the table has not
|
|
# been updated. To test that a query has been executed after this
|
|
# time, we wait 10 seconds more.
|
|
#
|
|
# To simulate that the slave lags due to slow queries, we invoke a
|
|
# stored function that executes SLEEP if @@gloval.server_id==2. This
|
|
# requires that we run with binlog_format=STATEMENT.
|
|
#
|
|
# ==== Related Bugs and Worklogs ====
|
|
#
|
|
# WL#344: Time-delayed replication
|
|
# BUG#28760: Simulating a replication lag
|
|
# [duplicate] BUG#22072: configurable delayed replication
|
|
# [duplicate] BUG#21639: Add Replication Delay parameter
|
|
# BUG#56442: Slave executes delayed statements when STOP SLAVE is issued
|
|
#
|
|
# ==== Issues with this Test Case ====
|
|
#
|
|
# The test is inherently timing-sensitive (i.e., contains races) and
|
|
# is likely to fail sporadically on a loaded host.
|
|
#
|
|
# The test takes a long time; it sleeps for around 20*10 seconds.
|
|
|
|
--source include/big_test.inc
|
|
--source include/not_valgrind.inc
|
|
--source include/master-slave.inc
|
|
# Needed so that sleeps get executed in the slave SQL thread.
|
|
--source include/have_binlog_format_statement.inc
|
|
|
|
|
|
call mtr.add_suppression("Unsafe statement written to the binary log using statement format");
|
|
--connection slave
|
|
call mtr.add_suppression("Unsafe statement written to the binary log using statement format");
|
|
--connection master
|
|
|
|
|
|
# We assume that any simple operation takes zero time, with an error
|
|
# margin of $time1 seconds. Hence, if we run with a delay of $time2
|
|
# seconds, we expect that:
|
|
# - If we execute a query on master and wait $time1 seconds, then the
|
|
# query has been copied to slave but not yet executed.
|
|
# - If we execute a query on master and wait $time3 seconds, then the
|
|
# query has been executed.
|
|
--let $time1= 10
|
|
if (`SELECT '$max_query_execution_time' > 0`) {
|
|
--let $time1= $max_query_execution_time
|
|
}
|
|
--let $time2= `SELECT 2 * $time1`
|
|
--let $time3= `SELECT 3 * $time1`
|
|
|
|
|
|
--echo [on master]
|
|
CREATE TABLE t1 (a VARCHAR(100), b INT);
|
|
INSERT INTO t1 VALUES ("zero", 0);
|
|
|
|
|
|
--echo ==== Normal setup ====
|
|
|
|
--echo [on slave]
|
|
--sync_slave_with_master
|
|
|
|
--source include/stop_slave.inc
|
|
|
|
--echo # CHANGE MASTER TO MASTER_DELAY = 2*T
|
|
--disable_query_log
|
|
eval CHANGE MASTER TO MASTER_DELAY = $time2;
|
|
--enable_query_log
|
|
|
|
--source include/start_slave.inc
|
|
|
|
--let $assert_text= SHOW SLAVE STATUS should return the same delay that we set with CHANGE MASTER
|
|
--let $assert_cond= [SHOW SLAVE STATUS, SQL_Delay, 1] = $time2
|
|
--source include/rpl_assert.inc
|
|
|
|
--echo [on master]
|
|
--connection master
|
|
INSERT INTO t1 VALUES ('normal setup', 1);
|
|
|
|
--let $query_number= 1
|
|
--source include/delayed_slave_wait_on_query.inc
|
|
|
|
|
|
--echo ==== Slave lags "naturally" after master ====
|
|
|
|
--echo [on master]
|
|
--connection master
|
|
|
|
--disable_query_log
|
|
--echo # CREATE FUNCTION delay_on_slave(time_units INT) RETURNS INT BEGIN IF @@GLOBAL.server_id = 2 THEN RETURN SLEEP(time_units * T); ELSE RETURN 0; END IF; END
|
|
--eval CREATE FUNCTION delay_on_slave(time_units INT) RETURNS INT BEGIN IF @@GLOBAL.server_id = 2 THEN RETURN SLEEP(time_units * $time1); ELSE RETURN 0; END IF; END
|
|
--enable_query_log
|
|
|
|
INSERT INTO t1 SELECT delay_on_slave(3), 2;
|
|
|
|
--save_master_pos
|
|
INSERT INTO t1 VALUES ('slave is already lagging: this statement should execute immediately', 3);
|
|
INSERT INTO t1 SELECT delay_on_slave(2), 4;
|
|
|
|
--echo [on slave]
|
|
--source include/sync_slave_io_with_master.inc
|
|
--echo # sleep 1*T
|
|
--sleep $time1
|
|
|
|
--let $assert_text= No query executed
|
|
--let $assert_cond= MAX(b) = 1 FROM t1
|
|
--source include/rpl_assert.inc
|
|
|
|
--let $assert_text= Status should be 'Waiting until MASTER_DELAY...'
|
|
--let $assert_cond= "[SHOW SLAVE STATUS, Slave_SQL_Running_State, 1]" LIKE "Waiting until MASTER_DELAY%"
|
|
--source include/rpl_assert.inc
|
|
|
|
--echo # wait for first query to execute
|
|
--sync_with_master
|
|
|
|
--echo # sleep 1*T
|
|
--sleep $time1
|
|
|
|
--let $assert_text= Second query executed
|
|
--let $assert_cond= MAX(b) = 3 FROM t1
|
|
--source include/rpl_assert.inc
|
|
|
|
let $parallel= `SELECT @@GLOBAL.slave_parallel_threads`;
|
|
if (!$parallel)
|
|
{
|
|
let $assert_text= Status should be executing third query (i.e., 'User sleep');
|
|
let $assert_cond= "[SHOW SLAVE STATUS, Slave_SQL_Running_State, 1]" = "User sleep";
|
|
source include/rpl_assert.inc;
|
|
}
|
|
|
|
--echo # sleep 2*T
|
|
--sleep $time2
|
|
|
|
--let $assert_text= Third query executed
|
|
--let $assert_cond= MAX(b) = 4 FROM t1
|
|
--source include/rpl_assert.inc
|
|
|
|
--let $assert_text= Status should be 'Has read all relay log...'
|
|
--let $assert_cond= "[SHOW SLAVE STATUS, Slave_SQL_Running_State, 1]" LIKE "Slave has read all relay log%"
|
|
--source include/rpl_assert.inc
|
|
|
|
|
|
--echo ==== Seconds_Behind_Master ====
|
|
|
|
--echo # Bring slave to sync.
|
|
--source include/stop_slave.inc
|
|
CHANGE MASTER TO MASTER_DELAY = 0;
|
|
--source include/start_slave.inc
|
|
|
|
--connection master
|
|
INSERT INTO t1 VALUES ('Syncing slave', 5);
|
|
--sync_slave_with_master
|
|
|
|
--source include/stop_slave.inc
|
|
--echo # CHANGE MASTER TO MASTER_DELAY = 2*T
|
|
--disable_query_log
|
|
eval CHANGE MASTER TO MASTER_DELAY = $time2;
|
|
--enable_query_log
|
|
--source include/start_slave.inc
|
|
|
|
# Ensure that slave has started properly
|
|
--connection master
|
|
INSERT INTO t1 VALUES ('Syncing slave', 5);
|
|
--save_master_pos
|
|
--sync_slave_with_master
|
|
|
|
--connection master
|
|
INSERT INTO t1 VALUES (delay_on_slave(1), 6);
|
|
--save_master_pos
|
|
--connection slave
|
|
|
|
--echo # sleep 1*T
|
|
--sleep $time1
|
|
|
|
--let $assert_cond= [SHOW SLAVE STATUS, Seconds_Behind_Master, 1] >= 0 AND <1> < $time2
|
|
--let $assert_text= Seconds_Behind_Master should be between 0 and the 2*T
|
|
--source include/rpl_assert.inc
|
|
|
|
--echo # sleep 1*T
|
|
--sleep $time1
|
|
|
|
--let $assert_cond= [SHOW SLAVE STATUS, Seconds_Behind_Master, 1] >= $time2
|
|
--let $assert_text= Seconds_Behind_Master should be at least 2*T
|
|
--source include/rpl_assert.inc
|
|
|
|
--sync_with_master
|
|
|
|
|
|
--echo ==== STOP SLAVE / START SLAVE + DML ====
|
|
|
|
# Set up a longer delay.
|
|
--source include/stop_slave.inc
|
|
|
|
--echo # CHANGE MASTER TO MASTER_DELAY = 3*T
|
|
--disable_query_log
|
|
eval CHANGE MASTER TO MASTER_DELAY = $time3;
|
|
--enable_query_log
|
|
|
|
--source include/start_slave.inc
|
|
|
|
--echo [on master]
|
|
--connection master
|
|
INSERT INTO t1 VALUES ('stop slave and start slave: DML', 7);
|
|
|
|
--echo [on slave]
|
|
--connection slave
|
|
--echo # sleep 1*T
|
|
--sleep $time1
|
|
--let $timestamp_before_stop= `SELECT UNIX_TIMESTAMP()`
|
|
--let $relay_log_pos_before_stop= query_get_value(SHOW SLAVE STATUS, Relay_Log_Pos, 1)
|
|
--source include/stop_slave.inc
|
|
|
|
--let $assert_text= STOP SLAVE should finish quickly, not wait for the ongoing sleep to finish
|
|
--let $assert_cond= UNIX_TIMESTAMP() - $timestamp_before_stop < $time1
|
|
--source include/rpl_assert.inc
|
|
|
|
--let $assert_text= SQL thread position should not increase after STOP SLAVE
|
|
--let $assert_cond= [SHOW SLAVE STATUS, Relay_Log_Pos, 1] = $relay_log_pos_before_stop
|
|
--source include/rpl_assert.inc
|
|
|
|
--let $assert_text= Query should not be executed after STOP SLAVE
|
|
--let $assert_cond= MAX(b) = 6 FROM t1
|
|
--source include/rpl_assert.inc
|
|
|
|
--let $assert_text= Status should be '' after STOP SLAVE
|
|
--let $assert_cond= "[SHOW SLAVE STATUS, Slave_SQL_Running_State, 1]" = ""
|
|
--source include/rpl_assert.inc
|
|
|
|
--source include/start_slave.inc
|
|
|
|
--let $assert_text= START SLAVE should finish quickly
|
|
--let $assert_cond= UNIX_TIMESTAMP() - $timestamp_before_stop < $time1
|
|
--source include/rpl_assert.inc
|
|
|
|
--let $query_number= 7
|
|
--source include/delayed_slave_wait_on_query.inc
|
|
|
|
|
|
--echo ==== STOP SLAVE / START SLAVE + DDL ====
|
|
|
|
--echo This verifies BUG#56442
|
|
|
|
--echo [on master]
|
|
--connection master
|
|
CREATE TABLE t_check_dml_not_executed_prematurely (a INT);
|
|
--source include/save_master_pos.inc
|
|
|
|
--echo [on slave]
|
|
--connection slave
|
|
--echo # sleep 1*T
|
|
--sleep $time1
|
|
|
|
--let $timestamp_before_stop= `SELECT UNIX_TIMESTAMP()`
|
|
--let $relay_log_pos_before_stop= query_get_value(SHOW SLAVE STATUS, Relay_Log_Pos, 1)
|
|
--source include/stop_slave.inc
|
|
|
|
--let $assert_text= STOP SLAVE should finish quickly, not wait for the ongoing sleep to finish
|
|
--let $assert_cond= UNIX_TIMESTAMP() - $timestamp_before_stop < $time1
|
|
--source include/rpl_assert.inc
|
|
|
|
--let $assert_text= SQL thread position should not increase after STOP SLAVE
|
|
--let $assert_cond= [SHOW SLAVE STATUS, Relay_Log_Pos, 1] = $relay_log_pos_before_stop
|
|
--source include/rpl_assert.inc
|
|
|
|
--let $assert_text= Query should not be executed after STOP SLAVE
|
|
--let $assert_cond= COUNT(*) = 0 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = "t_check_dml_not_executed_prematurely"
|
|
--source include/rpl_assert.inc
|
|
|
|
--let $assert_text= Status should be '' after STOP SLAVE
|
|
--let $assert_cond= "[SHOW SLAVE STATUS, Slave_SQL_Running_State, 1]" = ""
|
|
--source include/rpl_assert.inc
|
|
|
|
--source include/start_slave.inc
|
|
|
|
--let $assert_text= START SLAVE should finish quickly
|
|
--let $assert_cond= UNIX_TIMESTAMP() - $timestamp_before_stop < $time1
|
|
--source include/rpl_assert.inc
|
|
|
|
--echo # sleep 1*T
|
|
--sleep $time1
|
|
|
|
--let $assert_text= DDL Query should not be executed after START SLAVE
|
|
--let $assert_cond= COUNT(*) = 0 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = "t_check_dml_not_executed_prematurely"
|
|
--source include/rpl_assert.inc
|
|
|
|
--let $assert_text= Status should be 'Waiting until MASTER_DELAY...'
|
|
--let $assert_cond= "[SHOW SLAVE STATUS, Slave_SQL_Running_State, 1]" LIKE "Waiting until MASTER_DELAY%"
|
|
--source include/rpl_assert.inc
|
|
|
|
--echo # sleep 1*T
|
|
--sleep $time1
|
|
|
|
--echo # sync with master (with timeout 1*T)
|
|
--source include/sync_with_master.inc
|
|
|
|
--let $assert_text= DDL Query should be executed
|
|
--let $assert_cond= COUNT(*) = 1 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = "t_check_dml_not_executed_prematurely"
|
|
--source include/rpl_assert.inc
|
|
|
|
--let $assert_text= Status should be 'Has read all relay log...'
|
|
--let $assert_cond= "[SHOW SLAVE STATUS, Slave_SQL_Running_State, 1]" LIKE "Slave has read all relay log%"
|
|
--source include/rpl_assert.inc
|
|
|
|
--source include/check_slave_is_running.inc
|
|
|
|
|
|
--echo ==== Change back to no delay ====
|
|
|
|
--echo [on slave]
|
|
--connection slave
|
|
--source include/stop_slave.inc
|
|
CHANGE MASTER TO MASTER_DELAY = 0;
|
|
|
|
--let $assert_text= Delay should be 0 when we set it to 0
|
|
--let $assert_cond= [SHOW SLAVE STATUS, SQL_Delay, 1] = 0
|
|
--source include/rpl_assert.inc
|
|
|
|
--source include/start_slave.inc
|
|
|
|
--echo [on master]
|
|
--connection master
|
|
INSERT INTO t1 VALUES ('change back to no delay', 8);
|
|
|
|
--echo [on slave]
|
|
--source include/sync_slave_io_with_master.inc
|
|
--echo # sleep 1*T
|
|
--sleep $time1
|
|
|
|
--let $assert_text= Query should be executed
|
|
--let $assert_cond= MAX(b) = 8 FROM t1
|
|
--source include/rpl_assert.inc
|
|
|
|
--let $assert_text= Status should be 'Slave has read all relay log...'
|
|
--let $assert_cond= "[SHOW SLAVE STATUS, Slave_SQL_Running_State, 1]" Like "Slave has read all relay log%"
|
|
--source include/rpl_assert.inc
|
|
|
|
|
|
--echo ==== Reset delay with RESET SLAVE ====
|
|
|
|
--source include/stop_slave.inc
|
|
CHANGE MASTER TO MASTER_DELAY = 71;
|
|
--source include/start_slave.inc
|
|
|
|
--let $assert_text= Delay should be 71 when we set it to 71
|
|
--let $assert_cond= [SHOW SLAVE STATUS, SQL_Delay, 1] = 71
|
|
--source include/rpl_assert.inc
|
|
|
|
--source include/stop_slave.inc
|
|
RESET SLAVE;
|
|
--echo [on master]
|
|
--connection master
|
|
RESET MASTER;
|
|
--echo [on slave]
|
|
--connection slave
|
|
--source include/start_slave.inc
|
|
|
|
--let $assert_text= Delay should be 0 after RESET SLAVE
|
|
--let $assert_cond= [SHOW SLAVE STATUS, SQL_Delay, 1] = 0
|
|
--source include/rpl_assert.inc
|
|
|
|
|
|
--echo ==== Set an invalid value for the delay ====
|
|
|
|
--source include/stop_slave.inc
|
|
|
|
--echo # Expect error for setting negative delay
|
|
--error ER_PARSE_ERROR
|
|
CHANGE MASTER TO MASTER_DELAY = -1;
|
|
|
|
--echo # Expect that it's ok to set delay of 2^31-1
|
|
CHANGE MASTER TO MASTER_DELAY = 2147483647;
|
|
--echo # Expect error for setting delay between 2^31 and 2^32-1
|
|
--error ER_MASTER_DELAY_VALUE_OUT_OF_RANGE
|
|
CHANGE MASTER TO MASTER_DELAY = 2147483648;
|
|
|
|
--echo # Expect error for setting delay to nonsense
|
|
--error ER_PARSE_ERROR
|
|
CHANGE MASTER TO MASTER_DELAY = blah;
|
|
|
|
# todo: CHANGE MASTER TO MASTER_DELAY = 999999999999999999999999999
|
|
# should give error
|
|
|
|
CHANGE MASTER TO MASTER_DELAY = 0;
|
|
--source include/start_slave.inc
|
|
|
|
|
|
--echo ==== Clean up ====
|
|
|
|
--echo [on master]
|
|
--connection master
|
|
DROP TABLE t1, t_check_dml_not_executed_prematurely;
|
|
DROP FUNCTION delay_on_slave;
|
|
|
|
--echo [on slave]
|
|
--sync_slave_with_master
|
|
SELECT @@GLOBAL.slave_parallel_mode;
|
|
SELECT @@GLOBAL.slave_parallel_threads;
|
|
|
|
--source include/rpl_end.inc
|