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

   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"
20
#ifdef HAVE_BERKELEY_DB
21
#include "ha_berkeley.h"
22
#endif
23
#include <hash.h>
unknown's avatar
unknown committed
24
#include <myisam.h>
25
#include <my_dir.h>
unknown's avatar
unknown committed
26 27 28 29 30

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

unknown's avatar
unknown committed
31
const char *primary_key_name="PRIMARY";
unknown's avatar
unknown committed
32 33 34 35 36 37

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,
				    List<create_field> &create,
				    enum enum_duplicates handle_duplicates,
38
                                    bool ignore,
39
				    uint order_num, ORDER *order,
unknown's avatar
unknown committed
40
				    ha_rows *copied,ha_rows *deleted);
unknown's avatar
unknown committed
41

unknown's avatar
unknown committed
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
/*
 delete (drop) tables.

  SYNOPSIS
   mysql_rm_table()
   thd			Thread handle
   tables		List of tables to delete
   if_exists		If 1, don't give error if one table doesn't exists

  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
unknown's avatar
unknown committed
60 61
    FALSE OK.  In this case ok packet is sent to user
    TRUE  Error
unknown's avatar
unknown committed
62 63

*/
unknown's avatar
unknown committed
64

unknown's avatar
unknown committed
65 66
bool mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists,
                    my_bool drop_temporary)
unknown's avatar
unknown committed
67
{
unknown's avatar
unknown committed
68
  bool error= FALSE;
unknown's avatar
unknown committed
69 70 71 72 73 74 75 76
  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));

77
  if (!drop_temporary && global_read_lock)
unknown's avatar
unknown committed
78
  {
unknown's avatar
unknown committed
79
    if (thd->global_read_lock)
80
    {
81
      my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), tables->table_name);
unknown's avatar
unknown committed
82
      error= TRUE;
unknown's avatar
unknown committed
83 84 85 86 87
      goto err;
    }
    while (global_read_lock && ! thd->killed)
    {
      (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
88
    }
unknown's avatar
unknown committed
89 90

  }
unknown's avatar
VIEW  
unknown committed
91
  error= mysql_rm_table_part2(thd, tables, if_exists, drop_temporary, 0, 0);
92

93
 err:
94 95 96 97 98 99 100 101
  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)
unknown's avatar
unknown committed
102
    DBUG_RETURN(TRUE);
103
  send_ok(thd);
unknown's avatar
unknown committed
104
  DBUG_RETURN(FALSE);
105 106
}

unknown's avatar
unknown committed
107 108 109 110 111

/*
 delete (drop) tables.

  SYNOPSIS
112 113 114 115 116 117
    mysql_rm_table_part2_with_lock()
    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. This will also not
			generate warnings if the handler files doesn't exists  
unknown's avatar
unknown committed
118 119 120 121 122 123 124 125 126 127

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

 RETURN
  0	ok
  1	error
*/

unknown's avatar
unknown committed
128 129
int mysql_rm_table_part2_with_lock(THD *thd,
				   TABLE_LIST *tables, bool if_exists,
130
				   bool drop_temporary, bool dont_log_query)
unknown's avatar
unknown committed
131 132 133 134 135 136
{
  int error;
  thd->mysys_var->current_mutex= &LOCK_open;
  thd->mysys_var->current_cond= &COND_refresh;
  VOID(pthread_mutex_lock(&LOCK_open));

unknown's avatar
VIEW  
unknown committed
137 138
  error= mysql_rm_table_part2(thd, tables, if_exists, drop_temporary, 1,
			      dont_log_query);
unknown's avatar
unknown committed
139 140 141 142 143 144 145 146 147 148

  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;
}

unknown's avatar
unknown committed
149

150
/*
151 152 153 154 155 156 157 158 159
  Execute the drop of a normal or temporary table

  SYNOPSIS
    mysql_rm_table_part2()
    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
unknown's avatar
VIEW  
unknown committed
160
    drop_view		Allow to delete VIEW .frm
161 162
    dont_log_query	Don't write query to log files. This will also not
			generate warnings if the handler files doesn't exists  
163

164 165 166 167 168 169 170 171 172
  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.
173 174 175 176 177

 RETURN
   0	ok
   1	Error
   -1	Thread was killed
178
*/
179 180

int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
unknown's avatar
VIEW  
unknown committed
181 182
			 bool drop_temporary, bool drop_view,
			 bool dont_log_query)
183 184
{
  TABLE_LIST *table;
unknown's avatar
unknown committed
185
  char	path[FN_REFLEN], *alias;
186 187
  String wrong_tables;
  int error;
unknown's avatar
unknown committed
188
  bool some_tables_deleted=0, tmp_table_deleted=0, foreign_key_error=0;
189 190
  DBUG_ENTER("mysql_rm_table_part2");

191
  if (lock_table_names(thd, tables))
192
    DBUG_RETURN(1);
193

194 195 196
  /* Don't give warnings for not found errors, as we already generate notes */
  thd->no_warnings_for_error= 1;

unknown's avatar
VIEW  
unknown committed
197
  for (table= tables; table; table= table->next_local)
unknown's avatar
unknown committed
198
  {
199
    char *db=table->db;
200
    mysql_ha_flush(thd, table, MYSQL_HA_CLOSE_FINAL);
201
    if (!close_temporary_table(thd, db, table->table_name))
unknown's avatar
unknown committed
202
    {
203
      tmp_table_deleted=1;
unknown's avatar
unknown committed
204
      continue;					// removed temporary table
unknown's avatar
unknown committed
205
    }
unknown's avatar
unknown committed
206 207

    error=0;
208
    if (!drop_temporary)
unknown's avatar
unknown committed
209
    {
210 211
      abort_locked_tables(thd,db,table->table_name);
      while (remove_table_from_cache(thd,db,table->table_name) && !thd->killed)
212 213 214 215 216
      {
	dropping_tables++;
	(void) pthread_cond_wait(&COND_refresh,&LOCK_open);
	dropping_tables--;
      }
217
      drop_locked_tables(thd,db,table->table_name);
218
      if (thd->killed)
219 220
      {
        thd->no_warnings_for_error= 0;
221
	DBUG_RETURN(-1);
222
      }
223
      alias= (lower_case_table_names == 2) ? table->alias : table->table_name;
224
      /* remove form file and isam files */
unknown's avatar
unknown committed
225
      strxmov(path, mysql_data_home, "/", db, "/", alias, reg_ext, NullS);
226
      (void) unpack_filename(path,path);
unknown's avatar
unknown committed
227
    }
unknown's avatar
unknown committed
228
    if (drop_temporary ||
229 230
        (access(path,F_OK) &&
         ha_create_table_from_engine(thd,db,alias,TRUE)) ||
unknown's avatar
unknown committed
231
        (!drop_view && mysql_frm_type(path) != FRMTYPE_TABLE))
unknown's avatar
unknown committed
232
    {
233
      if (if_exists)
234 235
	push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
			    ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
236
			    table->table_name);
237
      else
238
	error= 1;
unknown's avatar
unknown committed
239 240 241
    }
    else
    {
unknown's avatar
unknown committed
242
      char *end;
unknown's avatar
unknown committed
243
      db_type table_type= get_table_type(path);
unknown's avatar
unknown committed
244
      *(end=fn_ext(path))=0;			// Remove extension for delete
245 246
      error= ha_delete_table(thd, table_type, path, table->table_name,
                             !dont_log_query);
247 248
      if ((error == ENOENT || error == HA_ERR_NO_SUCH_TABLE) && if_exists)
	error= 0;
unknown's avatar
unknown committed
249
      if (error == HA_ERR_ROW_IS_REFERENCED)
unknown's avatar
unknown committed
250 251
      {
	/* the table is referenced by a foreign key constraint */
252
	foreign_key_error=1;
unknown's avatar
unknown committed
253
      }
254
      if (!error || error == ENOENT || error == HA_ERR_NO_SUCH_TABLE)
unknown's avatar
unknown committed
255
      {
256
        int new_error;
unknown's avatar
unknown committed
257 258
	/* Delete the table definition file */
	strmov(end,reg_ext);
259
	if (!(new_error=my_delete(path,MYF(MY_WME))))
unknown's avatar
unknown committed
260
	  some_tables_deleted=1;
261
        error|= new_error;
262
      }
unknown's avatar
unknown committed
263 264 265 266 267
    }
    if (error)
    {
      if (wrong_tables.length())
	wrong_tables.append(',');
268
      wrong_tables.append(String(table->table_name,system_charset_info));
unknown's avatar
unknown committed
269 270
    }
  }
unknown's avatar
unknown committed
271
  thd->tmp_table_used= tmp_table_deleted;
272 273 274 275
  error= 0;
  if (wrong_tables.length())
  {
    if (!foreign_key_error)
276
      my_error(ER_BAD_TABLE_ERROR, MYF(0), wrong_tables.c_ptr());
277
    else
unknown's avatar
unknown committed
278
      my_message(ER_ROW_IS_REFERENCED, ER(ER_ROW_IS_REFERENCED), MYF(0));
279 280 281 282
    error= 1;
  }

  if (some_tables_deleted || tmp_table_deleted || !error)
unknown's avatar
unknown committed
283
  {
unknown's avatar
unknown committed
284
    query_cache_invalidate3(thd, tables, 0);
285
    if (!dont_log_query && mysql_bin_log.is_open())
286
    {
unknown's avatar
unknown committed
287 288
      if (!error)
        thd->clear_error();
unknown's avatar
unknown committed
289
      Query_log_event qinfo(thd, thd->query, thd->query_length, FALSE, FALSE);
290
      mysql_bin_log.write(&qinfo);
291
    }
unknown's avatar
unknown committed
292
  }
unknown's avatar
unknown committed
293

294
  unlock_table_names(thd, tables);
295
  thd->no_warnings_for_error= 0;
296
  DBUG_RETURN(error);
unknown's avatar
unknown committed
297 298 299 300 301 302 303 304
}


int quick_rm_table(enum db_type base,const char *db,
		   const char *table_name)
{
  char path[FN_REFLEN];
  int error=0;
305 306
  my_snprintf(path, sizeof(path), "%s/%s/%s%s",
	      mysql_data_home, db, table_name, reg_ext);
unknown's avatar
unknown committed
307 308 309
  unpack_filename(path,path);
  if (my_delete(path,MYF(0)))
    error=1; /* purecov: inspected */
310
  my_snprintf(path, sizeof(path), "%s/%s/%s", mysql_data_home, db, table_name);
unknown's avatar
unknown committed
311
  unpack_filename(path,path);
312
  return ha_delete_table(current_thd, base, path, table_name, 0) || error;
unknown's avatar
unknown committed
313 314
}

315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
/*
  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;
333
    if ((a->flags ^ b->flags) & (HA_NULL_PART_KEY | HA_END_SPACE_KEY))
334 335
    {
      /* Sort NOT NULL keys before other keys */
336
      return (a->flags & (HA_NULL_PART_KEY | HA_END_SPACE_KEY)) ? 1 : -1;
337 338 339 340 341 342 343 344 345 346 347 348 349
    }
    if (a->name == primary_key_name)
      return -1;
    if (b->name == primary_key_name)
      return 1;
  }
  else if (b->flags & HA_NOSAME)
    return 1;					// Prefer b

  if ((a->flags ^ b->flags) & HA_FULLTEXT)
  {
    return (a->flags & HA_FULLTEXT) ? 1 : -1;
  }
unknown's avatar
unknown committed
350
  /*
351
    Prefer original key order.	usable_key_parts contains here
unknown's avatar
unknown committed
352 353 354 355 356
    the original key position.
  */
  return ((a->usable_key_parts < b->usable_key_parts) ? -1 :
	  (a->usable_key_parts > b->usable_key_parts) ? 1 :
	  0);
357 358
}

359 360
/*
  Check TYPELIB (set or enum) for duplicates
361

362 363 364
  SYNOPSIS
    check_duplicates_in_interval()
    set_or_name   "SET" or "ENUM" string for warning message
365 366
    name	  name of the checked column
    typelib	  list of values for the column
367 368

  DESCRIPTION
369
    This function prints an warning for each value in list
370 371 372 373 374 375 376
    which has some duplicates on its right

  RETURN VALUES
    void
*/

void check_duplicates_in_interval(const char *set_or_name,
377 378
                                  const char *name, TYPELIB *typelib,
                                  CHARSET_INFO *cs)
379
{
380
  TYPELIB tmp= *typelib;
381
  const char **cur_value= typelib->type_names;
382 383 384
  unsigned int *cur_length= typelib->type_lengths;
  
  for ( ; tmp.count > 1; cur_value++, cur_length++)
385
  {
386 387 388 389
    tmp.type_names++;
    tmp.type_lengths++;
    tmp.count--;
    if (find_type2(&tmp, (const char*)*cur_value, *cur_length, cs))
390
    {
unknown's avatar
unknown committed
391
      push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_NOTE,
392 393 394 395 396 397
			  ER_DUPLICATED_VALUE_IN_TYPE,
			  ER(ER_DUPLICATED_VALUE_IN_TYPE),
			  name,*cur_value,set_or_name);
    }
  }
}
398

399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433

/*
  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);
  }
}


unknown's avatar
unknown committed
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 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
/*
  Prepare a create_table instance for packing

  SYNOPSIS
    prepare_create_field()
    sql_field     field to prepare for packing
    blob_columns  count for BLOBs
    timestamps    count for timestamps
    table_flags   table flags

  DESCRIPTION
    This function prepares a create_field instance.
    Fields such as pack_flag are valid after this call.

  RETURN VALUES
   0	ok
   1	Error
*/

int prepare_create_field(create_field *sql_field, 
			 uint &blob_columns, 
			 int &timestamps, int &timestamps_with_niladic,
			 uint table_flags)
{
  DBUG_ENTER("prepare_field");
  {
    /* This code came from mysql_prepare_table.
       Indent preserved to make patching easier */
    DBUG_ASSERT(sql_field->charset);

    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 |
	pack_length_to_packflag(sql_field->pack_length -
				portable_sizeof_char_ptr);
      if (sql_field->charset->state & MY_CS_BINSORT)
	sql_field->pack_flag|=FIELDFLAG_BINARY;
      sql_field->length=8;			// Unireg field length
      sql_field->unireg_check=Field::BLOB_FIELD;
      blob_columns++;
      break;
    case FIELD_TYPE_GEOMETRY:
#ifdef HAVE_SPATIAL
      if (!(table_flags & HA_CAN_GEOMETRY))
      {
	my_printf_error(ER_CHECK_NOT_IMPLEMENTED, ER(ER_CHECK_NOT_IMPLEMENTED),
			MYF(0), "GEOMETRY");
	DBUG_RETURN(1);
      }
      sql_field->pack_flag=FIELDFLAG_GEOM |
	pack_length_to_packflag(sql_field->pack_length -
				portable_sizeof_char_ptr);
      if (sql_field->charset->state & MY_CS_BINSORT)
	sql_field->pack_flag|=FIELDFLAG_BINARY;
      sql_field->length=8;			// Unireg field length
      sql_field->unireg_check=Field::BLOB_FIELD;
      blob_columns++;
      break;
#else
      my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED), MYF(0),
		      sym_group_geom.name, sym_group_geom.needed_define);
      DBUG_RETURN(1);
#endif /*HAVE_SPATIAL*/
    case MYSQL_TYPE_VARCHAR:
#ifndef QQ_ALL_HANDLERS_SUPPORT_VARCHAR
      if (table_flags & HA_NO_VARCHAR)
      {
        /* convert VARCHAR to CHAR because handler is not yet up to date */
        sql_field->sql_type=    MYSQL_TYPE_VAR_STRING;
        sql_field->pack_length= calc_pack_length(sql_field->sql_type,
                                                 (uint) sql_field->length);
        if ((sql_field->length / sql_field->charset->mbmaxlen) >
            MAX_FIELD_CHARLENGTH)
        {
          my_printf_error(ER_TOO_BIG_FIELDLENGTH, ER(ER_TOO_BIG_FIELDLENGTH),
                          MYF(0), sql_field->field_name, MAX_FIELD_CHARLENGTH);
          DBUG_RETURN(1);
        }
      }
#endif
      /* fall through */
    case FIELD_TYPE_STRING:
      sql_field->pack_flag=0;
      if (sql_field->charset->state & MY_CS_BINSORT)
	sql_field->pack_flag|=FIELDFLAG_BINARY;
      break;
    case FIELD_TYPE_ENUM:
      sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
	FIELDFLAG_INTERVAL;
      if (sql_field->charset->state & MY_CS_BINSORT)
	sql_field->pack_flag|=FIELDFLAG_BINARY;
      sql_field->unireg_check=Field::INTERVAL_FIELD;
      check_duplicates_in_interval("ENUM",sql_field->field_name,
				   sql_field->interval,
                                   sql_field->charset);
      break;
    case FIELD_TYPE_SET:
      sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
	FIELDFLAG_BITFIELD;
      if (sql_field->charset->state & MY_CS_BINSORT)
	sql_field->pack_flag|=FIELDFLAG_BINARY;
      sql_field->unireg_check=Field::BIT_FIELD;
      check_duplicates_in_interval("SET",sql_field->field_name,
				   sql_field->interval,
                                   sql_field->charset);
      break;
    case FIELD_TYPE_DATE:			// Rest of string types
    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_BIT:
      if (!(table_flags & HA_CAN_BIT_FIELD))
      {
        my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), "BIT FIELD");
        DBUG_RETURN(1);
      }
      sql_field->pack_flag= FIELDFLAG_NUMBER;
      break;
    case FIELD_TYPE_NEWDECIMAL:
      sql_field->pack_flag=(FIELDFLAG_NUMBER |
                            (sql_field->flags & UNSIGNED_FLAG ? 0 :
                             FIELDFLAG_DECIMAL) |
                            (sql_field->flags & ZEROFILL_FLAG ?
                             FIELDFLAG_ZEROFILL : 0) |
                            (sql_field->decimals << FIELDFLAG_DEC_SHIFT));
      break;
    case FIELD_TYPE_TIMESTAMP:
      /* We should replace old TIMESTAMP fields with their newer analogs */
      if (sql_field->unireg_check == Field::TIMESTAMP_OLD_FIELD)
      {
	if (!timestamps)
	{
	  sql_field->unireg_check= Field::TIMESTAMP_DNUN_FIELD;
	  timestamps_with_niladic++;
	}
	else
	  sql_field->unireg_check= Field::NONE;
      }
      else if (sql_field->unireg_check != Field::NONE)
	timestamps_with_niladic++;

      timestamps++;
      /* fall-through */
    default:
      sql_field->pack_flag=(FIELDFLAG_NUMBER |
			    (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));
      break;
    }
    if (!(sql_field->flags & NOT_NULL_FLAG))
      sql_field->pack_flag|= FIELDFLAG_MAYBE_NULL;
    if (sql_field->flags & NO_DEFAULT_VALUE_FLAG)
      sql_field->pack_flag|= FIELDFLAG_NO_DEFAULT;
  }
  DBUG_RETURN(0);
}

