sql_table.cc 86.7 KB
Newer Older
1
/* Copyright (C) 2000-2003 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 20

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

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

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


/* drop and alter of tables */

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

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

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

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,
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 60 61 62 63
/*
 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
    0		ok.  In this case ok packet is sent to user
    -1		Error  (Error message given but not sent to user)

*/
unknown's avatar
unknown committed
64

65 66
int 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
merge  
unknown committed
68
  int error= 0;
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
    {
unknown's avatar
unknown committed
81 82
      my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE,MYF(0),
	       tables->real_name);
83
      error= 1;
unknown's avatar
unknown committed
84 85 86 87 88
      goto err;
    }
    while (global_read_lock && ! thd->killed)
    {
      (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
89
    }
unknown's avatar
unknown committed
90 91

  }
92
  error=mysql_rm_table_part2(thd,tables, if_exists, drop_temporary, 0);
93

94
 err:
95 96 97 98 99 100 101 102 103
  pthread_mutex_unlock(&LOCK_open);

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

  if (error)
    DBUG_RETURN(-1);
104
  send_ok(thd);
105 106 107
  DBUG_RETURN(0);
}

unknown's avatar
unknown committed
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

/*
 delete (drop) tables.

  SYNOPSIS
   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

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

137 138
  error=mysql_rm_table_part2(thd,tables, if_exists, drop_temporary,
			     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 160 161
  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
    dont_log_query	Don't log the query

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

 RETURN
   0	ok
   1	Error
   -1	Thread was killed
176
*/
177 178

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

188
  if (lock_table_names(thd, tables))
189
    DBUG_RETURN(1);
190

unknown's avatar
unknown committed
191
  for (table=tables ; table ; table=table->next)
unknown's avatar
unknown committed
192
  {
193
    char *db=table->db;
194
    mysql_ha_closeall(thd, table);
unknown's avatar
unknown committed
195
    if (!close_temporary_table(thd, db, table->real_name))
unknown's avatar
unknown committed
196
    {
197
      tmp_table_deleted=1;
unknown's avatar
unknown committed
198
      continue;					// removed temporary table
unknown's avatar
unknown committed
199
    }
unknown's avatar
unknown committed
200 201

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

273 274
  unlock_table_names(thd, tables);
  error= 0;
unknown's avatar
unknown committed
275 276
  if (wrong_tables.length())
  {
unknown's avatar
unknown committed
277 278 279 280
    if (!foreign_key_error)
      my_error(ER_BAD_TABLE_ERROR,MYF(0),wrong_tables.c_ptr());
    else
      my_error(ER_ROW_IS_REFERENCED,MYF(0));
281
    error= 1;
unknown's avatar
unknown committed
282
  }
283
  DBUG_RETURN(error);
unknown's avatar
unknown committed
284 285 286 287 288 289 290 291 292 293 294 295 296
}


int quick_rm_table(enum db_type base,const char *db,
		   const char *table_name)
{
  char path[FN_REFLEN];
  int error=0;
  (void) sprintf(path,"%s/%s/%s%s",mysql_data_home,db,table_name,reg_ext);
  unpack_filename(path,path);
  if (my_delete(path,MYF(0)))
    error=1; /* purecov: inspected */
  sprintf(path,"%s/%s/%s",mysql_data_home,db,table_name);
unknown's avatar
unknown committed
297
  unpack_filename(path,path);
unknown's avatar
unknown committed
298 299 300
  return ha_delete_table(base,path) || error;
}

301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
/*
  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;
319
    if ((a->flags ^ b->flags) & (HA_NULL_PART_KEY | HA_END_SPACE_KEY))
320 321
    {
      /* Sort NOT NULL keys before other keys */
322
      return (a->flags & (HA_NULL_PART_KEY | HA_END_SPACE_KEY)) ? 1 : -1;
323 324 325 326 327 328 329 330 331 332 333 334 335
    }
    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
336 337 338 339 340 341 342
  /*
    Prefer original key order.  usable_key_parts contains here
    the original key position.
  */
  return ((a->usable_key_parts < b->usable_key_parts) ? -1 :
	  (a->usable_key_parts > b->usable_key_parts) ? 1 :
	  0);
343 344
}

345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
/*
  Check TYPELIB (set or enum) for duplicates
  
  SYNOPSIS
    check_duplicates_in_interval()
    set_or_name   "SET" or "ENUM" string for warning message
    name          name of the checked column
    typelib       list of values for the column

  DESCRIPTION
    This function prints an warning for each value in list 
    which has some duplicates on its right

  RETURN VALUES
    void
*/

void check_duplicates_in_interval(const char *set_or_name,
				  const char *name, TYPELIB *typelib)
{
  unsigned int old_count= typelib->count;
  const char **old_type_names= typelib->type_names;

  if (typelib->count <= 1)
    return;

  old_count= typelib->count;
  old_type_names= typelib->type_names;
  const char **cur_value= typelib->type_names;
  for ( ; typelib->count > 1; cur_value++)
  {
    typelib->type_names++;
    typelib->count--;
    if (find_type((char*)*cur_value,typelib,1))
    {
      push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
			  ER_DUPLICATED_VALUE_IN_TYPE,
			  ER(ER_DUPLICATED_VALUE_IN_TYPE),
			  name,*cur_value,set_or_name);
    }
  }
  typelib->count= old_count;
  typelib->type_names= old_type_names;
}
389

unknown's avatar
unknown committed
390 391 392 393 394 395 396 397 398 399 400
/*
  Create a table

  SYNOPSIS
    mysql_create_table()
    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
401
    tmp_table		Set to 1 if this is an internal temporary table
402
			(From ALTER TABLE)
unknown's avatar
unknown committed
403 404
    no_log		Don't log the query to binary log.

405
  DESCRIPTION
unknown's avatar
unknown committed
406 407 408 409 410 411 412 413 414 415 416
    If one creates a temporary table, this is automaticly opened

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

  RETURN VALUES
    0	ok
    -1	error
*/
unknown's avatar
unknown committed
417 418 419 420

int mysql_create_table(THD *thd,const char *db, const char *table_name,
		       HA_CREATE_INFO *create_info,
		       List<create_field> &fields,
421 422
		       List<Key> &keys,bool tmp_table,bool no_log,
                       uint select_field_count)
unknown's avatar
unknown committed
423 424
{
  char		path[FN_REFLEN];
unknown's avatar
unknown committed
425
  const char	*key_name, *alias;
unknown's avatar
unknown committed
426 427 428 429
  create_field	*sql_field,*dup_field;
  int		error= -1;
  uint		db_options,field,null_fields,blob_columns;
  ulong		pos;
430
  KEY	        *key_info,*key_info_buffer;
unknown's avatar
unknown committed
431 432 433
  KEY_PART_INFO *key_part_info;
  int		auto_increment=0;
  handler	*file;
434
  int           field_no,dup_no;
435
  enum db_type	new_db_type;
unknown's avatar
unknown committed
436 437
  DBUG_ENTER("mysql_create_table");

unknown's avatar
unknown committed
438
  /* Check for duplicate fields and check type of table to create */
unknown's avatar
unknown committed
439 440 441 442 443 444
  if (!fields.elements)
  {
    my_error(ER_TABLE_MUST_HAVE_COLUMNS,MYF(0));
    DBUG_RETURN(-1);
  }
  List_iterator<create_field> it(fields),it2(fields);
445
  int select_field_pos=fields.elements - select_field_count;
unknown's avatar
unknown committed
446
  null_fields=blob_columns=0;
447 448 449 450 451 452 453
  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
454
			ha_get_storage_engine(new_db_type),
455 456
			table_name);
  }
unknown's avatar
unknown committed
457 458 459
  db_options=create_info->table_options;
  if (create_info->row_type == ROW_TYPE_DYNAMIC)
    db_options|=HA_OPTION_PACK_RECORD;
unknown's avatar
unknown committed
460
  alias= table_case_name(create_info, table_name);
unknown's avatar
unknown committed
461 462
  file=get_new_handler((TABLE*) 0, create_info->db_type);

463
  if ((create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
464
      (file->table_flags() & HA_NO_TEMP_TABLES))
465 466 467 468 469
  {
    my_error(ER_ILLEGAL_HA,MYF(0),table_name);
    DBUG_RETURN(-1);
  }

470
  for (field_no=0; (sql_field=it++) ; field_no++)
unknown's avatar
unknown committed
471
  {
472
    if (!sql_field->charset)
473 474 475 476 477 478
      sql_field->charset= create_info->default_table_charset;
    /*
      table_charset is set in ALTER TABLE if we want change character set
      for all varchar/char columns
    */
    if (create_info->table_charset)
479 480
      sql_field->charset= create_info->table_charset;
    sql_field->create_length_to_internal_length();
481

482
    /* Don't pack keys in old tables if the user has requested this */
unknown's avatar
unknown committed
483 484 485 486 487 488 489 490
    if ((sql_field->flags & BLOB_FLAG) ||
	sql_field->sql_type == FIELD_TYPE_VAR_STRING &&
	create_info->row_type != ROW_TYPE_FIXED)
    {
      db_options|=HA_OPTION_PACK_RECORD;
    }
    if (!(sql_field->flags & NOT_NULL_FLAG))
      null_fields++;
491

unknown's avatar
unknown committed
492 493
    if (check_column_name(sql_field->field_name))
    {
494
      my_error(ER_WRONG_COLUMN_NAME, MYF(0), sql_field->field_name);
unknown's avatar
unknown committed
495 496
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
497

498 499
    /* 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
500
    {
501 502
      if (my_strcasecmp(system_charset_info,
                        sql_field->field_name,
503
                        dup_field->field_name) == 0)
unknown's avatar
unknown committed
504
      {
505 506 507 508 509
	/*
	  If this was a CREATE ... SELECT statement, accept a field
	  redefinition if we are changing a field in the SELECT part
	*/
        if (field_no < select_field_pos || dup_no >= select_field_pos)
510 511 512 513 514 515
        {
          my_error(ER_DUP_FIELDNAME,MYF(0),sql_field->field_name);
          DBUG_RETURN(-1);
        }
        else
        {
516
	  /* Field redefined */
517
	  sql_field->sql_type=		dup_field->sql_type;
518 519 520
	  sql_field->charset=		(dup_field->charset ?
					 dup_field->charset :
					 create_info->default_table_charset);
521
	  sql_field->length=		dup_field->length;
522 523
	  sql_field->pack_length=	dup_field->pack_length;
	  sql_field->create_length_to_internal_length();
524 525 526 527 528 529
	  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;
530
        }
unknown's avatar
unknown committed
531 532 533 534
      }
    }
    it2.rewind();
  }
535
  /* If fixed row records, we need one bit to check for deleted rows */
unknown's avatar
unknown committed
536 537 538 539 540 541 542
  if (!(db_options & HA_OPTION_PACK_RECORD))
    null_fields++;
  pos=(null_fields+7)/8;

  it.rewind();
  while ((sql_field=it++))
  {
543 544
    DBUG_ASSERT(sql_field->charset);

unknown's avatar
unknown committed
545 546 547 548 549 550 551 552
    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);
553
      if (sql_field->charset->state & MY_CS_BINSORT)
unknown's avatar
unknown committed
554 555 556 557 558
	sql_field->pack_flag|=FIELDFLAG_BINARY;
      sql_field->length=8;			// Unireg field length
      sql_field->unireg_check=Field::BLOB_FIELD;
      blob_columns++;
      break;
unknown's avatar
unknown committed
559
    case FIELD_TYPE_GEOMETRY:
unknown's avatar
unknown committed
560
#ifdef HAVE_SPATIAL
561 562
      if (!(file->table_flags() & HA_HAS_GEOMETRY))
      {
563 564
	my_printf_error(ER_CHECK_NOT_IMPLEMENTED, ER(ER_CHECK_NOT_IMPLEMENTED),
			MYF(0), "GEOMETRY");
565 566
	DBUG_RETURN(-1);
      }
unknown's avatar
unknown committed
567 568 569
      sql_field->pack_flag=FIELDFLAG_GEOM |
	pack_length_to_packflag(sql_field->pack_length -
				portable_sizeof_char_ptr);
unknown's avatar
unknown committed
570
      if (sql_field->charset->state & MY_CS_BINSORT)
unknown's avatar
unknown committed
571 572 573 574 575
	sql_field->pack_flag|=FIELDFLAG_BINARY;
      sql_field->length=8;			// Unireg field length
      sql_field->unireg_check=Field::BLOB_FIELD;
      blob_columns++;
      break;
unknown's avatar
unknown committed
576 577
#else
      my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED), MYF(0),
unknown's avatar
SCRUM  
unknown committed
578
		      sym_group_geom.name, sym_group_geom.needed_define);
unknown's avatar
unknown committed
579 580
      DBUG_RETURN(-1);
#endif /*HAVE_SPATIAL*/
unknown's avatar
unknown committed
581 582 583
    case FIELD_TYPE_VAR_STRING:
    case FIELD_TYPE_STRING:
      sql_field->pack_flag=0;
584
      if (sql_field->charset->state & MY_CS_BINSORT)
unknown's avatar
unknown committed
585 586 587 588 589
	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;
590 591
      if (sql_field->charset->state & MY_CS_BINSORT)
	sql_field->pack_flag|=FIELDFLAG_BINARY;
unknown's avatar
unknown committed
592
      sql_field->unireg_check=Field::INTERVAL_FIELD;
593 594
      check_duplicates_in_interval("ENUM",sql_field->field_name,
				   sql_field->interval);
unknown's avatar
unknown committed
595 596 597 598
      break;
    case FIELD_TYPE_SET:
      sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
	FIELDFLAG_BITFIELD;
599 600
      if (sql_field->charset->state & MY_CS_BINSORT)
	sql_field->pack_flag|=FIELDFLAG_BINARY;
unknown's avatar
unknown committed
601
      sql_field->unireg_check=Field::BIT_FIELD;
602 603
      check_duplicates_in_interval("SET",sql_field->field_name,
				   sql_field->interval);
unknown's avatar
unknown committed
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
      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_TIMESTAMP:
      sql_field->unireg_check=Field::TIMESTAMP_FIELD;
      /* 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;
    sql_field->offset= pos;
    if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
      auto_increment++;
    pos+=sql_field->pack_length;
  }
  if (auto_increment > 1)
  {
    my_error(ER_WRONG_AUTO_KEY,MYF(0));
    DBUG_RETURN(-1);
  }
  if (auto_increment &&
638
      (file->table_flags() & HA_NO_AUTO_INCREMENT))
unknown's avatar
unknown committed
639 640 641 642 643
  {
    my_error(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT,MYF(0));
    DBUG_RETURN(-1);
  }

644
  if (blob_columns && (file->table_flags() & HA_NO_BLOBS))
unknown's avatar
unknown committed
645 646 647 648 649 650
  {
    my_error(ER_TABLE_CANT_HANDLE_BLOB,MYF(0));
    DBUG_RETURN(-1);
  }

  /* Create keys */
651

unknown's avatar
unknown committed
652
  List_iterator<Key> key_iterator(keys);
653
  uint key_parts=0, key_count=0, fk_key_count=0;
654
  List<Key> keys_in_order;			// Add new keys here
655
  bool primary_key=0,unique_key=0;
unknown's avatar
unknown committed
656
  Key *key;
unknown's avatar
unknown committed
657
  uint tmp, key_number;
658

659
  /* Calculate number of key segements */
660

unknown's avatar
unknown committed
661 662
  while ((key=key_iterator++))
  {
663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
    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)
      {
	my_error(ER_WRONG_FK_DEF, MYF(0), fk_key->name ? fk_key->name :
		 "foreign key without name",
		 ER(ER_KEY_REF_DO_NOT_MATCH_TABLE_REF));
	DBUG_RETURN(-1);
      }
      continue;
    }
    key_count++;
unknown's avatar
unknown committed
678 679 680 681 682 683
    tmp=max(file->max_key_parts(),MAX_REF_PARTS);
    if (key->columns.elements > tmp)
    {
      my_error(ER_TOO_MANY_KEY_PARTS,MYF(0),tmp);
      DBUG_RETURN(-1);
    }
684
    if (key->name && strlen(key->name) > NAME_LEN)
unknown's avatar
unknown committed
685
    {
686
      my_error(ER_TOO_LONG_IDENT, MYF(0), key->name);
unknown's avatar
unknown committed
687 688 689
      DBUG_RETURN(-1);
    }
    key_parts+=key->columns.elements;
690 691 692 693 694 695
    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);
    }
696
  }
697 698 699 700 701 702
  tmp=min(file->max_keys(), MAX_KEY);
  if (key_count > tmp)
  {
    my_error(ER_TOO_MANY_KEYS,MYF(0),tmp);
    DBUG_RETURN(-1);
  }
703 704 705 706 707 708

  key_info_buffer=key_info=(KEY*) sql_calloc(sizeof(KEY)*key_count);
  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

709
  key_iterator.rewind();
unknown's avatar
unknown committed
710
  key_number=0;
unknown's avatar
unknown committed
711
  for (; (key=key_iterator++) ; key_number++)
712 713 714 715
  {
    uint key_length=0;
    key_part_spec *column;

unknown's avatar
unknown committed
716
    switch(key->type){
unknown's avatar
unknown committed
717
    case Key::MULTIPLE:
unknown's avatar
unknown committed
718 719
        key_info->flags = 0;
        break;
unknown's avatar
unknown committed
720
    case Key::FULLTEXT:
unknown's avatar
unknown committed
721 722
        key_info->flags = HA_FULLTEXT;
        break;
unknown's avatar
unknown committed
723
    case Key::SPATIAL:
unknown's avatar
unknown committed
724
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
725 726
        key_info->flags = HA_SPATIAL;
        break;
unknown's avatar
unknown committed
727 728
#else
	my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED),MYF(0),
unknown's avatar
SCRUM  
unknown committed
729
			sym_group_geom.name, sym_group_geom.needed_define);
unknown's avatar
unknown committed
730 731
	DBUG_RETURN(-1);
#endif
732 733 734 735
    case Key::FOREIGN_KEY:
      key_number--;				// Skip this key
      continue;
    default:
unknown's avatar
unknown committed
736 737 738
        key_info->flags = HA_NOSAME;
    }

unknown's avatar
unknown committed
739 740
    key_info->key_parts=(uint8) key->columns.elements;
    key_info->key_part=key_part_info;
unknown's avatar
unknown committed
741
    key_info->usable_key_parts= key_number;
742
    key_info->algorithm=key->algorithm;
unknown's avatar
unknown committed
743

744 745
    if (key->type == Key::FULLTEXT)
    {
746
      if (!(file->table_flags() & HA_CAN_FULLTEXT))
747
      {
748
        my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0));
749 750 751
        DBUG_RETURN(-1);
      }
    }
unknown's avatar
unknown committed
752 753 754
    /*
       Make SPATIAL to be RTREE by default
       SPATIAL only on BLOB or at least BINARY, this
755
       actually should be replaced by special GEOM type
unknown's avatar
unknown committed
756 757 758
       in near future when new frm file is ready
       checking for proper key parts number:
    */
759

760
    /* TODO: Add proper checks if handler supports key_type and algorithm */
761 762 763 764
    if (key_info->flags == HA_SPATIAL)
    {
      if (key_info->key_parts != 1)
      {
unknown's avatar
unknown committed
765 766 767 768
        my_printf_error(ER_WRONG_ARGUMENTS,
                        ER(ER_WRONG_ARGUMENTS),MYF(0),"SPATIAL INDEX");
        DBUG_RETURN(-1);
      }
769
    }
unknown's avatar
unknown committed
770 771
    else
    if (key_info->algorithm == HA_KEY_ALG_RTREE)
unknown's avatar
unknown committed
772
    {
unknown's avatar
unknown committed
773
#ifdef HAVE_RTREE_KEYS
774 775 776 777 778
      if ((key_info->key_parts & 1) == 1)
      {
	my_printf_error(ER_WRONG_ARGUMENTS,
			ER(ER_WRONG_ARGUMENTS),MYF(0),"RTREE INDEX");
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
779
      }
780 781 782 783
      /* TODO: To be deleted */
      my_printf_error(ER_NOT_SUPPORTED_YET, ER(ER_NOT_SUPPORTED_YET),
		      MYF(0), "RTREE INDEX");
      DBUG_RETURN(-1);
unknown's avatar
unknown committed
784 785
#else
      my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED),MYF(0),
unknown's avatar
SCRUM  
unknown committed
786
		      sym_group_rtree.name, sym_group_rtree.needed_define);
unknown's avatar
unknown committed
787 788
      DBUG_RETURN(-1);
#endif
unknown's avatar
unknown committed
789
    }
790

unknown's avatar
unknown committed
791
    List_iterator<key_part_spec> cols(key->columns);
792
    CHARSET_INFO *ft_key_charset=0;  // for FULLTEXT
unknown's avatar
unknown committed
793 794 795 796 797
    for (uint column_nr=0 ; (column=cols++) ; column_nr++)
    {
      it.rewind();
      field=0;
      while ((sql_field=it++) &&
798 799 800
	     my_strcasecmp(system_charset_info,
                           column->field_name,
                           sql_field->field_name))
unknown's avatar
unknown committed
801 802 803 804 805 806 807 808
	field++;
      if (!sql_field)
      {
	my_printf_error(ER_KEY_COLUMN_DOES_NOT_EXITS,
			ER(ER_KEY_COLUMN_DOES_NOT_EXITS),MYF(0),
			column->field_name);
	DBUG_RETURN(-1);
      }
809 810 811 812 813 814 815
      /* 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).
      */
      if (key->type == Key::FULLTEXT)
816 817 818 819 820
      {
        if ((sql_field->sql_type != FIELD_TYPE_STRING &&
             sql_field->sql_type != FIELD_TYPE_VAR_STRING &&
             !f_is_blob(sql_field->pack_flag)) ||
            sql_field->charset == &my_charset_bin ||
821
            sql_field->charset->state & MY_CS_NONTEXT || // ucs2 doesn't work yet
822 823 824 825 826 827 828 829 830 831 832 833 834 835
            (ft_key_charset && sql_field->charset != ft_key_charset))
        {
            my_printf_error(ER_BAD_FT_COLUMN,ER(ER_BAD_FT_COLUMN),MYF(0),
                            column->field_name);
            DBUG_RETURN(-1);
        }
        ft_key_charset=sql_field->charset;
        /*
          for fulltext keys keyseg length is 1 for blobs (it's ignored in ft
          code anyway, and 0 (set to column width later) for char's. it has
          to be correct col width for char's, as char data are not prefixed
          with length (unlike blobs, where ft code takes data length from a
          data prefix, ignoring column->length).
        */
836
        column->length=test(f_is_blob(sql_field->pack_flag));
837
      }
838
      else
839
      {
840 841
        column->length*= sql_field->charset->mbmaxlen;

842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857
        if (f_is_blob(sql_field->pack_flag))
        {
          if (!(file->table_flags() & HA_BLOB_KEY))
          {
            my_printf_error(ER_BLOB_USED_AS_KEY,ER(ER_BLOB_USED_AS_KEY),MYF(0),
                            column->field_name);
            DBUG_RETURN(-1);
          }
          if (!column->length)
          {
            my_printf_error(ER_BLOB_KEY_WITHOUT_LENGTH,
                            ER(ER_BLOB_KEY_WITHOUT_LENGTH),MYF(0),
                            column->field_name);
            DBUG_RETURN(-1);
          }
        }
unknown's avatar
unknown committed
858
#ifdef HAVE_SPATIAL
859 860 861 862 863 864 865 866 867 868 869
        if (key->type  == Key::SPATIAL)
        {
          if (!column->length )
          {
            /*
            BAR: 4 is: (Xmin,Xmax,Ymin,Ymax), this is for 2D case
                 Lately we'll extend this code to support more dimensions
            */
            column->length=4*sizeof(double);
          }
        }
unknown's avatar
unknown committed
870
#endif
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897
        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;
          if (!(file->table_flags() & HA_NULL_KEY))
          {
            my_printf_error(ER_NULL_COLUMN_IN_INDEX,ER(ER_NULL_COLUMN_IN_INDEX),
                            MYF(0),column->field_name);
            DBUG_RETURN(-1);
          }
          if (key->type == Key::SPATIAL)
          {
            my_error(ER_SPATIAL_CANT_HAVE_NULL, MYF(0));
            DBUG_RETURN(-1);
          }
        }
        if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
        {
          if (column_nr == 0 || (file->table_flags() & HA_AUTO_PART_KEY))
            auto_increment--;			// Field is used
        }
unknown's avatar
unknown committed
898
      }
899

