database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-06-13 13:01:51 +03:00
Code Activity

protocol fixups

Browse Source
This commit is contained in:
venu@myvenu.com
2002-11-22 10:04:42 -08:00
parent 5601da7ad3
commit b74c43f475
9 changed files with 398 additions and 273 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
libmysql/errmsg.c
View File

@ -58,7 +58,7 @@ const char *client_errors[]=
"No parameters exists in the statement", "No parameters exists in the statement",
"Invalid parameter number", "Invalid parameter number",
"Can't send long data for non string or binary data types (parameter: %d)", "Can't send long data for non string or binary data types (parameter: %d)",
"Using not supported parameter type: %d (parameter: %d)" "Using un supported parameter type: %d (parameter: %d)"
"Shared memory (%lu)", "Shared memory (%lu)",
"Can't open shared memory. Request event don't create (%lu)", "Can't open shared memory. Request event don't create (%lu)",
"Can't open shared memory. Answer event don't create (%lu)", "Can't open shared memory. Answer event don't create (%lu)",
@ -111,7 +111,7 @@ const char *client_errors[]=
"No parameters exists in the statement", "No parameters exists in the statement",
"Invalid parameter number", "Invalid parameter number",
"Can't send long data for non string or binary data types (parameter: %d)", "Can't send long data for non string or binary data types (parameter: %d)",
"Using not supported parameter type: %d (parameter: %d)" "Using un supported parameter type: %d (parameter: %d)"
"Shared memory (%lu)", "Shared memory (%lu)",
"Can't open shared memory. Request event don't create (%lu)", "Can't open shared memory. Request event don't create (%lu)",
"Can't open shared memory. Answer event don't create (%lu)", "Can't open shared memory. Answer event don't create (%lu)",
@ -162,7 +162,7 @@ const char *client_errors[]=
"No parameters exists in the statement", "No parameters exists in the statement",
"Invalid parameter number", "Invalid parameter number",
"Can't send long data for non string or binary data types (parameter: %d)", "Can't send long data for non string or binary data types (parameter: %d)",
"Using not supported parameter type: %d (parameter: %d)" "Using un supported parameter type: %d (parameter: %d)"
"Shared memory (%lu)", "Shared memory (%lu)",
"Can't open shared memory. Request event don't create (%lu)", "Can't open shared memory. Request event don't create (%lu)",
"Can't open shared memory. Answer event don't create (%lu)", "Can't open shared memory. Answer event don't create (%lu)",

291
libmysql/libmysql.c
View File

