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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
sql_table.cc
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：49k
源码类别：

MySQL数据库

开发平台：

Visual C++

sql_table.cc：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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. /* drop and alter of tables */
  20. #include "mysql_priv.h"
  21. #include <hash.h>
  22. #include <myisam.h>
  24. #ifdef __WIN__
  25. #include <io.h>
  26. #endif
  28. extern HASH open_cache;
  30. static bool check_if_keyname_exists(const char *name,KEY *start, KEY *end);
  31. static char *make_unique_key_name(const char *field_name,KEY *start,KEY *end);
  32. static int copy_data_between_tables(TABLE *from,TABLE *to,
  33.     List<create_field> &create,
  34.     enum enum_duplicates handle_duplicates,
  35.                                     ORDER *order,
  36.     ha_rows *copied,ha_rows *deleted);
  38. /*****************************************************************************
  39. ** Remove all possbile tables and give a compact errormessage for all
  40. ** wrong tables.
  41. ** This will wait for all users to free the table before dropping it
  42. *****************************************************************************/
  44. int mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists)
  45. {
  46.   char path[FN_REFLEN];
  47.   String wrong_tables;
  48.   bool some_tables_deleted=0;
  49.   uint error;
  50.   db_type table_type;
  51.   TABLE_LIST *table;
  52.   DBUG_ENTER("mysql_rm_table");
  54.   /* mark for close and remove all cached entries */
  56.   pthread_mutex_lock(&thd->mysys_var->mutex);
  57.   thd->mysys_var->current_mutex= &LOCK_open;
  58.   thd->mysys_var->current_cond= &COND_refresh;
  59.   VOID(pthread_mutex_lock(&LOCK_open));
  60.   pthread_mutex_unlock(&thd->mysys_var->mutex);
  62.   if(global_read_lock)
  63.   {
  64.     if(thd->global_read_lock)
  65.     {
  66.       my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE,MYF(0),
  67.        tables->real_name);
  68.       error = 1;
  69.       goto err;
  70.     }
  71.     while (global_read_lock && ! thd->killed)
  72.     {
  73.       (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
  74.     }
  76.   }
  77.   
  78.   for (table=tables ; table ; table=table->next)
  79.   {
  80.     char *db=table->db ? table->db : thd->db;
  81.     if (!close_temporary_table(thd, db, table->real_name))
  82.     {
  83.       some_tables_deleted=1; // Log query
  84.       continue; // removed temporary table
  85.     }
  87.     abort_locked_tables(thd,db,table->real_name);
  88.     while (remove_table_from_cache(thd,db,table->real_name) && !thd->killed)
  89.     {
  90.       dropping_tables++;
  91.       (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
  92.       dropping_tables--;
  93.     }
  94.     drop_locked_tables(thd,db,table->real_name);
  95.     if (thd->killed)
  96.     {
  97.       VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
  98.       VOID(pthread_mutex_unlock(&LOCK_open));
  99.       pthread_mutex_lock(&thd->mysys_var->mutex);
  100.       thd->mysys_var->current_mutex= 0;
  101.       thd->mysys_var->current_cond= 0;
  102.       pthread_mutex_unlock(&thd->mysys_var->mutex);
  103.       DBUG_RETURN(-1);
  104.     }
  105.     /* remove form file and isam files */
  106.     (void) sprintf(path,"%s/%s/%s%s",mysql_data_home,db,table->real_name,
  107.    reg_ext);
  108.     (void) unpack_filename(path,path);
  109.     error=0;
  111.     table_type=get_table_type(path);
  113.     if (access(path,F_OK))
  114.     {
  115.       if (!if_exists)
  116. error=1;
  117.     }
  118.     else
  119.     {
  120.       char *end;
  121.       *(end=fn_ext(path))=0; // Remove extension
  122.       error=ha_delete_table(table_type, path);
  123.       if (error == ENOENT && if_exists)
  124. error = 0;
  125.       if (!error || error == ENOENT)
  126.       {
  127. /* Delete the table definition file */
  128. strmov(end,reg_ext);
  129. if (!(error=my_delete(path,MYF(MY_WME))))
  130.   some_tables_deleted=1;
  131.       }
  132.     }
  133.     if (error)
  134.     {
  135.       if (wrong_tables.length())
  136. wrong_tables.append(',');
  137.       wrong_tables.append(String(table->real_name));
  138.     }
  139.   }
  140.   if (some_tables_deleted)
  141.   {
  142.     mysql_update_log.write(thd, thd->query,thd->query_length);
  143.     if (mysql_bin_log.is_open())
  144.     {
  145.       Query_log_event qinfo(thd, thd->query);
  146.       mysql_bin_log.write(&qinfo);
  147.     }
  148.   }
  149.   
  150.   error = 0;
  151.  err:  
  152.   VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
  153.   pthread_mutex_unlock(&LOCK_open);
  155.   pthread_mutex_lock(&thd->mysys_var->mutex);
  156.   thd->mysys_var->current_mutex= 0;
  157.   thd->mysys_var->current_cond= 0;
  158.   pthread_mutex_unlock(&thd->mysys_var->mutex);
  160.   if (wrong_tables.length())
  161.   {
  162.     my_error(ER_BAD_TABLE_ERROR,MYF(0),wrong_tables.c_ptr());
  163.     error=1;
  164.   }
  165.   if(error)
  166.     DBUG_RETURN(-1);
  167.   send_ok(&thd->net);
  168.   DBUG_RETURN(0);
  169. }
  172. int quick_rm_table(enum db_type base,const char *db,
  173.    const char *table_name)
  174. {
  175.   char path[FN_REFLEN];
  176.   int error=0;
  177.   (void) sprintf(path,"%s/%s/%s%s",mysql_data_home,db,table_name,reg_ext);
  178.   unpack_filename(path,path);
  179.   if (my_delete(path,MYF(0)))
  180.     error=1; /* purecov: inspected */
  181.   sprintf(path,"%s/%s/%s",mysql_data_home,db,table_name);
  182.   unpack_filename(path,path);
  183.   return ha_delete_table(base,path) || error;
  184. }
  186. /*****************************************************************************
  187.  * Create at table.
  188.  * If one creates a temporary table, this is automaticly opened
  189.  ****************************************************************************/
  191. int mysql_create_table(THD *thd,const char *db, const char *table_name,
  192.        HA_CREATE_INFO *create_info,
  193.        List<create_field> &fields,
  194.        List<Key> &keys,bool tmp_table,bool no_log)
  195. {
  196.   char path[FN_REFLEN];
  197.   const char *key_name;
  198.   create_field *sql_field,*dup_field;
  199.   int error= -1;
  200.   uint db_options,field,null_fields,blob_columns;
  201.   ulong pos;
  202.   KEY *key_info,*key_info_buffer;
  203.   KEY_PART_INFO *key_part_info;
  204.   int auto_increment=0;
  205.   handler *file;
  206.   DBUG_ENTER("mysql_create_table");
  208.   /*
  209.   ** Check for duplicate fields and check type of table to create
  210.   */
  212.   if (!fields.elements)
  213.   {
  214.     my_error(ER_TABLE_MUST_HAVE_COLUMNS,MYF(0));
  215.     DBUG_RETURN(-1);
  216.   }
  217.   List_iterator<create_field> it(fields),it2(fields);
  218.   null_fields=blob_columns=0;
  219.   db_options=create_info->table_options;
  220.   if (create_info->row_type == ROW_TYPE_DYNAMIC)
  221.     db_options|=HA_OPTION_PACK_RECORD;
  222.   file=get_new_handler((TABLE*) 0, create_info->db_type);
  224.   /* Don't pack keys in old tables if the user has requested this */
  226.   while ((sql_field=it++))
  227.   {
  228.     if ((sql_field->flags & BLOB_FLAG) ||
  229. sql_field->sql_type == FIELD_TYPE_VAR_STRING &&
  230. create_info->row_type != ROW_TYPE_FIXED)
  231.     {
  232.       db_options|=HA_OPTION_PACK_RECORD;
  233.     }
  234.     if (!(sql_field->flags & NOT_NULL_FLAG))
  235.       null_fields++;
  236.     while ((dup_field=it2++) != sql_field)
  237.     {
  238.       if (my_strcasecmp(sql_field->field_name, dup_field->field_name) == 0)
  239.       {
  240. my_error(ER_DUP_FIELDNAME,MYF(0),sql_field->field_name);
  241. DBUG_RETURN(-1);
  242.       }
  243.     }
  244.     it2.rewind();
  245.   }
  246.   /* If fixed row records, we need on bit to check for deleted rows */
  247.   if (!(db_options & HA_OPTION_PACK_RECORD))
  248.     null_fields++;
  249.   pos=(null_fields+7)/8;
  251.   it.rewind();
  252.   while ((sql_field=it++))
  253.   {
  254.     switch (sql_field->sql_type) {
  255.     case FIELD_TYPE_BLOB:
  256.     case FIELD_TYPE_MEDIUM_BLOB:
  257.     case FIELD_TYPE_TINY_BLOB:
  258.     case FIELD_TYPE_LONG_BLOB:
  259.       sql_field->pack_flag=FIELDFLAG_BLOB |
  260. pack_length_to_packflag(sql_field->pack_length -
  261. portable_sizeof_char_ptr);
  262.       if (sql_field->flags & BINARY_FLAG)
  263. sql_field->pack_flag|=FIELDFLAG_BINARY;
  264.       sql_field->length=8; // Unireg field length
  265.       sql_field->unireg_check=Field::BLOB_FIELD;
  266.       blob_columns++;
  267.       break;
  268.     case FIELD_TYPE_VAR_STRING:
  269.     case FIELD_TYPE_STRING:
  270.       sql_field->pack_flag=0;
  271.       if (sql_field->flags & BINARY_FLAG)
  272. sql_field->pack_flag|=FIELDFLAG_BINARY;
  273.       break;
  274.     case FIELD_TYPE_ENUM:
  275.       sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
  276. FIELDFLAG_INTERVAL;
  277.       sql_field->unireg_check=Field::INTERVAL_FIELD;
  278.       break;
  279.     case FIELD_TYPE_SET:
  280.       sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
  281. FIELDFLAG_BITFIELD;
  282.       sql_field->unireg_check=Field::BIT_FIELD;
  283.       break;
  284.     case FIELD_TYPE_DATE: // Rest of string types
  285.     case FIELD_TYPE_NEWDATE:
  286.     case FIELD_TYPE_TIME:
  287.     case FIELD_TYPE_DATETIME:
  288.     case FIELD_TYPE_NULL:
  289.       sql_field->pack_flag=f_settype((uint) sql_field->sql_type);
  290.       break;
  291.     case FIELD_TYPE_TIMESTAMP:
  292.       sql_field->unireg_check=Field::TIMESTAMP_FIELD;
  293.       /* fall through */
  294.     default:
  295.       sql_field->pack_flag=(FIELDFLAG_NUMBER |
  296.     (sql_field->flags & UNSIGNED_FLAG ? 0 :
  297.      FIELDFLAG_DECIMAL) |
  298.     (sql_field->flags & ZEROFILL_FLAG ?
  299.      FIELDFLAG_ZEROFILL : 0) |
  300.     f_settype((uint) sql_field->sql_type) |
  301.     (sql_field->decimals << FIELDFLAG_DEC_SHIFT));
  302.       break;
  303.     }
  304.     if (!(sql_field->flags & NOT_NULL_FLAG))
  305.       sql_field->pack_flag|=FIELDFLAG_MAYBE_NULL;
  306.     sql_field->offset= pos;
  307.     if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
  308.       auto_increment++;
  309.     pos+=sql_field->pack_length;
  310.   }
  311.   if (auto_increment > 1)
  312.   {
  313.     my_error(ER_WRONG_AUTO_KEY,MYF(0));
  314.     DBUG_RETURN(-1);
  315.   }
  316.   if (auto_increment &&
  317.       (file->option_flag() & HA_WRONG_ASCII_ORDER))
  318.   {
  319.     my_error(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT,MYF(0));
  320.     DBUG_RETURN(-1);
  321.   }
  323.   if (blob_columns && (file->option_flag() & HA_NO_BLOBS))
  324.   {
  325.     my_error(ER_TABLE_CANT_HANDLE_BLOB,MYF(0));
  326.     DBUG_RETURN(-1);
  327.   }
  329.   /* Create keys */
  331.   List_iterator<Key> key_iterator(keys);
  332.   uint key_parts=0,key_count=keys.elements;
  333.   List<Key> keys_in_order; // Add new keys here
  334.   Key *primary_key=0;
  335.   bool unique_key=0;
  336.   Key *key;
  337.   uint tmp;
  338.   tmp=min(file->max_keys(), MAX_KEY);
  339.   if (key_count > tmp)
  340.   {
  341.     my_error(ER_TOO_MANY_KEYS,MYF(0),tmp);
  342.     DBUG_RETURN(-1);
  343.   }
  345.   /*
  346.     Check keys;
  347.     Put PRIMARY KEY first, then UNIQUE keys and other keys last
  348.     This will make checking for duplicated keys faster and ensure that
  349.     primary keys are prioritized.
  350.   */
  352.   while ((key=key_iterator++))
  353.   {
  354.     tmp=max(file->max_key_parts(),MAX_REF_PARTS);
  355.     if (key->columns.elements > tmp)
  356.     {
  357.       my_error(ER_TOO_MANY_KEY_PARTS,MYF(0),tmp);
  358.       DBUG_RETURN(-1);
  359.     }
  360.     if (key->name() && strlen(key->name()) > NAME_LEN)
  361.     {
  362.       my_error(ER_TOO_LONG_IDENT, MYF(0), key->name());
  363.       DBUG_RETURN(-1);
  364.     }
  365.     key_parts+=key->columns.elements;
  366.     if (key->type == Key::PRIMARY)
  367.     {
  368.       if (primary_key)
  369.       {
  370. my_error(ER_MULTIPLE_PRI_KEY,MYF(0));
  371. DBUG_RETURN(-1);
  372.       }
  373.       primary_key=key;
  374.     }
  375.     else if (key->type == Key::UNIQUE)
  376.     {
  377.       unique_key=1;
  378.       if (keys_in_order.push_front(key))
  379. DBUG_RETURN(-1);
  380.     }
  381.     else if (keys_in_order.push_back(key))
  382.       DBUG_RETURN(-1);
  383.   }
  384.   if (primary_key)
  385.   {
  386.     if (keys_in_order.push_front(primary_key))
  387.       DBUG_RETURN(-1);
  388.   }
  389.   else if (!unique_key && (file->option_flag() & HA_REQUIRE_PRIMARY_KEY))
  390.   {
  391.     my_error(ER_REQUIRES_PRIMARY_KEY,MYF(0));
  392.     DBUG_RETURN(-1);
  393.   }
  395.   key_info_buffer=key_info=(KEY*) sql_calloc(sizeof(KEY)*key_count);
  396.   key_part_info=(KEY_PART_INFO*) sql_calloc(sizeof(KEY_PART_INFO)*key_parts);
  397.   if (!key_info_buffer || ! key_part_info)
  398.     DBUG_RETURN(-1); // Out of memory
  400.   List_iterator<Key> key_iterator_in_order(keys_in_order);
  401.   for (; (key=key_iterator_in_order++) ; key_info++)
  402.   {
  403.     uint key_length=0;
  404.     key_part_spec *column;
  406.     key_info->flags= (key->type == Key::MULTIPLE) ? 0 :
  407.                      (key->type == Key::FULLTEXT) ? HA_FULLTEXT : HA_NOSAME;
  408.     key_info->key_parts=(uint8) key->columns.elements;
  409.     key_info->key_part=key_part_info;
  411.     List_iterator<key_part_spec> cols(key->columns);
  412.     for (uint column_nr=0 ; (column=cols++) ; column_nr++)
  413.     {
  414.       it.rewind();
  415.       field=0;
  416.       while ((sql_field=it++) &&
  417.      my_strcasecmp(column->field_name,sql_field->field_name))
  418. field++;
  419.       if (!sql_field)
  420.       {
  421. my_printf_error(ER_KEY_COLUMN_DOES_NOT_EXITS,
  422. ER(ER_KEY_COLUMN_DOES_NOT_EXITS),MYF(0),
  423. column->field_name);
  424. DBUG_RETURN(-1);
  425.       }
  426.       if (f_is_blob(sql_field->pack_flag))
  427.       {
  428. if (!(file->option_flag() & HA_BLOB_KEY))
  429. {
  430.   my_printf_error(ER_BLOB_USED_AS_KEY,ER(ER_BLOB_USED_AS_KEY),MYF(0),
  431.   column->field_name);
  432.   DBUG_RETURN(-1);
  433. }
  434. if (!column->length)
  435. {
  436.           if (key->type == Key::FULLTEXT)
  437.             column->length=1; /* ft-code ignores it anyway :-) */
  438.           else
  439.           {
  440.     my_printf_error(ER_BLOB_KEY_WITHOUT_LENGTH,
  441.     ER(ER_BLOB_KEY_WITHOUT_LENGTH),MYF(0),
  442.     column->field_name);
  443.     DBUG_RETURN(-1);
  444.           }
  445. }
  446.       }
  447.       if (!(sql_field->flags & NOT_NULL_FLAG))
  448.       {
  449. if (key->type == Key::PRIMARY)
  450. {
  451.   my_error(ER_PRIMARY_CANT_HAVE_NULL, MYF(0));
  452.   DBUG_RETURN(-1);
  453. }
  454. if (!(file->option_flag() & HA_NULL_KEY))
  455. {
  456.   my_printf_error(ER_NULL_COLUMN_IN_INDEX,ER(ER_NULL_COLUMN_IN_INDEX),
  457.   MYF(0),column->field_name);
  458.   DBUG_RETURN(-1);
  459. }
  460.       }
  461.       if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
  462.       {
  463. if (column_nr == 0 || (file->option_flag() & HA_AUTO_PART_KEY))
  464.   auto_increment--; // Field is used
  465.       }
  466.       key_part_info->fieldnr= field;
  467.       key_part_info->offset=  (uint16) sql_field->offset;
  468.       key_part_info->key_type=sql_field->pack_flag;
  469.       uint length=sql_field->pack_length;
  470.       if (column->length)
  471.       {
  472. if (f_is_blob(sql_field->pack_flag))
  473. {
  474.   if ((length=column->length) > file->max_key_length() ||
  475.       length > file->max_key_part_length())
  476.   {
  477.     my_error(ER_WRONG_SUB_KEY,MYF(0));
  478.     DBUG_RETURN(-1);
  479.   }
  480. }
  481. else if (column->length > length ||
  482.     (f_is_packed(sql_field->pack_flag) && column->length != length))
  483. {
  484.   my_error(ER_WRONG_SUB_KEY,MYF(0));
  485.   DBUG_RETURN(-1);
  486. }
  487. length=column->length;
  488.       }
  489.       else if (length == 0)
  490.       {
  491. my_printf_error(ER_WRONG_KEY_COLUMN, ER(ER_WRONG_KEY_COLUMN), MYF(0),
  492. column->field_name);
  493.   DBUG_RETURN(-1);
  494.       }
  495.       key_part_info->length=(uint8) length;
  496.       /* Use packed keys for long strings on the first column */
  497.       if (!(db_options & HA_OPTION_NO_PACK_KEYS) &&
  498.   (length >= KEY_DEFAULT_PACK_LENGTH &&
  499.    (sql_field->sql_type == FIELD_TYPE_STRING ||
  500.     sql_field->sql_type == FIELD_TYPE_VAR_STRING ||
  501.     sql_field->pack_flag & FIELDFLAG_BLOB)))
  502.       {
  503. if (column_nr == 0 && (sql_field->pack_flag & FIELDFLAG_BLOB))
  504.   key_info->flags|= HA_BINARY_PACK_KEY;
  505. else
  506.   key_info->flags|= HA_PACK_KEY;
  507.       }
  508.       key_length+=length;
  509.       key_part_info++;
  511.       /* Create the key name based on the first column (if not given) */
  512.       if (column_nr == 0)
  513.       {
  514. if (key->type == Key::PRIMARY)
  515.   key_name="PRIMARY";
  516. else if (!(key_name = key->name()))
  517.   key_name=make_unique_key_name(sql_field->field_name,
  518. key_info_buffer,key_info);
  519. if (check_if_keyname_exists(key_name,key_info_buffer,key_info))
  520. {
  521.   my_error(ER_DUP_KEYNAME,MYF(0),key_name);
  522.   DBUG_RETURN(-1);
  523. }
  524. key_info->name=(char*) key_name;
  525.       }
  526.     }
  527.     key_info->key_length=(uint16) key_length;
  528.     if (key_length > file->max_key_length() && key->type != Key::FULLTEXT)
  529.     {
  530.       my_error(ER_TOO_LONG_KEY,MYF(0),file->max_key_length());
  531.       DBUG_RETURN(-1);
  532.     }
  533.   }
  534.   if (auto_increment > 0)
  535.   {
  536.     my_error(ER_WRONG_AUTO_KEY,MYF(0));
  537.     DBUG_RETURN(-1);
  538.   }
  540.       /* Check if table exists */
  541.   if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  542.   {
  543.     sprintf(path,"%s%s%lx_%lx_%x%s",mysql_tmpdir,tmp_file_prefix,
  544.     current_pid, thd->thread_id, thd->tmp_table++,reg_ext);
  545.     create_info->table_options|=HA_CREATE_DELAY_KEY_WRITE;
  546.   }
  547.   else
  548.     (void) sprintf(path,"%s/%s/%s%s",mysql_data_home,db,table_name,reg_ext);
  549.   unpack_filename(path,path);
  550.   /* Check if table already exists */
  551.   if ((create_info->options & HA_LEX_CREATE_TMP_TABLE)
  552.       && find_temporary_table(thd,db,table_name))
  553.   {
  554.     if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
  555.       DBUG_RETURN(0);
  556.     my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
  557.     DBUG_RETURN(-1);
  558.   }
  559.   VOID(pthread_mutex_lock(&LOCK_open));
  560.   if (!tmp_table && !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
  561.   {
  562.     if (!access(path,F_OK))
  563.     {
  564.       VOID(pthread_mutex_unlock(&LOCK_open));
  565.       if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
  566. DBUG_RETURN(0);
  567.       my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
  568.       DBUG_RETURN(-1);
  569.     }
  570.   }
  572.   thd->proc_info="creating table";
  574.   create_info->table_options=db_options;
  575.   if (rea_create_table(path, create_info, fields, key_count,
  576.        key_info_buffer))
  577.   {
  578.     /* my_error(ER_CANT_CREATE_TABLE,MYF(0),table_name,my_errno); */
  579.     goto end;
  580.   }
  581.   if (!tmp_table && !no_log)
  582.   {
  583.     // Must be written before unlock
  584.     mysql_update_log.write(thd,thd->query, thd->query_length);
  585.     if (mysql_bin_log.is_open())
  586.     {
  587.       Query_log_event qinfo(thd, thd->query);
  588.       mysql_bin_log.write(&qinfo);
  589.     }
  590.   }
  591.   if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  592.   {
  593.     /* Open table and put in temporary table list */
  594.     if (!(open_temporary_table(thd, path, db, table_name, 1)))
  595.     {
  596.       (void) rm_temporary_table(create_info->db_type, path);
  597.       goto end;
  598.     }
  599.   }
  600.   error=0;
  601. end:
  602.   VOID(pthread_mutex_unlock(&LOCK_open));
  603.   thd->proc_info="After create";
  604.   DBUG_RETURN(error);
  605. }
  607. /*
  608. ** Give the key name after the first field with an optional '_#' after
  609. **/
  611. static bool
  612. check_if_keyname_exists(const char *name, KEY *start, KEY *end)
  613. {
  614.   for (KEY *key=start ; key != end ; key++)
  615.     if (!my_strcasecmp(name,key->name))
  616.       return 1;
  617.   return 0;
  618. }
  621. static char *
  622. make_unique_key_name(const char *field_name,KEY *start,KEY *end)
  623. {
  624.   char buff[MAX_FIELD_NAME],*buff_end;
  626.   if (!check_if_keyname_exists(field_name,start,end))
  627.     return (char*) field_name; // Use fieldname
  628.   buff_end=strmake(buff,field_name,MAX_FIELD_NAME-4);
  629.   for (uint i=2 ; ; i++)
  630.   {
  631.     sprintf(buff_end,"_%d",i);
  632.     if (!check_if_keyname_exists(buff,start,end))
  633.       return sql_strdup(buff);
  634.   }
  635. }
  637. /****************************************************************************
  638. ** Create table from a list of fields and items
  639. ****************************************************************************/
  641. TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
  642.        const char *db, const char *name,
  643.        List<create_field> *extra_fields,
  644.        List<Key> *keys,
  645.        List<Item> *items,
  646.        MYSQL_LOCK **lock)
  647. {
  648.   TABLE tmp_table; // Used during 'create_field()'
  649.   TABLE *table;
  650.   tmp_table.table_name=0;
  651.   DBUG_ENTER("create_table_from_items");
  653.   /* Add selected items to field list */
  654.   List_iterator<Item> it(*items);
  655.   Item *item;
  656.   Field *tmp_field;
  657.   tmp_table.db_create_options=0;
  658.   tmp_table.null_row=tmp_table.maybe_null=0;
  659.   tmp_table.blob_ptr_size=portable_sizeof_char_ptr;
  660.   tmp_table.db_low_byte_first= test(create_info->db_type == DB_TYPE_MYISAM ||
  661.     create_info->db_type == DB_TYPE_HEAP);
  663.   while ((item=it++))
  664.   {
  665.     create_field *cr_field;
  666.     if (strlen(item->name) > NAME_LEN ||
  667. check_column_name(item->name))
  668.     {
  669.       my_error(ER_WRONG_COLUMN_NAME,MYF(0),item->name);
  670.       DBUG_RETURN(0);
  671.     }
  673.     Field *field=create_tmp_field(&tmp_table,item,item->type(),
  674.   (Item_result_field***) 0, &tmp_field,0,0);
  675.     if (!field ||
  676. !(cr_field=new create_field(field,(item->type() == Item::FIELD_ITEM ?
  677.    ((Item_field *)item)->field :
  678.    (Field*) 0))))
  679.       DBUG_RETURN(0);
  680.     extra_fields->push_back(cr_field);
  681.   }
  682.   /* create and lock table */
  683.   /* QQ: This should be done atomic ! */
  684.   if (mysql_create_table(thd,db,name,create_info,*extra_fields,
  685.  *keys,0,1)) // no logging
  686.     DBUG_RETURN(0);
  687.   if (!(table=open_table(thd,db,name,name,(bool*) 0)))
  688.   {
  689.     quick_rm_table(create_info->db_type,db,name);
  690.     DBUG_RETURN(0);
  691.   }
  692.   table->reginfo.lock_type=TL_WRITE;
  693.   if (!((*lock)=mysql_lock_tables(thd,&table,1)))
  694.   {
  695.     hash_delete(&open_cache,(byte*) table);
  696.     quick_rm_table(create_info->db_type,db,name);
  697.     DBUG_RETURN(0);
  698.   }
  699.   table->file->extra(HA_EXTRA_WRITE_CACHE);
  700.   DBUG_RETURN(table);
  701. }
  704. /****************************************************************************
  705. ** Alter a table definition
  706. ****************************************************************************/
  708. bool
  709. mysql_rename_table(enum db_type base,
  710.    const char *old_db,
  711.    const char * old_name,
  712.    const char *new_db,
  713.    const char * new_name)
  714. {
  715.   char from[FN_REFLEN],to[FN_REFLEN];
  716.   handler *file=get_new_handler((TABLE*) 0, base);
  717.   int error=0;
  718.   DBUG_ENTER("mysql_rename_table");
  719.   (void) sprintf(from,"%s/%s/%s",mysql_data_home,old_db,old_name);
  720.   (void) sprintf(to,"%s/%s/%s",mysql_data_home,new_db,new_name);
  721.   fn_format(from,from,"","",4);
  722.   fn_format(to,to,    "","",4);
  723.   if (!(error=file->rename_table((const char*) from,(const char *) to)))
  724.   {
  725.     if (rename_file_ext(from,to,reg_ext))
  726.     {
  727.       error=my_errno;
  728.       /* Restore old file name */
  729.       file->rename_table((const char*) to,(const char *) from);
  730.     }
  731.   }
  732.   delete file;
  733.   if (error)
  734.     my_error(ER_ERROR_ON_RENAME, MYF(0), from, to, error);
  735.   DBUG_RETURN(error != 0);
  736. }
  738. /*
  739.   close table in this thread and force close + reopen in other threads
  740.   This assumes that the calling thread has lock on LOCK_open
  741.   Win32 clients must also have a WRITE LOCK on the table !
  742. */
  744. bool close_cached_table(THD *thd,TABLE *table)
  745. {
  746.   bool result=0;
  747.   DBUG_ENTER("close_cached_table");
  748.   if (table)
  749.   {
  750.     DBUG_PRINT("enter",("table: %s", table->table_name));
  751.     VOID(table->file->extra(HA_EXTRA_FORCE_REOPEN)); // Close all data files
  752.     /* Mark all tables that are in use as 'old' */
  753.     mysql_lock_abort(thd,table);  // end threads waiting on lock
  755. #ifdef REMOVE_LOCKS
  756.     /* Wait until all there are no other threads that has this table open */
  757.     while (remove_table_from_cache(thd,table->table_cache_key,
  758.    table->table_name))
  759.     {
  760.       dropping_tables++;
  761.       (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
  762.       dropping_tables--;
  763.     }
  764. #else
  765.     (void) remove_table_from_cache(thd,table->table_cache_key,
  766.    table->table_name);
  767. #endif
  768.     /* When lock on LOCK_open is freed other threads can continue */
  769.     pthread_cond_broadcast(&COND_refresh);
  771.     /* Close lock if this is not got with LOCK TABLES */
  772.     if (thd->lock)
  773.     {
  774.       mysql_unlock_tables(thd, thd->lock); thd->lock=0; // Start locked threads
  775.     }
  776.     /* Close all copies of 'table'.  This also frees all LOCK TABLES lock */
  777.     thd->open_tables=unlink_open_table(thd,thd->open_tables,table);
  778.   }
  779.   DBUG_RETURN(result);
  780. }
  782. static int send_check_errmsg(THD* thd, TABLE_LIST* table,
  783.      const char* operator_name, const char* errmsg)
  785. {
  787.   String* packet = &thd->packet;
  788.   packet->length(0);
  789.   net_store_data(packet, table->name);
  790.   net_store_data(packet, (char*)operator_name);
  791.   net_store_data(packet, "error");
  792.   net_store_data(packet, errmsg);
  793.   thd->net.last_error[0]=0;
  794.   if (my_net_write(&thd->net, (char*) thd->packet.ptr(),
  795.    packet->length()))
  796.     return -1;
  797.   return 1;
  798. }
  800. static int prepare_for_restore(THD* thd, TABLE_LIST* table)
  801. {
  802.   DBUG_ENTER("prepare_for_restore");
  804.   if (table->table) // do not overwrite existing tables on restore
  805.   {
  806.     DBUG_RETURN(send_check_errmsg(thd, table, "restore",
  807.   "table exists, will not overwrite on restore"
  808.   ));
  809.   }
  810.   else
  811.   {
  812.     char* backup_dir = thd->lex.backup_dir;
  813.     char src_path[FN_REFLEN], dst_path[FN_REFLEN];
  814.     char* table_name = table->name;
  815.     char* db = thd->db ? thd->db : table->db;
  817.     if (!fn_format(src_path, table_name, backup_dir, reg_ext, 4 + 64))
  818.       DBUG_RETURN(-1); // protect buffer overflow
  820.     sprintf(dst_path, "%s/%s/%s", mysql_real_data_home, db, table_name);
  822.     int lock_retcode;
  823.     pthread_mutex_lock(&LOCK_open);
  824.     if((lock_retcode = lock_table_name(thd, table)) < 0)
  825.     {
  826.       pthread_mutex_unlock(&LOCK_open);
  827.       DBUG_RETURN(-1);
  828.     }
  830.     if(lock_retcode && wait_for_locked_table_names(thd, table))
  831.     {
  832.       unlock_table_name(thd, table);
  833.       pthread_mutex_unlock(&LOCK_open);
  834.       DBUG_RETURN(-1);
  835.     }
  836.     pthread_mutex_unlock(&LOCK_open);
  838.     if(my_copy(src_path,
  839.        fn_format(dst_path, dst_path,"",
  840.  reg_ext, 4),
  841.        MYF(MY_WME)))
  842.     {
  843.       unlock_table_name(thd, table);
  844.       DBUG_RETURN(send_check_errmsg(thd, table, "restore",
  845.     "Failed copying .frm file"));
  846.     }
  847.     bool save_no_send_ok = thd->net.no_send_ok;
  848.     thd->net.no_send_ok = 1;
  849.     // generate table will try to send OK which messes up the output
  850.     // for the client
  852.     if(generate_table(thd, table, 0))
  853.     {
  854.       unlock_table_name(thd, table);
  855.       thd->net.no_send_ok = save_no_send_ok;
  856.       DBUG_RETURN(send_check_errmsg(thd, table, "restore",
  857.     "Failed generating table from .frm file"));
  858.     }
  860.     thd->net.no_send_ok = save_no_send_ok;
  861.   }
  863.   DBUG_RETURN(0);
  864. }
  866. static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
  867.      HA_CHECK_OPT* check_opt,
  868.      const char *operator_name,
  869.      thr_lock_type lock_type,
  870.      bool open_for_modify, bool restore,
  871.      uint extra_open_options,
  872.      int (handler::*operator_func)
  873.      (THD *, HA_CHECK_OPT *))
  874. {
  875.   TABLE_LIST *table;
  876.   List<Item> field_list;
  877.   Item* item;
  878.   String* packet = &thd->packet;
  879.   DBUG_ENTER("mysql_admin_table");
  881.   field_list.push_back(item = new Item_empty_string("Table", NAME_LEN*2));
  882.   item->maybe_null = 1;
  883.   field_list.push_back(item = new Item_empty_string("Op", 10));
  884.   item->maybe_null = 1;
  885.   field_list.push_back(item = new Item_empty_string("Msg_type", 10));
  886.   item->maybe_null = 1;
  887.   field_list.push_back(item = new Item_empty_string("Msg_text", 255));
  888.   item->maybe_null = 1;
  889.   if (send_fields(thd, field_list, 1))
  890.     DBUG_RETURN(-1);
  892.   for (table = tables; table; table = table->next)
  893.   {
  894.     char table_name[NAME_LEN*2+2];
  895.     char* db = (table->db) ? table->db : thd->db;
  896.     bool fatal_error=0;
  897.     strxmov(table_name,db ? db : "",".",table->name,NullS);
  899.     thd->open_options|= extra_open_options;
  900.     table->table = open_ltable(thd, table, lock_type);
  901.     thd->open_options&= ~extra_open_options;
  902.     packet->length(0);
  903.     if (restore)
  904.     {
  905.       switch (prepare_for_restore(thd, table)) {
  906.       case 1: continue; // error, message written to net
  907.       case -1: goto err; // error, message could be written to net
  908.       default: ;// should be 0 otherwise
  909.       }
  911.       // now we should be able to open the partially restored table
  912.       // to finish the restore in the handler later on
  913.       if(!(table->table = reopen_name_locked_table(thd, table)))
  914.         unlock_table_name(thd, table);
  915.     }
  917.     if (!table->table)
  918.     {
  919.       const char *err_msg;
  920.       net_store_data(packet, table_name);
  921.       net_store_data(packet, operator_name);
  922.       net_store_data(packet, "error");
  923.       if (!(err_msg=thd->net.last_error))
  924. err_msg=ER(ER_CHECK_NO_SUCH_TABLE);
  925.       net_store_data(packet, err_msg);
  926.       thd->net.last_error[0]=0;
  927.       if (my_net_write(&thd->net, (char*) thd->packet.ptr(),
  928.        packet->length()))
  929. goto err;
  930.       continue;
  931.     }
  932.     if ((table->table->db_stat & HA_READ_ONLY) && open_for_modify)
  933.     {
  934.       char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
  935.       net_store_data(packet, table_name);
  936.       net_store_data(packet, operator_name);
  937.       net_store_data(packet, "error");
  938.       sprintf(buff, ER(ER_OPEN_AS_READONLY), table_name);
  939.       net_store_data(packet, buff);
  940.       close_thread_tables(thd);
  941.       if (my_net_write(&thd->net, (char*) thd->packet.ptr(),
  942.        packet->length()))
  943. goto err;
  944.       continue;
  945.     }
  947.     /* Close all instances of the table to allow repair to rename files */
  948.     if (open_for_modify && table->table->version)
  949.     {
  950.       pthread_mutex_lock(&LOCK_open);
  951.       mysql_lock_abort(thd,table->table);
  952.       while (remove_table_from_cache(thd, table->table->table_cache_key,
  953.      table->table->real_name) &&
  954.      ! thd->killed)
  955.       {
  956. dropping_tables++;
  957. (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
  958. dropping_tables--;
  959.       }
  960.       pthread_mutex_unlock(&LOCK_open);
  961.       if (thd->killed)
  962. goto err;
  963.     }
  965.     int result_code = (table->table->file->*operator_func)(thd, check_opt);
  966.     packet->length(0);
  967.     net_store_data(packet, table_name);
  968.     net_store_data(packet, operator_name);
  970.     switch (result_code) {
  971.     case HA_ADMIN_NOT_IMPLEMENTED:
  972.       net_store_data(packet, "error");
  973.       net_store_data(packet, ER(ER_CHECK_NOT_IMPLEMENTED));
  974.       break;
  976.     case HA_ADMIN_OK:
  977.       net_store_data(packet, "status");
  978.       net_store_data(packet, "OK");
  979.       break;
  981.     case HA_ADMIN_FAILED:
  982.       net_store_data(packet, "status");
  983.       net_store_data(packet, "Operation failed");
  984.       break;
  986.     case HA_ADMIN_ALREADY_DONE:
  987.       net_store_data(packet, "status");
  988.       net_store_data(packet, "Table is already up to date");
  989.       break;
  991.     case HA_ADMIN_CORRUPT:
  992.       net_store_data(packet, "error");
  993.       net_store_data(packet, "Corrupt");
  994.       fatal_error=1;
  995.       break;
  997.     case HA_ADMIN_INVALID:
  998.       net_store_data(packet, "error");
  999.       net_store_data(packet, "Invalid argument");
  1000.       break;
  1002.     default: // Probably HA_ADMIN_INTERNAL_ERROR
  1003.       net_store_data(packet, "error");
  1004.       net_store_data(packet, "Unknown - internal error during operation");
  1005.       fatal_error=1;
  1006.       break;
  1007.     }
  1008.     if (fatal_error)
  1009.       table->table->version=0; // Force close of table
  1010.     close_thread_tables(thd);
  1011.     if (my_net_write(&thd->net, (char*) packet->ptr(),
  1012.      packet->length()))
  1013.       goto err;
  1014.   }
  1016.   send_eof(&thd->net);
  1017.   DBUG_RETURN(0);
  1018.  err:
  1019.   close_thread_tables(thd); // Shouldn't be needed
  1020.   DBUG_RETURN(-1);
  1021. }
  1023. int mysql_backup_table(THD* thd, TABLE_LIST* table_list)
  1024. {
  1025.   DBUG_ENTER("mysql_backup_table");
  1026.   DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
  1027. "backup", TL_READ, 0, 0, 0,
  1028. &handler::backup));
  1029. }
  1031. int mysql_restore_table(THD* thd, TABLE_LIST* table_list)
  1032. {
  1033.   DBUG_ENTER("mysql_restore_table");
  1034.   DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
  1035. "restore", TL_WRITE, 1, 1,0,
  1036. &handler::restore));
  1037. }
  1039. int mysql_repair_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
  1040. {
  1041.   DBUG_ENTER("mysql_repair_table");
  1042.   DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
  1043. "repair", TL_WRITE, 1, 0, HA_OPEN_FOR_REPAIR,
  1044. &handler::repair));
  1045. }
  1047. int mysql_optimize_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
  1048. {
  1049.   DBUG_ENTER("mysql_optimize_table");
  1050.   DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
  1051. "optimize", TL_WRITE, 1,0,0,
  1052. &handler::optimize));
  1053. }
  1056. int mysql_analyze_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
  1057. {
  1058.   DBUG_ENTER("mysql_analyze_table");
  1059.   DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
  1060. "analyze",TL_READ_NO_INSERT, 1,0,0,
  1061. &handler::analyze));
  1062. }
  1065. int mysql_check_table(THD* thd, TABLE_LIST* tables,HA_CHECK_OPT* check_opt)
  1066. {
  1067.   DBUG_ENTER("mysql_check_table");
  1068.   DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
  1069. "check",
  1070. TL_READ_NO_INSERT, 0, 0, HA_OPEN_FOR_REPAIR,
  1071. &handler::check));
  1072. }
  1075. int mysql_alter_table(THD *thd,char *new_db, char *new_name,
  1076.       HA_CREATE_INFO *create_info,
  1077.       TABLE_LIST *table_list,
  1078.       List<create_field> &fields,
  1079.       List<Key> &keys,List<Alter_drop> &drop_list,
  1080.       List<Alter_column> &alter_list,
  1081.                       ORDER *order,
  1082.       bool drop_primary,
  1083.       enum enum_duplicates handle_duplicates)
  1084. {
  1085.   TABLE *table,*new_table;
  1086.   int error;
  1087.   char tmp_name[80],old_name[32],new_name_buff[FN_REFLEN],
  1088.     *table_name,*db;
  1089.   bool use_timestamp=0;
  1090.   ha_rows copied,deleted;
  1091.   ulonglong next_insert_id;
  1092.   uint save_time_stamp,db_create_options;
  1093.   enum db_type old_db_type,new_db_type;
  1094.   DBUG_ENTER("mysql_alter_table");
  1096.   thd->proc_info="init";
  1097.   table_name=table_list->real_name;
  1098.   db=table_list->db;
  1099.   if (!new_db)
  1100.     new_db=db;
  1102.   if (!(table=open_ltable(thd,table_list,TL_WRITE_ALLOW_READ)))
  1103.     DBUG_RETURN(-1);
  1105.   /* Check that we are not trying to rename to an existing table */
  1106.   if (new_name)
  1107.   {
  1108.     strmov(new_name_buff,new_name);
  1109.     fn_same(new_name_buff,table_name,3);
  1110. #ifdef FN_LOWER_CASE
  1111.     if (!my_strcasecmp(new_name_buff,table_name))// Check if name changed
  1112. #else
  1113.     if (!strcmp(new_name_buff,table_name)) // Check if name changed
  1114. #endif
  1115.       new_name=table_name; // No. Make later check easier
  1116.     else
  1117.     {
  1118.       if (table->tmp_table)
  1119.       {
  1120. if (find_temporary_table(thd,new_db,new_name_buff))
  1121. {
  1122.   my_error(ER_TABLE_EXISTS_ERROR,MYF(0),new_name);
  1123.   DBUG_RETURN(-1);
  1124. }
  1125.       }
  1126.       else
  1127.       {
  1128. if (!access(fn_format(new_name_buff,new_name_buff,new_db,reg_ext,0),
  1129.     F_OK))
  1130. {
  1131.   /* Table will be closed in do_command() */
  1132.   my_error(ER_TABLE_EXISTS_ERROR,MYF(0),new_name);
  1133.   DBUG_RETURN(-1);
  1134. }
  1135.       }
  1136.     }
  1137.   }
  1138.   else
  1139.     new_name=table_name;
  1141.   old_db_type=table->db_type;
  1142.   if (create_info->db_type == DB_TYPE_DEFAULT)
  1143.     create_info->db_type=old_db_type;
  1144.   new_db_type=create_info->db_type= ha_checktype(create_info->db_type);
  1145.   if (create_info->row_type == ROW_TYPE_DEFAULT)
  1146.     create_info->row_type=table->row_type;
  1148.   /* Check if the user only wants to do a simple RENAME */
  1150.   thd->proc_info="setup";
  1151.   if (new_name != table_name &&
  1152.       !fields.elements && !keys.elements && ! drop_list.elements &&
  1153.       !alter_list.elements && !drop_primary &&
  1154.       new_db_type == old_db_type && create_info->max_rows == 0 &&
  1155.       create_info->auto_increment_value == 0 && !table->tmp_table)
  1156.   {
  1157.     thd->proc_info="rename";
  1158.     VOID(pthread_mutex_lock(&LOCK_open));
  1159.     /* Then do a 'simple' rename of the table */
  1160.     error=0;
  1161.     if (!access(new_name_buff,F_OK))
  1162.     {
  1163.       my_error(ER_TABLE_EXISTS_ERROR,MYF(0),new_name);
  1164.       error= -1;
  1165.     }
  1166.     else
  1167.     {
  1168.       *fn_ext(new_name)=0;
  1169.       close_cached_table(thd,table);
  1170.       if (mysql_rename_table(old_db_type,db,table_name,new_db,new_name))
  1171. error= -1;
  1172.     }
  1173.     VOID(pthread_cond_broadcast(&COND_refresh));
  1174.     VOID(pthread_mutex_unlock(&LOCK_open));
  1175.     if (!error)
  1176.     {
  1177.       mysql_update_log.write(thd, thd->query, thd->query_length);
  1178.       if (mysql_bin_log.is_open())
  1179.       {
  1180. Query_log_event qinfo(thd, thd->query);
  1181. mysql_bin_log.write(&qinfo);
  1182.       }
  1183.       send_ok(&thd->net);
  1184.     }
  1186.     DBUG_RETURN(error);
  1187.   }
  1189.   /* Full alter table */
  1190.   restore_record(table,2); // Empty record for DEFAULT
  1191.   List_iterator<Alter_drop> drop_it(drop_list);
  1192.   List_iterator<create_field> def_it(fields);
  1193.   List_iterator<Alter_column> alter_it(alter_list);
  1194.   List<create_field> create_list; // Add new fields here
  1195.   List<Key> key_list; // Add new keys here
  1197.   /*
  1198.   ** First collect all fields from table which isn't in drop_list
  1199.   */
  1201.   create_field *def;
  1202.   Field **f_ptr,*field;
  1203.   for (f_ptr=table->field ; (field= *f_ptr) ; f_ptr++)
  1204.   {
  1205.     /* Check if field should be droped */
  1206.     Alter_drop *drop;
  1207.     drop_it.rewind();
  1208.     while ((drop=drop_it++))
  1209.     {
  1210.       if (drop->type == Alter_drop::COLUMN &&
  1211.   !my_strcasecmp(field->field_name, drop->name))
  1212. break;
  1213.     }
  1214.     if (drop)
  1215.     {
  1216.       drop_it.remove();
  1217.       continue;
  1218.     }
  1219.     /* Check if field is changed */
  1220.     def_it.rewind();
  1221.     while ((def=def_it++))
  1222.     {
  1223.       if (def->change && !my_strcasecmp(field->field_name, def->change))
  1224. break;
  1225.     }
  1226.     if (def)
  1227.     { // Field is changed
  1228.       def->field=field;
  1229.       if (def->sql_type == FIELD_TYPE_TIMESTAMP)
  1230. use_timestamp=1;
  1231.       create_list.push_back(def);
  1232.       def_it.remove();
  1233.     }
  1234.     else
  1235.     { // Use old field value
  1236.       create_list.push_back(def=new create_field(field,field));
  1237.       if (def->sql_type == FIELD_TYPE_TIMESTAMP)
  1238. use_timestamp=1;
  1240.       alter_it.rewind(); // Change default if ALTER
  1241.       Alter_column *alter;
  1242.       while ((alter=alter_it++))
  1243.       {
  1244. if (!my_strcasecmp(field->field_name, alter->name))
  1245.   break;
  1246.       }
  1247.       if (alter)
  1248.       {
  1249.         if (def->sql_type == FIELD_TYPE_BLOB)
  1250.         {
  1251.           my_error(ER_BLOB_CANT_HAVE_DEFAULT,MYF(0),def->change);
  1252.           DBUG_RETURN(-1);
  1253.         }
  1254. def->def=alter->def; // Use new default
  1255. alter_it.remove();
  1256.       }
  1257.     }
  1258.   }
  1259.   def_it.rewind();
  1260.   List_iterator<create_field> find_it(create_list);
  1261.   while ((def=def_it++)) // Add new columns
  1262.   {
  1263.     if (def->change)
  1264.     {
  1265.       my_error(ER_BAD_FIELD_ERROR,MYF(0),def->change,table_name);
  1266.       DBUG_RETURN(-1);
  1267.     }
  1268.     if (!def->after)
  1269.       create_list.push_back(def);
  1270.     else if (def->after == first_keyword)
  1271.       create_list.push_front(def);
  1272.     else
  1273.     {
  1274.       create_field *find;
  1275.       find_it.rewind();
  1276.       while ((find=find_it++)) // Add new columns
  1277.       {
  1278. if (!my_strcasecmp(def->after, find->field_name))
  1279.   break;
  1280.       }
  1281.       if (!find)
  1282.       {
  1283. my_error(ER_BAD_FIELD_ERROR,MYF(0),def->after,table_name);
  1284. DBUG_RETURN(-1);
  1285.       }
  1286.       find_it.after(def); // Put element after this
  1287.     }
  1288.   }
  1289.   if (alter_list.elements)
  1290.   {
  1291.     my_error(ER_BAD_FIELD_ERROR,MYF(0),alter_list.head()->name,table_name);
  1292.     DBUG_RETURN(-1);
  1293.   }
  1294.   if (!create_list.elements)
  1295.   {
  1296.     my_error(ER_CANT_REMOVE_ALL_FIELDS,MYF(0));
  1297.     DBUG_RETURN(-1);
  1298.   }
  1300.   /*
  1301.   ** Collect all keys which isn't in drop list. Add only those
  1302.   ** for which some fields exists.
  1303.   */
  1305.   List_iterator<Key> key_it(keys);
  1306.   List_iterator<create_field> field_it(create_list);
  1307.   List<key_part_spec> key_parts;
  1309.   KEY *key_info=table->key_info;
  1310.   for (uint i=0 ; i < table->keys ; i++,key_info++)
  1311.   {
  1312.     if (drop_primary && (key_info->flags & HA_NOSAME))
  1313.     {
  1314.       drop_primary=0;
  1315.       continue;
  1316.     }
  1318.     char *key_name=key_info->name;
  1319.     Alter_drop *drop;
  1320.     drop_it.rewind();
  1321.     while ((drop=drop_it++))
  1322.     {
  1323.       if (drop->type == Alter_drop::KEY &&
  1324.   !my_strcasecmp(key_name, drop->name))
  1325. break;
  1326.     }
  1327.     if (drop)
  1328.     {
  1329.       drop_it.remove();
  1330.       continue;
  1331.     }
  1333.     KEY_PART_INFO *key_part= key_info->key_part;
  1334.     key_parts.empty();
  1335.     for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
  1336.     {
  1337.       if (!key_part->field)
  1338. continue; // Wrong field (from UNIREG)
  1339.       const char *key_part_name=key_part->field->field_name;
  1340.       create_field *cfield;
  1341.       field_it.rewind();
  1342.       while ((cfield=field_it++))
  1343.       {
  1344. if (cfield->change)
  1345. {
  1346.   if (!my_strcasecmp(key_part_name, cfield->change))
  1347.     break;
  1348. }
  1349. else if (!my_strcasecmp(key_part_name, cfield->field_name))
  1350.     break;
  1351.       }
  1352.       if (!cfield)
  1353. continue; // Field is removed
  1354.       uint key_part_length=key_part->length;
  1355.       if (cfield->field) // Not new field
  1356.       { // Check if sub key
  1357. if (cfield->field->type() != FIELD_TYPE_BLOB &&
  1358.     (cfield->field->pack_length() == key_part_length ||
  1359.      cfield->length != cfield->pack_length ||
  1360.      cfield->pack_length <= key_part_length))
  1361.   key_part_length=0; // Use whole field
  1362.       }
  1363.       key_parts.push_back(new key_part_spec(cfield->field_name,
  1364.     key_part_length));
  1365.     }
  1366.     if (key_parts.elements)
  1367.       key_list.push_back(new Key(key_info->flags & HA_NOSAME ?
  1368.  (!my_strcasecmp(key_name, "PRIMARY") ?
  1369.   Key::PRIMARY  : Key::UNIQUE) :
  1370.                                  (key_info->flags & HA_FULLTEXT ?
  1371.                                  Key::FULLTEXT : Key::MULTIPLE),
  1372.  key_name,key_parts));
  1373.   }
  1374.   key_it.rewind();
  1375.   {
  1376.     Key *key;
  1377.     while ((key=key_it++)) // Add new keys
  1378.       key_list.push_back(key);
  1379.   }
  1381.   if (drop_list.elements)
  1382.   {
  1383.     my_error(ER_CANT_DROP_FIELD_OR_KEY,MYF(0),drop_list.head()->name);
  1384.     goto err;
  1385.   }
  1386.   if (alter_list.elements)
  1387.   {
  1388.     my_error(ER_CANT_DROP_FIELD_OR_KEY,MYF(0),alter_list.head()->name);
  1389.     goto err;
  1390.   }
  1392.   (void) sprintf(tmp_name,"%s-%lx_%lx", tmp_file_prefix, current_pid,
  1393.  thd->thread_id);
  1394.   create_info->db_type=new_db_type;
  1395.   if (!create_info->max_rows)
  1396.     create_info->max_rows=table->max_rows;
  1397.   if (!create_info->avg_row_length)
  1398.     create_info->avg_row_length=table->avg_row_length;
  1399.   table->file->update_create_info(create_info);
  1400.   if (!create_info->comment)
  1401.     create_info->comment=table->comment;
  1402.   /* let new create options override the old ones */
  1403.   db_create_options=table->db_create_options & ~(HA_OPTION_PACK_RECORD);
  1404.   if (create_info->table_options &
  1405.       (HA_OPTION_PACK_KEYS | HA_OPTION_NO_PACK_KEYS))
  1406.     db_create_options&= ~(HA_OPTION_PACK_KEYS | HA_OPTION_NO_PACK_KEYS);
  1407.   if (create_info->table_options &
  1408.       (HA_OPTION_CHECKSUM | HA_OPTION_NO_CHECKSUM))
  1409.     db_create_options&= ~(HA_OPTION_CHECKSUM | HA_OPTION_NO_CHECKSUM);
  1410.   if (create_info->table_options &
  1411.       (HA_OPTION_DELAY_KEY_WRITE | HA_OPTION_NO_DELAY_KEY_WRITE))
  1412.     db_create_options&= ~(HA_OPTION_DELAY_KEY_WRITE |
  1413.   HA_OPTION_NO_DELAY_KEY_WRITE);
  1414.   create_info->table_options|= db_create_options;
  1416.   if (table->tmp_table)
  1417.     create_info->options|=HA_LEX_CREATE_TMP_TABLE;
  1419.   if ((error=mysql_create_table(thd, new_db, tmp_name,
  1420. create_info,
  1421. create_list,key_list,1,1))) // no logging
  1422.     DBUG_RETURN(error);
  1423.   {
  1424.     if (table->tmp_table)
  1425.       new_table=open_table(thd,new_db,tmp_name,tmp_name,0);
  1426.     else
  1427.     {
  1428.       char path[FN_REFLEN];
  1429.       (void) sprintf(path,"%s/%s/%s",mysql_data_home,new_db,tmp_name);
  1430.       fn_format(path,path,"","",4);
  1431.       new_table=open_temporary_table(thd, path, new_db, tmp_name,0);
  1432.     }
  1433.     if (!new_table)
  1434.     {
  1435.       VOID(quick_rm_table(new_db_type,new_db,tmp_name));
  1436.       goto err;
  1437.     }
  1438.   }
  1440.   save_time_stamp=new_table->time_stamp;
  1441.   if (use_timestamp)
  1442.     new_table->time_stamp=0;
  1443.   new_table->next_number_field=new_table->found_next_number_field;
  1444.   thd->count_cuted_fields=1; // calc cuted fields
  1445.   thd->cuted_fields=0L;
  1446.   thd->proc_info="copy to tmp table";
  1447.   next_insert_id=thd->next_insert_id; // Remember for loggin
  1448.   copied=deleted=0;
  1449.   if (!new_table->is_view)
  1450.     error=copy_data_between_tables(table,new_table,create_list,
  1451.    handle_duplicates,
  1452.    order, &copied, &deleted);
  1453.   thd->last_insert_id=next_insert_id; // Needed for correct log
  1454.   thd->count_cuted_fields=0; // Don`t calc cuted fields
  1455.   new_table->time_stamp=save_time_stamp;
  1457.   if (table->tmp_table)
  1458.   {
  1459.     /* We changed a temporary table */
  1460.     if (error)
  1461.     {
  1462.       close_temporary_table(thd,new_db,tmp_name);
  1463.       my_free((gptr) new_table,MYF(0));
  1464.       goto err;
  1465.     }
  1466.     /* Remove link to old table and rename the new one */
  1467.     close_temporary_table(thd,table->table_cache_key,table_name);
  1468.     if (rename_temporary_table(thd, new_table, new_db, new_name))
  1469.     { // Fatal error
  1470.       close_temporary_table(thd,new_db,tmp_name);
  1471.       my_free((gptr) new_table,MYF(0));
  1472.       goto err;
  1473.     }
  1474.     mysql_update_log.write(thd, thd->query,thd->query_length);
  1475.     if (mysql_bin_log.is_open())
  1476.     {
  1477.       Query_log_event qinfo(thd, thd->query);
  1478.       mysql_bin_log.write(&qinfo);
  1479.     }
  1480.     goto end_temporary;
  1481.   }
  1483.   intern_close_table(new_table); /* close temporary table */
  1484.   my_free((gptr) new_table,MYF(0));
  1485.   VOID(pthread_mutex_lock(&LOCK_open));
  1486.   if (error)
  1487.   {
  1488.     VOID(quick_rm_table(new_db_type,new_db,tmp_name));
  1489.     VOID(pthread_mutex_unlock(&LOCK_open));
  1490.     goto err;
  1491.   }
  1492.   /*
  1493.   ** Data is copied.  Now we rename the old table to a temp name,
  1494.   ** rename the new one to the old name, remove all entries from the old table
  1495.   ** from the cash, free all locks, close the old table and remove it.
  1496.   */
  1498.   thd->proc_info="rename result table";
  1499.   sprintf(old_name,"%s2-%lx-%lx", tmp_file_prefix, current_pid,
  1500.   thd->thread_id);
  1501.   if (new_name != table_name)
  1502.   {
  1503.     if (!access(new_name_buff,F_OK))
  1504.     {
  1505.       error=1;
  1506.       my_error(ER_TABLE_EXISTS_ERROR,MYF(0),new_name_buff);
  1507.       VOID(quick_rm_table(new_db_type,new_db,tmp_name));
  1508.       VOID(pthread_mutex_unlock(&LOCK_open));
  1509.       goto err;
  1510.     }
  1511.   }
  1513. #if defined( __WIN__) || defined( __EMX__)
  1514.   // Win32 can't rename an open table, so we must close the org table!
  1515.   table_name=thd->strdup(table_name); // must be saved
  1516.   if (close_cached_table(thd,table))
  1517.   { // Aborted
  1518.     VOID(quick_rm_table(new_db_type,new_db,tmp_name));
  1519.     VOID(pthread_mutex_unlock(&LOCK_open));
  1520.     goto err;
  1521.   }
  1522.   table=0; // Marker for win32 version
  1523. #else
  1524.   table->file->extra(HA_EXTRA_FORCE_REOPEN); // Don't use this file anymore
  1525. #endif
  1527.   error=0;
  1528.   if (mysql_rename_table(old_db_type,db,table_name,db,old_name))
  1529.   {
  1530.     error=1;
  1531.     VOID(quick_rm_table(new_db_type,new_db,tmp_name));
  1532.   }
  1533.   else if (mysql_rename_table(new_db_type,new_db,tmp_name,new_db,
  1534.       new_name))
  1535.   { // Try to get everything back
  1536.     error=1;
  1537.     VOID(quick_rm_table(new_db_type,new_db,new_name));
  1538.     VOID(quick_rm_table(new_db_type,new_db,tmp_name));
  1539.     VOID(mysql_rename_table(old_db_type,db,old_name,db,table_name));
  1540.   }
  1541.   if (error)
  1542.   {
  1543.     // This shouldn't happen.  We solve this the safe way by
  1544.     // closing the locked table.
  1545.     close_cached_table(thd,table);
  1546.     VOID(pthread_mutex_unlock(&LOCK_open));
  1547.     goto err;
  1548.   }
  1549.   if (thd->lock || new_name != table_name) // True if WIN32
  1550.   {
  1551.     // Not table locking or alter table with rename
  1552.     // free locks and remove old table
  1553.     close_cached_table(thd,table);
  1554.     VOID(quick_rm_table(old_db_type,db,old_name));
  1555.   }
  1556.   else
  1557.   {
  1558.     // Using LOCK TABLES without rename.
  1559.     // This code is never executed on WIN32!
  1560.     // Remove old renamed table, reopen table and get new locks
  1561.     if (table)
  1562.     {
  1563.       VOID(table->file->extra(HA_EXTRA_FORCE_REOPEN)); // Use new file
  1564.       remove_table_from_cache(thd,db,table_name); // Mark all in-use copies old
  1565.       mysql_lock_abort(thd,table);  // end threads waiting on lock
  1566.     }
  1567.     VOID(quick_rm_table(old_db_type,db,old_name));
  1568.     if (close_data_tables(thd,db,table_name) ||
  1569. reopen_tables(thd,1,0))
  1570.     { // This shouldn't happen
  1571.       close_cached_table(thd,table); // Remove lock for table
  1572.       VOID(pthread_mutex_unlock(&LOCK_open));
  1573.       goto err;
  1574.     }
  1575.   }
  1577.   /* The ALTER TABLE is always in it's own transaction */
  1578.   error = ha_commit_stmt(thd);
  1579.   if (ha_commit(thd))
  1580.     error=1;
  1581.   if (error)
  1582.   {
  1583.     VOID(pthread_cond_broadcast(&COND_refresh));
  1584.     VOID(pthread_mutex_unlock(&LOCK_open));
  1585.     goto err;
  1586.   }
  1588.   thd->proc_info="end";
  1589.   mysql_update_log.write(thd, thd->query,thd->query_length);
  1590.   if (mysql_bin_log.is_open())
  1591.   {
  1592.     Query_log_event qinfo(thd, thd->query);
  1593.     mysql_bin_log.write(&qinfo);
  1594.   }
  1595.   VOID(pthread_cond_broadcast(&COND_refresh));
  1596.   VOID(pthread_mutex_unlock(&LOCK_open));
  1598. end_temporary:
  1599.   sprintf(tmp_name,ER(ER_INSERT_INFO),(ulong) (copied+deleted),
  1600.   (ulong) deleted, thd->cuted_fields);
  1601.   send_ok(&thd->net,copied+deleted,0L,tmp_name);
  1602.   thd->some_tables_deleted=0;
  1603.   DBUG_RETURN(0);
  1605.  err:
  1606.   DBUG_RETURN(-1);
  1607. }
  1610. static int
  1611. copy_data_between_tables(TABLE *from,TABLE *to,
  1612.                          List<create_field> &create,
  1613.  enum enum_duplicates handle_duplicates,
  1614.                          ORDER *order,
  1615.  ha_rows *copied,
  1616.                          ha_rows *deleted)
  1617. {
  1618.   int error;
  1619.   Copy_field *copy,*copy_end;
  1620.   ulong found_count,delete_count;
  1621.   THD *thd= current_thd;
  1622.   uint length;
  1623.   SORT_FIELD *sortorder;
  1624.   READ_RECORD info;
  1625.   Field *next_field;
  1626.   TABLE_LIST   tables;
  1627.   List<Item>   fields;
  1628.   List<Item>   all_fields;
  1629.   DBUG_ENTER("copy_data_between_tables");
  1631.   if (!(copy= new Copy_field[to->fields]))
  1632.     DBUG_RETURN(-1); /* purecov: inspected */
  1634.   to->file->external_lock(thd,F_WRLCK);
  1635.   to->file->extra(HA_EXTRA_WRITE_CACHE);
  1636.   from->file->info(HA_STATUS_VARIABLE);
  1637.   to->file->deactivate_non_unique_index(from->file->records);
  1639.   List_iterator<create_field> it(create);
  1640.   create_field *def;
  1641.   copy_end=copy;
  1642.   for (Field **ptr=to->field ; *ptr ; ptr++)
  1643.   {
  1644.     def=it++;
  1645.     if (def->field)
  1646.       (copy_end++)->set(*ptr,def->field,0);
  1647.   }
  1649.   found_count=delete_count=0;
  1651.   if (order)
  1652.   {
  1653.     from->io_cache=(IO_CACHE*) my_malloc(sizeof(IO_CACHE),
  1654.                                          MYF(MY_FAE | MY_ZEROFILL));
  1655.     bzero((char*) &tables,sizeof(tables));
  1656.     tables.table = from;
  1657.     tables.name  = tables.real_name= from->real_name;
  1658.     tables.db  = from->table_cache_key;
  1659.     error=1;
  1661.     if (setup_order(thd, &tables, fields, all_fields, order) ||
  1662.         !(sortorder=make_unireg_sortorder(order, &length)) ||
  1663.         (from->found_records = filesort(&from, sortorder, length, 
  1664.                                          (SQL_SELECT *) 0, 0L, HA_POS_ERROR))
  1665.         == HA_POS_ERROR)
  1666.       goto err;
  1667.   };
  1669.   init_read_record(&info, thd, from, (SQL_SELECT *) 0, 1,1);
  1670.   if (handle_duplicates == DUP_IGNORE ||
  1671.       handle_duplicates == DUP_REPLACE)
  1672.     to->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
  1673.   next_field=to->next_number_field;
  1674.   while (!(error=info.read_record(&info)))
  1675.   {
  1676.     if (thd->killed)
  1677.     {
  1678.       my_error(ER_SERVER_SHUTDOWN,MYF(0));
  1679.       error= 1;
  1680.       break;
  1681.     }
  1682.     if (next_field)
  1683.       next_field->reset();
  1684.     for (Copy_field *copy_ptr=copy ; copy_ptr != copy_end ; copy_ptr++)
  1685.       copy_ptr->do_copy(copy_ptr);
  1686.     if ((error=to->file->write_row((byte*) to->record[0])))
  1687.     {
  1688.       if ((handle_duplicates != DUP_IGNORE &&
  1689.    handle_duplicates != DUP_REPLACE) ||
  1690.   (error != HA_ERR_FOUND_DUPP_KEY &&
  1691.    error != HA_ERR_FOUND_DUPP_UNIQUE))
  1692.       {
  1693. to->file->print_error(error,MYF(0));
  1694. break;
  1695.       }
  1696.       delete_count++;
  1697.     }
  1698.     else
  1699.       found_count++;
  1700.   }
  1701.   end_read_record(&info);
  1702.   free_io_cache(from);
  1703.   delete [] copy;
  1704.   uint tmp_error;
  1705.   if ((tmp_error=to->file->extra(HA_EXTRA_NO_CACHE)))
  1706.   {
  1707.     to->file->print_error(tmp_error,MYF(0));
  1708.     error=1;
  1709.   }
  1710.   to->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
  1711.   if (to->file->activate_all_index(thd))
  1712.     error=1;
  1714.   /*
  1715.     Ensure that the new table is saved properly to disk so that we
  1716.     can do a rename
  1717.   */
  1718.   if (ha_commit_stmt(thd))
  1719.     error=1;
  1720.   if (ha_commit(thd))
  1721.     error=1;
  1722.   if (to->file->external_lock(thd,F_UNLCK))
  1723.     error=1;
  1724.  err:
  1725.   free_io_cache(from);
  1726.   *copied= found_count;
  1727.   *deleted=delete_count;
  1728.   DBUG_RETURN(error > 0 ? -1 : 0);
  1729. }