1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Auto-merge from mysql-next-mr.

Browse Source
This commit is contained in:
Alexander Nozdrin 2009-11-25 16:46:45 +03:00
commit 4b28a6ce84
161 changed files with 1611 additions and 1368 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
client/mysqladmin.cc
View File

@ -325,8 +325,8 @@ int main(int argc,char *argv[])
if (tty_password)
opt_password = get_tty_password(NullS);
VOID(signal(SIGINT,endprog)); /* Here if abort */
VOID(signal(SIGTERM,endprog)); /* Here if abort */
(void) signal(SIGINT,endprog); /* Here if abort */
(void) signal(SIGTERM,endprog); /* Here if abort */
if (opt_compress)
mysql_options(&mysql,MYSQL_OPT_COMPRESS,NullS);

10
client/mysqldump.c
View File

@ -2001,7 +2001,7 @@ static uint dump_events_for_db(char *db)
mysql_free_result(event_list_res);
if (lock_tables)
VOID(mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES"));
(void) mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES");
DBUG_RETURN(0);
}
@ -2204,7 +2204,7 @@ static uint dump_routines_for_db(char *db)
DBUG_RETURN(1);
if (lock_tables)
VOID(mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES"));
(void) mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES");
DBUG_RETURN(0);
}
@ -4086,7 +4086,7 @@ static int dump_all_tables_in_db(char *database)
check_io(md_result_file);
}
if (lock_tables)
VOID(mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES"));
(void) mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES");
if (flush_privileges && using_mysql_db == 0)
{
fprintf(md_result_file,"\n--\n-- Flush Grant Tables \n--\n");
@ -4160,7 +4160,7 @@ static my_bool dump_all_views_in_db(char *database)
check_io(md_result_file);
}
if (lock_tables)
VOID(mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES"));
(void) mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES");
return 0;
} /* dump_all_tables_in_db */
@ -4332,7 +4332,7 @@ static int dump_selected_tables(char *db, char **table_names, int tables)
check_io(md_result_file);
}
if (lock_tables)
VOID(mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES"));
(void) mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES");
DBUG_RETURN(0);
} /* dump_selected_tables */

8
client/mysqlimport.c
View File

@ -610,8 +610,8 @@ int main(int argc, char **argv)
pthread_attr_setdetachstate(&attr,
PTHREAD_CREATE_DETACHED);
VOID(pthread_mutex_init(&counter_mutex, NULL));
VOID(pthread_cond_init(&count_threshhold, NULL));
pthread_mutex_init(&counter_mutex, NULL);
pthread_cond_init(&count_threshhold, NULL);
for (counter= 0; *argv != NULL; argv++) /* Loop through tables */
{
@ -650,8 +650,8 @@ int main(int argc, char **argv)
pthread_cond_timedwait(&count_threshhold, &counter_mutex, &abstime);
}
pthread_mutex_unlock(&counter_mutex);
VOID(pthread_mutex_destroy(&counter_mutex));
VOID(pthread_cond_destroy(&count_threshhold));
pthread_mutex_destroy(&counter_mutex);
pthread_cond_destroy(&count_threshhold);
pthread_attr_destroy(&attr);
}
else

16
client/mysqlslap.c
View File

@ -352,10 +352,10 @@ int main(int argc, char **argv)
}
}
VOID(pthread_mutex_init(&counter_mutex, NULL));
VOID(pthread_cond_init(&count_threshhold, NULL));
VOID(pthread_mutex_init(&sleeper_mutex, NULL));
VOID(pthread_cond_init(&sleep_threshhold, NULL));
pthread_mutex_init(&counter_mutex, NULL);
pthread_cond_init(&count_threshhold, NULL);
pthread_mutex_init(&sleeper_mutex, NULL);
pthread_cond_init(&sleep_threshhold, NULL);
/* Main iterations loop */
eptr= engine_options;
@ -386,10 +386,10 @@ int main(int argc, char **argv)
} while (eptr ? (eptr= eptr->next) : 0);
VOID(pthread_mutex_destroy(&counter_mutex));
VOID(pthread_cond_destroy(&count_threshhold));
VOID(pthread_mutex_destroy(&sleeper_mutex));
VOID(pthread_cond_destroy(&sleep_threshhold));
pthread_mutex_destroy(&counter_mutex);
pthread_cond_destroy(&count_threshhold);
pthread_mutex_destroy(&sleeper_mutex);
pthread_cond_destroy(&sleep_threshhold);
if (!opt_only_print)
mysql_close(&mysql); /* Close & free connection */

8
client/mysqltest.cc
View File

@ -696,12 +696,12 @@ pthread_handler_t send_one_query(void *arg)
struct st_connection *cn= (struct st_connection*)arg;
mysql_thread_init();
VOID(mysql_send_query(&cn->mysql, cn->cur_query, cn->cur_query_len));
(void) mysql_send_query(&cn->mysql, cn->cur_query, cn->cur_query_len);
mysql_thread_end();
pthread_mutex_lock(&cn->mutex);
cn->query_done= 1;
VOID(pthread_cond_signal(&cn->cond));
pthread_cond_signal(&cn->cond);
pthread_mutex_unlock(&cn->mutex);
pthread_exit(0);
return 0;
@ -9063,7 +9063,7 @@ REPLACE *init_replace(char * *from, char * *to,uint count,
free_sets(&sets);
DBUG_RETURN(0);
}
VOID(make_new_set(&sets)); /* Set starting set */
(void) make_new_set(&sets); /* Set starting set */
make_sets_invisible(&sets); /* Hide previus sets */
used_sets=-1;
word_states=make_new_set(&sets); /* Start of new word */
@ -9534,7 +9534,7 @@ int insert_pointer_name(reg1 POINTER_ARRAY *pa,char * name)
pa->flag[pa->typelib.count]=0; /* Reset flag */
pa->typelib.type_names[pa->typelib.count++]= (char*) pa->str+pa->length;
pa->typelib.type_names[pa->typelib.count]= NullS; /* Put end-mark */
VOID(strmov((char*) pa->str+pa->length,name));
(void) strmov((char*) pa->str+pa->length,name);
pa->length+=length;
DBUG_RETURN(0);
} /* insert_pointer_name */

2
client/sql_string.cc
View File

@ -130,7 +130,7 @@ bool String::set(double num,uint decimals, CHARSET_INFO *cs)
int decpt,sign;
char *pos,*to;
VOID(fconvert(num,(int) decimals,&decpt,&sign,buff+1));
(void) fconvert(num,(int) decimals,&decpt,&sign,buff+1);
if (!my_isdigit(&my_charset_latin1, buff[1]))
{ // Nan or Inf
pos=buff+1;

8
configure.in
View File

@ -2123,11 +2123,9 @@ AC_CHECK_FUNCS(alarm bcmp bfill bmove bsearch bzero \
localtime_r gethrtime gmtime_r \
locking longjmp lrand48 madvise mallinfo memcpy memmove \
mkstemp mlockall perror poll pread pthread_attr_create mmap mmap64 getpagesize \
pthread_attr_getstacksize pthread_attr_setprio pthread_attr_setschedparam \
pthread_attr_setstacksize pthread_condattr_create pthread_getsequence_np \
pthread_key_delete pthread_rwlock_rdlock pthread_setprio \
pthread_setprio_np pthread_setschedparam pthread_sigmask readlink \
realpath rename rint rwlock_init setupterm \
pthread_attr_getstacksize pthread_attr_setstacksize pthread_condattr_create \
pthread_getsequence_np pthread_key_delete pthread_rwlock_rdlock pthread_sigmask \
readlink realpath rename rint rwlock_init setupterm \
shmget shmat shmdt shmctl sigaction sigemptyset sigaddset \
sighold sigset sigthreadmask port_create sleep thr_yield \
snprintf socket stpcpy strcasecmp strerror strsignal strnlen strpbrk strstr \

8
extra/comp_err.c
View File

@ -1039,11 +1039,11 @@ static char *parse_text_line(char *pos)
switch (*++pos) {
case '\\':
case '"':
VOID(strmov(pos - 1, pos));
(void) strmov(pos - 1, pos);
break;
case 'n':
pos[-1]= '\n';
VOID(strmov(pos, pos + 1));
(void) strmov(pos, pos + 1);
break;
default:
if (*pos >= '0' && *pos < '8')
@ -1053,10 +1053,10 @@ static char *parse_text_line(char *pos)
nr= nr * 8 + (*(pos++) - '0');
pos -= i;
pos[-1]= nr;
VOID(strmov(pos, pos + i));
(void) strmov(pos, pos + i);
}
else if (*pos)
VOID(strmov(pos - 1, pos)); /* Remove '\' */
(void) strmov(pos - 1, pos); /* Remove '\' */
}
}
else

4
extra/replace.c
View File

@ -311,7 +311,7 @@ static int insert_pointer_name(reg1 POINTER_ARRAY *pa,char * name)
pa->flag[pa->typelib.count]=0; /* Reset flag */
pa->typelib.type_names[pa->typelib.count++]= (char*) (pa->str+pa->length);
pa->typelib.type_names[pa->typelib.count]= NullS; /* Put end-mark */
VOID(strmov((char*) pa->str + pa->length, name));
(void) strmov((char*) pa->str + pa->length, name);
pa->length+=length;
DBUG_RETURN(0);
} /* insert_pointer_name */
@ -433,7 +433,7 @@ static REPLACE *init_replace(char * *from, char * *to,uint count,
free_sets(&sets);
DBUG_RETURN(0);
}
VOID(make_new_set(&sets)); /* Set starting set */
(void) make_new_set(&sets); /* Set starting set */
make_sets_invisible(&sets); /* Hide previus sets */
used_sets=-1;
word_states=make_new_set(&sets); /* Start of new word */

1
include/config-netware.h
View File