unknown's avatar
unknown committed
900 901 902 903 904 905 906 907
      key_part_info->fieldnr= field;
      key_part_info->offset=  (uint16) sql_field->offset;
      key_part_info->key_type=sql_field->pack_flag;
      uint length=sql_field->pack_length;
      if (column->length)
      {
	if (f_is_blob(sql_field->pack_flag))
	{
908 909
	  if ((length=column->length) > file->max_key_length() ||
	      length > file->max_key_part_length())
910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925
          {
            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];
              sprintf(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
926
	}
927 928 929 930 931 932 933 934 935 936 937 938
	else if (!f_is_geom(sql_field->pack_flag) &&
                  (column->length > length ||
                   ((f_is_packed(sql_field->pack_flag) ||
                     ((file->table_flags() & HA_NO_PREFIX_CHAR_KEYS) &&
                      (key_info->flags & HA_NOSAME))) &&
                    column->length != length)))
        {
          my_error(ER_WRONG_SUB_KEY,MYF(0));
          DBUG_RETURN(-1);
        }
        else if (!(file->table_flags() & HA_NO_PREFIX_CHAR_KEYS))
          length=column->length;
unknown's avatar
unknown committed
939 940 941 942 943 944 945
      }
      else if (length == 0)
      {
	my_printf_error(ER_WRONG_KEY_COLUMN, ER(ER_WRONG_KEY_COLUMN), MYF(0),
			column->field_name);
	  DBUG_RETURN(-1);
      }
946 947
      if (length > file->max_key_part_length())
      {
948 949 950 951 952 953 954 955 956 957 958 959 960 961
        length=file->max_key_part_length();
        if (key->type == Key::MULTIPLE)
        {
          /* not a critical problem */
          char warn_buff[MYSQL_ERRMSG_SIZE];
          sprintf(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);
        }
962 963
      }
      key_part_info->length=(uint16) length;
unknown's avatar
unknown committed
964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982
      /* Use packed keys for long strings on the first column */
      if (!(db_options & HA_OPTION_NO_PACK_KEYS) &&
	  (length >= KEY_DEFAULT_PACK_LENGTH &&
	   (sql_field->sql_type == FIELD_TYPE_STRING ||
	    sql_field->sql_type == FIELD_TYPE_VAR_STRING ||
	    sql_field->pack_flag & FIELDFLAG_BLOB)))
      {
	if (column_nr == 0 && (sql_field->pack_flag & FIELDFLAG_BLOB))
	  key_info->flags|= HA_BINARY_PACK_KEY;
	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)
983 984 985 986 987 988 989 990 991
	{
	  if (primary_key)
	  {
	    my_error(ER_MULTIPLE_PRI_KEY,MYF(0));
	    DBUG_RETURN(-1);
	  }
	  key_name=primary_key_name;
	  primary_key=1;
	}
992
	else if (!(key_name = key->name))
unknown's avatar
unknown committed
993 994 995 996 997 998 999 1000 1001 1002
	  key_name=make_unique_key_name(sql_field->field_name,
					key_info_buffer,key_info);
	if (check_if_keyname_exists(key_name,key_info_buffer,key_info))
	{
	  my_error(ER_DUP_KEYNAME,MYF(0),key_name);
	  DBUG_RETURN(-1);
	}
	key_info->name=(char*) key_name;
      }
    }
1003 1004
    if (!key_info->name || check_column_name(key_info->name))
    {
1005
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key_info->name);
1006 1007
      DBUG_RETURN(-1);
    }
1008 1009
    if (!(key_info->flags & HA_NULL_PART_KEY))
      unique_key=1;
unknown's avatar
unknown committed
1010
    key_info->key_length=(uint16) key_length;
unknown's avatar
unknown committed
1011
    uint max_key_length= min(file->max_key_length(), MAX_KEY_LENGTH);
1012
    if (key_length > max_key_length && key->type != Key::FULLTEXT)
unknown's avatar
unknown committed
1013
    {
1014
      my_error(ER_TOO_LONG_KEY,MYF(0),max_key_length);
unknown's avatar
unknown committed
1015 1016
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
1017
    key_info++;
unknown's avatar
unknown committed
1018
  }
1019
  if (!unique_key && !primary_key &&
1020
      (file->table_flags() & HA_REQUIRE_PRIMARY_KEY))
1021 1022 1023 1024
  {
    my_error(ER_REQUIRES_PRIMARY_KEY,MYF(0));
    DBUG_RETURN(-1);
  }
unknown's avatar
unknown committed
1025 1026 1027 1028 1029
  if (auto_increment > 0)
  {
    my_error(ER_WRONG_AUTO_KEY,MYF(0));
    DBUG_RETURN(-1);
  }
1030 1031
  /* Sort keys in optimized order */
  qsort((gptr) key_info_buffer, key_count, sizeof(KEY), (qsort_cmp) sort_keys);
unknown's avatar
unknown committed
1032 1033 1034 1035 1036 1037 1038 1039 1040

      /* Check if table exists */
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
    sprintf(path,"%s%s%lx_%lx_%x%s",mysql_tmpdir,tmp_file_prefix,
	    current_pid, thd->thread_id, thd->tmp_table++,reg_ext);
    create_info->table_options|=HA_CREATE_DELAY_KEY_WRITE;
  }
  else
unknown's avatar
unknown committed
1041
    (void) sprintf(path,"%s/%s/%s%s",mysql_data_home,db,alias,reg_ext);
unknown's avatar
unknown committed
1042 1043 1044 1045 1046
  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))
  {
1047
    if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
1048 1049
    {
      create_info->table_existed= 1;		// Mark that table existed
1050
      DBUG_RETURN(0);
1051
    }
unknown's avatar
unknown committed
1052
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), alias);
unknown's avatar
unknown committed
1053 1054
    DBUG_RETURN(-1);
  }
1055 1056
  if (wait_if_global_read_lock(thd, 0))
    DBUG_RETURN(error);
unknown's avatar
unknown committed
1057 1058 1059 1060 1061 1062
  VOID(pthread_mutex_lock(&LOCK_open));
  if (!tmp_table && !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
  {
    if (!access(path,F_OK))
    {
      if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
1063 1064
      {
	create_info->table_existed= 1;		// Mark that table existed
1065
	error= 0;
unknown's avatar
unknown committed
1066
      }  
1067
      else
unknown's avatar
unknown committed
1068
        my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
1069
      goto end;
unknown's avatar
unknown committed
1070 1071 1072 1073
    }
  }

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

unknown's avatar
unknown committed
1076
  if (thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE)
1077
    create_info->data_file_name= create_info->index_file_name= 0;
unknown's avatar
unknown committed
1078
  create_info->table_options=db_options;
1079

1080
  if (rea_create_table(thd, path, create_info, fields, key_count,
unknown's avatar
unknown committed
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
		       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
1094
    thd->tmp_table_used= 1;
unknown's avatar
unknown committed
1095
  }
1096 1097 1098 1099 1100 1101
  if (!tmp_table && !no_log)
  {
    // Must be written before unlock
    mysql_update_log.write(thd,thd->query, thd->query_length);
    if (mysql_bin_log.is_open())
    {
unknown's avatar
unknown committed
1102
      thd->clear_error();
1103 1104 1105 1106 1107 1108
      Query_log_event qinfo(thd, thd->query, thd->query_length,
			    test(create_info->options &
				 HA_LEX_CREATE_TMP_TABLE));
      mysql_bin_log.write(&qinfo);
    }
  }
unknown's avatar
unknown committed
1109 1110 1111
  error=0;
end:
  VOID(pthread_mutex_unlock(&LOCK_open));
1112
  start_waiting_global_read_lock(thd);
unknown's avatar
unknown committed
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124
  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++)
1125
    if (!my_strcasecmp(system_charset_info,name,key->name))
unknown's avatar
unknown committed
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
      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;

1136 1137
  if (!check_if_keyname_exists(field_name,start,end) &&
      my_strcasecmp(system_charset_info,field_name,primary_key_name))
unknown's avatar
unknown committed
1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
    return (char*) field_name;			// Use fieldname
  buff_end=strmake(buff,field_name,MAX_FIELD_NAME-4);
  for (uint i=2 ; ; i++)
  {
    sprintf(buff_end,"_%d",i);
    if (!check_if_keyname_exists(buff,start,end))
      return sql_strdup(buff);
  }
}

/****************************************************************************
** Create table from a list of fields and items
****************************************************************************/

TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
			       const char *db, const char *name,
			       List<create_field> *extra_fields,
			       List<Key> *keys,
			       List<Item> *items,
			       MYSQL_LOCK **lock)
{
  TABLE tmp_table;		// Used during 'create_field()'
  TABLE *table;
  tmp_table.table_name=0;
1162
  uint select_field_count= items->elements;
unknown's avatar
unknown committed
1163 1164 1165
  DBUG_ENTER("create_table_from_items");

  /* Add selected items to field list */
unknown's avatar
unknown committed
1166
  List_iterator_fast<Item> it(*items);
unknown's avatar
unknown committed
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177
  Item *item;
  Field *tmp_field;
  tmp_table.db_create_options=0;
  tmp_table.null_row=tmp_table.maybe_null=0;
  tmp_table.blob_ptr_size=portable_sizeof_char_ptr;
  tmp_table.db_low_byte_first= test(create_info->db_type == DB_TYPE_MYISAM ||
				    create_info->db_type == DB_TYPE_HEAP);

  while ((item=it++))
  {
    create_field *cr_field;
1178 1179 1180 1181 1182
    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
1183
				  (Item ***) 0, &tmp_field,0,0);
1184 1185
    if (!field ||
	!(cr_field=new create_field(field,(item->type() == Item::FIELD_ITEM ?
1186 1187
					   ((Item_field *)item)->field :
					   (Field*) 0))))
unknown's avatar
unknown committed
1188 1189 1190 1191 1192 1193
      DBUG_RETURN(0);
    extra_fields->push_back(cr_field);
  }
  /* create and lock table */
  /* QQ: This should be done atomic ! */
  if (mysql_create_table(thd,db,name,create_info,*extra_fields,
1194
			 *keys,0,1,select_field_count)) // no logging
unknown's avatar
unknown committed
1195 1196 1197
    DBUG_RETURN(0);
  if (!(table=open_table(thd,db,name,name,(bool*) 0)))
  {
unknown's avatar
unknown committed
1198
    quick_rm_table(create_info->db_type,db,table_case_name(create_info,name));
unknown's avatar
unknown committed
1199 1200 1201 1202 1203
    DBUG_RETURN(0);
  }
  table->reginfo.lock_type=TL_WRITE;
  if (!((*lock)=mysql_lock_tables(thd,&table,1)))
  {
1204
    VOID(pthread_mutex_lock(&LOCK_open));
unknown's avatar
unknown committed
1205
    hash_delete(&open_cache,(byte*) table);
1206
    VOID(pthread_mutex_unlock(&LOCK_open));
unknown's avatar
unknown committed
1207
    quick_rm_table(create_info->db_type,db,table_case_name(create_info, name));
unknown's avatar
unknown committed
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
    DBUG_RETURN(0);
  }
  table->file->extra(HA_EXTRA_WRITE_CACHE);
  DBUG_RETURN(table);
}


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

1219
bool
unknown's avatar
unknown committed
1220 1221
mysql_rename_table(enum db_type base,
		   const char *old_db,
unknown's avatar
unknown committed
1222
		   const char *old_name,
unknown's avatar
unknown committed
1223
		   const char *new_db,
unknown's avatar
unknown committed
1224
		   const char *new_name)
unknown's avatar
unknown committed
1225
{
unknown's avatar
unknown committed
1226 1227
  char from[FN_REFLEN], to[FN_REFLEN];
  char tmp_from[NAME_LEN+1], tmp_to[NAME_LEN+1];
unknown's avatar
unknown committed
1228
  handler *file=get_new_handler((TABLE*) 0, base);
unknown's avatar
unknown committed
1229
  int error=0;
unknown's avatar
unknown committed
1230
  DBUG_ENTER("mysql_rename_table");
unknown's avatar
unknown committed
1231 1232 1233 1234 1235

  if (lower_case_table_names == 2 && !(file->table_flags() & HA_FILE_BASED))
  {
    /* Table handler expects to get all file names as lower case */
    strmov(tmp_from, old_name);
unknown's avatar
unknown committed
1236
    my_casedn_str(system_charset_info, tmp_from);
unknown's avatar
unknown committed
1237 1238 1239
    old_name= tmp_from;

    strmov(tmp_to, new_name);
unknown's avatar
unknown committed
1240
    my_casedn_str(system_charset_info, tmp_to);
unknown's avatar
unknown committed
1241 1242
    new_name= tmp_to;
  }
unknown's avatar
unknown committed
1243 1244 1245 1246
  (void) sprintf(from,"%s/%s/%s",mysql_data_home,old_db,old_name);
  (void) sprintf(to,"%s/%s/%s",mysql_data_home,new_db,new_name);
  fn_format(from,from,"","",4);
  fn_format(to,to,    "","",4);
unknown's avatar
unknown committed
1247

unknown's avatar
unknown committed
1248
  if (!(error=file->rename_table((const char*) from,(const char *) to)))
1249 1250 1251
  {
    if (rename_file_ext(from,to,reg_ext))
    {
unknown's avatar
unknown committed
1252
      error=my_errno;
1253 1254 1255 1256
      /* Restore old file name */
      file->rename_table((const char*) to,(const char *) from);
    }
  }
unknown's avatar
unknown committed
1257
  delete file;
unknown's avatar
unknown committed
1258 1259 1260
  if (error)
    my_error(ER_ERROR_ON_RENAME, MYF(0), from, to, error);
  DBUG_RETURN(error != 0);
unknown's avatar
unknown committed
1261 1262
}

unknown's avatar
unknown committed
1263

unknown's avatar
unknown committed
1264
/*
1265 1266 1267 1268 1269 1270
  Force all other threads to stop using the table

  SYNOPSIS
    wait_while_table_is_used()
    thd			Thread handler
    table		Table to remove from cache
1271 1272
    function		HA_EXTRA_PREPARE_FOR_DELETE if table is to be deleted
			HA_EXTRA_FORCE_REOPEN if table is not be used    
1273 1274 1275 1276 1277 1278 1279
  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
1280 1281
*/

1282 1283
static void wait_while_table_is_used(THD *thd,TABLE *table,
				     enum ha_extra_function function)
unknown's avatar
unknown committed
1284
{
1285 1286 1287
  DBUG_PRINT("enter",("table: %s", table->real_name));
  DBUG_ENTER("wait_while_table_is_used");
  safe_mutex_assert_owner(&LOCK_open);
unknown's avatar
unknown committed
1288

1289
  VOID(table->file->extra(function));
1290 1291 1292 1293 1294 1295
  /* 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 */
  while (remove_table_from_cache(thd,table->table_cache_key,
				 table->real_name))
unknown's avatar
unknown committed
1296
  {
1297 1298 1299
    dropping_tables++;
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
    dropping_tables--;
1300 1301 1302
  }
  DBUG_VOID_RETURN;
}
unknown's avatar
unknown committed
1303

1304 1305
/*
  Close a cached table
unknown's avatar
unknown committed
1306

1307
  SYNOPSIS
unknown's avatar
unknown committed
1308
    close_cached_table()
1309 1310 1311 1312 1313 1314
    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
1315

1316 1317 1318 1319 1320 1321
  PREREQUISITES
    Lock on LOCK_open
    Win32 clients must also have a WRITE LOCK on the table !
*/
  
static bool close_cached_table(THD *thd, TABLE *table)
1322 1323
{
  DBUG_ENTER("close_cached_table");
1324
  
1325
  wait_while_table_is_used(thd, table, HA_EXTRA_PREPARE_FOR_DELETE);
1326 1327
  /* Close lock if this is not got with LOCK TABLES */
  if (thd->lock)
1328
  {
1329 1330
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;			// Start locked threads
unknown's avatar
unknown committed
1331
  }
1332 1333 1334 1335 1336
  /* 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);
1337
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1338 1339
}

1340
static int send_check_errmsg(THD *thd, TABLE_LIST* table,
unknown's avatar
unknown committed
1341
			     const char* operator_name, const char* errmsg)
1342

unknown's avatar
unknown committed
1343
{
1344 1345
  Protocol *protocol= thd->protocol;
  protocol->prepare_for_resend();
1346 1347 1348 1349
  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
1350
  thd->net.last_error[0]=0;
1351
  if (protocol->write())
unknown's avatar
unknown committed
1352 1353 1354 1355
    return -1;
  return 1;
}

1356

unknown's avatar
unknown committed
1357
static int prepare_for_restore(THD* thd, TABLE_LIST* table,
1358
			       HA_CHECK_OPT *check_opt)
unknown's avatar
unknown committed
1359
{
unknown's avatar
unknown committed
1360
  DBUG_ENTER("prepare_for_restore");
1361

unknown's avatar
unknown committed
1362 1363 1364 1365 1366 1367
  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
1368
  else
unknown's avatar
unknown committed
1369
  {
1370
    char* backup_dir= thd->lex->backup_dir;
unknown's avatar
unknown committed
1371
    char src_path[FN_REFLEN], dst_path[FN_REFLEN];
1372
    char* table_name = table->real_name;
unknown's avatar
unknown committed
1373
    char* db = thd->db ? thd->db : table->db;
1374

1375 1376
    if (fn_format_relative_to_data_home(src_path, table_name, backup_dir,
					reg_ext))
unknown's avatar
unknown committed
1377
      DBUG_RETURN(-1); // protect buffer overflow
unknown's avatar
unknown committed
1378

unknown's avatar
unknown committed
1379
    sprintf(dst_path, "%s/%s/%s", mysql_real_data_home, db, table_name);
1380

1381
    if (lock_and_wait_for_table_name(thd,table))
unknown's avatar
unknown committed
1382
      DBUG_RETURN(-1);
1383

1384
    if (my_copy(src_path,
1385 1386
		fn_format(dst_path, dst_path,"", reg_ext, 4),
		MYF(MY_WME)))
unknown's avatar
unknown committed
1387
    {
1388
      pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
1389
      unlock_table_name(thd, table);
1390
      pthread_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
1391 1392 1393
      DBUG_RETURN(send_check_errmsg(thd, table, "restore",
				    "Failed copying .frm file"));
    }
1394
    if (mysql_truncate(thd, table, 1))
unknown's avatar
unknown committed
1395
    {
1396
      pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
1397
      unlock_table_name(thd, table);
1398
      pthread_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
1399 1400
      DBUG_RETURN(send_check_errmsg(thd, table, "restore",
				    "Failed generating table from .frm file"));
unknown's avatar
unknown committed
1401
    }
unknown's avatar
unknown committed
1402
  }
unknown's avatar
unknown committed
1403

1404 1405 1406 1407
  /*
    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
1408
  if (!(table->table = reopen_name_locked_table(thd, table)))
1409 1410
  {
    pthread_mutex_lock(&LOCK_open);
1411
    unlock_table_name(thd, table);
1412 1413
    pthread_mutex_unlock(&LOCK_open);
  }
unknown's avatar
unknown committed
1414
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1415
}
1416

1417

unknown's avatar
unknown committed
1418
static int prepare_for_repair(THD* thd, TABLE_LIST *table_list,
1419
			      HA_CHECK_OPT *check_opt)
unknown's avatar
unknown committed
1420
{
unknown's avatar
unknown committed
1421 1422
  int error= 0;
  TABLE tmp_table, *table;
unknown's avatar
unknown committed
1423 1424 1425 1426
  DBUG_ENTER("prepare_for_repair");

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

  if (!(table= table_list->table))		/* if open_ltable failed */
unknown's avatar
unknown committed
1429
  {
unknown's avatar
unknown committed
1430 1431 1432 1433 1434 1435
    char name[FN_REFLEN];
    strxmov(name, mysql_data_home, "/", table_list->db, "/",
	    table_list->real_name, NullS);
    if (openfrm(name, "", 0, 0, 0, &tmp_table))
      DBUG_RETURN(0);				// Can't open frm file
    table= &tmp_table;
1436
  }
unknown's avatar
unknown committed
1437

unknown's avatar
unknown committed
1438 1439 1440 1441 1442 1443 1444 1445 1446
  /*
    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
1447

unknown's avatar
unknown committed
1448 1449 1450
  char from[FN_REFLEN],tmp[FN_REFLEN+32];
  const char **ext= table->file->bas_ext();
  MY_STAT stat_info;
unknown's avatar
unknown committed
1451

unknown's avatar
unknown committed
1452 1453 1454 1455 1456 1457
  /*
    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
1458

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

unknown's avatar
unknown committed
1463 1464
  sprintf(tmp,"%s-%lx_%lx", from, current_pid, thd->thread_id);

1465 1466 1467 1468 1469 1470 1471
  /* 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
1472
  if (lock_and_wait_for_table_name(thd,table_list))
unknown's avatar
unknown committed
1473
  {
unknown's avatar
unknown committed
1474 1475
    error= -1;
    goto end;
unknown's avatar
unknown committed
1476
  }
unknown's avatar
unknown committed
1477
  if (my_rename(from, tmp, MYF(MY_WME)))
unknown's avatar
unknown committed
1478
  {
1479
    pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
1480
    unlock_table_name(thd, table_list);
1481
    pthread_mutex_unlock(&LOCK_open);
unknown's avatar
unknown committed
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502
    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
1503 1504
  }

1505 1506 1507 1508
  /*
    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
1509
  if (!(table_list->table = reopen_name_locked_table(thd, table_list)))
unknown's avatar
unknown committed
1510 1511
  {
    pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
1512
    unlock_table_name(thd, table_list);
unknown's avatar
unknown committed
1513 1514
    pthread_mutex_unlock(&LOCK_open);
  }
unknown's avatar
unknown committed
1515 1516 1517 1518 1519

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

1522

1523 1524
static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
			     HA_CHECK_OPT* check_opt,
1525
			     const char *operator_name,
unknown's avatar
unknown committed
1526
			     thr_lock_type lock_type,
unknown's avatar
unknown committed
1527
			     bool open_for_modify,
unknown's avatar
unknown committed
1528
			     uint extra_open_options,
1529 1530
			     int (*prepare_func)(THD *, TABLE_LIST *,
						 HA_CHECK_OPT *),
1531 1532
			     int (handler::*operator_func)
			     (THD *, HA_CHECK_OPT *))
unknown's avatar
unknown committed
1533 1534 1535
{
  TABLE_LIST *table;
  List<Item> field_list;
1536 1537
  Item *item;
  Protocol *protocol= thd->protocol;
1538
  DBUG_ENTER("mysql_admin_table");
unknown's avatar
unknown committed
1539 1540 1541 1542 1543 1544 1545 1546 1547

  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;
1548
  if (protocol->send_fields(&field_list, 1))
unknown's avatar
unknown committed
1549 1550
    DBUG_RETURN(-1);

1551
  mysql_ha_closeall(thd, tables);
unknown's avatar
unknown committed
1552 1553 1554 1555
  for (table = tables; table; table = table->next)
  {
    char table_name[NAME_LEN*2+2];
    char* db = (table->db) ? table->db : thd->db;
1556
    bool fatal_error=0;
1557
    strxmov(table_name,db ? db : "",".",table->real_name,NullS);
unknown's avatar
unknown committed
1558

unknown's avatar
unknown committed
1559
    thd->open_options|= extra_open_options;
1560
    table->table = open_ltable(thd, table, lock_type);
1561 1562 1563
#ifdef EMBEDDED_LIBRARY
    thd->net.last_errno= 0;  // these errors shouldn't get client
#endif
unknown's avatar
unknown committed
1564
    thd->open_options&= ~extra_open_options;
1565

unknown's avatar
unknown committed
1566
    if (prepare_func)
1567
    {
unknown's avatar
unknown committed
1568
      switch ((*prepare_func)(thd, table, check_opt)) {
unknown's avatar
unknown committed
1569 1570 1571
        case  1: continue; // error, message written to net
        case -1: goto err; // error, message could be written to net
        default:         ; // should be 0 otherwise
unknown's avatar
unknown committed
1572
      }
1573
    }
1574

unknown's avatar
unknown committed
1575 1576 1577
    if (!table->table)
    {
      const char *err_msg;
1578
      protocol->prepare_for_resend();
1579 1580 1581
      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
1582 1583
      if (!(err_msg=thd->net.last_error))
	err_msg=ER(ER_CHECK_NO_SUCH_TABLE);
1584
      protocol->store(err_msg, system_charset_info);
unknown's avatar
unknown committed
1585
      thd->net.last_error[0]=0;
1586
      if (protocol->write())
unknown's avatar
unknown committed
1587 1588 1589
	goto err;
      continue;
    }
unknown's avatar
unknown committed
1590
    table->table->pos_in_table_list= table;
1591
    if ((table->table->db_stat & HA_READ_ONLY) && open_for_modify)
unknown's avatar
unknown committed
1592
    {
unknown's avatar
unknown committed
1593
      char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
1594
      protocol->prepare_for_resend();
1595 1596 1597
      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
1598
      sprintf(buff, ER(ER_OPEN_AS_READONLY), table_name);
1599
      protocol->store(buff, system_charset_info);
1600
      close_thread_tables(thd);
unknown's avatar
unknown committed
1601
      table->table=0;				// For query cache
1602
      if (protocol->write())
unknown's avatar
unknown committed
1603 1604 1605 1606
	goto err;
      continue;
    }

1607
    /* Close all instances of the table to allow repair to rename files */
1608
    if (lock_type == TL_WRITE && table->table->version)
1609 1610
    {
      pthread_mutex_lock(&LOCK_open);
1611 1612
      const char *old_message=thd->enter_cond(&COND_refresh, &LOCK_open,
					      "Waiting to get writelock");
1613 1614 1615 1616 1617 1618 1619 1620 1621
      mysql_lock_abort(thd,table->table);
      while (remove_table_from_cache(thd, table->table->table_cache_key,
				     table->table->real_name) &&
	     ! thd->killed)
      {
	dropping_tables++;
	(void) pthread_cond_wait(&COND_refresh,&LOCK_open);
	dropping_tables--;
      }
1622
      thd->exit_cond(old_message);
1623 1624 1625
      pthread_mutex_unlock(&LOCK_open);
      if (thd->killed)
	goto err;
unknown's avatar
unknown committed
1626
      open_for_modify=0;
1627 1628
    }

1629
    int result_code = (table->table->file->*operator_func)(thd, check_opt);
unknown's avatar
unknown committed
1630 1631 1632
#ifdef EMBEDDED_LIBRARY
    thd->net.last_errno= 0;  // these errors shouldn't get client
#endif
1633
    protocol->prepare_for_resend();
1634 1635
    protocol->store(table_name, system_charset_info);
    protocol->store(operator_name, system_charset_info);
unknown's avatar
unknown committed
1636

1637 1638
    switch (result_code) {
    case HA_ADMIN_NOT_IMPLEMENTED:
1639 1640
      {
        char buf[ERRMSGSIZE+20];
1641 1642
        uint length=my_snprintf(buf, ERRMSGSIZE,
				ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);
1643 1644
        protocol->store("error", 5, system_charset_info);
        protocol->store(buf, length, system_charset_info);
1645
      }
unknown's avatar
unknown committed
1646 1647
      break;

1648
    case HA_ADMIN_OK:
1649 1650
      protocol->store("status", 6, system_charset_info);
      protocol->store("OK",2, system_charset_info);
unknown's avatar
unknown committed
1651 1652
      break;

1653
    case HA_ADMIN_FAILED:
1654 1655
      protocol->store("status", 6, system_charset_info);
      protocol->store("Operation failed",16, system_charset_info);
unknown's avatar
unknown committed
1656 1657
      break;

1658
    case HA_ADMIN_ALREADY_DONE:
1659 1660
      protocol->store("status", 6, system_charset_info);
      protocol->store("Table is already up to date", 27, system_charset_info);
1661 1662
      break;

1663
    case HA_ADMIN_CORRUPT:
1664
      protocol->store("error", 5, system_charset_info);
1665
      protocol->store("Corrupt", 7, system_charset_info);
1666
      fatal_error=1;
unknown's avatar
unknown committed
1667 1668
      break;

unknown's avatar
unknown committed
1669
    case HA_ADMIN_INVALID:
1670 1671
      protocol->store("error", 5, system_charset_info);
      protocol->store("Invalid argument",16, system_charset_info);
unknown's avatar
unknown committed
1672 1673
      break;

1674
    default:				// Probably HA_ADMIN_INTERNAL_ERROR
1675 1676 1677
      protocol->store("error", 5, system_charset_info);
      protocol->store("Unknown - internal error during operation", 41
		      , system_charset_info);
1678
      fatal_error=1;
unknown's avatar
unknown committed
1679 1680
      break;
    }
1681
    if (fatal_error)
1682
      table->table->version=0;			// Force close of table
unknown's avatar
unknown committed
1683
    else if (open_for_modify)
1684
    {
1685
      pthread_mutex_lock(&LOCK_open);
unknown's avatar
unknown committed
1686 1687
      remove_table_from_cache(thd, table->table->table_cache_key,
			      table->table->real_name);
1688
      pthread_mutex_unlock(&LOCK_open);
1689 1690 1691
      /* May be something modified consequently we have to invalidate cache */
      query_cache_invalidate3(thd, table->table, 0);
    }
unknown's avatar
unknown committed
1692
    close_thread_tables(thd);
unknown's avatar
unknown committed
1693
    table->table=0;				// For query cache
1694
    if (protocol->write())
unknown's avatar
unknown committed
1695 1696 1697
      goto err;
  }