unknown's avatar
unknown committed
601
/*
602
  Preparation for table creation
unknown's avatar
unknown committed
603 604

  SYNOPSIS
605
    mysql_prepare_table()
unknown's avatar
unknown committed
606 607 608 609 610
    thd			Thread object
    create_info		Create information (like MAX_ROWS)
    fields		List of fields to create
    keys		List of keys to create

611
  DESCRIPTION
612
    Prepares the table and key structures for table creation.
unknown's avatar
unknown committed
613

614 615 616
  NOTES
    sets create_info->varchar if the table has a varchar or blob.

unknown's avatar
unknown committed
617 618 619 620
  RETURN VALUES
    0	ok
    -1	error
*/
unknown's avatar
unknown committed
621

622
int mysql_prepare_table(THD *thd, HA_CREATE_INFO *create_info,
623 624 625 626
			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)
unknown's avatar
unknown committed
627
{
628
  const char	*key_name;
unknown's avatar
unknown committed
629
  create_field	*sql_field,*dup_field;
630
  uint		field,null_fields,blob_columns;
631
  uint		max_key_length= file->max_key_length();
unknown's avatar
unknown committed
632
  ulong		pos;
633
  KEY		*key_info;
unknown's avatar
unknown committed
634
  KEY_PART_INFO *key_part_info;
635 636 637
  int		timestamps= 0, timestamps_with_niladic= 0;
  int		field_no,dup_no;
  int		select_field_pos,auto_increment=0;
638
  List_iterator<create_field> it(fields),it2(fields);
unknown's avatar
unknown committed
639
  uint total_uneven_bit_length= 0;
640
  DBUG_ENTER("mysql_prepare_table");
unknown's avatar
unknown committed
641

642
  select_field_pos=fields.elements - select_field_count;
unknown's avatar
unknown committed
643
  null_fields=blob_columns=0;
644
  create_info->varchar= 0;
645

646
  for (field_no=0; (sql_field=it++) ; field_no++)
unknown's avatar
unknown committed
647
  {
648 649
    CHARSET_INFO *save_cs;

650
    if (!sql_field->charset)
651 652 653
      sql_field->charset= create_info->default_table_charset;
    /*
      table_charset is set in ALTER TABLE if we want change character set
654 655 656
      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.
657
    */
658
    if (create_info->table_charset && sql_field->charset != &my_charset_bin)
659
      sql_field->charset= create_info->table_charset;
660

661
    save_cs= sql_field->charset;
662 663 664 665 666
    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];
667
      strmake(strmake(tmp, save_cs->csname, sizeof(tmp)-4), "_bin", 4);
668 669 670
      my_error(ER_UNKNOWN_COLLATION, MYF(0), tmp);
      DBUG_RETURN(-1);
    }
671

672 673
    if (sql_field->sql_type == FIELD_TYPE_SET ||
        sql_field->sql_type == FIELD_TYPE_ENUM)
674 675 676
    {
      uint32 dummy;
      CHARSET_INFO *cs= sql_field->charset;
677
      TYPELIB *interval= sql_field->interval;
678 679 680 681 682 683

      /*
        Create typelib from interval_list, and if necessary
        convert strings from client character set to the
        column character set.
      */
684
      if (!interval)
685
      {
686 687 688 689
        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++)
690
        {
691 692 693 694 695 696 697 698 699 700 701
          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();
          }
702

703 704 705 706 707
          // 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';
708
        }
709
        sql_field->interval_list.empty(); // Don't need interval_list anymore
710 711 712 713 714 715 716 717 718 719 720 721 722 723
      }

      /*
        Convert the default value from client character
        set into the column character set if necessary.
      */
      if (sql_field->def)
      {
        sql_field->def= 
          sql_field->def->safe_charset_converter(cs);
      }

      if (sql_field->sql_type == FIELD_TYPE_SET)
      {
724
        uint32 field_length;
725 726 727 728 729 730 731 732 733 734 735 736 737 738 739
        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);
          }
        }
740 741
        calculate_interval_lengths(cs, interval, &dummy, &field_length);
        sql_field->length= field_length + (interval->count - 1);
742 743 744
      }
      else  /* FIELD_TYPE_ENUM */
      {
745
        uint32 field_length;
746 747 748 749 750 751 752 753 754 755
        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);
          }
        }
756 757
        calculate_interval_lengths(cs, interval, &field_length, &dummy);
        sql_field->length= field_length;
758 759 760 761
      }
      set_if_smaller(sql_field->length, MAX_FIELD_WIDTH-1);
    }

762
    sql_field->create_length_to_internal_length();
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793
    if (sql_field->length > MAX_FIELD_VARCHARLENGTH &&
        !(sql_field->flags & BLOB_FLAG))
    {
      /* Convert long VARCHAR columns to TEXT or BLOB */
      char warn_buff[MYSQL_ERRMSG_SIZE];

      if (sql_field->def)
      {
        my_error(ER_TOO_BIG_FIELDLENGTH, MYF(0), sql_field->field_name,
                 MAX_FIELD_VARCHARLENGTH / sql_field->charset->mbmaxlen);
        DBUG_RETURN(-1);
      }
      sql_field->sql_type= FIELD_TYPE_BLOB;
      sql_field->flags|= BLOB_FLAG;
      sprintf(warn_buff, ER(ER_AUTO_CONVERT), sql_field->field_name,
              "VARCHAR",
              (sql_field->charset == &my_charset_bin) ? "BLOB" : "TEXT");
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE, ER_AUTO_CONVERT,
                   warn_buff);
    }
    
    if ((sql_field->flags & BLOB_FLAG) && sql_field->length)
    {
      if (sql_field->sql_type == FIELD_TYPE_BLOB)
      {
        /* The user has given a length to the blob column */
        sql_field->sql_type= get_blob_type_from_length(sql_field->length);
        sql_field->pack_length= calc_pack_length(sql_field->sql_type, 0);
      }
      sql_field->length= 0;                     // Probably from an item
    }
794

unknown's avatar
unknown committed
795 796
    if (!(sql_field->flags & NOT_NULL_FLAG))
      null_fields++;
797

unknown's avatar
unknown committed
798 799 800
    if (sql_field->sql_type == FIELD_TYPE_BIT)
      total_uneven_bit_length+= sql_field->length & 7;

unknown's avatar
unknown committed
801 802
    if (check_column_name(sql_field->field_name))
    {
803
      my_error(ER_WRONG_COLUMN_NAME, MYF(0), sql_field->field_name);
unknown's avatar
unknown committed
804 805
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
806

807 808
    /* Check if we have used the same field name before */
    for (dup_no=0; (dup_field=it2++) != sql_field; dup_no++)
unknown's avatar
unknown committed
809
    {
810
      if (my_strcasecmp(system_charset_info,
811 812
			sql_field->field_name,
			dup_field->field_name) == 0)
unknown's avatar
unknown committed
813
      {
814 815 816 817
	/*
	  If this was a CREATE ... SELECT statement, accept a field
	  redefinition if we are changing a field in the SELECT part
	*/
818 819
	if (field_no < select_field_pos || dup_no >= select_field_pos)
	{
820
	  my_error(ER_DUP_FIELDNAME, MYF(0), sql_field->field_name);
821 822 823 824
	  DBUG_RETURN(-1);
	}
	else
	{
825
	  /* Field redefined */
826
	  sql_field->sql_type=		dup_field->sql_type;
827 828 829
	  sql_field->charset=		(dup_field->charset ?
					 dup_field->charset :
					 create_info->default_table_charset);
830
	  sql_field->length=		dup_field->length;
831
	  sql_field->pack_length=	dup_field->pack_length;
832
          sql_field->key_length=	dup_field->key_length;
833
	  sql_field->create_length_to_internal_length();
834 835 836 837 838 839
	  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;
840
	}
unknown's avatar
unknown committed
841 842
      }
    }
843 844 845 846 847
    /* Don't pack rows in old tables if the user has requested this */
    if ((sql_field->flags & BLOB_FLAG) ||
	sql_field->sql_type == MYSQL_TYPE_VARCHAR &&
	create_info->row_type != ROW_TYPE_FIXED)
      db_options|= HA_OPTION_PACK_RECORD;
unknown's avatar
unknown committed
848 849
    it2.rewind();
  }
850
  /* If fixed row records, we need one bit to check for deleted rows */
unknown's avatar
unknown committed
851 852
  if (!(db_options & HA_OPTION_PACK_RECORD))
    null_fields++;
unknown's avatar
unknown committed
853
  pos= (null_fields + total_uneven_bit_length + 7) / 8;
unknown's avatar
unknown committed
854 855 856 857

  it.rewind();
  while ((sql_field=it++))
  {
858
    DBUG_ASSERT(sql_field->charset != 0);
859

unknown's avatar
unknown committed
860 861 862
    if (prepare_create_field(sql_field, blob_columns, 
			     timestamps, timestamps_with_niladic,
			     file->table_flags()))
unknown's avatar
unknown committed
863
      DBUG_RETURN(-1);
unknown's avatar
unknown committed
864 865 866 867 868 869 870
    if (sql_field->sql_type == FIELD_TYPE_BLOB ||
        sql_field->sql_type == FIELD_TYPE_MEDIUM_BLOB ||
        sql_field->sql_type == FIELD_TYPE_TINY_BLOB ||
        sql_field->sql_type == FIELD_TYPE_LONG_BLOB ||
        sql_field->sql_type == FIELD_TYPE_GEOMETRY ||
        sql_field->sql_type == MYSQL_TYPE_VARCHAR)
      create_info->varchar= 1;
unknown's avatar
unknown committed
871 872 873 874 875
    sql_field->offset= pos;
    if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
      auto_increment++;
    pos+=sql_field->pack_length;
  }
876 877
  if (timestamps_with_niladic > 1)
  {
unknown's avatar
unknown committed
878 879
    my_message(ER_TOO_MUCH_AUTO_TIMESTAMP_COLS,
               ER(ER_TOO_MUCH_AUTO_TIMESTAMP_COLS), MYF(0));
880 881
    DBUG_RETURN(-1);
  }
unknown's avatar
unknown committed
882 883
  if (auto_increment > 1)
  {
unknown's avatar
unknown committed
884
    my_message(ER_WRONG_AUTO_KEY, ER(ER_WRONG_AUTO_KEY), MYF(0));
unknown's avatar
unknown committed
885 886 887
    DBUG_RETURN(-1);
  }
  if (auto_increment &&
888
      (file->table_flags() & HA_NO_AUTO_INCREMENT))
unknown's avatar
unknown committed
889
  {
unknown's avatar
unknown committed
890 891
    my_message(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT,
               ER(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT), MYF(0));
unknown's avatar
unknown committed
892 893 894
    DBUG_RETURN(-1);
  }

895
  if (blob_columns && (file->table_flags() & HA_NO_BLOBS))
unknown's avatar
unknown committed
896
  {
unknown's avatar
unknown committed
897 898
    my_message(ER_TABLE_CANT_HANDLE_BLOB, ER(ER_TABLE_CANT_HANDLE_BLOB),
               MYF(0));
unknown's avatar
unknown committed
899 900 901 902
    DBUG_RETURN(-1);
  }

  /* Create keys */
903

904
  List_iterator<Key> key_iterator(keys), key_iterator2(keys);
905
  uint key_parts=0, fk_key_count=0;
906
  bool primary_key=0,unique_key=0;
907
  Key *key, *key2;
unknown's avatar
unknown committed
908
  uint tmp, key_number;
909 910
  /* special marker for keys to be ignored */
  static char ignore_key[1];
911

912
  /* Calculate number of key segements */
913
  *key_count= 0;
914

unknown's avatar
unknown committed
915 916
  while ((key=key_iterator++))
  {
917 918 919 920 921 922 923
    if (key->type == Key::FOREIGN_KEY)
    {
      fk_key_count++;
      foreign_key *fk_key= (foreign_key*) key;
      if (fk_key->ref_columns.elements &&
	  fk_key->ref_columns.elements != fk_key->columns.elements)
      {
924 925 926
        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));
927 928 929 930
	DBUG_RETURN(-1);
      }
      continue;
    }
931
    (*key_count)++;
unknown's avatar
unknown committed
932
    tmp=file->max_key_parts();
unknown's avatar
unknown committed
933 934 935 936 937
    if (key->columns.elements > tmp)
    {
      my_error(ER_TOO_MANY_KEY_PARTS,MYF(0),tmp);
      DBUG_RETURN(-1);
    }
938
    if (key->name && strlen(key->name) > NAME_LEN)
unknown's avatar
unknown committed
939
    {
940
      my_error(ER_TOO_LONG_IDENT, MYF(0), key->name);
unknown's avatar
unknown committed
941 942
      DBUG_RETURN(-1);
    }
943
    key_iterator2.rewind ();
944
    if (key->type != Key::FOREIGN_KEY)
945
    {
946
      while ((key2 = key_iterator2++) != key)
947
      {
unknown's avatar
unknown committed
948
	/*
949 950 951
          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.
unknown's avatar
unknown committed
952
        */
953 954 955
        if ((key2->type != Key::FOREIGN_KEY &&
             key2->name != ignore_key &&
             !foreign_key_prefix(key, key2)))
956
        {
957
          /* TODO: issue warning message */
958 959 960 961 962 963 964
          /* mark that the generated key should be ignored */
          if (!key2->generated ||
              (key->generated && key->columns.elements <
               key2->columns.elements))
            key->name= ignore_key;
          else
          {
965 966 967
            key2->name= ignore_key;
            key_parts-= key2->columns.elements;
            (*key_count)--;
968 969 970
          }
          break;
        }
971 972 973 974 975 976
      }
    }
    if (key->name != ignore_key)
      key_parts+=key->columns.elements;
    else
      (*key_count)--;
977 978 979 980 981 982
    if (key->name && !tmp_table &&
	!my_strcasecmp(system_charset_info,key->name,primary_key_name))
    {
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name);
      DBUG_RETURN(-1);
    }
983
  }
unknown's avatar
unknown committed
984
  tmp=file->max_keys();
985
  if (*key_count > tmp)
986 987 988 989
  {
    my_error(ER_TOO_MANY_KEYS,MYF(0),tmp);
    DBUG_RETURN(-1);
  }
990

991
  key_info_buffer=key_info=(KEY*) sql_calloc(sizeof(KEY)* *key_count);
992 993 994 995
  key_part_info=(KEY_PART_INFO*) sql_calloc(sizeof(KEY_PART_INFO)*key_parts);
  if (!key_info_buffer || ! key_part_info)
    DBUG_RETURN(-1);				// Out of memory

996
  key_iterator.rewind();
unknown's avatar
unknown committed
997
  key_number=0;
unknown's avatar
unknown committed
998
  for (; (key=key_iterator++) ; key_number++)
