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

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

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

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


/* drop and alter of tables */

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

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

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

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

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

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

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

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

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



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

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

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

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

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

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

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

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

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

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

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

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

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

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

137 138 139 140 141 142

/*
 delete (drop) tables.

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

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

 RETURN
153 154
  0	ok
  1	error
155 156
*/

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

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

  pthread_mutex_unlock(&LOCK_open);

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

178

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

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

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

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

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

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

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

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

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

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

314
  unlock_table_names(thd, tables);
315
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
316 317 318 319
}


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

331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
/*
  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;
349
    if ((a->flags ^ b->flags) & (HA_NULL_PART_KEY | HA_END_SPACE_KEY))
350 351
    {
      /* Sort NOT NULL keys before other keys */
352
      return (a->flags & (HA_NULL_PART_KEY | HA_END_SPACE_KEY)) ? 1 : -1;
353 354 355 356 357 358 359
    }
    if (a->name == primary_key_name)
      return -1;
    if (b->name == primary_key_name)
      return 1;
  }
  else if (b->flags & HA_NOSAME)
360
    return 1;					// Prefer b
361 362 363 364 365

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

375 376
/*
  Check TYPELIB (set or enum) for duplicates
377

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

  DESCRIPTION
385
    This function prints an warning for each value in list
386 387 388 389 390 391 392
    which has some duplicates on its right

  RETURN VALUES
    void
*/

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

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

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

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

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

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


450
/*
451
  Preparation for table creation
452 453

  SYNOPSIS
454
    mysql_prepare_table()
455 456 457 458
    thd			Thread object
    create_info		Create information (like MAX_ROWS)
    fields		List of fields to create
    keys		List of keys to create
459

460
  DESCRIPTION
461
    Prepares the table and key structures for table creation.
462 463

  RETURN VALUES
464 465
    0	ok
    -1	error
466
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
467

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

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

489
  for (field_no=0; (sql_field=it++) ; field_no++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
490
  {
491 492 493 494 495 496
    /*
      Initialize length from its original value (number of characters),
      which was set in the parser. This is necessary if we're
      executing a prepared statement for the second time.
    */
    sql_field->length= sql_field->char_length;
497
    if (!sql_field->charset)
498 499 500
      sql_field->charset= create_info->default_table_charset;
    /*
      table_charset is set in ALTER TABLE if we want change character set
501 502 503
      for all varchar/char columns.
      But the table charset must not affect the BLOB fields, so don't
      allow to change my_charset_bin to somethig else.
504
    */
505
    if (create_info->table_charset && sql_field->charset != &my_charset_bin)
506
      sql_field->charset= create_info->table_charset;
507 508 509 510 511 512 513 514 515 516 517

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

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

      /*
        Create typelib from interval_list, and if necessary
        convert strings from client character set to the
        column character set.
      */
531
      if (!interval)
532
      {
533 534 535 536 537 538 539 540
        /*
          Create the typelib in prepared statement memory if we're
          executing one.
        */
        MEM_ROOT *stmt_root= thd->current_arena->mem_root;

        interval= sql_field->interval= typelib(stmt_root,
                                               sql_field->interval_list);
541 542 543
        List_iterator<String> it(sql_field->interval_list);
        String conv, *tmp;
        for (uint i= 0; (tmp= it++); i++)
544
        {
545 546 547 548 549
          if (String::needs_conversion(tmp->length(), tmp->charset(),
                                       cs, &dummy))
          {
            uint cnv_errs;
            conv.copy(tmp->ptr(), tmp->length(), tmp->charset(), cs, &cnv_errs);
550
            char *buf= (char*) alloc_root(stmt_root, conv.length()+1);
551 552 553 554 555
            memcpy(buf, conv.ptr(), conv.length());
            buf[conv.length()]= '\0';
            interval->type_names[i]= buf;
            interval->type_lengths[i]= conv.length();
          }
556

557 558 559 560 561 562 563
          // Strip trailing spaces.
          uint lengthsp= cs->cset->lengthsp(cs, interval->type_names[i],
                                            interval->type_lengths[i]);
          interval->type_lengths[i]= lengthsp;
          ((uchar *)interval->type_names[i])[lengthsp]= '\0';
        }
        sql_field->interval_list.empty(); // Don't need interval_list anymore
564 565 566 567 568 569
      }

      /*
        Convert the default value from client character
        set into the column character set if necessary.
      */
bar@mysql.com's avatar
bar@mysql.com committed
570
      if (sql_field->def && cs != sql_field->def->collation.collation)
571
      {
572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587
        Item_arena backup_arena;
        bool need_to_change_arena=
          !thd->current_arena->is_conventional_execution();
        if (need_to_change_arena)
        {
          /* Asser that we don't do that at every PS execute */
          DBUG_ASSERT(thd->current_arena->is_first_stmt_execute());
          thd->set_n_backup_item_arena(thd->current_arena, &backup_arena);
        }

        sql_field->def= sql_field->def->safe_charset_converter(cs);

        if (need_to_change_arena)
          thd->restore_backup_item_arena(thd->current_arena, &backup_arena);

        if (! sql_field->def)
bar@mysql.com's avatar
bar@mysql.com committed
588 589 590 591 592
        {
          /* Could not convert */
          my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
          DBUG_RETURN(-1);
        }
593 594 595 596 597 598 599 600 601 602 603 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
      }

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

632
    sql_field->create_length_to_internal_length();
633

634
    /* Don't pack keys in old tables if the user has requested this */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
635
    if ((sql_field->flags & BLOB_FLAG) ||
636 637
	sql_field->sql_type == FIELD_TYPE_VAR_STRING &&
	create_info->row_type != ROW_TYPE_FIXED)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
638 639 640 641 642
    {
      db_options|=HA_OPTION_PACK_RECORD;
    }
    if (!(sql_field->flags & NOT_NULL_FLAG))
      null_fields++;
643

644 645
    if (check_column_name(sql_field->field_name))
    {
646
      my_error(ER_WRONG_COLUMN_NAME, MYF(0), sql_field->field_name);
647 648
      DBUG_RETURN(-1);
    }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
649

650 651
    /* Check if we have used the same field name before */
    for (dup_no=0; (dup_field=it2++) != sql_field; dup_no++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
652
    {
653
      if (my_strcasecmp(system_charset_info,
654 655
			sql_field->field_name,
			dup_field->field_name) == 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
656
      {
657 658 659 660 661 662 663 664 665 666 667 668
	/*
	  If this was a CREATE ... SELECT statement, accept a field
	  redefinition if we are changing a field in the SELECT part
	*/
	if (field_no < select_field_pos || dup_no >= select_field_pos)
	{
	  my_error(ER_DUP_FIELDNAME,MYF(0),sql_field->field_name);
	  DBUG_RETURN(-1);
	}
	else
	{
	  /* Field redefined */
669
	  sql_field->def=		dup_field->def;
670 671 672 673
	  sql_field->sql_type=		dup_field->sql_type;
	  sql_field->charset=		(dup_field->charset ?
					 dup_field->charset :
					 create_info->default_table_charset);
674
	  sql_field->length=		dup_field->char_length;
675
          sql_field->pack_length=	dup_field->pack_length;
676 677 678
	  sql_field->create_length_to_internal_length();
	  sql_field->decimals=		dup_field->decimals;
	  sql_field->unireg_check=	dup_field->unireg_check;
679 680 681 682 683 684 685 686
          /* 
            We're making one field from two, the result field will have
            dup_field->flags as flags. If we've incremented null_fields
            because of sql_field->flags, decrement it back.
          */
          if (!(sql_field->flags & NOT_NULL_FLAG))
            null_fields--;
	  sql_field->flags=		dup_field->flags;
andrey@lmy004's avatar
andrey@lmy004 committed
687
          sql_field->interval=          dup_field->interval;
688 689 690 691
	  it2.remove();			// Remove first (create) definition
	  select_field_pos--;
	  break;
	}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
692 693 694 695
      }
    }
    it2.rewind();
  }
696 697 698

  /* record_offset will be increased with 'length-of-null-bits' later */
  record_offset= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
699 700 701 702

  it.rewind();
  while ((sql_field=it++))
  {
703 704
    DBUG_ASSERT(sql_field->charset);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
705 706 707 708 709 710
    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 |
711 712
	pack_length_to_packflag(sql_field->pack_length -
				portable_sizeof_char_ptr);
713
      if (sql_field->charset->state & MY_CS_BINSORT)
714 715
	sql_field->pack_flag|=FIELDFLAG_BINARY;
      sql_field->length=8;			// Unireg field length
bk@work.mysql.com's avatar
bk@work.mysql.com committed
716 717 718
      sql_field->unireg_check=Field::BLOB_FIELD;
      blob_columns++;
      break;
719
    case FIELD_TYPE_GEOMETRY:
hf@deer.(none)'s avatar
hf@deer.(none) committed
720
#ifdef HAVE_SPATIAL
721
      if (!(file->table_flags() & HA_CAN_GEOMETRY))
722
      {
723 724 725
	my_printf_error(ER_CHECK_NOT_IMPLEMENTED, ER(ER_CHECK_NOT_IMPLEMENTED),
			MYF(0), "GEOMETRY");
	DBUG_RETURN(-1);
726
      }
727
      sql_field->pack_flag=FIELDFLAG_GEOM |
728 729
	pack_length_to_packflag(sql_field->pack_length -
				portable_sizeof_char_ptr);
hf@deer.mysql.r18.ru's avatar
hf@deer.mysql.r18.ru committed
730
      if (sql_field->charset->state & MY_CS_BINSORT)
731 732
	sql_field->pack_flag|=FIELDFLAG_BINARY;
      sql_field->length=8;			// Unireg field length
733 734 735
      sql_field->unireg_check=Field::BLOB_FIELD;
      blob_columns++;
      break;
hf@deer.(none)'s avatar
hf@deer.(none) committed
736 737
#else
      my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED), MYF(0),
738
		      sym_group_geom.name, sym_group_geom.needed_define);
hf@deer.(none)'s avatar
hf@deer.(none) committed
739 740
      DBUG_RETURN(-1);
#endif /*HAVE_SPATIAL*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
741 742 743
    case FIELD_TYPE_VAR_STRING:
    case FIELD_TYPE_STRING:
      sql_field->pack_flag=0;
744
      if (sql_field->charset->state & MY_CS_BINSORT)
745
	sql_field->pack_flag|=FIELDFLAG_BINARY;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
746 747 748
      break;
    case FIELD_TYPE_ENUM:
      sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
749
	FIELDFLAG_INTERVAL;
750
      if (sql_field->charset->state & MY_CS_BINSORT)
751
	sql_field->pack_flag|=FIELDFLAG_BINARY;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
752
      sql_field->unireg_check=Field::INTERVAL_FIELD;
753
      check_duplicates_in_interval("ENUM",sql_field->field_name,
754 755
                                   sql_field->interval,
                                   sql_field->charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
756 757 758
      break;
    case FIELD_TYPE_SET:
      sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
759
	FIELDFLAG_BITFIELD;
760
      if (sql_field->charset->state & MY_CS_BINSORT)
761
	sql_field->pack_flag|=FIELDFLAG_BINARY;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
762
      sql_field->unireg_check=Field::BIT_FIELD;
763
      check_duplicates_in_interval("SET",sql_field->field_name,
764 765
                                   sql_field->interval,
                                   sql_field->charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
766
      break;
767
    case FIELD_TYPE_DATE:			// Rest of string types
bk@work.mysql.com's avatar
bk@work.mysql.com committed
768 769 770 771 772 773 774
    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:
775 776 777
      /* We should replace old TIMESTAMP fields with their newer analogs */
      if (sql_field->unireg_check == Field::TIMESTAMP_OLD_FIELD)
      {
778 779 780 781 782 783 784
	if (!timestamps)
	{
	  sql_field->unireg_check= Field::TIMESTAMP_DNUN_FIELD;
	  timestamps_with_niladic++;
	}
	else
	  sql_field->unireg_check= Field::NONE;
785
      }
786
      else if (sql_field->unireg_check != Field::NONE)
787 788
	timestamps_with_niladic++;

789
      timestamps++;
790
      /* fall-through */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
791 792
    default:
      sql_field->pack_flag=(FIELDFLAG_NUMBER |
793 794 795 796 797 798
			    (sql_field->flags & UNSIGNED_FLAG ? 0 :
			     FIELDFLAG_DECIMAL) |
			    (sql_field->flags & ZEROFILL_FLAG ?
			     FIELDFLAG_ZEROFILL : 0) |
			    f_settype((uint) sql_field->sql_type) |
			    (sql_field->decimals << FIELDFLAG_DEC_SHIFT));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
799 800 801 802
      break;
    }
    if (!(sql_field->flags & NOT_NULL_FLAG))
      sql_field->pack_flag|=FIELDFLAG_MAYBE_NULL;
803
    sql_field->offset= record_offset;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
804 805
    if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
      auto_increment++;
806
    record_offset+= sql_field->pack_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
807
  }
808 809 810 811 812
  if (timestamps_with_niladic > 1)
  {
    my_error(ER_TOO_MUCH_AUTO_TIMESTAMP_COLS,MYF(0));
    DBUG_RETURN(-1);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
813 814 815 816 817 818
  if (auto_increment > 1)
  {
    my_error(ER_WRONG_AUTO_KEY,MYF(0));
    DBUG_RETURN(-1);
  }
  if (auto_increment &&
819
      (file->table_flags() & HA_NO_AUTO_INCREMENT))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
820 821 822 823 824
  {
    my_error(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT,MYF(0));
    DBUG_RETURN(-1);
  }

825
  if (blob_columns && (file->table_flags() & HA_NO_BLOBS))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
826 827 828 829 830 831
  {
    my_error(ER_TABLE_CANT_HANDLE_BLOB,MYF(0));
    DBUG_RETURN(-1);
  }

  /* Create keys */
832

833
  List_iterator<Key> key_iterator(keys), key_iterator2(keys);
834
  uint key_parts=0, fk_key_count=0;
835
  bool primary_key=0,unique_key=0;
836
  Key *key, *key2;
837
  uint tmp, key_number;
838 839
  /* special marker for keys to be ignored */
  static char ignore_key[1];
840

841
  /* Calculate number of key segements */
842
  *key_count= 0;
843

bk@work.mysql.com's avatar
bk@work.mysql.com committed
844 845
  while ((key=key_iterator++))
  {
846 847 848 849 850
    if (key->type == Key::FOREIGN_KEY)
    {
      fk_key_count++;
      foreign_key *fk_key= (foreign_key*) key;
      if (fk_key->ref_columns.elements &&
851
	  fk_key->ref_columns.elements != fk_key->columns.elements)
852
      {
853 854 855 856
	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);
857 858 859
      }
      continue;
    }
860
    (*key_count)++;
861
    tmp=file->max_key_parts();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
862 863 864 865 866
    if (key->columns.elements > tmp)
    {
      my_error(ER_TOO_MANY_KEY_PARTS,MYF(0),tmp);
      DBUG_RETURN(-1);
    }
867
    if (key->name && strlen(key->name) > NAME_LEN)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
868
    {
869
      my_error(ER_TOO_LONG_IDENT, MYF(0), key->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
870 871
      DBUG_RETURN(-1);
    }
872
    key_iterator2.rewind ();
873
    if (key->type != Key::FOREIGN_KEY)
874
    {
875
      while ((key2 = key_iterator2++) != key)
876
      {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
877
	/*
878 879 880
          foreign_key_prefix(key, key2) returns 0 if key or key2, or both, is
          'generated', and a generated key is a prefix of the other key.
          Then we do not need the generated shorter key.
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
881
        */
882 883 884
        if ((key2->type != Key::FOREIGN_KEY &&
             key2->name != ignore_key &&
             !foreign_key_prefix(key, key2)))
885
        {
886
          /* TODO: issue warning message */
887 888 889 890 891 892 893 894 895 896 897 898 899
          /* mark that the generated key should be ignored */
          if (!key2->generated ||
              (key->generated && key->columns.elements <
               key2->columns.elements))
            key->name= ignore_key;
          else
          {
            key2->name= ignore_key;
            key_parts-= key2->columns.elements;
            (*key_count)--;
          }
          break;
        }
900 901 902 903 904 905
      }
    }
    if (key->name != ignore_key)
      key_parts+=key->columns.elements;
    else
      (*key_count)--;
906
    if (key->name && !tmp_table &&
907
	!my_strcasecmp(system_charset_info,key->name,primary_key_name))
908 909 910 911
    {
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name);
      DBUG_RETURN(-1);
    }
912
  }