@ -73,7 +73,6 @@ extern "C" {
#undef HAVE_FINITE
#undef HAVE_GETPWNAM
#undef HAVE_GETPWUID
#undef HAVE_PTHREAD_SETSCHEDPARAM
#undef HAVE_READLINK
#undef HAVE_STPCPY
/* changes end */

17
include/config-win.h
View File

@ -145,12 +145,23 @@ typedef __int64 os_off_t;
#ifdef _WIN64
typedef UINT_PTR rf_SetTimer;
#else
#ifndef HAVE_SIZE_T
typedef unsigned int size_t;
#endif
typedef uint rf_SetTimer;
#endif
#ifndef HAVE_SIZE_T
#ifndef _SIZE_T_DEFINED
typedef SIZE_T size_t;
#define _SIZE_T_DEFINED
#endif
#endif
#ifndef HAVE_SSIZE_T
#ifndef _SSIZE_T_DEFINED
typedef SSIZE_T ssize_t;
#define _SSIZE_T_DEFINED
#endif
#endif
#define Socket_defined
#define my_socket SOCKET
#define SIGPIPE SIGINT

10
include/my_alarm.h
View File

@ -33,15 +33,15 @@ extern ulong my_time_to_wait_for_lock;
#define ALARM_INIT my_have_got_alarm=0 ; \
alarm_old=(uint) alarm(MY_HOW_OFTEN_TO_ALARM); \
alarm_signal=signal(SIGALRM,my_set_alarm_variable);
#define ALARM_END VOID(signal(SIGALRM,alarm_signal)); \
VOID(alarm(alarm_old));
#define ALARM_END (void) signal(SIGALRM,alarm_signal); \
(void) alarm(alarm_old);
#define ALARM_TEST my_have_got_alarm
#ifdef DONT_REMEMBER_SIGNAL
#define ALARM_REINIT VOID(alarm(MY_HOW_OFTEN_TO_ALARM)); \
VOID(signal(SIGALRM,my_set_alarm_variable));\
#define ALARM_REINIT (void) alarm(MY_HOW_OFTEN_TO_ALARM); \
(void) signal(SIGALRM,my_set_alarm_variable);\
my_have_got_alarm=0;
#else
#define ALARM_REINIT VOID(alarm((uint) MY_HOW_OFTEN_TO_ALARM)); \
#define ALARM_REINIT (void) alarm((uint) MY_HOW_OFTEN_TO_ALARM); \
my_have_got_alarm=0;
#endif /* DONT_REMEMBER_SIGNAL */
#else

11
include/my_global.h
View File

@ -542,17 +542,6 @@ extern "C" int madvise(void *addr, size_t len, int behav);
#define DONT_REMEMBER_SIGNAL
#endif
/* Define void to stop lint from generating "null effekt" comments */
#ifndef DONT_DEFINE_VOID
#ifdef _lint
int __void__;
#define VOID(X) (__void__ = (int) (X))
#else
#undef VOID
#define VOID(X) (X)
#endif
#endif /* DONT_DEFINE_VOID */
#if defined(_lint) || defined(FORCE_INIT_OF_VARS)
#define LINT_INIT(var) var=0 /* No uninitialize-warning */
#else

35
include/my_pthread.h
View File

@ -35,7 +35,6 @@ typedef DWORD pthread_t;
typedef struct thread_attr {
DWORD dwStackSize ;
DWORD dwCreatingFlag ;
int priority ;
} pthread_attr_t ;
typedef struct { int dummy; } pthread_condattr_t;
@ -110,7 +109,6 @@ int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_attr_init(pthread_attr_t *connect_att);
int pthread_attr_setstacksize(pthread_attr_t *connect_att,DWORD stack);
int pthread_attr_setprio(pthread_attr_t *connect_att,int priority);
int pthread_attr_destroy(pthread_attr_t *connect_att);
struct tm *localtime_r(const time_t *timep,struct tm *tmp);
struct tm *gmtime_r(const time_t *timep,struct tm *tmp);
@ -141,20 +139,19 @@ int pthread_join(pthread_t thread, void **value_ptr);
#define pthread_mutex_trylock(A) win_pthread_mutex_trylock((A))
#define pthread_mutex_unlock(A) LeaveCriticalSection(A)
#define pthread_mutex_destroy(A) DeleteCriticalSection(A)
#define my_pthread_setprio(A,B) SetThreadPriority(GetCurrentThread(), (B))
#define pthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)
/* Dummy defines for easier code */
#define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
#define my_pthread_attr_setprio(A,B) pthread_attr_setprio(A,B)
#define pthread_attr_setscope(A,B)
#define pthread_detach_this_thread()
#define pthread_condattr_init(A)
#define pthread_condattr_destroy(A)
#define pthread_yield() SwitchToThread()
#define my_pthread_getprio(thread_id) pthread_dummy(0)
/* per the platform's documentation */
#define pthread_yield() Sleep(0)
#else /* Normal threads */
@ -182,8 +179,6 @@ void my_pthread_exit(void *status);
#define pthread_exit(A) my_pthread_exit(A)
#endif
extern int my_pthread_getprio(pthread_t thread_id);
#define pthread_key(T,V) pthread_key_t V
#define my_pthread_getspecific_ptr(T,V) my_pthread_getspecific(T,(V))
#define my_pthread_setspecific_ptr(T,V) pthread_setspecific(T,(void*) (V))
@ -255,32 +250,6 @@ int sigwait(sigset_t *setp, int *sigp); /* Use our implemention */
#define my_sigset(A,B) signal((A),(B))
#endif
#ifndef my_pthread_setprio
#if defined(HAVE_PTHREAD_SETPRIO_NP) /* FSU threads */
#define my_pthread_setprio(A,B) pthread_setprio_np((A),(B))
#elif defined(HAVE_PTHREAD_SETPRIO)
#define my_pthread_setprio(A,B) pthread_setprio((A),(B))
#elif defined(HAVE_PTHREAD_SETSCHEDPRIO) && !defined (__GNUC__)
/*
Workaround for bug on Solaris where pthread.h have bug in GNU
version of pthread.h => configure says yes, header files says
no. So not used with gcc and issue is Solaris only, so will
be used on Solaris using SunStudio.
*/
#define my_pthread_setprio(A,B) pthread_setschedprio((A),(B))
#else
extern void my_pthread_setprio(pthread_t thread_id,int prior);
#endif
#endif
#ifndef my_pthread_attr_setprio
#ifdef HAVE_PTHREAD_ATTR_SETPRIO
#define my_pthread_attr_setprio(A,B) pthread_attr_setprio((A),(B))
#else
extern void my_pthread_attr_setprio(pthread_attr_t *attr, int priority);
#endif
#endif
#if !defined(HAVE_PTHREAD_ATTR_SETSCOPE) || defined(HAVE_DEC_3_2_THREADS)
#define pthread_attr_setscope(A,B)
#undef HAVE_GETHOSTBYADDR_R /* No definition */

1
include/violite.h
View File

@ -86,6 +86,7 @@ my_bool vio_peer_addr(Vio* vio, char *buf, uint16 *port);
void vio_in_addr(Vio *vio, struct in_addr *in);
my_bool vio_poll_read(Vio *vio, uint timeout);
my_bool vio_is_connected(Vio *vio);
ssize_t vio_pending(Vio *vio);
#ifdef HAVE_OPENSSL
#include <openssl/opensslv.h>

2
libmysql/libmysql.c
View File

@ -556,7 +556,7 @@ my_bool handle_local_infile(MYSQL *mysql, const char *net_filename)
if ((*options->local_infile_init)(&li_ptr, net_filename,
options->local_infile_userdata))
{
VOID(my_net_write(net,(const uchar*) "",0)); /* Server needs one packet */
(void) my_net_write(net,(const uchar*) "",0); /* Server needs one packet */
net_flush(net);
strmov(net->sqlstate, unknown_sqlstate);
net->last_errno=

20
mysql-test/r/drop.result
View File

@ -86,6 +86,26 @@ select 1;
1
1
unlock tables;
drop table if exists t1,t2;
create table t1 (a int);
create table t2 (a int);
lock table t1 read;
drop table t2;
ERROR HY000: Table 't2' was not locked with LOCK TABLES
drop table t1;
ERROR HY000: Table 't1' was locked with a READ lock and can't be updated
unlock tables;
drop table t1,t2;
create table t1 (i int);
create table t2 (i int);
lock tables t1 read;
lock tables t2 read;
drop table t1;
ERROR HY000: Table 't1' was not locked with LOCK TABLES
drop table t1,t2;
ERROR HY000: Table 't1' was locked with a READ lock and can't be updated
unlock tables;
drop table t1,t2;
End of 5.0 tests
create database mysql_test;
create table mysql_test.t1(f1 int);

36
mysql-test/r/errors.result
View File

@ -55,6 +55,42 @@ Error 1054 Unknown column 'b' in 'field list'
INSERT INTO t1 SELECT b FROM t1;
ERROR 42S22: Unknown column 'b' in 'field list'
DROP TABLE t1;
flush status;
drop table if exists t1, t2;
create table t1 (a int unique);
create table t2 (a int);
drop function if exists f1;
Warnings:
Note 1305 FUNCTION f1 does not exist
drop function if exists f2;
Warnings:
Note 1305 FUNCTION f2 does not exist
create function f1() returns int
begin
insert into t1 (a) values (1);
insert into t1 (a) values (1);
return 1;
end|
create function f2() returns int
begin
insert into t2 (a) values (1);
return 2;
end|
flush status;
select f1(), f2();
ERROR 23000: Duplicate entry '1' for key 'a'
show status like 'Com_insert';
Variable_name Value
Com_insert 2
select * from t1;
a
1
select * from t2;
a
drop table t1;
drop table t2;
drop function f1;
drop function f2;
SET NAMES utf8;
SET sql_quote_show_create= _binary x'5452C39C45';
ERROR 42000: Variable 'sql_quote_show_create' can't be set to the value of 'TR\xC3\x9CE'

3
mysql-test/r/group_by.result
View File

@ -107,8 +107,9 @@ SELECT cid, CONCAT(firstname, ' ', surname), COUNT(call_id) FROM t1 LEFT JOIN t2
cid CONCAT(firstname, ' ', surname) COUNT(call_id)
SELECT HIGH_PRIORITY cid, CONCAT(firstname, ' ', surname), COUNT(call_id) FROM t1 LEFT JOIN t2 ON cid=contact_id WHERE firstname like '%foo%' GROUP BY cid ORDER BY surname, firstname;
cid CONCAT(firstname, ' ', surname) COUNT(call_id)
drop table t1,t2;
drop table t2;
unlock tables;
drop table t1;
CREATE TABLE t1 (
bug_id mediumint(9) NOT NULL auto_increment,
groupset bigint(20) DEFAULT '0' NOT NULL,

1
mysql-test/r/insert_notembedded.result
View File

@ -122,5 +122,6 @@ a b
connection: default
select * from t1;
a b
unlock tables;
drop table t1;
set low_priority_updates=default;

6
mysql-test/r/lock.result
View File

@ -48,6 +48,9 @@ unlock tables;
lock tables t1 write, t1 as t1_alias read;
insert into t1 select index1,nr from t1 as t1_alias;
drop table t1,t2;
ERROR HY000: Table 't2' was not locked with LOCK TABLES
unlock tables;
drop table t1,t2;
create table t1 (c1 int);
create table t2 (c1 int);
create table t3 (c1 int);
@ -69,6 +72,9 @@ ERROR HY000: Table 't2' was locked with a READ lock and can't be updated
delete t2 from t1,t2 where t1.a=t2.a;
ERROR HY000: Table 't2' was locked with a READ lock and can't be updated
drop table t1,t2;
ERROR HY000: Table 't2' was locked with a READ lock and can't be updated
unlock tables;
drop table t2,t1;
End of 4.1 tests.
drop table if exists t1;
create table t1 (a int);

10
mysql-test/r/lock_multi.result
View File

@ -27,6 +27,7 @@ update t1,t2 set c=a where b=d;
select c from t2;
c
2
unlock tables;
drop table t1;
drop table t2;
create table t1 (a int);
@ -209,3 +210,12 @@ select @tlwa < @tlwb;
@tlwa < @tlwb
1
End of 5.1 tests
drop table if exists t1;
create table t1 (i int);
connection: default
lock tables t1 write;
connection: flush
flush tables with read lock;;
connection: default
flush tables;
drop table t1;

2
mysql-test/r/myisam.result
View File

@ -529,6 +529,7 @@ select straight_join * from t1,t2 force index (primary) where t1.a=t2.a;
a a b
1 1 1
2 2 1
unlock tables;
drop table t1,t2;
CREATE TABLE t1 (c1 varchar(250) NOT NULL);
CREATE TABLE t2 (c1 varchar(250) NOT NULL, PRIMARY KEY (c1));
@ -542,6 +543,7 @@ INSERT INTO t2 VALUES ('test000001'), ('test000005');
SELECT t1.c1 AS t1c1, t2.c1 AS t2c1 FROM t1, t2
WHERE t1.c1 = t2.c1 HAVING t1c1 != t2c1;
t1c1 t2c1
UNLOCK TABLES;
DROP TABLE t1,t2;
CREATE TABLE t1 (`a` int(11) NOT NULL default '0', `b` int(11) NOT NULL default '0', UNIQUE KEY `a` USING RTREE (`a`,`b`)) ENGINE=MyISAM;
Got one of the listed errors

1
mysql-test/r/query_cache_notembedded.result
View File

@ -93,6 +93,7 @@ a
3
SELECT * FROM t1;
a
UNLOCK TABLES;
drop table t1;
flush query cache;
reset query cache;

23
mysql-test/r/sp-error.result
View File

@ -1659,6 +1659,29 @@ begin
declare continue handler for sqlstate '00000' set @x=0;
end$$
ERROR 42000: Bad SQLSTATE: '00000'
drop procedure if exists proc_36510;
create procedure proc_36510()
begin
declare should_be_illegal condition for sqlstate '00123';
declare continue handler for should_be_illegal set @x=0;
end$$
ERROR 42000: Bad SQLSTATE: '00123'
create procedure proc_36510()
begin
declare continue handler for sqlstate '00123' set @x=0;
end$$
ERROR 42000: Bad SQLSTATE: '00123'
create procedure proc_36510()
begin
declare should_be_illegal condition for 0;
declare continue handler for should_be_illegal set @x=0;
end$$
ERROR HY000: Incorrect CONDITION value: '0'
create procedure proc_36510()
begin
declare continue handler for 0 set @x=0;
end$$
ERROR HY000: Incorrect CONDITION value: '0'
drop procedure if exists p1;
set @old_recursion_depth = @@max_sp_recursion_depth;
set @@max_sp_recursion_depth = 255;

34
mysql-test/r/sp.result
View File

@ -3321,9 +3321,43 @@ call bug11529()|
call bug11529()|
delete from t1|
drop procedure bug11529|
set character set utf8|
drop procedure if exists bug6063|
drop procedure if exists bug7088_1|
drop procedure if exists bug7088_2|
create procedure bug6063()
begin
lâbel: begin end;
label: begin end;
label1: begin end;
end|
create procedure bug7088_1()
label1: begin end label1|
create procedure bug7088_2()
läbel1: begin end|
call bug6063()|
call bug7088_1()|
call bug7088_2()|
set character set default|
show create procedure bug6063|
Procedure sql_mode Create Procedure character_set_client collation_connection Database Collation
bug6063 CREATE DEFINER=`root`@`localhost` PROCEDURE `bug6063`()
begin
lâbel: begin end;
label: begin end;
label1: begin end;
end utf8 latin1_swedish_ci latin1_swedish_ci
show create procedure bug7088_1|
Procedure sql_mode Create Procedure character_set_client collation_connection Database Collation
bug7088_1 CREATE DEFINER=`root`@`localhost` PROCEDURE `bug7088_1`()
label1: begin end label1 utf8 latin1_swedish_ci latin1_swedish_ci
show create procedure bug7088_2|
Procedure sql_mode Create Procedure character_set_client collation_connection Database Collation
bug7088_2 CREATE DEFINER=`root`@`localhost` PROCEDURE `bug7088_2`()
läbel1: begin end utf8 latin1_swedish_ci latin1_swedish_ci
drop procedure bug6063|
drop procedure bug7088_1|
drop procedure bug7088_2|
drop procedure if exists bug9565_sub|
drop procedure if exists bug9565|
create procedure bug9565_sub()

6
mysql-test/r/status.result
View File

@ -238,5 +238,11 @@ SELECT 9;
9
DROP PROCEDURE p1;
DROP FUNCTION f1;
DROP VIEW IF EXISTS v1;
CREATE VIEW v1 AS SELECT VARIABLE_NAME AS NAME, CONVERT(VARIABLE_VALUE, UNSIGNED) AS VALUE FROM INFORMATION_SCHEMA.GLOBAL_STATUS;
SELECT VALUE INTO @tc FROM v1 WHERE NAME = 'Threads_connected';
SELECT NAME FROM v1 WHERE NAME = 'Threads_created' AND VALUE < @tc;
NAME
DROP VIEW v1;
set @@global.concurrent_insert= @old_concurrent_insert;
SET GLOBAL log_output = @old_log_output;

3
mysql-test/r/view.result
View File

@ -1104,6 +1104,9 @@ select * from t2;
ERROR HY000: Table 't2' was not locked with LOCK TABLES
drop view v1;
drop table t1, t2;
ERROR HY000: Table 't1' was locked with a READ lock and can't be updated
unlock tables;
drop table t1, t2;
create table t1 (a int);
create view v1 as select * from t1 where a < 2 with check option;
insert into v1 values(1);

33
mysql-test/t/drop.test
View File

@ -124,6 +124,39 @@ disconnect addconroot1;
--source include/wait_until_disconnected.inc
connection default;
#
# Bug#25858 Some DROP TABLE under LOCK TABLES can cause deadlocks
#
--disable_warnings
drop table if exists t1,t2;
--enable_warnings
create table t1 (a int);
create table t2 (a int);
lock table t1 read;
--error ER_TABLE_NOT_LOCKED
drop table t2;
--error ER_TABLE_NOT_LOCKED_FOR_WRITE
drop table t1;
unlock tables;
drop table t1,t2;
connect (addconroot, localhost, root,,);
connection default;
create table t1 (i int);
create table t2 (i int);
lock tables t1 read;
connection addconroot;
lock tables t2 read;
--error ER_TABLE_NOT_LOCKED
drop table t1;
connection default;
--error ER_TABLE_NOT_LOCKED_FOR_WRITE
drop table t1,t2;
disconnect addconroot;
connection default;
unlock tables;
drop table t1,t2;
--echo End of 5.0 tests
#

34
mysql-test/t/errors.test
View File

@ -68,6 +68,40 @@ INSERT INTO t1 SELECT b FROM t1;
DROP TABLE t1;
# End of 5.0 tests
flush status;
--disable_warnings
drop table if exists t1, t2;
--enable_warnings
create table t1 (a int unique);
create table t2 (a int);
drop function if exists f1;
drop function if exists f2;
delimiter |;
create function f1() returns int
begin
insert into t1 (a) values (1);
insert into t1 (a) values (1);
return 1;
end|
create function f2() returns int
begin
insert into t2 (a) values (1);
return 2;
end|
delimiter ;|
flush status;
--error 1062
select f1(), f2();
show status like 'Com_insert';
select * from t1;
select * from t2;
drop table t1;
drop table t2;
drop function f1;
drop function f2;
#
# testing the value encoding in the error messages of set_var
#

3
mysql-test/t/group_by.test
View File

@ -120,8 +120,9 @@ SELECT cid, CONCAT(firstname, ' ', surname), COUNT(call_id) FROM t1 LEFT JOIN t2
SELECT cid, CONCAT(firstname, ' ', surname), COUNT(call_id) FROM t1 LEFT JOIN t2 ON cid=contact_id WHERE firstname like '%foo%' GROUP BY cid ORDER BY NULL;
SELECT HIGH_PRIORITY cid, CONCAT(firstname, ' ', surname), COUNT(call_id) FROM t1 LEFT JOIN t2 ON cid=contact_id WHERE firstname like '%foo%' GROUP BY cid ORDER BY surname, firstname;
drop table t1,t2;
drop table t2;
unlock tables;
drop table t1;
#
# Test of group by bug in bugzilla

1
mysql-test/t/insert_notembedded.test
View File

@ -185,5 +185,6 @@ select * from t1;
connection default;
disconnect update;
disconnect select;
unlock tables;
drop table t1;
set low_priority_updates=default;

6
mysql-test/t/lock.test
View File

@ -58,6 +58,9 @@ insert into t1 select index1,nr from t1;
unlock tables;
lock tables t1 write, t1 as t1_alias read;
insert into t1 select index1,nr from t1 as t1_alias;
--error ER_TABLE_NOT_LOCKED
drop table t1,t2;
unlock tables;
drop table t1,t2;
#
@ -90,7 +93,10 @@ delete t1 from t1,t2 where t1.a=t2.a;
delete from t2 using t1,t2 where t1.a=t2.a;
--error 1099
delete t2 from t1,t2 where t1.a=t2.a;
--error ER_TABLE_NOT_LOCKED_FOR_WRITE
drop table t1,t2;
unlock tables;
drop table t2,t1;
--echo End of 4.1 tests.

38
mysql-test/t/lock_multi.test
View File

@ -76,6 +76,7 @@ update t1,t2 set c=a where b=d;
connection reader;
select c from t2;
connection locker;
unlock tables;
drop table t1;
drop table t2;
@ -635,6 +636,41 @@ select @tlwa < @tlwb;
--echo End of 5.1 tests
#
# Test that DROP TABLES does not wait for a impending FLUSH TABLES
# WITH READ LOCK
#
--disable_warnings
drop table if exists t1;
--enable_warnings
create table t1 (i int);
connect (flush,localhost,root,,test,,);
connection default;
--echo connection: default
lock tables t1 write;
connection flush;
--echo connection: flush
--send flush tables with read lock;
connection default;
--echo connection: default
let $wait_condition=
select count(*) = 1 from information_schema.processlist
where state = "Flushing tables";
--source include/wait_condition.inc
flush tables;
let $wait_condition=
select count(*) = 1 from information_schema.processlist
where state = "Flushing tables";
--source include/wait_condition.inc
drop table t1;
let $wait_condition=
select count(*) = 0 from information_schema.processlist
where state = "Flushing tables";
--source include/wait_condition.inc
connection flush;
--reap
connection default;
disconnect flush;
# Wait till all disconnects are completed
--source include/wait_until_count_sessions.inc

2
mysql-test/t/myisam.test
View File

@ -503,6 +503,7 @@ insert into t2 values(2,0);
disconnect root;
connection default;
select straight_join * from t1,t2 force index (primary) where t1.a=t2.a;
unlock tables;
drop table t1,t2;
#
# Full key.
@ -520,6 +521,7 @@ disconnect con1;
connection default;
SELECT t1.c1 AS t1c1, t2.c1 AS t2c1 FROM t1, t2
WHERE t1.c1 = t2.c1 HAVING t1c1 != t2c1;
UNLOCK TABLES;
DROP TABLE t1,t2;
# End of 4.0 tests

1
mysql-test/t/query_cache_notembedded.test
View File

@ -99,6 +99,7 @@ connection root2;
SELECT * FROM t1;
connection root;
SELECT * FROM t1;
UNLOCK TABLES;
drop table t1;
connection default;
disconnect root;

37
mysql-test/t/sp-error.test
View File

@ -2419,6 +2419,43 @@ end$$
delimiter ;$$
#
# Bug#36510 (Stored Procedures: mysql_error_code 0 should be illegal)
#
--disable_warnings
drop procedure if exists proc_36510;
--enable_warnings
delimiter $$;
--error ER_SP_BAD_SQLSTATE
create procedure proc_36510()
begin
declare should_be_illegal condition for sqlstate '00123';
declare continue handler for should_be_illegal set @x=0;
end$$
--error ER_SP_BAD_SQLSTATE
create procedure proc_36510()
begin
declare continue handler for sqlstate '00123' set @x=0;
end$$
--error ER_WRONG_VALUE
create procedure proc_36510()
begin
declare should_be_illegal condition for 0;
declare continue handler for should_be_illegal set @x=0;
end$$
--error ER_WRONG_VALUE
create procedure proc_36510()
begin
declare continue handler for 0 set @x=0;
end$$
delimiter ;$$
#
# Bug#15192: "fatal errors" are caught by handlers in stored procedures
#

21
mysql-test/t/sp.test
View File

@ -4061,34 +4061,41 @@ drop procedure bug11529|
# BUG#6063: Stored procedure labels are subject to restrictions (partial)
# BUG#7088: Stored procedures: labels won't work if character set is utf8
#
set character set utf8|
--disable_warnings
drop procedure if exists bug6063|
drop procedure if exists bug7088_1|
drop procedure if exists bug7088_2|
--enable_warnings
--disable_parsing # temporarily disabled until Bar fixes BUG#11986
create procedure bug6063()
lâbel: begin end|
call bug6063()|
# QQ Known bug: this will not show the label correctly.
show create procedure bug6063|
begin
lâbel: begin end;
label: begin end;
label1: begin end;
end|
set character set utf8|
create procedure bug7088_1()
label1: begin end label1|
create procedure bug7088_2()
läbel1: begin end|
call bug6063()|
call bug7088_1()|
call bug7088_2()|
set character set default|
show create procedure bug6063|
show create procedure bug7088_1|
show create procedure bug7088_2|
drop procedure bug6063|
drop procedure bug7088_1|
drop procedure bug7088_2|
--enable_parsing
#
# BUG#9565: "Wrong locking in stored procedure if a sub-sequent procedure

15
mysql-test/t/status.test
View File

@ -353,6 +353,21 @@ DROP FUNCTION f1;
# End of 5.1 tests
#
# Bug#17954 Threads_connected > Threads_created
#
--disable_warnings
DROP VIEW IF EXISTS v1;
--enable_warnings
CREATE VIEW v1 AS SELECT VARIABLE_NAME AS NAME, CONVERT(VARIABLE_VALUE, UNSIGNED) AS VALUE FROM INFORMATION_SCHEMA.GLOBAL_STATUS;
SELECT VALUE INTO @tc FROM v1 WHERE NAME = 'Threads_connected';
SELECT NAME FROM v1 WHERE NAME = 'Threads_created' AND VALUE < @tc;
DROP VIEW v1;
# Restore global concurrent_insert value. Keep in the end of the test file.
--connection default
set @@global.concurrent_insert= @old_concurrent_insert;

3
mysql-test/t/view.test
View File

@ -1017,6 +1017,9 @@ select * from v1;
-- error ER_TABLE_NOT_LOCKED
select * from t2;
drop view v1;
--error ER_TABLE_NOT_LOCKED_FOR_WRITE
drop table t1, t2;
unlock tables;
drop table t1, t2;
#

2
mysys/errors.c
View File

@ -104,7 +104,7 @@ void wait_for_free_space(const char *filename, int errors)
MYF(ME_BELL | ME_NOREFRESH),
MY_WAIT_FOR_USER_TO_FIX_PANIC,
MY_WAIT_GIVE_USER_A_MESSAGE * MY_WAIT_FOR_USER_TO_FIX_PANIC );
VOID(sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC));
(void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
}
const char **get_global_errmsgs()

2
mysys/hash.c
View File

@ -541,7 +541,7 @@ my_bool my_hash_delete(HASH *hash, uchar *record)
pos->next=empty_index;
exit:
VOID(pop_dynamic(&hash->array));
(void) pop_dynamic(&hash->array);
if (hash->free)
(*hash->free)((uchar*) record);
DBUG_RETURN(0);

4
mysys/mf_iocache2.c
View File

@ -135,7 +135,7 @@ void my_b_seek(IO_CACHE *info,my_off_t pos)
b) see if there is a better way to make it work
*/
if (info->type == SEQ_READ_APPEND)
VOID(flush_io_cache(info));
(void) flush_io_cache(info);
offset=(pos - info->pos_in_file);
@ -163,7 +163,7 @@ void my_b_seek(IO_CACHE *info,my_off_t pos)
info->write_pos = info->write_buffer + offset;
DBUG_VOID_RETURN;
}
VOID(flush_io_cache(info));
(void) flush_io_cache(info);
/* Correct buffer end so that we write in increments of IO_SIZE */
info->write_end=(info->write_buffer+info->buffer_length-
(pos & (IO_SIZE-1)));

8
mysys/mf_loadpath.c
View File

@ -34,7 +34,7 @@ char * my_load_path(char * to, const char *path,
if ((path[0] == FN_HOMELIB && path[1] == FN_LIBCHAR) ||
test_if_hard_path(path))
VOID(strmov(buff,path));
(void) strmov(buff,path);
else if ((is_cur=(path[0] == FN_CURLIB && path[1] == FN_LIBCHAR)) ||
(is_prefix(path,FN_PARENTDIR)) ||
! own_path_prefix)
@ -42,12 +42,12 @@ char * my_load_path(char * to, const char *path,
if (is_cur)
is_cur=2; /* Remove current dir */
if (! my_getwd(buff,(uint) (FN_REFLEN-strlen(path)+is_cur),MYF(0)))
VOID(strcat(buff,path+is_cur));
(void) strcat(buff,path+is_cur);
else
VOID(strmov(buff,path)); /* Return org file name */
(void) strmov(buff,path); /* Return org file name */
}
else
VOID(strxmov(buff,own_path_prefix,path,NullS));
(void) strxmov(buff,own_path_prefix,path,NullS);
strmov(to,buff);
DBUG_PRINT("exit",("to: %s",to));
DBUG_RETURN(to);

6
mysys/mf_path.c
View File

@ -42,7 +42,7 @@ char * my_path(char * to, const char *progname,
((prog=getenv("_")) != 0 &&
dirname_part(to, prog, &to_length))))
{
VOID(intern_filename(to,to));
(void) intern_filename(to,to);
if (!test_if_hard_path(to))
{
if (!my_getwd(curr_dir,FN_REFLEN,MYF(0)))
@ -60,11 +60,11 @@ char * my_path(char * to, const char *progname,
end= (char*) "/my/";
#endif
}
VOID(intern_filename(to,end));
(void) intern_filename(to,end);
to=strend(to);
if (to != start && to[-1] != FN_LIBCHAR)
*to++ = FN_LIBCHAR;
VOID(strmov(to,own_pathname_part));
(void) strmov(to,own_pathname_part);
}
DBUG_PRINT("exit",("to: '%s'",start));
DBUG_RETURN(start);

4
mysys/my_append.c
View File

@ -58,7 +58,7 @@ int my_append(const char *from, const char *to, myf MyFlags)
}
}
err:
if (from_file >= 0) VOID(my_close(from_file,MyFlags));
if (to_file >= 0) VOID(my_close(to_file,MyFlags));
if (from_file >= 0) (void) my_close(from_file,MyFlags);
if (to_file >= 0) (void) my_close(to_file,MyFlags);
DBUG_RETURN(-1);
}

2
mysys/my_clock.c
View File

@ -24,7 +24,7 @@ long my_clock(void)
{
#if !defined(__WIN__) && !defined(__NETWARE__)
struct tms tmsbuf;
VOID(times(&tmsbuf));
(void) times(&tmsbuf);
return (tmsbuf.tms_utime + tmsbuf.tms_stime);
#else
return clock();

8
mysys/my_copy.c
View File

@ -112,19 +112,19 @@ int my_copy(const char *from, const char *to, myf MyFlags)
struct utimbuf timep;
timep.actime = stat_buff.st_atime;
timep.modtime = stat_buff.st_mtime;
VOID(utime((char*) to, &timep)); /* last accessed and modified times */
(void) utime((char*) to, &timep); /* last accessed and modified times */
}
#endif
DBUG_RETURN(0);
}
err:
if (from_file >= 0) VOID(my_close(from_file,MyFlags));
if (from_file >= 0) (void) my_close(from_file,MyFlags);
if (to_file >= 0)
{
VOID(my_close(to_file, MyFlags));
(void) my_close(to_file, MyFlags);
/* attempt to delete the to-file we've partially written */
VOID(my_delete(to, MyFlags));
(void) my_delete(to, MyFlags);
}
DBUG_RETURN(-1);
} /* my_copy */

4
mysys/my_fstream.c
View File

@ -119,7 +119,7 @@ size_t my_fwrite(FILE *stream, const uchar *Buffer, size_t Count, myf MyFlags)
#ifdef EINTR
if (errno == EINTR)
{
VOID(my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0)));
(void) my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0));
continue;
}
#endif
@ -133,7 +133,7 @@ size_t my_fwrite(FILE *stream, const uchar *Buffer, size_t Count, myf MyFlags)
{
wait_for_free_space("[stream]", errors);
errors++;
VOID(my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0)));
(void) my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0));
continue;
}
#endif

2
mysys/my_getwd.c
View File

@ -51,7 +51,7 @@ int my_getwd(char * buf, size_t size, myf MyFlags)
(long) buf, (uint) size, MyFlags));
if (curr_dir[0]) /* Current pos is saved here */
VOID(strmake(buf,&curr_dir[0],size-1));
(void) strmake(buf,&curr_dir[0],size-1);
else
{
#if defined(HAVE_GETCWD)

22
mysys/my_lib.c
View File

@ -159,8 +159,8 @@ MY_DIR *my_dir(const char *path, myf MyFlags)
goto error;
bzero(finfo.mystat, sizeof(MY_STAT));
VOID(strmov(tmp_file,dp->d_name));
VOID(my_stat(tmp_path, finfo.mystat, MyFlags));
(void) strmov(tmp_file,dp->d_name);
(void) my_stat(tmp_path, finfo.mystat, MyFlags);
if (!(finfo.mystat->st_mode & MY_S_IREAD))
continue;
}
@ -266,7 +266,7 @@ char * directory_file_name (char * dst, const char *src)
/* what about when we have logical_name:???? */
if (src[slen] == FN_DEVCHAR)
{ /* Xlate logical name and see what we get */
VOID(strmov(dst,src));
(void) strmov(dst,src);
dst[slen] = 0; /* remove colon */
if (!(src = getenv (dst)))
return dst; /* Can't translate */
@ -282,13 +282,13 @@ char * directory_file_name (char * dst, const char *src)
slen = strlen (src) - 1;
if (src[slen] != FN_C_AFTER_DIR && src[slen] != FN_C_AFTER_DIR_2)
{ /* no recursion here! */
VOID(strmov(dst, src));
(void) strmov(dst, src);
return(dst);
}
}
else
{ /* not a directory spec */
VOID(strmov(dst, src));
(void) strmov(dst, src);
return(dst);
}
}
@ -296,13 +296,13 @@ char * directory_file_name (char * dst, const char *src)
bracket = src[slen]; /* End char */
if (!(ptr = strchr (src, bracket - 2)))
{ /* no opening bracket */
VOID(strmov (dst, src));
(void) strmov (dst, src);
return dst;
}
if (!(rptr = strrchr (src, '.')))
rptr = ptr;
slen = rptr - src;
VOID(strmake (dst, src, slen));
(void) strmake (dst, src, slen);
if (*rptr == '.')
{ /* Put bracket and add */
@ -323,7 +323,7 @@ char * directory_file_name (char * dst, const char *src)
&& (ptr[rlen] == FN_C_AFTER_DIR || ptr[rlen] == FN_C_AFTER_DIR_2)
&& ptr[rlen - 1] == '.')
{
VOID(strmov(esa,ptr));
(void) strmov(esa,ptr);
esa[rlen - 1] = FN_C_AFTER_DIR;
esa[rlen] = '\0';
return (directory_file_name (dst, esa));
@ -331,13 +331,13 @@ char * directory_file_name (char * dst, const char *src)
else
dst[slen - 1] = ':';
}
VOID(strmov(dst+slen,"[000000]"));
(void) strmov(dst+slen,"[000000]");
slen += 8;
}
VOID(strmov(strmov(dst+slen,rptr+1)-1,".DIR.1"));
(void) strmov(strmov(dst+slen,rptr+1)-1,".DIR.1");
return dst;
}
VOID(strmov(dst, src));
(void) strmov(dst, src);
if (dst[slen] == '/' && slen > 1)
dst[slen] = 0;
return dst;