1698
  send_eof(thd);
unknown's avatar
unknown committed
1699 1700
  DBUG_RETURN(0);
 err:
1701
  close_thread_tables(thd);			// Shouldn't be needed
unknown's avatar
unknown committed
1702 1703
  if (table)
    table->table=0;
unknown's avatar
unknown committed
1704 1705 1706
  DBUG_RETURN(-1);
}

unknown's avatar
unknown committed
1707

unknown's avatar
unknown committed
1708 1709 1710 1711
int mysql_backup_table(THD* thd, TABLE_LIST* table_list)
{
  DBUG_ENTER("mysql_backup_table");
  DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
1712
				"backup", TL_READ, 0, 0, 0,
unknown's avatar
unknown committed
1713 1714
				&handler::backup));
}
unknown's avatar
unknown committed
1715

1716

unknown's avatar
unknown committed
1717 1718 1719 1720
int mysql_restore_table(THD* thd, TABLE_LIST* table_list)
{
  DBUG_ENTER("mysql_restore_table");
  DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
unknown's avatar
unknown committed
1721 1722
				"restore", TL_WRITE, 1, 0,
                                &prepare_for_restore,
unknown's avatar
unknown committed
1723 1724
				&handler::restore));
}
unknown's avatar
unknown committed
1725

1726

1727 1728 1729 1730
int mysql_repair_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
{
  DBUG_ENTER("mysql_repair_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
unknown's avatar
unknown committed
1731 1732
				"repair", TL_WRITE, 1, HA_OPEN_FOR_REPAIR,
                                &prepare_for_repair,
1733 1734 1735
				&handler::repair));
}

1736

1737 1738 1739 1740
int mysql_optimize_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
{
  DBUG_ENTER("mysql_optimize_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
unknown's avatar
unknown committed
1741
				"optimize", TL_WRITE, 1,0,0,
1742 1743 1744 1745
				&handler::optimize));
}


unknown's avatar
unknown committed
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758
/*
  Assigned specified indexes for a table into key cache

  SYNOPSIS
    mysql_assign_to_keycache()
    thd	        Thread object
    tables      Table list (one table only)

  RETURN VALUES
    0	  ok
   -1	  error
*/

1759 1760
int mysql_assign_to_keycache(THD* thd, TABLE_LIST* tables,
			     LEX_STRING *key_cache_name)
unknown's avatar
unknown committed
1761
{
1762
  HA_CHECK_OPT check_opt;
unknown's avatar
unknown committed
1763
  KEY_CACHE *key_cache;
unknown's avatar
unknown committed
1764
  DBUG_ENTER("mysql_assign_to_keycache");
1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777

  check_opt.init();
  pthread_mutex_lock(&LOCK_global_system_variables);
  if (!(key_cache= get_key_cache(key_cache_name)))
  {
    pthread_mutex_unlock(&LOCK_global_system_variables);
    my_error(ER_UNKNOWN_KEY_CACHE, MYF(0), key_cache_name->str);
    DBUG_RETURN(-1);
  }
  pthread_mutex_unlock(&LOCK_global_system_variables);
  check_opt.key_cache= key_cache;
  DBUG_RETURN(mysql_admin_table(thd, tables, &check_opt,
				"assign_to_keycache", TL_READ_NO_INSERT, 0, 
unknown's avatar
unknown committed
1778
                                0, 0, &handler::assign_to_keycache));
unknown's avatar
unknown committed
1779 1780
}

unknown's avatar
unknown committed
1781 1782 1783 1784 1785 1786 1787 1788

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

  SYNOPSIS
    reassign_keycache_tables()
    thd	        Thread object
    src_cache   Reference to the key cache to clean up
1789
    dest_cache  New key cache
unknown's avatar
unknown committed
1790

1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803
  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
1804 1805 1806
    0	  ok
*/

unknown's avatar
unknown committed
1807 1808
int reassign_keycache_tables(THD *thd, KEY_CACHE *src_cache, 
                             KEY_CACHE *dst_cache)
unknown's avatar
unknown committed
1809 1810 1811
{
  DBUG_ENTER("reassign_keycache_tables");

1812 1813
  DBUG_ASSERT(src_cache != dst_cache);
  DBUG_ASSERT(src_cache->in_init);
unknown's avatar
unknown committed
1814
  src_cache->param_buff_size= 0;		// Free key cache
1815 1816
  ha_resize_key_cache(src_cache);
  ha_change_key_cache(src_cache, dst_cache);
unknown's avatar
unknown committed
1817 1818 1819 1820
  DBUG_RETURN(0);            
}


unknown's avatar
unknown committed
1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842
/*
  Preload specified indexes for a table into key cache

  SYNOPSIS
    mysql_preload_keys()
    thd	        Thread object
    tables      Table list (one table only)

  RETURN VALUES
    0	  ok
   -1	  error
*/

int mysql_preload_keys(THD* thd, TABLE_LIST* tables)
{
  DBUG_ENTER("mysql_preload_keys");
  DBUG_RETURN(mysql_admin_table(thd, tables, 0,
				"preload_keys", TL_READ, 0, 0, 0,
				&handler::preload_keys));
}


unknown's avatar
unknown committed
1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878
/*
  Create a table identical to the specified table

  SYNOPSIS
    mysql_create_like_table()
    thd	        Thread object
    table       Table list (one table only)
    create_info Create info
    table_ident Src table_ident

  RETURN VALUES
    0	  ok
    -1	error
*/

int mysql_create_like_table(THD* thd, TABLE_LIST* table, 
                            HA_CREATE_INFO *create_info,
                            Table_ident *table_ident)
{
  TABLE **tmp_table;
  char src_path[FN_REFLEN], dst_path[FN_REFLEN];
  char *db= table->db;
  char *table_name= table->real_name;
  char *src_db= thd->db;
  char *src_table= table_ident->table.str;
  int  err;
  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)))
  {
1879
    my_error(ER_WRONG_TABLE_NAME, MYF(0), src_table);
unknown's avatar
unknown committed
1880
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935
  }

  if ((tmp_table= find_temporary_table(thd, src_db, src_table)))
    strxmov(src_path, (*tmp_table)->path, reg_ext, NullS);
  else
  {
    strxmov(src_path, mysql_data_home, "/", src_db, "/", src_table, 
            reg_ext, NullS); 
    if (access(src_path, F_OK))
    {
      my_error(ER_BAD_TABLE_ERROR, MYF(0), src_table);
      DBUG_RETURN(-1);
    }
  }

  /*
    Validate the destination table

    skip the destination table name checking as this is already 
    validated.
  */
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
    if (find_temporary_table(thd, db, table_name))
      goto table_exists;
    sprintf(dst_path,"%s%s%lx_%lx_%x%s",mysql_tmpdir,tmp_file_prefix,
	    current_pid, thd->thread_id, thd->tmp_table++,reg_ext);
    create_info->table_options|= HA_CREATE_DELAY_KEY_WRITE;
  }
  else
  {
    strxmov(dst_path, mysql_data_home, "/", db, "/", table_name, 
            reg_ext, NullS); 
    if (!access(dst_path, F_OK))
      goto table_exists;
  }

  /* 
    Create a new table by copying from source table
  */
  if (my_copy(src_path, dst_path, MYF(MY_WME)))
    DBUG_RETURN(-1);

  /*
    As mysql_truncate don't work on a new table at this stage of 
    creation, instead create the table directly (for both normal 
    and temporary tables).
  */
  *fn_ext(dst_path)= 0; 
  err= ha_create_table(dst_path, create_info, 1);
  
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
    if (err || !open_temporary_table(thd, dst_path, db, table_name, 1))
    {
unknown's avatar
unknown committed
1936 1937 1938
      (void) rm_temporary_table(create_info->db_type, 
                                dst_path); /* purecov: inspected */
      DBUG_RETURN(-1);     /* purecov: inspected */
unknown's avatar
unknown committed
1939 1940 1941 1942
    }
  }
  else if (err)
  {
unknown's avatar
unknown committed
1943 1944 1945
    (void) quick_rm_table(create_info->db_type, db, 
                          table_name); /* purecov: inspected */
    DBUG_RETURN(-1);       /* purecov: inspected */
unknown's avatar
unknown committed
1946
  }
1947 1948 1949 1950

  // Must be written before unlock
  mysql_update_log.write(thd,thd->query, thd->query_length);
  if (mysql_bin_log.is_open())
unknown's avatar
unknown committed
1951
  {
1952 1953 1954 1955 1956
    thd->clear_error();
    Query_log_event qinfo(thd, thd->query, thd->query_length,
			  test(create_info->options &
			       HA_LEX_CREATE_TMP_TABLE));
    mysql_bin_log.write(&qinfo);
unknown's avatar
unknown committed
1957
  }
unknown's avatar
unknown committed
1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
  DBUG_RETURN(0);
  
table_exists:
  if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
  {
    char warn_buff[MYSQL_ERRMSG_SIZE];
    sprintf(warn_buff,ER(ER_TABLE_EXISTS_ERROR),table_name);
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
                 ER_TABLE_EXISTS_ERROR,warn_buff);
    DBUG_RETURN(0);
  }
  my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
  DBUG_RETURN(-1);
}


1974 1975
int mysql_analyze_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
{
unknown's avatar
unknown committed
1976 1977 1978 1979 1980 1981
#ifdef OS2
  thr_lock_type lock_type = TL_WRITE;
#else
  thr_lock_type lock_type = TL_READ_NO_INSERT;
#endif

1982 1983
  DBUG_ENTER("mysql_analyze_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
unknown's avatar
unknown committed
1984
				"analyze", lock_type, 1,0,0,
1985 1986 1987 1988 1989 1990
				&handler::analyze));
}