913
  tmp=file->max_keys();
914
  if (*key_count > tmp)
915 916 917 918
  {
    my_error(ER_TOO_MANY_KEYS,MYF(0),tmp);
    DBUG_RETURN(-1);
  }
919

920
  key_info_buffer=key_info=(KEY*) sql_calloc(sizeof(KEY)* *key_count);
921 922
  key_part_info=(KEY_PART_INFO*) sql_calloc(sizeof(KEY_PART_INFO)*key_parts);
  if (!key_info_buffer || ! key_part_info)
923
    DBUG_RETURN(-1);				// Out of memory
924

925
  key_iterator.rewind();
926
  key_number=0;
927
  for (; (key=key_iterator++) ; key_number++)
928 929 930 931
  {
    uint key_length=0;
    key_part_spec *column;

932 933 934 935 936 937 938 939 940 941
    if (key->name == ignore_key)
    {
      /* ignore redundant keys */
      do
	key=key_iterator++;
      while (key && key->name == ignore_key);
      if (!key)
	break;
    }

942
    switch(key->type){
943
    case Key::MULTIPLE:
944
	key_info->flags= 0;
945
	break;
946
    case Key::FULLTEXT:
947
	key_info->flags= HA_FULLTEXT;
948
	break;
949
    case Key::SPATIAL:
hf@deer.(none)'s avatar
hf@deer.(none) committed
950
#ifdef HAVE_SPATIAL
951
	key_info->flags= HA_SPATIAL;
952
	break;
hf@deer.(none)'s avatar
hf@deer.(none) committed
953
#else
954 955 956
	my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED),MYF(0),
			sym_group_geom.name, sym_group_geom.needed_define);
	DBUG_RETURN(-1);
hf@deer.(none)'s avatar
hf@deer.(none) committed
957
#endif
958
    case Key::FOREIGN_KEY:
959
      key_number--;				// Skip this key
960 961
      continue;
    default:
962 963
      key_info->flags = HA_NOSAME;
      break;
964
    }
965 966
    if (key->generated)
      key_info->flags|= HA_GENERATED_KEY;
967

bk@work.mysql.com's avatar
bk@work.mysql.com committed
968 969
    key_info->key_parts=(uint8) key->columns.elements;
    key_info->key_part=key_part_info;
970
    key_info->usable_key_parts= key_number;
971
    key_info->algorithm=key->algorithm;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
972

973 974
    if (key->type == Key::FULLTEXT)
    {
975
      if (!(file->table_flags() & HA_CAN_FULLTEXT))
976
      {
977 978
	my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0));
	DBUG_RETURN(-1);
979 980
      }
    }
981 982 983
    /*
       Make SPATIAL to be RTREE by default
       SPATIAL only on BLOB or at least BINARY, this
984
       actually should be replaced by special GEOM type
985 986 987
       in near future when new frm file is ready
       checking for proper key parts number:
    */
988

989
    /* TODO: Add proper checks if handler supports key_type and algorithm */
990
    if (key_info->flags & HA_SPATIAL)
991 992 993
    {
      if (key_info->key_parts != 1)
      {
994 995 996
	my_printf_error(ER_WRONG_ARGUMENTS,
			ER(ER_WRONG_ARGUMENTS),MYF(0),"SPATIAL INDEX");
	DBUG_RETURN(-1);
997
      }
998
    }
999
    else if (key_info->algorithm == HA_KEY_ALG_RTREE)
1000
    {
hf@deer.(none)'s avatar
hf@deer.(none) committed
1001
#ifdef HAVE_RTREE_KEYS
1002 1003
      if ((key_info->key_parts & 1) == 1)
      {
1004 1005 1006
	my_printf_error(ER_WRONG_ARGUMENTS,
			ER(ER_WRONG_ARGUMENTS),MYF(0),"RTREE INDEX");
	DBUG_RETURN(-1);
1007
      }
1008 1009
      /* TODO: To be deleted */
      my_printf_error(ER_NOT_SUPPORTED_YET, ER(ER_NOT_SUPPORTED_YET),
1010
		      MYF(0), "RTREE INDEX");
1011
      DBUG_RETURN(-1);
hf@deer.(none)'s avatar
hf@deer.(none) committed
1012 1013
#else
      my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED),MYF(0),
1014
		      sym_group_rtree.name, sym_group_rtree.needed_define);
hf@deer.(none)'s avatar
hf@deer.(none) committed
1015 1016
      DBUG_RETURN(-1);
#endif
1017
    }
1018

1019
    List_iterator<key_part_spec> cols(key->columns), cols2(key->columns);
1020
    CHARSET_INFO *ft_key_charset=0;  // for FULLTEXT
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1021 1022
    for (uint column_nr=0 ; (column=cols++) ; column_nr++)
    {
1023 1024
      key_part_spec *dup_column;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1025 1026 1027
      it.rewind();
      field=0;
      while ((sql_field=it++) &&
1028 1029 1030 1031
	     my_strcasecmp(system_charset_info,
			   column->field_name,
			   sql_field->field_name))
	field++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1032 1033
      if (!sql_field)
      {
1034 1035 1036 1037
	my_printf_error(ER_KEY_COLUMN_DOES_NOT_EXITS,
			ER(ER_KEY_COLUMN_DOES_NOT_EXITS),MYF(0),
			column->field_name);
	DBUG_RETURN(-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1038
      }
1039
      while ((dup_column= cols2++) != column)
1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
      {
        if (!my_strcasecmp(system_charset_info,
	     	           column->field_name, dup_column->field_name))
	{
	  my_printf_error(ER_DUP_FIELDNAME,
			  ER(ER_DUP_FIELDNAME),MYF(0),
			  column->field_name);
	  DBUG_RETURN(-1);
	}
      }
      cols2.rewind();
1051
      if (key->type == Key::FULLTEXT)
1052
      {
1053 1054 1055 1056
	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 ||
1057
	    sql_field->charset->mbminlen > 1 || // ucs2 doesn't work yet
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
	    (ft_key_charset && sql_field->charset != ft_key_charset))
	{
	    my_printf_error(ER_BAD_FT_COLUMN,ER(ER_BAD_FT_COLUMN),MYF(0),
			    column->field_name);
	    DBUG_RETURN(-1);
	}
	ft_key_charset=sql_field->charset;
	/*
	  for fulltext keys keyseg length is 1 for blobs (it's ignored in ft
	  code anyway, and 0 (set to column width later) for char's. it has
	  to be correct col width for char's, as char data are not prefixed
	  with length (unlike blobs, where ft code takes data length from a
	  data prefix, ignoring column->length).
	*/
	column->length=test(f_is_blob(sql_field->pack_flag));
1073
      }
1074
      else
1075
      {
1076 1077 1078 1079
	column->length*= sql_field->charset->mbmaxlen;

	if (f_is_blob(sql_field->pack_flag))
	{
1080
	  if (!(file->table_flags() & HA_CAN_INDEX_BLOBS))
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
	  {
	    my_printf_error(ER_BLOB_USED_AS_KEY,ER(ER_BLOB_USED_AS_KEY),MYF(0),
			    column->field_name);
	    DBUG_RETURN(-1);
	  }
	  if (!column->length)
	  {
	    my_printf_error(ER_BLOB_KEY_WITHOUT_LENGTH,
			    ER(ER_BLOB_KEY_WITHOUT_LENGTH),MYF(0),
			    column->field_name);
	    DBUG_RETURN(-1);
	  }
	}
hf@deer.(none)'s avatar
hf@deer.(none) committed
1094
#ifdef HAVE_SPATIAL
1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
	if (key->type  == Key::SPATIAL)
	{
	  if (!column->length )
	  {
	    /*
	    BAR: 4 is: (Xmin,Xmax,Ymin,Ymax), this is for 2D case
		 Lately we'll extend this code to support more dimensions
	    */
	    column->length=4*sizeof(double);
	  }
	}
hf@deer.(none)'s avatar
hf@deer.(none) committed
1106
#endif
1107 1108 1109 1110 1111 1112 1113
	if (!(sql_field->flags & NOT_NULL_FLAG))
	{
	  if (key->type == Key::PRIMARY)
	  {
	    /* Implicitly set primary key fields to NOT NULL for ISO conf. */
	    sql_field->flags|= NOT_NULL_FLAG;
	    sql_field->pack_flag&= ~FIELDFLAG_MAYBE_NULL;
monty@mysql.com's avatar
monty@mysql.com committed
1114
            null_fields--;
1115 1116 1117
	  }
	  else
	     key_info->flags|= HA_NULL_PART_KEY;
1118
	  if (!(file->table_flags() & HA_NULL_IN_KEY))
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
	  {
	    my_printf_error(ER_NULL_COLUMN_IN_INDEX,ER(ER_NULL_COLUMN_IN_INDEX),
			    MYF(0),column->field_name);
	    DBUG_RETURN(-1);
	  }
	  if (key->type == Key::SPATIAL)
	  {
	    my_error(ER_SPATIAL_CANT_HAVE_NULL, MYF(0));
	    DBUG_RETURN(-1);
	  }
	}
	if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
	{
	  if (column_nr == 0 || (file->table_flags() & HA_AUTO_PART_KEY))
	    auto_increment--;			// Field is used
	}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1135
      }
1136

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1137 1138 1139 1140 1141 1142
      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)
      {
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
	if (f_is_blob(sql_field->pack_flag))
	{
	  if ((length=column->length) > file->max_key_length() ||
	      length > file->max_key_part_length())
	  {
	    length=min(file->max_key_length(), file->max_key_part_length());
	    if (key->type == Key::MULTIPLE)
	    {
	      /* not a critical problem */
	      char warn_buff[MYSQL_ERRMSG_SIZE];
	      my_snprintf(warn_buff, sizeof(warn_buff), ER(ER_TOO_LONG_KEY),
			  length);
	      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			   ER_TOO_LONG_KEY, warn_buff);
	    }
	    else
	    {
	      my_error(ER_TOO_LONG_KEY,MYF(0),length);
	      DBUG_RETURN(-1);
	    }
	  }
	}
	else if (!f_is_geom(sql_field->pack_flag) &&
		  (column->length > length ||
		   ((f_is_packed(sql_field->pack_flag) ||
		     ((file->table_flags() & HA_NO_PREFIX_CHAR_KEYS) &&
		      (key_info->flags & HA_NOSAME))) &&
		    column->length != length)))
	{
	  my_error(ER_WRONG_SUB_KEY,MYF(0));
	  DBUG_RETURN(-1);
	}
	else if (!(file->table_flags() & HA_NO_PREFIX_CHAR_KEYS))
	  length=column->length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1177 1178 1179
      }
      else if (length == 0)
      {
1180 1181 1182
	my_printf_error(ER_WRONG_KEY_COLUMN, ER(ER_WRONG_KEY_COLUMN), MYF(0),
			column->field_name);
	  DBUG_RETURN(-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1183
      }
1184 1185
      if (length > file->max_key_part_length())
      {
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
	length=file->max_key_part_length();
	if (key->type == Key::MULTIPLE)
	{
	  /* not a critical problem */
	  char warn_buff[MYSQL_ERRMSG_SIZE];
	  my_snprintf(warn_buff, sizeof(warn_buff), ER(ER_TOO_LONG_KEY),
		      length);
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
		       ER_TOO_LONG_KEY, warn_buff);
	}
	else
	{
	  my_error(ER_TOO_LONG_KEY,MYF(0),length);
	  DBUG_RETURN(-1);
	}
1201 1202
      }
      key_part_info->length=(uint16) length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1203 1204
      /* Use packed keys for long strings on the first column */
      if (!(db_options & HA_OPTION_NO_PACK_KEYS) &&
1205 1206 1207 1208
	  (length >= KEY_DEFAULT_PACK_LENGTH &&
	   (sql_field->sql_type == FIELD_TYPE_STRING ||
	    sql_field->sql_type == FIELD_TYPE_VAR_STRING ||
	    sql_field->pack_flag & FIELDFLAG_BLOB)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1209
      {
1210 1211 1212 1213
	if (column_nr == 0 && (sql_field->pack_flag & FIELDFLAG_BLOB))
	  key_info->flags|= HA_BINARY_PACK_KEY;
	else
	  key_info->flags|= HA_PACK_KEY;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1214 1215 1216 1217 1218 1219 1220
      }
      key_length+=length;
      key_part_info++;

      /* Create the key name based on the first column (if not given) */
      if (column_nr == 0)
      {
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
	if (key->type == Key::PRIMARY)
	{
	  if (primary_key)
	  {
	    my_error(ER_MULTIPLE_PRI_KEY,MYF(0));
	    DBUG_RETURN(-1);
	  }
	  key_name=primary_key_name;
	  primary_key=1;
	}
	else if (!(key_name = key->name))
	  key_name=make_unique_key_name(sql_field->field_name,
					key_info_buffer,key_info);
	if (check_if_keyname_exists(key_name,key_info_buffer,key_info))
	{
	  my_error(ER_DUP_KEYNAME,MYF(0),key_name);
	  DBUG_RETURN(-1);
	}
	key_info->name=(char*) key_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1240 1241
      }
    }
1242 1243
    if (!key_info->name || check_column_name(key_info->name))
    {
1244
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key_info->name);
1245 1246
      DBUG_RETURN(-1);
    }
1247 1248
    if (!(key_info->flags & HA_NULL_PART_KEY))
      unique_key=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1249
    key_info->key_length=(uint16) key_length;
1250
    uint max_key_length= file->max_key_length();
1251
    if (key_length > max_key_length && key->type != Key::FULLTEXT)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1252
    {
1253
      my_error(ER_TOO_LONG_KEY,MYF(0),max_key_length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1254 1255
      DBUG_RETURN(-1);
    }
1256
    key_info++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1257
  }
1258
  if (!unique_key && !primary_key &&
1259
      (file->table_flags() & HA_REQUIRE_PRIMARY_KEY))
1260 1261 1262 1263
  {
    my_error(ER_REQUIRES_PRIMARY_KEY,MYF(0));
    DBUG_RETURN(-1);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1264 1265 1266 1267 1268
  if (auto_increment > 0)
  {
    my_error(ER_WRONG_AUTO_KEY,MYF(0));
    DBUG_RETURN(-1);
  }
1269
  /* Sort keys in optimized order */
1270 1271
  qsort((gptr) key_info_buffer, *key_count, sizeof(KEY),
	(qsort_cmp) sort_keys);
monty@mysql.com's avatar
monty@mysql.com committed
1272
  create_info->null_bits= null_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1273

1274 1275 1276
  DBUG_RETURN(0);
}

1277

1278 1279 1280 1281 1282
/*
  Create a table

  SYNOPSIS
    mysql_create_table()
1283 1284 1285 1286 1287 1288 1289 1290
    thd			Thread object
    db			Database
    table_name		Table name
    create_info		Create information (like MAX_ROWS)
    fields		List of fields to create
    keys		List of keys to create
    tmp_table		Set to 1 if this is an internal temporary table
			(From ALTER TABLE)
1291 1292 1293 1294 1295 1296 1297 1298 1299 1300

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

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

  RETURN VALUES
1301 1302
    0	ok
    -1	error
1303 1304 1305
*/

int mysql_create_table(THD *thd,const char *db, const char *table_name,
1306 1307
		       HA_CREATE_INFO *create_info,
		       List<create_field> &fields,
1308
		       List<Key> &keys,bool tmp_table,
1309
		       uint select_field_count)
1310
{
1311 1312 1313 1314 1315 1316 1317
  char		path[FN_REFLEN];
  const char	*alias;
  int		error= -1;
  uint		db_options, key_count;
  KEY		*key_info_buffer;
  handler	*file;
  enum db_type	new_db_type;
1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330
  DBUG_ENTER("mysql_create_table");

  /* Check for duplicate fields and check type of table to create */
  if (!fields.elements)
  {
    my_error(ER_TABLE_MUST_HAVE_COLUMNS,MYF(0));
    DBUG_RETURN(-1);
  }
  if ((new_db_type= ha_checktype(create_info->db_type)) !=
      create_info->db_type)
  {
    create_info->db_type= new_db_type;
    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
1331 1332 1333 1334
			ER_WARN_USING_OTHER_HANDLER,
			ER(ER_WARN_USING_OTHER_HANDLER),
			ha_get_storage_engine(new_db_type),
			table_name);
1335 1336 1337 1338 1339 1340 1341
  }
  db_options=create_info->table_options;
  if (create_info->row_type == ROW_TYPE_DYNAMIC)
    db_options|=HA_OPTION_PACK_RECORD;
  alias= table_case_name(create_info, table_name);
  file=get_new_handler((TABLE*) 0, create_info->db_type);

1342 1343 1344 1345 1346 1347 1348 1349
#ifdef NOT_USED
  /*
    if there is a technical reason for a handler not to have support
    for temp. tables this code can be re-enabled.
    Otherwise, if a handler author has a wish to prohibit usage of
    temporary tables for his handler he should implement a check in
    ::create() method
  */
1350 1351 1352 1353 1354 1355
  if ((create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
      (file->table_flags() & HA_NO_TEMP_TABLES))
  {
    my_error(ER_ILLEGAL_HA,MYF(0),table_name);
    DBUG_RETURN(-1);
  }
1356
#endif
1357

1358 1359 1360 1361 1362 1363 1364 1365 1366
  /*
    If the table character set was not given explicitely,
    let's fetch the database default character set and
    apply it to the table.
  */
  if (!create_info->default_table_charset)
  {
    HA_CREATE_INFO db_info;
    char  path[FN_REFLEN];
1367 1368
    /* Abuse build_table_path() to build the path to the db.opt file */
    build_table_path(path, sizeof(path), db, MY_DB_OPT_FILE, "");
1369 1370 1371 1372
    load_db_opt(thd, path, &db_info);
    create_info->default_table_charset= db_info.default_table_charset;
  }

1373
  if (mysql_prepare_table(thd, create_info, fields,
1374 1375 1376
			  keys, tmp_table, db_options, file,
			  key_info_buffer, &key_count,
			  select_field_count))
1377 1378
    DBUG_RETURN(-1);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1379 1380 1381
      /* Check if table exists */
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
1382 1383 1384
    my_snprintf(path, sizeof(path), "%s%s%lx_%lx_%x%s",
		mysql_tmpdir, tmp_file_prefix, current_pid, thd->thread_id,
		thd->tmp_table++, reg_ext);
1385
    if (lower_case_table_names)
1386
      my_casedn_str(files_charset_info, path);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1387 1388 1389
    create_info->table_options|=HA_CREATE_DELAY_KEY_WRITE;
  }
  else
1390 1391
    build_table_path(path, sizeof(path), db, alias, reg_ext);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1392 1393 1394 1395
  /* Check if table already exists */
  if ((create_info->options & HA_LEX_CREATE_TMP_TABLE)
      && find_temporary_table(thd,db,table_name))
  {
1396
    if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
1397
    {
1398
      create_info->table_existed= 1;		// Mark that table existed
1399 1400 1401
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
                          ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
                          alias);
1402
      DBUG_RETURN(0);
1403
    }
monty@mysql.com's avatar
monty@mysql.com committed
1404
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), alias);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1405 1406
    DBUG_RETURN(-1);
  }
serg@serg.mylan's avatar
serg@serg.mylan committed
1407
  if (wait_if_global_read_lock(thd, 0, 1))
1408
    DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1409 1410 1411 1412 1413 1414
  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)
1415 1416
        goto warn;
      my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
1417
      goto end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1418 1419 1420
    }
  }

1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
  /*
    Check that table with given name does not already
    exist in any storage engine. In such a case it should
    be discovered and the error ER_TABLE_EXISTS_ERROR be returned
    unless user specified CREATE TABLE IF EXISTS
    The LOCK_open mutex has been locked to make sure no
    one else is attempting to discover the table. Since
    it's not on disk as a frm file, no one could be using it!
  */
  if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
  {
    bool create_if_not_exists =
      create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS;
1434
    if (ha_table_exists_in_engine(thd, db, table_name))
1435
    {
1436
      DBUG_PRINT("info", ("Table with same name already existed in handler"));
1437 1438

      if (create_if_not_exists)
1439 1440
        goto warn;
      my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
1441 1442 1443 1444
      goto end;
    }
  }

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

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1448
  if (thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE)
1449
    create_info->data_file_name= create_info->index_file_name= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1450
  create_info->table_options=db_options;
1451

monty@mysql.com's avatar
monty@mysql.com committed
1452
  if (rea_create_table(thd, path, db, table_name,
1453
                       create_info, fields, key_count,
1454
		       key_info_buffer))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1455 1456 1457 1458 1459 1460 1461 1462 1463
    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;
    }
1464
    thd->tmp_table_used= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1465
  }
1466
  if (!tmp_table)
1467 1468 1469 1470 1471
  {
    // Must be written before unlock
    mysql_update_log.write(thd,thd->query, thd->query_length);
    if (mysql_bin_log.is_open())
    {
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1472
      thd->clear_error();
1473
      Query_log_event qinfo(thd, thd->query, thd->query_length,
1474
			    test(create_info->options &
1475 1476
				 HA_LEX_CREATE_TMP_TABLE),
			    FALSE);
1477 1478 1479
      mysql_bin_log.write(&qinfo);
    }
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1480
  error=0;
1481 1482 1483 1484 1485 1486 1487 1488 1489
  goto end;

warn:
  error= 0;
  push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
                      ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
                      alias);
  create_info->table_existed= 1;		// Mark that table existed

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1490 1491
end:
  VOID(pthread_mutex_unlock(&LOCK_open));
1492
  start_waiting_global_read_lock(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
  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++)
1505
    if (!my_strcasecmp(system_charset_info,name,key->name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
      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;

1516 1517
  if (!check_if_keyname_exists(field_name,start,end) &&
      my_strcasecmp(system_charset_info,field_name,primary_key_name))
1518 1519 1520 1521 1522 1523 1524
    return (char*) field_name;			// Use fieldname
  buff_end=strmake(buff,field_name, sizeof(buff)-4);

  /*
    Only 3 chars + '\0' left, so need to limit to 2 digit
    This is ok as we can't have more than 100 keys anyway
  */
1525
  for (uint i=2 ; i< 100; i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1526
  {
1527 1528
    *buff_end= '_';
    int10_to_str(i, buff_end+1, 10);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1529 1530 1531
    if (!check_if_keyname_exists(buff,start,end))
      return sql_strdup(buff);
  }
1532
  return (char*) "not_specified";		// Should never happen
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1533 1534
}

1535

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1536 1537 1538 1539 1540
/****************************************************************************
** Create table from a list of fields and items
****************************************************************************/

TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
1541 1542 1543 1544 1545
			       const char *db, const char *name,
			       List<create_field> *extra_fields,
			       List<Key> *keys,
			       List<Item> *items,
			       MYSQL_LOCK **lock)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1546
{
1547
  TABLE tmp_table;		// Used during 'create_field()'
1548
  TABLE *table= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1549
  tmp_table.table_name=0;
1550
  uint select_field_count= items->elements;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1551 1552 1553
  DBUG_ENTER("create_table_from_items");

  /* Add selected items to field list */
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1554
  List_iterator_fast<Item> it(*items);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1555 1556 1557 1558 1559 1560
  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 ||
1561
				    create_info->db_type == DB_TYPE_HEAP);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1562 1563 1564 1565

  while ((item=it++))
  {
    create_field *cr_field;
1566 1567 1568 1569 1570
    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(),
1571
				  (Item ***) 0, &tmp_field, 0, 0, 0);
1572
    if (!field ||
1573 1574 1575
	!(cr_field=new create_field(field,(item->type() == Item::FIELD_ITEM ?
					   ((Item_field *)item)->field :
					   (Field*) 0))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1576 1577 1578 1579
      DBUG_RETURN(0);
    extra_fields->push_back(cr_field);
  }
  /* create and lock table */
1580
  /* QQ: create and open should be done atomic ! */
1581
  /*
1582
    We don't log the statement, it will be logged later.
1583 1584 1585 1586
    If this is a HEAP table, the automatic DELETE FROM which is written to the
    binlog when a HEAP table is opened for the first time since startup, must
    not be written: 1) it would be wrong (imagine we're in CREATE SELECT: we
    don't want to delete from it) 2) it would be written before the CREATE
1587 1588
    TABLE, which is a wrong order. So we keep binary logging disabled when we
    open_table().
1589
  */
1590
  tmp_disable_binlog(thd);
serg@serg.mylan's avatar
serg@serg.mylan committed
1591
  if (!mysql_create_table(thd,db,name,create_info,*extra_fields,
serg@serg.mylan's avatar
serg@serg.mylan committed
1592
			 *keys,0,select_field_count))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1593
  {
1594 1595
    if (!(table=open_table(thd,db,name,name,(bool*) 0)))
      quick_rm_table(create_info->db_type,db,table_case_name(create_info,name));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1596
  }
1597 1598 1599
  reenable_binlog(thd);
  if (!table)
    DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1600
  table->reginfo.lock_type=TL_WRITE;
1601
  if (! ((*lock)= mysql_lock_tables(thd, &table, 1, MYSQL_LOCK_IGNORE_FLUSH)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1602
  {
1603
    VOID(pthread_mutex_lock(&LOCK_open));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1604
    hash_delete(&open_cache,(byte*) table);
1605
    VOID(pthread_mutex_unlock(&LOCK_open));
1606
    quick_rm_table(create_info->db_type,db,table_case_name(create_info, name));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617
    DBUG_RETURN(0);
  }
  table->file->extra(HA_EXTRA_WRITE_CACHE);
  DBUG_RETURN(table);
}


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

1618
bool
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1619
mysql_rename_table(enum db_type base,
1620 1621 1622 1623
		   const char *old_db,
		   const char *old_name,
		   const char *new_db,
		   const char *new_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1624
{
1625 1626 1627
  char from[FN_REFLEN], to[FN_REFLEN], lc_from[FN_REFLEN], lc_to[FN_REFLEN];
  char *from_base= from, *to_base= to;
  char tmp_name[NAME_LEN+1];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1628
  handler *file=get_new_handler((TABLE*) 0, base);
1629
  int error=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1630
  DBUG_ENTER("mysql_rename_table");
1631

1632 1633 1634 1635 1636 1637 1638 1639
  build_table_path(from, sizeof(from), old_db, old_name, "");
  build_table_path(to, sizeof(to), new_db, new_name, "");

  /*
    If lower_case_table_names == 2 (case-preserving but case-insensitive
    file system) and the storage is not HA_FILE_BASED, we need to provide
    a lowercase file name, but we leave the .frm in mixed case.
   */
1640 1641
  if (lower_case_table_names == 2 && !(file->table_flags() & HA_FILE_BASED))
  {
1642 1643 1644 1645
    strmov(tmp_name, old_name);
    my_casedn_str(files_charset_info, tmp_name);
    build_table_path(lc_from, sizeof(lc_from), old_db, tmp_name, "");
    from_base= lc_from;
1646

1647 1648 1649 1650
    strmov(tmp_name, new_name);
    my_casedn_str(files_charset_info, tmp_name);
    build_table_path(lc_to, sizeof(lc_to), new_db, tmp_name, "");
    to_base= lc_to;
1651 1652
  }

1653
  if (!(error=file->rename_table(from_base, to_base)))
1654 1655 1656
  {
    if (rename_file_ext(from,to,reg_ext))
    {
1657
      error=my_errno;
1658
      /* Restore old file name */
1659
      file->rename_table(to_base, from_base);
1660 1661
    }
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1662
  delete file;
1663 1664 1665
  if (error)
    my_error(ER_ERROR_ON_RENAME, MYF(0), from, to, error);
  DBUG_RETURN(error != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1666 1667
}

1668

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1669
/*
1670 1671 1672 1673
  Force all other threads to stop using the table

  SYNOPSIS
    wait_while_table_is_used()
1674 1675 1676 1677
    thd			Thread handler
    table		Table to remove from cache
    function		HA_EXTRA_PREPARE_FOR_DELETE if table is to be deleted
			HA_EXTRA_FORCE_REOPEN if table is not be used
1678 1679 1680 1681 1682 1683 1684
  NOTES
   When returning, the table will be unusable for other threads until
   the table is closed.

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

1687
static void wait_while_table_is_used(THD *thd,TABLE *table,
1688
				     enum ha_extra_function function)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1689
{
1690 1691 1692
  DBUG_PRINT("enter",("table: %s", table->real_name));
  DBUG_ENTER("wait_while_table_is_used");
  safe_mutex_assert_owner(&LOCK_open);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1693

1694
  VOID(table->file->extra(function));
1695
  /* Mark all tables that are in use as 'old' */
1696
  mysql_lock_abort(thd, table);			// end threads waiting on lock
1697 1698

  /* Wait until all there are no other threads that has this table open */
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
1699
  remove_table_from_cache(thd,table->table_cache_key,
1700
                          table->real_name, RTFC_WAIT_OTHER_THREAD_FLAG);
1701 1702
  DBUG_VOID_RETURN;
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1703

1704 1705
/*
  Close a cached table
1706

1707
  SYNOPSIS
1708
    close_cached_table()
1709 1710
    thd			Thread handler
    table		Table to remove from cache
1711 1712 1713 1714

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

1716 1717 1718 1719
  PREREQUISITES
    Lock on LOCK_open
    Win32 clients must also have a WRITE LOCK on the table !
*/
1720

1721
static bool close_cached_table(THD *thd, TABLE *table)
1722 1723
{
  DBUG_ENTER("close_cached_table");
1724

1725
  wait_while_table_is_used(thd, table, HA_EXTRA_PREPARE_FOR_DELETE);
1726 1727
  /* Close lock if this is not got with LOCK TABLES */
  if (thd->lock)
1728
  {
1729
    mysql_unlock_tables(thd, thd->lock);
1730
    thd->lock=0;			// Start locked threads
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1731
  }
1732 1733 1734 1735 1736
  /* 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);
1737
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1738 1739
}

1740
static int send_check_errmsg(THD *thd, TABLE_LIST* table,
1741
			     const char* operator_name, const char* errmsg)
1742

1743
{
1744 1745
  Protocol *protocol= thd->protocol;
  protocol->prepare_for_resend();
1746 1747 1748 1749
  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);
1750
  thd->net.last_error[0]=0;
1751
  if (protocol->write())
1752 1753 1754 1755
    return -1;
  return 1;
}

1756

serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1757
static int prepare_for_restore(THD* thd, TABLE_LIST* table,
1758
			       HA_CHECK_OPT *check_opt)
1759
{
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1760
  DBUG_ENTER("prepare_for_restore");
1761

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1762 1763 1764
  if (table->table) // do not overwrite existing tables on restore
  {
    DBUG_RETURN(send_check_errmsg(thd, table, "restore",
1765 1766
				  "table exists, will not overwrite on restore"
				  ));
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1767
  }
1768
  else
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1769
  {
1770
    char* backup_dir= thd->lex->backup_dir;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1771
    char src_path[FN_REFLEN], dst_path[FN_REFLEN];
1772
    char* table_name = table->real_name;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1773
    char* db = thd->db ? thd->db : table->db;
1774

1775
    if (fn_format_relative_to_data_home(src_path, table_name, backup_dir,
1776
					reg_ext))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1777
      DBUG_RETURN(-1); // protect buffer overflow
1778

1779
    my_snprintf(dst_path, sizeof(dst_path), "%s%s/%s",
1780
		mysql_real_data_home, db, table_name);
1781

1782
    if (lock_and_wait_for_table_name(thd,table))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1783
      DBUG_RETURN(-1);
1784

1785
    if (my_copy(src_path,
1786 1787
		fn_format(dst_path, dst_path,"", reg_ext, 4),
		MYF(MY_WME)))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1788
    {
1789
      pthread_mutex_lock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1790
      unlock_table_name(thd, table);
1791
      pthread_mutex_unlock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1792
      DBUG_RETURN(send_check_errmsg(thd, table, "restore",
1793
				    "Failed copying .frm file"));
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1794
    }
1795
    if (mysql_truncate(thd, table, 1))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1796
    {
1797
      pthread_mutex_lock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1798
      unlock_table_name(thd, table);
1799
      pthread_mutex_unlock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1800
      DBUG_RETURN(send_check_errmsg(thd, table, "restore",
1801
				    "Failed generating table from .frm file"));
1802
    }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1803
  }
1804

1805 1806 1807 1808
  /*
    Now we should be able to open the partially restored table
    to finish the restore in the handler later on
  */
1809
  if (!(table->table = reopen_name_locked_table(thd, table)))
1810 1811
  {
    pthread_mutex_lock(&LOCK_open);
1812
    unlock_table_name(thd, table);
1813 1814
    pthread_mutex_unlock(&LOCK_open);
  }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1815
  DBUG_RETURN(0);
1816
}
1817

1818

1819
static int prepare_for_repair(THD* thd, TABLE_LIST *table_list,
1820
			      HA_CHECK_OPT *check_opt)
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1821
{
1822 1823
  int error= 0;
  TABLE tmp_table, *table;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1824 1825 1826 1827
  DBUG_ENTER("prepare_for_repair");

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

1829
  if (!(table= table_list->table))		/* if open_ltable failed */
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1830
  {
1831
    char name[FN_REFLEN];
1832 1833
    build_table_path(name, sizeof(name), table_list->db,
                     table_list->real_name, "");
1834
    if (openfrm(name, "", 0, 0, 0, &tmp_table))
1835
      DBUG_RETURN(0);				// Can't open frm file
1836
    table= &tmp_table;
1837
  }
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1838

1839 1840 1841 1842 1843 1844 1845 1846 1847
  /*
    User gave us USE_FRM which means that the header in the index file is
    trashed.
    In this case we will try to fix the table the following way:
    - Rename the data file to a temporary name
    - Truncate the table
    - Replace the new data file with the old one
    - Run a normal repair using the new index file and the old data file
  */
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1848

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

1853 1854 1855 1856 1857
  /*
    Check if this is a table type that stores index and data separately,
    like ISAM or MyISAM
  */
  if (!ext[0] || !ext[1])
1858
    goto end;					// No data file
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1859

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

1864 1865
  my_snprintf(tmp, sizeof(tmp), "%s-%lx_%lx",
	      from, current_pid, thd->thread_id);
1866

1867 1868 1869 1870 1871 1872 1873
  /* 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);
  }
1874
  if (lock_and_wait_for_table_name(thd,table_list))
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1875
  {
1876 1877
    error= -1;
    goto end;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1878
  }
1879
  if (my_rename(from, tmp, MYF(MY_WME)))
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1880
  {
1881
    pthread_mutex_lock(&LOCK_open);
1882
    unlock_table_name(thd, table_list);
1883
    pthread_mutex_unlock(&LOCK_open);
1884
    error= send_check_errmsg(thd, table_list, "repair",
1885
			     "Failed renaming data file");
1886 1887 1888 1889 1890 1891 1892 1893
    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",
1894
			     "Failed generating table from .frm file");
1895 1896 1897 1898 1899 1900 1901 1902
    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",
1903
			     "Failed restoring .MYD file");
1904
    goto end;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1905 1906
  }

1907 1908 1909 1910
  /*
    Now we should be able to open the partially repaired table
    to finish the repair in the handler later on.
  */
1911
  if (!(table_list->table = reopen_name_locked_table(thd, table_list)))
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1912 1913
  {
    pthread_mutex_lock(&LOCK_open);
1914
    unlock_table_name(thd, table_list);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1915 1916
    pthread_mutex_unlock(&LOCK_open);
  }
1917 1918 1919

end:
  if (table == &tmp_table)
1920
    closefrm(table);				// Free allocated memory
1921
  DBUG_RETURN(error);
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1922
}
1923

1924

1925 1926 1927 1928 1929 1930
/*
  RETURN VALUES
    0   Message sent to net (admin operation went ok)
   -1   Message should be sent by caller 
        (admin operation or network communication failed)
*/
1931
static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
1932 1933 1934 1935 1936 1937 1938 1939 1940
			     HA_CHECK_OPT* check_opt,
			     const char *operator_name,
			     thr_lock_type lock_type,
			     bool open_for_modify,
			     uint extra_open_options,
			     int (*prepare_func)(THD *, TABLE_LIST *,
						 HA_CHECK_OPT *),
			     int (handler::*operator_func)
			     (THD *, HA_CHECK_OPT *))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1941 1942 1943
{
  TABLE_LIST *table;
  List<Item> field_list;
1944 1945
  Item *item;
  Protocol *protocol= thd->protocol;
1946
  DBUG_ENTER("mysql_admin_table");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1947 1948 1949 1950 1951 1952 1953 1954 1955

  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;
1956
  if (protocol->send_fields(&field_list, 1))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1957 1958
    DBUG_RETURN(-1);

1959
  mysql_ha_flush(thd, tables, MYSQL_HA_CLOSE_FINAL, FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1960 1961 1962
  for (table = tables; table; table = table->next)
  {
    char table_name[NAME_LEN*2+2];
1963
    char* db = table->db;
1964
    bool fatal_error=0;
1965
    strxmov(table_name, db, ".", table->real_name, NullS);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1966

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1967
    thd->open_options|= extra_open_options;
1968
    table->table = open_ltable(thd, table, lock_type);
1969 1970 1971
#ifdef EMBEDDED_LIBRARY
    thd->net.last_errno= 0;  // these errors shouldn't get client
#endif
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1972
    thd->open_options&= ~extra_open_options;
1973

1974
    if (prepare_func)
1975
    {
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
1976
      switch ((*prepare_func)(thd, table, check_opt)) {
1977 1978 1979 1980 1981 1982 1983
      case  1:           // error, message written to net
        close_thread_tables(thd);
        continue;
      case -1:           // error, message could be written to net
        goto err;
      default:           // should be 0 otherwise
        ;
1984
      }
1985
    }
1986

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1987 1988 1989
    if (!table->table)
    {
      const char *err_msg;
1990
      protocol->prepare_for_resend();
1991 1992 1993
      protocol->store(table_name, system_charset_info);
      protocol->store(operator_name, system_charset_info);
      protocol->store("error",5, system_charset_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1994
      if (!(err_msg=thd->net.last_error))
1995
	err_msg=ER(ER_CHECK_NO_SUCH_TABLE);
1996
      protocol->store(err_msg, system_charset_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1997
      thd->net.last_error[0]=0;
1998
      if (protocol->write())
1999
	goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2000 2001
      continue;
    }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2002
    table->table->pos_in_table_list= table;
2003
    if ((table->table->db_stat & HA_READ_ONLY) && open_for_modify)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2004
    {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2005
      char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
2006
      protocol->prepare_for_resend();
2007 2008 2009
      protocol->store(table_name, system_charset_info);
      protocol->store(operator_name, system_charset_info);
      protocol->store("error", 5, system_charset_info);
2010
      my_snprintf(buff, sizeof(buff), ER(ER_OPEN_AS_READONLY), table_name);
2011
      protocol->store(buff, system_charset_info);
2012
      close_thread_tables(thd);
2013
      table->table=0;				// For query cache
2014
      if (protocol->write())
2015
	goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2016 2017 2018
      continue;
    }

2019
    /* Close all instances of the table to allow repair to rename files */
2020
    if (lock_type == TL_WRITE && table->table->version)
2021 2022
    {
      pthread_mutex_lock(&LOCK_open);
2023
      const char *old_message=thd->enter_cond(&COND_refresh, &LOCK_open,
2024
					      "Waiting to get writelock");
2025
      mysql_lock_abort(thd,table->table);
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
2026
      remove_table_from_cache(thd, table->table->table_cache_key,
monty@mysql.com's avatar
monty@mysql.com committed
2027 2028 2029
                              table->table->real_name,
                              RTFC_WAIT_OTHER_THREAD_FLAG |
                              RTFC_CHECK_KILLED_FLAG);
2030
      thd->exit_cond(old_message);
2031
      if (thd->killed)
2032
	goto err;
2033 2034 2035
      /* Flush entries in the query cache involving this table. */
      query_cache_invalidate3(thd, table->table, 0);
      open_for_modify= 0;
2036 2037
    }

2038
    int result_code = (table->table->file->*operator_func)(thd, check_opt);
hf@bisonxp.(none)'s avatar
hf@bisonxp.(none) committed
2039 2040 2041
#ifdef EMBEDDED_LIBRARY
    thd->net.last_errno= 0;  // these errors shouldn't get client
#endif
2042
    protocol->prepare_for_resend();
2043 2044
    protocol->store(table_name, system_charset_info);
    protocol->store(operator_name, system_charset_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2045

2046 2047 2048
send_result_message:

    DBUG_PRINT("info", ("result_code: %d", result_code));
2049 2050
    switch (result_code) {
    case HA_ADMIN_NOT_IMPLEMENTED:
2051
      {
2052 2053 2054
	char buf[ERRMSGSIZE+20];
	uint length=my_snprintf(buf, ERRMSGSIZE,
				ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);
2055
	protocol->store("note", 4, system_charset_info);
2056
	protocol->store(buf, length, system_charset_info);
2057
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2058 2059
      break;

2060
    case HA_ADMIN_OK:
2061 2062
      protocol->store("status", 6, system_charset_info);
      protocol->store("OK",2, system_charset_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2063 2064
      break;

2065
    case HA_ADMIN_FAILED:
2066 2067
      protocol->store("status", 6, system_charset_info);
      protocol->store("Operation failed",16, system_charset_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2068 2069
      break;

vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
2070 2071 2072
    case HA_ADMIN_REJECT:
      protocol->store("status", 6, system_charset_info);
      protocol->store("Operation need committed state",30, system_charset_info);
monty@mysql.com's avatar
monty@mysql.com committed
2073
      open_for_modify= FALSE;
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
2074 2075
      break;

2076
    case HA_ADMIN_ALREADY_DONE:
2077 2078
      protocol->store("status", 6, system_charset_info);
      protocol->store("Table is already up to date", 27, system_charset_info);
2079 2080
      break;

2081
    case HA_ADMIN_CORRUPT:
2082
      protocol->store("error", 5, system_charset_info);
2083
      protocol->store("Corrupt", 7, system_charset_info);
2084
      fatal_error=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2085 2086
      break;

2087
    case HA_ADMIN_INVALID:
2088 2089
      protocol->store("error", 5, system_charset_info);
      protocol->store("Invalid argument",16, system_charset_info);
2090 2091
      break;

2092 2093 2094 2095 2096 2097 2098 2099 2100 2101
    case HA_ADMIN_TRY_ALTER:
    {
      /*
        This is currently used only by InnoDB. ha_innobase::optimize() answers
        "try with alter", so here we close the table, do an ALTER TABLE,
        reopen the table and do ha_innobase::analyze() on it.
      */
      close_thread_tables(thd);
      TABLE_LIST *save_next= table->next;
      table->next= 0;
2102
      tmp_disable_binlog(thd); // binlogging is done by caller if wanted
2103
      result_code= mysql_recreate_table(thd, table, 0);
2104
      reenable_binlog(thd);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2105
      close_thread_tables(thd);
2106 2107 2108 2109 2110 2111
      if (!result_code) // recreation went ok
      {
        if ((table->table= open_ltable(thd, table, lock_type)) &&
            ((result_code= table->table->file->analyze(thd, check_opt)) > 0))
          result_code= 0; // analyze went ok
      }
2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133
      if (result_code) // either mysql_recreate_table or analyze failed
      {
        const char *err_msg;
        if ((err_msg= thd->net.last_error))
        {
          if (!thd->vio_ok())
          {
            sql_print_error(err_msg);
          }
          else
          {
            /* Hijack the row already in-progress. */
            protocol->store("error", 5, system_charset_info);
            protocol->store(err_msg, system_charset_info);
            (void)protocol->write();
            /* Start off another row for HA_ADMIN_FAILED */
            protocol->prepare_for_resend();
            protocol->store(table_name, system_charset_info);
            protocol->store(operator_name, system_charset_info);
          }
        }
      }
2134 2135 2136 2137 2138
      result_code= result_code ? HA_ADMIN_FAILED : HA_ADMIN_OK;
      table->next= save_next;
      goto send_result_message;
    }

2139
    default:				// Probably HA_ADMIN_INTERNAL_ERROR
2140 2141
      protocol->store("error", 5, system_charset_info);
      protocol->store("Unknown - internal error during operation", 41
2142
		      , system_charset_info);
2143
      fatal_error=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2144 2145
      break;
    }
2146
    if (fatal_error)
2147
      table->table->version=0;			// Force close of table
2148
    else if (open_for_modify)
2149
    {
2150
      pthread_mutex_lock(&LOCK_open);
2151
      remove_table_from_cache(thd, table->table->table_cache_key,
2152
			      table->table->real_name, RTFC_NO_FLAG);
2153
      pthread_mutex_unlock(&LOCK_open);
2154 2155 2156
      /* May be something modified consequently we have to invalidate cache */
      query_cache_invalidate3(thd, table->table, 0);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2157
    close_thread_tables(thd);
2158
    table->table=0;				// For query cache
2159
    if (protocol->write())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2160 2161 2162
      goto err;
  }

2163
  send_eof(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2164 2165
  DBUG_RETURN(0);
 err:
2166
  close_thread_tables(thd);			// Shouldn't be needed
2167 2168
  if (table)
    table->table=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2169 2170 2171
  DBUG_RETURN(-1);
}

2172

2173 2174 2175 2176
int mysql_backup_table(THD* thd, TABLE_LIST* table_list)
{
  DBUG_ENTER("mysql_backup_table");
  DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
2177 2178
				"backup", TL_READ, 0, 0, 0,
				&handler::backup));
2179
}
2180

2181

2182 2183 2184 2185
int mysql_restore_table(THD* thd, TABLE_LIST* table_list)
{
  DBUG_ENTER("mysql_restore_table");
  DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
2186 2187 2188
				"restore", TL_WRITE, 1, 0,
				&prepare_for_restore,
				&handler::restore));
2189
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2190

2191

2192 2193 2194 2195
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,
2196 2197 2198
				"repair", TL_WRITE, 1, HA_OPEN_FOR_REPAIR,
				&prepare_for_repair,
				&handler::repair));
2199 2200
}

2201

2202 2203 2204 2205
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,
2206 2207
				"optimize", TL_WRITE, 1,0,0,
				&handler::optimize));
2208 2209 2210
}


igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2211 2212 2213 2214 2215
/*
  Assigned specified indexes for a table into key cache

  SYNOPSIS
    mysql_assign_to_keycache()
2216 2217
    thd		Thread object
    tables	Table list (one table only)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2218 2219

  RETURN VALUES
2220 2221
    0	  ok
   -1	  error
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2222 2223
*/

2224
int mysql_assign_to_keycache(THD* thd, TABLE_LIST* tables,
2225
			     LEX_STRING *key_cache_name)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2226
{
2227
  HA_CHECK_OPT check_opt;
2228
  KEY_CACHE *key_cache;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2229
  DBUG_ENTER("mysql_assign_to_keycache");
2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241

  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,
2242 2243
				"assign_to_keycache", TL_READ_NO_INSERT, 0,
				0, 0, &handler::assign_to_keycache));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2244 2245
}

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2246 2247 2248 2249 2250 2251

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

  SYNOPSIS
    reassign_keycache_tables()
2252 2253 2254
    thd		Thread object
    src_cache	Reference to the key cache to clean up
    dest_cache	New key cache
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2255

2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268
  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
2269
    0	  ok
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2270 2271
*/

2272 2273
int reassign_keycache_tables(THD *thd, KEY_CACHE *src_cache,
			     KEY_CACHE *dst_cache)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2274 2275 2276
{
  DBUG_ENTER("reassign_keycache_tables");

2277 2278
  DBUG_ASSERT(src_cache != dst_cache);
  DBUG_ASSERT(src_cache->in_init);
2279
  src_cache->param_buff_size= 0;		// Free key cache
2280 2281
  ha_resize_key_cache(src_cache);
  ha_change_key_cache(src_cache, dst_cache);
2282
  DBUG_RETURN(0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2283 2284 2285
}


igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2286 2287 2288 2289 2290
/*
  Preload specified indexes for a table into key cache

  SYNOPSIS
    mysql_preload_keys()
2291 2292
    thd		Thread object
    tables	Table list (one table only)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2293 2294

  RETURN VALUES
2295 2296
    0	  ok
   -1	  error
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2297 2298 2299 2300 2301 2302
*/

int mysql_preload_keys(THD* thd, TABLE_LIST* tables)
{
  DBUG_ENTER("mysql_preload_keys");
  DBUG_RETURN(mysql_admin_table(thd, tables, 0,
2303 2304
				"preload_keys", TL_READ, 0, 0, 0,
				&handler::preload_keys));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2305 2306 2307
}


venu@myvenu.com's avatar
venu@myvenu.com committed
2308 2309 2310 2311 2312
/*
  Create a table identical to the specified table

  SYNOPSIS
    mysql_create_like_table()
2313 2314
    thd		Thread object
    table	Table list (one table only)
venu@myvenu.com's avatar
venu@myvenu.com committed
2315 2316 2317 2318
    create_info Create info
    table_ident Src table_ident

  RETURN VALUES
2319 2320
    0	  ok
    -1	error
venu@myvenu.com's avatar
venu@myvenu.com committed
2321 2322
*/

2323 2324 2325
int mysql_create_like_table(THD* thd, TABLE_LIST* table,
			    HA_CREATE_INFO *create_info,
			    Table_ident *table_ident)
venu@myvenu.com's avatar
venu@myvenu.com committed
2326 2327 2328 2329 2330
{
  TABLE **tmp_table;
  char src_path[FN_REFLEN], dst_path[FN_REFLEN];
  char *db= table->db;
  char *table_name= table->real_name;
2331
  char *src_db;
venu@myvenu.com's avatar
venu@myvenu.com committed
2332
  char *src_table= table_ident->table.str;
2333 2334
  int  err, res= -1;
  TABLE_LIST src_tables_list;
venu@myvenu.com's avatar
venu@myvenu.com committed
2335
  DBUG_ENTER("mysql_create_like_table");
2336
  src_db= table_ident->db.str ? table_ident->db.str : thd->db;
venu@myvenu.com's avatar
venu@myvenu.com committed
2337 2338 2339 2340 2341 2342

  /*
    Validate the source table
  */
  if (table_ident->table.length > NAME_LEN ||
      (table_ident->table.length &&
2343
       check_table_name(src_table,table_ident->table.length)))
venu@myvenu.com's avatar
venu@myvenu.com committed
2344
  {
2345
    my_error(ER_WRONG_TABLE_NAME, MYF(0), src_table);
2346
    DBUG_RETURN(-1);
venu@myvenu.com's avatar
venu@myvenu.com committed
2347
  }
2348 2349 2350 2351 2352
  if (!src_db || check_db_name(src_db))
  {
    my_error(ER_WRONG_DB_NAME, MYF(0), src_db ? src_db : "NULL");
    DBUG_RETURN(-1);
  }
2353

2354 2355
  src_tables_list.db= src_db;
  src_tables_list.real_name= src_table;
2356
  src_tables_list.next= 0;
2357

2358 2359
  if (lock_and_wait_for_table_name(thd, &src_tables_list))
    goto err;
venu@myvenu.com's avatar
venu@myvenu.com committed
2360 2361 2362 2363 2364

  if ((tmp_table= find_temporary_table(thd, src_db, src_table)))
    strxmov(src_path, (*tmp_table)->path, reg_ext, NullS);
  else
  {
2365 2366 2367 2368
    strxmov(src_path, mysql_data_home, "/", src_db, "/", src_table,
	    reg_ext, NullS);
    /* Resolve symlinks (for windows) */
    fn_format(src_path, src_path, "", "", MYF(MY_UNPACK_FILENAME));
2369 2370
    if (lower_case_table_names)
      my_casedn_str(files_charset_info, src_path);
venu@myvenu.com's avatar
venu@myvenu.com committed
2371 2372 2373
    if (access(src_path, F_OK))
    {
      my_error(ER_BAD_TABLE_ERROR, MYF(0), src_table);
2374
      goto err;
venu@myvenu.com's avatar
venu@myvenu.com committed
2375 2376 2377 2378 2379 2380
    }
  }

  /*
    Validate the destination table

2381
    skip the destination table name checking as this is already
venu@myvenu.com's avatar
venu@myvenu.com committed
2382 2383 2384 2385 2386 2387
    validated.
  */
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
    if (find_temporary_table(thd, db, table_name))
      goto table_exists;
2388 2389 2390
    my_snprintf(dst_path, sizeof(dst_path), "%s%s%lx_%lx_%x%s",
		mysql_tmpdir, tmp_file_prefix, current_pid,
		thd->thread_id, thd->tmp_table++, reg_ext);
2391 2392
    if (lower_case_table_names)
      my_casedn_str(files_charset_info, dst_path);
venu@myvenu.com's avatar
venu@myvenu.com committed
2393 2394 2395 2396
    create_info->table_options|= HA_CREATE_DELAY_KEY_WRITE;
  }
  else
  {
2397 2398 2399
    strxmov(dst_path, mysql_data_home, "/", db, "/", table_name,
	    reg_ext, NullS);
    fn_format(dst_path, dst_path, "", "", MYF(MY_UNPACK_FILENAME));
venu@myvenu.com's avatar
venu@myvenu.com committed
2400 2401 2402 2403
    if (!access(dst_path, F_OK))
      goto table_exists;
  }

2404
  /*
venu@myvenu.com's avatar
venu@myvenu.com committed
2405
    Create a new table by copying from source table
2406
  */
2407 2408 2409 2410 2411 2412
  if (my_copy(src_path, dst_path, MYF(MY_DONT_OVERWRITE_FILE)))
  {
    if (my_errno == ENOENT)
      my_error(ER_BAD_DB_ERROR,MYF(0),db);
    else
      my_error(ER_CANT_CREATE_FILE,MYF(0),dst_path,my_errno);
2413
    goto err;
2414
  }
venu@myvenu.com's avatar
venu@myvenu.com committed
2415 2416

  /*
2417 2418
    As mysql_truncate don't work on a new table at this stage of
    creation, instead create the table directly (for both normal
venu@myvenu.com's avatar
venu@myvenu.com committed
2419 2420
    and temporary tables).
  */
2421
  *fn_ext(dst_path)= 0;
venu@myvenu.com's avatar
venu@myvenu.com committed
2422
  err= ha_create_table(dst_path, create_info, 1);
2423

venu@myvenu.com's avatar
venu@myvenu.com committed
2424 2425 2426 2427
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
    if (err || !open_temporary_table(thd, dst_path, db, table_name, 1))
    {
2428 2429
      (void) rm_temporary_table(create_info->db_type,
				dst_path); /* purecov: inspected */
2430
      goto err;     /* purecov: inspected */
venu@myvenu.com's avatar
venu@myvenu.com committed
2431 2432 2433 2434
    }
  }
  else if (err)
  {
2435 2436 2437
    (void) quick_rm_table(create_info->db_type, db,
			  table_name); /* purecov: inspected */
    goto err;	    /* purecov: inspected */
venu@myvenu.com's avatar
venu@myvenu.com committed
2438
  }
2439 2440 2441 2442

  // Must be written before unlock
  mysql_update_log.write(thd,thd->query, thd->query_length);
  if (mysql_bin_log.is_open())
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
2443
  {
2444 2445
    thd->clear_error();
    Query_log_event qinfo(thd, thd->query, thd->query_length,
2446
			  test(create_info->options &
2447 2448
			       HA_LEX_CREATE_TMP_TABLE), 
			  FALSE);
2449
    mysql_bin_log.write(&qinfo);
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
2450
  }
2451
  res= 0;
2452
  goto err;
2453

venu@myvenu.com's avatar
venu@myvenu.com committed
2454 2455 2456 2457
table_exists:
  if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
  {
    char warn_buff[MYSQL_ERRMSG_SIZE];
2458 2459 2460 2461
    my_snprintf(warn_buff, sizeof(warn_buff),
		ER(ER_TABLE_EXISTS_ERROR), table_name);
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
		 ER_TABLE_EXISTS_ERROR,warn_buff);
2462
    res= 0;
venu@myvenu.com's avatar
venu@myvenu.com committed
2463
  }
2464 2465 2466 2467 2468 2469 2470 2471
  else
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);

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


2475 2476
int mysql_analyze_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2477 2478 2479 2480 2481 2482
#ifdef OS2
  thr_lock_type lock_type = TL_WRITE;
#else
  thr_lock_type lock_type = TL_READ_NO_INSERT;
#endif

2483 2484
  DBUG_ENTER("mysql_analyze_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
2485 2486
				"analyze", lock_type, 1,0,0,
				&handler::analyze));