999 1000 1001 1002
  {
    uint key_length=0;
    key_part_spec *column;

1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
    if (key->name == ignore_key)
    {
      /* ignore redundant keys */
      do
	key=key_iterator++;
      while (key && key->name == ignore_key);
      if (!key)
	break;
    }

unknown's avatar
unknown committed
1013
    switch(key->type){
unknown's avatar
unknown committed
1014
    case Key::MULTIPLE:
1015
	key_info->flags= 0;
1016
	break;
unknown's avatar
unknown committed
1017
    case Key::FULLTEXT:
1018
	key_info->flags= HA_FULLTEXT;
1019
	break;
unknown's avatar
unknown committed
1020
    case Key::SPATIAL:
unknown's avatar
unknown committed
1021
#ifdef HAVE_SPATIAL
1022
	key_info->flags= HA_SPATIAL;
1023
	break;
unknown's avatar
unknown committed
1024
#else
1025 1026
	my_error(ER_FEATURE_DISABLED, MYF(0),
                 sym_group_geom.name, sym_group_geom.needed_define);
unknown's avatar
unknown committed
1027 1028
	DBUG_RETURN(-1);
#endif
1029 1030 1031 1032
    case Key::FOREIGN_KEY:
      key_number--;				// Skip this key
      continue;
    default:
1033 1034
      key_info->flags = HA_NOSAME;
      break;
unknown's avatar
unknown committed
1035
    }
1036 1037
    if (key->generated)
      key_info->flags|= HA_GENERATED_KEY;
unknown's avatar
unknown committed
1038

unknown's avatar
unknown committed
1039 1040
    key_info->key_parts=(uint8) key->columns.elements;
    key_info->key_part=key_part_info;
unknown's avatar
unknown committed
1041
    key_info->usable_key_parts= key_number;
1042
    key_info->algorithm=key->algorithm;
unknown's avatar
unknown committed
1043

1044 1045
    if (key->type == Key::FULLTEXT)
    {
1046
      if (!(file->table_flags() & HA_CAN_FULLTEXT))
1047
      {
unknown's avatar
unknown committed
1048 1049
	my_message(ER_TABLE_CANT_HANDLE_FT, ER(ER_TABLE_CANT_HANDLE_FT),
                   MYF(0));
1050
	DBUG_RETURN(-1);
1051 1052
      }
    }
unknown's avatar
unknown committed
1053 1054 1055
    /*
       Make SPATIAL to be RTREE by default
       SPATIAL only on BLOB or at least BINARY, this
1056
       actually should be replaced by special GEOM type
unknown's avatar
unknown committed
1057 1058 1059
       in near future when new frm file is ready
       checking for proper key parts number:
    */
1060

1061
    /* TODO: Add proper checks if handler supports key_type and algorithm */
1062
    if (key_info->flags & HA_SPATIAL)
1063 1064 1065
    {
      if (key_info->key_parts != 1)
      {
1066
	my_error(ER_WRONG_ARGUMENTS, MYF(0), "SPATIAL INDEX");
1067
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
1068
      }
1069
    }
unknown's avatar
unknown committed
1070
    else if (key_info->algorithm == HA_KEY_ALG_RTREE)
unknown's avatar
unknown committed
1071
    {
unknown's avatar
unknown committed
1072
#ifdef HAVE_RTREE_KEYS
1073 1074
      if ((key_info->key_parts & 1) == 1)
      {
1075
	my_error(ER_WRONG_ARGUMENTS, MYF(0), "RTREE INDEX");
1076
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
1077
      }
1078
      /* TODO: To be deleted */
1079
      my_error(ER_NOT_SUPPORTED_YET, MYF(0), "RTREE INDEX");
1080
      DBUG_RETURN(-1);
unknown's avatar
unknown committed
1081
#else
1082 1083
      my_error(ER_FEATURE_DISABLED, MYF(0),
               sym_group_rtree.name, sym_group_rtree.needed_define);
unknown's avatar
unknown committed
1084 1085
      DBUG_RETURN(-1);
#endif
unknown's avatar
unknown committed
1086
    }
1087

1088
    List_iterator<key_part_spec> cols(key->columns), cols2(key->columns);
1089
    CHARSET_INFO *ft_key_charset=0;  // for FULLTEXT
unknown's avatar
unknown committed
1090 1091
    for (uint column_nr=0 ; (column=cols++) ; column_nr++)
    {
1092
      uint length;
unknown's avatar
unknown committed
1093 1094
      key_part_spec *dup_column;

unknown's avatar
unknown committed
1095 1096 1097
      it.rewind();
      field=0;
      while ((sql_field=it++) &&
1098
	     my_strcasecmp(system_charset_info,
1099 1100
			   column->field_name,
			   sql_field->field_name))
unknown's avatar
unknown committed
1101 1102 1103
	field++;
      if (!sql_field)
      {
1104
	my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name);
unknown's avatar
unknown committed
1105 1106
	DBUG_RETURN(-1);
      }
unknown's avatar
unknown committed
1107
      while ((dup_column= cols2++) != column)
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
      {
        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();
1119
      if (key->type == Key::FULLTEXT)
1120
      {
1121 1122
	if ((sql_field->sql_type != MYSQL_TYPE_STRING &&
	     sql_field->sql_type != MYSQL_TYPE_VARCHAR &&
1123 1124
	     !f_is_blob(sql_field->pack_flag)) ||
	    sql_field->charset == &my_charset_bin ||
1125
	    sql_field->charset->mbminlen > 1 || // ucs2 doesn't work yet
1126 1127
	    (ft_key_charset && sql_field->charset != ft_key_charset))
	{
1128
	    my_error(ER_BAD_FT_COLUMN, MYF(0), column->field_name);
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
	    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));
1140
      }
1141
      else
1142
      {
1143 1144 1145 1146
	column->length*= sql_field->charset->mbmaxlen;

	if (f_is_blob(sql_field->pack_flag))
	{
unknown's avatar
unknown committed
1147
	  if (!(file->table_flags() & HA_CAN_INDEX_BLOBS))
1148
	  {
1149
	    my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name);
1150 1151 1152 1153
	    DBUG_RETURN(-1);
	  }
	  if (!column->length)
	  {
1154
	    my_error(ER_BLOB_KEY_WITHOUT_LENGTH, MYF(0), column->field_name);
1155 1156 1157
	    DBUG_RETURN(-1);
	  }
	}
unknown's avatar
unknown committed
1158
#ifdef HAVE_SPATIAL
1159
	if (key->type == Key::SPATIAL)
1160
	{
1161
	  if (!column->length)
1162 1163
	  {
	    /*
1164 1165
              4 is: (Xmin,Xmax,Ymin,Ymax), this is for 2D case
              Lately we'll extend this code to support more dimensions
1166
	    */
1167
	    column->length= 4*sizeof(double);
1168 1169
	  }
	}
unknown's avatar
unknown committed
1170
#endif
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
	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;
	  }
	  else
	     key_info->flags|= HA_NULL_PART_KEY;
unknown's avatar
unknown committed
1181
	  if (!(file->table_flags() & HA_NULL_IN_KEY))
1182
	  {
1183
	    my_error(ER_NULL_COLUMN_IN_INDEX, MYF(0), column->field_name);
1184 1185 1186 1187
	    DBUG_RETURN(-1);
	  }
	  if (key->type == Key::SPATIAL)
	  {
unknown's avatar
unknown committed
1188 1189
	    my_message(ER_SPATIAL_CANT_HAVE_NULL,
                       ER(ER_SPATIAL_CANT_HAVE_NULL), MYF(0));
1190 1191 1192 1193 1194 1195 1196 1197
	    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
	}
unknown's avatar
unknown committed
1198
      }
1199

unknown's avatar
unknown committed
1200 1201 1202
      key_part_info->fieldnr= field;
      key_part_info->offset=  (uint16) sql_field->offset;
      key_part_info->key_type=sql_field->pack_flag;
1203 1204
      length= sql_field->key_length;

unknown's avatar
unknown committed
1205 1206 1207 1208
      if (column->length)
      {
	if (f_is_blob(sql_field->pack_flag))
	{
1209 1210
	  if ((length=column->length) > file->max_key_length() ||
	      length > file->max_key_part_length())
1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227
	  {
	    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);
	    }
	  }
unknown's avatar
unknown committed
1228
	}
1229
	else if (!f_is_geom(sql_field->pack_flag) &&
1230 1231 1232 1233 1234 1235
		  (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)))
	{
unknown's avatar
unknown committed
1236
	  my_message(ER_WRONG_SUB_KEY, ER(ER_WRONG_SUB_KEY), MYF(0));
1237 1238 1239 1240
	  DBUG_RETURN(-1);
	}
	else if (!(file->table_flags() & HA_NO_PREFIX_CHAR_KEYS))
	  length=column->length;
unknown's avatar
unknown committed
1241 1242 1243
      }
      else if (length == 0)
      {
1244
	my_error(ER_WRONG_KEY_COLUMN, MYF(0), column->field_name);
unknown's avatar
unknown committed
1245 1246
	  DBUG_RETURN(-1);
      }
1247 1248
      if (length > file->max_key_part_length())
      {
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
	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);
	}
1264 1265
      }
      key_part_info->length=(uint16) length;
unknown's avatar
unknown committed
1266 1267 1268
      /* Use packed keys for long strings on the first column */
      if (!(db_options & HA_OPTION_NO_PACK_KEYS) &&
	  (length >= KEY_DEFAULT_PACK_LENGTH &&
1269 1270
	   (sql_field->sql_type == MYSQL_TYPE_STRING ||
	    sql_field->sql_type == MYSQL_TYPE_VARCHAR ||
unknown's avatar
unknown committed
1271 1272
	    sql_field->pack_flag & FIELDFLAG_BLOB)))
      {
1273 1274 1275
	if (column_nr == 0 && (sql_field->pack_flag & FIELDFLAG_BLOB) ||
            sql_field->sql_type == MYSQL_TYPE_VARCHAR)
	  key_info->flags|= HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY;
unknown's avatar
unknown committed
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
	else
	  key_info->flags|= HA_PACK_KEY;
      }
      key_length+=length;
      key_part_info++;

      /* Create the key name based on the first column (if not given) */
      if (column_nr == 0)
      {
	if (key->type == Key::PRIMARY)
1286 1287 1288
	{
	  if (primary_key)
	  {
unknown's avatar
unknown committed
1289 1290
	    my_message(ER_MULTIPLE_PRI_KEY, ER(ER_MULTIPLE_PRI_KEY),
                       MYF(0));
1291 1292 1293 1294 1295
	    DBUG_RETURN(-1);
	  }
	  key_name=primary_key_name;
	  primary_key=1;
	}
1296
	else if (!(key_name = key->name))
unknown's avatar
unknown committed
1297 1298 1299 1300
	  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))
	{
1301
	  my_error(ER_DUP_KEYNAME, MYF(0), key_name);
unknown's avatar
unknown committed
1302 1303 1304 1305 1306
	  DBUG_RETURN(-1);
	}
	key_info->name=(char*) key_name;
      }
    }
1307 1308
    if (!key_info->name || check_column_name(key_info->name))
    {
1309
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key_info->name);
1310 1311
      DBUG_RETURN(-1);
    }
1312 1313
    if (!(key_info->flags & HA_NULL_PART_KEY))
      unique_key=1;
unknown's avatar
unknown committed
1314
    key_info->key_length=(uint16) key_length;
1315
    if (key_length > max_key_length && key->type != Key::FULLTEXT)
unknown's avatar
unknown committed
1316
    {
1317
      my_error(ER_TOO_LONG_KEY,MYF(0),max_key_length);
unknown's avatar
unknown committed
1318 1319
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
1320
    key_info++;
unknown's avatar
unknown committed
1321
  }
1322
  if (!unique_key && !primary_key &&
1323
      (file->table_flags() & HA_REQUIRE_PRIMARY_KEY))
1324
  {
unknown's avatar
unknown committed
1325
    my_message(ER_REQUIRES_PRIMARY_KEY, ER(ER_REQUIRES_PRIMARY_KEY), MYF(0));
1326 1327
    DBUG_RETURN(-1);
  }
unknown's avatar
unknown committed
1328 1329
  if (auto_increment > 0)
  {
unknown's avatar
unknown committed
1330
    my_message(ER_WRONG_AUTO_KEY, ER(ER_WRONG_AUTO_KEY), MYF(0));
unknown's avatar
unknown committed
1331 1332
    DBUG_RETURN(-1);
  }
1333
  /* Sort keys in optimized order */
1334 1335
  qsort((gptr) key_info_buffer, *key_count, sizeof(KEY),
	(qsort_cmp) sort_keys);
unknown's avatar
unknown committed
1336

1337 1338 1339
  DBUG_RETURN(0);
}

1340

1341 1342 1343 1344 1345
/*
  Create a table

  SYNOPSIS
    mysql_create_table()
1346 1347 1348 1349 1350 1351
    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
unknown's avatar
unknown committed
1352
    internal_tmp_table  Set to 1 if this is an internal temporary table
1353
			(From ALTER TABLE)
1354 1355

  DESCRIPTION
1356
    If one creates a temporary table, this is automatically opened
1357 1358 1359 1360 1361 1362 1363

    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
unknown's avatar
unknown committed
1364 1365
    FALSE OK
    TRUE  error
1366 1367
*/

unknown's avatar
unknown committed
1368 1369 1370
bool mysql_create_table(THD *thd,const char *db, const char *table_name,
                        HA_CREATE_INFO *create_info,
                        List<create_field> &fields,
unknown's avatar
unknown committed
1371
                        List<Key> &keys,bool internal_tmp_table,
unknown's avatar
unknown committed
1372
                        uint select_field_count)
1373
{
1374 1375 1376 1377 1378
  char		path[FN_REFLEN];
  const char	*alias;
  uint		db_options, key_count;
  KEY		*key_info_buffer;
  handler	*file;
unknown's avatar
unknown committed
1379
  bool		error= TRUE;
1380
  enum db_type	new_db_type;
1381 1382 1383 1384 1385
  DBUG_ENTER("mysql_create_table");

  /* Check for duplicate fields and check type of table to create */
  if (!fields.elements)
  {
unknown's avatar
unknown committed
1386 1387
    my_message(ER_TABLE_MUST_HAVE_COLUMNS, ER(ER_TABLE_MUST_HAVE_COLUMNS),
               MYF(0));
unknown's avatar
unknown committed
1388
    DBUG_RETURN(TRUE);
1389 1390 1391 1392 1393 1394
  }
  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,
1395 1396 1397 1398
			ER_WARN_USING_OTHER_HANDLER,
			ER(ER_WARN_USING_OTHER_HANDLER),
			ha_get_storage_engine(new_db_type),
			table_name);
1399 1400 1401 1402 1403 1404 1405
  }
  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);

unknown's avatar
unknown committed
1406 1407 1408 1409 1410 1411 1412 1413
#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
  */
1414 1415 1416
  if ((create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
      (file->table_flags() & HA_NO_TEMP_TABLES))
  {
1417
    my_error(ER_ILLEGAL_HA, MYF(0), table_name);
unknown's avatar
unknown committed
1418
    DBUG_RETURN(TRUE);
1419
  }
unknown's avatar
unknown committed
1420
#endif
1421

1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
  /*
    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;
    uint length;
    char  path[FN_REFLEN];
unknown's avatar
unknown committed
1432
    strxmov(path, mysql_data_home, "/", db, NullS);
1433 1434 1435 1436 1437 1438
    length= unpack_dirname(path,path);             // Convert if not unix
    strmov(path+length, MY_DB_OPT_FILE);
    load_db_opt(thd, path, &db_info);
    create_info->default_table_charset= db_info.default_table_charset;
  }

1439
  if (mysql_prepare_table(thd, create_info, fields,
unknown's avatar
unknown committed
1440
			  keys, internal_tmp_table, db_options, file,
1441 1442
			  key_info_buffer, &key_count,
			  select_field_count))
unknown's avatar
unknown committed
1443
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
1444 1445 1446 1447

      /* Check if table exists */
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
1448 1449 1450
    my_snprintf(path, sizeof(path), "%s%s%lx_%lx_%x%s",
		mysql_tmpdir, tmp_file_prefix, current_pid, thd->thread_id,
		thd->tmp_table++, reg_ext);
1451 1452
    if (lower_case_table_names)
      my_casedn_str(files_charset_info, path);
unknown's avatar
unknown committed
1453 1454 1455
    create_info->table_options|=HA_CREATE_DELAY_KEY_WRITE;
  }
  else
1456 1457
    my_snprintf(path, sizeof(path), "%s/%s/%s%s", mysql_data_home, db,
		alias, reg_ext);
unknown's avatar
unknown committed
1458 1459 1460 1461 1462
  unpack_filename(path,path);
  /* Check if table already exists */
  if ((create_info->options & HA_LEX_CREATE_TMP_TABLE)
      && find_temporary_table(thd,db,table_name))
  {
1463
    if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
1464 1465
    {
      create_info->table_existed= 1;		// Mark that table existed
unknown's avatar
unknown committed
1466
      DBUG_RETURN(FALSE);
1467
    }
unknown's avatar
unknown committed
1468
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), alias);
unknown's avatar
unknown committed
1469
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
1470
  }
unknown's avatar
unknown committed
1471
  if (wait_if_global_read_lock(thd, 0, 1))
1472
    DBUG_RETURN(error);
unknown's avatar
unknown committed
1473
  VOID(pthread_mutex_lock(&LOCK_open));
unknown's avatar
unknown committed
1474
  if (!internal_tmp_table && !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
unknown's avatar
unknown committed
1475 1476 1477 1478
  {
    if (!access(path,F_OK))
    {
      if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
1479 1480
      {
	create_info->table_existed= 1;		// Mark that table existed
unknown's avatar
unknown committed
1481
	error= FALSE;
1482
      }
1483
      else
1484
	my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
1485
      goto end;
unknown's avatar
unknown committed
1486 1487 1488
    }
  }

unknown's avatar
unknown committed
1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501
  /*
    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;
1502 1503
    if (!ha_create_table_from_engine(thd, db, table_name,
				     create_if_not_exists))
unknown's avatar
unknown committed
1504 1505 1506 1507 1508 1509
    {
      DBUG_PRINT("info", ("Table already existed in handler"));

      if (create_if_not_exists)
      {
       create_info->table_existed= 1;   // Mark that table existed
unknown's avatar
unknown committed
1510
       error= FALSE;
unknown's avatar
unknown committed
1511
      }
1512
      else
1513
       my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
1514
      goto end;
unknown's avatar
unknown committed
1515 1516 1517 1518
    }
  }

  thd->proc_info="creating table";
1519
  create_info->table_existed= 0;		// Mark that table is created
unknown's avatar
unknown committed
1520

unknown's avatar
unknown committed
1521
  if (thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE)
1522
    create_info->data_file_name= create_info->index_file_name= 0;
unknown's avatar
unknown committed
1523
  create_info->table_options=db_options;
1524

1525
  if (rea_create_table(thd, path, create_info, fields, key_count,
unknown's avatar
unknown committed
1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538
		       key_info_buffer))
  {
    /* 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;
    }
unknown's avatar
unknown committed
1539
    thd->tmp_table_used= 1;
unknown's avatar
unknown committed
1540
  }
unknown's avatar
unknown committed
1541
  if (!internal_tmp_table && mysql_bin_log.is_open())
1542
  {
unknown's avatar
unknown committed
1543
    thd->clear_error();
unknown's avatar
unknown committed
1544
    Query_log_event qinfo(thd, thd->query, thd->query_length, FALSE, FALSE);
1545
    mysql_bin_log.write(&qinfo);
1546
  }
unknown's avatar
unknown committed
1547
  error= FALSE;
unknown's avatar
unknown committed
1548

unknown's avatar
unknown committed
1549 1550
end:
  VOID(pthread_mutex_unlock(&LOCK_open));
1551
  start_waiting_global_read_lock(thd);
unknown's avatar
unknown committed
1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
  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++)
1564
    if (!my_strcasecmp(system_charset_info,name,key->name))
unknown's avatar
unknown committed
1565 1566 1567 1568 1569 1570 1571 1572 1573 1574
      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;

1575 1576
  if (!check_if_keyname_exists(field_name,start,end) &&
      my_strcasecmp(system_charset_info,field_name,primary_key_name))
unknown's avatar
unknown committed
1577
    return (char*) field_name;			// Use fieldname
1578 1579 1580 1581 1582 1583
  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
  */
1584
  for (uint i=2 ; i< 100; i++)
unknown's avatar
unknown committed
1585
  {
1586 1587
    *buff_end= '_';
    int10_to_str(i, buff_end+1, 10);
unknown's avatar
unknown committed
1588 1589 1590
    if (!check_if_keyname_exists(buff,start,end))
      return sql_strdup(buff);
  }
1591
  return (char*) "not_specified";		// Should never happen
unknown's avatar
unknown committed
1592 1593
}

1594

unknown's avatar
unknown committed
1595 1596 1597 1598 1599
/****************************************************************************
** Create table from a list of fields and items
****************************************************************************/

TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
unknown's avatar
VIEW  
unknown committed
1600
			       TABLE_LIST *create_table,