int mysql_check_table(THD* thd, TABLE_LIST* tables,HA_CHECK_OPT* check_opt)
{
unknown's avatar
unknown committed
1991 1992 1993 1994 1995 1996
#ifdef OS2
  thr_lock_type lock_type = TL_WRITE;
#else
  thr_lock_type lock_type = TL_READ_NO_INSERT;
#endif

1997 1998
  DBUG_ENTER("mysql_check_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
unknown's avatar
unknown committed
1999
				"check", lock_type,
unknown's avatar
unknown committed
2000
				0, HA_OPEN_FOR_REPAIR, 0,
2001 2002 2003
				&handler::check));
}

unknown's avatar
unknown committed
2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059
/* table_list should contain just one table */
int mysql_discard_or_import_tablespace(THD *thd,
		      TABLE_LIST *table_list,
		      enum tablespace_op_type tablespace_op)
{
  TABLE *table;
  my_bool discard;
  int error;
  DBUG_ENTER("mysql_discard_or_import_tablespace");

  /* Note that DISCARD/IMPORT TABLESPACE always is the only operation in an
  ALTER TABLE */

  thd->proc_info="discard_or_import_tablespace";

  if (tablespace_op == DISCARD_TABLESPACE)
    discard = TRUE;
  else
    discard = FALSE;

  thd->tablespace_op=TRUE; /* we set this flag so that ha_innobase::open
			   and ::external_lock() do not complain when we
			   lock the table */
  mysql_ha_closeall(thd, table_list);

  if (!(table=open_ltable(thd,table_list,TL_WRITE)))
  {
    thd->tablespace_op=FALSE;
    DBUG_RETURN(-1);
  }
  
  error=table->file->discard_or_import_tablespace(discard);

  thd->proc_info="end";

  if (error)
    goto err;

  /* The 0 in the call below means 'not in a transaction', which means
  immediate invalidation; that is probably what we wish here */
  query_cache_invalidate3(thd, table_list, 0);

  /* The ALTER TABLE is always in its own transaction */
  error = ha_commit_stmt(thd);
  if (ha_commit(thd))
    error=1;
  if (error)
    goto err;
  mysql_update_log.write(thd, thd->query,thd->query_length);
  if (mysql_bin_log.is_open())
  {
    Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
    mysql_bin_log.write(&qinfo);
  }
err:
  close_thread_tables(thd);
unknown's avatar
unknown committed
2060
  thd->tablespace_op=FALSE;
unknown's avatar
unknown committed
2061 2062 2063 2064 2065 2066
  if (error == 0) {
    send_ok(thd);
   DBUG_RETURN(0);
  }
  DBUG_RETURN(error);
}
unknown's avatar
unknown committed
2067 2068 2069 2070 2071 2072 2073

int 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,List<Alter_drop> &drop_list,
		      List<Alter_column> &alter_list,
2074
                      uint order_num, ORDER *order,
2075
		      enum enum_duplicates handle_duplicates,
unknown's avatar
unknown committed
2076
	              enum enum_enable_or_disable keys_onoff,
unknown's avatar
unknown committed
2077
		      enum tablespace_op_type tablespace_op,
2078
                      bool simple_alter)
unknown's avatar
unknown committed
2079 2080 2081
{
  TABLE *table,*new_table;
  int error;
unknown's avatar
unknown committed
2082 2083
  char tmp_name[80],old_name[32],new_name_buff[FN_REFLEN];
  char new_alias_buff[FN_REFLEN], *table_name, *db, *new_alias, *alias;
2084
  char index_file[FN_REFLEN], data_file[FN_REFLEN];
unknown's avatar
unknown committed
2085
  bool use_timestamp=0;
unknown's avatar
unknown committed
2086 2087
  ha_rows copied,deleted;
  ulonglong next_insert_id;
2088
  uint save_time_stamp,db_create_options, used_fields;
unknown's avatar
unknown committed
2089 2090 2091 2092 2093
  enum db_type old_db_type,new_db_type;
  DBUG_ENTER("mysql_alter_table");

  thd->proc_info="init";
  table_name=table_list->real_name;
unknown's avatar
unknown committed
2094 2095
  alias= (lower_case_table_names == 2) ? table_list->alias : table_name;

unknown's avatar
unknown committed
2096
  db=table_list->db;
unknown's avatar
unknown committed
2097
  if (!new_db || !my_strcasecmp(table_alias_charset, new_db, db))
2098 2099 2100
  {
    new_db= db;
  }
2101
  used_fields=create_info->used_fields;
unknown's avatar
unknown committed
2102

2103
  mysql_ha_closeall(thd, table_list);
unknown's avatar
unknown committed
2104

unknown's avatar
unknown committed
2105
  /* DISCARD/IMPORT TABLESPACE is always alone in an ALTER TABLE */
unknown's avatar
unknown committed
2106 2107
  if (tablespace_op != NO_TABLESPACE_OP)
    DBUG_RETURN(mysql_discard_or_import_tablespace(thd,table_list,
unknown's avatar
unknown committed
2108
						   tablespace_op));
unknown's avatar
unknown committed
2109 2110 2111 2112 2113 2114 2115
  if (!(table=open_ltable(thd,table_list,TL_WRITE_ALLOW_READ)))
    DBUG_RETURN(-1);

  /* Check that we are not trying to rename to an existing table */
  if (new_name)
  {
    strmov(new_name_buff,new_name);
2116
    strmov(new_alias= new_alias_buff, new_name);
unknown's avatar
unknown committed
2117
    if (lower_case_table_names)
unknown's avatar
unknown committed
2118 2119 2120
    {
      if (lower_case_table_names != 2)
      {
unknown's avatar
unknown committed
2121
	my_casedn_str(system_charset_info, new_name_buff);
unknown's avatar
unknown committed
2122 2123
	new_alias= new_name;			// Create lower case table name
      }
unknown's avatar
unknown committed
2124
      my_casedn_str(system_charset_info, new_name);
unknown's avatar
unknown committed
2125
    }
2126
    if (new_db == db &&
unknown's avatar
unknown committed
2127
	!my_strcasecmp(table_alias_charset, new_name_buff, table_name))
2128 2129 2130 2131 2132
    {
      /*
        Source and destination table names are equal: make later check
        easier.
      */
unknown's avatar
unknown committed
2133
      new_alias= new_name= table_name;
2134
    }
unknown's avatar
unknown committed
2135 2136 2137 2138 2139 2140
    else
    {
      if (table->tmp_table)
      {
	if (find_temporary_table(thd,new_db,new_name_buff))
	{
unknown's avatar
unknown committed
2141
	  my_error(ER_TABLE_EXISTS_ERROR,MYF(0),new_name_buff);
unknown's avatar
unknown committed
2142 2143 2144 2145 2146 2147 2148 2149 2150
	  DBUG_RETURN(-1);
	}
      }
      else
      {
	if (!access(fn_format(new_name_buff,new_name_buff,new_db,reg_ext,0),
		    F_OK))
	{
	  /* Table will be closed in do_command() */
unknown's avatar
unknown committed
2151
	  my_error(ER_TABLE_EXISTS_ERROR,MYF(0), new_alias);
unknown's avatar
unknown committed
2152 2153 2154 2155 2156 2157
	  DBUG_RETURN(-1);
	}
      }
    }
  }
  else
unknown's avatar
unknown committed
2158
    new_alias= new_name= table_name;
unknown's avatar
unknown committed
2159 2160 2161 2162

  old_db_type=table->db_type;
  if (create_info->db_type == DB_TYPE_DEFAULT)
    create_info->db_type=old_db_type;
2163 2164 2165 2166 2167 2168 2169
  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
2170
			ha_get_storage_engine(new_db_type),
2171 2172
			new_name);
  }
2173
  if (create_info->row_type == ROW_TYPE_NOT_USED)
unknown's avatar
unknown committed
2174 2175 2176
    create_info->row_type=table->row_type;

  thd->proc_info="setup";
2177
  if (simple_alter && !table->tmp_table)
unknown's avatar
unknown committed
2178 2179
  {
    error=0;
2180
    if (new_name != table_name || new_db != db)
unknown's avatar
unknown committed
2181
    {
2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193
      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))
      {
        my_error(ER_TABLE_EXISTS_ERROR,MYF(0),new_name);
        error= -1;
      }
      else
      {
        *fn_ext(new_name)=0;
2194
        close_cached_table(thd, table);
unknown's avatar
unknown committed
2195
        if (mysql_rename_table(old_db_type,db,table_name,new_db,new_alias))
2196 2197 2198
	  error= -1;
      }
      VOID(pthread_mutex_unlock(&LOCK_open));
unknown's avatar
unknown committed
2199
    }
unknown's avatar
unknown committed
2200

2201
    if (!error)
2202
    {
2203 2204 2205 2206
      switch (keys_onoff) {
      case LEAVE_AS_IS:
	break;
      case ENABLE:
2207
	VOID(pthread_mutex_lock(&LOCK_open));
2208
	wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
2209 2210 2211
	VOID(pthread_mutex_unlock(&LOCK_open));
	error= table->file->activate_all_index(thd);
	/* COND_refresh will be signaled in close_thread_tables() */
2212 2213
	break;
      case DISABLE:
unknown's avatar
unknown committed
2214 2215 2216
 	if (table->db_type == DB_TYPE_MYISAM)
 	{
	  VOID(pthread_mutex_lock(&LOCK_open));
unknown's avatar
unknown committed
2217
	  wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
unknown's avatar
unknown committed
2218 2219
	  VOID(pthread_mutex_unlock(&LOCK_open));
 	  table->file->deactivate_non_unique_index(HA_POS_ERROR);
2220
	/* COND_refresh will be signaled in close_thread_tables() */
unknown's avatar
unknown committed
2221 2222 2223 2224 2225
 	}
 	else
 	  push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
 			      ER_ILLEGAL_HA,
 			      ER(ER_ILLEGAL_HA), table->table_name);
2226
	break;
2227
      }
2228
    }
unknown's avatar
unknown committed
2229 2230
    if (!error)
    {
2231 2232 2233
      mysql_update_log.write(thd, thd->query, thd->query_length);
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
2234
        thd->clear_error();
2235
	Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
2236 2237
	mysql_bin_log.write(&qinfo);
      }
2238
      send_ok(thd);
unknown's avatar
unknown committed
2239
    }
2240 2241
    table_list->table=0;				// For query cache
    query_cache_invalidate3(thd, table_list, 0);
unknown's avatar
unknown committed
2242 2243 2244 2245
    DBUG_RETURN(error);
  }

  /* Full alter table */
2246 2247 2248 2249 2250 2251 2252 2253

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

unknown's avatar
unknown committed
2257
  restore_record(table,default_values);		// Empty record for DEFAULT
unknown's avatar
unknown committed
2258 2259 2260 2261 2262
  List_iterator<Alter_drop> drop_it(drop_list);
  List_iterator<create_field> def_it(fields);
  List_iterator<Alter_column> alter_it(alter_list);
  List<create_field> create_list;		// Add new fields here
  List<Key> key_list;				// Add new keys here
2263 2264
  create_field *def;

unknown's avatar
unknown committed
2265
  /*
2266
    First collect all fields from table which isn't in drop_list
unknown's avatar
unknown committed
2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277
  */

  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 &&
2278
	  !my_strcasecmp(system_charset_info,field->field_name, drop->name))
2279 2280 2281
      {
	/* Reset auto_increment value if it was dropped */
	if (MTYP_TYPENR(field->unireg_check) == Field::NEXT_NUMBER &&
2282
	    !(used_fields & HA_CREATE_USED_AUTO))
2283 2284 2285 2286
	{
	  create_info->auto_increment_value=0;
	  create_info->used_fields|=HA_CREATE_USED_AUTO;
	}
unknown's avatar
unknown committed
2287
	break;
2288
      }