2487 2488 2489 2490 2491
}


int mysql_check_table(THD* thd, TABLE_LIST* tables,HA_CHECK_OPT* check_opt)
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2492 2493 2494 2495 2496 2497
#ifdef OS2
  thr_lock_type lock_type = TL_WRITE;
#else
  thr_lock_type lock_type = TL_READ_NO_INSERT;
#endif

2498 2499
  DBUG_ENTER("mysql_check_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
2500 2501 2502
				"check", lock_type,
				0, HA_OPEN_FOR_REPAIR, 0,
				&handler::check));
2503 2504
}

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

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2506
/* table_list should contain just one table */
monty@mysql.com's avatar
monty@mysql.com committed
2507 2508 2509 2510
static int
mysql_discard_or_import_tablespace(THD *thd,
                                   TABLE_LIST *table_list,
                                   enum tablespace_op_type tablespace_op)
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2511 2512 2513 2514 2515 2516
{
  TABLE *table;
  my_bool discard;
  int error;
  DBUG_ENTER("mysql_discard_or_import_tablespace");

monty@mysql.com's avatar
monty@mysql.com committed
2517 2518 2519 2520
  /*
    Note that DISCARD/IMPORT TABLESPACE always is the only operation in an
    ALTER TABLE
  */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2521 2522 2523

  thd->proc_info="discard_or_import_tablespace";

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

monty@mysql.com's avatar
monty@mysql.com committed
2526 2527 2528 2529 2530
 /*
   We set this flag so that ha_innobase::open and ::external_lock() do
   not complain when we lock the table
 */
  thd->tablespace_op= TRUE;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2531 2532 2533 2534 2535
  if (!(table=open_ltable(thd,table_list,TL_WRITE)))
  {
    thd->tablespace_op=FALSE;
    DBUG_RETURN(-1);
  }
2536

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2537 2538 2539 2540 2541 2542 2543
  error=table->file->discard_or_import_tablespace(discard);

  thd->proc_info="end";

  if (error)
    goto err;

monty@mysql.com's avatar
monty@mysql.com committed
2544 2545 2546 2547
  /*
    The 0 in the call below means 'not in a transaction', which means
    immediate invalidation; that is probably what we wish here
  */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558
  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())
  {
2559
    Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2560 2561 2562 2563
    mysql_bin_log.write(&qinfo);
  }
