diff options
Diffstat (limited to 'libmysql/libmysql.c')
| -rw-r--r-- | libmysql/libmysql.c | 1163 |
1 files changed, 782 insertions, 381 deletions
diff --git a/libmysql/libmysql.c b/libmysql/libmysql.c index e963c0e429c..304c20132ff 100644 --- a/libmysql/libmysql.c +++ b/libmysql/libmysql.c @@ -92,7 +92,7 @@ my_bool net_flush(NET *net); #define unsigned_field(A) ((A)->flags & UNSIGNED_FLAG) static void append_wild(char *to,char *end,const char *wild); -sig_handler pipe_sig_handler(int sig); +sig_handler my_pipe_sig_handler(int sig); static my_bool mysql_client_init= 0; static my_bool org_my_init_done= 0; @@ -175,18 +175,24 @@ void STDCALL mysql_server_end() #ifdef EMBEDDED_LIBRARY end_embedded_server(); #endif + finish_client_errs(); + vio_end(); + /* If library called my_init(), free memory allocated by it */ if (!org_my_init_done) { - my_end(0); + my_end(MY_DONT_FREE_DBUG); #ifndef THREAD /* Remove TRACING, if enabled by mysql_debug() */ DBUG_POP(); #endif } else + { + free_charsets(); mysql_thread_end(); - free_charsets(); + } + mysql_client_init= org_my_init_done= 0; #ifdef EMBEDDED_SERVER if (stderror_file) @@ -301,11 +307,11 @@ mysql_debug(const char *debug __attribute__((unused))) **************************************************************************/ sig_handler -pipe_sig_handler(int sig __attribute__((unused))) +my_pipe_sig_handler(int sig __attribute__((unused))) { DBUG_PRINT("info",("Hit by signal %d",sig)); #ifdef DONT_REMEMBER_SIGNAL - (void) signal(SIGPIPE,pipe_sig_handler); + (void) signal(SIGPIPE, my_pipe_sig_handler); #endif } @@ -326,6 +332,7 @@ my_bool STDCALL mysql_master_send_query(MYSQL *mysql, const char *q, DBUG_ENTER("mysql_master_send_query"); if (!master->net.vio && !mysql_real_connect(master,0,0,0,0,0,0,0)) DBUG_RETURN(1); + master->reconnect= 1; mysql->last_used_con = master; DBUG_RETURN(simple_command(master, COM_QUERY, q, length, 1)); } @@ -360,6 +367,7 @@ my_bool STDCALL mysql_slave_send_query(MYSQL *mysql, const char *q, if (!slave_to_use->net.vio && !mysql_real_connect(slave_to_use, 0,0,0, 0,0,0,0)) DBUG_RETURN(1); + slave_to_use->reconnect= 1; DBUG_RETURN(simple_command(slave_to_use, COM_QUERY, q, length, 1)); } @@ -457,6 +465,7 @@ static my_bool get_slaves_from_master(MYSQL* mysql) expand_error(mysql, CR_PROBE_MASTER_CONNECT); DBUG_RETURN(1); } + mysql->reconnect= 1; if (mysql_query(mysql, "SHOW SLAVE HOSTS") || !(res = mysql_store_result(mysql))) @@ -624,6 +633,7 @@ mysql_connect(MYSQL *mysql,const char *host, if (mysql->free_me) my_free((gptr) mysql,MYF(0)); } + mysql->reconnect= 1; DBUG_RETURN(res); } } @@ -639,7 +649,7 @@ int cli_read_change_user_result(MYSQL *mysql, char *buff, const char *passwd) NET *net= &mysql->net; ulong pkt_length; - pkt_length= net_safe_read(mysql); + pkt_length= cli_safe_read(mysql); if (pkt_length == packet_error) return 1; @@ -660,7 +670,7 @@ int cli_read_change_user_result(MYSQL *mysql, char *buff, const char *passwd) return 1; } /* Read what server thinks about out new auth message report */ - if (net_safe_read(mysql) == packet_error) + if (cli_safe_read(mysql) == packet_error) return 1; } return 0; @@ -813,7 +823,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)) { - my_net_write(net,"",0); /* Server needs one packet */ + VOID(my_net_write(net,"",0)); /* Server needs one packet */ net_flush(net); strmov(net->sqlstate, unknown_sqlstate); net->last_errno= (*options->local_infile_error)(li_ptr, @@ -1119,25 +1129,6 @@ mysql_fetch_field(MYSQL_RES *result) /************************************************************************** - Get column lengths of the current row - If one uses mysql_use_result, res->lengths contains the length information, - else the lengths are calculated from the offset between pointers. -**************************************************************************/ - -ulong * STDCALL -mysql_fetch_lengths(MYSQL_RES *res) -{ - MYSQL_ROW column; - - if (!(column=res->current_row)) - return 0; /* Something is wrong */ - if (res->data) - (*res->methods->fetch_lengths)(res->lengths, column, res->field_count); - return res->lengths; -} - - -/************************************************************************** Move to a specific row and column **************************************************************************/ @@ -1384,8 +1375,12 @@ mysql_stat(MYSQL *mysql) int STDCALL mysql_ping(MYSQL *mysql) { + int res; DBUG_ENTER("mysql_ping"); - DBUG_RETURN(simple_command(mysql,COM_PING,0,0,0)); + res= simple_command(mysql,COM_PING,0,0,0); + if (res == CR_SERVER_LOST && mysql->reconnect) + res= simple_command(mysql,COM_PING,0,0,0); + DBUG_RETURN(res); } @@ -1396,35 +1391,6 @@ mysql_get_server_info(MYSQL *mysql) } -/* - Get version number for server in a form easy to test on - - SYNOPSIS - mysql_get_server_version() - mysql Connection - - EXAMPLE - 4.1.0-alfa -> 40100 - - NOTES - We will ensure that a newer server always has a bigger number. - - RETURN - Signed number > 323000 -*/ - -ulong STDCALL -mysql_get_server_version(MYSQL *mysql) -{ - uint major, minor, version; - char *pos= mysql->server_version, *end_pos; - major= (uint) strtoul(pos, &end_pos, 10); pos=end_pos+1; - minor= (uint) strtoul(pos, &end_pos, 10); pos=end_pos+1; - version= (uint) strtoul(pos, &end_pos, 10); - return (ulong) major*10000L+(ulong) (minor*100+version); -} - - const char * STDCALL mysql_get_host_info(MYSQL *mysql) { @@ -1516,44 +1482,22 @@ const char * STDCALL mysql_character_set_name(MYSQL *mysql) return mysql->charset->csname; } - -int STDCALL mysql_set_character_set(MYSQL *mysql, const char *cs_name) +void STDCALL mysql_get_character_set_info(MYSQL *mysql, MY_CHARSET_INFO *csinfo) { - struct charset_info_st *cs; - const char *save_csdir= charsets_dir; + csinfo->number = mysql->charset->number; + csinfo->state = mysql->charset->state; + csinfo->csname = mysql->charset->csname; + csinfo->name = mysql->charset->name; + csinfo->comment = mysql->charset->comment; + csinfo->mbminlen = mysql->charset->mbminlen; + csinfo->mbmaxlen = mysql->charset->mbmaxlen; if (mysql->options.charset_dir) - charsets_dir= mysql->options.charset_dir; - - if (strlen(cs_name) < MY_CS_NAME_SIZE && - (cs= get_charset_by_csname(cs_name, MY_CS_PRIMARY, MYF(0)))) - { - char buff[MY_CS_NAME_SIZE + 10]; - charsets_dir= save_csdir; - /* Skip execution of "SET NAMES" for pre-4.1 servers */ - if (mysql_get_server_version(mysql) < 40100) - return 0; - sprintf(buff, "SET NAMES %s", cs_name); - if (!mysql_query(mysql, buff)) - { - mysql->charset= cs; - } - } + csinfo->dir = mysql->options.charset_dir; else - { - char cs_dir_name[FN_REFLEN]; - get_charsets_dir(cs_dir_name); - mysql->net.last_errno= CR_CANT_READ_CHARSET; - strmov(mysql->net.sqlstate, unknown_sqlstate); - my_snprintf(mysql->net.last_error, sizeof(mysql->net.last_error) - 1, - ER(mysql->net.last_errno), cs_name, cs_dir_name); - - } - charsets_dir= save_csdir; - return mysql->net.last_errno; + csinfo->dir = charsets_dir; } - uint STDCALL mysql_thread_safe(void) { #ifdef THREAD @@ -1634,14 +1578,16 @@ mysql_hex_string(char *to, const char *from, ulong length) ulong STDCALL mysql_escape_string(char *to,const char *from,ulong length) { - return escape_string_for_mysql(default_charset_info, to, from, length); + return escape_string_for_mysql(default_charset_info, to, 0, from, length); } ulong STDCALL mysql_real_escape_string(MYSQL *mysql, char *to,const char *from, ulong length) { - return escape_string_for_mysql(mysql->charset, to, from, length); + if (mysql->server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES) + return escape_quotes_for_mysql(mysql->charset, to, 0, from, length); + return escape_string_for_mysql(mysql->charset, to, 0, from, length); } @@ -1761,6 +1707,9 @@ myodbc_remove_escape(MYSQL *mysql,char *name) /******************* Declarations ***********************************/ +/* Default number of rows fetched per one COM_STMT_FETCH command. */ + +#define DEFAULT_PREFETCH_ROWS (ulong) 1 /* These functions are called by function pointer MYSQL_STMT::read_row_func. @@ -1772,13 +1721,24 @@ myodbc_remove_escape(MYSQL *mysql,char *name) static int stmt_read_row_unbuffered(MYSQL_STMT *stmt, unsigned char **row); static int stmt_read_row_buffered(MYSQL_STMT *stmt, unsigned char **row); +static int stmt_read_row_from_cursor(MYSQL_STMT *stmt, unsigned char **row); static int stmt_read_row_no_data(MYSQL_STMT *stmt, unsigned char **row); +static int stmt_read_row_no_result_set(MYSQL_STMT *stmt, unsigned char **row); /* This function is used in mysql_stmt_store_result if STMT_ATTR_UPDATE_MAX_LENGTH attribute is set. */ static void stmt_update_metadata(MYSQL_STMT *stmt, MYSQL_ROWS *data); +static my_bool setup_one_fetch_function(MYSQL_BIND *bind, MYSQL_FIELD *field); + +/* Auxilary function used to reset statement handle. */ + +#define RESET_SERVER_SIDE 1 +#define RESET_LONG_DATA 2 +#define RESET_STORE_RESULT 4 + +static my_bool reset_stmt_handle(MYSQL_STMT *stmt, uint flags); /* Maximum sizes of MYSQL_TYPE_DATE, MYSQL_TYPE_TIME, MYSQL_TYPE_DATETIME @@ -1802,6 +1762,20 @@ static void stmt_update_metadata(MYSQL_STMT *stmt, MYSQL_ROWS *data); #define MAX_DOUBLE_STRING_REP_LENGTH 331 +/* A macro to check truncation errors */ + +#define IS_TRUNCATED(value, is_unsigned, min, max, umax) \ + ((is_unsigned) ? (((value) > (umax) || (value) < 0) ? 1 : 0) : \ + (((value) > (max) || (value) < (min)) ? 1 : 0)) + +#define BIND_RESULT_DONE 1 +/* + We report truncations only if at least one of MYSQL_BIND::error + pointers is set. In this case stmt->bind_result_done |-ed with + this flag. +*/ +#define REPORT_DATA_TRUNCATION 2 + /**************** Misc utility functions ****************************/ /* @@ -1845,7 +1819,6 @@ static void net_clear_error(NET *net) } } - static void stmt_clear_error(MYSQL_STMT *stmt) { if (stmt->last_errno) @@ -1896,7 +1869,7 @@ void set_stmt_errmsg(MYSQL_STMT * stmt, const char *err, int errcode, } /* - Read and unpack server reply to COM_PREPARE command (sent from + Read and unpack server reply to COM_STMT_PREPARE command (sent from mysql_stmt_prepare). SYNOPSIS @@ -1913,12 +1886,14 @@ my_bool cli_read_prepare_result(MYSQL *mysql, MYSQL_STMT *stmt) { uchar *pos; uint field_count, param_count; + ulong packet_length; MYSQL_DATA *fields_data; - DBUG_ENTER("read_prepare_result"); + DBUG_ENTER("cli_read_prepare_result"); mysql= mysql->last_used_con; - if (net_safe_read(mysql) == packet_error) + if ((packet_length= cli_safe_read(mysql)) == packet_error) DBUG_RETURN(1); + mysql->warning_count= 0; pos= (uchar*) mysql->net.read_pos; stmt->stmt_id= uint4korr(pos+1); pos+= 5; @@ -1926,6 +1901,8 @@ my_bool cli_read_prepare_result(MYSQL *mysql, MYSQL_STMT *stmt) field_count= uint2korr(pos); pos+= 2; /* Number of placeholders in the statement */ param_count= uint2korr(pos); pos+= 2; + if (packet_length >= 12) + mysql->warning_count= uint2korr(pos+1); if (param_count != 0) { @@ -1942,7 +1919,6 @@ my_bool cli_read_prepare_result(MYSQL *mysql, MYSQL_STMT *stmt) if (!(mysql->server_status & SERVER_STATUS_AUTOCOMMIT)) mysql->server_status|= SERVER_STATUS_IN_TRANS; - mysql->extra_info= net_field_length_ll(&pos); if (!(fields_data= (*mysql->methods->read_rows)(mysql,(MYSQL_FIELD*)0,7))) DBUG_RETURN(1); if (!(stmt->fields= unpack_fields(fields_data,&stmt->mem_root, @@ -1950,9 +1926,10 @@ my_bool cli_read_prepare_result(MYSQL *mysql, MYSQL_STMT *stmt) mysql->server_capabilities))) DBUG_RETURN(1); } - stmt->field_count= (uint) field_count; + stmt->field_count= field_count; stmt->param_count= (ulong) param_count; - mysql->warning_count= 0; + DBUG_PRINT("exit",("field_count: %u param_count: %u warning_count: %u", + field_count, param_count, (uint) mysql->warning_count)); DBUG_RETURN(0); } @@ -2009,7 +1986,9 @@ mysql_stmt_init(MYSQL *mysql) stmt->list.data= stmt; stmt->state= MYSQL_STMT_INIT_DONE; stmt->mysql= mysql; - stmt->read_row_func= stmt_read_row_no_data; + stmt->read_row_func= stmt_read_row_no_result_set; + stmt->prefetch_rows= DEFAULT_PREFETCH_ROWS; + strmov(stmt->sqlstate, not_error_sqlstate); /* The rest of statement members was bzeroed inside malloc */ DBUG_RETURN(stmt); @@ -2068,7 +2047,8 @@ mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query, ulong length) /* This is second prepare with another statement */ char buff[MYSQL_STMT_HEADER]; /* 4 bytes - stmt id */ - mysql_stmt_free_result(stmt); + if (reset_stmt_handle(stmt, RESET_LONG_DATA | RESET_STORE_RESULT)) + DBUG_RETURN(1); /* These members must be reset for API to function in case of error or misuse. @@ -2085,7 +2065,7 @@ mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query, ulong length) mysql_use_result it won't be freed in mysql_stmt_free_result and we should get 'Commands out of sync' here. */ - if (stmt_command(mysql, COM_CLOSE_STMT, buff, 4, stmt)) + if (stmt_command(mysql, COM_STMT_CLOSE, buff, 4, stmt)) { set_stmt_errmsg(stmt, mysql->net.last_error, mysql->net.last_errno, mysql->net.sqlstate); @@ -2094,7 +2074,7 @@ mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query, ulong length) stmt->state= MYSQL_STMT_INIT_DONE; } - if (stmt_command(mysql, COM_PREPARE, query, length, stmt)) + if (stmt_command(mysql, COM_STMT_PREPARE, query, length, stmt)) { set_stmt_errmsg(stmt, mysql->net.last_error, mysql->net.last_errno, mysql->net.sqlstate); @@ -2124,7 +2104,7 @@ mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query, ulong length) } stmt->bind= stmt->params + stmt->param_count; stmt->state= MYSQL_STMT_PREPARE_DONE; - DBUG_PRINT("info", ("Parameter count: %ld", stmt->param_count)); + DBUG_PRINT("info", ("Parameter count: %u", stmt->param_count)); DBUG_RETURN(0); } @@ -2178,7 +2158,7 @@ static unsigned int alloc_stmt_fields(MYSQL_STMT *stmt) /* Update result set columns metadata if it was sent again in - reply to COM_EXECUTE. + reply to COM_STMT_EXECUTE. */ static void update_stmt_fields(MYSQL_STMT *stmt) @@ -2186,6 +2166,7 @@ static void update_stmt_fields(MYSQL_STMT *stmt) MYSQL_FIELD *field= stmt->mysql->fields; MYSQL_FIELD *field_end= field + stmt->field_count; MYSQL_FIELD *stmt_field= stmt->fields; + MYSQL_BIND *bind= stmt->bind_result_done ? stmt->bind : 0; DBUG_ASSERT(stmt->field_count == stmt->mysql->field_count); @@ -2196,6 +2177,11 @@ static void update_stmt_fields(MYSQL_STMT *stmt) stmt_field->type = field->type; stmt_field->flags = field->flags; stmt_field->decimals = field->decimals; + if (bind) + { + /* Ignore return value: it should be 0 if bind_result succeeded. */ + (void) setup_one_fetch_function(bind++, stmt_field); + } } } @@ -2461,10 +2447,10 @@ static my_bool store_param(MYSQL_STMT *stmt, MYSQL_BIND *param) { NET *net= &stmt->mysql->net; DBUG_ENTER("store_param"); - DBUG_PRINT("enter",("type: %d, buffer:%lx, length: %lu is_null: %d", + DBUG_PRINT("enter",("type: %d buffer: 0x%lx length: %lu is_null: %d", param->buffer_type, - param->buffer ? param->buffer : "0", *param->length, - *param->is_null)); + (long) (param->buffer ? param->buffer : NullS), + *param->length, *param->is_null)); if (*param->is_null) store_param_null(net, param); @@ -2486,7 +2472,7 @@ static my_bool store_param(MYSQL_STMT *stmt, MYSQL_BIND *param) /* - Auxilary function to send COM_EXECUTE packet to server and read reply. + Auxilary function to send COM_STMT_EXECUTE packet to server and read reply. Used from cli_stmt_execute, which is in turn used by mysql_stmt_execute. */ @@ -2499,17 +2485,18 @@ static my_bool execute(MYSQL_STMT *stmt, char *packet, ulong length) my_bool res; DBUG_ENTER("execute"); - DBUG_PRINT("enter",("packet: %s, length :%d",packet ? packet :" ", length)); + DBUG_DUMP("packet", packet, length); mysql->last_used_con= mysql; int4store(buff, stmt->stmt_id); /* Send stmt id to server */ - buff[4]= (char) 0; /* no flags */ + buff[4]= (char) stmt->flags; int4store(buff+5, 1); /* iteration count */ - res= test(cli_advanced_command(mysql, COM_EXECUTE, buff, sizeof(buff), + res= test(cli_advanced_command(mysql, COM_STMT_EXECUTE, buff, sizeof(buff), packet, length, 1, NULL) || (*mysql->methods->read_query_result)(mysql)); stmt->affected_rows= mysql->affected_rows; + stmt->server_status= mysql->server_status; stmt->insert_id= mysql->insert_id; if (res) { @@ -2526,7 +2513,8 @@ int cli_stmt_execute(MYSQL_STMT *stmt) if (stmt->param_count) { - NET *net= &stmt->mysql->net; + MYSQL *mysql= stmt->mysql; + NET *net= &mysql->net; MYSQL_BIND *param, *param_end; char *param_data; ulong length; @@ -2538,7 +2526,8 @@ int cli_stmt_execute(MYSQL_STMT *stmt) set_stmt_error(stmt, CR_PARAMS_NOT_BOUND, unknown_sqlstate); DBUG_RETURN(1); } - if (stmt->mysql->status != MYSQL_STATUS_READY) + if (mysql->status != MYSQL_STATUS_READY || + mysql->server_status & SERVER_MORE_RESULTS_EXISTS) { set_stmt_error(stmt, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate); DBUG_RETURN(1); @@ -2685,6 +2674,59 @@ error: return rc; } + +/* + Fetch statement row using server side cursor. + + SYNOPSIS + stmt_read_row_from_cursor() + + RETURN VALUE + 0 success + 1 error + MYSQL_NO_DATA end of data +*/ + +static int +stmt_read_row_from_cursor(MYSQL_STMT *stmt, unsigned char **row) +{ + if (stmt->data_cursor) + return stmt_read_row_buffered(stmt, row); + if (stmt->server_status & SERVER_STATUS_LAST_ROW_SENT) + stmt->server_status &= ~SERVER_STATUS_LAST_ROW_SENT; + else + { + MYSQL *mysql= stmt->mysql; + NET *net= &mysql->net; + MYSQL_DATA *result= &stmt->result; + char buff[4 /* statement id */ + + 4 /* number of rows to fetch */]; + + free_root(&result->alloc, MYF(MY_KEEP_PREALLOC)); + result->data= NULL; + result->rows= 0; + /* Send row request to the server */ + int4store(buff, stmt->stmt_id); + int4store(buff + 4, stmt->prefetch_rows); /* number of rows to fetch */ + if ((*mysql->methods->advanced_command)(mysql, COM_STMT_FETCH, + buff, sizeof(buff), NullS, 0, + 1, NULL)) + { + set_stmt_errmsg(stmt, net->last_error, net->last_errno, net->sqlstate); + return 1; + } + if ((*mysql->methods->read_rows_from_cursor)(stmt)) + return 1; + stmt->server_status= mysql->server_status; + + stmt->data_cursor= result->data; + return stmt_read_row_buffered(stmt, row); + } + *row= 0; + return MYSQL_NO_DATA; +} + + /* Default read row function to not SIGSEGV in client in case of wrong sequence of API calls. @@ -2694,14 +2736,17 @@ static int stmt_read_row_no_data(MYSQL_STMT *stmt __attribute__((unused)), unsigned char **row __attribute__((unused))) { - if ((int) stmt->state < (int) MYSQL_STMT_PREPARE_DONE) - { - set_stmt_error(stmt, CR_NO_PREPARE_STMT, unknown_sqlstate); - return 1; - } return MYSQL_NO_DATA; } +static int +stmt_read_row_no_result_set(MYSQL_STMT *stmt __attribute__((unused)), + unsigned char **row __attribute__((unused))) +{ + set_stmt_error(stmt, CR_NO_RESULT_SET, unknown_sqlstate); + return 1; +} + /* Get/set statement attributes @@ -2726,10 +2771,30 @@ my_bool STDCALL mysql_stmt_attr_set(MYSQL_STMT *stmt, case STMT_ATTR_UPDATE_MAX_LENGTH: stmt->update_max_length= value ? *(const my_bool*) value : 0; break; + case STMT_ATTR_CURSOR_TYPE: + { + ulong cursor_type; + cursor_type= value ? *(ulong*) value : 0UL; + if (cursor_type > (ulong) CURSOR_TYPE_READ_ONLY) + goto err_not_implemented; + stmt->flags= cursor_type; + break; + } + case STMT_ATTR_PREFETCH_ROWS: + { + ulong prefetch_rows= value ? *(ulong*) value : DEFAULT_PREFETCH_ROWS; + if (value == 0) + return TRUE; + stmt->prefetch_rows= prefetch_rows; + break; + } default: - return TRUE; + goto err_not_implemented; } return FALSE; +err_not_implemented: + set_stmt_error(stmt, CR_NOT_IMPLEMENTED, unknown_sqlstate); + return TRUE; } @@ -2741,6 +2806,12 @@ my_bool STDCALL mysql_stmt_attr_get(MYSQL_STMT *stmt, case STMT_ATTR_UPDATE_MAX_LENGTH: *(unsigned long *) value= stmt->update_max_length; break; + case STMT_ATTR_CURSOR_TYPE: + *(ulong*) value= stmt->flags; + break; + case STMT_ATTR_PREFETCH_ROWS: + *(ulong*) value= stmt->prefetch_rows; + break; default: return TRUE; } @@ -2803,7 +2874,8 @@ int STDCALL mysql_stmt_execute(MYSQL_STMT *stmt) DBUG_RETURN(1); } - mysql_stmt_free_result(stmt); + if (reset_stmt_handle(stmt, RESET_STORE_RESULT)) + DBUG_RETURN(1); /* No need to check for stmt->state: if the statement wasn't prepared we'll get 'unknown statement handler' error from server. @@ -2833,7 +2905,7 @@ int STDCALL mysql_stmt_execute(MYSQL_STMT *stmt) - if data dictionary changed between prepare and execute, for example a table used in the query was altered. Note, that now (4.1.3) we always send metadata in reply to - COM_EXECUTE (even if it is not necessary), so either this or + COM_STMT_EXECUTE (even if it is not necessary), so either this or previous branch always works. TODO: send metadata only when it's really necessary and add a warning 'Metadata changed' when it's sent twice. @@ -2844,9 +2916,28 @@ int STDCALL mysql_stmt_execute(MYSQL_STMT *stmt) stmt->state= MYSQL_STMT_EXECUTE_DONE; if (stmt->field_count) { - stmt->mysql->unbuffered_fetch_owner= &stmt->unbuffered_fetch_cancelled; - stmt->unbuffered_fetch_cancelled= FALSE; - stmt->read_row_func= stmt_read_row_unbuffered; + if (stmt->server_status & SERVER_STATUS_CURSOR_EXISTS) + { + mysql->status= MYSQL_STATUS_READY; + stmt->read_row_func= stmt_read_row_from_cursor; + } + else if (stmt->flags & CURSOR_TYPE_READ_ONLY) + { + /* + This is a single-row result set, a result set with no rows, EXPLAIN, + SHOW VARIABLES, or some other command which either a) bypasses the + cursors framework in the server and writes rows directly to the + network or b) is more efficient if all (few) result set rows are + precached on client and server's resources are freed. + */ + DBUG_RETURN(mysql_stmt_store_result(stmt)); + } + else + { + stmt->mysql->unbuffered_fetch_owner= &stmt->unbuffered_fetch_cancelled; + stmt->unbuffered_fetch_cancelled= FALSE; + stmt->read_row_func= stmt_read_row_unbuffered; + } } DBUG_RETURN(0); } @@ -3160,8 +3251,11 @@ my_bool STDCALL mysql_stmt_bind_param(MYSQL_STMT *stmt, MYSQL_BIND *bind) case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_BLOB: + case MYSQL_TYPE_VARCHAR: case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_STRING: + case MYSQL_TYPE_DECIMAL: + case MYSQL_TYPE_NEWDECIMAL: param->store_param_func= store_param_str; /* For variable length types user must set either length or @@ -3239,8 +3333,8 @@ mysql_stmt_send_long_data(MYSQL_STMT *stmt, uint param_number, MYSQL_BIND *param; DBUG_ENTER("mysql_stmt_send_long_data"); DBUG_ASSERT(stmt != 0); - DBUG_PRINT("enter",("param no : %d, data : %lx, length : %ld", - param_number, data, length)); + DBUG_PRINT("enter",("param no: %d data: 0x%lx, length : %ld", + param_number, (long) data, length)); /* We only need to check for stmt->param_count, if it's not null @@ -3281,9 +3375,9 @@ mysql_stmt_send_long_data(MYSQL_STMT *stmt, uint param_number, Note that we don't get any ok packet from the server in this case This is intentional to save bandwidth. */ - if ((*mysql->methods->advanced_command)(mysql, COM_LONG_DATA, buff, - sizeof(buff), data, length, 1, - NULL)) + if ((*mysql->methods->advanced_command)(mysql, COM_STMT_SEND_LONG_DATA, + buff, sizeof(buff), data, + length, 1, NULL)) { set_stmt_errmsg(stmt, mysql->net.last_error, mysql->net.last_errno, mysql->net.sqlstate); @@ -3412,6 +3506,7 @@ static void fetch_string_with_conversion(MYSQL_BIND *param, char *value, { char *buffer= (char *)param->buffer; int err= 0; + char *endptr= value + length; /* This function should support all target buffer types: the rest @@ -3422,45 +3517,48 @@ static void fetch_string_with_conversion(MYSQL_BIND *param, char *value, break; case MYSQL_TYPE_TINY: { - uchar data= (uchar) my_strntol(&my_charset_latin1, value, length, 10, - NULL, &err); - *buffer= data; + longlong data= my_strtoll10(value, &endptr, &err); + *param->error= (IS_TRUNCATED(data, param->is_unsigned, + INT_MIN8, INT_MAX8, UINT_MAX8) || err > 0); + *buffer= (uchar) data; break; } case MYSQL_TYPE_SHORT: { - short data= (short) my_strntol(&my_charset_latin1, value, length, 10, - NULL, &err); - shortstore(buffer, data); + longlong data= my_strtoll10(value, &endptr, &err); + *param->error= (IS_TRUNCATED(data, param->is_unsigned, + INT_MIN16, INT_MAX16, UINT_MAX16) || err > 0); + shortstore(buffer, (short) data); break; } case MYSQL_TYPE_LONG: { - int32 data= (int32)my_strntol(&my_charset_latin1, value, length, 10, - NULL, &err); - longstore(buffer, data); + longlong data= my_strtoll10(value, &endptr, &err); + *param->error= (IS_TRUNCATED(data, param->is_unsigned, + INT_MIN32, INT_MAX32, UINT_MAX32) || err > 0); + longstore(buffer, (int32) data); break; } case MYSQL_TYPE_LONGLONG: { - longlong data= my_strntoll(&my_charset_latin1, value, length, 10, - NULL, &err); + longlong data= my_strtoll10(value, &endptr, &err); + *param->error= param->is_unsigned ? err != 0 : + (err > 0 || (err == 0 && data < 0)); longlongstore(buffer, data); break; } case MYSQL_TYPE_FLOAT: { - char *end_not_used; - float data = (float) my_strntod(&my_charset_latin1, value, length, - &end_not_used, &err); - floatstore(buffer, data); + double data= my_strntod(&my_charset_latin1, value, length, &endptr, &err); + float fdata= (float) data; + *param->error= (fdata != data) | test(err); + floatstore(buffer, fdata); break; } case MYSQL_TYPE_DOUBLE: { - char *end_not_used; - double data= my_strntod(&my_charset_latin1, value, length, &end_not_used, - &err); + double data= my_strntod(&my_charset_latin1, value, length, &endptr, &err); + *param->error= test(err); doublestore(buffer, data); break; } @@ -3468,6 +3566,7 @@ static void fetch_string_with_conversion(MYSQL_BIND *param, char *value, { MYSQL_TIME *tm= (MYSQL_TIME *)buffer; str_to_time(value, length, tm, &err); + *param->error= test(err); break; } case MYSQL_TYPE_DATE: @@ -3475,13 +3574,17 @@ static void fetch_string_with_conversion(MYSQL_BIND *param, char *value, case MYSQL_TYPE_TIMESTAMP: { MYSQL_TIME *tm= (MYSQL_TIME *)buffer; - str_to_datetime(value, length, tm, 0, &err); + (void) str_to_datetime(value, length, tm, TIME_FUZZY_DATE, &err); + *param->error= test(err) && (param->buffer_type == MYSQL_TYPE_DATE && + tm->time_type != MYSQL_TIMESTAMP_DATE); break; } case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_BLOB: + case MYSQL_TYPE_DECIMAL: + case MYSQL_TYPE_NEWDECIMAL: default: { /* @@ -3502,6 +3605,7 @@ static void fetch_string_with_conversion(MYSQL_BIND *param, char *value, copy_length= 0; if (copy_length < param->buffer_length) buffer[copy_length]= '\0'; + *param->error= copy_length > param->buffer_length; /* param->length will always contain length of entire column; number of copied bytes may be way different: @@ -3524,44 +3628,79 @@ static void fetch_string_with_conversion(MYSQL_BIND *param, char *value, */ static void fetch_long_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field, - longlong value) + longlong value, my_bool is_unsigned) { char *buffer= (char *)param->buffer; - uint field_is_unsigned= field->flags & UNSIGNED_FLAG; switch (param->buffer_type) { case MYSQL_TYPE_NULL: /* do nothing */ break; case MYSQL_TYPE_TINY: + *param->error= IS_TRUNCATED(value, param->is_unsigned, + INT_MIN8, INT_MAX8, UINT_MAX8); *(uchar *)param->buffer= (uchar) value; break; case MYSQL_TYPE_SHORT: - shortstore(buffer, value); + *param->error= IS_TRUNCATED(value, param->is_unsigned, + INT_MIN16, INT_MAX16, UINT_MAX16); + shortstore(buffer, (short) value); break; case MYSQL_TYPE_LONG: - longstore(buffer, value); + *param->error= IS_TRUNCATED(value, param->is_unsigned, + INT_MIN32, INT_MAX32, UINT_MAX32); + longstore(buffer, (int32) value); break; case MYSQL_TYPE_LONGLONG: longlongstore(buffer, value); + *param->error= param->is_unsigned != is_unsigned && value < 0; break; case MYSQL_TYPE_FLOAT: { - float data= field_is_unsigned ? (float) ulonglong2double(value) : - (float) value; + /* + We need to store data in the buffer before the truncation check to + workaround Intel FPU executive precision feature. + (See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=323 for details) + AFAIU it does not guarantee to work. + */ + float data; + if (is_unsigned) + data= (float) ulonglong2double(value); + else + data= (float) value; floatstore(buffer, data); + *param->error= is_unsigned ? + ((ulonglong) value) != ((ulonglong) (*(float*) buffer)) : + ((longlong) value) != ((longlong) (*(float*) buffer)); break; } case MYSQL_TYPE_DOUBLE: { - double data= field_is_unsigned ? ulonglong2double(value) : - (double) value; + double data; + if (is_unsigned) + data= ulonglong2double(value); + else + data= (double)value; doublestore(buffer, data); + *param->error= is_unsigned ? + ((ulonglong) value) != ((ulonglong) (*(double*) buffer)) : + ((longlong) value) != ((longlong) (*(double*) buffer)); + break; + } + case MYSQL_TYPE_TIME: + case MYSQL_TYPE_DATE: + case MYSQL_TYPE_TIMESTAMP: + case MYSQL_TYPE_DATETIME: + { + int error; + value= number_to_datetime(value, (MYSQL_TIME *) buffer, TIME_FUZZY_DATE, + &error); + *param->error= test(error); break; } default: { char buff[22]; /* Enough for longlong */ - char *end= longlong10_to_str(value, buff, field_is_unsigned ? 10: -10); + char *end= longlong10_to_str(value, buff, is_unsigned ? 10: -10); /* Resort to string conversion which supports all typecodes */ uint length= (uint) (end-buff); @@ -3578,7 +3717,6 @@ static void fetch_long_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field, } } - /* Convert double/float column to supplied buffer of any type. @@ -3595,29 +3733,73 @@ static void fetch_float_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field, double value, int width) { char *buffer= (char *)param->buffer; + double val64 = (value < 0 ? -floor(-value) : floor(value)); switch (param->buffer_type) { case MYSQL_TYPE_NULL: /* do nothing */ break; case MYSQL_TYPE_TINY: - *buffer= (uchar)value; + /* + We need to _store_ data in the buffer before the truncation check to + workaround Intel FPU executive precision feature. + (See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=323 for details) + Sic: AFAIU it does not guarantee to work. + */ + if (param->is_unsigned) + *buffer= (uint8) value; + else + *buffer= (int8) value; + *param->error= val64 != (param->is_unsigned ? (double)((uint8) *buffer) : + (double)((int8) *buffer)); break; case MYSQL_TYPE_SHORT: - shortstore(buffer, (short)value); + if (param->is_unsigned) + { + ushort data= (ushort) value; + shortstore(buffer, data); + } + else + { + short data= (short) value; + shortstore(buffer, data); + } + *param->error= val64 != (param->is_unsigned ? (double) (*(ushort*) buffer): + (double) (*(short*) buffer)); break; case MYSQL_TYPE_LONG: - longstore(buffer, (long)value); - break; + if (param->is_unsigned) + { + uint32 data= (uint32) value; + longstore(buffer, data); + } + else + { + int32 data= (int32) value; + longstore(buffer, data); + } + *param->error= val64 != (param->is_unsigned ? (double) (*(uint32*) buffer): + (double) (*(int32*) buffer)); + break; case MYSQL_TYPE_LONGLONG: - { - longlong val= (longlong) value; - longlongstore(buffer, val); + if (param->is_unsigned) + { + ulonglong data= (ulonglong) value; + longlongstore(buffer, data); + } + else + { + longlong data= (longlong) value; + longlongstore(buffer, data); + } + *param->error= val64 != (param->is_unsigned ? + ulonglong2double(*(ulonglong*) buffer) : + (double) (*(longlong*) buffer)); break; - } case MYSQL_TYPE_FLOAT: { float data= (float) value; floatstore(buffer, data); + *param->error= (*(float*) buffer) != value; break; } case MYSQL_TYPE_DOUBLE: @@ -3671,18 +3853,47 @@ static void fetch_float_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field, */ static void fetch_datetime_with_conversion(MYSQL_BIND *param, + MYSQL_FIELD *field, MYSQL_TIME *time) { switch (param->buffer_type) { case MYSQL_TYPE_NULL: /* do nothing */ break; case MYSQL_TYPE_DATE: + *(MYSQL_TIME *)(param->buffer)= *time; + *param->error= time->time_type != MYSQL_TIMESTAMP_DATE; + break; case MYSQL_TYPE_TIME: + *(MYSQL_TIME *)(param->buffer)= *time; + *param->error= time->time_type != MYSQL_TIMESTAMP_TIME; + break; case MYSQL_TYPE_DATETIME: case MYSQL_TYPE_TIMESTAMP: - /* XXX: should we copy only relevant members here? */ *(MYSQL_TIME *)(param->buffer)= *time; + /* No error: time and date are compatible with datetime */ + break; + case MYSQL_TYPE_YEAR: + shortstore(param->buffer, time->year); + *param->error= 1; + break; + case MYSQL_TYPE_FLOAT: + case MYSQL_TYPE_DOUBLE: + { + ulonglong value= TIME_to_ulonglong(time); + fetch_float_with_conversion(param, field, + ulonglong2double(value), DBL_DIG); + break; + } + case MYSQL_TYPE_TINY: + case MYSQL_TYPE_SHORT: + case MYSQL_TYPE_INT24: + case MYSQL_TYPE_LONG: + case MYSQL_TYPE_LONGLONG: + { + longlong value= (longlong) TIME_to_ulonglong(time); + fetch_long_with_conversion(param, field, value, TRUE); break; + } default: { /* @@ -3728,7 +3939,7 @@ static void fetch_result_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field, /* sic: we need to cast to 'signed char' as 'char' may be unsigned */ longlong data= field_is_unsigned ? (longlong) value : (longlong) (signed char) value; - fetch_long_with_conversion(param, field, data); + fetch_long_with_conversion(param, field, data, 0); *row+= 1; break; } @@ -3738,7 +3949,7 @@ static void fetch_result_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field, short value= sint2korr(*row); longlong data= field_is_unsigned ? (longlong) (unsigned short) value : (longlong) value; - fetch_long_with_conversion(param, field, data); + fetch_long_with_conversion(param, field, data, 0); *row+= 2; break; } @@ -3748,14 +3959,15 @@ static void fetch_result_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field, int32 value= sint4korr(*row); longlong data= field_is_unsigned ? (longlong) (uint32) value : (longlong) value; - fetch_long_with_conversion(param, field, data); + fetch_long_with_conversion(param, field, data, 0); *row+= 4; break; } case MYSQL_TYPE_LONGLONG: { longlong value= (longlong)sint8korr(*row); - fetch_long_with_conversion(param, field, value); + fetch_long_with_conversion(param, field, value, + field->flags & UNSIGNED_FLAG); *row+= 8; break; } @@ -3780,7 +3992,7 @@ static void fetch_result_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field, MYSQL_TIME tm; read_binary_date(&tm, row); - fetch_datetime_with_conversion(param, &tm); + fetch_datetime_with_conversion(param, field, &tm); break; } case MYSQL_TYPE_TIME: @@ -3788,7 +4000,7 @@ static void fetch_result_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field, MYSQL_TIME tm; read_binary_time(&tm, row); - fetch_datetime_with_conversion(param, &tm); + fetch_datetime_with_conversion(param, field, &tm); break; } case MYSQL_TYPE_DATETIME: @@ -3797,7 +4009,7 @@ static void fetch_result_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field, MYSQL_TIME tm; read_binary_datetime(&tm, row); - fetch_datetime_with_conversion(param, &tm); + fetch_datetime_with_conversion(param, field, &tm); break; } default: @@ -3830,34 +4042,51 @@ static void fetch_result_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field, none */ -static void fetch_result_tinyint(MYSQL_BIND *param, uchar **row) +static void fetch_result_tinyint(MYSQL_BIND *param, MYSQL_FIELD *field, + uchar **row) { - *(uchar *)param->buffer= **row; + my_bool field_is_unsigned= test(field->flags & UNSIGNED_FLAG); + uchar data= **row; + *(uchar *)param->buffer= data; + *param->error= param->is_unsigned != field_is_unsigned && data > INT_MAX8; (*row)++; } -static void fetch_result_short(MYSQL_BIND *param, uchar **row) +static void fetch_result_short(MYSQL_BIND *param, MYSQL_FIELD *field, + uchar **row) { - short value = (short)sint2korr(*row); - shortstore(param->buffer, value); + my_bool field_is_unsigned= test(field->flags & UNSIGNED_FLAG); + ushort data= (ushort) sint2korr(*row); + shortstore(param->buffer, data); + *param->error= param->is_unsigned != field_is_unsigned && data > INT_MAX16; *row+= 2; } -static void fetch_result_int32(MYSQL_BIND *param, uchar **row) +static void fetch_result_int32(MYSQL_BIND *param, + MYSQL_FIELD *field __attribute__((unused)), + uchar **row) { - int32 value= (int32)sint4korr(*row); - longstore(param->buffer, value); + my_bool field_is_unsigned= test(field->flags & UNSIGNED_FLAG); + uint32 data= (uint32) sint4korr(*row); + longstore(param->buffer, data); + *param->error= param->is_unsigned != field_is_unsigned && data > INT_MAX32; *row+= 4; } -static void fetch_result_int64(MYSQL_BIND *param, uchar **row) +static void fetch_result_int64(MYSQL_BIND *param, + MYSQL_FIELD *field __attribute__((unused)), + uchar **row) { - longlong value= (longlong)sint8korr(*row); - longlongstore(param->buffer, value); + my_bool field_is_unsigned= test(field->flags & UNSIGNED_FLAG); + ulonglong data= (ulonglong) sint8korr(*row); + *param->error= param->is_unsigned != field_is_unsigned && data > LONGLONG_MAX; + longlongstore(param->buffer, data); *row+= 8; } -static void fetch_result_float(MYSQL_BIND *param, uchar **row) +static void fetch_result_float(MYSQL_BIND *param, + MYSQL_FIELD *field __attribute__((unused)), + uchar **row) { float value; float4get(value,*row); @@ -3865,7 +4094,9 @@ static void fetch_result_float(MYSQL_BIND *param, uchar **row) *row+= 4; } -static void fetch_result_double(MYSQL_BIND *param, uchar **row) +static void fetch_result_double(MYSQL_BIND *param, + MYSQL_FIELD *field __attribute__((unused)), + uchar **row) { double value; float8get(value,*row); @@ -3873,34 +4104,45 @@ static void fetch_result_double(MYSQL_BIND *param, uchar **row) *row+= 8; } -static void fetch_result_time(MYSQL_BIND *param, uchar **row) +static void fetch_result_time(MYSQL_BIND *param, + MYSQL_FIELD *field __attribute__((unused)), + uchar **row) { MYSQL_TIME *tm= (MYSQL_TIME *)param->buffer; read_binary_time(tm, row); } -static void fetch_result_date(MYSQL_BIND *param, uchar **row) +static void fetch_result_date(MYSQL_BIND *param, + MYSQL_FIELD *field __attribute__((unused)), + uchar **row) { MYSQL_TIME *tm= (MYSQL_TIME *)param->buffer; read_binary_date(tm, row); } -static void fetch_result_datetime(MYSQL_BIND *param, uchar **row) +static void fetch_result_datetime(MYSQL_BIND *param, + MYSQL_FIELD *field __attribute__((unused)), + uchar **row) { MYSQL_TIME *tm= (MYSQL_TIME *)param->buffer; read_binary_datetime(tm, row); } -static void fetch_result_bin(MYSQL_BIND *param, uchar **row) +static void fetch_result_bin(MYSQL_BIND *param, + MYSQL_FIELD *field __attribute__((unused)), + uchar **row) { ulong length= net_field_length(row); ulong copy_length= min(length, param->buffer_length); memcpy(param->buffer, (char *)*row, copy_length); *param->length= length; + *param->error= copy_length < length; *row+= length; } -static void fetch_result_str(MYSQL_BIND *param, uchar **row) +static void fetch_result_str(MYSQL_BIND *param, + MYSQL_FIELD *field __attribute__((unused)), + uchar **row) { ulong length= net_field_length(row); ulong copy_length= min(length, param->buffer_length); @@ -3909,6 +4151,7 @@ static void fetch_result_str(MYSQL_BIND *param, uchar **row) if (copy_length != param->buffer_length) ((uchar *)param->buffer)[copy_length]= '\0'; *param->length= length; /* return total length */ + *param->error= copy_length < length; *row+= length; } @@ -3950,6 +4193,220 @@ static void skip_result_string(MYSQL_BIND *param __attribute__((unused)), /* + Check that two field types are binary compatible i. e. + have equal representation in the binary protocol and + require client-side buffers of the same type. + + SYNOPSIS + is_binary_compatible() + type1 parameter type supplied by user + type2 field type, obtained from result set metadata + + RETURN + TRUE or FALSE +*/ + +static my_bool is_binary_compatible(enum enum_field_types type1, + enum enum_field_types type2) +{ + static const enum enum_field_types + range1[]= { MYSQL_TYPE_SHORT, MYSQL_TYPE_YEAR, MYSQL_TYPE_NULL }, + range2[]= { MYSQL_TYPE_INT24, MYSQL_TYPE_LONG, MYSQL_TYPE_NULL }, + range3[]= { MYSQL_TYPE_DATETIME, MYSQL_TYPE_TIMESTAMP, MYSQL_TYPE_NULL }, + range4[]= { MYSQL_TYPE_ENUM, MYSQL_TYPE_SET, MYSQL_TYPE_TINY_BLOB, + MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_BLOB, + MYSQL_TYPE_VAR_STRING, MYSQL_TYPE_STRING, MYSQL_TYPE_GEOMETRY, + MYSQL_TYPE_DECIMAL, MYSQL_TYPE_NULL }; + static const enum enum_field_types + *range_list[]= { range1, range2, range3, range4 }, + **range_list_end= range_list + sizeof(range_list)/sizeof(*range_list); + const enum enum_field_types **range, *type; + + if (type1 == type2) + return TRUE; + for (range= range_list; range != range_list_end; ++range) + { + /* check that both type1 and type2 are in the same range */ + bool type1_found= FALSE, type2_found= FALSE; + for (type= *range; *type != MYSQL_TYPE_NULL; type++) + { + type1_found|= type1 == *type; + type2_found|= type2 == *type; + } + if (type1_found || type2_found) + return type1_found && type2_found; + } + return FALSE; +} + + +/* + Setup a fetch function for one column of a result set. + + SYNOPSIS + setup_one_fetch_function() + param output buffer descriptor + field column descriptor + + DESCRIPTION + When user binds result set buffers or when result set + metadata is changed, we need to setup fetch (and possibly + conversion) functions for all columns of the result set. + In addition to that here we set up skip_result function, used + to update result set metadata in case when + STMT_ATTR_UPDATE_MAX_LENGTH attribute is set. + Notice that while fetch_result is chosen depending on both + field->type and param->type, skip_result depends on field->type + only. + + RETURN + TRUE fetch function for this typecode was not found (typecode + is not supported by the client library) + FALSE success +*/ + +static my_bool setup_one_fetch_function(MYSQL_BIND *param, MYSQL_FIELD *field) +{ + /* Setup data copy functions for the different supported types */ + switch (param->buffer_type) { + case MYSQL_TYPE_NULL: /* for dummy binds */ + /* + It's not binary compatible with anything the server can return: + no need to setup fetch_result, as it'll be reset anyway + */ + *param->length= 0; + break; + case MYSQL_TYPE_TINY: + param->fetch_result= fetch_result_tinyint; + *param->length= 1; + break; + case MYSQL_TYPE_SHORT: + case MYSQL_TYPE_YEAR: + param->fetch_result= fetch_result_short; + *param->length= 2; + break; + case MYSQL_TYPE_INT24: + case MYSQL_TYPE_LONG: + param->fetch_result= fetch_result_int32; + *param->length= 4; + break; + case MYSQL_TYPE_LONGLONG: + param->fetch_result= fetch_result_int64; + *param->length= 8; + break; + case MYSQL_TYPE_FLOAT: + param->fetch_result= fetch_result_float; + *param->length= 4; + break; + case MYSQL_TYPE_DOUBLE: + param->fetch_result= fetch_result_double; + *param->length= 8; + break; + case MYSQL_TYPE_TIME: + param->fetch_result= fetch_result_time; + *param->length= sizeof(MYSQL_TIME); + break; + case MYSQL_TYPE_DATE: + param->fetch_result= fetch_result_date; + *param->length= sizeof(MYSQL_TIME); + break; + case MYSQL_TYPE_DATETIME: + case MYSQL_TYPE_TIMESTAMP: + param->fetch_result= fetch_result_datetime; + *param->length= sizeof(MYSQL_TIME); + break; + case MYSQL_TYPE_TINY_BLOB: + case MYSQL_TYPE_MEDIUM_BLOB: + case MYSQL_TYPE_LONG_BLOB: + case MYSQL_TYPE_BLOB: + case MYSQL_TYPE_BIT: + DBUG_ASSERT(param->buffer_length != 0); + param->fetch_result= fetch_result_bin; + break; + case MYSQL_TYPE_VAR_STRING: + case MYSQL_TYPE_STRING: + case MYSQL_TYPE_DECIMAL: + case MYSQL_TYPE_NEWDECIMAL: + DBUG_ASSERT(param->buffer_length != 0); + param->fetch_result= fetch_result_str; + break; + default: + return TRUE; + } + if (! is_binary_compatible(param->buffer_type, field->type)) + param->fetch_result= fetch_result_with_conversion; + + /* Setup skip_result functions (to calculate max_length) */ + param->skip_result= skip_result_fixed; + switch (field->type) { + case MYSQL_TYPE_NULL: /* for dummy binds */ + param->pack_length= 0; + field->max_length= 0; + break; + case MYSQL_TYPE_TINY: + param->pack_length= 1; + field->max_length= 4; /* as in '-127' */ + break; + case MYSQL_TYPE_YEAR: + case MYSQL_TYPE_SHORT: + param->pack_length= 2; + field->max_length= 6; /* as in '-32767' */ + break; + case MYSQL_TYPE_INT24: + field->max_length= 9; /* as in '16777216' or in '-8388607' */ + param->pack_length= 4; + break; + case MYSQL_TYPE_LONG: + field->max_length= 11; /* '-2147483647' */ + param->pack_length= 4; + break; + case MYSQL_TYPE_LONGLONG: + field->max_length= 21; /* '18446744073709551616' */ + param->pack_length= 8; + break; + case MYSQL_TYPE_FLOAT: + param->pack_length= 4; + field->max_length= MAX_DOUBLE_STRING_REP_LENGTH; + break; + case MYSQL_TYPE_DOUBLE: + param->pack_length= 8; + field->max_length= MAX_DOUBLE_STRING_REP_LENGTH; + break; + case MYSQL_TYPE_TIME: + field->max_length= 15; /* 19:23:48.123456 */ + param->skip_result= skip_result_with_length; + case MYSQL_TYPE_DATE: + field->max_length= 10; /* 2003-11-11 */ + param->skip_result= skip_result_with_length; + break; + break; + case MYSQL_TYPE_DATETIME: + case MYSQL_TYPE_TIMESTAMP: + param->skip_result= skip_result_with_length; + field->max_length= MAX_DATE_STRING_REP_LENGTH; + break; + case MYSQL_TYPE_DECIMAL: + case MYSQL_TYPE_NEWDECIMAL: + case MYSQL_TYPE_ENUM: + case MYSQL_TYPE_SET: + case MYSQL_TYPE_GEOMETRY: + case MYSQL_TYPE_TINY_BLOB: + case MYSQL_TYPE_MEDIUM_BLOB: + case MYSQL_TYPE_LONG_BLOB: + case MYSQL_TYPE_BLOB: + case MYSQL_TYPE_VAR_STRING: + case MYSQL_TYPE_STRING: + case MYSQL_TYPE_BIT: + param->skip_result= skip_result_string; + break; + default: + return TRUE; + } + return FALSE; +} + + +/* Setup the bind buffers for resultset processing */ @@ -3960,7 +4417,7 @@ my_bool STDCALL mysql_stmt_bind_result(MYSQL_STMT *stmt, MYSQL_BIND *bind) ulong bind_count= stmt->field_count; uint param_count= 0; DBUG_ENTER("mysql_stmt_bind_result"); - DBUG_PRINT("enter",("field_count: %d", bind_count)); + DBUG_PRINT("enter",("field_count: %lu", bind_count)); if (!bind_count) { @@ -3991,142 +4448,30 @@ my_bool STDCALL mysql_stmt_bind_result(MYSQL_STMT *stmt, MYSQL_BIND *bind) This is to make the execute code easier */ if (!param->is_null) - param->is_null= ¶m->internal_is_null; + param->is_null= ¶m->is_null_value; if (!param->length) - param->length= ¶m->internal_length; + param->length= ¶m->length_value; + + if (!param->error) + param->error= ¶m->error_value; param->param_number= param_count++; param->offset= 0; - /* Setup data copy functions for the different supported types */ - switch (param->buffer_type) { - case MYSQL_TYPE_NULL: /* for dummy binds */ - *param->length= 0; - break; - case MYSQL_TYPE_TINY: - param->fetch_result= fetch_result_tinyint; - *param->length= 1; - break; - case MYSQL_TYPE_SHORT: - case MYSQL_TYPE_YEAR: - param->fetch_result= fetch_result_short; - *param->length= 2; - break; - case MYSQL_TYPE_INT24: - case MYSQL_TYPE_LONG: - param->fetch_result= fetch_result_int32; - *param->length= 4; - break; - case MYSQL_TYPE_LONGLONG: - param->fetch_result= fetch_result_int64; - *param->length= 8; - break; - case MYSQL_TYPE_FLOAT: - param->fetch_result= fetch_result_float; - *param->length= 4; - break; - case MYSQL_TYPE_DOUBLE: - param->fetch_result= fetch_result_double; - *param->length= 8; - break; - case MYSQL_TYPE_TIME: - param->fetch_result= fetch_result_time; - *param->length= sizeof(MYSQL_TIME); - break; - case MYSQL_TYPE_DATE: - param->fetch_result= fetch_result_date; - *param->length= sizeof(MYSQL_TIME); - break; - case MYSQL_TYPE_DATETIME: - case MYSQL_TYPE_TIMESTAMP: - param->fetch_result= fetch_result_datetime; - *param->length= sizeof(MYSQL_TIME); - break; - case MYSQL_TYPE_TINY_BLOB: - case MYSQL_TYPE_MEDIUM_BLOB: - case MYSQL_TYPE_LONG_BLOB: - case MYSQL_TYPE_BLOB: - DBUG_ASSERT(param->buffer_length != 0); - param->fetch_result= fetch_result_bin; - break; - case MYSQL_TYPE_VAR_STRING: - case MYSQL_TYPE_STRING: - DBUG_ASSERT(param->buffer_length != 0); - param->fetch_result= fetch_result_str; - break; - default: - strmov(stmt->sqlstate, unknown_sqlstate); - sprintf(stmt->last_error, - ER(stmt->last_errno= CR_UNSUPPORTED_PARAM_TYPE), - param->buffer_type, param_count); - DBUG_RETURN(1); - } - - /* Setup skip_result functions (to calculate max_length) */ - param->skip_result= skip_result_fixed; - switch (field->type) { - case MYSQL_TYPE_NULL: /* for dummy binds */ - param->pack_length= 0; - field->max_length= 0; - break; - case MYSQL_TYPE_TINY: - param->pack_length= 1; - field->max_length= 4; /* as in '-127' */ - break; - case MYSQL_TYPE_YEAR: - case MYSQL_TYPE_SHORT: - param->pack_length= 2; - field->max_length= 6; /* as in '-32767' */ - break; - case MYSQL_TYPE_INT24: - field->max_length= 9; /* as in '16777216' or in '-8388607' */ - param->pack_length= 4; - break; - case MYSQL_TYPE_LONG: - field->max_length= 11; /* '-2147483647' */ - param->pack_length= 4; - break; - case MYSQL_TYPE_LONGLONG: - field->max_length= 21; /* '18446744073709551616' */ - param->pack_length= 8; - break; - case MYSQL_TYPE_FLOAT: - param->pack_length= 4; - field->max_length= MAX_DOUBLE_STRING_REP_LENGTH; - break; - case MYSQL_TYPE_DOUBLE: - param->pack_length= 8; - field->max_length= MAX_DOUBLE_STRING_REP_LENGTH; - break; - case MYSQL_TYPE_TIME: - case MYSQL_TYPE_DATE: - case MYSQL_TYPE_DATETIME: - case MYSQL_TYPE_TIMESTAMP: - param->skip_result= skip_result_with_length; - field->max_length= MAX_DATE_STRING_REP_LENGTH; - break; - case MYSQL_TYPE_DECIMAL: - case MYSQL_TYPE_ENUM: - case MYSQL_TYPE_SET: - case MYSQL_TYPE_GEOMETRY: - case MYSQL_TYPE_TINY_BLOB: - case MYSQL_TYPE_MEDIUM_BLOB: - case MYSQL_TYPE_LONG_BLOB: - case MYSQL_TYPE_BLOB: - case MYSQL_TYPE_VAR_STRING: - case MYSQL_TYPE_STRING: - param->skip_result= skip_result_string; - break; - default: + if (setup_one_fetch_function(param, field)) + { strmov(stmt->sqlstate, unknown_sqlstate); sprintf(stmt->last_error, - ER(stmt->last_errno= CR_UNSUPPORTED_PARAM_TYPE), - field->type, param_count); + ER(stmt->last_errno= CR_UNSUPPORTED_PARAM_TYPE), + field->type, param_count); DBUG_RETURN(1); } } - stmt->bind_result_done= TRUE; + stmt->bind_result_done= BIND_RESULT_DONE; + if (stmt->mysql->options.report_data_truncation) + stmt->bind_result_done|= REPORT_DATA_TRUNCATION; + DBUG_RETURN(0); } @@ -4140,6 +4485,7 @@ static int stmt_fetch_row(MYSQL_STMT *stmt, uchar *row) MYSQL_BIND *bind, *end; MYSQL_FIELD *field; uchar *null_ptr, bit; + int truncation_count= 0; /* Precondition: if stmt->field_count is zero or row is NULL, read_row_* function must return no data. @@ -4162,26 +4508,25 @@ static int stmt_fetch_row(MYSQL_STMT *stmt, uchar *row) bind < end ; bind++, field++) { + *bind->error= 0; if (*null_ptr & bit) { /* - We should set both inter_buffer and is_null to be able to see + We should set both row_ptr and is_null to be able to see nulls in mysql_stmt_fetch_column. This is because is_null may point to user data which can be overwritten between mysql_stmt_fetch and mysql_stmt_fetch_column, and in this case nullness of column will be lost. See mysql_stmt_fetch_column for details. */ - bind->inter_buffer= NULL; + bind->row_ptr= NULL; *bind->is_null= 1; } else { *bind->is_null= 0; - bind->inter_buffer= row; - if (field->type == bind->buffer_type) - (*bind->fetch_result)(bind, &row); - else - fetch_result_with_conversion(bind, field, &row); + bind->row_ptr= row; + (*bind->fetch_result)(bind, field, &row); + truncation_count+= *bind->error; } if (!((bit<<=1) & 255)) { @@ -4189,13 +4534,15 @@ static int stmt_fetch_row(MYSQL_STMT *stmt, uchar *row) null_ptr++; } } + if (truncation_count && (stmt->bind_result_done & REPORT_DATA_TRUNCATION)) + return MYSQL_DATA_TRUNCATED; return 0; } int cli_unbuffered_fetch(MYSQL *mysql, char **row) { - if (packet_error == net_safe_read(mysql)) + if (packet_error == cli_safe_read(mysql)) return 1; *row= ((mysql->net.read_pos[0] == 254) ? NULL : @@ -4215,10 +4562,11 @@ int STDCALL mysql_stmt_fetch(MYSQL_STMT *stmt) DBUG_ENTER("mysql_stmt_fetch"); if ((rc= (*stmt->read_row_func)(stmt, &row)) || - (rc= stmt_fetch_row(stmt, row))) + ((rc= stmt_fetch_row(stmt, row)) && rc != MYSQL_DATA_TRUNCATED)) { stmt->state= MYSQL_STMT_PREPARE_DONE; /* XXX: this is buggy */ - stmt->read_row_func= stmt_read_row_no_data; + stmt->read_row_func= (rc == MYSQL_NO_DATA) ? + stmt_read_row_no_data : stmt_read_row_no_result_set; } else { @@ -4262,17 +4610,20 @@ int STDCALL mysql_stmt_fetch_column(MYSQL_STMT *stmt, MYSQL_BIND *bind, DBUG_RETURN(1); } - if (param->inter_buffer) + if (!bind->error) + bind->error= &bind->error_value; + *bind->error= 0; + if (param->row_ptr) { MYSQL_FIELD *field= stmt->fields+column; - uchar *row= param->inter_buffer; + uchar *row= param->row_ptr; bind->offset= offset; if (bind->is_null) *bind->is_null= 0; if (bind->length) /* Set the length if non char/binary types */ *bind->length= *param->length; else - bind->length= ¶m->internal_length; /* Needed for fetch_result() */ + bind->length= ¶m->length_value; /* Needed for fetch_result() */ fetch_result_with_conversion(bind, field, &row); } else @@ -4300,7 +4651,7 @@ int cli_read_binary_rows(MYSQL_STMT *stmt) mysql= mysql->last_used_con; - while ((pkt_len= net_safe_read(mysql)) != packet_error) + while ((pkt_len= cli_safe_read(mysql)) != packet_error) { cp= net->read_pos; if (cp[0] != 254 || pkt_len >= 8) @@ -4393,8 +4744,34 @@ int STDCALL mysql_stmt_store_result(MYSQL_STMT *stmt) if (!stmt->field_count) DBUG_RETURN(0); - if ((int) stmt->state < (int) MYSQL_STMT_EXECUTE_DONE || - mysql->status != MYSQL_STATUS_GET_RESULT) + + if ((int) stmt->state < (int) MYSQL_STMT_EXECUTE_DONE) + { + set_stmt_error(stmt, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate); + DBUG_RETURN(1); + } + + if (mysql->status == MYSQL_STATUS_READY && + stmt->server_status & SERVER_STATUS_CURSOR_EXISTS) + { + /* + Server side cursor exist, tell server to start sending the rows + */ + NET *net= &mysql->net; + char buff[4 /* statement id */ + + 4 /* number of rows to fetch */]; + + /* Send row request to the server */ + int4store(buff, stmt->stmt_id); + int4store(buff + 4, (int)~0); /* number of rows to fetch */ + if (cli_advanced_command(mysql, COM_STMT_FETCH, buff, sizeof(buff), + NullS, 0, 1, NULL)) + { + set_stmt_errmsg(stmt, net->last_error, net->last_errno, net->sqlstate); + DBUG_RETURN(1); + } + } + else if (mysql->status != MYSQL_STATUS_GET_RESULT) { set_stmt_error(stmt, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate); DBUG_RETURN(1); @@ -4432,6 +4809,10 @@ int STDCALL mysql_stmt_store_result(MYSQL_STMT *stmt) DBUG_RETURN(1); } + /* Assert that if there was a cursor, all rows have been fetched */ + DBUG_ASSERT(mysql->status != MYSQL_STATUS_READY || + (mysql->server_status & SERVER_STATUS_LAST_ROW_SENT)); + if (stmt->update_max_length) { MYSQL_ROWS *cur= result->data; @@ -4511,18 +4892,26 @@ my_ulonglong STDCALL mysql_stmt_num_rows(MYSQL_STMT *stmt) DBUG_RETURN(stmt->result.rows); } -my_bool STDCALL mysql_stmt_free_result(MYSQL_STMT *stmt) -{ - MYSQL_DATA *result= &stmt->result; - DBUG_ENTER("mysql_stmt_free_result"); - DBUG_ASSERT(stmt != 0); +/* + Free the client side memory buffers, reset long data state + on client if necessary, and reset the server side statement if + this has been requested. +*/ +static my_bool reset_stmt_handle(MYSQL_STMT *stmt, uint flags) +{ + /* If statement hasn't been prepared there is nothing to reset */ if ((int) stmt->state > (int) MYSQL_STMT_INIT_DONE) { MYSQL *mysql= stmt->mysql; + MYSQL_DATA *result= &stmt->result; - if (result->data) + /* + Reset stored result set if so was requested or it's a part + of cursor fetch. + */ + if (result->data && (flags & RESET_STORE_RESULT)) { /* Result buffered */ free_root(&result->alloc, MYF(MY_KEEP_PREALLOC)); @@ -4530,23 +4919,59 @@ my_bool STDCALL mysql_stmt_free_result(MYSQL_STMT *stmt) result->rows= 0; stmt->data_cursor= NULL; } - - if (mysql && stmt->field_count && - (int) stmt->state > (int) MYSQL_STMT_PREPARE_DONE) + if (flags & RESET_LONG_DATA) { - if (mysql->unbuffered_fetch_owner == &stmt->unbuffered_fetch_cancelled) - mysql->unbuffered_fetch_owner= 0; - if (mysql->status != MYSQL_STATUS_READY) + MYSQL_BIND *param= stmt->params, *param_end= param + stmt->param_count; + /* Clear long_data_used flags */ + for (; param < param_end; param++) + param->long_data_used= 0; + } + stmt->read_row_func= stmt_read_row_no_result_set; + if (mysql) + { + if ((int) stmt->state > (int) MYSQL_STMT_PREPARE_DONE) { - /* There is a result set and it belongs to this statement */ - (*mysql->methods->flush_use_result)(mysql); - mysql->status= MYSQL_STATUS_READY; + if (mysql->unbuffered_fetch_owner == &stmt->unbuffered_fetch_cancelled) + mysql->unbuffered_fetch_owner= 0; + if (stmt->field_count && mysql->status != MYSQL_STATUS_READY) + { + /* There is a result set and it belongs to this statement */ + (*mysql->methods->flush_use_result)(mysql); + if (mysql->unbuffered_fetch_owner) + *mysql->unbuffered_fetch_owner= TRUE; + mysql->status= MYSQL_STATUS_READY; + } + } + if (flags & RESET_SERVER_SIDE) + { + /* + Reset the server side statement and close the server side + cursor if it exists. + */ + char buff[MYSQL_STMT_HEADER]; /* packet header: 4 bytes for stmt id */ + int4store(buff, stmt->stmt_id); + if ((*mysql->methods->advanced_command)(mysql, COM_STMT_RESET, buff, + sizeof(buff), 0, 0, 0, NULL)) + { + set_stmt_errmsg(stmt, mysql->net.last_error, mysql->net.last_errno, + mysql->net.sqlstate); + stmt->state= MYSQL_STMT_INIT_DONE; + return 1; + } + stmt_clear_error(stmt); } } stmt->state= MYSQL_STMT_PREPARE_DONE; - stmt->read_row_func= stmt_read_row_no_data; } - DBUG_RETURN(0); + return 0; +} + +my_bool STDCALL mysql_stmt_free_result(MYSQL_STMT *stmt) +{ + DBUG_ENTER("mysql_stmt_free_result"); + + /* Free the client side and close the server side cursor if there is one */ + DBUG_RETURN(reset_stmt_handle(stmt, RESET_LONG_DATA | RESET_STORE_RESULT)); } /******************************************************************** @@ -4600,7 +5025,7 @@ my_bool STDCALL mysql_stmt_close(MYSQL_STMT *stmt) mysql->status= MYSQL_STATUS_READY; } int4store(buff, stmt->stmt_id); - if ((rc= stmt_command(mysql, COM_CLOSE_STMT, buff, 4, stmt))) + if ((rc= stmt_command(mysql, COM_STMT_CLOSE, buff, 4, stmt))) { set_stmt_errmsg(stmt, mysql->net.last_error, mysql->net.last_errno, mysql->net.sqlstate); @@ -4619,40 +5044,16 @@ my_bool STDCALL mysql_stmt_close(MYSQL_STMT *stmt) my_bool STDCALL mysql_stmt_reset(MYSQL_STMT *stmt) { - char buff[MYSQL_STMT_HEADER]; /* packet header: 4 bytes for stmt id */ - MYSQL *mysql; - MYSQL_BIND *param, *param_end; DBUG_ENTER("mysql_stmt_reset"); DBUG_ASSERT(stmt != 0); - - /* If statement hasnt been prepared there is nothing to reset */ - if ((int) stmt->state < (int) MYSQL_STMT_PREPARE_DONE) - DBUG_RETURN(0); if (!stmt->mysql) { /* mysql can be reset in mysql_close called from mysql_reconnect */ set_stmt_error(stmt, CR_SERVER_LOST, unknown_sqlstate); - DBUG_RETURN(1); - } - - mysql= stmt->mysql->last_used_con; - int4store(buff, stmt->stmt_id); /* Send stmt id to server */ - if ((*mysql->methods->advanced_command)(mysql, COM_RESET_STMT, buff, - sizeof(buff), 0, 0, 0, 0)) - { - set_stmt_errmsg(stmt, mysql->net.last_error, mysql->net.last_errno, - mysql->net.sqlstate); DBUG_RETURN(1); } - - /* Clear long_data_used for next call (as we do in mysql_stmt_execute() */ - for (param= stmt->params, param_end= param + stmt->param_count; - param < param_end; - param++) - param->long_data_used= 0; - stmt_clear_error(stmt); - - DBUG_RETURN(0); + /* Reset the client and server sides of the prepared statement */ + DBUG_RETURN(reset_stmt_handle(stmt, RESET_SERVER_SIDE | RESET_LONG_DATA)); } /* @@ -4716,9 +5117,9 @@ my_bool STDCALL mysql_autocommit(MYSQL * mysql, my_bool auto_mode) DBUG_ENTER("mysql_autocommit"); DBUG_PRINT("enter", ("mode : %d", auto_mode)); - if (auto_mode) /* set to true */ - DBUG_RETURN((my_bool) mysql_real_query(mysql, "set autocommit=1", 16)); - DBUG_RETURN((my_bool) mysql_real_query(mysql, "set autocommit=0", 16)); + DBUG_RETURN((my_bool) mysql_real_query(mysql, auto_mode ? + "set autocommit=1":"set autocommit=0", + 16)); } |