unknown's avatar
unknown committed
2289 2290 2291 2292 2293 2294 2295 2296 2297 2298
    }
    if (drop)
    {
      drop_it.remove();
      continue;
    }
    /* Check if field is changed */
    def_it.rewind();
    while ((def=def_it++))
    {
2299
      if (def->change &&
2300
          !my_strcasecmp(system_charset_info,field->field_name, def->change))
unknown's avatar
unknown committed
2301 2302 2303 2304 2305 2306 2307
	break;
    }
    if (def)
    {						// Field is changed
      def->field=field;
      if (def->sql_type == FIELD_TYPE_TIMESTAMP)
	use_timestamp=1;
2308 2309 2310 2311 2312
      if (!def->after)
      {
	create_list.push_back(def);
	def_it.remove();
      }
unknown's avatar
unknown committed
2313 2314 2315
    }
    else
    {						// Use old field value
2316
      create_list.push_back(def=new create_field(field,field));
unknown's avatar
unknown committed
2317 2318 2319 2320 2321 2322 2323
      if (def->sql_type == FIELD_TYPE_TIMESTAMP)
	use_timestamp=1;

      alter_it.rewind();			// Change default if ALTER
      Alter_column *alter;
      while ((alter=alter_it++))
      {
2324
	if (!my_strcasecmp(system_charset_info,field->field_name, alter->name))
unknown's avatar
unknown committed
2325 2326 2327 2328
	  break;
      }
      if (alter)
      {
2329 2330 2331 2332 2333
        if (def->sql_type == FIELD_TYPE_BLOB)
        {
          my_error(ER_BLOB_CANT_HAVE_DEFAULT,MYF(0),def->change);
          DBUG_RETURN(-1);
        }
unknown's avatar
unknown committed
2334 2335 2336 2337 2338 2339 2340 2341 2342
	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
  {
2343
    if (def->change && ! def->field)
unknown's avatar
unknown committed
2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357
    {
      my_error(ER_BAD_FIELD_ERROR,MYF(0),def->change,table_name);
      DBUG_RETURN(-1);
    }
    if (!def->after)
      create_list.push_back(def);
    else if (def->after == first_keyword)
      create_list.push_front(def);
    else
    {
      create_field *find;
      find_it.rewind();
      while ((find=find_it++))			// Add new columns
      {
2358
	if (!my_strcasecmp(system_charset_info,def->after, find->field_name))
unknown's avatar
unknown committed
2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380
	  break;
      }
      if (!find)
      {
	my_error(ER_BAD_FIELD_ERROR,MYF(0),def->after,table_name);
	DBUG_RETURN(-1);
      }
      find_it.after(def);			// Put element after this
    }
  }
  if (alter_list.elements)
  {
    my_error(ER_BAD_FIELD_ERROR,MYF(0),alter_list.head()->name,table_name);
    DBUG_RETURN(-1);
  }
  if (!create_list.elements)
  {
    my_error(ER_CANT_REMOVE_ALL_FIELDS,MYF(0));
    DBUG_RETURN(-1);
  }

  /*
2381 2382
    Collect all keys which isn't in drop list. Add only those
    for which some fields exists.
unknown's avatar
unknown committed
2383 2384 2385 2386 2387 2388 2389 2390 2391
  */

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

  KEY *key_info=table->key_info;
  for (uint i=0 ; i < table->keys ; i++,key_info++)
  {
2392
    char *key_name= key_info->name;
unknown's avatar
unknown committed
2393 2394 2395 2396 2397
    Alter_drop *drop;
    drop_it.rewind();
    while ((drop=drop_it++))
    {
      if (drop->type == Alter_drop::KEY &&
2398
	  !my_strcasecmp(system_charset_info,key_name, drop->name))
unknown's avatar
unknown committed
2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419
	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
2420 2421
	  if (!my_strcasecmp(system_charset_info, key_part_name,
			     cfield->change))
unknown's avatar
unknown committed
2422 2423
	    break;
	}
2424 2425
	else if (!my_strcasecmp(system_charset_info,
                                key_part_name, cfield->field_name))
unknown's avatar
unknown committed
2426
	  break;
unknown's avatar
unknown committed
2427 2428 2429 2430 2431 2432 2433 2434
      }
      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 ||
2435
	     cfield->length <= key_part_length /
2436
			       key_part->field->charset()->mbmaxlen))
unknown's avatar
unknown committed
2437 2438
	  key_part_length=0;			// Use whole field
      }
2439
      key_part_length /= key_part->field->charset()->mbmaxlen;
unknown's avatar
unknown committed
2440 2441 2442 2443
      key_parts.push_back(new key_part_spec(cfield->field_name,
					    key_part_length));
    }
    if (key_parts.elements)
unknown's avatar
unknown committed
2444 2445
      key_list.push_back(new Key(key_info->flags & HA_SPATIAL ? Key::SPATIAL :
                                 (key_info->flags & HA_NOSAME ?
2446
				 (!my_strcasecmp(system_charset_info,
2447
                                                 key_name, primary_key_name) ?
unknown's avatar
unknown committed
2448
				  Key::PRIMARY  : Key::UNIQUE) :
2449 2450 2451
				  (key_info->flags & HA_FULLTEXT ?
				   Key::FULLTEXT : Key::MULTIPLE)),
				 key_name,
2452
                                 key_info->algorithm,
2453
				 key_parts));
unknown's avatar
unknown committed
2454 2455 2456 2457
  }
  {
    Key *key;
    while ((key=key_it++))			// Add new keys
2458 2459 2460
    {
      if (key->type != Key::FOREIGN_KEY)
	key_list.push_back(key);
2461 2462 2463 2464 2465 2466
      if (key->name &&
	  !my_strcasecmp(system_charset_info,key->name,primary_key_name))
      {
	my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name);
	DBUG_RETURN(-1);
      }
2467
    }
unknown's avatar
unknown committed
2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480
  }

  if (drop_list.elements)
  {
    my_error(ER_CANT_DROP_FIELD_OR_KEY,MYF(0),drop_list.head()->name);
    goto err;
  }
  if (alter_list.elements)
  {
    my_error(ER_CANT_DROP_FIELD_OR_KEY,MYF(0),alter_list.head()->name);
    goto err;
  }

2481
  db_create_options=table->db_create_options & ~(HA_OPTION_PACK_RECORD);
unknown's avatar
unknown committed
2482 2483 2484 2485 2486
  (void) sprintf(tmp_name,"%s-%lx_%lx", tmp_file_prefix, current_pid,
		 thd->thread_id);
  create_info->db_type=new_db_type;
  if (!create_info->comment)
    create_info->comment=table->comment;
2487 2488 2489 2490 2491

  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
2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504
    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;

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

2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548
  /*
    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);
    }
  }
2549 2550
  else
    create_info->data_file_name=create_info->index_file_name=0;
2551

unknown's avatar
unknown committed
2552 2553
  if ((error=mysql_create_table(thd, new_db, tmp_name,
				create_info,
2554
				create_list,key_list,1,1,0))) // no logging
unknown's avatar
unknown committed
2555
    DBUG_RETURN(error);
unknown's avatar
unknown committed
2556 2557 2558 2559

  if (table->tmp_table)
    new_table=open_table(thd,new_db,tmp_name,tmp_name,0);
  else
unknown's avatar
unknown committed
2560
  {
unknown's avatar
unknown committed
2561 2562 2563 2564 2565 2566 2567 2568 2569
    char path[FN_REFLEN];
    (void) sprintf(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
2570 2571 2572 2573 2574 2575
  }

  save_time_stamp=new_table->time_stamp;
  if (use_timestamp)
    new_table->time_stamp=0;
  new_table->next_number_field=new_table->found_next_number_field;
2576
  thd->count_cuted_fields= CHECK_FIELD_WARN;	// calc cuted fields
unknown's avatar
unknown committed
2577 2578
  thd->cuted_fields=0L;
  thd->proc_info="copy to tmp table";
unknown's avatar
unknown committed
2579
  next_insert_id=thd->next_insert_id;		// Remember for loggin
unknown's avatar
unknown committed
2580 2581 2582 2583
  copied=deleted=0;
  if (!new_table->is_view)
    error=copy_data_between_tables(table,new_table,create_list,
				   handle_duplicates,
2584
				   order_num, order, &copied, &deleted);
unknown's avatar
unknown committed
2585
  thd->last_insert_id=next_insert_id;		// Needed for correct log
2586
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
unknown's avatar
unknown committed
2587 2588 2589 2590 2591 2592 2593
  new_table->time_stamp=save_time_stamp;

  if (table->tmp_table)
  {
    /* We changed a temporary table */
    if (error)
    {
unknown's avatar
unknown committed
2594 2595 2596
      /*
	The following function call will free the new_table pointer,
	in close_temporary_table(), so we can safely directly jump to err
2597
      */
unknown's avatar
unknown committed
2598 2599 2600
      close_temporary_table(thd,new_db,tmp_name);
      goto err;
    }
2601 2602 2603 2604 2605 2606
    /* 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
2607 2608
    /* Remove link to old table and rename the new one */
    close_temporary_table(thd,table->table_cache_key,table_name);
unknown's avatar
unknown committed
2609
    if (rename_temporary_table(thd, new_table, new_db, new_alias))
unknown's avatar
unknown committed
2610 2611 2612 2613 2614
    {						// Fatal error
      close_temporary_table(thd,new_db,tmp_name);
      my_free((gptr) new_table,MYF(0));
      goto err;
    }
2615 2616 2617
    mysql_update_log.write(thd, thd->query,thd->query_length);
    if (mysql_bin_log.is_open())
    {
unknown's avatar
unknown committed
2618
      thd->clear_error();
2619
      Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
2620 2621
      mysql_bin_log.write(&qinfo);
    }
unknown's avatar
unknown committed
2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634
    goto end_temporary;
  }

  intern_close_table(new_table);		/* close temporary table */
  my_free((gptr) new_table,MYF(0));
  VOID(pthread_mutex_lock(&LOCK_open));
  if (error)
  {
    VOID(quick_rm_table(new_db_type,new_db,tmp_name));
    VOID(pthread_mutex_unlock(&LOCK_open));
    goto err;
  }
  /*
2635 2636 2637
    Data is copied.  Now we rename the old table to a temp name,
    rename the new one to the old name, remove all entries from the old table
    from the cash, free all locks, close the old table and remove it.
unknown's avatar
unknown committed
2638 2639 2640 2641 2642
  */

  thd->proc_info="rename result table";
  sprintf(old_name,"%s2-%lx-%lx", tmp_file_prefix, current_pid,
	  thd->thread_id);
2643
  if (new_name != table_name || new_db != db)
unknown's avatar
unknown committed
2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654
  {
    if (!access(new_name_buff,F_OK))
    {
      error=1;
      my_error(ER_TABLE_EXISTS_ERROR,MYF(0),new_name_buff);
      VOID(quick_rm_table(new_db_type,new_db,tmp_name));
      VOID(pthread_mutex_unlock(&LOCK_open));
      goto err;
    }
  }

unknown's avatar
unknown committed
2655 2656 2657 2658 2659
#if (!defined( __WIN__) && !defined( __EMX__) && !defined( OS2))
  if (table->file->has_transactions())
#endif
  {
    /*
2660
      Win32 and InnoDB can't drop a table that is in use, so we must
2661
      close the original table at before doing the rename
unknown's avatar
unknown committed
2662 2663
    */
    table_name=thd->strdup(table_name);		// must be saved
2664
    if (close_cached_table(thd, table))
unknown's avatar
unknown committed
2665 2666 2667 2668 2669 2670
    {						// Aborted
      VOID(quick_rm_table(new_db_type,new_db,tmp_name));
      VOID(pthread_mutex_unlock(&LOCK_open));
      goto err;
    }
    table=0;					// Marker that table is closed
unknown's avatar
unknown committed
2671
  }
unknown's avatar
unknown committed
2672 2673 2674
#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
2675 2676
#endif

unknown's avatar
unknown committed
2677

unknown's avatar
unknown committed
2678 2679 2680 2681 2682 2683 2684
  error=0;
  if (mysql_rename_table(old_db_type,db,table_name,db,old_name))
  {
    error=1;
    VOID(quick_rm_table(new_db_type,new_db,tmp_name));
  }
  else if (mysql_rename_table(new_db_type,new_db,tmp_name,new_db,
unknown's avatar
unknown committed
2685
			      new_alias))
