开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
sql_prepare.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：57k
源码类别：

MySQL数据库

开发平台：

Visual C++

sql_prepare.cpp：源码内容
  1. /* Copyright (C) 1995-2002 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA */
  17. /**********************************************************************
  18. This file contains the implementation of prepare and executes. 
  20. Prepare:
  22.   - Server gets the query from client with command 'COM_PREPARE'; 
  23.     in the following format:
  24.     [COM_PREPARE:1] [query]
  25.   - Parse the query and recognize any parameter markers '?' and 
  26.     store its information list in lex->param_list
  27.   - Allocate a new statement for this prepare; and keep this in 
  28.     'thd->prepared_statements' pool.
  29.   - Without executing the query, return back to client the total 
  30.     number of parameters along with result-set metadata information
  31.     (if any) in the following format:
  32.     [STMT_ID:4]
  33.     [Column_count:2]
  34.     [Param_count:2]
  35.     [Columns meta info] (if Column_count > 0)
  36.     [Params meta info]  (if Param_count > 0 ) (TODO : 4.1.1)
  37.      
  38. Prepare-execute:
  40.   - Server gets the command 'COM_EXECUTE' to execute the 
  41.     previously prepared query. If there is any param markers; then client
  42.     will send the data in the following format:
  43.     [COM_EXECUTE:1]
  44.     [STMT_ID:4]
  45.     [NULL_BITS:(param_count+7)/8)]
  46.     [TYPES_SUPPLIED_BY_CLIENT(0/1):1]
  47.     [[length]data]
  48.     [[length]data] .. [[length]data]. 
  49.     (Note: Except for string/binary types; all other types will not be 
  50.     supplied with length field)
  51.   - Replace the param items with this new data. If it is a first execute 
  52.     or types altered by client; then setup the conversion routines.
  53.   - Execute the query without re-parsing and send back the results 
  54.     to client
  56. Long data handling:
  58.   - Server gets the long data in pieces with command type 'COM_LONG_DATA'.
  59.   - The packet recieved will have the format as:
  60.     [COM_LONG_DATA:1][STMT_ID:4][parameter_number:2][data]
  61.   - data from the packet is appended to long data value buffer for this
  62.     placeholder.
  63.   - It's up to the client to check for read data ended. The server doesn't
  64.     care; and also server doesn't notify to the client that it got the 
  65.     data or not; if there is any error; then during execute; the error 
  66.     will be returned
  68. ***********************************************************************/
  70. #include "mysql_priv.h"
  71. #include "sql_select.h" // for JOIN
  72. #include <m_ctype.h>  // for isspace()
  73. #ifdef EMBEDDED_LIBRARY
  74. /* include MYSQL_BIND headers */
  75. #include <mysql.h>
  76. #endif
  78. /******************************************************************************
  79.   Prepared_statement: statement which can contain placeholders
  80. ******************************************************************************/
  82. class Prepared_statement: public Statement
  83. {
  84. public:
  85.   THD *thd;
  86.   Item_param **param_array;
  87.   uint param_count;
  88.   uint last_errno;
  89.   char last_error[MYSQL_ERRMSG_SIZE];
  90. #ifndef EMBEDDED_LIBRARY
  91.   bool (*set_params)(Prepared_statement *st, uchar *data, uchar *data_end,
  92.                      uchar *read_pos, String *expanded_query);
  93. #else
  94.   bool (*set_params_data)(Prepared_statement *st, String *expanded_query);
  95. #endif
  96.   bool (*set_params_from_vars)(Prepared_statement *stmt, 
  97.                                List<LEX_STRING>& varnames,
  98.                                String *expanded_query);
  99. public:
  100.   Prepared_statement(THD *thd_arg);
  101.   virtual ~Prepared_statement();
  102.   void setup_set_params();
  103.   virtual Item_arena::Type type() const;
  104. };
  106. static void execute_stmt(THD *thd, Prepared_statement *stmt,
  107.                          String *expanded_query, bool set_context);
  109. /******************************************************************************
  110.   Implementation
  111. ******************************************************************************/
  114. inline bool is_param_null(const uchar *pos, ulong param_no)
  115. {
  116.   return pos[param_no/8] & (1 << (param_no & 7));
  117. }
  119. enum { STMT_QUERY_LOG_LENGTH= 8192 };
  121. enum enum_send_error { DONT_SEND_ERROR= 0, SEND_ERROR };
  123. /*
  124.   Seek prepared statement in statement map by id: returns zero if statement
  125.   was not found, pointer otherwise.
  126. */
  128. static Prepared_statement *
  129. find_prepared_statement(THD *thd, ulong id, const char *where,
  130.                         enum enum_send_error se)
  131. {
  132.   Statement *stmt= thd->stmt_map.find(id);
  134.   if (stmt == 0 || stmt->type() != Item_arena::PREPARED_STATEMENT)
  135.   {
  136.     char llbuf[22];
  137.     my_error(ER_UNKNOWN_STMT_HANDLER, MYF(0), 22, llstr(id, llbuf), where);
  138.     if (se == SEND_ERROR)
  139.       send_error(thd);
  140.     return 0;
  141.   }
  142.   return (Prepared_statement *) stmt;
  143. }
  146. /*
  147.   Send prepared stmt info to client after prepare
  148. */
  150. #ifndef EMBEDDED_LIBRARY
  151. static bool send_prep_stmt(Prepared_statement *stmt, uint columns)
  152. {
  153.   NET *net= &stmt->thd->net;
  154.   char buff[9];
  155.   DBUG_ENTER("send_prep_stmt");
  157.   buff[0]= 0;                                   /* OK packet indicator */
  158.   int4store(buff+1, stmt->id);
  159.   int2store(buff+5, columns);
  160.   int2store(buff+7, stmt->param_count);
  161.   /*
  162.     Send types and names of placeholders to the client
  163.     XXX: fix this nasty upcast from List<Item_param> to List<Item>
  164.   */
  165.   DBUG_RETURN(my_net_write(net, buff, sizeof(buff)) || 
  166.               (stmt->param_count &&
  167.                stmt->thd->protocol_simple.send_fields((List<Item> *)
  168.                                                       &stmt->lex->param_list,
  169.                                                       0)));
  170. }
  171. #else
  172. static bool send_prep_stmt(Prepared_statement *stmt,
  173.                            uint columns __attribute__((unused)))
  174. {
  175.   THD *thd= stmt->thd;
  177.   thd->client_stmt_id= stmt->id;
  178.   thd->client_param_count= stmt->param_count;
  179.   thd->net.last_errno= 0;
  181.   return 0;
  182. }
  183. #endif /*!EMBEDDED_LIBRARY*/
  186. /*
  187.   Read the length of the parameter data and return back to
  188.   caller by positing the pointer to param data.
  189. */
  191. #ifndef EMBEDDED_LIBRARY
  192. static ulong get_param_length(uchar **packet, ulong len)
  193. {
  194.   reg1 uchar *pos= *packet;
  195.   if (len < 1)
  196.     return 0;
  197.   if (*pos < 251)
  198.   {
  199.     (*packet)++;
  200.     return (ulong) *pos;
  201.   }
  202.   if (len < 3)
  203.     return 0;
  204.   if (*pos == 252)
  205.   {
  206.     (*packet)+=3;
  207.     return (ulong) uint2korr(pos+1);
  208.   }
  209.   if (len < 4)
  210.     return 0;
  211.   if (*pos == 253)
  212.   {
  213.     (*packet)+=4;
  214.     return (ulong) uint3korr(pos+1);
  215.   }
  216.   if (len < 5)
  217.     return 0;
  218.   (*packet)+=9; // Must be 254 when here 
  219.   /*
  220.     In our client-server protocol all numbers bigger than 2^24
  221.     stored as 8 bytes with uint8korr. Here we always know that
  222.     parameter length is less than 2^4 so don't look at the second
  223.     4 bytes. But still we need to obey the protocol hence 9 in the
  224.     assignment above.
  225.   */
  226.   return (ulong) uint4korr(pos+1);
  227. }
  228. #else
  229. #define get_param_length(packet, len) len
  230. #endif /*!EMBEDDED_LIBRARY*/
  232.  /*
  233.    Data conversion routines
  234.    SYNOPSIS
  235.    set_param_xx()
  236.     param   parameter item
  237.     pos     input data buffer
  238.     len     length of data in the buffer
  240.   All these functions read the data from pos, convert it to requested type 
  241.   and assign to param; pos is advanced to predefined length.
  243.   Make a note that the NULL handling is examined at first execution
  244.   (i.e. when input types altered) and for all subsequent executions
  245.   we don't read any values for this.
  247.   RETURN VALUE
  248.     none
  249. */
  251. static void set_param_tiny(Item_param *param, uchar **pos, ulong len)
  252. {
  253. #ifndef EMBEDDED_LIBRARY
  254.   if (len < 1)
  255.     return;
  256. #endif
  257.   int8 value= (int8) **pos;
  258.   param->set_int(param->unsigned_flag ? (longlong) ((uint8) value) : 
  259.                                         (longlong) value, 4);
  260.   *pos+= 1;
  261. }
  263. static void set_param_short(Item_param *param, uchar **pos, ulong len)
  264. {
  265.   int16 value;
  266. #ifndef EMBEDDED_LIBRARY
  267.   if (len < 2)
  268.     return;
  269.   value= sint2korr(*pos);
  270. #else
  271.   shortget(value, *pos);
  272. #endif
  273.   param->set_int(param->unsigned_flag ? (longlong) ((uint16) value) :
  274.                                         (longlong) value, 6);
  275.   *pos+= 2;
  276. }
  278. static void set_param_int32(Item_param *param, uchar **pos, ulong len)
  279. {
  280.   int32 value;
  281. #ifndef EMBEDDED_LIBRARY
  282.   if (len < 4)
  283.     return;
  284.   value= sint4korr(*pos);
  285. #else
  286.   longget(value, *pos);
  287. #endif
  288.   param->set_int(param->unsigned_flag ? (longlong) ((uint32) value) :
  289.                                         (longlong) value, 11);
  290.   *pos+= 4;
  291. }
  293. static void set_param_int64(Item_param *param, uchar **pos, ulong len)
  294. {
  295.   longlong value;
  296. #ifndef EMBEDDED_LIBRARY
  297.   if (len < 8)
  298.     return;
  299.   value= (longlong) sint8korr(*pos);
  300. #else
  301.   longlongget(value, *pos);
  302. #endif
  303.   param->set_int(value, 21);
  304.   *pos+= 8;
  305. }
  307. static void set_param_float(Item_param *param, uchar **pos, ulong len)
  308. {
  309.   float data;
  310. #ifndef EMBEDDED_LIBRARY
  311.   if (len < 4)
  312.     return;
  313.   float4get(data,*pos);
  314. #else
  315.   floatget(data, *pos);
  316. #endif
  317.   param->set_double((double) data);
  318.   *pos+= 4;
  319. }
  321. static void set_param_double(Item_param *param, uchar **pos, ulong len)
  322. {
  323.   double data;
  324. #ifndef EMBEDDED_LIBRARY
  325.   if (len < 8)
  326.     return;
  327.   float8get(data,*pos);
  328. #else
  329.   doubleget(data, *pos);
  330. #endif
  331.   param->set_double((double) data);
  332.   *pos+= 8;
  333. }
  335. #ifndef EMBEDDED_LIBRARY
  337. /*
  338.   Read date/time/datetime parameter values from network (binary
  339.   protocol). See writing counterparts of these functions in
  340.   libmysql.c (store_param_{time,date,datetime}).
  341. */
  343. static void set_param_time(Item_param *param, uchar **pos, ulong len)
  344. {
  345.   MYSQL_TIME tm;
  346.   ulong length= get_param_length(pos, len);
  348.   if (length >= 8)
  349.   {
  350.     uchar *to= *pos;
  351.     uint day;
  353.     tm.neg= (bool) to[0];
  354.     day= (uint) sint4korr(to+1);
  355.     tm.hour=   (uint) to[5] + day * 24;
  356.     tm.minute= (uint) to[6];
  357.     tm.second= (uint) to[7];
  358.     tm.second_part= (length > 8) ? (ulong) sint4korr(to+8) : 0;
  359.     if (tm.hour > 838)
  360.     {
  361.       /* TODO: add warning 'Data truncated' here */
  362.       tm.hour= 838;
  363.       tm.minute= 59;
  364.       tm.second= 59;
  365.     }
  366.     tm.day= tm.year= tm.month= 0;
  367.   }
  368.   else
  369.     set_zero_time(&tm, MYSQL_TIMESTAMP_TIME);
  370.   param->set_time(&tm, MYSQL_TIMESTAMP_TIME,
  371.                   MAX_TIME_WIDTH * MY_CHARSET_BIN_MB_MAXLEN);
  372.   *pos+= length;
  373. }
  375. static void set_param_datetime(Item_param *param, uchar **pos, ulong len)
  376. {
  377.   MYSQL_TIME tm;
  378.   ulong length= get_param_length(pos, len);
  380.   if (length >= 4)
  381.   {
  382.     uchar *to= *pos;
  384.     tm.neg=    0;
  385.     tm.year=   (uint) sint2korr(to);
  386.     tm.month=  (uint) to[2];
  387.     tm.day=    (uint) to[3];
  388.     if (length > 4)
  389.     {
  390.       tm.hour=   (uint) to[4];
  391.       tm.minute= (uint) to[5];
  392.       tm.second= (uint) to[6];
  393.     }
  394.     else
  395.       tm.hour= tm.minute= tm.second= 0;
  397.     tm.second_part= (length > 7) ? (ulong) sint4korr(to+7) : 0;
  398.   }
  399.   else
  400.     set_zero_time(&tm, MYSQL_TIMESTAMP_DATETIME);
  401.   param->set_time(&tm, MYSQL_TIMESTAMP_DATETIME,
  402.                   MAX_DATETIME_WIDTH * MY_CHARSET_BIN_MB_MAXLEN);
  403.   *pos+= length;
  404. }
  406. static void set_param_date(Item_param *param, uchar **pos, ulong len)
  407. {
  408.   MYSQL_TIME tm;
  409.   ulong length= get_param_length(pos, len);
  411.   if (length >= 4)
  412.   {
  413.     uchar *to= *pos;
  415.     tm.year=  (uint) sint2korr(to);
  416.     tm.month=  (uint) to[2];
  417.     tm.day= (uint) to[3];
  419.     tm.hour= tm.minute= tm.second= 0;
  420.     tm.second_part= 0;
  421.     tm.neg= 0;
  422.   }
  423.   else
  424.     set_zero_time(&tm, MYSQL_TIMESTAMP_DATE);
  425.   param->set_time(&tm, MYSQL_TIMESTAMP_DATE,
  426.                   MAX_DATE_WIDTH * MY_CHARSET_BIN_MB_MAXLEN);
  427.   *pos+= length;
  428. }
  430. #else/*!EMBEDDED_LIBRARY*/
  431. void set_param_time(Item_param *param, uchar **pos, ulong len)
  432. {
  433.   MYSQL_TIME tm= *((MYSQL_TIME*)*pos);
  434.   tm.hour+= tm.day * 24;
  435.   tm.day= tm.year= tm.month= 0;
  436.   if (tm.hour > 838)
  437.   {
  438.     /* TODO: add warning 'Data truncated' here */
  439.     tm.hour= 838;
  440.     tm.minute= 59;
  441.     tm.second= 59;
  442.   }
  443.   param->set_time(&tm, MYSQL_TIMESTAMP_TIME,
  444.                   MAX_TIME_WIDTH * MY_CHARSET_BIN_MB_MAXLEN);
  446. }
  448. void set_param_datetime(Item_param *param, uchar **pos, ulong len)
  449. {
  450.   MYSQL_TIME *to= (MYSQL_TIME*)*pos;
  452.   param->set_time(to, MYSQL_TIMESTAMP_DATETIME,
  453.                   MAX_DATETIME_WIDTH * MY_CHARSET_BIN_MB_MAXLEN);
  454. }
  456. void set_param_date(Item_param *param, uchar **pos, ulong len)
  457. {
  458.   MYSQL_TIME *to= (MYSQL_TIME*)*pos;
  460.   param->set_time(to, MYSQL_TIMESTAMP_DATE,
  461.                   MAX_DATE_WIDTH * MY_CHARSET_BIN_MB_MAXLEN);
  462. }
  463. #endif /*!EMBEDDED_LIBRARY*/
  466. static void set_param_str(Item_param *param, uchar **pos, ulong len)
  467. {
  468.   ulong length= get_param_length(pos, len);
  469.   param->set_str((const char *)*pos, length);
  470.   *pos+= length;
  471. }
  474. #undef get_param_length 
  476. static void setup_one_conversion_function(THD *thd, Item_param *param,
  477.                                           uchar param_type)
  478. {
  479.   switch (param_type) {
  480.   case MYSQL_TYPE_TINY:
  481.     param->set_param_func= set_param_tiny;
  482.     param->item_type= Item::INT_ITEM;
  483.     param->item_result_type= INT_RESULT;
  484.     break;
  485.   case MYSQL_TYPE_SHORT:
  486.     param->set_param_func= set_param_short;
  487.     param->item_type= Item::INT_ITEM;
  488.     param->item_result_type= INT_RESULT;
  489.     break;
  490.   case MYSQL_TYPE_LONG:
  491.     param->set_param_func= set_param_int32;
  492.     param->item_type= Item::INT_ITEM;
  493.     param->item_result_type= INT_RESULT;
  494.     break;
  495.   case MYSQL_TYPE_LONGLONG:
  496.     param->set_param_func= set_param_int64;
  497.     param->item_type= Item::INT_ITEM;
  498.     param->item_result_type= INT_RESULT;
  499.     break;
  500.   case MYSQL_TYPE_FLOAT:
  501.     param->set_param_func= set_param_float;
  502.     param->item_type= Item::REAL_ITEM;
  503.     param->item_result_type= REAL_RESULT;
  504.     break;
  505.   case MYSQL_TYPE_DOUBLE:
  506.     param->set_param_func= set_param_double;
  507.     param->item_type= Item::REAL_ITEM;
  508.     param->item_result_type= REAL_RESULT;
  509.     break;
  510.   case MYSQL_TYPE_TIME:
  511.     param->set_param_func= set_param_time;
  512.     param->item_type= Item::STRING_ITEM;
  513.     param->item_result_type= STRING_RESULT;
  514.     break;
  515.   case MYSQL_TYPE_DATE:
  516.     param->set_param_func= set_param_date;
  517.     param->item_type= Item::STRING_ITEM;
  518.     param->item_result_type= STRING_RESULT;
  519.     break;
  520.   case MYSQL_TYPE_DATETIME:
  521.   case MYSQL_TYPE_TIMESTAMP:
  522.     param->set_param_func= set_param_datetime;
  523.     param->item_type= Item::STRING_ITEM;
  524.     param->item_result_type= STRING_RESULT;
  525.     break;
  526.   case MYSQL_TYPE_TINY_BLOB:
  527.   case MYSQL_TYPE_MEDIUM_BLOB:
  528.   case MYSQL_TYPE_LONG_BLOB:
  529.   case MYSQL_TYPE_BLOB:
  530.     param->set_param_func= set_param_str;
  531.     param->value.cs_info.character_set_of_placeholder= &my_charset_bin;
  532.     param->value.cs_info.character_set_client=
  533.       thd->variables.character_set_client;
  534.     param->value.cs_info.final_character_set_of_str_value= &my_charset_bin;
  535.     param->item_type= Item::STRING_ITEM;
  536.     param->item_result_type= STRING_RESULT;
  537.     break;
  538.   default:
  539.     /*
  540.       The client library ensures that we won't get any other typecodes
  541.       except typecodes above and typecodes for string types. Marking
  542.       label as 'default' lets us to handle malformed packets as well.
  543.     */
  544.     {
  545.       CHARSET_INFO *fromcs= thd->variables.character_set_client;
  546.       CHARSET_INFO *tocs= thd->variables.collation_connection;
  547.       uint32 dummy_offset;
  549.       param->value.cs_info.character_set_of_placeholder= fromcs;
  550.       param->value.cs_info.character_set_client= fromcs;
  552.       /*
  553.         Setup source and destination character sets so that they
  554.         are different only if conversion is necessary: this will
  555.         make later checks easier.
  556.       */
  557.       param->value.cs_info.final_character_set_of_str_value=
  558.         String::needs_conversion(0, fromcs, tocs, &dummy_offset) ?
  559.         tocs : fromcs;
  560.       param->set_param_func= set_param_str;
  561.       /*
  562.         Exact value of max_length is not known unless data is converted to
  563.         charset of connection, so we have to set it later.
  564.       */
  565.       param->item_type= Item::STRING_ITEM;
  566.       param->item_result_type= STRING_RESULT;
  567.     }
  568.   }
  569.   param->param_type= (enum enum_field_types) param_type;
  570. }
  572. #ifndef EMBEDDED_LIBRARY
  573. /*
  574.   Update the parameter markers by reading data from client packet 
  575.   and if binary/update log is set, generate the valid query.
  576. */
  578. static bool insert_params_withlog(Prepared_statement *stmt, uchar *null_array,
  579.                                   uchar *read_pos, uchar *data_end, 
  580.                                   String *query)
  581. {
  582.   THD  *thd= stmt->thd;
  583.   Item_param **begin= stmt->param_array;
  584.   Item_param **end= begin + stmt->param_count;
  585.   uint32 length= 0;
  586.   String str; 
  587.   const String *res;
  588.   DBUG_ENTER("insert_params_withlog"); 
  590.   if (query->copy(stmt->query, stmt->query_length, default_charset_info))
  591.     DBUG_RETURN(1);
  592.   
  593.   for (Item_param **it= begin; it < end; ++it)
  594.   {
  595.     Item_param *param= *it;
  596.     if (param->state != Item_param::LONG_DATA_VALUE)
  597.     {
  598.       if (is_param_null(null_array, it - begin))
  599.         param->set_null();
  600.       else
  601.       {
  602.         if (read_pos >= data_end)
  603.           DBUG_RETURN(1);
  604.         param->set_param_func(param, &read_pos, data_end - read_pos);
  605.       }
  606.     }
  607.     res= param->query_val_str(&str);
  608.     if (param->convert_str_value(thd))
  609.       DBUG_RETURN(1);                           /* out of memory */
  611.     if (query->replace(param->pos_in_query+length, 1, *res))
  612.       DBUG_RETURN(1);
  613.     
  614.     length+= res->length()-1;
  615.   }
  616.   DBUG_RETURN(0);
  617. }
  620. static bool insert_params(Prepared_statement *stmt, uchar *null_array,
  621.                           uchar *read_pos, uchar *data_end, 
  622.                           String *expanded_query)
  623. {
  624.   Item_param **begin= stmt->param_array;
  625.   Item_param **end= begin + stmt->param_count;
  627.   DBUG_ENTER("insert_params"); 
  629.   for (Item_param **it= begin; it < end; ++it)
  630.   {
  631.     Item_param *param= *it;
  632.     if (param->state != Item_param::LONG_DATA_VALUE)
  633.     {
  634.       if (is_param_null(null_array, it - begin))
  635.         param->set_null();
  636.       else
  637.       {
  638.         if (read_pos >= data_end)
  639.           DBUG_RETURN(1);
  640.         param->set_param_func(param, &read_pos, data_end - read_pos);
  641.       }
  642.     }
  643.     if (param->convert_str_value(stmt->thd))
  644.       DBUG_RETURN(1);                           /* out of memory */
  645.   }
  646.   DBUG_RETURN(0);
  647. }
  650. static bool setup_conversion_functions(Prepared_statement *stmt,
  651.                                        uchar **data, uchar *data_end)
  652. {
  653.   /* skip null bits */
  654.   uchar *read_pos= *data + (stmt->param_count+7) / 8;
  656.   DBUG_ENTER("setup_conversion_functions");
  658.   if (*read_pos++) //types supplied / first execute
  659.   {
  660.     /*
  661.       First execute or types altered by the client, setup the 
  662.       conversion routines for all parameters (one time)
  663.     */
  664.     Item_param **it= stmt->param_array;
  665.     Item_param **end= it + stmt->param_count;
  666.     THD *thd= stmt->thd;
  667.     for (; it < end; ++it)
  668.     {
  669.       ushort typecode;
  670.       const uint signed_bit= 1 << 15;
  672.       if (read_pos >= data_end)
  673.         DBUG_RETURN(1);
  675.       typecode= sint2korr(read_pos);
  676.       read_pos+= 2;
  677.       (**it).unsigned_flag= test(typecode & signed_bit);
  678.       setup_one_conversion_function(thd, *it, (uchar) (typecode & ~signed_bit));
  679.     }
  680.   }
  681.   *data= read_pos;
  682.   DBUG_RETURN(0);
  683. }
  685. #else
  687. static bool emb_insert_params(Prepared_statement *stmt, String *expanded_query)
  688. {
  689.   THD *thd= stmt->thd;
  690.   Item_param **it= stmt->param_array;
  691.   Item_param **end= it + stmt->param_count;
  692.   MYSQL_BIND *client_param= stmt->thd->client_params;
  694.   DBUG_ENTER("emb_insert_params");
  696.   for (; it < end; ++it, ++client_param)
  697.   {
  698.     Item_param *param= *it;
  699.     setup_one_conversion_function(thd, param, client_param->buffer_type);
  700.     if (param->state != Item_param::LONG_DATA_VALUE)
  701.     {
  702.       if (*client_param->is_null)
  703.         param->set_null();
  704.       else
  705.       {
  706.         uchar *buff= (uchar*) client_param->buffer;
  707.         param->unsigned_flag= client_param->is_unsigned;
  708.         param->set_param_func(param, &buff,
  709.                               client_param->length ? 
  710.                               *client_param->length : 
  711.                               client_param->buffer_length);
  712.       }
  713.     }
  714.     if (param->convert_str_value(thd))
  715.       DBUG_RETURN(1);                           /* out of memory */
  716.   }
  717.   DBUG_RETURN(0);
  718. }
  721. static bool emb_insert_params_withlog(Prepared_statement *stmt, String *query)
  722. {
  723.   THD *thd= stmt->thd;
  724.   Item_param **it= stmt->param_array;
  725.   Item_param **end= it + stmt->param_count;
  726.   MYSQL_BIND *client_param= thd->client_params;
  728.   String str;
  729.   const String *res;
  730.   uint32 length= 0;
  732.   DBUG_ENTER("emb_insert_params_withlog");
  734.   if (query->copy(stmt->query, stmt->query_length, default_charset_info))
  735.     DBUG_RETURN(1);
  736.   
  737.   for (; it < end; ++it, ++client_param)
  738.   {
  739.     Item_param *param= *it;
  740.     setup_one_conversion_function(thd, param, client_param->buffer_type);
  741.     if (param->state != Item_param::LONG_DATA_VALUE)
  742.     {
  743.       if (*client_param->is_null)
  744.         param->set_null();
  745.       else
  746.       {
  747.         uchar *buff= (uchar*)client_param->buffer;
  748. param->unsigned_flag= client_param->is_unsigned;
  749.         param->set_param_func(param, &buff,
  750.                               client_param->length ? 
  751.                               *client_param->length : 
  752.                               client_param->buffer_length);
  753.       }
  754.     }
  755.     res= param->query_val_str(&str);
  756.     if (param->convert_str_value(thd))
  757.       DBUG_RETURN(1);                           /* out of memory */
  759.     if (query->replace(param->pos_in_query+length, 1, *res))
  760.       DBUG_RETURN(1);
  762.     length+= res->length()-1;
  763.   }
  764.   DBUG_RETURN(0);
  765. }
  767. #endif /*!EMBEDDED_LIBRARY*/
  770. /*
  771.   Set prepared statement parameters from user variables.
  772.   SYNOPSIS
  773.     insert_params_from_vars()
  774.       stmt      Statement
  775.       varnames  List of variables. Caller must ensure that number of variables
  776.                 in the list is equal to number of statement parameters
  777.       query     Ignored
  778. */
  780. static bool insert_params_from_vars(Prepared_statement *stmt,
  781.                                     List<LEX_STRING>& varnames,
  782.                                     String *query __attribute__((unused)))
  783. {
  784.   Item_param **begin= stmt->param_array;
  785.   Item_param **end= begin + stmt->param_count;
  786.   user_var_entry *entry;
  787.   LEX_STRING *varname;
  788.   List_iterator<LEX_STRING> var_it(varnames);
  789.   DBUG_ENTER("insert_params_from_vars");
  791.   for (Item_param **it= begin; it < end; ++it)
  792.   {
  793.     Item_param *param= *it;
  794.     varname= var_it++;
  795.     entry= (user_var_entry*)hash_search(&stmt->thd->user_vars,
  796.                                         (byte*) varname->str,
  797.                                          varname->length);
  798.     if (param->set_from_user_var(stmt->thd, entry) ||
  799.         param->convert_str_value(stmt->thd))
  800.       DBUG_RETURN(1);
  801.   }
  802.   DBUG_RETURN(0);
  803. }
  806. /*
  807.   Do the same as insert_params_from_vars but also construct query text for
  808.   binary log.
  809.   SYNOPSIS
  810.     insert_params_from_vars()
  811.       stmt      Statement
  812.       varnames  List of variables. Caller must ensure that number of variables
  813.                 in the list is equal to number of statement parameters
  814.       query     The query with parameter markers replaced with their values
  815. */
  817. static bool insert_params_from_vars_with_log(Prepared_statement *stmt,
  818.                                              List<LEX_STRING>& varnames,
  819.                                              String *query)
  820. {
  821.   Item_param **begin= stmt->param_array;
  822.   Item_param **end= begin + stmt->param_count;
  823.   user_var_entry *entry;
  824.   LEX_STRING *varname;
  825.   DBUG_ENTER("insert_params_from_vars");
  827.   List_iterator<LEX_STRING> var_it(varnames);
  828.   String buf;
  829.   const String *val;
  830.   uint32 length= 0;
  831.   if (query->copy(stmt->query, stmt->query_length, default_charset_info))
  832.     DBUG_RETURN(1);
  834.   for (Item_param **it= begin; it < end; ++it)
  835.   {
  836.     Item_param *param= *it;
  837.     varname= var_it++;
  838.     if (get_var_with_binlog(stmt->thd, *varname, &entry))
  839.         DBUG_RETURN(1);
  841.     if (param->set_from_user_var(stmt->thd, entry))
  842.       DBUG_RETURN(1);
  843.     /* Insert @'escaped-varname' instead of parameter in the query */
  844.     if (entry)
  845.     {
  846.       char *begin, *ptr;
  847.       buf.length(0);
  848.       if (buf.reserve(entry->name.length*2+3))
  849.         DBUG_RETURN(1);
  851.       begin= ptr= buf.c_ptr_quick();
  852.       *ptr++= '@';
  853.       *ptr++= ''';
  854.       ptr+= escape_string_for_mysql(&my_charset_utf8_general_ci,
  855.                                     ptr, entry->name.str, entry->name.length);
  856.       *ptr++= ''';
  857.       buf.length(ptr - begin);
  858.       val= &buf;
  859.     }
  860.     else
  861.       val= &my_null_string;
  863.     if (param->convert_str_value(stmt->thd))
  864.       DBUG_RETURN(1);                           /* out of memory */
  866.     if (query->replace(param->pos_in_query+length, 1, *val))
  867.       DBUG_RETURN(1);
  868.     length+= val->length()-1;
  869.   }
  870.   DBUG_RETURN(0);
  871. }
  873. /*
  874.   Validate INSERT statement: 
  876.   SYNOPSIS
  877.     mysql_test_insert()
  878.     stmt prepared statemen handler
  879.     tables list of tables queries  
  881.   RETURN VALUE
  882.     0   ok
  883.     1   error, sent to the client
  884.    -1   error, not sent to client
  885. */
  886. static int mysql_test_insert(Prepared_statement *stmt,
  887.      TABLE_LIST *table_list,
  888.      List<Item> &fields, 
  889.      List<List_item> &values_list,
  890.      List<Item> &update_fields,
  891.      List<Item> &update_values,
  892.      enum_duplicates duplic)
  893. {
  894.   THD *thd= stmt->thd;
  895.   LEX *lex= stmt->lex;
  896.   List_iterator_fast<List_item> its(values_list);
  897.   List_item *values;
  898.   int res= -1;
  899.   TABLE_LIST *insert_table_list=
  900.     (TABLE_LIST*) lex->select_lex.table_list.first;
  901.   DBUG_ENTER("mysql_test_insert");
  903.   if ((res= insert_precheck(thd, table_list)))
  904.     DBUG_RETURN(res);
  906.   /*
  907.      open temporary memory pool for temporary data allocated by derived
  908.      tables & preparation procedure
  909.      Note that this is done without locks (should not be needed as we will not
  910.      access any data here)
  911.      If we would use locks, then we have to ensure we are not using
  912.      TL_WRITE_DELAYED as having two such locks can cause table corruption.
  913.   */
  914.   if (open_normal_and_derived_tables(thd, table_list))
  915.   {
  916.     DBUG_RETURN(-1);
  917.   }
  919.   if ((values= its++))
  920.   {
  921.     uint value_count;
  922.     ulong counter= 0;
  924.     table_list->table->insert_values=(byte *)1; // don't allocate insert_values
  925.     if ((res= mysql_prepare_insert(thd, table_list, insert_table_list,
  926.                                    insert_table_list,
  927.    table_list->table, fields, values,
  928.    update_fields, update_values, duplic)))
  929.       goto error;
  931.     value_count= values->elements;
  932.     its.rewind();
  934.     while ((values= its++))
  935.     {
  936.       counter++;
  937.       if (values->elements != value_count)
  938.       {
  939.         my_printf_error(ER_WRONG_VALUE_COUNT_ON_ROW,
  940. ER(ER_WRONG_VALUE_COUNT_ON_ROW),
  941. MYF(0), counter);
  942.         goto error;
  943.       }
  944.       if (setup_fields(thd, 0, insert_table_list, *values, 0, 0, 0))
  945. goto error;
  946.     }
  947.   }
  949.   res= 0;
  950. error:
  951.   lex->unit.cleanup();
  952.   table_list->table->insert_values=0;
  953.   DBUG_RETURN(res);
  954. }
  957. /*
  958.   Validate UPDATE statement
  960.   SYNOPSIS
  961.     mysql_test_update()
  962.     stmt prepared statemen handler
  963.     tables list of tables queries
  965.   RETURN VALUE
  966.     0   success
  967.     1   error, sent to client
  968.    -1   error, not sent to client
  969. */
  970. static int mysql_test_update(Prepared_statement *stmt,
  971.      TABLE_LIST *table_list)
  972. {
  973.   int res;
  974.   THD *thd= stmt->thd;
  975.   SELECT_LEX *select= &stmt->lex->select_lex;
  976.   DBUG_ENTER("mysql_test_update");
  978.   if ((res= update_precheck(thd, table_list)))
  979.     DBUG_RETURN(res);
  981.   if (open_and_lock_tables(thd, table_list))
  982.     res= -1;
  983.   else
  984.   {
  985.     TABLE_LIST *update_table_list= (TABLE_LIST *)select->table_list.first;
  986.     if (!(res= mysql_prepare_update(thd, table_list,
  987.     update_table_list,
  988.     &select->where,
  989.     select->order_list.elements,
  990.     (ORDER *) select->order_list.first)))
  991.     {
  992.       if (setup_fields(thd, 0, update_table_list,
  993.        select->item_list, 1, 0, 0) ||
  994.   setup_fields(thd, 0, update_table_list,
  995.        stmt->lex->value_list, 0, 0, 0))
  996. res= -1;
  997.     }
  998.     stmt->lex->unit.cleanup();
  999.   }
  1000.   /* TODO: here we should send types of placeholders to the client. */ 
  1001.   DBUG_RETURN(res);
  1002. }
  1005. /*
  1006.   Validate DELETE statement
  1008.   SYNOPSIS
  1009.     mysql_test_delete()
  1010.     stmt prepared statemen handler
  1011.     tables list of tables queries
  1013.   RETURN VALUE
  1014.     0   success
  1015.     1   error, sent to client
  1016.    -1   error, not sent to client
  1017. */
  1018. static int mysql_test_delete(Prepared_statement *stmt,
  1019.      TABLE_LIST *table_list)
  1020. {
  1021.   int res;
  1022.   THD *thd= stmt->thd;
  1023.   LEX *lex= stmt->lex;
  1024.   DBUG_ENTER("mysql_test_delete");
  1026.   if ((res= delete_precheck(thd, table_list)))
  1027.     DBUG_RETURN(res);
  1029.   if (open_and_lock_tables(thd, table_list))
  1030.     res= -1;
  1031.   else
  1032.   {
  1033.     res= mysql_prepare_delete(thd, table_list, &lex->select_lex.where);
  1034.     lex->unit.cleanup();
  1035.   }
  1036.   /* TODO: here we should send types of placeholders to the client. */ 
  1037.   DBUG_RETURN(res);
  1038. }
  1041. /*
  1042.   Validate SELECT statement.
  1043.   In case of success, if this query is not EXPLAIN, send column list info
  1044.   back to client. 
  1046.   SYNOPSIS
  1047.     mysql_test_select()
  1048.     stmt prepared statemen handler
  1049.     tables list of tables queries
  1051.   RETURN VALUE
  1052.     0   success
  1053.     1   error, sent to client
  1054.    -1   error, not sent to client
  1055. */
  1057. static int mysql_test_select(Prepared_statement *stmt,
  1058.      TABLE_LIST *tables, bool text_protocol)
  1059. {
  1060.   THD *thd= stmt->thd;
  1061.   LEX *lex= stmt->lex;
  1062.   SELECT_LEX_UNIT *unit= &lex->unit;
  1063.   int result= 1;
  1064.   DBUG_ENTER("mysql_test_select");
  1066. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  1067.   ulong privilege= lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL;
  1068.   if (tables)
  1069.   {
  1070.     if (check_table_access(thd, privilege, tables,0))
  1071.       DBUG_RETURN(1);
  1072.   }
  1073.   else if (check_access(thd, privilege, any_db,0,0,0))
  1074.     DBUG_RETURN(1);
  1075. #endif
  1077.   if (!lex->result && !(lex->result= new (stmt->mem_root) select_send))
  1078.   {
  1079.     send_error(thd);
  1080.     goto err;
  1081.   }
  1083.   if (open_and_lock_tables(thd, tables))
  1084.   {
  1085.     send_error(thd);
  1086.     goto err;
  1087.   }
  1089.   thd->used_tables= 0;                        // Updated by setup_fields
  1091.   // JOIN::prepare calls
  1092.   if (unit->prepare(thd, 0, 0, ""))
  1093.   {
  1094.     send_error(thd);
  1095.     goto err_prep;
  1096.   }
  1097.   if (!text_protocol)
  1098.   {
  1099.     if (lex->describe)
  1100.     {
  1101.       if (send_prep_stmt(stmt, 0) || thd->protocol->flush())
  1102.         goto err_prep;
  1103.     }
  1104.     else
  1105.     {
  1106.       /* Make copy of item list, as change_columns may change it */
  1107.       List<Item> fields(lex->select_lex.item_list);
  1109.       /* Change columns if a procedure like analyse() */
  1110.       if (unit->last_procedure &&
  1111.           unit->last_procedure->change_columns(fields))
  1112.         goto err_prep;
  1114.       /*
  1115.         We can use lex->result as it should've been
  1116.         prepared in unit->prepare call above.
  1117.       */
  1118.       if (send_prep_stmt(stmt, lex->result->field_count(fields)) ||
  1119.           lex->result->send_fields(fields, 0) ||
  1120.           thd->protocol->flush())
  1121.         goto err_prep;
  1122.     }
  1123.   }
  1124.   result= 0;                                    // ok
  1126. err_prep:
  1127.   unit->cleanup();
  1128. err:
  1129.   DBUG_RETURN(result);
  1130. }
  1133. /*
  1134.   Validate and prepare for execution DO statement expressions
  1136.   SYNOPSIS
  1137.     mysql_test_do_fields()
  1138.     stmt prepared statemen handler
  1139.     tables list of tables queries
  1140.     values list of expressions
  1142.   RETURN VALUE
  1143.     0   success
  1144.     1   error, sent to client
  1145.    -1   error, not sent to client
  1146. */
  1148. static int mysql_test_do_fields(Prepared_statement *stmt,
  1149. TABLE_LIST *tables,
  1150. List<Item> *values)
  1151. {
  1152.   DBUG_ENTER("mysql_test_do_fields");
  1153.   THD *thd= stmt->thd;
  1154.   int res= 0;
  1155.   if (tables && (res= check_table_access(thd, SELECT_ACL, tables, 0)))
  1156.     DBUG_RETURN(res);
  1158.   if (tables && (res= open_and_lock_tables(thd, tables)))
  1159.   {
  1160.     DBUG_RETURN(res);
  1161.   }
  1162.   res= setup_fields(thd, 0, 0, *values, 0, 0, 0);
  1163.   stmt->lex->unit.cleanup();
  1164.   if (res)
  1165.     DBUG_RETURN(-1);
  1166.   DBUG_RETURN(0);
  1167. }
  1170. /*
  1171.   Validate and prepare for execution SET statement expressions
  1173.   SYNOPSIS
  1174.     mysql_test_set_fields()
  1175.     stmt prepared statemen handler
  1176.     tables list of tables queries
  1177.     values list of expressions
  1179.   RETURN VALUE
  1180.     0   success
  1181.     1   error, sent to client
  1182.    -1   error, not sent to client
  1183. */
  1184. static int mysql_test_set_fields(Prepared_statement *stmt,
  1185. TABLE_LIST *tables,
  1186. List<set_var_base> *var_list)
  1187. {
  1188.   DBUG_ENTER("mysql_test_set_fields");
  1189.   List_iterator_fast<set_var_base> it(*var_list);
  1190.   THD *thd= stmt->thd;
  1191.   set_var_base *var;
  1192.   int res= 0;
  1194.   if (tables && (res= check_table_access(thd, SELECT_ACL, tables, 0)))
  1195.     DBUG_RETURN(res);
  1197.   if (tables && (res= open_and_lock_tables(thd, tables)))
  1198.     goto error;
  1199.   while ((var= it++))
  1200.   {
  1201.     if (var->light_check(thd))
  1202.     {
  1203.       stmt->lex->unit.cleanup();
  1204.       res= -1;
  1205.       goto error;
  1206.     }
  1207.   }
  1208. error:
  1209.   stmt->lex->unit.cleanup();
  1210.   DBUG_RETURN(res);
  1211. }
  1214. /*
  1215.   Check internal SELECT of the prepared command
  1217.   SYNOPSIS
  1218.     select_like_statement_test()
  1219.       stmt - prepared table handler
  1220.       tables - global list of tables
  1222.   RETURN VALUE
  1223.     0   success
  1224.     1   error, sent to client
  1225.    -1   error, not sent to client
  1226. */
  1227. static int select_like_statement_test(Prepared_statement *stmt,
  1228.       TABLE_LIST *tables)
  1229. {
  1230.   DBUG_ENTER("select_like_statement_test");
  1231.   THD *thd= stmt->thd;
  1232.   LEX *lex= stmt->lex;
  1233.   int res= 0;
  1235.   if (tables && (res= open_and_lock_tables(thd, tables)))
  1236.     goto end;
  1238.   thd->used_tables= 0;                        // Updated by setup_fields
  1240.   // JOIN::prepare calls
  1241.   if (lex->unit.prepare(thd, 0, 0, ""))
  1242.   {
  1243.     res= thd->net.report_error ? -1 : 1;
  1244.   }
  1245. end:
  1246.   lex->unit.cleanup();
  1247.   DBUG_RETURN(res);
  1248. }
  1251. /*
  1252.   Validate and prepare for execution CREATE TABLE statement
  1254.   SYNOPSIS
  1255.     mysql_test_create_table()
  1256.     stmt prepared statemen handler
  1257.     tables list of tables queries
  1259.   RETURN VALUE
  1260.     0   success
  1261.     1   error, sent to client
  1262.    -1   error, not sent to client
  1263. */
  1264. static int mysql_test_create_table(Prepared_statement *stmt,
  1265.    TABLE_LIST *tables)
  1266. {
  1267.   DBUG_ENTER("mysql_test_create_table");
  1268.   THD *thd= stmt->thd;
  1269.   LEX *lex= stmt->lex;
  1270.   SELECT_LEX *select_lex= &lex->select_lex;
  1271.   int res= 0;
  1273.   /* Skip first table, which is the table we are creating */
  1274.   TABLE_LIST *create_table, *create_table_local;
  1275.   tables= lex->unlink_first_table(tables, &create_table,
  1276.   &create_table_local);
  1278.   if (!(res= create_table_precheck(thd, tables, create_table)) &&
  1279.       select_lex->item_list.elements)
  1280.   {
  1281.     select_lex->resolve_mode= SELECT_LEX::SELECT_MODE;
  1282.     res= select_like_statement_test(stmt, tables);
  1283.     select_lex->resolve_mode= SELECT_LEX::NOMATTER_MODE;
  1284.   }
  1286.   /* put tables back for PS rexecuting */
  1287.   tables= lex->link_first_table_back(tables, create_table,
  1288.      create_table_local);
  1289.   DBUG_RETURN(res);
  1290. }
  1293. /*
  1294.   Validate and prepare for execution multi update statement
  1296.   SYNOPSIS
  1297.     mysql_test_multiupdate()
  1298.     stmt prepared statemen handler
  1299.     tables list of tables queries
  1301.   RETURN VALUE
  1302.     0   success
  1303.     1   error, sent to client
  1304.    -1   error, not sent to client
  1305. */
  1306. static int mysql_test_multiupdate(Prepared_statement *stmt,
  1307.   TABLE_LIST *tables)
  1308. {
  1309.   int res;
  1310.   if ((res= multi_update_precheck(stmt->thd, tables)))
  1311.     return res;
  1312.   return select_like_statement_test(stmt, tables);
  1313. }
  1316. /*
  1317.   Validate and prepare for execution multi delete statement
  1319.   SYNOPSIS
  1320.     mysql_test_multidelete()
  1321.     stmt prepared statemen handler
  1322.     tables list of tables queries
  1324.   RETURN VALUE
  1325.     0   success
  1326.     1   error, sent to client
  1327.    -1   error, not sent to client
  1328. */
  1329. static int mysql_test_multidelete(Prepared_statement *stmt,
  1330.   TABLE_LIST *tables)
  1331. {
  1332.   int res;
  1333.   stmt->thd->lex->current_select= &stmt->thd->lex->select_lex;
  1334.   if (add_item_to_list(stmt->thd, new Item_null()))
  1335.     return -1;
  1337.   uint fake_counter;
  1338.   if ((res= multi_delete_precheck(stmt->thd, tables, &fake_counter)))
  1339.     return res;
  1340.   return select_like_statement_test(stmt, tables);
  1341. }
  1344. /*
  1345.   Validate and prepare for execution INSERT ... SELECT statement
  1347.   SYNOPSIS
  1348.     mysql_test_insert_select()
  1349.     stmt prepared statemen handler
  1350.     tables list of tables queries
  1352.   RETURN VALUE
  1353.     0   success
  1354.     1   error, sent to client
  1355.    -1   error, not sent to client
  1356. */
  1357. static int mysql_test_insert_select(Prepared_statement *stmt,
  1358.     TABLE_LIST *tables)
  1359. {
  1360.   int res;
  1361.   LEX *lex= stmt->lex;
  1362.   if ((res= insert_precheck(stmt->thd, tables)))
  1363.     return res;
  1364.   TABLE_LIST *first_local_table=
  1365.     (TABLE_LIST *)lex->select_lex.table_list.first;
  1366.   /* Skip first table, which is the table we are inserting in */
  1367.   lex->select_lex.table_list.first= (byte*) first_local_table->next;
  1368.   /*
  1369.     insert/replace from SELECT give its SELECT_LEX for SELECT,
  1370.     and item_list belong to SELECT
  1371.   */
  1372.   lex->select_lex.resolve_mode= SELECT_LEX::SELECT_MODE;
  1373.   res= select_like_statement_test(stmt, tables);
  1374.   /* revert changes*/
  1375.   lex->select_lex.table_list.first= (byte*) first_local_table;
  1376.   lex->select_lex.resolve_mode= SELECT_LEX::INSERT_MODE;
  1377.   return res;
  1378. }
  1381. /*
  1382.   Send the prepare query results back to client
  1383.   SYNOPSIS
  1384.   send_prepare_results()
  1385.     stmt prepared statement
  1386.   RETURN VALUE
  1387.     0   success
  1388.     1   error, sent to client
  1389. */
  1390. static int send_prepare_results(Prepared_statement *stmt, bool text_protocol)
  1391. {   
  1392.   THD *thd= stmt->thd;
  1393.   LEX *lex= stmt->lex;
  1394.   SELECT_LEX *select_lex= &lex->select_lex;
  1395.   TABLE_LIST *tables=(TABLE_LIST*) select_lex->table_list.first;
  1396.   enum enum_sql_command sql_command= lex->sql_command;
  1397.   int res= 0;
  1398.   DBUG_ENTER("send_prepare_results");
  1399.   DBUG_PRINT("enter",("command: %d, param_count: %ld",
  1400.                       sql_command, stmt->param_count));
  1402.   if ((&lex->select_lex != lex->all_selects_list ||
  1403.        lex->time_zone_tables_used) &&
  1404.       lex->unit.create_total_list(thd, lex, &tables))
  1405.     DBUG_RETURN(1);
  1407.   switch (sql_command) {
  1408.   case SQLCOM_REPLACE:
  1409.   case SQLCOM_INSERT:
  1410.     res= mysql_test_insert(stmt, tables, lex->field_list,
  1411.    lex->many_values,
  1412.    select_lex->item_list, lex->value_list,
  1413.    lex->duplicates);
  1414.     break;
  1416.   case SQLCOM_UPDATE:
  1417.     res= mysql_test_update(stmt, tables);
  1418.     break;
  1420.   case SQLCOM_DELETE:
  1421.     res= mysql_test_delete(stmt, tables);
  1422.     break;
  1424.   case SQLCOM_SELECT:
  1425.     if ((res= mysql_test_select(stmt, tables, text_protocol)))
  1426.       goto error;
  1427.     /* Statement and field info has already been sent */
  1428.     DBUG_RETURN(0);
  1430.   case SQLCOM_CREATE_TABLE:
  1431.     res= mysql_test_create_table(stmt, tables);
  1432.     break;
  1433.   
  1434.   case SQLCOM_DO:
  1435.     res= mysql_test_do_fields(stmt, tables, lex->insert_list);
  1436.     break;
  1438.   case SQLCOM_SET_OPTION:
  1439.     res= mysql_test_set_fields(stmt, tables, &lex->var_list);
  1440.     break;
  1442.   case SQLCOM_DELETE_MULTI:
  1443.     res= mysql_test_multidelete(stmt, tables);
  1444.     break;
  1445.   
  1446.   case SQLCOM_UPDATE_MULTI:
  1447.     res= mysql_test_multiupdate(stmt, tables);
  1448.     break;
  1450.   case SQLCOM_INSERT_SELECT:
  1451.   case SQLCOM_REPLACE_SELECT:
  1452.     res= mysql_test_insert_select(stmt, tables);
  1453.     break;
  1455.   case SQLCOM_SHOW_DATABASES:
  1456.   case SQLCOM_SHOW_PROCESSLIST:
  1457.   case SQLCOM_SHOW_STORAGE_ENGINES:
  1458.   case SQLCOM_SHOW_PRIVILEGES:
  1459.   case SQLCOM_SHOW_COLUMN_TYPES:
  1460.   case SQLCOM_SHOW_STATUS:
  1461.   case SQLCOM_SHOW_VARIABLES:
  1462.   case SQLCOM_SHOW_LOGS:
  1463.   case SQLCOM_SHOW_TABLES:
  1464.   case SQLCOM_SHOW_OPEN_TABLES:
  1465.   case SQLCOM_SHOW_CHARSETS:
  1466.   case SQLCOM_SHOW_COLLATIONS:
  1467.   case SQLCOM_SHOW_FIELDS:
  1468.   case SQLCOM_SHOW_KEYS:
  1469.   case SQLCOM_SHOW_CREATE_DB:
  1470.   case SQLCOM_SHOW_GRANTS:
  1471.   case SQLCOM_DROP_TABLE:
  1472.   case SQLCOM_RENAME_TABLE:
  1473.     break;
  1475.   default:
  1476.     /*
  1477.       All other is not supported yet
  1478.     */
  1479.     res= -1;
  1480.     my_error(ER_UNSUPPORTED_PS, MYF(0));
  1481.     goto error;
  1482.   }
  1483.   if (res == 0)
  1484.     DBUG_RETURN(text_protocol? 0 : (send_prep_stmt(stmt, 0) ||
  1485.                                     thd->protocol->flush()));
  1486. error:
  1487.   if (res < 0)
  1488.     send_error(thd, thd->killed ? ER_SERVER_SHUTDOWN : 0);
  1489.   DBUG_RETURN(1);
  1490. }
  1492. /*
  1493.   Initialize array of parameters in statement from LEX.
  1494.   (We need to have quick access to items by number in mysql_stmt_get_longdata).
  1495.   This is to avoid using malloc/realloc in the parser.
  1496. */
  1498. static bool init_param_array(Prepared_statement *stmt)
  1499. {
  1500.   LEX *lex= stmt->lex;
  1501.   THD *thd= stmt->thd;
  1502.   if ((stmt->param_count= lex->param_list.elements))
  1503.   {
  1504.     if (stmt->param_count > (uint) UINT_MAX16)
  1505.     {
  1506.       /* Error code to be defined in 5.0 */
  1507.       send_error(thd, ER_UNKNOWN_ERROR,
  1508.                  "Prepared statement contains too many placeholders.");
  1509.       return 1;
  1510.     }
  1511.     Item_param **to;
  1512.     List_iterator<Item_param> param_iterator(lex->param_list);
  1513.     /* Use thd->mem_root as it points at statement mem_root */
  1514.     stmt->param_array= (Item_param **)
  1515.                        alloc_root(stmt->thd->mem_root,
  1516.                                   sizeof(Item_param*) * stmt->param_count);
  1517.     if (!stmt->param_array)
  1518.     {
  1519.       send_error(thd, ER_OUT_OF_RESOURCES);
  1520.       return 1;
  1521.     }
  1522.     for (to= stmt->param_array;
  1523.          to < stmt->param_array + stmt->param_count;
  1524.          ++to)
  1525.     {
  1526.       *to= param_iterator++;
  1527.     }
  1528.   }
  1529.   return 0;
  1530. }
  1532. /*
  1533.   Given a query string with parameter markers, create a Prepared Statement
  1534.   from it and send PS info back to the client.
  1535.   
  1536.   SYNOPSIS
  1537.     mysql_stmt_prepare()
  1538.       packet         query to be prepared 
  1539.       packet_length  query string length, including ignored trailing NULL or 
  1540.                      quote char.
  1541.       name           NULL or statement name. For unnamed statements binary PS
  1542.                      protocol is used, for named statements text protocol is 
  1543.                      used.
  1544.   RETURN 
  1545.     0      OK, statement prepared successfully
  1546.     other  Error
  1547.   
  1548.   NOTES
  1549.     This function parses the query and sends the total number of parameters 
  1550.     and resultset metadata information back to client (if any), without 
  1551.     executing the query i.e. without any log/disk writes. This allows the 
  1552.     queries to be re-executed without re-parsing during execute. 
  1554.     If parameter markers are found in the query, then store the information
  1555.     using Item_param along with maintaining a list in lex->param_array, so 
  1556.     that a fast and direct retrieval can be made without going through all 
  1557.     field items.
  1558.    
  1559. */
  1561. int mysql_stmt_prepare(THD *thd, char *packet, uint packet_length,
  1562.                        LEX_STRING *name)
  1563. {
  1564.   LEX *lex;
  1565.   Prepared_statement *stmt= new Prepared_statement(thd);
  1566.   int error;
  1567.   DBUG_ENTER("mysql_stmt_prepare");
  1569.   DBUG_PRINT("prep_query", ("%s", packet));
  1571.   /*
  1572.     If this is an SQLCOM_PREPARE, we also increase Com_prepare_sql.
  1573.     However, it seems handy if com_stmt_prepare is increased always,
  1574.     no matter what kind of prepare is processed.
  1575.   */
  1576.   statistic_increment(com_stmt_prepare, &LOCK_status);
  1578.   if (stmt == 0)
  1579.   {
  1580.     send_error(thd, ER_OUT_OF_RESOURCES);
  1581.     DBUG_RETURN(1);
  1582.   }
  1584.   if (name)
  1585.   {
  1586.     stmt->name.length= name->length;
  1587.     if (!(stmt->name.str= memdup_root(stmt->mem_root, (char*)name->str,
  1588.                                       name->length)))
  1589.     {
  1590.       delete stmt;
  1591.       send_error(thd, ER_OUT_OF_RESOURCES);
  1592.       DBUG_RETURN(1);
  1593.     }
  1594.   }
  1596.   if (thd->stmt_map.insert(stmt))
  1597.   {
  1598.     delete stmt;
  1599.     send_error(thd, ER_OUT_OF_RESOURCES);
  1600.     DBUG_RETURN(1);
  1601.   }
  1603.   thd->set_n_backup_statement(stmt, &thd->stmt_backup);
  1604.   thd->set_n_backup_item_arena(stmt, &thd->stmt_backup);
  1606.   if (alloc_query(thd, packet, packet_length))
  1607.   {
  1608.     thd->restore_backup_statement(stmt, &thd->stmt_backup);
  1609.     thd->restore_backup_item_arena(stmt, &thd->stmt_backup);
  1610.     /* Statement map deletes statement on erase */
  1611.     thd->stmt_map.erase(stmt);
  1612.     send_error(thd, ER_OUT_OF_RESOURCES);
  1613.     DBUG_RETURN(1);
  1614.   }
  1616.   mysql_log.write(thd, thd->command, "[%lu] %s", stmt->id, packet);
  1618.   thd->current_arena= stmt;
  1619.   mysql_init_query(thd, (uchar *) thd->query, thd->query_length);
  1620.   /* Reset warnings from previous command */
  1621.   mysql_reset_errors(thd);
  1622.   lex= thd->lex;
  1623.   lex->safe_to_cache_query= 0;
  1625.   error= yyparse((void *)thd) || thd->is_fatal_error ||
  1626.          thd->net.report_error || init_param_array(stmt);
  1627.   /*
  1628.     While doing context analysis of the query (in send_prepare_results) we
  1629.     allocate a lot of additional memory: for open tables, JOINs, derived
  1630.     tables, etc.  Let's save a snapshot of current parse tree to the
  1631.     statement and restore original THD. In cases when some tree
  1632.     transformation can be reused on execute, we set again thd->mem_root from
  1633.     stmt->mem_root (see setup_wild for one place where we do that).
  1634.   */
  1635.   thd->restore_backup_item_arena(stmt, &thd->stmt_backup);
  1637.   if (!error)
  1638.     error= send_prepare_results(stmt, test(name));
  1640.   /* restore to WAIT_PRIOR: QUERY_PRIOR is set inside alloc_query */
  1641.   if (!(specialflag & SPECIAL_NO_PRIOR))
  1642.     my_pthread_setprio(pthread_self(),WAIT_PRIOR);
  1643.   lex_end(lex);
  1644.   thd->restore_backup_statement(stmt, &thd->stmt_backup);
  1645.   cleanup_items(stmt->free_list);
  1646.   close_thread_tables(thd);
  1647.   free_items(thd->free_list);
  1648.   thd->rollback_item_tree_changes();
  1649.   thd->free_list= 0;
  1650.   thd->current_arena= thd;
  1652.   if (error)
  1653.   {
  1654.     /* Statement map deletes statement on erase */
  1655.     thd->stmt_map.erase(stmt);
  1656.     stmt= NULL;
  1657.     if (thd->net.report_error)
  1658.       send_error(thd);
  1659.     /* otherwise the error is sent inside yyparse/send_prepare_results */
  1660.   }
  1661.   else
  1662.   {
  1663.     stmt->setup_set_params();
  1664.     SELECT_LEX *sl= stmt->lex->all_selects_list;
  1665.     for (; sl; sl= sl->next_select_in_list())
  1666.     {
  1667.       /*
  1668.         Save WHERE clause pointers, because they may be changed
  1669.         during query optimisation.
  1670.       */
  1671.       sl->prep_where= sl->where;
  1672.       /*
  1673.         Switch off a temporary flag that prevents evaluation of
  1674.         subqueries in statement prepare.
  1675.       */
  1676.       sl->uncacheable&= ~UNCACHEABLE_PREPARE;
  1677.     }
  1678.     stmt->state= Item_arena::PREPARED;
  1679.   }
  1681.   DBUG_RETURN(!stmt);
  1682. }
  1684. /* Reinit statement before execution */
  1686. static void reset_stmt_for_execute(Prepared_statement *stmt)
  1687. {
  1688.   THD *thd= stmt->thd;
  1689.   LEX *lex= stmt->lex;
  1690.   SELECT_LEX *sl= lex->all_selects_list;
  1692.   for (; sl; sl= sl->next_select_in_list())
  1693.   {
  1694.     /* remove option which was put by mysql_explain_union() */
  1695.     sl->options&= ~SELECT_DESCRIBE;
  1696.     /*
  1697.       Copy WHERE clause pointers to avoid damaging they by optimisation
  1698.     */
  1699.     if (sl->prep_where)
  1700.     {
  1701.       sl->where= sl->prep_where->copy_andor_structure(thd);
  1702.       sl->where->cleanup();
  1703.     }
  1704.     DBUG_ASSERT(sl->join == 0);
  1705.     ORDER *order;
  1706.     /* Fix GROUP list */
  1707.     for (order= (ORDER *)sl->group_list.first; order; order= order->next)
  1708.       order->item= &order->item_ptr;
  1709.     /* Fix ORDER list */
  1710.     for (order= (ORDER *)sl->order_list.first; order; order= order->next)
  1711.       order->item= &order->item_ptr;
  1713.     /*
  1714.       TODO: When the new table structure is ready, then have a status bit 
  1715.       to indicate the table is altered, and re-do the setup_* 
  1716.       and open the tables back.
  1717.     */
  1718.     for (TABLE_LIST *tables= (TABLE_LIST*) sl->table_list.first;
  1719.  tables;
  1720.  tables= tables->next)
  1721.     {
  1722.       /*
  1723.         Reset old pointers to TABLEs: they are not valid since the tables
  1724.         were closed in the end of previous prepare or execute call.
  1725.       */
  1726.       tables->table= 0;
  1727.       tables->table_list= 0;
  1728.     }
  1729.     
  1730.     {
  1731.       SELECT_LEX_UNIT *unit= sl->master_unit();
  1732.       unit->unclean();
  1733.       unit->types.empty();
  1734.       /* for derived tables & PS (which can't be reset by Item_subquery) */
  1735.       unit->reinit_exec_mechanism();
  1736.     }
  1737.   }
  1738.   lex->current_select= &lex->select_lex;
  1739.   if (lex->result)
  1740.     lex->result->cleanup();
  1741. }
  1744. /* 
  1745.     Clears parameters from data left from previous execution or long data
  1746.     
  1747.   SYNOPSIS
  1748.     reset_stmt_params()
  1749.       stmt - prepared statement for which parameters should be reset
  1750. */
  1752. static void reset_stmt_params(Prepared_statement *stmt)
  1753. {
  1754.   Item_param **item= stmt->param_array;
  1755.   Item_param **end= item + stmt->param_count;
  1756.   for (;item < end ; ++item)
  1757.     (**item).reset();
  1758. }
  1761. /*
  1762.   Executes previously prepared query.
  1763.   If there is any parameters, then replace markers with the data supplied
  1764.   from client, and then execute the query.
  1765.   SYNOPSIS
  1766.     mysql_stmt_execute()
  1767.       thd            Current thread
  1768.       packet         Query string
  1769.       packet_length  Query string length, including terminator character.
  1770. */
  1772. void mysql_stmt_execute(THD *thd, char *packet, uint packet_length)
  1773. {
  1774.   ulong stmt_id= uint4korr(packet);
  1775.   /*
  1776.     Query text for binary log, or empty string if the query is not put into
  1777.     binary log.
  1778.   */
  1779.   String expanded_query;
  1780. #ifndef EMBEDDED_LIBRARY
  1781.   uchar *packet_end= (uchar *) packet + packet_length - 1;
  1782. #endif
  1783.   Prepared_statement *stmt;
  1784.   DBUG_ENTER("mysql_stmt_execute");
  1786.   packet+= 9;                               /* stmt_id + 5 bytes of flags */
  1788.   statistic_increment(com_stmt_execute, &LOCK_status);
  1789.   if (!(stmt= find_prepared_statement(thd, stmt_id, "mysql_stmt_execute",
  1790.                                       SEND_ERROR)))
  1791.     DBUG_VOID_RETURN;
  1793.   DBUG_PRINT("exec_query:", ("%s", stmt->query));
  1795.   /* Check if we got an error when sending long data */
  1796.   if (stmt->state == Item_arena::ERROR)
  1797.   {
  1798.     send_error(thd, stmt->last_errno, stmt->last_error);
  1799.     DBUG_VOID_RETURN;
  1800.   }
  1802.   DBUG_ASSERT(thd->free_list == NULL);
  1803.   mysql_reset_thd_for_next_command(thd);
  1804. #ifndef EMBEDDED_LIBRARY
  1805.   if (stmt->param_count)
  1806.   {
  1807.     uchar *null_array= (uchar *) packet;
  1808.     if (setup_conversion_functions(stmt, (uchar **) &packet, packet_end) ||
  1809.         stmt->set_params(stmt, null_array, (uchar *) packet, packet_end,
  1810.                          &expanded_query))
  1811.       goto set_params_data_err;
  1812.   }
  1813. #else
  1814.   /*
  1815.     In embedded library we re-install conversion routines each time 
  1816.     we set params, and also we don't need to parse packet. 
  1817.     So we do it in one function.
  1818.   */
  1819.   if (stmt->param_count && stmt->set_params_data(stmt, &expanded_query))
  1820.     goto set_params_data_err;
  1821. #endif
  1822.   thd->protocol= &thd->protocol_prep;           // Switch to binary protocol
  1823.   execute_stmt(thd, stmt, &expanded_query, TRUE);
  1824.   thd->protocol= &thd->protocol_simple;         // Use normal protocol
  1825.   DBUG_VOID_RETURN;
  1827. set_params_data_err:
  1828.   reset_stmt_params(stmt);
  1829.   my_error(ER_WRONG_ARGUMENTS, MYF(0), "mysql_stmt_execute");
  1830.   send_error(thd);
  1831.   DBUG_VOID_RETURN;
  1832. }
  1835. /*
  1836.   Execute prepared statement using parameter values from
  1837.   lex->prepared_stmt_params and send result to the client using text protocol.
  1838. */
  1840. void mysql_sql_stmt_execute(THD *thd, LEX_STRING *stmt_name)
  1841. {
  1842.   Prepared_statement *stmt;
  1843.   /*
  1844.     Query text for binary log, or empty string if the query is not put into
  1845.     binary log.
  1846.   */
  1847.   String expanded_query;
  1848.   DBUG_ENTER("mysql_sql_stmt_execute");
  1850.   /* See comment for statistics_increment in mysql_stmt_prepare */
  1851.   statistic_increment(com_stmt_execute, &LOCK_status);
  1852.   if (!(stmt= (Prepared_statement*)thd->stmt_map.find_by_name(stmt_name)))
  1853.   {
  1854.     my_error(ER_UNKNOWN_STMT_HANDLER, MYF(0), stmt_name->length,
  1855.              stmt_name->str, "EXECUTE");
  1856.     send_error(thd);
  1857.     DBUG_VOID_RETURN;
  1858.   }
  1860.   if (stmt->param_count != thd->lex->prepared_stmt_params.elements)
  1861.   {
  1862.     my_error(ER_WRONG_ARGUMENTS, MYF(0), "EXECUTE");
  1863.     send_error(thd);
  1864.     DBUG_VOID_RETURN;
  1865.   }
  1867.   DBUG_ASSERT(thd->free_list == NULL);
  1868.   /* Must go before setting variables, as it clears thd->user_var_events */
  1869.   mysql_reset_thd_for_next_command(thd);
  1870.   thd->set_n_backup_statement(stmt, &thd->stmt_backup);
  1871.   if (stmt->set_params_from_vars(stmt,
  1872.                                  thd->stmt_backup.lex->prepared_stmt_params,
  1873.                                  &expanded_query))
  1874.   {
  1875.     my_error(ER_WRONG_ARGUMENTS, MYF(0), "EXECUTE");
  1876.     send_error(thd);
  1877.   }
  1878.   thd->command= COM_EXECUTE; /* For nice messages in general log */
  1879.   execute_stmt(thd, stmt, &expanded_query, FALSE);
  1880.   DBUG_VOID_RETURN;
  1881. }
  1884. /*
  1885.   Execute prepared statement.
  1886.   SYNOPSIS
  1887.     execute_stmt()
  1888.       thd            Current thread
  1889.       stmt           Statement to execute
  1890.       expanded_query If binary log is enabled, query string with parameter
  1891.                      placeholders replaced with actual values. Otherwise empty
  1892.                      string.
  1893.   NOTES
  1894.   Caller must set parameter values and thd::protocol.
  1895.   thd->free_list is assumed to be garbage.
  1896. */
  1898. static void execute_stmt(THD *thd, Prepared_statement *stmt,
  1899.                          String *expanded_query, bool set_context)
  1900. {
  1901.   DBUG_ENTER("execute_stmt");
  1902.   if (set_context)
  1903.     thd->set_n_backup_statement(stmt, &thd->stmt_backup);
  1904.   reset_stmt_for_execute(stmt);
  1906.   if (expanded_query->length() &&
  1907.       alloc_query(thd, (char *)expanded_query->ptr(),
  1908.                   expanded_query->length()+1))
  1909.   {
  1910.     my_error(ER_OUTOFMEMORY, 0, expanded_query->length());
  1911.     DBUG_VOID_RETURN;
  1912.   }
  1913.   mysql_log.write(thd, thd->command, "[%lu] %s", stmt->id, thd->query);
  1914.   /*
  1915.     At first execution of prepared statement we will perform logical
  1916.     transformations of the query tree (i.e. negations elimination).
  1917.     This should be done permanently on the parse tree of this statement.
  1918.   */
  1919.   thd->current_arena= stmt;
  1921.   if (!(specialflag & SPECIAL_NO_PRIOR))
  1922.     my_pthread_setprio(pthread_self(),QUERY_PRIOR);
  1923.   mysql_execute_command(thd);
  1924.   thd->lex->unit.cleanup();
  1925.   if (!(specialflag & SPECIAL_NO_PRIOR))
  1926.     my_pthread_setprio(pthread_self(), WAIT_PRIOR);
  1927.   /*
  1928.     'start_time' is set in dispatch_command, but THD::query will
  1929.     be freed when we return from this function. So let's log the slow
  1930.     query here.
  1931.   */
  1932.   log_slow_statement(thd);
  1933.   /* Prevent from second logging in the end of dispatch_command */
  1934.   thd->enable_slow_log= FALSE;
  1936.   /* Free Items that were created during this execution of the PS. */
  1937.   free_items(thd->free_list);
  1938.   thd->free_list= 0;
  1939.   if (stmt->state == Item_arena::PREPARED)
  1940.     stmt->state= Item_arena::EXECUTED;
  1941.   thd->current_arena= thd;
  1942.   cleanup_items(stmt->free_list);
  1943.   thd->rollback_item_tree_changes();
  1944.   reset_stmt_params(stmt);
  1945.   close_thread_tables(thd);                    // to close derived tables
  1946.   thd->set_statement(&thd->stmt_backup);
  1947.   DBUG_VOID_RETURN;
  1948. }
  1951. /*
  1952.   Reset a prepared statement in case there was a recoverable error.
  1953.   SYNOPSIS
  1954.     mysql_stmt_reset()
  1955.       thd       Thread handle
  1956.       packet Packet with stmt id 
  1958.   DESCRIPTION
  1959.     This function resets statement to the state it was right after prepare.
  1960.     It can be used to:
  1961.      - clear an error happened during mysql_stmt_send_long_data
  1962.      - cancel long data stream for all placeholders without
  1963.        having to call mysql_stmt_execute.
  1964.     Sends 'OK' packet in case of success (statement was reset)
  1965.     or 'ERROR' packet (unrecoverable error/statement not found/etc).
  1966. */
  1968. void mysql_stmt_reset(THD *thd, char *packet)
  1969. {
  1970.   /* There is always space for 4 bytes in buffer */
  1971.   ulong stmt_id= uint4korr(packet);
  1972.   Prepared_statement *stmt;
  1973.   
  1974.   DBUG_ENTER("mysql_stmt_reset");
  1976.   statistic_increment(com_stmt_reset, &LOCK_status);
  1977.   if (!(stmt= find_prepared_statement(thd, stmt_id, "mysql_stmt_reset",
  1978.                                       SEND_ERROR)))
  1979.     DBUG_VOID_RETURN;
  1981.   stmt->state= Item_arena::PREPARED;
  1983.   /* 
  1984.     Clear parameters from data which could be set by 
  1985.     mysql_stmt_send_long_data() call.
  1986.   */
  1987.   reset_stmt_params(stmt);
  1989.   mysql_reset_thd_for_next_command(thd);
  1990.   send_ok(thd);
  1991.   
  1992.   DBUG_VOID_RETURN;
  1993. }
  1996. /*
  1997.   Delete a prepared statement from memory.
  1998.   Note: we don't send any reply to that command. 
  1999. */
  2001. void mysql_stmt_free(THD *thd, char *packet)
  2002. {
  2003.   /* There is always space for 4 bytes in packet buffer */
  2004.   ulong stmt_id= uint4korr(packet);
  2005.   Prepared_statement *stmt;
  2007.   DBUG_ENTER("mysql_stmt_free");
  2009.   statistic_increment(com_stmt_close, &LOCK_status);
  2010.   if (!(stmt= find_prepared_statement(thd, stmt_id, "mysql_stmt_close",
  2011.                                       DONT_SEND_ERROR)))
  2012.     DBUG_VOID_RETURN;
  2014.   /* Statement map deletes statement on erase */
  2015.   thd->stmt_map.erase(stmt);
  2016.   DBUG_VOID_RETURN;
  2017. }
  2020. /*
  2021.   Long data in pieces from client
  2023.   SYNOPSIS
  2024.     mysql_stmt_get_longdata()
  2025.     thd Thread handle
  2026.     pos String to append
  2027.     packet_length Length of string
  2029.   DESCRIPTION
  2030.     Get a part of a long data.
  2031.     To make the protocol efficient, we are not sending any return packages
  2032.     here.
  2033.     If something goes wrong, then we will send the error on 'execute'
  2035.     We assume that the client takes care of checking that all parts are sent
  2036.     to the server. (No checking that we get a 'end of column' in the server)
  2037. */
  2039. void mysql_stmt_get_longdata(THD *thd, char *packet, ulong packet_length)
  2040. {
  2041.   ulong stmt_id;
  2042.   uint param_number;
  2043.   Prepared_statement *stmt;
  2044.   Item_param *param;
  2045.   char *packet_end= packet + packet_length - 1;
  2046.   
  2047.   DBUG_ENTER("mysql_stmt_get_longdata");
  2049.   statistic_increment(com_stmt_send_long_data, &LOCK_status);
  2050. #ifndef EMBEDDED_LIBRARY
  2051.   /* Minimal size of long data packet is 6 bytes */
  2052.   if ((ulong) (packet_end - packet) < MYSQL_LONG_DATA_HEADER)
  2053.   {
  2054.     my_error(ER_WRONG_ARGUMENTS, MYF(0), "mysql_stmt_send_long_data");
  2055.     DBUG_VOID_RETURN;
  2056.   }
  2057. #endif
  2059.   stmt_id= uint4korr(packet);
  2060.   packet+= 4;
  2062.   if (!(stmt=find_prepared_statement(thd, stmt_id, "mysql_stmt_send_long_data",
  2063.                                      DONT_SEND_ERROR)))
  2064.     DBUG_VOID_RETURN;
  2066.   param_number= uint2korr(packet);
  2067.   packet+= 2;
  2068. #ifndef EMBEDDED_LIBRARY
  2069.   if (param_number >= stmt->param_count)
  2070.   {
  2071.     /* Error will be sent in execute call */
  2072.     stmt->state= Item_arena::ERROR;
  2073.     stmt->last_errno= ER_WRONG_ARGUMENTS;
  2074.     sprintf(stmt->last_error, ER(ER_WRONG_ARGUMENTS),
  2075.             "mysql_stmt_send_long_data");
  2076.     DBUG_VOID_RETURN;
  2077.   }
  2078. #endif
  2080.   param= stmt->param_array[param_number];
  2082. #ifndef EMBEDDED_LIBRARY
  2083.   if (param->set_longdata(packet, (ulong) (packet_end - packet)))
  2084. #else
  2085.   if (param->set_longdata(thd->extra_data, thd->extra_length))
  2086. #endif
  2087.   {
  2088.     stmt->state= Item_arena::ERROR;
  2089.     stmt->last_errno= ER_OUTOFMEMORY;
  2090.     sprintf(stmt->last_error, ER(ER_OUTOFMEMORY), 0);
  2091.   }
  2092.   DBUG_VOID_RETURN;
  2093. }
  2096. Prepared_statement::Prepared_statement(THD *thd_arg)
  2097.   :Statement(thd_arg),
  2098.   thd(thd_arg),
  2099.   param_array(0),
  2100.   param_count(0),
  2101.   last_errno(0)
  2102. {
  2103.   *last_error= '';
  2104. }
  2107. void Prepared_statement::setup_set_params()
  2108. {
  2109.   /* Setup binary logging */
  2110.   if (mysql_bin_log.is_open() && is_update_query(lex->sql_command) ||
  2111.       mysql_log.is_open() || mysql_slow_log.is_open())
  2112.   {
  2113.     set_params_from_vars= insert_params_from_vars_with_log;
  2114. #ifndef EMBEDDED_LIBRARY
  2115.     set_params= insert_params_withlog;
  2116. #else
  2117.     set_params_data= emb_insert_params_withlog;
  2118. #endif
  2119.   }
  2120.   else
  2121.   {
  2122.     set_params_from_vars= insert_params_from_vars;
  2123. #ifndef EMBEDDED_LIBRARY
  2124.     set_params= insert_params;
  2125. #else
  2126.     set_params_data= emb_insert_params;
  2127. #endif
  2128.   }
  2129. }
  2132. Prepared_statement::~Prepared_statement()
  2133. {
  2134.   free_items(free_list);
  2135.   delete lex->result;
  2136. }
  2139. Item_arena::Type Prepared_statement::type() const
  2140. {
  2141.   return PREPARED_STATEMENT;
  2142. }