4
mysys/my_lockmem.c
View File

@ -59,7 +59,7 @@ uchar *my_malloc_lock(uint size,myf MyFlags)
/* Add block in a list for munlock */
if (!(element=(struct st_mem_list*) my_malloc(sizeof(*element),MyFlags)))
{
VOID(munlock((uchar*) ptr,size));
(void) munlock((uchar*) ptr,size);
free(ptr);
DBUG_RETURN(0);
}
@ -85,7 +85,7 @@ void my_free_lock(uchar *ptr,myf Myflags __attribute__((unused)))
element=(struct st_mem_list*) list->data;
if (ptr == element->page)
{ /* Found locked mem */
VOID(munlock((uchar*) ptr,element->size));
(void) munlock((uchar*) ptr,element->size);
mem_list=list_delete(mem_list,list);
break;
}

49
mysys/my_pthread.c
View File

@ -31,46 +31,6 @@
uint thd_lib_detected= 0;
#ifndef my_pthread_setprio
void my_pthread_setprio(pthread_t thread_id,int prior)
{
#ifdef HAVE_PTHREAD_SETSCHEDPARAM
struct sched_param tmp_sched_param;
bzero((char*) &tmp_sched_param,sizeof(tmp_sched_param));
tmp_sched_param.sched_priority=prior;
VOID(pthread_setschedparam(thread_id,SCHED_POLICY,&tmp_sched_param));
#endif
}
#endif
#ifndef my_pthread_getprio
int my_pthread_getprio(pthread_t thread_id)
{
#ifdef HAVE_PTHREAD_SETSCHEDPARAM
struct sched_param tmp_sched_param;
int policy;
if (!pthread_getschedparam(thread_id,&policy,&tmp_sched_param))
{
return tmp_sched_param.sched_priority;
}
#endif
return -1;
}
#endif
#ifndef my_pthread_attr_setprio
void my_pthread_attr_setprio(pthread_attr_t *attr, int priority)
{
#ifdef HAVE_PTHREAD_SETSCHEDPARAM
struct sched_param tmp_sched_param;
bzero((char*) &tmp_sched_param,sizeof(tmp_sched_param));
tmp_sched_param.sched_priority=priority;
VOID(pthread_attr_setschedparam(attr,&tmp_sched_param));
#endif
}
#endif
/* To allow use of pthread_getspecific with two arguments */
#ifdef HAVE_NONPOSIX_PTHREAD_GETSPECIFIC
@ -308,7 +268,7 @@ void sigwait_handle_sig(int sig)
{
pthread_mutex_lock(&LOCK_sigwait);
sigaddset(&pending_set, sig);
VOID(pthread_cond_signal(&COND_sigwait)); /* inform sigwait() about signal */
pthread_cond_signal(&COND_sigwait); /* inform sigwait() about signal */
pthread_mutex_unlock(&LOCK_sigwait);
}
@ -364,9 +324,8 @@ int sigwait(sigset_t *setp, int *sigp)
pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_PROCESS);
pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
pthread_attr_setstacksize(&thr_attr,8196);
my_pthread_attr_setprio(&thr_attr,100); /* Very high priority */
VOID(pthread_create(&sigwait_thread_id,&thr_attr,sigwait_thread,setp));
VOID(pthread_attr_destroy(&thr_attr));
pthread_create(&sigwait_thread_id,&thr_attr,sigwait_thread,setp);
pthread_attr_destroy(&thr_attr);
}
pthread_mutex_lock(&LOCK_sigwait);
@ -392,7 +351,7 @@ int sigwait(sigset_t *setp, int *sigp)
return 0;
}
}
VOID(pthread_cond_wait(&COND_sigwait,&LOCK_sigwait));
pthread_cond_wait(&COND_sigwait,&LOCK_sigwait);
}
return 0;
}

6
mysys/my_redel.c
View File

@ -89,7 +89,7 @@ int my_copystat(const char *from, const char *to, int MyFlags)
}
if ((statbuf.st_mode & S_IFMT) != S_IFREG)
return 1;
VOID(chmod(to, statbuf.st_mode & 07777)); /* Copy modes */
(void) chmod(to, statbuf.st_mode & 07777); /* Copy modes */
#if !defined(__WIN__) && !defined(__NETWARE__)
if (statbuf.st_nlink > 1 && MyFlags & MY_LINK_WARNING)
@ -107,7 +107,7 @@ int my_copystat(const char *from, const char *to, int MyFlags)
struct utimbuf timep;
timep.actime = statbuf.st_atime;
timep.modtime = statbuf.st_mtime;
VOID(utime((char*) to, &timep));/* Update last accessed and modified times */
(void) utime((char*) to, &timep);/* Update last accessed and modified times */
}
#else
if (MyFlags & MY_COPYTIME)
@ -115,7 +115,7 @@ int my_copystat(const char *from, const char *to, int MyFlags)
time_t time[2];
time[0]= statbuf.st_atime;
time[1]= statbuf.st_mtime;
VOID(utime((char*) to, time));/* Update last accessed and modified times */
(void) utime((char*) to, time);/* Update last accessed and modified times */
}
#endif
#endif

7
mysys/my_wincond.c
View File

@ -181,7 +181,6 @@ int pthread_attr_init(pthread_attr_t *connect_att)
{
connect_att->dwStackSize = 0;
connect_att->dwCreatingFlag = 0;
connect_att->priority = 0;
return 0;
}
@ -191,12 +190,6 @@ int pthread_attr_setstacksize(pthread_attr_t *connect_att,DWORD stack)
return 0;
}
int pthread_attr_setprio(pthread_attr_t *connect_att,int priority)
{
connect_att->priority=priority;
return 0;
}
int pthread_attr_destroy(pthread_attr_t *connect_att)
{
bzero((uchar*) connect_att,sizeof(*connect_att));

3
mysys/stacktrace.c
View File

@ -13,9 +13,6 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/* Workaround for Bug#32082: VOID redefinition on Win results in compile errors*/
#define DONT_DEFINE_VOID 1
#include <my_global.h>
#include <my_stacktrace.h>

22
mysys/thr_alarm.c
View File

@ -97,10 +97,8 @@ void init_thr_alarm(uint max_alarms)
pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_PROCESS);
pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
pthread_attr_setstacksize(&thr_attr,8196);
my_pthread_attr_setprio(&thr_attr,100); /* Very high priority */
VOID(pthread_create(&alarm_thread,&thr_attr,alarm_handler,NULL));
VOID(pthread_attr_destroy(&thr_attr));
pthread_create(&alarm_thread,&thr_attr,alarm_handler,NULL);
pthread_attr_destroy(&thr_attr);
}
#elif defined(USE_ONE_SIGNAL_HAND)
pthread_sigmask(SIG_BLOCK, &s, NULL); /* used with sigwait() */
@ -774,7 +772,7 @@ static void *test_thread(void *arg)
break;
continue;
}
VOID(getchar()); /* Somebody was playing */
(void) getchar(); /* Somebody was playing */
}
}
}
@ -786,7 +784,7 @@ static void *test_thread(void *arg)
}
pthread_mutex_lock(&LOCK_thread_count);
thread_count--;
VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
pthread_mutex_unlock(&LOCK_thread_count);
free((uchar*) arg);
return 0;
@ -815,7 +813,7 @@ static void *signal_hand(void *arg __attribute__((unused)))
pthread_detach_this_thread();
init_thr_alarm(10); /* Setup alarm handler */
pthread_mutex_lock(&LOCK_thread_count); /* Required by bsdi */
VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
pthread_mutex_unlock(&LOCK_thread_count);
sigemptyset(&set); /* Catch all signals */
@ -906,7 +904,7 @@ int main(int argc __attribute__((unused)),char **argv __attribute__((unused)))
#ifdef NOT_USED
sigemptyset(&set);
sigaddset(&set, thr_client_alarm);
VOID(pthread_sigmask(SIG_UNBLOCK, &set, (sigset_t*) 0));
pthread_sigmask(SIG_UNBLOCK, &set, (sigset_t*) 0);
#endif
pthread_attr_init(&thr_attr);
@ -915,10 +913,10 @@ int main(int argc __attribute__((unused)),char **argv __attribute__((unused)))
pthread_attr_setstacksize(&thr_attr,65536L);
/* Start signal thread and wait for it to start */
VOID(pthread_mutex_lock(&LOCK_thread_count));
pthread_mutex_lock(&LOCK_thread_count);
pthread_create(&tid,&thr_attr,signal_hand,NULL);
VOID(pthread_cond_wait(&COND_thread_count,&LOCK_thread_count));
VOID(pthread_mutex_unlock(&LOCK_thread_count));
pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
pthread_mutex_unlock(&LOCK_thread_count);
DBUG_PRINT("info",("signal thread created"));
thr_setconcurrency(3);
@ -946,7 +944,7 @@ int main(int argc __attribute__((unused)),char **argv __attribute__((unused)))
alarm_info.next_alarm_time);
while (thread_count)
{
VOID(pthread_cond_wait(&COND_thread_count,&LOCK_thread_count));
pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
if (thread_count == 1)
{
printf("Calling end_thr_alarm. This should cancel the last thread\n");

18
mysys/thr_lock.c
View File

@ -316,7 +316,7 @@ void thr_lock_init(THR_LOCK *lock)
{
DBUG_ENTER("thr_lock_init");
bzero((char*) lock,sizeof(*lock));
VOID(pthread_mutex_init(&lock->mutex,MY_MUTEX_INIT_FAST));
pthread_mutex_init(&lock->mutex,MY_MUTEX_INIT_FAST);
lock->read.last= &lock->read.data;
lock->read_wait.last= &lock->read_wait.data;
lock->write_wait.last= &lock->write_wait.data;
@ -522,7 +522,7 @@ thr_lock(THR_LOCK_DATA *data, THR_LOCK_OWNER *owner,
data->cond=0; /* safety */
data->type=lock_type;
data->owner= owner; /* Must be reset ! */
VOID(pthread_mutex_lock(&lock->mutex));
pthread_mutex_lock(&lock->mutex);
DBUG_PRINT("lock",("data: 0x%lx thread: 0x%lx lock: 0x%lx type: %d",
(long) data, data->owner->info->thread_id,
(long) lock, (int) lock_type));
@ -794,7 +794,7 @@ static inline void free_all_read_locks(THR_LOCK *lock,
data->owner->info->thread_id));
/* purecov: end */
data->cond=0; /* Mark thread free */
VOID(pthread_cond_signal(cond));
pthread_cond_signal(cond);
} while ((data=data->next));
*lock->read_wait.last=0;
if (!lock->read_wait.data)
@ -904,7 +904,7 @@ static void wake_up_waiters(THR_LOCK *lock)
{
pthread_cond_t *cond=data->cond;
data->cond=0; /* Mark thread free */
VOID(pthread_cond_signal(cond)); /* Start waiting thread */
pthread_cond_signal(cond); /* Start waiting thread */
}
if (data->type != TL_WRITE_ALLOW_WRITE ||
!lock->write_wait.data ||
@ -955,7 +955,7 @@ static void wake_up_waiters(THR_LOCK *lock)
lock->write.last= &data->next;
data->next=0; /* Only one write lock */
data->cond=0; /* Mark thread free */
VOID(pthread_cond_signal(cond)); /* Start waiting thread */
pthread_cond_signal(cond); /* Start waiting thread */
} while (lock_type == TL_WRITE_ALLOW_WRITE &&
(data=lock->write_wait.data) &&
data->type == TL_WRITE_ALLOW_WRITE);
@ -1526,7 +1526,7 @@ void thr_print_locks(void)
list= list_rest(list))
{
THR_LOCK *lock=(THR_LOCK*) list->data;
VOID(pthread_mutex_lock(&lock->mutex));
pthread_mutex_lock(&lock->mutex);
printf("lock: 0x%lx:",(ulong) lock);
if ((lock->write_wait.data || lock->read_wait.data) &&
(! lock->read.data && ! lock->write.data))
@ -1544,7 +1544,7 @@ void thr_print_locks(void)
thr_print_lock("write_wait",&lock->write_wait);
thr_print_lock("read",&lock->read);
thr_print_lock("read_wait",&lock->read_wait);
VOID(pthread_mutex_unlock(&lock->mutex));
pthread_mutex_unlock(&lock->mutex);
puts("");
}
fflush(stdout);
@ -1684,7 +1684,7 @@ static void *test_thread(void *arg)
thr_print_locks();
pthread_mutex_lock(&LOCK_thread_count);
thread_count--;
VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
pthread_mutex_unlock(&LOCK_thread_count);
free((uchar*) arg);
return 0;
@ -1745,7 +1745,7 @@ int main(int argc __attribute__((unused)),char **argv __attribute__((unused)))
}
#endif
#ifdef HAVE_THR_SETCONCURRENCY
VOID(thr_setconcurrency(2));
(void) thr_setconcurrency(2);
#endif
for (i=0 ; i < (int) array_elements(lock_counts) ; i++)
{

6
sql/derror.cc
View File

@ -143,7 +143,7 @@ Error message file '%s' had only %d error messages,\n\
but it should contain at least %d error messages.\n\
Check that the above file is the right version for this program!",
name,count,error_messages);
VOID(my_close(file,MYF(MY_WME)));
(void) my_close(file,MYF(MY_WME));
DBUG_RETURN(1);
}
@ -170,7 +170,7 @@ Check that the above file is the right version for this program!",
{
point[i]= *point +uint2korr(head+10+i+i);
}
VOID(my_close(file,MYF(0)));
(void) my_close(file,MYF(0));
DBUG_RETURN(0);
err:
@ -187,7 +187,7 @@ err:
}
sql_print_error(errmsg, name);
if (file != FERR)
VOID(my_close(file,MYF(MY_WME)));
(void) my_close(file,MYF(MY_WME));
DBUG_RETURN(1);
} /* read_texts */

4
sql/des_key_file.cc
View File

@ -43,7 +43,7 @@ load_des_key_file(const char *file_name)
DBUG_ENTER("load_des_key_file");
DBUG_PRINT("enter",("name: %s",file_name));
VOID(pthread_mutex_lock(&LOCK_des_key_file));
pthread_mutex_lock(&LOCK_des_key_file);
if ((file=my_open(file_name,O_RDONLY | O_BINARY ,MYF(MY_WME))) < 0 ||
init_io_cache(&io, file, IO_SIZE*2, READ_CACHE, 0, 0, MYF(MY_WME)))
goto error;
@ -96,7 +96,7 @@ error:
my_close(file,MYF(0));
end_io_cache(&io);
}
VOID(pthread_mutex_unlock(&LOCK_des_key_file));
pthread_mutex_unlock(&LOCK_des_key_file);
DBUG_RETURN(result);
}
#endif /* HAVE_OPENSSL */

4
sql/discover.cc
View File

@ -82,7 +82,7 @@ int readfrm(const char *name, uchar **frmdata, size_t *len)
err:
if (file > 0)
VOID(my_close(file,MYF(MY_WME)));
(void) my_close(file,MYF(MY_WME));
err_end: /* Here when no file */
DBUG_RETURN (error);
@ -118,7 +118,7 @@ int writefrm(const char *name, const uchar *frmdata, size_t len)
{
if (my_write(file, frmdata, len,MYF(MY_WME | MY_NABP)))
error= 2;
VOID(my_close(file,MYF(0)));
(void) my_close(file,MYF(0));
}
DBUG_RETURN(error);
} /* writefrm */

4
sql/field.cc
View File

@ -4200,7 +4200,7 @@ String *Field_float::val_str(String *val_buffer,
char buff[70],*pos=buff;
int decpt,sign,tmp_dec=dec;
VOID(sfconvert(&nr,tmp_dec,&decpt,&sign,buff));
(void) sfconvert(&nr,tmp_dec,&decpt,&sign,buff);
if (sign)
{
*to++='-';
@ -4559,7 +4559,7 @@ String *Field_double::val_str(String *val_buffer,
char *pos= buff;
int decpt,sign,tmp_dec=dec;
VOID(fconvert(nr,tmp_dec,&decpt,&sign,buff));
(void) fconvert(nr,tmp_dec,&decpt,&sign,buff);
if (sign)
{
*to++='-';

2
sql/filesort.cc
View File

@ -1318,7 +1318,7 @@ int merge_buffers(SORTPARAM *param, IO_CACHE *from_file,
if (!(error= (int) read_to_buffer(from_file,buffpek,
rec_length)))
{
VOID(queue_remove(&queue,0));
(void) queue_remove(&queue,0);
reuse_freed_buff(&queue, buffpek, rec_length);
break; /* One buffer have been removed */
}

4
sql/ha_ndbcluster.cc
View File

@ -6904,7 +6904,7 @@ int ndbcluster_drop_database_impl(const char *path)
while ((tabname=it++))
{
tablename_to_filename(tabname, tmp, FN_REFLEN - (tmp - full_path)-1);
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
if (ha_ndbcluster::delete_table(0, ndb, full_path, dbname, tabname))
{
const NdbError err= dict->getNdbError();
@ -6914,7 +6914,7 @@ int ndbcluster_drop_database_impl(const char *path)
ret= ndb_to_mysql_error(&err);
}
}
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
}
DBUG_RETURN(ret);
}

28
sql/ha_partition.cc
View File

@ -641,7 +641,7 @@ int ha_partition::drop_partitions(const char *path)
part_elem->part_state= PART_IS_DROPPED;
}
} while (++i < num_parts);
VOID(sync_ddl_log());
(void) sync_ddl_log();
DBUG_RETURN(error);
}
@ -739,7 +739,7 @@ int ha_partition::rename_partitions(const char *path)
part_elem->log_entry= NULL; /* Indicate success */
}
} while (++i < temp_partitions);
VOID(sync_ddl_log());
(void) sync_ddl_log();
}
i= 0;
do
@ -791,7 +791,7 @@ int ha_partition::rename_partitions(const char *path)
error= ret_error;
else if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos))
error= 1;
VOID(sync_ddl_log());
(void) sync_ddl_log();
}
file= m_new_file[part];
create_subpartition_name(part_name_buff, path,
@ -822,7 +822,7 @@ int ha_partition::rename_partitions(const char *path)
error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
VOID(sync_ddl_log());
(void) sync_ddl_log();
}
file= m_new_file[i];
create_partition_name(part_name_buff, path,
@ -840,7 +840,7 @@ int ha_partition::rename_partitions(const char *path)
}
}
} while (++i < num_parts);
VOID(sync_ddl_log());
(void) sync_ddl_log();
DBUG_RETURN(error);
}
@ -1295,7 +1295,7 @@ int ha_partition::prepare_new_partition(TABLE *tbl,
DBUG_RETURN(0);
error:
if (create_flag)
VOID(file->ha_delete_table(part_name));
(void) file->ha_delete_table(part_name);
DBUG_RETURN(error);
}
@ -2210,7 +2210,7 @@ bool ha_partition::create_handler_file(const char *name)
{
result= my_write(file, (uchar *) file_buffer, tot_len_byte,
MYF(MY_WME | MY_NABP)) != 0;
VOID(my_close(file, MYF(0)));
(void) my_close(file, MYF(0));
}
else
result= TRUE;
@ -2396,7 +2396,7 @@ bool ha_partition::get_from_handler_file(const char *name, MEM_ROOT *mem_root)
len_bytes= 4 * len_words;
if (!(file_buffer= (char*) my_malloc(len_bytes, MYF(0))))
goto err1;
VOID(my_seek(file, 0, MY_SEEK_SET, MYF(0)));
my_seek(file, 0, MY_SEEK_SET, MYF(0));
if (my_read(file, (uchar *) file_buffer, len_bytes, MYF(MY_NABP)))
goto err2;
@ -2418,7 +2418,7 @@ bool ha_partition::get_from_handler_file(const char *name, MEM_ROOT *mem_root)
if (len_words != (tot_partition_words + tot_name_words + 4))
goto err3;
name_buffer_ptr= file_buffer + 16 + 4 * tot_partition_words;
VOID(my_close(file, MYF(0)));
(void) my_close(file, MYF(0));
m_file_buffer= file_buffer; // Will be freed in clear_handler_file()
m_name_buffer_ptr= name_buffer_ptr;
@ -2443,7 +2443,7 @@ err3:
err2:
my_free(file_buffer, MYF(0));
err1:
VOID(my_close(file, MYF(0)));
(void) my_close(file, MYF(0));
DBUG_RETURN(TRUE);
}
@ -5844,9 +5844,9 @@ void ha_partition::late_extra_cache(uint partition_id)
DBUG_VOID_RETURN;
file= m_file[partition_id];
if (m_extra_cache_size == 0)
VOID(file->extra(HA_EXTRA_CACHE));
(void) file->extra(HA_EXTRA_CACHE);
else
VOID(file->extra_opt(HA_EXTRA_CACHE, m_extra_cache_size));
(void) file->extra_opt(HA_EXTRA_CACHE, m_extra_cache_size);
DBUG_VOID_RETURN;
}
@ -5870,7 +5870,7 @@ void ha_partition::late_extra_no_cache(uint partition_id)
if (!m_extra_cache)
DBUG_VOID_RETURN;
file= m_file[partition_id];
VOID(file->extra(HA_EXTRA_NO_CACHE));
(void) file->extra(HA_EXTRA_NO_CACHE);
DBUG_VOID_RETURN;
}
@ -6675,7 +6675,7 @@ static PARTITION_SHARE *get_share(const char *table_name, TABLE *table)
if (!partition_init)
{
partition_init++;
VOID(pthread_mutex_init(&partition_mutex, MY_MUTEX_INIT_FAST));
pthread_mutex_init(&partition_mutex, MY_MUTEX_INIT_FAST);
(void) hash_init(&partition_open_tables, system_charset_info, 32, 0, 0,
(hash_get_key) partition_get_key, 0, 0);
}

