From f5c22f8b1c1407db2daf66af1a4ba5c70b730ad0 Mon Sep 17 00:00:00 2001 From: "John H. Embretsen" Date: Thu, 18 Mar 2010 11:26:27 +0100 Subject: Bug#52060 - test udf fails on Snow Leopard reverse DNS lookup of "localhost" returns "broadcasthost" on Snow Leopard, and NULL on most others. Simply ignore the output, as this is not an essential part of UDF testing. --- mysql-test/r/udf.result | 2 -- mysql-test/t/udf.test | 7 +++++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/mysql-test/r/udf.result b/mysql-test/r/udf.result index 601b364fbbe..4104ca44e66 100644 --- a/mysql-test/r/udf.result +++ b/mysql-test/r/udf.result @@ -38,8 +38,6 @@ ERROR HY000: Can't initialize function 'reverse_lookup'; Wrong number of argumen select reverse_lookup("127.0.0.1"); select reverse_lookup(127,0,0,1); select reverse_lookup("localhost"); -reverse_lookup("localhost") -NULL select avgcost(); ERROR HY000: Can't initialize function 'avgcost'; wrong number of arguments: AVGCOST() requires two arguments select avgcost(100,23.76); diff --git a/mysql-test/t/udf.test b/mysql-test/t/udf.test index 7bf252040e5..9295969c05f 100644 --- a/mysql-test/t/udf.test +++ b/mysql-test/t/udf.test @@ -51,14 +51,17 @@ select lookup("localhost"); --error ER_CANT_INITIALIZE_UDF select reverse_lookup(); -# These two functions should return "localhost", but it's +# These two function calls should return "localhost", but it's # depending on configuration, so just call them and don't log the result --disable_result_log select reverse_lookup("127.0.0.1"); select reverse_lookup(127,0,0,1); ---enable_result_log +# This function call may return different results depending on platform, +# so ignore results (see Bug#52060). select reverse_lookup("localhost"); +--enable_result_log + --error ER_CANT_INITIALIZE_UDF select avgcost(); --error ER_CANT_INITIALIZE_UDF -- cgit v1.2.1 From 700fca4c32e4deed62838da2d822c0681359e648 Mon Sep 17 00:00:00 2001 From: Andrei Elkin Date: Fri, 19 Mar 2010 11:06:40 +0200 Subject: Bug #51648 DBUG_SYNC_POINT is not defined on all platforms and mtr cant pre-check that DBUG_SYNC_POINT has at least one strong limitation that it's not defined on all platforms. It has issues cooperating with @@debug. All in all its functionality is superseded by DEBUG_SYNC facility and there is no reason to maintain the old less flexible one. Fixed with adding debug_sync_set_action() function as a facility to set up a sync-action in the server sources code and re-writing existing simulations (found 3) to use it. Couple of tests have been reworked as well. The patch offers a pattern for setting sync-points in replication threads where the standard DEBUG_SYNC does not suffice to reach goals. mysql-test/extra/rpl_tests/rpl_get_master_version_and_clock.test: rewriting the test from GET_LOCK()-based to DEBUG_SYNC-based; a pattern of usage DEBUG_SYNC for replication testing is provided. mysql-test/suite/rpl/r/rpl_get_master_version_and_clock.result: results are changed. mysql-test/suite/rpl/t/rpl_get_master_version_and_clock.test: rewriting the test from GET_LOCK()-based to DEBUG_SYNC-based; limiting the test to run only with MIXED binlog-format as the test last some 10 secs sensitively contributing to the total of tests run. mysql-test/suite/rpl/t/rpl_show_slave_running.test: rewriting the test from GET_LOCK()-based to DEBUG_SYNC-based. sql/debug_sync.cc: adding debug_sync_set_action() function as a facility to set up a sync-action in the server sources code. sql/debug_sync.h: externalizing debug_sync_set_action(). sql/item_func.cc: purging sources from DBUG_SYNC_POINT. sql/mysql_priv.h: purging sources from DBUG_SYNC_POINT. sql/slave.cc: rewriting failure simulations to base on DEBUG_SYNC rather than GET_LOCK()-based DBUG_SYNC_POINT. sql/sql_repl.cc: removing an orphan failure simulation line because no counterpart in tests existing. --- .../rpl_get_master_version_and_clock.test | 53 +++++++++++++--- .../rpl/r/rpl_get_master_version_and_clock.result | 31 ++++----- .../suite/rpl/r/rpl_show_slave_running.result | 11 ++-- .../rpl/t/rpl_get_master_version_and_clock.test | 27 +++++--- mysql-test/suite/rpl/t/rpl_show_slave_running.test | 12 ++-- sql/debug_sync.cc | 38 +++++++++++ sql/debug_sync.h | 1 + sql/item_func.cc | 74 ---------------------- sql/mysql_priv.h | 14 ---- sql/slave.cc | 33 +++++++++- sql/sql_repl.cc | 1 - 11 files changed, 152 insertions(+), 143 deletions(-) diff --git a/mysql-test/extra/rpl_tests/rpl_get_master_version_and_clock.test b/mysql-test/extra/rpl_tests/rpl_get_master_version_and_clock.test index 89c136d8893..c392686454d 100644 --- a/mysql-test/extra/rpl_tests/rpl_get_master_version_and_clock.test +++ b/mysql-test/extra/rpl_tests/rpl_get_master_version_and_clock.test @@ -3,26 +3,53 @@ # The common part of the "rpl_get_master_version_and_clock" test. # Restart slave under network disconnection between slave and master # following the steps: -# 1 - Got DBUG_SYNC_POINT lock -# 2 - Set DBUG_SYNC_POINT before call mysql_real_query(...) function in get_master_version_and_clock(...) function and hang here -# 3 - shutdown master server for simulating network disconnection -# 4 - Release DBUG_SYNC_POINT lock -# 5 - Check if the slave I/O thread tries to reconnect to master. +# 0 - Set DEBUG_SYNC_ACTION to wait +# before call mysql_real_query(...) function in get_master_version_and_clock(...) +# function and hang here +# 1 - activate a sync-point through the $dbug_sync_point argument of the test +# 2 - shutdown master server for simulating network disconnection +# 3 - signal to the IO thread through $debug_sync_action to unhold from the sync-point +# 4 - check if the slave I/O thread tries to reconnect to master. # -# Note: Please make sure initialize the $debug_lock when call the test script. +# Note: make sure to initialize the $debug_sync_action and $dbug_sync_point +# before calling the test script. # +# Pattern of usage: +# +# The caller test supplies the DBUG_EXECUTE_IF name +# +# let $dbug_sync_point = 'dbug_execute_if_name'; +# +# as well as the action list for DEBUG_SYNC +# +# let $debug_sync_action= 'now signal signal_name'; +# +# The $dbug_sync_point becomes the value of @@global.debug generating +# a newly started IO-slave thread's session value. +# Notice incremental operations to add and remove dbug_execute_if_name +# from the global variable allows propagation more dbug arguments +# out of mtr. +# The action list is to fire at proper time according to test logics +# (see pp 0-4 above). +# + connection slave; -if (`SELECT '$debug_lock' = ''`) +if (`SELECT $debug_sync_action = ''`) { - --die Cannot continue. Please set value for $debug_lock. + --die Cannot continue. Please set value for debug_sync_action. } # Restart slave --disable_warnings stop slave; source include/wait_for_slave_to_stop.inc; + +eval SET @@global.debug= "+d,$dbug_sync_point"; + start slave; source include/wait_for_slave_to_start.inc; +--echo slave is going to hang in get_master_version_and_clock + connection master; # Write file to make mysql-test-run.pl expect the "crash", but don't start # it until it's told to @@ -35,7 +62,9 @@ EOF shutdown_server 10; connection slave; -eval SELECT RELEASE_LOCK($debug_lock); +--echo slave is unblocked + +eval SET DEBUG_SYNC=$debug_sync_action; # Show slave last IO errno connection slave; @@ -53,6 +82,12 @@ if (`SELECT '$last_io_errno' = '2013' || # CR_SERVER_LOST --echo NETWORK ERROR } +# deactivate the sync point of get_master_version_and_clock() +# now to avoid restarting IO-thread to re-enter it. +# There will be a new IO thread forked out with its @@session.debug +# unset. +eval set @@global.debug = "-d,$dbug_sync_point"; + # Write file to make mysql-test-run.pl start up the server again --append_file $MYSQLTEST_VARDIR/tmp/mysqld.1.expect restart diff --git a/mysql-test/suite/rpl/r/rpl_get_master_version_and_clock.result b/mysql-test/suite/rpl/r/rpl_get_master_version_and_clock.result index d054cb573d3..a34c536feb8 100644 --- a/mysql-test/suite/rpl/r/rpl_get_master_version_and_clock.result +++ b/mysql-test/suite/rpl/r/rpl_get_master_version_and_clock.result @@ -7,34 +7,24 @@ start slave; call mtr.add_suppression("Slave I/O: Master command COM_REGISTER_SLAVE failed: .*"); call mtr.add_suppression("Fatal error: The slave I/O thread stops because master and slave have equal MySQL server ids; .*"); call mtr.add_suppression("Slave I/O thread .* register on master"); -SELECT IS_FREE_LOCK("debug_lock.before_get_UNIX_TIMESTAMP"); -IS_FREE_LOCK("debug_lock.before_get_UNIX_TIMESTAMP") -1 -SELECT GET_LOCK("debug_lock.before_get_UNIX_TIMESTAMP", 1000); -GET_LOCK("debug_lock.before_get_UNIX_TIMESTAMP", 1000) -1 -set global debug= 'd,debug_lock.before_get_UNIX_TIMESTAMP'; stop slave; +SET @@global.debug= "+d,'debug_lock.before_get_UNIX_TIMESTAMP'"; start slave; -SELECT RELEASE_LOCK("debug_lock.before_get_UNIX_TIMESTAMP"); -RELEASE_LOCK("debug_lock.before_get_UNIX_TIMESTAMP") -1 +slave is going to hang in get_master_version_and_clock +slave is unblocked +SET DEBUG_SYNC='now SIGNAL signal.get_unix_timestamp'; Check network error happened here NETWORK ERROR -SELECT IS_FREE_LOCK("debug_lock.before_get_SERVER_ID"); -IS_FREE_LOCK("debug_lock.before_get_SERVER_ID") -1 -SELECT GET_LOCK("debug_lock.before_get_SERVER_ID", 1000); -GET_LOCK("debug_lock.before_get_SERVER_ID", 1000) -1 -set global debug= 'd,debug_lock.before_get_SERVER_ID'; +set @@global.debug = "-d,'debug_lock.before_get_UNIX_TIMESTAMP'"; stop slave; +SET @@global.debug= "+d,'debug_lock.before_get_SERVER_ID'"; start slave; -SELECT RELEASE_LOCK("debug_lock.before_get_SERVER_ID"); -RELEASE_LOCK("debug_lock.before_get_SERVER_ID") -1 +slave is going to hang in get_master_version_and_clock +slave is unblocked +SET DEBUG_SYNC='now SIGNAL signal.get_server_id'; Check network error happened here NETWORK ERROR +set @@global.debug = "-d,'debug_lock.before_get_SERVER_ID'"; set global debug= ''; reset master; include/stop_slave.inc @@ -43,3 +33,4 @@ start slave; *** must be having the replicate-same-server-id IO thread error *** Slave_IO_Errno= 1593 Slave_IO_Error= Fatal error: The slave I/O thread stops because master and slave have equal MySQL server ids; these ids must be different for replication to work (or the --replicate-same-server-id option must be used on slave but this does not always make sense; please check the manual before using it). +SET DEBUG_SYNC= 'RESET'; diff --git a/mysql-test/suite/rpl/r/rpl_show_slave_running.result b/mysql-test/suite/rpl/r/rpl_show_slave_running.result index da26190e76d..598762d5188 100644 --- a/mysql-test/suite/rpl/r/rpl_show_slave_running.result +++ b/mysql-test/suite/rpl/r/rpl_show_slave_running.result @@ -4,11 +4,9 @@ reset master; reset slave; drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9; start slave; +SET DEBUG_SYNC= 'RESET'; include/stop_slave.inc -SELECT GET_LOCK("debug_lock.before_get_running_status_yes", 1000); -GET_LOCK("debug_lock.before_get_running_status_yes", 1000) -1 -set global debug= 'd,debug_lock.before_get_running_status_yes'; +set global debug= 'd,dbug.before_get_running_status_yes'; Slave_running, Slave_IO_Running, Slave_SQL_Running, must be OFF, NO, NO in three following queries SHOW STATUS LIKE 'Slave_running'; Variable_name Value @@ -22,9 +20,7 @@ Variable_name Value Slave_running OFF Slave_IO_Running= No Slave_SQL_Running= No -SELECT RELEASE_LOCK("debug_lock.before_get_running_status_yes"); -RELEASE_LOCK("debug_lock.before_get_running_status_yes") -1 +SET DEBUG_SYNC='now SIGNAL signal.io_thread_let_running'; Slave_running, Slave_IO_Running, Slave_SQL_Running must be OFF YES NO in three following queries SHOW STATUS LIKE 'Slave_running'; Variable_name Value @@ -39,4 +35,5 @@ Slave_running ON Slave_IO_Running= Yes Slave_SQL_Running= Yes set global debug= ''; +SET DEBUG_SYNC= 'RESET'; End of tests diff --git a/mysql-test/suite/rpl/t/rpl_get_master_version_and_clock.test b/mysql-test/suite/rpl/t/rpl_get_master_version_and_clock.test index 24309e8a14a..4a9276d9880 100644 --- a/mysql-test/suite/rpl/t/rpl_get_master_version_and_clock.test +++ b/mysql-test/suite/rpl/t/rpl_get_master_version_and_clock.test @@ -16,8 +16,16 @@ source include/master-slave.inc; source include/have_debug.inc; +source include/have_debug_sync.inc; + +# +# The test is not supposed to have any binglog affairs. +# Hence it's enough it to run only with one binlog format +# +source include/have_binlog_format_mixed.inc; connection slave; + call mtr.add_suppression("Slave I/O: Master command COM_REGISTER_SLAVE failed: .*"); call mtr.add_suppression("Fatal error: The slave I/O thread stops because master and slave have equal MySQL server ids; .*"); call mtr.add_suppression("Slave I/O thread .* register on master"); @@ -25,20 +33,16 @@ call mtr.add_suppression("Slave I/O thread .* register on master"); #Test case 1: Try to get the value of the UNIX_TIMESTAMP from master under network disconnection let $debug_saved= `select @@global.debug`; -let $debug_lock= "debug_lock.before_get_UNIX_TIMESTAMP"; -eval SELECT IS_FREE_LOCK($debug_lock); -eval SELECT GET_LOCK($debug_lock, 1000); - -set global debug= 'd,debug_lock.before_get_UNIX_TIMESTAMP'; +# set up two parameters to pass into extra/rpl_tests/rpl_get_master_version_and_clock +let $dbug_sync_point= 'debug_lock.before_get_UNIX_TIMESTAMP'; +let $debug_sync_action= 'now SIGNAL signal.get_unix_timestamp'; source extra/rpl_tests/rpl_get_master_version_and_clock.test; #Test case 2: Try to get the value of the SERVER_ID from master under network disconnection connection slave; -let $debug_lock= "debug_lock.before_get_SERVER_ID"; -eval SELECT IS_FREE_LOCK($debug_lock); -eval SELECT GET_LOCK($debug_lock, 1000); -set global debug= 'd,debug_lock.before_get_SERVER_ID'; +let $dbug_sync_point= 'debug_lock.before_get_SERVER_ID'; +let $debug_sync_action= 'now SIGNAL signal.get_server_id'; source extra/rpl_tests/rpl_get_master_version_and_clock.test; eval set global debug= '$debug_saved'; @@ -62,4 +66,9 @@ let $last_io_error= query_get_value("show slave status", Last_IO_Error, 1); echo Slave_IO_Errno= $last_io_errno; echo Slave_IO_Error= $last_io_error; +# cleanup + +# is not really necessary but avoids mtr post-run env check warnings +SET DEBUG_SYNC= 'RESET'; + # End of tests diff --git a/mysql-test/suite/rpl/t/rpl_show_slave_running.test b/mysql-test/suite/rpl/t/rpl_show_slave_running.test index 62cc311e6b2..bfdd1c279fc 100644 --- a/mysql-test/suite/rpl/t/rpl_show_slave_running.test +++ b/mysql-test/suite/rpl/t/rpl_show_slave_running.test @@ -5,14 +5,14 @@ # source include/master-slave.inc; source include/have_debug.inc; +source include/have_debug_sync.inc; connection slave; - +SET DEBUG_SYNC= 'RESET'; source include/stop_slave.inc; let $debug_saved= `select @@global.debug`; -let $debug_lock= "debug_lock.before_get_running_status_yes"; -eval SELECT GET_LOCK($debug_lock, 1000); -set global debug= 'd,debug_lock.before_get_running_status_yes'; +set global debug= 'd,dbug.before_get_running_status_yes'; # to block due-started IO + # Test 1. Slave is stopped @@ -40,7 +40,7 @@ echo Slave_SQL_Running= $status; # Test 3. The slave IO thread is started and got connected to master # and SQL thread is still not started -eval SELECT RELEASE_LOCK($debug_lock); +SET DEBUG_SYNC='now SIGNAL signal.io_thread_let_running'; # unblock IO thread now let $slave_param= Slave_IO_Running; let $slave_param_value= YES; source include/wait_for_slave_param.inc; @@ -72,5 +72,5 @@ echo Slave_SQL_Running= $status; connection slave; eval set global debug= '$debug_saved'; - +SET DEBUG_SYNC= 'RESET'; --echo End of tests diff --git a/sql/debug_sync.cc b/sql/debug_sync.cc index 2580d526b52..23a649a89fa 100644 --- a/sql/debug_sync.cc +++ b/sql/debug_sync.cc @@ -1903,4 +1903,42 @@ void debug_sync(THD *thd, const char *sync_point_name, size_t name_len) DBUG_VOID_RETURN; } +/** + Define debug sync action. + + @param[in] thd thread handle + @param[in] action_str action string + + @return status + @retval FALSE ok + @retval TRUE error + + @description + The function is similar to @c debug_sync_eval_action but is + to be called immediately from the server code rather than + to be triggered by setting a value to DEBUG_SYNC system variable. + + @note + The input string is copied prior to be fed to + @c debug_sync_eval_action to let the latter modify it. + + Caution. + The function allocates in THD::mem_root and therefore + is not recommended to be deployed inside big loops. +*/ + +bool debug_sync_set_action(THD *thd, const char *action_str, size_t len) +{ + bool rc; + char *value; + DBUG_ENTER("debug_sync_set_action"); + DBUG_ASSERT(thd); + DBUG_ASSERT(action_str); + + value= strmake_root(thd->mem_root, action_str, len); + rc= debug_sync_eval_action(thd, value); + DBUG_RETURN(rc); +} + + #endif /* defined(ENABLED_DEBUG_SYNC) */ diff --git a/sql/debug_sync.h b/sql/debug_sync.h index f4cd0b364cf..9ac7da39d4d 100644 --- a/sql/debug_sync.h +++ b/sql/debug_sync.h @@ -50,6 +50,7 @@ extern void debug_sync_end(void); extern void debug_sync_init_thread(THD *thd); extern void debug_sync_end_thread(THD *thd); extern void debug_sync(THD *thd, const char *sync_point_name, size_t name_len); +extern bool debug_sync_set_action(THD *thd, const char *action_str, size_t len); #else /* defined(ENABLED_DEBUG_SYNC) */ diff --git a/sql/item_func.cc b/sql/item_func.cc index 845654c1881..1e31755179b 100644 --- a/sql/item_func.cc +++ b/sql/item_func.cc @@ -3362,80 +3362,6 @@ longlong Item_master_pos_wait::val_int() return event_count; } -#ifdef EXTRA_DEBUG -void debug_sync_point(const char* lock_name, uint lock_timeout) -{ - THD* thd=current_thd; - User_level_lock* ull; - struct timespec abstime; - size_t lock_name_len; - lock_name_len= strlen(lock_name); - pthread_mutex_lock(&LOCK_user_locks); - - if (thd->ull) - { - item_user_lock_release(thd->ull); - thd->ull=0; - } - - /* - If the lock has not been aquired by some client, we do not want to - create an entry for it, since we immediately release the lock. In - this case, we will not be waiting, but rather, just waste CPU and - memory on the whole deal - */ - if (!(ull= ((User_level_lock*) hash_search(&hash_user_locks, - (uchar*) lock_name, - lock_name_len)))) - { - pthread_mutex_unlock(&LOCK_user_locks); - return; - } - ull->count++; - - /* - Structure is now initialized. Try to get the lock. - Set up control struct to allow others to abort locks - */ - thd_proc_info(thd, "User lock"); - thd->mysys_var->current_mutex= &LOCK_user_locks; - thd->mysys_var->current_cond= &ull->cond; - - set_timespec(abstime,lock_timeout); - while (ull->locked && !thd->killed) - { - int error= pthread_cond_timedwait(&ull->cond, &LOCK_user_locks, &abstime); - if (error == ETIMEDOUT || error == ETIME) - break; - } - - if (ull->locked) - { - if (!--ull->count) - delete ull; // Should never happen - } - else - { - ull->locked=1; - ull->set_thread(thd); - thd->ull=ull; - } - pthread_mutex_unlock(&LOCK_user_locks); - pthread_mutex_lock(&thd->mysys_var->mutex); - thd_proc_info(thd, 0); - thd->mysys_var->current_mutex= 0; - thd->mysys_var->current_cond= 0; - pthread_mutex_unlock(&thd->mysys_var->mutex); - pthread_mutex_lock(&LOCK_user_locks); - if (thd->ull) - { - item_user_lock_release(thd->ull); - thd->ull=0; - } - pthread_mutex_unlock(&LOCK_user_locks); -} - -#endif /** Get a user level lock. If the thread has an old lock this is first released. diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h index 90b02f5337a..098ea514cb6 100644 --- a/sql/mysql_priv.h +++ b/sql/mysql_priv.h @@ -580,20 +580,6 @@ protected: /* Used to check GROUP BY list in the MODE_ONLY_FULL_GROUP_BY mode */ #define UNDEF_POS (-1) -#ifdef EXTRA_DEBUG -/** - Sync points allow us to force the server to reach a certain line of code - and block there until the client tells the server it is ok to go on. - The client tells the server to block with SELECT GET_LOCK() - and unblocks it with SELECT RELEASE_LOCK(). Used for debugging difficult - concurrency problems -*/ -#define DBUG_SYNC_POINT(lock_name,lock_timeout) \ - debug_sync_point(lock_name,lock_timeout) -void debug_sync_point(const char* lock_name, uint lock_timeout); -#else -#define DBUG_SYNC_POINT(lock_name,lock_timeout) -#endif /* EXTRA_DEBUG */ /* BINLOG_DUMP options */ diff --git a/sql/slave.cc b/sql/slave.cc index a89ac2e682b..e8405ffcd37 100644 --- a/sql/slave.cc +++ b/sql/slave.cc @@ -44,6 +44,7 @@ #ifdef HAVE_REPLICATION #include "rpl_tblmap.h" +#include "debug_sync.h" #define FLAGSTR(V,F) ((V)&(F)?#F" ":"") @@ -981,7 +982,16 @@ static int get_master_version_and_clock(MYSQL* mysql, Master_info* mi) unavailable (very old master not supporting UNIX_TIMESTAMP()?). */ - DBUG_SYNC_POINT("debug_lock.before_get_UNIX_TIMESTAMP", 10); + DBUG_EXECUTE_IF("dbug.before_get_UNIX_TIMESTAMP", + { + const char act[]= + "now " + "wait_for signal.get_unix_timestamp"; + DBUG_ASSERT(opt_debug_sync_timeout > 0); + DBUG_ASSERT(!debug_sync_set_action(current_thd, + STRING_WITH_LEN(act))); + };); + master_res= NULL; if (!mysql_real_query(mysql, STRING_WITH_LEN("SELECT UNIX_TIMESTAMP()")) && (master_res= mysql_store_result(mysql)) && @@ -1020,7 +1030,15 @@ static int get_master_version_and_clock(MYSQL* mysql, Master_info* mi) Note: we could have put a @@SERVER_ID in the previous SELECT UNIX_TIMESTAMP() instead, but this would not have worked on 3.23 masters. */ - DBUG_SYNC_POINT("debug_lock.before_get_SERVER_ID", 10); + DBUG_EXECUTE_IF("dbug.before_get_SERVER_ID", + { + const char act[]= + "now " + "wait_for signal.get_server_id"; + DBUG_ASSERT(opt_debug_sync_timeout > 0); + DBUG_ASSERT(!debug_sync_set_action(current_thd, + STRING_WITH_LEN(act))); + };); master_res= NULL; master_row= NULL; if (!mysql_real_query(mysql, @@ -2557,7 +2575,16 @@ pthread_handler_t handle_slave_io(void *arg) connected: - DBUG_SYNC_POINT("debug_lock.before_get_running_status_yes", 10); + DBUG_EXECUTE_IF("dbug.before_get_running_status_yes", + { + const char act[]= + "now " + "wait_for signal.io_thread_let_running"; + DBUG_ASSERT(opt_debug_sync_timeout > 0); + DBUG_ASSERT(!debug_sync_set_action(thd, + STRING_WITH_LEN(act))); + };); + // TODO: the assignment below should be under mutex (5.0) mi->slave_running= MYSQL_SLAVE_RUN_CONNECT; thd->slave_net = &mysql->net; diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc index ae995ea5ed3..44215d90634 100644 --- a/sql/sql_repl.cc +++ b/sql/sql_repl.cc @@ -1711,7 +1711,6 @@ int log_loaded_block(IO_CACHE* file) if (mysql_bin_log.write(&b)) DBUG_RETURN(1); lf_info->wrote_create_file= 1; - DBUG_SYNC_POINT("debug_lock.created_file_event",10); } } DBUG_RETURN(0); -- cgit v1.2.1 From 5cf7c188964f6de83c448605ba9583914d64a8dd Mon Sep 17 00:00:00 2001 From: Andrei Elkin Date: Mon, 22 Mar 2010 07:50:19 +0200 Subject: bug#51648 comments to rpl_show_slave_running test are added to ease merging --- mysql-test/suite/rpl/t/rpl_show_slave_running.test | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/mysql-test/suite/rpl/t/rpl_show_slave_running.test b/mysql-test/suite/rpl/t/rpl_show_slave_running.test index bfdd1c279fc..8a3e56975ad 100644 --- a/mysql-test/suite/rpl/t/rpl_show_slave_running.test +++ b/mysql-test/suite/rpl/t/rpl_show_slave_running.test @@ -29,6 +29,12 @@ echo Slave_SQL_Running= $status; start slave io_thread; +# +# Notice a difference between versions in showing p.2: +# 5.1 has two OFF,ON IO-thread state running state whereas later versions +# have three: OFF,Connecting,ON. +# Hence, 5.1 must display OFF NO NO where as 5.1+ OFF Connecting NO +# --echo Slave_running, Slave_IO_Running, Slave_SQL_Running must be OFF NO NO in three following queries SHOW STATUS LIKE 'Slave_running'; -- cgit v1.2.1 From dbf78da1c8ddd878870f6f3506a00ad97b99f80c Mon Sep 17 00:00:00 2001 From: Gleb Shchepa Date: Mon, 22 Mar 2010 12:33:25 +0400 Subject: Bug #49910: Behavioural change in SELECT/WHERE on YEAR(4) data type (Original patch by Sinisa Milivojevic) The YEAR(4) value of 2000 was equal to the "bad" YEAR(4) value of 0000. The get_year_value() function has been modified to not adjust bad YEAR(4) value to 2000. mysql-test/r/type_year.result: Test case for bug #49910. mysql-test/t/type_year.test: Test case for bug #49910. sql/item_cmpfunc.cc: Bug #49910: Behavioural change in SELECT/WHERE on YEAR(4) data type The get_year_value() function has been modified to not adjust bad YEAR(4) value to 2000. --- mysql-test/r/type_year.result | 32 ++++++++++++++++++++++++++++++++ mysql-test/t/type_year.test | 16 ++++++++++++++++ sql/item_cmpfunc.cc | 19 ++++++++++++++----- 3 files changed, 62 insertions(+), 5 deletions(-) diff --git a/mysql-test/r/type_year.result b/mysql-test/r/type_year.result index 56b326327c6..8948214f565 100644 --- a/mysql-test/r/type_year.result +++ b/mysql-test/r/type_year.result @@ -309,4 +309,36 @@ yyyy c4 2069 2069 DROP TABLE t2, t4; # +# Bug #49910: Behavioural change in SELECT/WHERE on YEAR(4) data type +# +CREATE TABLE t1 (y YEAR NOT NULL, s VARCHAR(4)); +INSERT INTO t1 (s) VALUES ('bad'); +Warnings: +Warning 1364 Field 'y' doesn't have a default value +INSERT INTO t1 (y, s) VALUES (0, 0), (2000, 2000), (2001, 2001); +SELECT * FROM t1 ta, t1 tb WHERE ta.y = tb.y; +y s y s +0000 bad 0000 bad +0000 0 0000 bad +0000 bad 0000 0 +0000 0 0000 0 +2000 2000 2000 2000 +2001 2001 2001 2001 +SELECT * FROM t1 WHERE t1.y = 0; +y s +0000 bad +0000 0 +SELECT * FROM t1 WHERE t1.y = 2000; +y s +2000 2000 +SELECT ta.y AS ta_y, ta.s, tb.y AS tb_y, tb.s FROM t1 ta, t1 tb HAVING ta_y = tb_y; +ta_y s tb_y s +0000 bad 0000 bad +0000 0 0000 bad +0000 bad 0000 0 +0000 0 0000 0 +2000 2000 2000 2000 +2001 2001 2001 2001 +DROP TABLE t1; +# End of 5.1 tests diff --git a/mysql-test/t/type_year.test b/mysql-test/t/type_year.test index 16fd39a59d8..d8da4ccc82c 100644 --- a/mysql-test/t/type_year.test +++ b/mysql-test/t/type_year.test @@ -133,6 +133,22 @@ SELECT * FROM t4 WHERE yyyy > 123; DROP TABLE t2, t4; +--echo # +--echo # Bug #49910: Behavioural change in SELECT/WHERE on YEAR(4) data type +--echo # + +CREATE TABLE t1 (y YEAR NOT NULL, s VARCHAR(4)); +INSERT INTO t1 (s) VALUES ('bad'); +INSERT INTO t1 (y, s) VALUES (0, 0), (2000, 2000), (2001, 2001); + +SELECT * FROM t1 ta, t1 tb WHERE ta.y = tb.y; +SELECT * FROM t1 WHERE t1.y = 0; +SELECT * FROM t1 WHERE t1.y = 2000; + +SELECT ta.y AS ta_y, ta.s, tb.y AS tb_y, tb.s FROM t1 ta, t1 tb HAVING ta_y = tb_y; + +DROP TABLE t1; + --echo # --echo End of 5.1 tests diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc index cd3f18fe1eb..6e38220abd1 100644 --- a/sql/item_cmpfunc.cc +++ b/sql/item_cmpfunc.cc @@ -1190,12 +1190,21 @@ get_year_value(THD *thd, Item ***item_arg, Item **cache_arg, /* Coerce value to the 19XX form in order to correctly compare YEAR(2) & YEAR(4) types. + Here we are converting all item values but YEAR(4) fields since + 1) YEAR(4) already has a regular YYYY form and + 2) we don't want to convert zero/bad YEAR(4) values to the + value of 2000. */ - if (value < 70) - value+= 100; - if (value <= 1900) - value+= 1900; - + Item *real_item= item->real_item(); + if (!(real_item->type() == Item::FIELD_ITEM && + ((Item_field *)real_item)->field->type() == MYSQL_TYPE_YEAR && + ((Item_field *)real_item)->field->field_length == 4)) + { + if (value < 70) + value+= 100; + if (value <= 1900) + value+= 1900; + } /* Convert year to DATETIME of form YYYY-00-00 00:00:00 (YYYY0000000000). */ value*= 10000000000LL; -- cgit v1.2.1 From ea238aa84da6797be238d721f1acf632609e9d62 Mon Sep 17 00:00:00 2001 From: Mats Kindahl Date: Mon, 22 Mar 2010 13:10:18 +0100 Subject: BUG#49618: Field length stored incorrectly in binary log for InnoDB Patch to fix result files for the binlog suite under row- based replication. --- mysql-test/r/mysqlbinlog_row_innodb.result | 32 +++++++++++++++--------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/mysql-test/r/mysqlbinlog_row_innodb.result b/mysql-test/r/mysqlbinlog_row_innodb.result index 86f0b67ebb3..ee448311278 100644 --- a/mysql-test/r/mysqlbinlog_row_innodb.result +++ b/mysql-test/r/mysqlbinlog_row_innodb.result @@ -2365,7 +2365,7 @@ BEGIN #010909 4:46:40 server id 1 end_log_pos # Write_rows: table id # flags: STMT_END_F ### INSERT INTO test.t1 ### SET -### @1=b'00000000' /* BIT(8) meta=256 nullable=1 is_null=0 */ +### @1=b'0' /* BIT(1) meta=1 nullable=1 is_null=0 */ ### @2=b'0000000000000000000000000000000000000000000000000000000000000000' /* BIT(64) meta=2048 nullable=1 is_null=0 */ ### @3=-128 (128) /* TINYINT meta=0 nullable=1 is_null=0 */ ### @4=0 /* TINYINT meta=0 nullable=1 is_null=0 */ @@ -2458,7 +2458,7 @@ BEGIN #010909 4:46:40 server id 1 end_log_pos # Write_rows: table id # flags: STMT_END_F ### INSERT INTO test.t1 ### SET -### @1=b'00000001' /* BIT(8) meta=256 nullable=1 is_null=0 */ +### @1=b'1' /* BIT(1) meta=1 nullable=1 is_null=0 */ ### @2=b'1111111111111111111111111111111111111111111111111111111111111111' /* BIT(64) meta=2048 nullable=1 is_null=0 */ ### @3=127 /* TINYINT meta=0 nullable=1 is_null=0 */ ### @4=-1 (255) /* TINYINT meta=0 nullable=1 is_null=0 */ @@ -2553,7 +2553,7 @@ BEGIN #010909 4:46:40 server id 1 end_log_pos # Write_rows: table id # flags: STMT_END_F ### INSERT INTO test.t1 ### SET -### @1=NULL /* type=16 meta=256 nullable=1 is_null=1 */ +### @1=NULL /* type=16 meta=1 nullable=1 is_null=1 */ ### @2=NULL /* type=16 meta=2048 nullable=1 is_null=1 */ ### @3=NULL /* type=1 meta=0 nullable=1 is_null=1 */ ### @4=NULL /* type=1 meta=0 nullable=1 is_null=1 */ @@ -2634,7 +2634,7 @@ BEGIN ### @79=3 /* INT meta=0 nullable=1 is_null=0 */ ### INSERT INTO test.t1 ### SET -### @1=b'00000001' /* BIT(8) meta=256 nullable=1 is_null=0 */ +### @1=b'1' /* BIT(1) meta=1 nullable=1 is_null=0 */ ### @2=b'1111111111111111111111111111111111111111111111111111111111111111' /* BIT(64) meta=2048 nullable=1 is_null=0 */ ### @3=127 /* TINYINT meta=0 nullable=1 is_null=0 */ ### @4=0 /* TINYINT meta=0 nullable=1 is_null=0 */ @@ -2727,7 +2727,7 @@ BEGIN #010909 4:46:40 server id 1 end_log_pos # Update_rows: table id # flags: STMT_END_F ### UPDATE test.t1 ### WHERE -### @1=b'00000000' /* BIT(8) meta=256 nullable=1 is_null=0 */ +### @1=b'0' /* BIT(1) meta=1 nullable=1 is_null=0 */ ### @2=b'0000000000000000000000000000000000000000000000000000000000000000' /* BIT(64) meta=2048 nullable=1 is_null=0 */ ### @3=-128 (128) /* TINYINT meta=0 nullable=1 is_null=0 */ ### @4=0 /* TINYINT meta=0 nullable=1 is_null=0 */ @@ -2807,7 +2807,7 @@ BEGIN ### @78=b'00000000' /* SET(1 bytes) meta=63489 nullable=1 is_null=0 */ ### @79=1 /* INT meta=0 nullable=1 is_null=0 */ ### SET -### @1=b'00000001' /* BIT(8) meta=256 nullable=1 is_null=0 */ +### @1=b'1' /* BIT(1) meta=1 nullable=1 is_null=0 */ ### @2=b'1111111111111111111111111111111111111111111111111111111111111111' /* BIT(64) meta=2048 nullable=1 is_null=0 */ ### @3=127 /* TINYINT meta=0 nullable=1 is_null=0 */ ### @4=-1 (255) /* TINYINT meta=0 nullable=1 is_null=0 */ @@ -2900,7 +2900,7 @@ BEGIN #010909 4:46:40 server id 1 end_log_pos # Update_rows: table id # flags: STMT_END_F ### UPDATE test.t1 ### WHERE -### @1=b'00000001' /* BIT(8) meta=256 nullable=1 is_null=0 */ +### @1=b'1' /* BIT(1) meta=1 nullable=1 is_null=0 */ ### @2=b'1111111111111111111111111111111111111111111111111111111111111111' /* BIT(64) meta=2048 nullable=1 is_null=0 */ ### @3=127 /* TINYINT meta=0 nullable=1 is_null=0 */ ### @4=-1 (255) /* TINYINT meta=0 nullable=1 is_null=0 */ @@ -2980,7 +2980,7 @@ BEGIN ### @78=b'00000111' /* SET(1 bytes) meta=63489 nullable=1 is_null=0 */ ### @79=2 /* INT meta=0 nullable=1 is_null=0 */ ### SET -### @1=b'00000000' /* BIT(8) meta=256 nullable=1 is_null=0 */ +### @1=b'0' /* BIT(1) meta=1 nullable=1 is_null=0 */ ### @2=b'0000000000000000000000000000000000000000000000000000000000000000' /* BIT(64) meta=2048 nullable=1 is_null=0 */ ### @3=-128 (128) /* TINYINT meta=0 nullable=1 is_null=0 */ ### @4=0 /* TINYINT meta=0 nullable=1 is_null=0 */ @@ -3073,7 +3073,7 @@ BEGIN #010909 4:46:40 server id 1 end_log_pos # Update_rows: table id # flags: STMT_END_F ### UPDATE test.t1 ### WHERE -### @1=NULL /* type=16 meta=256 nullable=1 is_null=1 */ +### @1=NULL /* type=16 meta=1 nullable=1 is_null=1 */ ### @2=NULL /* type=16 meta=2048 nullable=1 is_null=1 */ ### @3=NULL /* type=1 meta=0 nullable=1 is_null=1 */ ### @4=NULL /* type=1 meta=0 nullable=1 is_null=1 */ @@ -3153,7 +3153,7 @@ BEGIN ### @78=NULL /* TIMESTAMP meta=63489 nullable=1 is_null=1 */ ### @79=3 /* INT meta=0 nullable=1 is_null=0 */ ### SET -### @1=b'00000001' /* BIT(8) meta=256 nullable=1 is_null=0 */ +### @1=b'1' /* BIT(1) meta=1 nullable=1 is_null=0 */ ### @2=b'1111111111111111111111111111111111111111111111111111111111111111' /* BIT(64) meta=2048 nullable=1 is_null=0 */ ### @3=127 /* TINYINT meta=0 nullable=1 is_null=0 */ ### @4=0 /* TINYINT meta=0 nullable=1 is_null=0 */ @@ -3246,7 +3246,7 @@ BEGIN #010909 4:46:40 server id 1 end_log_pos # Update_rows: table id # flags: STMT_END_F ### UPDATE test.t1 ### WHERE -### @1=b'00000001' /* BIT(8) meta=256 nullable=1 is_null=0 */ +### @1=b'1' /* BIT(1) meta=1 nullable=1 is_null=0 */ ### @2=b'1111111111111111111111111111111111111111111111111111111111111111' /* BIT(64) meta=2048 nullable=1 is_null=0 */ ### @3=127 /* TINYINT meta=0 nullable=1 is_null=0 */ ### @4=0 /* TINYINT meta=0 nullable=1 is_null=0 */ @@ -3326,7 +3326,7 @@ BEGIN ### @78=b'00000110' /* SET(1 bytes) meta=63489 nullable=1 is_null=0 */ ### @79=4 /* INT meta=0 nullable=1 is_null=0 */ ### SET -### @1=NULL /* type=16 meta=256 nullable=1 is_null=1 */ +### @1=NULL /* type=16 meta=1 nullable=1 is_null=1 */ ### @2=NULL /* type=16 meta=2048 nullable=1 is_null=1 */ ### @3=NULL /* type=1 meta=0 nullable=1 is_null=1 */ ### @4=NULL /* type=1 meta=0 nullable=1 is_null=1 */ @@ -3419,7 +3419,7 @@ BEGIN #010909 4:46:40 server id 1 end_log_pos # Delete_rows: table id # flags: STMT_END_F ### DELETE FROM test.t1 ### WHERE -### @1=b'00000001' /* BIT(8) meta=256 nullable=1 is_null=0 */ +### @1=b'1' /* BIT(1) meta=1 nullable=1 is_null=0 */ ### @2=b'1111111111111111111111111111111111111111111111111111111111111111' /* BIT(64) meta=2048 nullable=1 is_null=0 */ ### @3=127 /* TINYINT meta=0 nullable=1 is_null=0 */ ### @4=-1 (255) /* TINYINT meta=0 nullable=1 is_null=0 */ @@ -3512,7 +3512,7 @@ BEGIN #010909 4:46:40 server id 1 end_log_pos # Delete_rows: table id # flags: STMT_END_F ### DELETE FROM test.t1 ### WHERE -### @1=b'00000000' /* BIT(8) meta=256 nullable=1 is_null=0 */ +### @1=b'0' /* BIT(1) meta=1 nullable=1 is_null=0 */ ### @2=b'0000000000000000000000000000000000000000000000000000000000000000' /* BIT(64) meta=2048 nullable=1 is_null=0 */ ### @3=-128 (128) /* TINYINT meta=0 nullable=1 is_null=0 */ ### @4=0 /* TINYINT meta=0 nullable=1 is_null=0 */ @@ -3605,7 +3605,7 @@ BEGIN #010909 4:46:40 server id 1 end_log_pos # Delete_rows: table id # flags: STMT_END_F ### DELETE FROM test.t1 ### WHERE -### @1=b'00000001' /* BIT(8) meta=256 nullable=1 is_null=0 */ +### @1=b'1' /* BIT(1) meta=1 nullable=1 is_null=0 */ ### @2=b'1111111111111111111111111111111111111111111111111111111111111111' /* BIT(64) meta=2048 nullable=1 is_null=0 */ ### @3=127 /* TINYINT meta=0 nullable=1 is_null=0 */ ### @4=0 /* TINYINT meta=0 nullable=1 is_null=0 */ @@ -3698,7 +3698,7 @@ BEGIN #010909 4:46:40 server id 1 end_log_pos # Delete_rows: table id # flags: STMT_END_F ### DELETE FROM test.t1 ### WHERE -### @1=NULL /* type=16 meta=256 nullable=1 is_null=1 */ +### @1=NULL /* type=16 meta=1 nullable=1 is_null=1 */ ### @2=NULL /* type=16 meta=2048 nullable=1 is_null=1 */ ### @3=NULL /* type=1 meta=0 nullable=1 is_null=1 */ ### @4=NULL /* type=1 meta=0 nullable=1 is_null=1 */ -- cgit v1.2.1 From 19617d110c19d023cdc7572ce5b3624fdd2c2a9f Mon Sep 17 00:00:00 2001 From: Alexander Barkov Date: Mon, 22 Mar 2010 16:27:59 +0400 Subject: Bug #51976 LDML collations issue Problem: caseup_multiply and casedn_multiply members were not initialized for a dynamic collation, so UPPER() and LOWER() functions returned empty strings. Fix: initializing the members properly. Adding tests: mysql-test/r/ctype_ldml.result mysql-test/t/ctype_ldml.test Applying the fix: mysys/charset.c --- mysql-test/r/ctype_ldml.result | 9 +++++++++ mysql-test/t/ctype_ldml.test | 8 ++++++++ mysys/charset.c | 2 ++ 3 files changed, 19 insertions(+) diff --git a/mysql-test/r/ctype_ldml.result b/mysql-test/r/ctype_ldml.result index d5585dcfad9..aa9fb478217 100644 --- a/mysql-test/r/ctype_ldml.result +++ b/mysql-test/r/ctype_ldml.result @@ -49,6 +49,15 @@ SELECT * FROM t1 WHERE LOWER(a)=LOWER('N'); a DROP TABLE t1; # +# Bug#51976 LDML collations issue (cyrillic example) +# +CREATE TABLE t1 (a VARCHAR(10) CHARACTER SET utf8 COLLATE utf8_test_ci); +INSERT INTO t1 (a) VALUES ('Hello'); +SELECT a, UPPER(a), LOWER(a) FROM t1; +a UPPER(a) LOWER(a) +Hello HELLO hello +DROP TABLE t1; +# # Bug#43827 Server closes connections and restarts # CREATE TABLE t1 (c1 VARCHAR(10) CHARACTER SET utf8 COLLATE utf8_test_ci); diff --git a/mysql-test/t/ctype_ldml.test b/mysql-test/t/ctype_ldml.test index 0395de273de..9ab458ba516 100644 --- a/mysql-test/t/ctype_ldml.test +++ b/mysql-test/t/ctype_ldml.test @@ -45,6 +45,14 @@ INSERT INTO t1 (a) VALUES ('hello!'); SELECT * FROM t1 WHERE LOWER(a)=LOWER('N'); DROP TABLE t1; +--echo # +--echo # Bug#51976 LDML collations issue (cyrillic example) +--echo # +CREATE TABLE t1 (a VARCHAR(10) CHARACTER SET utf8 COLLATE utf8_test_ci); +INSERT INTO t1 (a) VALUES ('Hello'); +SELECT a, UPPER(a), LOWER(a) FROM t1; +DROP TABLE t1; + --echo # --echo # Bug#43827 Server closes connections and restarts --echo # diff --git a/mysys/charset.c b/mysys/charset.c index 9678febc9ba..f15c445adde 100644 --- a/mysys/charset.c +++ b/mysys/charset.c @@ -245,6 +245,8 @@ static int add_collation(CHARSET_INFO *cs) if (cs_copy_data(all_charsets[cs->number],cs)) return MY_XML_ERROR; + newcs->caseup_multiply= newcs->casedn_multiply= 1; + if (!strcmp(cs->csname,"ucs2") ) { #if defined(HAVE_CHARSET_ucs2) && defined(HAVE_UCA_COLLATIONS) -- cgit v1.2.1