unknown's avatar
unknown committed
1601 1602 1603 1604 1605 1606
			       List<create_field> *extra_fields,
			       List<Key> *keys,
			       List<Item> *items,
			       MYSQL_LOCK **lock)
{
  TABLE tmp_table;		// Used during 'create_field()'
1607
  TABLE *table= 0;
1608
  uint select_field_count= items->elements;
unknown's avatar
unknown committed
1609
  /* Add selected items to field list */
unknown's avatar
unknown committed
1610
  List_iterator_fast<Item> it(*items);
unknown's avatar
unknown committed
1611 1612
  Item *item;
  Field *tmp_field;
1613 1614 1615 1616 1617 1618 1619 1620
  DBUG_ENTER("create_table_from_items");

  tmp_table.alias= 0;
  tmp_table.s= &tmp_table.share_not_to_be_used;
  tmp_table.s->db_create_options=0;
  tmp_table.s->blob_ptr_size= portable_sizeof_char_ptr;
  tmp_table.s->db_low_byte_first= test(create_info->db_type == DB_TYPE_MYISAM ||
                                       create_info->db_type == DB_TYPE_HEAP);
unknown's avatar
unknown committed
1621 1622 1623 1624 1625
  tmp_table.null_row=tmp_table.maybe_null=0;

  while ((item=it++))
  {
    create_field *cr_field;
1626 1627 1628 1629 1630
    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(),
unknown's avatar
unknown committed
1631
                             (Item ***) 0, &tmp_field,0,0,0);
1632 1633
    if (!field ||
	!(cr_field=new create_field(field,(item->type() == Item::FIELD_ITEM ?
1634 1635
					   ((Item_field *)item)->field :
					   (Field*) 0))))
unknown's avatar
unknown committed
1636
      DBUG_RETURN(0);
unknown's avatar
unknown committed
1637 1638
    if (item->maybe_null)
      cr_field->flags &= ~NOT_NULL_FLAG;
unknown's avatar
unknown committed
1639 1640
    extra_fields->push_back(cr_field);
  }
1641
  /*
unknown's avatar
unknown committed
1642 1643
    create and lock table

1644
    We don't log the statement, it will be logged later.
unknown's avatar
unknown committed
1645

1646 1647 1648 1649
    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
1650 1651
    TABLE, which is a wrong order. So we keep binary logging disabled when we
    open_table().
unknown's avatar
unknown committed
1652
    TODO: create and open should be done atomic !
1653
  */
unknown's avatar
unknown committed
1654
  {
unknown's avatar
unknown committed
1655
    tmp_disable_binlog(thd);
1656
    if (!mysql_create_table(thd, create_table->db, create_table->table_name,
unknown's avatar
unknown committed
1657 1658 1659
                            create_info, *extra_fields, *keys, 0,
                            select_field_count))
    {
unknown's avatar
unknown committed
1660
      if (!(table= open_table(thd, create_table, thd->mem_root, (bool*) 0)))
unknown's avatar
unknown committed
1661
        quick_rm_table(create_info->db_type, create_table->db,
1662
                       table_case_name(create_info, create_table->table_name));
unknown's avatar
unknown committed
1663 1664 1665 1666
    }
    reenable_binlog(thd);
    if (!table)                                   // open failed
      DBUG_RETURN(0);
unknown's avatar
unknown committed
1667
  }
unknown's avatar
unknown committed
1668

unknown's avatar
unknown committed
1669
  table->reginfo.lock_type=TL_WRITE;
unknown's avatar
VIEW  
unknown committed
1670
  if (!((*lock)= mysql_lock_tables(thd, &table,1)))
unknown's avatar
unknown committed
1671
  {
1672
    VOID(pthread_mutex_lock(&LOCK_open));
unknown's avatar
unknown committed
1673
    hash_delete(&open_cache,(byte*) table);
1674
    VOID(pthread_mutex_unlock(&LOCK_open));
unknown's avatar
VIEW  
unknown committed
1675
    quick_rm_table(create_info->db_type, create_table->db,
1676
		   table_case_name(create_info, create_table->table_name));
unknown's avatar
unknown committed
1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687
    DBUG_RETURN(0);
  }
  table->file->extra(HA_EXTRA_WRITE_CACHE);
  DBUG_RETURN(table);
}


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

1688
bool
unknown's avatar
unknown committed
1689 1690
mysql_rename_table(enum db_type base,
		   const char *old_db,
unknown's avatar
unknown committed
1691
		   const char *old_name,
unknown's avatar
unknown committed
1692
		   const char *new_db,
unknown's avatar
unknown committed
1693
		   const char *new_name)
unknown's avatar
unknown committed
1694
{
unknown's avatar
unknown committed
1695 1696
  char from[FN_REFLEN], to[FN_REFLEN];
  char tmp_from[NAME_LEN+1], tmp_to[NAME_LEN+1];
1697
  handler *file=(base == DB_TYPE_UNKNOWN ? 0 : get_new_handler((TABLE*) 0, base));
unknown's avatar
unknown committed
1698
  int error=0;
unknown's avatar
unknown committed
1699
  DBUG_ENTER("mysql_rename_table");
unknown's avatar
unknown committed
1700

1701 1702
  if (lower_case_table_names == 2 && file &&
      !(file->table_flags() & HA_FILE_BASED))
unknown's avatar
unknown committed
1703 1704 1705
  {
    /* Table handler expects to get all file names as lower case */
    strmov(tmp_from, old_name);
1706
    my_casedn_str(files_charset_info, tmp_from);
unknown's avatar
unknown committed
1707 1708 1709
    old_name= tmp_from;

    strmov(tmp_to, new_name);
1710
    my_casedn_str(files_charset_info, tmp_to);
unknown's avatar
unknown committed
1711 1712
    new_name= tmp_to;
  }
1713 1714 1715 1716
  my_snprintf(from, sizeof(from), "%s/%s/%s",
	      mysql_data_home, old_db, old_name);
  my_snprintf(to, sizeof(to), "%s/%s/%s",
	      mysql_data_home, new_db, new_name);
unknown's avatar
unknown committed
1717 1718
  fn_format(from,from,"","",4);
  fn_format(to,to,    "","",4);
unknown's avatar
unknown committed
1719

1720 1721
  if (!file ||
      !(error=file->rename_table((const char*) from,(const char *) to)))
1722 1723 1724
  {
    if (rename_file_ext(from,to,reg_ext))
    {
unknown's avatar
unknown committed
1725
      error=my_errno;
1726
      /* Restore old file name */
1727 1728
      if (file)
        file->rename_table((const char*) to,(const char *) from);
1729 1730
    }
  }
unknown's avatar
unknown committed
1731
  delete file;
unknown's avatar
unknown committed
1732 1733 1734
  if (error)
    my_error(ER_ERROR_ON_RENAME, MYF(0), from, to, error);
  DBUG_RETURN(error != 0);
unknown's avatar
unknown committed
1735 1736
}

unknown's avatar
unknown committed
1737

unknown's avatar
unknown committed
1738
/*
1739 1740 1741 1742 1743 1744
  Force all other threads to stop using the table

  SYNOPSIS
    wait_while_table_is_used()
    thd			Thread handler
    table		Table to remove from cache
1745
    function		HA_EXTRA_PREPARE_FOR_DELETE if table is to be deleted
1746
			HA_EXTRA_FORCE_REOPEN if table is not be used
1747 1748 1749 1750 1751 1752 1753
  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 !
unknown's avatar
unknown committed
1754 1755
*/

1756 1757
static void wait_while_table_is_used(THD *thd,TABLE *table,
				     enum ha_extra_function function)
unknown's avatar
unknown committed
1758
{
1759
  DBUG_PRINT("enter",("table: %s", table->s->table_name));
1760 1761
  DBUG_ENTER("wait_while_table_is_used");
  safe_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
1762

1763
  VOID(table->file->extra(function));
1764 1765 1766 1767
  /* Mark all tables that are in use as 'old' */
  mysql_lock_abort(thd, table);			// end threads waiting on lock

  /* Wait until all there are no other threads that has this table open */
1768
  while (remove_table_from_cache(thd, table->s->db, table->s->table_name))
unknown's avatar
unknown committed
1769
  {
1770 1771 1772
    dropping_tables++;
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
    dropping_tables--;
1773 1774 1775
  }
  DBUG_VOID_RETURN;
}
unknown's avatar
unknown committed
1776

1777 1778
/*
  Close a cached table
unknown's avatar
unknown committed
1779

1780
  SYNOPSIS
unknown's avatar
unknown committed
1781
    close_cached_table()
1782 1783 1784 1785 1786 1787
    thd			Thread handler
    table		Table to remove from cache

  NOTES
    Function ends by signaling threads waiting for the table to try to
    reopen the table.
unknown's avatar
unknown committed
1788

1789 1790 1791 1792
  PREREQUISITES
    Lock on LOCK_open
    Win32 clients must also have a WRITE LOCK on the table !
*/
1793

1794
void close_cached_table(THD *thd, TABLE *table)
1795 1796
{
  DBUG_ENTER("close_cached_table");
1797

1798
  wait_while_table_is_used(thd, table, HA_EXTRA_PREPARE_FOR_DELETE);
1799 1800
  /* Close lock if this is not got with LOCK TABLES */
  if (thd->lock)
1801
  {
1802 1803
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;			// Start locked threads
unknown's avatar
unknown committed
1804
  }
1805 1806 1807 1808 1809
  /* 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);
unknown's avatar
unknown committed
1810
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1811 1812
}

1813
static int send_check_errmsg(THD *thd, TABLE_LIST* table,
unknown's avatar
unknown committed
1814
			     const char* operator_name, const char* errmsg)
1815

unknown's avatar
unknown committed
1816
{
1817 1818
  Protocol *protocol= thd->protocol;
  protocol->prepare_for_resend();
1819 1820 1821 1822
  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);
unknown's avatar
unknown committed
1823
  thd->clear_error();
1824
  if (protocol->write())
unknown's avatar
unknown committed
1825 1826 1827 1828
    return -1;
  return 1;
}

1829

unknown's avatar
unknown committed
1830
static int prepare_for_restore(THD* thd, TABLE_LIST* table,
1831
			       HA_CHECK_OPT *check_opt)
unknown's avatar
unknown committed
1832
{
unknown's avatar
unknown committed
1833
  DBUG_ENTER("prepare_for_restore");
1834

unknown's avatar
unknown committed
1835 1836 1837 1838 1839 1840
  if (table->table) // do not overwrite existing tables on restore
  {
    DBUG_RETURN(send_check_errmsg(thd, table, "restore",
				  "table exists, will not overwrite on restore"
				  ));
  }
unknown's avatar
unknown committed
1841
  else
unknown's avatar
unknown committed
1842
  {
1843
    char* backup_dir= thd->lex->backup_dir;
unknown's avatar
unknown committed
1844
    char src_path[FN_REFLEN], dst_path[FN_REFLEN];
1845
    char* table_name = table->table_name;
unknown's avatar
unknown committed
1846
    char* db = thd->db ? thd->db : table->db;
1847

1848 1849
    if (fn_format_relative_to_data_home(src_path, table_name, backup_dir,
					reg_ext))
unknown's avatar
unknown committed
1850
      DBUG_RETURN(-1); // protect buffer overflow
unknown's avatar
unknown committed
1851

1852
    my_snprintf(dst_path, sizeof(dst_path), "%s%s/%s",
1853
		mysql_real_data_home, db, table_name);
1854

1855
    if (lock_and_wait_for_table_name(thd,table))
unknown's avatar
unknown committed
1856
      DBUG_RETURN(-1);
1857

1858
    if (my_copy(src_path,
1859 1860
		fn_format(dst_path, dst_path,"", reg_ext, 4),
		MYF(MY_WME)))
unknown's avatar
unknown committed
1861
    {
1862
      pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
1863
      unlock_table_name(thd, table);
1864
      pthread_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
1865 1866 1867
      DBUG_RETURN(send_check_errmsg(thd, table, "restore",
				    "Failed copying .frm file"));
    }
1868
    if (mysql_truncate(thd, table, 1))
unknown's avatar
unknown committed
1869
    {
1870
      pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
1871
      unlock_table_name(thd, table);
1872
      pthread_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
1873 1874
      DBUG_RETURN(send_check_errmsg(thd, table, "restore",
				    "Failed generating table from .frm file"));
unknown's avatar
unknown committed
1875
    }
unknown's avatar
unknown committed
1876
  }
unknown's avatar
unknown committed
1877

1878 1879 1880 1881
  /*
    Now we should be able to open the partially restored table
    to finish the restore in the handler later on
  */
unknown's avatar
unknown committed
1882
  if (!(table->table = reopen_name_locked_table(thd, table)))
1883 1884
  {
    pthread_mutex_lock(&LOCK_open);
1885
    unlock_table_name(thd, table);
1886 1887
    pthread_mutex_unlock(&LOCK_open);
  }
unknown's avatar
unknown committed
1888
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1889
}
1890

1891

unknown's avatar
unknown committed
1892
static int prepare_for_repair(THD* thd, TABLE_LIST *table_list,
1893
			      HA_CHECK_OPT *check_opt)
unknown's avatar
unknown committed
1894
{
unknown's avatar
unknown committed
1895 1896
  int error= 0;
  TABLE tmp_table, *table;
unknown's avatar
unknown committed
1897 1898 1899 1900
  DBUG_ENTER("prepare_for_repair");

  if (!(check_opt->sql_flags & TT_USEFRM))
    DBUG_RETURN(0);
unknown's avatar
unknown committed
1901 1902

  if (!(table= table_list->table))		/* if open_ltable failed */
unknown's avatar
unknown committed
1903
  {
unknown's avatar
unknown committed
1904 1905
    char name[FN_REFLEN];
    strxmov(name, mysql_data_home, "/", table_list->db, "/",
1906
	    table_list->table_name, NullS);
1907
    if (openfrm(thd, name, "", 0, 0, 0, &tmp_table))
unknown's avatar
unknown committed
1908 1909
      DBUG_RETURN(0);				// Can't open frm file
    table= &tmp_table;
1910
  }
unknown's avatar
unknown committed
1911

unknown's avatar
unknown committed
1912 1913 1914 1915 1916 1917 1918 1919 1920
  /*
    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
  */
unknown's avatar
unknown committed
1921

unknown's avatar
unknown committed
1922 1923 1924
  char from[FN_REFLEN],tmp[FN_REFLEN+32];
  const char **ext= table->file->bas_ext();
  MY_STAT stat_info;
unknown's avatar
unknown committed
1925

unknown's avatar
unknown committed
1926 1927 1928 1929 1930 1931
  /*
    Check if this is a table type that stores index and data separately,
    like ISAM or MyISAM
  */
  if (!ext[0] || !ext[1])
    goto end;					// No data file
unknown's avatar
unknown committed
1932

1933
  strxmov(from, table->s->path, ext[1], NullS);	// Name of data file
unknown's avatar
unknown committed
1934 1935
  if (!my_stat(from, &stat_info, MYF(0)))
    goto end;				// Can't use USE_FRM flag
unknown's avatar
unknown committed
1936

1937 1938
  my_snprintf(tmp, sizeof(tmp), "%s-%lx_%lx",
	      from, current_pid, thd->thread_id);
unknown's avatar
unknown committed
1939

1940 1941 1942 1943 1944 1945 1946
  /* 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);
  }
unknown's avatar
unknown committed
1947
  if (lock_and_wait_for_table_name(thd,table_list))
unknown's avatar
unknown committed
1948
  {
unknown's avatar
unknown committed
1949 1950
    error= -1;
    goto end;
unknown's avatar
unknown committed
1951
  }
unknown's avatar
unknown committed
1952
  if (my_rename(from, tmp, MYF(MY_WME)))
unknown's avatar
unknown committed
1953
  {
1954
    pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
1955
    unlock_table_name(thd, table_list);
1956
    pthread_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977
    error= send_check_errmsg(thd, table_list, "repair",
			     "Failed renaming data file");
    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",
			     "Failed generating table from .frm file");
    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",
			     "Failed restoring .MYD file");
    goto end;
unknown's avatar
unknown committed
1978 1979
  }

1980 1981 1982 1983
  /*
    Now we should be able to open the partially repaired table
    to finish the repair in the handler later on.
  */
unknown's avatar
unknown committed
1984
  if (!(table_list->table = reopen_name_locked_table(thd, table_list)))
unknown's avatar
unknown committed
1985 1986
  {
    pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
1987
    unlock_table_name(thd, table_list);
unknown's avatar
unknown committed
1988 1989
    pthread_mutex_unlock(&LOCK_open);
  }
unknown's avatar
unknown committed
1990 1991 1992 1993 1994

end:
  if (table == &tmp_table)
    closefrm(table);				// Free allocated memory
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1995
}
1996

1997

unknown's avatar
unknown committed
1998 1999
/*
  RETURN VALUES
unknown's avatar
merge  
unknown committed
2000 2001 2002
    FALSE Message sent to net (admin operation went ok)
    TRUE  Message should be sent by caller 
          (admin operation or network communication failed)
unknown's avatar
unknown committed
2003
*/
unknown's avatar
unknown committed
2004 2005 2006 2007 2008
static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
                              HA_CHECK_OPT* check_opt,
                              const char *operator_name,
                              thr_lock_type lock_type,
                              bool open_for_modify,
2009
                              bool no_warnings_for_error,
unknown's avatar
unknown committed
2010 2011 2012
                              uint extra_open_options,
                              int (*prepare_func)(THD *, TABLE_LIST *,
                                                  HA_CHECK_OPT *),
unknown's avatar
unknown committed
2013 2014 2015
                              int (handler::*operator_func)(THD *,
                                                            HA_CHECK_OPT *),
                              int (view_operator_func)(THD *, TABLE_LIST*))