27
sql/handler.cc
View File

@ -992,7 +992,7 @@ int ha_prepare(THD *thd)
THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
Ha_trx_info *ha_info= trans->ha_list;
DBUG_ENTER("ha_prepare");
#ifdef USING_TRANSACTIONS
if (ha_info)
{
for (; ha_info; ha_info= ha_info->next())
@ -1018,7 +1018,7 @@ int ha_prepare(THD *thd)
}
}
}
#endif /* USING_TRANSACTIONS */
DBUG_RETURN(error);
}
@ -1146,7 +1146,7 @@ int ha_commit_trans(THD *thd, bool all)
my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
DBUG_RETURN(2);
}
#ifdef USING_TRANSACTIONS
if (ha_info)
{
uint rw_ha_count;
@ -1227,7 +1227,6 @@ end:
/* Free resources and perform other cleanup even for 'empty' transactions. */
else if (is_real_trans)
thd->transaction.cleanup();
#endif /* USING_TRANSACTIONS */
DBUG_RETURN(error);
}
@ -1249,7 +1248,7 @@ int ha_commit_one_phase(THD *thd, bool all)
bool is_real_trans=all || thd->transaction.all.ha_list == 0;
Ha_trx_info *ha_info= trans->ha_list, *ha_info_next;
DBUG_ENTER("ha_commit_one_phase");
#ifdef USING_TRANSACTIONS
if (ha_info)
{
for (; ha_info; ha_info= ha_info_next)
@ -1279,7 +1278,7 @@ int ha_commit_one_phase(THD *thd, bool all)
/* Free resources and perform other cleanup even for 'empty' transactions. */
if (is_real_trans)
thd->transaction.cleanup();
#endif /* USING_TRANSACTIONS */
DBUG_RETURN(error);
}
@ -1319,7 +1318,7 @@ int ha_rollback_trans(THD *thd, bool all)
my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
DBUG_RETURN(1);
}
#ifdef USING_TRANSACTIONS
if (ha_info)
{
/* Close all cursors that can not survive ROLLBACK */
@ -1350,7 +1349,6 @@ int ha_rollback_trans(THD *thd, bool all)
/* Always cleanup. Even if there nht==0. There may be savepoints. */
if (is_real_trans)
thd->transaction.cleanup();
#endif /* USING_TRANSACTIONS */
if (all)
thd->transaction_rollback_request= FALSE;
@ -1386,7 +1384,7 @@ int ha_rollback_trans(THD *thd, bool all)
int ha_autocommit_or_rollback(THD *thd, int error)
{
DBUG_ENTER("ha_autocommit_or_rollback");
#ifdef USING_TRANSACTIONS
if (thd->transaction.stmt.ha_list)
{
if (!error)
@ -1404,7 +1402,6 @@ int ha_autocommit_or_rollback(THD *thd, int error)
thd->variables.tx_isolation=thd->session_tx_isolation;
}
else
#endif
{
if (!error)
RUN_HOOK(transaction, after_commit, (thd, FALSE));
@ -1812,7 +1809,7 @@ int ha_savepoint(THD *thd, SAVEPOINT *sv)
&thd->transaction.all);
Ha_trx_info *ha_info= trans->ha_list;
DBUG_ENTER("ha_savepoint");
#ifdef USING_TRANSACTIONS
for (; ha_info; ha_info= ha_info->next())
{
int err;
@ -1836,7 +1833,7 @@ int ha_savepoint(THD *thd, SAVEPOINT *sv)
engines are prepended to the beginning of the list.
*/
sv->ha_list= trans->ha_list;
#endif /* USING_TRANSACTIONS */
DBUG_RETURN(error);
}
@ -3017,7 +3014,7 @@ static bool update_frm_version(TABLE *table)
}
err:
if (file >= 0)
VOID(my_close(file,MYF(MY_WME)));
(void) my_close(file,MYF(MY_WME));
DBUG_RETURN(result);
}
@ -3650,7 +3647,7 @@ int ha_create_table(THD *thd, const char *path,
name= get_canonical_filename(table.file, share.path.str, name_buff);
error= table.file->ha_create(name, &table, create_info);
VOID(closefrm(&table, 0));
(void) closefrm(&table, 0);
if (error)
{
strxmov(name_buff, db, ".", table_name, NullS);
@ -3721,7 +3718,7 @@ int ha_create_table_from_engine(THD* thd, const char *db, const char *name)
get_canonical_filename(table.file, path, path);
error=table.file->ha_create(path, &table, &create_info);
VOID(closefrm(&table, 1));
(void) closefrm(&table, 1);
DBUG_RETURN(error != 0);
}

2
sql/handler.h
View File

@ -31,8 +31,6 @@
#define NO_HASH /* Not yet implemented */
#endif
#define USING_TRANSACTIONS
// the following is for checking tables
#define HA_ADMIN_ALREADY_DONE 1

28
sql/hostname.cc
View File

@ -87,7 +87,7 @@ static void add_hostname(struct in_addr *in,const char *name)
{
if (!(specialflag & SPECIAL_NO_HOST_CACHE))
{
VOID(pthread_mutex_lock(&hostname_cache->lock));
pthread_mutex_lock(&hostname_cache->lock);
host_entry *entry;
if (!(entry=(host_entry*) hostname_cache->search((uchar*) &in->s_addr,0)))
{
@ -106,7 +106,7 @@ static void add_hostname(struct in_addr *in,const char *name)
(void) hostname_cache->add(entry);
}
}
VOID(pthread_mutex_unlock(&hostname_cache->lock));
pthread_mutex_unlock(&hostname_cache->lock);
}
}
@ -118,20 +118,20 @@ inline void add_wrong_ip(struct in_addr *in)
void inc_host_errors(struct in_addr *in)
{
VOID(pthread_mutex_lock(&hostname_cache->lock));
pthread_mutex_lock(&hostname_cache->lock);
host_entry *entry;
if ((entry=(host_entry*) hostname_cache->search((uchar*) &in->s_addr,0)))
entry->errors++;
VOID(pthread_mutex_unlock(&hostname_cache->lock));
pthread_mutex_unlock(&hostname_cache->lock);
}
void reset_host_errors(struct in_addr *in)
{
VOID(pthread_mutex_lock(&hostname_cache->lock));
pthread_mutex_lock(&hostname_cache->lock);
host_entry *entry;
if ((entry=(host_entry*) hostname_cache->search((uchar*) &in->s_addr,0)))
entry->errors=0;
VOID(pthread_mutex_unlock(&hostname_cache->lock));
pthread_mutex_unlock(&hostname_cache->lock);
}
/* Deal with systems that don't defined INADDR_LOOPBACK */
@ -153,7 +153,7 @@ char * ip_to_hostname(struct in_addr *in, uint *errors)
/* Check first if we have name in cache */
if (!(specialflag & SPECIAL_NO_HOST_CACHE))
{
VOID(pthread_mutex_lock(&hostname_cache->lock));
pthread_mutex_lock(&hostname_cache->lock);
if ((entry=(host_entry*) hostname_cache->search((uchar*) &in->s_addr,0)))
{
char *name;
@ -162,10 +162,10 @@ char * ip_to_hostname(struct in_addr *in, uint *errors)
else
name=my_strdup(entry->hostname,MYF(0));
*errors= entry->errors;
VOID(pthread_mutex_unlock(&hostname_cache->lock));
pthread_mutex_unlock(&hostname_cache->lock);
DBUG_RETURN(name);
}
VOID(pthread_mutex_unlock(&hostname_cache->lock));
pthread_mutex_unlock(&hostname_cache->lock);
}
struct hostent *hp, *check;
@ -214,10 +214,10 @@ char * ip_to_hostname(struct in_addr *in, uint *errors)
}
my_gethostbyname_r_free();
#else
VOID(pthread_mutex_lock(&LOCK_hostname));
pthread_mutex_lock(&LOCK_hostname);
if (!(hp=gethostbyaddr((char*) in,sizeof(*in), AF_INET)))
{
VOID(pthread_mutex_unlock(&LOCK_hostname));
pthread_mutex_unlock(&LOCK_hostname);
DBUG_PRINT("error",("gethostbyaddr returned %d",errno));
if (errno == HOST_NOT_FOUND || errno == NO_DATA)
@ -227,17 +227,17 @@ char * ip_to_hostname(struct in_addr *in, uint *errors)
}
if (!hp->h_name[0]) // Don't allow empty hostnames
{
VOID(pthread_mutex_unlock(&LOCK_hostname));
pthread_mutex_unlock(&LOCK_hostname);
DBUG_PRINT("error",("Got an empty hostname"));
goto add_wrong_ip_and_return;
}
if (!(name=my_strdup(hp->h_name,MYF(0))))
{
VOID(pthread_mutex_unlock(&LOCK_hostname));
pthread_mutex_unlock(&LOCK_hostname);
DBUG_RETURN(0); // out of memory
}
check=gethostbyname(name);
VOID(pthread_mutex_unlock(&LOCK_hostname));
pthread_mutex_unlock(&LOCK_hostname);
if (!check)
{
DBUG_PRINT("error",("gethostbyname returned %d",errno));

2
sql/init.cc
View File

@ -40,7 +40,7 @@ void unireg_init(ulong options)
my_abort_hook=unireg_abort; /* Abort with close of databases */
#endif
VOID(strmov(reg_ext,".frm"));
(void) strmov(reg_ext,".frm");
reg_ext_length= 4;
specialflag=SPECIAL_SAME_DB_NAME | options; /* Set options from argv */
DBUG_VOID_RETURN;

2
sql/item.cc
View File

@ -1196,7 +1196,7 @@ void Item_case_expr::print(String *str, enum_query_type)
{
if (str->reserve(MAX_INT_WIDTH + sizeof("case_expr@")))
return; /* purecov: inspected */
VOID(str->append(STRING_WITH_LEN("case_expr@")));
(void) str->append(STRING_WITH_LEN("case_expr@"));
str->qs_append(m_case_expr_id);
}

2
sql/item_cmpfunc.cc
View File

@ -4187,7 +4187,7 @@ void Item_cond::neg_arguments(THD *thd)
if (!(new_item= new Item_func_not(item)))
return; // Fatal OEM error
}
VOID(li.replace(new_item));
(void) li.replace(new_item);
}
}

12
sql/item_strfunc.cc
View File

@ -465,18 +465,18 @@ String *Item_func_des_encrypt::val_str(String *str)
if (arg_count == 1)
{
/* Protect against someone doing FLUSH DES_KEY_FILE */
VOID(pthread_mutex_lock(&LOCK_des_key_file));
pthread_mutex_lock(&LOCK_des_key_file);
keyschedule= des_keyschedule[key_number=des_default_key];
VOID(pthread_mutex_unlock(&LOCK_des_key_file));
pthread_mutex_unlock(&LOCK_des_key_file);
}
else if (args[1]->result_type() == INT_RESULT)
{
key_number= (uint) args[1]->val_int();
if (key_number > 9)
goto error;
VOID(pthread_mutex_lock(&LOCK_des_key_file));
pthread_mutex_lock(&LOCK_des_key_file);
keyschedule= des_keyschedule[key_number];
VOID(pthread_mutex_unlock(&LOCK_des_key_file));
pthread_mutex_unlock(&LOCK_des_key_file);
}
else
{
@ -566,9 +566,9 @@ String *Item_func_des_decrypt::val_str(String *str)
key_number > 9)
goto error;
VOID(pthread_mutex_lock(&LOCK_des_key_file));
pthread_mutex_lock(&LOCK_des_key_file);
keyschedule= des_keyschedule[key_number];
VOID(pthread_mutex_unlock(&LOCK_des_key_file));
pthread_mutex_unlock(&LOCK_des_key_file);
}
else
{

173
sql/lock.cc
View File

@ -90,7 +90,6 @@ extern HASH open_cache;
static MYSQL_LOCK *get_lock_data(THD *thd, TABLE **table,uint count,
uint flags, TABLE **write_locked);
static void reset_lock_data(MYSQL_LOCK *sql_lock);
static int lock_external(THD *thd, TABLE **table,uint count);
static int unlock_external(THD *thd, TABLE **table,uint count);
static void print_lock_error(int error, const char *);
@ -194,6 +193,60 @@ int mysql_lock_tables_check(THD *thd, TABLE **tables, uint count, uint flags)
DBUG_RETURN(0);
}
/**
Reset lock type in lock data and free.
@param mysql_lock Lock structures to reset.
@note After a locking error we want to quit the locking of the table(s).
The test case in the bug report for Bug #18544 has the following
cases: 1. Locking error in lock_external() due to InnoDB timeout.
2. Locking error in get_lock_data() due to missing write permission.
3. Locking error in wait_if_global_read_lock() due to lock conflict.
@note In all these cases we have already set the lock type into the lock
data of the open table(s). If the table(s) are in the open table
cache, they could be reused with the non-zero lock type set. This
could lead to ignoring a different lock type with the next lock.
@note Clear the lock type of all lock data. This ensures that the next
lock request will set its lock type properly.
*/
static void reset_lock_data(MYSQL_LOCK *sql_lock)
{
THR_LOCK_DATA **ldata, **ldata_end;
DBUG_ENTER("reset_lock_data");
/* Clear the lock type of all lock data to avoid reusage. */
for (ldata= sql_lock->locks, ldata_end= ldata + sql_lock->lock_count;
ldata < ldata_end;
ldata++)
{
/* Reset lock type. */
(*ldata)->type= TL_UNLOCK;
}
DBUG_VOID_RETURN;
}
/**
Reset lock type in lock data and free.
@param mysql_lock Lock structures to reset.
*/
static void reset_lock_data_and_free(MYSQL_LOCK **mysql_lock)
{
reset_lock_data(*mysql_lock);
my_free(*mysql_lock, MYF(0));
*mysql_lock= 0;
}
MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **tables, uint count,
uint flags, bool *need_reopen)
{
@ -224,16 +277,13 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **tables, uint count,
if (wait_if_global_read_lock(thd, 1, 1))
{
/* Clear the lock type of all lock data to avoid reusage. */
reset_lock_data(sql_lock);
my_free((uchar*) sql_lock,MYF(0));
sql_lock=0;
reset_lock_data_and_free(&sql_lock);
break;
}
if (thd->version != refresh_version)
{
/* Clear the lock type of all lock data to avoid reusage. */
reset_lock_data(sql_lock);
my_free((uchar*) sql_lock,MYF(0));
reset_lock_data_and_free(&sql_lock);
goto retry;
}
}
@ -248,9 +298,7 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **tables, uint count,
Someone has issued SET GLOBAL READ_ONLY=1 and we want a write lock.
We do not wait for READ_ONLY=0, and fail.
*/
reset_lock_data(sql_lock);
my_free((uchar*) sql_lock, MYF(0));
sql_lock=0;
reset_lock_data_and_free(&sql_lock);
my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
break;
}
@ -261,14 +309,11 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **tables, uint count,
sql_lock->table_count))
{
/* Clear the lock type of all lock data to avoid reusage. */
reset_lock_data(sql_lock);
my_free((uchar*) sql_lock,MYF(0));
sql_lock=0;
reset_lock_data_and_free(&sql_lock);
break;
}
thd_proc_info(thd, "Table lock");
DBUG_PRINT("info", ("thd->proc_info %s", thd->proc_info));
thd->locked=1;
thd_proc_info(thd, "Locked");
/* Copy the lock data array. thr_multi_lock() reorders its contens. */
memcpy(sql_lock->locks + sql_lock->lock_count, sql_lock->locks,
sql_lock->lock_count * sizeof(*sql_lock->locks));
@ -280,23 +325,16 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **tables, uint count,
if (rc > 1) /* a timeout or a deadlock */
{
if (sql_lock->table_count)
VOID(unlock_external(thd, sql_lock->table, sql_lock->table_count));
(void) unlock_external(thd, sql_lock->table, sql_lock->table_count);
reset_lock_data_and_free(&sql_lock);
my_error(rc, MYF(0));
my_free((uchar*) sql_lock,MYF(0));
sql_lock= 0;
break;
}
else if (rc == 1) /* aborted */
{
/*
reset_lock_data is required here. If thr_multi_lock fails it
resets lock type for tables, which were locked before (and
including) one that caused error. Lock type for other tables
preserved.
*/
reset_lock_data(sql_lock);
thd->some_tables_deleted=1; // Try again
sql_lock->lock_count= 0; // Locks are already freed
// Fall through: unlock, reset lock data, free and retry
}
else if (!thd->some_tables_deleted || (flags & MYSQL_LOCK_IGNORE_FLUSH))
{
@ -304,23 +342,30 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **tables, uint count,
Thread was killed or lock aborted. Let upper level close all
used tables and retry or give error.
*/
thd->locked=0;
break;
}
else if (!thd->open_tables)
{
// Only using temporary tables, no need to unlock
thd->some_tables_deleted=0;
thd->locked=0;
break;
}
thd_proc_info(thd, 0);
/* some table was altered or deleted. reopen tables marked deleted */
mysql_unlock_tables(thd,sql_lock);
thd->locked=0;
/* going to retry, unlock all tables */
if (sql_lock->lock_count)
thr_multi_unlock(sql_lock->locks, sql_lock->lock_count);
if (sql_lock->table_count)
(void) unlock_external(thd, sql_lock->table, sql_lock->table_count);
/*
If thr_multi_lock fails it resets lock type for tables, which
were locked before (and including) one that caused error. Lock
type for other tables preserved.
*/
reset_lock_data_and_free(&sql_lock);
retry:
sql_lock=0;
if (flags & MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN)
{
*need_reopen= TRUE;
@ -388,7 +433,7 @@ void mysql_unlock_tables(THD *thd, MYSQL_LOCK *sql_lock)
if (sql_lock->lock_count)
thr_multi_unlock(sql_lock->locks,sql_lock->lock_count);
if (sql_lock->table_count)
VOID(unlock_external(thd,sql_lock->table,sql_lock->table_count));
(void) unlock_external(thd,sql_lock->table,sql_lock->table_count);
my_free((uchar*) sql_lock,MYF(0));
DBUG_VOID_RETURN;
}
@ -452,7 +497,7 @@ void mysql_unlock_read_tables(THD *thd, MYSQL_LOCK *sql_lock)
/* Unlock all read locked tables */
if (i != found)
{
VOID(unlock_external(thd,table,i-found));
(void) unlock_external(thd,table,i-found);
sql_lock->table_count=found;
}
/* Fix the lock positions in TABLE */
@ -863,8 +908,7 @@ static MYSQL_LOCK *get_lock_data(THD *thd, TABLE **table_ptr, uint count,
my_error(ER_OPEN_AS_READONLY,MYF(0),table->alias);
/* Clear the lock type of the lock data that are stored already. */
sql_lock->lock_count= (uint) (locks - sql_lock->locks);
reset_lock_data(sql_lock);
my_free((uchar*) sql_lock,MYF(0));
reset_lock_data_and_free(&sql_lock);
DBUG_RETURN(0);
}
}
@ -905,42 +949,6 @@ static MYSQL_LOCK *get_lock_data(THD *thd, TABLE **table_ptr, uint count,
}
/**
Reset lock type in lock data.
After a locking error we want to quit the locking of the table(s).
The test case in the bug report for Bug #18544 has the following
cases:
-# Locking error in lock_external() due to InnoDB timeout.
-# Locking error in get_lock_data() due to missing write permission.
-# Locking error in wait_if_global_read_lock() due to lock conflict.
In all these cases we have already set the lock type into the lock
data of the open table(s). If the table(s) are in the open table
cache, they could be reused with the non-zero lock type set. This
could lead to ignoring a different lock type with the next lock.
Clear the lock type of all lock data. This ensures that the next
lock request will set its lock type properly.
@param sql_lock The MySQL lock.
*/
static void reset_lock_data(MYSQL_LOCK *sql_lock)
{
THR_LOCK_DATA **ldata;
THR_LOCK_DATA **ldata_end;
for (ldata= sql_lock->locks, ldata_end= ldata + sql_lock->lock_count;
ldata < ldata_end;
ldata++)
{
/* Reset lock type. */
(*ldata)->type= TL_UNLOCK;
}
}
/*****************************************************************************
Lock table based on the name.
This is used when we need total access to a closed, not open table
@ -970,7 +978,7 @@ int lock_and_wait_for_table_name(THD *thd, TABLE_LIST *table_list)
if (wait_if_global_read_lock(thd, 0, 1))
DBUG_RETURN(1);
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
if ((lock_retcode = lock_table_name(thd, table_list, TRUE)) < 0)
goto end;
if (lock_retcode && wait_for_locked_table_names(thd, table_list))
@ -1020,6 +1028,7 @@ int lock_table_name(THD *thd, TABLE_LIST *table_list, bool check_in_use)
char key[MAX_DBKEY_LENGTH];
char *db= table_list->db;
uint key_length;
bool found_locked_table= FALSE;
HASH_SEARCH_STATE state;
DBUG_ENTER("lock_table_name");
DBUG_PRINT("enter",("db: %s name: %s", db, table_list->table_name));
@ -1035,6 +1044,13 @@ int lock_table_name(THD *thd, TABLE_LIST *table_list, bool check_in_use)
table = (TABLE*) my_hash_next(&open_cache,(uchar*) key,
key_length, &state))
{
if (table->reginfo.lock_type < TL_WRITE)
{
if (table->in_use == thd)
found_locked_table= TRUE;
continue;
}
if (table->in_use == thd)
{
DBUG_PRINT("info", ("Table is in use"));
@ -1045,6 +1061,17 @@ int lock_table_name(THD *thd, TABLE_LIST *table_list, bool check_in_use)
}
}
if (thd->locked_tables && thd->locked_tables->table_count &&
! find_temporary_table(thd, table_list->db, table_list->table_name))
{
if (found_locked_table)
my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), table_list->alias);
else
my_error(ER_TABLE_NOT_LOCKED, MYF(0), table_list->alias);
DBUG_RETURN(-1);
}
if (!(table= table_cache_insert_placeholder(thd, key, key_length)))
DBUG_RETURN(-1);
@ -1595,8 +1622,8 @@ bool make_global_read_lock_block_commit(THD *thd)
void broadcast_refresh(void)
{
VOID(pthread_cond_broadcast(&COND_refresh));
VOID(pthread_cond_broadcast(&COND_global_read_lock));
pthread_cond_broadcast(&COND_refresh);
pthread_cond_broadcast(&COND_global_read_lock);
}
/**

23
sql/log.cc
View File

@ -2909,7 +2909,7 @@ bool MYSQL_BIN_LOG::reset_logs(THD* thd)
thread. If the transaction involved MyISAM tables, it should go
into binlog even on rollback.
*/
VOID(pthread_mutex_lock(&LOCK_thread_count));
pthread_mutex_lock(&LOCK_thread_count);
/* Save variables so that we can reopen the log */
save_name=name;
@ -2989,7 +2989,7 @@ bool MYSQL_BIN_LOG::reset_logs(THD* thd)
my_free((uchar*) save_name, MYF(0));
err:
VOID(pthread_mutex_unlock(&LOCK_thread_count));
pthread_mutex_unlock(&LOCK_thread_count);
pthread_mutex_unlock(&LOCK_index);
pthread_mutex_unlock(&LOCK_log);
DBUG_RETURN(error);
@ -4084,12 +4084,11 @@ bool MYSQL_BIN_LOG::write(Log_event *event_info)
if ((thd && !(thd->options & OPTION_BIN_LOG)) ||
(!binlog_filter->db_ok(local_db)))
{
VOID(pthread_mutex_unlock(&LOCK_log));
pthread_mutex_unlock(&LOCK_log);
DBUG_RETURN(0);
}
#endif /* HAVE_REPLICATION */
#if defined(USING_TRANSACTIONS)
/*
Should we write to the binlog cache or to the binlog on disk?
Write to the binlog cache if:
@ -4124,7 +4123,7 @@ bool MYSQL_BIN_LOG::write(Log_event *event_info)
LOCK_log.
*/
}
#endif /* USING_TRANSACTIONS */
DBUG_PRINT("info",("event type: %d",event_info->get_type_code()));
/*
@ -4547,7 +4546,7 @@ bool MYSQL_BIN_LOG::write(THD *thd, IO_CACHE *cache, Log_event *commit_event,
bool incident)
{
DBUG_ENTER("MYSQL_BIN_LOG::write(THD *, IO_CACHE *, Log_event *)");
VOID(pthread_mutex_lock(&LOCK_log));
pthread_mutex_lock(&LOCK_log);
/* NULL would represent nothing to replicate after ROLLBACK */
DBUG_ASSERT(commit_event != NULL);
@ -4636,7 +4635,7 @@ bool MYSQL_BIN_LOG::write(THD *thd, IO_CACHE *cache, Log_event *commit_event,
else
rotate_and_purge(RP_LOCK_LOG_IS_ALREADY_LOCKED);
}
VOID(pthread_mutex_unlock(&LOCK_log));
pthread_mutex_unlock(&LOCK_log);
DBUG_RETURN(0);
@ -4646,7 +4645,7 @@ err:
write_error= 1;
sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
}
VOID(pthread_mutex_unlock(&LOCK_log));
pthread_mutex_unlock(&LOCK_log);
DBUG_RETURN(1);
}
@ -4866,7 +4865,7 @@ bool flush_error_log()
char err_renamed[FN_REFLEN], *end;
end= strmake(err_renamed,log_error_file,FN_REFLEN-4);
strmov(end, "-old");
VOID(pthread_mutex_lock(&LOCK_error_log));
pthread_mutex_lock(&LOCK_error_log);
#ifdef __WIN__
char err_temp[FN_REFLEN+4];
/*
@ -4913,7 +4912,7 @@ bool flush_error_log()
else
result= 1;
#endif
VOID(pthread_mutex_unlock(&LOCK_error_log));
pthread_mutex_unlock(&LOCK_error_log);
}
return result;
}
@ -4988,7 +4987,7 @@ static void print_buffer_to_file(enum loglevel level, const char *buffer)
DBUG_ENTER("print_buffer_to_file");
DBUG_PRINT("enter",("buffer: %s", buffer));
VOID(pthread_mutex_lock(&LOCK_error_log));
pthread_mutex_lock(&LOCK_error_log);
skr= my_time(0);
localtime_r(&skr, &tm_tmp);
@ -5007,7 +5006,7 @@ static void print_buffer_to_file(enum loglevel level, const char *buffer)
fflush(stderr);
VOID(pthread_mutex_unlock(&LOCK_error_log));
pthread_mutex_unlock(&LOCK_error_log);
DBUG_VOID_RETURN;
}

11
sql/log_event.cc
View File

@ -3056,9 +3056,9 @@ int Query_log_event::do_apply_event(Relay_log_info const *rli,
{
thd->set_time((time_t)when);
thd->set_query((char*)query_arg, q_len_arg);
VOID(pthread_mutex_lock(&LOCK_thread_count));
pthread_mutex_lock(&LOCK_thread_count);
thd->query_id = next_query_id();
VOID(pthread_mutex_unlock(&LOCK_thread_count));
pthread_mutex_unlock(&LOCK_thread_count);
thd->variables.pseudo_thread_id= thread_id; // for temp tables
DBUG_PRINT("query",("%s", thd->query()));
@ -3895,7 +3895,6 @@ int Format_description_log_event::do_apply_event(Relay_log_info const *rli)
int ret= 0;
DBUG_ENTER("Format_description_log_event::do_apply_event");
#ifdef USING_TRANSACTIONS
/*
As a transaction NEVER spans on 2 or more binlogs:
if we have an active transaction at this point, the master died
@ -3917,7 +3916,7 @@ int Format_description_log_event::do_apply_event(Relay_log_info const *rli)
"its binary log, thus rolled back too.");
const_cast<Relay_log_info*>(rli)->cleanup_context(thd, 1);
}
#endif
/*
If this event comes from ourselves, there is no cleaning task to
perform, we don't call Start_log_event_v3::do_apply_event()
@ -4581,9 +4580,9 @@ int Load_log_event::do_apply_event(NET* net, Relay_log_info const *rli,
if (rpl_filter->db_ok(thd->db))
{
thd->set_time((time_t)when);
VOID(pthread_mutex_lock(&LOCK_thread_count));
pthread_mutex_lock(&LOCK_thread_count);
thd->query_id = next_query_id();
VOID(pthread_mutex_unlock(&LOCK_thread_count));
pthread_mutex_unlock(&LOCK_thread_count);
thd->warning_info->opt_clear_warning_info(thd->query_id);
TABLE_LIST tables;

12
sql/mysql_priv.h
View File

@ -428,17 +428,7 @@ protected:
#if defined(__WIN__)
#undef FLUSH_TIME
#define FLUSH_TIME 1800 /**< Flush every half hour */
#define INTERRUPT_PRIOR -2
#define CONNECT_PRIOR -1
#define WAIT_PRIOR 0
#define QUERY_PRIOR 2
#else
#define INTERRUPT_PRIOR 10
#define CONNECT_PRIOR 9
#define WAIT_PRIOR 8
#define QUERY_PRIOR 6
#endif /* __WIN92__ */
#endif /* __WIN__ */
/* Bits from testflag */
#define TEST_PRINT_CACHED_TABLES 1

