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

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

MySQL数据库

开发平台：

Visual C++

sql_show.cpp：源码内容
  1. /* Copyright (C) 2000-2004 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 */
  18. /* Function with list databases, tables or fields */
  20. #include "mysql_priv.h"
  21. #include "sql_select.h"                         // For select_describe
  22. #include "repl_failsafe.h"
  23. #include <my_dir.h>
  25. #ifdef HAVE_BERKELEY_DB
  26. #include "ha_berkeley.h" // For berkeley_show_logs
  27. #endif
  29. static const char *grant_names[]={
  30.   "select","insert","update","delete","create","drop","reload","shutdown",
  31.   "process","file","grant","references","index","alter"};
  33. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  34. static TYPELIB grant_types = { sizeof(grant_names)/sizeof(char **),
  35.                                "grant_types",
  36.                                grant_names, NULL};
  37. #endif
  39. static int
  40. store_create_info(THD *thd, TABLE *table, String *packet);
  43. /*
  44.   Report list of databases
  45.   A database is a directory in the mysql_data_home directory
  46. */
  48. int
  49. mysqld_show_dbs(THD *thd,const char *wild)
  50. {
  51.   Item_string *field=new Item_string("",0,thd->charset());
  52.   List<Item> field_list;
  53.   char *end;
  54.   List<char> files;
  55.   char *file_name;
  56.   Protocol *protocol= thd->protocol;
  57.   DBUG_ENTER("mysqld_show_dbs");
  59.   field->name=(char*) thd->alloc(20+ (wild ? (uint) strlen(wild)+4: 0));
  60.   field->max_length=NAME_LEN;
  61.   end=strmov(field->name,"Database");
  62.   if (wild && wild[0])
  63.     strxmov(end," (",wild,")",NullS);
  64.   field_list.push_back(field);
  66.   if (protocol->send_fields(&field_list,1))
  67.     DBUG_RETURN(1);
  68.   if (mysql_find_files(thd,&files,NullS,mysql_data_home,wild,1))
  69.     DBUG_RETURN(1);
  70.   List_iterator_fast<char> it(files);
  72.   while ((file_name=it++))
  73.   {
  74. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  75.     if (thd->master_access & (DB_ACLS | SHOW_DB_ACL) ||
  76. acl_get(thd->host, thd->ip, thd->priv_user, file_name,0) ||
  77. (grant_option && !check_grant_db(thd, file_name)))
  78. #endif
  79.     {
  80.       protocol->prepare_for_resend();
  81.       protocol->store(file_name, system_charset_info);
  82.       if (protocol->write())
  83. DBUG_RETURN(-1);
  84.     }
  85.   }
  86.   send_eof(thd);
  87.   DBUG_RETURN(0);
  88. }
  91. /***************************************************************************
  92.   List all open tables in a database
  93. ***************************************************************************/
  95. int mysqld_show_open_tables(THD *thd,const char *wild)
  96. {
  97.   List<Item> field_list;
  98.   OPEN_TABLE_LIST *open_list;
  99.   Protocol *protocol= thd->protocol;
  100.   DBUG_ENTER("mysqld_show_open_tables");
  102.   field_list.push_back(new Item_empty_string("Database",NAME_LEN));
  103.   field_list.push_back(new Item_empty_string("Table",NAME_LEN));
  104.   field_list.push_back(new Item_return_int("In_use", 1, MYSQL_TYPE_TINY));
  105.   field_list.push_back(new Item_return_int("Name_locked", 4, MYSQL_TYPE_TINY));
  107.   if (protocol->send_fields(&field_list,1))
  108.     DBUG_RETURN(1);
  110.   if (!(open_list=list_open_tables(thd,wild)) && thd->is_fatal_error)
  111.     DBUG_RETURN(-1);
  113.   for (; open_list ; open_list=open_list->next)
  114.   {
  115.     protocol->prepare_for_resend();
  116.     protocol->store(open_list->db, system_charset_info);
  117.     protocol->store(open_list->table, system_charset_info);
  118.     protocol->store_tiny((longlong) open_list->in_use);
  119.     protocol->store_tiny((longlong) open_list->locked);
  120.     if (protocol->write())
  121.     {
  122.       DBUG_RETURN(-1);
  123.     }
  124.   }
  125.   send_eof(thd);
  126.   DBUG_RETURN(0);
  127. }
  130. /***************************************************************************
  131. ** List all tables in a database (fast version)
  132. ** A table is a .frm file in the current databasedir
  133. ***************************************************************************/
  135. int mysqld_show_tables(THD *thd,const char *db,const char *wild)
  136. {
  137.   Item_string *field=new Item_string("",0,thd->charset());
  138.   List<Item> field_list;
  139.   char path[FN_LEN],*end;
  140.   List<char> files;
  141.   char *file_name;
  142.   Protocol *protocol= thd->protocol;
  143.   DBUG_ENTER("mysqld_show_tables");
  145.   field->name=(char*) thd->alloc(20+(uint) strlen(db)+
  146.  (wild ? (uint) strlen(wild)+4:0));
  147.   end=strxmov(field->name,"Tables_in_",db,NullS);
  148.   if (wild && wild[0])
  149.     strxmov(end," (",wild,")",NullS);
  150.   field->max_length=NAME_LEN;
  151.   (void) sprintf(path,"%s/%s",mysql_data_home,db);
  152.   (void) unpack_dirname(path,path);
  153.   field_list.push_back(field);
  154.   if (protocol->send_fields(&field_list,1))
  155.     DBUG_RETURN(1);
  156.   if (mysql_find_files(thd,&files,db,path,wild,0))
  157.     DBUG_RETURN(-1);
  158.   List_iterator_fast<char> it(files);
  159.   while ((file_name=it++))
  160.   {
  161.     protocol->prepare_for_resend();
  162.     protocol->store(file_name, system_charset_info);
  163.     if (protocol->write())
  164.       DBUG_RETURN(-1);
  165.   }
  166.   send_eof(thd);
  167.   DBUG_RETURN(0);
  168. }
  170. /***************************************************************************
  171. ** List all table types supported 
  172. ***************************************************************************/
  174. int mysqld_show_storage_engines(THD *thd)
  175. {
  176.   List<Item> field_list;
  177.   Protocol *protocol= thd->protocol;
  178.   DBUG_ENTER("mysqld_show_storage_engines");
  180.   field_list.push_back(new Item_empty_string("Engine",10));
  181.   field_list.push_back(new Item_empty_string("Support",10));
  182.   field_list.push_back(new Item_empty_string("Comment",80));
  184.   if (protocol->send_fields(&field_list,1))
  185.     DBUG_RETURN(1);
  187.   const char *default_type_name= 
  188.     ha_get_storage_engine((enum db_type)thd->variables.table_type);
  190.   show_table_type_st *types;
  191.   for (types= sys_table_types; types->type; types++)
  192.   {
  193.     protocol->prepare_for_resend();
  194.     protocol->store(types->type, system_charset_info);
  195.     const char *option_name= show_comp_option_name[(int) *types->value];
  197.     if (*types->value == SHOW_OPTION_YES &&
  198. !my_strcasecmp(system_charset_info, default_type_name, types->type))
  199.       option_name= "DEFAULT";
  200.     protocol->store(option_name, system_charset_info);
  201.     protocol->store(types->comment, system_charset_info);
  202.     if (protocol->write())
  203.       DBUG_RETURN(-1);
  204.   }
  205.   send_eof(thd);
  206.   DBUG_RETURN(0);
  207. }
  210. /***************************************************************************
  211.  List all privileges supported
  212. ***************************************************************************/
  214. struct show_privileges_st {
  215.   const char *privilege;
  216.   const char *context;
  217.   const char *comment;
  218. };
  220. static struct show_privileges_st sys_privileges[]=
  221. {
  222.   {"Alter", "Tables",  "To alter the table"},
  223.   {"Create temporary tables","Databases","To use CREATE TEMPORARY TABLE"},
  224.   {"Create", "Databases,Tables,Indexes",  "To create new databases and tables"},
  225.   {"Delete", "Tables",  "To delete existing rows"},
  226.   {"Drop", "Databases,Tables", "To drop databases and tables"},
  227.   {"File", "File access on server",   "To read and write files on the server"},
  228.   {"Grant option",  "Databases,Tables", "To give to other users those privileges you possess"},
  229.   {"Index", "Tables",  "To create or drop indexes"},
  230.   {"Insert", "Tables",  "To insert data into tables"},
  231.   {"Lock tables","Databases","To use LOCK TABLES (together with SELECT privilege)"},
  232.   {"Process", "Server Admin", "To view the plain text of currently executing queries"},
  233.   {"References", "Databases,Tables", "To have references on tables"},
  234.   {"Reload", "Server Admin", "To reload or refresh tables, logs and privileges"},
  235.   {"Replication client","Server Admin","To ask where the slave or master servers are"},
  236.   {"Replication slave","Server Admin","To read binary log events from the master"},
  237.   {"Select", "Tables",  "To retrieve rows from table"},
  238.   {"Show databases","Server Admin","To see all databases with SHOW DATABASES"},
  239.   {"Shutdown","Server Admin", "To shutdown the server"},
  240.   {"Super","Server Admin","To use KILL thread, SET GLOBAL, CHANGE MASTER, etc."},
  241.   {"Update", "Tables",  "To update existing rows"},
  242.   {"Usage","Server Admin","No privileges - allow connect only"},
  243.   {NullS, NullS, NullS}
  244. };
  246. int mysqld_show_privileges(THD *thd)
  247. {
  248.   List<Item> field_list;
  249.   Protocol *protocol= thd->protocol;
  250.   DBUG_ENTER("mysqld_show_privileges");
  252.   field_list.push_back(new Item_empty_string("Privilege",10));
  253.   field_list.push_back(new Item_empty_string("Context",15));
  254.   field_list.push_back(new Item_empty_string("Comment",NAME_LEN));
  256.   if (protocol->send_fields(&field_list,1))
  257.     DBUG_RETURN(1);
  259.   show_privileges_st *privilege= sys_privileges;
  260.   for (privilege= sys_privileges; privilege->privilege ; privilege++)
  261.   {
  262.     protocol->prepare_for_resend();
  263.     protocol->store(privilege->privilege, system_charset_info);
  264.     protocol->store(privilege->context, system_charset_info);
  265.     protocol->store(privilege->comment, system_charset_info);
  266.     if (protocol->write())
  267.       DBUG_RETURN(-1);
  268.   }
  269.   send_eof(thd);
  270.   DBUG_RETURN(0);
  271. }
  274. /***************************************************************************
  275.   List all column types
  276. ***************************************************************************/
  278. struct show_column_type_st
  279. {
  280.   const char *type;
  281.   uint size;
  282.   const char *min_value;
  283.   const char *max_value;
  284.   uint precision;
  285.   uint scale;
  286.   const char *nullable;
  287.   const char *auto_increment;
  288.   const char *unsigned_attr;
  289.   const char *zerofill;
  290.   const char *searchable;
  291.   const char *case_sensitivity;
  292.   const char *default_value;
  293.   const char *comment;
  294. };
  296. /* TODO: Add remaning types */
  298. static struct show_column_type_st sys_column_types[]=
  299. {
  300.   {"tinyint",
  301.     1,  "-128",  "127",  0,  0,  "YES",  "YES",
  302.     "NO",   "YES", "YES",  "NO",  "NULL,0",
  303.     "A very small integer"},
  304.   {"tinyint unsigned",
  305.     1,  "0"   ,  "255",  0,  0,  "YES",  "YES",
  306.     "YES",  "YES",  "YES",  "NO",  "NULL,0",
  307.     "A very small integer"},
  308. };
  310. int mysqld_show_column_types(THD *thd)
  311. {
  312.   List<Item> field_list;
  313.   Protocol *protocol= thd->protocol;
  314.   DBUG_ENTER("mysqld_show_column_types");
  316.   field_list.push_back(new Item_empty_string("Type",30));
  317.   field_list.push_back(new Item_int("Size",(longlong) 1,21));
  318.   field_list.push_back(new Item_empty_string("Min_Value",20));
  319.   field_list.push_back(new Item_empty_string("Max_Value",20));
  320.   field_list.push_back(new Item_return_int("Prec", 4, MYSQL_TYPE_SHORT));
  321.   field_list.push_back(new Item_return_int("Scale", 4, MYSQL_TYPE_SHORT));
  322.   field_list.push_back(new Item_empty_string("Nullable",4));
  323.   field_list.push_back(new Item_empty_string("Auto_Increment",4));
  324.   field_list.push_back(new Item_empty_string("Unsigned",4));
  325.   field_list.push_back(new Item_empty_string("Zerofill",4));
  326.   field_list.push_back(new Item_empty_string("Searchable",4));
  327.   field_list.push_back(new Item_empty_string("Case_Sensitive",4));
  328.   field_list.push_back(new Item_empty_string("Default",NAME_LEN));
  329.   field_list.push_back(new Item_empty_string("Comment",NAME_LEN));
  331.   if (protocol->send_fields(&field_list,1))
  332.     DBUG_RETURN(1);
  334.   /* TODO: Change the loop to not use 'i' */
  335.   for (uint i=0; i < sizeof(sys_column_types)/sizeof(sys_column_types[0]); i++)
  336.   {
  337.     protocol->prepare_for_resend();
  338.     protocol->store(sys_column_types[i].type, system_charset_info);
  339.     protocol->store((ulonglong) sys_column_types[i].size);
  340.     protocol->store(sys_column_types[i].min_value, system_charset_info);
  341.     protocol->store(sys_column_types[i].max_value, system_charset_info);
  342.     protocol->store_short((longlong) sys_column_types[i].precision);
  343.     protocol->store_short((longlong) sys_column_types[i].scale);
  344.     protocol->store(sys_column_types[i].nullable, system_charset_info);
  345.     protocol->store(sys_column_types[i].auto_increment, system_charset_info);
  346.     protocol->store(sys_column_types[i].unsigned_attr, system_charset_info);
  347.     protocol->store(sys_column_types[i].zerofill, system_charset_info);
  348.     protocol->store(sys_column_types[i].searchable, system_charset_info);
  349.     protocol->store(sys_column_types[i].case_sensitivity, system_charset_info);
  350.     protocol->store(sys_column_types[i].default_value, system_charset_info);
  351.     protocol->store(sys_column_types[i].comment, system_charset_info);
  352.     if (protocol->write())
  353.       DBUG_RETURN(-1);
  354.   }
  355.   send_eof(thd);
  356.   DBUG_RETURN(0);
  357. }
  360. int
  361. mysql_find_files(THD *thd,List<char> *files, const char *db,const char *path,
  362.                  const char *wild, bool dir)
  363. {
  364.   uint i;
  365.   char *ext;
  366.   MY_DIR *dirp;
  367.   FILEINFO *file;
  368. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  369.   uint col_access=thd->col_access;
  370. #endif
  371.   TABLE_LIST table_list;
  372.   DBUG_ENTER("mysql_find_files");
  374.   if (wild && !wild[0])
  375.     wild=0;
  377.   bzero((char*) &table_list,sizeof(table_list));
  379.   if (!(dirp = my_dir(path,MYF(MY_WME | (dir ? MY_WANT_STAT : 0)))))
  380.     DBUG_RETURN(-1);
  382.   for (i=0 ; i < (uint) dirp->number_off_files  ; i++)
  383.   {
  384.     file=dirp->dir_entry+i;
  385.     if (dir)
  386.     {                                           /* Return databases */
  387. #ifdef USE_SYMDIR
  388.       char *ext;
  389.       char buff[FN_REFLEN];
  390.       if (my_use_symdir && !strcmp(ext=fn_ext(file->name), ".sym"))
  391.       {
  392. /* Only show the sym file if it points to a directory */
  393. char *end;
  394.         *ext=0;                                 /* Remove extension */
  395. unpack_dirname(buff, file->name);
  396. end= strend(buff);
  397. if (end != buff && end[-1] == FN_LIBCHAR)
  398.   end[-1]= 0; // Remove end FN_LIBCHAR
  399.         if (!my_stat(buff, file->mystat, MYF(0)))
  400.                continue;
  401.        }
  402. #endif
  403.         if (file->name[0] == '.' || !MY_S_ISDIR(file->mystat->st_mode) ||
  404.             (wild && wild_compare(file->name,wild,0)))
  405.           continue;
  406.     }
  407.     else
  408.     {
  409.         // Return only .frm files which aren't temp files.
  410.       if (my_strcasecmp(system_charset_info, ext=fn_ext(file->name),reg_ext) ||
  411.           is_prefix(file->name,tmp_file_prefix))
  412.         continue;
  413.       *ext=0;
  414.       if (wild)
  415.       {
  416. if (lower_case_table_names)
  417. {
  418.   if (wild_case_compare(files_charset_info, file->name, wild))
  419.     continue;
  420. }
  421. else if (wild_compare(file->name,wild,0))
  422.   continue;
  423.       }
  424.     }
  425. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  426.     /* Don't show tables where we don't have any privileges */
  427.     if (db && !(col_access & TABLE_ACLS))
  428.     {
  429.       table_list.db= (char*) db;
  430.       table_list.real_name=file->name;
  431.       table_list.grant.privilege=col_access;
  432.       if (check_grant(thd, TABLE_ACLS, &table_list, 1, UINT_MAX, 1))
  433.         continue;
  434.     }
  435. #endif
  436.     if (files->push_back(thd->strdup(file->name)))
  437.     {
  438.       my_dirend(dirp);
  439.       DBUG_RETURN(-1);
  440.     }
  441.   }
  442.   DBUG_PRINT("info",("found: %d files", files->elements));
  443.   my_dirend(dirp);
  445.   VOID(ha_find_files(thd,db,path,wild,dir,files));
  447.   DBUG_RETURN(0);
  448. }
  451. /***************************************************************************
  452.  Extended version of mysqld_show_tables
  453. ***************************************************************************/
  455. int mysqld_extend_show_tables(THD *thd,const char *db,const char *wild)
  456. {
  457.   Item *item;
  458.   List<char> files;
  459.   List<Item> field_list;
  460.   char path[FN_LEN];
  461.   char *file_name;
  462.   TABLE *table;
  463.   Protocol *protocol= thd->protocol;
  464.   TIME time;
  465.   int res= 0;
  466.   DBUG_ENTER("mysqld_extend_show_tables");
  468.   (void) sprintf(path,"%s/%s",mysql_data_home,db);
  469.   (void) unpack_dirname(path,path);
  470.   field_list.push_back(item=new Item_empty_string("Name",NAME_LEN));
  471.   field_list.push_back(item=new Item_empty_string("Engine",10));
  472.   item->maybe_null=1;
  473.   field_list.push_back(item=new Item_int("Version", (longlong) 0, 21));
  474.   item->maybe_null=1;
  475.   field_list.push_back(item=new Item_empty_string("Row_format",10));
  476.   item->maybe_null=1;
  477.   field_list.push_back(item=new Item_int("Rows",(longlong) 1,21));
  478.   item->maybe_null=1;
  479.   field_list.push_back(item=new Item_int("Avg_row_length",(int32) 0,21));
  480.   item->maybe_null=1;
  481.   field_list.push_back(item=new Item_int("Data_length",(longlong) 1,21));
  482.   item->maybe_null=1;
  483.   field_list.push_back(item=new Item_int("Max_data_length",(longlong) 1,21));
  484.   item->maybe_null=1;
  485.   field_list.push_back(item=new Item_int("Index_length",(longlong) 1,21));
  486.   item->maybe_null=1;
  487.   field_list.push_back(item=new Item_int("Data_free",(longlong) 1,21));
  488.   item->maybe_null=1;
  489.   field_list.push_back(item=new Item_int("Auto_increment",(longlong) 1,21));
  490.   item->maybe_null=1;
  491.   field_list.push_back(item=new Item_datetime("Create_time"));
  492.   item->maybe_null=1;
  493.   field_list.push_back(item=new Item_datetime("Update_time"));
  494.   item->maybe_null=1;
  495.   field_list.push_back(item=new Item_datetime("Check_time"));
  496.   item->maybe_null=1;
  497.   field_list.push_back(item=new Item_empty_string("Collation",32));
  498.   item->maybe_null=1;
  499.   field_list.push_back(item=new Item_int("Checksum",(longlong) 1,21));
  500.   item->maybe_null=1;
  501.   field_list.push_back(item=new Item_empty_string("Create_options",255));
  502.   item->maybe_null=1;
  503.   field_list.push_back(item=new Item_empty_string("Comment",80));
  504.   item->maybe_null=1;
  505.   if (protocol->send_fields(&field_list,1))
  506.     DBUG_RETURN(1);
  508.   if (mysql_find_files(thd,&files,db,path,wild,0))
  509.     DBUG_RETURN(-1);
  510.   List_iterator_fast<char> it(files);
  511.   while ((file_name=it++))
  512.   {
  513.     TABLE_LIST table_list;
  514.     bzero((char*) &table_list,sizeof(table_list));
  515.     protocol->prepare_for_resend();
  516.     protocol->store(file_name, system_charset_info);
  517.     table_list.db=(char*) db;
  518.     table_list.real_name= table_list.alias= file_name;
  519.     if (lower_case_table_names)
  520.       my_casedn_str(files_charset_info, file_name);
  521.     if (!(table = open_ltable(thd, &table_list, TL_READ)))
  522.     {
  523.       for (uint i=2 ; i < field_list.elements ; i++)
  524.         protocol->store_null();
  525.       // Send error to Comment field
  526.       protocol->store(thd->net.last_error, system_charset_info);
  527.       thd->clear_error();
  528.     }
  529.     else
  530.     {
  531.       const char *str;
  532.       handler *file=table->file;
  533.       file->info(HA_STATUS_VARIABLE | HA_STATUS_TIME | HA_STATUS_NO_LOCK);
  534.       protocol->store(file->table_type(), system_charset_info);
  535.       protocol->store((ulonglong) table->frm_version);
  536.       str= ((table->db_options_in_use & HA_OPTION_COMPRESS_RECORD) ?
  537.     "Compressed" :
  538.     (table->db_options_in_use & HA_OPTION_PACK_RECORD) ?
  539.     "Dynamic" : "Fixed");
  540.       protocol->store(str, system_charset_info);
  541.       protocol->store((ulonglong) file->records);
  542.       protocol->store((ulonglong) file->mean_rec_length);
  543.       protocol->store((ulonglong) file->data_file_length);
  544.       if (file->max_data_file_length)
  545.         protocol->store((ulonglong) file->max_data_file_length);
  546.       else
  547.         protocol->store_null();
  548.       protocol->store((ulonglong) file->index_file_length);
  549.       protocol->store((ulonglong) file->delete_length);
  550.       if (table->found_next_number_field)
  551.       {
  552.         table->next_number_field=table->found_next_number_field;
  553.         table->next_number_field->reset();
  554.         file->update_auto_increment();
  555.         protocol->store(table->next_number_field->val_int());
  556.         table->next_number_field=0;
  557.       }
  558.       else
  559.         protocol->store_null();
  560.       if (!file->create_time)
  561.         protocol->store_null();
  562.       else
  563.       {
  564.         thd->variables.time_zone->gmt_sec_to_TIME(&time, file->create_time);
  565.         protocol->store(&time);
  566.       }
  567.       if (!file->update_time)
  568.         protocol->store_null();
  569.       else
  570.       {
  571.         thd->variables.time_zone->gmt_sec_to_TIME(&time, file->update_time);
  572.         protocol->store(&time);
  573.       }
  574.       if (!file->check_time)
  575.         protocol->store_null();
  576.       else
  577.       {
  578.         thd->variables.time_zone->gmt_sec_to_TIME(&time, file->check_time);
  579.         protocol->store(&time);
  580.       }
  581.       str= (table->table_charset ? table->table_charset->name : "default");
  582.       protocol->store(str, system_charset_info);
  583.       if (file->table_flags() & HA_HAS_CHECKSUM)
  584.         protocol->store((ulonglong)file->checksum());
  585.       else
  586.         protocol->store_null(); // Checksum
  587.       {
  588.         char option_buff[350],*ptr;
  589.         ptr=option_buff;
  590.         if (table->min_rows)
  591.         {
  592.           ptr=strmov(ptr," min_rows=");
  593.           ptr=longlong10_to_str(table->min_rows,ptr,10);
  594.         }
  595.         if (table->max_rows)
  596.         {
  597.           ptr=strmov(ptr," max_rows=");
  598.           ptr=longlong10_to_str(table->max_rows,ptr,10);
  599.         }
  600.         if (table->avg_row_length)
  601.         {
  602.           ptr=strmov(ptr," avg_row_length=");
  603.           ptr=longlong10_to_str(table->avg_row_length,ptr,10);
  604.         }
  605.         if (table->db_create_options & HA_OPTION_PACK_KEYS)
  606.           ptr=strmov(ptr," pack_keys=1");
  607.         if (table->db_create_options & HA_OPTION_NO_PACK_KEYS)
  608.           ptr=strmov(ptr," pack_keys=0");
  609.         if (table->db_create_options & HA_OPTION_CHECKSUM)
  610.           ptr=strmov(ptr," checksum=1");
  611.         if (table->db_create_options & HA_OPTION_DELAY_KEY_WRITE)
  612.           ptr=strmov(ptr," delay_key_write=1");
  613.         if (table->row_type != ROW_TYPE_DEFAULT)
  614.           ptr=strxmov(ptr, " row_format=", ha_row_type[(uint) table->row_type],
  615.                       NullS);
  616.         if (file->raid_type)
  617.         {
  618.           char buff[100];
  619.           sprintf(buff," raid_type=%s raid_chunks=%d raid_chunksize=%ld",
  620.                   my_raid_type(file->raid_type), file->raid_chunks, file->raid_chunksize/RAID_BLOCK_SIZE);
  621.           ptr=strmov(ptr,buff);
  622.         }
  623.         protocol->store(option_buff+1,
  624. (ptr == option_buff ? 0 : (uint) (ptr-option_buff)-1)
  625. , system_charset_info);
  626.       }
  627.       {
  628. char *comment=table->file->update_table_comment(table->comment);
  629. protocol->store(comment, system_charset_info);
  630. if (comment != table->comment)
  631.   my_free(comment,MYF(0));
  632.       }
  633.       close_thread_tables(thd,0);
  634.     }
  635.     if (protocol->write())
  636.     {
  637.       res= -1;
  638.       break;
  639.     }
  640.   }
  641.   thd->insert_id(0);
  642.   if (!res)
  643.     send_eof(thd);
  644.   DBUG_RETURN(res);
  645. }
  648. /***************************************************************************
  649. ** List all columns in a table_list->real_name
  650. ***************************************************************************/
  652. int
  653. mysqld_show_fields(THD *thd, TABLE_LIST *table_list,const char *wild,
  654.    bool verbose)
  655. {
  656.   TABLE *table;
  657.   handler *file;
  658.   char tmp[MAX_FIELD_WIDTH];
  659.   char tmp1[MAX_FIELD_WIDTH];
  660.   Item *item;
  661.   Protocol *protocol= thd->protocol;
  662.   DBUG_ENTER("mysqld_show_fields");
  663.   DBUG_PRINT("enter",("db: %s  table: %s",table_list->db,
  664.                       table_list->real_name));
  666.   if (!(table = open_ltable(thd, table_list, TL_UNLOCK)))
  667.   {
  668.     send_error(thd);
  669.     DBUG_RETURN(1);
  670.   }
  671.   file=table->file;
  672.   file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
  673. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  674.   (void) get_table_grant(thd, table_list);
  675. #endif
  676.   List<Item> field_list;
  677.   field_list.push_back(new Item_empty_string("Field",NAME_LEN));
  678.   field_list.push_back(new Item_empty_string("Type", 40));
  679.   if (verbose)
  680.     field_list.push_back(new Item_empty_string("Collation",40));
  681.   field_list.push_back(new Item_empty_string("Null",1));
  682.   field_list.push_back(new Item_empty_string("Key",3));
  683.   field_list.push_back(item=new Item_empty_string("Default",NAME_LEN));
  684.   item->maybe_null=1;
  685.   field_list.push_back(new Item_empty_string("Extra",20));
  686.   if (verbose)
  687.   {
  688.     field_list.push_back(new Item_empty_string("Privileges",80));
  689.     field_list.push_back(new Item_empty_string("Comment",255));
  690.   }
  691.         // Send first number of fields and records
  692.   if (protocol->send_records_num(&field_list, (ulonglong)file->records) ||
  693.       protocol->send_fields(&field_list,0))
  694.     DBUG_RETURN(1);
  695.   restore_record(table,default_values);      // Get empty record
  697.   Field **ptr,*field;
  698.   for (ptr=table->field; (field= *ptr) ; ptr++)
  699.   {
  700.     if (!wild || !wild[0] || 
  701.         !wild_case_compare(system_charset_info, field->field_name,wild))
  702.     {
  703.       {
  704.         byte *pos;
  705.         uint flags=field->flags;
  706.         String type(tmp,sizeof(tmp), system_charset_info);
  707. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  708.         uint col_access;
  709. #endif
  710. protocol->prepare_for_resend();
  711.         protocol->store(field->field_name, system_charset_info);
  712.         field->sql_type(type);
  713.         protocol->store(type.ptr(), type.length(), system_charset_info);
  714. if (verbose)
  715.   protocol->store(field->has_charset() ? field->charset()->name : "NULL",
  716. system_charset_info);
  717.         /*
  718.           Even if TIMESTAMP field can't contain NULL as its value it
  719.           will accept NULL if you will try to insert such value and will
  720.           convert NULL value to current TIMESTAMP. So YES here means
  721.           that NULL is allowed for assignment (but may be won't be
  722.           returned).
  723.         */
  724.         pos=(byte*) ((flags & NOT_NULL_FLAG) &&
  725.                      field->type() != FIELD_TYPE_TIMESTAMP ?
  726.                      "" : "YES");
  727.         protocol->store((const char*) pos, system_charset_info);
  728.         pos=(byte*) ((field->flags & PRI_KEY_FLAG) ? "PRI" :
  729.                      (field->flags & UNIQUE_KEY_FLAG) ? "UNI" :
  730.                      (field->flags & MULTIPLE_KEY_FLAG) ? "MUL":"");
  731.         protocol->store((char*) pos, system_charset_info);
  733.         if (table->timestamp_field == field &&
  734.             field->unireg_check != Field::TIMESTAMP_UN_FIELD)
  735.         {
  736.           /*
  737.             We have NOW() as default value but we use CURRENT_TIMESTAMP form
  738.             because it is more SQL standard comatible
  739.           */
  740.           protocol->store("CURRENT_TIMESTAMP", system_charset_info);
  741.         }
  742.         else if (field->unireg_check != Field::NEXT_NUMBER &&
  743.                  !field->is_null())
  744.         {                                               // Not null by default
  745.           /*
  746.             Note: we have to convert the default value into
  747.             system_charset_info before sending.
  748.             This is necessary for "SET NAMES binary":
  749.             If the client character set is binary, we want to
  750.             send metadata in UTF8 rather than in the column's
  751.             character set.
  752.             This conversion also makes "SHOW COLUMNS" and
  753.             "SHOW CREATE TABLE" output consistent. Without
  754.             this conversion the default values were displayed
  755.             differently.
  756.           */
  757.           String def(tmp1,sizeof(tmp1), system_charset_info);
  758.           type.set(tmp, sizeof(tmp), field->charset());
  759.           field->val_str(&type);
  760.           uint dummy_errors;
  761.           def.copy(type.ptr(), type.length(), type.charset(), 
  762.                    system_charset_info, &dummy_errors);
  763.           protocol->store(def.ptr(), def.length(), def.charset());
  764.         }
  765.         else if (field->unireg_check == Field::NEXT_NUMBER ||
  766.                  field->maybe_null())
  767.           protocol->store_null();                       // Null as default
  768.         else
  769.           protocol->store("",0, system_charset_info); // empty string
  771.         char *end=tmp;
  772.         if (field->unireg_check == Field::NEXT_NUMBER)
  773.           end=strmov(tmp,"auto_increment");
  774.         protocol->store(tmp,(uint) (end-tmp), system_charset_info);
  776. if (verbose)
  777. {
  778.   /* Add grant options & comments */
  779.   end=tmp;
  780. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  781.   col_access= get_column_grant(thd,table_list,field) & COL_ACLS;
  782.   for (uint bitnr=0; col_access ; col_access>>=1,bitnr++)
  783.   {
  784.     if (col_access & 1)
  785.     {
  786.       *end++=',';
  787.       end=strmov(end,grant_types.type_names[bitnr]);
  788.     }
  789.   }
  790. #else
  791.   end=strmov(end,"");
  792. #endif
  793.   protocol->store(tmp+1,end == tmp ? 0 : (uint) (end-tmp-1),
  794.   system_charset_info);
  795.   protocol->store(field->comment.str, field->comment.length,
  796.   system_charset_info);
  797. }
  798.         if (protocol->write())
  799.           DBUG_RETURN(1);
  800.       }
  801.     }
  802.   }
  803.   send_eof(thd);
  804.   DBUG_RETURN(0);
  805. }
  808. int
  809. mysqld_show_create(THD *thd, TABLE_LIST *table_list)
  810. {
  811.   TABLE *table;
  812.   Protocol *protocol= thd->protocol;
  813.   char buff[2048];
  814.   String buffer(buff, sizeof(buff), system_charset_info);
  815.   DBUG_ENTER("mysqld_show_create");
  816.   DBUG_PRINT("enter",("db: %s  table: %s",table_list->db,
  817.                       table_list->real_name));
  819.   /* Only one table for now */
  820.   if (!(table = open_ltable(thd, table_list, TL_UNLOCK)))
  821.   {
  822.     send_error(thd);
  823.     DBUG_RETURN(1);
  824.   }
  826.   buffer.length(0);
  827.   if (store_create_info(thd, table, &buffer))
  828.     DBUG_RETURN(-1);
  830.   List<Item> field_list;
  831.   field_list.push_back(new Item_empty_string("Table",NAME_LEN));
  832.   // 1024 is for not to confuse old clients
  833.   field_list.push_back(new Item_empty_string("Create Table",
  834.      max(buffer.length(),1024)));
  836.   if (protocol->send_fields(&field_list, 1))
  837.     DBUG_RETURN(1);
  838.   protocol->prepare_for_resend();
  839.   protocol->store(table->table_name, system_charset_info);
  840.   protocol->store(buffer.ptr(), buffer.length(), buffer.charset());
  841.   if (protocol->write())
  842.     DBUG_RETURN(1);
  843.   send_eof(thd);
  844.   DBUG_RETURN(0);
  845. }
  847. int mysqld_show_create_db(THD *thd, char *dbname,
  848.   HA_CREATE_INFO *create_info)
  849. {
  850.   int length;
  851.   char path[FN_REFLEN];
  852.   char buff[2048];
  853.   String buffer(buff, sizeof(buff), system_charset_info);
  854. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  855.   uint db_access;
  856. #endif
  857.   bool found_libchar;
  858.   HA_CREATE_INFO create;
  859.   uint create_options = create_info ? create_info->options : 0;
  860.   Protocol *protocol=thd->protocol;
  861.   DBUG_ENTER("mysql_show_create_db");
  863.   if (check_db_name(dbname))
  864.   {
  865.     net_printf(thd,ER_WRONG_DB_NAME, dbname);
  866.     DBUG_RETURN(1);
  867.   }
  869. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  870.   if (test_all_bits(thd->master_access,DB_ACLS))
  871.     db_access=DB_ACLS;
  872.   else
  873.     db_access= (acl_get(thd->host,thd->ip, thd->priv_user,dbname,0) |
  874. thd->master_access);
  875.   if (!(db_access & DB_ACLS) && (!grant_option || check_grant_db(thd,dbname)))
  876.   {
  877.     net_printf(thd,ER_DBACCESS_DENIED_ERROR,
  878.        thd->priv_user, thd->host_or_ip, dbname);
  879.     mysql_log.write(thd,COM_INIT_DB,ER(ER_DBACCESS_DENIED_ERROR),
  880.     thd->priv_user, thd->host_or_ip, dbname);
  881.     DBUG_RETURN(1);
  882.   }
  883. #endif
  885.   (void) sprintf(path,"%s/%s",mysql_data_home, dbname);
  886.   length=unpack_dirname(path,path); // Convert if not unix
  887.   found_libchar= 0;
  888.   if (length && path[length-1] == FN_LIBCHAR)
  889.   {
  890.     found_libchar= 1;
  891.     path[length-1]=0; // remove ending ''
  892.   }
  893.   if (access(path,F_OK))
  894.   {
  895.     net_printf(thd,ER_BAD_DB_ERROR,dbname);
  896.     DBUG_RETURN(1);
  897.   }
  898.   if (found_libchar)
  899.     path[length-1]= FN_LIBCHAR;
  900.   strmov(path+length, MY_DB_OPT_FILE);
  901.   load_db_opt(thd, path, &create);
  903.   List<Item> field_list;
  904.   field_list.push_back(new Item_empty_string("Database",NAME_LEN));
  905.   field_list.push_back(new Item_empty_string("Create Database",1024));
  907.   if (protocol->send_fields(&field_list,1))
  908.     DBUG_RETURN(1);
  910.   protocol->prepare_for_resend();
  911.   protocol->store(dbname, strlen(dbname), system_charset_info);
  912.   buffer.length(0);
  913.   buffer.append("CREATE DATABASE ", 16);
  914.   if (create_options & HA_LEX_CREATE_IF_NOT_EXISTS)
  915.     buffer.append("/*!32312 IF NOT EXISTS*/ ", 25);
  916.   append_identifier(thd, &buffer, dbname, strlen(dbname));
  918.   if (create.default_table_charset)
  919.   {
  920.     buffer.append(" /*!40100", 9);
  921.     buffer.append(" DEFAULT CHARACTER SET ", 23);
  922.     buffer.append(create.default_table_charset->csname);
  923.     if (!(create.default_table_charset->state & MY_CS_PRIMARY))
  924.     {
  925.       buffer.append(" COLLATE ", 9);
  926.       buffer.append(create.default_table_charset->name);
  927.     }
  928.     buffer.append(" */", 3);
  929.   }
  930.   protocol->store(buffer.ptr(), buffer.length(), buffer.charset());
  932.   if (protocol->write())
  933.     DBUG_RETURN(1);
  934.   send_eof(thd);
  935.   DBUG_RETURN(0);
  936. }
  938. int
  939. mysqld_show_logs(THD *thd)
  940. {
  941.   List<Item> field_list;
  942.   Protocol *protocol= thd->protocol;
  943.   DBUG_ENTER("mysqld_show_logs");
  945.   field_list.push_back(new Item_empty_string("File",FN_REFLEN));
  946.   field_list.push_back(new Item_empty_string("Type",10));
  947.   field_list.push_back(new Item_empty_string("Status",10));
  949.   if (protocol->send_fields(&field_list,1))
  950.     DBUG_RETURN(1);
  952. #ifdef HAVE_BERKELEY_DB
  953.   if ((have_berkeley_db == SHOW_OPTION_YES) && berkeley_show_logs(protocol))
  954.     DBUG_RETURN(-1);
  955. #endif
  957.   send_eof(thd);
  958.   DBUG_RETURN(0);
  959. }
  962. int
  963. mysqld_show_keys(THD *thd, TABLE_LIST *table_list)
  964. {
  965.   TABLE *table;
  966.   Protocol *protocol= thd->protocol;
  967.   DBUG_ENTER("mysqld_show_keys");
  968.   DBUG_PRINT("enter",("db: %s  table: %s",table_list->db,
  969.                       table_list->real_name));
  971.   if (!(table = open_ltable(thd, table_list, TL_UNLOCK)))
  972.   {
  973.     send_error(thd);
  974.     DBUG_RETURN(1);
  975.   }
  977.   List<Item> field_list;
  978.   Item *item;
  979.   field_list.push_back(new Item_empty_string("Table",NAME_LEN));
  980.   field_list.push_back(new Item_return_int("Non_unique",1, MYSQL_TYPE_TINY));
  981.   field_list.push_back(new Item_empty_string("Key_name",NAME_LEN));
  982.   field_list.push_back(new Item_return_int("Seq_in_index",2, MYSQL_TYPE_TINY));
  983.   field_list.push_back(new Item_empty_string("Column_name",NAME_LEN));
  984.   field_list.push_back(item=new Item_empty_string("Collation",1));
  985.   item->maybe_null=1;
  986.   field_list.push_back(item=new Item_int("Cardinality",0,21));
  987.   item->maybe_null=1;
  988.   field_list.push_back(item=new Item_return_int("Sub_part",3,
  989. MYSQL_TYPE_SHORT));
  990.   item->maybe_null=1;
  991.   field_list.push_back(item=new Item_empty_string("Packed",10));
  992.   item->maybe_null=1;
  993.   field_list.push_back(new Item_empty_string("Null",3));
  994.   field_list.push_back(new Item_empty_string("Index_type",16));
  995.   field_list.push_back(new Item_empty_string("Comment",255));
  996.   item->maybe_null=1;
  998.   if (protocol->send_fields(&field_list,1))
  999.     DBUG_RETURN(1);
  1001.   KEY *key_info=table->key_info;
  1002.   table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK | HA_STATUS_TIME);
  1003.   for (uint i=0 ; i < table->keys ; i++,key_info++)
  1004.   {
  1005.     KEY_PART_INFO *key_part= key_info->key_part;
  1006.     const char *str;
  1007.     for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
  1008.     {
  1009.       protocol->prepare_for_resend();
  1010.       protocol->store(table->table_name, system_charset_info);
  1011.       protocol->store_tiny((longlong) ((key_info->flags & HA_NOSAME) ? 0 :1));
  1012.       protocol->store(key_info->name, system_charset_info);
  1013.       protocol->store_tiny((longlong) (j+1));
  1014.       str=(key_part->field ? key_part->field->field_name :
  1015.    "?unknown field?");
  1016.       protocol->store(str, system_charset_info);
  1017.       if (table->file->index_flags(i, j, 0) & HA_READ_ORDER)
  1018.         protocol->store(((key_part->key_part_flag & HA_REVERSE_SORT) ?
  1019.  "D" : "A"), 1, system_charset_info);
  1020.       else
  1021.         protocol->store_null(); /* purecov: inspected */
  1022.       KEY *key=table->key_info+i;
  1023.       if (key->rec_per_key[j])
  1024.       {
  1025.         ha_rows records=(table->file->records / key->rec_per_key[j]);
  1026.         protocol->store((ulonglong) records);
  1027.       }
  1028.       else
  1029.         protocol->store_null();
  1031.       /* Check if we have a key part that only uses part of the field */
  1032.       if (!(key_info->flags & HA_FULLTEXT) && (!key_part->field ||
  1033.           key_part->length != table->field[key_part->fieldnr-1]->key_length()))
  1034.         protocol->store_short((longlong) key_part->length / 
  1035.                              key_part->field->charset()->mbmaxlen);
  1036.       else
  1037.         protocol->store_null();
  1038.       protocol->store_null();                   // No pack_information yet
  1040.       /* Null flag */
  1041.       uint flags= key_part->field ? key_part->field->flags : 0;
  1042.       char *pos=(char*) ((flags & NOT_NULL_FLAG) ? "" : "YES");
  1043.       protocol->store((const char*) pos, system_charset_info);
  1044.       protocol->store(table->file->index_type(i), system_charset_info);
  1045.       /* Comment */
  1046.       if (!table->keys_in_use.is_set(i))
  1047. protocol->store("disabled",8, system_charset_info);
  1048.       else
  1049.         protocol->store("", 0, system_charset_info);
  1050.       if (protocol->write())
  1051.         DBUG_RETURN(1); /* purecov: inspected */
  1052.     }
  1053.   }
  1054.   send_eof(thd);
  1055.   DBUG_RETURN(0);
  1056. }
  1059. /****************************************************************************
  1060.   Return only fields for API mysql_list_fields
  1061.   Use "show table wildcard" in mysql instead of this
  1062. ****************************************************************************/
  1064. void
  1065. mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild)
  1066. {
  1067.   TABLE *table;
  1068.   DBUG_ENTER("mysqld_list_fields");
  1069.   DBUG_PRINT("enter",("table: %s",table_list->real_name));
  1071.   if (!(table = open_ltable(thd, table_list, TL_UNLOCK)))
  1072.   {
  1073.     send_error(thd);
  1074.     DBUG_VOID_RETURN;
  1075.   }
  1076.   List<Item> field_list;
  1078.   Field **ptr,*field;
  1079.   for (ptr=table->field ; (field= *ptr); ptr++)
  1080.   {
  1081.     if (!wild || !wild[0] || 
  1082.         !wild_case_compare(system_charset_info, field->field_name,wild))
  1083.       field_list.push_back(new Item_field(field));
  1084.   }
  1085.   restore_record(table,default_values);              // Get empty record
  1086.   if (thd->protocol->send_fields(&field_list,2))
  1087.     DBUG_VOID_RETURN;
  1088.   thd->protocol->flush();
  1089.   DBUG_VOID_RETURN;
  1090. }
  1093. int
  1094. mysqld_dump_create_info(THD *thd, TABLE *table, int fd)
  1095. {
  1096.   Protocol *protocol= thd->protocol;
  1097.   String *packet= protocol->storage_packet();
  1098.   DBUG_ENTER("mysqld_dump_create_info");
  1099.   DBUG_PRINT("enter",("table: %s",table->real_name));
  1101.   protocol->prepare_for_resend();
  1102.   if (store_create_info(thd, table, packet))
  1103.     DBUG_RETURN(-1);
  1105.   if (fd < 0)
  1106.   {
  1107.     if (protocol->write())
  1108.       DBUG_RETURN(-1);
  1109.     protocol->flush();
  1110.   }
  1111.   else
  1112.   {
  1113.     if (my_write(fd, (const byte*) packet->ptr(), packet->length(),
  1114.  MYF(MY_WME)))
  1115.       DBUG_RETURN(-1);
  1116.   }
  1117.   DBUG_RETURN(0);
  1118. }
  1120. /*
  1121.   Go through all character combinations and ensure that sql_lex.cc can
  1122.   parse it as an identifer.
  1124.   SYNOPSIS
  1125.   require_quotes()
  1126.   name attribute name
  1127.   name_length length of name
  1129.   RETURN
  1130.     # Pointer to conflicting character
  1131.     0 No conflicting character
  1132. */
  1134. static const char *require_quotes(const char *name, uint name_length)
  1135. {
  1136.   uint length;
  1137.   const char *end= name + name_length;
  1139.   for ( ; name < end ; name++)
  1140.   {
  1141.     uchar chr= (uchar) *name;
  1142.     length= my_mbcharlen(system_charset_info, chr);
  1143.     if (length == 1 && !system_charset_info->ident_map[chr])
  1144.       return name;
  1145.   }
  1146.   return 0;
  1147. }
  1150. void
  1151. append_identifier(THD *thd, String *packet, const char *name, uint length)
  1152. {
  1153.   const char *name_end;
  1154.   char quote_char;
  1155.   int q= get_quote_char_for_identifier(thd, name, length);
  1157.   if (q == EOF)
  1158.   {
  1159.     packet->append(name, length, system_charset_info);
  1160.     return;
  1161.   }
  1163.   /*
  1164.     The identifier must be quoted as it includes a quote character or
  1165.    it's a keyword
  1166.   */
  1168.   packet->reserve(length*2 + 2);
  1169.   quote_char= (char) q;
  1170.   packet->append(&quote_char, 1, system_charset_info);
  1172.   for (name_end= name+length ; name < name_end ; name+= length)
  1173.   {
  1174.     uchar chr= (uchar) *name;
  1175.     length= my_mbcharlen(system_charset_info, chr);
  1176.     /*
  1177.       my_mbcharlen can retur 0 on a wrong multibyte
  1178.       sequence. It is possible when upgrading from 4.0,
  1179.       and identifier contains some accented characters.
  1180.       The manual says it does not work. So we'll just
  1181.       change length to 1 not to hang in the endless loop.
  1182.     */
  1183.     if (!length)
  1184.       length= 1;
  1185.     if (length == 1 && chr == (uchar) quote_char)
  1186.       packet->append(&quote_char, 1, system_charset_info);
  1187.     packet->append(name, length, packet->charset());
  1188.   }
  1189.   packet->append(&quote_char, 1, system_charset_info);
  1190. }
  1193. /*
  1194.   Get the quote character for displaying an identifier.
  1196.   SYNOPSIS
  1197.     get_quote_char_for_identifier()
  1198.     thd Thread handler
  1199.     name name to quote
  1200.     length length of name
  1202.   IMPLEMENTATION
  1203.     If name is a keyword or includes a special character, then force
  1204.     quoting.
  1205.     Otherwise identifier is quoted only if the option OPTION_QUOTE_SHOW_CREATE
  1206.     is set.
  1208.   RETURN
  1209.     EOF   No quote character is needed
  1210.     #   Quote character
  1211. */
  1213. int get_quote_char_for_identifier(THD *thd, const char *name, uint length)
  1214. {
  1215.   if (!is_keyword(name,length) &&
  1216.       !require_quotes(name, length) &&
  1217.       !(thd->options & OPTION_QUOTE_SHOW_CREATE))
  1218.     return EOF;
  1219.   if (thd->variables.sql_mode & MODE_ANSI_QUOTES)
  1220.     return '"';
  1221.   return '`';
  1222. }
  1225. /* Append directory name (if exists) to CREATE INFO */
  1227. static void append_directory(THD *thd, String *packet, const char *dir_type,
  1228.      const char *filename)
  1229. {
  1230.   if (filename && !(thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE))
  1231.   {
  1232.     uint length= dirname_length(filename);
  1233.     packet->append(' ');
  1234.     packet->append(dir_type);
  1235.     packet->append(" DIRECTORY='", 12);
  1236. #ifdef __WIN__
  1237.     char *winfilename = thd->memdup(filename, length);
  1238.     for (uint i=0; i < length; i++)
  1239.     if (winfilename[i] == '\')
  1240.     winfilename[i] = '/';
  1241.     packet->append(winfilename, length);
  1242. #else
  1243.     packet->append(filename, length);
  1244. #endif
  1245.     packet->append(''');
  1246.   }
  1247. }
  1250. #define LIST_PROCESS_HOST_LEN 64
  1252. static int
  1253. store_create_info(THD *thd, TABLE *table, String *packet)
  1254. {
  1255.   List<Item> field_list;
  1256.   char tmp[MAX_FIELD_WIDTH], *for_str, buff[128], *end, *alias;
  1257.   String type(tmp, sizeof(tmp), system_charset_info);
  1258.   Field **ptr,*field;
  1259.   uint primary_key;
  1260.   KEY *key_info;
  1261.   handler *file= table->file;
  1262.   HA_CREATE_INFO create_info;
  1263.   my_bool foreign_db_mode=    (thd->variables.sql_mode & (MODE_POSTGRESQL |
  1264.   MODE_ORACLE |
  1265.   MODE_MSSQL |
  1266.   MODE_DB2 |
  1267.   MODE_MAXDB |
  1268.   MODE_ANSI)) != 0;
  1269.   my_bool limited_mysql_mode= (thd->variables.sql_mode &
  1270.        (MODE_NO_FIELD_OPTIONS | MODE_MYSQL323 |
  1271. MODE_MYSQL40)) != 0;
  1273.   DBUG_ENTER("store_create_info");
  1274.   DBUG_PRINT("enter",("table: %s",table->real_name));
  1276.   restore_record(table,default_values); // Get empty record
  1278.   if (table->tmp_table)
  1279.     packet->append("CREATE TEMPORARY TABLE ", 23);
  1280.   else
  1281.     packet->append("CREATE TABLE ", 13);
  1282.   alias= (lower_case_table_names == 2 ? table->table_name :
  1283.   table->real_name);
  1284.   append_identifier(thd, packet, alias, strlen(alias));
  1285.   packet->append(" (n", 3);
  1287.   for (ptr=table->field ; (field= *ptr); ptr++)
  1288.   {
  1289.     bool has_default;
  1290.     bool has_now_default;
  1291.     uint flags = field->flags;
  1293.     if (ptr != table->field)
  1294.       packet->append(",n", 2);
  1296.     packet->append("  ", 2);
  1297.     append_identifier(thd,packet,field->field_name, strlen(field->field_name));
  1298.     packet->append(' ');
  1299.     // check for surprises from the previous call to Field::sql_type()
  1300.     if (type.ptr() != tmp)
  1301.       type.set(tmp, sizeof(tmp), system_charset_info);
  1302.     else
  1303.       type.set_charset(system_charset_info);
  1305.     field->sql_type(type);
  1306.     packet->append(type.ptr(), type.length(), system_charset_info);
  1308.     if (field->has_charset() && 
  1309.         !(thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)))
  1310.     {
  1311.       if (field->charset() != table->table_charset)
  1312.       {
  1313. packet->append(" character set ", 15);
  1314. packet->append(field->charset()->csname);
  1315.       }
  1316.       /* 
  1317. For string types dump collation name only if 
  1318. collation is not primary for the given charset
  1319.       */
  1320.       if (!(field->charset()->state & MY_CS_PRIMARY))
  1321.       {
  1322. packet->append(" collate ", 9);
  1323. packet->append(field->charset()->name);
  1324.       }
  1325.     }
  1327.     if (flags & NOT_NULL_FLAG)
  1328.       packet->append(" NOT NULL", 9);
  1329.     else if (field->type() == FIELD_TYPE_TIMESTAMP)
  1330.     {
  1331.       /*
  1332.         TIMESTAMP field require explicit NULL flag, because unlike
  1333.         all other fields they are treated as NOT NULL by default.
  1334.       */
  1335.       packet->append(" NULL", 5);
  1336.     }
  1338.     /* 
  1339.       Again we are using CURRENT_TIMESTAMP instead of NOW because it is
  1340.       more standard 
  1341.     */
  1342.     has_now_default= table->timestamp_field == field && 
  1343.                      field->unireg_check != Field::TIMESTAMP_UN_FIELD;
  1344.     
  1345.     has_default= (field->type() != FIELD_TYPE_BLOB &&
  1346.   field->unireg_check != Field::NEXT_NUMBER &&
  1347.                   !((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
  1348.                     has_now_default));
  1350.     if (has_default)
  1351.     {
  1352.       packet->append(" default ", 9);
  1353.       if (has_now_default)
  1354.         packet->append("CURRENT_TIMESTAMP",17);
  1355.       else if (!field->is_null())
  1356.       {                                             // Not null by default
  1357.         type.set(tmp, sizeof(tmp), field->charset());
  1358.         field->val_str(&type);
  1359. if (type.length())
  1360. {
  1361.   String def_val;
  1362.           uint dummy_errors;
  1363.   /* convert to system_charset_info == utf8 */
  1364.   def_val.copy(type.ptr(), type.length(), field->charset(),
  1365.        system_charset_info, &dummy_errors);
  1366.           append_unescaped(packet, def_val.ptr(), def_val.length());
  1367. }
  1368.         else
  1369.   packet->append("''",2);
  1370.       }
  1371.       else if (field->maybe_null())
  1372.         packet->append("NULL", 4);                    // Null as default
  1373.       else
  1374.         packet->append(tmp);
  1375.     }
  1377.     if (!(thd->variables.sql_mode & MODE_NO_FIELD_OPTIONS) &&
  1378.         table->timestamp_field == field && 
  1379.         field->unireg_check != Field::TIMESTAMP_DN_FIELD)
  1380.       packet->append(" on update CURRENT_TIMESTAMP",28);
  1382.     if (field->unireg_check == Field::NEXT_NUMBER && 
  1383.         !(thd->variables.sql_mode & MODE_NO_FIELD_OPTIONS))
  1384.       packet->append(" auto_increment", 15 );
  1386.     if (field->comment.length)
  1387.     {
  1388.       packet->append(" COMMENT ",9);
  1389.       append_unescaped(packet, field->comment.str, field->comment.length);
  1390.     }
  1391.   }
  1393.   key_info= table->key_info;
  1394.   file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK | HA_STATUS_TIME);
  1395.   bzero((char*) &create_info, sizeof(create_info));
  1396.   file->update_create_info(&create_info);
  1397.   primary_key= table->primary_key;
  1399.   for (uint i=0 ; i < table->keys ; i++,key_info++)
  1400.   {
  1401.     KEY_PART_INFO *key_part= key_info->key_part;
  1402.     bool found_primary=0;
  1403.     packet->append(",n  ", 4);
  1405.     if (i == primary_key && !strcmp(key_info->name, primary_key_name))
  1406.     {
  1407.       found_primary=1;
  1408.       packet->append("PRIMARY ", 8);
  1409.     }
  1410.     else if (key_info->flags & HA_NOSAME)
  1411.       packet->append("UNIQUE ", 7);
  1412.     else if (key_info->flags & HA_FULLTEXT)
  1413.       packet->append("FULLTEXT ", 9);
  1414.     else if (key_info->flags & HA_SPATIAL)
  1415.       packet->append("SPATIAL ", 8);
  1416.     packet->append("KEY ", 4);
  1418.     if (!found_primary)
  1419.      append_identifier(thd, packet, key_info->name, strlen(key_info->name));
  1421.     if (!(thd->variables.sql_mode & MODE_NO_KEY_OPTIONS) &&
  1422. !limited_mysql_mode && !foreign_db_mode)
  1423.     {
  1424.       if (key_info->algorithm == HA_KEY_ALG_BTREE)
  1425. packet->append(" USING BTREE", 12);
  1426.       
  1427.       if (key_info->algorithm == HA_KEY_ALG_HASH)
  1428. packet->append(" USING HASH", 11);
  1429.       
  1430.       // +BAR: send USING only in non-default case: non-spatial rtree
  1431.       if ((key_info->algorithm == HA_KEY_ALG_RTREE) &&
  1432.   !(key_info->flags & HA_SPATIAL))
  1433. packet->append(" USING RTREE", 12);
  1435.       // No need to send TYPE FULLTEXT, it is sent as FULLTEXT KEY
  1436.     }
  1437.     packet->append(" (", 2);
  1439.     for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
  1440.     {
  1441.       if (j)
  1442.         packet->append(',');
  1444.       if (key_part->field)
  1445.         append_identifier(thd,packet,key_part->field->field_name,
  1446.   strlen(key_part->field->field_name));
  1447.       if (!key_part->field ||
  1448.           (key_part->length !=
  1449.            table->field[key_part->fieldnr-1]->key_length() &&
  1450.            !(key_info->flags & HA_FULLTEXT)))
  1451.       {
  1452.         buff[0] = '(';
  1453.         char* end=int10_to_str((long) key_part->length / 
  1454.        key_part->field->charset()->mbmaxlen,
  1455.        buff + 1,10);
  1456.         *end++ = ')';
  1457.         packet->append(buff,(uint) (end-buff));
  1458.       }
  1459.     }
  1460.     packet->append(')');
  1461.   }
  1463.   /*
  1464.     Get possible foreign key definitions stored in InnoDB and append them
  1465.     to the CREATE TABLE statement
  1466.   */
  1468.   if ((for_str= file->get_foreign_key_create_info()))
  1469.   {
  1470.     packet->append(for_str, strlen(for_str));
  1471.     file->free_foreign_key_create_info(for_str);
  1472.   }
  1474.   packet->append("n)", 2);
  1475.   if (!(thd->variables.sql_mode & MODE_NO_TABLE_OPTIONS) && !foreign_db_mode)
  1476.   {
  1477.     if (thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40))
  1478.       packet->append(" TYPE=", 6);
  1479.     else
  1480.       packet->append(" ENGINE=", 8);
  1481.     packet->append(file->table_type());
  1482.     
  1483.     if (table->table_charset &&
  1484. !(thd->variables.sql_mode & MODE_MYSQL323) &&
  1485. !(thd->variables.sql_mode & MODE_MYSQL40))
  1486.     {
  1487.       packet->append(" DEFAULT CHARSET=", 17);
  1488.       packet->append(table->table_charset->csname);
  1489.       if (!(table->table_charset->state & MY_CS_PRIMARY))
  1490.       {
  1491. packet->append(" COLLATE=", 9);
  1492. packet->append(table->table_charset->name);
  1493.       }
  1494.     }
  1496.     if (table->min_rows)
  1497.     {
  1498.       packet->append(" MIN_ROWS=", 10);
  1499.       end= longlong10_to_str(table->min_rows, buff, 10);
  1500.       packet->append(buff, (uint) (end- buff));
  1501.     }
  1503.     if (table->max_rows)
  1504.     {
  1505.       packet->append(" MAX_ROWS=", 10);
  1506.       end= longlong10_to_str(table->max_rows, buff, 10);
  1507.       packet->append(buff, (uint) (end - buff));
  1508.     }
  1510.     if (table->avg_row_length)
  1511.     {
  1512.       packet->append(" AVG_ROW_LENGTH=", 16);
  1513.       end= longlong10_to_str(table->avg_row_length, buff,10);
  1514.       packet->append(buff, (uint) (end - buff));
  1515.     }
  1517.     if (table->db_create_options & HA_OPTION_PACK_KEYS)
  1518.       packet->append(" PACK_KEYS=1", 12);
  1519.     if (table->db_create_options & HA_OPTION_NO_PACK_KEYS)
  1520.       packet->append(" PACK_KEYS=0", 12);
  1521.     if (table->db_create_options & HA_OPTION_CHECKSUM)
  1522.       packet->append(" CHECKSUM=1", 11);
  1523.     if (table->db_create_options & HA_OPTION_DELAY_KEY_WRITE)
  1524.       packet->append(" DELAY_KEY_WRITE=1",18);
  1525.     if (table->row_type != ROW_TYPE_DEFAULT)
  1526.     {
  1527.       packet->append(" ROW_FORMAT=",12);
  1528.       packet->append(ha_row_type[(uint) table->row_type]);
  1529.     }
  1530.     table->file->append_create_info(packet);
  1531.     if (table->comment && table->comment[0])
  1532.     {
  1533.       packet->append(" COMMENT=", 9);
  1534.       append_unescaped(packet, table->comment, strlen(table->comment));
  1535.     }
  1536.     if (file->raid_type)
  1537.     {
  1538.       uint length;
  1539.       length= my_snprintf(buff,sizeof(buff),
  1540.   " RAID_TYPE=%s RAID_CHUNKS=%d RAID_CHUNKSIZE=%ld",
  1541.   my_raid_type(file->raid_type), file->raid_chunks,
  1542.   file->raid_chunksize/RAID_BLOCK_SIZE);
  1543.       packet->append(buff, length);
  1544.     }
  1545.     append_directory(thd, packet, "DATA",  create_info.data_file_name);
  1546.     append_directory(thd, packet, "INDEX", create_info.index_file_name);
  1547.   }
  1548.   DBUG_RETURN(0);
  1549. }
  1552. /****************************************************************************
  1553.   Return info about all processes
  1554.   returns for each thread: thread id, user, host, db, command, info
  1555. ****************************************************************************/
  1557. class thread_info :public ilink {
  1558. public:
  1559.   static void *operator new(size_t size) {return (void*) sql_alloc((uint) size); }
  1560.   static void operator delete(void *ptr __attribute__((unused)),
  1561.                               size_t size __attribute__((unused))) {} /*lint -e715 */
  1563.   ulong thread_id;
  1564.   time_t start_time;
  1565.   uint   command;
  1566.   const char *user,*host,*db,*proc_info,*state_info;
  1567.   char *query;
  1568. };
  1570. #ifdef __GNUC__
  1571. template class I_List<thread_info>;
  1572. #endif
  1574. void mysqld_list_processes(THD *thd,const char *user, bool verbose)
  1575. {
  1576.   Item *field;
  1577.   List<Item> field_list;
  1578.   I_List<thread_info> thread_infos;
  1579.   ulong max_query_length= (verbose ? thd->variables.max_allowed_packet :
  1580.    PROCESS_LIST_WIDTH);
  1581.   Protocol *protocol= thd->protocol;
  1582.   DBUG_ENTER("mysqld_list_processes");
  1584.   field_list.push_back(new Item_int("Id",0,11));
  1585.   field_list.push_back(new Item_empty_string("User",16));
  1586.   field_list.push_back(new Item_empty_string("Host",LIST_PROCESS_HOST_LEN));
  1587.   field_list.push_back(field=new Item_empty_string("db",NAME_LEN));
  1588.   field->maybe_null=1;
  1589.   field_list.push_back(new Item_empty_string("Command",16));
  1590.   field_list.push_back(new Item_return_int("Time",7, FIELD_TYPE_LONG));
  1591.   field_list.push_back(field=new Item_empty_string("State",30));
  1592.   field->maybe_null=1;
  1593.   field_list.push_back(field=new Item_empty_string("Info",max_query_length));
  1594.   field->maybe_null=1;
  1595.   if (protocol->send_fields(&field_list,1))
  1596.     DBUG_VOID_RETURN;
  1598.   VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
  1599.   if (!thd->killed)
  1600.   {
  1601.     I_List_iterator<THD> it(threads);
  1602.     THD *tmp;
  1603.     while ((tmp=it++))
  1604.     {
  1605.       struct st_my_thread_var *mysys_var;
  1606.       if ((tmp->vio_ok() || tmp->system_thread) &&
  1607.           (!user || (tmp->user && !strcmp(tmp->user,user))))
  1608.       {
  1609.         thread_info *thd_info=new thread_info;
  1611.         thd_info->thread_id=tmp->thread_id;
  1612.         thd_info->user=thd->strdup(tmp->user ? tmp->user :
  1613.    (tmp->system_thread ?
  1614.     "system user" : "unauthenticated user"));
  1615. if (tmp->peer_port && (tmp->host || tmp->ip) && thd->host_or_ip[0])
  1616. {
  1617.   if ((thd_info->host= thd->alloc(LIST_PROCESS_HOST_LEN+1)))
  1618.     my_snprintf((char *) thd_info->host, LIST_PROCESS_HOST_LEN,
  1619. "%s:%u", tmp->host_or_ip, tmp->peer_port);
  1620. }
  1621. else
  1622.   thd_info->host= thd->strdup(tmp->host_or_ip);
  1623.         if ((thd_info->db=tmp->db))             // Safe test
  1624.           thd_info->db=thd->strdup(thd_info->db);
  1625.         thd_info->command=(int) tmp->command;
  1626.         if ((mysys_var= tmp->mysys_var))
  1627.           pthread_mutex_lock(&mysys_var->mutex);
  1628.         thd_info->proc_info= (char*) (tmp->killed ? "Killed" : 0);
  1629. #ifndef EMBEDDED_LIBRARY
  1630.         thd_info->state_info= (char*) (tmp->locked ? "Locked" :
  1631.                                        tmp->net.reading_or_writing ?
  1632.                                        (tmp->net.reading_or_writing == 2 ?
  1633.                                         "Writing to net" :
  1634.                                         thd_info->command == COM_SLEEP ? "" :
  1635.                                         "Reading from net") :
  1636.                                        tmp->proc_info ? tmp->proc_info :
  1637.                                        tmp->mysys_var &&
  1638.                                        tmp->mysys_var->current_cond ?
  1639.                                        "Waiting on cond" : NullS);
  1640. #else
  1641.         thd_info->state_info= (char*)"Writing to net";
  1642. #endif
  1643.         if (mysys_var)
  1644.           pthread_mutex_unlock(&mysys_var->mutex);
  1646. #if !defined(DONT_USE_THR_ALARM) && ! defined(SCO)
  1647.         if (pthread_kill(tmp->real_id,0))
  1648.           tmp->proc_info="*** DEAD ***";        // This shouldn't happen
  1649. #endif
  1650. #ifdef EXTRA_DEBUG
  1651.         thd_info->start_time= tmp->time_after_lock;
  1652. #else
  1653.         thd_info->start_time= tmp->start_time;
  1654. #endif
  1655.         thd_info->query=0;
  1656.         if (tmp->query)
  1657.         {
  1658.   /* 
  1659.             query_length is always set to 0 when we set query = NULL; see
  1660.     the comment in sql_class.h why this prevents crashes in possible
  1661.             races with query_length
  1662.           */
  1663.           uint length= min(max_query_length, tmp->query_length);
  1664.           thd_info->query=(char*) thd->strmake(tmp->query,length);
  1665.         }
  1666.         thread_infos.append(thd_info);
  1667.       }
  1668.     }
  1669.   }
  1670.   VOID(pthread_mutex_unlock(&LOCK_thread_count));
  1672.   thread_info *thd_info;
  1673.   time_t now= time(0);
  1674.   while ((thd_info=thread_infos.get()))
  1675.   {
  1676.     protocol->prepare_for_resend();
  1677.     protocol->store((ulonglong) thd_info->thread_id);
  1678.     protocol->store(thd_info->user, system_charset_info);
  1679.     protocol->store(thd_info->host, system_charset_info);
  1680.     protocol->store(thd_info->db, system_charset_info);
  1681.     if (thd_info->proc_info)
  1682.       protocol->store(thd_info->proc_info, system_charset_info);
  1683.     else
  1684.       protocol->store(command_name[thd_info->command], system_charset_info);
  1685.     if (thd_info->start_time)
  1686.       protocol->store((uint32) (now - thd_info->start_time));
  1687.     else
  1688.       protocol->store_null();
  1689.     protocol->store(thd_info->state_info, system_charset_info);
  1690.     protocol->store(thd_info->query, system_charset_info);
  1691.     if (protocol->write())
  1692.       break; /* purecov: inspected */
  1693.   }
  1694.   send_eof(thd);
  1695.   DBUG_VOID_RETURN;
  1696. }
  1698. /*****************************************************************************
  1699.   Status functions
  1700. *****************************************************************************/
  1702. static bool write_collation(Protocol *protocol, CHARSET_INFO *cs)
  1703. {
  1704.   protocol->prepare_for_resend();
  1705.   protocol->store(cs->name, system_charset_info);
  1706.   protocol->store(cs->csname, system_charset_info);
  1707.   protocol->store_short((longlong) cs->number);
  1708.   protocol->store((cs->state & MY_CS_PRIMARY) ? "Yes" : "",system_charset_info);
  1709.   protocol->store((cs->state & MY_CS_COMPILED)? "Yes" : "",system_charset_info);
  1710.   protocol->store_short((longlong) cs->strxfrm_multiply);
  1711.   return protocol->write();
  1712. }
  1714. int mysqld_show_collations(THD *thd, const char *wild)
  1715. {
  1716.   char buff[8192];
  1717.   String packet2(buff,sizeof(buff),thd->charset());
  1718.   List<Item> field_list;
  1719.   CHARSET_INFO **cs;
  1720.   Protocol *protocol= thd->protocol;
  1722.   DBUG_ENTER("mysqld_show_charsets");
  1724.   field_list.push_back(new Item_empty_string("Collation",30));
  1725.   field_list.push_back(new Item_empty_string("Charset",30));
  1726.   field_list.push_back(new Item_return_int("Id",11, FIELD_TYPE_SHORT));
  1727.   field_list.push_back(new Item_empty_string("Default",30));
  1728.   field_list.push_back(new Item_empty_string("Compiled",30));
  1729.   field_list.push_back(new Item_return_int("Sortlen",3, FIELD_TYPE_SHORT));
  1731.   if (protocol->send_fields(&field_list, 1))
  1732.     DBUG_RETURN(1);
  1734.   for ( cs= all_charsets ; cs < all_charsets+255 ; cs++ )
  1735.   {
  1736.     CHARSET_INFO **cl;
  1737.     if (!cs[0] || !(cs[0]->state & MY_CS_AVAILABLE) || 
  1738.         !(cs[0]->state & MY_CS_PRIMARY))
  1739.       continue;
  1740.     for ( cl= all_charsets; cl < all_charsets+255 ;cl ++)
  1741.     {
  1742.       if (!cl[0] || !(cl[0]->state & MY_CS_AVAILABLE) || 
  1743.           !my_charset_same(cs[0],cl[0]))
  1744. continue;
  1745.       if (!(wild && wild[0] &&
  1746.   wild_case_compare(system_charset_info,cl[0]->name,wild)))
  1747.       {
  1748.         if (write_collation(protocol, cl[0]))
  1749.   goto err;
  1750.       }
  1751.     }
  1752.   }
  1753.   send_eof(thd); 
  1754.   DBUG_RETURN(0);
  1755. err:
  1756.   DBUG_RETURN(1);
  1757. }
  1759. static bool write_charset(Protocol *protocol, CHARSET_INFO *cs)
  1760. {
  1761.   protocol->prepare_for_resend();
  1762.   protocol->store(cs->csname, system_charset_info);
  1763.   protocol->store(cs->comment ? cs->comment : "", system_charset_info);
  1764.   protocol->store(cs->name, system_charset_info);
  1765.   protocol->store_short((longlong) cs->mbmaxlen);
  1766.   return protocol->write();
  1767. }
  1769. int mysqld_show_charsets(THD *thd, const char *wild)
  1770. {
  1771.   char buff[8192];
  1772.   String packet2(buff,sizeof(buff),thd->charset());
  1773.   List<Item> field_list;
  1774.   CHARSET_INFO **cs;
  1775.   Protocol *protocol= thd->protocol;
  1777.   DBUG_ENTER("mysqld_show_charsets");
  1779.   field_list.push_back(new Item_empty_string("Charset",30));
  1780.   field_list.push_back(new Item_empty_string("Description",60));
  1781.   field_list.push_back(new Item_empty_string("Default collation",60));
  1782.   field_list.push_back(new Item_return_int("Maxlen",3, FIELD_TYPE_SHORT));
  1784.   if (protocol->send_fields(&field_list, 1))
  1785.     DBUG_RETURN(1);
  1787.   for ( cs= all_charsets ; cs < all_charsets+255 ; cs++ )
  1788.   {
  1789.     if (cs[0] && (cs[0]->state & MY_CS_PRIMARY) && 
  1790.         (cs[0]->state & MY_CS_AVAILABLE) &&
  1791.         !(wild && wild[0] &&
  1792.         wild_case_compare(system_charset_info,cs[0]->csname,wild)))
  1793.     {
  1794.       if (write_charset(protocol, cs[0]))
  1795. goto err;
  1796.     }
  1797.   }
  1798.   send_eof(thd); 
  1799.   DBUG_RETURN(0);
  1800. err:
  1801.   DBUG_RETURN(1);
  1802. }
  1804.   
  1806. int mysqld_show(THD *thd, const char *wild, show_var_st *variables,
  1807. enum enum_var_type value_type,
  1808. pthread_mutex_t *mutex)
  1809. {
  1810.   char buff[1024];
  1811.   List<Item> field_list;
  1812.   Protocol *protocol= thd->protocol;
  1813.   LEX_STRING null_lex_str;
  1814.   DBUG_ENTER("mysqld_show");
  1816.   field_list.push_back(new Item_empty_string("Variable_name",30));
  1817.   field_list.push_back(new Item_empty_string("Value",256));
  1818.   if (protocol->send_fields(&field_list,1))
  1819.     DBUG_RETURN(1); /* purecov: inspected */
  1820.   null_lex_str.str= 0; // For sys_var->value_ptr()
  1821.   null_lex_str.length= 0;
  1823.   pthread_mutex_lock(mutex);
  1824.   for (; variables->name; variables++)
  1825.   {
  1826.     if (!(wild && wild[0] && wild_case_compare(system_charset_info,
  1827.        variables->name,wild)))
  1828.     {
  1829.       protocol->prepare_for_resend();
  1830.       protocol->store(variables->name, system_charset_info);
  1831.       SHOW_TYPE show_type=variables->type;
  1832.       char *value=variables->value;
  1833.       const char *pos, *end;
  1834.       long nr;
  1836.       if (show_type == SHOW_SYS)
  1837.       {
  1838. show_type= ((sys_var*) value)->type();
  1839. value=     (char*) ((sys_var*) value)->value_ptr(thd, value_type,
  1840.  &null_lex_str);
  1841.       }
  1843.       pos= end= buff;
  1844.       switch (show_type) {
  1845.       case SHOW_LONG:
  1846.       case SHOW_LONG_CONST:
  1847. end= int10_to_str(*(long*) value, buff, 10);
  1848.         break;
  1849.       case SHOW_LONGLONG:
  1850. end= longlong10_to_str(*(longlong*) value, buff, 10);
  1851. break;
  1852.       case SHOW_HA_ROWS:
  1853.         end= longlong10_to_str((longlong) *(ha_rows*) value, buff, 10);
  1854.         break;
  1855.       case SHOW_BOOL:
  1856. end= strmov(buff, *(bool*) value ? "ON" : "OFF");
  1857.         break;
  1858.       case SHOW_MY_BOOL:
  1859. end= strmov(buff, *(my_bool*) value ? "ON" : "OFF");
  1860.         break;
  1861.       case SHOW_INT_CONST:
  1862.       case SHOW_INT:
  1863. end= int10_to_str((long) *(uint32*) value, buff, 10);
  1864.         break;
  1865.       case SHOW_HAVE:
  1866.       {
  1867. SHOW_COMP_OPTION tmp= *(SHOW_COMP_OPTION*) value;
  1868. pos= show_comp_option_name[(int) tmp];
  1869. end= strend(pos);
  1870.         break;
  1871.       }
  1872.       case SHOW_CHAR:
  1873.       {
  1874.         if (!(pos= value))
  1875.           pos= "";
  1876.         end= strend(pos);
  1877.         break;
  1878.        }
  1879.       case SHOW_STARTTIME:
  1880. nr= (long) (thd->query_start() - start_time);
  1881. end= int10_to_str(nr, buff, 10);
  1882.         break;
  1883.       case SHOW_QUESTION:
  1884. end= int10_to_str((long) thd->query_id, buff, 10);
  1885.         break;
  1886. #ifdef HAVE_REPLICATION
  1887.       case SHOW_RPL_STATUS:
  1888. end= strmov(buff, rpl_status_type[(int)rpl_status]);
  1889. break;
  1890.       case SHOW_SLAVE_RUNNING:
  1891.       {
  1892. pthread_mutex_lock(&LOCK_active_mi);
  1893. end= strmov(buff, (active_mi && active_mi->slave_running &&
  1894.    active_mi->rli.slave_running) ? "ON" : "OFF");
  1895. pthread_mutex_unlock(&LOCK_active_mi);
  1896. break;
  1897.       }
  1898.       case SHOW_SLAVE_RETRIED_TRANS:
  1899.       {
  1900.         /*
  1901.           TODO: in 5.1 with multimaster, have one such counter per line in SHOW
  1902.           SLAVE STATUS, and have the sum over all lines here.
  1903.         */
  1904. pthread_mutex_lock(&LOCK_active_mi);
  1905.         if (active_mi)
  1906.         {
  1907.           pthread_mutex_lock(&active_mi->rli.data_lock);
  1908.           end= int10_to_str(active_mi->rli.retried_trans, buff, 10);
  1909.           pthread_mutex_unlock(&active_mi->rli.data_lock);
  1910.         }
  1911. pthread_mutex_unlock(&LOCK_active_mi);
  1912. break;
  1913.       }
  1914. #endif /* HAVE_REPLICATION */
  1915.       case SHOW_OPENTABLES:
  1916. end= int10_to_str((long) cached_tables(), buff, 10);
  1917.         break;
  1918.       case SHOW_CHAR_PTR:
  1919.       {
  1920.         if (!(pos= *(char**) value))
  1921.           pos= "";
  1922.         end= strend(pos);
  1923.         break;
  1924.       }
  1925. #ifdef HAVE_OPENSSL
  1926. /* First group - functions relying on CTX */
  1927.       case SHOW_SSL_CTX_SESS_ACCEPT:
  1928. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1929.   SSL_CTX_sess_accept(ssl_acceptor_fd->
  1930.       ssl_context)),
  1931.   buff, 10);
  1932.         break;
  1933.       case SHOW_SSL_CTX_SESS_ACCEPT_GOOD:
  1934. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1935.   SSL_CTX_sess_accept_good(ssl_acceptor_fd->
  1936.    ssl_context)),
  1937.   buff, 10);
  1938.         break;
  1939.       case SHOW_SSL_CTX_SESS_CONNECT_GOOD:
  1940. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1941.   SSL_CTX_sess_connect_good(ssl_acceptor_fd->
  1942.     ssl_context)),
  1943.   buff, 10);
  1944.         break;
  1945.       case SHOW_SSL_CTX_SESS_ACCEPT_RENEGOTIATE:
  1946. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1947.   SSL_CTX_sess_accept_renegotiate(ssl_acceptor_fd->ssl_context)),
  1948.   buff, 10);
  1949.         break;
  1950.       case SHOW_SSL_CTX_SESS_CONNECT_RENEGOTIATE:
  1951. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1952.   SSL_CTX_sess_connect_renegotiate(ssl_acceptor_fd-> ssl_context)),
  1953.   buff, 10);
  1954.         break;
  1955.       case SHOW_SSL_CTX_SESS_CB_HITS:
  1956. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1957.   SSL_CTX_sess_cb_hits(ssl_acceptor_fd->
  1958.        ssl_context)),
  1959.   buff, 10);
  1960.         break;
  1961.       case SHOW_SSL_CTX_SESS_HITS:
  1962. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1963.   SSL_CTX_sess_hits(ssl_acceptor_fd->
  1964.     ssl_context)),
  1965.   buff, 10);
  1966.         break;
  1967.       case SHOW_SSL_CTX_SESS_CACHE_FULL:
  1968. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1969.   SSL_CTX_sess_cache_full(ssl_acceptor_fd->
  1970.   ssl_context)),
  1971.   buff, 10);
  1972.         break;
  1973.       case SHOW_SSL_CTX_SESS_MISSES:
  1974. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1975.   SSL_CTX_sess_misses(ssl_acceptor_fd->
  1976.       ssl_context)),
  1977.   buff, 10);
  1978.         break;
  1979.       case SHOW_SSL_CTX_SESS_TIMEOUTS:
  1980. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1981.   SSL_CTX_sess_timeouts(ssl_acceptor_fd->ssl_context)),
  1982.   buff,10);
  1983.         break;
  1984.       case SHOW_SSL_CTX_SESS_NUMBER:
  1985. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1986.   SSL_CTX_sess_number(ssl_acceptor_fd->ssl_context)),
  1987.   buff,10);
  1988.         break;
  1989.       case SHOW_SSL_CTX_SESS_CONNECT:
  1990. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1991.   SSL_CTX_sess_connect(ssl_acceptor_fd->ssl_context)),
  1992.   buff,10);
  1993.         break;
  1994.       case SHOW_SSL_CTX_SESS_GET_CACHE_SIZE:
  1995. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  1996.   SSL_CTX_sess_get_cache_size(ssl_acceptor_fd->ssl_context)),
  1997.   buff,10);
  1998.         break;
  1999.       case SHOW_SSL_CTX_GET_VERIFY_MODE:
  2000. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  2001.   SSL_CTX_get_verify_mode(ssl_acceptor_fd->ssl_context)),
  2002.   buff,10);
  2003.         break;
  2004.       case SHOW_SSL_CTX_GET_VERIFY_DEPTH:
  2005. end= int10_to_str((long) (!ssl_acceptor_fd ? 0 :
  2006.   SSL_CTX_get_verify_depth(ssl_acceptor_fd->ssl_context)),
  2007.   buff,10);
  2008.         break;
  2009.       case SHOW_SSL_CTX_GET_SESSION_CACHE_MODE:
  2010. if (!ssl_acceptor_fd)
  2011. {
  2012.   pos= "NONE";
  2013.   end= pos+4;
  2014.   break;
  2015. }
  2016. switch (SSL_CTX_get_session_cache_mode(ssl_acceptor_fd->ssl_context))
  2017. {
  2018.           case SSL_SESS_CACHE_OFF:
  2019.             pos= "OFF";
  2020.     break;
  2021.           case SSL_SESS_CACHE_CLIENT:
  2022.             pos= "CLIENT";
  2023.     break;
  2024.           case SSL_SESS_CACHE_SERVER:
  2025.             pos= "SERVER";
  2026.     break;
  2027.           case SSL_SESS_CACHE_BOTH:
  2028.             pos= "BOTH";
  2029.     break;
  2030.           case SSL_SESS_CACHE_NO_AUTO_CLEAR:
  2031.             pos= "NO_AUTO_CLEAR";
  2032.     break;
  2033.           case SSL_SESS_CACHE_NO_INTERNAL_LOOKUP:
  2034.             pos= "NO_INTERNAL_LOOKUP";
  2035.     break;
  2036.   default:
  2037.             pos= "Unknown";
  2038.     break;
  2039. }
  2040. end= strend(pos);
  2041.         break;
  2042. /* First group - functions relying on SSL */
  2043.       case SHOW_SSL_GET_VERSION:
  2044. pos= (thd->net.vio->ssl_arg ?
  2045.       SSL_get_version((SSL*) thd->net.vio->ssl_arg) : "");
  2046. end= strend(pos);
  2047.         break;
  2048.       case SHOW_SSL_SESSION_REUSED:
  2049. end= int10_to_str((long) (thd->net.vio->ssl_arg ?
  2050.   SSL_session_reused((SSL*) thd->net.vio->
  2051.      ssl_arg) :
  2052.   0),
  2053.   buff, 10);
  2054.         break;
  2055.       case SHOW_SSL_GET_DEFAULT_TIMEOUT:
  2056. end= int10_to_str((long) (thd->net.vio->ssl_arg ?
  2057.   SSL_get_default_timeout((SSL*) thd->net.vio->
  2058.   ssl_arg) :
  2059.   0),
  2060.   buff, 10);
  2061.         break;
  2062.       case SHOW_SSL_GET_VERIFY_MODE:
  2063. end= int10_to_str((long) (thd->net.vio->ssl_arg ?
  2064.   SSL_get_verify_mode((SSL*) thd->net.vio->
  2065.       ssl_arg):
  2066.   0),
  2067.   buff, 10);
  2068.         break;
  2069.       case SHOW_SSL_GET_VERIFY_DEPTH:
  2070. end= int10_to_str((long) (thd->net.vio->ssl_arg ?
  2071.   SSL_get_verify_depth((SSL*) thd->net.vio->
  2072.        ssl_arg):
  2073.   0),
  2074.   buff, 10);
  2075.         break;
  2076.       case SHOW_SSL_GET_CIPHER:
  2077. pos= (thd->net.vio->ssl_arg ?
  2078.       SSL_get_cipher((SSL*) thd->net.vio->ssl_arg) : "" );
  2079. end= strend(pos);
  2080. break;
  2081.       case SHOW_SSL_GET_CIPHER_LIST:
  2082. if (thd->net.vio->ssl_arg)
  2083. {
  2084.   char *to= buff;
  2085.   for (int i=0 ; i++ ;)
  2086.   {
  2087.     const char *p= SSL_get_cipher_list((SSL*) thd->net.vio->ssl_arg,i);
  2088.     if (p == NULL) 
  2089.       break;
  2090.     to= strmov(to, p);
  2091.     *to++= ':';
  2092.   }
  2093.   if (to != buff)
  2094.     to--; // Remove last ':'
  2095.   end= to;
  2096.         }
  2097.         break;
  2099. #endif /* HAVE_OPENSSL */
  2100.       case SHOW_KEY_CACHE_LONG:
  2101.       case SHOW_KEY_CACHE_CONST_LONG:
  2102. value= (value-(char*) &dflt_key_cache_var)+ (char*) dflt_key_cache;
  2103. end= int10_to_str(*(long*) value, buff, 10);
  2104.         break;
  2105.       case SHOW_KEY_CACHE_LONGLONG:
  2106. value= (value-(char*) &dflt_key_cache_var)+ (char*) dflt_key_cache;
  2107. end= longlong10_to_str(*(longlong*) value, buff, 10);
  2108. break;
  2109.       case SHOW_UNDEF: // Show never happen
  2110.       case SHOW_SYS:
  2111. break; // Return empty string
  2112.       default:
  2113. break;
  2114.       }
  2115.       if (protocol->store(pos, (uint32) (end - pos), system_charset_info) ||
  2116.   protocol->write())
  2117.         goto err;                               /* purecov: inspected */
  2118.     }
  2119.   }
  2120.   pthread_mutex_unlock(mutex);
  2121.   send_eof(thd);
  2122.   DBUG_RETURN(0);
  2124.  err:
  2125.   pthread_mutex_unlock(mutex);
  2126.   DBUG_RETURN(1);
  2127. }
  2129. #ifdef __GNUC__
  2130. template class List_iterator_fast<char>;
  2131. template class List<char>;
  2132. #endif