err:
  close_thread_tables(thd);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2564
  thd->tablespace_op=FALSE;
monty@mysql.com's avatar
monty@mysql.com committed
2565 2566
  if (error == 0)
  {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2567
    send_ok(thd);
monty@mysql.com's avatar
monty@mysql.com committed
2568
    DBUG_RETURN(0);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2569
  }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2570 2571 2572 2573 2574

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

2577 2578

#ifdef NOT_USED
2579 2580 2581 2582 2583 2584 2585
/*
  CREATE INDEX and DROP INDEX are implemented by calling ALTER TABLE with
  the proper arguments.  This isn't very fast but it should work for most
  cases.
  One should normally create all indexes with CREATE TABLE or ALTER TABLE.
*/

2586
int mysql_create_indexes(THD *thd, TABLE_LIST *table_list, List<Key> &keys)
2587 2588 2589 2590 2591
{
  List<create_field> fields;
  List<Alter_drop>   drop;
  List<Alter_column> alter;
  HA_CREATE_INFO     create_info;
2592 2593 2594 2595 2596 2597 2598 2599
  int		     rc;
  uint		     idx;
  uint		     db_options;
  uint		     key_count;
  TABLE		     *table;
  Field		     **f_ptr;
  KEY		     *key_info_buffer;
  char		     path[FN_REFLEN+1];
2600 2601 2602
  DBUG_ENTER("mysql_create_index");

  /*
2603 2604 2605
    Try to use online generation of index.
    This requires that all indexes can be created online.
    Otherwise, the old alter table procedure is executed.
2606

2607 2608
    Open the table to have access to the correct table handler.
  */
2609 2610 2611 2612
  if (!(table=open_ltable(thd,table_list,TL_WRITE_ALLOW_READ)))
    DBUG_RETURN(-1);

  /*
2613 2614 2615 2616 2617
    The add_index method takes an array of KEY structs for the new indexes.
    Preparing a new table structure generates this array.
    It needs a list with all fields of the table, which does not need to
    be correct in every respect. The field names are important.
  */
2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628
  for (f_ptr= table->field; *f_ptr; f_ptr++)
  {
    create_field *c_fld= new create_field(*f_ptr, *f_ptr);
    c_fld->unireg_check= Field::NONE; /*avoid multiple auto_increments*/
    fields.push_back(c_fld);
  }
  bzero((char*) &create_info,sizeof(create_info));
  create_info.db_type=DB_TYPE_DEFAULT;
  create_info.default_table_charset= thd->variables.collation_database;
  db_options= 0;
  if (mysql_prepare_table(thd, &create_info, fields,
2629 2630 2631
			  keys, /*tmp_table*/ 0, db_options, table->file,
			  key_info_buffer, key_count,
			  /*select_field_count*/ 0))
2632 2633 2634
    DBUG_RETURN(-1);

  /*
2635 2636 2637
    Check if all keys can be generated with the add_index method.
    If anyone cannot, then take the old way.
  */
2638 2639 2640 2641
  for (idx=0; idx< key_count; idx++)
  {
    DBUG_PRINT("info", ("creating index %s", key_info_buffer[idx].name));
    if (!(table->file->index_ddl_flags(key_info_buffer+idx)&
2642
	  (HA_DDL_ONLINE| HA_DDL_WITH_LOCK)))
2643 2644
      break ;
  }
2645
  if ((idx < key_count)|| !key_count)
2646 2647 2648 2649 2650 2651 2652 2653
  {
    /* Re-initialize the create_info, which was changed by prepare table. */
    bzero((char*) &create_info,sizeof(create_info));
    create_info.db_type=DB_TYPE_DEFAULT;
    create_info.default_table_charset= thd->variables.collation_database;
    /* Cleanup the fields list. We do not want to create existing fields. */
    fields.delete_elements();
    if (real_alter_table(thd, table_list->db, table_list->real_name,
2654 2655 2656 2657
			 &create_info, table_list, table,
			 fields, keys, drop, alter, 0, (ORDER*)0,
			 ALTER_ADD_INDEX, DUP_ERROR))
      /* Don't need to free((gptr) key_info_buffer);*/
2658 2659 2660 2661 2662
      DBUG_RETURN(-1);
  }
  else
  {
    if (table->file->add_index(table, key_info_buffer, key_count)||
2663 2664
        build_table_path(path, sizeof(path), table_list->db,
                         (lower_case_table_names == 2) ?
2665
                         table_list->alias : table_list->real_name,
2666
                         reg_ext) == 0 ||
2667 2668 2669
	mysql_create_frm(thd, path, &create_info,
			 fields, key_count, key_info_buffer, table->file))
      /* don't need to free((gptr) key_info_buffer);*/
2670 2671
      DBUG_RETURN(-1);
  }
2672
  /* don't need to free((gptr) key_info_buffer);*/
2673 2674 2675 2676
  DBUG_RETURN(0);
}


2677 2678
int mysql_drop_indexes(THD *thd, TABLE_LIST *table_list,
		       List<Alter_drop> &drop)
2679 2680
{
  List<create_field> fields;
2681
  List<Key>	     keys;
2682 2683
  List<Alter_column> alter;
  HA_CREATE_INFO     create_info;
2684 2685 2686 2687 2688 2689 2690 2691 2692
  uint		     idx;
  uint		     db_options;
  uint		     key_count;
  uint		     *key_numbers;
  TABLE		     *table;
  Field		     **f_ptr;
  KEY		     *key_info;
  KEY		     *key_info_buffer;
  char		     path[FN_REFLEN];
2693 2694 2695
  DBUG_ENTER("mysql_drop_index");

  /*
2696 2697 2698
    Try to use online generation of index.
    This requires that all indexes can be created online.
    Otherwise, the old alter table procedure is executed.
2699

2700 2701
    Open the table to have access to the correct table handler.
  */
2702 2703 2704 2705
  if (!(table=open_ltable(thd,table_list,TL_WRITE_ALLOW_READ)))
    DBUG_RETURN(-1);

  /*
2706 2707 2708
    The drop_index method takes an array of key numbers.
    It cannot get more entries than keys in the table.
  */
2709 2710 2711 2712
  key_numbers= (uint*) thd->alloc(sizeof(uint*)*table->keys);
  key_count= 0;

  /*
2713 2714
    Get the number of each key and check if it can be created online.
  */
2715 2716 2717 2718 2719 2720 2721 2722 2723
  List_iterator<Alter_drop> drop_it(drop);
  Alter_drop *drop_key;
  while ((drop_key= drop_it++))
  {
    /* Find the key in the table. */
    key_info=table->key_info;
    for (idx=0; idx< table->keys; idx++, key_info++)
    {
      if (!my_strcasecmp(system_charset_info, key_info->name, drop_key->name))
2724
	break;
2725 2726 2727 2728 2729 2730 2731 2732
    }
    if (idx>= table->keys)
    {
      my_error(ER_CANT_DROP_FIELD_OR_KEY, MYF(0), drop_key->name);
      /*don't need to free((gptr) key_numbers);*/
      DBUG_RETURN(-1);
    }
    /*
2733 2734 2735
      Check if the key can be generated with the add_index method.
      If anyone cannot, then take the old way.
    */
2736 2737
    DBUG_PRINT("info", ("dropping index %s", table->key_info[idx].name));
    if (!(table->file->index_ddl_flags(table->key_info+idx)&
2738
	  (HA_DDL_ONLINE| HA_DDL_WITH_LOCK)))
2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749
      break ;
    key_numbers[key_count++]= idx;
  }

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

  if ((drop_key)|| (drop.elements<= 0))
  {
    if (real_alter_table(thd, table_list->db, table_list->real_name,
2750 2751 2752
			 &create_info, table_list, table,
			 fields, keys, drop, alter, 0, (ORDER*)0,
			 ALTER_DROP_INDEX, DUP_ERROR))
2753 2754 2755 2756 2757 2758 2759
      /*don't need to free((gptr) key_numbers);*/
      DBUG_RETURN(-1);
  }
  else
  {
    db_options= 0;
    if (table->file->drop_index(table, key_numbers, key_count)||
2760 2761 2762 2763
	mysql_prepare_table(thd, &create_info, fields,
			    keys, /*tmp_table*/ 0, db_options, table->file,
			    key_info_buffer, key_count,
			    /*select_field_count*/ 0)||
2764 2765
        build_table_path(path, sizeof(path), table_list->db,
                         (lower_case_table_names == 2) ?
2766
                         table_list->alias : table_list->real_name,
2767
                         reg_ext) == 0 ||
2768 2769
	mysql_create_frm(thd, path, &create_info,
			 fields, key_count, key_info_buffer, table->file))
2770 2771 2772 2773 2774 2775 2776
      /*don't need to free((gptr) key_numbers);*/
      DBUG_RETURN(-1);
  }

  /*don't need to free((gptr) key_numbers);*/
  DBUG_RETURN(0);
}
2777
#endif /* NOT_USED */
2778 2779