unknown's avatar
unknown committed
2016
{
2017
  TABLE_LIST *table, *next_global_table;
unknown's avatar
unknown committed
2018
  List<Item> field_list;
2019 2020
  Item *item;
  Protocol *protocol= thd->protocol;
2021
  int result_code;
2022
  DBUG_ENTER("mysql_admin_table");
unknown's avatar
unknown committed
2023 2024 2025 2026 2027 2028 2029 2030 2031

  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;
2032 2033
  if (protocol->send_fields(&field_list,
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
unknown's avatar
unknown committed
2034
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2035

2036
  mysql_ha_flush(thd, tables, MYSQL_HA_CLOSE_FINAL);
unknown's avatar
VIEW  
unknown committed
2037
  for (table= tables; table; table= table->next_local)
unknown's avatar
unknown committed
2038 2039
  {
    char table_name[NAME_LEN*2+2];
2040
    char* db = table->db;
2041
    bool fatal_error=0;
unknown's avatar
unknown committed
2042

unknown's avatar
unknown committed
2043
    strxmov(table_name, db, ".", table->table_name, NullS);
unknown's avatar
unknown committed
2044
    thd->open_options|= extra_open_options;
2045 2046 2047 2048
    table->lock_type= lock_type;
    /* open only one table from local list of command */
    next_global_table= table->next_global;
    table->next_global= 0;
2049
    thd->no_warnings_for_error= no_warnings_for_error;
2050
    open_and_lock_tables(thd, table);
2051
    thd->no_warnings_for_error= 0;
2052 2053 2054 2055 2056 2057 2058
    table->next_global= next_global_table;
    /* if view are unsupported */
    if (table->view && !view_operator_func)
    {
      result_code= HA_ADMIN_NOT_IMPLEMENTED;
      goto send_result;
    }
unknown's avatar
unknown committed
2059
    thd->open_options&= ~extra_open_options;
2060

unknown's avatar
unknown committed
2061
    if (prepare_func)
2062
    {
unknown's avatar
unknown committed
2063
      switch ((*prepare_func)(thd, table, check_opt)) {
2064 2065 2066 2067 2068 2069 2070
      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
        ;
unknown's avatar
unknown committed
2071
      }
2072
    }
2073

2074
    /*
unknown's avatar
unknown committed
2075 2076 2077 2078 2079 2080
      CHECK TABLE command is only command where VIEW allowed here and this
      command use only temporary teble method for VIEWs resolving => there
      can't be VIEW tree substitition of join view => if opening table
      succeed then table->table will have real TABLE pointer as value (in
      case of join view substitution table->table can be 0, but here it is
      impossible)
2081
    */
unknown's avatar
unknown committed
2082 2083
    if (!table->table)
    {
unknown's avatar
unknown committed
2084
      char buf[ERRMSGSIZE+ERRMSGSIZE+2];
unknown's avatar
unknown committed
2085
      const char *err_msg;
2086
      protocol->prepare_for_resend();
2087 2088 2089
      protocol->store(table_name, system_charset_info);
      protocol->store(operator_name, system_charset_info);
      protocol->store("error",5, system_charset_info);
unknown's avatar
unknown committed
2090 2091
      if (!(err_msg=thd->net.last_error))
	err_msg=ER(ER_CHECK_NO_SUCH_TABLE);
2092 2093 2094 2095
      /* if it was a view will check md5 sum */
      if (table->view &&
          view_checksum(thd, table) == HA_ADMIN_WRONG_CHECKSUM)
      {
unknown's avatar
unknown committed
2096
        strxmov(buf, err_msg, "; ", ER(ER_VIEW_CHECKSUM), NullS);
2097 2098
        err_msg= (const char *)buf;
      }
2099
      protocol->store(err_msg, system_charset_info);
unknown's avatar
unknown committed
2100
      thd->clear_error();
2101
      if (protocol->write())
unknown's avatar
unknown committed
2102 2103 2104
	goto err;
      continue;
    }
2105 2106 2107 2108 2109 2110 2111

    if (table->view)
    {
      result_code= (*view_operator_func)(thd, table);
      goto send_result;
    }

unknown's avatar
unknown committed
2112
    table->table->pos_in_table_list= table;
2113
    if ((table->table->db_stat & HA_READ_ONLY) && open_for_modify)
unknown's avatar
unknown committed
2114
    {
unknown's avatar
unknown committed
2115
      char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
2116
      protocol->prepare_for_resend();
2117 2118 2119
      protocol->store(table_name, system_charset_info);
      protocol->store(operator_name, system_charset_info);
      protocol->store("error", 5, system_charset_info);
2120
      my_snprintf(buff, sizeof(buff), ER(ER_OPEN_AS_READONLY), table_name);
2121
      protocol->store(buff, system_charset_info);
2122
      close_thread_tables(thd);
unknown's avatar
unknown committed
2123
      table->table=0;				// For query cache
2124
      if (protocol->write())
unknown's avatar
unknown committed
2125 2126 2127 2128
	goto err;
      continue;
    }

2129
    /* Close all instances of the table to allow repair to rename files */
2130
    if (lock_type == TL_WRITE && table->table->s->version)
2131 2132
    {
      pthread_mutex_lock(&LOCK_open);
2133 2134
      const char *old_message=thd->enter_cond(&COND_refresh, &LOCK_open,
					      "Waiting to get writelock");
2135
      mysql_lock_abort(thd,table->table);
2136 2137
      while (remove_table_from_cache(thd, table->table->s->db,
				     table->table->s->table_name) &&
2138 2139 2140 2141 2142 2143
	     ! thd->killed)
      {
	dropping_tables++;
	(void) pthread_cond_wait(&COND_refresh,&LOCK_open);
	dropping_tables--;
      }
2144
      thd->exit_cond(old_message);
2145 2146
      if (thd->killed)
	goto err;
unknown's avatar
unknown committed
2147
      open_for_modify=0;
2148 2149
    }

2150 2151 2152 2153
    result_code = (table->table->file->*operator_func)(thd, check_opt);

send_result:

unknown's avatar
unknown committed
2154
    thd->clear_error();  // these errors shouldn't get client
2155
    protocol->prepare_for_resend();
2156 2157
    protocol->store(table_name, system_charset_info);
    protocol->store(operator_name, system_charset_info);
unknown's avatar
unknown committed
2158

2159 2160 2161
send_result_message:

    DBUG_PRINT("info", ("result_code: %d", result_code));
2162 2163
    switch (result_code) {
    case HA_ADMIN_NOT_IMPLEMENTED:
2164
      {
2165 2166
	char buf[ERRMSGSIZE+20];
	uint length=my_snprintf(buf, ERRMSGSIZE,
2167
				ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);
2168
	protocol->store("note", 4, system_charset_info);
2169
	protocol->store(buf, length, system_charset_info);
2170
      }
unknown's avatar
unknown committed
2171 2172
      break;

2173
    case HA_ADMIN_OK:
2174 2175
      protocol->store("status", 6, system_charset_info);
      protocol->store("OK",2, system_charset_info);
unknown's avatar
unknown committed
2176 2177
      break;

2178
    case HA_ADMIN_FAILED:
2179 2180
      protocol->store("status", 6, system_charset_info);
      protocol->store("Operation failed",16, system_charset_info);
unknown's avatar
unknown committed
2181 2182
      break;

unknown's avatar
unknown committed
2183 2184 2185
    case HA_ADMIN_REJECT:
      protocol->store("status", 6, system_charset_info);
      protocol->store("Operation need committed state",30, system_charset_info);
unknown's avatar
unknown committed
2186
      open_for_modify= FALSE;
unknown's avatar
unknown committed
2187 2188
      break;

2189
    case HA_ADMIN_ALREADY_DONE:
2190 2191
      protocol->store("status", 6, system_charset_info);
      protocol->store("Table is already up to date", 27, system_charset_info);
2192 2193
      break;

2194
    case HA_ADMIN_CORRUPT:
2195
      protocol->store("error", 5, system_charset_info);
2196
      protocol->store("Corrupt", 7, system_charset_info);
2197
      fatal_error=1;
unknown's avatar
unknown committed
2198 2199
      break;

unknown's avatar
unknown committed
2200
    case HA_ADMIN_INVALID:
2201 2202
      protocol->store("error", 5, system_charset_info);
      protocol->store("Invalid argument",16, system_charset_info);
unknown's avatar
unknown committed
2203 2204
      break;

2205 2206 2207 2208 2209 2210 2211 2212
    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);
unknown's avatar
VIEW  
unknown committed
2213 2214 2215
      TABLE_LIST *save_next_local= table->next_local,
                 *save_next_global= table->next_global;
      table->next_local= table->next_global= 0;
2216
      result_code= mysql_recreate_table(thd, table, 0);
unknown's avatar
unknown committed
2217
      close_thread_tables(thd);
2218 2219 2220 2221 2222 2223 2224
      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
      }
      result_code= result_code ? HA_ADMIN_FAILED : HA_ADMIN_OK;
unknown's avatar
VIEW  
unknown committed
2225 2226
      table->next_local= save_next_local;
      table->next_global= save_next_global;
2227 2228
      goto send_result_message;
    }
2229 2230 2231
    case HA_ADMIN_WRONG_CHECKSUM:
    {
      protocol->store("note", 4, system_charset_info);
unknown's avatar
unknown committed
2232 2233
      protocol->store(ER(ER_VIEW_CHECKSUM), strlen(ER(ER_VIEW_CHECKSUM)),
                      system_charset_info);
2234 2235
      break;
    }
2236

2237
    default:				// Probably HA_ADMIN_INTERNAL_ERROR
2238 2239 2240
      protocol->store("error", 5, system_charset_info);
      protocol->store("Unknown - internal error during operation", 41
		      , system_charset_info);
2241
      fatal_error=1;
unknown's avatar
unknown committed
2242 2243
      break;
    }
2244
    if (fatal_error)
2245
      table->table->s->version=0;               // Force close of table
unknown's avatar
unknown committed
2246
    else if (open_for_modify)
2247
    {
2248
      pthread_mutex_lock(&LOCK_open);
2249 2250
      remove_table_from_cache(thd, table->table->s->db,
			      table->table->s->table_name);
2251
      pthread_mutex_unlock(&LOCK_open);
2252 2253 2254
      /* May be something modified consequently we have to invalidate cache */
      query_cache_invalidate3(thd, table->table, 0);
    }
unknown's avatar
unknown committed
2255
    close_thread_tables(thd);
unknown's avatar
unknown committed
2256
    table->table=0;				// For query cache
2257
    if (protocol->write())
unknown's avatar
unknown committed
2258 2259 2260
      goto err;
  }

2261
  send_eof(thd);
unknown's avatar
unknown committed
2262
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
2263
 err:
2264
  close_thread_tables(thd);			// Shouldn't be needed
unknown's avatar
unknown committed
2265 2266
  if (table)
    table->table=0;
unknown's avatar
unknown committed
2267
  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2268 2269
}

unknown's avatar
unknown committed
2270

unknown's avatar
unknown committed
2271
bool mysql_backup_table(THD* thd, TABLE_LIST* table_list)
unknown's avatar
unknown committed
2272 2273 2274
{
  DBUG_ENTER("mysql_backup_table");
  DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
2275
				"backup", TL_READ, 0, 0, 0, 0,
2276
				&handler::backup, 0));
unknown's avatar
unknown committed
2277
}
unknown's avatar
unknown committed
2278

2279

unknown's avatar
unknown committed
2280
bool mysql_restore_table(THD* thd, TABLE_LIST* table_list)
unknown's avatar
unknown committed
2281 2282 2283
{
  DBUG_ENTER("mysql_restore_table");
  DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
2284
				"restore", TL_WRITE, 1, 1, 0,
2285
				&prepare_for_restore,
2286
				&handler::restore, 0));
unknown's avatar
unknown committed
2287
}
unknown's avatar
unknown committed
2288

2289

unknown's avatar
unknown committed
2290
bool mysql_repair_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
2291 2292 2293
{
  DBUG_ENTER("mysql_repair_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
2294 2295 2296
				"repair", TL_WRITE, 1,
                                test(check_opt->sql_flags & TT_USEFRM),
                                HA_OPEN_FOR_REPAIR,
2297
				&prepare_for_repair,
2298
				&handler::repair, 0));
2299 2300
}

2301

unknown's avatar
unknown committed
2302
bool mysql_optimize_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
2303 2304 2305
{
  DBUG_ENTER("mysql_optimize_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
2306
				"optimize", TL_WRITE, 1,0,0,0,
2307
				&handler::optimize, 0));
2308 2309 2310
}


unknown's avatar
unknown committed
2311 2312 2313 2314 2315
/*
  Assigned specified indexes for a table into key cache

  SYNOPSIS
    mysql_assign_to_keycache()
2316 2317
    thd		Thread object
    tables	Table list (one table only)
unknown's avatar
unknown committed
2318 2319

  RETURN VALUES
unknown's avatar
unknown committed
2320 2321
   FALSE ok
   TRUE  error
unknown's avatar
unknown committed
2322 2323
*/

unknown's avatar
unknown committed
2324
bool mysql_assign_to_keycache(THD* thd, TABLE_LIST* tables,
2325
			     LEX_STRING *key_cache_name)
unknown's avatar
unknown committed
2326
{
2327
  HA_CHECK_OPT check_opt;
unknown's avatar
unknown committed
2328
  KEY_CACHE *key_cache;
unknown's avatar
unknown committed
2329
  DBUG_ENTER("mysql_assign_to_keycache");
2330 2331 2332 2333 2334 2335 2336

  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);
unknown's avatar
unknown committed
2337
    DBUG_RETURN(TRUE);
2338 2339 2340 2341
  }
  pthread_mutex_unlock(&LOCK_global_system_variables);
  check_opt.key_cache= key_cache;
  DBUG_RETURN(mysql_admin_table(thd, tables, &check_opt,
2342
				"assign_to_keycache", TL_READ_NO_INSERT, 0, 0,
2343
				0, 0, &handler::assign_to_keycache, 0));
unknown's avatar
unknown committed
2344 2345
}

unknown's avatar
unknown committed
2346 2347 2348 2349 2350 2351

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

  SYNOPSIS
    reassign_keycache_tables()
2352 2353 2354
    thd		Thread object
    src_cache	Reference to the key cache to clean up
    dest_cache	New key cache
unknown's avatar
unknown committed
2355

2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368
  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
unknown's avatar
unknown committed
2369 2370 2371
    0	  ok
*/

2372 2373
int reassign_keycache_tables(THD *thd, KEY_CACHE *src_cache,
			     KEY_CACHE *dst_cache)
unknown's avatar
unknown committed
2374 2375 2376
{
  DBUG_ENTER("reassign_keycache_tables");

2377 2378
  DBUG_ASSERT(src_cache != dst_cache);
  DBUG_ASSERT(src_cache->in_init);
unknown's avatar
unknown committed
2379
  src_cache->param_buff_size= 0;		// Free key cache
2380 2381
  ha_resize_key_cache(src_cache);
  ha_change_key_cache(src_cache, dst_cache);
2382
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2383 2384 2385
}


unknown's avatar
unknown committed
2386 2387 2388 2389 2390
/*
  Preload specified indexes for a table into key cache

  SYNOPSIS
    mysql_preload_keys()
2391 2392
    thd		Thread object
    tables	Table list (one table only)
unknown's avatar
unknown committed
2393 2394

  RETURN VALUES
unknown's avatar
unknown committed
2395 2396
    FALSE ok
    TRUE  error
unknown's avatar
unknown committed
2397 2398
*/

unknown's avatar
unknown committed
2399
bool mysql_preload_keys(THD* thd, TABLE_LIST* tables)
unknown's avatar
unknown committed
2400 2401 2402
{
  DBUG_ENTER("mysql_preload_keys");
  DBUG_RETURN(mysql_admin_table(thd, tables, 0,
2403
				"preload_keys", TL_READ, 0, 0, 0, 0,
2404
				&handler::preload_keys, 0));
unknown's avatar
unknown committed
2405 2406 2407
}


unknown's avatar
unknown committed
2408 2409 2410 2411 2412
/*
  Create a table identical to the specified table

  SYNOPSIS
    mysql_create_like_table()
2413 2414
    thd		Thread object
    table	Table list (one table only)
unknown's avatar
unknown committed
2415 2416 2417 2418
    create_info Create info
    table_ident Src table_ident

  RETURN VALUES
unknown's avatar
unknown committed
2419 2420
    FALSE OK
    TRUE  error
unknown's avatar
unknown committed
2421 2422
*/

unknown's avatar
unknown committed
2423 2424 2425
bool mysql_create_like_table(THD* thd, TABLE_LIST* table,
                             HA_CREATE_INFO *create_info,
                             Table_ident *table_ident)
unknown's avatar
unknown committed
2426 2427 2428 2429
{
  TABLE **tmp_table;
  char src_path[FN_REFLEN], dst_path[FN_REFLEN];
  char *db= table->db;
2430
  char *table_name= table->table_name;
unknown's avatar
unknown committed
2431 2432
  char *src_db= thd->db;
  char *src_table= table_ident->table.str;
unknown's avatar
unknown committed
2433 2434
  int  err;
  bool res= TRUE;
2435
  TABLE_LIST src_tables_list;
unknown's avatar
unknown committed
2436 2437 2438 2439 2440 2441 2442 2443 2444 2445
  DBUG_ENTER("mysql_create_like_table");

  /*
    Validate the source table
  */
  if (table_ident->table.length > NAME_LEN ||
      (table_ident->table.length &&
       check_table_name(src_table,table_ident->table.length)) ||
      table_ident->db.str && check_db_name((src_db= table_ident->db.str)))
  {
2446
    my_error(ER_WRONG_TABLE_NAME, MYF(0), src_table);
unknown's avatar
unknown committed
2447
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2448
  }
2449

unknown's avatar
VIEW  
unknown committed
2450
  bzero((gptr)&src_tables_list, sizeof(src_tables_list));
2451
  src_tables_list.db= table_ident->db.str ? table_ident->db.str : thd->db;
2452
  src_tables_list.table_name= table_ident->table.str;
2453

2454 2455
  if (lock_and_wait_for_table_name(thd, &src_tables_list))
    goto err;
unknown's avatar
unknown committed
2456 2457

  if ((tmp_table= find_temporary_table(thd, src_db, src_table)))
2458
    strxmov(src_path, (*tmp_table)->s->path, reg_ext, NullS);
unknown's avatar
unknown committed
2459 2460
  else
  {
2461 2462 2463 2464
    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));
unknown's avatar
unknown committed
2465 2466 2467
    if (access(src_path, F_OK))
    {
      my_error(ER_BAD_TABLE_ERROR, MYF(0), src_table);
2468
      goto err;
unknown's avatar
unknown committed
2469 2470 2471 2472 2473 2474
    }
  }

  /*
    Validate the destination table

2475
    skip the destination table name checking as this is already
unknown's avatar
unknown committed
2476 2477 2478 2479 2480 2481
    validated.
  */
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
    if (find_temporary_table(thd, db, table_name))
      goto table_exists;
