sql_table.cc 108 KB
Newer Older
1
/* Copyright (C) 2000-2004 MySQL AB
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/* drop and alter of tables */

#include "mysql_priv.h"
21
#ifdef HAVE_BERKELEY_DB
22
#include "ha_berkeley.h"
23
#endif
24
#include <hash.h>
bk@work.mysql.com's avatar
bk@work.mysql.com committed
25
#include <myisam.h>
26
#include <my_dir.h>
bk@work.mysql.com's avatar
bk@work.mysql.com committed
27 28 29 30 31

#ifdef __WIN__
#include <io.h>
#endif

serg@serg.mylan's avatar
serg@serg.mylan committed
32
const char *primary_key_name="PRIMARY";
bk@work.mysql.com's avatar
bk@work.mysql.com committed
33 34 35 36

static bool check_if_keyname_exists(const char *name,KEY *start, KEY *end);
static char *make_unique_key_name(const char *field_name,KEY *start,KEY *end);
static int copy_data_between_tables(TABLE *from,TABLE *to,
37 38
				    List<create_field> &create,
				    enum enum_duplicates handle_duplicates,
39
                                    bool ignore,
40 41
				    uint order_num, ORDER *order,
				    ha_rows *copied,ha_rows *deleted);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
42

43 44 45 46 47 48 49 50 51 52 53 54 55 56

/*
 Build the path to a file for a table (or the base path that can
 then have various extensions stuck on to it).

  SYNOPSIS
   build_table_path()
   buff                 Buffer to build the path into
   bufflen              sizeof(buff)
   db                   Name of database
   table                Name of table
   ext                  Filename extension

  RETURN
57 58
    0                   Error
    #                   Size of path
59 60
 */

61
static uint build_table_path(char *buff, size_t bufflen, const char *db,
62 63 64 65
                             const char *table, const char *ext)
{
  strxnmov(buff, bufflen-1, mysql_data_home, "/", db, "/", table, ext,
           NullS);
66
  return unpack_filename(buff,buff);
67 68 69 70
}



71 72 73 74 75
/*
 delete (drop) tables.

  SYNOPSIS
   mysql_rm_table()
76 77 78
   thd			Thread handle
   tables		List of tables to delete
   if_exists		If 1, don't give error if one table doesn't exists
79 80 81 82 83 84 85 86 87 88

  NOTES
    Will delete all tables that can be deleted and give a compact error
    messages for tables that could not be deleted.
    If a table is in use, we will wait for all users to free the table
    before dropping it

    Wait if global_read_lock (FLUSH TABLES WITH READ LOCK) is set.

  RETURN
89 90
    0		ok.  In this case ok packet is sent to user
    -1		Error  (Error message given but not sent to user)
91 92

*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
93

94
int mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists,
95
		   my_bool drop_temporary)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
96
{
monty@narttu.mysql.fi's avatar
merge  
monty@narttu.mysql.fi committed
97
  int error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
98 99 100 101 102 103 104 105
  DBUG_ENTER("mysql_rm_table");

  /* mark for close and remove all cached entries */

  thd->mysys_var->current_mutex= &LOCK_open;
  thd->mysys_var->current_cond= &COND_refresh;
  VOID(pthread_mutex_lock(&LOCK_open));

106
  if (!drop_temporary && global_read_lock)
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
107
  {
108
    if (thd->global_read_lock)
109
    {
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
110
      my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE,MYF(0),
111
	       tables->real_name);
112
      error= 1;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
113 114 115 116 117
      goto err;
    }
    while (global_read_lock && ! thd->killed)
    {
      (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
118
    }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
119 120

  }
121
  error=mysql_rm_table_part2(thd,tables, if_exists, drop_temporary, 0);
122

123
 err:
124 125 126 127 128 129 130 131 132
  pthread_mutex_unlock(&LOCK_open);

  pthread_mutex_lock(&thd->mysys_var->mutex);
  thd->mysys_var->current_mutex= 0;
  thd->mysys_var->current_cond= 0;
  pthread_mutex_unlock(&thd->mysys_var->mutex);

  if (error)
    DBUG_RETURN(-1);
133
  send_ok(thd);
134 135 136
  DBUG_RETURN(0);
}

137 138 139 140 141 142

/*
 delete (drop) tables.

  SYNOPSIS
   mysql_rm_table_part2_with_lock()
143 144 145 146
   thd			Thread handle
   tables		List of tables to delete
   if_exists		If 1, don't give error if one table doesn't exists
   dont_log_query	Don't write query to log files
147 148 149 150 151 152

 NOTES
   Works like documented in mysql_rm_table(), but don't check
   global_read_lock and don't send_ok packet to server.

 RETURN
153 154
  0	ok
  1	error
155 156
*/

157
int mysql_rm_table_part2_with_lock(THD *thd,
158 159
				   TABLE_LIST *tables, bool if_exists,
				   bool drop_temporary, bool dont_log_query)
160 161 162 163 164 165
{
  int error;
  thd->mysys_var->current_mutex= &LOCK_open;
  thd->mysys_var->current_cond= &COND_refresh;
  VOID(pthread_mutex_lock(&LOCK_open));

166
  error=mysql_rm_table_part2(thd,tables, if_exists, drop_temporary,
167
			     dont_log_query);
168 169 170 171 172 173 174 175 176 177

  pthread_mutex_unlock(&LOCK_open);

  pthread_mutex_lock(&thd->mysys_var->mutex);
  thd->mysys_var->current_mutex= 0;
  thd->mysys_var->current_cond= 0;
  pthread_mutex_unlock(&thd->mysys_var->mutex);
  return error;
}

178

179
/*
180 181 182 183
  Execute the drop of a normal or temporary table

  SYNOPSIS
    mysql_rm_table_part2()
184 185 186 187 188 189
    thd			Thread handler
    tables		Tables to drop
    if_exists		If set, don't give an error if table doesn't exists.
			In this case we give an warning of level 'NOTE'
    drop_temporary	Only drop temporary tables
    dont_log_query	Don't log the query
190

191 192 193 194 195 196 197 198 199
  TODO:
    When logging to the binary log, we should log
    tmp_tables and transactional tables as separate statements if we
    are in a transaction;  This is needed to get these tables into the
    cached binary log that is only written on COMMIT.

   The current code only writes DROP statements that only uses temporary
   tables to the cache binary log.  This should be ok on most cases, but
   not all.
200 201

 RETURN
202 203 204
   0	ok
   1	Error
   -1	Thread was killed
205
*/
206 207

int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
208
			 bool drop_temporary, bool dont_log_query)