unknown's avatar
unknown committed
2686 2687
  {						// Try to get everything back
    error=1;
unknown's avatar
unknown committed
2688
    VOID(quick_rm_table(new_db_type,new_db,new_alias));
unknown's avatar
unknown committed
2689
    VOID(quick_rm_table(new_db_type,new_db,tmp_name));
unknown's avatar
unknown committed
2690
    VOID(mysql_rename_table(old_db_type,db,old_name,db,alias));
unknown's avatar
unknown committed
2691 2692 2693
  }
  if (error)
  {
unknown's avatar
unknown committed
2694 2695 2696 2697
    /*
      This shouldn't happen.  We solve this the safe way by
      closing the locked table.
    */
2698 2699
    if (table)
      close_cached_table(thd,table);
unknown's avatar
unknown committed
2700 2701 2702 2703 2704
    VOID(pthread_mutex_unlock(&LOCK_open));
    goto err;
  }
  if (thd->lock || new_name != table_name)	// True if WIN32
  {
unknown's avatar
unknown committed
2705 2706 2707 2708
    /*
      Not table locking or alter table with rename
      free locks and remove old table
    */
2709 2710
    if (table)
      close_cached_table(thd,table);
unknown's avatar
unknown committed
2711 2712 2713 2714
    VOID(quick_rm_table(old_db_type,db,old_name));
  }
  else
  {
unknown's avatar
unknown committed
2715 2716 2717 2718 2719
    /*
      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
2720 2721 2722 2723 2724 2725 2726 2727 2728 2729
    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
2730 2731
      if (table)
	close_cached_table(thd,table);		// Remove lock for table
unknown's avatar
unknown committed
2732 2733 2734 2735
      VOID(pthread_mutex_unlock(&LOCK_open));
      goto err;
    }
  }
unknown's avatar
unknown committed
2736
  /* The ALTER TABLE is always in its own transaction */
2737 2738 2739 2740
  error = ha_commit_stmt(thd);
  if (ha_commit(thd))
    error=1;
  if (error)
unknown's avatar
unknown committed
2741 2742
  {
    VOID(pthread_mutex_unlock(&LOCK_open));
2743
    VOID(pthread_cond_broadcast(&COND_refresh));
unknown's avatar
unknown committed
2744 2745 2746
    goto err;
  }
  thd->proc_info="end";
2747 2748
  mysql_update_log.write(thd, thd->query,thd->query_length);
  if (mysql_bin_log.is_open())
unknown's avatar
unknown committed
2749
  {
unknown's avatar
unknown committed
2750
    thd->clear_error();
2751
    Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
unknown's avatar
unknown committed
2752 2753 2754 2755
    mysql_bin_log.write(&qinfo);
  }
  VOID(pthread_cond_broadcast(&COND_refresh));
  VOID(pthread_mutex_unlock(&LOCK_open));
2756 2757 2758
#ifdef HAVE_BERKELEY_DB
  if (old_db_type == DB_TYPE_BERKELEY_DB)
  {
unknown's avatar
unknown committed
2759 2760 2761 2762 2763
    /*
      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.
    */
2764 2765 2766 2767 2768
    char path[FN_REFLEN];
    (void) sprintf(path,"%s/%s/%s",mysql_data_home,new_db,table_name);
    fn_format(path,path,"","",4);
    table=open_temporary_table(thd, path, new_db, tmp_name,0);
    if (table)
unknown's avatar
unknown committed
2769
    {
2770 2771
      intern_close_table(table);
      my_free((char*) table, MYF(0));
unknown's avatar
unknown committed
2772
    }
2773 2774 2775 2776
    else
      sql_print_error("Warning: Could not open BDB table %s.%s after rename\n",
		      new_db,table_name);
    (void) berkeley_flush_logs();
2777 2778
  }
#endif
unknown's avatar
unknown committed
2779
  table_list->table=0;				// For query cache
unknown's avatar
unknown committed
2780
  query_cache_invalidate3(thd, table_list, 0);
unknown's avatar
unknown committed
2781 2782

end_temporary:
2783 2784
  sprintf(tmp_name, ER(ER_INSERT_INFO), (ulong) (copied + deleted),
	  (ulong) deleted, (ulong) thd->cuted_fields);
2785
  send_ok(thd,copied+deleted,0L,tmp_name);
unknown's avatar
unknown committed
2786 2787 2788 2789 2790 2791 2792 2793 2794
  thd->some_tables_deleted=0;
  DBUG_RETURN(0);

 err:
  DBUG_RETURN(-1);
}


static int
unknown's avatar
unknown committed
2795 2796
copy_data_between_tables(TABLE *from,TABLE *to,
                         List<create_field> &create,
unknown's avatar
unknown committed
2797
			 enum enum_duplicates handle_duplicates,
2798
                         uint order_num, ORDER *order,
unknown's avatar
unknown committed
2799 2800
			 ha_rows *copied,
                         ha_rows *deleted)
unknown's avatar
unknown committed
2801 2802 2803 2804 2805
{
  int error;
  Copy_field *copy,*copy_end;
  ulong found_count,delete_count;
  THD *thd= current_thd;
unknown's avatar
unknown committed
2806 2807 2808 2809 2810 2811 2812
  uint length;
  SORT_FIELD *sortorder;
  READ_RECORD info;
  Field *next_field;
  TABLE_LIST   tables;
  List<Item>   fields;
  List<Item>   all_fields;
2813
  ha_rows examined_rows;
unknown's avatar
unknown committed
2814 2815 2816 2817 2818 2819 2820
  DBUG_ENTER("copy_data_between_tables");

  if (!(copy= new Copy_field[to->fields]))
    DBUG_RETURN(-1);				/* purecov: inspected */

  to->file->external_lock(thd,F_WRLCK);
  to->file->extra(HA_EXTRA_WRITE_CACHE);
2821 2822
  from->file->info(HA_STATUS_VARIABLE);
  to->file->deactivate_non_unique_index(from->file->records);
unknown's avatar
unknown committed
2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833

  List_iterator<create_field> it(create);
  create_field *def;
  copy_end=copy;
  for (Field **ptr=to->field ; *ptr ; ptr++)
  {
    def=it++;
    if (def->field)
      (copy_end++)->set(*ptr,def->field,0);
  }

2834 2835
  found_count=delete_count=0;

unknown's avatar
unknown committed
2836 2837
  if (order)
  {
unknown's avatar
unknown committed
2838 2839
    from->sort.io_cache=(IO_CACHE*) my_malloc(sizeof(IO_CACHE),
                                              MYF(MY_FAE | MY_ZEROFILL));
unknown's avatar
unknown committed
2840 2841
    bzero((char*) &tables,sizeof(tables));
    tables.table = from;
2842
    tables.alias = tables.real_name= from->real_name;
unknown's avatar
unknown committed
2843
    tables.db	 = from->table_cache_key;
unknown's avatar
unknown committed
2844 2845
    error=1;

2846 2847
    if (thd->lex->select_lex.setup_ref_array(thd, order_num) ||
	setup_order(thd, thd->lex->select_lex.ref_pointer_array,
2848
		    &tables, fields, all_fields, order) ||
unknown's avatar
unknown committed
2849
        !(sortorder=make_unireg_sortorder(order, &length)) ||
unknown's avatar
unknown committed
2850 2851 2852
        (from->sort.found_records = filesort(thd, from, sortorder, length, 
                                             (SQL_SELECT *) 0, HA_POS_ERROR,
                                             &examined_rows))
unknown's avatar
unknown committed
2853 2854 2855 2856
        == HA_POS_ERROR)
      goto err;
  };

2857 2858 2859
  /* 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.              */
unknown's avatar
unknown committed
2860
  error = ha_recovery_logging(thd,FALSE);
2861
  if (error)
2862 2863 2864 2865 2866
  {
    error = 1;
    goto err;
  }

unknown's avatar
unknown committed
2867
  init_read_record(&info, thd, from, (SQL_SELECT *) 0, 1,1);
2868 2869
  if (handle_duplicates == DUP_IGNORE ||
      handle_duplicates == DUP_REPLACE)
unknown's avatar
unknown committed
2870
    to->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
unknown's avatar
unknown committed
2871
  next_field=to->next_number_field;
2872
  thd->row_count= 0;
unknown's avatar
unknown committed
2873 2874 2875 2876 2877 2878 2879 2880
  while (!(error=info.read_record(&info)))
  {
    if (thd->killed)
    {
      my_error(ER_SERVER_SHUTDOWN,MYF(0));
      error= 1;
      break;
    }
2881
    thd->row_count++;
unknown's avatar
unknown committed
2882 2883 2884 2885 2886 2887
    if (next_field)
      next_field->reset();
    for (Copy_field *copy_ptr=copy ; copy_ptr != copy_end ; copy_ptr++)
      copy_ptr->do_copy(copy_ptr);
    if ((error=to->file->write_row((byte*) to->record[0])))
    {
2888 2889
      if ((handle_duplicates != DUP_IGNORE &&
	   handle_duplicates != DUP_REPLACE) ||
unknown's avatar
unknown committed
2890 2891 2892 2893 2894 2895 2896 2897 2898
	  (error != HA_ERR_FOUND_DUPP_KEY &&
	   error != HA_ERR_FOUND_DUPP_UNIQUE))
      {
	to->file->print_error(error,MYF(0));
	break;
      }
      delete_count++;
    }
    else
2899
      found_count++;
unknown's avatar
unknown committed
2900 2901
  }
  end_read_record(&info);
2902
  free_io_cache(from);
2903
  delete [] copy;				// This is never 0
unknown's avatar
unknown committed
2904 2905 2906 2907 2908 2909
  uint tmp_error;
  if ((tmp_error=to->file->extra(HA_EXTRA_NO_CACHE)))
  {
    to->file->print_error(tmp_error,MYF(0));
    error=1;
  }
unknown's avatar
unknown committed
2910
  to->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
2911 2912
  if (to->file->activate_all_index(thd))
    error=1;
2913

unknown's avatar
unknown committed
2914
  tmp_error = ha_recovery_logging(thd,TRUE);
2915 2916 2917 2918 2919 2920 2921 2922 2923
  /*
    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;
  if (to->file->external_lock(thd,F_UNLCK))
unknown's avatar
unknown committed
2924
    error=1;
unknown's avatar
unknown committed
2925 2926
 err:
  free_io_cache(from);
unknown's avatar
unknown committed
2927 2928 2929 2930
  *copied= found_count;
  *deleted=delete_count;
  DBUG_RETURN(error > 0 ? -1 : 0);
}
2931

unknown's avatar
unknown committed
2932 2933

int mysql_checksum_table(THD *thd, TABLE_LIST *tables, HA_CHECK_OPT *check_opt)
2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947
{
  TABLE_LIST *table;
  List<Item> field_list;
  Item *item;
  Protocol *protocol= thd->protocol;
  DBUG_ENTER("mysql_admin_table");

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

unknown's avatar
unknown committed
2948
  for (table= tables; table; table= table->next)
2949 2950
  {
    char table_name[NAME_LEN*2+2];
2951
    TABLE *t;
2952

unknown's avatar
unknown committed
2953 2954 2955 2956
    strxmov(table_name, table->db ,".", table->real_name, NullS);

    t= table->table= open_ltable(thd, table, TL_READ_NO_INSERT);
    thd->clear_error();			// these errors shouldn't get client
2957 2958 2959 2960

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

2961
    if (!t)
2962
    {
unknown's avatar
unknown committed
2963
      /* Table didn't exist */
2964 2965 2966 2967 2968
      protocol->store_null();
      thd->net.last_error[0]=0;
    }
    else
    {
2969
      t->pos_in_table_list= table;
2970

2971 2972 2973 2974
      if (t->file->table_flags() & HA_HAS_CHECKSUM &&
          !(check_opt->flags & T_EXTEND))
        protocol->store((ulonglong)t->file->checksum());
      else if (!(t->file->table_flags() & HA_HAS_CHECKSUM) &&
unknown's avatar
unknown committed
2975
	       (check_opt->flags & T_QUICK))
2976
        protocol->store_null();
2977 2978 2979
      else
      {
        /* calculating table's checksum */
unknown's avatar
unknown committed
2980
        ha_checksum crc= 0;
unknown's avatar
unknown committed
2981 2982 2983 2984 2985 2986 2987 2988

	if (t->db_type == DB_TYPE_INNODB) {
	  /* 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);
	}

2989 2990 2991 2992 2993 2994
        if (t->file->rnd_init(1))
          protocol->store_null();
        else
        {
          while (!t->file->rnd_next(t->record[0]))
          {
unknown's avatar
unknown committed
2995
            ha_checksum row_crc= 0;
unknown's avatar
unknown committed
2996
            if (t->record[0] != (byte*) t->field[0]->ptr)
unknown's avatar
unknown committed
2997
              row_crc= my_checksum(row_crc, t->record[0],
unknown's avatar
unknown committed
2998
				   ((byte*) t->field[0]->ptr) - t->record[0]);
2999

unknown's avatar
unknown committed
3000
            for (uint i= 0; i < t->fields; i++ )
3001
            {
unknown's avatar
unknown committed
3002
              Field *f= t->field[i];
3003 3004 3005 3006
              if (f->type() == FIELD_TYPE_BLOB)
              {
                String tmp;
                f->val_str(&tmp,&tmp);
unknown's avatar
unknown committed
3007
                row_crc= my_checksum(row_crc, (byte*) tmp.ptr(), tmp.length());
3008 3009
              }
              else
unknown's avatar
unknown committed
3010 3011
                row_crc= my_checksum(row_crc, (byte*) f->ptr,
				     f->pack_length());
3012 3013
            }

unknown's avatar
unknown committed
3014
            crc+= row_crc;
3015 3016 3017 3018
          }
          protocol->store((ulonglong)crc);
        }
      }
unknown's avatar
unknown committed
3019
      thd->clear_error();
3020 3021 3022 3023 3024 3025 3026 3027 3028
      close_thread_tables(thd);
      table->table=0;				// For query cache
    }
    if (protocol->write())
      goto err;
  }

  send_eof(thd);
  DBUG_RETURN(0);
unknown's avatar
unknown committed
3029

3030 3031 3032 3033 3034 3035
 err:
  close_thread_tables(thd);			// Shouldn't be needed
  if (table)
    table->table=0;
  DBUG_RETURN(-1);
}