From a8386d01c21c1dd24ab1f86232b1d5d5633ad2eb Mon Sep 17 00:00:00 2001 From: "sergefp@mysql.com" <> Date: Mon, 5 Apr 2004 19:43:37 +0400 Subject: [PATCH 1/6] Many files: SQL Syntax for Prepared Statements (WL#1622) ps.test, ps.result: new file --- mysql-test/r/ps.result | 77 ++++++++++++++++ mysql-test/t/ps.test | 75 +++++++++++++++ sql/item.cc | 11 ++- sql/item.h | 1 + sql/lex.h | 2 + sql/mysql_priv.h | 5 +- sql/mysqld.cc | 3 + sql/sql_class.cc | 23 ++++- sql/sql_class.h | 14 +++ sql/sql_lex.h | 6 ++ sql/sql_parse.cc | 86 +++++++++++++++++- sql/sql_prepare.cc | 202 +++++++++++++++++++++++++++++++++++++---- sql/sql_yacc.yy | 74 +++++++++++++++ 13 files changed, 555 insertions(+), 24 deletions(-) create mode 100644 mysql-test/r/ps.result create mode 100644 mysql-test/t/ps.test diff --git a/mysql-test/r/ps.result b/mysql-test/r/ps.result new file mode 100644 index 00000000000..234c4af56f4 --- /dev/null +++ b/mysql-test/r/ps.result @@ -0,0 +1,77 @@ +drop table if exists t1,t2; +create table t1 +( +a int primary key, +b char(10), +); +insert into t1 values (1,'one'); +insert into t1 values (2,'two'); +insert into t1 values (3,'three'); +insert into t1 values (4,'four'); +set @a=2; +prepare stmt1 from 'select * from t1 where a <= ?'; +execute stmt1 using @a; +a b +1 one +2 two +set @a=3; +execute stmt1 using @a; +a b +1 one +2 two +3 three +deallocate prepare no_such_statement; +ERROR HY000: Undefined prepared statement +execute stmt1; +ERROR HY000: Wrong arguments to mysql_execute +prepare stmt2 from 'prepare nested_stmt from "select 1"'; +ERROR 42000: You have an error in your SQL syntax. Check the manual that corresponds to your MySQL server version for the right syntax to use near '"select 1"' at line 1 +prepare stmt2 from 'execute stmt1'; +ERROR 42000: You have an error in your SQL syntax. Check the manual that corresponds to your MySQL server version for the right syntax to use near 'stmt1' at line 1 +prepare stmt2 from 'deallocate prepare z'; +ERROR 42000: You have an error in your SQL syntax. Check the manual that corresponds to your MySQL server version for the right syntax to use near 'z' at line 1 +prepare stmt3 from 'insert into t1 values (?,?)'; +set @arg1=5, @arg2='five'; +execute stmt3 using @arg1, @arg2; +select * from t1 where a>3; +a b +4 four +5 five +prepare stmt4 from 'update t1 set a=? where b=?'; +set @arg1=55, @arg2='five'; +execute stmt4 using @arg1, @arg2; +select * from t1 where a>3; +a b +4 four +55 five +prepare stmt4 from 'create table t2 (a int)'; +execute stmt4; +prepare stmt4 from 'drop table t2'; +execute stmt4; +execute stmt4; +ERROR 42S02: Unknown table 't2' +prepare stmt5 from 'select ? + a from t1'; +set @a=1; +execute stmt5 using @a; +? + a +2 +3 +4 +5 +56 +execute stmt5 using @no_such_var; +? + a +NULL +NULL +NULL +NULL +NULL +set @nullvar=NULL; +execute stmt5 using @nullvar; +? + a +NULL +NULL +NULL +NULL +NULL +drop table t1; diff --git a/mysql-test/t/ps.test b/mysql-test/t/ps.test new file mode 100644 index 00000000000..a97de1a0de7 --- /dev/null +++ b/mysql-test/t/ps.test @@ -0,0 +1,75 @@ +# +# SQL Syntax for Prepared Statements test +# +--disable_warnings +drop table if exists t1,t2; +--enable_warnings + +create table t1 +( + a int primary key, + b char(10), +); +insert into t1 values (1,'one'); +insert into t1 values (2,'two'); +insert into t1 values (3,'three'); +insert into t1 values (4,'four'); + +# basic functionality +set @a=2; +prepare stmt1 from 'select * from t1 where a <= ?'; +execute stmt1 using @a; +set @a=3; +execute stmt1 using @a; + +# non-existant statement +--error 1243 +deallocate prepare no_such_statement; + +--error 1210 +execute stmt1; + +# Nesting ps commands is not allowed: +--error 1064 +prepare stmt2 from 'prepare nested_stmt from "select 1"'; + +--error 1064 +prepare stmt2 from 'execute stmt1'; + +--error 1064 +prepare stmt2 from 'deallocate prepare z'; + +# PS insert +prepare stmt3 from 'insert into t1 values (?,?)'; +set @arg1=5, @arg2='five'; +execute stmt3 using @arg1, @arg2; +select * from t1 where a>3; + +# PS update +prepare stmt4 from 'update t1 set a=? where b=?'; +set @arg1=55, @arg2='five'; +execute stmt4 using @arg1, @arg2; +select * from t1 where a>3; + +# PS create/delete +prepare stmt4 from 'create table t2 (a int)'; +execute stmt4; +prepare stmt4 from 'drop table t2'; +execute stmt4; + +# Do something that will cause error +--error 1051 +execute stmt4; + +# placeholders in result field names. +prepare stmt5 from 'select ? + a from t1'; +set @a=1; +execute stmt5 using @a; + +execute stmt5 using @no_such_var; + +set @nullvar=NULL; +execute stmt5 using @nullvar; + +drop table t1; + diff --git a/sql/item.cc b/sql/item.cc index 48e35f06ec3..eacee9b4653 100644 --- a/sql/item.cc +++ b/sql/item.cc @@ -610,16 +610,21 @@ void Item_param::set_double(double value) } -void Item_param::set_value(const char *str, uint length) +void Item_param::set_value(const char *str, uint length, CHARSET_INFO *ci) { DBUG_ENTER("Item_param::set_value"); - str_value.copy(str,length,default_charset()); + str_value.copy(str,length,ci); item_type= STRING_ITEM; value_is_set= 1; DBUG_PRINT("info", ("string: %s", str_value.ptr())); DBUG_VOID_RETURN; } +void Item_param::set_value(const char *str, uint length) +{ + set_value(str, length, default_charset()); +} + void Item_param::set_time(TIME *tm, timestamp_type type) { @@ -1471,7 +1476,7 @@ bool Item::send(Protocol *protocol, String *buffer) } case MYSQL_TYPE_TINY: { - longlong nr; + longlong nr; nr= val_int(); if (!null_value) result= protocol->store_tiny(nr); diff --git a/sql/item.h b/sql/item.h index dffa93eaac8..eea8bc011f4 100644 --- a/sql/item.h +++ b/sql/item.h @@ -385,6 +385,7 @@ public: void set_int(longlong i); void set_double(double i); void set_value(const char *str, uint length); + void set_value(const char *str, uint length, CHARSET_INFO *ci); 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); diff --git a/sql/lex.h b/sql/lex.h index 3b32d2bcd3b..589579eda51 100644 --- a/sql/lex.h +++ b/sql/lex.h @@ -131,6 +131,7 @@ static SYMBOL symbols[] = { { "DAY_MICROSECOND", SYM(DAY_MICROSECOND_SYM)}, { "DAY_MINUTE", SYM(DAY_MINUTE_SYM)}, { "DAY_SECOND", SYM(DAY_SECOND_SYM)}, + { "DEALLOCATE", SYM(DEALLOCATE_SYM)}, { "DEC", SYM(DECIMAL_SYM)}, { "DECIMAL", SYM(DECIMAL_SYM)}, { "DEFAULT", SYM(DEFAULT)}, @@ -320,6 +321,7 @@ static SYMBOL symbols[] = { { "POINT", SYM(POINT_SYM)}, { "POLYGON", SYM(POLYGON)}, { "PRECISION", SYM(PRECISION)}, + { "PREPARE", SYM(PREPARE_SYM)}, { "PREV", SYM(PREV_SYM)}, { "PRIMARY", SYM(PRIMARY_SYM)}, { "PRIVILEGES", SYM(PRIVILEGES)}, diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h index bd919d12348..7845d3199f4 100644 --- a/sql/mysql_priv.h +++ b/sql/mysql_priv.h @@ -604,8 +604,11 @@ int mysqld_show_column_types(THD *thd); int mysqld_help (THD *thd, const char *text); /* sql_prepare.cc */ -void mysql_stmt_prepare(THD *thd, char *packet, uint packet_length); +class Prepared_statement; +Prepared_statement *mysql_stmt_prepare(THD *thd, char *packet, + uint packet_length, bool text_protocol=false); void mysql_stmt_execute(THD *thd, char *packet, uint packet_length); +void mysql_sql_stmt_execute(THD *thd, Prepared_statement *stmt); void mysql_stmt_free(THD *thd, char *packet); void mysql_stmt_reset(THD *thd, char *packet); void mysql_stmt_get_longdata(THD *thd, char *pos, ulong packet_length); diff --git a/sql/mysqld.cc b/sql/mysqld.cc index d602c44c8f9..38e493ce5d6 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -4805,6 +4805,9 @@ struct show_var_st status_vars[]= { {"Com_unlock_tables", (char*) (com_stat+(uint) SQLCOM_UNLOCK_TABLES),SHOW_LONG}, {"Com_update", (char*) (com_stat+(uint) SQLCOM_UPDATE),SHOW_LONG}, {"Com_update_multi", (char*) (com_stat+(uint) SQLCOM_UPDATE_MULTI),SHOW_LONG}, + {"Com_prepare_sql", (char*) (com_stat+(uint) SQLCOM_PREPARE), SHOW_LONG}, + {"Com_execute_sql", (char*) (com_stat+(uint) SQLCOM_EXECUTE), SHOW_LONG}, + {"Com_dealloc_sql", (char*) (com_stat+(uint) SQLCOM_DEALLOCATE_PREPARE), SHOW_LONG}, {"Connections", (char*) &thread_id, SHOW_LONG_CONST}, {"Created_tmp_disk_tables", (char*) &created_tmp_disk_tables,SHOW_LONG}, {"Created_tmp_files", (char*) &my_tmp_file_created, SHOW_LONG}, diff --git a/sql/sql_class.cc b/sql/sql_class.cc index 1b4c8bec416..49fa0455a30 100644 --- a/sql/sql_class.cc +++ b/sql/sql_class.cc @@ -78,6 +78,23 @@ extern "C" void free_user_var(user_var_entry *entry) my_free((char*) entry,MYF(0)); } +/**************************************************************************** +** SQL syntax names for Prepared Statements +****************************************************************************/ + +extern "C" byte *get_stmt_key(SQL_PREP_STMT_ENTRY *entry, uint *length, + my_bool not_used __attribute__((unused))) +{ + *length=(uint) entry->name.length; + return (byte*) entry->name.str; +} + +extern "C" void free_sql_stmt(SQL_PREP_STMT_ENTRY *entry) +{ + char *pos= (char*) entry+ALIGN_SIZE(sizeof(*entry)); + my_free((char*) entry,MYF(0)); +} + /**************************************************************************** ** Thread specific functions @@ -160,7 +177,10 @@ THD::THD():user_time(0), current_statement(0), is_fatal_error(0), 16); else bzero((char*) &user_var_events, sizeof(user_var_events)); - + + hash_init(&sql_prepared_stmts, &my_charset_bin, USER_VARS_HASH_SIZE, 0, 0, + (hash_get_key) get_stmt_key, + (hash_free_key) free_sql_stmt,0); /* Protocol */ protocol= &protocol_simple; // Default protocol protocol_simple.init(this); @@ -279,6 +299,7 @@ void THD::cleanup(void) my_free((char*) variables.datetime_format, MYF(MY_ALLOW_ZERO_PTR)); delete_dynamic(&user_var_events); hash_free(&user_vars); + hash_free(&sql_prepared_stmts); if (global_read_lock) unlock_global_read_lock(this); if (ull) diff --git a/sql/sql_class.h b/sql/sql_class.h index 6815d0ae43c..22cb1197b21 100644 --- a/sql/sql_class.h +++ b/sql/sql_class.h @@ -594,6 +594,12 @@ public: struct system_variables variables; // Changeable local variables pthread_mutex_t LOCK_delete; // Locked before thd is deleted + /* + statement_name -> (Statement*) map of statements prepared using SQL syntax. + Hash element is SQL_PREP_STMT_ENTRY. + */ + HASH sql_prepared_stmts; + /* all prepared statements and cursors of this connection */ Statement_map stmt_map; /* @@ -1269,6 +1275,14 @@ class user_var_entry DTCollation collation; }; +class Prepared_statement; +/* Needed by THD::sql_prepared_stmts */ +typedef struct st_sql_prep_stmt_entry +{ + public: + LEX_STRING name; + Prepared_statement *stmt; +}SQL_PREP_STMT_ENTRY; /* Class for unique (removing of duplicates) */ diff --git a/sql/sql_lex.h b/sql/sql_lex.h index b9d85a23011..b1dd0355d62 100644 --- a/sql/sql_lex.h +++ b/sql/sql_lex.h @@ -76,6 +76,7 @@ enum enum_sql_command { SQLCOM_SHOW_COLUMN_TYPES, SQLCOM_SHOW_STORAGE_ENGINES, SQLCOM_SHOW_PRIVILEGES, SQLCOM_HELP, SQLCOM_DROP_USER, SQLCOM_REVOKE_ALL, SQLCOM_CHECKSUM, + SQLCOM_PREPARE, SQLCOM_EXECUTE, SQLCOM_DEALLOCATE_PREPARE, /* This should be the last !!! */ SQLCOM_END }; @@ -583,6 +584,11 @@ typedef struct st_lex bool in_comment, ignore_space, verbose, simple_alter, no_write_to_binlog; bool derived_tables; bool safe_to_cache_query; + /* Prepared statements SQL syntax:*/ + LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */ + LEX_STRING prepared_stmt_code; /* Statement query (in PREPARE )*/ + /* Names of user variables holding parameters (in EXECUTE) */ + List prepared_stmt_params; st_lex() {} inline void uncacheable(uint8 cause) { diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 68ef195cdc4..f2c36eb5513 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -1956,7 +1956,91 @@ mysql_execute_command(THD *thd) } break; } - + case SQLCOM_PREPARE: + { + char *stmt_name= lex->prepared_stmt_name.str; + uint name_len= lex->prepared_stmt_name.length; + Prepared_statement *stmt; + SQL_PREP_STMT_ENTRY *entry; + DBUG_PRINT("info", ("PREPARE: %.*s FROM '%.*s' \n", name_len, stmt_name, + lex->prepared_stmt_code.length, + lex->prepared_stmt_code.str)); + if ((entry=(SQL_PREP_STMT_ENTRY*)hash_search(&thd->sql_prepared_stmts, + (byte*)stmt_name, name_len))) + { + /* Free the statement with the same name and reuse hash entry */ + thd->stmt_map.erase((Statement*)entry->stmt); + } + else + { + uint size=ALIGN_SIZE(sizeof(SQL_PREP_STMT_ENTRY))+name_len+1; + if (!hash_inited(&thd->sql_prepared_stmts) || + !(entry= (SQL_PREP_STMT_ENTRY*)my_malloc(size,MYF(MY_WME)))) + { + send_error(thd, ER_OUT_OF_RESOURCES); + break; + } + entry->name.str= (char*)entry + ALIGN_SIZE(sizeof(SQL_PREP_STMT_ENTRY)); + entry->name.length= name_len; + memcpy(entry->name.str, stmt_name, name_len+1); + if (my_hash_insert(&thd->sql_prepared_stmts, (byte*)entry)) + { + my_free((char*)entry,MYF(0)); + send_error(thd, ER_OUT_OF_RESOURCES); + break; + } + } + /* Pretend this is a COM_PREPARE query so parser allows placeholders etc*/ + thd->command= COM_PREPARE; + /* 'length+1' is for alloc_query that strips the last character */ + stmt= mysql_stmt_prepare(thd, lex->prepared_stmt_code.str, + lex->prepared_stmt_code.length + 1, true); + if (stmt) + { + entry->stmt= stmt; + send_ok(thd, 0L, 0L, "Statement prepared"); + } + else + hash_delete(&thd->sql_prepared_stmts, (byte*)entry); + break; + } + case SQLCOM_EXECUTE: + { + char *stmt_name= lex->prepared_stmt_name.str; + uint name_len= lex->prepared_stmt_name.length; + SQL_PREP_STMT_ENTRY *entry; + DBUG_PRINT("info", ("EXECUTE: %.*s\n", name_len, stmt_name)); + + if (!(entry= (SQL_PREP_STMT_ENTRY*)hash_search(&thd->sql_prepared_stmts, + (byte*)stmt_name, + name_len))) + { + send_error(thd, ER_UNKNOWN_STMT_HANDLER, "Undefined prepared statement"); + lex->prepared_stmt_params.empty(); + break; + } + mysql_sql_stmt_execute(thd, entry->stmt); + lex->prepared_stmt_params.empty(); + break; + } + case SQLCOM_DEALLOCATE_PREPARE: + { + char *stmt_name= lex->prepared_stmt_name.str; + uint name_len= lex->prepared_stmt_name.length; + SQL_PREP_STMT_ENTRY *entry; + DBUG_PRINT("info", ("DEALLOCATE PREPARE: %.*s\n", name_len, stmt_name)); + if (!(entry= (SQL_PREP_STMT_ENTRY*)hash_search(&thd->sql_prepared_stmts, + (byte*)stmt_name, + name_len))) + { + send_error(thd, ER_UNKNOWN_STMT_HANDLER, "Undefined prepared statement"); + break; + } + thd->stmt_map.erase((Statement*)entry->stmt); + hash_delete(&thd->sql_prepared_stmts, (byte*)entry); + send_ok(thd); + break; + } case SQLCOM_DO: if (tables && ((res= check_table_access(thd, SELECT_ACL, tables,0)) || (res= open_and_lock_tables(thd,tables)))) diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index 0285c1eec2f..655285d263c 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -99,6 +99,8 @@ public: #else bool (*set_params_data)(Prepared_statement *st); #endif + bool (*set_params_from_vars)(Prepared_statement *stmt, + List& varnames); public: Prepared_statement(THD *thd_arg); virtual ~Prepared_statement(); @@ -623,6 +625,120 @@ static bool emb_insert_params_withlog(Prepared_statement *stmt) #endif /*!EMBEDDED_LIBRARY*/ + +/* + Set prepared statement parameters from user variables. + Also replace '?' marks with values in thd->query if binary logging is on. + SYNOPSIS + insert_params_from_vars() + stmt Statement + varnames List of variables. Caller must ensure that number of variables + in the list is equal to number of statement parameters + +*/ + +static bool insert_params_from_vars(Prepared_statement *stmt, + List& varnames) +{ + Item_param **begin= stmt->param_array; + Item_param **end= begin + stmt->param_count; + user_var_entry *entry; + LEX_STRING *varname; + DBUG_ENTER("insert_params_from_vars"); + + List_iterator var_it(varnames); + for (Item_param **it= begin; it < end; ++it) + { + Item_param *param= *it; + varname= var_it++; + if ((entry= (user_var_entry*)hash_search(&stmt->thd->user_vars, + (byte*) varname->str, + varname->length))) + { + param->item_result_type= entry->type; + switch (entry->type) + { + case REAL_RESULT: + param->set_double(*(double*)entry->value); + break; + case INT_RESULT: + param->set_int(*(longlong*)entry->value); + break; + case STRING_RESULT: + param->set_value(entry->value, entry->length, + entry->collation.collation); + break; + default: + DBUG_ASSERT(0); + } + } + else + { + param->item_result_type= INT_RESULT; + param->maybe_null= param->null_value= 1; + param->value_is_set= 0; + } + } + DBUG_RETURN(0); +} + +static bool insert_params_from_vars_with_log(Prepared_statement *stmt, + List& varnames) +{ + Item_param **begin= stmt->param_array; + Item_param **end= begin + stmt->param_count; + user_var_entry *entry; + LEX_STRING *varname; + DBUG_ENTER("insert_params_from_vars"); + + List_iterator var_it(varnames); + String str, query; + const String *res; + uint32 length= 0; + + for (Item_param **it= begin; it < end; ++it) + { + Item_param *param= *it; + varname= var_it++; + if ((entry= (user_var_entry*)hash_search(&stmt->thd->user_vars, + (byte*) varname->str, + varname->length))) + { + param->item_result_type= entry->type; + switch (entry->type) + { + case REAL_RESULT: + param->set_double(*(double*)entry->value); + break; + case INT_RESULT: + param->set_int(*(longlong*)entry->value); + break; + case STRING_RESULT: + param->set_value(entry->value, entry->length, + entry->collation.collation); + break; + default: + DBUG_ASSERT(0); + } + res= param->query_val_str(&str); + } + else + { + param->item_result_type= INT_RESULT; + param->maybe_null= param->null_value= 1; + param->value_is_set= 0; + res= &my_null_string; + } + + if (query.replace(param->pos_in_query+length, 1, *res)) + DBUG_RETURN(1); + length+= res->length()-1; + } + if (alloc_query(stmt->thd, (char *) query.ptr(), query.length()+1)) + DBUG_RETURN(1); + DBUG_RETURN(0); +} + /* Validate the following information for INSERT statement: - field existence @@ -780,7 +896,8 @@ static int mysql_test_select_fields(Prepared_statement *stmt, Item *having, ORDER *proc, ulong select_options, SELECT_LEX_UNIT *unit, - SELECT_LEX *select_lex) + SELECT_LEX *select_lex, + bool text_protocol) { THD *thd= stmt->thd; LEX *lex= stmt->lex; @@ -814,7 +931,7 @@ static int mysql_test_select_fields(Prepared_statement *stmt, if (lex->describe) { - if (send_prep_stmt(stmt, 0)) + if (!text_protocol && send_prep_stmt(stmt, 0)) goto err; } else @@ -834,14 +951,16 @@ static int mysql_test_select_fields(Prepared_statement *stmt, goto err_prep; } - if (send_prep_stmt(stmt, fields.elements) || - thd->protocol_simple.send_fields(&fields, 0) + if (!text_protocol) + { + if (send_prep_stmt(stmt, fields.elements) || + thd->protocol_simple.send_fields(&fields, 0) #ifndef EMBEDDED_LIBRARY - || net_flush(&thd->net) + || net_flush(&thd->net) #endif - ) - goto err_prep; - + ) + goto err_prep; + } unit->cleanup(); } thd->free_temporary_memory_pool_for_ps_preparing(); @@ -865,7 +984,7 @@ err: 1 error, sent to client */ -static int send_prepare_results(Prepared_statement *stmt) +static int send_prepare_results(Prepared_statement *stmt, bool text_protocol) { THD *thd= stmt->thd; LEX *lex= stmt->lex; @@ -905,7 +1024,8 @@ static int send_prepare_results(Prepared_statement *stmt) select_lex->having, (ORDER*)lex->proc_list.first, select_lex->options | thd->options, - &(lex->unit), select_lex))) + &(lex->unit), select_lex, + text_protocol))) goto error; /* Statement and field info has already been sent */ DBUG_RETURN(0); @@ -917,7 +1037,7 @@ static int send_prepare_results(Prepared_statement *stmt) */ break; } - DBUG_RETURN(send_prep_stmt(stmt, 0)); + DBUG_RETURN(text_protocol? 0: send_prep_stmt(stmt, 0)); error: if (res < 0) @@ -970,9 +1090,11 @@ static bool init_param_array(Prepared_statement *stmt) list in lex->param_array, so that a fast and direct retrieval can be made without going through all field items. + */ -void mysql_stmt_prepare(THD *thd, char *packet, uint packet_length) +Prepared_statement *mysql_stmt_prepare(THD *thd, char *packet, + uint packet_length, bool text_protocol) { LEX *lex; Prepared_statement *stmt= new Prepared_statement(thd); @@ -982,14 +1104,14 @@ void mysql_stmt_prepare(THD *thd, char *packet, uint packet_length) if (stmt == 0) { send_error(thd, ER_OUT_OF_RESOURCES); - DBUG_VOID_RETURN; + DBUG_RETURN(NULL); } if (thd->stmt_map.insert(stmt)) { delete stmt; send_error(thd, ER_OUT_OF_RESOURCES); - DBUG_VOID_RETURN; + DBUG_RETURN(NULL); } thd->stmt_backup.set_statement(thd); @@ -1006,7 +1128,7 @@ void mysql_stmt_prepare(THD *thd, char *packet, uint packet_length) /* Statement map deletes statement on erase */ thd->stmt_map.erase(stmt); send_error(thd, ER_OUT_OF_RESOURCES); - DBUG_VOID_RETURN; + DBUG_RETURN(NULL); } mysql_log.write(thd, COM_PREPARE, "%s", packet); @@ -1018,7 +1140,7 @@ void mysql_stmt_prepare(THD *thd, char *packet, uint packet_length) error= yyparse((void *)thd) || thd->is_fatal_error || init_param_array(stmt) || - send_prepare_results(stmt); + send_prepare_results(stmt, text_protocol); /* restore to WAIT_PRIOR: QUERY_PRIOR is set inside alloc_query */ if (!(specialflag & SPECIAL_NO_PRIOR)) @@ -1034,6 +1156,7 @@ void mysql_stmt_prepare(THD *thd, char *packet, uint packet_length) { /* Statement map deletes statement on erase */ thd->stmt_map.erase(stmt); + stmt= NULL; /* error is sent inside yyparse/send_prepare_results */ } else @@ -1048,7 +1171,7 @@ void mysql_stmt_prepare(THD *thd, char *packet, uint packet_length) sl->prep_where= sl->where; } } - DBUG_VOID_RETURN; + DBUG_RETURN(stmt); } /* Reinit statement before execution */ @@ -1109,7 +1232,6 @@ static void reset_stmt_for_execute(Prepared_statement *stmt) mysql_stmt_execute() */ - void mysql_stmt_execute(THD *thd, char *packet, uint packet_length) { ulong stmt_id= uint4korr(packet); @@ -1181,6 +1303,46 @@ set_params_data_err: } +/* + Execute prepared statement using parameter values from + lex->prepared_stmt_params and send result to the client using text protocol. +*/ + +void mysql_sql_stmt_execute(THD *thd, Prepared_statement *stmt) +{ + DBUG_ENTER("mysql_stmt_execute"); + if (stmt->param_count != thd->lex->prepared_stmt_params.elements) + { + my_error(ER_WRONG_ARGUMENTS, MYF(0), "mysql_execute"); + send_error(thd); + DBUG_VOID_RETURN; + } + thd->stmt_backup.set_statement(thd); + thd->set_statement(stmt); + reset_stmt_for_execute(stmt); + thd->command= COM_EXECUTE; + + if (stmt->set_params_from_vars(stmt, thd->stmt_backup.lex-> + prepared_stmt_params)) + { + thd->set_statement(&thd->stmt_backup); + my_error(ER_WRONG_ARGUMENTS, MYF(0), "mysql_execute"); + send_error(thd); + } + + if (!(specialflag & SPECIAL_NO_PRIOR)) + my_pthread_setprio(pthread_self(),QUERY_PRIOR); + mysql_execute_command(thd); + if (!(specialflag & SPECIAL_NO_PRIOR)) + my_pthread_setprio(pthread_self(), WAIT_PRIOR); + + cleanup_items(stmt->free_list); + close_thread_tables(thd); // to close derived tables + thd->set_statement(&thd->stmt_backup); + DBUG_VOID_RETURN; +} + + /* Reset a prepared statement, in case there was an error in send_longdata. Note: we don't send any reply to that command. @@ -1322,6 +1484,7 @@ Prepared_statement::Prepared_statement(THD *thd_arg) if (mysql_bin_log.is_open()) { log_full_query= 1; + set_params_from_vars= insert_params_from_vars_with_log; #ifndef EMBEDDED_LIBRARY set_params= insert_params_withlog; #else @@ -1329,11 +1492,14 @@ Prepared_statement::Prepared_statement(THD *thd_arg) #endif } else + { + set_params_from_vars= insert_params_from_vars; #ifndef EMBEDDED_LIBRARY set_params= insert_params; #else set_params_data= emb_insert_params; #endif + } } diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy index 90dc209f0bc..9e9b698f0b4 100644 --- a/sql/sql_yacc.yy +++ b/sql/sql_yacc.yy @@ -430,6 +430,8 @@ bool my_yyoverflow(short **a, YYSTYPE **b,int *yystacksize); %token MEDIUMTEXT %token NUMERIC_SYM %token PRECISION +%token PREPARE_SYM +%token DEALLOCATE_SYM %token QUICK %token REAL %token SIGNED_SYM @@ -722,6 +724,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b,int *yystacksize); precision subselect_start opt_and charset subselect_end select_var_list select_var_list_init help opt_len opt_extended_describe + prepare execute deallocate END_OF_INPUT %type @@ -758,10 +761,12 @@ verb_clause: | checksum | commit | create + | deallocate | delete | describe | do | drop + | execute | flush | grant | handler @@ -773,6 +778,7 @@ verb_clause: | optimize | keycache | preload + | prepare | purge | rename | repair @@ -793,6 +799,72 @@ verb_clause: | use ; +deallocate: + DEALLOCATE_SYM PREPARE_SYM ident + { + THD *thd=YYTHD; + LEX *lex= thd->lex; + if (thd->command == COM_PREPARE) + { + yyerror(ER(ER_SYNTAX_ERROR)); + YYABORT; + } + lex->sql_command= SQLCOM_DEALLOCATE_PREPARE; + lex->prepared_stmt_name= $3; + }; + +prepare: + PREPARE_SYM ident FROM TEXT_STRING_sys + { + THD *thd=YYTHD; + LEX *lex= thd->lex; + if (thd->command == COM_PREPARE) + { + yyerror(ER(ER_SYNTAX_ERROR)); + YYABORT; + } + lex->sql_command= SQLCOM_PREPARE; + lex->prepared_stmt_name= $2; + lex->prepared_stmt_code= $4; + }; + + +execute: + EXECUTE_SYM ident + { + THD *thd=YYTHD; + LEX *lex= thd->lex; + if (thd->command == COM_PREPARE) + { + yyerror(ER(ER_SYNTAX_ERROR)); + YYABORT; + } + lex->sql_command= SQLCOM_EXECUTE; + lex->prepared_stmt_name= $2; + } + execute_using + {} + ; + +execute_using: + /* nothing */ + | USING execute_var_list + ; + +execute_var_list: + execute_var_list ',' execute_var_ident + | execute_var_ident + ; + +execute_var_ident: '@' ident_or_text + { + LEX *lex=Lex; + LEX_STRING *lexstr= (LEX_STRING*)sql_memdup(&$2, sizeof(LEX_STRING)); + if (!lexstr || lex->prepared_stmt_params.push_back(lexstr)) + YYABORT; + } + ; + /* help */ help: @@ -4782,6 +4854,7 @@ keyword: | DATETIME {} | DATE_SYM {} | DAY_SYM {} + | DEALLOCATE_SYM {} | DELAY_KEY_WRITE_SYM {} | DES_KEY_FILE {} | DIRECTORY_SYM {} @@ -4879,6 +4952,7 @@ keyword: | PASSWORD {} | POINT_SYM {} | POLYGON {} + | PREPARE_SYM {} | PREV_SYM {} | PROCESS {} | PROCESSLIST_SYM {} From ca75b62d5a44a1a44f9b68e8ab245d6e8fd84d6f Mon Sep 17 00:00:00 2001 From: "sergefp@mysql.com" <> Date: Wed, 7 Apr 2004 12:58:28 +0400 Subject: [PATCH 2/6] Correct handling of parameter variables with NULL values in PREPARE queries --- mysql-test/r/ps.result | 9 +++++++++ mysql-test/t/ps.test | 4 ++++ sql/sql_prepare.cc | 6 ++++-- 3 files changed, 17 insertions(+), 2 deletions(-) diff --git a/mysql-test/r/ps.result b/mysql-test/r/ps.result index 234c4af56f4..14af3c32292 100644 --- a/mysql-test/r/ps.result +++ b/mysql-test/r/ps.result @@ -66,6 +66,7 @@ NULL NULL NULL NULL +set @nullvar=1; set @nullvar=NULL; execute stmt5 using @nullvar; ? + a @@ -74,4 +75,12 @@ NULL NULL NULL NULL +set @nullvar2=NULL; +execute stmt5 using @nullvar2; +? + a +NULL +NULL +NULL +NULL +NULL drop table t1; diff --git a/mysql-test/t/ps.test b/mysql-test/t/ps.test index a97de1a0de7..ab698174161 100644 --- a/mysql-test/t/ps.test +++ b/mysql-test/t/ps.test @@ -68,8 +68,12 @@ execute stmt5 using @a; execute stmt5 using @no_such_var; +set @nullvar=1; set @nullvar=NULL; execute stmt5 using @nullvar; +set @nullvar2=NULL; +execute stmt5 using @nullvar2; + drop table t1; diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index 08691f67aa1..d9d19647c8c 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -661,7 +661,8 @@ static bool insert_params_from_vars(Prepared_statement *stmt, varname= var_it++; if ((entry= (user_var_entry*)hash_search(&stmt->thd->user_vars, (byte*) varname->str, - varname->length))) + varname->length)) + && entry->value) { param->item_result_type= entry->type; switch (entry->type) @@ -710,7 +711,8 @@ static bool insert_params_from_vars_with_log(Prepared_statement *stmt, varname= var_it++; if ((entry= (user_var_entry*)hash_search(&stmt->thd->user_vars, (byte*) varname->str, - varname->length))) + varname->length)) + && entry->value) { param->item_result_type= entry->type; switch (entry->type) From a314cbefa1d0cbf8d6d47438cded88b7eb7b29dc Mon Sep 17 00:00:00 2001 From: "sergefp@mysql.com" <> Date: Tue, 13 Apr 2004 01:58:48 +0400 Subject: [PATCH 3/6] WL#1622 "SQL Syntax for Prepared Statements": post-review fixes: Moved PS name to Statement class, Statement_map now handles name-to-statement resolution. Both named and unnamed statements are now executed in one function (sql_prepare.cc:execute_stmt) Fixed a problem: Malformed sequence of commands from client could cause server to use previously deleted objects. Some code cleanup and small fixes --- sql/mysql_priv.h | 7 ++- sql/sql_class.cc | 62 +++++++++++++++---------- sql/sql_class.h | 43 ++++++++--------- sql/sql_parse.cc | 91 +++++++++--------------------------- sql/sql_prepare.cc | 113 ++++++++++++++++++++++++++------------------- 5 files changed, 150 insertions(+), 166 deletions(-) diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h index 2d65e8395ea..b24fa4f5cbd 100644 --- a/sql/mysql_priv.h +++ b/sql/mysql_priv.h @@ -613,11 +613,10 @@ int mysqld_show_column_types(THD *thd); int mysqld_help (THD *thd, const char *text); /* sql_prepare.cc */ -class Prepared_statement; -Prepared_statement *mysql_stmt_prepare(THD *thd, char *packet, - uint packet_length, bool text_protocol=false); +int mysql_stmt_prepare(THD *thd, char *packet, uint packet_length, + LEX_STRING *name=NULL); void mysql_stmt_execute(THD *thd, char *packet, uint packet_length); -void mysql_sql_stmt_execute(THD *thd, Prepared_statement *stmt); +void mysql_sql_stmt_execute(THD *thd, LEX_STRING *stmt_name); void mysql_stmt_free(THD *thd, char *packet); void mysql_stmt_reset(THD *thd, char *packet); void mysql_stmt_get_longdata(THD *thd, char *pos, ulong packet_length); diff --git a/sql/sql_class.cc b/sql/sql_class.cc index 49fa0455a30..87b6c49a4b7 100644 --- a/sql/sql_class.cc +++ b/sql/sql_class.cc @@ -78,24 +78,6 @@ extern "C" void free_user_var(user_var_entry *entry) my_free((char*) entry,MYF(0)); } -/**************************************************************************** -** SQL syntax names for Prepared Statements -****************************************************************************/ - -extern "C" byte *get_stmt_key(SQL_PREP_STMT_ENTRY *entry, uint *length, - my_bool not_used __attribute__((unused))) -{ - *length=(uint) entry->name.length; - return (byte*) entry->name.str; -} - -extern "C" void free_sql_stmt(SQL_PREP_STMT_ENTRY *entry) -{ - char *pos= (char*) entry+ALIGN_SIZE(sizeof(*entry)); - my_free((char*) entry,MYF(0)); -} - - /**************************************************************************** ** Thread specific functions ****************************************************************************/ @@ -178,9 +160,6 @@ THD::THD():user_time(0), current_statement(0), is_fatal_error(0), else bzero((char*) &user_var_events, sizeof(user_var_events)); - hash_init(&sql_prepared_stmts, &my_charset_bin, USER_VARS_HASH_SIZE, 0, 0, - (hash_get_key) get_stmt_key, - (hash_free_key) free_sql_stmt,0); /* Protocol */ protocol= &protocol_simple; // Default protocol protocol_simple.init(this); @@ -299,7 +278,6 @@ void THD::cleanup(void) my_free((char*) variables.datetime_format, MYF(MY_ALLOW_ZERO_PTR)); delete_dynamic(&user_var_events); hash_free(&user_vars); - hash_free(&sql_prepared_stmts); if (global_read_lock) unlock_global_read_lock(this); if (ull) @@ -1220,6 +1198,7 @@ Statement::Statement(THD *thd) query_length(0), free_list(0) { + name.str= NULL; init_sql_alloc(&mem_root, thd->variables.query_alloc_block_size, thd->variables.query_prealloc_size); @@ -1303,17 +1282,52 @@ static void delete_statement_as_hash_key(void *key) delete (Statement *) key; } +byte *get_stmt_name_hash_key(Statement *entry, uint *length, + my_bool not_used __attribute__((unused))) +{ + *length=(uint) entry->name.length; + return (byte*) entry->name.str; +} + C_MODE_END Statement_map::Statement_map() : last_found_statement(0) { - enum { START_HASH_SIZE = 16 }; - hash_init(&st_hash, default_charset_info, START_HASH_SIZE, 0, 0, + enum + { + START_STMT_HASH_SIZE = 16, + START_NAME_HASH_SIZE = 16 + }; + hash_init(&st_hash, default_charset_info, START_STMT_HASH_SIZE, 0, 0, get_statement_id_as_hash_key, delete_statement_as_hash_key, MYF(0)); + hash_init(&names_hash, &my_charset_bin, START_NAME_HASH_SIZE, 0, 0, + (hash_get_key) get_stmt_name_hash_key, + NULL,MYF(0)); } +int Statement_map::insert(Statement *statement) +{ + int rc= my_hash_insert(&st_hash, (byte *) statement); + if (rc == 0) + last_found_statement= statement; + if (statement->name.str) + { + /* + If there is a statement with the same name, remove it. It is ok to + remove old and fail to insert new one at the same time. + */ + Statement *old_stmt; + if ((old_stmt= find_by_name(&statement->name))) + erase(old_stmt); + if ((rc= my_hash_insert(&names_hash, (byte*)statement))) + hash_delete(&st_hash, (byte*)statement); + } + return rc; +} + + bool select_dumpvar::send_data(List &items) { List_iterator_fast li(vars); diff --git a/sql/sql_class.h b/sql/sql_class.h index 4eb86b20337..8ccfe3cddd5 100644 --- a/sql/sql_class.h +++ b/sql/sql_class.h @@ -456,6 +456,7 @@ public: */ bool allow_sum_func; + LEX_STRING name; /* name for named prepared statements */ LEX *lex; // parse tree descriptor /* Points to the query associated with this statement. It's const, but @@ -522,8 +523,14 @@ public: /* - Used to seek all existing statements in the connection - Deletes all statements in destructor. + Container for all statements created/used in a connection. + Statements in Statement_map have unique Statement::id (guaranteed by id + assignment in Statement::Statement) + Non-empty statement names are unique too: attempt to insert a new statement + with duplicate name causes older statement to be deleted + + Statements are auto-deleted when they are removed from the map and when the + map is deleted. */ class Statement_map @@ -531,12 +538,14 @@ class Statement_map public: Statement_map(); - int insert(Statement *statement) + int insert(Statement *statement); + + Statement *find_by_name(LEX_STRING *name) { - int rc= my_hash_insert(&st_hash, (byte *) statement); - if (rc == 0) - last_found_statement= statement; - return rc; + Statement *stmt; + stmt= (Statement*)hash_search(&names_hash, (byte*)name->str, + name->length); + return stmt; } Statement *find(ulong id) @@ -550,15 +559,21 @@ public: { if (statement == last_found_statement) last_found_statement= 0; + if (statement->name.str) + { + hash_delete(&names_hash, (byte *) statement); + } hash_delete(&st_hash, (byte *) statement); } ~Statement_map() { hash_free(&st_hash); + hash_free(&names_hash); } private: HASH st_hash; + HASH names_hash; Statement *last_found_statement; }; @@ -594,12 +609,6 @@ public: struct system_variables variables; // Changeable local variables pthread_mutex_t LOCK_delete; // Locked before thd is deleted - /* - statement_name -> (Statement*) map of statements prepared using SQL syntax. - Hash element is SQL_PREP_STMT_ENTRY. - */ - HASH sql_prepared_stmts; - /* all prepared statements and cursors of this connection */ Statement_map stmt_map; /* @@ -1276,14 +1285,6 @@ class user_var_entry DTCollation collation; }; -class Prepared_statement; -/* Needed by THD::sql_prepared_stmts */ -typedef struct st_sql_prep_stmt_entry -{ - public: - LEX_STRING name; - Prepared_statement *stmt; -}SQL_PREP_STMT_ENTRY; /* Class for unique (removing of duplicates) */ diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 91bcc9e0495..bdf6ac747c3 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -1960,88 +1960,41 @@ mysql_execute_command(THD *thd) break; } case SQLCOM_PREPARE: - { - char *stmt_name= lex->prepared_stmt_name.str; - uint name_len= lex->prepared_stmt_name.length; - Prepared_statement *stmt; - SQL_PREP_STMT_ENTRY *entry; - DBUG_PRINT("info", ("PREPARE: %.*s FROM '%.*s' \n", name_len, stmt_name, + { + DBUG_PRINT("info", ("PREPARE: %.*s FROM '%.*s' \n", + lex->prepared_stmt_name.length, + lex->prepared_stmt_name.str, lex->prepared_stmt_code.length, lex->prepared_stmt_code.str)); - if ((entry=(SQL_PREP_STMT_ENTRY*)hash_search(&thd->sql_prepared_stmts, - (byte*)stmt_name, name_len))) - { - /* Free the statement with the same name and reuse hash entry */ - thd->stmt_map.erase((Statement*)entry->stmt); - } - else - { - uint size=ALIGN_SIZE(sizeof(SQL_PREP_STMT_ENTRY))+name_len+1; - if (!hash_inited(&thd->sql_prepared_stmts) || - !(entry= (SQL_PREP_STMT_ENTRY*)my_malloc(size,MYF(MY_WME)))) - { - send_error(thd, ER_OUT_OF_RESOURCES); - break; - } - entry->name.str= (char*)entry + ALIGN_SIZE(sizeof(SQL_PREP_STMT_ENTRY)); - entry->name.length= name_len; - memcpy(entry->name.str, stmt_name, name_len+1); - if (my_hash_insert(&thd->sql_prepared_stmts, (byte*)entry)) - { - my_free((char*)entry,MYF(0)); - send_error(thd, ER_OUT_OF_RESOURCES); - break; - } - } - /* Pretend this is a COM_PREPARE query so parser allows placeholders etc*/ thd->command= COM_PREPARE; - /* 'length+1' is for alloc_query that strips the last character */ - stmt= mysql_stmt_prepare(thd, lex->prepared_stmt_code.str, - lex->prepared_stmt_code.length + 1, true); - if (stmt) - { - entry->stmt= stmt; + if (!mysql_stmt_prepare(thd, lex->prepared_stmt_code.str, + lex->prepared_stmt_code.length + 1, + &lex->prepared_stmt_name)) send_ok(thd, 0L, 0L, "Statement prepared"); - } - else - hash_delete(&thd->sql_prepared_stmts, (byte*)entry); break; } case SQLCOM_EXECUTE: { - char *stmt_name= lex->prepared_stmt_name.str; - uint name_len= lex->prepared_stmt_name.length; - SQL_PREP_STMT_ENTRY *entry; - DBUG_PRINT("info", ("EXECUTE: %.*s\n", name_len, stmt_name)); - - if (!(entry= (SQL_PREP_STMT_ENTRY*)hash_search(&thd->sql_prepared_stmts, - (byte*)stmt_name, - name_len))) - { - send_error(thd, ER_UNKNOWN_STMT_HANDLER, "Undefined prepared statement"); - lex->prepared_stmt_params.empty(); - break; - } - mysql_sql_stmt_execute(thd, entry->stmt); + DBUG_PRINT("info", ("EXECUTE: %.*s\n", + lex->prepared_stmt_name.length, + lex->prepared_stmt_name.str)); + mysql_sql_stmt_execute(thd, &lex->prepared_stmt_name); lex->prepared_stmt_params.empty(); break; } case SQLCOM_DEALLOCATE_PREPARE: { - char *stmt_name= lex->prepared_stmt_name.str; - uint name_len= lex->prepared_stmt_name.length; - SQL_PREP_STMT_ENTRY *entry; - DBUG_PRINT("info", ("DEALLOCATE PREPARE: %.*s\n", name_len, stmt_name)); - if (!(entry= (SQL_PREP_STMT_ENTRY*)hash_search(&thd->sql_prepared_stmts, - (byte*)stmt_name, - name_len))) + Statement* stmt; + DBUG_PRINT("info", ("DEALLOCATE PREPARE: %.*s\n", + lex->prepared_stmt_name.length, + lex->prepared_stmt_name.str)); + if ((stmt= thd->stmt_map.find_by_name(&lex->prepared_stmt_name))) { - send_error(thd, ER_UNKNOWN_STMT_HANDLER, "Undefined prepared statement"); - break; + thd->stmt_map.erase(stmt); + send_ok(thd); } - thd->stmt_map.erase((Statement*)entry->stmt); - hash_delete(&thd->sql_prepared_stmts, (byte*)entry); - send_ok(thd); + else + send_error(thd,ER_UNKNOWN_STMT_HANDLER,"Undefined prepared statement"); break; } case SQLCOM_DO: @@ -2259,9 +2212,9 @@ mysql_execute_command(THD *thd) tables= tables->next; // and from local list if it is not the same if (&lex->select_lex != lex->all_selects_list) - lex->select_lex.table_list.first= (gptr)create_table_local->next; + lex->select_lex.table_list.first= (gptr)create_table_local->next; else - lex->select_lex.table_list.first= (gptr)tables; + lex->select_lex.table_list.first= (gptr)tables; create_table->next= 0; ulong want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ? diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index 51d75f07bd3..501d37e1383 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -107,6 +107,7 @@ public: virtual Statement::Type type() const; }; +static void execute_stmt(THD *thd, Prepared_statement *stmt); /****************************************************************************** Implementation @@ -636,7 +637,6 @@ static bool emb_insert_params_withlog(Prepared_statement *stmt) /* Set prepared statement parameters from user variables. - Also replace '?' marks with values in thd->query if binary logging is on. SYNOPSIS insert_params_from_vars() stmt Statement @@ -682,11 +682,7 @@ static bool insert_params_from_vars(Prepared_statement *stmt, } } else - { - param->item_result_type= INT_RESULT; - param->maybe_null= param->null_value= 1; - param->value_is_set= 0; - } + param->maybe_null= param->null_value= param->value_is_set= 1; } DBUG_RETURN(0); } @@ -704,6 +700,8 @@ static bool insert_params_from_vars_with_log(Prepared_statement *stmt, String str, query; const String *res; uint32 length= 0; + if (query.copy(stmt->query, stmt->query_length, default_charset_info)) + DBUG_RETURN(1); for (Item_param **it= begin; it < end; ++it) { @@ -734,9 +732,7 @@ static bool insert_params_from_vars_with_log(Prepared_statement *stmt, } else { - param->item_result_type= INT_RESULT; - param->maybe_null= param->null_value= 1; - param->value_is_set= 0; + param->maybe_null= param->null_value= param->value_is_set= 1; res= &my_null_string; } @@ -1089,6 +1085,14 @@ static bool init_param_array(Prepared_statement *stmt) /* + SYNOPSIS + mysql_stmt_prepare() + packet Prepared query + packet_length query length, with ignored trailing NULL or quote char. + name NULL or statement name. For unnamed statements binary PS + protocol is used, for named statmenents text protocol is + used. + Parse the query and send the total number of parameters and resultset metadata information back to client (if any), without executing the query i.e. without any log/disk @@ -1100,11 +1104,11 @@ static bool init_param_array(Prepared_statement *stmt) list in lex->param_array, so that a fast and direct retrieval can be made without going through all field items. - + */ -Prepared_statement *mysql_stmt_prepare(THD *thd, char *packet, - uint packet_length, bool text_protocol) +int mysql_stmt_prepare(THD *thd, char *packet, uint packet_length, + LEX_STRING *name) { LEX *lex; Prepared_statement *stmt= new Prepared_statement(thd); @@ -1116,14 +1120,26 @@ Prepared_statement *mysql_stmt_prepare(THD *thd, char *packet, if (stmt == 0) { send_error(thd, ER_OUT_OF_RESOURCES); - DBUG_RETURN(NULL); + DBUG_RETURN(1); + } + + if (name) + { + stmt->name.length= name->length; + if (!(stmt->name.str= my_memdup((byte*)name->str, name->length, + MYF(MY_WME)))) + { + delete stmt; + send_error(thd, ER_OUT_OF_RESOURCES); + DBUG_RETURN(1); + } } if (thd->stmt_map.insert(stmt)) { delete stmt; send_error(thd, ER_OUT_OF_RESOURCES); - DBUG_RETURN(NULL); + DBUG_RETURN(1); } thd->stmt_backup.set_statement(thd); @@ -1140,7 +1156,7 @@ Prepared_statement *mysql_stmt_prepare(THD *thd, char *packet, /* Statement map deletes statement on erase */ thd->stmt_map.erase(stmt); send_error(thd, ER_OUT_OF_RESOURCES); - DBUG_RETURN(NULL); + DBUG_RETURN(1); } mysql_log.write(thd, COM_PREPARE, "%s", packet); @@ -1152,7 +1168,7 @@ Prepared_statement *mysql_stmt_prepare(THD *thd, char *packet, error= yyparse((void *)thd) || thd->is_fatal_error || init_param_array(stmt) || - send_prepare_results(stmt, text_protocol); + send_prepare_results(stmt, test(name)); /* restore to WAIT_PRIOR: QUERY_PRIOR is set inside alloc_query */ if (!(specialflag & SPECIAL_NO_PRIOR)) @@ -1183,7 +1199,7 @@ Prepared_statement *mysql_stmt_prepare(THD *thd, char *packet, sl->prep_where= sl->where; } } - DBUG_RETURN(stmt); + DBUG_RETURN(!stmt); } /* Reinit statement before execution */ @@ -1236,6 +1252,7 @@ static void reset_stmt_for_execute(Prepared_statement *stmt) } } + /* Executes previously prepared query. If there is any parameters, then replace markers with the data supplied @@ -1267,11 +1284,6 @@ void mysql_stmt_execute(THD *thd, char *packet, uint packet_length) DBUG_VOID_RETURN; } - thd->stmt_backup.set_statement(thd); - thd->set_statement(stmt); - - reset_stmt_for_execute(stmt); - #ifndef EMBEDDED_LIBRARY if (stmt->param_count) { @@ -1289,30 +1301,12 @@ void mysql_stmt_execute(THD *thd, char *packet, uint packet_length) if (stmt->param_count && stmt->set_params_data(stmt)) goto set_params_data_err; #endif - - if (!(specialflag & SPECIAL_NO_PRIOR)) - my_pthread_setprio(pthread_self(),QUERY_PRIOR); - - /* - TODO: - Also, have checks on basic executions such as mysql_insert(), - mysql_delete(), mysql_update() and mysql_select() to not to - have re-check on setup_* and other things .. - */ thd->protocol= &thd->protocol_prep; // Switch to binary protocol - mysql_execute_command(thd); + execute_stmt(thd, stmt); thd->protocol= &thd->protocol_simple; // Use normal protocol - - if (!(specialflag & SPECIAL_NO_PRIOR)) - my_pthread_setprio(pthread_self(), WAIT_PRIOR); - - cleanup_items(stmt->free_list); - close_thread_tables(thd); // to close derived tables - thd->set_statement(&thd->stmt_backup); DBUG_VOID_RETURN; set_params_data_err: - thd->set_statement(&thd->stmt_backup); my_error(ER_WRONG_ARGUMENTS, MYF(0), "mysql_execute"); send_error(thd); DBUG_VOID_RETURN; @@ -1324,28 +1318,48 @@ set_params_data_err: lex->prepared_stmt_params and send result to the client using text protocol. */ -void mysql_sql_stmt_execute(THD *thd, Prepared_statement *stmt) +void mysql_sql_stmt_execute(THD *thd, LEX_STRING *stmt_name) { + Prepared_statement *stmt; DBUG_ENTER("mysql_stmt_execute"); + + if (!(stmt= (Prepared_statement*)thd->stmt_map.find_by_name(stmt_name))) + { + send_error(thd, ER_UNKNOWN_STMT_HANDLER, + "Undefined prepared statement"); + DBUG_VOID_RETURN; + } + if (stmt->param_count != thd->lex->prepared_stmt_params.elements) { my_error(ER_WRONG_ARGUMENTS, MYF(0), "mysql_execute"); send_error(thd); DBUG_VOID_RETURN; } - thd->stmt_backup.set_statement(thd); - thd->set_statement(stmt); - reset_stmt_for_execute(stmt); + /* Item_param allows setting parameters in COM_EXECUTE only */ thd->command= COM_EXECUTE; - if (stmt->set_params_from_vars(stmt, thd->stmt_backup.lex-> - prepared_stmt_params)) + if (stmt->set_params_from_vars(stmt, thd->lex->prepared_stmt_params)) { - thd->set_statement(&thd->stmt_backup); my_error(ER_WRONG_ARGUMENTS, MYF(0), "mysql_execute"); send_error(thd); } + execute_stmt(thd, stmt); + DBUG_VOID_RETURN; +} + +/* + Execute prepared statement. + Caller must set parameter values and thd::protocol. +*/ +static void execute_stmt(THD *thd, Prepared_statement *stmt) +{ + DBUG_ENTER("execute_stmt"); + thd->stmt_backup.set_statement(thd); + thd->set_statement(stmt); + reset_stmt_for_execute(stmt); + if (!(specialflag & SPECIAL_NO_PRIOR)) my_pthread_setprio(pthread_self(),QUERY_PRIOR); mysql_execute_command(thd); @@ -1359,6 +1373,7 @@ void mysql_sql_stmt_execute(THD *thd, Prepared_statement *stmt) } + /* Reset a prepared statement, in case there was an error in send_longdata. Note: we don't send any reply to that command. @@ -1522,6 +1537,8 @@ Prepared_statement::Prepared_statement(THD *thd_arg) Prepared_statement::~Prepared_statement() { free_items(free_list); + if (name.str) + my_free(name.str, MYF(0)); } From 42c00f2aede8e80801b6bc96844304e39f5f2788 Mon Sep 17 00:00:00 2001 From: "sergefp@mysql.com" <> Date: Wed, 14 Apr 2004 22:20:19 +0400 Subject: [PATCH 4/6] Post-merge fixes --- sql/sql_prepare.cc | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index e578dc988f8..d468fce1af6 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -1628,7 +1628,6 @@ void mysql_stmt_execute(THD *thd, char *packet, uint packet_length) #endif thd->protocol= &thd->protocol_prep; // Switch to binary protocol execute_stmt(thd, stmt); - thd->lex->unit.cleanup(); thd->protocol= &thd->protocol_simple; // Use normal protocol DBUG_VOID_RETURN; @@ -1670,7 +1669,6 @@ void mysql_sql_stmt_execute(THD *thd, LEX_STRING *stmt_name) my_error(ER_WRONG_ARGUMENTS, MYF(0), "mysql_execute"); send_error(thd); } - execute_stmt(thd, stmt); DBUG_VOID_RETURN; } @@ -1689,6 +1687,7 @@ static void execute_stmt(THD *thd, Prepared_statement *stmt) if (!(specialflag & SPECIAL_NO_PRIOR)) my_pthread_setprio(pthread_self(),QUERY_PRIOR); mysql_execute_command(thd); + thd->lex->unit.cleanup(); if (!(specialflag & SPECIAL_NO_PRIOR)) my_pthread_setprio(pthread_self(), WAIT_PRIOR); From 9a4acccd05e1013b06631f58e8e42b7953757ace Mon Sep 17 00:00:00 2001 From: "sergefp@mysql.com" <> Date: Fri, 30 Apr 2004 20:08:38 +0400 Subject: [PATCH 5/6] WL#1622 "SQL Syntax for Prepared Statements" - cosmetic code review fixes --- mysql-test/r/ps.result | 6 ++++++ mysql-test/t/ps.test | 11 +++++++++++ sql/sql_class.cc | 8 ++++---- sql/sql_yacc.yy | 19 +++++++++---------- 4 files changed, 30 insertions(+), 14 deletions(-) diff --git a/mysql-test/r/ps.result b/mysql-test/r/ps.result index 14af3c32292..d16f24b34c6 100644 --- a/mysql-test/r/ps.result +++ b/mysql-test/r/ps.result @@ -83,4 +83,10 @@ NULL NULL NULL NULL +prepare stmt6 from 'select 1; select2'; +ERROR 42000: You have an error in your SQL syntax. Check the manual that corresponds to your MySQL server version for the right syntax to use near '; select2' at line 1 +prepare stmt6 from 'insert into t1 values (5,"five"); select2'; +ERROR 42000: You have an error in your SQL syntax. Check the manual that corresponds to your MySQL server version for the right syntax to use near '; select2' at line 1 +explain prepare stmt6 from 'insert into t1 values (5,"five"); select2'; +ERROR 42000: You have an error in your SQL syntax. Check the manual that corresponds to your MySQL server version for the right syntax to use near 'from 'insert into t1 values (5,"five"); select2'' at line 1 drop table t1; diff --git a/mysql-test/t/ps.test b/mysql-test/t/ps.test index ab698174161..dc9f054da0d 100644 --- a/mysql-test/t/ps.test +++ b/mysql-test/t/ps.test @@ -75,5 +75,16 @@ execute stmt5 using @nullvar; set @nullvar2=NULL; execute stmt5 using @nullvar2; +# Check that multiple SQL statements are disabled inside PREPARE +--error 1064 +prepare stmt6 from 'select 1; select2'; + +--error 1064 +prepare stmt6 from 'insert into t1 values (5,"five"); select2'; + +# This shouldn't parse +--error 1064 +explain prepare stmt6 from 'insert into t1 values (5,"five"); select2'; + drop table t1; diff --git a/sql/sql_class.cc b/sql/sql_class.cc index 87b6c49a4b7..bf2dbb3fc5c 100644 --- a/sql/sql_class.cc +++ b/sql/sql_class.cc @@ -1282,8 +1282,8 @@ static void delete_statement_as_hash_key(void *key) delete (Statement *) key; } -byte *get_stmt_name_hash_key(Statement *entry, uint *length, - my_bool not_used __attribute__((unused))) +static byte *get_stmt_name_hash_key(Statement *entry, uint *length, + my_bool not_used __attribute__((unused))) { *length=(uint) entry->name.length; return (byte*) entry->name.str; @@ -1303,8 +1303,8 @@ Statement_map::Statement_map() : get_statement_id_as_hash_key, delete_statement_as_hash_key, MYF(0)); hash_init(&names_hash, &my_charset_bin, START_NAME_HASH_SIZE, 0, 0, - (hash_get_key) get_stmt_name_hash_key, - NULL,MYF(0)); + (hash_get_key) get_stmt_name_hash_key, + NULL,MYF(0)); } int Statement_map::insert(Statement *statement) diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy index 247bec84e8e..afd461e0383 100644 --- a/sql/sql_yacc.yy +++ b/sql/sql_yacc.yy @@ -805,13 +805,13 @@ deallocate: DEALLOCATE_SYM PREPARE_SYM ident { THD *thd=YYTHD; - LEX *lex= thd->lex; + LEX *lex= thd->lex; if (thd->command == COM_PREPARE) { yyerror(ER(ER_SYNTAX_ERROR)); YYABORT; } - lex->sql_command= SQLCOM_DEALLOCATE_PREPARE; + lex->sql_command= SQLCOM_DEALLOCATE_PREPARE; lex->prepared_stmt_name= $3; }; @@ -819,29 +819,28 @@ prepare: PREPARE_SYM ident FROM TEXT_STRING_sys { THD *thd=YYTHD; - LEX *lex= thd->lex; + LEX *lex= thd->lex; if (thd->command == COM_PREPARE) { yyerror(ER(ER_SYNTAX_ERROR)); YYABORT; } - lex->sql_command= SQLCOM_PREPARE; + lex->sql_command= SQLCOM_PREPARE; lex->prepared_stmt_name= $2; lex->prepared_stmt_code= $4; }; - execute: EXECUTE_SYM ident { THD *thd=YYTHD; - LEX *lex= thd->lex; + LEX *lex= thd->lex; if (thd->command == COM_PREPARE) { yyerror(ER(ER_SYNTAX_ERROR)); YYABORT; } - lex->sql_command= SQLCOM_EXECUTE; + lex->sql_command= SQLCOM_EXECUTE; lex->prepared_stmt_name= $2; } execute_using @@ -854,8 +853,8 @@ execute_using: ; execute_var_list: - execute_var_list ',' execute_var_ident - | execute_var_ident + execute_var_list ',' execute_var_ident + | execute_var_ident ; execute_var_ident: '@' ident_or_text @@ -864,7 +863,7 @@ execute_var_ident: '@' ident_or_text LEX_STRING *lexstr= (LEX_STRING*)sql_memdup(&$2, sizeof(LEX_STRING)); if (!lexstr || lex->prepared_stmt_params.push_back(lexstr)) YYABORT; - } + } ; /* help */ From 1eb588215bfb29eb2d7ea02b6ce1741b0eb996a0 Mon Sep 17 00:00:00 2001 From: "sergefp@mysql.com" <> Date: Fri, 30 Apr 2004 20:44:46 +0400 Subject: [PATCH 6/6] More small WL#1622 fixes: Allocate name of Prepared Statement on PS's mem_root. --- sql/sql_prepare.cc | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index efc5b9bdbf8..739b09cf958 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -1463,8 +1463,8 @@ int mysql_stmt_prepare(THD *thd, char *packet, uint packet_length, if (name) { stmt->name.length= name->length; - if (!(stmt->name.str= my_memdup((byte*)name->str, name->length, - MYF(MY_WME)))) + if (!(stmt->name.str= memdup_root(&stmt->mem_root, (byte*)name->str, + name->length))) { delete stmt; send_error(thd, ER_OUT_OF_RESOURCES); @@ -1874,8 +1874,6 @@ Prepared_statement::Prepared_statement(THD *thd_arg) Prepared_statement::~Prepared_statement() { free_items(free_list); - if (name.str) - my_free(name.str, MYF(0)); }