2482 2483 2484
    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);
2485 2486
    if (lower_case_table_names)
      my_casedn_str(files_charset_info, dst_path);
unknown's avatar
unknown committed
2487 2488 2489 2490
    create_info->table_options|= HA_CREATE_DELAY_KEY_WRITE;
  }
  else
  {
2491 2492 2493
    strxmov(dst_path, mysql_data_home, "/", db, "/", table_name,
	    reg_ext, NullS);
    fn_format(dst_path, dst_path, "", "", MYF(MY_UNPACK_FILENAME));
unknown's avatar
unknown committed
2494 2495 2496 2497
    if (!access(dst_path, F_OK))
      goto table_exists;
  }

2498
  /*
unknown's avatar
unknown committed
2499
    Create a new table by copying from source table
2500
  */
2501 2502
  if (my_copy(src_path, dst_path, MYF(MY_WME|MY_DONT_OVERWRITE_FILE)))
    goto err;
unknown's avatar
unknown committed
2503 2504

  /*
2505 2506
    As mysql_truncate don't work on a new table at this stage of
    creation, instead create the table directly (for both normal
unknown's avatar
unknown committed
2507 2508
    and temporary tables).
  */
2509
  *fn_ext(dst_path)= 0;
unknown's avatar
unknown committed
2510
  err= ha_create_table(dst_path, create_info, 1);
2511

unknown's avatar
unknown committed
2512 2513 2514 2515
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
    if (err || !open_temporary_table(thd, dst_path, db, table_name, 1))
    {
2516 2517
      (void) rm_temporary_table(create_info->db_type,
				dst_path); /* purecov: inspected */
2518
      goto err;     /* purecov: inspected */
unknown's avatar
unknown committed
2519 2520 2521 2522
    }
  }
  else if (err)
  {
2523 2524 2525
    (void) quick_rm_table(create_info->db_type, db,
			  table_name); /* purecov: inspected */
    goto err;	    /* purecov: inspected */
unknown's avatar
unknown committed
2526
  }
2527 2528 2529

  // Must be written before unlock
  if (mysql_bin_log.is_open())
unknown's avatar
unknown committed
2530
  {
2531
    thd->clear_error();
unknown's avatar
unknown committed
2532
    Query_log_event qinfo(thd, thd->query, thd->query_length, FALSE, FALSE);
2533
    mysql_bin_log.write(&qinfo);
unknown's avatar
unknown committed
2534
  }
unknown's avatar
unknown committed
2535
  res= FALSE;
2536
  goto err;
2537

unknown's avatar
unknown committed
2538 2539 2540 2541
table_exists:
  if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
  {
    char warn_buff[MYSQL_ERRMSG_SIZE];
2542 2543
    my_snprintf(warn_buff, sizeof(warn_buff),
		ER(ER_TABLE_EXISTS_ERROR), table_name);
2544
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
2545
		 ER_TABLE_EXISTS_ERROR,warn_buff);
unknown's avatar
unknown committed
2546
    res= FALSE;
unknown's avatar
unknown committed
2547
  }
2548 2549 2550 2551 2552 2553 2554 2555
  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);
unknown's avatar
unknown committed
2556 2557 2558
}


unknown's avatar
unknown committed
2559
bool mysql_analyze_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
2560
{
unknown's avatar
unknown committed
2561 2562 2563 2564 2565 2566
#ifdef OS2
  thr_lock_type lock_type = TL_WRITE;
#else
  thr_lock_type lock_type = TL_READ_NO_INSERT;
#endif

2567 2568
  DBUG_ENTER("mysql_analyze_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
2569
				"analyze", lock_type, 1, 0, 0, 0,
2570
				&handler::analyze, 0));
2571 2572 2573
}


unknown's avatar
unknown committed
2574
bool mysql_check_table(THD* thd, TABLE_LIST* tables,HA_CHECK_OPT* check_opt)
2575
{
unknown's avatar
unknown committed
2576 2577 2578 2579 2580 2581
#ifdef OS2
  thr_lock_type lock_type = TL_WRITE;
#else
  thr_lock_type lock_type = TL_READ_NO_INSERT;
#endif

2582 2583
  DBUG_ENTER("mysql_check_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
unknown's avatar
unknown committed
2584
				"check", lock_type,
2585
				0, HA_OPEN_FOR_REPAIR, 0, 0,
2586
				&handler::check, &view_checksum));
2587 2588
}

unknown's avatar
unknown committed
2589

unknown's avatar
unknown committed
2590
/* table_list should contain just one table */
unknown's avatar
unknown committed
2591 2592 2593 2594
static int
mysql_discard_or_import_tablespace(THD *thd,
                                   TABLE_LIST *table_list,
                                   enum tablespace_op_type tablespace_op)
unknown's avatar
unknown committed
2595 2596 2597 2598 2599 2600
{
  TABLE *table;
  my_bool discard;
  int error;
  DBUG_ENTER("mysql_discard_or_import_tablespace");

unknown's avatar
unknown committed
2601 2602 2603 2604
  /*
    Note that DISCARD/IMPORT TABLESPACE always is the only operation in an
    ALTER TABLE
  */
unknown's avatar
unknown committed
2605 2606 2607

  thd->proc_info="discard_or_import_tablespace";

unknown's avatar
unknown committed
2608
  discard= test(tablespace_op == DISCARD_TABLESPACE);
unknown's avatar
unknown committed
2609

unknown's avatar
unknown committed
2610 2611 2612 2613 2614
 /*
   We set this flag so that ha_innobase::open and ::external_lock() do
   not complain when we lock the table
 */
  thd->tablespace_op= TRUE;
unknown's avatar
unknown committed
2615 2616 2617 2618 2619
  if (!(table=open_ltable(thd,table_list,TL_WRITE)))
  {
    thd->tablespace_op=FALSE;
    DBUG_RETURN(-1);
  }
2620

unknown's avatar
unknown committed
2621 2622 2623 2624 2625 2626 2627
  error=table->file->discard_or_import_tablespace(discard);

  thd->proc_info="end";

  if (error)
    goto err;

unknown's avatar
unknown committed
2628 2629 2630 2631
  /*
    The 0 in the call below means 'not in a transaction', which means
    immediate invalidation; that is probably what we wish here
  */
unknown's avatar
unknown committed
2632 2633 2634 2635 2636 2637 2638 2639 2640 2641
  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;
  if (mysql_bin_log.is_open())
  {
unknown's avatar
unknown committed
2642
    Query_log_event qinfo(thd, thd->query, thd->query_length, FALSE, FALSE);
unknown's avatar
unknown committed
2643 2644 2645 2646
    mysql_bin_log.write(&qinfo);
  }
err:
  close_thread_tables(thd);
unknown's avatar
unknown committed
2647
  thd->tablespace_op=FALSE;
unknown's avatar
unknown committed
2648 2649
  if (error == 0)
  {
unknown's avatar
unknown committed
2650
    send_ok(thd);
unknown's avatar
unknown committed
2651
    DBUG_RETURN(0);
unknown's avatar
unknown committed
2652
  }
unknown's avatar
unknown committed
2653 2654 2655 2656 2657

  if (error == HA_ERR_ROW_IS_REFERENCED)
    my_error(ER_ROW_IS_REFERENCED, MYF(0));
  
  DBUG_RETURN(-1);
unknown's avatar
unknown committed
2658
}
unknown's avatar
unknown committed
2659

2660 2661

#ifdef NOT_USED
2662 2663 2664 2665 2666 2667 2668
/*
  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.
*/

2669
int mysql_create_indexes(THD *thd, TABLE_LIST *table_list, List<Key> &keys)
2670 2671 2672 2673 2674
{
  List<create_field> fields;
  List<Alter_drop>   drop;
  List<Alter_column> alter;
  HA_CREATE_INFO     create_info;
2675 2676 2677 2678 2679 2680 2681 2682
  int		     rc;
  uint		     idx;
  uint		     db_options;
  uint		     key_count;
  TABLE		     *table;
  Field		     **f_ptr;
  KEY		     *key_info_buffer;
  char		     path[FN_REFLEN+1];
2683 2684 2685
  DBUG_ENTER("mysql_create_index");

  /*
2686 2687 2688
    Try to use online generation of index.
    This requires that all indexes can be created online.
    Otherwise, the old alter table procedure is executed.
2689

2690 2691
    Open the table to have access to the correct table handler.
  */
2692 2693 2694 2695
  if (!(table=open_ltable(thd,table_list,TL_WRITE_ALLOW_READ)))
    DBUG_RETURN(-1);

  /*
2696 2697 2698 2699 2700
    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.
  */
2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711
  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,
2712 2713 2714
			  keys, /*tmp_table*/ 0, db_options, table->file,
			  key_info_buffer, key_count,
			  /*select_field_count*/ 0))
2715 2716 2717
    DBUG_RETURN(-1);

  /*
2718 2719 2720
    Check if all keys can be generated with the add_index method.
    If anyone cannot, then take the old way.
  */
2721 2722 2723 2724
  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)&
2725
	  (HA_DDL_ONLINE| HA_DDL_WITH_LOCK)))
2726 2727
      break ;
  }
2728
  if ((idx < key_count)|| !key_count)
2729 2730 2731 2732 2733 2734 2735
  {
    /* 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();
2736
    if (real_alter_table(thd, table_list->db, table_list->table_name,
2737 2738 2739 2740
			 &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);*/
2741 2742 2743 2744 2745
      DBUG_RETURN(-1);
  }
  else
  {
    if (table->file->add_index(table, key_info_buffer, key_count)||
2746 2747
	(my_snprintf(path, sizeof(path), "%s/%s/%s%s", mysql_data_home,
		     table_list->db, (lower_case_table_names == 2) ?
2748
		     table_list->alias: table_list->table_name, reg_ext) >=
2749 2750 2751 2752 2753
	 (int) sizeof(path)) ||
	! unpack_filename(path, path) ||
	mysql_create_frm(thd, path, &create_info,
			 fields, key_count, key_info_buffer, table->file))
      /* don't need to free((gptr) key_info_buffer);*/
2754 2755
      DBUG_RETURN(-1);
  }
2756
  /* don't need to free((gptr) key_info_buffer);*/
2757 2758 2759 2760
  DBUG_RETURN(0);
}


2761 2762
int mysql_drop_indexes(THD *thd, TABLE_LIST *table_list,
		       List<Alter_drop> &drop)
2763 2764
{
  List<create_field> fields;
2765
  List<Key>	     keys;
2766 2767
  List<Alter_column> alter;
  HA_CREATE_INFO     create_info;
2768 2769 2770 2771 2772 2773 2774 2775 2776
  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];
2777 2778 2779
  DBUG_ENTER("mysql_drop_index");

  /*
2780 2781 2782
    Try to use online generation of index.
    This requires that all indexes can be created online.
    Otherwise, the old alter table procedure is executed.
2783

2784 2785
    Open the table to have access to the correct table handler.
  */
2786 2787 2788 2789
  if (!(table=open_ltable(thd,table_list,TL_WRITE_ALLOW_READ)))
    DBUG_RETURN(-1);

  /*
2790 2791 2792
    The drop_index method takes an array of key numbers.
    It cannot get more entries than keys in the table.
  */
2793 2794 2795 2796
  key_numbers= (uint*) thd->alloc(sizeof(uint*)*table->keys);
  key_count= 0;

  /*
2797 2798
    Get the number of each key and check if it can be created online.
  */
2799 2800 2801 2802 2803 2804 2805 2806 2807
  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))
2808
	break;
2809 2810 2811 2812 2813 2814 2815 2816
    }
    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);
    }
    /*
2817 2818 2819
      Check if the key can be generated with the add_index method.
      If anyone cannot, then take the old way.
    */
2820 2821
    DBUG_PRINT("info", ("dropping index %s", table->key_info[idx].name));
    if (!(table->file->index_ddl_flags(table->key_info+idx)&
2822
	  (HA_DDL_ONLINE| HA_DDL_WITH_LOCK)))
2823 2824 2825 2826 2827 2828 2829 2830 2831 2832
      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))
  {
2833
    if (real_alter_table(thd, table_list->db, table_list->table_name,
2834 2835 2836
			 &create_info, table_list, table,
			 fields, keys, drop, alter, 0, (ORDER*)0,
			 ALTER_DROP_INDEX, DUP_ERROR))
2837 2838 2839 2840 2841 2842 2843
      /*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)||
2844 2845 2846 2847 2848 2849
	mysql_prepare_table(thd, &create_info, fields,
			    keys, /*tmp_table*/ 0, db_options, table->file,
			    key_info_buffer, key_count,
			    /*select_field_count*/ 0)||
	(snprintf(path, sizeof(path), "%s/%s/%s%s", mysql_data_home,
		  table_list->db, (lower_case_table_names == 2)?
2850
		  table_list->alias: table_list->table_name, reg_ext)>=
2851 2852 2853 2854
	 (int)sizeof(path))||
	! unpack_filename(path, path)||
	mysql_create_frm(thd, path, &create_info,
			 fields, key_count, key_info_buffer, table->file))
2855 2856 2857 2858 2859 2860 2861
      /*don't need to free((gptr) key_numbers);*/
      DBUG_RETURN(-1);
  }

  /*don't need to free((gptr) key_numbers);*/
  DBUG_RETURN(0);
}
2862
#endif /* NOT_USED */
2863 2864


2865 2866 2867
/*
  Alter table
*/
2868

unknown's avatar
unknown committed
2869 2870 2871 2872 2873
bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
                       HA_CREATE_INFO *create_info,
                       TABLE_LIST *table_list,
                       List<create_field> &fields, List<Key> &keys,
                       uint order_num, ORDER *order,
2874
                       enum enum_duplicates handle_duplicates, bool ignore,
unknown's avatar
unknown committed
2875
                       ALTER_INFO *alter_info, bool do_send_ok)
unknown's avatar
unknown committed
2876
{
2877
  TABLE *table,*new_table=0;
unknown's avatar
unknown committed
2878
  int error;
unknown's avatar
unknown committed
2879 2880
  char tmp_name[80],old_name[32],new_name_buff[FN_REFLEN];
  char new_alias_buff[FN_REFLEN], *table_name, *db, *new_alias, *alias;
2881
  char index_file[FN_REFLEN], data_file[FN_REFLEN];
unknown's avatar
unknown committed
2882 2883
  ha_rows copied,deleted;
  ulonglong next_insert_id;
2884
  uint db_create_options, used_fields;
unknown's avatar
unknown committed
2885
  enum db_type old_db_type,new_db_type;
2886
  bool need_copy_table;
unknown's avatar
unknown committed
2887 2888 2889
  DBUG_ENTER("mysql_alter_table");

  thd->proc_info="init";
2890
  table_name=table_list->table_name;
unknown's avatar
unknown committed
2891 2892
  alias= (lower_case_table_names == 2) ? table_list->alias : table_name;

unknown's avatar
unknown committed
2893
  db=table_list->db;
unknown's avatar
unknown committed
2894
  if (!new_db || !my_strcasecmp(table_alias_charset, new_db, db))
2895
    new_db= db;
2896
  used_fields=create_info->used_fields;
unknown's avatar
unknown committed
2897

2898
  mysql_ha_flush(thd, table_list, MYSQL_HA_CLOSE_FINAL);
unknown's avatar
unknown committed
2899
  /* DISCARD/IMPORT TABLESPACE is always alone in an ALTER TABLE */
2900
  if (alter_info->tablespace_op != NO_TABLESPACE_OP)
unknown's avatar
unknown committed
2901
    DBUG_RETURN(mysql_discard_or_import_tablespace(thd,table_list,
2902
						   alter_info->tablespace_op));
unknown's avatar
unknown committed
2903
  if (!(table=open_ltable(thd,table_list,TL_WRITE_ALLOW_READ)))
unknown's avatar
unknown committed
2904
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2905 2906 2907 2908 2909

  /* Check that we are not trying to rename to an existing table */
  if (new_name)
  {
    strmov(new_name_buff,new_name);
2910
    strmov(new_alias= new_alias_buff, new_name);
unknown's avatar
unknown committed
2911
    if (lower_case_table_names)
unknown's avatar
unknown committed
2912 2913 2914
    {
      if (lower_case_table_names != 2)
      {
2915
	my_casedn_str(files_charset_info, new_name_buff);
unknown's avatar
unknown committed
2916 2917
	new_alias= new_name;			// Create lower case table name
      }
2918
      my_casedn_str(files_charset_info, new_name);
unknown's avatar
unknown committed
2919
    }
2920
    if (new_db == db &&
unknown's avatar
unknown committed
2921
	!my_strcasecmp(table_alias_charset, new_name_buff, table_name))
2922 2923
    {
      /*
2924 2925
	Source and destination table names are equal: make later check
	easier.
2926
      */
unknown's avatar
unknown committed
2927
      new_alias= new_name= table_name;
2928
    }
unknown's avatar
unknown committed
2929 2930
    else
    {
2931
      if (table->s->tmp_table)
unknown's avatar
unknown committed
2932 2933 2934
      {
	if (find_temporary_table(thd,new_db,new_name_buff))
	{
2935
	  my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_name_buff);
unknown's avatar
unknown committed
2936
	  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2937 2938 2939 2940
	}
      }
      else
      {
2941 2942 2943
	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),
unknown's avatar
unknown committed
2944 2945 2946
		    F_OK))
	{
	  /* Table will be closed in do_command() */
2947
	  my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_alias);
unknown's avatar
unknown committed
2948
	  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
2949 2950 2951 2952 2953
	}
      }
    }
  }
  else
2954 2955 2956 2957
  {
    new_alias= (lower_case_table_names == 2) ? alias : table_name;
    new_name= table_name;
  }
unknown's avatar
unknown committed
2958

2959
  old_db_type= table->s->db_type;
unknown's avatar
unknown committed
2960
  if (create_info->db_type == DB_TYPE_DEFAULT)
2961
    create_info->db_type= old_db_type;
2962 2963 2964 2965 2966 2967 2968
  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,
			ER_WARN_USING_OTHER_HANDLER,
			ER(ER_WARN_USING_OTHER_HANDLER),
