summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--libmysql/errmsg.c6
-rw-r--r--libmysql/libmysql.c289
-rw-r--r--libmysql/libmysql.def20
-rw-r--r--sql/item.cc17
-rw-r--r--sql/item.h13
-rw-r--r--sql/mysql_priv.h2
-rw-r--r--sql/sql_class.h3
-rw-r--r--sql/sql_error.cc2
-rw-r--r--sql/sql_prepare.cc317
9 files changed, 397 insertions, 272 deletions
diff --git a/libmysql/errmsg.c b/libmysql/errmsg.c
index 0945aed6772..4b8613f460d 100644
--- a/libmysql/errmsg.c
+++ b/libmysql/errmsg.c
@@ -58,7 +58,7 @@ const char *client_errors[]=
"No parameters exists in the statement",
"Invalid parameter number",
"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)",
"Can't open shared memory. Request 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",
"Invalid parameter number",
"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)",
"Can't open shared memory. Request 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",
"Invalid parameter number",
"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)",
"Can't open shared memory. Request event don't create (%lu)",
"Can't open shared memory. Answer event don't create (%lu)",
diff --git a/libmysql/libmysql.c b/libmysql/libmysql.c
index 0bb6b54bee5..0912f8997f9 100644
--- a/libmysql/libmysql.c
+++ b/libmysql/libmysql.c
@@ -927,7 +927,8 @@ static const char *default_options[]=
"character-sets-dir", "default-character-set", "interactive-timeout",
"connect-timeout", "local-infile", "disable-local-infile",
"replication-probe", "enable-reads-from-master", "repl-parse-query",
- "ssl-cipher","protocol", "shared_memory_base_name",
+ "ssl-cipher","protocol",
+ "shared_memory_base_name",
NullS
};
@@ -1736,11 +1737,10 @@ mysql_ssl_set(MYSQL *mysql __attribute__((unused)) ,
Free strings in the SSL structure and clear 'use_ssl' flag.
NB! Errors are not reported until you do mysql_real_connect.
**************************************************************************/
-
static void
mysql_ssl_free(MYSQL *mysql __attribute__((unused)))
{
-#ifdef HAVE_OPENSSL
+#ifdef HAVE_OPENSLL
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_ca, MYF(MY_ALLOW_ZERO_PTR));
@@ -1754,7 +1754,7 @@ mysql_ssl_free(MYSQL *mysql __attribute__((unused)))
mysql->options.ssl_cipher= 0;
mysql->options.use_ssl = FALSE;
mysql->connector_fd = 0;
-#endif /* HAVE_OPENSSL */
+#endif /* HAVE_OPENSLL */
}
/**************************************************************************
@@ -2567,7 +2567,7 @@ get_info:
{
mysql->affected_rows= net_field_length_ll(&pos);
mysql->insert_id= net_field_length_ll(&pos);
- if (mysql->server_capabilities & CLIENT_PROTOCOL_41)
+ if (protocol_41(mysql))
{
mysql->server_status=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_STMT *stmt;
- DBUG_ENTER("mysql_real_prepare");
+ DBUG_ENTER("mysql_prepare");
DBUG_ASSERT(mysql != 0);
-#ifdef EXTRA_CHECK_ARGUMENTS
+#ifdef CHECK_EXTRA_ARGUMENTS
if (!query)
{
set_mysql_error(mysql, CR_NULL_POINTER);
@@ -3674,7 +3674,6 @@ mysql_prepare(MYSQL *mysql, const char *query, ulong length)
mysql_stmt_close(stmt);
DBUG_RETURN(0);
}
- stmt->state= MY_ST_PREPARE;
init_alloc_root(&stmt->mem_root,8192,0);
if (read_prepare_result(mysql, stmt))
@@ -3682,8 +3681,8 @@ mysql_prepare(MYSQL *mysql, const char *query, ulong length)
mysql_stmt_close(stmt);
DBUG_RETURN(0);
}
-
- stmt->mysql= mysql;
+ stmt->state= MY_ST_PREPARE;
+ stmt->mysql= mysql;
DBUG_PRINT("info", ("Parameter count: %ld", stmt->param_count));
DBUG_RETURN(stmt);
}
@@ -3819,7 +3818,7 @@ static void store_param_str(NET *net, MYSQL_BIND *param)
ulong length= *param->length;
char *to= (char *) net_store_length((char *) net->write_pos, length);
memcpy(to, param->buffer, length);
- net->write_pos+= 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;
NET *net = &mysql->net;
DBUG_ENTER("store_param");
- DBUG_PRINT("enter",("type : %d, buffer :%lx", param->buffer_type,
- param->buffer));
-
- /* Allocate for worst case (long string) */
- if ((my_realloc_str(net, 9 + *param->length)))
- return 1;
- if (!param->buffer)
+ DBUG_PRINT("enter",("type: %d, buffer:%lx, length: %d", param->buffer_type,
+ param->buffer ? param->buffer : "0", *param->length));
+
+ if (param->is_null || param->buffer_type == MYSQL_TYPE_NULL)
store_param_null(net, param);
else
+ {
+ /* Allocate for worst case (long string) */
+ if ((my_realloc_str(net, 9 + *param->length)))
+ DBUG_RETURN(1);
(*param->store_param_func)(net, param);
- DBUG_RETURN(1);
+ }
+ DBUG_RETURN(0);
}
@@ -3875,13 +3876,13 @@ static my_bool execute(MYSQL_STMT * stmt, char *packet, ulong length)
{
MYSQL *mysql= stmt->mysql;
NET *net= &mysql->net;
- char buff[4];
+ char buff[MYSQL_STMT_HEADER];
DBUG_ENTER("execute");
DBUG_PRINT("enter",("packet: %s, length :%d",packet ? packet :" ", length));
mysql->last_used_con= mysql;
int4store(buff, stmt->stmt_id); /* Send stmt id to server */
- if (advanced_command(mysql, COM_EXECUTE, buff, sizeof(buff), packet,
+ if (advanced_command(mysql, COM_EXECUTE, buff, MYSQL_STMT_HEADER, packet,
length, 1) ||
mysql_read_query_result(mysql))
{
@@ -3889,12 +3890,14 @@ static my_bool execute(MYSQL_STMT * stmt, char *packet, ulong length)
DBUG_RETURN(1);
}
stmt->state= MY_ST_EXECUTE;
-
- if (stmt->bind)
+ mysql_free_result(stmt->result);
+#if USED_IN_FETCH
+ if (stmt->res_buffers) /* Result buffers exists, cache results */
{
mysql_free_result(stmt->result);
stmt->result= mysql_store_result(mysql);
}
+ #endif
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)
{
- ulong length;
- uint null_count;
DBUG_ENTER("mysql_execute");
if (stmt->state == MY_ST_UNKNOWN)
@@ -3920,14 +3921,18 @@ int STDCALL mysql_execute(MYSQL_STMT *stmt)
NET *net= &stmt->mysql->net;
MYSQL_BIND *param, *param_end;
char *param_data;
- my_bool result;
+ ulong length;
+ uint null_count;
+ my_bool result;
- if (!stmt->params)
+#ifdef CHECK_EXTRA_ARGUMENTS
+ if (!stmt->param_buffers)
{
/* Parameters exists, but no bound buffers */
set_stmt_error(stmt, CR_NOT_ALL_PARAMS_BOUND);
DBUG_RETURN(1);
}
+#endif
net_clear(net); /* Sets net->write_pos */
/* Reserve place for null-marker bytes */
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;
/* In case if buffers (type) altered, indicate to server */
- *(net->write_pos)++= (uchar) stmt->types_supplied;
- if (!stmt->types_supplied)
+ *(net->write_pos)++= (uchar) stmt->send_types_to_server;
+ if (stmt->send_types_to_server)
{
- stmt->types_supplied=1;
/*
Store types of parameters in first in first package
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 */
if (param->is_long_data)
{
- if (!param->long_ended)
- DBUG_RETURN(MYSQL_NEED_DATA);
+ if (!param->long_ended)
+ DBUG_RETURN(MYSQL_NEED_DATA);
}
else if (store_param(stmt, param))
- DBUG_RETURN(1);
+ DBUG_RETURN(1);
}
length= (ulong) (net->write_pos - net->buff);
/* TODO: Look into avoding the following memdup */
- if (!(param_data= my_memdup((byte *) net->buff, length, MYF(0))))
+ if (!(param_data= my_memdup( net->buff, length, MYF(0))))
{
set_stmt_error(stmt, CR_OUT_OF_MEMORY);
DBUG_RETURN(1);
}
net->write_pos= net->buff; /* Reset for net_write() */
result= execute(stmt, param_data, length);
+ stmt->send_types_to_server=0;
my_free(param_data, MYF(MY_WME));
DBUG_RETURN(result);
}
@@ -4030,15 +4035,19 @@ my_bool STDCALL mysql_bind_param(MYSQL_STMT *stmt, MYSQL_BIND * bind)
param->param_number);
DBUG_RETURN(1);
}
+
/*
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
*/
if (!param->length)
param->length= &param->bind_length;
-
+
/* Setup data copy functions for the different supported types */
switch (param->buffer_type) {
+ case MYSQL_TYPE_NULL:
+ param->is_null=1;
+ break;
case MYSQL_TYPE_TINY:
param->bind_length= 1;
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;
break;
case MYSQL_TYPE_DOUBLE:
- param->bind_length= 4;
+ param->bind_length= 8;
param->store_param_func= store_param_double;
break;
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->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 */
- stmt->types_supplied= 0;
+ stmt->send_types_to_server= 1;
+ stmt->param_buffers= 1;
DBUG_RETURN(0);
}
@@ -4152,6 +4163,73 @@ mysql_send_long_data(MYSQL_STMT *stmt, uint param_number,
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
*/
@@ -4163,21 +4241,62 @@ my_bool STDCALL mysql_bind_result(MYSQL_STMT *stmt, MYSQL_BIND *bind)
DBUG_ENTER("mysql_bind_result");
DBUG_ASSERT(stmt != 0);
-#ifdef EXTRA_CHECK_ARGUMENTS
+#ifdef CHECK_EXTRA_ARGUMENTS
if (!bind)
{
set_stmt_error(stmt, CR_NULL_POINTER);
DBUG_RETURN(1);
}
#endif
- bind_count= stmt->result->field_count;
+ bind_count= stmt->field_count;
memcpy((char*) stmt->bind, (char*) bind,
sizeof(MYSQL_BIND)*bind_count);
for (param= stmt->bind, end= param+bind_count; param < end ; param++)
{
- /* TODO: Set up convert functions like in mysql_bind_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);
}
@@ -4187,16 +4306,16 @@ my_bool STDCALL mysql_bind_result(MYSQL_STMT *stmt, MYSQL_BIND *bind)
*/
static my_bool
-my_fetch_row(MYSQL_STMT *stmt, MYSQL_RES *result, const byte *row)
+stmt_fetch_row(MYSQL_STMT *stmt, uchar **row)
{
MYSQL_BIND *bind, *end;
- uchar *null_ptr= (uchar*) row, bit;
-
- result->row_count++;
- row+= (result->field_count+7)/8;
- /* Copy complete row to application buffers */
+ uchar *null_ptr= (uchar*) *row, bit;
+
+ *row+= (stmt->field_count+7)/8;
bit=1;
- for (bind= stmt->bind, end= (MYSQL_BIND *) bind + result->field_count;
+
+ /* Copy complete row to application buffers */
+ for (bind= stmt->bind, end= (MYSQL_BIND *) bind + stmt->field_count;
bind < end;
bind++)
{
@@ -4205,7 +4324,7 @@ my_fetch_row(MYSQL_STMT *stmt, MYSQL_RES *result, const byte *row)
else
{
bind->is_null= 0;
- row= (byte*) (*bind->fetch_result)(bind, (char*) row);
+ (*bind->fetch_result)(bind, row);
}
if (! (bit<<=1) & 255)
{
@@ -4216,12 +4335,9 @@ my_fetch_row(MYSQL_STMT *stmt, MYSQL_RES *result, const byte *row)
return 0;
}
-
-static int
-read_binary_data(MYSQL *mysql)
-{
- ulong pkt_len;
- if ((pkt_len= net_safe_read(mysql)) == packet_error)
+static int read_binary_data(MYSQL *mysql)
+{
+ if (packet_error == net_safe_read(mysql))
return -1;
if (mysql->net.read_pos[0])
return 1; /* End of data */
@@ -4235,57 +4351,30 @@ read_binary_data(MYSQL *mysql)
int STDCALL mysql_fetch(MYSQL_STMT *stmt)
{
- MYSQL_RES *result;
+ MYSQL *mysql= stmt->mysql;
DBUG_ENTER("mysql_fetch");
- result= stmt->result;
- if (!result)
- DBUG_RETURN(MYSQL_NO_DATA);
-
- if (!result->data)
+ if (stmt->res_buffers)
{
- MYSQL *mysql= stmt->mysql;
- if (!result->eof)
+ int res;
+ if (!(res= read_binary_data(mysql)))
{
- int res;
- if (!(res= read_binary_data(result->handle)))
- DBUG_RETURN((int) my_fetch_row(stmt, result,
- (byte*) mysql->net.read_pos+1));
- DBUG_PRINT("info", ("end of data"));
- result->eof= 1;
- result->handle->status= MYSQL_STATUS_READY;
-
- /* Don't clear handle in mysql_free_results */
- result->handle= 0;
- if (res < 0) /* Network error */
- {
- set_stmt_errmsg(stmt,(char *)mysql->net.last_error,
- mysql->net.last_errno);
- DBUG_RETURN(MYSQL_STATUS_ERROR);
- }
+ if (stmt->res_buffers)
+ DBUG_RETURN((int) stmt_fetch_row(stmt,(uchar **) &mysql->net.read_pos+1));
+ DBUG_RETURN(0);
}
- DBUG_RETURN(MYSQL_NO_DATA); /* no more data */
- }
- {
- /*
- 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"));
+ mysql->status= MYSQL_STATUS_READY;
+
+ if (res < 0) /* Network error */
{
- DBUG_PRINT("info", ("end of data"));
- result->current_row= (MYSQL_ROW) NULL;
- DBUG_RETURN(MYSQL_NO_DATA);
+ set_stmt_errmsg(stmt,(char *)mysql->net.last_error,
+ mysql->net.last_errno);
+ DBUG_RETURN(MYSQL_STATUS_ERROR);
}
- values= result->data_cursor->data;
- result->data_cursor= result->data_cursor->next;
-
- DBUG_RETURN((int) my_fetch_row(stmt,result, (byte*) values));
+ DBUG_RETURN(MYSQL_NO_DATA); /* no more data */
}
- DBUG_RETURN(0);
+ DBUG_RETURN(0); //?? do we need to set MYSQL_STATUS_READY ?
}
@@ -4302,17 +4391,15 @@ my_bool STDCALL mysql_stmt_close(MYSQL_STMT *stmt)
my_bool error=0;
DBUG_ENTER("mysql_stmt_close");
- if (stmt->state)
+ if (stmt->state != MY_ST_UNKNOWN)
{
char buff[4];
int4store(buff, stmt->stmt_id);
error= simple_command(stmt->mysql, COM_CLOSE_STMT, buff, 4, 0);
}
-
+ mysql_free_result(stmt->result);
free_root(&stmt->mem_root, MYF(0));
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->params, MY_ALLOW_ZERO_PTR);
my_free((gptr) stmt, MYF(MY_WME));
DBUG_RETURN(error);
}
diff --git a/libmysql/libmysql.def b/libmysql/libmysql.def
index a7fb4d378e5..0d650467665 100644
--- a/libmysql/libmysql.def
+++ b/libmysql/libmysql.def
@@ -102,8 +102,24 @@ EXPORTS
mysql_add_slave
mysql_warning_count
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
+
+
diff --git a/sql/item.cc b/sql/item.cc
index 48ec11d02c2..cd321488548 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -315,32 +315,27 @@ void Item_param::set_null()
void Item_param::set_int(longlong i)
{
int_value=(longlong)i;
- item_result_type = INT_RESULT;
item_type = INT_ITEM;
}
void Item_param::set_double(double value)
{
real_value=value;
- item_result_type = REAL_RESULT;
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);
- item_result_type = STRING_RESULT;
+ str_value.set(str,length,thd_charset());
item_type = STRING_ITEM;
}
-void Item_param::set_longdata(const char *str, ulong length, CHARSET_INFO *cs)
-{
- /* TODO: Fix this for binary handling by making use of
- buffer_type..
- */
- str_value.append(str,length);
+void Item_param::set_longdata(const char *str, ulong length)
+{
+ str_value.append(str,length);
+ long_data_supplied= 1;
}
diff --git a/sql/item.h b/sql/item.h
index c67c16c50ad..490317f9bc9 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -186,8 +186,8 @@ public:
Item_param(char *name_par=0)
{
name= name_par ? name_par : (char*) "?";
- long_data_supplied = false;
- item_type = STRING_ITEM;
+ long_data_supplied= false;
+ item_type= STRING_ITEM;
item_result_type = STRING_RESULT;
}
enum Type type() const { return item_type; }
@@ -199,12 +199,13 @@ public:
void set_null();
void set_int(longlong i);
void set_double(double i);
- void set_value(const char *str, uint length, CHARSET_INFO *cs);
- void set_long_str(const char *str, ulong length, CHARSET_INFO *cs);
- void set_long_binary(const char *str, ulong length, CHARSET_INFO *cs);
- void set_longdata(const char *str, ulong length, CHARSET_INFO *cs);
+ void set_value(const char *str, uint length);
+ void set_long_str(const char *str, ulong length);
+ void set_long_binary(const char *str, ulong length);
+ void set_longdata(const char *str, ulong length);
void set_long_end();
void reset() {}
+ void (*setup_param_func)(Item_param *param, uchar **pos);
enum Item_result result_type () const
{ return item_result_type; }
Item *new_item() { return new Item_param(name); }
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index c9b95963c32..98afe2681df 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -509,7 +509,7 @@ int mysqld_show_column_types(THD *thd);
int mysqld_help (THD *thd, const char *text);
/* 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);
bool mysql_stmt_prepare(THD *thd, char *packet, uint packet_length);
void mysql_stmt_execute(THD *thd, char *packet);
diff --git a/sql/sql_class.h b/sql/sql_class.h
index a619e8e3aff..20abfe64fe0 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -325,7 +325,7 @@ typedef struct st_prep_stmt
uint param_count;
uint last_errno;
char last_error[MYSQL_ERRMSG_SIZE];
- bool error_in_prepare, long_data_used;
+ bool error_in_prepare, long_data_used, param_inited;
} PREP_STMT;
@@ -510,7 +510,6 @@ public:
bool safe_to_cache_query;
bool volatile killed;
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
diff --git a/sql/sql_error.cc b/sql/sql_error.cc
index 3d6a0fa24aa..768c54c202e 100644
--- a/sql/sql_error.cc
+++ b/sql/sql_error.cc
@@ -115,7 +115,7 @@ static const char *warning_level_names[]= {"Note", "Warning", "Error", "?"};
my_bool mysqld_show_warnings(THD *thd, ulong levels_to_show)
{
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_int("Code",0,4));
diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc
index 08377a10501..4bc66778ffb 100644
--- a/sql/sql_prepare.cc
+++ b/sql/sql_prepare.cc
@@ -30,10 +30,11 @@ Prepare:
Prepare-execute:
- Server gets the command 'COM_EXECUTE' to execute the
- previously prepared query.
- - If there is are any parameters, then replace the markers with the
- data supplied by client with the following format:
- [types_specified(0/1)][type][length][data] .. [type][length]..
+ previously prepared query. If there is any param markers; then client
+ will send the data in the following format:
+ [null_bits][types_specified(0/1)][[length][data]][[length][data] .. [length][data].
+ - 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
to client
@@ -53,33 +54,9 @@ Long data handling:
#include <assert.h> // for DEBUG_ASSERT()
#include <m_ctype.h> // for isspace()
-extern int yyparse(void);
-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);
+#define IS_PARAM_NULL(pos, param_no) pos[param_no/8] & (1 << param_no & 7)
+extern int yyparse(void);
/*
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
*/
-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)
-{
- free_root(&stmt->mem_root, MYF(0));
+{
free_items(stmt->free_list);
+ free_root(&stmt->mem_root, MYF(0));
}
/*
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];
int4store(buff, stmt->stmt_id);
int2store(buff+4, columns);
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
*/
-bool send_item_params(PREP_STMT *stmt)
+static bool send_item_params(PREP_STMT *stmt)
{
+#if 0
char buff[1];
buff[0]=0;
- return 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)++;
+ if (my_net_write(&stmt->thd->net, buff, sizeof(buff)))
return 1;
- }
+ send_eof(stmt->thd);
+#endif
return 0;
}
@@ -222,60 +172,103 @@ static ulong get_param_length(uchar **packet)
(*packet)+=9; // Must be 254 when here
return (ulong) uint4korr(pos+1);
}
+ /*
+ Setup param conversion routines
-/*
- Read and return the data for parameters supplied by client
+ setup_param_xx()
+ 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,
- uchar *pos, uint buffer_type)
+static void setup_param_tiny(Item_param *param, uchar **pos)
{
- if (param_is_null(&pos))
- {
- item_param->set_null();
- return(pos);
- }
- switch (buffer_type) {
+ param->set_int((longlong)(**pos));
+ *pos+= 1;
+}
+
+static void setup_param_short(Item_param *param, uchar **pos)
+{
+ 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:
- item_param->set_int((longlong)(*pos));
- pos += 1;
+ param->setup_param_func= setup_param_tiny;
+ param->item_result_type = INT_RESULT;
break;
case FIELD_TYPE_SHORT:
- item_param->set_int((longlong)sint2korr(pos));
- pos += 2;
- break;
- case FIELD_TYPE_INT24:
- item_param->set_int((longlong)sint4korr(pos));
- pos += 3;
+ param->setup_param_func= setup_param_short;
+ param->item_result_type = INT_RESULT;
break;
case FIELD_TYPE_LONG:
- item_param->set_int((longlong)sint4korr(pos));
- pos += 4;
+ param->setup_param_func= setup_param_int32;
+ param->item_result_type = INT_RESULT;
break;
case FIELD_TYPE_LONGLONG:
- item_param->set_int((longlong)sint8korr(pos));
- pos += 8;
+ param->setup_param_func= setup_param_int64;
+ param->item_result_type = INT_RESULT;
break;
case FIELD_TYPE_FLOAT:
- float data;
- float4get(data,pos);
- item_param->set_double((double) data);
- pos += 4;
+ param->setup_param_func= setup_param_float;
+ param->item_result_type = REAL_RESULT;
break;
case FIELD_TYPE_DOUBLE:
- double j;
- float8get(j,pos)
- item_param->set_double(j);
- pos += 8;
+ param->setup_param_func= setup_param_double;
+ param->item_result_type = REAL_RESULT;
break;
default:
- {
- ulong len=get_param_length(&pos);
- item_param->set_value((const char*)pos,len,current_thd->thd_charset);
- pos+=len;
- }
+ param->setup_param_func= setup_param_str;
+ param->item_result_type = STRING_RESULT;
}
- return(pos);
}
/*
@@ -283,42 +276,45 @@ static uchar* setup_param_field(Item_param *item_param,
from client ..
*/
-static bool setup_param_fields(THD *thd, PREP_STMT *stmt)
-{
- DBUG_ENTER("setup_param_fields");
-#ifdef READY_TO_BE_USED
- Item_param *item_param;
- ulong param_count=0;
- uchar *pos=(uchar*) thd->net.read_pos+1;// skip command type
+static bool setup_params_data(THD *thd, PREP_STMT *stmt)
+{
+ List<Item> &params= thd->lex.param_list;
+ List_iterator<Item> param_iterator(params);
+ Item_param *param;
+ DBUG_ENTER("setup_params_data");
-
- if (*pos++) // No types supplied, read only param data
- {
- while ((item_param=(Item_param *)it++) &&
- (param_count++ < stmt->param_count))
- {
- if (item_param->long_data_supplied)
- continue;
+ uchar *pos=(uchar*) thd->net.read_pos+1+MYSQL_STMT_HEADER; //skip header
+ uchar *read_pos= pos+(stmt->param_count+7) / 8; //skip null bits
+ ulong param_no;
- if (!(pos=setup_param_field(item_param,pos,item_param->buffer_type)))
- DBUG_RETURN(1);
+ if (*read_pos++) //types supplied / first execute
+ {
+ /*
+ 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;
+ }
}
- }
- else // Types supplied, read and store it along with param data
+ param_iterator.rewind();
+ }
+ param_no= 0;
+ while ((param= (Item_param *)param_iterator++))
{
- while ((item_param=(Item_param *)it++) &&
- (param_count++ < thd->param_count))
+ if (!param->long_data_supplied)
{
- if (item_param->long_data_supplied)
- continue;
-
- if (!(pos=setup_param_field(item_param,pos,
- item_param->buffer_type=
- (enum_field_types) get_buffer_type(&pos))))
- DBUG_RETURN(1);
+ if (IS_PARAM_NULL(pos,param_no))
+ param->maybe_null=param->null_value=1;
+ else
+ param->setup_param_func(param,&read_pos);
}
+ param_no++;
}
-#endif
DBUG_RETURN(0);
}
@@ -583,6 +579,8 @@ static bool send_prepare_results(PREP_STMT *stmt)
Rest fall through to default category, no parsing
for non-DML statements
*/
+ if (send_prep_stmt(stmt, 0))
+ goto abort;
}
}
DBUG_RETURN(0);
@@ -597,7 +595,7 @@ abort:
*/
static bool parse_prepare_query(PREP_STMT *stmt,
- char *packet, uint length)
+ char *packet, uint length)
{
bool error= 1;
THD *thd= stmt->thd;
@@ -607,6 +605,7 @@ static bool parse_prepare_query(PREP_STMT *stmt,
mysql_init_query(thd);
thd->prepare_command=true;
thd->safe_to_cache_query= 0;
+ thd->lex.param_count=0;
LEX *lex=lex_start(thd, (uchar*) packet, length);
if (!yyparse() && !thd->fatal_error)
@@ -615,6 +614,25 @@ static bool parse_prepare_query(PREP_STMT *stmt,
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
@@ -648,10 +666,15 @@ bool mysql_stmt_prepare(THD *thd, char *packet, uint packet_length)
goto err;
if (!(specialflag & SPECIAL_NO_PRIOR))
- my_pthread_setprio(pthread_self(),WAIT_PRIOR);
-
- stmt.mem_root= thd->mem_root;
+ my_pthread_setprio(pthread_self(),WAIT_PRIOR);
+#if 0
+ 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->last_prepared_stmt= &stmt;
DBUG_RETURN(0);
err:
@@ -685,11 +708,11 @@ void mysql_stmt_execute(THD *thd, char *packet)
/* Check if we got an error when sending long data */
if (stmt->error_in_prepare)
{
- send_error(thd);
+ send_error(thd, stmt->last_errno, stmt->last_error);
DBUG_VOID_RETURN;
}
- if (stmt->param_count && setup_param_fields(thd, stmt))
+ if (stmt->param_count && setup_params_data(thd, stmt))
DBUG_VOID_RETURN;
MEM_ROOT thd_root= thd->mem_root;
@@ -705,6 +728,8 @@ void mysql_stmt_execute(THD *thd, char *packet)
*/
mysql_execute_command(thd);
+ thd->last_prepared_stmt= stmt;
+
if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(), WAIT_PRIOR);
@@ -768,8 +793,10 @@ void mysql_stmt_close(THD *thd, char *packet)
send_error(thd);
DBUG_VOID_RETURN;
}
+ stmt->param= 0;
+ my_free((char *)stmt->param, MYF(MY_ALLOW_ZERO_PTR));
/* 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;
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");
/* 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");
DBUG_VOID_RETURN;
}
- pos++; // skip command type at first position
ulong stmt_id= uint4korr(pos);
uint param_number= uint2korr(pos+4);
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")))
{
@@ -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");
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;
DBUG_VOID_RETURN;
}
+
View Lorry Controller Status