43
sql/mysqld.cc
View File

@ -48,10 +48,6 @@
#endif
#endif
#ifndef DEFAULT_SKIP_THREAD_PRIORITY
#define DEFAULT_SKIP_THREAD_PRIORITY 0
#endif
#include <thr_alarm.h>
#include <ft_global.h>
#include <errmsg.h>
@ -1043,14 +1039,14 @@ static void close_server_sock()
{
ip_sock=INVALID_SOCKET;
DBUG_PRINT("info",("calling shutdown on TCP/IP socket"));
VOID(shutdown(tmp_sock, SHUT_RDWR));
(void) shutdown(tmp_sock, SHUT_RDWR);
#if defined(__NETWARE__)
/*
The following code is disabled for normal systems as it causes MySQL
to hang on AIX 4.3 during shutdown
*/
DBUG_PRINT("info",("calling closesocket on TCP/IP socket"));
VOID(closesocket(tmp_sock));
(void) closesocket(tmp_sock);
#endif
}
tmp_sock=unix_sock;
@ -1058,16 +1054,16 @@ static void close_server_sock()
{
unix_sock=INVALID_SOCKET;
DBUG_PRINT("info",("calling shutdown on unix socket"));
VOID(shutdown(tmp_sock, SHUT_RDWR));
(void) shutdown(tmp_sock, SHUT_RDWR);
#if defined(__NETWARE__)
/*
The following code is disabled for normal systems as it may cause MySQL
to hang on AIX 4.3 during shutdown
*/
DBUG_PRINT("info",("calling closesocket on unix/IP socket"));
VOID(closesocket(tmp_sock));
(void) closesocket(tmp_sock);
#endif
VOID(unlink(mysqld_unix_port));
(void) unlink(mysqld_unix_port);
}
DBUG_VOID_RETURN;
#endif
@ -2471,7 +2467,8 @@ and this may fail.\n\n");
fprintf(stderr, "read_buffer_size=%ld\n", (long) global_system_variables.read_buff_size);
fprintf(stderr, "max_used_connections=%lu\n", max_used_connections);
fprintf(stderr, "max_threads=%u\n", thread_scheduler.max_threads);
fprintf(stderr, "threads_connected=%u\n", thread_count);
fprintf(stderr, "thread_count=%u\n", thread_count);
fprintf(stderr, "connection_count=%u\n", connection_count);
fprintf(stderr, "It is possible that mysqld could use up to \n\
key_buffer_size + (read_buffer_size + sort_buffer_size)*max_threads = %lu K\n\
bytes of memory\n", ((ulong) dflt_key_cache->key_cache_mem_size +
@ -2680,8 +2677,6 @@ static void start_signal_handler(void)
#if !defined(HAVE_DEC_3_2_THREADS)
pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_SYSTEM);
(void) pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
if (!(opt_specialflag & SPECIAL_NO_PRIOR))
my_pthread_attr_setprio(&thr_attr,INTERRUPT_PRIOR);
#if defined(__ia64__) || defined(__ia64)
/*
Peculiar things with ia64 platforms - it seems we only have half the
@ -2801,8 +2796,6 @@ pthread_handler_t signal_hand(void *arg __attribute__((unused)))
abort_loop=1; // mark abort for threads
#ifdef USE_ONE_SIGNAL_HAND
pthread_t tmp;
if (!(opt_specialflag & SPECIAL_NO_PRIOR))
my_pthread_attr_setprio(&connection_attrib,INTERRUPT_PRIOR);
if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
(void*) &sig))
sql_print_error("Can't create thread to kill server");
@ -3628,8 +3621,6 @@ static int init_thread_environment()
(void) pthread_attr_setdetachstate(&connection_attrib,
PTHREAD_CREATE_DETACHED);
pthread_attr_setscope(&connection_attrib, PTHREAD_SCOPE_SYSTEM);
if (!(opt_specialflag & SPECIAL_NO_PRIOR))
my_pthread_attr_setprio(&connection_attrib,WAIT_PRIOR);
if (pthread_key_create(&THR_THD,NULL) ||
pthread_key_create(&THR_MALLOC,NULL))
@ -4337,8 +4328,6 @@ int main(int argc, char **argv)
unireg_abort(1); // Will do exit
init_signals();
if (!(opt_specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(),CONNECT_PRIOR);
#if defined(__ia64__) || defined(__ia64)
/*
Peculiar things with ia64 platforms - it seems we only have half the
@ -5028,8 +5017,6 @@ void handle_connections_sockets()
LINT_INIT(new_sock);
(void) my_pthread_getprio(pthread_self()); // For debugging
FD_ZERO(&clientFDs);
if (ip_sock != INVALID_SOCKET)
{
@ -5188,7 +5175,7 @@ void handle_connections_sockets()
if (!(thd= new THD))
{
(void) shutdown(new_sock, SHUT_RDWR);
VOID(closesocket(new_sock));
(void) closesocket(new_sock);
continue;
}
if (!(vio_tmp=vio_new(new_sock,
@ -6452,8 +6439,9 @@ Can't be set to 1 if --log-slave-updates is used.",
{"skip-symlink", OPT_SKIP_SYMLINKS, "Don't allow symlinking of tables. Deprecated option. Use --skip-symbolic-links instead.",
0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
{"skip-thread-priority", OPT_SKIP_PRIOR,
"Don't give threads different priorities. Deprecated option.", 0, 0, 0, GET_NO_ARG, NO_ARG,
DEFAULT_SKIP_THREAD_PRIORITY, 0, 0, 0, 0, 0},
"Don't give threads different priorities. This option is deprecated "
"because it has no effect; the implied behavior is already the default.",
0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
#ifdef HAVE_REPLICATION
{"slave-load-tmpdir", OPT_SLAVE_LOAD_TMPDIR,
"The location where the slave should put its temporary files when \
@ -7624,7 +7612,7 @@ SHOW_VAR status_vars[]= {
{"Tc_log_page_waits", (char*) &tc_log_page_waits, SHOW_LONG},
#endif
{"Threads_cached", (char*) &cached_thread_count, SHOW_LONG_NOFLUSH},
{"Threads_connected", (char*) &thread_count, SHOW_INT},
{"Threads_connected", (char*) &connection_count, SHOW_INT},
{"Threads_created", (char*) &thread_created, SHOW_LONG_NOFLUSH},
{"Threads_running", (char*) &thread_running, SHOW_INT},
{"Uptime", (char*) &show_starttime, SHOW_FUNC},
@ -7921,9 +7909,6 @@ static int mysql_init_variables(void)
#ifdef HAVE_SMEM
shared_memory_base_name= default_shared_memory_base_name;
#endif
#if !defined(my_pthread_setprio) && !defined(HAVE_PTHREAD_SETSCHEDPARAM)
opt_specialflag |= SPECIAL_NO_PRIOR;
#endif
#if defined(__WIN__) || defined(__NETWARE__)
/* Allow Win32 and NetWare users to move MySQL anywhere */
@ -8207,8 +8192,8 @@ mysqld_get_one_option(int optid,
case (int) OPT_SKIP_PRIOR:
opt_specialflag|= SPECIAL_NO_PRIOR;
sql_print_warning("The --skip-thread-priority startup option is deprecated "
"and will be removed in MySQL 7.0. MySQL 6.0 and up do not "
"give threads different priorities.");
"and will be removed in MySQL 7.0. This option has no effect "
"as the implied behavior is already the default.");
break;
case (int) OPT_SKIP_LOCK:
opt_external_locking=0;

2
sql/opt_range.h
View File

@ -730,7 +730,7 @@ class SQL_SELECT :public Sql_alloc {
class FT_SELECT: public QUICK_RANGE_SELECT {
public:
FT_SELECT(THD *thd, TABLE *table, uint key) :
QUICK_RANGE_SELECT (thd, table, key, 1) { VOID(init()); }
QUICK_RANGE_SELECT (thd, table, key, 1) { (void) init(); }
~FT_SELECT() { file->ft_end(); }
int init() { return error=file->ft_init(); }
int reset() { return 0; }

3
sql/protocol.cc
View File

@ -247,6 +247,7 @@ net_send_ok(THD *thd,
if (!error)
error= net_flush(net);
thd->stmt_da->can_overwrite_status= FALSE;
DBUG_PRINT("info", ("OK sent, so no more error sending allowed"));
@ -406,6 +407,7 @@ bool net_send_error_packet(THD *thd, uint sql_errno, const char *err,
buff[2]= '#';
pos= (uchar*) strmov((char*) buff+3, sqlstate);
}
converted_err_len= convert_error_message((char*)converted_err,
sizeof(converted_err),
thd->variables.character_set_results,
@ -414,6 +416,7 @@ bool net_send_error_packet(THD *thd, uint sql_errno, const char *err,
length= (uint) (strmake((char*) pos, (char*)converted_err, MYSQL_ERRMSG_SIZE) -
(char*) buff);
err= (char*) buff;
DBUG_RETURN(net_write_command(net,(uchar) 255, (uchar*) "", 0, (uchar*) err,
length));
}

6
sql/records.cc
View File

@ -178,7 +178,7 @@ void init_read_record(READ_RECORD *info,THD *thd, TABLE *table,
if (table->s->tmp_table == NON_TRANSACTIONAL_TMP_TABLE &&
!table->sort.addon_field)
VOID(table->file->extra(HA_EXTRA_MMAP));
(void) table->file->extra(HA_EXTRA_MMAP);
if (table->sort.addon_field)
{
@ -266,8 +266,8 @@ void init_read_record(READ_RECORD *info,THD *thd, TABLE *table,
!(table->s->db_options_in_use & HA_OPTION_PACK_RECORD) ||
(use_record_cache < 0 &&
!(table->file->ha_table_flags() & HA_NOT_DELETE_WITH_CACHE))))
VOID(table->file->extra_opt(HA_EXTRA_CACHE,
thd->variables.read_buff_size));
(void) table->file->extra_opt(HA_EXTRA_CACHE,
thd->variables.read_buff_size);
}
/* Condition pushdown to storage engine */
if (thd->variables.engine_condition_pushdown &&

2
sql/set_var.cc
View File

@ -1395,12 +1395,10 @@ static void fix_thd_mem_root(THD *thd, enum_var_type type)
static void fix_trans_mem_root(THD *thd, enum_var_type type)
{
#ifdef USING_TRANSACTIONS
if (type != OPT_GLOBAL)
reset_root_defaults(&thd->transaction.mem_root,
thd->variables.trans_alloc_block_size,
thd->variables.trans_prealloc_size);
#endif
}

9
sql/slave.cc
View File

@ -612,8 +612,7 @@ int start_slave_thread(pthread_handler h_func, pthread_mutex_t *start_lock,
pthread_cond_t *start_cond,
volatile uint *slave_running,
volatile ulong *slave_run_id,
Master_info* mi,
bool high_priority)
Master_info* mi)
{
pthread_t th;
ulong start_id;
@ -643,8 +642,6 @@ int start_slave_thread(pthread_handler h_func, pthread_mutex_t *start_lock,
}
start_id= *slave_run_id;
DBUG_PRINT("info",("Creating new slave thread"));
if (high_priority)
my_pthread_attr_setprio(&connection_attrib,CONNECT_PRIOR);
if (pthread_create(&th, &connection_attrib, h_func, (void*)mi))
{
if (start_lock)
@ -707,13 +704,13 @@ int start_slave_threads(bool need_slave_mutex, bool wait_for_start,
error=start_slave_thread(handle_slave_io,lock_io,lock_cond_io,
cond_io,
&mi->slave_running, &mi->slave_run_id,
mi, 1); //high priority, to read the most possible
mi);
if (!error && (thread_mask & SLAVE_SQL))
{
error=start_slave_thread(handle_slave_sql,lock_sql,lock_cond_sql,
cond_sql,
&mi->rli.slave_running, &mi->rli.slave_run_id,
mi, 0);
mi);
if (error)
terminate_slave_threads(mi, thread_mask & SLAVE_IO, !need_slave_mutex);
}

3
sql/slave.h
View File

@ -164,8 +164,7 @@ int start_slave_thread(pthread_handler h_func, pthread_mutex_t* start_lock,
pthread_cond_t* start_cond,
volatile uint *slave_running,
volatile ulong *slave_run_id,
Master_info* mi,
bool high_priority);
Master_info* mi);
/* If fd is -1, dump to NET */
int mysql_table_dump(THD* thd, const char* db,

8
sql/sp_head.cc
View File

@ -1769,9 +1769,9 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
as one select and not resetting THD::user_var_events before
each invocation.
*/
VOID(pthread_mutex_lock(&LOCK_thread_count));
pthread_mutex_lock(&LOCK_thread_count);
q= global_query_id;
VOID(pthread_mutex_unlock(&LOCK_thread_count));
pthread_mutex_unlock(&LOCK_thread_count);
mysql_bin_log.start_union_events(thd, q + 1);
binlog_save_options= thd->options;
thd->options&= ~OPTION_BIN_LOG;
@ -2736,9 +2736,9 @@ sp_lex_keeper::reset_lex_and_exec_core(THD *thd, uint *nextp,
*/
thd->lex= m_lex;
VOID(pthread_mutex_lock(&LOCK_thread_count));
pthread_mutex_lock(&LOCK_thread_count);
thd->query_id= next_query_id();
VOID(pthread_mutex_unlock(&LOCK_thread_count));
pthread_mutex_unlock(&LOCK_thread_count);
if (thd->prelocked_mode == NON_PRELOCKED)
{

40
sql/sp_pcontext.cc
View File

@ -63,21 +63,21 @@ sp_pcontext::sp_pcontext()
m_context_handlers(0), m_parent(NULL), m_pboundary(0),
m_label_scope(LABEL_DEFAULT_SCOPE)
{
VOID(my_init_dynamic_array(&m_vars, sizeof(sp_variable_t *),
(void) my_init_dynamic_array(&m_vars, sizeof(sp_variable_t *),
PCONTEXT_ARRAY_INIT_ALLOC,
PCONTEXT_ARRAY_INCREMENT_ALLOC));
VOID(my_init_dynamic_array(&m_case_expr_id_lst, sizeof(int),
PCONTEXT_ARRAY_INCREMENT_ALLOC);
(void) my_init_dynamic_array(&m_case_expr_id_lst, sizeof(int),
PCONTEXT_ARRAY_INIT_ALLOC,
PCONTEXT_ARRAY_INCREMENT_ALLOC));
VOID(my_init_dynamic_array(&m_conds, sizeof(sp_cond_type_t *),
PCONTEXT_ARRAY_INCREMENT_ALLOC);
(void) my_init_dynamic_array(&m_conds, sizeof(sp_cond_type_t *),
PCONTEXT_ARRAY_INIT_ALLOC,
PCONTEXT_ARRAY_INCREMENT_ALLOC));
VOID(my_init_dynamic_array(&m_cursors, sizeof(LEX_STRING),
PCONTEXT_ARRAY_INCREMENT_ALLOC);
(void) my_init_dynamic_array(&m_cursors, sizeof(LEX_STRING),
PCONTEXT_ARRAY_INIT_ALLOC,
PCONTEXT_ARRAY_INCREMENT_ALLOC));
VOID(my_init_dynamic_array(&m_handlers, sizeof(sp_cond_type_t *),
PCONTEXT_ARRAY_INCREMENT_ALLOC);
(void) my_init_dynamic_array(&m_handlers, sizeof(sp_cond_type_t *),
PCONTEXT_ARRAY_INIT_ALLOC,
PCONTEXT_ARRAY_INCREMENT_ALLOC));
PCONTEXT_ARRAY_INCREMENT_ALLOC);
m_label.empty();
m_children.empty();
@ -91,21 +91,21 @@ sp_pcontext::sp_pcontext(sp_pcontext *prev, label_scope_type label_scope)
m_context_handlers(0), m_parent(prev), m_pboundary(0),
m_label_scope(label_scope)
{
VOID(my_init_dynamic_array(&m_vars, sizeof(sp_variable_t *),
(void) my_init_dynamic_array(&m_vars, sizeof(sp_variable_t *),
PCONTEXT_ARRAY_INIT_ALLOC,
PCONTEXT_ARRAY_INCREMENT_ALLOC));
VOID(my_init_dynamic_array(&m_case_expr_id_lst, sizeof(int),
PCONTEXT_ARRAY_INCREMENT_ALLOC);
(void) my_init_dynamic_array(&m_case_expr_id_lst, sizeof(int),
PCONTEXT_ARRAY_INIT_ALLOC,
PCONTEXT_ARRAY_INCREMENT_ALLOC));
VOID(my_init_dynamic_array(&m_conds, sizeof(sp_cond_type_t *),
PCONTEXT_ARRAY_INCREMENT_ALLOC);
(void) my_init_dynamic_array(&m_conds, sizeof(sp_cond_type_t *),
PCONTEXT_ARRAY_INIT_ALLOC,
PCONTEXT_ARRAY_INCREMENT_ALLOC));
VOID(my_init_dynamic_array(&m_cursors, sizeof(LEX_STRING),
PCONTEXT_ARRAY_INCREMENT_ALLOC);
(void) my_init_dynamic_array(&m_cursors, sizeof(LEX_STRING),
PCONTEXT_ARRAY_INIT_ALLOC,
PCONTEXT_ARRAY_INCREMENT_ALLOC));
VOID(my_init_dynamic_array(&m_handlers, sizeof(sp_cond_type_t *),
PCONTEXT_ARRAY_INCREMENT_ALLOC);
(void) my_init_dynamic_array(&m_handlers, sizeof(sp_cond_type_t *),
PCONTEXT_ARRAY_INIT_ALLOC,
PCONTEXT_ARRAY_INCREMENT_ALLOC));
PCONTEXT_ARRAY_INCREMENT_ALLOC);
m_label.empty();
m_children.empty();

101
sql/sql_acl.cc
View File

@ -326,7 +326,7 @@ static my_bool acl_load(THD *thd, TABLE_LIST *tables)
init_read_record(&read_record_info,thd,table= tables[0].table,NULL,1,0,
FALSE);
table->use_all_columns();
VOID(my_init_dynamic_array(&acl_hosts,sizeof(ACL_HOST),20,50));
(void) my_init_dynamic_array(&acl_hosts,sizeof(ACL_HOST),20,50);
while (!(read_record_info.read_record(&read_record_info)))
{
ACL_HOST host;
@ -366,7 +366,7 @@ static my_bool acl_load(THD *thd, TABLE_LIST *tables)
host.access|=REFERENCES_ACL | INDEX_ACL | ALTER_ACL | CREATE_TMP_ACL;
}
#endif
VOID(push_dynamic(&acl_hosts,(uchar*) &host));
(void) push_dynamic(&acl_hosts,(uchar*) &host);
}
my_qsort((uchar*) dynamic_element(&acl_hosts,0,ACL_HOST*),acl_hosts.elements,
sizeof(ACL_HOST),(qsort_cmp) acl_compare);
@ -375,7 +375,7 @@ static my_bool acl_load(THD *thd, TABLE_LIST *tables)
init_read_record(&read_record_info,thd,table=tables[1].table,NULL,1,0,FALSE);
table->use_all_columns();
VOID(my_init_dynamic_array(&acl_users,sizeof(ACL_USER),50,100));
(void) my_init_dynamic_array(&acl_users,sizeof(ACL_USER),50,100);
password_length= table->field[2]->field_length /
table->field[2]->charset()->mbmaxlen;
if (password_length < SCRAMBLED_PASSWORD_CHAR_LENGTH_323)
@ -550,7 +550,7 @@ static my_bool acl_load(THD *thd, TABLE_LIST *tables)
user.access|= SUPER_ACL | EXECUTE_ACL;
#endif
}
VOID(push_dynamic(&acl_users,(uchar*) &user));
(void) push_dynamic(&acl_users,(uchar*) &user);
if (!user.host.hostname ||
(user.host.hostname[0] == wild_many && !user.host.hostname[1]))
allow_all_hosts=1; // Anyone can connect
@ -563,7 +563,7 @@ static my_bool acl_load(THD *thd, TABLE_LIST *tables)
init_read_record(&read_record_info,thd,table=tables[2].table,NULL,1,0,FALSE);
table->use_all_columns();
VOID(my_init_dynamic_array(&acl_dbs,sizeof(ACL_DB),50,100));
(void) my_init_dynamic_array(&acl_dbs,sizeof(ACL_DB),50,100);
while (!(read_record_info.read_record(&read_record_info)))
{
ACL_DB db;
@ -613,7 +613,7 @@ static my_bool acl_load(THD *thd, TABLE_LIST *tables)
db.access|=REFERENCES_ACL | INDEX_ACL | ALTER_ACL;
}
#endif
VOID(push_dynamic(&acl_dbs,(uchar*) &db));
(void) push_dynamic(&acl_dbs,(uchar*) &db);
}
my_qsort((uchar*) dynamic_element(&acl_dbs,0,ACL_DB*),acl_dbs.elements,
sizeof(ACL_DB),(qsort_cmp) acl_compare);
@ -706,7 +706,7 @@ my_bool acl_reload(THD *thd)
}
if ((old_initialized=initialized))
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
old_acl_hosts=acl_hosts;
old_acl_users=acl_users;
@ -733,7 +733,7 @@ my_bool acl_reload(THD *thd)
delete_dynamic(&old_acl_dbs);
}
if (old_initialized)
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
end:
close_thread_tables(thd);
DBUG_RETURN(return_val);
@ -885,7 +885,7 @@ int acl_getroot(THD *thd, USER_RESOURCES *mqh,
DBUG_RETURN(0);
}
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
/*
Find acl entry in user database. Note, that find_acl_user is not the same,
@ -1064,7 +1064,7 @@ int acl_getroot(THD *thd, USER_RESOURCES *mqh,
else
*sctx->priv_host= 0;
}
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
DBUG_RETURN(res);
}
@ -1111,7 +1111,7 @@ bool acl_getroot_no_password(Security_context *sctx, char *user, char *host,
DBUG_RETURN(FALSE);
}
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
sctx->master_access= 0;
sctx->db_access= 0;
@ -1165,7 +1165,7 @@ bool acl_getroot_no_password(Security_context *sctx, char *user, char *host,
else
*sctx->priv_host= 0;
}
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
DBUG_RETURN(res);
}
@ -1254,7 +1254,7 @@ static void acl_insert_user(const char *user, const char *host,
set_user_salt(&acl_user, password, password_len);
VOID(push_dynamic(&acl_users,(uchar*) &acl_user));
(void) push_dynamic(&acl_users,(uchar*) &acl_user);
if (!acl_user.host.hostname ||
(acl_user.host.hostname[0] == wild_many && !acl_user.host.hostname[1]))
allow_all_hosts=1; // Anyone can connect /* purecov: tested */
@ -1320,7 +1320,7 @@ static void acl_insert_db(const char *user, const char *host, const char *db,
acl_db.db=strdup_root(&mem,db);
acl_db.access=privileges;
acl_db.sort=get_sort(3,acl_db.host.hostname,acl_db.db,acl_db.user);
VOID(push_dynamic(&acl_dbs,(uchar*) &acl_db));
(void) push_dynamic(&acl_dbs,(uchar*) &acl_db);
my_qsort((uchar*) dynamic_element(&acl_dbs,0,ACL_DB*),acl_dbs.elements,
sizeof(ACL_DB),(qsort_cmp) acl_compare);
}
@ -1344,7 +1344,7 @@ ulong acl_get(const char *host, const char *ip,
acl_entry *entry;
DBUG_ENTER("acl_get");
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
end=strmov((tmp_db=strmov(strmov(key, ip ? ip : "")+1,user)+1),db);
if (lower_case_table_names)
{
@ -1356,7 +1356,7 @@ ulong acl_get(const char *host, const char *ip,
key_length)))
{
db_access=entry->access;
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
DBUG_PRINT("exit", ("access: 0x%lx", db_access));
DBUG_RETURN(db_access);
}
@ -1410,7 +1410,7 @@ exit:
memcpy((uchar*) entry->key,key,key_length);
acl_cache->add(entry);
}
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
DBUG_PRINT("exit", ("access: 0x%lx", db_access & host_access));
DBUG_RETURN(db_access & host_access);
}
@ -1426,10 +1426,11 @@ exit:
static void init_check_host(void)
{
DBUG_ENTER("init_check_host");
VOID(my_init_dynamic_array(&acl_wild_hosts,sizeof(struct acl_host_and_ip),
acl_users.elements,1));
VOID(my_hash_init(&acl_check_hosts,system_charset_info,acl_users.elements,0,0,
(my_hash_get_key) check_get_key,0,0));
(void) my_init_dynamic_array(&acl_wild_hosts,sizeof(struct acl_host_and_ip),
acl_users.elements,1);
(void) my_hash_init(&acl_check_hosts,system_charset_info,
acl_users.elements, 0, 0,
(my_hash_get_key) check_get_key, 0, 0);
if (!allow_all_hosts)
{
for (uint i=0 ; i < acl_users.elements ; i++)
@ -1491,12 +1492,12 @@ bool acl_check_host(const char *host, const char *ip)
{
if (allow_all_hosts)
return 0;
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
if ((host && my_hash_search(&acl_check_hosts,(uchar*) host,strlen(host))) ||
(ip && my_hash_search(&acl_check_hosts,(uchar*) ip, strlen(ip))))
{
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
return 0; // Found host
}
for (uint i=0 ; i < acl_wild_hosts.elements ; i++)
@ -1504,11 +1505,11 @@ bool acl_check_host(const char *host, const char *ip)
acl_host_and_ip *acl=dynamic_element(&acl_wild_hosts,i,acl_host_and_ip*);
if (compare_hostname(acl, host, ip))
{
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
return 0; // Host ok
}
}
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
return 1; // Host is not allowed
}
@ -1622,11 +1623,11 @@ bool change_password(THD *thd, const char *host, const char *user,
if (!(table= open_ltable(thd, &tables, TL_WRITE, 0)))
DBUG_RETURN(1);
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
ACL_USER *acl_user;
if (!(acl_user= find_acl_user(host, user, TRUE)))
{
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
my_message(ER_PASSWORD_NO_MATCH, ER(ER_PASSWORD_NO_MATCH), MYF(0));
goto end;
}
@ -1638,12 +1639,12 @@ bool change_password(THD *thd, const char *host, const char *user,
acl_user->user ? acl_user->user : "",
new_password, new_password_len))
{
VOID(pthread_mutex_unlock(&acl_cache->lock)); /* purecov: deadcode */
pthread_mutex_unlock(&acl_cache->lock); /* purecov: deadcode */
goto end;
}
acl_cache->clear(1); // Clear locked hostname cache
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
result= 0;
if (mysql_bin_log.is_open())
{
@ -1684,9 +1685,9 @@ bool is_acl_user(const char *host, const char *user)
if (!initialized)
return TRUE;
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
res= find_acl_user(host, user, TRUE) != NULL;
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
return res;
}
@ -3443,7 +3444,7 @@ bool mysql_grant(THD *thd, const char *db, List <LEX_USER> &list,
/* go through users in user_list */
rw_wrlock(&LOCK_grant);
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
grant_version++;
int result=0;
@ -3475,7 +3476,7 @@ bool mysql_grant(THD *thd, const char *db, List <LEX_USER> &list,
}
}
}
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
if (!result)
{
@ -4635,12 +4636,12 @@ bool mysql_show_grants(THD *thd,LEX_USER *lex_user)
}
rw_rdlock(&LOCK_grant);
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
acl_user= find_acl_user(lex_user->host.str, lex_user->user.str, TRUE);
if (!acl_user)
{
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
rw_unlock(&LOCK_grant);
my_error(ER_NONEXISTING_GRANT, MYF(0),
@ -4658,7 +4659,7 @@ bool mysql_show_grants(THD *thd,LEX_USER *lex_user)
if (protocol->send_result_set_metadata(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
{
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
rw_unlock(&LOCK_grant);
DBUG_RETURN(TRUE);
@ -4969,7 +4970,7 @@ bool mysql_show_grants(THD *thd,LEX_USER *lex_user)
}
end:
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
rw_unlock(&LOCK_grant);
my_eof(thd);
@ -5767,7 +5768,7 @@ bool mysql_create_user(THD *thd, List <LEX_USER> &list)
DBUG_RETURN(result != 1);
rw_wrlock(&LOCK_grant);
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
while ((tmp_user_name= user_list++))
{
@ -5797,7 +5798,7 @@ bool mysql_create_user(THD *thd, List <LEX_USER> &list)
}
}
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
if (result)
my_error(ER_CANNOT_USER, MYF(0), "CREATE USER", wrong_users.c_ptr_safe());
@ -5849,7 +5850,7 @@ bool mysql_drop_user(THD *thd, List <LEX_USER> &list)
thd->variables.sql_mode&= ~MODE_PAD_CHAR_TO_FULL_LENGTH;
rw_wrlock(&LOCK_grant);
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
while ((tmp_user_name= user_list++))
{
@ -5870,7 +5871,7 @@ bool mysql_drop_user(THD *thd, List <LEX_USER> &list)
/* Rebuild 'acl_check_hosts' since 'acl_users' has been modified */
rebuild_check_host();
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
if (result)
my_error(ER_CANNOT_USER, MYF(0), "DROP USER", wrong_users.c_ptr_safe());
@ -5921,7 +5922,7 @@ bool mysql_rename_user(THD *thd, List <LEX_USER> &list)
DBUG_RETURN(result != 1);
rw_wrlock(&LOCK_grant);
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
while ((tmp_user_from= user_list++))
{
@ -5955,7 +5956,7 @@ bool mysql_rename_user(THD *thd, List <LEX_USER> &list)
/* Rebuild 'acl_check_hosts' since 'acl_users' has been modified */
rebuild_check_host();
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
if (result)
my_error(ER_CANNOT_USER, MYF(0), "RENAME USER", wrong_users.c_ptr_safe());
@ -6002,7 +6003,7 @@ bool mysql_revoke_all(THD *thd, List <LEX_USER> &list)
DBUG_RETURN(result != 1);
rw_wrlock(&LOCK_grant);
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
LEX_USER *lex_user, *tmp_lex_user;
List_iterator <LEX_USER> user_list(list);
@ -6141,7 +6142,7 @@ bool mysql_revoke_all(THD *thd, List <LEX_USER> &list)
} while (revoked);
}
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
write_bin_log(thd, FALSE, thd->query(), thd->query_length());
@ -6250,7 +6251,7 @@ bool sp_revoke_privileges(THD *thd, const char *sp_db, const char *sp_name,
thd->push_internal_handler(&error_handler);
rw_wrlock(&LOCK_grant);
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
/*
This statement will be replicated as a statement, even when using
@ -6288,7 +6289,7 @@ bool sp_revoke_privileges(THD *thd, const char *sp_db, const char *sp_name,
}
} while (revoked);
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
rw_unlock(&LOCK_grant);
close_thread_tables(thd);
@ -6329,7 +6330,7 @@ bool sp_grant_privileges(THD *thd, const char *sp_db, const char *sp_name,
combo->user.str= sctx->user;
VOID(pthread_mutex_lock(&acl_cache->lock));
pthread_mutex_lock(&acl_cache->lock);
if ((au= find_acl_user(combo->host.str=(char*)sctx->host_or_ip,combo->user.str,FALSE)))
goto found_acl;
@ -6340,11 +6341,11 @@ bool sp_grant_privileges(THD *thd, const char *sp_db, const char *sp_name,
if((au= find_acl_user(combo->host.str=(char*)"%", combo->user.str, FALSE)))
goto found_acl;
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
DBUG_RETURN(TRUE);
found_acl:
VOID(pthread_mutex_unlock(&acl_cache->lock));
pthread_mutex_unlock(&acl_cache->lock);
bzero((char*)tables, sizeof(TABLE_LIST));
user_list.empty();

146
sql/sql_base.cc
View File

@ -438,7 +438,7 @@ found:
oldest_unused_share->next)
{
pthread_mutex_lock(&oldest_unused_share->mutex);
VOID(my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share);
}
DBUG_PRINT("exit", ("share: 0x%lx ref_count: %u",
@ -714,7 +714,7 @@ OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *db, const char *wild)
TABLE_LIST table_list;
DBUG_ENTER("list_open_tables");
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
bzero((char*) &table_list,sizeof(table_list));
start_list= &open_list;
open_list=0;
@ -767,7 +767,7 @@ OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *db, const char *wild)
start_list= &(*start_list)->next;
*start_list=0;
}
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_RETURN(open_list);
}
@ -787,7 +787,7 @@ void intern_close_table(TABLE *table)
free_io_cache(table);
delete table->triggers;
if (table->file) // Not true if name lock
VOID(closefrm(table, 1)); // close file
(void) closefrm(table, 1); // close file
DBUG_VOID_RETURN;
}
@ -864,7 +864,7 @@ bool close_cached_tables(THD *thd, TABLE_LIST *tables, bool have_lock,
DBUG_ASSERT(thd || (!wait_for_refresh && !tables));
if (!have_lock)
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
if (!tables)
{
refresh_version++; // Force close of open tables
@ -874,14 +874,14 @@ bool close_cached_tables(THD *thd, TABLE_LIST *tables, bool have_lock,
if (my_hash_delete(&open_cache,(uchar*) unused_tables))
printf("Warning: Couldn't delete open table from hash\n");
#else
VOID(my_hash_delete(&open_cache,(uchar*) unused_tables));
(void) my_hash_delete(&open_cache,(uchar*) unused_tables);
#endif
}
/* Free table shares */
while (oldest_unused_share->next)
{
pthread_mutex_lock(&oldest_unused_share->mutex);
VOID(my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
(void) my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share);
}
DBUG_PRINT("tcache", ("incremented global refresh_version to: %lu",
refresh_version));
@ -1019,7 +1019,7 @@ bool close_cached_tables(THD *thd, TABLE_LIST *tables, bool have_lock,
}
}
if (!have_lock)
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
if (wait_for_refresh)
{
pthread_mutex_lock(&thd->mysys_var->mutex);
@ -1049,7 +1049,7 @@ bool close_cached_connection_tables(THD *thd, bool if_wait_for_refresh,
bzero(&tmp, sizeof(TABLE_LIST));
if (!have_lock)
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
for (idx= 0; idx < table_def_cache.records; idx++)
{
@ -1082,7 +1082,7 @@ bool close_cached_connection_tables(THD *thd, bool if_wait_for_refresh,
result= close_cached_tables(thd, tables, TRUE, FALSE, FALSE);
if (!have_lock)
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
if (if_wait_for_refresh)
{
@ -1199,7 +1199,7 @@ static void close_open_tables(THD *thd)
safe_mutex_assert_not_owner(&LOCK_open);
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
DBUG_PRINT("info", ("thd->open_tables: 0x%lx", (long) thd->open_tables));
@ -1209,7 +1209,7 @@ static void close_open_tables(THD *thd)
/* Free tables to hold down open files */
while (open_cache.records > table_cache_size && unused_tables)
VOID(my_hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
my_hash_delete(&open_cache,(uchar*) unused_tables); /* purecov: tested */
check_unused();
if (found_old_table)
{
@ -1217,7 +1217,7 @@ static void close_open_tables(THD *thd)
broadcast_refresh();
}
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
}
@ -1395,7 +1395,7 @@ bool close_thread_table(THD *thd, TABLE **table_ptr)
if (table->needs_reopen_or_name_lock() ||
thd->version != refresh_version || !table->db_stat)
{
VOID(my_hash_delete(&open_cache,(uchar*) table));
my_hash_delete(&open_cache,(uchar*) table);
found_old_table=1;
}
else
@ -1680,20 +1680,42 @@ TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list,
DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
for (;;)
{
if (((! (res= find_table_in_global_list(table_list, d_name, t_name))) &&
(! (res= mysql_lock_have_duplicate(thd, table, table_list)))) ||
((!res->table || res->table != table->table) &&
(!check_alias || !(lower_case_table_names ?
my_strcasecmp(files_charset_info, t_alias, res->alias) :
strcmp(t_alias, res->alias))) &&
res->select_lex && !res->select_lex->exclude_from_table_unique_test &&
!res->prelocking_placeholder))
/*
Table is unique if it is present only once in the global list
of tables and once in the list of table locks.
*/
if (! (res= find_table_in_global_list(table_list, d_name, t_name)) &&
! (res= mysql_lock_have_duplicate(thd, table, table_list)))
break;
/* Skip if same underlying table. */
if (res->table && (res->table == table->table))
goto next;
/* Skip if table alias does not match. */
if (check_alias)
{
if (lower_case_table_names ?
my_strcasecmp(files_charset_info, t_alias, res->alias) :
strcmp(t_alias, res->alias))
goto next;
}
/*
Skip if marked to be excluded (could be a derived table) or if
entry is a prelocking placeholder.
*/
if (res->select_lex &&
!res->select_lex->exclude_from_table_unique_test &&
!res->prelocking_placeholder)
break;
/*
If we found entry of this table or table of SELECT which already
processed in derived table or top select of multi-update/multi-delete
(exclude_from_table_unique_test) or prelocking placeholder.
*/
next:
table_list= res->next_global;
DBUG_PRINT("info",
("found same copy of table or table which we should skip"));
@ -2099,7 +2121,7 @@ void unlink_open_table(THD *thd, TABLE *find, bool unlock)
/* Remove table from open_tables list. */
*prev= list->next;
/* Close table. */
VOID(my_hash_delete(&open_cache,(uchar*) list)); // Close table
my_hash_delete(&open_cache,(uchar*) list); // Close table
}
else
{
@ -2141,14 +2163,14 @@ void drop_open_table(THD *thd, TABLE *table, const char *db_name,
else
{
handlerton *table_type= table->s->db_type();
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
/*
unlink_open_table() also tells threads waiting for refresh or close
that something has happened.
*/
unlink_open_table(thd, table, FALSE);
quick_rm_table(table_type, db_name, table_name, 0);
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
}
}
@ -2403,24 +2425,24 @@ bool lock_table_name_if_not_cached(THD *thd, const char *db,
DBUG_ENTER("lock_table_name_if_not_cached");
key_length= (uint)(strmov(strmov(key, db) + 1, table_name) - key) + 1;
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
if (my_hash_search(&open_cache, (uchar *)key, key_length))
{
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_PRINT("info", ("Table is cached, name-lock is not obtained"));
*table= 0;
DBUG_RETURN(FALSE);
}
if (!(*table= table_cache_insert_placeholder(thd, key, key_length)))
{
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_RETURN(TRUE);
}
(*table)->open_placeholder= 1;
(*table)->next= thd->open_tables;
thd->open_tables= *table;
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_RETURN(FALSE);
}
@ -2677,15 +2699,15 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
*/
TABLE tab;
table= &tab;
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
if (!open_unireg_entry(thd, table, table_list, alias,
key, key_length, mem_root, 0))
{
DBUG_ASSERT(table_list->view != 0);
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_RETURN(0); // VIEW
}
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
}
}
/*
@ -2718,7 +2740,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
on disk.
*/
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
/*
If it's the first table from a list of tables used in a query,
@ -2736,7 +2758,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
/* Someone did a refresh while thread was opening tables */
if (refresh)
*refresh=1;
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_RETURN(0);
}
@ -2802,7 +2824,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
/* Avoid self-deadlocks by detecting self-dependencies. */
if (table->open_placeholder && table->in_use == thd)
{
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
my_error(ER_UPDATE_TABLE_USED, MYF(0), table->s->table_name.str);
DBUG_RETURN(0);
}
@ -2843,7 +2865,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
}
else
{
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
}
/*
There is a refresh in progress for this table.
@ -2876,7 +2898,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
DBUG_PRINT("tcache", ("opening new table"));
/* Free cache if too big */
while (open_cache.records > table_cache_size && unused_tables)
VOID(my_hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
my_hash_delete(&open_cache,(uchar*) unused_tables); /* purecov: tested */
if (table_list->create)
{
@ -2884,7 +2906,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
if (check_if_table_exists(thd, table_list, &exists))
{
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_RETURN(NULL);
}
@ -2895,7 +2917,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
*/
if (!(table= table_cache_insert_placeholder(thd, key, key_length)))
{
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_RETURN(NULL);
}
/*
@ -2906,7 +2928,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
table->open_placeholder= 1;
table->next= thd->open_tables;
thd->open_tables= table;
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_RETURN(table);
}
/* Table exists. Let us try to open it. */
@ -2915,7 +2937,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
/* make a new table */
if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
{
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_RETURN(NULL);
}
@ -2924,7 +2946,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
if (error > 0)
{
my_free((uchar*)table, MYF(0));
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_RETURN(NULL);
}
if (table_list->view || error < 0)
@ -2937,18 +2959,18 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
table_list->view= (LEX*)1;
my_free((uchar*)table, MYF(0));
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_RETURN(0); // VIEW
}
DBUG_PRINT("info", ("inserting table '%s'.'%s' 0x%lx into the cache",
table->s->db.str, table->s->table_name.str,
(long) table));
VOID(my_hash_insert(&open_cache,(uchar*) table));
(void) my_hash_insert(&open_cache,(uchar*) table);
}
check_unused(); // Debugging call
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
if (refresh)
{
table->next=thd->open_tables; /* Link into simple list */
@ -3087,13 +3109,13 @@ bool reopen_table(TABLE *table)
fix_merge_after_open(table->child_l, table->child_last_l,
tmp.child_l, tmp.child_last_l))
{
VOID(closefrm(&tmp, 1)); // close file, free everything
(void) closefrm(&tmp, 1); // close file, free everything
goto end;
}
delete table->triggers;
if (table->file)
VOID(closefrm(table, 1)); // close file, free everything
(void) closefrm(table, 1); // close file, free everything
*table= tmp;
table->default_column_bitmaps();
@ -3334,7 +3356,7 @@ bool reopen_tables(THD *thd, bool get_locks, bool mark_share_as_old)
*/
if (table->child_l || table->parent)
detach_merge_children(table, TRUE);
VOID(my_hash_delete(&open_cache,(uchar*) table));
my_hash_delete(&open_cache,(uchar*) table);
error=1;
}
else
@ -3363,7 +3385,7 @@ bool reopen_tables(THD *thd, bool get_locks, bool mark_share_as_old)
{
while (err_tables)
{
VOID(my_hash_delete(&open_cache, (uchar*) err_tables));
my_hash_delete(&open_cache, (uchar*) err_tables);
err_tables= err_tables->next;
}
}
@ -3645,7 +3667,7 @@ TABLE *drop_locked_tables(THD *thd,const char *db, const char *table_name)
else
{
/* We already have a name lock, remove copy */
VOID(my_hash_delete(&open_cache,(uchar*) table));
my_hash_delete(&open_cache,(uchar*) table);
}
}
else
@ -4252,7 +4274,7 @@ void detach_merge_children(TABLE *table, bool clear_refs)
*/
if ((first_detach= parent->children_attached))
{
VOID(parent->file->extra(HA_EXTRA_DETACH_CHILDREN));
(void) parent->file->extra(HA_EXTRA_DETACH_CHILDREN);
parent->children_attached= FALSE;
DBUG_PRINT("myrg", ("detached parent: '%s'.'%s' 0x%lx", parent->s->db.str,
parent->s->table_name.str, (long) parent));
@ -8354,7 +8376,7 @@ my_bool mysql_rm_tmp_tables(void)
So we hide error messages which happnes during deleting of these
files(MYF(0)).
*/
VOID(my_delete(filePath, MYF(0)));
(void) my_delete(filePath, MYF(0));
}
}
my_dirend(dirp);
@ -8396,7 +8418,7 @@ void remove_db_from_cache(const char *db)
}
}
while (unused_tables && !unused_tables->s->version)
VOID(my_hash_delete(&open_cache,(uchar*) unused_tables));
my_hash_delete(&open_cache,(uchar*) unused_tables);
}
@ -8520,7 +8542,7 @@ bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
}
}
while (unused_tables && !unused_tables->s->version)
VOID(my_hash_delete(&open_cache,(uchar*) unused_tables));
my_hash_delete(&open_cache,(uchar*) unused_tables);
DBUG_PRINT("info", ("Removing table from table_def_cache"));
/* Remove table from table definition cache if it's not in use */
@ -8533,7 +8555,7 @@ bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
if (share->ref_count == 0)
{
pthread_mutex_lock(&share->mutex);
VOID(my_hash_delete(&table_def_cache, (uchar*) share));
my_hash_delete(&table_def_cache, (uchar*) share);
}
}
@ -8710,12 +8732,12 @@ int abort_and_upgrade_lock(ALTER_PARTITION_PARAM_TYPE *lpt)
DBUG_ENTER("abort_and_upgrade_locks");
lpt->old_lock_type= lpt->table->reginfo.lock_type;
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
/* If MERGE child, forward lock handling to parent. */
mysql_lock_abort(lpt->thd, lpt->table->parent ? lpt->table->parent :
lpt->table, TRUE);
VOID(remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name, flags));
VOID(pthread_mutex_unlock(&LOCK_open));
(void) remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name, flags);
pthread_mutex_unlock(&LOCK_open);
DBUG_RETURN(0);
}
@ -8737,10 +8759,10 @@ int abort_and_upgrade_lock(ALTER_PARTITION_PARAM_TYPE *lpt)
/* purecov: begin deadcode */
void close_open_tables_and_downgrade(ALTER_PARTITION_PARAM_TYPE *lpt)
{
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name,
RTFC_WAIT_OTHER_THREAD_FLAG);
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
/* If MERGE child, forward lock handling to parent. */
mysql_lock_downgrade_write(lpt->thd, lpt->table->parent ? lpt->table->parent :
lpt->table, lpt->old_lock_type);
@ -8779,7 +8801,7 @@ void mysql_wait_completed_table(ALTER_PARTITION_PARAM_TYPE *lpt, TABLE *my_table
DBUG_ENTER("mysql_wait_completed_table");
key_length=(uint) (strmov(strmov(key,lpt->db)+1,lpt->table_name)-key)+1;
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
HASH_SEARCH_STATE state;
for (table= (TABLE*) my_hash_first(&open_cache,(uchar*) key,key_length,
&state) ;
@ -8837,7 +8859,7 @@ void mysql_wait_completed_table(ALTER_PARTITION_PARAM_TYPE *lpt, TABLE *my_table
*/
mysql_lock_abort(lpt->thd, my_table->parent ? my_table->parent : my_table,
FALSE);
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
DBUG_VOID_RETURN;
}

17
sql/sql_cache.cc
View File

@ -2126,8 +2126,8 @@ ulong Query_cache::init_cache()
DUMP(this);
VOID(my_hash_init(&queries, &my_charset_bin, def_query_hash_size, 0, 0,
query_cache_query_get_key, 0, 0));
(void) my_hash_init(&queries, &my_charset_bin, def_query_hash_size, 0, 0,
query_cache_query_get_key, 0, 0);
#ifndef FN_NO_CASE_SENCE
/*
If lower_case_table_names!=0 then db and table names are already
@ -2137,8 +2137,8 @@ ulong Query_cache::init_cache()
lower_case_table_names == 0 then we should distinguish my_table
and MY_TABLE cases and so again can use binary collation.
*/
VOID(my_hash_init(&tables, &my_charset_bin, def_table_hash_size, 0, 0,
query_cache_table_get_key, 0, 0));
(void) my_hash_init(&tables, &my_charset_bin, def_table_hash_size, 0, 0,
query_cache_table_get_key, 0, 0);
#else
/*
On windows, OS/2, MacOS X with HFS+ or any other case insensitive
@ -2148,10 +2148,11 @@ ulong Query_cache::init_cache()
file system) and so should use case insensitive collation for
comparison.
*/
VOID(my_hash_init(&tables,
lower_case_table_names ? &my_charset_bin :
files_charset_info,
def_table_hash_size, 0, 0,query_cache_table_get_key, 0, 0));
(void) my_hash_init(&tables,
lower_case_table_names ? &my_charset_bin :
files_charset_info,
def_table_hash_size, 0, 0,query_cache_table_get_key,
0, 0);
#endif
queries_in_cache = 0;

6
sql/sql_class.cc
View File

@ -483,7 +483,7 @@ THD::THD()
catalog= (char*)"std"; // the only catalog we have for now
main_security_ctx.init();
security_ctx= &main_security_ctx;
locked=some_tables_deleted=no_errors=password= 0;
some_tables_deleted=no_errors=password= 0;
query_start_used= 0;
count_cuted_fields= CHECK_FIELD_IGNORE;
killed= NOT_KILLED;
@ -936,11 +936,9 @@ void THD::init_for_queries()
reset_root_defaults(mem_root, variables.query_alloc_block_size,
variables.query_prealloc_size);
#ifdef USING_TRANSACTIONS
reset_root_defaults(&transaction.mem_root,
variables.trans_alloc_block_size,
variables.trans_prealloc_size);
#endif
transaction.xid_state.xid.null();
transaction.xid_state.in_thd=1;
}
@ -1059,9 +1057,7 @@ THD::~THD()
DBUG_PRINT("info", ("freeing security context"));
main_security_ctx.destroy();
safeFree(db);
#ifdef USING_TRANSACTIONS
free_root(&transaction.mem_root,MYF(0));
#endif
mysys_var=0; // Safety (shouldn't be needed)
pthread_mutex_destroy(&LOCK_thd_data);
#ifndef DBUG_OFF

12
sql/sql_class.h
View File

@ -1434,19 +1434,13 @@ public:
*/
if (!xid_state.rm_error)
xid_state.xid.null();
#ifdef USING_TRANSACTIONS
free_root(&mem_root,MYF(MY_KEEP_PREALLOC));
#endif
}
st_transactions()
{
#ifdef USING_TRANSACTIONS
bzero((char*)this, sizeof(*this));
xid_state.xid.null();
init_sql_alloc(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
#else
xid_state.xa_state= XA_NOTR;
#endif
}
} transaction;
Field *dup_field;
@ -1696,7 +1690,7 @@ public:
bool slave_thread, one_shot_set;
/* tells if current statement should binlog row-based(1) or stmt-based(0) */
bool current_stmt_binlog_row_based;
bool locked, some_tables_deleted;
bool some_tables_deleted;
bool last_cuted_field;
bool no_errors, password;
/**
@ -1932,11 +1926,7 @@ public:
}
inline bool active_transaction()
{
#ifdef USING_TRANSACTIONS
return server_status & SERVER_STATUS_IN_TRANS;
#else
return 0;
#endif
}
inline bool fill_derived_tables()
{

2
sql/sql_connect.cc
View File

@ -410,7 +410,7 @@ check_user(THD *thd, enum enum_server_command command,
pthread_mutex_lock(&LOCK_connection_count);
bool count_ok= connection_count <= max_connections ||
(thd->main_security_ctx.master_access & SUPER_ACL);
VOID(pthread_mutex_unlock(&LOCK_connection_count));
pthread_mutex_unlock(&LOCK_connection_count);
if (!count_ok)
{ // too many connections

16
sql/sql_db.cc
View File

@ -643,7 +643,7 @@ int mysql_create_db(THD *thd, char *db, HA_CREATE_INFO *create_info,
goto exit2;
}
VOID(pthread_mutex_lock(&LOCK_mysql_create_db));
pthread_mutex_lock(&LOCK_mysql_create_db);
/* Check directory */
path_len= build_table_filename(path, sizeof(path) - 1, db, "", "", 0);
@ -753,7 +753,7 @@ not_silent:
}
exit:
VOID(pthread_mutex_unlock(&LOCK_mysql_create_db));
pthread_mutex_unlock(&LOCK_mysql_create_db);
start_waiting_global_read_lock(thd);
exit2:
DBUG_RETURN(error);
@ -784,7 +784,7 @@ bool mysql_alter_db(THD *thd, const char *db, HA_CREATE_INFO *create_info)
if ((error=wait_if_global_read_lock(thd,0,1)))
goto exit2;
VOID(pthread_mutex_lock(&LOCK_mysql_create_db));
pthread_mutex_lock(&LOCK_mysql_create_db);
/*
Recreate db options file: /dbpath/.db.opt
@ -830,7 +830,7 @@ bool mysql_alter_db(THD *thd, const char *db, HA_CREATE_INFO *create_info)
my_ok(thd, result);
exit:
VOID(pthread_mutex_unlock(&LOCK_mysql_create_db));
pthread_mutex_unlock(&LOCK_mysql_create_db);
start_waiting_global_read_lock(thd);
exit2:
DBUG_RETURN(error);
@ -882,7 +882,7 @@ bool mysql_rm_db(THD *thd,char *db,bool if_exists, bool silent)
goto exit2;
}
VOID(pthread_mutex_lock(&LOCK_mysql_create_db));
pthread_mutex_lock(&LOCK_mysql_create_db);
length= build_table_filename(path, sizeof(path) - 1, db, "", "", 0);
strmov(path+length, MY_DB_OPT_FILE); // Append db option file name
@ -1030,7 +1030,7 @@ exit:
*/
if (thd->db && !strcmp(thd->db, db) && error == 0)
mysql_change_db_impl(thd, NULL, 0, thd->variables.collation_server);
VOID(pthread_mutex_unlock(&LOCK_mysql_create_db));
pthread_mutex_unlock(&LOCK_mysql_create_db);
start_waiting_global_read_lock(thd);
exit2:
DBUG_RETURN(error);
@ -1143,9 +1143,9 @@ static long mysql_rm_known_files(THD *thd, MY_DIR *dirp, const char *db,
goto err;
table_list->db= (char*) (table_list+1);
table_list->table_name= strmov(table_list->db, db) + 1;
VOID(filename_to_tablename(file->name, table_list->table_name,
(void) filename_to_tablename(file->name, table_list->table_name,
MYSQL50_TABLE_NAME_PREFIX_LENGTH +
strlen(file->name) + 1));
strlen(file->name) + 1);
table_list->alias= table_list->table_name; // If lower_case_table_names=2
table_list->internal_tmp_table= is_prefix(file->name, tmp_file_prefix);
/* Link into list */

12
sql/sql_delete.cc
View File

@ -1166,10 +1166,10 @@ bool mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok)
// crashes, replacement works. *(path + path_length - reg_ext_length)=
// '\0';
path[path_length - reg_ext_length] = 0;
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
error= ha_create_table(thd, path, table_list->db, table_list->table_name,
&create_info, 1);
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
query_cache_invalidate3(thd, table_list, 0);
end:
@ -1184,15 +1184,15 @@ end:
write_bin_log(thd, TRUE, thd->query(), thd->query_length());
my_ok(thd); // This should return record count
}
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
unlock_table_name(thd, table_list);
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
}
else if (error)
{
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
unlock_table_name(thd, table_list);
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
}
DBUG_RETURN(error);