@ -927,7 +927,8 @@ static const char *default_options[]=
"character-sets-dir", "default-character-set", "interactive-timeout", "character-sets-dir", "default-character-set", "interactive-timeout",
"connect-timeout", "local-infile", "disable-local-infile", "connect-timeout", "local-infile", "disable-local-infile",
"replication-probe", "enable-reads-from-master", "repl-parse-query", "replication-probe", "enable-reads-from-master", "repl-parse-query",
"ssl-cipher","protocol", "ssl-cipher","protocol",
"shared_memory_base_name",
NullS NullS
}; };
@ -1736,11 +1737,10 @@ mysql_ssl_set(MYSQL *mysql __attribute__((unused)) ,
Free strings in the SSL structure and clear 'use_ssl' flag. Free strings in the SSL structure and clear 'use_ssl' flag.
NB! Errors are not reported until you do mysql_real_connect. NB! Errors are not reported until you do mysql_real_connect.
**************************************************************************/ **************************************************************************/
**************************************************************************/
static void static void
mysql_ssl_free(MYSQL *mysql __attribute__((unused))) mysql_ssl_free(MYSQL *mysql __attribute__((unused)))
{ {
{ #ifdef HAVE_OPENSLL
my_free(mysql->options.ssl_key, MYF(MY_ALLOW_ZERO_PTR)); my_free(mysql->options.ssl_key, MYF(MY_ALLOW_ZERO_PTR));
my_free(mysql->options.ssl_cert, MYF(MY_ALLOW_ZERO_PTR)); my_free(mysql->options.ssl_cert, MYF(MY_ALLOW_ZERO_PTR));
my_free(mysql->options.ssl_ca, MYF(MY_ALLOW_ZERO_PTR)); my_free(mysql->options.ssl_ca, MYF(MY_ALLOW_ZERO_PTR));
@ -1754,7 +1754,7 @@ mysql_ssl_free(MYSQL *mysql __attribute__((unused)))
mysql->options.ssl_cipher= 0; mysql->options.ssl_cipher= 0;
mysql->options.use_ssl = FALSE; mysql->options.use_ssl = FALSE;
mysql->connector_fd = 0; mysql->connector_fd = 0;
mysql->connector_fd = 0; #endif /* HAVE_OPENSLL */
} }
/************************************************************************** /**************************************************************************
@ -2567,7 +2567,7 @@ get_info:
{ {
mysql->affected_rows= net_field_length_ll(&pos); mysql->affected_rows= net_field_length_ll(&pos);
mysql->insert_id= net_field_length_ll(&pos); mysql->insert_id= net_field_length_ll(&pos);
mysql->insert_id= net_field_length_ll(&pos); if (protocol_41(mysql))
{ {
mysql->server_status=uint2korr(pos); pos+=2; mysql->server_status=uint2korr(pos); pos+=2;
mysql->warning_count=uint2korr(pos); pos+=2; mysql->warning_count=uint2korr(pos); pos+=2;
@ -3650,10 +3650,10 @@ MYSQL_STMT *STDCALL
mysql_prepare(MYSQL *mysql, const char *query, ulong length) mysql_prepare(MYSQL *mysql, const char *query, ulong length)
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
MYSQL_STMT *stmt; DBUG_ENTER("mysql_prepare");
DBUG_ASSERT(mysql != 0); DBUG_ASSERT(mysql != 0);
#ifdef CHECK_EXTRA_ARGUMENTS
if (!query) if (!query)
{ {
set_mysql_error(mysql, CR_NULL_POINTER); set_mysql_error(mysql, CR_NULL_POINTER);
@ -3674,7 +3674,6 @@ mysql_prepare(MYSQL *mysql, const char *query, ulong length)
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
DBUG_RETURN(0); DBUG_RETURN(0);
} }
}
init_alloc_root(&stmt->mem_root,8192,0); init_alloc_root(&stmt->mem_root,8192,0);
if (read_prepare_result(mysql, stmt)) if (read_prepare_result(mysql, stmt))
@ -3682,8 +3681,8 @@ mysql_prepare(MYSQL *mysql, const char *query, ulong length)
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
DBUG_RETURN(0); DBUG_RETURN(0);
} }
} stmt->state= MY_ST_PREPARE;
stmt->mysql= mysql;
DBUG_PRINT("info", ("Parameter count: %ld", stmt->param_count)); DBUG_PRINT("info", ("Parameter count: %ld", stmt->param_count));
DBUG_RETURN(stmt); DBUG_RETURN(stmt);
} }
@ -3819,7 +3818,7 @@ static void store_param_str(NET *net, MYSQL_BIND *param)
ulong length= *param->length; ulong length= *param->length;
char *to= (char *) net_store_length((char *) net->write_pos, length); char *to= (char *) net_store_length((char *) net->write_pos, length);
memcpy(to, param->buffer, length); memcpy(to, param->buffer, length);
memcpy(to, param->buffer, length); net->write_pos= to+length;
} }
@ -3853,17 +3852,19 @@ static my_bool store_param(MYSQL_STMT *stmt, MYSQL_BIND *param)
MYSQL *mysql= stmt->mysql; MYSQL *mysql= stmt->mysql;
NET *net = &mysql->net; NET *net = &mysql->net;
DBUG_ENTER("store_param"); DBUG_ENTER("store_param");
DBUG_ENTER("store_param"); DBUG_PRINT("enter",("type: %d, buffer:%lx, length: %d", param->buffer_type,
DBUG_PRINT("enter",("type : %d, buffer :%lx", param->buffer_type, param->buffer ? param->buffer : "0", *param->length));
param->buffer));
if (param->is_null || param->buffer_type == MYSQL_TYPE_NULL)
/* Allocate for worst case (long string) */
if ((my_realloc_str(net, 9 + *param->length)))
return 1;
store_param_null(net, param); store_param_null(net, param);
else else
{
/* Allocate for worst case (long string) */
if ((my_realloc_str(net, 9 + *param->length)))
DBUG_RETURN(1);
(*param->store_param_func)(net, param); (*param->store_param_func)(net, param);
(*param->store_param_func)(net, param); }
DBUG_RETURN(0);
} }
@ -3875,13 +3876,13 @@ static my_bool execute(MYSQL_STMT * stmt, char *packet, ulong length)
{ {
MYSQL *mysql= stmt->mysql; MYSQL *mysql= stmt->mysql;
NET *net= &mysql->net; NET *net= &mysql->net;
NET *net= &mysql->net; char buff[MYSQL_STMT_HEADER];
DBUG_ENTER("execute"); DBUG_ENTER("execute");
DBUG_PRINT("enter",("packet: %s, length :%d",packet ? packet :" ", length)); DBUG_PRINT("enter",("packet: %s, length :%d",packet ? packet :" ", length));
mysql->last_used_con= mysql; mysql->last_used_con= mysql;
int4store(buff, stmt->stmt_id); /* Send stmt id to server */ int4store(buff, stmt->stmt_id); /* Send stmt id to server */
int4store(buff, stmt->stmt_id); /* Send stmt id to server */ if (advanced_command(mysql, COM_EXECUTE, buff, MYSQL_STMT_HEADER, packet,
length, 1) || length, 1) ||
mysql_read_query_result(mysql)) mysql_read_query_result(mysql))
{ {
@ -3889,12 +3890,14 @@ static my_bool execute(MYSQL_STMT * stmt, char *packet, ulong length)
DBUG_RETURN(1); DBUG_RETURN(1);
} }
stmt->state= MY_ST_EXECUTE; stmt->state= MY_ST_EXECUTE;
stmt->state= MY_ST_EXECUTE; mysql_free_result(stmt->result);
#if USED_IN_FETCH
if (stmt->res_buffers) /* Result buffers exists, cache results */
{ {
mysql_free_result(stmt->result); mysql_free_result(stmt->result);
stmt->result= mysql_store_result(mysql); stmt->result= mysql_store_result(mysql);
} }
#endif
DBUG_RETURN(0); DBUG_RETURN(0);
} }
@ -3905,8 +3908,6 @@ static my_bool execute(MYSQL_STMT * stmt, char *packet, ulong length)
int STDCALL mysql_execute(MYSQL_STMT *stmt) int STDCALL mysql_execute(MYSQL_STMT *stmt)
{ {
{
ulong length;
DBUG_ENTER("mysql_execute"); DBUG_ENTER("mysql_execute");
if (stmt->state == MY_ST_UNKNOWN) if (stmt->state == MY_ST_UNKNOWN)
@ -3920,14 +3921,18 @@ int STDCALL mysql_execute(MYSQL_STMT *stmt)
NET *net= &stmt->mysql->net; NET *net= &stmt->mysql->net;
MYSQL_BIND *param, *param_end; MYSQL_BIND *param, *param_end;
char *param_data; char *param_data;
char *param_data; ulong length;
uint null_count;
my_bool result;
#ifdef CHECK_EXTRA_ARGUMENTS
if (!stmt->param_buffers)
{ {
/* Parameters exists, but no bound buffers */ /* Parameters exists, but no bound buffers */
set_stmt_error(stmt, CR_NOT_ALL_PARAMS_BOUND); set_stmt_error(stmt, CR_NOT_ALL_PARAMS_BOUND);
DBUG_RETURN(1); DBUG_RETURN(1);
} }
#endif
net_clear(net); /* Sets net->write_pos */ net_clear(net); /* Sets net->write_pos */
/* Reserve place for null-marker bytes */ /* Reserve place for null-marker bytes */
null_count= (stmt->param_count+7) /8; null_count= (stmt->param_count+7) /8;
@ -3936,10 +3941,9 @@ int STDCALL mysql_execute(MYSQL_STMT *stmt)
param_end= stmt->params + stmt->param_count; param_end= stmt->params + stmt->param_count;
/* In case if buffers (type) altered, indicate to server */ /* In case if buffers (type) altered, indicate to server */
/* In case if buffers (type) altered, indicate to server */ *(net->write_pos)++= (uchar) stmt->send_types_to_server;
*(net->write_pos)++= (uchar) stmt->types_supplied; if (stmt->send_types_to_server)
{ {
{
/* /*
Store types of parameters in first in first package Store types of parameters in first in first package
that is sent to the server. that is sent to the server.
@ -3953,21 +3957,22 @@ int STDCALL mysql_execute(MYSQL_STMT *stmt)
/* Check for long data which has not been propery given/terminated */ /* Check for long data which has not been propery given/terminated */
if (param->is_long_data) if (param->is_long_data)
{ {
{ if (!param->long_ended)
if (!param->long_ended) DBUG_RETURN(MYSQL_NEED_DATA);
} }
else if (store_param(stmt, param)) else if (store_param(stmt, param))
else if (store_param(stmt, param)) DBUG_RETURN(1);
} }
length= (ulong) (net->write_pos - net->buff); length= (ulong) (net->write_pos - net->buff);
/* TODO: Look into avoding the following memdup */ /* TODO: Look into avoding the following memdup */
/* TODO: Look into avoding the following memdup */ if (!(param_data= my_memdup( net->buff, length, MYF(0))))
{ {
set_stmt_error(stmt, CR_OUT_OF_MEMORY); set_stmt_error(stmt, CR_OUT_OF_MEMORY);
DBUG_RETURN(1); DBUG_RETURN(1);
} }
net->write_pos= net->buff; /* Reset for net_write() */ net->write_pos= net->buff; /* Reset for net_write() */
result= execute(stmt, param_data, length); result= execute(stmt, param_data, length);
stmt->send_types_to_server=0;
my_free(param_data, MYF(MY_WME)); my_free(param_data, MYF(MY_WME));
DBUG_RETURN(result); DBUG_RETURN(result);
} }
@ -4030,15 +4035,19 @@ my_bool STDCALL mysql_bind_param(MYSQL_STMT *stmt, MYSQL_BIND * bind)
param->param_number); param->param_number);
DBUG_RETURN(1); DBUG_RETURN(1);
} }
/* /*
If param->length is not given, change it to point to bind_length. If param->length is not given, change it to point to bind_length.
This way we can always use *param->length to get the length of data This way we can always use *param->length to get the length of data
*/ */
if (!param->length) if (!param->length)
param->length= &param->bind_length; param->length= &param->bind_length;
param->length= &param->bind_length;
/* Setup data copy functions for the different supported types */ /* Setup data copy functions for the different supported types */
switch (param->buffer_type) { switch (param->buffer_type) {
case MYSQL_TYPE_NULL:
param->is_null=1;
break;
case MYSQL_TYPE_TINY: case MYSQL_TYPE_TINY:
param->bind_length= 1; param->bind_length= 1;
param->store_param_func= store_param_tinyint; param->store_param_func= store_param_tinyint;
@ -4060,12 +4069,13 @@ my_bool STDCALL mysql_bind_param(MYSQL_STMT *stmt, MYSQL_BIND * bind)
param->store_param_func= store_param_float; param->store_param_func= store_param_float;
break; break;
case MYSQL_TYPE_DOUBLE: case MYSQL_TYPE_DOUBLE:
case MYSQL_TYPE_DOUBLE: param->bind_length= 8;
param->store_param_func= store_param_double; param->store_param_func= store_param_double;
break; break;
case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_TINY_BLOB:
case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_BLOB:
case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_VAR_STRING:
case MYSQL_TYPE_STRING: case MYSQL_TYPE_STRING:
param->bind_length= param->buffer_length; param->bind_length= param->buffer_length;
@ -4078,7 +4088,8 @@ my_bool STDCALL mysql_bind_param(MYSQL_STMT *stmt, MYSQL_BIND * bind)
} }
} }
/* We have to send/resendtype information to MySQL */ /* We have to send/resendtype information to MySQL */
/* We have to send/resendtype information to MySQL */ stmt->send_types_to_server= 1;
stmt->param_buffers= 1;
DBUG_RETURN(0); DBUG_RETURN(0);
} }
@ -4152,6 +4163,73 @@ mysql_send_long_data(MYSQL_STMT *stmt, uint param_number,
Fetch-bind related implementations Fetch-bind related implementations
*********************************************************************/ *********************************************************************/
/****************************************************************************
Functions to fetch data to application buffers
All functions has the following characteristics:
SYNOPSIS
fetch_result_xxx()
param MySQL bind param
row Row value
RETURN VALUES
0 ok
1 Error (Can't alloc net->buffer)
****************************************************************************/
static void fetch_result_tinyint(MYSQL_BIND *param, uchar **row)
{
*param->buffer= (uchar) **row;
*row++;
}
static void fetch_result_short(MYSQL_BIND *param, uchar **row)
{
short value= *(short *)row;
int2store(param->buffer, value);
*row+=2;
}
static void fetch_result_int32(MYSQL_BIND *param, uchar **row)
{
int32 value= *(int32 *)row;
int4store(param->buffer, value);
*row+=4;
}
static void fetch_result_int64(MYSQL_BIND *param, uchar **row)
{
longlong value= *(longlong *)row;
int8store(param->buffer, value);
*row+=8;
}
static void fetch_result_float(MYSQL_BIND *param, uchar **row)
{
float value;
float4get(value,*row);
float4store(param->buffer, *row);
*row+=4;
}
static void fetch_result_double(MYSQL_BIND *param, uchar **row)
{
double value;
float8get(value,*row);
float8store(param->buffer, value);
*row+=8;
}
static void fetch_result_str(MYSQL_BIND *param, uchar **row)
{
ulong length= net_field_length(row);
memcpy(param->buffer, (char *)*row, length);
*param->length= length;
*row+=length;
}
/* /*
Setup the bind buffers for resultset processing Setup the bind buffers for resultset processing
*/ */
@ -4163,21 +4241,62 @@ my_bool STDCALL mysql_bind_result(MYSQL_STMT *stmt, MYSQL_BIND *bind)
DBUG_ENTER("mysql_bind_result"); DBUG_ENTER("mysql_bind_result");
DBUG_ASSERT(stmt != 0); DBUG_ASSERT(stmt != 0);
#ifdef CHECK_EXTRA_ARGUMENTS
if (!bind) if (!bind)
{ {
set_stmt_error(stmt, CR_NULL_POINTER); set_stmt_error(stmt, CR_NULL_POINTER);
DBUG_RETURN(1); DBUG_RETURN(1);
} }
#endif #endif
#endif bind_count= stmt->field_count;
memcpy((char*) stmt->bind, (char*) bind, memcpy((char*) stmt->bind, (char*) bind,
sizeof(MYSQL_BIND)*bind_count); sizeof(MYSQL_BIND)*bind_count);
for (param= stmt->bind, end= param+bind_count; param < end ; param++) for (param= stmt->bind, end= param+bind_count; param < end ; param++)
{ {
{ /* Setup data copy functions for the different supported types */
switch (param->buffer_type) {
case MYSQL_TYPE_TINY:
param->bind_length= 1;
param->fetch_result= fetch_result_tinyint;
break;
case MYSQL_TYPE_SHORT:
param->bind_length= 2;
param->fetch_result= fetch_result_short;
break;
case MYSQL_TYPE_LONG:
param->bind_length= 4;
param->fetch_result= fetch_result_int32;
break;
case MYSQL_TYPE_LONGLONG:
param->bind_length= 8;
param->fetch_result= fetch_result_int64;
break;
case MYSQL_TYPE_FLOAT:
param->bind_length= 4;
param->fetch_result= fetch_result_float;
break;
case MYSQL_TYPE_DOUBLE:
param->bind_length= 8;
param->fetch_result= fetch_result_double;
break;
case MYSQL_TYPE_TINY_BLOB:
case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_VAR_STRING:
case MYSQL_TYPE_STRING:
param->length= &param->buffer_length;
param->fetch_result= fetch_result_str;
break;
default:
sprintf(stmt->last_error, ER(stmt->last_errno= CR_UNSUPPORTED_PARAM_TYPE),
param->buffer_type, param->param_number);
DBUG_RETURN(1);
}
if (!param->length)
param->length= &param->bind_length;
} }
stmt->res_buffers= 1;
DBUG_RETURN(0); DBUG_RETURN(0);
} }
@ -4187,16 +4306,16 @@ my_bool STDCALL mysql_bind_result(MYSQL_STMT *stmt, MYSQL_BIND *bind)
*/ */
static my_bool static my_bool
static my_bool stmt_fetch_row(MYSQL_STMT *stmt, uchar **row)
{ {
MYSQL_BIND *bind, *end; MYSQL_BIND *bind, *end;
MYSQL_BIND *bind, *end; uchar *null_ptr= (uchar*) *row, bit;
uchar *null_ptr= (uchar*) row, bit;
*row+= (stmt->field_count+7)/8;
result->row_count++;
row+= (result->field_count+7)/8;
bit=1; bit=1;
bit=1;
/* Copy complete row to application buffers */
for (bind= stmt->bind, end= (MYSQL_BIND *) bind + stmt->field_count;
bind < end; bind < end;
bind++) bind++)
{ {
@ -4205,7 +4324,7 @@ my_fetch_row(MYSQL_STMT *stmt, MYSQL_RES *result, const byte *row)
else else
{ {
bind->is_null= 0; bind->is_null= 0;
bind->is_null= 0; (*bind->fetch_result)(bind, row);
} }
if (! (bit<<=1) & 255) if (! (bit<<=1) & 255)
{ {
@ -4216,12 +4335,9 @@ my_fetch_row(MYSQL_STMT *stmt, MYSQL_RES *result, const byte *row)
return 0; return 0;
} }
static int read_binary_data(MYSQL *mysql)
{
static int if (packet_error == net_safe_read(mysql))
read_binary_data(MYSQL *mysql)
{
ulong pkt_len;
return -1; return -1;
if (mysql->net.read_pos[0]) if (mysql->net.read_pos[0])
return 1; /* End of data */ return 1; /* End of data */
@ -4235,57 +4351,30 @@ read_binary_data(MYSQL *mysql)
int STDCALL mysql_fetch(MYSQL_STMT *stmt) int STDCALL mysql_fetch(MYSQL_STMT *stmt)
{ {
{ MYSQL *mysql= stmt->mysql;
DBUG_ENTER("mysql_fetch"); DBUG_ENTER("mysql_fetch");
if (stmt->res_buffers)
result= stmt->result;
if (!result)
DBUG_RETURN(MYSQL_NO_DATA);
{ {
{ int res;
MYSQL *mysql= stmt->mysql; if (!(res= read_binary_data(mysql)))
{ {
{ if (stmt->res_buffers)
int res; DBUG_RETURN((int) stmt_fetch_row(stmt,(uchar **) &mysql->net.read_pos+1));
if (!(res= read_binary_data(result->handle))) DBUG_RETURN(0);
DBUG_RETURN((int) my_fetch_row(stmt, result, }
(byte*) mysql->net.read_pos+1)); DBUG_PRINT("info", ("end of data"));
DBUG_PRINT("info", ("end of data")); mysql->status= MYSQL_STATUS_READY;
result->eof= 1;
result->handle->status= MYSQL_STATUS_READY; if (res < 0) /* Network error */
{
/* Don't clear handle in mysql_free_results */ set_stmt_errmsg(stmt,(char *)mysql->net.last_error,
result->handle= 0; mysql->net.last_errno);
if (res < 0) /* Network error */ DBUG_RETURN(MYSQL_STATUS_ERROR);
{
set_stmt_errmsg(stmt,(char *)mysql->net.last_error,
mysql->net.last_errno);
DBUG_RETURN(MYSQL_STATUS_ERROR);
} }
DBUG_RETURN(MYSQL_NO_DATA); /* no more data */ DBUG_RETURN(MYSQL_NO_DATA); /* no more data */
} }
} DBUG_RETURN(0); //?? do we need to set MYSQL_STATUS_READY ?
{
/*
For prepared statements, the row data is a string of binary bytes,
not a set of string pointers as for normal statements
It's however convenient to use the data pointer also for prepared
statements.
*/
MYSQL_ROW values;
if (!result->data_cursor)
{
DBUG_PRINT("info", ("end of data"));
result->current_row= (MYSQL_ROW) NULL;
DBUG_RETURN(MYSQL_NO_DATA);
}
values= result->data_cursor->data;
result->data_cursor= result->data_cursor->next;
DBUG_RETURN((int) my_fetch_row(stmt,result, (byte*) values));
}
} }
@ -4302,17 +4391,15 @@ my_bool STDCALL mysql_stmt_close(MYSQL_STMT *stmt)
my_bool error=0; my_bool error=0;
DBUG_ENTER("mysql_stmt_close"); DBUG_ENTER("mysql_stmt_close");
if (stmt->state != MY_ST_UNKNOWN)
{ {
char buff[4]; char buff[4];
int4store(buff, stmt->stmt_id); int4store(buff, stmt->stmt_id);
error= simple_command(stmt->mysql, COM_CLOSE_STMT, buff, 4, 0); error= simple_command(stmt->mysql, COM_CLOSE_STMT, buff, 4, 0);
} }
} mysql_free_result(stmt->result);
free_root(&stmt->mem_root, MYF(0)); free_root(&stmt->mem_root, MYF(0));
my_free((gptr) stmt->query, MYF(MY_WME | MY_ALLOW_ZERO_PTR)); my_free((gptr) stmt->query, MYF(MY_WME | MY_ALLOW_ZERO_PTR));
my_free((gptr) stmt->query, MYF(MY_WME | MY_ALLOW_ZERO_PTR));
my_free((gptr) stmt->bind, MY_ALLOW_ZERO_PTR);
my_free((gptr) stmt, MYF(MY_WME)); my_free((gptr) stmt, MYF(MY_WME));
DBUG_RETURN(error); DBUG_RETURN(error);
} }

20
libmysql/libmysql.def
View File

@ -102,8 +102,24 @@ EXPORTS
mysql_add_slave mysql_add_slave
mysql_warning_count mysql_warning_count
mysql_warnings mysql_warnings
mysql_prepare
mysql_execute
mysql_param_count
mysql_bind_param
mysql_bind_result
mysql_prepare_result
mysql_stmt_close
mysql_stmt_error
mysql_stmt_errno
mysql_fetch
mysql_send_long_data
mysql_multi_query
mysql_next_result
mysql_commit
mysql_rollback
mysql_autocommit

17
sql/item.cc
View File

@ -315,32 +315,27 @@ void Item_param::set_null()
void Item_param::set_int(longlong i) void Item_param::set_int(longlong i)
{ {
int_value=(longlong)i; int_value=(longlong)i;
item_result_type = INT_RESULT;
item_type = INT_ITEM; item_type = INT_ITEM;
} }
void Item_param::set_double(double value) void Item_param::set_double(double value)
{ {
real_value=value; real_value=value;
item_result_type = REAL_RESULT;
item_type = REAL_ITEM; item_type = REAL_ITEM;
} }
void Item_param::set_value(const char *str, uint length, CHARSET_INFO *cs) void Item_param::set_value(const char *str, uint length)
{ {
str_value.set(str,length,cs); str_value.set(str,length,thd_charset());
item_result_type = STRING_RESULT;
item_type = STRING_ITEM; item_type = STRING_ITEM;
} }
void Item_param::set_longdata(const char *str, ulong length, CHARSET_INFO *cs) void Item_param::set_longdata(const char *str, ulong length)
{ {
/* TODO: Fix this for binary handling by making use of str_value.append(str,length);
buffer_type.. long_data_supplied= 1;
*/
str_value.append(str,length);
} }

13
sql/item.h
View File

@ -186,8 +186,8 @@ public:
Item_param(char *name_par=0) Item_param(char *name_par=0)
{ {
name= name_par ? name_par : (char*) "?"; name= name_par ? name_par : (char*) "?";
long_data_supplied = false; long_data_supplied= false;
item_type = STRING_ITEM; item_type= STRING_ITEM;
item_result_type = STRING_RESULT; item_result_type = STRING_RESULT;
} }
enum Type type() const { return item_type; } enum Type type() const { return item_type; }
@ -199,12 +199,13 @@ public:
void set_null(); void set_null();
void set_int(longlong i); void set_int(longlong i);
void set_double(double i); void set_double(double i);
void set_value(const char *str, uint length, CHARSET_INFO *cs); void set_value(const char *str, uint length);
void set_long_str(const char *str, ulong length, CHARSET_INFO *cs); void set_long_str(const char *str, ulong length);
void set_long_binary(const char *str, ulong length, CHARSET_INFO *cs); void set_long_binary(const char *str, ulong length);
void set_longdata(const char *str, ulong length, CHARSET_INFO *cs); void set_longdata(const char *str, ulong length);
void set_long_end(); void set_long_end();
void reset() {} void reset() {}
void (*setup_param_func)(Item_param *param, uchar **pos);
enum Item_result result_type () const enum Item_result result_type () const
{ return item_result_type; } { return item_result_type; }
Item *new_item() { return new Item_param(name); } Item *new_item() { return new Item_param(name); }

2
sql/mysql_priv.h
View File

@ -509,7 +509,7 @@ int mysqld_show_column_types(THD *thd);
int mysqld_help (THD *thd, const char *text); int mysqld_help (THD *thd, const char *text);
/* sql_prepare.cc */ /* sql_prepare.cc */
int compare_prep_stmt(PREP_STMT *a, PREP_STMT *b, void *not_used); int compare_prep_stmt(void *not_used, PREP_STMT *stmt, ulong *key);
void free_prep_stmt(PREP_STMT *stmt, TREE_FREE mode, void *not_used); void free_prep_stmt(PREP_STMT *stmt, TREE_FREE mode, void *not_used);
bool mysql_stmt_prepare(THD *thd, char *packet, uint packet_length); bool mysql_stmt_prepare(THD *thd, char *packet, uint packet_length);
void mysql_stmt_execute(THD *thd, char *packet); void mysql_stmt_execute(THD *thd, char *packet);

3
sql/sql_class.h
View File

@ -325,7 +325,7 @@ typedef struct st_prep_stmt
uint param_count; uint param_count;
uint last_errno; uint last_errno;
char last_error[MYSQL_ERRMSG_SIZE]; char last_error[MYSQL_ERRMSG_SIZE];
bool error_in_prepare, long_data_used; bool error_in_prepare, long_data_used, param_inited;
} PREP_STMT; } PREP_STMT;
@ -510,7 +510,6 @@ public:
bool safe_to_cache_query; bool safe_to_cache_query;
bool volatile killed; bool volatile killed;
bool prepare_command; bool prepare_command;
Item_param *params; // Pointer to array of params
/* /*
If we do a purge of binary logs, log index info of the threads If we do a purge of binary logs, log index info of the threads

2
sql/sql_error.cc
View File

@ -115,7 +115,7 @@ static const char *warning_level_names[]= {"Note", "Warning", "Error", "?"};
my_bool mysqld_show_warnings(THD *thd, ulong levels_to_show) my_bool mysqld_show_warnings(THD *thd, ulong levels_to_show)
{ {
List<Item> field_list; List<Item> field_list;
DBUG_ENTER("mysqld_show_errors"); DBUG_ENTER("mysqld_show_warnings");
field_list.push_back(new Item_empty_string("Level", 7)); field_list.push_back(new Item_empty_string("Level", 7));
field_list.push_back(new Item_int("Code",0,4)); field_list.push_back(new Item_int("Code",0,4));

317
sql/sql_prepare.cc
View File

@ -30,10 +30,11 @@ Prepare:
Prepare-execute: Prepare-execute:
- Server gets the command 'COM_EXECUTE' to execute the - Server gets the command 'COM_EXECUTE' to execute the
previously prepared query. previously prepared query. If there is any param markers; then client
- If there is are any parameters, then replace the markers with the will send the data in the following format:
data supplied by client with the following format: [null_bits][types_specified(0/1)][[length][data]][[length][data] .. [length][data].
[types_specified(0/1)][type][length][data] .. [type][length].. - Replace the param items with this new data. If it is a first execute
or types altered by client; then setup the conversion routines.
- Execute the query without re-parsing and send back the results - Execute the query without re-parsing and send back the results
to client to client
@ -53,33 +54,9 @@ Long data handling:
#include <assert.h> // for DEBUG_ASSERT() #include <assert.h> // for DEBUG_ASSERT()
#include <m_ctype.h> // for isspace() #include <m_ctype.h> // for isspace()
extern int yyparse(void); #define IS_PARAM_NULL(pos, param_no) pos[param_no/8] & (1 << param_no & 7)
static ulong get_param_length(uchar **packet);
static uint get_buffer_type(uchar **packet);
static bool param_is_null(uchar **packet);
static bool setup_param_fields(THD *thd,List<Item> &params);
static uchar* setup_param_field(Item_param *item_param, uchar *pos,
uint buffer_type);
static void setup_longdata_field(Item_param *item_param, uchar *pos);
static bool setup_longdata(THD *thd,List<Item> &params);
static bool send_prepare_results(PREP_STMT *stmt);
static bool parse_prepare_query(PREP_STMT *stmt, char *packet, uint length);
static bool mysql_send_insert_fields(PREP_STMT *stmt, TABLE_LIST *table_list,
List<Item> &fields,
List<List_item> &values_list,
thr_lock_type lock_type);
static bool mysql_test_insert_fields(PREP_STMT *stmt, TABLE_LIST *table_list,
List<Item> &fields,
List<List_item> &values_list,
thr_lock_type lock_type);
static bool mysql_test_upd_fields(PREP_STMT *stmt, TABLE_LIST *table_list,
List<Item> &fields, List<Item> &values,
COND *conds,thr_lock_type lock_type);
static bool mysql_test_select_fields(PREP_STMT *stmt, TABLE_LIST *tables,
List<Item> &fields, List<Item> &values,
COND *conds, ORDER *order, ORDER *group,
Item *having,thr_lock_type lock_type);
extern int yyparse(void);
/* /*
Find prepared statement in thd Find prepared statement in thd
@ -114,9 +91,9 @@ static PREP_STMT *find_prepared_statement(THD *thd, ulong stmt_id,
Compare two prepared statements; Used to find a prepared statement Compare two prepared statements; Used to find a prepared statement
*/ */
int compare_prep_stmt(PREP_STMT *a, PREP_STMT *b, void *not_used) int compare_prep_stmt(void *not_used, PREP_STMT *stmt, ulong *key)
{ {
return (a->stmt_id < b->stmt_id) ? -1 : (a->stmt_id == b->stmt_id) ? 0 : 1; return (stmt->stmt_id == *key) ? 0 : (stmt->stmt_id < *key) ? -1 : 1;
} }
@ -132,22 +109,23 @@ int compare_prep_stmt(PREP_STMT *a, PREP_STMT *b, void *not_used)
*/ */
void free_prep_stmt(PREP_STMT *stmt, TREE_FREE mode, void *not_used) void free_prep_stmt(PREP_STMT *stmt, TREE_FREE mode, void *not_used)
{ {
free_root(&stmt->mem_root, MYF(0));
free_items(stmt->free_list); free_items(stmt->free_list);
free_root(&stmt->mem_root, MYF(0));
} }
/* /*
Send prepared stmt info to client after prepare Send prepared stmt info to client after prepare
*/ */
bool send_prep_stmt(PREP_STMT *stmt, uint columns) static bool send_prep_stmt(PREP_STMT *stmt, uint columns)
{ {
NET *net=&stmt->thd->net;
char buff[8]; char buff[8];
int4store(buff, stmt->stmt_id); int4store(buff, stmt->stmt_id);
int2store(buff+4, columns); int2store(buff+4, columns);
int2store(buff+6, stmt->param_count); int2store(buff+6, stmt->param_count);
return my_net_write(&stmt->thd->net, buff, sizeof(buff)); return (my_net_write(net, buff, sizeof(buff)) || net_flush(net));
} }
/* /*
@ -156,43 +134,15 @@ bool send_prep_stmt(PREP_STMT *stmt, uint columns)
TODO: Not yet ready TODO: Not yet ready
*/ */
bool send_item_params(PREP_STMT *stmt) static bool send_item_params(PREP_STMT *stmt)
{ {
#if 0
char buff[1]; char buff[1];
buff[0]=0; buff[0]=0;
return my_net_write(&stmt->thd->net, buff, sizeof(buff)); if (my_net_write(&stmt->thd->net, buff, sizeof(buff)))
}
/*
Read the buffer type, this happens only first time
*/
static uint get_buffer_type(uchar **packet)
{
reg1 uchar *pos= *packet;
(*packet)+= 2;
return (uint) uint2korr(pos);
}
/*
Check for NULL param data
RETURN VALUES
0 Value was not NULL
1 Value was NULL
*/
static bool param_is_null(uchar **packet)
{
reg1 uchar *pos= *packet;
if (*pos == 251)
{
(*packet)++;
return 1; return 1;
} send_eof(stmt->thd);
#endif
return 0; return 0;
} }
@ -222,60 +172,103 @@ static ulong get_param_length(uchar **packet)
(*packet)+=9; // Must be 254 when here (*packet)+=9; // Must be 254 when here
return (ulong) uint4korr(pos+1); return (ulong) uint4korr(pos+1);
} }
/*
Setup param conversion routines
/* setup_param_xx()
Read and return the data for parameters supplied by client param Parameter Item
pos Input data buffer
All these functions reads the data from pos and sets up that data
through 'param' and advances the buffer position to predifined
length position.
Make a note that the NULL handling is examined at first execution
(i.e. when input types altered) and for all subsequent executions
we don't read any values for this.
RETURN VALUES
*/ */
static uchar* setup_param_field(Item_param *item_param, static void setup_param_tiny(Item_param *param, uchar **pos)
uchar *pos, uint buffer_type)
{ {
if (param_is_null(&pos)) param->set_int((longlong)(**pos));
{ *pos+= 1;
item_param->set_null(); }
return(pos);
} static void setup_param_short(Item_param *param, uchar **pos)
switch (buffer_type) { {
param->set_int((longlong)sint2korr(*pos));
*pos+= 2;
}
static void setup_param_int32(Item_param *param, uchar **pos)
{
param->set_int((longlong)sint4korr(*pos));
*pos+= 4;
}
static void setup_param_int64(Item_param *param, uchar **pos)
{
param->set_int((longlong)sint8korr(*pos));
*pos+= 8;
}
static void setup_param_float(Item_param *param, uchar **pos)
{
float data;
float4get(data,*pos);
param->set_double((double) data);
*pos+= 4;
}
static void setup_param_double(Item_param *param, uchar **pos)
{
double data;
float8get(data,*pos);
param->set_double((double) data);
*pos+= 8;
}
static void setup_param_str(Item_param *param, uchar **pos)
{
ulong len=get_param_length(pos);
param->set_value((const char *)*pos, len);
*pos+=len;
}
static void setup_param_functions(Item_param *param, uchar read_pos)
{
switch (read_pos) {
case FIELD_TYPE_TINY: case FIELD_TYPE_TINY:
item_param->set_int((longlong)(*pos)); param->setup_param_func= setup_param_tiny;
pos += 1; param->item_result_type = INT_RESULT;
break; break;
case FIELD_TYPE_SHORT: case FIELD_TYPE_SHORT:
item_param->set_int((longlong)sint2korr(pos)); param->setup_param_func= setup_param_short;
pos += 2; param->item_result_type = INT_RESULT;
break;
case FIELD_TYPE_INT24:
item_param->set_int((longlong)sint4korr(pos));
pos += 3;
break; break;
case FIELD_TYPE_LONG: case FIELD_TYPE_LONG:
item_param->set_int((longlong)sint4korr(pos)); param->setup_param_func= setup_param_int32;
pos += 4; param->item_result_type = INT_RESULT;
break; break;
case FIELD_TYPE_LONGLONG: case FIELD_TYPE_LONGLONG:
item_param->set_int((longlong)sint8korr(pos)); param->setup_param_func= setup_param_int64;
pos += 8; param->item_result_type = INT_RESULT;
break; break;
case FIELD_TYPE_FLOAT: case FIELD_TYPE_FLOAT:
float data; param->setup_param_func= setup_param_float;
float4get(data,pos); param->item_result_type = REAL_RESULT;
item_param->set_double((double) data);
pos += 4;
break; break;
case FIELD_TYPE_DOUBLE: case FIELD_TYPE_DOUBLE:
double j; param->setup_param_func= setup_param_double;
float8get(j,pos) param->item_result_type = REAL_RESULT;
item_param->set_double(j);
pos += 8;
break; break;
default: default:
{ param->setup_param_func= setup_param_str;
ulong len=get_param_length(&pos); param->item_result_type = STRING_RESULT;
item_param->set_value((const char*)pos,len,current_thd->thd_charset);
pos+=len;
}
} }
return(pos);
} }
/* /*
@ -283,42 +276,45 @@ static uchar* setup_param_field(Item_param *item_param,
from client .. from client ..
*/ */
static bool setup_param_fields(THD *thd, PREP_STMT *stmt) static bool setup_params_data(THD *thd, PREP_STMT *stmt)
{ {
DBUG_ENTER("setup_param_fields"); List<Item> &params= thd->lex.param_list;
#ifdef READY_TO_BE_USED List_iterator<Item> param_iterator(params);
Item_param *item_param; Item_param *param;
ulong param_count=0; DBUG_ENTER("setup_params_data");
uchar *pos=(uchar*) thd->net.read_pos+1;// skip command type
uchar *pos=(uchar*) thd->net.read_pos+1+MYSQL_STMT_HEADER; //skip header
if (*pos++) // No types supplied, read only param data uchar *read_pos= pos+(stmt->param_count+7) / 8; //skip null bits
{ ulong param_no;
while ((item_param=(Item_param *)it++) &&
(param_count++ < stmt->param_count))
{
if (item_param->long_data_supplied)
continue;
if (!(pos=setup_param_field(item_param,pos,item_param->buffer_type))) if (*read_pos++) //types supplied / first execute
DBUG_RETURN(1); {
/*
First execute or types altered by the client, setup the
conversion routines for all parameters (one time)
*/
while ((param= (Item_param *)param_iterator++))
{
if (!param->long_data_supplied)
{
setup_param_functions(param,*read_pos);
read_pos+= 2;
}
} }
} param_iterator.rewind();
else // Types supplied, read and store it along with param data }
param_no= 0;
while ((param= (Item_param *)param_iterator++))
{ {
while ((item_param=(Item_param *)it++) && if (!param->long_data_supplied)
(param_count++ < thd->param_count))
{ {
if (item_param->long_data_supplied) if (IS_PARAM_NULL(pos,param_no))
continue; param->maybe_null=param->null_value=1;
else
if (!(pos=setup_param_field(item_param,pos, param->setup_param_func(param,&read_pos);
item_param->buffer_type=
(enum_field_types) get_buffer_type(&pos))))
DBUG_RETURN(1);
} }
param_no++;
} }
#endif
DBUG_RETURN(0); DBUG_RETURN(0);
} }
@ -583,6 +579,8 @@ static bool send_prepare_results(PREP_STMT *stmt)
Rest fall through to default category, no parsing Rest fall through to default category, no parsing
for non-DML statements for non-DML statements
*/ */
if (send_prep_stmt(stmt, 0))
goto abort;
} }
} }
DBUG_RETURN(0); DBUG_RETURN(0);
@ -597,7 +595,7 @@ abort:
*/ */
static bool parse_prepare_query(PREP_STMT *stmt, static bool parse_prepare_query(PREP_STMT *stmt,
char *packet, uint length) char *packet, uint length)
{ {
bool error= 1; bool error= 1;
THD *thd= stmt->thd; THD *thd= stmt->thd;
@ -607,6 +605,7 @@ static bool parse_prepare_query(PREP_STMT *stmt,
mysql_init_query(thd); mysql_init_query(thd);
thd->prepare_command=true; thd->prepare_command=true;
thd->safe_to_cache_query= 0; thd->safe_to_cache_query= 0;
thd->lex.param_count=0;
LEX *lex=lex_start(thd, (uchar*) packet, length); LEX *lex=lex_start(thd, (uchar*) packet, length);
if (!yyparse() && !thd->fatal_error) if (!yyparse() && !thd->fatal_error)
@ -615,6 +614,25 @@ static bool parse_prepare_query(PREP_STMT *stmt,
DBUG_RETURN(error); DBUG_RETURN(error);
} }
/*
Initialize parameter items in statement
*/
static bool init_param_items(THD *thd, PREP_STMT *stmt)
{
#if TO_BE_TESTED
Item_param **to;
if (!(to= (Item_param *)
my_malloc(sizeof(Item_param*) * stmt->param_count, MYF(MY_WME))))
return 1;
List<Item> &params= thd->lex.param_list;
List_iterator<Item> param_iterator(params);
while ((to++ = (Item_param *)param_iterator++))
{
DBUG_PRINT("info",("param: %lx", to));
}
return 0;
#endif
}
/* /*
Parse the query and send the total number of parameters Parse the query and send the total number of parameters
@ -648,10 +666,15 @@ bool mysql_stmt_prepare(THD *thd, char *packet, uint packet_length)
goto err; goto err;
if (!(specialflag & SPECIAL_NO_PRIOR)) if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(),WAIT_PRIOR); my_pthread_setprio(pthread_self(),WAIT_PRIOR);
#if 0
stmt.mem_root= thd->mem_root; if (init_param_items(thd, &stmt))
goto err;
#endif
stmt.mem_root= thd->mem_root;
tree_insert(&thd->prepared_statements, (void *)&stmt, 0, (void *)0);
thd->mem_root= thd_root; // restore main mem_root thd->mem_root= thd_root; // restore main mem_root
thd->last_prepared_stmt= &stmt;
DBUG_RETURN(0); DBUG_RETURN(0);
err: err:
@ -685,11 +708,11 @@ void mysql_stmt_execute(THD *thd, char *packet)
/* Check if we got an error when sending long data */ /* Check if we got an error when sending long data */
if (stmt->error_in_prepare) if (stmt->error_in_prepare)
{ {
send_error(thd); send_error(thd, stmt->last_errno, stmt->last_error);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
if (stmt->param_count && setup_param_fields(thd, stmt)) if (stmt->param_count && setup_params_data(thd, stmt))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
MEM_ROOT thd_root= thd->mem_root; MEM_ROOT thd_root= thd->mem_root;
@ -705,6 +728,8 @@ void mysql_stmt_execute(THD *thd, char *packet)
*/ */
mysql_execute_command(thd); mysql_execute_command(thd);
thd->last_prepared_stmt= stmt;
if (!(specialflag & SPECIAL_NO_PRIOR)) if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(), WAIT_PRIOR); my_pthread_setprio(pthread_self(), WAIT_PRIOR);
@ -768,8 +793,10 @@ void mysql_stmt_close(THD *thd, char *packet)
send_error(thd); send_error(thd);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
stmt->param= 0;
my_free((char *)stmt->param, MYF(MY_ALLOW_ZERO_PTR));
/* Will call free_prep_stmt() */ /* Will call free_prep_stmt() */
tree_delete(&thd->prepared_statements, (void*) stmt, NULL); tree_delete(&thd->prepared_statements, (void*) &stmt, (void *)0);
thd->last_prepared_stmt=0; thd->last_prepared_stmt=0;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -800,17 +827,16 @@ void mysql_stmt_get_longdata(THD *thd, char *pos, ulong packet_length)
DBUG_ENTER("mysql_stmt_get_longdata"); DBUG_ENTER("mysql_stmt_get_longdata");
/* The following should never happen */ /* The following should never happen */
if (packet_length < 9) if (packet_length < MYSQL_LONG_DATA_HEADER+1)
{ {
my_error(ER_WRONG_ARGUMENTS, MYF(0), "get_longdata"); my_error(ER_WRONG_ARGUMENTS, MYF(0), "get_longdata");
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
pos++; // skip command type at first position
ulong stmt_id= uint4korr(pos); ulong stmt_id= uint4korr(pos);
uint param_number= uint2korr(pos+4); uint param_number= uint2korr(pos+4);
uint param_type= uint2korr(pos+6); uint param_type= uint2korr(pos+6);
pos+=8; // Point to data pos+=MYSQL_LONG_DATA_HEADER; // Point to data
if (!(stmt=find_prepared_statement(thd, stmt_id, "get_longdata"))) if (!(stmt=find_prepared_statement(thd, stmt_id, "get_longdata")))
{ {
@ -829,7 +855,8 @@ void mysql_stmt_get_longdata(THD *thd, char *pos, ulong packet_length)
sprintf(stmt->last_error, ER(ER_WRONG_ARGUMENTS), "get_longdata"); sprintf(stmt->last_error, ER(ER_WRONG_ARGUMENTS), "get_longdata");
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
stmt->param[param_number].set_longdata(pos, packet_length-9, current_thd->thd_charset); stmt->param[param_number].set_longdata(pos, packet_length-9);
stmt->long_data_used= 1; stmt->long_data_used= 1;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }