diff options
Diffstat (limited to 'sql-common/mysql_async.c')
| -rw-r--r-- | sql-common/mysql_async.c | 1441 |
1 files changed, 956 insertions, 485 deletions
diff --git a/sql-common/mysql_async.c b/sql-common/mysql_async.c index a8e699e5012..a2b818b77e2 100644 --- a/sql-common/mysql_async.c +++ b/sql-common/mysql_async.c @@ -1,17 +1,15 @@ /* - Copyright 2011 Kristian Nielsen + Copyright 2011 Kristian Nielsen and Monty Program Ab - Experiments with non-blocking libmysql. + This file is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. - This is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 2 of the License, or - (at your option) any later version. - - This is distributed in the hope that it will be useful, + This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. You should have received a copy of the GNU General Public License along with this. If not, see <http://www.gnu.org/licenses/>. @@ -28,6 +26,7 @@ #include "sql_common.h" #include "my_context.h" #include "violite.h" +#include "mysql_async.h" #ifdef __WIN__ @@ -36,15 +35,13 @@ that the socket is non-blocking at the start of every operation. */ #define WIN_SET_NONBLOCKING(mysql) { \ - my_bool old_mode__; \ - if ((mysql)->net.vio) vio_blocking((mysql)->net.vio, FALSE, &old_mode__); \ + my_bool old_mode; \ + if ((mysql)->net.vio) vio_blocking((mysql)->net.vio, FALSE, &old_mode); \ } #else #define WIN_SET_NONBLOCKING(mysql) #endif -extern struct mysql_async_context *mysql_get_async_context(MYSQL *mysql); - void my_context_install_suspend_resume_hook(struct mysql_async_context *b, @@ -62,12 +59,9 @@ my_connect_async(struct mysql_async_context *b, my_socket fd, const struct sockaddr *name, uint namelen, uint timeout) { int res; -#ifdef __WIN__ - int s_err_size; -#else - socklen_t s_err_size; -#endif + size_socket s_err_size; + b->events_to_wait_for= 0; /* Start to connect asynchronously. If this will block, we suspend the call and return control to the @@ -75,33 +69,31 @@ my_connect_async(struct mysql_async_context *b, my_socket fd, polls ready for write, indicating that the connection attempt completed. */ res= connect(fd, name, namelen); -#ifdef __WIN__ if (res != 0) { +#ifdef __WIN__ int wsa_err= WSAGetLastError(); if (wsa_err != WSAEWOULDBLOCK) return res; + b->events_to_wait_for|= MYSQL_WAIT_EXCEPT; #else - if (res < 0) - { - if (errno != EINPROGRESS && errno != EALREADY && errno != EAGAIN) + int err= errno; + if (err != EINPROGRESS && err != EALREADY && err != EAGAIN) return res; #endif + b->events_to_wait_for|= MYSQL_WAIT_WRITE; b->timeout_value= timeout; - b->ret_status= MYSQL_WAIT_WRITE | - (timeout ? MYSQL_WAIT_TIMEOUT : 0); -#ifdef __WIN__ - b->ret_status|= MYSQL_WAIT_EXCEPT; -#endif + if (timeout) + b->events_to_wait_for|= MYSQL_WAIT_TIMEOUT; if (b->suspend_resume_hook) (*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data); my_context_yield(&b->async_context); if (b->suspend_resume_hook) (*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data); - if (b->ret_status & MYSQL_WAIT_TIMEOUT) + if (b->events_occured & MYSQL_WAIT_TIMEOUT) return -1; - s_err_size= sizeof(int); + s_err_size= sizeof(res); if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (char*) &res, &s_err_size) != 0) return -1; if (res) @@ -113,6 +105,10 @@ my_connect_async(struct mysql_async_context *b, my_socket fd, return res; } +#define IS_BLOCKING_ERROR() \ + IF_WIN(WSAGetLastError() != WSAEWOULDBLOCK, \ + (errno != EAGAIN && errno != EINTR)) + ssize_t my_recv_async(struct mysql_async_context *b, int fd, unsigned char *buf, size_t size, uint timeout) @@ -121,25 +117,13 @@ my_recv_async(struct mysql_async_context *b, int fd, for (;;) { - res= recv(fd, buf, size, -#ifdef __WIN__ - 0 -#else - MSG_DONTWAIT -#endif - ); - if (res >= 0 || -#ifdef __WIN__ - WSAGetLastError() != WSAEWOULDBLOCK -#else - (errno != EAGAIN && errno != EINTR) -#endif - ) + res= recv(fd, buf, size, IF_WIN(0, MSG_DONTWAIT)); + if (res >= 0 || IS_BLOCKING_ERROR()) return res; - b->ret_status= MYSQL_WAIT_READ; + b->events_to_wait_for= MYSQL_WAIT_READ; if (timeout) { - b->ret_status|= MYSQL_WAIT_TIMEOUT; + b->events_to_wait_for|= MYSQL_WAIT_TIMEOUT; b->timeout_value= timeout; } if (b->suspend_resume_hook) @@ -147,11 +131,12 @@ my_recv_async(struct mysql_async_context *b, int fd, my_context_yield(&b->async_context); if (b->suspend_resume_hook) (*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data); - if (b->ret_status & MYSQL_WAIT_TIMEOUT) + if (b->events_occured & MYSQL_WAIT_TIMEOUT) return -1; } } + ssize_t my_send_async(struct mysql_async_context *b, int fd, const unsigned char *buf, size_t size, uint timeout) @@ -160,25 +145,13 @@ my_send_async(struct mysql_async_context *b, int fd, for (;;) { - res= send(fd, buf, size, -#ifdef __WIN__ - 0 -#else - MSG_DONTWAIT -#endif - ); - if (res >= 0 || -#ifdef __WIN__ - WSAGetLastError() != WSAEWOULDBLOCK -#else - (errno != EAGAIN && errno != EINTR) -#endif - ) + res= send(fd, buf, size, IF_WIN(0, MSG_DONTWAIT)); + if (res >= 0 || IS_BLOCKING_ERROR()) return res; - b->ret_status= MYSQL_WAIT_WRITE; + b->events_to_wait_for= MYSQL_WAIT_WRITE; if (timeout) { - b->ret_status|= MYSQL_WAIT_TIMEOUT; + b->events_to_wait_for|= MYSQL_WAIT_TIMEOUT; b->timeout_value= timeout; } if (b->suspend_resume_hook) @@ -186,7 +159,7 @@ my_send_async(struct mysql_async_context *b, int fd, my_context_yield(&b->async_context); if (b->suspend_resume_hook) (*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data); - if (b->ret_status & MYSQL_WAIT_TIMEOUT) + if (b->events_occured & MYSQL_WAIT_TIMEOUT) return -1; } } @@ -195,41 +168,51 @@ my_send_async(struct mysql_async_context *b, int fd, my_bool my_poll_read_async(struct mysql_async_context *b, uint timeout) { - b->ret_status= MYSQL_WAIT_READ | MYSQL_WAIT_TIMEOUT; + b->events_to_wait_for= MYSQL_WAIT_READ | MYSQL_WAIT_TIMEOUT; b->timeout_value= timeout; if (b->suspend_resume_hook) (*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data); my_context_yield(&b->async_context); if (b->suspend_resume_hook) (*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data); - return (b->ret_status & MYSQL_WAIT_READ) ? 0 : 1; + return (b->events_occured & MYSQL_WAIT_READ) ? 0 : 1; } #ifdef HAVE_OPENSSL +static my_bool +my_ssl_async_check_result(int res, struct mysql_async_context *b, SSL *ssl) +{ + int ssl_err; + b->events_to_wait_for= 0; + if (res >= 0) + return 1; + ssl_err= SSL_get_error(ssl, res); + if (ssl_err == SSL_ERROR_WANT_READ) + b->events_to_wait_for|= MYSQL_WAIT_READ; + else if (ssl_err == SSL_ERROR_WANT_WRITE) + b->events_to_wait_for|= MYSQL_WAIT_WRITE; + else + return 1; + if (b->suspend_resume_hook) + (*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data); + my_context_yield(&b->async_context); + if (b->suspend_resume_hook) + (*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data); + return 0; +} + int my_ssl_read_async(struct mysql_async_context *b, SSL *ssl, void *buf, int size) { - int res, ssl_err; + int res; for (;;) { res= SSL_read(ssl, buf, size); - if (res >= 0) + if (my_ssl_async_check_result(res, b, ssl)) return res; - ssl_err= SSL_get_error(ssl, res); - if (ssl_err == SSL_ERROR_WANT_READ) - b->ret_status= MYSQL_WAIT_READ; - else if (ssl_err == SSL_ERROR_WANT_WRITE) - b->ret_status= MYSQL_WAIT_WRITE; - else - return res; - if (b->suspend_resume_hook) - (*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data); - my_context_yield(&b->async_context); - if (b->suspend_resume_hook) - (*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data); } } @@ -237,25 +220,13 @@ int my_ssl_write_async(struct mysql_async_context *b, SSL *ssl, const void *buf, int size) { - int res, ssl_err; + int res; for (;;) { res= SSL_write(ssl, buf, size); - if (res >= 0) + if (my_ssl_async_check_result(res, b, ssl)) return res; - ssl_err= SSL_get_error(ssl, res); - if (ssl_err == SSL_ERROR_WANT_READ) - b->ret_status= MYSQL_WAIT_READ; - else if (ssl_err == SSL_ERROR_WANT_WRITE) - b->ret_status= MYSQL_WAIT_WRITE; - else - return res; - if (b->suspend_resume_hook) - (*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data); - my_context_yield(&b->async_context); - if (b->suspend_resume_hook) - (*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data); } } #endif /* HAVE_OPENSSL */ @@ -263,12 +234,10 @@ my_ssl_write_async(struct mysql_async_context *b, SSL *ssl, unsigned int STDCALL mysql_get_timeout_value(const MYSQL *mysql) { - if (mysql->extension && mysql->extension->async_context) - return mysql->extension->async_context->timeout_value; - else - return 0; + return mysql->options.extension->async_context->timeout_value; } + /* Now create non-blocking definitions for all the calls that may block. @@ -279,184 +248,123 @@ mysql_get_timeout_value(const MYSQL *mysql) can continue a suspended operation. */ -#define MK_ASYNC_CALLS(call__, decl_args__, invoke_args__, cont_arg__, mysql_val__, parms_mysql_val__, parms_assign__, ret_type__, err_val__, ok_val__, extra1__) \ -static void \ -call__ ## _start_internal(void *d) \ -{ \ - struct call__ ## _params *parms; \ - ret_type__ ret; \ - struct mysql_async_context *b; \ - \ - parms= (struct call__ ## _params *)d; \ - b= (parms_mysql_val__)->extension->async_context; \ +#define MK_ASYNC_INTERNAL_BODY(call, invoke_args, mysql_val, ret_type, ok_val)\ + struct call ## _params *parms= (struct call ## _params *)d; \ + ret_type ret; \ + struct mysql_async_context *b= \ + (mysql_val)->options.extension->async_context; \ \ - ret= call__ invoke_args__; \ - b->ret_result. ok_val__ = ret; \ - b->ret_status= 0; \ -} \ -int STDCALL \ -call__ ## _start decl_args__ \ -{ \ + ret= call invoke_args; \ + b->ret_result. ok_val = ret; \ + b->events_to_wait_for= 0; + +#define MK_ASYNC_START_BODY(call, mysql_val, parms_assign, err_val, ok_val, extra1) \ int res; \ struct mysql_async_context *b; \ - struct call__ ## _params parms; \ + struct call ## _params parms; \ \ - extra1__ \ - if (!(b= mysql_get_async_context((mysql_val__)))) \ - { \ - *ret= err_val__; \ - return 0; \ - } \ - parms_assign__ \ + extra1 \ + b= mysql_val->options.extension->async_context; \ + parms_assign \ \ b->active= 1; \ - res= my_context_spawn(&b->async_context, call__ ## _start_internal, &parms);\ - b->active= 0; \ - if (res < 0) \ - { \ - set_mysql_error((mysql_val__), CR_OUT_OF_MEMORY, unknown_sqlstate); \ - b->suspended= 0; \ - *ret= err_val__; \ - return 0; \ - } \ - else if (res > 0) \ + res= my_context_spawn(&b->async_context, call ## _start_internal, &parms); \ + b->active= b->suspended= 0; \ + if (res > 0) \ { \ /* Suspended. */ \ b->suspended= 1; \ - return b->ret_status; \ + return b->events_to_wait_for; \ } \ - else \ + if (res < 0) \ { \ - /* Finished. */ \ - b->suspended= 0; \ - *ret= b->ret_result. ok_val__; \ - return 0; \ + set_mysql_error((mysql_val), CR_OUT_OF_MEMORY, unknown_sqlstate); \ + *ret= err_val; \ } \ -} \ -int STDCALL \ -call__ ## _cont(ret_type__ *ret, cont_arg__, int ready_status) \ -{ \ + else \ + *ret= b->ret_result. ok_val; \ + return 0; + +#define MK_ASYNC_CONT_BODY(mysql_val, err_val, ok_val) \ int res; \ - struct mysql_async_context *b; \ - \ - b= (mysql_val__)->extension->async_context; \ - if (!b || !b->suspended) \ + struct mysql_async_context *b= \ + (mysql_val)->options.extension->async_context; \ + if (!b->suspended) \ { \ - set_mysql_error((mysql_val__), CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);\ - *ret= err_val__; \ + set_mysql_error((mysql_val), CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate); \ + *ret= err_val; \ return 0; \ } \ \ b->active= 1; \ - b->ret_status= ready_status; \ + b->events_occured= ready_status; \ res= my_context_continue(&b->async_context); \ b->active= 0; \ + if (res > 0) \ + return b->events_to_wait_for; /* (Still) suspended */ \ + b->suspended= 0; \ if (res < 0) \ { \ - set_mysql_error((mysql_val__), CR_OUT_OF_MEMORY, unknown_sqlstate); \ - b->suspended= 0; \ - *ret= err_val__; \ - return 0; \ - } \ - else if (res > 0) \ - { \ - /* Suspended. */ \ - return b->ret_status; \ + set_mysql_error((mysql_val), CR_OUT_OF_MEMORY, unknown_sqlstate); \ + *ret= err_val; \ } \ else \ - { \ - /* Finished. */ \ - b->suspended= 0; \ - *ret= b->ret_result. ok_val__; \ - return 0; \ - } \ -} + *ret= b->ret_result. ok_val; /* Finished. */ \ + return 0; -#define MK_ASYNC_CALLS_VOID_RETURN(call__, decl_args__, invoke_args__, cont_arg__, mysql_val__, parms_mysql_val__, parms_assign__, extra1__) \ -static void \ -call__ ## _start_internal(void *d) \ -{ \ - struct call__ ## _params *parms; \ - struct mysql_async_context *b; \ - \ - parms= (struct call__ ## _params *)d; \ - b= (parms_mysql_val__)->extension->async_context; \ +#define MK_ASYNC_INTERNAL_BODY_VOID_RETURN(call, invoke_args, mysql_val) \ + struct call ## _params *parms= (struct call ## _params *)d; \ + struct mysql_async_context *b= \ + (mysql_val)->options.extension->async_context; \ \ - call__ invoke_args__; \ - b->ret_status= 0; \ -} \ -int STDCALL \ -call__ ## _start decl_args__ \ -{ \ + call invoke_args; \ + b->events_to_wait_for= 0; + +#define MK_ASYNC_START_BODY_VOID_RETURN(call, mysql_val, parms_assign, extra1)\ int res; \ struct mysql_async_context *b; \ - struct call__ ## _params parms; \ + struct call ## _params parms; \ \ - extra1__ \ - if (!(b= mysql_get_async_context((mysql_val__)))) \ - { \ - return 0; \ - } \ - parms_assign__ \ + extra1 \ + b= mysql_val->options.extension->async_context; \ + parms_assign \ \ b->active= 1; \ - res= my_context_spawn(&b->async_context, call__ ## _start_internal, &parms);\ - b->active= 0; \ - if (res < 0) \ - { \ - set_mysql_error((mysql_val__), CR_OUT_OF_MEMORY, unknown_sqlstate); \ - b->suspended= 0; \ - return 0; \ - } \ - else if (res > 0) \ + res= my_context_spawn(&b->async_context, call ## _start_internal, &parms); \ + b->active= b->suspended= 0; \ + if (res > 0) \ { \ /* Suspended. */ \ b->suspended= 1; \ - return b->ret_status; \ + return b->events_to_wait_for; \ } \ - else \ - { \ - /* Finished. */ \ - b->suspended= 0; \ - return 0; \ - } \ -} \ -int STDCALL \ -call__ ## _cont(cont_arg__, int ready_status) \ -{ \ + if (res < 0) \ + set_mysql_error((mysql_val), CR_OUT_OF_MEMORY, unknown_sqlstate); \ + return 0; + +#define MK_ASYNC_CONT_BODY_VOID_RETURN(mysql_val) \ int res; \ - struct mysql_async_context *b; \ - \ - b= (mysql_val__)->extension->async_context; \ - if (!b || !b->suspended) \ + struct mysql_async_context *b= \ + (mysql_val)->options.extension->async_context; \ + if (!b->suspended) \ { \ - set_mysql_error((mysql_val__), CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);\ + set_mysql_error((mysql_val), CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate); \ return 0; \ } \ \ b->active= 1; \ - b->ret_status= ready_status; \ + b->events_occured= ready_status; \ res= my_context_continue(&b->async_context); \ b->active= 0; \ + if (res > 0) \ + return b->events_to_wait_for; /* (Still) suspended */ \ + b->suspended= 0; \ if (res < 0) \ - { \ - set_mysql_error((mysql_val__), CR_OUT_OF_MEMORY, unknown_sqlstate); \ - b->suspended= 0; \ - return 0; \ - } \ - else if (res > 0) \ - { \ - /* Suspended. */ \ - return b->ret_status; \ - } \ - else \ - { \ - /* Finished. */ \ - b->suspended= 0; \ - return 0; \ - } \ -} + set_mysql_error((mysql_val), CR_OUT_OF_MEMORY, unknown_sqlstate); \ + return 0; + +/* Structure used to pass parameters from mysql_real_connect_start(). */ struct mysql_real_connect_params { MYSQL *mysql; const char *host; @@ -467,16 +375,26 @@ struct mysql_real_connect_params { const char *unix_socket; unsigned long client_flags; }; -MK_ASYNC_CALLS( +static void +mysql_real_connect_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_real_connect, - (MYSQL **ret, MYSQL *mysql, const char *host, const char *user, - const char *passwd, const char *db, unsigned int port, - const char *unix_socket, unsigned long client_flags), (parms->mysql, parms->host, parms->user, parms->passwd, parms->db, parms->port, parms->unix_socket, parms->client_flags), - MYSQL *mysql, - mysql, parms->mysql, + MYSQL *, + r_ptr) +} +int STDCALL +mysql_real_connect_start(MYSQL **ret, MYSQL *mysql, const char *host, + const char *user, const char *passwd, const char *db, + unsigned int port, const char *unix_socket, + unsigned long client_flags) +{ +MK_ASYNC_START_BODY( + mysql_real_connect, + mysql, { parms.mysql= mysql; parms.host= host; @@ -487,49 +405,84 @@ MK_ASYNC_CALLS( parms.unix_socket= unix_socket; parms.client_flags= client_flags; }, - MYSQL *, NULL, r_ptr, /* Nothing */) +} +int STDCALL +mysql_real_connect_cont(MYSQL **ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + NULL, + r_ptr) +} +/* Structure used to pass parameters from mysql_real_query_start(). */ struct mysql_real_query_params { MYSQL *mysql; const char *stmt_str; unsigned long length; }; -MK_ASYNC_CALLS( +static void +mysql_real_query_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_real_query, - (int *ret, MYSQL *mysql, const char *stmt_str, unsigned long length), (parms->mysql, parms->stmt_str, parms->length), - MYSQL *mysql, - mysql, parms->mysql, + int, + r_int) +} +int STDCALL +mysql_real_query_start(int *ret, MYSQL *mysql, const char *stmt_str, unsigned long length) +{ +MK_ASYNC_START_BODY( + mysql_real_query, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.stmt_str= stmt_str; parms.length= length; }, - int, 1, r_int, /* Nothing */) +} +int STDCALL +mysql_real_query_cont(int *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_fetch_row_start(). */ struct mysql_fetch_row_params { MYSQL_RES *result; }; -MK_ASYNC_CALLS( +static void +mysql_fetch_row_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_fetch_row, - (MYSQL_ROW *ret, MYSQL_RES *result), (parms->result), - MYSQL_RES *result, - result->handle, parms->result->handle, + MYSQL_ROW, + r_ptr) +} +int STDCALL +mysql_fetch_row_start(MYSQL_ROW *ret, MYSQL_RES *result) +{ +MK_ASYNC_START_BODY( + mysql_fetch_row, + result->handle, { WIN_SET_NONBLOCKING(result->handle) parms.result= result; }, - MYSQL_ROW, NULL, r_ptr, /* @@ -542,103 +495,191 @@ MK_ASYNC_CALLS( { *ret= mysql_fetch_row(result); return 0; - } -) + }) +} +int STDCALL +mysql_fetch_row_cont(MYSQL_ROW *ret, MYSQL_RES *result, int ready_status) +{ +MK_ASYNC_CONT_BODY( + result->handle, + NULL, + r_ptr) +} +/* Structure used to pass parameters from mysql_set_character_set_start(). */ struct mysql_set_character_set_params { MYSQL *mysql; const char *csname; }; -MK_ASYNC_CALLS( +static void +mysql_set_character_set_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_set_character_set, - (int *ret, MYSQL *mysql, const char *csname), (parms->mysql, parms->csname), - MYSQL *mysql, - mysql, parms->mysql, + int, + r_int) +} +int STDCALL +mysql_set_character_set_start(int *ret, MYSQL *mysql, const char *csname) +{ +MK_ASYNC_START_BODY( + mysql_set_character_set, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.csname= csname; }, - int, 1, r_int, /* Nothing */) +} +int STDCALL +mysql_set_character_set_cont(int *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_sekect_db_start(). */ struct mysql_select_db_params { MYSQL *mysql; const char *db; }; -MK_ASYNC_CALLS( +static void +mysql_select_db_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_select_db, - (int *ret, MYSQL *mysql, const char *db), (parms->mysql, parms->db), - MYSQL *mysql, - mysql, parms->mysql, + int, + r_int) +} +int STDCALL +mysql_select_db_start(int *ret, MYSQL *mysql, const char *db) +{ +MK_ASYNC_START_BODY( + mysql_select_db, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.db= db; }, - int, 1, r_int, /* Nothing */) +} +int STDCALL +mysql_select_db_cont(int *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_send_query_start(). */ struct mysql_send_query_params { MYSQL *mysql; const char *q; unsigned long length; }; -MK_ASYNC_CALLS( +static void +mysql_send_query_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_send_query, - (int *ret, MYSQL *mysql, const char *q, unsigned long length), (parms->mysql, parms->q, parms->length), - MYSQL *mysql, - mysql, parms->mysql, + int, + r_int) +} +int STDCALL +mysql_send_query_start(int *ret, MYSQL *mysql, const char *q, unsigned long length) +{ +MK_ASYNC_START_BODY( + mysql_send_query, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.q= q; parms.length= length; }, - int, 1, r_int, /* Nothing */) +} +int STDCALL +mysql_send_query_cont(int *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_store_result_start(). */ struct mysql_store_result_params { MYSQL *mysql; }; -MK_ASYNC_CALLS( +static void +mysql_store_result_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_store_result, - (MYSQL_RES **ret, MYSQL *mysql), (parms->mysql), - MYSQL *mysql, - mysql, parms->mysql, + MYSQL_RES *, + r_ptr) +} +int STDCALL +mysql_store_result_start(MYSQL_RES **ret, MYSQL *mysql) +{ +MK_ASYNC_START_BODY( + mysql_store_result, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; }, - MYSQL_RES *, NULL, r_ptr, /* Nothing */) +} +int STDCALL +mysql_store_result_cont(MYSQL_RES **ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + NULL, + r_ptr) +} +/* Structure used to pass parameters from mysql_free_result_start(). */ struct mysql_free_result_params { MYSQL_RES *result; }; -MK_ASYNC_CALLS_VOID_RETURN( +static void +mysql_free_result_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY_VOID_RETURN( mysql_free_result, - (MYSQL_RES *result), (parms->result), - MYSQL_RES *result, + parms->result->handle) +} +int STDCALL +mysql_free_result_start(MYSQL_RES *result) +{ +MK_ASYNC_START_BODY_VOID_RETURN( + mysql_free_result, result->handle, - parms->result->handle, { WIN_SET_NONBLOCKING(result->handle) parms.result= result; @@ -655,30 +696,49 @@ MK_ASYNC_CALLS_VOID_RETURN( mysql_free_result(result); return 0; }) +} +int STDCALL +mysql_free_result_cont(MYSQL_RES *result, int ready_status) +{ +MK_ASYNC_CONT_BODY_VOID_RETURN(result->handle) +} -struct mysql_pre_close_params { +/* Structure used to pass parameters from mysql_close_slow_part_start(). */ +struct mysql_close_slow_part_params { MYSQL *sock; }; /* We need special handling for mysql_close(), as the first part may block, while the last part needs to free our extra library context stack. - So we do the first part (mysql_pre_close()) non-blocking, but the last part - blocking. + So we do the first part (mysql_close_slow_part()) non-blocking, but the last + part blocking. */ -extern void mysql_pre_close(MYSQL *mysql); -MK_ASYNC_CALLS_VOID_RETURN( - mysql_pre_close, - (MYSQL *sock), +static void +mysql_close_slow_part_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY_VOID_RETURN( + mysql_close_slow_part, (parms->sock), - MYSQL *sock, + parms->sock) +} +int STDCALL +mysql_close_slow_part_start(MYSQL *sock) +{ +MK_ASYNC_START_BODY_VOID_RETURN( + mysql_close_slow_part, sock, - parms->sock, { WIN_SET_NONBLOCKING(sock) parms.sock= sock; }, /* Nothing */) +} +int STDCALL +mysql_close_slow_part_cont(MYSQL *sock, int ready_status) +{ +MK_ASYNC_CONT_BODY_VOID_RETURN(sock) +} int STDCALL mysql_close_start(MYSQL *sock) { @@ -687,7 +747,7 @@ mysql_close_start(MYSQL *sock) /* It is legitimate to have NULL sock argument, which will do nothing. */ if (sock) { - res= mysql_pre_close_start(sock); + res= mysql_close_slow_part_start(sock); /* If we need to block, return now and do the rest in mysql_close_cont(). */ if (res) return res; @@ -700,101 +760,41 @@ mysql_close_cont(MYSQL *sock, int ready_status) { int res; - res= mysql_pre_close_cont(sock, ready_status); + res= mysql_close_slow_part_cont(sock, ready_status); if (res) return res; mysql_close(sock); return 0; } -#ifdef USE_OLD_FUNCTIONS -struct mysql_connect_params { - MYSQL *mysql; - const char *host; - const char *user; - const char *passwd; -}; -MK_ASYNC_CALLS( - mysql_connect, - (MYSQL **ret, MYSQL *mysql, const char *host, const char *user, const char *passwd), - (parms->mysql, parms->host, parms->user, parms->passwd), - MYSQL *mysql, - mysql, - parms->mysql, - { - WIN_SET_NONBLOCKING(mysql) - parms.mysql= mysql; - parms.host= host; - parms.user= user; - parms.passwd= passwd; - }, - MYSQL *, - NULL, - r_ptr, - /* Nothing */) - -struct mysql_create_db_params { - MYSQL *mysql; - const char *DB; -}; -MK_ASYNC_CALLS( - mysql_create_db, - (int *ret, MYSQL *mysql, const char *DB), - (parms->mysql, parms->DB), - MYSQL *mysql, - mysql, - parms->mysql, - { - WIN_SET_NONBLOCKING(mysql) - parms.mysql= mysql; - parms.DB= DB; - }, - int, - 1, - r_int, - /* Nothing */) - -struct mysql_drop_db_params { - MYSQL *mysql; - const char *DB; -}; -MK_ASYNC_CALLS( - mysql_drop_db, - (int *ret, MYSQL *mysql, const char *DB), - (parms->mysql, parms->DB), - MYSQL *mysql, - mysql, - parms->mysql, - { - WIN_SET_NONBLOCKING(mysql) - parms.mysql= mysql; - parms.DB= DB; - }, - int, - 1, - r_int, - /* Nothing */) - -#endif - /* These following are not available inside the server (neither blocking or non-blocking). */ #ifndef MYSQL_SERVER +/* Structure used to pass parameters from mysql_change_user_start(). */ struct mysql_change_user_params { MYSQL *mysql; const char *user; const char *passwd; const char *db; }; -MK_ASYNC_CALLS( +static void +mysql_change_user_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_change_user, - (my_bool *ret, MYSQL *mysql, const char *user, const char *passwd, const char *db), (parms->mysql, parms->user, parms->passwd, parms->db), - MYSQL *mysql, - mysql, parms->mysql, + my_bool, + r_my_bool) +} +int STDCALL +mysql_change_user_start(my_bool *ret, MYSQL *mysql, const char *user, const char *passwd, const char *db) +{ +MK_ASYNC_START_BODY( + mysql_change_user, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; @@ -802,295 +802,549 @@ MK_ASYNC_CALLS( parms.passwd= passwd; parms.db= db; }, - my_bool, TRUE, r_my_bool, /* Nothing */) +} +int STDCALL +mysql_change_user_cont(my_bool *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + TRUE, + r_my_bool) +} +/* Structure used to pass parameters from mysql_query_start(). */ struct mysql_query_params { MYSQL *mysql; const char *q; }; -MK_ASYNC_CALLS( +static void +mysql_query_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_query, - (int *ret, MYSQL *mysql, const char *q), (parms->mysql, parms->q), - MYSQL *mysql, - mysql, parms->mysql, + int, + r_int) +} +int STDCALL +mysql_query_start(int *ret, MYSQL *mysql, const char *q) +{ +MK_ASYNC_START_BODY( + mysql_query, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.q= q; }, - int, 1, r_int, /* Nothing */) +} +int STDCALL +mysql_query_cont(int *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_shutdown_start(). */ struct mysql_shutdown_params { MYSQL *mysql; enum mysql_enum_shutdown_level shutdown_level; }; -MK_ASYNC_CALLS( +static void +mysql_shutdown_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_shutdown, - (int *ret, MYSQL *mysql, enum mysql_enum_shutdown_level shutdown_level), (parms->mysql, parms->shutdown_level), - MYSQL *mysql, - mysql, parms->mysql, + int, + r_int) +} +int STDCALL +mysql_shutdown_start(int *ret, MYSQL *mysql, enum mysql_enum_shutdown_level shutdown_level) +{ +MK_ASYNC_START_BODY( + mysql_shutdown, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.shutdown_level= shutdown_level; }, - int, 1, r_int, /* Nothing */) +} +int STDCALL +mysql_shutdown_cont(int *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_dump_debug_info_start(). */ struct mysql_dump_debug_info_params { MYSQL *mysql; }; -MK_ASYNC_CALLS( +static void +mysql_dump_debug_info_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_dump_debug_info, - (int *ret, MYSQL *mysql), (parms->mysql), - MYSQL *mysql, - mysql, parms->mysql, + int, + r_int) +} +int STDCALL +mysql_dump_debug_info_start(int *ret, MYSQL *mysql) +{ +MK_ASYNC_START_BODY( + mysql_dump_debug_info, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; }, - int, 1, r_int, /* Nothing */) +} +int STDCALL +mysql_dump_debug_info_cont(int *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_refresh_start(). */ struct mysql_refresh_params { MYSQL *mysql; unsigned int refresh_options; }; -MK_ASYNC_CALLS( +static void +mysql_refresh_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_refresh, - (int *ret, MYSQL *mysql, unsigned int refresh_options), (parms->mysql, parms->refresh_options), - MYSQL *mysql, - mysql, parms->mysql, + int, + r_int) +} +int STDCALL +mysql_refresh_start(int *ret, MYSQL *mysql, unsigned int refresh_options) +{ +MK_ASYNC_START_BODY( + mysql_refresh, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.refresh_options= refresh_options; }, - int, 1, r_int, /* Nothing */) +} +int STDCALL +mysql_refresh_cont(int *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_kill_start(). */ struct mysql_kill_params { MYSQL *mysql; unsigned long pid; }; -MK_ASYNC_CALLS( +static void +mysql_kill_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_kill, - (int *ret, MYSQL *mysql, unsigned long pid), (parms->mysql, parms->pid), - MYSQL *mysql, - mysql, parms->mysql, + int, + r_int) +} +int STDCALL +mysql_kill_start(int *ret, MYSQL *mysql, unsigned long pid) +{ +MK_ASYNC_START_BODY( + mysql_kill, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.pid= pid; }, - int, 1, r_int, /* Nothing */) +} +int STDCALL +mysql_kill_cont(int *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_set_server_option_start(). */ struct mysql_set_server_option_params { MYSQL *mysql; enum enum_mysql_set_option option; }; -MK_ASYNC_CALLS( +static void +mysql_set_server_option_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_set_server_option, - (int *ret, MYSQL *mysql, enum enum_mysql_set_option option), (parms->mysql, parms->option), - MYSQL *mysql, - mysql, parms->mysql, + int, + r_int) +} +int STDCALL +mysql_set_server_option_start(int *ret, MYSQL *mysql, + enum enum_mysql_set_option option) +{ +MK_ASYNC_START_BODY( + mysql_set_server_option, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.option= option; }, - int, 1, r_int, /* Nothing */) +} +int STDCALL +mysql_set_server_option_cont(int *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_ping_start(). */ struct mysql_ping_params { MYSQL *mysql; }; -MK_ASYNC_CALLS( +static void +mysql_ping_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_ping, - (int *ret, MYSQL *mysql), (parms->mysql), - MYSQL *mysql, - mysql, parms->mysql, + int, + r_int) +} +int STDCALL +mysql_ping_start(int *ret, MYSQL *mysql) +{ +MK_ASYNC_START_BODY( + mysql_ping, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; }, - int, 1, r_int, /* Nothing */) +} +int STDCALL +mysql_ping_cont(int *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_stat_start(). */ struct mysql_stat_params { MYSQL *mysql; }; -MK_ASYNC_CALLS( +static void +mysql_stat_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_stat, - (const char **ret, MYSQL *mysql), (parms->mysql), - MYSQL *mysql, - mysql, parms->mysql, + const char *, + r_const_ptr) +} +int STDCALL +mysql_stat_start(const char **ret, MYSQL *mysql) +{ +MK_ASYNC_START_BODY( + mysql_stat, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; }, - const char *, NULL, r_const_ptr, /* Nothing */) +} +int STDCALL +mysql_stat_cont(const char **ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + NULL, + r_const_ptr) +} +/* Structure used to pass parameters from mysql_list_dbs_start(). */ struct mysql_list_dbs_params { MYSQL *mysql; const char *wild; }; -MK_ASYNC_CALLS( +static void +mysql_list_dbs_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_list_dbs, - (MYSQL_RES **ret, MYSQL *mysql, const char *wild), (parms->mysql, parms->wild), - MYSQL *mysql, - mysql, parms->mysql, + MYSQL_RES *, + r_ptr) +} +int STDCALL +mysql_list_dbs_start(MYSQL_RES **ret, MYSQL *mysql, const char *wild) +{ +MK_ASYNC_START_BODY( + mysql_list_dbs, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.wild= wild; }, - MYSQL_RES *, NULL, r_ptr, /* Nothing */) +} +int STDCALL +mysql_list_dbs_cont(MYSQL_RES **ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + NULL, + r_ptr) +} +/* Structure used to pass parameters from mysql_list_tables_start(). */ struct mysql_list_tables_params { MYSQL *mysql; const char *wild; }; -MK_ASYNC_CALLS( +static void +mysql_list_tables_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_list_tables, - (MYSQL_RES **ret, MYSQL *mysql, const char *wild), (parms->mysql, parms->wild), - MYSQL *mysql, - mysql, parms->mysql, + MYSQL_RES *, + r_ptr) +} +int STDCALL +mysql_list_tables_start(MYSQL_RES **ret, MYSQL *mysql, const char *wild) +{ +MK_ASYNC_START_BODY( + mysql_list_tables, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.wild= wild; }, - MYSQL_RES *, NULL, r_ptr, /* Nothing */) +} +int STDCALL +mysql_list_tables_cont(MYSQL_RES **ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + NULL, + r_ptr) +} +/* Structure used to pass parameters from mysql_list_processes_start(). */ struct mysql_list_processes_params { MYSQL *mysql; }; -MK_ASYNC_CALLS( +static void +mysql_list_processes_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_list_processes, - (MYSQL_RES **ret, MYSQL *mysql), (parms->mysql), - MYSQL *mysql, - mysql, parms->mysql, + MYSQL_RES *, + r_ptr) +} +int STDCALL +mysql_list_processes_start(MYSQL_RES **ret, MYSQL *mysql) +{ +MK_ASYNC_START_BODY( + mysql_list_processes, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; }, - MYSQL_RES *, NULL, r_ptr, /* Nothing */) +} +int STDCALL +mysql_list_processes_cont(MYSQL_RES **ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + NULL, + r_ptr) +} +/* Structure used to pass parameters from mysql_list_fields_start(). */ struct mysql_list_fields_params { MYSQL *mysql; const char *table; const char *wild; }; -MK_ASYNC_CALLS( +static void +mysql_list_fields_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_list_fields, - (MYSQL_RES **ret, MYSQL *mysql, const char *table, const char *wild), (parms->mysql, parms->table, parms->wild), - MYSQL *mysql, - mysql, parms->mysql, + MYSQL_RES *, + r_ptr) +} +int STDCALL +mysql_list_fields_start(MYSQL_RES **ret, MYSQL *mysql, const char *table, + const char *wild) +{ +MK_ASYNC_START_BODY( + mysql_list_fields, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.table= table; parms.wild= wild; }, - MYSQL_RES *, NULL, r_ptr, /* Nothing */) +} +int STDCALL +mysql_list_fields_cont(MYSQL_RES **ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + NULL, + r_ptr) +} +/* Structure used to pass parameters from mysql_read_query_result_start(). */ struct mysql_read_query_result_params { MYSQL *mysql; }; -MK_ASYNC_CALLS( +static void +mysql_read_query_result_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_read_query_result, - (my_bool *ret, MYSQL *mysql), (parms->mysql), - MYSQL *mysql, - mysql, parms->mysql, + my_bool, + r_my_bool) +} +int STDCALL +mysql_read_query_result_start(my_bool *ret, MYSQL *mysql) +{ +MK_ASYNC_START_BODY( + mysql_read_query_result, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; }, - my_bool, TRUE, r_my_bool, /* Nothing */) +} +int STDCALL +mysql_read_query_result_cont(my_bool *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + TRUE, + r_my_bool) +} +/* Structure used to pass parameters from mysql_stmt_prepare_start(). */ struct mysql_stmt_prepare_params { MYSQL_STMT *stmt; const char *query; unsigned long length; }; -MK_ASYNC_CALLS( +static void +mysql_stmt_prepare_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_stmt_prepare, - (int *ret, MYSQL_STMT *stmt, const char *query, unsigned long length), (parms->stmt, parms->query, parms->length), - MYSQL_STMT *stmt, - stmt->mysql, parms->stmt->mysql, + int, + r_int) +} +int STDCALL +mysql_stmt_prepare_start(int *ret, MYSQL_STMT *stmt, const char *query, + unsigned long length) +{ +MK_ASYNC_START_BODY( + mysql_stmt_prepare, + stmt->mysql, { WIN_SET_NONBLOCKING(stmt->mysql) parms.stmt= stmt; parms.query= query; parms.length= length; }, - int, 1, r_int, /* If stmt->mysql==NULL then we will not block so can call directly. */ @@ -1099,22 +1353,40 @@ MK_ASYNC_CALLS( *ret= mysql_stmt_prepare(stmt, query, length); return 0; }) +} +int STDCALL +mysql_stmt_prepare_cont(int *ret, MYSQL_STMT *stmt, int ready_status) +{ +MK_ASYNC_CONT_BODY( + stmt->mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_stmt_execute_start(). */ struct mysql_stmt_execute_params { MYSQL_STMT *stmt; }; -MK_ASYNC_CALLS( +static void +mysql_stmt_execute_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_stmt_execute, - (int *ret, MYSQL_STMT *stmt), (parms->stmt), - MYSQL_STMT *stmt, - stmt->mysql, parms->stmt->mysql, + int, + r_int) +} +int STDCALL +mysql_stmt_execute_start(int *ret, MYSQL_STMT *stmt) +{ +MK_ASYNC_START_BODY( + mysql_stmt_execute, + stmt->mysql, { WIN_SET_NONBLOCKING(stmt->mysql) parms.stmt= stmt; }, - int, 1, r_int, /* @@ -1126,22 +1398,40 @@ MK_ASYNC_CALLS( *ret= mysql_stmt_execute(stmt); return 0; }) +} +int STDCALL +mysql_stmt_execute_cont(int *ret, MYSQL_STMT *stmt, int ready_status) +{ +MK_ASYNC_CONT_BODY( + stmt->mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_stmt_fetch_start(). */ struct mysql_stmt_fetch_params { MYSQL_STMT *stmt; }; -MK_ASYNC_CALLS( +static void +mysql_stmt_fetch_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_stmt_fetch, - (int *ret, MYSQL_STMT *stmt), (parms->stmt), - MYSQL_STMT *stmt, - stmt->mysql, parms->stmt->mysql, + int, + r_int) +} +int STDCALL +mysql_stmt_fetch_start(int *ret, MYSQL_STMT *stmt) +{ +MK_ASYNC_START_BODY( + mysql_stmt_fetch, + stmt->mysql, { WIN_SET_NONBLOCKING(stmt->mysql) parms.stmt= stmt; }, - int, 1, r_int, /* If stmt->mysql==NULL then we will not block so can call directly. */ @@ -1150,22 +1440,40 @@ MK_ASYNC_CALLS( *ret= mysql_stmt_fetch(stmt); return 0; }) +} +int STDCALL +mysql_stmt_fetch_cont(int *ret, MYSQL_STMT *stmt, int ready_status) +{ +MK_ASYNC_CONT_BODY( + stmt->mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_stmt_store_result_start(). */ struct mysql_stmt_store_result_params { MYSQL_STMT *stmt; }; -MK_ASYNC_CALLS( +static void +mysql_stmt_store_result_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_stmt_store_result, - (int *ret, MYSQL_STMT *stmt), (parms->stmt), - MYSQL_STMT *stmt, - stmt->mysql, parms->stmt->mysql, + int, + r_int) +} +int STDCALL +mysql_stmt_store_result_start(int *ret, MYSQL_STMT *stmt) +{ +MK_ASYNC_START_BODY( + mysql_stmt_store_result, + stmt->mysql, { WIN_SET_NONBLOCKING(stmt->mysql) parms.stmt= stmt; }, - int, 1, r_int, /* If stmt->mysql==NULL then we will not block so can call directly. */ @@ -1174,22 +1482,40 @@ MK_ASYNC_CALLS( *ret= mysql_stmt_store_result(stmt); return 0; }) +} +int STDCALL +mysql_stmt_store_result_cont(int *ret, MYSQL_STMT *stmt, int ready_status) +{ +MK_ASYNC_CONT_BODY( + stmt->mysql, + 1, + r_int) +} +/* Structure used to pass parameters from mysql_stmt_close_start(). */ struct mysql_stmt_close_params { MYSQL_STMT *stmt; }; -MK_ASYNC_CALLS( +static void +mysql_stmt_close_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_stmt_close, - (my_bool *ret, MYSQL_STMT *stmt), (parms->stmt), - MYSQL_STMT *stmt, - stmt->mysql, parms->stmt->mysql, + my_bool, + r_my_bool) +} +int STDCALL +mysql_stmt_close_start(my_bool *ret, MYSQL_STMT *stmt) +{ +MK_ASYNC_START_BODY( + mysql_stmt_close, + stmt->mysql, { WIN_SET_NONBLOCKING(stmt->mysql) parms.stmt= stmt; }, - my_bool, TRUE, r_my_bool, /* If stmt->mysql==NULL then we will not block so can call directly. */ @@ -1198,22 +1524,40 @@ MK_ASYNC_CALLS( *ret= mysql_stmt_close(stmt); return 0; }) +} +int STDCALL +mysql_stmt_close_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status) +{ +MK_ASYNC_CONT_BODY( + stmt->mysql, + TRUE, + r_my_bool) +} +/* Structure used to pass parameters from mysql_stmt_reset_start(). */ struct mysql_stmt_reset_params { MYSQL_STMT *stmt; }; -MK_ASYNC_CALLS( +static void +mysql_stmt_reset_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_stmt_reset, - (my_bool *ret, MYSQL_STMT *stmt), (parms->stmt), - MYSQL_STMT *stmt, - stmt->mysql, parms->stmt->mysql, + my_bool, + r_my_bool) +} +int STDCALL +mysql_stmt_reset_start(my_bool *ret, MYSQL_STMT *stmt) +{ +MK_ASYNC_START_BODY( + mysql_stmt_reset, + stmt->mysql, { WIN_SET_NONBLOCKING(stmt->mysql) parms.stmt= stmt; }, - my_bool, TRUE, r_my_bool, /* If stmt->mysql==NULL then we will not block so can call directly. */ @@ -1222,22 +1566,40 @@ MK_ASYNC_CALLS( *ret= mysql_stmt_reset(stmt); return 0; }) +} +int STDCALL +mysql_stmt_reset_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status) +{ +MK_ASYNC_CONT_BODY( + stmt->mysql, + TRUE, + r_my_bool) +} +/* Structure used to pass parameters from mysql_stmt_free_result_start(). */ struct mysql_stmt_free_result_params { MYSQL_STMT *stmt; }; -MK_ASYNC_CALLS( +static void +mysql_stmt_free_result_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_stmt_free_result, - (my_bool *ret, MYSQL_STMT *stmt), (parms->stmt), - MYSQL_STMT *stmt, - stmt->mysql, parms->stmt->mysql, + my_bool, + r_my_bool) +} +int STDCALL +mysql_stmt_free_result_start(my_bool *ret, MYSQL_STMT *stmt) +{ +MK_ASYNC_START_BODY( + mysql_stmt_free_result, + stmt->mysql, { WIN_SET_NONBLOCKING(stmt->mysql) parms.stmt= stmt; }, - my_bool, TRUE, r_my_bool, /* If stmt->mysql==NULL then we will not block so can call directly. */ @@ -1246,20 +1608,41 @@ MK_ASYNC_CALLS( *ret= mysql_stmt_free_result(stmt); return 0; }) +} +int STDCALL +mysql_stmt_free_result_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status) +{ +MK_ASYNC_CONT_BODY( + stmt->mysql, + TRUE, + r_my_bool) +} +/* Structure used to pass parameters from mysql_stmt_send_long_data_start(). */ struct mysql_stmt_send_long_data_params { MYSQL_STMT *stmt; unsigned int param_number; const char *data; unsigned long length; }; -MK_ASYNC_CALLS( +static void +mysql_stmt_send_long_data_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_stmt_send_long_data, - (my_bool *ret, MYSQL_STMT *stmt, unsigned int param_number, const char *data, unsigned long length), (parms->stmt, parms->param_number, parms->data, parms->length), - MYSQL_STMT *stmt, - stmt->mysql, parms->stmt->mysql, + my_bool, + r_my_bool) +} +int STDCALL +mysql_stmt_send_long_data_start(my_bool *ret, MYSQL_STMT *stmt, + unsigned int param_number, + const char *data, unsigned long length) +{ +MK_ASYNC_START_BODY( + mysql_stmt_send_long_data, + stmt->mysql, { WIN_SET_NONBLOCKING(stmt->mysql) parms.stmt= stmt; @@ -1267,7 +1650,6 @@ MK_ASYNC_CALLS( parms.data= data; parms.length= length; }, - my_bool, TRUE, r_my_bool, /* If stmt->mysql==NULL then we will not block so can call directly. */ @@ -1276,88 +1658,177 @@ MK_ASYNC_CALLS( *ret= mysql_stmt_send_long_data(stmt, param_number, data, length); return 0; }) +} +int STDCALL +mysql_stmt_send_long_data_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status) +{ +MK_ASYNC_CONT_BODY( + stmt->mysql, + TRUE, + r_my_bool) +} +/* Structure used to pass parameters from mysql_commit_start(). */ struct mysql_commit_params { MYSQL *mysql; }; -MK_ASYNC_CALLS( +static void +mysql_commit_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_commit, - (my_bool *ret, MYSQL *mysql), (parms->mysql), - MYSQL *mysql, - mysql, parms->mysql, + my_bool, + r_my_bool) +} +int STDCALL +mysql_commit_start(my_bool *ret, MYSQL *mysql) +{ +MK_ASYNC_START_BODY( + mysql_commit, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; }, - my_bool, TRUE, r_my_bool, /* Nothing */) +} +int STDCALL +mysql_commit_cont(my_bool *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + TRUE, + r_my_bool) +} +/* Structure used to pass parameters from mysql_rollback_start(). */ struct mysql_rollback_params { MYSQL *mysql; }; -MK_ASYNC_CALLS( +static void +mysql_rollback_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_rollback, - (my_bool *ret, MYSQL *mysql), (parms->mysql), - MYSQL *mysql, - mysql, parms->mysql, + my_bool, + r_my_bool) +} +int STDCALL +mysql_rollback_start(my_bool *ret, MYSQL *mysql) +{ +MK_ASYNC_START_BODY( + mysql_rollback, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; }, - my_bool, TRUE, r_my_bool, /* Nothing */) +} +int STDCALL +mysql_rollback_cont(my_bool *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + TRUE, + r_my_bool) +} +/* Structure used to pass parameters from mysql_autocommit_start(). */ struct mysql_autocommit_params { MYSQL *mysql; my_bool auto_mode; }; -MK_ASYNC_CALLS( +static void +mysql_autocommit_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_autocommit, - (my_bool *ret, MYSQL *mysql, my_bool auto_mode), (parms->mysql, parms->auto_mode), - MYSQL *mysql, - mysql, parms->mysql, + my_bool, + r_my_bool) +} +int STDCALL +mysql_autocommit_start(my_bool *ret, MYSQL *mysql, my_bool auto_mode) +{ +MK_ASYNC_START_BODY( + mysql_autocommit, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; parms.auto_mode= auto_mode; }, - my_bool, TRUE, r_my_bool, /* Nothing */) +} +int STDCALL +mysql_autocommit_cont(my_bool *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + TRUE, + r_my_bool) +} +/* Structure used to pass parameters from mysql_next_result_start(). */ struct mysql_next_result_params { MYSQL *mysql; }; -MK_ASYNC_CALLS( +static void +mysql_next_result_start_internal(void *d) +{ +MK_ASYNC_INTERNAL_BODY( mysql_next_result, - (int *ret, MYSQL *mysql), (parms->mysql), - MYSQL *mysql, - mysql, parms->mysql, + int, + r_int) +} +int STDCALL +mysql_next_result_start(int *ret, MYSQL *mysql) +{ +MK_ASYNC_START_BODY( + mysql_next_result, + mysql, { WIN_SET_NONBLOCKING(mysql) parms.mysql= mysql; }, - int, 1, r_int, /* Nothing */) +} +int STDCALL +mysql_next_result_cont(int *ret, MYSQL *mysql, int ready_status) +{ +MK_ASYNC_CONT_BODY( + mysql, + 1, + r_int) +} #endif /* + The following functions are deprecated, and so have no non-blocking version: + + mysql_connect + mysql_create_db + mysql_drop_db +*/ + +/* The following functions can newer block, and so do not have special non-blocking versions: |