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

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

MySQL数据库

开发平台：

Visual C++

protocol.cpp：源码内容
  1. /* Copyright (C) 2000-2003 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.   Low level functions for storing data to be send to the MySQL client
  19.   The actual communction is handled by the net_xxx functions in net_serv.cc
  20. */
  22. #ifdef USE_PRAGMA_IMPLEMENTATION
  23. #pragma implementation // gcc: Class implementation
  24. #endif
  26. #include "mysql_priv.h"
  27. #include <stdarg.h>
  29. static const unsigned int PACKET_BUFFER_EXTRA_ALLOC= 1024;
  31. #ifndef EMBEDDED_LIBRARY
  32. bool Protocol::net_store_data(const char *from, uint length)
  33. #else
  34. bool Protocol_prep::net_store_data(const char *from, uint length)
  35. #endif
  36. {
  37.   ulong packet_length=packet->length();
  38.   /* 
  39.      The +9 comes from that strings of length longer than 16M require
  40.      9 bytes to be stored (see net_store_length).
  41.   */
  42.   if (packet_length+9+length > packet->alloced_length() &&
  43.       packet->realloc(packet_length+9+length))
  44.     return 1;
  45.   char *to=(char*) net_store_length((char*) packet->ptr()+packet_length,
  46.     (ulonglong) length);
  47.   memcpy(to,from,length);
  48.   packet->length((uint) (to+length-packet->ptr()));
  49.   return 0;
  50. }
  53. /* Send a error string to client */
  55. void send_error(THD *thd, uint sql_errno, const char *err)
  56. {
  57. #ifndef EMBEDDED_LIBRARY 
  58.   uint length;
  59.   char buff[MYSQL_ERRMSG_SIZE+2], *pos;
  60. #endif
  61.   const char *orig_err= err;
  62.   NET *net= &thd->net;
  63.   DBUG_ENTER("send_error");
  64.   DBUG_PRINT("enter",("sql_errno: %d  err: %s", sql_errno,
  65.       err ? err : net->last_error[0] ?
  66.       net->last_error : "NULL"));
  68. #ifndef EMBEDDED_LIBRARY  /* TODO query cache in embedded library*/
  69.   query_cache_abort(net);
  70. #endif
  71.   thd->query_error=  1; // needed to catch query errors during replication
  72.   if (!err)
  73.   {
  74.     if (sql_errno)
  75.       err=ER(sql_errno);
  76.     else
  77.     {
  78.       if ((err=net->last_error)[0])
  79. sql_errno=net->last_errno;
  80.       else
  81.       {
  82. sql_errno=ER_UNKNOWN_ERROR;
  83. err=ER(sql_errno);  /* purecov: inspected */
  84.       }
  85.     }
  86.     orig_err= err;
  87.   }
  89. #ifdef EMBEDDED_LIBRARY
  90.   net->last_errno= sql_errno;
  91.   strmake(net->last_error, err, sizeof(net->last_error)-1);
  92.   strmov(net->sqlstate, mysql_errno_to_sqlstate(sql_errno));
  93. #else
  95.   if (net->vio == 0)
  96.   {
  97.     if (thd->bootstrap)
  98.     {
  99.       /* In bootstrap it's ok to print on stderr */
  100.       fprintf(stderr,"ERROR: %d  %sn",sql_errno,err);
  101.     }
  102.     DBUG_VOID_RETURN;
  103.   }
  105.   if (net->return_errno)
  106.   { // new client code; Add errno before message
  107.     int2store(buff,sql_errno);
  108.     pos= buff+2;
  109.     if (thd->client_capabilities & CLIENT_PROTOCOL_41)
  110.     {
  111.       /* The first # is to make the protocol backward compatible */
  112.       buff[2]= '#';
  113.       pos= strmov(buff+3, mysql_errno_to_sqlstate(sql_errno));
  114.     }
  115.     length= (uint) (strmake(pos, err, MYSQL_ERRMSG_SIZE-1) - buff);
  116.     err=buff;
  117.   }
  118.   else
  119.   {
  120.     length=(uint) strlen(err);
  121.     set_if_smaller(length,MYSQL_ERRMSG_SIZE-1);
  122.   }
  123.   VOID(net_write_command(net,(uchar) 255, "", 0, (char*) err,length));
  124. #endif  /* EMBEDDED_LIBRARY*/
  125.   if (!thd->killed)
  126.     push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, sql_errno,
  127.                  orig_err ? orig_err : ER(sql_errno));
  128.   thd->is_fatal_error=0; // Error message is given
  129.   thd->net.report_error= 0;
  131.   /* Abort multi-result sets */
  132.   thd->lex->found_colon= 0;
  133.   thd->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
  134.   DBUG_VOID_RETURN;
  135. }
  138. /*
  139.   Send a warning to the end user
  141.   SYNOPSIS
  142.     send_warning()
  143.     thd Thread handler
  144.     sql_errno Warning number (error message)
  145.     err Error string.  If not set, use ER(sql_errno)
  147.   DESCRIPTION
  148.     Register the warning so that the user can get it with mysql_warnings()
  149.     Send an ok (+ warning count) to the end user.
  150. */
  152. void send_warning(THD *thd, uint sql_errno, const char *err)
  153. {
  154.   DBUG_ENTER("send_warning");  
  155.   push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, sql_errno,
  156.        err ? err : ER(sql_errno));
  157.   send_ok(thd);
  158.   DBUG_VOID_RETURN;
  159. }
  162. /*
  163.    Write error package and flush to client
  164.    It's a little too low level, but I don't want to use another buffer for
  165.    this
  166. */
  168. void
  169. net_printf(THD *thd, uint errcode, ...)
  170. {
  171.   va_list args;
  172.   uint length,offset;
  173.   const char *format;
  174. #ifndef EMBEDDED_LIBRARY
  175.   const char *text_pos;
  176.   int head_length= NET_HEADER_SIZE;
  177. #else
  178.   char text_pos[1024];
  179. #endif
  180.   NET *net= &thd->net;
  182.   DBUG_ENTER("net_printf");
  183.   DBUG_PRINT("enter",("message: %u",errcode));
  185.   thd->query_error=  1; // needed to catch query errors during replication
  186. #ifndef EMBEDDED_LIBRARY
  187.   query_cache_abort(net); // Safety
  188. #endif
  189.   va_start(args,errcode);
  190.   /*
  191.     The following is needed to make net_printf() work with 0 argument for
  192.     errorcode and use the argument after that as the format string. This
  193.     is useful for rare errors that are not worth the hassle to put in
  194.     errmsg.sys, but at the same time, the message is not fixed text
  195.   */
  196.   if (errcode)
  197.     format= ER(errcode);
  198.   else
  199.   {
  200.     format=va_arg(args,char*);
  201.     errcode= ER_UNKNOWN_ERROR;
  202.   }
  203.   offset= (net->return_errno ?
  204.    ((thd->client_capabilities & CLIENT_PROTOCOL_41) ?
  205.     2+SQLSTATE_LENGTH+1 : 2) : 0);
  206. #ifndef EMBEDDED_LIBRARY
  207.   text_pos=(char*) net->buff + head_length + offset + 1;
  208.   length= (uint) ((char*)net->buff_end - text_pos);
  209. #else
  210.   length=sizeof(text_pos)-1;
  211. #endif
  212.   length=my_vsnprintf(my_const_cast(char*) (text_pos),
  213.                       min(length, sizeof(net->last_error)),
  214.                       format,args);
  215.   va_end(args);
  217.   /* Replication slave relies on net->last_* to see if there was error */
  218.   net->last_errno= errcode;
  219.   strmake(net->last_error, text_pos, sizeof(net->last_error)-1);
  221. #ifndef EMBEDDED_LIBRARY
  222.   if (net->vio == 0)
  223.   {
  224.     if (thd->bootstrap)
  225.     {
  226.       /*
  227. In bootstrap it's ok to print on stderr
  228. This may also happen when we get an error from a slave thread
  229.       */
  230.       fprintf(stderr,"ERROR: %d  %sn",errcode,text_pos);
  231.       thd->fatal_error();
  232.     }
  233.     DBUG_VOID_RETURN;
  234.   }
  236.   int3store(net->buff,length+1+offset);
  237.   net->buff[3]= (net->compress) ? 0 : (uchar) (net->pkt_nr++);
  238.   net->buff[head_length]=(uchar) 255; // Error package
  239.   if (offset)
  240.   {
  241.     uchar *pos= net->buff+head_length+1;
  242.     int2store(pos, errcode);
  243.     if (thd->client_capabilities & CLIENT_PROTOCOL_41)
  244.     {
  245.       pos[2]= '#';      /* To make the protocol backward compatible */
  246.       memcpy(pos+3, mysql_errno_to_sqlstate(errcode), SQLSTATE_LENGTH);
  247.     }
  248.   }
  249.   VOID(net_real_write(net,(char*) net->buff,length+head_length+1+offset));
  250. #else
  251.   net->last_errno= errcode;
  252.   strmake(net->last_error, text_pos, length);
  253.   strmake(net->sqlstate, mysql_errno_to_sqlstate(errcode), SQLSTATE_LENGTH);
  254. #endif
  255.   if (!thd->killed)
  256.     push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, errcode,
  257.                  text_pos ? text_pos : ER(errcode));
  258.   thd->is_fatal_error=0; // Error message is given
  259.   DBUG_VOID_RETURN;
  260. }
  262. /*
  263.   Return ok to the client.
  265.   SYNOPSIS
  266.     send_ok()
  267.     thd Thread handler
  268.     affected_rows Number of rows changed by statement
  269.     id Auto_increment id for first row (if used)
  270.     message Message to send to the client (Used by mysql_status)
  272.   DESCRIPTION
  273.     The ok packet has the following structure
  275.     0 Marker (1 byte)
  276.     affected_rows Stored in 1-9 bytes
  277.     id Stored in 1-9 bytes
  278.     server_status Copy of thd->server_status;  Can be used by client
  279. to check if we are inside an transaction
  280. New in 4.0 protocol
  281.     warning_count Stored in 2 bytes; New in 4.1 protocol
  282.     message Stored as packed length (1-9 bytes) + message
  283. Is not stored if no message
  285.    If net->no_send_ok return without sending packet
  286. */    
  288. #ifndef EMBEDDED_LIBRARY
  289. void
  290. send_ok(THD *thd, ha_rows affected_rows, ulonglong id, const char *message)
  291. {
  292.   NET *net= &thd->net;
  293.   char buff[MYSQL_ERRMSG_SIZE+10],*pos;
  294.   DBUG_ENTER("send_ok");
  296.   if (net->no_send_ok || !net->vio) // hack for re-parsing queries
  297.     DBUG_VOID_RETURN;
  299.   buff[0]=0; // No fields
  300.   pos=net_store_length(buff+1,(ulonglong) affected_rows);
  301.   pos=net_store_length(pos, (ulonglong) id);
  302.   if (thd->client_capabilities & CLIENT_PROTOCOL_41)
  303.   {
  304.     DBUG_PRINT("info",
  305.        ("affected_rows: %lu  id: %lu  status: %u  warning_count: %u",
  306. (ulong) affected_rows,
  307. (ulong) id,
  308. (uint) (thd->server_status & 0xffff),
  309. (uint) thd->total_warn_count));
  310.     int2store(pos,thd->server_status);
  311.     pos+=2;
  313.     /* We can only return up to 65535 warnings in two bytes */
  314.     uint tmp= min(thd->total_warn_count, 65535);
  315.     int2store(pos, tmp);
  316.     pos+= 2;
  317.   }
  318.   else if (net->return_status) // For 4.0 protocol
  319.   {
  320.     int2store(pos,thd->server_status);
  321.     pos+=2;
  322.   }
  323.   if (message)
  324.     pos=net_store_data((char*) pos, message, strlen(message));
  325.   VOID(my_net_write(net,buff,(uint) (pos-buff)));
  326.   VOID(net_flush(net));
  327.   /* We can't anymore send an error to the client */
  328.   thd->net.report_error= 0;
  329.   DBUG_VOID_RETURN;
  330. }
  332. static char eof_buff[1]= { (char) 254 };        /* Marker for end of fields */
  334. /*
  335.   Send eof (= end of result set) to the client
  337.   SYNOPSIS
  338.     send_eof()
  339.     thd Thread handler
  340.     no_flush Set to 1 if there will be more data to the client,
  341. like in send_fields().
  343.   DESCRIPTION
  344.     The eof packet has the following structure
  346.     254 Marker (1 byte)
  347.     warning_count Stored in 2 bytes; New in 4.1 protocol
  348.     status_flag Stored in 2 bytes;
  349. For flags like SERVER_STATUS_MORE_RESULTS
  351.     Note that the warning count will not be sent if 'no_flush' is set as
  352.     we don't want to report the warning count until all data is sent to the
  353.     client.
  354. */    
  356. void
  357. send_eof(THD *thd, bool no_flush)
  358. {
  359.   NET *net= &thd->net;
  360.   DBUG_ENTER("send_eof");
  361.   if (net->vio != 0)
  362.   {
  363.     if (thd->client_capabilities & CLIENT_PROTOCOL_41)
  364.     {
  365.       uchar buff[5];
  366.       uint tmp= min(thd->total_warn_count, 65535);
  367.       buff[0]=254;
  368.       int2store(buff+1, tmp);
  369.       /*
  370. The following test should never be true, but it's better to do it
  371. because if 'is_fatal_error' is set the server is not going to execute
  372. other queries (see the if test in dispatch_command / COM_QUERY)
  373.       */
  374.       if (thd->is_fatal_error)
  375. thd->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
  376.       int2store(buff+3, thd->server_status);
  377.       VOID(my_net_write(net,(char*) buff,5));
  378.       VOID(net_flush(net));
  379.     }
  380.     else
  381.     {
  382.       VOID(my_net_write(net,eof_buff,1));
  383.       if (!no_flush)
  384. VOID(net_flush(net));
  385.     }
  386.   }
  387.   DBUG_VOID_RETURN;
  388. }
  390. /*
  391.     Please client to send scrambled_password in old format.
  392.   SYNOPSYS
  393.     send_old_password_request()
  394.     thd thread handle
  395.      
  396.   RETURN VALUE
  397.     0  ok
  398.    !0  error
  399. */
  401. bool send_old_password_request(THD *thd)
  402. {
  403.   NET *net= &thd->net;
  404.   return my_net_write(net, eof_buff, 1) || net_flush(net);
  405. }
  407. #endif /* EMBEDDED_LIBRARY */
  409. /*
  410.   Faster net_store_length when we know that length is less than 65536.
  411.   We keep a separate version for that range because it's widely used in
  412.   libmysql.
  413.   uint is used as agrument type because of MySQL type conventions:
  414.   uint for 0..65536
  415.   ulong for 0..4294967296
  416.   ulonglong for bigger numbers.
  417. */
  419. char *net_store_length(char *pkg, uint length)
  420. {
  421.   uchar *packet=(uchar*) pkg;
  422.   if (length < 251)
  423.   {
  424.     *packet=(uchar) length;
  425.     return (char*) packet+1;
  426.   }
  427.   *packet++=252;
  428.   int2store(packet,(uint) length);
  429.   return (char*) packet+2;
  430. }
  433. /****************************************************************************
  434.   Functions used by the protocol functions (like send_ok) to store strings
  435.   and numbers in the header result packet.
  436. ****************************************************************************/
  438. /* The following will only be used for short strings < 65K */
  440. char *net_store_data(char *to,const char *from, uint length)
  441. {
  442.   to=net_store_length(to,length);
  443.   memcpy(to,from,length);
  444.   return to+length;
  445. }
  447. char *net_store_data(char *to,int32 from)
  448. {
  449.   char buff[20];
  450.   uint length=(uint) (int10_to_str(from,buff,10)-buff);
  451.   to=net_store_length(to,length);
  452.   memcpy(to,buff,length);
  453.   return to+length;
  454. }
  456. char *net_store_data(char *to,longlong from)
  457. {
  458.   char buff[22];
  459.   uint length=(uint) (longlong10_to_str(from,buff,10)-buff);
  460.   to=net_store_length(to,length);
  461.   memcpy(to,buff,length);
  462.   return to+length;
  463. }
  466. /*****************************************************************************
  467.   Default Protocol functions
  468. *****************************************************************************/
  470. void Protocol::init(THD *thd_arg)
  471. {
  472.   thd=thd_arg;
  473.   packet= &thd->packet;
  474.   convert= &thd->convert_buffer;
  475. #ifndef DEBUG_OFF
  476.   field_types= 0;
  477. #endif
  478. }
  481. bool Protocol::flush()
  482. {
  483. #ifndef EMBEDDED_LIBRARY
  484.   return net_flush(&thd->net);
  485. #else
  486.   return 0;
  487. #endif
  488. }
  490. /*
  491.   Send name and type of result to client.
  493.   SYNOPSIS
  494.     send_fields()
  495.     THD Thread data object
  496.     list List of items to send to client
  497.     flag Bit mask with the following functions:
  498. 1 send number of rows
  499. 2 send default values
  501.   DESCRIPTION
  502.     Sum fields has table name empty and field_name.
  504.   RETURN VALUES
  505.     0 ok
  506.     1 Error  (Note that in this case the error is not sent to the client)
  507. */
  509. #ifndef EMBEDDED_LIBRARY
  510. bool Protocol::send_fields(List<Item> *list, uint flag)
  511. {
  512.   List_iterator_fast<Item> it(*list);
  513.   Item *item;
  514.   char buff[80];
  515.   String tmp((char*) buff,sizeof(buff),&my_charset_bin);
  516.   Protocol_simple prot(thd);
  517.   String *local_packet= prot.storage_packet();
  518.   CHARSET_INFO *thd_charset= thd->variables.character_set_results;
  519.   DBUG_ENTER("send_fields");
  521.   if (flag & 1)
  522.   { // Packet with number of elements
  523.     char *pos=net_store_length(buff, (uint) list->elements);
  524.     (void) my_net_write(&thd->net, buff,(uint) (pos-buff));
  525.   }
  527. #ifndef DEBUG_OFF
  528.   field_types= (enum_field_types*) thd->alloc(sizeof(field_types) *
  529.       list->elements);
  530.   uint count= 0;
  531. #endif
  533.   while ((item=it++))
  534.   {
  535.     char *pos;
  536.     CHARSET_INFO *cs= system_charset_info;
  537.     Send_field field;
  538.     item->make_field(&field);
  539.     prot.prepare_for_resend();
  541.     if (thd->client_capabilities & CLIENT_PROTOCOL_41)
  542.     {
  543.       if (prot.store("def", 3, cs, thd_charset) ||
  544.   prot.store(field.db_name, (uint) strlen(field.db_name),
  545.      cs, thd_charset) ||
  546.   prot.store(field.table_name, (uint) strlen(field.table_name),
  547.      cs, thd_charset) ||
  548.   prot.store(field.org_table_name, (uint) strlen(field.org_table_name),
  549.      cs, thd_charset) ||
  550.   prot.store(field.col_name, (uint) strlen(field.col_name),
  551.      cs, thd_charset) ||
  552.   prot.store(field.org_col_name, (uint) strlen(field.org_col_name),
  553.      cs, thd_charset) ||
  554.   local_packet->realloc(local_packet->length()+12))
  555. goto err;
  556.       /* Store fixed length fields */
  557.       pos= (char*) local_packet->ptr()+local_packet->length();
  558.       *pos++= 12; // Length of packed fields
  559.       if (item->collation.collation == &my_charset_bin || thd_charset == NULL)
  560.       {
  561.         /* No conversion */
  562.         int2store(pos, field.charsetnr);
  563.         int4store(pos+2, field.length);
  564.       }
  565.       else
  566.       {
  567.         /* With conversion */
  568.         int2store(pos, thd_charset->number);
  569.         uint char_len= field.length / item->collation.collation->mbmaxlen;
  570.         int4store(pos+2, char_len * thd_charset->mbmaxlen);
  571.       }
  572.       pos[6]= field.type;
  573.       int2store(pos+7,field.flags);
  574.       pos[9]= (char) field.decimals;
  575.       pos[10]= 0; // For the future
  576.       pos[11]= 0; // For the future
  577.       pos+= 12;
  578.     }
  579.     else
  580.     {
  581.       if (prot.store(field.table_name, (uint) strlen(field.table_name),
  582.      cs, thd_charset) ||
  583.   prot.store(field.col_name, (uint) strlen(field.col_name),
  584.      cs, thd_charset) ||
  585.   local_packet->realloc(local_packet->length()+10))
  586. goto err;
  587.       pos= (char*) local_packet->ptr()+local_packet->length();
  589. #ifdef TO_BE_DELETED_IN_6
  590.       if (!(thd->client_capabilities & CLIENT_LONG_FLAG))
  591.       {
  592. pos[0]=3;
  593. int3store(pos+1,field.length);
  594. pos[4]=1;
  595. pos[5]=field.type;
  596. pos[6]=2;
  597. pos[7]= (char) field.flags;
  598. pos[8]= (char) field.decimals;
  599. pos+= 9;
  600.       }
  601.       else
  602. #endif
  603.       {
  604. pos[0]=3;
  605. int3store(pos+1,field.length);
  606. pos[4]=1;
  607. pos[5]=field.type;
  608. pos[6]=3;
  609. int2store(pos+7,field.flags);
  610. pos[9]= (char) field.decimals;
  611. pos+= 10;
  612.       }
  613.     }
  614.     local_packet->length((uint) (pos - local_packet->ptr()));
  615.     if (flag & 2)
  616.       item->send(&prot, &tmp); // Send default value
  617.     if (prot.write())
  618.       break; /* purecov: inspected */
  619. #ifndef DEBUG_OFF
  620.     field_types[count++]= field.type;
  621. #endif
  622.   }
  624.   my_net_write(&thd->net, eof_buff, 1);
  625.   DBUG_RETURN(prepare_for_send(list));
  627. err:
  628.   send_error(thd,ER_OUT_OF_RESOURCES); /* purecov: inspected */
  629.   DBUG_RETURN(1); /* purecov: inspected */
  630. }
  633. bool Protocol::send_records_num(List<Item> *list, ulonglong records)
  634. {
  635.   char *pos;
  636.   char buff[20];
  637.   pos=net_store_length(buff, (uint) list->elements);
  638.   pos=net_store_length(pos, records);
  639.   return my_net_write(&thd->net, buff,(uint) (pos-buff));
  640. }
  643. bool Protocol::write()
  644. {
  645.   DBUG_ENTER("Protocol::write");
  646.   DBUG_RETURN(my_net_write(&thd->net, packet->ptr(), packet->length()));
  647. }
  648. #endif /* EMBEDDED_LIBRARY */
  651. /*
  652.   Send  end terminated string
  654.   SYNOPSIS
  655.     store()
  656.     from NullS or  terminated string
  658.   NOTES
  659.     In most cases one should use store(from, length) instead of this function
  661.   RETURN VALUES
  662.     0 ok
  663.     1 error
  664. */
  666. bool Protocol::store(const char *from, CHARSET_INFO *cs)
  667. {
  668.   if (!from)
  669.     return store_null();
  670.   uint length= strlen(from);
  671.   return store(from, length, cs);
  672. }
  675. /*
  676.   Send a set of strings as one long string with ',' in between
  677. */
  679. bool Protocol::store(I_List<i_string>* str_list)
  680. {
  681.   char buf[256];
  682.   String tmp(buf, sizeof(buf), &my_charset_bin);
  683.   uint32 len;
  684.   I_List_iterator<i_string> it(*str_list);
  685.   i_string* s;
  687.   tmp.length(0);
  688.   while ((s=it++))
  689.   {
  690.     tmp.append(s->ptr);
  691.     tmp.append(',');
  692.   }
  693.   if ((len= tmp.length()))
  694.     len--; // Remove last ','
  695.   return store((char*) tmp.ptr(), len,  tmp.charset());
  696. }
  699. /****************************************************************************
  700.   Functions to handle the simple (default) protocol where everything is
  701.   This protocol is the one that is used by default between the MySQL server
  702.   and client when you are not using prepared statements.
  704.   All data are sent as 'packed-string-length' followed by 'string-data'
  705. ****************************************************************************/
  707. #ifndef EMBEDDED_LIBRARY
  708. void Protocol_simple::prepare_for_resend()
  709. {
  710.   packet->length(0);
  711. #ifndef DEBUG_OFF
  712.   field_pos= 0;
  713. #endif
  714. }
  716. bool Protocol_simple::store_null()
  717. {
  718. #ifndef DEBUG_OFF
  719.   field_pos++;
  720. #endif
  721.   char buff[1];
  722.   buff[0]= (char)251;
  723.   return packet->append(buff, sizeof(buff), PACKET_BUFFER_EXTRA_ALLOC);
  724. }
  725. #endif
  728. /*
  729.   Auxilary function to convert string to the given character set
  730.   and store in network buffer.
  731. */
  733. bool Protocol::store_string_aux(const char *from, uint length,
  734.                                 CHARSET_INFO *fromcs, CHARSET_INFO *tocs)
  735. {
  736.   /* 'tocs' is set 0 when client issues SET character_set_results=NULL */
  737.   if (tocs && !my_charset_same(fromcs, tocs) &&
  738.       fromcs != &my_charset_bin &&
  739.       tocs != &my_charset_bin)
  740.   {
  741.     uint dummy_errors;
  742.     return convert->copy(from, length, fromcs, tocs, &dummy_errors) ||
  743.            net_store_data(convert->ptr(), convert->length());
  744.   }
  745.   return net_store_data(from, length);
  746. }
  749. bool Protocol_simple::store(const char *from, uint length,
  750.     CHARSET_INFO *fromcs, CHARSET_INFO *tocs)
  751. {
  752. #ifndef DEBUG_OFF
  753.   DBUG_ASSERT(field_types == 0 ||
  754.       field_types[field_pos] == MYSQL_TYPE_DECIMAL ||
  755.       (field_types[field_pos] >= MYSQL_TYPE_ENUM &&
  756.        field_types[field_pos] <= MYSQL_TYPE_GEOMETRY));
  757.   field_pos++;
  758. #endif
  759.   return store_string_aux(from, length, fromcs, tocs);
  760. }
  763. bool Protocol_simple::store(const char *from, uint length,
  764.     CHARSET_INFO *fromcs)
  765. {
  766.   CHARSET_INFO *tocs= this->thd->variables.character_set_results;
  767. #ifndef DEBUG_OFF
  768.   DBUG_ASSERT(field_types == 0 ||
  769.       field_types[field_pos] == MYSQL_TYPE_DECIMAL ||
  770.       (field_types[field_pos] >= MYSQL_TYPE_ENUM &&
  771.        field_types[field_pos] <= MYSQL_TYPE_GEOMETRY));
  772.   field_pos++;
  773. #endif
  774.   return store_string_aux(from, length, fromcs, tocs);
  775. }
  778. bool Protocol_simple::store_tiny(longlong from)
  779. {
  780. #ifndef DEBUG_OFF
  781.   DBUG_ASSERT(field_types == 0 || field_types[field_pos] == MYSQL_TYPE_TINY);
  782.   field_pos++;
  783. #endif
  784.   char buff[20];
  785.   return net_store_data((char*) buff,
  786. (uint) (int10_to_str((int) from,buff, -10)-buff));
  787. }
  790. bool Protocol_simple::store_short(longlong from)
  791. {
  792. #ifndef DEBUG_OFF
  793.   DBUG_ASSERT(field_types == 0 ||
  794.       field_types[field_pos] == MYSQL_TYPE_SHORT);
  795.   field_pos++;
  796. #endif
  797.   char buff[20];
  798.   return net_store_data((char*) buff,
  799. (uint) (int10_to_str((int) from,buff, -10)-buff));
  800. }
  803. bool Protocol_simple::store_long(longlong from)
  804. {
  805. #ifndef DEBUG_OFF
  806.   DBUG_ASSERT(field_types == 0 ||
  807.               field_types[field_pos] == MYSQL_TYPE_INT24 ||
  808.               field_types[field_pos] == MYSQL_TYPE_LONG);
  809.   field_pos++;
  810. #endif
  811.   char buff[20];
  812.   return net_store_data((char*) buff,
  813. (uint) (int10_to_str((long int)from,buff, (from <0)?-10:10)-buff));
  814. }
  817. bool Protocol_simple::store_longlong(longlong from, bool unsigned_flag)
  818. {
  819. #ifndef DEBUG_OFF
  820.   DBUG_ASSERT(field_types == 0 ||
  821.       field_types[field_pos] == MYSQL_TYPE_LONGLONG);
  822.   field_pos++;
  823. #endif
  824.   char buff[22];
  825.   return net_store_data((char*) buff,
  826. (uint) (longlong10_to_str(from,buff,
  827.   unsigned_flag ? 10 : -10)-
  828. buff));
  829. }
  832. bool Protocol_simple::store(float from, uint32 decimals, String *buffer)
  833. {
  834. #ifndef DEBUG_OFF
  835.   DBUG_ASSERT(field_types == 0 ||
  836.       field_types[field_pos] == MYSQL_TYPE_FLOAT);
  837.   field_pos++;
  838. #endif
  839.   buffer->set((double) from, decimals, thd->charset());
  840.   return net_store_data((char*) buffer->ptr(), buffer->length());
  841. }
  844. bool Protocol_simple::store(double from, uint32 decimals, String *buffer)
  845. {
  846. #ifndef DEBUG_OFF
  847.   DBUG_ASSERT(field_types == 0 ||
  848.       field_types[field_pos] == MYSQL_TYPE_DOUBLE);
  849.   field_pos++;
  850. #endif
  851.   buffer->set(from, decimals, thd->charset());
  852.   return net_store_data((char*) buffer->ptr(), buffer->length());
  853. }
  856. bool Protocol_simple::store(Field *field)
  857. {
  858.   if (field->is_null())
  859.     return store_null();
  860. #ifndef DEBUG_OFF
  861.   field_pos++;
  862. #endif
  863.   char buff[MAX_FIELD_WIDTH];
  864.   String str(buff,sizeof(buff), &my_charset_bin);
  865.   CHARSET_INFO *tocs= this->thd->variables.character_set_results;
  867.   field->val_str(&str);
  868.   return store_string_aux(str.ptr(), str.length(), str.charset(), tocs);
  869. }
  872. /*
  873.    TODO:
  874.         Second_part format ("%06") needs to change when 
  875.         we support 0-6 decimals for time.
  876. */
  879. bool Protocol_simple::store(TIME *tm)
  880. {
  881. #ifndef DEBUG_OFF
  882.   DBUG_ASSERT(field_types == 0 ||
  883.       field_types[field_pos] == MYSQL_TYPE_DATETIME ||
  884.       field_types[field_pos] == MYSQL_TYPE_TIMESTAMP);
  885.   field_pos++;
  886. #endif
  887.   char buff[40];
  888.   uint length;
  889.   length= my_sprintf(buff,(buff, "%04d-%02d-%02d %02d:%02d:%02d",
  890.    (int) tm->year,
  891.    (int) tm->month,
  892.    (int) tm->day,
  893.    (int) tm->hour,
  894.    (int) tm->minute,
  895.    (int) tm->second));
  896.   if (tm->second_part)
  897.     length+= my_sprintf(buff+length,(buff+length, ".%06d", (int)tm->second_part));
  898.   return net_store_data((char*) buff, length);
  899. }
  902. bool Protocol_simple::store_date(TIME *tm)
  903. {
  904. #ifndef DEBUG_OFF
  905.   DBUG_ASSERT(field_types == 0 ||
  906.       field_types[field_pos] == MYSQL_TYPE_DATE);
  907.   field_pos++;
  908. #endif
  909.   char buff[MAX_DATE_STRING_REP_LENGTH];
  910.   int length= my_date_to_str(tm, buff);
  911.   return net_store_data(buff, (uint) length);
  912. }
  915. /*
  916.    TODO:
  917.         Second_part format ("%06") needs to change when 
  918.         we support 0-6 decimals for time.
  919. */
  921. bool Protocol_simple::store_time(TIME *tm)
  922. {
  923. #ifndef DEBUG_OFF
  924.   DBUG_ASSERT(field_types == 0 ||
  925.       field_types[field_pos] == MYSQL_TYPE_TIME);
  926.   field_pos++;
  927. #endif
  928.   char buff[40];
  929.   uint length;
  930.   uint day= (tm->year || tm->month) ? 0 : tm->day;
  931.   length= my_sprintf(buff,(buff, "%s%02ld:%02d:%02d",
  932.    tm->neg ? "-" : "",
  933.    (long) day*24L+(long) tm->hour,
  934.    (int) tm->minute,
  935.    (int) tm->second));
  936.   if (tm->second_part)
  937.     length+= my_sprintf(buff+length,(buff+length, ".%06d", (int)tm->second_part));
  938.   return net_store_data((char*) buff, length);
  939. }
  942. /****************************************************************************
  943.   Functions to handle the binary protocol used with prepared statements
  945.   Data format:
  947.    [ok:1]                            reserved ok packet
  948.    [null_field:(field_count+7+2)/8]  reserved to send null data. The size is
  949.                                      calculated using:
  950.                                      bit_fields= (field_count+7+2)/8; 
  951.                                      2 bits are reserved for identifying type
  952.      of package.
  953.    [[length]data]                    data field (the length applies only for 
  954.                                      string/binary/time/timestamp fields and 
  955.                                      rest of them are not sent as they have 
  956.                                      the default length that client understands
  957.                                      based on the field type
  958.    [..]..[[length]data]              data
  959. ****************************************************************************/
  961. bool Protocol_prep::prepare_for_send(List<Item> *item_list)
  962. {
  963.   Protocol::prepare_for_send(item_list);
  964.   bit_fields= (field_count+9)/8;
  965.   if (packet->alloc(bit_fields+1))
  966.     return 1;
  967.   /* prepare_for_resend will be called after this one */
  968.   return 0;
  969. }
  972. void Protocol_prep::prepare_for_resend()
  973. {
  974.   packet->length(bit_fields+1);
  975.   bzero((char*) packet->ptr(), 1+bit_fields);
  976.   field_pos=0;
  977. }
  980. bool Protocol_prep::store(const char *from, uint length, CHARSET_INFO *fromcs)
  981. {
  982.   CHARSET_INFO *tocs= thd->variables.character_set_results;
  983. #ifndef DEBUG_OFF
  984.   DBUG_ASSERT(field_types == 0 ||
  985.       field_types[field_pos] == MYSQL_TYPE_DECIMAL ||
  986.       (field_types[field_pos] >= MYSQL_TYPE_ENUM &&
  987.        field_types[field_pos] <= MYSQL_TYPE_GEOMETRY));
  988. #endif
  989.   field_pos++;
  990.   return store_string_aux(from, length, fromcs, tocs);
  991. }
  993. bool Protocol_prep::store(const char *from,uint length,
  994.   CHARSET_INFO *fromcs, CHARSET_INFO *tocs)
  995. {
  996. #ifndef DEBUG_OFF
  997.   DBUG_ASSERT(field_types == 0 ||
  998.       field_types[field_pos] == MYSQL_TYPE_DECIMAL ||
  999.       (field_types[field_pos] >= MYSQL_TYPE_ENUM &&
  1000.        field_types[field_pos] <= MYSQL_TYPE_GEOMETRY));
  1001. #endif
  1002.   field_pos++;
  1003.   return store_string_aux(from, length, fromcs, tocs);
  1004. }
  1006. bool Protocol_prep::store_null()
  1007. {
  1008.   uint offset= (field_pos+2)/8+1, bit= (1 << ((field_pos+2) & 7));
  1009.   /* Room for this as it's allocated in prepare_for_send */
  1010.   char *to= (char*) packet->ptr()+offset;
  1011.   *to= (char) ((uchar) *to | (uchar) bit);
  1012.   field_pos++;
  1013.   return 0;
  1014. }
  1017. bool Protocol_prep::store_tiny(longlong from)
  1018. {
  1019. #ifndef DEBUG_OFF
  1020.   DBUG_ASSERT(field_types == 0 ||
  1021.       field_types[field_pos] == MYSQL_TYPE_TINY);
  1022. #endif
  1023.   char buff[1];
  1024.   field_pos++;
  1025.   buff[0]= (uchar) from;
  1026.   return packet->append(buff, sizeof(buff), PACKET_BUFFER_EXTRA_ALLOC);
  1027. }
  1030. bool Protocol_prep::store_short(longlong from)
  1031. {
  1032. #ifndef DEBUG_OFF
  1033.   DBUG_ASSERT(field_types == 0 ||
  1034.         field_types[field_pos] == MYSQL_TYPE_SHORT ||
  1035.         field_types[field_pos] == MYSQL_TYPE_YEAR);
  1036. #endif
  1037.   field_pos++;
  1038.   char *to= packet->prep_append(2, PACKET_BUFFER_EXTRA_ALLOC);
  1039.   if (!to)
  1040.     return 1;
  1041.   int2store(to, (int) from);
  1042.   return 0;
  1043. }
  1046. bool Protocol_prep::store_long(longlong from)
  1047. {
  1048. #ifndef DEBUG_OFF
  1049.   DBUG_ASSERT(field_types == 0 ||
  1050.       field_types[field_pos] == MYSQL_TYPE_INT24 ||
  1051.       field_types[field_pos] == MYSQL_TYPE_LONG);
  1052. #endif
  1053.   field_pos++;
  1054.   char *to= packet->prep_append(4, PACKET_BUFFER_EXTRA_ALLOC);
  1055.   if (!to)
  1056.     return 1;
  1057.   int4store(to, from);
  1058.   return 0;
  1059. }
  1062. bool Protocol_prep::store_longlong(longlong from, bool unsigned_flag)
  1063. {
  1064. #ifndef DEBUG_OFF
  1065.   DBUG_ASSERT(field_types == 0 ||
  1066.       field_types[field_pos] == MYSQL_TYPE_LONGLONG);
  1067. #endif
  1068.   field_pos++;
  1069.   char *to= packet->prep_append(8, PACKET_BUFFER_EXTRA_ALLOC);
  1070.   if (!to)
  1071.     return 1;
  1072.   int8store(to, from);
  1073.   return 0;
  1074. }
  1077. bool Protocol_prep::store(float from, uint32 decimals, String *buffer)
  1078. {
  1079. #ifndef DEBUG_OFF
  1080.   DBUG_ASSERT(field_types == 0 ||
  1081.       field_types[field_pos] == MYSQL_TYPE_FLOAT);
  1082. #endif
  1083.   field_pos++;
  1084.   char *to= packet->prep_append(4, PACKET_BUFFER_EXTRA_ALLOC);
  1085.   if (!to)
  1086.     return 1;
  1087.   float4store(to, from);
  1088.   return 0;
  1089. }
  1092. bool Protocol_prep::store(double from, uint32 decimals, String *buffer)
  1093. {
  1094. #ifndef DEBUG_OFF
  1095.   DBUG_ASSERT(field_types == 0 ||
  1096.       field_types[field_pos] == MYSQL_TYPE_DOUBLE);
  1097. #endif
  1098.   field_pos++;
  1099.   char *to= packet->prep_append(8, PACKET_BUFFER_EXTRA_ALLOC);
  1100.   if (!to)
  1101.     return 1;
  1102.   float8store(to, from);
  1103.   return 0;
  1104. }
  1107. bool Protocol_prep::store(Field *field)
  1108. {
  1109.   /*
  1110.     We should not increment field_pos here as send_binary() will call another
  1111.     protocol function to do this for us
  1112.   */
  1113.   if (field->is_null())
  1114.     return store_null();
  1115.   return field->send_binary(this);
  1116. }
  1119. bool Protocol_prep::store(TIME *tm)
  1120. {
  1121. #ifndef DEBUG_OFF
  1122.   DBUG_ASSERT(field_types == 0 ||
  1123.       field_types[field_pos] == MYSQL_TYPE_DATETIME ||
  1124.       field_types[field_pos] == MYSQL_TYPE_DATE ||
  1125.       field_types[field_pos] == MYSQL_TYPE_TIMESTAMP);
  1126. #endif
  1127.   char buff[12],*pos;
  1128.   uint length;
  1129.   field_pos++;
  1130.   pos= buff+1;
  1132.   int2store(pos, tm->year);
  1133.   pos[2]= (uchar) tm->month;
  1134.   pos[3]= (uchar) tm->day;
  1135.   pos[4]= (uchar) tm->hour;
  1136.   pos[5]= (uchar) tm->minute;
  1137.   pos[6]= (uchar) tm->second;
  1138.   int4store(pos+7, tm->second_part);
  1139.   if (tm->second_part)
  1140.     length=11;
  1141.   else if (tm->hour || tm->minute || tm->second)
  1142.     length=7;
  1143.   else if (tm->year || tm->month || tm->day)
  1144.     length=4;
  1145.   else
  1146.     length=0;
  1147.   buff[0]=(char) length; // Length is stored first
  1148.   return packet->append(buff, length+1, PACKET_BUFFER_EXTRA_ALLOC);
  1149. }
  1151. bool Protocol_prep::store_date(TIME *tm)
  1152. {
  1153.   tm->hour= tm->minute= tm->second=0;
  1154.   tm->second_part= 0;
  1155.   return Protocol_prep::store(tm);
  1156. }
  1159. bool Protocol_prep::store_time(TIME *tm)
  1160. {
  1161. #ifndef DEBUG_OFF
  1162.   DBUG_ASSERT(field_types == 0 ||
  1163.       field_types[field_pos] == MYSQL_TYPE_TIME);
  1164. #endif
  1165.   char buff[13], *pos;
  1166.   uint length;
  1167.   field_pos++;
  1168.   pos= buff+1;
  1169.   pos[0]= tm->neg ? 1 : 0;
  1170.   if (tm->hour >= 24)
  1171.   {
  1172.     /* Fix if we come from Item::send */
  1173.     uint days= tm->hour/24;
  1174.     tm->hour-= days*24;
  1175.     tm->day+= days;
  1176.   }
  1177.   int4store(pos+1, tm->day);
  1178.   pos[5]= (uchar) tm->hour;
  1179.   pos[6]= (uchar) tm->minute;
  1180.   pos[7]= (uchar) tm->second;
  1181.   int4store(pos+8, tm->second_part);
  1182.   if (tm->second_part)
  1183.     length=12;
  1184.   else if (tm->hour || tm->minute || tm->second || tm->day)
  1185.     length=8;
  1186.   else
  1187.     length=0;
  1188.   buff[0]=(char) length; // Length is stored first
  1189.   return packet->append(buff, length+1, PACKET_BUFFER_EXTRA_ALLOC);
  1190. }
  1192. #ifdef EMBEDDED_LIBRARY
  1193. /* Should be removed when we define the Protocol_cursor's future */
  1194. bool Protocol_cursor::write()
  1195. {
  1196.   return Protocol_simple::write();
  1197. }
  1198. #endif