2780 2781 2782
/*
  Alter table
*/
2783

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2784
int mysql_alter_table(THD *thd,char *new_db, char *new_name,
2785 2786
		      HA_CREATE_INFO *create_info,
		      TABLE_LIST *table_list,
2787 2788
		      List<create_field> &fields, List<Key> &keys,
		      uint order_num, ORDER *order,
2789
		      enum enum_duplicates handle_duplicates, bool ignore,
2790
		      ALTER_INFO *alter_info, bool do_send_ok)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2791
{
2792
  TABLE *table,*new_table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2793
  int error;
2794 2795
  char tmp_name[80],old_name[32],new_name_buff[FN_REFLEN];
  char new_alias_buff[FN_REFLEN], *table_name, *db, *new_alias, *alias;
2796
  char index_file[FN_REFLEN], data_file[FN_REFLEN];
2797 2798
  ha_rows copied,deleted;
  ulonglong next_insert_id;
2799
  uint db_create_options, used_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2800
  enum db_type old_db_type,new_db_type;
2801
  DBUG_ENTER("mysql_alter_table");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2802 2803 2804

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2807
  db=table_list->db;
monty@mysql.com's avatar
monty@mysql.com committed
2808
  if (!new_db || !my_strcasecmp(table_alias_charset, new_db, db))
2809
    new_db= db;
2810
  used_fields=create_info->used_fields;
2811
  
2812
  mysql_ha_flush(thd, table_list, MYSQL_HA_CLOSE_FINAL, FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2813

2814
  /* DISCARD/IMPORT TABLESPACE is always alone in an ALTER TABLE */
2815
  if (alter_info->tablespace_op != NO_TABLESPACE_OP)
2816
    DBUG_RETURN(mysql_discard_or_import_tablespace(thd,table_list,
2817
						   alter_info->tablespace_op));
2818 2819 2820
  if (!(table=open_ltable(thd,table_list,TL_WRITE_ALLOW_READ)))
    DBUG_RETURN(-1);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2821 2822 2823 2824
  /* Check that we are not trying to rename to an existing table */
  if (new_name)
  {
    strmov(new_name_buff,new_name);
2825
    strmov(new_alias= new_alias_buff, new_name);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2826
    if (lower_case_table_names)
2827 2828 2829
    {
      if (lower_case_table_names != 2)
      {
2830
	my_casedn_str(files_charset_info, new_name_buff);
2831
	new_alias= new_name;			// Create lower case table name
2832
      }
2833
      my_casedn_str(files_charset_info, new_name);
2834
    }
2835
    if (new_db == db &&
2836
	!my_strcasecmp(table_alias_charset, new_name_buff, table_name))
2837 2838
    {
      /*
2839 2840
	Source and destination table names are equal: make later check
	easier.
2841
      */
2842
      new_alias= new_name= table_name;
2843
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2844 2845 2846 2847
    else
    {
      if (table->tmp_table)
      {
2848 2849 2850 2851 2852
	if (find_temporary_table(thd,new_db,new_name_buff))
	{
	  my_error(ER_TABLE_EXISTS_ERROR,MYF(0),new_name_buff);
	  DBUG_RETURN(-1);
	}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2853 2854 2855
      }
      else
      {
2856 2857 2858
	char dir_buff[FN_REFLEN];
	strxnmov(dir_buff, FN_REFLEN, mysql_real_data_home, new_db, NullS);
	if (!access(fn_format(new_name_buff,new_name_buff,dir_buff,reg_ext,0),
2859 2860 2861 2862 2863 2864
		    F_OK))
	{
	  /* Table will be closed in do_command() */
	  my_error(ER_TABLE_EXISTS_ERROR,MYF(0), new_alias);
	  DBUG_RETURN(-1);
	}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2865 2866 2867 2868
      }
    }
  }
  else
2869 2870 2871 2872
  {
    new_alias= (lower_case_table_names == 2) ? alias : table_name;
    new_name= table_name;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2873 2874 2875 2876

  old_db_type=table->db_type;
  if (create_info->db_type == DB_TYPE_DEFAULT)
    create_info->db_type=old_db_type;
2877 2878 2879 2880 2881
  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,
2882 2883 2884 2885
			ER_WARN_USING_OTHER_HANDLER,
			ER(ER_WARN_USING_OTHER_HANDLER),
			ha_get_storage_engine(new_db_type),
			new_name);
2886
  }
2887
  if (create_info->row_type == ROW_TYPE_NOT_USED)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2888 2889 2890
    create_info->row_type=table->row_type;

  thd->proc_info="setup";
2891
  if (alter_info->is_simple && !table->tmp_table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2892 2893
  {
    error=0;
2894
    if (new_name != table_name || new_db != db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2895
    {
2896 2897 2898 2899 2900 2901
      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))
      {
2902 2903
	my_error(ER_TABLE_EXISTS_ERROR,MYF(0),new_name);
	error= -1;
2904 2905 2906
      }
      else
      {
2907 2908 2909 2910
	*fn_ext(new_name)=0;
	close_cached_table(thd, table);
	if (mysql_rename_table(old_db_type,db,table_name,new_db,new_alias))
	  error= -1;
2911 2912
      }
      VOID(pthread_mutex_unlock(&LOCK_open));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2913
    }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2914

2915
    if (!error)
2916
    {
2917
      switch (alter_info->keys_onoff) {
2918
      case LEAVE_AS_IS:
2919
	break;
2920
      case ENABLE:
2921
	VOID(pthread_mutex_lock(&LOCK_open));
2922
	wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
2923
	VOID(pthread_mutex_unlock(&LOCK_open));
2924
	error= table->file->enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
2925
	/* COND_refresh will be signaled in close_thread_tables() */
2926 2927
	break;
      case DISABLE:
2928 2929 2930
	VOID(pthread_mutex_lock(&LOCK_open));
	wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
	VOID(pthread_mutex_unlock(&LOCK_open));
2931
	error=table->file->disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
2932
	/* COND_refresh will be signaled in close_thread_tables() */
2933
	break;
2934
      }
2935
    }
2936
    if (error == HA_ERR_WRONG_COMMAND)
serg@serg.mylan's avatar
serg@serg.mylan committed
2937 2938
    {
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
2939 2940
			  ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
			  table->table_name);
serg@serg.mylan's avatar
serg@serg.mylan committed
2941 2942
      error=0;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2943 2944
    if (!error)
    {
2945 2946 2947
      mysql_update_log.write(thd, thd->query, thd->query_length);
      if (mysql_bin_log.is_open())
      {
2948
	thd->clear_error();
2949
	Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
2950
	mysql_bin_log.write(&qinfo);
2951
      }
2952 2953
      if (do_send_ok)
        send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2954
    }
2955
    else if (error > 0)
2956 2957
    {
      table->file->print_error(error, MYF(0));
2958
      error= -1;
2959
    }
2960
    table_list->table=0;				// For query cache
2961
    query_cache_invalidate3(thd, table_list, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2962 2963 2964 2965
    DBUG_RETURN(error);
  }

  /* Full alter table */
2966 2967 2968 2969 2970 2971 2972 2973

  /* 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;
2974 2975
  if (!(used_fields & HA_CREATE_USED_DEFAULT_CHARSET))
    create_info->default_table_charset= table->table_charset;
2976

2977
  restore_record(table,default_values);		// Empty record for DEFAULT
2978
  List_iterator<Alter_drop> drop_it(alter_info->drop_list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2979
  List_iterator<create_field> def_it(fields);
2980
  List_iterator<Alter_column> alter_it(alter_info->alter_list);
2981 2982
  List<create_field> create_list;		// Add new fields here
  List<Key> key_list;				// Add new keys here
2983 2984
  create_field *def;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2985
  /*
2986
    First collect all fields from table which isn't in drop_list
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2987 2988 2989 2990 2991
  */

  Field **f_ptr,*field;
  for (f_ptr=table->field ; (field= *f_ptr) ; f_ptr++)
  {
2992
    /* Check if field should be dropped */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2993 2994 2995 2996 2997
    Alter_drop *drop;
    drop_it.rewind();
    while ((drop=drop_it++))
    {
      if (drop->type == Alter_drop::COLUMN &&
2998
	  !my_strcasecmp(system_charset_info,field->field_name, drop->name))
2999
      {
3000 3001 3002 3003 3004 3005 3006 3007
	/* Reset auto_increment value if it was dropped */
	if (MTYP_TYPENR(field->unireg_check) == Field::NEXT_NUMBER &&
	    !(used_fields & HA_CREATE_USED_AUTO))
	{
	  create_info->auto_increment_value=0;
	  create_info->used_fields|=HA_CREATE_USED_AUTO;
	}
	break;
3008
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3009 3010 3011 3012 3013 3014 3015 3016 3017 3018
    }
    if (drop)
    {
      drop_it.remove();
      continue;
    }
    /* Check if field is changed */
    def_it.rewind();
    while ((def=def_it++))
    {
3019
      if (def->change &&
3020 3021
	  !my_strcasecmp(system_charset_info,field->field_name, def->change))
	break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3022 3023
    }
    if (def)
3024
    {						// Field is changed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3025
      def->field=field;
3026 3027
      if (!def->after)
      {
3028 3029
	create_list.push_back(def);
	def_it.remove();
3030
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3031 3032
    }
    else
3033
    {						// Use old field value
3034
      create_list.push_back(def=new create_field(field,field));
3035
      alter_it.rewind();			// Change default if ALTER
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3036 3037 3038
      Alter_column *alter;
      while ((alter=alter_it++))
      {
3039 3040
	if (!my_strcasecmp(system_charset_info,field->field_name, alter->name))
	  break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3041 3042 3043
      }
      if (alter)
      {
3044 3045 3046 3047 3048 3049 3050
	if (def->sql_type == FIELD_TYPE_BLOB)
	{
	  my_error(ER_BLOB_CANT_HAVE_DEFAULT,MYF(0),def->change);
	  DBUG_RETURN(-1);
	}
	def->def=alter->def;			// Use new default
	alter_it.remove();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3051 3052 3053 3054 3055
      }
    }
  }
  def_it.rewind();
  List_iterator<create_field> find_it(create_list);
3056
  while ((def=def_it++))			// Add new columns
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3057
  {
3058
    if (def->change && ! def->field)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070
    {
      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();
3071
      while ((find=find_it++))			// Add new columns
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3072
      {
3073 3074
	if (!my_strcasecmp(system_charset_info,def->after, find->field_name))
	  break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3075 3076 3077
      }
      if (!find)
      {
3078 3079
	my_error(ER_BAD_FIELD_ERROR,MYF(0),def->after,table_name);
	DBUG_RETURN(-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3080
      }
3081
      find_it.after(def);			// Put element after this
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3082 3083
    }
  }
3084
  if (alter_info->alter_list.elements)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3085
  {
3086 3087
    my_error(ER_BAD_FIELD_ERROR,MYF(0),alter_info->alter_list.head()->name,
	     table_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3088 3089 3090 3091 3092 3093 3094 3095 3096
    DBUG_RETURN(-1);
  }
  if (!create_list.elements)
  {
    my_error(ER_CANT_REMOVE_ALL_FIELDS,MYF(0));
    DBUG_RETURN(-1);
  }

  /*
3097 3098
    Collect all keys which isn't in drop list. Add only those
    for which some fields exists.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3099 3100 3101 3102 3103 3104 3105 3106 3107
  */

  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++)
  {
3108
    char *key_name= key_info->name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3109 3110 3111 3112 3113
    Alter_drop *drop;
    drop_it.rewind();
    while ((drop=drop_it++))
    {
      if (drop->type == Alter_drop::KEY &&
3114 3115
	  !my_strcasecmp(system_charset_info,key_name, drop->name))
	break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127
    }
    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)
3128
	continue;				// Wrong field (from UNIREG)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3129 3130 3131 3132 3133
      const char *key_part_name=key_part->field->field_name;
      create_field *cfield;
      field_it.rewind();
      while ((cfield=field_it++))
      {
3134 3135 3136 3137 3138 3139 3140 3141 3142
	if (cfield->change)
	{
	  if (!my_strcasecmp(system_charset_info, key_part_name,
			     cfield->change))
	    break;
	}
	else if (!my_strcasecmp(system_charset_info,
				key_part_name, cfield->field_name))
	  break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3143 3144
      }
      if (!cfield)
3145
	continue;				// Field is removed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3146
      uint key_part_length=key_part->length;
3147 3148 3149 3150 3151 3152 3153
      if (cfield->field)			// Not new field
      {						// Check if sub key
	if (cfield->field->type() != FIELD_TYPE_BLOB &&
	    (cfield->field->pack_length() == key_part_length ||
	     cfield->length <= key_part_length /
			       key_part->field->charset()->mbmaxlen))
	  key_part_length=0;			// Use whole field
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3154
      }
3155
      key_part_length /= key_part->field->charset()->mbmaxlen;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3156
      key_parts.push_back(new key_part_spec(cfield->field_name,
3157
					    key_part_length));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3158 3159
    }
    if (key_parts.elements)
3160
      key_list.push_back(new Key(key_info->flags & HA_SPATIAL ? Key::SPATIAL :
3161 3162 3163 3164 3165 3166 3167 3168
				 (key_info->flags & HA_NOSAME ?
				 (!my_strcasecmp(system_charset_info,
						 key_name, primary_key_name) ?
				  Key::PRIMARY	: Key::UNIQUE) :
				  (key_info->flags & HA_FULLTEXT ?
				   Key::FULLTEXT : Key::MULTIPLE)),
				 key_name,
				 key_info->algorithm,
3169
                                 test(key_info->flags & HA_GENERATED_KEY),
3170
				 key_parts));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3171 3172 3173
  }
  {
    Key *key;
3174
    while ((key=key_it++))			// Add new keys
3175 3176
    {
      if (key->type != Key::FOREIGN_KEY)
3177
	key_list.push_back(key);
3178
      if (key->name &&
3179
	  !my_strcasecmp(system_charset_info,key->name,primary_key_name))
3180
      {
3181 3182
	my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name);
	DBUG_RETURN(-1);
3183
      }
3184
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3185 3186
  }

3187
  if (alter_info->drop_list.elements)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3188
  {
3189 3190
    my_error(ER_CANT_DROP_FIELD_OR_KEY,MYF(0),
	     alter_info->drop_list.head()->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3191 3192
    goto err;
  }
3193
  if (alter_info->alter_list.elements)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3194
  {
3195 3196
    my_error(ER_CANT_DROP_FIELD_OR_KEY,MYF(0),
	     alter_info->alter_list.head()->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3197 3198 3199
    goto err;
  }

3200
  db_create_options=table->db_create_options & ~(HA_OPTION_PACK_RECORD);
3201 3202
  my_snprintf(tmp_name, sizeof(tmp_name), "%s-%lx_%lx", tmp_file_prefix,
	      current_pid, thd->thread_id);
3203 3204
  /* Safety fix for innodb */
  if (lower_case_table_names)
3205
    my_casedn_str(files_charset_info, tmp_name);
3206 3207 3208 3209
  if (new_db_type != old_db_type && !table->file->can_switch_engines()) {
    my_error(ER_ROW_IS_REFERENCED, MYF(0));
    goto err;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3210 3211 3212
  create_info->db_type=new_db_type;
  if (!create_info->comment)
    create_info->comment=table->comment;
3213 3214 3215 3216 3217

  table->file->update_create_info(create_info);
  if ((create_info->table_options &
       (HA_OPTION_PACK_KEYS | HA_OPTION_NO_PACK_KEYS)) ||
      (used_fields & HA_CREATE_USED_PACK_KEYS))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3218 3219 3220 3221 3222 3223 3224
    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 |
3225
			  HA_OPTION_NO_DELAY_KEY_WRITE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3226 3227 3228 3229 3230
  create_info->table_options|= db_create_options;

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

3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255
  /*
    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.
  */

3256
  if (!strcmp(db, new_db))		// Ignore symlink if db changed
3257 3258 3259 3260 3261 3262
  {
    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,
3263 3264
					   create_info->index_file_name,
					   1);
3265 3266 3267 3268 3269 3270
    }
    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,
3271 3272
					  create_info->data_file_name,
					  1);
3273 3274
    }
  }
3275 3276
  else
    create_info->data_file_name=create_info->index_file_name=0;
3277
  {
3278 3279
    /* We don't log the statement, it will be logged later. */
    tmp_disable_binlog(thd);
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3280
    error= mysql_create_table(thd, new_db, tmp_name,
serg@serg.mylan's avatar
serg@serg.mylan committed
3281
                              create_info,create_list,key_list,1,0);
3282 3283
    reenable_binlog(thd);
    if (error)
3284 3285
      DBUG_RETURN(error);
  }
3286 3287 3288
  if (table->tmp_table)
    new_table=open_table(thd,new_db,tmp_name,tmp_name,0);
  else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3289
  {
3290
    char path[FN_REFLEN];
3291
    build_table_path(path, sizeof(path), new_db, tmp_name, "");
3292 3293 3294 3295 3296 3297
    new_table=open_temporary_table(thd, path, new_db, tmp_name,0);
  }
  if (!new_table)
  {
    VOID(quick_rm_table(new_db_type,new_db,tmp_name));
    goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3298 3299
  }

3300

3301 3302
  /* We don't want update TIMESTAMP fields during ALTER TABLE. */
  new_table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3303
  new_table->next_number_field=new_table->found_next_number_field;
3304
  thd->count_cuted_fields= CHECK_FIELD_WARN;	// calc cuted fields
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3305 3306
  thd->cuted_fields=0L;
  thd->proc_info="copy to tmp table";
3307
  next_insert_id=thd->next_insert_id;		// Remember for loggin
3308 3309 3310
  copied=deleted=0;
  if (!new_table->is_view)
    error=copy_data_between_tables(table,new_table,create_list,
3311
				   handle_duplicates, ignore,
3312 3313
				   order_num, order, &copied, &deleted);
  thd->last_insert_id=next_insert_id;		// Needed for correct log
3314
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3315 3316 3317 3318 3319 3320

  if (table->tmp_table)
  {
    /* We changed a temporary table */
    if (error)
    {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3321
      /*
3322 3323
	The following function call will free the new_table pointer,
	in close_temporary_table(), so we can safely directly jump to err
3324
      */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3325 3326 3327
      close_temporary_table(thd,new_db,tmp_name);
      goto err;
    }
3328 3329 3330 3331 3332 3333
    /* Close lock if this is a transactional table */
    if (thd->lock)
    {
      mysql_unlock_tables(thd, thd->lock);
      thd->lock=0;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3334 3335
    /* Remove link to old table and rename the new one */
    close_temporary_table(thd,table->table_cache_key,table_name);
3336 3337
    /* Should pass the 'new_name' as we store table name in the cache */
    if (rename_temporary_table(thd, new_table, new_db, new_name))
3338
    {						// Fatal error
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3339 3340 3341 3342
      close_temporary_table(thd,new_db,tmp_name);
      my_free((gptr) new_table,MYF(0));
      goto err;
    }
3343 3344 3345
    mysql_update_log.write(thd, thd->query,thd->query_length);
    if (mysql_bin_log.is_open())
    {
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3346
      thd->clear_error();
3347
      Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3348 3349
      mysql_bin_log.write(&qinfo);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3350 3351 3352
    goto end_temporary;
  }

3353
  intern_close_table(new_table);		/* close temporary table */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3354 3355 3356 3357 3358 3359 3360 3361
  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;
  }
3362

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3363
  /*
3364 3365 3366
    Data is copied.  Now we rename the old table to a temp name,
    rename the new one to the old name, remove all entries from the old table
    from the cash, free all locks, close the old table and remove it.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3367 3368 3369
  */

  thd->proc_info="rename result table";
3370 3371
  my_snprintf(old_name, sizeof(old_name), "%s2-%lx-%lx", tmp_file_prefix,
	      current_pid, thd->thread_id);
3372 3373
  if (lower_case_table_names)
    my_casedn_str(files_charset_info, old_name);
3374
  if (new_name != table_name || new_db != db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385
  {
    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;
    }
  }

3386 3387 3388 3389 3390
#if (!defined( __WIN__) && !defined( __EMX__) && !defined( OS2))
  if (table->file->has_transactions())
#endif
  {
    /*
3391
      Win32 and InnoDB can't drop a table that is in use, so we must
3392
      close the original table at before doing the rename
3393
    */
3394
    table_name=thd->strdup(table_name);		// must be saved
3395
    if (close_cached_table(thd, table))
3396
    {						// Aborted
3397 3398 3399 3400
      VOID(quick_rm_table(new_db_type,new_db,tmp_name));
      VOID(pthread_mutex_unlock(&LOCK_open));
      goto err;
    }
3401
    table=0;					// Marker that table is closed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3402
  }
3403 3404
#if (!defined( __WIN__) && !defined( __EMX__) && !defined( OS2))
  else
3405
    table->file->extra(HA_EXTRA_FORCE_REOPEN);	// Don't use this file anymore
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3406 3407
#endif

3408

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3409 3410 3411 3412 3413 3414 3415
  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,
3416 3417
			      new_alias))
  {						// Try to get everything back
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3418
    error=1;
3419
    VOID(quick_rm_table(new_db_type,new_db,new_alias));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3420
    VOID(quick_rm_table(new_db_type,new_db,tmp_name));
3421
    VOID(mysql_rename_table(old_db_type,db,old_name,db,alias));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3422 3423 3424
  }
  if (error)
  {
3425 3426 3427 3428
    /*
      This shouldn't happen.  We solve this the safe way by
      closing the locked table.
    */
3429 3430
    if (table)
      close_cached_table(thd,table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3431 3432 3433
    VOID(pthread_mutex_unlock(&LOCK_open));
    goto err;
  }
3434
  if (thd->lock || new_name != table_name)	// True if WIN32
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3435
  {
3436 3437 3438 3439
    /*
      Not table locking or alter table with rename
      free locks and remove old table
    */
3440 3441
    if (table)
      close_cached_table(thd,table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3442 3443 3444 3445
    VOID(quick_rm_table(old_db_type,db,old_name));
  }
  else
  {
3446 3447 3448 3449 3450
    /*
      Using LOCK TABLES without rename.
      This code is never executed on WIN32!
      Remove old renamed table, reopen table and get new locks
    */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3451 3452 3453
    if (table)
    {
      VOID(table->file->extra(HA_EXTRA_FORCE_REOPEN)); // Use new file
monty@mysql.com's avatar
monty@mysql.com committed
3454
      /* Mark in-use copies old */
3455
      remove_table_from_cache(thd,db,table_name,RTFC_NO_FLAG);
monty@mysql.com's avatar
monty@mysql.com committed
3456 3457
      /* end threads waiting on lock */
      mysql_lock_abort(thd,table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3458 3459 3460
    }
    VOID(quick_rm_table(old_db_type,db,old_name));
    if (close_data_tables(thd,db,table_name) ||
3461 3462
	reopen_tables(thd,1,0))
    {						// This shouldn't happen
3463
      if (table)
3464
	close_cached_table(thd,table);		// Remove lock for table
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3465 3466 3467 3468
      VOID(pthread_mutex_unlock(&LOCK_open));
      goto err;
    }
  }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3469
  /* The ALTER TABLE is always in its own transaction */
3470 3471 3472 3473
  error = ha_commit_stmt(thd);
  if (ha_commit(thd))
    error=1;
  if (error)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3474 3475
  {
    VOID(pthread_mutex_unlock(&LOCK_open));
3476
    VOID(pthread_cond_broadcast(&COND_refresh));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3477 3478 3479
    goto err;
  }
  thd->proc_info="end";
3480 3481
  mysql_update_log.write(thd, thd->query,thd->query_length);
  if (mysql_bin_log.is_open())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3482
  {
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3483
    thd->clear_error();
3484
    Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3485 3486 3487 3488
    mysql_bin_log.write(&qinfo);
  }
  VOID(pthread_cond_broadcast(&COND_refresh));
  VOID(pthread_mutex_unlock(&LOCK_open));
3489 3490 3491
#ifdef HAVE_BERKELEY_DB
  if (old_db_type == DB_TYPE_BERKELEY_DB)
  {
3492 3493 3494 3495 3496
    /*
      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.
    */
3497
    char path[FN_REFLEN];
3498
    build_table_path(path, sizeof(path), new_db, table_name, "");
3499 3500
    table=open_temporary_table(thd, path, new_db, tmp_name,0);
    if (table)
3501
    {
3502 3503
      intern_close_table(table);
      my_free((char*) table, MYF(0));
3504
    }
3505
    else
serg@serg.mylan's avatar
serg@serg.mylan committed
3506 3507
      sql_print_warning("Could not open BDB table %s.%s after rename\n",
                        new_db,table_name);
3508
    (void) berkeley_flush_logs();
3509 3510
  }
#endif
3511
  table_list->table=0;				// For query cache
3512
  query_cache_invalidate3(thd, table_list, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3513 3514

end_temporary:
3515 3516 3517
  my_snprintf(tmp_name, sizeof(tmp_name), ER(ER_INSERT_INFO),
	      (ulong) (copied + deleted), (ulong) deleted,
	      (ulong) thd->cuted_fields);
3518 3519
  if (do_send_ok)
    send_ok(thd,copied+deleted,0L,tmp_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3520 3521 3522 3523 3524 3525 3526 3527 3528
  thd->some_tables_deleted=0;
  DBUG_RETURN(0);

 err:
  DBUG_RETURN(-1);
}


static int
3529
copy_data_between_tables(TABLE *from,TABLE *to,
3530 3531
			 List<create_field> &create,
			 enum enum_duplicates handle_duplicates,
3532
                         bool ignore,
3533 3534 3535
			 uint order_num, ORDER *order,
			 ha_rows *copied,
			 ha_rows *deleted)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3536 3537
{
  int error;
3538
  Copy_field *copy,*copy_end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3539 3540
  ulong found_count,delete_count;
  THD *thd= current_thd;
3541 3542 3543 3544 3545 3546
  uint length;
  SORT_FIELD *sortorder;
  READ_RECORD info;
  TABLE_LIST   tables;
  List<Item>   fields;
  List<Item>   all_fields;
3547
  ha_rows examined_rows;
3548
  bool auto_increment_field_copied= 0;
3549
  ulong save_sql_mode;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3550 3551
  DBUG_ENTER("copy_data_between_tables");

3552 3553 3554 3555 3556 3557
  /*
    Turn off recovery logging since rollback of an alter table is to
    delete the new table so there is no need to log the changes to it.
    
    This needs to be done before external_lock
  */
3558
  error= ha_enable_transaction(thd, FALSE);
3559 3560
  if (error)
    DBUG_RETURN(-1);
3561
  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3562
  if (!(copy= new Copy_field[to->fields]))
3563
    DBUG_RETURN(-1);				/* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3564

3565 3566
  if (to->file->external_lock(thd, F_WRLCK))
    DBUG_RETURN(-1);
3567
  from->file->info(HA_STATUS_VARIABLE);
3568
  to->file->start_bulk_insert(from->file->records);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3569

3570 3571
  save_sql_mode= thd->variables.sql_mode;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3572 3573 3574 3575 3576 3577 3578
  List_iterator<create_field> it(create);
  create_field *def;
  copy_end=copy;
  for (Field **ptr=to->field ; *ptr ; ptr++)
  {
    def=it++;
    if (def->field)
3579 3580
    {
      if (*ptr == to->next_number_field)
3581
      {
3582
        auto_increment_field_copied= TRUE;
3583 3584 3585 3586 3587 3588 3589 3590 3591
        /*
          If we are going to copy contents of one auto_increment column to
          another auto_increment column it is sensible to preserve zeroes.
          This condition also covers case when we are don't actually alter
          auto_increment column.
        */
        if (def->field == from->found_next_number_field)
          thd->variables.sql_mode|= MODE_NO_AUTO_VALUE_ON_ZERO;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3592
      (copy_end++)->set(*ptr,def->field,0);
3593 3594
    }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3595 3596
  }

3597 3598
  found_count=delete_count=0;

monty@donna.mysql.fi's avatar
monty@donna.mysql.fi committed
3599 3600
  if (order)
  {
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
3601
    from->sort.io_cache=(IO_CACHE*) my_malloc(sizeof(IO_CACHE),
3602
					      MYF(MY_FAE | MY_ZEROFILL));
3603 3604
    bzero((char*) &tables,sizeof(tables));
    tables.table = from;
3605
    tables.alias = tables.real_name= from->real_name;
3606
    tables.db	 = from->table_cache_key;
3607 3608
    error=1;

3609
    if (thd->lex->select_lex.setup_ref_array(thd, order_num) ||
3610 3611 3612 3613 3614 3615 3616
	setup_order(thd, thd->lex->select_lex.ref_pointer_array,
		    &tables, fields, all_fields, order) ||
	!(sortorder=make_unireg_sortorder(order, &length)) ||
	(from->sort.found_records = filesort(thd, from, sortorder, length,
					     (SQL_SELECT *) 0, HA_POS_ERROR,
					     &examined_rows))
	== HA_POS_ERROR)
3617 3618 3619
      goto err;
  };

3620 3621 3622 3623
  /* Handler must be told explicitly to retrieve all columns, because
     this function does not set field->query_id in the columns to the
     current query id */
  from->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3624
  init_read_record(&info, thd, from, (SQL_SELECT *) 0, 1,1);
3625
  if (ignore ||
3626
      handle_duplicates == DUP_REPLACE)
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
3627
    to->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
3628
  thd->row_count= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3629 3630 3631 3632 3633 3634 3635 3636
  while (!(error=info.read_record(&info)))
  {
    if (thd->killed)
    {
      my_error(ER_SERVER_SHUTDOWN,MYF(0));
      error= 1;
      break;
    }
3637
    thd->row_count++;
3638 3639
    if (to->next_number_field)
    {
3640
      if (auto_increment_field_copied)
3641
        to->auto_increment_field_not_null= TRUE;
3642 3643 3644 3645 3646
      else
        to->next_number_field->reset();
    }
    for (Copy_field *copy_ptr=copy ; copy_ptr != copy_end ; copy_ptr++)
    {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3647
      copy_ptr->do_copy(copy_ptr);
3648
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3649 3650
    if ((error=to->file->write_row((byte*) to->record[0])))
    {
3651
      if ((!ignore &&
3652 3653 3654
	   handle_duplicates != DUP_REPLACE) ||
	  (error != HA_ERR_FOUND_DUPP_KEY &&
	   error != HA_ERR_FOUND_DUPP_UNIQUE))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3655
      {
3656 3657
	to->file->print_error(error,MYF(0));
	break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3658 3659 3660 3661
      }
      delete_count++;
    }
    else
3662
      found_count++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3663 3664
  }
  end_read_record(&info);
3665
  free_io_cache(from);
3666
  delete [] copy;				// This is never 0
serg@serg.mylan's avatar
serg@serg.mylan committed
3667 3668

  if (to->file->end_bulk_insert() && !error)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3669
  {
serg@serg.mylan's avatar
serg@serg.mylan committed
3670
    to->file->print_error(my_errno,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3671 3672
    error=1;
  }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
3673
  to->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
3674

3675
  ha_enable_transaction(thd,TRUE);
3676

3677 3678 3679 3680 3681 3682 3683 3684
  /*
    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;
3685

3686
 err:
3687
  thd->variables.sql_mode= save_sql_mode;
3688
  free_io_cache(from);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3689 3690
  *copied= found_count;
  *deleted=delete_count;
3691 3692
  if (to->file->external_lock(thd,F_UNLCK))
    error=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3693 3694
  DBUG_RETURN(error > 0 ? -1 : 0);
}
3695

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

3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718
/*
  Recreates tables by calling mysql_alter_table().

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

 RETURN
    Like mysql_alter_table().
*/
int mysql_recreate_table(THD *thd, TABLE_LIST *table_list,
                         bool do_send_ok)
{
  DBUG_ENTER("mysql_recreate_table");
  LEX *lex= thd->lex;
  HA_CREATE_INFO create_info;
  lex->create_list.empty();
  lex->key_list.empty();
  lex->col_list.empty();
  lex->alter_info.reset();
3719
  lex->alter_info.is_simple= 0;                 // Force full recreate
3720 3721 3722 3723 3724 3725 3726
  bzero((char*) &create_info,sizeof(create_info));
  create_info.db_type=DB_TYPE_DEFAULT;
  create_info.row_type=ROW_TYPE_DEFAULT;
  create_info.default_table_charset=default_charset_info;
  DBUG_RETURN(mysql_alter_table(thd, NullS, NullS, &create_info,
                                table_list, lex->create_list,
                                lex->key_list, 0, (ORDER *) 0,
3727
                                DUP_ERROR, 0, &lex->alter_info, do_send_ok));
3728 3729 3730
}


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3731
int mysql_checksum_table(THD *thd, TABLE_LIST *tables, HA_CHECK_OPT *check_opt)
3732 3733 3734 3735 3736
{
  TABLE_LIST *table;
  List<Item> field_list;
  Item *item;
  Protocol *protocol= thd->protocol;
3737
  DBUG_ENTER("mysql_checksum_table");
3738 3739 3740 3741 3742 3743 3744 3745

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

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3746
  for (table= tables; table; table= table->next)
3747 3748
  {
    char table_name[NAME_LEN*2+2];
3749
    TABLE *t;
3750

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3751 3752 3753
    strxmov(table_name, table->db ,".", table->real_name, NullS);

    t= table->table= open_ltable(thd, table, TL_READ_NO_INSERT);
3754
    thd->clear_error();			// these errors shouldn't get client
3755 3756 3757 3758

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

3759
    if (!t)
3760
    {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3761
      /* Table didn't exist */
3762 3763 3764 3765 3766
      protocol->store_null();
      thd->net.last_error[0]=0;
    }
    else
    {
3767
      t->pos_in_table_list= table;
3768

3769
      if (t->file->table_flags() & HA_HAS_CHECKSUM &&
3770 3771
	  !(check_opt->flags & T_EXTEND))
	protocol->store((ulonglong)t->file->checksum());
3772
      else if (!(t->file->table_flags() & HA_HAS_CHECKSUM) &&
3773 3774
	       (check_opt->flags & T_QUICK))
	protocol->store_null();
3775 3776
      else
      {
3777 3778 3779 3780 3781 3782 3783 3784
	/* calculating table's checksum */
	ha_checksum crc= 0;

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

3785
	if (t->file->ha_rnd_init(1))
3786 3787 3788
	  protocol->store_null();
	else
	{
3789
	  for (;;)
3790 3791
	  {
	    ha_checksum row_crc= 0;
3792 3793 3794 3795 3796 3797 3798
            int error= t->file->rnd_next(t->record[0]);
            if (unlikely(error))
            {
              if (error == HA_ERR_RECORD_DELETED)
                continue;
              break;
            }
3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819
	    if (t->record[0] != (byte*) t->field[0]->ptr)
	      row_crc= my_checksum(row_crc, t->record[0],
				   ((byte*) t->field[0]->ptr) - t->record[0]);

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

	    crc+= row_crc;
	  }
	  protocol->store((ulonglong)crc);
3820
          t->file->ha_rnd_end();
3821
	}
3822
      }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3823
      thd->clear_error();
3824
      close_thread_tables(thd);
3825
      table->table=0;				// For query cache
3826 3827 3828 3829 3830 3831 3832
    }
    if (protocol->write())
      goto err;
  }

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

3834
 err:
3835
  close_thread_tables(thd);			// Shouldn't be needed
3836 3837 3838 3839
  if (table)
    table->table=0;
  DBUG_RETURN(-1);
}