unknown's avatar
unknown committed
2969
			ha_get_storage_engine(new_db_type),
2970 2971
			new_name);
  }
2972
  if (create_info->row_type == ROW_TYPE_NOT_USED)
2973
    create_info->row_type= table->s->row_type;
unknown's avatar
unknown committed
2974 2975

  thd->proc_info="setup";
2976
  if (!(alter_info->flags & ~(ALTER_RENAME | ALTER_KEYS_ONOFF)) &&
2977
      !table->s->tmp_table) // no need to touch frm
unknown's avatar
unknown committed
2978 2979
  {
    error=0;
2980
    if (new_name != table_name || new_db != db)
unknown's avatar
unknown committed
2981
    {
2982 2983 2984 2985 2986 2987
      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))
      {
2988
	my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_name);
2989
	error= -1;
2990 2991 2992
      }
      else
      {
2993 2994 2995
	*fn_ext(new_name)=0;
	close_cached_table(thd, table);
	if (mysql_rename_table(old_db_type,db,table_name,new_db,new_alias))
2996 2997 2998
	  error= -1;
      }
      VOID(pthread_mutex_unlock(&LOCK_open));
unknown's avatar
unknown committed
2999
    }
unknown's avatar
unknown committed
3000

3001
    if (!error)
3002
    {
3003
      switch (alter_info->keys_onoff) {
3004
      case LEAVE_AS_IS:
3005
        break;
3006
      case ENABLE:
3007 3008 3009 3010 3011 3012
        VOID(pthread_mutex_lock(&LOCK_open));
        wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
        VOID(pthread_mutex_unlock(&LOCK_open));
        error= table->file->enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
        /* COND_refresh will be signaled in close_thread_tables() */
        break;
3013
      case DISABLE:
3014 3015 3016 3017 3018 3019
        VOID(pthread_mutex_lock(&LOCK_open));
        wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
        VOID(pthread_mutex_unlock(&LOCK_open));
        error=table->file->disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
        /* COND_refresh will be signaled in close_thread_tables() */
        break;
3020
      }
3021
    }
3022

3023
    if (error == HA_ERR_WRONG_COMMAND)
unknown's avatar
unknown committed
3024 3025
    {
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
3026
			  ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
3027
			  table->alias);
unknown's avatar
unknown committed
3028 3029
      error=0;
    }
unknown's avatar
unknown committed
3030 3031
    if (!error)
    {
3032 3033
      if (mysql_bin_log.is_open())
      {
3034
	thd->clear_error();
unknown's avatar
unknown committed
3035
	Query_log_event qinfo(thd, thd->query, thd->query_length, FALSE, FALSE);
3036 3037
	mysql_bin_log.write(&qinfo);
      }
3038 3039
      if (do_send_ok)
        send_ok(thd);
unknown's avatar
unknown committed
3040
    }
3041
    else if (error > 0)
3042 3043
    {
      table->file->print_error(error, MYF(0));
3044
      error= -1;
3045
    }
3046 3047
    table_list->table=0;				// For query cache
    query_cache_invalidate3(thd, table_list, 0);
unknown's avatar
unknown committed
3048 3049 3050 3051
    DBUG_RETURN(error);
  }

  /* Full alter table */
3052

3053
  /* Let new create options override the old ones */
3054
  if (!(used_fields & HA_CREATE_USED_MIN_ROWS))
3055
    create_info->min_rows= table->s->min_rows;
3056
  if (!(used_fields & HA_CREATE_USED_MAX_ROWS))
3057
    create_info->max_rows= table->s->max_rows;
3058
  if (!(used_fields & HA_CREATE_USED_AVG_ROW_LENGTH))
3059
    create_info->avg_row_length= table->s->avg_row_length;
3060
  if (!(used_fields & HA_CREATE_USED_DEFAULT_CHARSET))
3061
    create_info->default_table_charset= table->s->table_charset;
3062

3063
  restore_record(table, s->default_values);     // Empty record for DEFAULT
3064
  List_iterator<Alter_drop> drop_it(alter_info->drop_list);
unknown's avatar
unknown committed
3065
  List_iterator<create_field> def_it(fields);
3066
  List_iterator<Alter_column> alter_it(alter_info->alter_list);
unknown's avatar
unknown committed
3067 3068
  List<create_field> create_list;		// Add new fields here
  List<Key> key_list;				// Add new keys here
3069 3070
  create_field *def;

unknown's avatar
unknown committed
3071
  /*
3072
    First collect all fields from table which isn't in drop_list
unknown's avatar
unknown committed
3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083
  */

  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 &&
3084
	  !my_strcasecmp(system_charset_info,field->field_name, drop->name))
3085 3086 3087
      {
	/* Reset auto_increment value if it was dropped */
	if (MTYP_TYPENR(field->unireg_check) == Field::NEXT_NUMBER &&
3088
	    !(used_fields & HA_CREATE_USED_AUTO))
3089 3090 3091 3092
	{
	  create_info->auto_increment_value=0;
	  create_info->used_fields|=HA_CREATE_USED_AUTO;
	}
unknown's avatar
unknown committed
3093
	break;
3094
      }
unknown's avatar
unknown committed
3095 3096 3097 3098 3099 3100 3101 3102 3103 3104
    }
    if (drop)
    {
      drop_it.remove();
      continue;
    }
    /* Check if field is changed */
    def_it.rewind();
    while ((def=def_it++))
    {
3105
      if (def->change &&
3106
	  !my_strcasecmp(system_charset_info,field->field_name, def->change))
unknown's avatar
unknown committed
3107 3108 3109 3110 3111
	break;
    }
    if (def)
    {						// Field is changed
      def->field=field;
3112 3113 3114 3115 3116
      if (!def->after)
      {
	create_list.push_back(def);
	def_it.remove();
      }
unknown's avatar
unknown committed
3117 3118 3119
    }
    else
    {						// Use old field value
3120
      create_list.push_back(def=new create_field(field,field));
unknown's avatar
unknown committed
3121 3122 3123 3124
      alter_it.rewind();			// Change default if ALTER
      Alter_column *alter;
      while ((alter=alter_it++))
      {
3125
	if (!my_strcasecmp(system_charset_info,field->field_name, alter->name))
unknown's avatar
unknown committed
3126 3127 3128 3129
	  break;
      }
      if (alter)
      {
3130 3131
	if (def->sql_type == FIELD_TYPE_BLOB)
	{
3132
	  my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0), def->change);
unknown's avatar
unknown committed
3133
	  DBUG_RETURN(TRUE);
3134
	}
unknown's avatar
unknown committed
3135 3136 3137 3138 3139 3140 3141 3142 3143
	def->def=alter->def;			// Use new default
	alter_it.remove();
      }
    }
  }
  def_it.rewind();
  List_iterator<create_field> find_it(create_list);
  while ((def=def_it++))			// Add new columns
  {
3144
    if (def->change && ! def->field)
unknown's avatar
unknown committed
3145
    {
3146
      my_error(ER_BAD_FIELD_ERROR, MYF(0), def->change, table_name);
unknown's avatar
unknown committed
3147
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158
    }
    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();
      while ((find=find_it++))			// Add new columns
      {
3159
	if (!my_strcasecmp(system_charset_info,def->after, find->field_name))
unknown's avatar
unknown committed
3160 3161 3162 3163
	  break;
      }
      if (!find)
      {
3164
	my_error(ER_BAD_FIELD_ERROR, MYF(0), def->after, table_name);
unknown's avatar
unknown committed
3165
	DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3166 3167 3168 3169
      }
      find_it.after(def);			// Put element after this
    }
  }
3170
  if (alter_info->alter_list.elements)
unknown's avatar
unknown committed
3171
  {
3172 3173
    my_error(ER_BAD_FIELD_ERROR, MYF(0),
             alter_info->alter_list.head()->name, table_name);
unknown's avatar
unknown committed
3174
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3175 3176 3177
  }
  if (!create_list.elements)
  {
unknown's avatar
unknown committed
3178 3179
    my_message(ER_CANT_REMOVE_ALL_FIELDS, ER(ER_CANT_REMOVE_ALL_FIELDS),
               MYF(0));
unknown's avatar
unknown committed
3180
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3181 3182 3183
  }

  /*
3184 3185
    Collect all keys which isn't in drop list. Add only those
    for which some fields exists.
unknown's avatar
unknown committed
3186 3187 3188 3189 3190 3191 3192
  */

  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;
3193
  for (uint i=0 ; i < table->s->keys ; i++,key_info++)
unknown's avatar
unknown committed
3194
  {
3195
    char *key_name= key_info->name;
unknown's avatar
unknown committed
3196 3197 3198 3199 3200
    Alter_drop *drop;
    drop_it.rewind();
    while ((drop=drop_it++))
    {
      if (drop->type == Alter_drop::KEY &&
3201
	  !my_strcasecmp(system_charset_info,key_name, drop->name))
unknown's avatar
unknown committed
3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222
	break;
    }
    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)
	continue;				// Wrong field (from UNIREG)
      const char *key_part_name=key_part->field->field_name;
      create_field *cfield;
      field_it.rewind();
      while ((cfield=field_it++))
      {
	if (cfield->change)
	{
unknown's avatar
unknown committed
3223 3224
	  if (!my_strcasecmp(system_charset_info, key_part_name,
			     cfield->change))
unknown's avatar
unknown committed
3225 3226
	    break;
	}
3227
	else if (!my_strcasecmp(system_charset_info,
3228
				key_part_name, cfield->field_name))
unknown's avatar
unknown committed
3229
	  break;
unknown's avatar
unknown committed
3230 3231 3232 3233 3234 3235 3236 3237
      }
      if (!cfield)
	continue;				// Field is removed
      uint key_part_length=key_part->length;
      if (cfield->field)			// Not new field
      {						// Check if sub key
	if (cfield->field->type() != FIELD_TYPE_BLOB &&
	    (cfield->field->pack_length() == key_part_length ||
3238
	     cfield->length <= key_part_length /
3239
			       key_part->field->charset()->mbmaxlen))
unknown's avatar
unknown committed
3240 3241
	  key_part_length=0;			// Use whole field
      }
3242
      key_part_length /= key_part->field->charset()->mbmaxlen;
unknown's avatar
unknown committed
3243 3244 3245 3246
      key_parts.push_back(new key_part_spec(cfield->field_name,
					    key_part_length));
    }
    if (key_parts.elements)
unknown's avatar
unknown committed
3247
      key_list.push_back(new Key(key_info->flags & HA_SPATIAL ? Key::SPATIAL :
3248
				 (key_info->flags & HA_NOSAME ?
3249
				 (!my_strcasecmp(system_charset_info,
3250 3251
						 key_name, primary_key_name) ?
				  Key::PRIMARY	: Key::UNIQUE) :
3252 3253 3254
				  (key_info->flags & HA_FULLTEXT ?
				   Key::FULLTEXT : Key::MULTIPLE)),
				 key_name,
3255
				 key_info->algorithm,
3256
                                 test(key_info->flags & HA_GENERATED_KEY),
3257
				 key_parts));
unknown's avatar
unknown committed
3258 3259 3260 3261
  }
  {
    Key *key;
    while ((key=key_it++))			// Add new keys
3262 3263 3264
    {
      if (key->type != Key::FOREIGN_KEY)
	key_list.push_back(key);
3265 3266 3267 3268
      if (key->name &&
	  !my_strcasecmp(system_charset_info,key->name,primary_key_name))
      {
	my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name);
unknown's avatar
unknown committed
3269
	DBUG_RETURN(TRUE);
3270
      }
3271
    }
unknown's avatar
unknown committed
3272 3273
  }

3274
  if (alter_info->drop_list.elements)
unknown's avatar
unknown committed
3275
  {
3276 3277
    my_error(ER_CANT_DROP_FIELD_OR_KEY, MYF(0),
             alter_info->drop_list.head()->name);
unknown's avatar
unknown committed
3278 3279
    goto err;
  }
3280
  if (alter_info->alter_list.elements)
unknown's avatar
unknown committed
3281
  {
3282 3283
    my_error(ER_CANT_DROP_FIELD_OR_KEY, MYF(0),
             alter_info->alter_list.head()->name);
unknown's avatar
unknown committed
3284 3285 3286
    goto err;
  }

3287
  db_create_options= table->s->db_create_options & ~(HA_OPTION_PACK_RECORD);
3288 3289
  my_snprintf(tmp_name, sizeof(tmp_name), "%s-%lx_%lx", tmp_file_prefix,
	      current_pid, thd->thread_id);
3290 3291
  /* Safety fix for innodb */
  if (lower_case_table_names)
3292
    my_casedn_str(files_charset_info, tmp_name);
unknown's avatar
unknown committed
3293 3294
  create_info->db_type=new_db_type;
  if (!create_info->comment)
3295
    create_info->comment= table->s->comment;
3296 3297 3298 3299 3300

  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))
unknown's avatar
unknown committed
3301 3302 3303 3304 3305 3306 3307 3308 3309 3310
    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 |
			  HA_OPTION_NO_DELAY_KEY_WRITE);
  create_info->table_options|= db_create_options;

3311
  if (table->s->tmp_table)
unknown's avatar
unknown committed
3312 3313
    create_info->options|=HA_LEX_CREATE_TMP_TABLE;

3314 3315 3316 3317 3318 3319 3320
  /*
    better have a negative test here, instead of positive, like
      alter_info->flags & ALTER_ADD_COLUMN|ALTER_ADD_INDEX|...
    so that ALTER TABLE won't break when somebody will add new flag
  */
  need_copy_table=(alter_info->flags & ~(ALTER_CHANGE_COLUMN_DEFAULT|ALTER_OPTIONS) ||
                   create_info->used_fields & ~(HA_CREATE_USED_COMMENT|HA_CREATE_USED_PASSWORD) ||
3321
                   table->s->tmp_table);
3322 3323
  create_info->frm_only= !need_copy_table;

3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367
  /*
    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.
  */

  if (!strcmp(db, new_db))		// Ignore symlink if db changed
  {
    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,
					   create_info->index_file_name,
					   1);
    }
    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,
					  create_info->data_file_name,
					  1);
    }
  }
3368 3369
  else
    create_info->data_file_name=create_info->index_file_name=0;
unknown's avatar
unknown committed
3370 3371

  /* We don't log the statement, it will be logged later. */
3372
  {
unknown's avatar
unknown committed
3373 3374 3375 3376 3377
    tmp_disable_binlog(thd);
    error= mysql_create_table(thd, new_db, tmp_name,
                              create_info,create_list,key_list,1,0);
    reenable_binlog(thd);
    if (error)
3378 3379
      DBUG_RETURN(error);
  }
3380
  if (need_copy_table)
unknown's avatar
unknown committed
3381
  {
3382
    if (table->s->tmp_table)
3383 3384 3385 3386
    {
      TABLE_LIST tbl;
      bzero((void*) &tbl, sizeof(tbl));
      tbl.db= new_db;
3387
      tbl.table_name= tbl.alias= tmp_name;
unknown's avatar
unknown committed
3388
      new_table= open_table(thd, &tbl, thd->mem_root, 0);
3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402
    }
    else
    {
      char path[FN_REFLEN];
      my_snprintf(path, sizeof(path), "%s/%s/%s", mysql_data_home,
                  new_db, tmp_name);
      fn_format(path,path,"","",4);
      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;
    }
unknown's avatar
unknown committed
3403 3404
  }

3405
  /* We don't want update TIMESTAMP fields during ALTER TABLE. */
3406
  thd->count_cuted_fields= CHECK_FIELD_WARN;	// calc cuted fields
unknown's avatar
unknown committed
3407 3408
  thd->cuted_fields=0L;
  thd->proc_info="copy to tmp table";
3409
  next_insert_id=thd->next_insert_id;		// Remember for logging
unknown's avatar
unknown committed
3410
  copied=deleted=0;
3411
  if (new_table && !new_table->s->is_view)
3412
  {
unknown's avatar
unknown committed
3413
    new_table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
3414
    new_table->next_number_field=new_table->found_next_number_field;
unknown's avatar
unknown committed
3415
    error=copy_data_between_tables(table,new_table,create_list,
3416
				   handle_duplicates, ignore,
3417
				   order_num, order, &copied, &deleted);
3418
  }
unknown's avatar
unknown committed
3419
  thd->last_insert_id=next_insert_id;		// Needed for correct log
3420
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
unknown's avatar
unknown committed
3421

3422
  if (table->s->tmp_table)
unknown's avatar
unknown committed
3423 3424 3425 3426
  {
    /* We changed a temporary table */
    if (error)
    {
unknown's avatar
unknown committed
3427 3428 3429
      /*
	The following function call will free the new_table pointer,
	in close_temporary_table(), so we can safely directly jump to err
3430
      */
unknown's avatar
unknown committed
3431 3432 3433
      close_temporary_table(thd,new_db,tmp_name);
      goto err;
    }
3434 3435 3436 3437 3438 3439
    /* Close lock if this is a transactional table */
    if (thd->lock)
    {
      mysql_unlock_tables(thd, thd->lock);
      thd->lock=0;
    }
unknown's avatar
unknown committed
3440
    /* Remove link to old table and rename the new one */
3441
    close_temporary_table(thd, table->s->db, table_name);
3442 3443
    /* Should pass the 'new_name' as we store table name in the cache */
    if (rename_temporary_table(thd, new_table, new_db, new_name))
unknown's avatar
unknown committed
3444 3445 3446 3447 3448
    {						// Fatal error
      close_temporary_table(thd,new_db,tmp_name);
      my_free((gptr) new_table,MYF(0));
      goto err;
    }
3449 3450
    if (mysql_bin_log.is_open())
    {
unknown's avatar
unknown committed
3451
      thd->clear_error();
unknown's avatar
unknown committed
3452
      Query_log_event qinfo(thd, thd->query, thd->query_length, FALSE, FALSE);
3453 3454
      mysql_bin_log.write(&qinfo);
    }
unknown's avatar
unknown committed
3455 3456 3457
    goto end_temporary;
  }

3458 3459 3460 3461 3462
  if (new_table)
  {
    intern_close_table(new_table);              /* close temporary table */
    my_free((gptr) new_table,MYF(0));
  }
unknown's avatar
unknown committed
3463 3464 3465 3466 3467 3468 3469
  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;
  }
3470

