mariadb/mysql-test/suite/rpl/t/rpl_dual_pos_advance.test

125 lines
2.5 KiB
Text
Raw Normal View History

Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
# This test checks that in a dual-head setup
# A->B->A, where A has --log-slave-updates (why would it?
# assume that there is a C as slave of A),
# then the Exec_master_log_pos of SHOW SLAVE STATUS does
# not stay too low on B(BUG#13023 due to events ignored because
# of their server id).
# It also will test BUG#13861.
source include/master-slave.inc;
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
source include/have_innodb.inc;
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
# set up "dual head"
BUG#37718: rpl.rpl_stm_mystery22 fails sporadically on pushbuild Problem 1: The test waits for an error in the slave sql thread, then resolves the error and issues 'start slave'. However, there is a gap between when the error is reported and the slave sql thread stops. If this gap was long, the slave would still be running when 'start slave' happened, so 'start slave' would fail and cause a test failure. Fix 1: Made wait_for_slave_sql_error wait for the slave to stop instead of wait for error in the IO thread. After stopping, the error code is verified. If the error code is wrong, debug info is printed. To print debug info, the debug printing code in wait_for_slave_param.inc was moved out to a new file, show_rpl_debug_info.inc. Problem 2: rpl_stm_mystery22 is a horrible name, the comments in the file didn't explain anything useful, the test was generally hard to follow, and the test was essentially duplicated between rpl_stm_mystery22 and rpl_row_mystery22. Fix 2: The test is about conflicts in the slave SQL thread, hence I renamed the tests to rpl_{stm,row}_conflicts. Refactored the test so that the work is done in extra/rpl_tests/rpl_conflicts.inc, and rpl.rpl_{row,stm}_conflicts merely sets some variables and then sourced extra/rpl_tests/rpl_conflicts.inc. The tests have been rewritten and comments added. Problem 3: When calling wait_for_slave_sql_error.inc, you always want to verify that the sql thread stops because of the expected error and not because of some other error. Currently, wait_for_slave_sql_error.inc allows the caller to omit the error code, in which case all error codes are accepted. Fix 3: Made wait_for_slave_sql_error.inc fail if no error code is given. Updated rpl_filter_tables_not_exist accordingly. Problem 4: rpl_filter_tables_not_exist had a typo, the dollar sign was missing in a 'let' statement. Fix 4: Added dollar sign. Problem 5: When replicating from other servers than the one named 'master', the wait_for_slave_* macros were unable to print debug info on the master. Fix 5: Replace parameter $slave_keep_connection by $master_connection. mysql-test/extra/rpl_tests/rpl_conflicts.test: rpl_stm_mystery22 and rpl_row_mystery22 have now been refactored and renamed: The two test cases rpl.rpl_stm_conflicts.test and rpl.rpl_row_conflicts.test just set some parameters, and then source include/rpl_tests/rpl_conflicts.test. Also, cleaned up the test case a bit, and fixed BUG#37718. mysql-test/include/show_rpl_debug_info.inc: Factored out the debug printing code from wait_for_slave_param.inc to a new file, show_rpl_debug_info.inc. Also removed the $slave_keep_connection parameter, and replaced it by $master_connection. This allows printing debug info on the master, no matter what the name of the master connection is. mysql-test/include/start_slave.inc: Replaced $slave_keep_connection by $master_connection. mysql-test/include/stop_slave.inc: Replaced $slave_keep_connection by $master_connection. mysql-test/include/sync_slave_io_with_master.inc: Replaced $slave_keep_connection by $master_connection. mysql-test/include/wait_for_slave_io_to_start.inc: Replaced $slave_keep_connection by $master_connection. mysql-test/include/wait_for_slave_io_to_stop.inc: Replaced $slave_keep_connection by $master_connection. mysql-test/include/wait_for_slave_param.inc: Factored out the debug printing code from wait_for_slave_param.inc to a new file, show_rpl_debug_info.inc. Also removed the $slave_keep_connection parameter, and replaced it by $master_connection. This allows printing debug info on the master, no matter what the name of the master connection is. Had to move the printing of debug info out of the while loop because of BUG number 41913. mysql-test/include/wait_for_slave_sql_error.inc: Made it wait until the slave sql thread has stopped. This takes very short time and avoids race condition bugs in test cases (e.g., fixes BUG#37718). Replaced $slave_keep_connection by $master_connection. mysql-test/include/wait_for_slave_sql_error_and_skip.inc: Since wait_for_slave_sql_error now waits for the slave sql thread to stop too, wait_for_slave_sql_error_and_skip does not have to wait for the slave sql thread to stop. Also, since wait_for_slave_sql_error now requires the parameter $slave_sql_errno to be set, wait_for_slave_sql_error_and_skip requires that as well: updated the usage instructions. mysql-test/include/wait_for_slave_sql_to_start.inc: Replaced $slave_keep_connection by $master_connection. mysql-test/include/wait_for_slave_sql_to_stop.inc: Replaced $slave_keep_connection by $master_connection. mysql-test/include/wait_for_slave_to_start.inc: Replaced $slave_keep_connection by $master_connection. mysql-test/include/wait_for_slave_to_stop.inc: Replaced $slave_keep_connection by $master_connection. mysql-test/suite/rpl/r/rpl_row_conflicts.result: update result file mysql-test/suite/rpl/r/rpl_stm_conflicts.result: update result file mysql-test/suite/rpl/t/rpl_dual_pos_advance.test: Replaced $slave_keep_connection by $master_connection. mysql-test/suite/rpl/t/rpl_filter_tables_not_exist.test: Set $slave_sql_errno, since it is now required. Add dollar sign to $show_sql_error (without dollar sign, mtr makes it an environment variable). mysql-test/suite/rpl/t/rpl_row_conflicts.test: rpl_stm_mystery22 and rpl_row_mystery22 have now been refactored and renamed: The two test cases rpl.rpl_stm_conflicts.test and rpl.rpl_row_conflicts.test just set some parameters, and then source include/rpl_tests/rpl_conflicts.test. Also, cleaned up the test case a bit, and fixed BUG#37718. mysql-test/suite/rpl/t/rpl_row_mystery22.test: rpl_stm_mystery22 and rpl_row_mystery22 have now been refactored and renamed: The two test cases rpl.rpl_stm_conflicts.test and rpl.rpl_row_conflicts.test just set some parameters, and then source include/rpl_tests/rpl_conflicts.test. Also, cleaned up the test case a bit, and fixed BUG#37718. mysql-test/suite/rpl/t/rpl_stm_conflicts.test: rpl_stm_mystery22 and rpl_row_mystery22 have now been refactored and renamed: The two test cases rpl.rpl_stm_conflicts.test and rpl.rpl_row_conflicts.test just set some parameters, and then source include/rpl_tests/rpl_conflicts.test. Also, cleaned up the test case a bit, and fixed BUG#37718.
2009-01-09 15:12:31 +01:00
# Needed for debug info in wait_for_slave_sql_to_stop.
let $master_connection= slave;
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
connection slave;
reset master;
connection master;
--replace_result $SLAVE_MYPORT SLAVE_PORT
eval change master to master_host="127.0.0.1",master_port=$SLAVE_MYPORT,master_user="root";
start slave;
# now we test it
connection slave;
create table t1 (n int);
save_master_pos;
connection master;
sync_with_master;
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
#
# BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if
# log-slave-updates and circul repl
#
stop slave;
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
create table t2 (n int); # create one ignored event
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
save_master_pos;
connection slave;
sync_with_master;
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
connection slave;
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
show tables;
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
save_master_pos;
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
create table t3 (n int) engine=innodb;
set @a=1;
insert into t3 values(@a);
begin;
insert into t3 values(2);
insert into t3 values(3);
commit;
insert into t3 values(4);
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
connection master;
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
# bug is that START SLAVE UNTIL may stop too late, we test that by
# asking it to stop before creation of t3.
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
start slave until master_log_file="slave-bin.000001",master_log_pos=195;
--source include/wait_for_slave_sql_to_stop.inc
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
# then BUG#13861 causes t3 to show up below (because stopped too
# late).
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
show tables;
# ensure that we do not break set @a=1; insert into t3 values(@a);
start slave until master_log_file="slave-bin.000001",master_log_pos=438;
--source include/wait_for_slave_sql_to_stop.inc
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
select * from t3;
# ensure that we do not break transaction
start slave until master_log_file="slave-bin.000001",master_log_pos=663;
--source include/wait_for_slave_sql_to_stop.inc
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
select * from t3;
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
start slave;
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
# BUG#13023 is that Exec_master_log_pos may stay too low "forever":
connection master;
create table t4 (n int); # create 3 ignored events
create table t5 (n int);
create table t6 (n int);
save_master_pos;
connection slave;
sync_with_master;
connection slave;
save_master_pos;
connection master;
# then BUG#13023 caused hang below ("master" looks behind, while it's
# not in terms of updates done).
sync_with_master;
show tables;
# cleanup
stop slave;
reset slave;
BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if log-slave-updates and circul repl Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. mysql-test/r/rpl_dual_pos_advance.result: A test case for BUG#13861. mysql-test/t/rpl_dual_pos_advance.test: A test case for BUG#13861. sql/log_event.cc: Store length of event. This is needed for further calculation of the beginning of event. sql/slave.cc: Slave SQL thread may execute one extra event when there are events skipped by slave I/O thread (e.g. originated by the same server). Whereas it was requested not to do so by the UNTIL condition. This happens because we compare with the end position of previously executed event. This is fine when there are no skipped by slave I/O thread events, as end position of previous event equals to start position of to be executed event. Otherwise this position equals to start position of skipped event. This is fixed by: - reading the event to be executed before checking if the until condition is satisfied. - comparing the start position of the event to be executed. Since we do not have the start position available, we compute it by subtracting event length from end position (which is available). - if there are no events on the event queue at the slave sql starting time, that meet until condition, we stop immediately, as in this case we do not want to wait for next event. sql/slave.h: Added master_log_pos parametr to is_until_satisfied(). mysql-test/t/rpl_dual_pos_advance-slave.opt: New BitKeeper file ``mysql-test/t/rpl_dual_pos_advance-slave.opt''
2008-02-22 19:07:07 +04:00
drop table t1,t2,t3,t4,t5,t6;
Fix for BUG#13023: "SQL Thread is up but doesn't move forward". Details in slave.cc; in short we now record whenever the slave I/O thread ignores a master's event because of its server id, and use this info in the slave SQL thread to advance Exec_master_log_pos. Because if we do not, this variable stays at the position of the last executed event, i.e. the last *non-ignored* executed one, which may not be the last of the master's binlog (and so the slave *looks* behind the master though it's data-wise it's not). mysql-test/t/rpl_dual_pos_advance-master.opt: empty; its goal is just to trigger a server restart after running the test, so that the master forgets that it was a slave (otherwise it affects the following tests). sql/log.cc: No more default arguments for Rotate_log_event constructor. MYSQL_LOG::appendv() is now called without mutex. sql/log_event.cc: Moving one Rotate_log_event constructor from log_event.h. Support for on-demand choice of duplicating the string argument of the constructor or not (because there now are needs for both alternatives, see slave.cc). sql/log_event.h: We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/slave.cc: A comment for BUG#13861 (to be fixed). llstr() instead of %ld as the number is ulonglong. mi->rli becomes rli in some places. Fix for BUG#13023: - in the slave I/O thread, whenever we ignore an event because of its server id we update a couple of coordinates in memory - in the slave SQL thread, whenever we bump into the end of the latest relay log, we check this couple of coordinates to see if we should advance our Exec_master_log_pos. - when the slave I/O thread terminates it saves these in-memory coordinates into a Rotate event in the relay log, so that they are durable. sql/slave.h: A couple of coordinates in RELAY_LOG_INFO to keep track of the last ignored events received by the slave I/O thread (ignored because of the server id). mysql-test/r/rpl_dual_pos_advance.result: New BitKeeper file ``mysql-test/r/rpl_dual_pos_advance.result'' mysql-test/t/rpl_dual_pos_advance.test: Test for BUG#13023 (with a part, disabled, to test BUG#13861 when I fix it). Before the fix, this test used to hang.
2005-10-12 13:29:55 +02:00
save_master_pos;
connection slave;
sync_with_master;
# End of 4.1 tests