(WL#794). This can be of interest in some recovery-from-backup scenarios, and also when you have
two databases in one mysqld, having a certain similarity and you want one db to be updated when the other is
(some sort of trigger).
Plus small fix for BUG#3568 "MySQL server crashes when built --with-debug and CHANGE MASTER +MASTER_POS_WAIT"
sql/mysqld.cc:
new option --replicate-same-server-id
sql/slave.cc:
new option replicate_same_server_id, to force a slave to execute its own queries.
Small fix for BUG#3568 "MySQL server crashes when built --with-debug and CHANGE MASTER +MASTER_POS_WAIT"
sql/slave.h:
new option --replicate-same-server-id
BitKeeper/deleted/.del-libmysqld.def~8edf7b8780ce943c:
Delete: VC++Files/libmysqld/libmysqld.def
sql/slave.cc:
Fix to modify tmp_buf instead of buf, which is a const char *
In tables_ok(), when there is no table having "updating==TRUE" in the list,
return that we don't replicate this statement (the slave is supposed to
replicate *changes* only).
In practice, the case can only happen for this statement:
DELETE t FROM t,u WHERE ... ;
tables_ok(t,u) will now return 0, which (check all_tables_not_ok())
will give a chance to tables_ok(t) to run.
sql/slave.cc:
In tables_ok(), when there is no table having "updating==TRUE" in the list,
return that we don't replicate this statement (the slave is supposed to
replicate *changes* only).
In practice, the case can only happen for this statement:
DELETE t FROM t,u WHERE ... ;
tables_ok(t,u) will now return 0, which (check all_tables_not_ok())
will give a chance to tables_ok(t) to run.
as we transform the 3.23 Load_log_event into a 4.0 Create_file_log_event which is one
byte longer, we need to increment event_len. The bug was that we did not increment it,
so later in code the end 0 was not seen so there was for example a segfault in
strlen(fname) because fname was not 0-terminated.
Other problems remain in 3.23->4.0 replication of LOAD DATA INFILE but they are less serious:
Exec_master_log_pos and Relay_log_space are incorrect. I'll document them.
They are not fixable without significant code changes (if you fix those problems in 4.0,
you get assertion failures somewhere else etc), * which are already done in 5.0.0 *.
sql/slave.cc:
In 3.23->4.0 replication of LOAD DATA INFILE:
as we transform the 3.23 Load_log_event into a 4.0 Create_file_log_event which is one
byte longer, we need to increment event_len.
So we need to modify the event_len stored in the event.
And we need to decrement event_len when we compute the offset in the master's binlog.
Backport of a part of this changeset of 4.1:
ChangeSet@1.1753.1.1, 2004-04-05 13:56:05+03:00, monty@mysql.com
which fixes the bug.
sql/slave.cc:
even if mi is already inited (replication already run once before),
we need to seek back to the beginning of the relay log to be able
to later check the binlog's magic number.
too big by 6 bytes. So I add code to substract 6 bytes if the master is 3.23.
This is not perfect (because it won't work if the slave I/O thread has not
noticed yet that the master is 3.23), but as long as the slave I/O thread
starts Exec_master_log_pos will be ok.
It must be merged to 4.1 but not to 5.0 (or it can be, because of #if MYSQL_VERSION_ID),
because 5.0 already works if the master is 3.23 (and in a more natural way:
in 5.0 we store the end_log_pos in the binlog and relay log).
I had to move functions from slave.h to slave.cc to satisfy gcc.
sql/log_event.cc:
make the event's length 6 bytes shorter if the master is 3.23
sql/slave.cc:
Moving several st_relay_log_info methods out of the declaration of the struct,
because gcc complained that 'mi' was not declared.
Substracting 6 bytes from the event's length in inc_pos() if the master is 3.23.
sql/slave.h:
moving several methods out of the declaration of st_relay_log_info.
Removing 'inline', let's have the compiler decide.
We introduce a new function mysql_test_parse_for_slave().
If the slave sees that the query got a really bad error on master
(killed e.g.), then it calls this function to know if this query
can be ignored because of replicate-*-table rules (do not worry
about replicate-*-db rules: they are checked so early that they have
no bug). If the answer is yes, it skips the query and continues. If
it's no, then it stops and say "fix your slave data manually" (like it
did before this change).
mysql-test/r/rpl_error_ignored_table.result:
result update
mysql-test/t/rpl_error_ignored_table-slave.opt:
ignore more tables
mysql-test/t/rpl_error_ignored_table.test:
we test if a killed query on the master, is ignored on the slave
if the tables it involves should be excluded because of replicate-*-table
rules.
sql/log_event.cc:
If the query got a really bad error on the master (thread killed etc),
parse it to test the table names: if the replicate-*-do|ignore-table
rules say "this query must be ignored" then we exit gracefully;
otherwise we warn about the bad error and tell DBA to check/fix it.
Before this change, we always warned and stopped.
sql/mysql_priv.h:
new function
sql/slave.cc:
don't print error immediately as we need to do one more test to
be sure.
sql/sql_parse.cc:
we add a function mysql_test_parse_for_slave(), to be used only
by the slave if it wants to know if the query should be ignored or not;
so this function only parses the query, does not execute it.
re-using unused LOCK_active_mi to serialize all administrative
commands related to replication:
START SLAVE, STOP SLAVE, RESET SLAVE, CHANGE MASTER, init_slave()
(replication autostart at server startup), end_slave() (replication
autostop at server shutdown), LOAD DATA FROM MASTER.
This protects us against a handful of deadlocks (like BUG#2921
when two START SLAVE, but when two STOP SLAVE too).
Removing unused variables.
sql/item_func.cc:
We don't need LOCK_active_mi just to MASTER_POS_WAIT().
sql/repl_failsafe.cc:
no need for macro
sql/set_var.cc:
no need for macro
sql/slave.cc:
Re-using unused LOCK_active_mi to serialize all administrative
commands related to replication:
START SLAVE, STOP SLAVE, RESET SLAVE, CHANGE MASTER, init_slave()
(replication autostart at server startup), end_slave() (replication
autostop at server shutdown), LOAD DATA FROM MASTER.
This protects us against a handful of deadlocks.
Removing unused variables.
sql/slave.h:
Re-using LOCK_active_mi to serialize administrative replication commands.
Macros unneeded. Removing unneeded variables.
sql/sql_parse.cc:
found unused variable.
Replacing macros.
sql/sql_show.cc:
replacing macros
ChangeSet 1.1620.12.1 and ChangeSet 1.1625.2.1
from 4.1. This makes the slave I/O thread flush the relay log
after every event, which provides additional safety in case
of brutal crash (reduces chances to lose a part of the relay log).
sql/repl_failsafe.cc:
update for new prototype
sql/slave.cc:
The slave I/O thread now flushes the relay log after writing
every event to it, like we already do in 4.1.
sql/slave.h:
new prototype
sql/sql_repl.cc:
update for new prototype
- the one about BUG#2921
- the one about relay log flushing
Both will be rewritten in a next changeset
(this one will not be pushed before the next changeset).
sql/log.cc:
undo
sql/log_event.cc:
undo
sql/repl_failsafe.cc:
undo
sql/slave.cc:
undo
sql/slave.h:
undo
sql/sql_repl.cc:
undo
BUILD/compile-pentium-debug-max:
Added --with-raid
configure.in:
Removed -DFN_NO_CASE_SENCE for Mac OS X as this is not always true
mysql-test/install_test_db.sh:
Added --skip-warnings
mysql-test/mysql-test-run.sh:
Fixes to get --gdb and --ddd to work
mysql-test/r/lowercase_table2.result:
Test for lower_case_table_names=2 and temporary tables
mysql-test/r/lowercase_table3.result:
Fixed error message
mysql-test/r/multi_update.result:
Test of behaviour of multi-table-delete and alias
mysql-test/t/lowercase_table2.test:
Test for lower_case_table_names=2 and temporary tables
mysql-test/t/lowercase_table3.test:
Fixed error
mysql-test/t/multi_update.test:
Test of behaviour of multi-table-delete and alias (Bug #2940)
mysys/mf_iocache.c:
Renamed _flush_io_cache to my_b_flush_io_cache
sql/ha_myisam.cc:
Added comment
sql/lock.cc:
Extra debugging
sql/log.cc:
New parameter to flush_relay_log_info
sql/log_event.cc:
New parameter to flush_relay_log_info
sql/mf_iocache.cc:
Removed not used header files
sql/mysqld.cc:
More debugging info
Less warnings when run with --skip-warnings
sql/opt_range.cc:
More debug information
sql/repl_failsafe.cc:
New parameter to flush_relay_log_info
sql/slave.cc:
First start SQL thread, then start IO thread. This fixed a raze condition in SLAVE START (Bug #2921)
Ensure that we have a lock on the IO thread before flushing a relay log file that. The original code could core dump when a relay log rotated.
sql/slave.h:
New parameter to flush_relay_log_info
sql/sql_base.cc:
Added warning
sql/sql_handler.cc:
Indentation fix
sql/sql_repl.cc:
New parameter to flush_relay_log_info
sql/sql_select.cc:
Fixed problem with deleting temporary tables when using lower_case_table_names=2. (Bug #2858)
sql/sql_table.cc:
Fixed comment
sql/sql_yacc.yy:
Removed compiler warning
include/my_sys.h:
Fixed usage of unpack_filename
mysys/mf_pack.c:
Changed unpack_filename() to return length of result string.
mysys/test_fn.c:
Fixed usage of unpack_filename
sql/sql_db.cc:
Fixed memory leak with raid tables
sql/table.cc:
Fixed usage of unpack_filename
release the mutex before exiting the function, or it will be kept forever
(=> START SLAVE, STOP SLAVE, etc will hang).
sql/slave.cc:
release the mutex before exiting the function, or it will be kept forever
(=> START SLAVE, STOP SLAVE, etc will hang).
we change THD::system_thread from a 'bool' to a bitmap to be able to
distinguish between delayed-insert threads and slave threads.
- Fix for BUG#1701 "Update from multiple tables" (one line in sql_parse.cc,
plus a new test rpl_multi_update.test). That's just adding an initialization.
sql/repl_failsafe.cc:
comment to warn about this unused code
sql/slave.cc:
Now thd->system_thread is a bitmap, not a bool.
sql/sql_class.h:
'bool' for THD::system_thread is not accurate enough; sometimes we need
to distinguish between delayed-insert threads and slave threads;
so changing THD::system_thread to a bitmap (uint).
sql/sql_insert.cc:
thd.system_thread is now a bitmap
sql/sql_parse.cc:
We need to initialize thd->lex.select_lex.options in mysql_init_query();
it's already initialized in dispatch_command() but replication calls
mysql_parse() directly, thus bypassing dispatch_command().
Not initing it here leads to a query influencing the next query,
in the slave SQL thread.
The initialization in dispatch_command() must be kept as this
command uses the variable in tests, even when the command was not a
query (i.e. when mysql_init_query() was not called).
The problem was that when the slave SQL thread reads a hot relay log (hot = the one being written to by the
slave I/O thread), it must have the LOCK_log. It already took it for read_log_event(), but needs
it also for check_binlog_magic().
This should fix all recently reported failures of the rpl_max_relay_size test in 4.1 and 5.0
(though the bug exists since 4.0, it showed up first in 5.0).
sql/slave.cc:
Fix for BUG#2011 "rare race condition producing "binlog has bad magic number" error in slave".
The problem was that when the slave SQL thread reads a hot relay log (hot = the one being written to by the
slave I/O thread), it must have the LOCK_log. It already took it for read_log_event(), but needs
it also for check_binlog_magic().
rli->save_temporary_tables and slave_open_temp_tables
(in old 4.0 you could make "SHOW STATUS LIKE 'slave_open_temp_tables'" grow
indefinitely by doing RESET SLAVE and replicating always the same CREATE
TEMPORARY TABLE).
It's critical to reset save_temporary_tables to 0 (otherwise you may later
read memory which has been freed) so this changeset should go into 4.1.
mysql-test/r/rpl_reset_slave.result:
result update
mysql-test/t/rpl_reset_slave.test:
test for RESET SLAVE and creating twice the same temp table in the slave.
sql/slave.cc:
when we delete the slave's temp tables (when slave server shuts down and when
RESET SLAVE), we reset 2 variables: rli->save_temporary_tables & slave_open_temp_tables.
- when we don't have in_addr_t, use uint32.
- a forgotten initialization of slave_proxy_id in sql/log_event.cc (was not really "forgot", was
"we needn't init it there", but there was one case where we needed...).
- made slave_proxy_id always meaningful in THD and Log_event, so we can
rely more on it (no need to test if it's meaningful). THD::slave_proxy_id
is equal to THD::thread_id except for the slave SQL thread.
- clean up the slave's temporary table (i.e. free their memory) when slave
server shuts down.
extra/resolveip.c:
removed #define as it is simpler to put it in my_net.h
(because we need the #define elsewhere)
include/my_net.h:
When in_addr_t is not defined, use uint32.
libmysql/libmysql.c:
using in_addr_t is more generic.
libmysql/manager.c:
using in_addr_t is more generic.
mysql-test/t/rpl_chain_temp_table.test:
comments
sql/log_event.cc:
* Had forgot to initialize slave_proxy_id in the event constructor (char* buf...).
Initializing is in fact only needed for Create_file_log_event, because
it uses slave_proxy_id even if it does not write an event to the binlog
(it uses slave_proxy_id to write it to SQL-LOAD.info).
* When we write events we now always write slave_proxy_id, which is now always
meaningful (as thd->slave_proxy_id is now always meaningful, see change in
sql_class.cc).
sql/mini_client.cc:
in_addr_t is more generic.
sql/slave.cc:
A RELAY_LOG_INFO method to free the slave's temporary tables from memory
at slave's server shutdown.
It is called by end_slave(), which is called by close_connections(),
which is called when the server terminates
(close_connections() is just before clean_up(); putting the call in
clean_up() was buggy, as active_mi is already deleted by close_connections().
sql/slave.h:
new method
sql/sql_class.cc:
By default we set THD::slave_proxy_id to THD::thread_id,
so THD::slave_proxy_id is always meaningful (not 0).
It's always the same as the thread id except for the slave
SQL thread.
"If 2 master threads with same-name temp table, slave makes bad binlog"
and (two birds with one stone) for
BUG#1240 "slave of slave breaks when STOP SLAVE was issud on parent slave
and temp tables".
Here is the design change:
in a slave running with --log-slave-updates, events are now logged with the
thread id they had on the master. So no more id conflicts between master threads,
but introduces id conflicts between one master thread and one normal
client thread connected to the slave. This is solved by storing the server id
in the temp table's name.
New test which requires mysql-test-run to be run with --manager,
otherwise it will be skipped.
Undoing a Monty's change (hum, a chill runs down my spine ;) which was
"Cleanup temporary tables when slave ends" in ChangeSet 1.1572.1.1.
mysql-test/mysql-test-run.sh:
One new test which needs more than one slave so must be hardcoded in mysql-test-run.sh.
sql/log_event.cc:
The event needs to carry a slave_proxy_id (which is set at event's creation
and used at event's logging).
This is used for events created by ::exec_event() in the slave SQL thread:
now we want to log these events with the thread id they had on the master.
This is so that several same-name temp tables simultaneously created on
the master end up with not the same thread id in the slave's binlog.
sql/log_event.h:
Query and Load need to carry a slave_proxy_id, like they carried a thread_id
(to replicate temp tables well).
sql/slave.cc:
Do not free temp tables in the slave SQL thread. Or they will be lost when
one does STOP SLAVE / START SLAVE.
We even save them in rli->save_temporary_tables and set thd->temporary_tables=0
to prevent them to be freed.
sql/sql_base.cc:
Put the server id in the table cache key name for temp tables
(we already put the slave_proxy_id, but we also need the server id
in case normal clients (not slave threads) are using temp tables
on the slave).
sql/unireg.h:
4 more bytes, to store the server id.
while the slave is connected.
mysql-test/t/rpl_trunc_binlog.test:
don't RESET MASTER while the slave is connected; this could confuse the master or slave.
(In replication you don't RESET MASTER while a slave is connected!)
sql/slave.cc:
typo
Fixed chsize() problem on windows
Extend default timeout on windows clients to 1 year (to avoid timeout problems)
include/mysql.h:
Added client timeouts (for TCP/IP)
libmysql/libmysql.c:
Added client timeouts (for TCP/IP)
mysql-test/r/create.result:
More tests for CREATE TABLE IF NOT EXISTS ... SELECT
mysql-test/t/create.test:
More tests for CREATE TABLE IF NOT EXISTS ... SELECT
mysys/my_chsize.c:
Fix for windows
sql/handler.h:
Remove not used field 'if_not_exists'
Ordered fields to be more optimized for new CPU's
Added field 'table_existed'
sql/slave.cc:
Cleanup temporary tables when slave ends
sql/sql_class.h:
Remove not used 'do_not_drop' field
sql/sql_insert.cc:
Better fix for CREATE TABLE IF NOT EXISTS ... SELECT
sql/sql_table.cc:
Better fix for CREATE TABLE IF NOT EXISTS ... SELECT
a Format_description_log_event (or maybe it will be named
Description_log_event) which is not recognized by 4.0, so
a 4.0 can't be a slave of 5.0. We detect it early to produce
a helpful message instead of "corrupted relay log" later.
sql/slave.cc:
Make the slave die if master is 5.0.
Now LOAD DATA FROM MASTER does not drop the database, instead it only tries to
create it, and drops/creates table-by-table.
* replicate_wild_ignore_table='db1.%' is now considered as "ignore the 'db1'
database as a whole", as it already works for CREATE DATABASE and DROP DATABASE.
mysql-test/r/rpl000009.result:
result update
mysql-test/t/rpl000009.test:
test that LOAD DATA FROM MASTER does not drop databases,
but rather table by table, thus preserving non-replicated tables.
Test that LOAD DATA FROM MASTER reports the error when a table could not
be dropped (system's "permission denied" for example).
Test that LOAD TABLE FROM MASTER reports the error when the table already exists.
sql/repl_failsafe.cc:
* replicate_wild_ignore_table='db1.%' is now considered as "ignore the 'db1'
database as a whole", as it already works for CREATE DATABASE and DROP DATABASE.
* If a db matches replicate_*_db rules, we don't drop/recreate it because this
could drop some tables in this db which could be slave-specific. Instead,
we do a CREATE DATABASE IF EXISTS, and we will drop each table which has
an equivalent on the master, table-by-table.
sql/slave.cc:
New argument to drop the table in create_table_from_dump()
(LOAD TABLE/DATA FROM MASTER are the only places where this function is used).
This is needed because LOAD DATA FROM MASTER does not drop the database anymore.
The behaviour when the table exists is unchanged: LOAD DATA silently replaces
the table, LOAD TABLE gives error.
sql/slave.h:
new argument to drop the table in fetch_master_table
sql/sql_parse.cc:
do not drop the table in LOAD TABLE FROM MASTER (this behaviour is already
true; but changes in LOAD DATA FROM MASTER made the argument needed).
Don't start the SQL slave thread with SQL_BIG_SELECTS;
it's better to inhibate max_join_size instead.
sql/slave.cc:
OPTION_BIG_SELECTS does more than ignoring max_join_size (talks to the optimiser),
just ignore max_join_size.
sql/slave.h:
comments
For example the Binlog_dump thread (on the master) sometimes showed "Slave:".
And there were confusing messages where "binlog" was employed instead
of "relay log".
sql/log.cc:
MYSQL_LOG::wait_for_update() is used by the binlog_dump and I/Oslave threads,
and it updates thd->proc_info, so we need a bool to not show the same
proc_info for 2 different things (previously we showed "Slave: etc" and that's
bad for a binlog_dump thread).
sql/slave.cc:
Clearer thd-proc_info for slave threads.
sql/sql_class.h:
prototype change
sql/sql_repl.cc:
clearer thd->proc_info for binlog_dump thread
OPTION_BIG_SELECTS.
sql/slave.cc:
The slave threads MUST not care about max_join_size.
I can imagine the case of a slave where users can connect and do SELECTs, but
DBA does not want them to issue crazy SELECTs, but he/she still wants replication
to work.
Before, this just printed a warning to the error log (not fatal) but that
was still annoying.
when the SQL thread stops, set rli->inside_transaction to 0. This is needed if the user
later restarts replication from a completely different place where there are only autocommit
statements.
* Detect the case where the master died while flushing the binlog cache to the binlog
and stop with error. Cannot add a testcase for this in 4.0 (I tested it manually)
as the slave always runs with --skip-innodb.
sql/log_event.cc:
Detect the case where the master died while flushing the binlog cache to the binlog:
in that case, we have a BEGIN with no COMMIT/ROLLBACK in the relay log; we detect
this with rli->inside_transaction in Rotate_log_event::exec_event() (which is the
only right place to detect this, see comments). When we see it, we stop with error.
In 4.1, I had put code in Start_log_event::exec_event(); I'll remove it next time
I push in the 4.1 tree.
sql/slave.cc:
* Use slave_print_error instead of sql_print_error, to put the info in SHOW SLAVE STATUS too.
* Fix for a potential bug:
when the SQL thread stops, set rli->inside_transaction to 0. This is not needed if
replication later restarts from the same position; but this is needed if the user
restarts replication from a completely different place where there are only autocommit
statements (in that case, if we didn't set to 0, the position would never increment in SHOW
SLAVE STATUS, even if queries are processed well).
Let's say the lack of comments did not help me ;)
Copying it back again and adding comments; now 3.23->4.0
replication of LOAD DATA INFILE works again.
sql/slave.cc:
Enabling again process_io_create_file
"LOAD DATA INFILE is badly filtered by binlog-*-db rules".
There will probably be a second final one to merge Dmitri's changes
to rpl_log.result and mine.
2 new tests:
rpl_loaddata_rule_m : test of logging of LOAD DATA INFILE when the master has binlog-*-db rules,
rpl_loaddata_rule_s : test of logging of LOAD DATA INFILE when the slave has binlog-*-db rules and --log-slave-updates.
mysql-test/r/rpl_loaddata.result:
Test that logging of LOAD DATA INFILE is done on the slave
mysql-test/t/rpl_loaddata.test:
Test that logging of LOAD DATA is done on the slave
sql/log.cc:
debug info
sql/log_event.cc:
* Append_block, Exec_load and Delete_file now have a member 'db' like Create_file.
This member is filled by mysql_load(). It is used for filtering by binlog-*-db rules,
that's all. It's not written to the binlog, and so can't be read from the binlog.
In other words, that's temporary info which is stored in the event and lost when
it is written and deleted.
* Better error messages in Append_block et al. events.
* The slave now logs (log-slave-updates) the Create_file et al. events in mysql_load()
(they are not directly copied from the events in the relay log, because this
prevented filtering by binlog-*-db rules). Before, mysql_load() in the slave
did no logging, now it does the logging, as in any regular thread.
sql/log_event.h:
New member 'db' for Append_block et al. events.
sql/slave.cc:
Removed useless code. Why was it useless:
- CREATE_FILE_EVENT is not defined in 3.23. It appeared in 4.0.
- in queue_old_event(), which is called only if the master is 3.23, we had a
case CREATE_FILE_EVENT:
so this case can be removed.
- this case was the only caller of process_io_create_file() so this function
can be removed.
sql/sql_load.cc:
Pass the db to events, so that they can be well filtered.
sql/sql_repl.cc:
Pass the db to events so that they can be well filtered.
log-slave-updates since this causes unexpected values in
Exec_master_log_pos in A->B->C replication setup, synchronization
problems in master_pos_wait()...
Still this brokes some functionality in sql/repl_failsafe.cc
(but this file is not used now)
mysql-test/r/rpl_log.result:
SHOW BINLOG EVENTS for binlog on slave should give the same
Orig_log_pos and Pos values
sql/log_event.cc:
Do not propagate our master's log pos to our bin log
sql/repl_failsafe.cc:
Added comment about broken SHOW NEW MASTER
sql/slave.cc:
Do not propagate our master's log pos to our bin log
sql/sql_class.cc:
THD::log_pos is no longer needed
sql/sql_class.h:
THD::log_pos is no longer needed
sql/sql_parse.cc:
Added comment about broken SHOW NEW MASTER
(Mostly code cleanups)
include/my_sys.h:
Removed not used define
myisam/mi_check.c:
Indentation change
mysql-test/t/rpl_insert_id.test:
Add test if server supports innodb
mysys/mf_format.c:
Remove QUOTE handling from fn_format()
(fn_format() should not have anything to do with quoting things)
sql/log_event.cc:
Removed some unnecessary casts (by changing functions to use const char *)
Cleaned up some error messages to make them shorter and (hopefully) more readable.
Fixed wrong format strings
Restored 'thd->options' on error.
sql/mini_client.cc:
Changed order of include files to remove compilation warning
sql/mysqld.cc:
Add proper quoting of service arguments (don't use fn_format)
sql/slave.cc:
Simple optimization and cleanup.
Changed rewrite_db() and print_slave_db_safe() to use const char* to avoid casting of arguments when calling functions.
Cleanup of some error messages.
sql/slave.h:
Changed protypes to use const char *
sql/sql_acl.cc:
Simple optimization
vio/viosslfactories.c:
Changed order of include files to remove compilation warning
- Bug #985: "Between RESET SLAVE and START SLAVE, SHOW SLAVE STATUS is wrong."
Now RESET SLAVE puts correct info in mi->host etc. A new test rpl_reset_slave
for that.
- Bug #986: "CHANGE MASTER & START SLAVE do not reset error columns in SHOW
SLAVE STATUS". Now these reset the errors.
mysql-test/r/rpl_loaddata.result:
result update.
mysql-test/t/rpl_loaddata.test:
Test that RESET SLAVE, START SLAVE and CHANGE MASTER all reset
Last_slave_error and Last_slave_errno (columns of SHOW SLAVE STATUS).
We do it in this test because that's one of tests which have
an intentional query error on the slave.
sql/slave.cc:
As we need TWICE the code to copy command-line options (--master-host etc)
to mi (we already had it in init_master_info, but we also need it in RESET
SLAVE to fix bug#985), I make a function of this code.
And a function to reset Last_slave_error and Last_slave_errno (we need
it in CHANGE MASTER, RESET SLAVE, and at the start of the SQL thread).
sql/slave.h:
declarations for new functions.
sql/sql_repl.cc:
copy --master-host etc to mi in RESET SLAVE, so that SHOW SLAVE STATUS
shows correct information.
I extended the task to cleaning error messages, making them look nicer,
and making the output of SHOW SLAVE STATUS (column Last_error) be as complete
as what's printed on the .err file;
previously we would have, for a failure of a replicated LOAD DATA INFILE:
- in the .err, 2 lines:
"duplicate entry 2708 for key 1"
"failed loading SQL_LOAD-5-2-2.info"
- and in SHOW SLAVE STATUS, only:
"failed loading SQL_LOAD-5-2-2.info".
Now SHOW SLAVE STATUS will contain the concatenation of the 2 messages.
sql/log_event.cc:
Print the default database when replication stops because of an error. Previously, we had:
"error "Duplicate entry 87987 for key 1", query 'insert into t values(87987)'", ie the db
was not mentioned, making it hard for cases where the same table name is used in
several databases.
Lengthened some error messages (for failing replication of LOAD DATA: mention the table
and the db).
Changes so that SHOW SLAVE STATUS reports as complete errors as the .err file.
sql/slave.cc:
Removed a useless declaration (the rewrite_db() function is already declared in slave.h).
Added missing ')' in error messages.
Tried to make error messages look nicer (previously we had
"do START SLAVE;, error_code=1062"
now we'll have
"do START SLAVE; . Error_code=1062".
This form has been discussed, I agree it's no panacea, but it's still more readable
like this. To be improved in the future :)
sql/slave.h:
declarations.
mysql-test/t/rpl_flush_log_loop.test:
Add timer to avoid problem when 'flush logs' is executed before we have read all data from master
sql/log.cc:
Better fix for bug #791:
Mark log as LOG_TO_BE_OPENED instead of LOG_CLOSED when it's closed and opened.
sql/mysqld.cc:
Better startup message
sql/slave.cc:
Fix argument to close()
sql/sql_class.h:
Better handling of log.close()
a safer way of initing the mutexes in MYSQL_LOG.
is_open() is now always thread-safe.
See each file for details.
sql/handler.cc:
is_open() with locks
sql/item_func.cc:
is_open() with locks
sql/log.cc:
No more 'inited'.
We now always use is_open() in a thread-safe manner.
This simplifies some functions (no more need to test is_open() twice).
sql/log_event.cc:
is_open() with locks
sql/mysqld.cc:
Init mutexes for the global MYSQL_LOG objects.
We care about no_rotate, because we can't do it in open() anymore (because
we don't have 'inited' anymore).
sql/repl_failsafe.cc:
is_open() with locks
sql/slave.cc:
init pthread objects (mutexes, conds) in the constructor of st_relay_log_info.
Some better locking in rotate_relay_log().
sql/sql_base.cc:
is_open() with locks
sql/sql_class.h:
Before, we inited LOCK_log in MYSQL_LOG::open(), so in other places of the code
when we were never 100% sure that it had been inited. For example, if the server
was running without --log-bin, ::open() was not called so the mutex was not
inited. We could detect it with !inited, but not safely as 'inited' was not
protected by any mutex.
So now:
we *always* init the LOCK_log mutex, even if the log is not used. We can't init
the mutex in MYSQL_LOG's constructor, because for global objects like
mysql_bin_log, mysql_log etc, the constructor is called before MY_INIT(), but
safe_mutex depends on MY_INIT(). So we have a new function MYSQL_LOG::init_pthread_objects
which we call in main(), after MY_INIT().
For the relay log, we call this function in the constructor of
st_relay_log_info, which is called before any function tries to
use the relay log (the relay log is always invoked as rli.relay_log).
So now we should be safe in all cases and we don't need 'inited'.
sql/sql_db.cc:
is_open() with locks
sql/sql_delete.cc:
is_open() with locks
sql/sql_insert.cc:
is_open() with locks
sql/sql_load.cc:
is_open() with locks
sql/sql_parse.cc:
is_open() with locks
sql/sql_rename.cc:
is_open() with locks
sql/sql_repl.cc:
is_open() with locks
sql/sql_table.cc:
is_open() with locks
sql/sql_update.cc:
is_open() with locks
FLUSH LOGS now rotates relay logs,
and a new variable max_relay_log_size.
Plus a very small bit of code cleaning.
libmysqld/lib_sql.cc:
open_log has no default arguments anymore.
mysql-test/r/rpl_flush_log_loop.result:
result update now that FLUSH LOGS rotates relay logs.
mysql-test/r/rpl_log.result:
result update now that FLUSH LOGS rotates relay logs.
mysql-test/r/rpl_rotate_logs.result:
result update now that max_binlog_size is 4096.
mysql-test/t/rpl_rotate_logs-master.opt:
now max_binlog_size must be a multiple of 4096 (see change in mysqld.cc)
sql/log.cc:
Got rid of default arguments of various MYSQL_LOG methods (the default arguments
made code reading uneasy).
Set max_size in ::init().
New function set_max_size() to set max_size of a MYSQL_LOG on-the-fly.
More DBUG info.
sql/mysql_priv.h:
no defaults in open_log().
New variables max_relay_log_size.
sql/mysqld.cc:
New variable and option max_relay_log_size.
max_binlog_size and max_relay_log_size are multiples of IO_SIZE.
No more default arguments for log functions.
sql/set_var.cc:
New variable max_relay_log_size.
If it is 0, then max_binlog_size will apply to relay logs.
When one of these variables is changed, fix_max_%log_size is called
to update max_size of the binary and/or relay logs.
sql/slave.cc:
New function rotate_relay_log().
sql/slave.h:
New function rotate_relay_log().
sql/sql_class.h:
New member max_size of MYSQL_LOG (for automatic rotation).
New method set_max_size() for setting on-the-fly.
sql/sql_parse.cc:
Flush the relay log in FLUSH LOGS.
so I commit again in a fresh tree.
Fix for bug#763 (Relay_log_space too big by 4 bytes),
plus comments and DBUG_PRINT, and we don't start replication
if --bootstrap.
mysql-test/r/rpl_log.result:
Result update
mysql-test/r/rpl_log_pos.result:
Result update
sql/mysqld.cc:
Don't start replication if in bootstrap mode (bootstrap isn't supposed to have
several threads).
sql/slave.cc:
Fix for bug 763 (Relay_log_space too big by 4 bytes).
A DBUG_PRINT.
sql/sql_acl.cc:
Replaced a return by DBUG_RETURN (happened to find this reading a debug log).
sql/sql_repl.cc:
A comment.
mysql-test/r/insert_select.result:
Fixed results
mysql-test/r/join_outer.result:
New test case for inner join table dependency
mysql-test/t/insert_select.test:
Remove not used drop tables.
Fixed table names
mysql-test/t/join_outer.test:
New test case for inner join table dependency
sql/slave.cc:
Simple optimizations
mysql-test/r/innodb.result:
Fixed test case after innodb optimize->analyze fix
mysys/mf_pack.c:
Added comments
sql/log_event.cc:
Fixed usage of fn_format()
sql/slave.cc:
Indentation fixes and comments cleanup
sql/sql_repl.cc:
Comment cleanup
mysql-test/r/rpl_rotate_logs.result:
result update
mysql-test/t/rpl_rotate_logs.test:
comments and test update with the error code
sql/slave.cc:
A DBUG_PRINT
sql/sql_repl.cc:
Use ER_MASTER_INFO instead of custom message and zero error code (which display
badly).
More messages.
Testcase for bug 651.
client/mysqltest.c:
More explicit error message if MASTER_POS_WAIT() returns NULL.
mysql-test/r/rpl_loaddata.result:
result update
mysql-test/r/rpl_master_pos_wait.result:
result update
mysql-test/t/rpl000001.test:
sync_with_master (=MASTER_POS_WAIT()) was called when we could expect the SQL slave thread had stopped.
As I yesterday changed code so that "SQL thread stops => MASTER_POS_WAIT() returns NULL immediately" (bugfix),
sync_with_master received NULL (on build.mysql.com, not on my machine; this is a question of milliseconds,
if the slave server will process MASTER_POS_WAIT() before or after the slave SQL thread has stopped), and
in mysqltest.c, sync_with_master complained that it could not sync.
So I just remove this sync_with_master, which does not make sense anymore: we just wait for the slave SQL
thread to stop.
mysql-test/t/rpl_loaddata.test:
Discovered we had wait_for_slave_to_stop, so used it as it automates things.
mysql-test/t/rpl_master_pos_wait.test:
Discovered we had 'send' to send a query without waiting for the resultn so could had a testcase for bug 651.
Shorter timeouts as there is no risk the position is reached.
sql/slave.cc:
A longer DBUG_PRINT.
thd->enter_cond() and exit_cond(), so that the I/O thread accepts to stop
when it's waiting for relay log space.
Reset ignore_log_space_limit to 0 when the SQL thread terminates.
mysql-test/r/rpl_relayspace.result:
result update
mysql-test/t/rpl_relayspace-slave.opt:
smaller relay_log_space_limit to speed up things.
mysql-test/t/rpl_relayspace.test:
Less queries in the test, to make it simpler.
Testcase if the IO thread blocked in wait_for_relay_log_space
accepts to stop when STOP SLAVE.
sql/slave.cc:
thd->enter_cond() and exit_cond(), so that the I/O thread accepts to stop
when it's waiting on cond (waiting for relay log space).
Reset ignore_log_space_limit to 0 when the SQL thread terminates.
Could not add a testcase for this: if the test goes into a MASTER_POS_WAIT, it waits
until this terminates (even doing "connection other_con" to launch "stop slave" is blocked).
- In MASTER_POS_WAIT() don't test if the I/O slave is running, but if the SQL thread
is running.
- Some DBUG info for this bugfix.
sql/slave.cc:
Fix for bug 651: now a dying SQL slave threads wakes up any waiting MASTER_POS_WAIT().
In MASTER_POS_WAIT() don't test if the I/O slave is running, but if the SQL thread
is running.
Some DBUG info.
support issue with an unclear message which can have N reasons for appearing.
This should help us know at which point it failed, and get the errno when
my_open was involved (as the reason for the unclear message is often a
permission problem).
RESET SLAVE resets last_error and last_errno in SHOW SLAVE STATUS (without this,
rpl_loaddata.test, which is expected to generate an error in last_error, influenced
rpl_log_pos.test).
A small test update.
Added STOP SLAVE to mysql-test-run to get rid of several stupid error messages
which are printed while the master restarts and the slave attempts/manages to
connect to it and sends it nonsense binlog requests.
mysql-test/mysql-test-run.sh:
Before running a test, stop slave threads if they exist (if they don't
the script goes on fine). This also works fine with the manager.
Before this change, when the master was stopped/restarted (which happened before
the slave server was stopped/restarted), the slave threads
noticed the stop (so printed an error message in slave.err), then managed to
reconnect (to the new master, the one that is running for the _next_ test),
and this reconnection had time to produce error messages (because, for example,
the binlog the slave thread was asking had been deleted) before the slave server
was killed. This change reduces by 10% (40 lines) slave.err in replication tests.
mysql-test/r/rpl000018.result:
Result update.
mysql-test/t/rpl000018.test:
This test does "show master logs" so should do "reset master" instead of
relying on the previous tests.
sql/slave.cc:
More error messages.
sql/sql_repl.cc:
More error messages.
RESET SLAVE resets last_error and last_errno in SHOW SLAVE STATUS.
we now make a distinction between if the master is < 3.23.57, 3.23 && >=57, and 4.x
(before the 2 3.23 were one). This is because in 3.23.57 we have a way to distinguish between
a Start_log_event written at server startup and one written at FLUSH LOGS, so we
have a way to know if the slave must drop old temp tables or not.
Change: mi->old_format was bool, now it's enum (to handle 3 cases). However, functions
which had 'bool old_format' as an argument have their prototypes unchanged, because
the old old_format == 0 now corresponds to the enum value BINLOG_FORMAT_CURRENT which
is equal to 0, so boolean tests are left untouched. The only case were we use mi->old_format
as an enum instead of casting it implicitly to a bool, is in Start_log_event::exec_event,
where we want to distinguish between the 3 possible enum values.
sql/log_event.cc:
Fix for bug 254 :
we now make a distinction between if the master is < 3.23.57, 3.23 && >=57, and 4.x
(before the 2 3.23 were one), to know if the slave must drop old temp tables or not.
sql/slave.cc:
Fix for bug 254 : mi->old_format is now enum.
An unrelated comment.
sql/slave.h:
fix for bug 254 : mi->old_format is now enum.
Plus a changeset which I had committed but forgot to push (and this changeset is lost on
another computer, so I recreate it here). This changeset is "user-friendly SHOW BINLOG EVENTS
and CHANGE MASTER TO when log positions < 4 are used.
sql/slave.cc:
fix for bug 576 (DBUG_ASSERT failure when using CHANGE MASTER TO RELAY_LOG_POS=4).
sql/sql_repl.cc:
User-friendly SHOW BINLOG EVENTS:
SHOW BINLOG EVENTS FROM 0: currently one gets
MASTER> show binlog events from 0;
ERROR 1220: Error when executing command SHOW BINLOG EVENTS: Invalid log position
so we silently convert <4 to 4.
sql/sql_yacc.yy:
User-friendly CHANGE MASTER TO:
presently when one does CHANGE MASTER TO MASTER_LOG_POS=0 he gets
030425 10:12:41 Slave I/O thread: connected to master 'root@localhost:3306', r
eplication started in log 'gbichot-bin.013' at position 151
030425 10:12:41 Error reading packet from server: Client requested master to st
art replication from impossible position (server_errno=1236)
030425 10:12:41 Got fatal error 1236: 'Client requested master to start replica
tion from impossible position' from master when reading data from binary log
030425 10:12:41 Slave I/O thread exiting, read up to log 'gbichot-bin.013', pos
ition 151
while she/he probably just wanted to start at the beginning of the
binlog, which is 4. So we silently convert <4 to 4 in sql_yacc.yy
(i.e. in the slave code; fortunately all versions have the same
BIN_LOG_HEADER_SIZE=4 and we should not change this). See comments
for an explaination of why we have to do this in sql_yacc.yy,
not in sql_repl.cc.
Same thing for CHANGE MASTER TO RELAY_LOG_POS.
sql/unireg.h:
warning comment