unknown's avatar
unknown committed
3471
  /*
3472 3473
    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
3474
    from the cache, free all locks, close the old table and remove it.
unknown's avatar
unknown committed
3475 3476 3477
  */

  thd->proc_info="rename result table";
3478 3479
  my_snprintf(old_name, sizeof(old_name), "%s2-%lx-%lx", tmp_file_prefix,
	      current_pid, thd->thread_id);
3480 3481
  if (lower_case_table_names)
    my_casedn_str(files_charset_info, old_name);
3482
  if (new_name != table_name || new_db != db)
unknown's avatar
unknown committed
3483 3484 3485 3486
  {
    if (!access(new_name_buff,F_OK))
    {
      error=1;
3487
      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_name_buff);
unknown's avatar
unknown committed
3488 3489 3490 3491 3492 3493
      VOID(quick_rm_table(new_db_type,new_db,tmp_name));
      VOID(pthread_mutex_unlock(&LOCK_open));
      goto err;
    }
  }

unknown's avatar
unknown committed
3494 3495 3496 3497 3498
#if (!defined( __WIN__) && !defined( __EMX__) && !defined( OS2))
  if (table->file->has_transactions())
#endif
  {
    /*
3499
      Win32 and InnoDB can't drop a table that is in use, so we must
3500
      close the original table at before doing the rename
unknown's avatar
unknown committed
3501 3502
    */
    table_name=thd->strdup(table_name);		// must be saved
3503
    close_cached_table(thd, table);
unknown's avatar
unknown committed
3504
    table=0;					// Marker that table is closed
unknown's avatar
unknown committed
3505
  }
unknown's avatar
unknown committed
3506 3507 3508
#if (!defined( __WIN__) && !defined( __EMX__) && !defined( OS2))
  else
    table->file->extra(HA_EXTRA_FORCE_REOPEN);	// Don't use this file anymore
unknown's avatar
unknown committed
3509 3510
#endif

unknown's avatar
unknown committed
3511

unknown's avatar
unknown committed
3512
  error=0;
3513 3514
  if (!need_copy_table)
    new_db_type=old_db_type=DB_TYPE_UNKNOWN; // this type cannot happen in regular ALTER
unknown's avatar
unknown committed
3515 3516 3517 3518 3519 3520
  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,
unknown's avatar
unknown committed
3521
			      new_alias))
unknown's avatar
unknown committed
3522 3523
  {						// Try to get everything back
    error=1;
unknown's avatar
unknown committed
3524
    VOID(quick_rm_table(new_db_type,new_db,new_alias));
unknown's avatar
unknown committed
3525
    VOID(quick_rm_table(new_db_type,new_db,tmp_name));
unknown's avatar
unknown committed
3526
    VOID(mysql_rename_table(old_db_type,db,old_name,db,alias));
unknown's avatar
unknown committed
3527 3528 3529
  }
  if (error)
  {
unknown's avatar
unknown committed
3530 3531 3532 3533
    /*
      This shouldn't happen.  We solve this the safe way by
      closing the locked table.
    */
3534 3535
    if (table)
      close_cached_table(thd,table);
unknown's avatar
unknown committed
3536 3537 3538 3539 3540
    VOID(pthread_mutex_unlock(&LOCK_open));
    goto err;
  }
  if (thd->lock || new_name != table_name)	// True if WIN32
  {
unknown's avatar
unknown committed
3541 3542 3543 3544
    /*
      Not table locking or alter table with rename
      free locks and remove old table
    */
3545 3546
    if (table)
      close_cached_table(thd,table);
unknown's avatar
unknown committed
3547 3548 3549 3550
    VOID(quick_rm_table(old_db_type,db,old_name));
  }
  else
  {
unknown's avatar
unknown committed
3551 3552 3553 3554 3555
    /*
      Using LOCK TABLES without rename.
      This code is never executed on WIN32!
      Remove old renamed table, reopen table and get new locks
    */
unknown's avatar
unknown committed
3556 3557 3558 3559 3560 3561 3562 3563 3564 3565
    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
      mysql_lock_abort(thd,table);		 // end threads waiting on lock
    }
    VOID(quick_rm_table(old_db_type,db,old_name));
    if (close_data_tables(thd,db,table_name) ||
	reopen_tables(thd,1,0))
    {						// This shouldn't happen
3566 3567
      if (table)
	close_cached_table(thd,table);		// Remove lock for table
unknown's avatar
unknown committed
3568 3569 3570 3571
      VOID(pthread_mutex_unlock(&LOCK_open));
      goto err;
    }
  }
unknown's avatar
unknown committed
3572
  /* The ALTER TABLE is always in its own transaction */
3573 3574 3575 3576
  error = ha_commit_stmt(thd);
  if (ha_commit(thd))
    error=1;
  if (error)
unknown's avatar
unknown committed
3577 3578
  {
    VOID(pthread_mutex_unlock(&LOCK_open));
3579
    VOID(pthread_cond_broadcast(&COND_refresh));
unknown's avatar
unknown committed
3580 3581 3582
    goto err;
  }
  thd->proc_info="end";
3583
  if (mysql_bin_log.is_open())
unknown's avatar
unknown committed
3584
  {
unknown's avatar
unknown committed
3585
    thd->clear_error();
unknown's avatar
unknown committed
3586
    Query_log_event qinfo(thd, thd->query, thd->query_length, FALSE, FALSE);
unknown's avatar
unknown committed
3587 3588 3589 3590
    mysql_bin_log.write(&qinfo);
  }
  VOID(pthread_cond_broadcast(&COND_refresh));
  VOID(pthread_mutex_unlock(&LOCK_open));
3591 3592 3593
#ifdef HAVE_BERKELEY_DB
  if (old_db_type == DB_TYPE_BERKELEY_DB)
  {
unknown's avatar
unknown committed
3594 3595 3596 3597 3598
    /*
      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.
    */
3599
    char path[FN_REFLEN];
3600 3601
    my_snprintf(path, sizeof(path), "%s/%s/%s", mysql_data_home,
		new_db, table_name);
3602 3603 3604
    fn_format(path,path,"","",4);
    table=open_temporary_table(thd, path, new_db, tmp_name,0);
    if (table)
unknown's avatar
unknown committed
3605
    {
3606 3607
      intern_close_table(table);
      my_free((char*) table, MYF(0));
unknown's avatar
unknown committed
3608
    }
3609
    else
unknown's avatar
unknown committed
3610 3611
      sql_print_warning("Could not open BDB table %s.%s after rename\n",
                        new_db,table_name);
3612
    (void) berkeley_flush_logs();
3613 3614
  }
#endif
unknown's avatar
unknown committed
3615
  table_list->table=0;				// For query cache
unknown's avatar
unknown committed
3616
  query_cache_invalidate3(thd, table_list, 0);
unknown's avatar
unknown committed
3617 3618

end_temporary:
3619 3620 3621
  my_snprintf(tmp_name, sizeof(tmp_name), ER(ER_INSERT_INFO),
	      (ulong) (copied + deleted), (ulong) deleted,
	      (ulong) thd->cuted_fields);
3622 3623
  if (do_send_ok)
    send_ok(thd,copied+deleted,0L,tmp_name);
unknown's avatar
unknown committed
3624
  thd->some_tables_deleted=0;
unknown's avatar
unknown committed
3625
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
3626 3627

 err:
unknown's avatar
unknown committed
3628
  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3629 3630 3631 3632
}


static int
unknown's avatar
unknown committed
3633
copy_data_between_tables(TABLE *from,TABLE *to,
3634
			 List<create_field> &create,
unknown's avatar
unknown committed
3635
			 enum enum_duplicates handle_duplicates,
3636
                         bool ignore,
3637
			 uint order_num, ORDER *order,
unknown's avatar
unknown committed
3638
			 ha_rows *copied,
3639
			 ha_rows *deleted)
unknown's avatar
unknown committed
3640 3641 3642 3643 3644
{
  int error;
  Copy_field *copy,*copy_end;
  ulong found_count,delete_count;
  THD *thd= current_thd;
unknown's avatar
unknown committed
3645 3646 3647 3648 3649 3650
  uint length;
  SORT_FIELD *sortorder;
  READ_RECORD info;
  TABLE_LIST   tables;
  List<Item>   fields;
  List<Item>   all_fields;
3651
  ha_rows examined_rows;
3652
  bool auto_increment_field_copied= 0;
3653
  ulong save_sql_mode;
unknown's avatar
unknown committed
3654 3655
  DBUG_ENTER("copy_data_between_tables");

3656 3657 3658 3659 3660 3661
  /*
    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
  */
3662
  error= ha_enable_transaction(thd, FALSE);
3663 3664
  if (error)
    DBUG_RETURN(-1);
3665
  
3666
  if (!(copy= new Copy_field[to->s->fields]))
unknown's avatar
unknown committed
3667 3668
    DBUG_RETURN(-1);				/* purecov: inspected */

3669 3670
  if (to->file->external_lock(thd, F_WRLCK))
    DBUG_RETURN(-1);
3671
  from->file->info(HA_STATUS_VARIABLE);
3672
  to->file->start_bulk_insert(from->file->records);
unknown's avatar
unknown committed
3673

3674 3675
  save_sql_mode= thd->variables.sql_mode;

unknown's avatar
unknown committed
3676 3677 3678 3679 3680 3681 3682
  List_iterator<create_field> it(create);
  create_field *def;
  copy_end=copy;
  for (Field **ptr=to->field ; *ptr ; ptr++)
  {
    def=it++;
    if (def->field)
3683 3684
    {
      if (*ptr == to->next_number_field)
3685
      {
3686
        auto_increment_field_copied= TRUE;
3687 3688 3689 3690 3691 3692 3693 3694 3695
        /*
          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;
      }
unknown's avatar
unknown committed
3696
      (copy_end++)->set(*ptr,def->field,0);
3697 3698
    }

unknown's avatar
unknown committed
3699 3700
  }

3701 3702
  found_count=delete_count=0;

unknown's avatar
unknown committed
3703 3704
  if (order)
  {
unknown's avatar
unknown committed
3705
    from->sort.io_cache=(IO_CACHE*) my_malloc(sizeof(IO_CACHE),
3706
					      MYF(MY_FAE | MY_ZEROFILL));
unknown's avatar
unknown committed
3707
    bzero((char*) &tables,sizeof(tables));
3708 3709 3710
    tables.table= from;
    tables.alias= tables.table_name= (char*) from->s->table_name;
    tables.db=    (char*) from->s->db;
unknown's avatar
unknown committed
3711 3712
    error=1;

unknown's avatar
unknown committed
3713
    if (thd->lex->select_lex.setup_ref_array(thd, order_num) ||
unknown's avatar
unknown committed
3714
	setup_order(thd, thd->lex->select_lex.ref_pointer_array,
3715
		    &tables, fields, all_fields, order) ||
3716 3717 3718 3719 3720
	!(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)
unknown's avatar
unknown committed
3721 3722 3723
      goto err;
  };

3724 3725 3726 3727
  /* 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);
unknown's avatar
unknown committed
3728
  init_read_record(&info, thd, from, (SQL_SELECT *) 0, 1,1);
3729
  if (ignore ||
3730
      handle_duplicates == DUP_REPLACE)
unknown's avatar
unknown committed
3731
    to->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
3732
  thd->row_count= 0;
3733
  restore_record(to, s->default_values);        // Create empty record
unknown's avatar
unknown committed
3734 3735 3736 3737
  while (!(error=info.read_record(&info)))
  {
    if (thd->killed)
    {
unknown's avatar
SCRUM  
unknown committed
3738
      thd->send_kill_message();
unknown's avatar
unknown committed
3739 3740 3741
      error= 1;
      break;
    }
3742
    thd->row_count++;
3743 3744
    if (to->next_number_field)
    {
3745
      if (auto_increment_field_copied)
3746
        to->auto_increment_field_not_null= TRUE;
3747 3748 3749
      else
        to->next_number_field->reset();
    }
unknown's avatar
unknown committed
3750
    for (Copy_field *copy_ptr=copy ; copy_ptr != copy_end ; copy_ptr++)
3751
    {
unknown's avatar
unknown committed
3752
      copy_ptr->do_copy(copy_ptr);
3753
    }
unknown's avatar
unknown committed
3754 3755
    if ((error=to->file->write_row((byte*) to->record[0])))
    {
3756
      if ((!ignore &&
3757
	   handle_duplicates != DUP_REPLACE) ||
unknown's avatar
unknown committed
3758 3759 3760 3761 3762 3763
	  (error != HA_ERR_FOUND_DUPP_KEY &&
	   error != HA_ERR_FOUND_DUPP_UNIQUE))
      {
	to->file->print_error(error,MYF(0));
	break;
      }
3764
      to->file->restore_auto_increment();
unknown's avatar
unknown committed
3765 3766 3767
      delete_count++;
    }
    else
3768
      found_count++;
unknown's avatar
unknown committed
3769 3770
  }
  end_read_record(&info);
3771
  free_io_cache(from);
3772
  delete [] copy;				// This is never 0
unknown's avatar
unknown committed
3773

3774
  if (to->file->end_bulk_insert() && error <= 0)
unknown's avatar
unknown committed
3775
  {
unknown's avatar
unknown committed
3776
    to->file->print_error(my_errno,MYF(0));
unknown's avatar
unknown committed
3777 3778
    error=1;
  }
unknown's avatar
unknown committed
3779
  to->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
3780

3781
  ha_enable_transaction(thd,TRUE);
3782

3783 3784 3785 3786 3787 3788 3789 3790
  /*
    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;
3791

unknown's avatar
unknown committed
3792
 err:
3793
  thd->variables.sql_mode= save_sql_mode;
unknown's avatar
unknown committed
3794
  free_io_cache(from);
unknown's avatar
unknown committed
3795 3796
  *copied= found_count;
  *deleted=delete_count;
3797 3798
  if (to->file->external_lock(thd,F_UNLCK))
    error=1;
unknown's avatar
unknown committed
3799 3800
  DBUG_RETURN(error > 0 ? -1 : 0);
}
3801

unknown's avatar
unknown committed
3802

3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814
/*
  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().
*/
unknown's avatar
unknown committed
3815 3816
bool mysql_recreate_table(THD *thd, TABLE_LIST *table_list,
                          bool do_send_ok)
3817 3818 3819 3820 3821 3822 3823 3824 3825 3826
{
  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();
  bzero((char*) &create_info,sizeof(create_info));
  create_info.db_type=DB_TYPE_DEFAULT;
unknown's avatar
unknown committed
3827
  create_info.row_type=ROW_TYPE_NOT_USED;
3828
  create_info.default_table_charset=default_charset_info;
unknown's avatar
unknown committed
3829 3830
  /* Force alter table to recreate table */
  lex->alter_info.flags= ALTER_CHANGE_COLUMN;
3831 3832 3833
  DBUG_RETURN(mysql_alter_table(thd, NullS, NullS, &create_info,
                                table_list, lex->create_list,
                                lex->key_list, 0, (ORDER *) 0,
3834
                                DUP_ERROR, 0, &lex->alter_info, do_send_ok));
3835 3836 3837
}


unknown's avatar
unknown committed
3838
bool mysql_checksum_table(THD *thd, TABLE_LIST *tables, HA_CHECK_OPT *check_opt)
3839 3840 3841 3842 3843
{
  TABLE_LIST *table;
  List<Item> field_list;
  Item *item;
  Protocol *protocol= thd->protocol;
unknown's avatar
unknown committed
3844
  DBUG_ENTER("mysql_checksum_table");
3845 3846 3847 3848 3849

  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;
3850 3851
  if (protocol->send_fields(&field_list,
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
unknown's avatar
unknown committed
3852
    DBUG_RETURN(TRUE);
3853

unknown's avatar
VIEW  
unknown committed
3854
  for (table= tables; table; table= table->next_local)
3855 3856
  {
    char table_name[NAME_LEN*2+2];
3857
    TABLE *t;
3858

3859
    strxmov(table_name, table->db ,".", table->table_name, NullS);
unknown's avatar
unknown committed
3860 3861 3862

    t= table->table= open_ltable(thd, table, TL_READ_NO_INSERT);
    thd->clear_error();			// these errors shouldn't get client
3863 3864 3865 3866

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

3867
    if (!t)
3868
    {
unknown's avatar
unknown committed
3869
      /* Table didn't exist */
3870
      protocol->store_null();
unknown's avatar
unknown committed
3871
      thd->clear_error();
3872 3873 3874
    }
    else
    {
3875
      t->pos_in_table_list= table;
3876

3877
      if (t->file->table_flags() & HA_HAS_CHECKSUM &&
3878 3879
	  !(check_opt->flags & T_EXTEND))
	protocol->store((ulonglong)t->file->checksum());
3880
      else if (!(t->file->table_flags() & HA_HAS_CHECKSUM) &&
unknown's avatar
unknown committed
3881
	       (check_opt->flags & T_QUICK))
3882
	protocol->store_null();
3883 3884
      else
      {
3885 3886 3887 3888 3889 3890 3891 3892
	/* 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);

unknown's avatar
unknown committed
3893
	if (t->file->ha_rnd_init(1))
3894 3895 3896 3897 3898 3899 3900 3901
	  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],
unknown's avatar
unknown committed
3902
				   ((byte*) t->field[0]->ptr) - t->record[0]);
3903

3904
	    for (uint i= 0; i < t->s->fields; i++ )
3905 3906 3907 3908 3909 3910 3911 3912 3913 3914
	    {
	      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,
unknown's avatar
unknown committed
3915
				     f->pack_length());
3916
	    }
3917

3918 3919 3920
	    crc+= row_crc;
	  }
	  protocol->store((ulonglong)crc);
unknown's avatar
unknown committed
3921
          t->file->ha_rnd_end();
3922
	}
3923
      }
unknown's avatar
unknown committed
3924
      thd->clear_error();
3925 3926 3927 3928 3929 3930 3931 3932
      close_thread_tables(thd);
      table->table=0;				// For query cache
    }
    if (protocol->write())
      goto err;
  }

  send_eof(thd);
unknown's avatar
unknown committed
3933
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
3934

3935 3936 3937 3938
 err:
  close_thread_tables(thd);			// Shouldn't be needed
  if (table)
    table->table=0;
unknown's avatar
unknown committed
3939
  DBUG_RETURN(TRUE);
3940
}