Many files:

  SQL Syntax for Prepared Statements (WL#1622)
ps.test, ps.result:
  new file

mysql-test/r/ps.result

+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;

mysql-test/t/ps.test

+#
+# 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;
+

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);

sql/item.h

@@ -385,6 +385,7 @@ class Item_param :public Item
   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);

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)},

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);

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},

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)

sql/sql_class.h

@@ -594,6 +594,12 @@ class THD :public ilink,
   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) */
 

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<LEX_STRING> prepared_stmt_params; 
   st_lex() {}
   inline void uncacheable(uint8 cause)
   {

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))))

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 <NONE>
@@ -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	{}