4
sql/sql_handler.cc
View File

@ -143,14 +143,14 @@ static void mysql_ha_close_table(THD *thd, TABLE_LIST *tables,
{
(*table_ptr)->file->ha_index_or_rnd_end();
if (! is_locked)
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
if (close_thread_table(thd, table_ptr))
{
/* Tell threads waiting for refresh that something has happened */
broadcast_refresh();
}
if (! is_locked)
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
}
else if (tables->table)
{

411
sql/sql_insert.cc
View File

@ -1033,7 +1033,7 @@ static bool check_view_insertability(THD * thd, TABLE_LIST *view)
DBUG_ASSERT(view->table != 0 && view->field_translation != 0);
VOID(bitmap_init(&used_fields, used_fields_buff, table->s->fields, 0));
(void) bitmap_init(&used_fields, used_fields_buff, table->s->fields, 0);
bitmap_clear_all(&used_fields);
view->contain_auto_increment= 0;
@ -1766,11 +1766,11 @@ public:
pthread_mutex_init(&mutex,MY_MUTEX_INIT_FAST);
pthread_cond_init(&cond,NULL);
pthread_cond_init(&cond_client,NULL);
VOID(pthread_mutex_lock(&LOCK_thread_count));
pthread_mutex_lock(&LOCK_thread_count);
delayed_insert_threads++;
delayed_lock= global_system_variables.low_priority_updates ?
TL_WRITE_LOW_PRIORITY : TL_WRITE;
VOID(pthread_mutex_unlock(&LOCK_thread_count));
pthread_mutex_unlock(&LOCK_thread_count);
}
~Delayed_insert()
{
@ -1780,7 +1780,7 @@ public:
delete row;
if (table)
close_thread_tables(&thd);
VOID(pthread_mutex_lock(&LOCK_thread_count));
pthread_mutex_lock(&LOCK_thread_count);
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
pthread_cond_destroy(&cond_client);
@ -1789,8 +1789,8 @@ public:
thd.security_ctx->user= thd.security_ctx->host=0;
thread_count--;
delayed_insert_threads--;
VOID(pthread_mutex_unlock(&LOCK_thread_count));
VOID(pthread_cond_broadcast(&COND_thread_count)); /* Tell main we are ready */
pthread_mutex_unlock(&LOCK_thread_count);
pthread_cond_broadcast(&COND_thread_count); /* Tell main we are ready */
}
/* The following is for checking when we can delete ourselves */
@ -2262,7 +2262,7 @@ static void end_delayed_insert(THD *thd)
void kill_delayed_threads(void)
{
VOID(pthread_mutex_lock(&LOCK_delayed_insert)); // For unlink from list
pthread_mutex_lock(&LOCK_delayed_insert); // For unlink from list
I_List_iterator<Delayed_insert> it(delayed_threads);
Delayed_insert *di;
@ -2287,202 +2287,7 @@ void kill_delayed_threads(void)
pthread_mutex_unlock(&di->thd.mysys_var->mutex);
}
}
VOID(pthread_mutex_unlock(&LOCK_delayed_insert)); // For unlink from list
}
static void handle_delayed_insert_impl(THD *thd, Delayed_insert *di)
{
DBUG_ENTER("handle_delayed_insert_impl");
thd->thread_stack= (char*) &thd;
if (init_thr_lock() || thd->store_globals())
{
/* Can't use my_error since store_globals has perhaps failed */
thd->stmt_da->set_error_status(thd, ER_OUT_OF_RESOURCES,
ER(ER_OUT_OF_RESOURCES), NULL);
thd->fatal_error();
goto err;
}
/*
Open table requires an initialized lex in case the table is
partitioned. The .frm file contains a partial SQL string which is
parsed using a lex, that depends on initialized thd->lex.
*/
lex_start(thd);
thd->lex->sql_command= SQLCOM_INSERT; // For innodb::store_lock()
/*
Statement-based replication of INSERT DELAYED has problems with RAND()
and user vars, so in mixed mode we go to row-based.
*/
thd->lex->set_stmt_unsafe();
thd->set_current_stmt_binlog_row_based_if_mixed();
/* Open table */
if (!(di->table= open_n_lock_single_table(thd, &di->table_list,
TL_WRITE_DELAYED)))
{
thd->fatal_error(); // Abort waiting inserts
goto err;
}
if (!(di->table->file->ha_table_flags() & HA_CAN_INSERT_DELAYED))
{
my_error(ER_DELAYED_NOT_SUPPORTED, MYF(ME_FATALERROR),
di->table_list.table_name);
goto err;
}
if (di->table->triggers)
{
/*
Table has triggers. This is not an error, but we do
not support triggers with delayed insert. Terminate the delayed
thread without an error and thus request lock upgrade.
*/
goto err;
}
di->table->copy_blobs=1;
/* Tell client that the thread is initialized */
pthread_cond_signal(&di->cond_client);
/* Now wait until we get an insert or lock to handle */
/* We will not abort as long as a client thread uses this thread */
for (;;)
{
if (thd->killed == THD::KILL_CONNECTION)
{
uint lock_count;
/*
Remove this from delay insert list so that no one can request a
table from this
*/
pthread_mutex_unlock(&di->mutex);
pthread_mutex_lock(&LOCK_delayed_insert);
di->unlink();
lock_count=di->lock_count();
pthread_mutex_unlock(&LOCK_delayed_insert);
pthread_mutex_lock(&di->mutex);
if (!lock_count && !di->tables_in_use && !di->stacked_inserts)
break; // Time to die
}
if (!di->status && !di->stacked_inserts)
{
struct timespec abstime;
set_timespec(abstime, delayed_insert_timeout);
/* Information for pthread_kill */
di->thd.mysys_var->current_mutex= &di->mutex;
di->thd.mysys_var->current_cond= &di->cond;
thd_proc_info(&(di->thd), "Waiting for INSERT");
DBUG_PRINT("info",("Waiting for someone to insert rows"));
while (!thd->killed)
{
int error;
#if defined(HAVE_BROKEN_COND_TIMEDWAIT)
error=pthread_cond_wait(&di->cond,&di->mutex);
#else
error=pthread_cond_timedwait(&di->cond,&di->mutex,&abstime);
#ifdef EXTRA_DEBUG
if (error && error != EINTR && error != ETIMEDOUT)
{
fprintf(stderr, "Got error %d from pthread_cond_timedwait\n",error);
DBUG_PRINT("error",("Got error %d from pthread_cond_timedwait",
error));
}
#endif
#endif
if (thd->killed || di->status)
break;
if (error == ETIMEDOUT || error == ETIME)
{
thd->killed= THD::KILL_CONNECTION;
break;
}
}
/* We can't lock di->mutex and mysys_var->mutex at the same time */
pthread_mutex_unlock(&di->mutex);
pthread_mutex_lock(&di->thd.mysys_var->mutex);
di->thd.mysys_var->current_mutex= 0;
di->thd.mysys_var->current_cond= 0;
pthread_mutex_unlock(&di->thd.mysys_var->mutex);
pthread_mutex_lock(&di->mutex);
}
thd_proc_info(&(di->thd), 0);
if (di->tables_in_use && ! thd->lock)
{
bool not_used;
/*
Request for new delayed insert.
Lock the table, but avoid to be blocked by a global read lock.
If we got here while a global read lock exists, then one or more
inserts started before the lock was requested. These are allowed
to complete their work before the server returns control to the
client which requested the global read lock. The delayed insert
handler will close the table and finish when the outstanding
inserts are done.
*/
if (! (thd->lock= mysql_lock_tables(thd, &di->table, 1,
MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK,
&not_used)))
{
/* Fatal error */
di->dead= 1;
thd->killed= THD::KILL_CONNECTION;
}
pthread_cond_broadcast(&di->cond_client);
}
if (di->stacked_inserts)
{
if (di->handle_inserts())
{
/* Some fatal error */
di->dead= 1;
thd->killed= THD::KILL_CONNECTION;
}
}
di->status=0;
if (!di->stacked_inserts && !di->tables_in_use && thd->lock)
{
/*
No one is doing a insert delayed
Unlock table so that other threads can use it
*/
MYSQL_LOCK *lock=thd->lock;
thd->lock=0;
pthread_mutex_unlock(&di->mutex);
/*
We need to release next_insert_id before unlocking. This is
enforced by handler::ha_external_lock().
*/
di->table->file->ha_release_auto_increment();
mysql_unlock_tables(thd, lock);
ha_autocommit_or_rollback(thd, 0);
di->group_count=0;
pthread_mutex_lock(&di->mutex);
}
if (di->tables_in_use)
pthread_cond_broadcast(&di->cond_client); // If waiting clients
}
err:
/*
mysql_lock_tables() can potentially start a transaction and write
a table map. In the event of an error, that transaction has to be
rolled back. We only need to roll back a potential statement
transaction, since real transactions are rolled back in
close_thread_tables().
TODO: This is not true any more, table maps are generated on the
first call to ha_*_row() instead. Remove code that are used to
cover for the case outlined above.
*/
ha_autocommit_or_rollback(thd, 1);
DBUG_VOID_RETURN;
pthread_mutex_unlock(&LOCK_delayed_insert); // For unlink from list
}
@ -2518,11 +2323,201 @@ pthread_handler_t handle_delayed_insert(void *arg)
/* Can't use my_error since store_globals has not yet been called */
thd->stmt_da->set_error_status(thd, ER_OUT_OF_RESOURCES,
ER(ER_OUT_OF_RESOURCES), NULL);
goto end;
}
handle_delayed_insert_impl(thd, di);
else
{
DBUG_ENTER("handle_delayed_insert");
thd->thread_stack= (char*) &thd;
if (init_thr_lock() || thd->store_globals())
{
/* Can't use my_error since store_globals has perhaps failed */
thd->stmt_da->set_error_status(thd, ER_OUT_OF_RESOURCES,
ER(ER_OUT_OF_RESOURCES), NULL);
thd->fatal_error();
goto err;
}
/*
Open table requires an initialized lex in case the table is
partitioned. The .frm file contains a partial SQL string which is
parsed using a lex, that depends on initialized thd->lex.
*/
lex_start(thd);
thd->lex->sql_command= SQLCOM_INSERT; // For innodb::store_lock()
/*
Statement-based replication of INSERT DELAYED has problems with RAND()
and user vars, so in mixed mode we go to row-based.
*/
thd->lex->set_stmt_unsafe();
thd->set_current_stmt_binlog_row_based_if_mixed();
/* Open table */
if (!(di->table= open_n_lock_single_table(thd, &di->table_list,
TL_WRITE_DELAYED)))
{
thd->fatal_error(); // Abort waiting inserts
goto err;
}
if (!(di->table->file->ha_table_flags() & HA_CAN_INSERT_DELAYED))
{
my_error(ER_DELAYED_NOT_SUPPORTED, MYF(ME_FATALERROR),
di->table_list.table_name);
goto err;
}
if (di->table->triggers)
{
/*
Table has triggers. This is not an error, but we do
not support triggers with delayed insert. Terminate the delayed
thread without an error and thus request lock upgrade.
*/
goto err;
}
di->table->copy_blobs=1;
/* Tell client that the thread is initialized */
pthread_cond_signal(&di->cond_client);
/* Now wait until we get an insert or lock to handle */
/* We will not abort as long as a client thread uses this thread */
for (;;)
{
if (thd->killed == THD::KILL_CONNECTION)
{
uint lock_count;
/*
Remove this from delay insert list so that no one can request a
table from this
*/
pthread_mutex_unlock(&di->mutex);
pthread_mutex_lock(&LOCK_delayed_insert);
di->unlink();
lock_count=di->lock_count();
pthread_mutex_unlock(&LOCK_delayed_insert);
pthread_mutex_lock(&di->mutex);
if (!lock_count && !di->tables_in_use && !di->stacked_inserts)
break; // Time to die
}
if (!di->status && !di->stacked_inserts)
{
struct timespec abstime;
set_timespec(abstime, delayed_insert_timeout);
/* Information for pthread_kill */
di->thd.mysys_var->current_mutex= &di->mutex;
di->thd.mysys_var->current_cond= &di->cond;
thd_proc_info(&(di->thd), "Waiting for INSERT");
DBUG_PRINT("info",("Waiting for someone to insert rows"));
while (!thd->killed)
{
int error;
#if defined(HAVE_BROKEN_COND_TIMEDWAIT)
error=pthread_cond_wait(&di->cond,&di->mutex);
#else
error=pthread_cond_timedwait(&di->cond,&di->mutex,&abstime);
#ifdef EXTRA_DEBUG
if (error && error != EINTR && error != ETIMEDOUT)
{
fprintf(stderr, "Got error %d from pthread_cond_timedwait\n",error);
DBUG_PRINT("error",("Got error %d from pthread_cond_timedwait",
error));
}
#endif
#endif
if (thd->killed || di->status)
break;
if (error == ETIMEDOUT || error == ETIME)
{
thd->killed= THD::KILL_CONNECTION;
break;
}
}
/* We can't lock di->mutex and mysys_var->mutex at the same time */
pthread_mutex_unlock(&di->mutex);
pthread_mutex_lock(&di->thd.mysys_var->mutex);
di->thd.mysys_var->current_mutex= 0;
di->thd.mysys_var->current_cond= 0;
pthread_mutex_unlock(&di->thd.mysys_var->mutex);
pthread_mutex_lock(&di->mutex);
}
thd_proc_info(&(di->thd), 0);
if (di->tables_in_use && ! thd->lock)
{
bool not_used;
/*
Request for new delayed insert.
Lock the table, but avoid to be blocked by a global read lock.
If we got here while a global read lock exists, then one or more
inserts started before the lock was requested. These are allowed
to complete their work before the server returns control to the
client which requested the global read lock. The delayed insert
handler will close the table and finish when the outstanding
inserts are done.
*/
if (! (thd->lock= mysql_lock_tables(thd, &di->table, 1,
MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK,
&not_used)))
{
/* Fatal error */
di->dead= 1;
thd->killed= THD::KILL_CONNECTION;
}
pthread_cond_broadcast(&di->cond_client);
}
if (di->stacked_inserts)
{
if (di->handle_inserts())
{
/* Some fatal error */
di->dead= 1;
thd->killed= THD::KILL_CONNECTION;
}
}
di->status=0;
if (!di->stacked_inserts && !di->tables_in_use && thd->lock)
{
/*
No one is doing a insert delayed
Unlock table so that other threads can use it
*/
MYSQL_LOCK *lock=thd->lock;
thd->lock=0;
pthread_mutex_unlock(&di->mutex);
/*
We need to release next_insert_id before unlocking. This is
enforced by handler::ha_external_lock().
*/
di->table->file->ha_release_auto_increment();
mysql_unlock_tables(thd, lock);
ha_autocommit_or_rollback(thd, 0);
di->group_count=0;
pthread_mutex_lock(&di->mutex);
}
if (di->tables_in_use)
pthread_cond_broadcast(&di->cond_client); // If waiting clients
}
err:
/*
mysql_lock_tables() can potentially start a transaction and write
a table map. In the event of an error, that transaction has to be
rolled back. We only need to roll back a potential statement
transaction, since real transactions are rolled back in
close_thread_tables().
TODO: This is not true any more, table maps are generated on the
first call to ha_*_row() instead. Remove code that are used to
cover for the case outlined above.
*/
ha_autocommit_or_rollback(thd, 1);
DBUG_LEAVE;
}
end:
/*
di should be unlinked from the thread handler list and have no active
clients
@ -3499,7 +3494,7 @@ static TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
{
VOID(pthread_mutex_lock(&LOCK_open));
pthread_mutex_lock(&LOCK_open);
if (reopen_name_locked_table(thd, create_table, FALSE))
{
quick_rm_table(create_info->db_type, create_table->db,
@ -3508,7 +3503,7 @@ static TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
}
else
table= create_table->table;
VOID(pthread_mutex_unlock(&LOCK_open));
pthread_mutex_unlock(&LOCK_open);
}
else
{

16
sql/sql_map.cc
View File

@ -48,12 +48,12 @@ mapped_files::mapped_files(const char * filename,uchar *magic,uint magic_length)
if (map && memcmp(map,magic,magic_length))
{
my_error(ER_WRONG_MAGIC, MYF(0), name);
VOID(my_munmap((char*) map,(size_t)size));
(void) my_munmap((char*) map,(size_t)size);
map=0;
}
if (!map)
{
VOID(my_close(file,MYF(0)));
(void) my_close(file,MYF(0));
file= -1;
}
}
@ -66,8 +66,8 @@ mapped_files::~mapped_files()
#ifdef HAVE_MMAP
if (file >= 0)
{
VOID(my_munmap((char*) map,(size_t)size));
VOID(my_close(file,MYF(0)));
(void) my_munmap((char*) map,(size_t)size);
(void) my_close(file,MYF(0));
file= -1; map=0;
}
my_free(name,MYF(0));
@ -85,7 +85,7 @@ static I_List<mapped_files> maps_in_use;
mapped_files *map_file(const char * name,uchar *magic,uint magic_length)
{
#ifdef HAVE_MMAP
VOID(pthread_mutex_lock(&LOCK_mapped_file));
pthread_mutex_lock(&LOCK_mapped_file);
I_List_iterator<mapped_files> list(maps_in_use);
mapped_files *map;
char path[FN_REFLEN];
@ -108,7 +108,7 @@ mapped_files *map_file(const char * name,uchar *magic,uint magic_length)
if (!map->map)
my_error(ER_NO_FILE_MAPPING, MYF(0), path, map->error);
}
VOID(pthread_mutex_unlock(&LOCK_mapped_file));
pthread_mutex_unlock(&LOCK_mapped_file);
return map;
#else
return NULL;
@ -122,10 +122,10 @@ mapped_files *map_file(const char * name,uchar *magic,uint magic_length)
void unmap_file(mapped_files *map)
{
#ifdef HAVE_MMAP
VOID(pthread_mutex_lock(&LOCK_mapped_file));
pthread_mutex_lock(&LOCK_mapped_file);
if (!map->use_count--)
delete map;
VOID(pthread_mutex_unlock(&LOCK_mapped_file));
pthread_mutex_unlock(&LOCK_mapped_file);
#endif
}

42
sql/sql_parse.cc
View File

@ -511,9 +511,7 @@ static void handle_bootstrap_impl(THD *thd)
break;
free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
#ifdef USING_TRANSACTIONS
free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
#endif
}
DBUG_VOID_RETURN;
@ -812,11 +810,7 @@ bool do_command(THD *thd)
net_new_transaction(net);
packet_length= my_net_read(net);
#if defined(ENABLED_PROFILING)
thd->profiling.start_new_query();
#endif
if (packet_length == packet_error)
if ((packet_length= my_net_read(net)) == packet_error)
{
DBUG_PRINT("info",("Got error %d reading command from socket %s",
net->error,
@ -873,9 +867,6 @@ bool do_command(THD *thd)
return_value= dispatch_command(command, thd, packet+1, (uint) (packet_length-1));
out:
#if defined(ENABLED_PROFILING)
thd->profiling.finish_current_query();
#endif
DBUG_RETURN(return_value);
}
#endif /* EMBEDDED_LIBRARY */
@ -977,6 +968,9 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
DBUG_ENTER("dispatch_command");
DBUG_PRINT("info",("packet: '%*.s'; command: %d", packet_length, packet, command));
#if defined(ENABLED_PROFILING)
thd->profiling.start_new_query();
#endif
MYSQL_COMMAND_START(thd->thread_id, command,
thd->security_ctx->priv_user,
(char *) thd->security_ctx->host_or_ip);
@ -989,7 +983,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
thd->enable_slow_log= TRUE;
thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
thd->set_time();
VOID(pthread_mutex_lock(&LOCK_thread_count));
pthread_mutex_lock(&LOCK_thread_count);
thd->query_id= global_query_id;
switch( command ) {
@ -1011,7 +1005,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
thread_running++;
/* TODO: set thd->lex->sql_command to SQLCOM_END here */
VOID(pthread_mutex_unlock(&LOCK_thread_count));
pthread_mutex_unlock(&LOCK_thread_count);
/**
Clear the set of flags that are expected to be cleared at the
@ -1234,9 +1228,6 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
thd->profiling.set_query_source(thd->query(), thd->query_length());
#endif
if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(),QUERY_PRIOR);
mysql_parse(thd, thd->query(), thd->query_length(), &end_of_stmt);
while (!thd->killed && (end_of_stmt != NULL) && ! thd->is_error())
@ -1277,7 +1268,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
(char *) thd->security_ctx->host_or_ip);
thd->set_query(beginning_of_next_stmt, length);
VOID(pthread_mutex_lock(&LOCK_thread_count));
pthread_mutex_lock(&LOCK_thread_count);
/*
Count each statement from the client.
*/
@ -1285,12 +1276,10 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
thd->query_id= next_query_id();
thd->set_time(); /* Reset the query start time. */
/* TODO: set thd->lex->sql_command to SQLCOM_END here */
VOID(pthread_mutex_unlock(&LOCK_thread_count));
pthread_mutex_unlock(&LOCK_thread_count);
mysql_parse(thd, beginning_of_next_stmt, length, &end_of_stmt);
}
if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(),WAIT_PRIOR);
DBUG_PRINT("info",("query ready"));
break;
}
@ -1505,8 +1494,8 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
}
#endif
#ifndef EMBEDDED_LIBRARY
VOID(my_net_write(net, (uchar*) buff, length));
VOID(net_flush(net));
(void) my_net_write(net, (uchar*) buff, length);
(void) net_flush(net);
thd->stmt_da->disable_status();
#endif
break;
@ -1601,13 +1590,16 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
thd_proc_info(thd, "cleaning up");
thd->set_query(NULL, 0);
thd->command=COM_SLEEP;
VOID(pthread_mutex_lock(&LOCK_thread_count)); // For process list
pthread_mutex_lock(&LOCK_thread_count); // For process list
thread_running--;
VOID(pthread_mutex_unlock(&LOCK_thread_count));
pthread_mutex_unlock(&LOCK_thread_count);
thd_proc_info(thd, 0);
thd->packet.shrink(thd->variables.net_buffer_length); // Reclaim some memory
free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
#if defined(ENABLED_PROFILING)
thd->profiling.finish_current_query();
#endif
if (MYSQL_QUERY_DONE_ENABLED() || MYSQL_COMMAND_DONE_ENABLED())
{
int res;
@ -7189,7 +7181,7 @@ uint kill_one_thread(THD *thd, ulong id, bool only_kill_query)
uint error=ER_NO_SUCH_THREAD;
DBUG_ENTER("kill_one_thread");
DBUG_PRINT("enter", ("id=%lu only_kill=%d", id, only_kill_query));
VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
I_List_iterator<THD> it(threads);
while ((tmp=it++))
{
@ -7201,7 +7193,7 @@ uint kill_one_thread(THD *thd, ulong id, bool only_kill_query)
break;
}
}
VOID(pthread_mutex_unlock(&LOCK_thread_count));
pthread_mutex_unlock(&LOCK_thread_count);
if (tmp)
{

12
sql/sql_prepare.cc
View File

@ -2615,14 +2615,8 @@ void mysqld_stmt_fetch(THD *thd, char *packet, uint packet_length)
thd->stmt_arena= stmt;
thd->set_n_backup_statement(stmt, &stmt_backup);
if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(), QUERY_PRIOR);
cursor->fetch(num_rows);
if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(), WAIT_PRIOR);
if (!cursor->is_open())
{
stmt->close_cursor();
@ -3386,14 +3380,8 @@ reexecute:
thd->m_reprepare_observer = &reprepare_observer;
}
if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(),QUERY_PRIOR);
error= execute(expanded_query, open_cursor) || thd->is_error();
if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(), WAIT_PRIOR);
thd->m_reprepare_observer= NULL;
if (error && !thd->is_fatal_error && !thd->killed &&

10
sql/sql_select.cc
View File

@ -3954,7 +3954,7 @@ update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
save_pos++;
}
i=(uint) (save_pos-(KEYUSE*) keyuse->buffer);
VOID(set_dynamic(keyuse,(uchar*) &key_end,i));
(void) set_dynamic(keyuse,(uchar*) &key_end,i);
keyuse->elements=i;
}
return FALSE;
@ -9189,7 +9189,7 @@ remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value)
li.remove();
else if (item != new_item)
{
VOID(li.replace(new_item));
(void) li.replace(new_item);
should_fix_fields=1;
}
if (*cond_value == Item::COND_UNDEF)
@ -11055,7 +11055,7 @@ do_select(JOIN *join,List<Item> *fields,TABLE *table,Procedure *procedure)
if (table)
{
VOID(table->file->extra(HA_EXTRA_WRITE_CACHE));
(void) table->file->extra(HA_EXTRA_WRITE_CACHE);
empty_record(table);
if (table->group && join->tmp_table_param.sum_func_count &&
table->s->keys && !table->file->inited)
@ -12401,7 +12401,7 @@ end_send_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
if (end_of_records)
DBUG_RETURN(NESTED_LOOP_OK);
join->first_record=1;
VOID(test_if_group_changed(join->group_fields));
(void) test_if_group_changed(join->group_fields);
}
if (idx < (int) join->send_group_parts)
{
@ -12664,7 +12664,7 @@ end_write_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
if (end_of_records)
DBUG_RETURN(NESTED_LOOP_OK);
join->first_record=1;
VOID(test_if_group_changed(join->group_fields));
(void) test_if_group_changed(join->group_fields);
}
if (idx < (int) join->send_group_parts)
{

6
sql/sql_servers.cc
View File

@ -664,8 +664,8 @@ delete_server_record_in_cache(LEX_SERVER_OPTIONS *server_options)
server->server_name,
server->server_name_length));
VOID(my_hash_delete(&servers_cache, (uchar*) server));
my_hash_delete(&servers_cache, (uchar*) server);
error= 0;
end:
@ -771,7 +771,7 @@ int update_server_record_in_cache(FOREIGN_SERVER *existing,
/*
delete the existing server struct from the server cache
*/
VOID(my_hash_delete(&servers_cache, (uchar*)existing));
my_hash_delete(&servers_cache, (uchar*)existing);
/*
Insert the altered server struct into the server cache

Some files were not shown because too many files have changed in this diff Show More