209 210
{
  TABLE_LIST *table;
211
  char	path[FN_REFLEN], *alias;
212 213
  String wrong_tables;
  int error;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
214
  bool some_tables_deleted=0, tmp_table_deleted=0, foreign_key_error=0;
215 216
  DBUG_ENTER("mysql_rm_table_part2");

217
  if (lock_table_names(thd, tables))
218
    DBUG_RETURN(1);
219

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
220
  for (table=tables ; table ; table=table->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
221
  {
222
    char *db=table->db;
223
    mysql_ha_flush(thd, table, MYSQL_HA_CLOSE_FINAL);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
224
    if (!close_temporary_table(thd, db, table->real_name))
225
    {
226
      tmp_table_deleted=1;
227
      continue;					// removed temporary table
228
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
229 230

    error=0;
231
    if (!drop_temporary)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
232
    {
233 234 235
      abort_locked_tables(thd,db,table->real_name);
      while (remove_table_from_cache(thd,db,table->real_name) && !thd->killed)
      {
236 237 238
	dropping_tables++;
	(void) pthread_cond_wait(&COND_refresh,&LOCK_open);
	dropping_tables--;
239 240 241
      }
      drop_locked_tables(thd,db,table->real_name);
      if (thd->killed)
242
	DBUG_RETURN(-1);
monty@mysql.com's avatar
monty@mysql.com committed
243
      alias= (lower_case_table_names == 2) ? table->alias : table->real_name;
244
      /* remove form file and isam files */
245
      build_table_path(path, sizeof(path), db, alias, reg_ext);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
246
    }
247 248 249
    if (drop_temporary ||
	(access(path,F_OK) &&
         ha_create_table_from_engine(thd, db, alias)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
250
    {
251
      // Table was not found on disk and table can't be created from engine
252
      if (if_exists)
253 254 255
	push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
			    ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
			    table->real_name);
256
      else
257
        error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
258 259 260
    }
    else
    {
261
      char *end;
monty@mysql.com's avatar
monty@mysql.com committed
262
      db_type table_type= get_table_type(path);
263
      *(end=fn_ext(path))=0;			// Remove extension for delete
bk@work.mysql.com's avatar
bk@work.mysql.com committed
264 265
      error=ha_delete_table(table_type, path);
      if (error == ENOENT && if_exists)
266
	error = 0;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
267
      if (error == HA_ERR_ROW_IS_REFERENCED)
monty@mysql.com's avatar
monty@mysql.com committed
268
      {
269 270
	/* the table is referenced by a foreign key constraint */
	foreign_key_error=1;
monty@mysql.com's avatar
monty@mysql.com committed
271
      }
272 273
      if (!error || error == ENOENT)
      {
274 275 276 277
	/* Delete the table definition file */
	strmov(end,reg_ext);
	if (!(error=my_delete(path,MYF(MY_WME))))
	  some_tables_deleted=1;
278
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
279 280 281 282
    }
    if (error)
    {
      if (wrong_tables.length())
283
	wrong_tables.append(',');
284
      wrong_tables.append(String(table->real_name,system_charset_info));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
285 286
    }
  }
287
  thd->tmp_table_used= tmp_table_deleted;
288 289 290 291
  error= 0;
  if (wrong_tables.length())
  {
    if (!foreign_key_error)
292
      my_printf_error(ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR), MYF(0),
serg@serg.mylan's avatar
serg@serg.mylan committed
293
                     wrong_tables.c_ptr());
294 295 296 297 298 299
    else
      my_error(ER_ROW_IS_REFERENCED, MYF(0));
    error= 1;
  }

  if (some_tables_deleted || tmp_table_deleted || !error)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
300
  {
301
    query_cache_invalidate3(thd, tables, 0);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
302
    if (!dont_log_query)
303
    {
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
304 305 306
      mysql_update_log.write(thd, thd->query,thd->query_length);
      if (mysql_bin_log.is_open())
      {
307 308
        if (!error)
          thd->clear_error();
309
	Query_log_event qinfo(thd, thd->query, thd->query_length,
310 311
			      tmp_table_deleted && !some_tables_deleted, 
			      FALSE);
312
	mysql_bin_log.write(&qinfo);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
313
      }
314
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
315
  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
316

317
  unlock_table_names(thd, tables);
318
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
319 320 321 322
}


int quick_rm_table(enum db_type base,const char *db,
323
		   const char *table_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
324 325 326
{
  char path[FN_REFLEN];
  int error=0;
327
  build_table_path(path, sizeof(path), db, table_name, reg_ext);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
328 329
  if (my_delete(path,MYF(0)))
    error=1; /* purecov: inspected */
330
  *fn_ext(path)= 0;                             // Remove reg_ext
bk@work.mysql.com's avatar
bk@work.mysql.com committed
331 332 333
  return ha_delete_table(base,path) || error;
}

334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
/*
  Sort keys in the following order:
  - PRIMARY KEY
  - UNIQUE keyws where all column are NOT NULL
  - Other UNIQUE keys
  - Normal keys
  - Fulltext keys

  This will make checking for duplicated keys faster and ensure that
  PRIMARY keys are prioritized.
*/

static int sort_keys(KEY *a, KEY *b)
{
  if (a->flags & HA_NOSAME)
  {
    if (!(b->flags & HA_NOSAME))
      return -1;
352
    if ((a->flags ^ b->flags) & (HA_NULL_PART_KEY | HA_END_SPACE_KEY))
353 354
    {
      /* Sort NOT NULL keys before other keys */
355
      return (a->flags & (HA_NULL_PART_KEY | HA_END_SPACE_KEY)) ? 1 : -1;
356 357 358 359 360 361 362
    }
    if (a->name == primary_key_name)
      return -1;
    if (b->name == primary_key_name)
      return 1;
  }
  else if (b->flags & HA_NOSAME)
363
    return 1;					// Prefer b
364 365 366 367 368

  if ((a->flags ^ b->flags) & HA_FULLTEXT)
  {
    return (a->flags & HA_FULLTEXT) ? 1 : -1;
  }
369
  /*
370
    Prefer original key order.	usable_key_parts contains here
371 372 373
    the original key position.
  */
  return ((a->usable_key_parts < b->usable_key_parts) ? -1 :
374 375
	  (a->usable_key_parts > b->usable_key_parts) ? 1 :
	  0);
376 377
}

378 379
/*
  Check TYPELIB (set or enum) for duplicates
380

381 382 383
  SYNOPSIS
    check_duplicates_in_interval()
    set_or_name   "SET" or "ENUM" string for warning message
384 385
    name	  name of the checked column
    typelib	  list of values for the column
386 387

  DESCRIPTION
388
    This function prints an warning for each value in list
389 390 391 392 393 394 395
    which has some duplicates on its right

  RETURN VALUES
    void
*/

void check_duplicates_in_interval(const char *set_or_name,
396 397
                                  const char *name, TYPELIB *typelib,
                                  CHARSET_INFO *cs)
398
{
399
  TYPELIB tmp= *typelib;
400
  const char **cur_value= typelib->type_names;
401 402 403
  unsigned int *cur_length= typelib->type_lengths;
  
  for ( ; tmp.count > 1; cur_value++, cur_length++)
404
  {
405 406 407 408
    tmp.type_names++;
    tmp.type_lengths++;
    tmp.count--;
    if (find_type2(&tmp, (const char*)*cur_value, *cur_length, cs))
409
    {
monty@mysql.com's avatar
monty@mysql.com committed
410
      push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_NOTE,
411 412 413
			  ER_DUPLICATED_VALUE_IN_TYPE,
			  ER(ER_DUPLICATED_VALUE_IN_TYPE),
			  name,*cur_value,set_or_name);
414 415 416
    }
  }
}
417

418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452

/*
  Check TYPELIB (set or enum) max and total lengths

  SYNOPSIS
    calculate_interval_lengths()
    cs            charset+collation pair of the interval
    typelib       list of values for the column
    max_length    length of the longest item
    tot_length    sum of the item lengths

  DESCRIPTION
    After this function call:
    - ENUM uses max_length
    - SET uses tot_length.

  RETURN VALUES
    void
*/
void calculate_interval_lengths(CHARSET_INFO *cs, TYPELIB *interval,
                                uint32 *max_length, uint32 *tot_length)
{
  const char **pos;
  uint *len;
  *max_length= *tot_length= 0;
  for (pos= interval->type_names, len= interval->type_lengths;
       *pos ; pos++, len++)
  {
    uint length= cs->cset->numchars(cs, *pos, *pos + *len);
    *tot_length+= length;
    set_if_bigger(*max_length, (uint32)length);
  }
}


453
/*
454
  Preparation for table creation
455 456

  SYNOPSIS
457
    mysql_prepare_table()
458 459 460 461
    thd			Thread object
    create_info		Create information (like MAX_ROWS)
    fields		List of fields to create
    keys		List of keys to create
462

463
  DESCRIPTION
464
    Prepares the table and key structures for table creation.
465 466

  RETURN VALUES
467 468
    0	ok
    -1	error
469
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
470

471
int mysql_prepare_table(THD *thd, HA_CREATE_INFO *create_info,
472 473 474 475
			List<create_field> &fields,
			List<Key> &keys, bool tmp_table, uint &db_options,
			handler *file, KEY *&key_info_buffer,
			uint *key_count, int select_field_count)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
476
{
477 478 479
  const char	*key_name;
  create_field	*sql_field,*dup_field;
  uint		field,null_fields,blob_columns;
monty@mysql.com's avatar
monty@mysql.com committed
480
  ulong		record_offset= 0;
481
  KEY		*key_info;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
482
  KEY_PART_INFO *key_part_info;
483 484 485
  int		timestamps= 0, timestamps_with_niladic= 0;
  int		field_no,dup_no;
  int		select_field_pos,auto_increment=0;
486
  DBUG_ENTER("mysql_prepare_table");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
487 488

  List_iterator<create_field> it(fields),it2(fields);
489
  select_field_pos=fields.elements - select_field_count;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
490
  null_fields=blob_columns=0;
491

492
  for (field_no=0; (sql_field=it++) ; field_no++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
493
  {
494
    if (!sql_field->charset)
495 496 497
      sql_field->charset= create_info->default_table_charset;
    /*
      table_charset is set in ALTER TABLE if we want change character set
498 499 500
      for all varchar/char columns.
      But the table charset must not affect the BLOB fields, so don't
      allow to change my_charset_bin to somethig else.
501
    */
502
    if (create_info->table_charset && sql_field->charset != &my_charset_bin)
503
      sql_field->charset= create_info->table_charset;
504 505 506 507 508 509 510 511 512 513 514

    CHARSET_INFO *savecs= sql_field->charset;
    if ((sql_field->flags & BINCMP_FLAG) &&
	!(sql_field->charset= get_charset_by_csname(sql_field->charset->csname,
						    MY_CS_BINSORT,MYF(0))))
    {
      char tmp[64];
      strmake(strmake(tmp, savecs->csname, sizeof(tmp)-4), "_bin", 4);
      my_error(ER_UNKNOWN_COLLATION, MYF(0), tmp);
      DBUG_RETURN(-1);
    }
515

516 517
    if (sql_field->sql_type == FIELD_TYPE_SET ||
        sql_field->sql_type == FIELD_TYPE_ENUM)
518 519 520
    {
      uint32 dummy;
      CHARSET_INFO *cs= sql_field->charset;
521
      TYPELIB *interval= sql_field->interval;
522 523 524 525 526 527

      /*
        Create typelib from interval_list, and if necessary
        convert strings from client character set to the
        column character set.
      */
528
      if (!interval)
529
      {
530 531 532 533
        interval= sql_field->interval= typelib(sql_field->interval_list);
        List_iterator<String> it(sql_field->interval_list);
        String conv, *tmp;
        for (uint i= 0; (tmp= it++); i++)
534
        {
535 536 537 538 539 540 541 542 543 544 545
          if (String::needs_conversion(tmp->length(), tmp->charset(),
                                       cs, &dummy))
          {
            uint cnv_errs;
            conv.copy(tmp->ptr(), tmp->length(), tmp->charset(), cs, &cnv_errs);
            char *buf= (char*) sql_alloc(conv.length()+1);
            memcpy(buf, conv.ptr(), conv.length());
            buf[conv.length()]= '\0';
            interval->type_names[i]= buf;
            interval->type_lengths[i]= conv.length();
          }
546

547 548 549 550 551 552 553
          // Strip trailing spaces.
          uint lengthsp= cs->cset->lengthsp(cs, interval->type_names[i],
                                            interval->type_lengths[i]);
          interval->type_lengths[i]= lengthsp;
          ((uchar *)interval->type_names[i])[lengthsp]= '\0';
        }
        sql_field->interval_list.empty(); // Don't need interval_list anymore
554 555 556 557 558 559
      }

      /*
        Convert the default value from client character
        set into the column character set if necessary.
      */
bar@mysql.com's avatar
bar@mysql.com committed
560
      if (sql_field->def && cs != sql_field->def->collation.collation)
561
      {
bar@mysql.com's avatar
bar@mysql.com committed
562 563 564 565 566 567 568
        if (!(sql_field->def= 
              sql_field->def->safe_charset_converter(cs)))
        {
          /* Could not convert */
          my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
          DBUG_RETURN(-1);
        }
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
      }

      if (sql_field->sql_type == FIELD_TYPE_SET)
      {
        if (sql_field->def)
        {
          char *not_used;
          uint not_used2;
          bool not_found= 0;
          String str, *def= sql_field->def->val_str(&str);
          def->length(cs->cset->lengthsp(cs, def->ptr(), def->length()));
          (void) find_set(interval, def->ptr(), def->length(),
                          cs, &not_used, &not_used2, &not_found);
          if (not_found)
          {
            my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
            DBUG_RETURN(-1);
          }
        }
        calculate_interval_lengths(cs, interval, &dummy, &sql_field->length);
        sql_field->length+= (interval->count - 1);
      }
      else  /* FIELD_TYPE_ENUM */
      {
        if (sql_field->def)
        {
          String str, *def= sql_field->def->val_str(&str);
          def->length(cs->cset->lengthsp(cs, def->ptr(), def->length()));
          if (!find_type2(interval, def->ptr(), def->length(), cs))
          {
            my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
            DBUG_RETURN(-1);
          }
        }
        calculate_interval_lengths(cs, interval, &sql_field->length, &dummy);
      }
      set_if_smaller(sql_field->length, MAX_FIELD_WIDTH-1);
    }

608
    sql_field->create_length_to_internal_length();
609

610
    /* Don't pack keys in old tables if the user has requested this */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
611
    if ((sql_field->flags & BLOB_FLAG) ||
612 613
	sql_field->sql_type == FIELD_TYPE_VAR_STRING &&
	create_info->row_type != ROW_TYPE_FIXED)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
614 615 616 617 618
    {
      db_options|=HA_OPTION_PACK_RECORD;
    }
    if (!(sql_field->flags & NOT_NULL_FLAG))
      null_fields++;
619

620 621
    if (check_column_name(sql_field->field_name))
    {
622
      my_error(ER_WRONG_COLUMN_NAME, MYF(0), sql_field->field_name);
623 624
      DBUG_RETURN(-1);
    }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
625

626 627
    /* Check if we have used the same field name before */
    for (dup_no=0; (dup_field=it2++) != sql_field; dup_no++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
628
    {
629
      if (my_strcasecmp(system_charset_info,
630 631
			sql_field->field_name,
			dup_field->field_name) == 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
632
      {
633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
	/*
	  If this was a CREATE ... SELECT statement, accept a field
	  redefinition if we are changing a field in the SELECT part
	*/
	if (field_no < select_field_pos || dup_no >= select_field_pos)
	{
	  my_error(ER_DUP_FIELDNAME,MYF(0),sql_field->field_name);
	  DBUG_RETURN(-1);
	}
	else
	{
	  /* Field redefined */
	  sql_field->sql_type=		dup_field->sql_type;
	  sql_field->charset=		(dup_field->charset ?
					 dup_field->charset :
					 create_info->default_table_charset);
	  sql_field->length=		dup_field->length;
	  sql_field->pack_length=	dup_field->pack_length;
	  sql_field->create_length_to_internal_length();
	  sql_field->decimals=		dup_field->decimals;
	  sql_field->flags=		dup_field->flags;
	  sql_field->unireg_check=	dup_field->unireg_check;
	  it2.remove();			// Remove first (create) definition
	  select_field_pos--;
	  break;
	}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
659 660 661 662
      }
    }
    it2.rewind();
  }
663 664 665

  /* record_offset will be increased with 'length-of-null-bits' later */
  record_offset= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
666 667 668 669

  it.rewind();
  while ((sql_field=it++))
  {
670 671
    DBUG_ASSERT(sql_field->charset);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
672 673 674 675 676 677
    switch (sql_field->sql_type) {
    case FIELD_TYPE_BLOB:
    case FIELD_TYPE_MEDIUM_BLOB:
    case FIELD_TYPE_TINY_BLOB:
    case FIELD_TYPE_LONG_BLOB:
      sql_field->pack_flag=FIELDFLAG_BLOB |
678 679
	pack_length_to_packflag(sql_field->pack_length -
				portable_sizeof_char_ptr);
680
      if (sql_field->charset->state & MY_CS_BINSORT)
681 682
	sql_field->pack_flag|=FIELDFLAG_BINARY;
      sql_field->length=8;			// Unireg field length
bk@work.mysql.com's avatar
bk@work.mysql.com committed
683 684 685
      sql_field->unireg_check=Field::BLOB_FIELD;
      blob_columns++;
      break;
686
    case FIELD_TYPE_GEOMETRY:
hf@deer.(none)'s avatar
hf@deer.(none) committed
687
#ifdef HAVE_SPATIAL
688
      if (!(file->table_flags() & HA_CAN_GEOMETRY))
689
      {
690 691 692
	my_printf_error(ER_CHECK_NOT_IMPLEMENTED, ER(ER_CHECK_NOT_IMPLEMENTED),
			MYF(0), "GEOMETRY");
	DBUG_RETURN(-1);
693
      }
694
      sql_field->pack_flag=FIELDFLAG_GEOM |
695 696
	pack_length_to_packflag(sql_field->pack_length -
				portable_sizeof_char_ptr);
hf@deer.mysql.r18.ru's avatar
hf@deer.mysql.r18.ru committed
697
      if (sql_field->charset->state & MY_CS_BINSORT)
698 699
	sql_field->pack_flag|=FIELDFLAG_BINARY;
      sql_field->length=8;			// Unireg field length
700 701 702
      sql_field->unireg_check=Field::BLOB_FIELD;
      blob_columns++;
      break;
hf@deer.(none)'s avatar
hf@deer.(none) committed
703 704
#else
      my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED), MYF(0),
705
		      sym_group_geom.name, sym_group_geom.needed_define);
hf@deer.(none)'s avatar
hf@deer.(none) committed
706 707
      DBUG_RETURN(-1);
#endif /*HAVE_SPATIAL*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
708 709 710
    case FIELD_TYPE_VAR_STRING:
    case FIELD_TYPE_STRING:
      sql_field->pack_flag=0;
711
      if (sql_field->charset->state & MY_CS_BINSORT)
712
	sql_field->pack_flag|=FIELDFLAG_BINARY;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
713 714 715
      break;
    case FIELD_TYPE_ENUM:
      sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
716
	FIELDFLAG_INTERVAL;
717
      if (sql_field->charset->state & MY_CS_BINSORT)
718
	sql_field->pack_flag|=FIELDFLAG_BINARY;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
719
      sql_field->unireg_check=Field::INTERVAL_FIELD;
720
      check_duplicates_in_interval("ENUM",sql_field->field_name,
721 722
                                   sql_field->interval,
                                   sql_field->charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
723 724 725
      break;
    case FIELD_TYPE_SET:
      sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
726
	FIELDFLAG_BITFIELD;
727
      if (sql_field->charset->state & MY_CS_BINSORT)
728
	sql_field->pack_flag|=FIELDFLAG_BINARY;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
729
      sql_field->unireg_check=Field::BIT_FIELD;
730
      check_duplicates_in_interval("SET",sql_field->field_name,
731 732
                                   sql_field->interval,
                                   sql_field->charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
733
      break;
734
    case FIELD_TYPE_DATE:			// Rest of string types
bk@work.mysql.com's avatar
bk@work.mysql.com committed
735 736 737 738 739 740 741
    case FIELD_TYPE_NEWDATE:
    case FIELD_TYPE_TIME:
    case FIELD_TYPE_DATETIME:
    case FIELD_TYPE_NULL:
      sql_field->pack_flag=f_settype((uint) sql_field->sql_type);
      break;
    case FIELD_TYPE_TIMESTAMP:
742 743 744
      /* We should replace old TIMESTAMP fields with their newer analogs */
      if (sql_field->unireg_check == Field::TIMESTAMP_OLD_FIELD)
      {
745 746 747 748 749 750 751
	if (!timestamps)
	{
	  sql_field->unireg_check= Field::TIMESTAMP_DNUN_FIELD;
	  timestamps_with_niladic++;
	}
	else
	  sql_field->unireg_check= Field::NONE;
752
      }
753
      else if (sql_field->unireg_check != Field::NONE)
754 755
	timestamps_with_niladic++;

756
      timestamps++;
757
      /* fall-through */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
758 759
    default:
      sql_field->pack_flag=(FIELDFLAG_NUMBER |
760 761 762 763 764 765
			    (sql_field->flags & UNSIGNED_FLAG ? 0 :
			     FIELDFLAG_DECIMAL) |
			    (sql_field->flags & ZEROFILL_FLAG ?
			     FIELDFLAG_ZEROFILL : 0) |
			    f_settype((uint) sql_field->sql_type) |
			    (sql_field->decimals << FIELDFLAG_DEC_SHIFT));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
766 767 768 769
      break;
    }
    if (!(sql_field->flags & NOT_NULL_FLAG))
      sql_field->pack_flag|=FIELDFLAG_MAYBE_NULL;
770
    sql_field->offset= record_offset;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
771 772
    if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
      auto_increment++;
773
    record_offset+= sql_field->pack_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
774
  }
775 776 777 778 779
  if (timestamps_with_niladic > 1)
  {
    my_error(ER_TOO_MUCH_AUTO_TIMESTAMP_COLS,MYF(0));
    DBUG_RETURN(-1);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
780 781 782 783 784 785
  if (auto_increment > 1)
  {
    my_error(ER_WRONG_AUTO_KEY,MYF(0));
    DBUG_RETURN(-1);
  }
  if (auto_increment &&
786
      (file->table_flags() & HA_NO_AUTO_INCREMENT))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
787 788 789 790 791
  {
    my_error(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT,MYF(0));
    DBUG_RETURN(-1);
  }

792
  if (blob_columns && (file->table_flags() & HA_NO_BLOBS))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
793 794 795 796 797 798
  {
    my_error(ER_TABLE_CANT_HANDLE_BLOB,MYF(0));
    DBUG_RETURN(-1);
  }

  /* Create keys */
799

800
  List_iterator<Key> key_iterator(keys), key_iterator2(keys);
801
  uint key_parts=0, fk_key_count=0;
802
  bool primary_key=0,unique_key=0;
803
  Key *key, *key2;
804
  uint tmp, key_number;
805 806
  /* special marker for keys to be ignored */
  static char ignore_key[1];
807

808
  /* Calculate number of key segements */
809
  *key_count= 0;
810

bk@work.mysql.com's avatar
bk@work.mysql.com committed
811 812
  while ((key=key_iterator++))
  {
813 814 815 816 817
    if (key->type == Key::FOREIGN_KEY)
    {
      fk_key_count++;
      foreign_key *fk_key= (foreign_key*) key;
      if (fk_key->ref_columns.elements &&
818
	  fk_key->ref_columns.elements != fk_key->columns.elements)
819
      {
820 821 822 823
	my_error(ER_WRONG_FK_DEF, MYF(0), fk_key->name ? fk_key->name :
		 "foreign key without name",
		 ER(ER_KEY_REF_DO_NOT_MATCH_TABLE_REF));
	DBUG_RETURN(-1);
824 825 826
      }
      continue;
    }
827
    (*key_count)++;
828
    tmp=file->max_key_parts();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
829 830 831 832 833
    if (key->columns.elements > tmp)
    {
      my_error(ER_TOO_MANY_KEY_PARTS,MYF(0),tmp);
      DBUG_RETURN(-1);
    }
834
    if (key->name && strlen(key->name) > NAME_LEN)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
835
    {
836
      my_error(ER_TOO_LONG_IDENT, MYF(0), key->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
837 838
      DBUG_RETURN(-1);
    }
839
    key_iterator2.rewind ();
840
    if (key->type != Key::FOREIGN_KEY)
841
    {
842
      while ((key2 = key_iterator2++) != key)
843
      {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
844
	/*
845 846 847
          foreign_key_prefix(key, key2) returns 0 if key or key2, or both, is
          'generated', and a generated key is a prefix of the other key.
          Then we do not need the generated shorter key.
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
848
        */
849 850 851
        if ((key2->type != Key::FOREIGN_KEY &&
             key2->name != ignore_key &&
             !foreign_key_prefix(key, key2)))
852
        {
853
          /* TODO: issue warning message */
854 855 856 857 858 859 860 861 862 863 864 865 866
          /* mark that the generated key should be ignored */
          if (!key2->generated ||
              (key->generated && key->columns.elements <
               key2->columns.elements))
            key->name= ignore_key;
          else
          {
            key2->name= ignore_key;
            key_parts-= key2->columns.elements;
            (*key_count)--;
          }
          break;
        }
867 868 869 870 871 872
      }
    }
    if (key->name != ignore_key)
      key_parts+=key->columns.elements;
    else
      (*key_count)--;
873
    if (key->name && !tmp_table &&
874
	!my_strcasecmp(system_charset_info,key->name,primary_key_name))
875 876 877 878
    {
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name);
      DBUG_RETURN(-1);
    }
879
  }
880
  tmp=file->max_keys();
881
  if (*key_count > tmp)
882 883 884 885
  {
    my_error(ER_TOO_MANY_KEYS,MYF(0),tmp);
    DBUG_RETURN(-1);
  }
886

887
  key_info_buffer=key_info=(KEY*) sql_calloc(sizeof(KEY)* *key_count);
888 889
  key_part_info=(KEY_PART_INFO*) sql_calloc(sizeof(KEY_PART_INFO)*key_parts);
  if (!key_info_buffer || ! key_part_info)
890
    DBUG_RETURN(-1);				// Out of memory
891

892
  key_iterator.rewind();
893
  key_number=0;
894
  for (; (key=key_iterator++) ; key_number++)
895 896 897 898
  {
    uint key_length=0;
    key_part_spec *column;

899 900 901 902 903 904 905 906 907 908
    if (key->name == ignore_key)
    {
      /* ignore redundant keys */
      do
	key=key_iterator++;
      while (key && key->name == ignore_key);
      if (!key)
	break;
    }

909
    switch(key->type){
910
    case Key::MULTIPLE:
911
	key_info->flags= 0;
912
	break;
913
    case Key::FULLTEXT:
914
	key_info->flags= HA_FULLTEXT;
915
	break;
916
    case Key::SPATIAL:
hf@deer.(none)'s avatar
hf@deer.(none) committed
917
#ifdef HAVE_SPATIAL
918
	key_info->flags= HA_SPATIAL;
919
	break;
hf@deer.(none)'s avatar
hf@deer.(none) committed
920
#else
921 922 923
	my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED),MYF(0),
			sym_group_geom.name, sym_group_geom.needed_define);
	DBUG_RETURN(-1);
hf@deer.(none)'s avatar
hf@deer.(none) committed
924
#endif
925
    case Key::FOREIGN_KEY:
926
      key_number--;				// Skip this key
927 928
      continue;
    default:
929 930
      key_info->flags = HA_NOSAME;
      break;
931
    }
932 933
    if (key->generated)
      key_info->flags|= HA_GENERATED_KEY;
934

bk@work.mysql.com's avatar
bk@work.mysql.com committed
935 936
    key_info->key_parts=(uint8) key->columns.elements;
    key_info->key_part=key_part_info;
937
    key_info->usable_key_parts= key_number;
938
    key_info->algorithm=key->algorithm;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
939

940 941
    if (key->type == Key::FULLTEXT)
    {
942
      if (!(file->table_flags() & HA_CAN_FULLTEXT))
943
      {
944 945
	my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0));
	DBUG_RETURN(-1);
946 947
      }
    }
948 949 950
    /*
       Make SPATIAL to be RTREE by default
       SPATIAL only on BLOB or at least BINARY, this
951
       actually should be replaced by special GEOM type
952 953 954
       in near future when new frm file is ready
       checking for proper key parts number:
    */
955

956
    /* TODO: Add proper checks if handler supports key_type and algorithm */
957
    if (key_info->flags & HA_SPATIAL)
958 959 960
    {
      if (key_info->key_parts != 1)
      {
961 962 963
	my_printf_error(ER_WRONG_ARGUMENTS,
			ER(ER_WRONG_ARGUMENTS),MYF(0),"SPATIAL INDEX");
	DBUG_RETURN(-1);
964
      }
965
    }
966
    else if (key_info->algorithm == HA_KEY_ALG_RTREE)
967
    {
hf@deer.(none)'s avatar
hf@deer.(none) committed
968
#ifdef HAVE_RTREE_KEYS
969 970
      if ((key_info->key_parts & 1) == 1)
      {
971 972 973
	my_printf_error(ER_WRONG_ARGUMENTS,
			ER(ER_WRONG_ARGUMENTS),MYF(0),"RTREE INDEX");
	DBUG_RETURN(-1);
974
      }
975 976
      /* TODO: To be deleted */
      my_printf_error(ER_NOT_SUPPORTED_YET, ER(ER_NOT_SUPPORTED_YET),
977
		      MYF(0), "RTREE INDEX");
978
      DBUG_RETURN(-1);
hf@deer.(none)'s avatar
hf@deer.(none) committed
979 980
#else
      my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED),MYF(0),
981
		      sym_group_rtree.name, sym_group_rtree.needed_define);
hf@deer.(none)'s avatar
hf@deer.(none) committed
982 983
      DBUG_RETURN(-1);
#endif
984
    }
985

986
    List_iterator<key_part_spec> cols(key->columns), cols2(key->columns);
987
    CHARSET_INFO *ft_key_charset=0;  // for FULLTEXT
bk@work.mysql.com's avatar
bk@work.mysql.com committed
988 989
    for (uint column_nr=0 ; (column=cols++) ; column_nr++)
    {
990 991
      key_part_spec *dup_column;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
992 993 994
      it.rewind();
      field=0;
      while ((sql_field=it++) &&
995 996 997 998
	     my_strcasecmp(system_charset_info,
			   column->field_name,
			   sql_field->field_name))
	field++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
999 1000
      if (!sql_field)
      {
1001 1002 1003 1004
	my_printf_error(ER_KEY_COLUMN_DOES_NOT_EXITS,
			ER(ER_KEY_COLUMN_DOES_NOT_EXITS),MYF(0),
			column->field_name);
	DBUG_RETURN(-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1005
      }
1006
      while ((dup_column= cols2++) != column)
1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
      {
        if (!my_strcasecmp(system_charset_info,
	     	           column->field_name, dup_column->field_name))
	{
	  my_printf_error(ER_DUP_FIELDNAME,
			  ER(ER_DUP_FIELDNAME),MYF(0),
			  column->field_name);
	  DBUG_RETURN(-1);
	}
      }
      cols2.rewind();
1018
      if (key->type == Key::FULLTEXT)
1019
      {
1020 1021 1022 1023
	if ((sql_field->sql_type != FIELD_TYPE_STRING &&
	     sql_field->sql_type != FIELD_TYPE_VAR_STRING &&
	     !f_is_blob(sql_field->pack_flag)) ||
	    sql_field->charset == &my_charset_bin ||
1024
	    sql_field->charset->mbminlen > 1 || // ucs2 doesn't work yet
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
	    (ft_key_charset && sql_field->charset != ft_key_charset))
	{
	    my_printf_error(ER_BAD_FT_COLUMN,ER(ER_BAD_FT_COLUMN),MYF(0),
			    column->field_name);
	    DBUG_RETURN(-1);
	}
	ft_key_charset=sql_field->charset;
	/*
	  for fulltext keys keyseg length is 1 for blobs (it's ignored in ft
	  code anyway, and 0 (set to column width later) for char's. it has
	  to be correct col width for char's, as char data are not prefixed
	  with length (unlike blobs, where ft code takes data length from a
	  data prefix, ignoring column->length).
	*/
	column->length=test(f_is_blob(sql_field->pack_flag));
1040
      }
1041
      else
1042
      {
1043 1044 1045 1046
	column->length*= sql_field->charset->mbmaxlen;

	if (f_is_blob(sql_field->pack_flag))
	{
1047
	  if (!(file->table_flags() & HA_CAN_INDEX_BLOBS))
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
	  {
	    my_printf_error(ER_BLOB_USED_AS_KEY,ER(ER_BLOB_USED_AS_KEY),MYF(0),
			    column->field_name);
	    DBUG_RETURN(-1);
	  }
	  if (!column->length)
	  {
	    my_printf_error(ER_BLOB_KEY_WITHOUT_LENGTH,
			    ER(ER_BLOB_KEY_WITHOUT_LENGTH),MYF(0),
			    column->field_name);
	    DBUG_RETURN(-1);
	  }
	}
hf@deer.(none)'s avatar
hf@deer.(none) committed
1061
#ifdef HAVE_SPATIAL
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
	if (key->type  == Key::SPATIAL)
	{
	  if (!column->length )
	  {
	    /*
	    BAR: 4 is: (Xmin,Xmax,Ymin,Ymax), this is for 2D case
		 Lately we'll extend this code to support more dimensions
	    */
	    column->length=4*sizeof(double);
	  }
	}
hf@deer.(none)'s avatar
hf@deer.(none) committed
1073
#endif
1074 1075 1076 1077 1078 1079 1080
	if (!(sql_field->flags & NOT_NULL_FLAG))
	{
	  if (key->type == Key::PRIMARY)
	  {
	    /* Implicitly set primary key fields to NOT NULL for ISO conf. */
	    sql_field->flags|= NOT_NULL_FLAG;
	    sql_field->pack_flag&= ~FIELDFLAG_MAYBE_NULL;
monty@mysql.com's avatar
monty@mysql.com committed
1081
            null_fields--;
1082 1083 1084
	  }
	  else
	     key_info->flags|= HA_NULL_PART_KEY;
1085
	  if (!(file->table_flags() & HA_NULL_IN_KEY))
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
	  {
	    my_printf_error(ER_NULL_COLUMN_IN_INDEX,ER(ER_NULL_COLUMN_IN_INDEX),
			    MYF(0),column->field_name);
	    DBUG_RETURN(-1);
	  }
	  if (key->type == Key::SPATIAL)
	  {
	    my_error(ER_SPATIAL_CANT_HAVE_NULL, MYF(0));
	    DBUG_RETURN(-1);
	  }
	}
	if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
	{
	  if (column_nr == 0 || (file->table_flags() & HA_AUTO_PART_KEY))
	    auto_increment--;			// Field is used
	}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1102
      }
1103

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1104 1105 1106 1107 1108 1109
      key_part_info->fieldnr= field;
      key_part_info->offset=  (uint16) sql_field->offset;
      key_part_info->key_type=sql_field->pack_flag;
      uint length=sql_field->pack_length;
      if (column->length)
      {
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
	if (f_is_blob(sql_field->pack_flag))
	{
	  if ((length=column->length) > file->max_key_length() ||
	      length > file->max_key_part_length())
	  {
	    length=min(file->max_key_length(), file->max_key_part_length());
	    if (key->type == Key::MULTIPLE)
	    {
	      /* not a critical problem */
	      char warn_buff[MYSQL_ERRMSG_SIZE];
	      my_snprintf(warn_buff, sizeof(warn_buff), ER(ER_TOO_LONG_KEY),
			  length);
	      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			   ER_TOO_LONG_KEY, warn_buff);
	    }
	    else
	    {
	      my_error(ER_TOO_LONG_KEY,MYF(0),length);
	      DBUG_RETURN(-1);
	    }
	  }
	}
	else if (!f_is_geom(sql_field->pack_flag) &&
		  (column->length > length ||
		   ((f_is_packed(sql_field->pack_flag) ||
		     ((file->table_flags() & HA_NO_PREFIX_CHAR_KEYS) &&
		      (key_info->flags & HA_NOSAME))) &&
		    column->length != length)))
	{
	  my_error(ER_WRONG_SUB_KEY,MYF(0));
	  DBUG_RETURN(-1);
	}
	else if (!(file->table_flags() & HA_NO_PREFIX_CHAR_KEYS))
	  length=column->length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1144 1145 1146
      }
      else if (length == 0)
      {
1147 1148 1149
	my_printf_error(ER_WRONG_KEY_COLUMN, ER(ER_WRONG_KEY_COLUMN), MYF(0),
			column->field_name);
	  DBUG_RETURN(-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1150
      }
1151 1152
      if (length > file->max_key_part_length())
      {
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
	length=file->max_key_part_length();
	if (key->type == Key::MULTIPLE)
	{
	  /* not a critical problem */
	  char warn_buff[MYSQL_ERRMSG_SIZE];
	  my_snprintf(warn_buff, sizeof(warn_buff), ER(ER_TOO_LONG_KEY),
		      length);
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
		       ER_TOO_LONG_KEY, warn_buff);
	}
	else
	{
	  my_error(ER_TOO_LONG_KEY,MYF(0),length);
	  DBUG_RETURN(-1);
	}
1168 1169
      }
      key_part_info->length=(uint16) length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1170 1171
      /* Use packed keys for long strings on the first column */
      if (!(db_options & HA_OPTION_NO_PACK_KEYS) &&
1172 1173 1174 1175
	  (length >= KEY_DEFAULT_PACK_LENGTH &&
	   (sql_field->sql_type == FIELD_TYPE_STRING ||
	    sql_field->sql_type == FIELD_TYPE_VAR_STRING ||
	    sql_field->pack_flag & FIELDFLAG_BLOB)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1176
      {
1177 1178 1179 1180
	if (column_nr == 0 && (sql_field->pack_flag & FIELDFLAG_BLOB))
	  key_info->flags|= HA_BINARY_PACK_KEY;
	else
	  key_info->flags|= HA_PACK_KEY;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1181 1182 1183 1184 1185 1186 1187
      }
      key_length+=length;
      key_part_info++;

      /* Create the key name based on the first column (if not given) */
      if (column_nr == 0)
      {
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206
	if (key->type == Key::PRIMARY)
	{
	  if (primary_key)
	  {
	    my_error(ER_MULTIPLE_PRI_KEY,MYF(0));
	    DBUG_RETURN(-1);
	  }
	  key_name=primary_key_name;
	  primary_key=1;
	}
	else if (!(key_name = key->name))
	  key_name=make_unique_key_name(sql_field->field_name,
					key_info_buffer,key_info);
	if (check_if_keyname_exists(key_name,key_info_buffer,key_info))
	{
	  my_error(ER_DUP_KEYNAME,MYF(0),key_name);
	  DBUG_RETURN(-1);
	}
	key_info->name=(char*) key_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1207 1208
      }
    }
1209 1210
    if (!key_info->name || check_column_name(key_info->name))
    {
1211
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key_info->name);
1212 1213
      DBUG_RETURN(-1);
    }
1214 1215
    if (!(key_info->flags & HA_NULL_PART_KEY))
      unique_key=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1216
    key_info->key_length=(uint16) key_length;
1217
    uint max_key_length= file->max_key_length();
1218
    if (key_length > max_key_length && key->type != Key::FULLTEXT)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1219
    {
1220
      my_error(ER_TOO_LONG_KEY,MYF(0),max_key_length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1221 1222
      DBUG_RETURN(-1);
    }
1223
    key_info++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1224
  }
1225
  if (!unique_key && !primary_key &&
1226
      (file->table_flags() & HA_REQUIRE_PRIMARY_KEY))
1227 1228 1229 1230
  {
    my_error(ER_REQUIRES_PRIMARY_KEY,MYF(0));
    DBUG_RETURN(-1);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1231 1232 1233 1234 1235
  if (auto_increment > 0)
  {
    my_error(ER_WRONG_AUTO_KEY,MYF(0));
    DBUG_RETURN(-1);
  }
1236
  /* Sort keys in optimized order */
1237 1238
  qsort((gptr) key_info_buffer, *key_count, sizeof(KEY),
	(qsort_cmp) sort_keys);
monty@mysql.com's avatar
monty@mysql.com committed
1239
  create_info->null_bits= null_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1240

1241 1242 1243
  DBUG_RETURN(0);
}

1244

1245 1246 1247 1248 1249
/*
  Create a table

  SYNOPSIS
    mysql_create_table()
1250 1251 1252 1253 1254 1255 1256 1257
    thd			Thread object
    db			Database
    table_name		Table name
    create_info		Create information (like MAX_ROWS)
    fields		List of fields to create
    keys		List of keys to create
    tmp_table		Set to 1 if this is an internal temporary table
			(From ALTER TABLE)
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267

  DESCRIPTION
    If one creates a temporary table, this is automaticly opened

    no_log is needed for the case of CREATE ... SELECT,
    as the logging will be done later in sql_insert.cc
    select_field_count is also used for CREATE ... SELECT,
    and must be zero for standard create of table.

  RETURN VALUES
1268 1269
    0	ok
    -1	error
1270 1271 1272
*/

int mysql_create_table(THD *thd,const char *db, const char *table_name,
1273 1274
		       HA_CREATE_INFO *create_info,
		       List<create_field> &fields,
1275
		       List<Key> &keys,bool tmp_table,
1276
		       uint select_field_count)
1277
{
1278 1279 1280 1281 1282 1283 1284
  char		path[FN_REFLEN];
  const char	*alias;
  int		error= -1;
  uint		db_options, key_count;
  KEY		*key_info_buffer;
  handler	*file;
  enum db_type	new_db_type;
1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297
  DBUG_ENTER("mysql_create_table");

  /* Check for duplicate fields and check type of table to create */
  if (!fields.elements)
  {
    my_error(ER_TABLE_MUST_HAVE_COLUMNS,MYF(0));
    DBUG_RETURN(-1);
  }
  if ((new_db_type= ha_checktype(create_info->db_type)) !=
      create_info->db_type)
  {
    create_info->db_type= new_db_type;
    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
1298 1299 1300 1301
			ER_WARN_USING_OTHER_HANDLER,
			ER(ER_WARN_USING_OTHER_HANDLER),
			ha_get_storage_engine(new_db_type),
			table_name);
1302 1303 1304 1305 1306 1307 1308
  }
  db_options=create_info->table_options;
  if (create_info->row_type == ROW_TYPE_DYNAMIC)
    db_options|=HA_OPTION_PACK_RECORD;
  alias= table_case_name(create_info, table_name);
  file=get_new_handler((TABLE*) 0, create_info->db_type);

1309 1310 1311 1312 1313 1314 1315 1316
#ifdef NOT_USED
  /*
    if there is a technical reason for a handler not to have support
    for temp. tables this code can be re-enabled.
    Otherwise, if a handler author has a wish to prohibit usage of
    temporary tables for his handler he should implement a check in
    ::create() method
  */
1317 1318 1319 1320 1321 1322
  if ((create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
      (file->table_flags() & HA_NO_TEMP_TABLES))
  {
    my_error(ER_ILLEGAL_HA,MYF(0),table_name);
    DBUG_RETURN(-1);
  }
1323
#endif
1324

1325 1326 1327 1328 1329 1330 1331 1332 1333
  /*
    If the table character set was not given explicitely,
    let's fetch the database default character set and
    apply it to the table.
  */
  if (!create_info->default_table_charset)
  {
    HA_CREATE_INFO db_info;
    char  path[FN_REFLEN];
1334 1335
    /* Abuse build_table_path() to build the path to the db.opt file */
    build_table_path(path, sizeof(path), db, MY_DB_OPT_FILE, "");
1336 1337 1338 1339
    load_db_opt(thd, path, &db_info);
    create_info->default_table_charset= db_info.default_table_charset;
  }

1340
  if (mysql_prepare_table(thd, create_info, fields,
1341 1342 1343
			  keys, tmp_table, db_options, file,
			  key_info_buffer, &key_count,
			  select_field_count))
1344 1345
    DBUG_RETURN(-1);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1346 1347 1348
      /* Check if table exists */
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
1349
    char tmp_table_name[tmp_file_prefix_length+22+22+22+3];
1350 1351 1352
    my_snprintf(tmp_table_name, sizeof(tmp_table_name), "%s%lx_%lx_%x",
		tmp_file_prefix, current_pid, thd->thread_id,
		thd->tmp_table++);
1353
    if (lower_case_table_names)
1354
      my_casedn_str(files_charset_info, tmp_table_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1355
    create_info->table_options|=HA_CREATE_DELAY_KEY_WRITE;
1356
    build_table_path(path, sizeof(path), db, tmp_table_name, reg_ext);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1357 1358
  }
  else
1359 1360
    build_table_path(path, sizeof(path), db, alias, reg_ext);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1361 1362 1363 1364
  /* Check if table already exists */
  if ((create_info->options & HA_LEX_CREATE_TMP_TABLE)
      && find_temporary_table(thd,db,table_name))
  {
1365
    if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
1366
    {
1367
      create_info->table_existed= 1;		// Mark that table existed
1368
      DBUG_RETURN(0);
1369
    }
monty@mysql.com's avatar
monty@mysql.com committed
1370
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1371 1372
    DBUG_RETURN(-1);
  }
serg@serg.mylan's avatar
serg@serg.mylan committed
1373
  if (wait_if_global_read_lock(thd, 0, 1))
1374
    DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1375 1376 1377 1378 1379 1380
  VOID(pthread_mutex_lock(&LOCK_open));
  if (!tmp_table && !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
  {
    if (!access(path,F_OK))
    {
      if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
1381
      {
1382 1383 1384
	create_info->table_existed= 1;		// Mark that table existed
	error= 0;
      }
1385
      else
1386
	my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
1387
      goto end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1388 1389 1390
    }
  }

1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403
  /*
    Check that table with given name does not already
    exist in any storage engine. In such a case it should
    be discovered and the error ER_TABLE_EXISTS_ERROR be returned
    unless user specified CREATE TABLE IF EXISTS
    The LOCK_open mutex has been locked to make sure no
    one else is attempting to discover the table. Since
    it's not on disk as a frm file, no one could be using it!
  */
  if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
  {
    bool create_if_not_exists =
      create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS;
1404
    if (ha_table_exists_in_engine(thd, db, table_name))
1405
    {
1406
      DBUG_PRINT("info", ("Table with same name already existed in handler"));
1407 1408 1409

      if (create_if_not_exists)
      {
1410 1411
        create_info->table_existed= 1;   // Mark that table existed
        error= 0;
1412 1413 1414 1415 1416 1417 1418
      }
      else
       my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
      goto end;
    }
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1419
  thd->proc_info="creating table";
1420
  create_info->table_existed= 0;		// Mark that table is created
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1421

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1422
  if (thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE)
1423
    create_info->data_file_name= create_info->index_file_name= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1424
  create_info->table_options=db_options;
1425

1426
  if (rea_create_table(thd, path, create_info, fields, key_count,
1427
		       key_info_buffer))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439
  {
    /* my_error(ER_CANT_CREATE_TABLE,MYF(0),table_name,my_errno); */
    goto end;
  }
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
    /* Open table and put in temporary table list */
    if (!(open_temporary_table(thd, path, db, table_name, 1)))
    {
      (void) rm_temporary_table(create_info->db_type, path);
      goto end;
    }
1440
    thd->tmp_table_used= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1441
  }
1442
  if (!tmp_table)
1443 1444 1445 1446 1447
  {
    // Must be written before unlock
    mysql_update_log.write(thd,thd->query, thd->query_length);
    if (mysql_bin_log.is_open())
    {
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1448
      thd->clear_error();
1449
      Query_log_event qinfo(thd, thd->query, thd->query_length,
1450
			    test(create_info->options &
1451 1452
				 HA_LEX_CREATE_TMP_TABLE),
			    FALSE);
1453 1454 1455
      mysql_bin_log.write(&qinfo);
    }
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1456 1457 1458
  error=0;
end:
  VOID(pthread_mutex_unlock(&LOCK_open));
1459
  start_waiting_global_read_lock(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471
  thd->proc_info="After create";
  DBUG_RETURN(error);
}

/*
** Give the key name after the first field with an optional '_#' after
**/

static bool
check_if_keyname_exists(const char *name, KEY *start, KEY *end)
{
  for (KEY *key=start ; key != end ; key++)
1472
    if (!my_strcasecmp(system_charset_info,name,key->name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1473 1474 1475 1476 1477 1478 1479 1480 1481 1482
      return 1;
  return 0;
}


static char *
make_unique_key_name(const char *field_name,KEY *start,KEY *end)
{
  char buff[MAX_FIELD_NAME],*buff_end;

1483 1484
  if (!check_if_keyname_exists(field_name,start,end) &&
      my_strcasecmp(system_charset_info,field_name,primary_key_name))
1485 1486 1487 1488 1489 1490 1491
    return (char*) field_name;			// Use fieldname
  buff_end=strmake(buff,field_name, sizeof(buff)-4);

  /*
    Only 3 chars + '\0' left, so need to limit to 2 digit
    This is ok as we can't have more than 100 keys anyway
  */
1492
  for (uint i=2 ; i< 100; i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1493
  {
1494 1495
    *buff_end= '_';
    int10_to_str(i, buff_end+1, 10);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1496 1497 1498
    if (!check_if_keyname_exists(buff,start,end))
      return sql_strdup(buff);
  }
1499
  return (char*) "not_specified";		// Should never happen
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1500 1501
}

1502

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1503 1504 1505 1506 1507
/****************************************************************************
** Create table from a list of fields and items
****************************************************************************/

TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
1508 1509 1510 1511 1512
			       const char *db, const char *name,
			       List<create_field> *extra_fields,
			       List<Key> *keys,
			       List<Item> *items,
			       MYSQL_LOCK **lock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1513
{
1514
  TABLE tmp_table;		// Used during 'create_field()'
1515
  TABLE *table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1516
  tmp_table.table_name=0;
1517
  uint select_field_count= items->elements;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1518 1519 1520
  DBUG_ENTER("create_table_from_items");

  /* Add selected items to field list */
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1521
  List_iterator_fast<Item> it(*items);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1522 1523 1524 1525 1526 1527
  Item *item;
  Field *tmp_field;
  tmp_table.db_create_options=0;
  tmp_table.null_row=tmp_table.maybe_null=0;
  tmp_table.blob_ptr_size=portable_sizeof_char_ptr;
  tmp_table.db_low_byte_first= test(create_info->db_type == DB_TYPE_MYISAM ||
1528
				    create_info->db_type == DB_TYPE_HEAP);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1529 1530 1531 1532

  while ((item=it++))
  {
    create_field *cr_field;
1533 1534 1535 1536 1537
    Field *field;
    if (item->type() == Item::FUNC_ITEM)
      field=item->tmp_table_field(&tmp_table);
    else
      field=create_tmp_field(thd, &tmp_table, item, item->type(),
1538
				  (Item ***) 0, &tmp_field, 0, 0, 0);
1539
    if (!field ||
1540 1541 1542
	!(cr_field=new create_field(field,(item->type() == Item::FIELD_ITEM ?
					   ((Item_field *)item)->field :
					   (Field*) 0))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1543 1544 1545 1546
      DBUG_RETURN(0);
    extra_fields->push_back(cr_field);
  }
  /* create and lock table */
1547
  /* QQ: create and open should be done atomic ! */
1548
  /*
1549
    We don't log the statement, it will be logged later.
1550 1551 1552 1553
    If this is a HEAP table, the automatic DELETE FROM which is written to the
    binlog when a HEAP table is opened for the first time since startup, must
    not be written: 1) it would be wrong (imagine we're in CREATE SELECT: we
    don't want to delete from it) 2) it would be written before the CREATE
1554 1555
    TABLE, which is a wrong order. So we keep binary logging disabled when we
    open_table().
1556
  */
1557
  tmp_disable_binlog(thd);
serg@serg.mylan's avatar
serg@serg.mylan committed
1558
  if (!mysql_create_table(thd,db,name,create_info,*extra_fields,
serg@serg.mylan's avatar
serg@serg.mylan committed
1559
			 *keys,0,select_field_count))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1560
  {
1561 1562
    if (!(table=open_table(thd,db,name,name,(bool*) 0)))
      quick_rm_table(create_info->db_type,db,table_case_name(create_info,name));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1563
  }
1564 1565 1566
  reenable_binlog(thd);
  if (!table)
    DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1567
  table->reginfo.lock_type=TL_WRITE;
1568
  if (! ((*lock)= mysql_lock_tables(thd, &table, 1, MYSQL_LOCK_IGNORE_FLUSH)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1569
  {
1570
    VOID(pthread_mutex_lock(&LOCK_open));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1571
    hash_delete(&open_cache,(byte*) table);
1572
    VOID(pthread_mutex_unlock(&LOCK_open));
1573
    quick_rm_table(create_info->db_type,db,table_case_name(create_info, name));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584
    DBUG_RETURN(0);
  }
  table->file->extra(HA_EXTRA_WRITE_CACHE);
  DBUG_RETURN(table);
}


/****************************************************************************
** Alter a table definition
****************************************************************************/

1585
bool
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1586
mysql_rename_table(enum db_type base,
1587 1588 1589 1590
		   const char *old_db,
		   const char *old_name,
		   const char *new_db,
		   const char *new_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1591
{
1592 1593 1594
  char from[FN_REFLEN], to[FN_REFLEN], lc_from[FN_REFLEN], lc_to[FN_REFLEN];
  char *from_base= from, *to_base= to;
  char tmp_name[NAME_LEN+1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1595
  handler *file=get_new_handler((TABLE*) 0, base);
1596
  int error=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1597
  DBUG_ENTER("mysql_rename_table");
1598

1599 1600 1601 1602 1603 1604 1605 1606
  build_table_path(from, sizeof(from), old_db, old_name, "");
  build_table_path(to, sizeof(to), new_db, new_name, "");

  /*
    If lower_case_table_names == 2 (case-preserving but case-insensitive
    file system) and the storage is not HA_FILE_BASED, we need to provide
    a lowercase file name, but we leave the .frm in mixed case.
   */
1607 1608
  if (lower_case_table_names == 2 && !(file->table_flags() & HA_FILE_BASED))
  {
1609 1610 1611 1612
    strmov(tmp_name, old_name);
    my_casedn_str(files_charset_info, tmp_name);
    build_table_path(lc_from, sizeof(lc_from), old_db, tmp_name, "");
    from_base= lc_from;
1613

1614 1615 1616 1617
    strmov(tmp_name, new_name);
    my_casedn_str(files_charset_info, tmp_name);
    build_table_path(lc_to, sizeof(lc_to), new_db, tmp_name, "");
    to_base= lc_to;
1618 1619
  }

1620
  if (!(error=file->rename_table(from_base, to_base)))
1621 1622 1623
  {
    if (rename_file_ext(from,to,reg_ext))
    {
1624
      error=my_errno;
1625
      /* Restore old file name */
1626
      file->rename_table(to_base, from_base);
1627 1628
    }
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1629
  delete file;
1630 1631 1632
  if (error)
    my_error(ER_ERROR_ON_RENAME, MYF(0), from, to, error);
  DBUG_RETURN(error != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1633 1634
}

1635

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1636
/*
1637 1638 1639 1640
  Force all other threads to stop using the table

  SYNOPSIS
    wait_while_table_is_used()
1641 1642 1643 1644
    thd			Thread handler
    table		Table to remove from cache
    function		HA_EXTRA_PREPARE_FOR_DELETE if table is to be deleted
			HA_EXTRA_FORCE_REOPEN if table is not be used
1645 1646 1647 1648 1649 1650 1651
  NOTES
   When returning, the table will be unusable for other threads until
   the table is closed.

  PREREQUISITES
    Lock on LOCK_open
    Win32 clients must also have a WRITE LOCK on the table !
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1652 1653
*/

1654
static void wait_while_table_is_used(THD *thd,TABLE *table,
1655
				     enum ha_extra_function function)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1656
{
1657 1658 1659
  DBUG_PRINT("enter",("table: %s", table->real_name));
  DBUG_ENTER("wait_while_table_is_used");
  safe_mutex_assert_owner(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1660

1661
  VOID(table->file->extra(function));
1662
  /* Mark all tables that are in use as 'old' */
1663
  mysql_lock_abort(thd, table);			// end threads waiting on lock
1664 1665 1666

  /* Wait until all there are no other threads that has this table open */
  while (remove_table_from_cache(thd,table->table_cache_key,
1667
				 table->real_name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1668
  {
1669 1670 1671
    dropping_tables++;
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
    dropping_tables--;
1672 1673 1674
  }
  DBUG_VOID_RETURN;
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1675

1676 1677
/*
  Close a cached table
1678

1679
  SYNOPSIS
1680
    close_cached_table()
1681 1682
    thd			Thread handler
    table		Table to remove from cache
1683 1684 1685 1686

  NOTES
    Function ends by signaling threads waiting for the table to try to
    reopen the table.
1687

1688 1689 1690 1691
  PREREQUISITES
    Lock on LOCK_open
    Win32 clients must also have a WRITE LOCK on the table !
*/
1692

1693
static bool close_cached_table(THD *thd, TABLE *table)
1694 1695
{
  DBUG_ENTER("close_cached_table");
1696

1697
  wait_while_table_is_used(thd, table, HA_EXTRA_PREPARE_FOR_DELETE);
1698 1699
  /* Close lock if this is not got with LOCK TABLES */
  if (thd->lock)
1700
  {
1701
    mysql_unlock_tables(thd, thd->lock);
1702
    thd->lock=0;			// Start locked threads
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1703
  }
1704 1705 1706 1707 1708
  /* Close all copies of 'table'.  This also frees all LOCK TABLES lock */
  thd->open_tables=unlink_open_table(thd,thd->open_tables,table);

  /* When lock on LOCK_open is freed other threads can continue */
  pthread_cond_broadcast(&COND_refresh);
1709
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1710 1711
}

1712
static int send_check_errmsg(THD *thd, TABLE_LIST* table,
1713
			     const char* operator_name, const char* errmsg)
1714

1715
{
1716 1717
  Protocol *protocol= thd->protocol;
  protocol->prepare_for_resend();
1718 1719 1720 1721
  protocol->store(table->alias, system_charset_info);
  protocol->store((char*) operator_name, system_charset_info);
  protocol->store("error", 5, system_charset_info);
  protocol->store(errmsg, system_charset_info);
1722
  thd->net.last_error[0]=0;
1723
  if (protocol->write())
1724 1725 1726 1727
    return -1;
  return 1;
}

1728

serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1729
static int prepare_for_restore(THD* thd, TABLE_LIST* table,
1730
			       HA_CHECK_OPT *check_opt)
1731
{
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1732
  DBUG_ENTER("prepare_for_restore");
1733

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1734 1735 1736
  if (table->table) // do not overwrite existing tables on restore
  {
    DBUG_RETURN(send_check_errmsg(thd, table, "restore",
1737 1738
				  "table exists, will not overwrite on restore"
				  ));
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1739
  }
1740
  else
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1741
  {
1742
    char* backup_dir= thd->lex->backup_dir;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1743
    char src_path[FN_REFLEN], dst_path[FN_REFLEN];
1744
    char* table_name = table->real_name;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1745
    char* db = thd->db ? thd->db : table->db;
1746

1747
    if (fn_format_relative_to_data_home(src_path, table_name, backup_dir,
1748
					reg_ext))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1749
      DBUG_RETURN(-1); // protect buffer overflow
1750

1751
    my_snprintf(dst_path, sizeof(dst_path), "%s%s/%s",
1752
		mysql_real_data_home, db, table_name);
1753

1754
    if (lock_and_wait_for_table_name(thd,table))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1755
      DBUG_RETURN(-1);
1756

1757
    if (my_copy(src_path,
1758 1759
		fn_format(dst_path, dst_path,"", reg_ext, 4),
		MYF(MY_WME)))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1760
    {
1761
      pthread_mutex_lock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1762
      unlock_table_name(thd, table);
1763
      pthread_mutex_unlock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1764
      DBUG_RETURN(send_check_errmsg(thd, table, "restore",
1765
				    "Failed copying .frm file"));
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1766
    }
1767
    if (mysql_truncate(thd, table, 1))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1768
    {
1769
      pthread_mutex_lock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1770
      unlock_table_name(thd, table);
1771
      pthread_mutex_unlock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1772
      DBUG_RETURN(send_check_errmsg(thd, table, "restore",
1773
				    "Failed generating table from .frm file"));
1774
    }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1775
  }
1776

1777 1778 1779 1780
  /*
    Now we should be able to open the partially restored table
    to finish the restore in the handler later on
  */
1781
  if (!(table->table = reopen_name_locked_table(thd, table)))
1782 1783
  {
    pthread_mutex_lock(&LOCK_open);
1784
    unlock_table_name(thd, table);
1785 1786
    pthread_mutex_unlock(&LOCK_open);
  }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1787
  DBUG_RETURN(0);
1788
}
1789

1790

1791
static int prepare_for_repair(THD* thd, TABLE_LIST *table_list,
1792
			      HA_CHECK_OPT *check_opt)
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1793
{
1794 1795
  int error= 0;
  TABLE tmp_table, *table;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1796 1797 1798 1799
  DBUG_ENTER("prepare_for_repair");

  if (!(check_opt->sql_flags & TT_USEFRM))
    DBUG_RETURN(0);
1800

1801
  if (!(table= table_list->table))		/* if open_ltable failed */
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1802
  {
1803
    char name[FN_REFLEN];
1804 1805
    build_table_path(name, sizeof(name), table_list->db,
                     table_list->real_name, "");
1806
    if (openfrm(name, "", 0, 0, 0, &tmp_table))
1807
      DBUG_RETURN(0);				// Can't open frm file
1808
    table= &tmp_table;
1809
  }
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1810

1811 1812 1813 1814 1815 1816 1817 1818 1819
  /*
    User gave us USE_FRM which means that the header in the index file is
    trashed.
    In this case we will try to fix the table the following way:
    - Rename the data file to a temporary name
    - Truncate the table
    - Replace the new data file with the old one
    - Run a normal repair using the new index file and the old data file
  */
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1820

1821 1822 1823
  char from[FN_REFLEN],tmp[FN_REFLEN+32];
  const char **ext= table->file->bas_ext();
  MY_STAT stat_info;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1824

1825 1826 1827 1828 1829
  /*
    Check if this is a table type that stores index and data separately,
    like ISAM or MyISAM
  */
  if (!ext[0] || !ext[1])
1830
    goto end;					// No data file
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1831

1832
  strxmov(from, table->path, ext[1], NullS);	// Name of data file
1833
  if (!my_stat(from, &stat_info, MYF(0)))
1834
    goto end;				// Can't use USE_FRM flag
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1835

1836 1837
  my_snprintf(tmp, sizeof(tmp), "%s-%lx_%lx",
	      from, current_pid, thd->thread_id);
1838

1839 1840 1841 1842 1843 1844 1845
  /* If we could open the table, close it */
  if (table_list->table)
  {
    pthread_mutex_lock(&LOCK_open);
    close_cached_table(thd, table);
    pthread_mutex_unlock(&LOCK_open);
  }
1846
  if (lock_and_wait_for_table_name(thd,table_list))
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1847
  {
1848 1849
    error= -1;
    goto end;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1850
  }
1851
  if (my_rename(from, tmp, MYF(MY_WME)))
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1852
  {
1853
    pthread_mutex_lock(&LOCK_open);
1854
    unlock_table_name(thd, table_list);
1855
    pthread_mutex_unlock(&LOCK_open);
1856
    error= send_check_errmsg(thd, table_list, "repair",
1857
			     "Failed renaming data file");
1858 1859 1860 1861 1862 1863 1864 1865
    goto end;
  }
  if (mysql_truncate(thd, table_list, 1))
  {
    pthread_mutex_lock(&LOCK_open);
    unlock_table_name(thd, table_list);
    pthread_mutex_unlock(&LOCK_open);
    error= send_check_errmsg(thd, table_list, "repair",
1866
			     "Failed generating table from .frm file");
1867 1868 1869 1870 1871 1872 1873 1874
    goto end;
  }
  if (my_rename(tmp, from, MYF(MY_WME)))
  {
    pthread_mutex_lock(&LOCK_open);
    unlock_table_name(thd, table_list);
    pthread_mutex_unlock(&LOCK_open);
    error= send_check_errmsg(thd, table_list, "repair",
1875
			     "Failed restoring .MYD file");
1876
    goto end;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1877 1878
  }

1879 1880 1881 1882
  /*
    Now we should be able to open the partially repaired table
    to finish the repair in the handler later on.
  */
1883
  if (!(table_list->table = reopen_name_locked_table(thd, table_list)))
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1884 1885
  {
    pthread_mutex_lock(&LOCK_open);
1886
    unlock_table_name(thd, table_list);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1887 1888
    pthread_mutex_unlock(&LOCK_open);
  }
1889 1890 1891

end:
  if (table == &tmp_table)
1892
    closefrm(table);				// Free allocated memory
1893
  DBUG_RETURN(error);
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1894
}
1895

1896

1897 1898 1899 1900 1901 1902
/*
  RETURN VALUES
    0   Message sent to net (admin operation went ok)
   -1   Message should be sent by caller 
        (admin operation or network communication failed)
*/
1903
static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
1904 1905 1906 1907 1908 1909 1910 1911 1912
			     HA_CHECK_OPT* check_opt,
			     const char *operator_name,
			     thr_lock_type lock_type,
			     bool open_for_modify,
			     uint extra_open_options,
			     int (*prepare_func)(THD *, TABLE_LIST *,
						 HA_CHECK_OPT *),
			     int (handler::*operator_func)
			     (THD *, HA_CHECK_OPT *))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1913 1914 1915
{
  TABLE_LIST *table;
  List<Item> field_list;
1916 1917
  Item *item;
  Protocol *protocol= thd->protocol;
1918
  DBUG_ENTER("mysql_admin_table");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1919 1920 1921 1922 1923 1924 1925 1926 1927

  field_list.push_back(item = new Item_empty_string("Table", NAME_LEN*2));
  item->maybe_null = 1;
  field_list.push_back(item = new Item_empty_string("Op", 10));
  item->maybe_null = 1;
  field_list.push_back(item = new Item_empty_string("Msg_type", 10));
  item->maybe_null = 1;
  field_list.push_back(item = new Item_empty_string("Msg_text", 255));
  item->maybe_null = 1;
1928
  if (protocol->send_fields(&field_list, 1))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1929 1930
    DBUG_RETURN(-1);

1931
  mysql_ha_flush(thd, tables, MYSQL_HA_CLOSE_FINAL);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1932 1933 1934
  for (table = tables; table; table = table->next)
  {
    char table_name[NAME_LEN*2+2];
1935
    char* db = table->db;
1936
    bool fatal_error=0;
1937
    strxmov(table_name, db, ".", table->real_name, NullS);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1938

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1939
    thd->open_options|= extra_open_options;
1940
    table->table = open_ltable(thd, table, lock_type);
1941 1942 1943
#ifdef EMBEDDED_LIBRARY
    thd->net.last_errno= 0;  // these errors shouldn't get client
#endif
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1944
    thd->open_options&= ~extra_open_options;
1945

1946
    if (prepare_func)
1947
    {
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1948
      switch ((*prepare_func)(thd, table, check_opt)) {
1949 1950 1951 1952 1953 1954 1955
      case  1:           // error, message written to net
        close_thread_tables(thd);
        continue;
      case -1:           // error, message could be written to net
        goto err;
      default:           // should be 0 otherwise
        ;
1956
      }
1957
    }
1958

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1959 1960 1961
    if (!table->table)
    {
      const char *err_msg;
1962
      protocol->prepare_for_resend();
1963 1964 1965
      protocol->store(table_name, system_charset_info);
      protocol->store(operator_name, system_charset_info);
      protocol->store("error",5, system_charset_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1966
      if (!(err_msg=thd->net.last_error))
1967
	err_msg=ER(ER_CHECK_NO_SUCH_TABLE);
1968
      protocol->store(err_msg, system_charset_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1969
      thd->net.last_error[0]=0;
1970
      if (protocol->write())
1971
	goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1972 1973
      continue;
    }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1974
    table->table->pos_in_table_list= table;
1975
    if ((table->table->db_stat & HA_READ_ONLY) && open_for_modify)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1976
    {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1977
      char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
1978
      protocol->prepare_for_resend();
1979 1980 1981
      protocol->store(table_name, system_charset_info);
      protocol->store(operator_name, system_charset_info);
      protocol->store("error", 5, system_charset_info);
1982
      my_snprintf(buff, sizeof(buff), ER(ER_OPEN_AS_READONLY), table_name);
1983
      protocol->store(buff, system_charset_info);
1984
      close_thread_tables(thd);
1985
      table->table=0;				// For query cache
1986
      if (protocol->write())
1987
	goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1988 1989 1990
      continue;
    }

1991
    /* Close all instances of the table to allow repair to rename files */
1992
    if (lock_type == TL_WRITE && table->table->version)
1993 1994
    {
      pthread_mutex_lock(&LOCK_open);
1995
      const char *old_message=thd->enter_cond(&COND_refresh, &LOCK_open,
1996
					      "Waiting to get writelock");
1997 1998
      mysql_lock_abort(thd,table->table);
      while (remove_table_from_cache(thd, table->table->table_cache_key,
1999 2000
				     table->table->real_name) &&
	     ! thd->killed)
2001
      {
2002 2003 2004
	dropping_tables++;
	(void) pthread_cond_wait(&COND_refresh,&LOCK_open);
	dropping_tables--;
2005
      }
2006
      thd->exit_cond(old_message);
2007
      if (thd->killed)
2008
	goto err;
2009 2010 2011
      /* Flush entries in the query cache involving this table. */
      query_cache_invalidate3(thd, table->table, 0);
      open_for_modify= 0;
2012 2013
    }

2014
    int result_code = (table->table->file->*operator_func)(thd, check_opt);
hf@bisonxp.(none)'s avatar
hf@bisonxp.(none) committed
2015 2016 2017
#ifdef EMBEDDED_LIBRARY
    thd->net.last_errno= 0;  // these errors shouldn't get client
#endif
2018
    protocol->prepare_for_resend();
2019 2020
    protocol->store(table_name, system_charset_info);
    protocol->store(operator_name, system_charset_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2021

2022 2023 2024
send_result_message:

    DBUG_PRINT("info", ("result_code: %d", result_code));
2025 2026
    switch (result_code) {
    case HA_ADMIN_NOT_IMPLEMENTED:
2027
      {
2028 2029 2030
	char buf[ERRMSGSIZE+20];
	uint length=my_snprintf(buf, ERRMSGSIZE,
				ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);
2031
	protocol->store("note", 4, system_charset_info);
2032
	protocol->store(buf, length, system_charset_info);
2033
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2034 2035
      break;

2036
    case HA_ADMIN_OK:
2037 2038
      protocol->store("status", 6, system_charset_info);
      protocol->store("OK",2, system_charset_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2039 2040
      break;

2041
    case HA_ADMIN_FAILED:
2042 2043
      protocol->store("status", 6, system_charset_info);
      protocol->store("Operation failed",16, system_charset_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2044 2045
      break;

vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
2046 2047 2048
    case HA_ADMIN_REJECT:
      protocol->store("status", 6, system_charset_info);
      protocol->store("Operation need committed state",30, system_charset_info);
monty@mysql.com's avatar
monty@mysql.com committed
2049
      open_for_modify= FALSE;
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
2050 2051
      break;

2052
    case HA_ADMIN_ALREADY_DONE:
2053 2054
      protocol->store("status", 6, system_charset_info);
      protocol->store("Table is already up to date", 27, system_charset_info);
2055 2056
      break;

2057
    case HA_ADMIN_CORRUPT:
2058
      protocol->store("error", 5, system_charset_info);
2059
      protocol->store("Corrupt", 7, system_charset_info);
2060
      fatal_error=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2061 2062
      break;

2063
    case HA_ADMIN_INVALID:
2064 2065
      protocol->store("error", 5, system_charset_info);
      protocol->store("Invalid argument",16, system_charset_info);
2066 2067
      break;

2068 2069 2070 2071 2072 2073 2074 2075 2076 2077
    case HA_ADMIN_TRY_ALTER:
    {
      /*
        This is currently used only by InnoDB. ha_innobase::optimize() answers
        "try with alter", so here we close the table, do an ALTER TABLE,
        reopen the table and do ha_innobase::analyze() on it.
      */
      close_thread_tables(thd);
      TABLE_LIST *save_next= table->next;
      table->next= 0;
2078
      tmp_disable_binlog(thd); // binlogging is done by caller if wanted
2079
      result_code= mysql_recreate_table(thd, table, 0);
2080
      reenable_binlog(thd);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2081
      close_thread_tables(thd);
2082 2083 2084 2085 2086 2087
      if (!result_code) // recreation went ok
      {
        if ((table->table= open_ltable(thd, table, lock_type)) &&
            ((result_code= table->table->file->analyze(thd, check_opt)) > 0))
          result_code= 0; // analyze went ok
      }
2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109
      if (result_code) // either mysql_recreate_table or analyze failed
      {
        const char *err_msg;
        if ((err_msg= thd->net.last_error))
        {
          if (!thd->vio_ok())
          {
            sql_print_error(err_msg);
          }
          else
          {
            /* Hijack the row already in-progress. */
            protocol->store("error", 5, system_charset_info);
            protocol->store(err_msg, system_charset_info);
            (void)protocol->write();
            /* Start off another row for HA_ADMIN_FAILED */
            protocol->prepare_for_resend();
            protocol->store(table_name, system_charset_info);
            protocol->store(operator_name, system_charset_info);
          }
        }
      }
2110 2111 2112 2113 2114
      result_code= result_code ? HA_ADMIN_FAILED : HA_ADMIN_OK;
      table->next= save_next;
      goto send_result_message;
    }

2115
    default:				// Probably HA_ADMIN_INTERNAL_ERROR
2116 2117
      protocol->store("error", 5, system_charset_info);
      protocol->store("Unknown - internal error during operation", 41
2118
		      , system_charset_info);
2119
      fatal_error=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2120 2121
      break;
    }
2122
    if (fatal_error)
2123
      table->table->version=0;			// Force close of table
2124
    else if (open_for_modify)
2125
    {
2126
      pthread_mutex_lock(&LOCK_open);
2127
      remove_table_from_cache(thd, table->table->table_cache_key,
2128
			      table->table->real_name);
2129
      pthread_mutex_unlock(&LOCK_open);
2130 2131 2132
      /* May be something modified consequently we have to invalidate cache */
      query_cache_invalidate3(thd, table->table, 0);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2133
    close_thread_tables(thd);
2134
    table->table=0;				// For query cache
2135
    if (protocol->write())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2136 2137 2138
      goto err;
  }

2139
  send_eof(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2140 2141
  DBUG_RETURN(0);
 err:
2142
  close_thread_tables(thd);			// Shouldn't be needed
2143 2144
  if (table)
    table->table=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2145 2146 2147
  DBUG_RETURN(-1);
}

2148

2149 2150 2151 2152
int mysql_backup_table(THD* thd, TABLE_LIST* table_list)
{
  DBUG_ENTER("mysql_backup_table");
  DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
2153 2154
				"backup", TL_READ, 0, 0, 0,
				&handler::backup));
2155
}
2156

2157

2158 2159 2160 2161
int mysql_restore_table(THD* thd, TABLE_LIST* table_list)
{
  DBUG_ENTER("mysql_restore_table");
  DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
2162 2163 2164
				"restore", TL_WRITE, 1, 0,
				&prepare_for_restore,
				&handler::restore));
2165
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2166

2167

2168 2169 2170 2171
int mysql_repair_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
{
  DBUG_ENTER("mysql_repair_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
2172 2173 2174
				"repair", TL_WRITE, 1, HA_OPEN_FOR_REPAIR,
				&prepare_for_repair,
				&handler::repair));
2175 2176
}

2177

2178 2179 2180 2181
int mysql_optimize_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
{
  DBUG_ENTER("mysql_optimize_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
2182 2183
				"optimize", TL_WRITE, 1,0,0,
				&handler::optimize));
2184 2185 2186
}


igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2187 2188 2189 2190 2191
/*
  Assigned specified indexes for a table into key cache

  SYNOPSIS
    mysql_assign_to_keycache()
2192 2193
    thd		Thread object
    tables	Table list (one table only)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2194 2195

  RETURN VALUES
2196 2197
    0	  ok
   -1	  error
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2198 2199
*/

2200
int mysql_assign_to_keycache(THD* thd, TABLE_LIST* tables,
2201
			     LEX_STRING *key_cache_name)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2202
{
2203
  HA_CHECK_OPT check_opt;
2204
  KEY_CACHE *key_cache;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2205
  DBUG_ENTER("mysql_assign_to_keycache");
2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217

  check_opt.init();
  pthread_mutex_lock(&LOCK_global_system_variables);
  if (!(key_cache= get_key_cache(key_cache_name)))
  {
    pthread_mutex_unlock(&LOCK_global_system_variables);
    my_error(ER_UNKNOWN_KEY_CACHE, MYF(0), key_cache_name->str);
    DBUG_RETURN(-1);
  }
  pthread_mutex_unlock(&LOCK_global_system_variables);
  check_opt.key_cache= key_cache;
  DBUG_RETURN(mysql_admin_table(thd, tables, &check_opt,
2218 2219
				"assign_to_keycache", TL_READ_NO_INSERT, 0,
				0, 0, &handler::assign_to_keycache));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2220 2221
}

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2222 2223 2224 2225 2226 2227

/*
  Reassign all tables assigned to a key cache to another key cache

  SYNOPSIS
    reassign_keycache_tables()
2228 2229 2230
    thd		Thread object
    src_cache	Reference to the key cache to clean up
    dest_cache	New key cache
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2231

2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244
  NOTES
    This is called when one sets a key cache size to zero, in which
    case we have to move the tables associated to this key cache to
    the "default" one.

    One has to ensure that one never calls this function while
    some other thread is changing the key cache. This is assured by
    the caller setting src_cache->in_init before calling this function.

    We don't delete the old key cache as there may still be pointers pointing
    to it for a while after this function returns.

 RETURN VALUES
2245
    0	  ok
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2246 2247
*/

2248 2249
int reassign_keycache_tables(THD *thd, KEY_CACHE *src_cache,
			     KEY_CACHE *dst_cache)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2250 2251 2252
{
  DBUG_ENTER("reassign_keycache_tables");

2253 2254
  DBUG_ASSERT(src_cache != dst_cache);
  DBUG_ASSERT(src_cache->in_init);
2255
  src_cache->param_buff_size= 0;		// Free key cache
2256 2257
  ha_resize_key_cache(src_cache);
  ha_change_key_cache(src_cache, dst_cache);
2258
  DBUG_RETURN(0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2259 2260 2261
}


igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2262 2263 2264 2265 2266
/*
  Preload specified indexes for a table into key cache

  SYNOPSIS
    mysql_preload_keys()
2267 2268
    thd		Thread object
    tables	Table list (one table only)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2269 2270

  RETURN VALUES
2271 2272
    0	  ok
   -1	  error
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2273 2274 2275 2276 2277 2278
*/

int mysql_preload_keys(THD* thd, TABLE_LIST* tables)
{
  DBUG_ENTER("mysql_preload_keys");
  DBUG_RETURN(mysql_admin_table(thd, tables, 0,
2279 2280
				"preload_keys", TL_READ, 0, 0, 0,
				&handler::preload_keys));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2281 2282 2283
}


venu@myvenu.com's avatar
venu@myvenu.com committed
2284 2285 2286 2287 2288
/*
  Create a table identical to the specified table

  SYNOPSIS
    mysql_create_like_table()
2289 2290
    thd		Thread object
    table	Table list (one table only)
venu@myvenu.com's avatar
venu@myvenu.com committed
2291 2292 2293 2294
    create_info Create info
    table_ident Src table_ident

  RETURN VALUES
2295 2296
    0	  ok
    -1	error
venu@myvenu.com's avatar
venu@myvenu.com committed
2297 2298
*/

2299 2300 2301
int mysql_create_like_table(THD* thd, TABLE_LIST* table,
			    HA_CREATE_INFO *create_info,
			    Table_ident *table_ident)
venu@myvenu.com's avatar
venu@myvenu.com committed
2302 2303 2304 2305 2306
{
  TABLE **tmp_table;
  char src_path[FN_REFLEN], dst_path[FN_REFLEN];
  char *db= table->db;
  char *table_name= table->real_name;
2307
  char *src_db;
venu@myvenu.com's avatar
venu@myvenu.com committed
2308
  char *src_table= table_ident->table.str;
2309 2310
  int  err, res= -1;
  TABLE_LIST src_tables_list;
venu@myvenu.com's avatar
venu@myvenu.com committed
2311
  DBUG_ENTER("mysql_create_like_table");
2312
  src_db= table_ident->db.str ? table_ident->db.str : thd->db;
venu@myvenu.com's avatar
venu@myvenu.com committed
2313 2314 2315 2316 2317 2318

  /*
    Validate the source table
  */
  if (table_ident->table.length > NAME_LEN ||
      (table_ident->table.length &&
2319
       check_table_name(src_table,table_ident->table.length)))
venu@myvenu.com's avatar
venu@myvenu.com committed
2320
  {
2321
    my_error(ER_WRONG_TABLE_NAME, MYF(0), src_table);
2322
    DBUG_RETURN(-1);
venu@myvenu.com's avatar
venu@myvenu.com committed
2323
  }
2324 2325 2326 2327 2328
  if (!src_db || check_db_name(src_db))
  {
    my_error(ER_WRONG_DB_NAME, MYF(0), src_db ? src_db : "NULL");
    DBUG_RETURN(-1);
  }
2329

2330 2331
  src_tables_list.db= src_db;
  src_tables_list.real_name= src_table;
2332
  src_tables_list.next= 0;
2333

2334 2335
  if (lock_and_wait_for_table_name(thd, &src_tables_list))
    goto err;
venu@myvenu.com's avatar
venu@myvenu.com committed
2336 2337 2338 2339 2340

  if ((tmp_table= find_temporary_table(thd, src_db, src_table)))
    strxmov(src_path, (*tmp_table)->path, reg_ext, NullS);
  else
  {
2341 2342 2343 2344
    strxmov(src_path, mysql_data_home, "/", src_db, "/", src_table,
	    reg_ext, NullS);
    /* Resolve symlinks (for windows) */
    fn_format(src_path, src_path, "", "", MYF(MY_UNPACK_FILENAME));
2345 2346
    if (lower_case_table_names)
      my_casedn_str(files_charset_info, src_path);
venu@myvenu.com's avatar
venu@myvenu.com committed
2347 2348 2349
    if (access(src_path, F_OK))
    {
      my_error(ER_BAD_TABLE_ERROR, MYF(0), src_table);
2350
      goto err;
venu@myvenu.com's avatar
venu@myvenu.com committed
2351 2352 2353 2354 2355 2356
    }
  }

  /*
    Validate the destination table

2357
    skip the destination table name checking as this is already
venu@myvenu.com's avatar
venu@myvenu.com committed
2358 2359 2360 2361 2362 2363
    validated.
  */
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
    if (find_temporary_table(thd, db, table_name))
      goto table_exists;
2364 2365 2366
    my_snprintf(dst_path, sizeof(dst_path), "%s%s%lx_%lx_%x%s",
		mysql_tmpdir, tmp_file_prefix, current_pid,
		thd->thread_id, thd->tmp_table++, reg_ext);
2367 2368
    if (lower_case_table_names)
      my_casedn_str(files_charset_info, dst_path);
venu@myvenu.com's avatar
venu@myvenu.com committed
2369 2370 2371 2372
    create_info->table_options|= HA_CREATE_DELAY_KEY_WRITE;
  }
  else
  {
2373 2374 2375
    strxmov(dst_path, mysql_data_home, "/", db, "/", table_name,
	    reg_ext, NullS);
    fn_format(dst_path, dst_path, "", "", MYF(MY_UNPACK_FILENAME));
venu@myvenu.com's avatar
venu@myvenu.com committed
2376 2377 2378 2379
    if (!access(dst_path, F_OK))
      goto table_exists;
  }

2380
  /*
venu@myvenu.com's avatar
venu@myvenu.com committed
2381
    Create a new table by copying from source table
2382
  */
2383 2384
  if (my_copy(src_path, dst_path, MYF(MY_WME|MY_DONT_OVERWRITE_FILE)))
    goto err;
venu@myvenu.com's avatar
venu@myvenu.com committed
2385 2386

  /*
2387 2388
    As mysql_truncate don't work on a new table at this stage of
    creation, instead create the table directly (for both normal
venu@myvenu.com's avatar
venu@myvenu.com committed
2389 2390
    and temporary tables).
  */
2391
  *fn_ext(dst_path)= 0;
venu@myvenu.com's avatar
venu@myvenu.com committed
2392
  err= ha_create_table(dst_path, create_info, 1);
2393

venu@myvenu.com's avatar
venu@myvenu.com committed
2394 2395 2396 2397
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
    if (err || !open_temporary_table(thd, dst_path, db, table_name, 1))
    {
2398 2399
      (void) rm_temporary_table(create_info->db_type,
				dst_path); /* purecov: inspected */
2400
      goto err;     /* purecov: inspected */
venu@myvenu.com's avatar
venu@myvenu.com committed
2401 2402 2403 2404
    }
  }
  else if (err)
  {
2405 2406 2407
    (void) quick_rm_table(create_info->db_type, db,
			  table_name); /* purecov: inspected */
    goto err;	    /* purecov: inspected */
venu@myvenu.com's avatar
venu@myvenu.com committed
2408
  }
2409 2410 2411 2412

  // Must be written before unlock
  mysql_update_log.write(thd,thd->query, thd->query_length);
  if (mysql_bin_log.is_open())
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
2413
  {
2414 2415
    thd->clear_error();
    Query_log_event qinfo(thd, thd->query, thd->query_length,
2416
			  test(create_info->options &
2417 2418
			       HA_LEX_CREATE_TMP_TABLE), 
			  FALSE);
2419
    mysql_bin_log.write(&qinfo);
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
2420
  }
2421
  res= 0;
2422
  goto err;
2423

venu@myvenu.com's avatar
venu@myvenu.com committed
2424 2425 2426 2427
table_exists:
  if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
  {
    char warn_buff[MYSQL_ERRMSG_SIZE];
2428 2429 2430 2431
    my_snprintf(warn_buff, sizeof(warn_buff),
		ER(ER_TABLE_EXISTS_ERROR), table_name);
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
		 ER_TABLE_EXISTS_ERROR,warn_buff);
2432
    res= 0;
venu@myvenu.com's avatar
venu@myvenu.com committed
2433
  }
2434 2435 2436 2437 2438 2439 2440 2441
  else
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);

err:
  pthread_mutex_lock(&LOCK_open);
  unlock_table_name(thd, &src_tables_list);
  pthread_mutex_unlock(&LOCK_open);
  DBUG_RETURN(res);
venu@myvenu.com's avatar
venu@myvenu.com committed
2442 2443 2444
}


2445 2446
int mysql_analyze_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2447 2448 2449 2450 2451 2452
#ifdef OS2
  thr_lock_type lock_type = TL_WRITE;
#else
  thr_lock_type lock_type = TL_READ_NO_INSERT;
#endif

2453 2454
  DBUG_ENTER("mysql_analyze_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
2455 2456
				"analyze", lock_type, 1,0,0,
				&handler::analyze));
2457 2458 2459 2460 2461
}


int mysql_check_table(THD* thd, TABLE_LIST* tables,HA_CHECK_OPT* check_opt)
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2462 2463 2464 2465 2466 2467
#ifdef OS2
  thr_lock_type lock_type = TL_WRITE;
#else
  thr_lock_type lock_type = TL_READ_NO_INSERT;
#endif

2468 2469
  DBUG_ENTER("mysql_check_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
2470 2471 2472
				"check", lock_type,
				0, HA_OPEN_FOR_REPAIR, 0,
				&handler::check));
2473 2474
}

monty@mysql.com's avatar
monty@mysql.com committed
2475

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2476
/* table_list should contain just one table */
monty@mysql.com's avatar
monty@mysql.com committed
2477 2478 2479 2480
static int
mysql_discard_or_import_tablespace(THD *thd,
                                   TABLE_LIST *table_list,
                                   enum tablespace_op_type tablespace_op)
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2481 2482 2483 2484 2485 2486
{
  TABLE *table;
  my_bool discard;
  int error;
  DBUG_ENTER("mysql_discard_or_import_tablespace");

monty@mysql.com's avatar
monty@mysql.com committed
2487 2488 2489 2490
  /*
    Note that DISCARD/IMPORT TABLESPACE always is the only operation in an
    ALTER TABLE
  */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2491 2492 2493

  thd->proc_info="discard_or_import_tablespace";

monty@mysql.com's avatar
monty@mysql.com committed
2494
  discard= test(tablespace_op == DISCARD_TABLESPACE);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2495

monty@mysql.com's avatar
monty@mysql.com committed
2496 2497 2498 2499 2500
 /*
   We set this flag so that ha_innobase::open and ::external_lock() do
   not complain when we lock the table
 */
  thd->tablespace_op= TRUE;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2501 2502 2503 2504 2505
  if (!(table=open_ltable(thd,table_list,TL_WRITE)))
  {
    thd->tablespace_op=FALSE;
    DBUG_RETURN(-1);
  }
2506

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2507 2508 2509 2510 2511 2512 2513
  error=table->file->discard_or_import_tablespace(discard);

  thd->proc_info="end";

  if (error)
    goto err;

monty@mysql.com's avatar
monty@mysql.com committed
2514 2515 2516 2517
  /*
    The 0 in the call below means 'not in a transaction', which means
    immediate invalidation; that is probably what we wish here
  */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528
  query_cache_invalidate3(thd, table_list, 0);

  /* The ALTER TABLE is always in its own transaction */
  error = ha_commit_stmt(thd);
  if (ha_commit(thd))
    error=1;
  if (error)
    goto err;
  mysql_update_log.write(thd, thd->query,thd->query_length);
  if (mysql_bin_log.is_open())
  {
2529
    Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2530 2531 2532 2533
    mysql_bin_log.write(&qinfo);
  }
err:
  close_thread_tables(thd);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2534
  thd->tablespace_op=FALSE;
monty@mysql.com's avatar
monty@mysql.com committed
2535 2536
  if (error == 0)
  {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2537
    send_ok(thd);
monty@mysql.com's avatar
monty@mysql.com committed
2538
    DBUG_RETURN(0);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2539
  }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2540 2541 2542 2543 2544

  if (error == HA_ERR_ROW_IS_REFERENCED)
    my_error(ER_ROW_IS_REFERENCED, MYF(0));
  
  DBUG_RETURN(-1);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2545
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2546

2547 2548

#ifdef NOT_USED
2549 2550 2551 2552 2553 2554 2555
/*
  CREATE INDEX and DROP INDEX are implemented by calling ALTER TABLE with
  the proper arguments.  This isn't very fast but it should work for most
  cases.
  One should normally create all indexes with CREATE TABLE or ALTER TABLE.
*/

2556
int mysql_create_indexes(THD *thd, TABLE_LIST *table_list, List<Key> &keys)
2557 2558 2559 2560 2561
{
  List<create_field> fields;
  List<Alter_drop>   drop;
  List<Alter_column> alter;
  HA_CREATE_INFO     create_info;
2562 2563 2564 2565 2566 2567 2568 2569
  int		     rc;
  uint		     idx;
  uint		     db_options;
  uint		     key_count;
  TABLE		     *table;
  Field		     **f_ptr;
  KEY		     *key_info_buffer;
  char		     path[FN_REFLEN+1];
2570 2571 2572
  DBUG_ENTER("mysql_create_index");

  /*
2573 2574 2575
    Try to use online generation of index.
    This requires that all indexes can be created online.
    Otherwise, the old alter table procedure is executed.
2576

2577 2578
    Open the table to have access to the correct table handler.
  */
2579 2580 2581 2582
  if (!(table=open_ltable(thd,table_list,TL_WRITE_ALLOW_READ)))
    DBUG_RETURN(-1);

  /*
2583 2584 2585 2586 2587
    The add_index method takes an array of KEY structs for the new indexes.
    Preparing a new table structure generates this array.
    It needs a list with all fields of the table, which does not need to
    be correct in every respect. The field names are important.
  */
2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598
  for (f_ptr= table->field; *f_ptr; f_ptr++)
  {
    create_field *c_fld= new create_field(*f_ptr, *f_ptr);
    c_fld->unireg_check= Field::NONE; /*avoid multiple auto_increments*/
    fields.push_back(c_fld);
  }
  bzero((char*) &create_info,sizeof(create_info));
  create_info.db_type=DB_TYPE_DEFAULT;
  create_info.default_table_charset= thd->variables.collation_database;
  db_options= 0;
  if (mysql_prepare_table(thd, &create_info, fields,
2599 2600 2601
			  keys, /*tmp_table*/ 0, db_options, table->file,
			  key_info_buffer, key_count,
			  /*select_field_count*/ 0))
2602 2603 2604
    DBUG_RETURN(-1);

  /*
2605 2606 2607
    Check if all keys can be generated with the add_index method.
    If anyone cannot, then take the old way.
  */
2608 2609 2610 2611
  for (idx=0; idx< key_count; idx++)
  {
    DBUG_PRINT("info", ("creating index %s", key_info_buffer[idx].name));
    if (!(table->file->index_ddl_flags(key_info_buffer+idx)&
2612
	  (HA_DDL_ONLINE| HA_DDL_WITH_LOCK)))
2613 2614
      break ;
  }
2615
  if ((idx < key_count)|| !key_count)
2616 2617 2618 2619 2620 2621 2622 2623
  {
    /* Re-initialize the create_info, which was changed by prepare table. */
    bzero((char*) &create_info,sizeof(create_info));
    create_info.db_type=DB_TYPE_DEFAULT;
    create_info.default_table_charset= thd->variables.collation_database;
    /* Cleanup the fields list. We do not want to create existing fields. */
    fields.delete_elements();
    if (real_alter_table(thd, table_list->db, table_list->real_name,
2624 2625 2626 2627
			 &create_info, table_list, table,
			 fields, keys, drop, alter, 0, (ORDER*)0,
			 ALTER_ADD_INDEX, DUP_ERROR))
      /* Don't need to free((gptr) key_info_buffer);*/
2628 2629 2630 2631 2632
      DBUG_RETURN(-1);
  }
  else
  {
    if (table->file->add_index(table, key_info_buffer, key_count)||
2633 2634
        build_table_path(path, sizeof(path), table_list->db,
                         (lower_case_table_names == 2) ?
2635
                         table_list->alias : table_list->real_name,
2636
                         reg_ext) == 0 ||
2637 2638 2639
	mysql_create_frm(thd, path, &create_info,
			 fields, key_count, key_info_buffer, table->file))
      /* don't need to free((gptr) key_info_buffer);*/
2640 2641
      DBUG_RETURN(-1);
  }
2642
  /* don't need to free((gptr) key_info_buffer);*/
2643 2644 2645 2646
  DBUG_RETURN(0);
}


2647 2648
int mysql_drop_indexes(THD *thd, TABLE_LIST *table_list,
		       List<Alter_drop> &drop)
2649 2650
{
  List<create_field> fields;
2651
  List<Key>	     keys;
2652 2653
  List<Alter_column> alter;
  HA_CREATE_INFO     create_info;
2654 2655 2656 2657 2658 2659 2660 2661 2662
  uint		     idx;
  uint		     db_options;
  uint		     key_count;
  uint		     *key_numbers;
  TABLE		     *table;
  Field		     **f_ptr;
  KEY		     *key_info;
  KEY		     *key_info_buffer;
  char		     path[FN_REFLEN];
2663 2664 2665
  DBUG_ENTER("mysql_drop_index");

  /*
2666 2667 2668
    Try to use online generation of index.
    This requires that all indexes can be created online.
    Otherwise, the old alter table procedure is executed.
2669

2670 2671
    Open the table to have access to the correct table handler.
  */
2672 2673 2674 2675
  if (!(table=open_ltable(thd,table_list,TL_WRITE_ALLOW_READ)))
    DBUG_RETURN(-1);

  /*
2676 2677 2678
    The drop_index method takes an array of key numbers.
    It cannot get more entries than keys in the table.
  */
2679 2680 2681 2682
  key_numbers= (uint*) thd->alloc(sizeof(uint*)*table->keys);
  key_count= 0;

  /*
2683 2684
    Get the number of each key and check if it can be created online.
  */
2685 2686 2687 2688 2689 2690 2691 2692 2693
  List_iterator<Alter_drop> drop_it(drop);
  Alter_drop *drop_key;
  while ((drop_key= drop_it++))
  {
    /* Find the key in the table. */
    key_info=table->key_info;
    for (idx=0; idx< table->keys; idx++, key_info++)
    {
      if (!my_strcasecmp(system_charset_info, key_info->name, drop_key->name))
2694
	break;
2695 2696 2697 2698 2699 2700 2701 2702
    }
    if (idx>= table->keys)
    {
      my_error(ER_CANT_DROP_FIELD_OR_KEY, MYF(0), drop_key->name);
      /*don't need to free((gptr) key_numbers);*/
      DBUG_RETURN(-1);
    }
    /*
2703 2704 2705
      Check if the key can be generated with the add_index method.
      If anyone cannot, then take the old way.
    */
2706 2707
    DBUG_PRINT("info", ("dropping index %s", table->key_info[idx].name));
    if (!(table->file->index_ddl_flags(table->key_info+idx)&
2708
	  (HA_DDL_ONLINE| HA_DDL_WITH_LOCK)))
2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719
      break ;
    key_numbers[key_count++]= idx;
  }

  bzero((char*) &create_info,sizeof(create_info));
  create_info.db_type=DB_TYPE_DEFAULT;
  create_info.default_table_charset= thd->variables.collation_database;

  if ((drop_key)|| (drop.elements<= 0))
  {
    if (real_alter_table(thd, table_list->db, table_list->real_name,
2720 2721 2722
			 &create_info, table_list, table,
			 fields, keys, drop, alter, 0, (ORDER*)0,
			 ALTER_DROP_INDEX, DUP_ERROR))
2723 2724 2725 2726 2727 2728 2729
      /*don't need to free((gptr) key_numbers);*/
      DBUG_RETURN(-1);
  }
  else
  {
    db_options= 0;
    if (table->file->drop_index(table, key_numbers, key_count)||
2730 2731 2732 2733
	mysql_prepare_table(thd, &create_info, fields,
			    keys, /*tmp_table*/ 0, db_options, table->file,
			    key_info_buffer, key_count,
			    /*select_field_count*/ 0)||
2734 2735
        build_table_path(path, sizeof(path), table_list->db,
                         (lower_case_table_names == 2) ?
2736
                         table_list->alias : table_list->real_name,
2737
                         reg_ext) == 0 ||
2738 2739
	mysql_create_frm(thd, path, &create_info,
			 fields, key_count, key_info_buffer, table->file))
2740 2741 2742 2743 2744 2745 2746
      /*don't need to free((gptr) key_numbers);*/
      DBUG_RETURN(-1);
  }

  /*don't need to free((gptr) key_numbers);*/
  DBUG_RETURN(0);
}
2747
#endif /* NOT_USED */
2748 2749


2750 2751 2752
/*
  Alter table
*/
2753

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2754
int mysql_alter_table(THD *thd,char *new_db, char *new_name,
2755 2756
		      HA_CREATE_INFO *create_info,
		      TABLE_LIST *table_list,
2757 2758
		      List<create_field> &fields, List<Key> &keys,
		      uint order_num, ORDER *order,
2759
		      enum enum_duplicates handle_duplicates, bool ignore,
2760
		      ALTER_INFO *alter_info, bool do_send_ok)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2761
{
2762
  TABLE *table,*new_table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2763
  int error;
2764 2765
  char tmp_name[80],old_name[32],new_name_buff[FN_REFLEN];
  char new_alias_buff[FN_REFLEN], *table_name, *db, *new_alias, *alias;
2766
  char index_file[FN_REFLEN], data_file[FN_REFLEN];
2767 2768
  ha_rows copied,deleted;
  ulonglong next_insert_id;
2769
  uint db_create_options, used_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2770
  enum db_type old_db_type,new_db_type;
2771
  DBUG_ENTER("mysql_alter_table");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2772 2773 2774

  thd->proc_info="init";
  table_name=table_list->real_name;
2775 2776
  alias= (lower_case_table_names == 2) ? table_list->alias : table_name;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2777
  db=table_list->db;
monty@mysql.com's avatar
monty@mysql.com committed
2778
  if (!new_db || !my_strcasecmp(table_alias_charset, new_db, db))
2779
    new_db= db;
2780
  used_fields=create_info->used_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2781

2782
  mysql_ha_flush(thd, table_list, MYSQL_HA_CLOSE_FINAL);
2783
  /* DISCARD/IMPORT TABLESPACE is always alone in an ALTER TABLE */
2784
  if (alter_info->tablespace_op != NO_TABLESPACE_OP)
2785
    DBUG_RETURN(mysql_discard_or_import_tablespace(thd,table_list,
2786
						   alter_info->tablespace_op));
2787 2788 2789
  if (!(table=open_ltable(thd,table_list,TL_WRITE_ALLOW_READ)))
    DBUG_RETURN(-1);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2790 2791 2792 2793
  /* Check that we are not trying to rename to an existing table */
  if (new_name)
  {
    strmov(new_name_buff,new_name);
2794
    strmov(new_alias= new_alias_buff, new_name);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2795
    if (lower_case_table_names)
2796 2797 2798
    {
      if (lower_case_table_names != 2)
      {
2799
	my_casedn_str(files_charset_info, new_name_buff);
2800
	new_alias= new_name;			// Create lower case table name
2801
      }
2802
      my_casedn_str(files_charset_info, new_name);
2803
    }
2804
    if (new_db == db &&
2805
	!my_strcasecmp(table_alias_charset, new_name_buff, table_name))
2806 2807
    {
      /*
2808 2809
	Source and destination table names are equal: make later check
	easier.
2810
      */
2811
      new_alias= new_name= table_name;
2812
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2813 2814 2815 2816
    else
    {
      if (table->tmp_table)
      {
2817 2818 2819 2820 2821
	if (find_temporary_table(thd,new_db,new_name_buff))
	{
	  my_error(ER_TABLE_EXISTS_ERROR,MYF(0),new_name_buff);
	  DBUG_RETURN(-1);
	}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2822 2823 2824
      }
      else
      {
2825 2826 2827
	char dir_buff[FN_REFLEN];
	strxnmov(dir_buff, FN_REFLEN, mysql_real_data_home, new_db, NullS);
	if (!access(fn_format(new_name_buff,new_name_buff,dir_buff,reg_ext,0),
2828 2829 2830 2831 2832 2833
		    F_OK))
	{
	  /* Table will be closed in do_command() */
	  my_error(ER_TABLE_EXISTS_ERROR,MYF(0), new_alias);
	  DBUG_RETURN(-1);
	}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2834 2835 2836 2837
      }
    }
  }
  else
2838 2839 2840 2841
  {
    new_alias= (lower_case_table_names == 2) ? alias : table_name;
    new_name= table_name;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2842 2843 2844 2845

  old_db_type=table->db_type;
  if (create_info->db_type == DB_TYPE_DEFAULT)
    create_info->db_type=old_db_type;
2846 2847 2848 2849 2850
  if ((new_db_type= ha_checktype(create_info->db_type)) !=
      create_info->db_type)
  {
    create_info->db_type= new_db_type;
    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
2851 2852 2853 2854
			ER_WARN_USING_OTHER_HANDLER,
			ER(ER_WARN_USING_OTHER_HANDLER),
			ha_get_storage_engine(new_db_type),
			new_name);
2855
  }
2856
  if (create_info->row_type == ROW_TYPE_NOT_USED)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2857 2858 2859
    create_info->row_type=table->row_type;

  thd->proc_info="setup";
2860
  if (alter_info->is_simple && !table->tmp_table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2861 2862
  {
    error=0;
2863
    if (new_name != table_name || new_db != db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2864
    {
2865 2866 2867 2868 2869 2870
      thd->proc_info="rename";
      VOID(pthread_mutex_lock(&LOCK_open));
      /* Then do a 'simple' rename of the table */
      error=0;
      if (!access(new_name_buff,F_OK))
      {
2871 2872
	my_error(ER_TABLE_EXISTS_ERROR,MYF(0),new_name);
	error= -1;
2873 2874 2875
      }
      else
      {
2876 2877 2878 2879
	*fn_ext(new_name)=0;
	close_cached_table(thd, table);
	if (mysql_rename_table(old_db_type,db,table_name,new_db,new_alias))
	  error= -1;
2880 2881
      }
      VOID(pthread_mutex_unlock(&LOCK_open));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2882
    }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2883

2884
    if (!error)
2885
    {
2886
      switch (alter_info->keys_onoff) {
2887
      case LEAVE_AS_IS:
2888
	break;
2889
      case ENABLE:
2890
	VOID(pthread_mutex_lock(&LOCK_open));
2891
	wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
2892
	VOID(pthread_mutex_unlock(&LOCK_open));
2893
	error= table->file->enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
2894
	/* COND_refresh will be signaled in close_thread_tables() */
2895 2896
	break;
      case DISABLE:
2897 2898 2899
	VOID(pthread_mutex_lock(&LOCK_open));
	wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
	VOID(pthread_mutex_unlock(&LOCK_open));
2900
	error=table->file->disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
2901
	/* COND_refresh will be signaled in close_thread_tables() */
2902
	break;
2903
      }
2904
    }
2905
    if (error == HA_ERR_WRONG_COMMAND)
serg@serg.mylan's avatar
serg@serg.mylan committed
2906 2907
    {
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
2908 2909
			  ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
			  table->table_name);
serg@serg.mylan's avatar
serg@serg.mylan committed
2910 2911
      error=0;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2912 2913
    if (!error)
    {
2914 2915 2916
      mysql_update_log.write(thd, thd->query, thd->query_length);
      if (mysql_bin_log.is_open())
      {
2917
	thd->clear_error();
2918
	Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
2919
	mysql_bin_log.write(&qinfo);
2920
      }
2921 2922
      if (do_send_ok)
        send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2923
    }
2924
    else if (error > 0)
2925 2926
    {
      table->file->print_error(error, MYF(0));
2927
      error= -1;
2928
    }
2929
    table_list->table=0;				// For query cache
2930
    query_cache_invalidate3(thd, table_list, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2931 2932 2933 2934
    DBUG_RETURN(error);
  }

  /* Full alter table */
2935 2936 2937 2938 2939 2940 2941 2942

  /* let new create options override the old ones */
  if (!(used_fields & HA_CREATE_USED_MIN_ROWS))
    create_info->min_rows=table->min_rows;
  if (!(used_fields & HA_CREATE_USED_MAX_ROWS))
    create_info->max_rows=table->max_rows;
  if (!(used_fields & HA_CREATE_USED_AVG_ROW_LENGTH))
    create_info->avg_row_length=table->avg_row_length;
2943 2944
  if (!(used_fields & HA_CREATE_USED_DEFAULT_CHARSET))
    create_info->default_table_charset= table->table_charset;
2945

2946
  restore_record(table,default_values);		// Empty record for DEFAULT
2947
  List_iterator<Alter_drop> drop_it(alter_info->drop_list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2948
  List_iterator<create_field> def_it(fields);
2949
  List_iterator<Alter_column> alter_it(alter_info->alter_list);
2950 2951
  List<create_field> create_list;		// Add new fields here
  List<Key> key_list;				// Add new keys here
2952 2953
  create_field *def;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2954
  /*
2955
    First collect all fields from table which isn't in drop_list
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966
  */

  Field **f_ptr,*field;
  for (f_ptr=table->field ; (field= *f_ptr) ; f_ptr++)
  {
    /* Check if field should be droped */
    Alter_drop *drop;
    drop_it.rewind();
    while ((drop=drop_it++))
    {
      if (drop->type == Alter_drop::COLUMN &&
2967
	  !my_strcasecmp(system_charset_info,field->field_name, drop->name))
2968
      {
2969 2970 2971 2972 2973 2974 2975 2976
	/* Reset auto_increment value if it was dropped */
	if (MTYP_TYPENR(field->unireg_check) == Field::NEXT_NUMBER &&
	    !(used_fields & HA_CREATE_USED_AUTO))
	{
	  create_info->auto_increment_value=0;
	  create_info->used_fields|=HA_CREATE_USED_AUTO;
	}
	break;
2977
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2978 2979 2980 2981 2982 2983 2984 2985 2986 2987
    }
    if (drop)
    {
      drop_it.remove();
      continue;
    }
    /* Check if field is changed */
    def_it.rewind();
    while ((def=def_it++))
    {
2988
      if (def->change &&
2989 2990
	  !my_strcasecmp(system_charset_info,field->field_name, def->change))
	break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2991 2992
    }
    if (def)
2993
    {						// Field is changed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2994
      def->field=field;
2995 2996
      if (!def->after)
      {
2997 2998
	create_list.push_back(def);
	def_it.remove();
2999
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3000 3001
    }
    else
3002
    {						// Use old field value
3003
      create_list.push_back(def=new create_field(field,field));
3004
      alter_it.rewind();			// Change default if ALTER
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3005 3006 3007
      Alter_column *alter;
      while ((alter=alter_it++))
      {
3008 3009
	if (!my_strcasecmp(system_charset_info,field->field_name, alter->name))
	  break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3010 3011 3012
      }
      if (alter)
      {
3013 3014 3015 3016 3017 3018 3019
	if (def->sql_type == FIELD_TYPE_BLOB)
	{
	  my_error(ER_BLOB_CANT_HAVE_DEFAULT,MYF(0),def->change);
	  DBUG_RETURN(-1);
	}
	def->def=alter->def;			// Use new default
	alter_it.remove();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3020 3021 3022 3023 3024
      }
    }
  }
  def_it.rewind();
  List_iterator<create_field> find_it(create_list);
3025
  while ((def=def_it++))			// Add new columns
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3026
  {
3027
    if (def->change && ! def->field)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039
    {
      my_error(ER_BAD_FIELD_ERROR,MYF(0),def->change,table_name);
      DBUG_RETURN(-1);
    }
    if (!def->after)
      create_list.push_back(def);
    else if (def->after == first_keyword)
      create_list.push_front(def);
    else
    {
      create_field *find;
      find_it.rewind();
3040
      while ((find=find_it++))			// Add new columns
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3041
      {
3042 3043
	if (!my_strcasecmp(system_charset_info,def->after, find->field_name))
	  break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3044 3045 3046
      }
      if (!find)
      {
3047 3048
	my_error(ER_BAD_FIELD_ERROR,MYF(0),def->after,table_name);
	DBUG_RETURN(-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3049
      }
3050
      find_it.after(def);			// Put element after this
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3051 3052
    }
  }
3053
  if (alter_info->alter_list.elements)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3054
  {
3055 3056
    my_error(ER_BAD_FIELD_ERROR,MYF(0),alter_info->alter_list.head()->name,
	     table_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3057 3058 3059 3060 3061 3062 3063 3064 3065
    DBUG_RETURN(-1);
  }
  if (!create_list.elements)
  {
    my_error(ER_CANT_REMOVE_ALL_FIELDS,MYF(0));
    DBUG_RETURN(-1);
  }

  /*
3066 3067
    Collect all keys which isn't in drop list. Add only those
    for which some fields exists.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3068 3069 3070 3071 3072 3073 3074 3075 3076
  */

  List_iterator<Key> key_it(keys);
  List_iterator<create_field> field_it(create_list);
  List<key_part_spec> key_parts;

  KEY *key_info=table->key_info;
  for (uint i=0 ; i < table->keys ; i++,key_info++)
  {
3077
    char *key_name= key_info->name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3078 3079 3080 3081 3082
    Alter_drop *drop;
    drop_it.rewind();
    while ((drop=drop_it++))
    {
      if (drop->type == Alter_drop::KEY &&
3083 3084
	  !my_strcasecmp(system_charset_info,key_name, drop->name))
	break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096
    }
    if (drop)
    {
      drop_it.remove();
      continue;
    }

    KEY_PART_INFO *key_part= key_info->key_part;
    key_parts.empty();
    for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
    {
      if (!key_part->field)
3097
	continue;				// Wrong field (from UNIREG)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3098 3099 3100 3101 3102
      const char *key_part_name=key_part->field->field_name;
      create_field *cfield;
      field_it.rewind();
      while ((cfield=field_it++))
      {
3103 3104 3105 3106 3107 3108 3109 3110 3111
	if (cfield->change)
	{
	  if (!my_strcasecmp(system_charset_info, key_part_name,
			     cfield->change))
	    break;
	}
	else if (!my_strcasecmp(system_charset_info,
				key_part_name, cfield->field_name))
	  break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3112 3113
      }
      if (!cfield)
3114
	continue;				// Field is removed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3115
      uint key_part_length=key_part->length;
3116 3117 3118 3119 3120 3121 3122
      if (cfield->field)			// Not new field
      {						// Check if sub key
	if (cfield->field->type() != FIELD_TYPE_BLOB &&
	    (cfield->field->pack_length() == key_part_length ||
	     cfield->length <= key_part_length /
			       key_part->field->charset()->mbmaxlen))
	  key_part_length=0;			// Use whole field
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3123
      }
3124
      key_part_length /= key_part->field->charset()->mbmaxlen;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3125
      key_parts.push_back(new key_part_spec(cfield->field_name,
3126
					    key_part_length));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3127 3128
    }
    if (key_parts.elements)
3129
      key_list.push_back(new Key(key_info->flags & HA_SPATIAL ? Key::SPATIAL :
3130 3131 3132 3133 3134 3135 3136 3137
				 (key_info->flags & HA_NOSAME ?
				 (!my_strcasecmp(system_charset_info,
						 key_name, primary_key_name) ?
				  Key::PRIMARY	: Key::UNIQUE) :
				  (key_info->flags & HA_FULLTEXT ?
				   Key::FULLTEXT : Key::MULTIPLE)),
				 key_name,
				 key_info->algorithm,
3138
                                 test(key_info->flags & HA_GENERATED_KEY),
3139
				 key_parts));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3140 3141 3142
  }
  {
    Key *key;
3143
    while ((key=key_it++))			// Add new keys
3144 3145
    {
      if (key->type != Key::FOREIGN_KEY)
3146
	key_list.push_back(key);
3147
      if (key->name &&
3148
	  !my_strcasecmp(system_charset_info,key->name,primary_key_name))
3149
      {
3150 3151
	my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name);
	DBUG_RETURN(-1);
3152
      }
3153
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3154 3155
  }

3156
  if (alter_info->drop_list.elements)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3157
  {
3158 3159
    my_error(ER_CANT_DROP_FIELD_OR_KEY,MYF(0),
	     alter_info->drop_list.head()->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3160 3161
    goto err;
  }
3162
  if (alter_info->alter_list.elements)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3163
  {
3164 3165
    my_error(ER_CANT_DROP_FIELD_OR_KEY,MYF(0),
	     alter_info->alter_list.head()->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3166 3167 3168
    goto err;
  }

3169
  db_create_options=table->db_create_options & ~(HA_OPTION_PACK_RECORD);
3170 3171
  my_snprintf(tmp_name, sizeof(tmp_name), "%s-%lx_%lx", tmp_file_prefix,
	      current_pid, thd->thread_id);
3172 3173
  /* Safety fix for innodb */
  if (lower_case_table_names)
3174
    my_casedn_str(files_charset_info, tmp_name);
3175 3176 3177 3178
  if (new_db_type != old_db_type && !table->file->can_switch_engines()) {
    my_error(ER_ROW_IS_REFERENCED, MYF(0));
    goto err;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3179 3180 3181
  create_info->db_type=new_db_type;
  if (!create_info->comment)
    create_info->comment=table->comment;
3182 3183 3184 3185 3186

  table->file->update_create_info(create_info);
  if ((create_info->table_options &
       (HA_OPTION_PACK_KEYS | HA_OPTION_NO_PACK_KEYS)) ||
      (used_fields & HA_CREATE_USED_PACK_KEYS))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3187 3188 3189 3190 3191 3192 3193
    db_create_options&= ~(HA_OPTION_PACK_KEYS | HA_OPTION_NO_PACK_KEYS);
  if (create_info->table_options &
      (HA_OPTION_CHECKSUM | HA_OPTION_NO_CHECKSUM))
    db_create_options&= ~(HA_OPTION_CHECKSUM | HA_OPTION_NO_CHECKSUM);
  if (create_info->table_options &
      (HA_OPTION_DELAY_KEY_WRITE | HA_OPTION_NO_DELAY_KEY_WRITE))
    db_create_options&= ~(HA_OPTION_DELAY_KEY_WRITE |
3194
			  HA_OPTION_NO_DELAY_KEY_WRITE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3195 3196 3197 3198 3199
  create_info->table_options|= db_create_options;

  if (table->tmp_table)
    create_info->options|=HA_LEX_CREATE_TMP_TABLE;

3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224
  /*
    Handling of symlinked tables:
    If no rename:
      Create new data file and index file on the same disk as the
      old data and index files.
      Copy data.
      Rename new data file over old data file and new index file over
      old index file.
      Symlinks are not changed.

   If rename:
      Create new data file and index file on the same disk as the
      old data and index files.  Create also symlinks to point at
      the new tables.
      Copy data.
      At end, rename temporary tables and symlinks to temporary table
      to final table name.
      Remove old table and old symlinks

    If rename is made to another database:
      Create new tables in new database.
      Copy data.
      Remove old table and symlinks.
  */

3225
  if (!strcmp(db, new_db))		// Ignore symlink if db changed
3226 3227 3228 3229 3230 3231
  {
    if (create_info->index_file_name)
    {
      /* Fix index_file_name to have 'tmp_name' as basename */
      strmov(index_file, tmp_name);
      create_info->index_file_name=fn_same(index_file,
3232 3233
					   create_info->index_file_name,
					   1);
3234 3235 3236 3237 3238 3239
    }
    if (create_info->data_file_name)
    {
      /* Fix data_file_name to have 'tmp_name' as basename */
      strmov(data_file, tmp_name);
      create_info->data_file_name=fn_same(data_file,
3240 3241
					  create_info->data_file_name,
					  1);
3242 3243
    }
  }
3244 3245
  else
    create_info->data_file_name=create_info->index_file_name=0;
3246
  {
3247 3248
    /* We don't log the statement, it will be logged later. */
    tmp_disable_binlog(thd);
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3249
    error= mysql_create_table(thd, new_db, tmp_name,
serg@serg.mylan's avatar
serg@serg.mylan committed
3250
                              create_info,create_list,key_list,1,0);
3251 3252
    reenable_binlog(thd);
    if (error)
3253 3254
      DBUG_RETURN(error);
  }
3255 3256 3257
  if (table->tmp_table)
    new_table=open_table(thd,new_db,tmp_name,tmp_name,0);
  else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3258
  {
3259
    char path[FN_REFLEN];
3260
    build_table_path(path, sizeof(path), new_db, tmp_name, "");
3261 3262 3263 3264 3265 3266
    new_table=open_temporary_table(thd, path, new_db, tmp_name,0);
  }
  if (!new_table)
  {
    VOID(quick_rm_table(new_db_type,new_db,tmp_name));
    goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3267 3268
  }

3269

3270 3271
  /* We don't want update TIMESTAMP fields during ALTER TABLE. */
  new_table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3272
  new_table->next_number_field=new_table->found_next_number_field;
3273
  thd->count_cuted_fields= CHECK_FIELD_WARN;	// calc cuted fields
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3274 3275
  thd->cuted_fields=0L;
  thd->proc_info="copy to tmp table";
3276
  next_insert_id=thd->next_insert_id;		// Remember for loggin
3277 3278 3279
  copied=deleted=0;
  if (!new_table->is_view)
    error=copy_data_between_tables(table,new_table,create_list,
3280
				   handle_duplicates, ignore,
3281 3282
				   order_num, order, &copied, &deleted);
  thd->last_insert_id=next_insert_id;		// Needed for correct log
3283
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3284 3285 3286 3287 3288 3289

  if (table->tmp_table)
  {
    /* We changed a temporary table */
    if (error)
    {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3290
      /*
3291 3292
	The following function call will free the new_table pointer,
	in close_temporary_table(), so we can safely directly jump to err
3293
      */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3294 3295 3296
      close_temporary_table(thd,new_db,tmp_name);
      goto err;
    }
3297 3298 3299 3300 3301 3302
    /* Close lock if this is a transactional table */
    if (thd->lock)
    {
      mysql_unlock_tables(thd, thd->lock);
      thd->lock=0;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3303 3304
    /* Remove link to old table and rename the new one */
    close_temporary_table(thd,table->table_cache_key,table_name);
3305 3306
    /* Should pass the 'new_name' as we store table name in the cache */
    if (rename_temporary_table(thd, new_table, new_db, new_name))
3307
    {						// Fatal error
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3308 3309 3310 3311
      close_temporary_table(thd,new_db,tmp_name);
      my_free((gptr) new_table,MYF(0));
      goto err;
    }
3312 3313 3314
    mysql_update_log.write(thd, thd->query,thd->query_length);
    if (mysql_bin_log.is_open())
    {
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3315
      thd->clear_error();
3316
      Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3317 3318
      mysql_bin_log.write(&qinfo);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3319 3320 3321
    goto end_temporary;
  }

3322
  intern_close_table(new_table);		/* close temporary table */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3323 3324 3325 3326 3327 3328 3329 3330
  my_free((gptr) new_table,MYF(0));
  VOID(pthread_mutex_lock(&LOCK_open));
  if (error)
  {
    VOID(quick_rm_table(new_db_type,new_db,tmp_name));
    VOID(pthread_mutex_unlock(&LOCK_open));
    goto err;
  }
3331

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3332
  /*
3333 3334 3335
    Data is copied.  Now we rename the old table to a temp name,
    rename the new one to the old name, remove all entries from the old table
    from the cash, free all locks, close the old table and remove it.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3336 3337 3338
  */

  thd->proc_info="rename result table";
3339 3340
  my_snprintf(old_name, sizeof(old_name), "%s2-%lx-%lx", tmp_file_prefix,
	      current_pid, thd->thread_id);
3341 3342
  if (lower_case_table_names)
    my_casedn_str(files_charset_info, old_name);
3343
  if (new_name != table_name || new_db != db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354
  {
    if (!access(new_name_buff,F_OK))
    {
      error=1;
      my_error(ER_TABLE_EXISTS_ERROR,MYF(0),new_name_buff);
      VOID(quick_rm_table(new_db_type,new_db,tmp_name));
      VOID(pthread_mutex_unlock(&LOCK_open));
      goto err;
    }
  }

3355 3356 3357 3358 3359
#if (!defined( __WIN__) && !defined( __EMX__) && !defined( OS2))
  if (table->file->has_transactions())
#endif
  {
    /*
3360
      Win32 and InnoDB can't drop a table that is in use, so we must
3361
      close the original table at before doing the rename
3362
    */
3363
    table_name=thd->strdup(table_name);		// must be saved
3364
    if (close_cached_table(thd, table))
3365
    {						// Aborted
3366 3367 3368 3369
      VOID(quick_rm_table(new_db_type,new_db,tmp_name));
      VOID(pthread_mutex_unlock(&LOCK_open));
      goto err;
    }
3370
    table=0;					// Marker that table is closed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3371
  }
3372 3373
#if (!defined( __WIN__) && !defined( __EMX__) && !defined( OS2))
  else
3374
    table->file->extra(HA_EXTRA_FORCE_REOPEN);	// Don't use this file anymore
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3375 3376
#endif

3377

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3378 3379 3380 3381 3382 3383 3384
  error=0;
  if (mysql_rename_table(old_db_type,db,table_name,db,old_name))
  {
    error=1;
    VOID(quick_rm_table(new_db_type,new_db,tmp_name));
  }
  else if (mysql_rename_table(new_db_type,new_db,tmp_name,new_db,
3385 3386
			      new_alias))
  {						// Try to get everything back
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3387
    error=1;
3388
    VOID(quick_rm_table(new_db_type,new_db,new_alias));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3389
    VOID(quick_rm_table(new_db_type,new_db,tmp_name));
3390
    VOID(mysql_rename_table(old_db_type,db,old_name,db,alias));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3391 3392 3393
  }
  if (error)
  {
3394 3395 3396 3397
    /*
      This shouldn't happen.  We solve this the safe way by
      closing the locked table.
    */
3398 3399
    if (table)
      close_cached_table(thd,table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3400 3401 3402
    VOID(pthread_mutex_unlock(&LOCK_open));
    goto err;
  }
3403
  if (thd->lock || new_name != table_name)	// True if WIN32
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3404
  {
3405 3406 3407 3408
    /*
      Not table locking or alter table with rename
      free locks and remove old table
    */
3409 3410
    if (table)
      close_cached_table(thd,table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3411 3412 3413 3414
    VOID(quick_rm_table(old_db_type,db,old_name));
  }
  else
  {
3415 3416 3417 3418 3419
    /*
      Using LOCK TABLES without rename.
      This code is never executed on WIN32!
      Remove old renamed table, reopen table and get new locks
    */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3420 3421 3422 3423
    if (table)
    {
      VOID(table->file->extra(HA_EXTRA_FORCE_REOPEN)); // Use new file
      remove_table_from_cache(thd,db,table_name); // Mark all in-use copies old
3424
      mysql_lock_abort(thd,table);		 // end threads waiting on lock
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3425 3426 3427
    }
    VOID(quick_rm_table(old_db_type,db,old_name));
    if (close_data_tables(thd,db,table_name) ||
3428 3429
	reopen_tables(thd,1,0))
    {						// This shouldn't happen
3430
      if (table)
3431
	close_cached_table(thd,table);		// Remove lock for table
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3432 3433 3434 3435
      VOID(pthread_mutex_unlock(&LOCK_open));
      goto err;
    }
  }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3436
  /* The ALTER TABLE is always in its own transaction */
3437 3438 3439 3440
  error = ha_commit_stmt(thd);
  if (ha_commit(thd))
    error=1;
  if (error)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3441 3442
  {
    VOID(pthread_mutex_unlock(&LOCK_open));
3443
    VOID(pthread_cond_broadcast(&COND_refresh));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3444 3445 3446
    goto err;
  }
  thd->proc_info="end";
3447 3448
  mysql_update_log.write(thd, thd->query,thd->query_length);
  if (mysql_bin_log.is_open())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3449
  {
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3450
    thd->clear_error();
3451
    Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3452 3453 3454 3455
    mysql_bin_log.write(&qinfo);
  }
  VOID(pthread_cond_broadcast(&COND_refresh));
  VOID(pthread_mutex_unlock(&LOCK_open));
3456 3457 3458
#ifdef HAVE_BERKELEY_DB
  if (old_db_type == DB_TYPE_BERKELEY_DB)
  {
3459 3460 3461 3462 3463
    /*
      For the alter table to be properly flushed to the logs, we
      have to open the new table.  If not, we get a problem on server
      shutdown.
    */
3464
    char path[FN_REFLEN];
3465
    build_table_path(path, sizeof(path), new_db, table_name, "");
3466 3467
    table=open_temporary_table(thd, path, new_db, tmp_name,0);
    if (table)
3468
    {
3469 3470
      intern_close_table(table);
      my_free((char*) table, MYF(0));
3471
    }
3472
    else
serg@serg.mylan's avatar
serg@serg.mylan committed
3473 3474
      sql_print_warning("Could not open BDB table %s.%s after rename\n",
                        new_db,table_name);
3475
    (void) berkeley_flush_logs();
3476 3477
  }
#endif
3478
  table_list->table=0;				// For query cache
3479
  query_cache_invalidate3(thd, table_list, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3480 3481

end_temporary:
3482 3483 3484
  my_snprintf(tmp_name, sizeof(tmp_name), ER(ER_INSERT_INFO),
	      (ulong) (copied + deleted), (ulong) deleted,
	      (ulong) thd->cuted_fields);
3485 3486
  if (do_send_ok)
    send_ok(thd,copied+deleted,0L,tmp_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3487 3488 3489 3490 3491 3492 3493 3494 3495
  thd->some_tables_deleted=0;
  DBUG_RETURN(0);

 err:
  DBUG_RETURN(-1);
}


static int
3496
copy_data_between_tables(TABLE *from,TABLE *to,
3497 3498
			 List<create_field> &create,
			 enum enum_duplicates handle_duplicates,
3499
                         bool ignore,
3500 3501 3502
			 uint order_num, ORDER *order,
			 ha_rows *copied,
			 ha_rows *deleted)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3503 3504
{
  int error;
3505
  Copy_field *copy,*copy_end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3506 3507
  ulong found_count,delete_count;
  THD *thd= current_thd;
3508 3509 3510 3511 3512 3513
  uint length;
  SORT_FIELD *sortorder;
  READ_RECORD info;
  TABLE_LIST   tables;
  List<Item>   fields;
  List<Item>   all_fields;
3514
  ha_rows examined_rows;
3515
  bool auto_increment_field_copied= 0;
3516
  ulong save_sql_mode;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3517 3518
  DBUG_ENTER("copy_data_between_tables");

3519 3520 3521 3522 3523 3524
  /*
    Turn off recovery logging since rollback of an alter table is to
    delete the new table so there is no need to log the changes to it.
    
    This needs to be done before external_lock
  */
3525
  error= ha_enable_transaction(thd, FALSE);
3526 3527
  if (error)
    DBUG_RETURN(-1);
3528
  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3529
  if (!(copy= new Copy_field[to->fields]))
3530
    DBUG_RETURN(-1);				/* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3531

3532 3533
  if (to->file->external_lock(thd, F_WRLCK))
    DBUG_RETURN(-1);
3534
  from->file->info(HA_STATUS_VARIABLE);
3535
  to->file->start_bulk_insert(from->file->records);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3536

3537 3538
  save_sql_mode= thd->variables.sql_mode;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3539 3540 3541 3542 3543 3544 3545
  List_iterator<create_field> it(create);
  create_field *def;
  copy_end=copy;
  for (Field **ptr=to->field ; *ptr ; ptr++)
  {
    def=it++;
    if (def->field)
3546 3547
    {
      if (*ptr == to->next_number_field)
3548
      {
3549
        auto_increment_field_copied= TRUE;
3550 3551 3552 3553 3554 3555 3556 3557 3558
        /*
          If we are going to copy contents of one auto_increment column to
          another auto_increment column it is sensible to preserve zeroes.
          This condition also covers case when we are don't actually alter
          auto_increment column.
        */
        if (def->field == from->found_next_number_field)
          thd->variables.sql_mode|= MODE_NO_AUTO_VALUE_ON_ZERO;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3559
      (copy_end++)->set(*ptr,def->field,0);
3560 3561
    }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3562 3563
  }

3564 3565
  found_count=delete_count=0;

monty@donna.mysql.fi's avatar
monty@donna.mysql.fi committed
3566 3567
  if (order)
  {
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
3568
    from->sort.io_cache=(IO_CACHE*) my_malloc(sizeof(IO_CACHE),
3569
					      MYF(MY_FAE | MY_ZEROFILL));
3570 3571
    bzero((char*) &tables,sizeof(tables));
    tables.table = from;
3572
    tables.alias = tables.real_name= from->real_name;
3573
    tables.db	 = from->table_cache_key;
3574 3575
    error=1;

3576
    if (thd->lex->select_lex.setup_ref_array(thd, order_num) ||
3577 3578 3579 3580 3581 3582 3583
	setup_order(thd, thd->lex->select_lex.ref_pointer_array,
		    &tables, fields, all_fields, order) ||
	!(sortorder=make_unireg_sortorder(order, &length)) ||
	(from->sort.found_records = filesort(thd, from, sortorder, length,
					     (SQL_SELECT *) 0, HA_POS_ERROR,
					     &examined_rows))
	== HA_POS_ERROR)
3584 3585 3586
      goto err;
  };

3587 3588 3589 3590
  /* Handler must be told explicitly to retrieve all columns, because
     this function does not set field->query_id in the columns to the
     current query id */
  from->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3591
  init_read_record(&info, thd, from, (SQL_SELECT *) 0, 1,1);
3592
  if (ignore ||
3593
      handle_duplicates == DUP_REPLACE)
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
3594
    to->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
3595
  thd->row_count= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3596 3597 3598 3599 3600 3601 3602 3603
  while (!(error=info.read_record(&info)))
  {
    if (thd->killed)
    {
      my_error(ER_SERVER_SHUTDOWN,MYF(0));
      error= 1;
      break;
    }
3604
    thd->row_count++;
3605 3606
    if (to->next_number_field)
    {
3607
      if (auto_increment_field_copied)
3608
        to->auto_increment_field_not_null= TRUE;
3609 3610 3611 3612 3613
      else
        to->next_number_field->reset();
    }
    for (Copy_field *copy_ptr=copy ; copy_ptr != copy_end ; copy_ptr++)
    {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3614
      copy_ptr->do_copy(copy_ptr);
3615
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3616 3617
    if ((error=to->file->write_row((byte*) to->record[0])))
    {
3618
      if ((!ignore &&
3619 3620 3621
	   handle_duplicates != DUP_REPLACE) ||
	  (error != HA_ERR_FOUND_DUPP_KEY &&
	   error != HA_ERR_FOUND_DUPP_UNIQUE))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3622
      {
3623 3624
	to->file->print_error(error,MYF(0));
	break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3625 3626 3627 3628
      }
      delete_count++;
    }
    else
3629
      found_count++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3630 3631
  }
  end_read_record(&info);
3632
  free_io_cache(from);
3633
  delete [] copy;				// This is never 0
serg@serg.mylan's avatar
serg@serg.mylan committed
3634 3635

  if (to->file->end_bulk_insert() && !error)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3636
  {
serg@serg.mylan's avatar
serg@serg.mylan committed
3637
    to->file->print_error(my_errno,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3638 3639
    error=1;
  }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
3640
  to->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
3641

3642
  ha_enable_transaction(thd,TRUE);
3643

3644 3645 3646 3647 3648 3649 3650 3651
  /*
    Ensure that the new table is saved properly to disk so that we
    can do a rename
  */
  if (ha_commit_stmt(thd))
    error=1;
  if (ha_commit(thd))
    error=1;
3652

3653
 err:
3654
  thd->variables.sql_mode= save_sql_mode;
3655
  free_io_cache(from);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3656 3657
  *copied= found_count;
  *deleted=delete_count;
3658 3659
  if (to->file->external_lock(thd,F_UNLCK))
    error=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3660 3661
  DBUG_RETURN(error > 0 ? -1 : 0);
}
3662

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3663

3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685
/*
  Recreates tables by calling mysql_alter_table().

  SYNOPSIS
    mysql_recreate_table()
    thd			Thread handler
    tables		Tables to recreate
    do_send_ok          If we should send_ok() or leave it to caller

 RETURN
    Like mysql_alter_table().
*/
int mysql_recreate_table(THD *thd, TABLE_LIST *table_list,
                         bool do_send_ok)
{
  DBUG_ENTER("mysql_recreate_table");
  LEX *lex= thd->lex;
  HA_CREATE_INFO create_info;
  lex->create_list.empty();
  lex->key_list.empty();
  lex->col_list.empty();
  lex->alter_info.reset();
3686
  lex->alter_info.is_simple= 0;                 // Force full recreate
3687 3688 3689 3690 3691 3692 3693
  bzero((char*) &create_info,sizeof(create_info));
  create_info.db_type=DB_TYPE_DEFAULT;
  create_info.row_type=ROW_TYPE_DEFAULT;
  create_info.default_table_charset=default_charset_info;
  DBUG_RETURN(mysql_alter_table(thd, NullS, NullS, &create_info,
                                table_list, lex->create_list,
                                lex->key_list, 0, (ORDER *) 0,
3694
                                DUP_ERROR, 0, &lex->alter_info, do_send_ok));
3695 3696 3697
}


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3698
int mysql_checksum_table(THD *thd, TABLE_LIST *tables, HA_CHECK_OPT *check_opt)
3699 3700 3701 3702 3703
{
  TABLE_LIST *table;
  List<Item> field_list;
  Item *item;
  Protocol *protocol= thd->protocol;
3704
  DBUG_ENTER("mysql_checksum_table");
3705 3706 3707 3708 3709 3710 3711 3712

  field_list.push_back(item = new Item_empty_string("Table", NAME_LEN*2));
  item->maybe_null= 1;
  field_list.push_back(item=new Item_int("Checksum",(longlong) 1,21));
  item->maybe_null= 1;
  if (protocol->send_fields(&field_list, 1))
    DBUG_RETURN(-1);

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3713
  for (table= tables; table; table= table->next)
3714 3715
  {
    char table_name[NAME_LEN*2+2];
3716
    TABLE *t;
3717

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3718 3719 3720
    strxmov(table_name, table->db ,".", table->real_name, NullS);

    t= table->table= open_ltable(thd, table, TL_READ_NO_INSERT);
3721
    thd->clear_error();			// these errors shouldn't get client
3722 3723 3724 3725

    protocol->prepare_for_resend();
    protocol->store(table_name, system_charset_info);

3726
    if (!t)
3727
    {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3728
      /* Table didn't exist */
3729 3730 3731 3732 3733
      protocol->store_null();
      thd->net.last_error[0]=0;
    }
    else
    {
3734
      t->pos_in_table_list= table;
3735

3736
      if (t->file->table_flags() & HA_HAS_CHECKSUM &&
3737 3738
	  !(check_opt->flags & T_EXTEND))
	protocol->store((ulonglong)t->file->checksum());
3739
      else if (!(t->file->table_flags() & HA_HAS_CHECKSUM) &&
3740 3741
	       (check_opt->flags & T_QUICK))
	protocol->store_null();
3742 3743
      else
      {
3744 3745 3746 3747 3748 3749 3750 3751
	/* calculating table's checksum */
	ha_checksum crc= 0;

	/* InnoDB must be told explicitly to retrieve all columns, because
	this function does not set field->query_id in the columns to the
	current query id */
	t->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);

3752
	if (t->file->ha_rnd_init(1))
3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779
	  protocol->store_null();
	else
	{
	  while (!t->file->rnd_next(t->record[0]))
	  {
	    ha_checksum row_crc= 0;
	    if (t->record[0] != (byte*) t->field[0]->ptr)
	      row_crc= my_checksum(row_crc, t->record[0],
				   ((byte*) t->field[0]->ptr) - t->record[0]);

	    for (uint i= 0; i < t->fields; i++ )
	    {
	      Field *f= t->field[i];
	      if (f->type() == FIELD_TYPE_BLOB)
	      {
		String tmp;
		f->val_str(&tmp);
		row_crc= my_checksum(row_crc, (byte*) tmp.ptr(), tmp.length());
	      }
	      else
		row_crc= my_checksum(row_crc, (byte*) f->ptr,
				     f->pack_length());
	    }

	    crc+= row_crc;
	  }
	  protocol->store((ulonglong)crc);
3780
          t->file->ha_rnd_end();
3781
	}
3782
      }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3783
      thd->clear_error();
3784
      close_thread_tables(thd);
3785
      table->table=0;				// For query cache
3786 3787 3788 3789 3790 3791 3792
    }
    if (protocol->write())
      goto err;
  }

  send_eof(thd);
  DBUG_RETURN(0);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3793

3794
 err:
3795
  close_thread_tables(thd);			// Shouldn't be needed
3796 3797 3798 3799
  if (table)
    table->table=0;
  DBUG_RETURN(-1);
}