From ef8a5401f146e0aa17d9cc342c52a82e16e7c6ef Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 5 Apr 2004 19:43:37 +0400 Subject: [PATCH 01/12] Many files: SQL Syntax for Prepared Statements (WL#1622) ps.test, ps.result: new file sql/item.cc: SQL Syntax for Prepared Statements (WL#1622) sql/item.h: SQL Syntax for Prepared Statements (WL#1622) sql/lex.h: SQL Syntax for Prepared Statements (WL#1622) sql/mysql_priv.h: SQL Syntax for Prepared Statements (WL#1622) sql/mysqld.cc: SQL Syntax for Prepared Statements (WL#1622) sql/sql_class.cc: SQL Syntax for Prepared Statements (WL#1622) sql/sql_class.h: SQL Syntax for Prepared Statements (WL#1622) sql/sql_lex.h: SQL Syntax for Prepared Statements (WL#1622) sql/sql_parse.cc: SQL Syntax for Prepared Statements (WL#1622) sql/sql_prepare.cc: SQL Syntax for Prepared Statements (WL#1622) sql/sql_yacc.yy: SQL Syntax for Prepared Statements (WL#1622) --- 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 4ceaf3a6292e08e33ba4e985e72e72d87cd9743f Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 7 Apr 2004 12:58:28 +0400 Subject: [PATCH 02/12] 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 756223bbda043a20840a1c2236a2f62a35640460 Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 13 Apr 2004 01:58:48 +0400 Subject: [PATCH 03/12] 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: WL#1622 "SQL Syntax for Prepared Statements": post-review fixes. sql/sql_class.cc: WL#1622 "SQL Syntax for Prepared Statements": post-review fixes. sql/sql_class.h: WL#1622 "SQL Syntax for Prepared Statements": post-review fixes. sql/sql_parse.cc: WL#1622 "SQL Syntax for Prepared Statements": post-review fixes. sql/sql_prepare.cc: WL#1622 "SQL Syntax for Prepared Statements": post-review 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 4a26ea142a80addd942034deed930794bb51868d Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 14 Apr 2004 22:20:19 +0400 Subject: [PATCH 04/12] 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 47322bf9b8e7eed66181d1b88cfd1a5d3ce2ea91 Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 30 Apr 2004 20:08:38 +0400 Subject: [PATCH 05/12] WL#1622 "SQL Syntax for Prepared Statements" - cosmetic code review fixes mysql-test/r/ps.result: Added check if multiple SQL statements inside a PS are disabled mysql-test/t/ps.test: Added check if multiple SQL statements inside a PS are disabled --- 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 8746b6a1027ef7c34d3c30e268ff44679ab46f17 Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 30 Apr 2004 20:44:46 +0400 Subject: [PATCH 06/12] More small WL#1622 fixes: Allocate name of Prepared Statement on PS's mem_root. sql/sql_prepare.cc: 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)); } From 60017fb2609f6993e941f662d79a8f1d44cfa11b Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 5 May 2004 19:11:40 +0400 Subject: [PATCH 07/12] WL#1622: Post-merge fixes --- sql/sql_parse.cc | 1 - sql/sql_prepare.cc | 16 ++++++++-------- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 0c79dc6b743..b4ef30dbd0c 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -1424,7 +1424,6 @@ bool dispatch_command(enum enum_server_command command, THD *thd, } case COM_EXECUTE: { - thd->free_list= NULL; mysql_stmt_execute(thd, packet, packet_length); break; } diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index eb995a8369f..d1448e62013 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -1654,17 +1654,10 @@ void mysql_stmt_execute(THD *thd, char *packet, uint packet_length) thd->protocol= &thd->protocol_prep; // Switch to binary protocol execute_stmt(thd, stmt); thd->protocol= &thd->protocol_simple; // Use normal protocol - //psergey-todo: move this into execute_stmt: - reset_stmt_params(stmt); - /* - Free Items that were created during this execution of the PS by query - optimizer. - */ - free_items(thd->free_list); DBUG_VOID_RETURN; set_params_data_err: - reset_stmt_params(stmt); //psergey-todo: check if this belongs here + reset_stmt_params(stmt); my_error(ER_WRONG_ARGUMENTS, MYF(0), "mysql_execute"); send_error(thd); DBUG_VOID_RETURN; @@ -1709,10 +1702,12 @@ void mysql_sql_stmt_execute(THD *thd, LEX_STRING *stmt_name) /* Execute prepared statement. Caller must set parameter values and thd::protocol. + thd->free_list is assumed to be garbage. */ static void execute_stmt(THD *thd, Prepared_statement *stmt) { DBUG_ENTER("execute_stmt"); + thd->free_list= NULL; thd->stmt_backup.set_statement(thd); thd->set_statement(stmt); reset_stmt_for_execute(stmt); @@ -1724,6 +1719,11 @@ static void execute_stmt(THD *thd, Prepared_statement *stmt) if (!(specialflag & SPECIAL_NO_PRIOR)) my_pthread_setprio(pthread_self(), WAIT_PRIOR); + /* + Free Items that were created during this execution of the PS by query + optimizer. + */ + free_items(thd->free_list); cleanup_items(stmt->free_list); reset_stmt_params(stmt); close_thread_tables(thd); // to close derived tables From dee8f22c079addf7ed2a27ea6ed73a81f52c5cb7 Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 7 May 2004 03:32:51 +0400 Subject: [PATCH 08/12] Added a test for a problem that was fixed by automerge and fixed a typo. --- mysql-test/r/ps.result | 13 +++++++++++-- mysql-test/t/ps.test | 16 ++++++++++++++-- 2 files changed, 25 insertions(+), 4 deletions(-) diff --git a/mysql-test/r/ps.result b/mysql-test/r/ps.result index d16f24b34c6..fc82645840c 100644 --- a/mysql-test/r/ps.result +++ b/mysql-test/r/ps.result @@ -2,7 +2,7 @@ drop table if exists t1,t2; create table t1 ( a int primary key, -b char(10), +b char(10) ); insert into t1 values (1,'one'); insert into t1 values (2,'two'); @@ -89,4 +89,13 @@ 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; +create table t2 +( +a int +); +insert into t2 values (0); +set @arg00=NULL ; +prepare stmt1 from 'select 1 FROM t2 where a=?' ; +execute stmt1 using @arg00 ; +1 +drop table t1,t2; diff --git a/mysql-test/t/ps.test b/mysql-test/t/ps.test index dc9f054da0d..989dc6026fe 100644 --- a/mysql-test/t/ps.test +++ b/mysql-test/t/ps.test @@ -8,7 +8,7 @@ drop table if exists t1,t2; create table t1 ( a int primary key, - b char(10), + b char(10) ); insert into t1 values (1,'one'); insert into t1 values (2,'two'); @@ -86,5 +86,17 @@ prepare stmt6 from 'insert into t1 values (5,"five"); select2'; --error 1064 explain prepare stmt6 from 'insert into t1 values (5,"five"); select2'; -drop table t1; +create table t2 +( + a int +); + +insert into t2 values (0); + +# parameter is NULL +set @arg00=NULL ; +prepare stmt1 from 'select 1 FROM t2 where a=?' ; +execute stmt1 using @arg00 ; + +drop table t1,t2; From e7710af7f4c41e77355f5599aafb04999b358292 Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 21 May 2004 04:27:50 +0400 Subject: [PATCH 09/12] WL#1622 "SQL Syntax for Prepared Statements": Post-review fixes (1 of 2) mysql-test/r/ps.result: Added tests for PREPARE stmt1 FROM @var syntax mysql-test/t/ps.test: Added tests for PREPARE stmt1 FROM @var syntax mysys/my_error.c: Added support for "%.*s" format sql/item.cc: Removed one redundant Item_param::set_value function sql/item.h: Removed one redundant Item_param::set_value function sql/mysqld.cc: Reformmated the code sql/share/czech/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/dutch/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/english/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/estonian/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/french/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/german/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/greek/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/hungarian/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/italian/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/japanese/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/korean/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/norwegian-ny/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/norwegian/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/polish/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/portuguese/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/romanian/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/russian/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/slovak/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/spanish/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/swedish/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/share/ukrainian/errmsg.txt: Changed ER_UNKNOWN_STMT_HANDLER format string sql/sql_class.h: SQL Prepared statements now can't be used by binary protocol commands sql/sql_lex.h: Added support for PREPARE stmt1 FROM @var syntax. sql/sql_parse.cc: Added support for PREPARE stmt1 FROM @var syntax. sql/sql_prepare.cc: Code cleanup sql/sql_yacc.yy: Added support for PREPARE stmt1 FROM @var syntax. --- mysql-test/r/ps.result | 16 ++++- mysql-test/t/ps.test | 17 ++++++ mysys/my_error.c | 55 +++++++++++++---- sql/item.cc | 7 +-- sql/item.h | 3 +- sql/mysqld.cc | 9 ++- sql/share/czech/errmsg.txt | 2 +- sql/share/dutch/errmsg.txt | 2 +- sql/share/english/errmsg.txt | 2 +- sql/share/estonian/errmsg.txt | 2 +- sql/share/french/errmsg.txt | 2 +- sql/share/german/errmsg.txt | 2 +- sql/share/greek/errmsg.txt | 2 +- sql/share/hungarian/errmsg.txt | 2 +- sql/share/italian/errmsg.txt | 2 +- sql/share/japanese/errmsg.txt | 2 +- sql/share/korean/errmsg.txt | 2 +- sql/share/norwegian-ny/errmsg.txt | 2 +- sql/share/norwegian/errmsg.txt | 2 +- sql/share/polish/errmsg.txt | 2 +- sql/share/portuguese/errmsg.txt | 2 +- sql/share/romanian/errmsg.txt | 2 +- sql/share/russian/errmsg.txt | 2 +- sql/share/slovak/errmsg.txt | 2 +- sql/share/spanish/errmsg.txt | 2 +- sql/share/swedish/errmsg.txt | 2 +- sql/share/ukrainian/errmsg.txt | 2 +- sql/sql_class.h | 9 ++- sql/sql_lex.h | 8 ++- sql/sql_parse.cc | 99 ++++++++++++++++++++++++++++--- sql/sql_prepare.cc | 50 +++++++++------- sql/sql_yacc.yy | 21 ++++++- 32 files changed, 257 insertions(+), 79 deletions(-) diff --git a/mysql-test/r/ps.result b/mysql-test/r/ps.result index fc82645840c..6c228327b8d 100644 --- a/mysql-test/r/ps.result +++ b/mysql-test/r/ps.result @@ -21,7 +21,7 @@ a b 2 two 3 three deallocate prepare no_such_statement; -ERROR HY000: Undefined prepared statement +ERROR HY000: Unknown prepared statement handler (no_such_statement) given to DEALLOCATE PREPARE execute stmt1; ERROR HY000: Wrong arguments to mysql_execute prepare stmt2 from 'prepare nested_stmt from "select 1"'; @@ -98,4 +98,18 @@ set @arg00=NULL ; prepare stmt1 from 'select 1 FROM t2 where a=?' ; execute stmt1 using @arg00 ; 1 +prepare stmt1 from @nosuchvar; +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 'NULL' at line 1 +set @ivar= 1234; +prepare stmt1 from @ivar; +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 '1234' at line 1 +set @fvar= 123.4567; +prepare stmt1 from @fvar; +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 '123.4567' at line 1 +set @str1 = 'select ?'; +set @str2 = convert(@str1 using ucs2); +prepare stmt1 from @str2; +execute stmt1 using @ivar; +? +1234 drop table t1,t2; diff --git a/mysql-test/t/ps.test b/mysql-test/t/ps.test index 989dc6026fe..d9e0f0852c5 100644 --- a/mysql-test/t/ps.test +++ b/mysql-test/t/ps.test @@ -98,5 +98,22 @@ set @arg00=NULL ; prepare stmt1 from 'select 1 FROM t2 where a=?' ; execute stmt1 using @arg00 ; +# prepare using variables: +--error 1064 +prepare stmt1 from @nosuchvar; + +set @ivar= 1234; +--error 1064 +prepare stmt1 from @ivar; + +set @fvar= 123.4567; +--error 1064 +prepare stmt1 from @fvar; + +set @str1 = 'select ?'; +set @str2 = convert(@str1 using ucs2); +prepare stmt1 from @str2; +execute stmt1 using @ivar; + drop table t1,t2; diff --git a/mysys/my_error.c b/mysys/my_error.c index 6fd346c89f7..7ca7dbae8de 100644 --- a/mysys/my_error.c +++ b/mysys/my_error.c @@ -33,6 +33,12 @@ char NEAR errbuff[NRERRBUFFS][ERRMSGSIZE]; nr Errno MyFlags Flags ... variable list + NOTE + The following subset of printf format is supported: + "%[0-9.-]*l?[sdu]", where all length flags are parsed but ignored. + + Additionally "%.*s" is supported and "%.*[ud]" is correctly parsed but + length value is ignored. */ int my_error(int nr,myf MyFlags, ...) @@ -43,7 +49,10 @@ int my_error(int nr,myf MyFlags, ...) reg2 char *endpos; char * par; char ebuff[ERRMSGSIZE+20]; + int prec_chars; + my_bool prec_supplied; DBUG_ENTER("my_error"); + LINT_INIT(prec_chars); /* protected by prec_supplied */ va_start(ap,MyFlags); DBUG_PRINT("my", ("nr: %d MyFlags: %d errno: %d", nr, MyFlags, errno)); @@ -59,7 +68,6 @@ int my_error(int nr,myf MyFlags, ...) if (tpos[0] != '%') { *endpos++= *tpos++; /* Copy ordinary char */ - olen++; continue; } if (*++tpos == '%') /* test if %% */ @@ -68,21 +76,48 @@ int my_error(int nr,myf MyFlags, ...) } else { - /* Skipp if max size is used (to be compatible with printf) */ - while (my_isdigit(&my_charset_latin1, *tpos) || *tpos == '.' || *tpos == '-') - tpos++; - if (*tpos == 'l') /* Skipp 'l' argument */ - tpos++; + /* + Skip size/precision flags to be compatible with printf. + The only size/precision flag supported is "%.*s". + "%.*u" and "%.*d" cause + */ + prec_supplied= 0; + if (*tpos== '.') + { + tpos++; + olen--; + if (*tpos == '*') + { + tpos++; + olen--; + prec_chars= va_arg(ap, int); /* get length parameter */ + prec_supplied= 1; + } + } + + if (!prec_supplied) + { + while (my_isdigit(&my_charset_latin1, *tpos) || *tpos == '.' || + *tpos == '-') + tpos++; + + if (*tpos == 'l') /* Skipp 'l' argument */ + tpos++; + } + if (*tpos == 's') /* String parameter */ { par = va_arg(ap, char *); plen = (uint) strlen(par); + if (prec_supplied && prec_chars > 0) + plen= min((uint)prec_chars, plen); if (olen + plen < ERRMSGSIZE+2) /* Replace if possible */ { - endpos=strmov(endpos,par); - tpos++; - olen+=plen-2; - continue; + memcpy(endpos,par, plen); + endpos += plen; + tpos++; + olen+=plen-2; + continue; } } else if (*tpos == 'd' || *tpos == 'u') /* Integer parameter */ diff --git a/sql/item.cc b/sql/item.cc index b6b99a9f717..8557820474d 100644 --- a/sql/item.cc +++ b/sql/item.cc @@ -253,7 +253,7 @@ bool Item::get_time(TIME *ltime) return 0; } -CHARSET_INFO * Item::default_charset() const +CHARSET_INFO * Item::default_charset() { return current_thd->variables.collation_connection; } @@ -678,11 +678,6 @@ void Item_param::set_value(const char *str, uint length, CHARSET_INFO *ci) 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) { diff --git a/sql/item.h b/sql/item.h index 471d502a6e1..062e1da990d 100644 --- a/sql/item.h +++ b/sql/item.h @@ -220,7 +220,7 @@ public: virtual Item *real_item() { return this; } virtual Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); } - CHARSET_INFO *default_charset() const; + static CHARSET_INFO *default_charset(); virtual CHARSET_INFO *compare_collation() { return NULL; } virtual bool walk(Item_processor processor, byte *arg) @@ -413,7 +413,6 @@ public: void set_null(); 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); diff --git a/sql/mysqld.cc b/sql/mysqld.cc index e810393af60..aa266861dd7 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -4842,9 +4842,12 @@ 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}, + {"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/share/czech/errmsg.txt b/sql/share/czech/errmsg.txt index f3a0c5e0eec..f554a1171d3 100644 --- a/sql/share/czech/errmsg.txt +++ b/sql/share/czech/errmsg.txt @@ -255,7 +255,7 @@ character-set=latin2 "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/dutch/errmsg.txt b/sql/share/dutch/errmsg.txt index 9d9dfb14a89..0db72a4fb22 100644 --- a/sql/share/dutch/errmsg.txt +++ b/sql/share/dutch/errmsg.txt @@ -257,7 +257,7 @@ character-set=latin1 "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/english/errmsg.txt b/sql/share/english/errmsg.txt index 14a854fbafb..592c44dc3f4 100644 --- a/sql/share/english/errmsg.txt +++ b/sql/share/english/errmsg.txt @@ -246,7 +246,7 @@ character-set=latin1 "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/estonian/errmsg.txt b/sql/share/estonian/errmsg.txt index 5d0f34fd4b2..caa0d8f039e 100644 --- a/sql/share/estonian/errmsg.txt +++ b/sql/share/estonian/errmsg.txt @@ -251,7 +251,7 @@ character-set=latin7 "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/french/errmsg.txt b/sql/share/french/errmsg.txt index adc9f66e96b..fb4a2f0f5b1 100644 --- a/sql/share/french/errmsg.txt +++ b/sql/share/french/errmsg.txt @@ -246,7 +246,7 @@ character-set=latin1 "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/german/errmsg.txt b/sql/share/german/errmsg.txt index 0b732ba48f8..6d484c36116 100644 --- a/sql/share/german/errmsg.txt +++ b/sql/share/german/errmsg.txt @@ -258,7 +258,7 @@ character-set=latin1 "Schlüssel- und Tabellenverweis passen nicht zusammen", "Operand solle %d Spalte(n) enthalten", "Unterabfrage lieferte mehr als einen Datensatz zurück", -"Unbekannter Prepared-Statement-Handler (%ld) für %s angegeben", +"Unbekannter Prepared-Statement-Handler (%.*s) für %s angegeben", "Die Hilfe-Datenbank ist beschädigt oder existiert nicht", "Zyklischer Verweis in Unterabfragen", "Spalte '%s' wird von %s nach %s umgewandelt", diff --git a/sql/share/greek/errmsg.txt b/sql/share/greek/errmsg.txt index f96c10b0e65..4bea8b2dfc6 100644 --- a/sql/share/greek/errmsg.txt +++ b/sql/share/greek/errmsg.txt @@ -246,7 +246,7 @@ character-set=greek "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/hungarian/errmsg.txt b/sql/share/hungarian/errmsg.txt index a26790a4ef9..f7552d6fa15 100644 --- a/sql/share/hungarian/errmsg.txt +++ b/sql/share/hungarian/errmsg.txt @@ -248,7 +248,7 @@ character-set=latin2 "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/italian/errmsg.txt b/sql/share/italian/errmsg.txt index 7c519e4e4bf..0a81a534fbc 100644 --- a/sql/share/italian/errmsg.txt +++ b/sql/share/italian/errmsg.txt @@ -246,7 +246,7 @@ character-set=latin1 "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/japanese/errmsg.txt b/sql/share/japanese/errmsg.txt index f973f84d2a4..ce58d87871b 100644 --- a/sql/share/japanese/errmsg.txt +++ b/sql/share/japanese/errmsg.txt @@ -248,7 +248,7 @@ character-set=ujis "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/korean/errmsg.txt b/sql/share/korean/errmsg.txt index 8b5d318ab19..6f3de30c6a5 100644 --- a/sql/share/korean/errmsg.txt +++ b/sql/share/korean/errmsg.txt @@ -246,7 +246,7 @@ character-set=euckr "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/norwegian-ny/errmsg.txt b/sql/share/norwegian-ny/errmsg.txt index c0a7d736e1f..1ce737955af 100644 --- a/sql/share/norwegian-ny/errmsg.txt +++ b/sql/share/norwegian-ny/errmsg.txt @@ -248,7 +248,7 @@ character-set=latin1 "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/norwegian/errmsg.txt b/sql/share/norwegian/errmsg.txt index fc9b5d2f6da..bb7afd5a8f4 100644 --- a/sql/share/norwegian/errmsg.txt +++ b/sql/share/norwegian/errmsg.txt @@ -248,7 +248,7 @@ character-set=latin1 "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/polish/errmsg.txt b/sql/share/polish/errmsg.txt index 36b7d67d134..b4ff175822a 100644 --- a/sql/share/polish/errmsg.txt +++ b/sql/share/polish/errmsg.txt @@ -250,7 +250,7 @@ character-set=latin2 "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/portuguese/errmsg.txt b/sql/share/portuguese/errmsg.txt index d4ffa2d5ef5..907ca6fc80c 100644 --- a/sql/share/portuguese/errmsg.txt +++ b/sql/share/portuguese/errmsg.txt @@ -247,7 +247,7 @@ character-set=latin1 "Referência da chave e referência da tabela não coincidem", "Operand should contain %d column(s)", "Subconsulta retorna mais que 1 registro", -"Desconhecido manipulador de declaração preparado (%ld) determinado para %s", +"Desconhecido manipulador de declaração preparado (%.*s) determinado para %s", "Banco de dado de ajuda corrupto ou não existente", "Referência cíclica em subconsultas", "Convertendo coluna '%s' de %s para %s", diff --git a/sql/share/romanian/errmsg.txt b/sql/share/romanian/errmsg.txt index 4918a6e1a10..cefd2074bf2 100644 --- a/sql/share/romanian/errmsg.txt +++ b/sql/share/romanian/errmsg.txt @@ -250,7 +250,7 @@ character-set=latin2 "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/russian/errmsg.txt b/sql/share/russian/errmsg.txt index dbc93306a38..f8bf9ea10b2 100644 --- a/sql/share/russian/errmsg.txt +++ b/sql/share/russian/errmsg.txt @@ -248,7 +248,7 @@ character-set=koi8r "Key reference and table reference doesn't match", "ïÐÅÒÁÎÄ ÄÏÌÖÅÎ ÓÏÄÅÒÖÁÔØ %d ËÏÌÏÎÏË", "ðÏÄÚÁÐÒÏÓ ×ÏÚ×ÒÁÝÁÅÔ ÂÏÌÅÅ ÏÄÎÏÊ ÚÁÐÉÓÉ", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "ãÉËÌÉÞÅÓËÁÑ ÓÓÙÌËÁ ÎÁ ÐÏÄÚÁÐÒÏÓ", "ðÒÅÏÂÒÁÚÏ×ÁÎÉÅ ÐÏÌÑ '%s' ÉÚ %s × %s", diff --git a/sql/share/slovak/errmsg.txt b/sql/share/slovak/errmsg.txt index 80d21f8e31f..16f9b0a8f35 100644 --- a/sql/share/slovak/errmsg.txt +++ b/sql/share/slovak/errmsg.txt @@ -254,7 +254,7 @@ character-set=latin2 "Key reference and table reference doesn't match", "Operand should contain %d column(s)", "Subquery returns more than 1 row", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "Cyclic reference on subqueries", "Converting column '%s' from %s to %s", diff --git a/sql/share/spanish/errmsg.txt b/sql/share/spanish/errmsg.txt index 512f06c8c50..9ae998184e5 100644 --- a/sql/share/spanish/errmsg.txt +++ b/sql/share/spanish/errmsg.txt @@ -248,7 +248,7 @@ character-set=latin1 "Referencia de llave y referencia de tabla no coinciden", "Operando debe tener %d columna(s)", "Subconsulta retorna mas que 1 línea", -"Desconocido preparado comando handler (%ld) dado para %s", +"Desconocido preparado comando handler (%.*s) dado para %s", "Base de datos Help está corrupto o no existe", "Cíclica referencia en subconsultas", "Convirtiendo columna '%s' de %s para %s", diff --git a/sql/share/swedish/errmsg.txt b/sql/share/swedish/errmsg.txt index 22e7cb786b5..aed3e9d3d34 100644 --- a/sql/share/swedish/errmsg.txt +++ b/sql/share/swedish/errmsg.txt @@ -246,7 +246,7 @@ character-set=latin1 "Nyckelreferensen och tabellreferensen stämmer inte överens", "Operand should contain %d column(s)", "Subquery returnerade mer än 1 rad", -"Okänd PREPARED STATEMENT id (%ld) var given till %s", +"Okänd PREPARED STATEMENT id (%.*s) var given till %s", "Hjälpdatabasen finns inte eller är skadad", "Cyklisk referens i subqueries", "Konvertar kolumn '%s' från %s till %s", diff --git a/sql/share/ukrainian/errmsg.txt b/sql/share/ukrainian/errmsg.txt index 3149d58b413..c0ccd76f157 100644 --- a/sql/share/ukrainian/errmsg.txt +++ b/sql/share/ukrainian/errmsg.txt @@ -251,7 +251,7 @@ character-set=koi8u "Key reference and table reference doesn't match", "ïÐÅÒÁÎÄ ÍÁ¤ ÓËÌÁÄÁÔÉÓÑ Ú %d ÓÔÏ×Âæ×", "ð¦ÄÚÁÐÉÔ ÐÏ×ÅÒÔÁ¤ ¦ÌØÛ ÎiÖ 1 ÚÁÐÉÓ", -"Unknown prepared statement handler (%ld) given to %s", +"Unknown prepared statement handler (%.*s) given to %s", "Help database is corrupt or does not exist", "ãÉË̦ÞÎÅ ÐÏÓÉÌÁÎÎÑ ÎÁ ЦÄÚÁÐÉÔ", "ðÅÒÅÔ×ÏÒÅÎÎÑ ÓÔÏ×ÂÃÁ '%s' Ú %s Õ %s", diff --git a/sql/sql_class.h b/sql/sql_class.h index f208a3f4d73..b5774688e1e 100644 --- a/sql/sql_class.h +++ b/sql/sql_class.h @@ -556,8 +556,13 @@ public: Statement *find(ulong id) { if (last_found_statement == 0 || id != last_found_statement->id) - last_found_statement= (Statement *) hash_search(&st_hash, (byte *) &id, - sizeof(id)); + { + Statement *stmt; + stmt= (Statement *) hash_search(&st_hash, (byte *) &id, sizeof(id)); + if (stmt->name.str) + return NULL; + last_found_statement= stmt; + } return last_found_statement; } void erase(Statement *statement) diff --git a/sql/sql_lex.h b/sql/sql_lex.h index a525bc485c1..9bea0de7b39 100644 --- a/sql/sql_lex.h +++ b/sql/sql_lex.h @@ -608,7 +608,13 @@ typedef struct st_lex 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 )*/ + /* + Prepared statement query text or name of variable that holds the + prepared statement (in PREPARE ... queries) + */ + LEX_STRING prepared_stmt_code; + /* If true, prepared_stmt_code is a name of variable that holds the query */ + bool prepared_stmt_code_is_varref; /* Names of user variables holding parameters (in EXECUTE) */ List prepared_stmt_params; st_lex() {} diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 65d538e3ac4..cd8891ad326 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -1972,14 +1972,90 @@ mysql_execute_command(THD *thd) } case SQLCOM_PREPARE: { - 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)); + char *query_str; + uint query_len; + if (lex->prepared_stmt_code_is_varref) + { + /* This is PREPARE stmt FROM @var*/ + String str; + CHARSET_INFO *to_cs= thd->variables.collation_connection; + CHARSET_INFO *from_cs; + const char *buf; + uint buf_len; + bool need_conversion; + //// psergey: find the variable and convert it. + LINT_INIT(from_cs); + user_var_entry *entry; + uint32 unused; + if ((entry= + (user_var_entry*)hash_search(&thd->user_vars, + (byte*)lex->prepared_stmt_code.str, + lex->prepared_stmt_code.length)) + && entry->value) + { + switch (entry->type) + { + case REAL_RESULT: + str.set(*(double*)entry->value, NOT_FIXED_DEC, to_cs); + buf_len= str.length(); + buf= str.ptr(); + need_conversion= false; + break; + case INT_RESULT: + str.set(*(longlong*)entry->value, to_cs); + buf_len= str.length(); + buf= str.ptr(); + need_conversion= false; + break; + case STRING_RESULT: + buf_len= entry->length; + buf= entry->value; + from_cs = entry->collation.collation; + need_conversion= String::needs_conversion(entry->length, from_cs, + to_cs, &unused); + break; + default: + buf= ""; + need_conversion= false; + buf_len= 0; + DBUG_ASSERT(0); + } + } + else + { + from_cs= &my_charset_bin; + str.set("NULL", 4, from_cs); + buf= str.ptr(); + buf_len= str.length(); + need_conversion= String::needs_conversion(str.length(), from_cs, + to_cs, &unused); + } + + query_len = need_conversion? (buf_len* to_cs->mbmaxlen) : buf_len; + if (!(query_str= alloc_root(&thd->mem_root, query_len+1))) + { + send_error(thd, ER_OUT_OF_RESOURCES); + } + + if (need_conversion) + query_len= copy_and_convert(query_str, query_len, to_cs, buf, buf_len, + from_cs); + else + memcpy(query_str, buf, query_len); + query_str[query_len] = 0; + } + else + { + 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)); + query_str= lex->prepared_stmt_code.str; + query_len= lex->prepared_stmt_code.length + 1; + } thd->command= COM_PREPARE; - if (!mysql_stmt_prepare(thd, lex->prepared_stmt_code.str, - lex->prepared_stmt_code.length + 1, + if (!mysql_stmt_prepare(thd, query_str, query_len + 1, &lex->prepared_stmt_name)) send_ok(thd, 0L, 0L, "Statement prepared"); break; @@ -2005,7 +2081,12 @@ mysql_execute_command(THD *thd) send_ok(thd); } else - send_error(thd,ER_UNKNOWN_STMT_HANDLER,"Undefined prepared statement"); + { + res= -1; + my_error(ER_UNKNOWN_STMT_HANDLER, MYF(0), + lex->prepared_stmt_name.length, lex->prepared_stmt_name.str, + "DEALLOCATE PREPARE"); + } break; } case SQLCOM_DO: @@ -3438,7 +3519,7 @@ error: */ int check_one_table_access(THD *thd, ulong privilege, TABLE_LIST *tables) - + { if (check_access(thd, privilege, tables->db, &tables->grant.privilege,0,0)) return 1; diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index 1612432cd67..af489d20783 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -135,7 +135,8 @@ find_prepared_statement(THD *thd, ulong id, const char *where, if (stmt == 0 || stmt->type() != Statement::PREPARED_STATEMENT) { - my_error(ER_UNKNOWN_STMT_HANDLER, MYF(0), id, where); + char llbuf[22]; + my_error(ER_UNKNOWN_STMT_HANDLER, MYF(0), 22, llstr(id, llbuf), where); if (se == SEND_ERROR) send_error(thd); return 0; @@ -392,7 +393,7 @@ void set_param_date(Item_param *param, uchar **pos, ulong len) void set_param_str(Item_param *param, uchar **pos, ulong len) { ulong length= get_param_length(pos, len); - param->set_value((const char *)*pos, length); + param->set_value((const char *)*pos, length, Item::default_charset()); *pos+= length; } @@ -1376,7 +1377,7 @@ static int send_prepare_results(Prepared_statement *stmt, bool text_protocol) goto error; } if (res == 0) - DBUG_RETURN(text_protocol?0:send_prep_stmt(stmt, 0)); + DBUG_RETURN(text_protocol? 0 : send_prep_stmt(stmt, 0)); error: if (res < 0) send_error(thd, thd->killed ? ER_SERVER_SHUTDOWN : 0); @@ -1417,25 +1418,31 @@ static bool init_param_array(Prepared_statement *stmt) /* + Given a query string with parameter markers, create a Prepared Statement + from it and send PS info back to the client. + SYNOPSIS mysql_stmt_prepare() - packet Prepared query - packet_length query length, with ignored trailing NULL or quote char. + packet query to be prepared + packet_length query string length, including 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 + protocol is used, for named statements text protocol is used. + RETURN + 0 OK, statement prepared successfully + other Error + + NOTES + This function parses the query and sends the total number of parameters + and resultset metadata information back to client (if any), without + executing the query i.e. without any log/disk writes. This allows the + queries to be re-executed without re-parsing during execute. - 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 - writes. This will allow the queries to be re-executed - without re-parsing during execute. - - If parameter markers are found in the query, then store - the information using Item_param along with maintaining a - list in lex->param_array, so that a fast and direct - retrieval can be made without going through all field - items. + If parameter markers are found in the query, then store the information + using Item_param along with maintaining a list in lex->param_array, so + that a fast and direct retrieval can be made without going through all + field items. */ @@ -1672,13 +1679,14 @@ set_params_data_err: void mysql_sql_stmt_execute(THD *thd, LEX_STRING *stmt_name) { Prepared_statement *stmt; - DBUG_ENTER("mysql_stmt_execute"); + DBUG_ENTER("mysql_sql_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; + my_error(ER_UNKNOWN_STMT_HANDLER, MYF(0), stmt_name->length, + stmt_name->str, "EXECUTE"); + send_error(thd); + DBUG_VOID_RETURN; } if (stmt->param_count != thd->lex->prepared_stmt_params.elements) diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy index 6a683a26b01..bb226f76b2c 100644 --- a/sql/sql_yacc.yy +++ b/sql/sql_yacc.yy @@ -726,7 +726,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 + prepare prepare_src execute deallocate END_OF_INPUT %type @@ -816,7 +816,7 @@ deallocate: }; prepare: - PREPARE_SYM ident FROM TEXT_STRING_sys + PREPARE_SYM ident FROM prepare_src { THD *thd=YYTHD; LEX *lex= thd->lex; @@ -827,9 +827,24 @@ prepare: } lex->sql_command= SQLCOM_PREPARE; lex->prepared_stmt_name= $2; - lex->prepared_stmt_code= $4; }; +prepare_src: + TEXT_STRING_sys + { + THD *thd=YYTHD; + LEX *lex= thd->lex; + lex->prepared_stmt_code= $1; + lex->prepared_stmt_code_is_varref= false; + } + | '@' ident_or_text + { + THD *thd=YYTHD; + LEX *lex= thd->lex; + lex->prepared_stmt_code= $2; + lex->prepared_stmt_code_is_varref= true; + }; + execute: EXECUTE_SYM ident { From c0729cbbca7632177a341cdd40e7e062af1a57a7 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 24 May 2004 21:08:22 +0400 Subject: [PATCH 10/12] Added support for PREPARE stmt1 FROM @var, Fixed the problem of previous patch with replication, More post-review fixes sql/sql_parse.cc: Added support for PREPARE stmt1 FROM @var sql/sql_prepare.cc: Added support for PREPARE stmt1 FROM @var, Fixed the problem of previous patch with replication Post-review fixes. --- sql/sql_parse.cc | 27 ++++++------ sql/sql_prepare.cc | 108 +++++++++++++++++++++++++++++---------------- 2 files changed, 83 insertions(+), 52 deletions(-) diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 013cac12e9b..1d5012a97a0 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -1978,17 +1978,21 @@ mysql_execute_command(THD *thd) uint query_len; if (lex->prepared_stmt_code_is_varref) { - /* This is PREPARE stmt FROM @var*/ + /* This is PREPARE stmt FROM @var. */ String str; CHARSET_INFO *to_cs= thd->variables.collation_connection; CHARSET_INFO *from_cs; const char *buf; uint buf_len; bool need_conversion; - //// psergey: find the variable and convert it. - LINT_INIT(from_cs); + LINT_INIT(from_cs); /* protected by need_conversion */ user_var_entry *entry; uint32 unused; + /* + Convert @var contents to string in connection character set. Although + it is known that int/real/NULL value cannot be a valid query we still + convert it for error messages to uniform. + */ if ((entry= (user_var_entry*)hash_search(&thd->user_vars, (byte*)lex->prepared_stmt_code.str, @@ -2033,32 +2037,29 @@ mysql_execute_command(THD *thd) to_cs, &unused); } - query_len = need_conversion? (buf_len* to_cs->mbmaxlen) : buf_len; + query_len = need_conversion? (buf_len * to_cs->mbmaxlen) : buf_len; if (!(query_str= alloc_root(&thd->mem_root, query_len+1))) - { send_error(thd, ER_OUT_OF_RESOURCES); - } if (need_conversion) query_len= copy_and_convert(query_str, query_len, to_cs, buf, buf_len, from_cs); else memcpy(query_str, buf, query_len); - query_str[query_len] = 0; + query_str[query_len]= 0; } else { + query_str= lex->prepared_stmt_code.str; + query_len= lex->prepared_stmt_code.length; 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)); - query_str= lex->prepared_stmt_code.str; - query_len= lex->prepared_stmt_code.length + 1; + query_len, query_str)); } thd->command= COM_PREPARE; - if (!mysql_stmt_prepare(thd, query_str, query_len + 1, - &lex->prepared_stmt_name)) + if (!mysql_stmt_prepare(thd, query_str, query_len + 1, + &lex->prepared_stmt_name)) send_ok(thd, 0L, 0L, "Statement prepared"); break; } diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index 39add455b45..32e70f24c9f 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -94,19 +94,21 @@ public: bool log_full_query; #ifndef EMBEDDED_LIBRARY bool (*set_params)(Prepared_statement *st, uchar *data, uchar *data_end, - uchar *read_pos); + uchar *read_pos, String *expanded_query); #else - bool (*set_params_data)(Prepared_statement *st); + bool (*set_params_data)(Prepared_statement *st, String *expanded_query); #endif bool (*set_params_from_vars)(Prepared_statement *stmt, - List& varnames); + List& varnames, + String *expanded_query); public: Prepared_statement(THD *thd_arg); virtual ~Prepared_statement(); virtual Statement::Type type() const; }; -static void execute_stmt(THD *thd, Prepared_statement *stmt); +static void execute_stmt(THD *thd, Prepared_statement *stmt, + String *expanded_query); /****************************************************************************** Implementation @@ -517,19 +519,20 @@ static void setup_one_conversion_function(Item_param *param, uchar param_type) */ static bool insert_params_withlog(Prepared_statement *stmt, uchar *null_array, - uchar *read_pos, uchar *data_end) + uchar *read_pos, uchar *data_end, + String *query) { THD *thd= stmt->thd; Item_param **begin= stmt->param_array; Item_param **end= begin + stmt->param_count; uint32 length= 0; - String str, query; + String str; const String *res; DBUG_ENTER("insert_params_withlog"); - if (query.copy(stmt->query, stmt->query_length, default_charset_info)) + if (query->copy(stmt->query, stmt->query_length, default_charset_info)) DBUG_RETURN(1); for (Item_param **it= begin; it < end; ++it) @@ -552,20 +555,18 @@ static bool insert_params_withlog(Prepared_statement *stmt, uchar *null_array, res= param->query_val_str(&str); } } - if (query.replace(param->pos_in_query+length, 1, *res)) + if (query->replace(param->pos_in_query+length, 1, *res)) DBUG_RETURN(1); length+= res->length()-1; } - if (alloc_query(thd, (char *)query.ptr(), query.length()+1)) - DBUG_RETURN(1); - DBUG_RETURN(0); } static bool insert_params(Prepared_statement *stmt, uchar *null_array, - uchar *read_pos, uchar *data_end) + uchar *read_pos, uchar *data_end, + String *expanded_query) { Item_param **begin= stmt->param_array; Item_param **end= begin + stmt->param_count; @@ -627,7 +628,7 @@ static bool setup_conversion_functions(Prepared_statement *stmt, #else -static bool emb_insert_params(Prepared_statement *stmt) +static bool emb_insert_params(Prepared_statement *stmt, String *expanded_query) { Item_param **it= stmt->param_array; Item_param **end= it + stmt->param_count; @@ -658,20 +659,20 @@ static bool emb_insert_params(Prepared_statement *stmt) } -static bool emb_insert_params_withlog(Prepared_statement *stmt) +static bool emb_insert_params_withlog(Prepared_statement *stmt, String *query) { THD *thd= stmt->thd; Item_param **it= stmt->param_array; Item_param **end= it + stmt->param_count; MYSQL_BIND *client_param= thd->client_params; - String str, query; + String str; const String *res; uint32 length= 0; DBUG_ENTER("emb_insert_params_withlog"); - if (query.copy(stmt->query, stmt->query_length, default_charset_info)) + if (query->copy(stmt->query, stmt->query_length, default_charset_info)) DBUG_RETURN(1); for (; it < end; ++it, ++client_param) @@ -697,14 +698,10 @@ static bool emb_insert_params_withlog(Prepared_statement *stmt) res= param->query_val_str(&str); } } - if (query.replace(param->pos_in_query+length, 1, *res)) + if (query->replace(param->pos_in_query+length, 1, *res)) DBUG_RETURN(1); length+= res->length()-1; } - - if (alloc_query(thd, (char *) query.ptr(), query.length()+1)) - DBUG_RETURN(1); - DBUG_RETURN(0); } @@ -718,11 +715,12 @@ static bool emb_insert_params_withlog(Prepared_statement *stmt) stmt Statement varnames List of variables. Caller must ensure that number of variables in the list is equal to number of statement parameters - + query Ignored */ static bool insert_params_from_vars(Prepared_statement *stmt, - List& varnames) + List& varnames, + String *query __attribute__((unused))) { Item_param **begin= stmt->param_array; Item_param **end= begin + stmt->param_count; @@ -763,8 +761,21 @@ static bool insert_params_from_vars(Prepared_statement *stmt, DBUG_RETURN(0); } + +/* + Do the same as insert_params_from_vars but also construct query text for + binary log. + 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 + query The query with parameter markers replaced with their values +*/ + static bool insert_params_from_vars_with_log(Prepared_statement *stmt, - List& varnames) + List& varnames, + String *query) { Item_param **begin= stmt->param_array; Item_param **end= begin + stmt->param_count; @@ -773,10 +784,10 @@ static bool insert_params_from_vars_with_log(Prepared_statement *stmt, DBUG_ENTER("insert_params_from_vars"); List_iterator var_it(varnames); - String str, query; + String str; const String *res; uint32 length= 0; - if (query.copy(stmt->query, stmt->query_length, default_charset_info)) + if (query->copy(stmt->query, stmt->query_length, default_charset_info)) DBUG_RETURN(1); for (Item_param **it= begin; it < end; ++it) @@ -812,12 +823,10 @@ static bool insert_params_from_vars_with_log(Prepared_statement *stmt, res= &my_null_string; } - if (query.replace(param->pos_in_query+length, 1, *res)) + 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); } @@ -1708,13 +1717,14 @@ void mysql_stmt_execute(THD *thd, char *packet, uint packet_length) DBUG_VOID_RETURN; } - + String expanded_query; #ifndef EMBEDDED_LIBRARY if (stmt->param_count) { uchar *null_array= (uchar *) packet; if (setup_conversion_functions(stmt, (uchar **) &packet, packet_end) || - stmt->set_params(stmt, null_array, (uchar *) packet, packet_end)) + stmt->set_params(stmt, null_array, (uchar *) packet, packet_end, + &expanded_query)) goto set_params_data_err; } #else @@ -1727,7 +1737,7 @@ void mysql_stmt_execute(THD *thd, char *packet, uint packet_length) goto set_params_data_err; #endif thd->protocol= &thd->protocol_prep; // Switch to binary protocol - execute_stmt(thd, stmt); + execute_stmt(thd, stmt, &expanded_query); thd->protocol= &thd->protocol_simple; // Use normal protocol DBUG_VOID_RETURN; @@ -1747,6 +1757,7 @@ set_params_data_err: void mysql_sql_stmt_execute(THD *thd, LEX_STRING *stmt_name) { Prepared_statement *stmt; + String expanded_query; DBUG_ENTER("mysql_sql_stmt_execute"); if (!(stmt= (Prepared_statement*)thd->stmt_map.find_by_name(stmt_name))) @@ -1766,27 +1777,47 @@ void mysql_sql_stmt_execute(THD *thd, LEX_STRING *stmt_name) /* Item_param allows setting parameters in COM_EXECUTE only */ thd->command= COM_EXECUTE; - if (stmt->set_params_from_vars(stmt, thd->lex->prepared_stmt_params)) + if (stmt->set_params_from_vars(stmt, thd->lex->prepared_stmt_params, + &expanded_query)) { my_error(ER_WRONG_ARGUMENTS, MYF(0), "mysql_execute"); send_error(thd); } - execute_stmt(thd, stmt); + execute_stmt(thd, stmt, &expanded_query); DBUG_VOID_RETURN; } + /* Execute prepared statement. + SYNOPSIS + execute_stmt() + thd Current thread + stmt Statement to execute + expanded_query If binary log is enabled, query string with parameter + placeholders replaced with actual values. Otherwise empty + string. + NOTES Caller must set parameter values and thd::protocol. thd->free_list is assumed to be garbage. */ -static void execute_stmt(THD *thd, Prepared_statement *stmt) + +static void execute_stmt(THD *thd, Prepared_statement *stmt, + String *expanded_query) { DBUG_ENTER("execute_stmt"); thd->free_list= NULL; thd->stmt_backup.set_statement(thd); thd->set_statement(stmt); reset_stmt_for_execute(stmt); + + if (expanded_query->length() && + alloc_query(thd, (char *)expanded_query->ptr(), + expanded_query->length()+1)) + { + my_error(ER_OUTOFMEMORY, 0, expanded_query->length()); + DBUG_VOID_RETURN; + } if (!(specialflag & SPECIAL_NO_PRIOR)) my_pthread_setprio(pthread_self(),QUERY_PRIOR); @@ -1808,13 +1839,12 @@ static void execute_stmt(THD *thd, Prepared_statement *stmt) } - /* - Reset a prepared statement in case there was a recoverable error. + Reset a prepared statement in case there was a recoverable error. SYNOPSIS mysql_stmt_reset() - thd Thread handle - packet Packet with stmt id + thd Thread handle + packet Packet with stmt id DESCRIPTION This function resets statement to the state it was right after prepare. From fbfdcf22f49eacc4a90fb6169dbbecb36d8e8b68 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 24 May 2004 21:12:05 +0400 Subject: [PATCH 11/12] Added replication tests --- mysql-test/r/rpl_ps.result | 28 +++++++++++++++++++++++++ mysql-test/t/rpl_ps.test | 43 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 71 insertions(+) create mode 100644 mysql-test/r/rpl_ps.result create mode 100644 mysql-test/t/rpl_ps.test diff --git a/mysql-test/r/rpl_ps.result b/mysql-test/r/rpl_ps.result new file mode 100644 index 00000000000..c969575de76 --- /dev/null +++ b/mysql-test/r/rpl_ps.result @@ -0,0 +1,28 @@ +stop slave; +drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9; +reset master; +reset slave; +drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9; +start slave; +drop table if exists t1; +create table t1(n char(30)); +prepare stmt1 from 'insert into t1 values (?)'; +set @var1= "from-master-1"; +execute stmt1 using @var1; +set @var1= "from-master-2-'',"; +execute stmt1 using @var1; +select * from t1; +n +from-master-1 +from-master-2-'', +set @var2= 'insert into t1 values (concat("from-var-", ?))'; +prepare stmt2 from @var2; +set @var1='from-master-3'; +execute stmt2 using @var1; +select * from t1; +n +from-master-1 +from-master-2-'', +from-var-from-master-3 +drop table t1; +stop slave; diff --git a/mysql-test/t/rpl_ps.test b/mysql-test/t/rpl_ps.test new file mode 100644 index 00000000000..79f48381a4f --- /dev/null +++ b/mysql-test/t/rpl_ps.test @@ -0,0 +1,43 @@ +# +# Test of replicating user variables +# +source include/master-slave.inc; + +#save_master_pos; +#connection slave; +#sync_with_master; +#reset master; +#connection master; + +--disable_warnings +drop table if exists t1; +--enable_warnings + +create table t1(n char(30)); + +prepare stmt1 from 'insert into t1 values (?)'; +set @var1= "from-master-1"; +execute stmt1 using @var1; +set @var1= "from-master-2-'',"; +execute stmt1 using @var1; +select * from t1; + +set @var2= 'insert into t1 values (concat("from-var-", ?))'; +prepare stmt2 from @var2; +set @var1='from-master-3'; +execute stmt2 using @var1; + +save_master_pos; +connection slave; +sync_with_master; +select * from t1; + +connection master; + +drop table t1; + +save_master_pos; +connection slave; +sync_with_master; +stop slave; + From 9626b4d073ed62746e23e2b04afbeb184bc57f40 Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 1 Jun 2004 17:27:40 +0400 Subject: [PATCH 12/12] * New, binlog-aware character sets support in SQL Syntax for Prepared statements. * The prepared statement query is put into binary log on execution only if it is an update query. sql/item_func.cc: New, binlog-aware character sets support in SQL Syntax for Prepared statements. sql/mysql_priv.h: New, binlog-aware character sets support in SQL Syntax for Prepared statements. --- sql/item_func.cc | 78 ++++++++++++++++------ sql/mysql_priv.h | 3 + sql/sql_prepare.cc | 158 ++++++++++++++++++++++++++++++++++++--------- 3 files changed, 190 insertions(+), 49 deletions(-) diff --git a/sql/item_func.cc b/sql/item_func.cc index f221e0dcc5c..2fc1f68b49c 100644 --- a/sql/item_func.cc +++ b/sql/item_func.cc @@ -2583,27 +2583,39 @@ longlong Item_func_get_user_var::val_int() /* + Get variable by name and, if necessary, put the record of variable + use into the binary log. + + SYNOPSIS + get_var_with_binlog() + thd Current thread + name Variable name + out_entry [out] variable structure or NULL. The pointer is set + regardless of whether function succeeded or not. + When a user variable is invoked from an update query (INSERT, UPDATE etc), stores this variable and its value in thd->user_var_events, so that it can be written to the binlog (will be written just before the query is written, see log.cc). + + RETURN + 0 OK + 1 Failed to put appropiate record into binary log + */ -void Item_func_get_user_var::fix_length_and_dec() +int get_var_with_binlog(THD *thd, LEX_STRING &name, + user_var_entry **out_entry) { - THD *thd=current_thd; BINLOG_USER_VAR_EVENT *user_var_event; - maybe_null=1; - decimals=NOT_FIXED_DEC; - max_length=MAX_BLOB_WIDTH; - - if (!(var_entry= get_variable(&thd->user_vars, name, 0))) - null_value= 1; - else - collation.set(var_entry->collation); + user_var_entry *var_entry; + var_entry= get_variable(&thd->user_vars, name, 0); if (!(opt_bin_log && is_update_query(thd->lex->sql_command))) - return; + { + *out_entry= var_entry; + return 0; + } if (!var_entry) { @@ -2630,13 +2642,16 @@ void Item_func_get_user_var::fix_length_and_dec() if (!(var_entry= get_variable(&thd->user_vars, name, 0))) goto err; } - /* - If this variable was already stored in user_var_events by this query - (because it's used in more than one place in the query), don't store - it. - */ else if (var_entry->used_query_id == thd->query_id) - return; + { + /* + If this variable was already stored in user_var_events by this query + (because it's used in more than one place in the query), don't store + it. + */ + *out_entry= var_entry; + return 0; + } uint size; /* @@ -2671,11 +2686,34 @@ void Item_func_get_user_var::fix_length_and_dec() var_entry->used_query_id= thd->query_id; if (insert_dynamic(&thd->user_var_events, (gptr) &user_var_event)) goto err; - - return; + + *out_entry= var_entry; + return 0; err: - thd->fatal_error(); + *out_entry= var_entry; + return 1; +} + + +void Item_func_get_user_var::fix_length_and_dec() +{ + THD *thd=current_thd; + int error; + maybe_null=1; + decimals=NOT_FIXED_DEC; + max_length=MAX_BLOB_WIDTH; + + error= get_var_with_binlog(thd, name, &var_entry); + + if (!var_entry) + null_value= 1; + else + collation.set(var_entry->collation); + + if (error) + thd->fatal_error(); + return; } diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h index fe3efd720f0..2a88f6843fc 100644 --- a/sql/mysql_priv.h +++ b/sql/mysql_priv.h @@ -1069,6 +1069,9 @@ Item *get_system_var(THD *thd, enum_var_type var_type, LEX_STRING name, LEX_STRING component); Item *get_system_var(THD *thd, enum_var_type var_type, const char *var_name, uint length, const char *item_name); +/* item_func.cc */ +int get_var_with_binlog(THD *thd, LEX_STRING &name, + user_var_entry **out_entry); /* log.cc */ bool flush_error_log(void); diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index 1224d1da194..70b6a9de006 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -101,11 +101,12 @@ public: public: Prepared_statement(THD *thd_arg); virtual ~Prepared_statement(); + void setup_set_params(); virtual Statement::Type type() const; }; static void execute_stmt(THD *thd, Prepared_statement *stmt, - String *expanded_query); + String *expanded_query, bool set_context=false); /****************************************************************************** Implementation @@ -769,12 +770,14 @@ static bool emb_insert_params_withlog(Prepared_statement *stmt, String *query) *client_param->length : client_param->buffer_length); } - res= param->query_val_str(&str); - if (param->convert_str_value(thd)) - DBUG_RETURN(1); /* out of memory */ } + res= param->query_val_str(&str); + if (param->convert_str_value(thd)) + DBUG_RETURN(1); /* out of memory */ + if (query->replace(param->pos_in_query+length, 1, *res)) DBUG_RETURN(1); + length+= res->length()-1; } DBUG_RETURN(0); @@ -820,18 +823,45 @@ static bool insert_params_from_vars(Prepared_statement *stmt, param->set_double(*(double*)entry->value); break; case INT_RESULT: - param->set_int(*(longlong*)entry->value); + param->set_int(*(longlong*)entry->value, 21); break; case STRING_RESULT: - param->set_value(entry->value, entry->length, - entry->collation.collation); + { + CHARSET_INFO *fromcs= entry->collation.collation; + CHARSET_INFO *tocs= stmt->thd->variables.collation_connection; + uint32 dummy_offset; + + param->value.cs_info.character_set_client= fromcs; + + /* + Setup source and destination character sets so that they + are different only if conversion is necessary: this will + make later checks easier. + */ + param->value.cs_info.final_character_set_of_str_value= + String::needs_conversion(0, fromcs, tocs, &dummy_offset) ? + tocs : fromcs; + /* + Exact value of max_length is not known unless data is converted to + charset of connection, so we have to set it later. + */ + param->item_type= Item::STRING_ITEM; + param->item_result_type= STRING_RESULT; + + if (param->set_str((const char *)entry->value, entry->length)) + DBUG_RETURN(1); + } break; default: DBUG_ASSERT(0); + param->set_null(); } } else - param->maybe_null= param->null_value= param->value_is_set= 1; + param->set_null(); + + if (param->convert_str_value(stmt->thd)) + DBUG_RETURN(1); /* out of memory */ } DBUG_RETURN(0); } @@ -869,10 +899,10 @@ static bool insert_params_from_vars_with_log(Prepared_statement *stmt, { Item_param *param= *it; varname= var_it++; - if ((entry= (user_var_entry*)hash_search(&stmt->thd->user_vars, - (byte*) varname->str, - varname->length)) - && entry->value) + if (get_var_with_binlog(stmt->thd, *varname, &entry)) + DBUG_RETURN(1); + DBUG_ASSERT(entry); + if (entry->value) { param->item_result_type= entry->type; switch (entry->type) @@ -881,26 +911,65 @@ static bool insert_params_from_vars_with_log(Prepared_statement *stmt, param->set_double(*(double*)entry->value); break; case INT_RESULT: - param->set_int(*(longlong*)entry->value); + param->set_int(*(longlong*)entry->value, 21); break; case STRING_RESULT: - param->set_value(entry->value, entry->length, - entry->collation.collation); + { + CHARSET_INFO *fromcs= entry->collation.collation; + CHARSET_INFO *tocs= stmt->thd->variables.collation_connection; + uint32 dummy_offset; + + param->value.cs_info.character_set_client= fromcs; + + /* + Setup source and destination character sets so that they + are different only if conversion is necessary: this will + make later checks easier. + */ + param->value.cs_info.final_character_set_of_str_value= + String::needs_conversion(0, fromcs, tocs, &dummy_offset) ? + tocs : fromcs; + /* + Exact value of max_length is not known unless data is converted to + charset of connection, so we have to set it later. + */ + param->item_type= Item::STRING_ITEM; + param->item_result_type= STRING_RESULT; + + if (param->set_str((const char *)entry->value, entry->length)) + DBUG_RETURN(1); + } break; default: DBUG_ASSERT(0); + param->set_null(); } - res= param->query_val_str(&str); } else - { - param->maybe_null= param->null_value= param->value_is_set= 1; - res= &my_null_string; - } + param->set_null(); - if (query->replace(param->pos_in_query+length, 1, *res)) + /* Insert @'escaped-varname' instead of parameter in the query */ + char *buf, *ptr; + str.length(0); + if (str.reserve(entry->name.length*2+3)) DBUG_RETURN(1); - length+= res->length()-1; + + buf= str.c_ptr_quick(); + ptr= buf; + *ptr++= '@'; + *ptr++= '\''; + ptr+= + escape_string_for_mysql(&my_charset_utf8_general_ci, + ptr, entry->name.str, entry->name.length); + *ptr++= '\''; + str.length(ptr - buf); + + if (param->convert_str_value(stmt->thd)) + DBUG_RETURN(1); /* out of memory */ + + if (query->replace(param->pos_in_query+length, 1, str)) + DBUG_RETURN(1); + length+= str.length()-1; } DBUG_RETURN(0); } @@ -1680,6 +1749,7 @@ int mysql_stmt_prepare(THD *thd, char *packet, uint packet_length, } else { + stmt->setup_set_params(); SELECT_LEX *sl= stmt->lex->all_selects_list; /* Save WHERE clause pointers, because they may be changed during query @@ -1689,7 +1759,9 @@ int mysql_stmt_prepare(THD *thd, char *packet, uint packet_length, { sl->prep_where= sl->where; } + } + DBUG_RETURN(!stmt); } @@ -1809,7 +1881,7 @@ void mysql_stmt_execute(THD *thd, char *packet, uint packet_length) we set params, and also we don't need to parse packet. So we do it in one function. */ - if (stmt->param_count && stmt->set_params_data(stmt)) + if (stmt->param_count && stmt->set_params_data(stmt, &expanded_query)) goto set_params_data_err; #endif thd->protocol= &thd->protocol_prep; // Switch to binary protocol @@ -1853,7 +1925,10 @@ void mysql_sql_stmt_execute(THD *thd, LEX_STRING *stmt_name) /* Item_param allows setting parameters in COM_EXECUTE only */ thd->command= COM_EXECUTE; - if (stmt->set_params_from_vars(stmt, thd->lex->prepared_stmt_params, + thd->free_list= NULL; + thd->stmt_backup.set_statement(thd); + thd->set_statement(stmt); + if (stmt->set_params_from_vars(stmt, thd->stmt_backup.lex->prepared_stmt_params, &expanded_query)) { my_error(ER_WRONG_ARGUMENTS, MYF(0), "mysql_execute"); @@ -1879,12 +1954,15 @@ void mysql_sql_stmt_execute(THD *thd, LEX_STRING *stmt_name) */ static void execute_stmt(THD *thd, Prepared_statement *stmt, - String *expanded_query) + String *expanded_query, bool set_context) { DBUG_ENTER("execute_stmt"); - thd->free_list= NULL; - thd->stmt_backup.set_statement(thd); - thd->set_statement(stmt); + if (set_context) + { + thd->free_list= NULL; + thd->stmt_backup.set_statement(thd); + thd->set_statement(stmt); + } reset_stmt_for_execute(stmt); if (expanded_query->length() && @@ -2060,7 +2138,7 @@ Prepared_statement::Prepared_statement(THD *thd_arg) get_longdata_error(0) { *last_error= '\0'; - if (mysql_bin_log.is_open()) + if (mysql_bin_log.is_open()) //psergey-todo: remove this! { set_params_from_vars= insert_params_from_vars_with_log; #ifndef EMBEDDED_LIBRARY @@ -2080,6 +2158,28 @@ Prepared_statement::Prepared_statement(THD *thd_arg) } } +void Prepared_statement::setup_set_params() +{ + /* Setup binary logging */ + if (mysql_bin_log.is_open() && is_update_query(lex->sql_command)) + { + set_params_from_vars= insert_params_from_vars_with_log; +#ifndef EMBEDDED_LIBRARY + set_params= insert_params_withlog; +#else + set_params_data= emb_insert_params_withlog; +#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 + } +} Prepared_statement::~Prepared_statement() {