lib_sql.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:21k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*
  2.  * Copyright (c)  2000
  3.  * SWsoft  company
  4.  *
  5.  * This material is provided "as is", with absolutely no warranty expressed
  6.  * or implied. Any use is at your own risk.
  7.  *
  8.  * Permission to use or copy this software for any purpose is hereby granted 
  9.  * without fee, provided the above notices are retained on all copies.
  10.  * Permission to modify the code and to distribute modified code is granted,
  11.  * provided the above notices are retained, and a notice that the code was
  12.  * modified is included with the above copyright notice.
  13.  *
  14.   This code was modified by the MySQL team
  15. */
  16. /*
  17.   The following is needed to not cause conflicts when we include mysqld.cc
  18. */
  19. #define main main1
  20. #define mysql_unix_port mysql_inix_port1
  21. #define mysql_port mysql_port1
  22. extern "C"
  23. {
  24.   extern unsigned long max_allowed_packet, net_buffer_length;
  25. }
  26. static int fake_argc= 1;
  27. static char *fake_argv[]= {(char *)"", 0};
  28. static const char *fake_groups[] = { "server", "embedded", 0 };
  29. #if defined (__WIN__)
  30. #include "../sql/mysqld.cpp"
  31. #else
  32. #include "../sql/mysqld.cc"
  33. #endif
  34. int check_user(THD *thd, enum enum_server_command command, 
  35.        const char *passwd, uint passwd_len, const char *db,
  36.        bool check_count);
  37. C_MODE_START
  38. #include <mysql.h>
  39. #undef ER
  40. #include "errmsg.h"
  41. #include <sql_common.h>
  42. void embedded_get_error(MYSQL *mysql)
  43. {
  44.   THD *thd=(THD *) mysql->thd;
  45.   NET *net= &mysql->net;
  46.   if ((net->last_errno= thd->net.last_errno))
  47.   {
  48.     memcpy(net->last_error, thd->net.last_error, sizeof(net->last_error));
  49.     memcpy(net->sqlstate, thd->net.sqlstate, sizeof(net->sqlstate));
  50.   }
  51.   else
  52.   {
  53.     net->last_error[0]= 0;
  54.     strmov(net->sqlstate, not_error_sqlstate);
  55.   }
  56. }
  57. static my_bool
  58. emb_advanced_command(MYSQL *mysql, enum enum_server_command command,
  59.      const char *header, ulong header_length,
  60.      const char *arg, ulong arg_length, my_bool skip_check)
  61. {
  62.   my_bool result= 1;
  63.   THD *thd=(THD *) mysql->thd;
  64.   NET *net= &mysql->net;
  65.   if (thd->data)
  66.   {
  67.     free_rows(thd->data);
  68.     thd->data= 0;
  69.   }
  70.   /* Check that we are calling the client functions in right order */
  71.   if (mysql->status != MYSQL_STATUS_READY)
  72.   {
  73.     strmov(net->last_error,
  74.    ER(net->last_errno=CR_COMMANDS_OUT_OF_SYNC));
  75.     return 1;
  76.   }
  77.   /* Clear result variables */
  78.   thd->clear_error();
  79.   mysql->affected_rows= ~(my_ulonglong) 0;
  80.   mysql->field_count= 0;
  81.   net->last_errno= 0;
  82.   thd->store_globals(); // Fix if more than one connect
  83.   /* 
  84.      We have to call free_old_query before we start to fill mysql->fields 
  85.      for new query. In the case of embedded server we collect field data
  86.      during query execution (not during data retrieval as it is in remote
  87.      client). So we have to call free_old_query here
  88.   */
  89.   free_old_query(mysql);
  90.   thd->extra_length= arg_length;
  91.   thd->extra_data= (char *)arg;
  92.   if (header)
  93.   {
  94.     arg= header;
  95.     arg_length= header_length;
  96.   }
  97.   result= dispatch_command(command, thd, (char *) arg, arg_length + 1);
  98.   if (!skip_check)
  99.     result= thd->net.last_errno ? -1 : 0;
  100.   /*
  101.     If mysql->field_count is set it means the parsing of the query was OK
  102.     and metadata was returned (see Protocol::send_fields).
  103.     In this case we postpone the error to be returned in mysql_stmt_store_result
  104.     (see emb_read_rows) to behave just as standalone server.
  105.   */
  106.   if (!mysql->field_count)
  107.     embedded_get_error(mysql);
  108.   mysql->server_status= thd->server_status;
  109.   mysql->warning_count= ((THD*)mysql->thd)->total_warn_count;
  110.   return result;
  111. }
  112. static void emb_flush_use_result(MYSQL *mysql)
  113. {
  114.   MYSQL_DATA *data= ((THD*)(mysql->thd))->data;
  115.   if (data)
  116.   {
  117.     free_rows(data);
  118.     ((THD*)(mysql->thd))->data= NULL;
  119.   }
  120. }
  121. static MYSQL_DATA *
  122. emb_read_rows(MYSQL *mysql, MYSQL_FIELD *mysql_fields __attribute__((unused)),
  123.       unsigned int fields __attribute__((unused)))
  124. {
  125.   MYSQL_DATA *result= ((THD*)mysql->thd)->data;
  126.   embedded_get_error(mysql);
  127.   if (mysql->net.last_errno)
  128.     return NULL;
  129.   if (!result)
  130.   {
  131.     if (!(result=(MYSQL_DATA*) my_malloc(sizeof(MYSQL_DATA),
  132.  MYF(MY_WME | MY_ZEROFILL))))
  133.     {
  134.       NET *net = &mysql->net;
  135.       net->last_errno=CR_OUT_OF_MEMORY;
  136.       strmov(net->sqlstate, unknown_sqlstate);
  137.       strmov(net->last_error,ER(net->last_errno));
  138.       return NULL;
  139.     }    
  140.     return result;
  141.   }
  142.   *result->prev_ptr= NULL;
  143.   ((THD*)mysql->thd)->data= NULL;
  144.   return result;
  145. }
  146. static MYSQL_FIELD *emb_list_fields(MYSQL *mysql)
  147. {
  148.   return mysql->fields;
  149. }
  150. static my_bool emb_read_prepare_result(MYSQL *mysql, MYSQL_STMT *stmt)
  151. {
  152.   THD *thd= (THD*)mysql->thd;
  153.   if (mysql->net.last_errno)
  154.     return 1;
  155.   stmt->stmt_id= thd->client_stmt_id;
  156.   stmt->param_count= thd->client_param_count;
  157.   stmt->field_count= mysql->field_count;
  158.   if (stmt->field_count != 0)
  159.   {
  160.     if (!(mysql->server_status & SERVER_STATUS_AUTOCOMMIT))
  161.       mysql->server_status|= SERVER_STATUS_IN_TRANS;
  162.     stmt->fields= mysql->fields;
  163.     stmt->mem_root= mysql->field_alloc;
  164.     mysql->fields= NULL;
  165.   }
  166.   return 0;
  167. }
  168. /**************************************************************************
  169.   Get column lengths of the current row
  170.   If one uses mysql_use_result, res->lengths contains the length information,
  171.   else the lengths are calculated from the offset between pointers.
  172. **************************************************************************/
  173. static void emb_fetch_lengths(ulong *to, MYSQL_ROW column,
  174.       unsigned int field_count)
  175.   MYSQL_ROW end;
  176.   for (end=column + field_count; column != end ; column++,to++)
  177.     *to= *column ? *(uint *)((*column) - sizeof(uint)) : 0;
  178. }
  179. static my_bool emb_mysql_read_query_result(MYSQL *mysql)
  180. {
  181.   if (mysql->net.last_errno)
  182.     return -1;
  183.   if (mysql->field_count)
  184.     mysql->status=MYSQL_STATUS_GET_RESULT;
  185.   return 0;
  186. }
  187. static int emb_stmt_execute(MYSQL_STMT *stmt)
  188. {
  189.   DBUG_ENTER("emb_stmt_execute");
  190.   char header[4];
  191.   int4store(header, stmt->stmt_id);
  192.   THD *thd= (THD*)stmt->mysql->thd;
  193.   thd->client_param_count= stmt->param_count;
  194.   thd->client_params= stmt->params;
  195.   if (emb_advanced_command(stmt->mysql, COM_EXECUTE,0,0,
  196.                            header, sizeof(header), 1) ||
  197.       emb_mysql_read_query_result(stmt->mysql))
  198.   {
  199.     NET *net= &stmt->mysql->net;
  200.     set_stmt_errmsg(stmt, net->last_error, net->last_errno, net->sqlstate);
  201.     DBUG_RETURN(1);
  202.   }
  203.   stmt->affected_rows= stmt->mysql->affected_rows;
  204.   stmt->insert_id= stmt->mysql->insert_id;
  205.   DBUG_RETURN(0);
  206. }
  207. int emb_read_binary_rows(MYSQL_STMT *stmt)
  208. {
  209.   MYSQL_DATA *data;
  210.   if (!(data= emb_read_rows(stmt->mysql, 0, 0)))
  211.     return 1;
  212.   stmt->result= *data;
  213.   my_free((char *) data, MYF(0));
  214.   return 0;
  215. }
  216. int emb_unbuffered_fetch(MYSQL *mysql, char **row)
  217. {
  218.   MYSQL_DATA *data= ((THD*)mysql->thd)->data;
  219.   embedded_get_error(mysql);
  220.   if (mysql->net.last_errno)
  221.     return mysql->net.last_errno;
  222.   if (!data || !data->data)
  223.   {
  224.     *row= NULL;
  225.     if (data)
  226.     {
  227.       free_rows(data);
  228.       ((THD*)mysql->thd)->data= NULL;
  229.     }
  230.   }
  231.   else
  232.   {
  233.     *row= (char *)data->data->data;
  234.     data->data= data->data->next;
  235.   }
  236.   return 0;
  237. }
  238. static void emb_free_embedded_thd(MYSQL *mysql)
  239. {
  240.   THD *thd= (THD*)mysql->thd;
  241.   if (thd->data)
  242.     free_rows(thd->data);
  243.   thread_count--;
  244.   delete thd;
  245.   mysql->thd=0;
  246. }
  247. static const char * emb_read_statistics(MYSQL *mysql)
  248. {
  249.   THD *thd= (THD*)mysql->thd;
  250.   return thd->net.last_error;
  251. }
  252. static MYSQL_RES * emb_mysql_store_result(MYSQL *mysql)
  253. {
  254.   return mysql_store_result(mysql);
  255. }
  256. my_bool emb_next_result(MYSQL *mysql)
  257. {
  258.   THD *thd= (THD*)mysql->thd;
  259.   DBUG_ENTER("emb_next_result");
  260.   if (emb_advanced_command(mysql, COM_QUERY,0,0,
  261.    thd->query_rest.ptr(),thd->query_rest.length(),1) ||
  262.       emb_mysql_read_query_result(mysql))
  263.     DBUG_RETURN(1);
  264.   DBUG_RETURN(0); /* No more results */
  265. }
  266. int emb_read_change_user_result(MYSQL *mysql, 
  267. char *buff __attribute__((unused)),
  268. const char *passwd __attribute__((unused)))
  269. {
  270.   return mysql_errno(mysql);
  271. }
  272. MYSQL_METHODS embedded_methods= 
  273. {
  274.   emb_mysql_read_query_result,
  275.   emb_advanced_command,
  276.   emb_read_rows,
  277.   emb_mysql_store_result,
  278.   emb_fetch_lengths, 
  279.   emb_flush_use_result,
  280.   emb_list_fields,
  281.   emb_read_prepare_result,
  282.   emb_stmt_execute,
  283.   emb_read_binary_rows,
  284.   emb_unbuffered_fetch,
  285.   emb_free_embedded_thd,
  286.   emb_read_statistics,
  287.   emb_next_result,
  288.   emb_read_change_user_result
  289. };
  290. C_MODE_END
  291. void THD::clear_error()
  292. {
  293.   net.last_error[0]= 0;
  294.   net.last_errno= 0;
  295.   net.report_error= 0;
  296. }
  297. /*
  298.   Make a copy of array and the strings array points to
  299. */
  300. char **copy_arguments(int argc, char **argv)
  301. {
  302.   uint length= 0;
  303.   char **from, **res, **end= argv+argc;
  304.   for (from=argv ; from != end ; from++)
  305.     length+= strlen(*from);
  306.   if ((res= (char**) my_malloc(sizeof(argv)*(argc+1)+length+argc,
  307.        MYF(MY_WME))))
  308.   {
  309.     char **to= res, *to_str= (char*) (res+argc+1);
  310.     for (from=argv ; from != end ;)
  311.     {
  312.       *to++= to_str;
  313.       to_str= strmov(to_str, *from++)+1;
  314.     }
  315.     *to= 0; // Last ptr should be null
  316.   }
  317.   return res;
  318. }
  319. extern "C"
  320. {
  321. char ** copy_arguments_ptr= 0; 
  322. int init_embedded_server(int argc, char **argv, char **groups)
  323. {
  324.   /*
  325.     This mess is to allow people to call the init function without
  326.     having to mess with a fake argv
  327.    */
  328.   int *argcp;
  329.   char ***argvp;
  330.   int fake_argc = 1;
  331.   char *fake_argv[] = { (char *)"", 0 };
  332.   const char *fake_groups[] = { "server", "embedded", 0 };
  333.   my_bool acl_error;
  334.   if (argc)
  335.   {
  336.     argcp= &argc;
  337.     argvp= (char***) &argv;
  338.   }
  339.   else
  340.   {
  341.     argcp= &fake_argc;
  342.     argvp= (char ***) &fake_argv;
  343.   }
  344.   if (!groups)
  345.     groups= (char**) fake_groups;
  346.   my_progname= (char *)"mysql_embedded";
  347.   if (init_common_variables("my", *argcp, *argvp, (const char **)groups))
  348.   {
  349.     mysql_server_end();
  350.     return 1;
  351.   }
  352.     
  353.   /* Get default temporary directory */
  354.   opt_mysql_tmpdir=getenv("TMPDIR"); /* Use this if possible */
  355. #if defined( __WIN__) || defined(OS2)
  356.   if (!opt_mysql_tmpdir)
  357.     opt_mysql_tmpdir=getenv("TEMP");
  358.   if (!opt_mysql_tmpdir)
  359.     opt_mysql_tmpdir=getenv("TMP");
  360. #endif
  361.   if (!opt_mysql_tmpdir || !opt_mysql_tmpdir[0])
  362.     opt_mysql_tmpdir=(char*) P_tmpdir; /* purecov: inspected */
  363.   umask(((~my_umask) & 0666));
  364.   if (init_server_components())
  365.   {
  366.     mysql_server_end();
  367.     return 1;
  368.   }
  369.   error_handler_hook = my_message_sql;
  370.   acl_error= 0;
  371. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  372.   if (!(acl_error= acl_init(opt_noacl)) &&
  373.       !opt_noacl)
  374.     (void) grant_init();
  375. #endif
  376.   if (acl_error || my_tz_init((THD *)0, default_tz_name, opt_bootstrap))
  377.   {
  378.     mysql_server_end();
  379.     return 1;
  380.   }
  381.   init_max_user_conn();
  382.   init_update_queries();
  383. #ifdef HAVE_DLOPEN
  384. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  385.   if (!opt_noacl)
  386. #endif
  387.     udf_init();
  388. #endif
  389.   (void) thr_setconcurrency(concurrency); // 10 by default
  390.   if (
  391. #ifdef HAVE_BERKELEY_DB
  392.       (have_berkeley_db == SHOW_OPTION_YES) ||
  393. #endif
  394.       (flush_time && flush_time != ~(ulong) 0L))
  395.   {
  396.     pthread_t hThread;
  397.     if (pthread_create(&hThread,&connection_attrib,handle_manager,0))
  398.       sql_print_error("Warning: Can't create thread to manage maintenance");
  399.   }
  400.   if (opt_init_file)
  401.   {
  402.     if (read_init_file(opt_init_file))
  403.     {
  404.       mysql_server_end();
  405.       return 1;
  406.     }
  407.   }
  408.   return 0;
  409. }
  410. void end_embedded_server()
  411. {
  412.   my_free((char*) copy_arguments_ptr, MYF(MY_ALLOW_ZERO_PTR));
  413.   copy_arguments_ptr=0;
  414.   clean_up(0);
  415. }
  416. } /* extern "C" */
  417. C_MODE_START
  418. void init_embedded_mysql(MYSQL *mysql, int client_flag, char *db)
  419. {
  420.   THD *thd = (THD *)mysql->thd;
  421.   thd->mysql= mysql;
  422.   mysql->server_version= server_version;
  423. }
  424. void *create_embedded_thd(int client_flag, char *db)
  425. {
  426.   THD * thd= new THD;
  427.   thd->thread_id= thread_id++;
  428.   if (thd->store_globals())
  429.   {
  430.     fprintf(stderr,"store_globals failed.n");
  431.     goto err;
  432.   }
  433.   thd->mysys_var= my_thread_var;
  434.   thd->dbug_thread_id= my_thread_id();
  435.   thd->thread_stack= (char*) &thd;
  436. /* TODO - add init_connect command execution */
  437.   if (thd->variables.max_join_size == HA_POS_ERROR)
  438.     thd->options |= OPTION_BIG_SELECTS;
  439.   thd->proc_info=0; // Remove 'login'
  440.   thd->command=COM_SLEEP;
  441.   thd->version=refresh_version;
  442.   thd->set_time();
  443.   thd->init_for_queries();
  444.   thd->client_capabilities= client_flag;
  445.   thd->db= db;
  446.   thd->db_length= db ? strip_sp(db) : 0;
  447. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  448.   thd->db_access= DB_ACLS;
  449.   thd->master_access= ~NO_ACCESS;
  450. #endif
  451.   thd->net.query_cache_query= 0;
  452.   thd->data= 0;
  453.   thread_count++;
  454.   return thd;
  455. err:
  456.   delete(thd);
  457.   return NULL;
  458. }
  459. #ifdef NO_EMBEDDED_ACCESS_CHECKS
  460. int check_embedded_connection(MYSQL *mysql)
  461. {
  462.   THD *thd= (THD*)mysql->thd;
  463.   thd->host= (char*)my_localhost;
  464.   thd->host_or_ip= thd->host;
  465.   thd->user= my_strdup(mysql->user, MYF(0));
  466.   thd->priv_user= thd->user;
  467.   return check_user(thd, COM_CONNECT, NULL, 0, thd->db, true);
  468. }
  469. #else
  470. int check_embedded_connection(MYSQL *mysql)
  471. {
  472.   THD *thd= (THD*)mysql->thd;
  473.   int result;
  474.   char scramble_buff[SCRAMBLE_LENGTH];
  475.   int passwd_len;
  476.   if (mysql->options.client_ip)
  477.   {
  478.     thd->host= my_strdup(mysql->options.client_ip, MYF(0));
  479.     thd->ip= my_strdup(thd->host, MYF(0));
  480.   }
  481.   else
  482.     thd->host= (char*)my_localhost;
  483.   thd->host_or_ip= thd->host;
  484.   if (acl_check_host(thd->host,thd->ip))
  485.   {
  486.     result= ER_HOST_NOT_PRIVILEGED;
  487.     goto err;
  488.   }
  489.   thd->user= my_strdup(mysql->user, MYF(0));
  490.   if (mysql->passwd && mysql->passwd[0])
  491.   {
  492.     memset(thd->scramble, 55, SCRAMBLE_LENGTH); // dummy scramble
  493.     thd->scramble[SCRAMBLE_LENGTH]= 0;
  494.     scramble(scramble_buff, thd->scramble, mysql->passwd);
  495.     passwd_len= SCRAMBLE_LENGTH;
  496.   }
  497.   else
  498.     passwd_len= 0;
  499.   if((result= check_user(thd, COM_CONNECT, 
  500.  scramble_buff, passwd_len, thd->db, true)))
  501.      goto err;
  502.   return 0;
  503. err:
  504.   {
  505.     NET *net= &mysql->net;
  506.     memcpy(net->last_error, thd->net.last_error, sizeof(net->last_error));
  507.     memcpy(net->sqlstate, thd->net.sqlstate, sizeof(net->sqlstate));
  508.   }
  509.   return result;
  510. }
  511. #endif
  512. C_MODE_END
  513. static char *dup_str_aux(MEM_ROOT *root, const char *from, uint length,
  514.  CHARSET_INFO *fromcs, CHARSET_INFO *tocs)
  515. {
  516.   uint32 dummy32;
  517.   uint dummy_err;
  518.   char *result;
  519.   /* 'tocs' is set 0 when client issues SET character_set_results=NULL */
  520.   if (tocs && String::needs_conversion(0, fromcs, tocs, &dummy32))
  521.   {
  522.     uint new_len= (tocs->mbmaxlen * length) / fromcs->mbminlen + 1;
  523.     result= (char *)alloc_root(root, new_len);
  524.     length= copy_and_convert(result, new_len,
  525.                              tocs, from, length, fromcs, &dummy_err);
  526.   }
  527.   else
  528.   {
  529.     result= (char *)alloc_root(root, length + 1);
  530.     memcpy(result, from, length);
  531.   }
  532.   result[length]= 0;
  533.   return result;
  534. }
  535. bool Protocol::send_fields(List<Item> *list, uint flag)
  536. {
  537.   List_iterator_fast<Item> it(*list);
  538.   Item                     *item;
  539.   MYSQL_FIELD              *client_field;
  540.   MYSQL                    *mysql= thd->mysql;
  541.   MEM_ROOT                 *field_alloc;
  542.   CHARSET_INFO             *thd_cs= thd->variables.character_set_results;
  543.   CHARSET_INFO             *cs= system_charset_info;
  544.   
  545.   DBUG_ENTER("send_fields");
  546.   if (!mysql)            // bootstrap file handling
  547.     DBUG_RETURN(0);
  548.   field_count= list->elements;
  549.   field_alloc= &mysql->field_alloc;
  550.   if (!(client_field= thd->mysql->fields= 
  551. (MYSQL_FIELD *)alloc_root(field_alloc, 
  552.   sizeof(MYSQL_FIELD) * field_count)))
  553.     goto err;
  554.   while ((item= it++))
  555.   {
  556.     Send_field server_field;
  557.     item->make_field(&server_field);
  558.     client_field->db= dup_str_aux(field_alloc, server_field.db_name,
  559.                                   strlen(server_field.db_name), cs, thd_cs);
  560.     client_field->table= dup_str_aux(field_alloc, server_field.table_name,
  561.                                      strlen(server_field.table_name), cs, thd_cs);
  562.     client_field->name= dup_str_aux(field_alloc, server_field.col_name,
  563.                                     strlen(server_field.col_name), cs, thd_cs);
  564.     client_field->org_table= dup_str_aux(field_alloc, server_field.org_table_name,
  565.                                          strlen(server_field.org_table_name), cs, thd_cs);
  566.     client_field->org_name= dup_str_aux(field_alloc, server_field.org_col_name,
  567.                                         strlen(server_field.org_col_name), cs, thd_cs);
  568.     if (item->collation.collation == &my_charset_bin || thd_cs == NULL)
  569.     {
  570.       /* No conversion */
  571.       client_field->charsetnr= server_field.charsetnr;
  572.       client_field->length= server_field.length;
  573.     }
  574.     else
  575.     {
  576.       /* With conversion */
  577.       client_field->charsetnr= thd_cs->number;
  578.       uint char_len= server_field.length / item->collation.collation->mbmaxlen;
  579.       client_field->length= char_len * thd_cs->mbmaxlen;
  580.     }
  581.     client_field->type=   server_field.type;
  582.     client_field->flags= server_field.flags;
  583.     client_field->decimals= server_field.decimals;
  584.     client_field->db_length= strlen(client_field->db);
  585.     client_field->table_length= strlen(client_field->table);
  586.     client_field->name_length= strlen(client_field->name);
  587.     client_field->org_name_length= strlen(client_field->org_name);
  588.     client_field->org_table_length= strlen(client_field->org_table);
  589.     client_field->catalog= dup_str_aux(field_alloc, "def", 3, cs, thd_cs);
  590.     client_field->catalog_length= 3;
  591.     if (INTERNAL_NUM_FIELD(client_field))
  592.       client_field->flags|= NUM_FLAG;
  593.     if (flag & 2)
  594.     {
  595.       char buff[80];
  596.       String tmp(buff, sizeof(buff), default_charset_info), *res;
  597.       if (!(res=item->val_str(&tmp)))
  598.       {
  599. client_field->def_length= 0;
  600. client_field->def= strmake_root(field_alloc, "",0);
  601.       }
  602.       else
  603.       {
  604. client_field->def_length= res->length();
  605. client_field->def= strmake_root(field_alloc, res->ptr(),
  606. client_field->def_length);
  607.       }
  608.     }
  609.     else
  610.       client_field->def=0;
  611.     client_field->max_length= 0;
  612.     ++client_field;
  613.   }
  614.   thd->mysql->field_count= field_count;
  615.   DBUG_RETURN(prepare_for_send(list));
  616.  err:
  617.   send_error(thd, ER_OUT_OF_RESOURCES); /* purecov: inspected */
  618.   DBUG_RETURN(1); /* purecov: inspected */
  619. }
  620. bool Protocol::send_records_num(List<Item> *list, ulonglong records)
  621. {
  622.   return false;
  623. }
  624. bool Protocol::write()
  625. {
  626.   if (!thd->mysql)            // bootstrap file handling
  627.     return false;
  628.   *next_field= 0;
  629.   return false;
  630. }
  631. bool Protocol_prep::write()
  632. {
  633.   MYSQL_ROWS *cur;
  634.   MYSQL_DATA *data= thd->data;
  635.   if (!data)
  636.   {
  637.     if (!(data= (MYSQL_DATA*) my_malloc(sizeof(MYSQL_DATA),
  638. MYF(MY_WME | MY_ZEROFILL))))
  639.       return true;
  640.     
  641.     alloc= &data->alloc;
  642.     init_alloc_root(alloc,8192,0); /* Assume rowlength < 8192 */
  643.     alloc->min_malloc=sizeof(MYSQL_ROWS);
  644.     data->rows=0;
  645.     data->fields=field_count;
  646.     data->prev_ptr= &data->data;
  647.     thd->data= data;
  648.   }
  649.   data->rows++;
  650.   if (!(cur= (MYSQL_ROWS *)alloc_root(alloc, sizeof(MYSQL_ROWS)+packet->length())))
  651.   {
  652.     my_error(ER_OUT_OF_RESOURCES,MYF(0));
  653.     return true;
  654.   }
  655.   cur->data= (MYSQL_ROW)(((char *)cur) + sizeof(MYSQL_ROWS));
  656.   memcpy(cur->data, packet->ptr()+1, packet->length()-1);
  657.   cur->length= packet->length();       /* To allow us to do sanity checks */
  658.   *data->prev_ptr= cur;
  659.   data->prev_ptr= &cur->next;
  660.   cur->next= 0;
  661.   
  662.   return false;
  663. }
  664. void
  665. send_ok(THD *thd,ha_rows affected_rows,ulonglong id,const char *message)
  666. {
  667.   DBUG_ENTER("send_ok");
  668.   MYSQL *mysql= current_thd->mysql;
  669.   if (!mysql)            // bootstrap file handling
  670.     DBUG_VOID_RETURN;
  671.   mysql->affected_rows= affected_rows;
  672.   mysql->insert_id= id;
  673.   if (message)
  674.   {
  675.     strmake(thd->net.last_error, message, sizeof(thd->net.last_error)-1);
  676.     mysql->info= thd->net.last_error;
  677.   }
  678.   DBUG_VOID_RETURN;
  679. }
  680. void
  681. send_eof(THD *thd, bool no_flush)
  682. {
  683. }
  684. void Protocol_simple::prepare_for_resend()
  685. {
  686.   MYSQL_ROWS *cur;
  687.   MYSQL_DATA *data= thd->data;
  688.   DBUG_ENTER("send_data");
  689.   if (!data)
  690.   {
  691.     if (!(data= (MYSQL_DATA*) my_malloc(sizeof(MYSQL_DATA),
  692. MYF(MY_WME | MY_ZEROFILL))))
  693.       goto err;
  694.     
  695.     alloc= &data->alloc;
  696.     init_alloc_root(alloc,8192,0); /* Assume rowlength < 8192 */
  697.     alloc->min_malloc=sizeof(MYSQL_ROWS);
  698.     data->rows=0;
  699.     data->fields=field_count;
  700.     data->prev_ptr= &data->data;
  701.     thd->data= data;
  702.   }
  703.   data->rows++;
  704.   if (!(cur= (MYSQL_ROWS *)alloc_root(alloc, sizeof(MYSQL_ROWS)+(field_count + 1) * sizeof(char *))))
  705.   {
  706.     my_error(ER_OUT_OF_RESOURCES,MYF(0));
  707.     DBUG_VOID_RETURN;
  708.   }
  709.   cur->data= (MYSQL_ROW)(((char *)cur) + sizeof(MYSQL_ROWS));
  710.   *data->prev_ptr= cur;
  711.   data->prev_ptr= &cur->next;
  712.   next_field=cur->data;
  713.   next_mysql_field= thd->mysql->fields;
  714. err:
  715.   DBUG_VOID_RETURN;
  716. }
  717. bool Protocol_simple::store_null()
  718. {
  719.   *(next_field++)= NULL;
  720.   ++next_mysql_field;
  721.   return false;
  722. }
  723. bool Protocol::net_store_data(const char *from, uint length)
  724. {
  725.   char *field_buf;
  726.   if (!thd->mysql)            // bootstrap file handling
  727.     return false;
  728.   if (!(field_buf=alloc_root(alloc, length + sizeof(uint) + 1)))
  729.     return true;
  730.   *(uint *)field_buf= length;
  731.   *next_field= field_buf + sizeof(uint);
  732.   memcpy(*next_field, from, length);
  733.   (*next_field)[length]= 0;
  734.   if (next_mysql_field->max_length < length)
  735.     next_mysql_field->max_length=length;
  736.   ++next_field;
  737.   ++next_mysql_field;
  738.   return false;
  739. }