sql_table.cc 250 KB
Newer Older
1
/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2 3 4

   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
5
   the Free Software Foundation; version 2 of the License.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6 7 8 9 10 11 12 13 14 15 16 17 18

   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"
19
#include <hash.h>
bk@work.mysql.com's avatar
bk@work.mysql.com committed
20
#include <myisam.h>
21
#include <my_dir.h>
22 23
#include "sp_head.h"
#include "sql_trigger.h"
24
#include "sql_show.h"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
25 26 27 28 29

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

30 31
int creating_table= 0;        // How many mysql_create_table are running

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
                                    List<Create_field> &create, bool ignore,
38
				    uint order_num, ORDER *order,
39
				    ha_rows *copied,ha_rows *deleted,
40 41
                                    enum enum_enable_or_disable keys_onoff,
                                    bool error_if_not_empty);
42

43
static bool prepare_blob_field(THD *thd, Create_field *sql_field);
serg@janus.mylan's avatar
serg@janus.mylan committed
44
static bool check_engine(THD *, const char *, HA_CREATE_INFO *);
45
static int
46 47 48 49 50 51 52
mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
                           Alter_info *alter_info,
                           bool tmp_table,
                           uint *db_options,
                           handler *file, KEY **key_info_buffer,
                           uint *key_count, int select_field_count);
static bool
53 54
mysql_prepare_alter_table(THD *thd, TABLE *table,
                          HA_CREATE_INFO *create_info,
55
                          Alter_info *alter_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
56

57
#ifndef DBUG_OFF
bk@work.mysql.com's avatar
bk@work.mysql.com committed
58

59 60 61 62 63 64 65 66 67 68
/* Wait until we get a 'mysql_kill' signal */

static void wait_for_kill_signal(THD *thd)
{
  while (thd->killed == 0)
    sleep(1);
  // Reset signal and continue as if nothing happend
  thd->killed= THD::NOT_KILLED;
}
#endif
69

70

71 72 73 74
/**
  @brief Helper function for explain_filename
*/
static char* add_identifier(char *to_p, const char * end_p,
75
                           const char* name, uint name_len, bool add_quotes)
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
{
  uint res;
  uint errors;
  const char *conv_name;
  char tmp_name[FN_REFLEN];
  char conv_string[FN_REFLEN];

  DBUG_ENTER("add_identifier");
  if (!name[name_len])
    conv_name= name;
  else
  {
    strnmov(tmp_name, name, name_len);
    tmp_name[name_len]= 0;
    conv_name= tmp_name;
  }
  res= strconvert(&my_charset_filename, conv_name, system_charset_info,
                  conv_string, FN_REFLEN, &errors);
  if (!res || errors)
95 96
  {
    DBUG_PRINT("error", ("strconvert of '%s' failed with %u (errors: %u)", conv_name, res, errors));
97
    conv_name= name;
98
  }
99 100 101 102 103 104
  else
  {
    DBUG_PRINT("info", ("conv '%s' -> '%s'", conv_name, conv_string));
    conv_name= conv_string;
  }

105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
  if (add_quotes && (end_p - to_p > 2))
  {
    *(to_p++)= '`';
    while (*conv_name && (end_p - to_p - 1) > 0)
    {
      uint length= my_mbcharlen(system_charset_info, *conv_name);
      if (!length)
        length= 1;
      if (length == 1 && *conv_name == '`')
      { 
        if ((end_p - to_p) < 3)
          break;
        *(to_p++)= '`';
        *(to_p++)= *(conv_name++);
      }
120
      else if (((long) length) < (end_p - to_p))
121 122 123 124 125 126 127 128 129
      {
        to_p= strnmov(to_p, conv_name, length);
        conv_name+= length;
      }
      else
        break;                               /* string already filled */
    }
    to_p= strnmov(to_p, "`", end_p - to_p);
  }
130
  else
131 132
    to_p= strnmov(to_p, conv_name, end_p - to_p);
  DBUG_RETURN(to_p);
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
}


/**
  @brief Explain a path name by split it to database, table etc.
  
  @details Break down the path name to its logic parts
  (database, table, partition, subpartition).
  filename_to_tablename cannot be used on partitions, due to the #P# part.
  There can be up to 6 '#', #P# for partition, #SP# for subpartition
  and #TMP# or #REN# for temporary or renamed partitions.
  This should be used when something should be presented to a user in a
  diagnostic, error etc. when it would be useful to know what a particular
  file [and directory] means. Such as SHOW ENGINE STATUS, error messages etc.

   @param      from         Path name in my_charset_filename
                            Null terminated in my_charset_filename, normalized
                            to use '/' as directory separation character.
   @param      to           Explained name in system_charset_info
   @param      to_length    Size of to buffer
   @param      explain_mode Requested output format.
                            EXPLAIN_ALL_VERBOSE ->
                            [Database `db`, ]Table `tbl`[,[ Temporary| Renamed]
                            Partition `p` [, Subpartition `sp`]]
                            EXPLAIN_PARTITIONS_VERBOSE -> `db`.`tbl`
                            [[ Temporary| Renamed] Partition `p`
                            [, Subpartition `sp`]]
                            EXPLAIN_PARTITIONS_AS_COMMENT -> `db`.`tbl` |*
                            [,[ Temporary| Renamed] Partition `p`
                            [, Subpartition `sp`]] *|
                            (| is really a /, and it is all in one line)
164 165
                            EXPLAIN_PARTITIONS_AS_COMMENT_NO_QUOTING ->
                            same as above but no quotes are added.
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275

   @retval     Length of returned string
*/

uint explain_filename(const char *from,
                      char *to,
                      uint to_length,
                      enum_explain_filename_mode explain_mode)
{
  uint res= 0;
  char *to_p= to;
  char *end_p= to_p + to_length;
  const char *db_name= NULL;
  int  db_name_len= 0;
  const char *table_name;
  int  table_name_len= 0;
  const char *part_name= NULL;
  int  part_name_len= 0;
  const char *subpart_name= NULL;
  int  subpart_name_len= 0;
  enum enum_file_name_type {NORMAL, TEMP, RENAMED} name_type= NORMAL;
  const char *tmp_p;
  DBUG_ENTER("explain_filename");
  DBUG_PRINT("enter", ("from '%s'", from));
  tmp_p= from;
  table_name= from;
  /*
    If '/' then take last directory part as database.
    '/' is the directory separator, not FN_LIB_CHAR
  */
  while ((tmp_p= strchr(tmp_p, '/')))
  {
    db_name= table_name;
    /* calculate the length */
    db_name_len= tmp_p - db_name;
    tmp_p++;
    table_name= tmp_p;
  }
  tmp_p= table_name;
  while (!res && (tmp_p= strchr(tmp_p, '#')))
  {
    tmp_p++;
    switch (tmp_p[0]) {
    case 'P':
    case 'p':
      if (tmp_p[1] == '#')
        part_name= tmp_p + 2;
      else
        res= 1;
      tmp_p+= 2;
      break;
    case 'S':
    case 's':
      if ((tmp_p[1] == 'P' || tmp_p[1] == 'p') && tmp_p[2] == '#')
      {
        part_name_len= tmp_p - part_name - 1;
        subpart_name= tmp_p + 3;
      }
      else
        res= 2;
      tmp_p+= 3;
      break;
    case 'T':
    case 't':
      if ((tmp_p[1] == 'M' || tmp_p[1] == 'm') &&
          (tmp_p[2] == 'P' || tmp_p[2] == 'p') &&
          tmp_p[3] == '#' && !tmp_p[4])
        name_type= TEMP;
      else
        res= 3;
      tmp_p+= 4;
      break;
    case 'R':
    case 'r':
      if ((tmp_p[1] == 'E' || tmp_p[1] == 'e') &&
          (tmp_p[2] == 'N' || tmp_p[2] == 'n') &&
          tmp_p[3] == '#' && !tmp_p[4])
        name_type= RENAMED;
      else
        res= 4;
      tmp_p+= 4;
      break;
    default:
      res= 5;
    }
  }
  if (res)
  {
    /* Better to give something back if we fail parsing, than nothing at all */
    DBUG_PRINT("info", ("Error in explain_filename: %u", res));
    sql_print_warning("Invalid (old?) table or database name '%s'", from);
    DBUG_RETURN(my_snprintf(to, to_length,
                            "<result %u when explaining filename '%s'>",
                            res, from));
  }
  if (part_name)
  {
    table_name_len= part_name - table_name - 3;
    if (subpart_name)
      subpart_name_len= strlen(subpart_name);
    else
      part_name_len= strlen(part_name);
    if (name_type != NORMAL)
    {
      if (subpart_name)
        subpart_name_len-= 5;
      else
        part_name_len-= 5;
    }
  }
276 277
  else
    table_name_len= strlen(table_name);
278 279 280 281
  if (db_name)
  {
    if (explain_mode == EXPLAIN_ALL_VERBOSE)
    {
282 283 284
      to_p= strnmov(to_p, ER(ER_DATABASE_NAME), end_p - to_p);
      *(to_p++)= ' ';
      to_p= add_identifier(to_p, end_p, db_name, db_name_len, 1);
285 286 287 288
      to_p= strnmov(to_p, ", ", end_p - to_p);
    }
    else
    {
289 290 291
      to_p= add_identifier(to_p, end_p, db_name, db_name_len,
                           (explain_mode !=
                            EXPLAIN_PARTITIONS_AS_COMMENT_NO_QUOTING));
292 293 294 295
      to_p= strnmov(to_p, ".", end_p - to_p);
    }
  }
  if (explain_mode == EXPLAIN_ALL_VERBOSE)
296 297 298 299 300
  {
    to_p= strnmov(to_p, ER(ER_TABLE_NAME), end_p - to_p);
    *(to_p++)= ' ';
    to_p= add_identifier(to_p, end_p, table_name, table_name_len, 1);
  }
301
  else
302 303 304
    to_p= add_identifier(to_p, end_p, table_name, table_name_len,
                         (explain_mode !=
                          EXPLAIN_PARTITIONS_AS_COMMENT_NO_QUOTING));
305 306
  if (part_name)
  {
307 308
    if (explain_mode == EXPLAIN_PARTITIONS_AS_COMMENT ||
        explain_mode == EXPLAIN_PARTITIONS_AS_COMMENT_NO_QUOTING)
309 310 311 312 313 314 315 316 317 318 319 320 321
      to_p= strnmov(to_p, " /* ", end_p - to_p);
    else if (explain_mode == EXPLAIN_PARTITIONS_VERBOSE)
      to_p= strnmov(to_p, " ", end_p - to_p);
    else
      to_p= strnmov(to_p, ", ", end_p - to_p);
    if (name_type != NORMAL)
    {
      if (name_type == TEMP)
        to_p= strnmov(to_p, ER(ER_TEMPORARY_NAME), end_p - to_p);
      else
        to_p= strnmov(to_p, ER(ER_RENAMED_NAME), end_p - to_p);
      to_p= strnmov(to_p, " ", end_p - to_p);
    }
322 323
    to_p= strnmov(to_p, ER(ER_PARTITION_NAME), end_p - to_p);
    *(to_p++)= ' ';
324
    to_p= add_identifier(to_p, end_p, part_name, part_name_len,
325 326
                         (explain_mode !=
                          EXPLAIN_PARTITIONS_AS_COMMENT_NO_QUOTING));
327 328 329
    if (subpart_name)
    {
      to_p= strnmov(to_p, ", ", end_p - to_p);
330 331
      to_p= strnmov(to_p, ER(ER_SUBPARTITION_NAME), end_p - to_p);
      *(to_p++)= ' ';
332
      to_p= add_identifier(to_p, end_p, subpart_name, subpart_name_len,
333 334
                           (explain_mode !=
                            EXPLAIN_PARTITIONS_AS_COMMENT_NO_QUOTING));
335
    }
336 337
    if (explain_mode == EXPLAIN_PARTITIONS_AS_COMMENT ||
        explain_mode == EXPLAIN_PARTITIONS_AS_COMMENT_NO_QUOTING)
338 339 340 341 342 343 344
      to_p= strnmov(to_p, " */", end_p - to_p);
  }
  DBUG_PRINT("exit", ("to '%s'", to));
  DBUG_RETURN(to_p - to);
}


345 346 347 348 349 350 351 352 353 354 355 356 357
/*
  Translate a file name to a table name (WL #1324).

  SYNOPSIS
    filename_to_tablename()
      from                      The file name in my_charset_filename.
      to                OUT     The table name in system_charset_info.
      to_length                 The size of the table name buffer.

  RETURN
    Table name length.
*/

358 359
uint filename_to_tablename(const char *from, char *to, uint to_length)
{
360
  uint errors;
361
  size_t res;
362 363 364 365
  DBUG_ENTER("filename_to_tablename");
  DBUG_PRINT("enter", ("from '%s'", from));

  if (!memcmp(from, tmp_file_prefix, tmp_file_prefix_length))
366
  {
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
    /* Temporary table name. */
    res= (strnmov(to, from, to_length) - to);
  }
  else
  {
    res= strconvert(&my_charset_filename, from,
                    system_charset_info,  to, to_length, &errors);
    if (errors) // Old 5.0 name
    {
      res= (strxnmov(to, to_length, MYSQL50_TABLE_NAME_PREFIX,  from, NullS) -
            to);
      sql_print_error("Invalid (old?) table or database name '%s'", from);
      /*
        TODO: add a stored procedure for fix table and database names,
        and mention its name in error log.
      */
    }
384
  }
385 386 387

  DBUG_PRINT("exit", ("to '%s'", to));
  DBUG_RETURN(res);
388 389 390
}


Ramil Kalimullin's avatar
Ramil Kalimullin committed
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
/**
  Check if given string begins with "#mysql50#" prefix, cut it if so.
  
  @param   from          string to check and cut 
  @param   to[out]       buffer for result string
  @param   to_length     its size
  
  @retval
    0      no prefix found
  @retval
    non-0  result string length
*/

uint check_n_cut_mysql50_prefix(const char *from, char *to, uint to_length)
{
  if (from[0] == '#' && 
      !strncmp(from, MYSQL50_TABLE_NAME_PREFIX,
               MYSQL50_TABLE_NAME_PREFIX_LENGTH))
    return (uint) (strmake(to, from + MYSQL50_TABLE_NAME_PREFIX_LENGTH,
                           to_length - 1) - to);
  return 0;
}


415 416 417 418 419 420 421 422 423 424 425 426 427
/*
  Translate a table name to a file name (WL #1324).

  SYNOPSIS
    tablename_to_filename()
      from                      The table name in system_charset_info.
      to                OUT     The file name in my_charset_filename.
      to_length                 The size of the file name buffer.

  RETURN
    File name length.
*/

428 429
uint tablename_to_filename(const char *from, char *to, uint to_length)
{
430
  uint errors, length;
431 432 433
  DBUG_ENTER("tablename_to_filename");
  DBUG_PRINT("enter", ("from '%s'", from));

Ramil Kalimullin's avatar
Ramil Kalimullin committed
434 435
  if ((length= check_n_cut_mysql50_prefix(from, to, to_length)))
    DBUG_RETURN(length);
436 437 438 439 440 441 442 443
  length= strconvert(system_charset_info, from,
                     &my_charset_filename, to, to_length, &errors);
  if (check_if_legal_tablename(to) &&
      length + 4 < to_length)
  {
    memcpy(to + length, "@@@", 4);
    length+= 3;
  }
444 445
  DBUG_PRINT("exit", ("to '%s'", to));
  DBUG_RETURN(length);
446 447 448
}


449
/*
450
  Creates path to a file: mysql_data_dir/db/table.ext
451 452

  SYNOPSIS
453
   build_table_filename()
454
     buff                       Where to write result in my_charset_filename.
455
                                This may be the same as table_name.
456 457 458 459 460 461
     bufflen                    buff size
     db                         Database name in system_charset_info.
     table_name                 Table name in system_charset_info.
     ext                        File extension.
     flags                      FN_FROM_IS_TMP or FN_TO_IS_TMP or FN_IS_TMP
                                table_name is temporary, do not change.
462 463 464 465 466 467

  NOTES

    Uses database and table name, and extension to create
    a file name in mysql_data_dir. Database and table
    names are converted from system_charset_info into "fscs".
468 469
    Unless flags indicate a temporary table name.
    'db' is always converted.
470
    'ext' is not converted.
471

472 473 474 475 476
    The conversion suppression is required for ALTER TABLE. This
    statement creates intermediate tables. These are regular
    (non-temporary) tables with a temporary name. Their path names must
    be derivable from the table name. So we cannot use
    build_tmptable_filename() for them.
477

478 479
  RETURN
    path length
480 481 482
*/

uint build_table_filename(char *buff, size_t bufflen, const char *db,
483
                          const char *table_name, const char *ext, uint flags)
484 485 486
{
  char dbbuff[FN_REFLEN];
  char tbbuff[FN_REFLEN];
487
  DBUG_ENTER("build_table_filename");
488 489
  DBUG_PRINT("enter", ("db: '%s'  table_name: '%s'  ext: '%s'  flags: %x",
                       db, table_name, ext, flags));
490 491 492 493 494 495

  if (flags & FN_IS_TMP) // FN_FROM_IS_TMP | FN_TO_IS_TMP
    strnmov(tbbuff, table_name, sizeof(tbbuff));
  else
    VOID(tablename_to_filename(table_name, tbbuff, sizeof(tbbuff)));

496
  VOID(tablename_to_filename(db, dbbuff, sizeof(dbbuff)));
497 498 499 500

  char *end = buff + bufflen;
  /* Don't add FN_ROOTDIR if mysql_data_home already includes it */
  char *pos = strnmov(buff, mysql_data_home, bufflen);
501
  size_t rootdir_len= strlen(FN_ROOTDIR);
502 503 504
  if (pos - rootdir_len >= buff &&
      memcmp(pos - rootdir_len, FN_ROOTDIR, rootdir_len) != 0)
    pos= strnmov(pos, FN_ROOTDIR, end - pos);
505 506 507 508 509 510
  pos= strxnmov(pos, end - pos, dbbuff, FN_ROOTDIR, NullS);
#ifdef USE_SYMDIR
  unpack_dirname(buff, buff);
  pos= strend(buff);
#endif
  pos= strxnmov(pos, end - pos, tbbuff, ext, NullS);
511

512
  DBUG_PRINT("exit", ("buff: '%s'", buff));
513
  DBUG_RETURN(pos - buff);
514 515 516
}


517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
/*
  Creates path to a file: mysql_tmpdir/#sql1234_12_1.ext

  SYNOPSIS
   build_tmptable_filename()
     thd                        The thread handle.
     buff                       Where to write result in my_charset_filename.
     bufflen                    buff size

  NOTES

    Uses current_pid, thread_id, and tmp_table counter to create
    a file name in mysql_tmpdir.

  RETURN
    path length
*/

535
uint build_tmptable_filename(THD* thd, char *buff, size_t bufflen)
536
{
537 538
  DBUG_ENTER("build_tmptable_filename");

539 540 541 542
  char *p= strnmov(buff, mysql_tmpdir, bufflen);
  my_snprintf(p, bufflen - (p - buff), "/%s%lx_%lx_%x%s",
              tmp_file_prefix, current_pid,
              thd->thread_id, thd->tmp_table++, reg_ext);
543

544 545 546 547 548
  if (lower_case_table_names)
  {
    /* Convert all except tmpdir to lower case */
    my_casedn_str(files_charset_info, p);
  }
549

550
  size_t length= unpack_filename(buff, buff);
551 552
  DBUG_PRINT("exit", ("buff: '%s'", buff));
  DBUG_RETURN(length);
553 554
}

555 556 557
/*
--------------------------------------------------------------------------

558
   MODULE: DDL log
559 560 561 562 563 564 565 566
   -----------------

   This module is used to ensure that we can recover from crashes that occur
   in the middle of a meta-data operation in MySQL. E.g. DROP TABLE t1, t2;
   We need to ensure that both t1 and t2 are dropped and not only t1 and
   also that each table drop is entirely done and not "half-baked".

   To support this we create log entries for each meta-data statement in the
567
   ddl log while we are executing. These entries are dropped when the
568 569 570 571
   operation is completed.

   At recovery those entries that were not completed will be executed.

572
   There is only one ddl log in the system and it is protected by a mutex
573 574 575
   and there is a global struct that contains information about its current
   state.

576 577
   History:
   First version written in 2006 by Mikael Ronstrom
578 579 580 581
--------------------------------------------------------------------------
*/


582
struct st_global_ddl_log
583
{
584 585 586 587 588 589
  /*
    We need to adjust buffer size to be able to handle downgrades/upgrades
    where IO_SIZE has changed. We'll set the buffer size such that we can
    handle that the buffer size was upto 4 times bigger in the version
    that wrote the DDL log.
  */
590
  char file_entry_buf[4*IO_SIZE];
591 592
  char file_name_str[FN_REFLEN];
  char *file_name;
593 594 595
  DDL_LOG_MEMORY_ENTRY *first_free;
  DDL_LOG_MEMORY_ENTRY *first_used;
  uint num_entries;
596 597
  File file_id;
  uint name_len;
598
  uint io_size;
599
  bool inited;
600
  bool do_release;
601
  bool recovery_phase;
602 603
  st_global_ddl_log() : inited(false), do_release(false) {}
};
604

605
st_global_ddl_log global_ddl_log;
606

607
pthread_mutex_t LOCK_gdl;
608

609 610 611 612 613
#define DDL_LOG_ENTRY_TYPE_POS 0
#define DDL_LOG_ACTION_TYPE_POS 1
#define DDL_LOG_PHASE_POS 2
#define DDL_LOG_NEXT_ENTRY_POS 4
#define DDL_LOG_NAME_POS 8
614

615 616
#define DDL_LOG_NUM_ENTRY_POS 0
#define DDL_LOG_NAME_LEN_POS 4
617
#define DDL_LOG_IO_SIZE_POS 8
618

619
/*
620
  Read one entry from ddl log file
621
  SYNOPSIS
622
    read_ddl_log_file_entry()
623
    entry_no                     Entry number to read
624
  RETURN VALUES
625 626
    TRUE                         Error
    FALSE                        Success
627 628
*/

629
static bool read_ddl_log_file_entry(uint entry_no)
630 631
{
  bool error= FALSE;
632
  File file_id= global_ddl_log.file_id;
633
  uchar *file_entry_buf= (uchar*)global_ddl_log.file_entry_buf;
634 635
  uint io_size= global_ddl_log.io_size;
  DBUG_ENTER("read_ddl_log_file_entry");
636

637
  if (my_pread(file_id, file_entry_buf, io_size, io_size * entry_no,
638
               MYF(MY_WME)) != io_size)
639 640 641 642 643 644
    error= TRUE;
  DBUG_RETURN(error);
}


/*
645
  Write one entry from ddl log file
646
  SYNOPSIS
647
    write_ddl_log_file_entry()
648 649 650 651 652 653
    entry_no                     Entry number to read
  RETURN VALUES
    TRUE                         Error
    FALSE                        Success
*/

654
static bool write_ddl_log_file_entry(uint entry_no)
655 656
{
  bool error= FALSE;
657 658 659
  File file_id= global_ddl_log.file_id;
  char *file_entry_buf= (char*)global_ddl_log.file_entry_buf;
  DBUG_ENTER("write_ddl_log_file_entry");
660

661
  if (my_pwrite(file_id, (uchar*)file_entry_buf,
662
                IO_SIZE, IO_SIZE * entry_no, MYF(MY_WME)) != IO_SIZE)
663 664 665 666 667 668
    error= TRUE;
  DBUG_RETURN(error);
}


/*
669
  Write ddl log header
670
  SYNOPSIS
671
    write_ddl_log_header()
672 673 674 675 676
  RETURN VALUES
    TRUE                      Error
    FALSE                     Success
*/

677
static bool write_ddl_log_header()
678 679
{
  uint16 const_var;
680
  bool error= FALSE;
681
  DBUG_ENTER("write_ddl_log_header");
682

683 684
  int4store(&global_ddl_log.file_entry_buf[DDL_LOG_NUM_ENTRY_POS],
            global_ddl_log.num_entries);
685
  const_var= FN_LEN;
686
  int4store(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_LEN_POS],
687
            (ulong) const_var);
688
  const_var= IO_SIZE;
689
  int4store(&global_ddl_log.file_entry_buf[DDL_LOG_IO_SIZE_POS],
690
            (ulong) const_var);
691
  if (write_ddl_log_file_entry(0UL))
692 693 694 695 696
  {
    sql_print_error("Error writing ddl log header");
    DBUG_RETURN(TRUE);
  }
  VOID(sync_ddl_log());
697
  DBUG_RETURN(error);
698 699 700
}


701
/*
702
  Create ddl log file name
703
  SYNOPSIS
704
    create_ddl_log_file_name()
705 706 707 708 709
    file_name                   Filename setup
  RETURN VALUES
    NONE
*/

710
static inline void create_ddl_log_file_name(char *file_name)
711
{
712
  strxmov(file_name, mysql_data_home, "/", "ddl_log.log", NullS);
713 714 715
}


716
/*
717
  Read header of ddl log file
718
  SYNOPSIS
719
    read_ddl_log_header()
720
  RETURN VALUES
721 722
    > 0                  Last entry in ddl log
    0                    No entries in ddl log
723
  DESCRIPTION
724 725 726
    When we read the ddl log header we get information about maximum sizes
    of names in the ddl log and we also get information about the number
    of entries in the ddl log.
727 728
*/

729
static uint read_ddl_log_header()
730
{
731
  char *file_entry_buf= (char*)global_ddl_log.file_entry_buf;
732
  char file_name[FN_REFLEN];
733
  uint entry_no;
734
  bool successful_open= FALSE;
735
  DBUG_ENTER("read_ddl_log_header");
736

737
  create_ddl_log_file_name(file_name);
738
  if ((global_ddl_log.file_id= my_open(file_name,
739
                                        O_RDWR | O_BINARY, MYF(0))) >= 0)
740
  {
741
    if (read_ddl_log_file_entry(0UL))
742
    {
743 744
      /* Write message into error log */
      sql_print_error("Failed to read ddl log file in recovery");
745
    }
746 747
    else
      successful_open= TRUE;
748
  }
749 750
  entry_no= uint4korr(&file_entry_buf[DDL_LOG_NUM_ENTRY_POS]);
  global_ddl_log.name_len= uint4korr(&file_entry_buf[DDL_LOG_NAME_LEN_POS]);
751 752
  if (successful_open)
  {
753
    global_ddl_log.io_size= uint4korr(&file_entry_buf[DDL_LOG_IO_SIZE_POS]);
754 755 756
    DBUG_ASSERT(global_ddl_log.io_size <=
                sizeof(global_ddl_log.file_entry_buf));
  }
757
  else
758 759 760
  {
    entry_no= 0;
  }
761 762 763 764
  global_ddl_log.first_free= NULL;
  global_ddl_log.first_used= NULL;
  global_ddl_log.num_entries= 0;
  VOID(pthread_mutex_init(&LOCK_gdl, MY_MUTEX_INIT_FAST));
765
  global_ddl_log.do_release= true;
766
  DBUG_RETURN(entry_no);
767 768 769 770
}


/*
771
  Read a ddl log entry
772
  SYNOPSIS
773
    read_ddl_log_entry()
774 775 776 777 778 779
    read_entry               Number of entry to read
    out:entry_info           Information from entry
  RETURN VALUES
    TRUE                     Error
    FALSE                    Success
  DESCRIPTION
780
    Read a specified entry in the ddl log
781 782
*/

783
bool read_ddl_log_entry(uint read_entry, DDL_LOG_ENTRY *ddl_log_entry)
784
{
785
  char *file_entry_buf= (char*)&global_ddl_log.file_entry_buf;
786
  uint inx;
787
  uchar single_char;
788
  DBUG_ENTER("read_ddl_log_entry");
789

790
  if (read_ddl_log_file_entry(read_entry))
791 792 793
  {
    DBUG_RETURN(TRUE);
  }
794
  ddl_log_entry->entry_pos= read_entry;
795 796 797 798
  single_char= file_entry_buf[DDL_LOG_ENTRY_TYPE_POS];
  ddl_log_entry->entry_type= (enum ddl_log_entry_code)single_char;
  single_char= file_entry_buf[DDL_LOG_ACTION_TYPE_POS];
  ddl_log_entry->action_type= (enum ddl_log_action_code)single_char;
799 800 801 802 803 804 805
  ddl_log_entry->phase= file_entry_buf[DDL_LOG_PHASE_POS];
  ddl_log_entry->next_entry= uint4korr(&file_entry_buf[DDL_LOG_NEXT_ENTRY_POS]);
  ddl_log_entry->name= &file_entry_buf[DDL_LOG_NAME_POS];
  inx= DDL_LOG_NAME_POS + global_ddl_log.name_len;
  ddl_log_entry->from_name= &file_entry_buf[inx];
  inx+= global_ddl_log.name_len;
  ddl_log_entry->handler_name= &file_entry_buf[inx];
806 807 808 809 810
  DBUG_RETURN(FALSE);
}


/*
811
  Initialise ddl log
812
  SYNOPSIS
813
    init_ddl_log()
814

815
  DESCRIPTION
816
    Write the header of the ddl log file and length of names. Also set
817
    number of entries to zero.
818 819 820 821

  RETURN VALUES
    TRUE                     Error
    FALSE                    Success
822 823
*/

824
static bool init_ddl_log()
825
{
826
  char file_name[FN_REFLEN];
827
  DBUG_ENTER("init_ddl_log");
828

829
  if (global_ddl_log.inited)
830 831
    goto end;

832
  global_ddl_log.io_size= IO_SIZE;
833
  create_ddl_log_file_name(file_name);
834 835 836 837
  if ((global_ddl_log.file_id= my_create(file_name,
                                         CREATE_MODE,
                                         O_RDWR | O_TRUNC | O_BINARY,
                                         MYF(MY_WME))) < 0)
838
  {
839
    /* Couldn't create ddl log file, this is serious error */
840 841
    sql_print_error("Failed to open ddl log file");
    DBUG_RETURN(TRUE);
842
  }
843
  global_ddl_log.inited= TRUE;
844
  if (write_ddl_log_header())
845
  {
846
    VOID(my_close(global_ddl_log.file_id, MYF(MY_WME)));
847
    global_ddl_log.inited= FALSE;
848
    DBUG_RETURN(TRUE);
849
  }
850 851

end:
852
  DBUG_RETURN(FALSE);
853 854 855 856
}


/*
857
  Execute one action in a ddl log entry
858
  SYNOPSIS
859 860
    execute_ddl_log_action()
    ddl_log_entry              Information in action entry to execute
861
  RETURN VALUES
862 863
    TRUE                       Error
    FALSE                      Success
864 865
*/

866
static int execute_ddl_log_action(THD *thd, DDL_LOG_ENTRY *ddl_log_entry)
867
{
868 869
  bool frm_action= FALSE;
  LEX_STRING handler_name;
870
  handler *file= NULL;
871
  MEM_ROOT mem_root;
872
  int error= TRUE;
873
  char to_path[FN_REFLEN];
874
  char from_path[FN_REFLEN];
875
#ifdef WITH_PARTITION_STORAGE_ENGINE
876
  char *par_ext= (char*)".par";
877
#endif
878
  handlerton *hton;
879
  DBUG_ENTER("execute_ddl_log_action");
880

881
  if (ddl_log_entry->entry_type == DDL_IGNORE_LOG_ENTRY_CODE)
882 883 884
  {
    DBUG_RETURN(FALSE);
  }
885 886
  handler_name.str= (char*)ddl_log_entry->handler_name;
  handler_name.length= strlen(ddl_log_entry->handler_name);
887
  init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0); 
888
  if (!strcmp(ddl_log_entry->handler_name, reg_ext))
889 890 891
    frm_action= TRUE;
  else
  {
antony@ppcg5.local's avatar
antony@ppcg5.local committed
892 893
    plugin_ref plugin= ha_resolve_by_name(thd, &handler_name);
    if (!plugin)
894 895 896 897
    {
      my_error(ER_ILLEGAL_HA, MYF(0), ddl_log_entry->handler_name);
      goto error;
    }
antony@ppcg5.local's avatar
antony@ppcg5.local committed
898 899
    hton= plugin_data(plugin, handlerton*);
    file= get_new_handler((TABLE_SHARE*)0, &mem_root, hton);
900
    if (!file)
901 902
    {
      mem_alloc_error(sizeof(handler));
903
      goto error;
904
    }
905
  }
906
  switch (ddl_log_entry->action_type)
907
  {
908
    case DDL_LOG_REPLACE_ACTION:
909
    case DDL_LOG_DELETE_ACTION:
910
    {
911
      if (ddl_log_entry->phase == 0)
912 913 914
      {
        if (frm_action)
        {
915 916 917
          strxmov(to_path, ddl_log_entry->name, reg_ext, NullS);
          if ((error= my_delete(to_path, MYF(MY_WME))))
          {
918
            if (my_errno != ENOENT)
919 920
              break;
          }
921
#ifdef WITH_PARTITION_STORAGE_ENGINE
922 923
          strxmov(to_path, ddl_log_entry->name, par_ext, NullS);
          VOID(my_delete(to_path, MYF(MY_WME)));
924
#endif
925 926 927
        }
        else
        {
928
          if ((error= file->ha_delete_table(ddl_log_entry->name)))
929 930 931 932
          {
            if (error != ENOENT && error != HA_ERR_NO_SUCH_TABLE)
              break;
          }
933
        }
934
        if ((deactivate_ddl_log_entry(ddl_log_entry->entry_pos)))
935 936 937
          break;
        VOID(sync_ddl_log());
        error= FALSE;
938 939
        if (ddl_log_entry->action_type == DDL_LOG_DELETE_ACTION)
          break;
940
      }
941 942 943 944 945 946
      DBUG_ASSERT(ddl_log_entry->action_type == DDL_LOG_REPLACE_ACTION);
      /*
        Fall through and perform the rename action of the replace
        action. We have already indicated the success of the delete
        action in the log entry by stepping up the phase.
      */
947
    }
948
    case DDL_LOG_RENAME_ACTION:
949
    {
950 951 952
      error= TRUE;
      if (frm_action)
      {
953
        strxmov(to_path, ddl_log_entry->name, reg_ext, NullS);
954
        strxmov(from_path, ddl_log_entry->from_name, reg_ext, NullS);
955
        if (my_rename(from_path, to_path, MYF(MY_WME)))
956
          break;
957
#ifdef WITH_PARTITION_STORAGE_ENGINE
958
        strxmov(to_path, ddl_log_entry->name, par_ext, NullS);
959
        strxmov(from_path, ddl_log_entry->from_name, par_ext, NullS);
960
        VOID(my_rename(from_path, to_path, MYF(MY_WME)));
961
#endif
962 963 964
      }
      else
      {
965 966
        if (file->ha_rename_table(ddl_log_entry->from_name,
                                  ddl_log_entry->name))
967
          break;
968 969
      }
      if ((deactivate_ddl_log_entry(ddl_log_entry->entry_pos)))
970 971 972
        break;
      VOID(sync_ddl_log());
      error= FALSE;
973
      break;
974
    }
975 976 977 978 979 980 981 982
    default:
      DBUG_ASSERT(0);
      break;
  }
  delete file;
error:
  free_root(&mem_root, MYF(0)); 
  DBUG_RETURN(error);
983 984 985
}


986
/*
987
  Get a free entry in the ddl log
988
  SYNOPSIS
989 990
    get_free_ddl_log_entry()
    out:active_entry                A ddl log memory entry returned
991
  RETURN VALUES
992 993
    TRUE                       Error
    FALSE                      Success
994 995
*/

996 997
static bool get_free_ddl_log_entry(DDL_LOG_MEMORY_ENTRY **active_entry,
                                   bool *write_header)
998
{
999 1000 1001
  DDL_LOG_MEMORY_ENTRY *used_entry;
  DDL_LOG_MEMORY_ENTRY *first_used= global_ddl_log.first_used;
  DBUG_ENTER("get_free_ddl_log_entry");
1002

1003
  if (global_ddl_log.first_free == NULL)
1004
  {
1005 1006
    if (!(used_entry= (DDL_LOG_MEMORY_ENTRY*)my_malloc(
                              sizeof(DDL_LOG_MEMORY_ENTRY), MYF(MY_WME))))
1007
    {
1008
      sql_print_error("Failed to allocate memory for ddl log free list");
1009 1010
      DBUG_RETURN(TRUE);
    }
1011
    global_ddl_log.num_entries++;
1012
    used_entry->entry_pos= global_ddl_log.num_entries;
1013
    *write_header= TRUE;
1014 1015 1016
  }
  else
  {
1017 1018
    used_entry= global_ddl_log.first_free;
    global_ddl_log.first_free= used_entry->next_log_entry;
1019
    *write_header= FALSE;
1020 1021 1022 1023 1024 1025
  }
  /*
    Move from free list to used list
  */
  used_entry->next_log_entry= first_used;
  used_entry->prev_log_entry= NULL;
1026
  global_ddl_log.first_used= used_entry;
1027 1028 1029 1030
  if (first_used)
    first_used->prev_log_entry= used_entry;

  *active_entry= used_entry;
1031
  DBUG_RETURN(FALSE);
1032 1033 1034 1035
}


/*
1036
  External interface methods for the DDL log Module
1037 1038 1039 1040
  ---------------------------------------------------
*/

/*
1041
  SYNOPSIS
1042 1043 1044
    write_ddl_log_entry()
    ddl_log_entry         Information about log entry
    out:entry_written     Entry information written into   
1045

1046
  RETURN VALUES
1047 1048 1049 1050
    TRUE                      Error
    FALSE                     Success

  DESCRIPTION
1051
    A careful write of the ddl log is performed to ensure that we can
1052
    handle crashes occurring during CREATE and ALTER TABLE processing.
1053 1054
*/

1055 1056
bool write_ddl_log_entry(DDL_LOG_ENTRY *ddl_log_entry,
                         DDL_LOG_MEMORY_ENTRY **active_entry)
1057
{
1058
  bool error, write_header;
1059 1060 1061 1062 1063 1064
  DBUG_ENTER("write_ddl_log_entry");

  if (init_ddl_log())
  {
    DBUG_RETURN(TRUE);
  }
1065 1066
  global_ddl_log.file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]=
                                    (char)DDL_LOG_ENTRY_CODE;
1067
  global_ddl_log.file_entry_buf[DDL_LOG_ACTION_TYPE_POS]=
1068
                                    (char)ddl_log_entry->action_type;
1069 1070 1071 1072
  global_ddl_log.file_entry_buf[DDL_LOG_PHASE_POS]= 0;
  int4store(&global_ddl_log.file_entry_buf[DDL_LOG_NEXT_ENTRY_POS],
            ddl_log_entry->next_entry);
  DBUG_ASSERT(strlen(ddl_log_entry->name) < FN_LEN);
1073 1074
  strmake(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS],
          ddl_log_entry->name, FN_LEN - 1);
1075 1076
  if (ddl_log_entry->action_type == DDL_LOG_RENAME_ACTION ||
      ddl_log_entry->action_type == DDL_LOG_REPLACE_ACTION)
1077
  {
1078
    DBUG_ASSERT(strlen(ddl_log_entry->from_name) < FN_LEN);
1079 1080
    strmake(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS + FN_LEN],
          ddl_log_entry->from_name, FN_LEN - 1);
1081
  }
1082
  else
1083 1084
    global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS + FN_LEN]= 0;
  DBUG_ASSERT(strlen(ddl_log_entry->handler_name) < FN_LEN);
1085 1086
  strmake(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS + (2*FN_LEN)],
          ddl_log_entry->handler_name, FN_LEN - 1);
1087
  if (get_free_ddl_log_entry(active_entry, &write_header))
1088 1089 1090 1091
  {
    DBUG_RETURN(TRUE);
  }
  error= FALSE;
1092
  if (write_ddl_log_file_entry((*active_entry)->entry_pos))
1093
  {
1094
    error= TRUE;
1095 1096 1097
    sql_print_error("Failed to write entry_no = %u",
                    (*active_entry)->entry_pos);
  }
1098 1099
  if (write_header && !error)
  {
1100 1101
    VOID(sync_ddl_log());
    if (write_ddl_log_header())
1102 1103
      error= TRUE;
  }
1104
  if (error)
1105
    release_ddl_log_memory_entry(*active_entry);
1106
  DBUG_RETURN(error);
1107 1108 1109 1110
}


/*
1111
  Write final entry in the ddl log
1112
  SYNOPSIS
1113
    write_execute_ddl_log_entry()
1114 1115 1116 1117
    first_entry                    First entry in linked list of entries
                                   to execute, if 0 = NULL it means that
                                   the entry is removed and the entries
                                   are put into the free list.
1118 1119 1120
    complete                       Flag indicating we are simply writing
                                   info about that entry has been completed
    in:out:active_entry            Entry to execute, 0 = NULL if the entry
1121 1122 1123
                                   is written first time and needs to be
                                   returned. In this case the entry written
                                   is returned in this parameter
1124
  RETURN VALUES
1125 1126 1127 1128
    TRUE                           Error
    FALSE                          Success

  DESCRIPTION
1129
    This is the last write in the ddl log. The previous log entries have
1130
    already been written but not yet synched to disk.
1131 1132 1133 1134
    We write a couple of log entries that describes action to perform.
    This entries are set-up in a linked list, however only when a first
    execute entry is put as the first entry these will be executed.
    This routine writes this first 
1135
*/ 
1136

1137 1138 1139
bool write_execute_ddl_log_entry(uint first_entry,
                                 bool complete,
                                 DDL_LOG_MEMORY_ENTRY **active_entry)
1140
{
1141
  bool write_header= FALSE;
1142 1143
  char *file_entry_buf= (char*)global_ddl_log.file_entry_buf;
  DBUG_ENTER("write_execute_ddl_log_entry");
1144

1145 1146 1147 1148
  if (init_ddl_log())
  {
    DBUG_RETURN(TRUE);
  }
1149 1150
  if (!complete)
  {
1151 1152 1153 1154 1155 1156
    /*
      We haven't synched the log entries yet, we synch them now before
      writing the execute entry. If complete is true we haven't written
      any log entries before, we are only here to write the execute
      entry to indicate it is done.
    */
1157
    VOID(sync_ddl_log());
1158
    file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]= (char)DDL_LOG_EXECUTE_CODE;
1159 1160
  }
  else
1161
    file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]= (char)DDL_IGNORE_LOG_ENTRY_CODE;
1162 1163 1164 1165 1166 1167
  file_entry_buf[DDL_LOG_ACTION_TYPE_POS]= 0; /* Ignored for execute entries */
  file_entry_buf[DDL_LOG_PHASE_POS]= 0;
  int4store(&file_entry_buf[DDL_LOG_NEXT_ENTRY_POS], first_entry);
  file_entry_buf[DDL_LOG_NAME_POS]= 0;
  file_entry_buf[DDL_LOG_NAME_POS + FN_LEN]= 0;
  file_entry_buf[DDL_LOG_NAME_POS + 2*FN_LEN]= 0;
1168
  if (!(*active_entry))
1169
  {
1170
    if (get_free_ddl_log_entry(active_entry, &write_header))
1171 1172 1173
    {
      DBUG_RETURN(TRUE);
    }
1174
  }
1175
  if (write_ddl_log_file_entry((*active_entry)->entry_pos))
1176
  {
1177
    sql_print_error("Error writing execute entry in ddl log");
1178
    release_ddl_log_memory_entry(*active_entry);
1179 1180
    DBUG_RETURN(TRUE);
  }
1181
  VOID(sync_ddl_log());
1182 1183
  if (write_header)
  {
1184
    if (write_ddl_log_header())
1185
    {
1186
      release_ddl_log_memory_entry(*active_entry);
1187 1188 1189
      DBUG_RETURN(TRUE);
    }
  }
1190 1191 1192 1193
  DBUG_RETURN(FALSE);
}


1194
/*
1195
  For complex rename operations we need to deactivate individual entries.
1196
  SYNOPSIS
1197
    deactivate_ddl_log_entry()
1198 1199 1200 1201 1202 1203 1204 1205
    entry_no                      Entry position of record to change
  RETURN VALUES
    TRUE                         Error
    FALSE                        Success
  DESCRIPTION
    During replace operations where we start with an existing table called
    t1 and a replacement table called t1#temp or something else and where
    we want to delete t1 and rename t1#temp to t1 this is not possible to
1206
    do in a safe manner unless the ddl log is informed of the phases in
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
    the change.

    Delete actions are 1-phase actions that can be ignored immediately after
    being executed.
    Rename actions from x to y is also a 1-phase action since there is no
    interaction with any other handlers named x and y.
    Replace action where drop y and x -> y happens needs to be a two-phase
    action. Thus the first phase will drop y and the second phase will
    rename x -> y.
*/

1218
bool deactivate_ddl_log_entry(uint entry_no)
1219
{
1220 1221
  char *file_entry_buf= (char*)global_ddl_log.file_entry_buf;
  DBUG_ENTER("deactivate_ddl_log_entry");
1222

1223
  if (!read_ddl_log_file_entry(entry_no))
1224
  {
1225
    if (file_entry_buf[DDL_LOG_ENTRY_TYPE_POS] == DDL_LOG_ENTRY_CODE)
1226
    {
1227 1228 1229 1230 1231 1232
      if (file_entry_buf[DDL_LOG_ACTION_TYPE_POS] == DDL_LOG_DELETE_ACTION ||
          file_entry_buf[DDL_LOG_ACTION_TYPE_POS] == DDL_LOG_RENAME_ACTION ||
          (file_entry_buf[DDL_LOG_ACTION_TYPE_POS] == DDL_LOG_REPLACE_ACTION &&
           file_entry_buf[DDL_LOG_PHASE_POS] == 1))
        file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]= DDL_IGNORE_LOG_ENTRY_CODE;
      else if (file_entry_buf[DDL_LOG_ACTION_TYPE_POS] == DDL_LOG_REPLACE_ACTION)
1233
      {
1234 1235
        DBUG_ASSERT(file_entry_buf[DDL_LOG_PHASE_POS] == 0);
        file_entry_buf[DDL_LOG_PHASE_POS]= 1;
1236 1237 1238 1239 1240
      }
      else
      {
        DBUG_ASSERT(0);
      }
1241 1242 1243 1244 1245 1246
      if (write_ddl_log_file_entry(entry_no))
      {
        sql_print_error("Error in deactivating log entry. Position = %u",
                        entry_no);
        DBUG_RETURN(TRUE);
      }
1247 1248
    }
  }
1249 1250 1251 1252 1253 1254
  else
  {
    sql_print_error("Failed in reading entry before deactivating it");
    DBUG_RETURN(TRUE);
  }
  DBUG_RETURN(FALSE);
1255 1256 1257 1258
}


/*
1259
  Sync ddl log file
1260
  SYNOPSIS
1261
    sync_ddl_log()
1262 1263 1264 1265 1266
  RETURN VALUES
    TRUE                      Error
    FALSE                     Success
*/

1267
bool sync_ddl_log()
1268 1269
{
  bool error= FALSE;
1270
  DBUG_ENTER("sync_ddl_log");
1271

1272 1273
  if ((!global_ddl_log.recovery_phase) &&
      init_ddl_log())
1274 1275 1276 1277
  {
    DBUG_RETURN(TRUE);
  }
  if (my_sync(global_ddl_log.file_id, MYF(0)))
1278 1279
  {
    /* Write to error log */
1280
    sql_print_error("Failed to sync ddl log");
1281 1282 1283 1284 1285 1286
    error= TRUE;
  }
  DBUG_RETURN(error);
}


1287 1288 1289
/*
  Release a log memory entry
  SYNOPSIS
1290
    release_ddl_log_memory_entry()
1291 1292 1293 1294 1295
    log_memory_entry                Log memory entry to release
  RETURN VALUES
    NONE
*/

1296
void release_ddl_log_memory_entry(DDL_LOG_MEMORY_ENTRY *log_entry)
1297
{
1298 1299 1300 1301
  DDL_LOG_MEMORY_ENTRY *first_free= global_ddl_log.first_free;
  DDL_LOG_MEMORY_ENTRY *next_log_entry= log_entry->next_log_entry;
  DDL_LOG_MEMORY_ENTRY *prev_log_entry= log_entry->prev_log_entry;
  DBUG_ENTER("release_ddl_log_memory_entry");
1302

1303
  global_ddl_log.first_free= log_entry;
1304 1305 1306 1307 1308
  log_entry->next_log_entry= first_free;

  if (prev_log_entry)
    prev_log_entry->next_log_entry= next_log_entry;
  else
1309
    global_ddl_log.first_used= next_log_entry;
1310 1311
  if (next_log_entry)
    next_log_entry->prev_log_entry= prev_log_entry;
1312
  DBUG_VOID_RETURN;
1313 1314 1315
}


1316
/*
1317
  Execute one entry in the ddl log. Executing an entry means executing
1318 1319
  a linked list of actions.
  SYNOPSIS
1320
    execute_ddl_log_entry()
1321 1322 1323 1324 1325 1326
    first_entry                Reference to first action in entry
  RETURN VALUES
    TRUE                       Error
    FALSE                      Success
*/

1327
bool execute_ddl_log_entry(THD *thd, uint first_entry)
1328
{
1329
  DDL_LOG_ENTRY ddl_log_entry;
1330
  uint read_entry= first_entry;
1331
  DBUG_ENTER("execute_ddl_log_entry");
1332

1333
  pthread_mutex_lock(&LOCK_gdl);
1334 1335
  do
  {
1336
    if (read_ddl_log_entry(read_entry, &ddl_log_entry))
1337 1338
    {
      /* Write to error log and continue with next log entry */
1339 1340
      sql_print_error("Failed to read entry = %u from ddl log",
                      read_entry);
1341 1342
      break;
    }
1343 1344
    DBUG_ASSERT(ddl_log_entry.entry_type == DDL_LOG_ENTRY_CODE ||
                ddl_log_entry.entry_type == DDL_IGNORE_LOG_ENTRY_CODE);
1345

1346
    if (execute_ddl_log_action(thd, &ddl_log_entry))
1347
    {
1348
      /* Write to error log and continue with next log entry */
1349 1350
      sql_print_error("Failed to execute action for entry = %u from ddl log",
                      read_entry);
1351
      break;
1352
    }
1353
    read_entry= ddl_log_entry.next_entry;
1354
  } while (read_entry);
1355
  pthread_mutex_unlock(&LOCK_gdl);
1356 1357 1358
  DBUG_RETURN(FALSE);
}

1359

1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379
/*
  Close the ddl log
  SYNOPSIS
    close_ddl_log()
  RETURN VALUES
    NONE
*/

static void close_ddl_log()
{
  DBUG_ENTER("close_ddl_log");
  if (global_ddl_log.file_id >= 0)
  {
    VOID(my_close(global_ddl_log.file_id, MYF(MY_WME)));
    global_ddl_log.file_id= (File) -1;
  }
  DBUG_VOID_RETURN;
}


1380
/*
1381
  Execute the ddl log at recovery of MySQL Server
1382
  SYNOPSIS
1383
    execute_ddl_log_recovery()
1384 1385 1386 1387
  RETURN VALUES
    NONE
*/

1388
void execute_ddl_log_recovery()
1389
{
1390
  uint num_entries, i;
1391
  THD *thd;
1392
  DDL_LOG_ENTRY ddl_log_entry;
1393
  char file_name[FN_REFLEN];
1394
  DBUG_ENTER("execute_ddl_log_recovery");
1395

1396 1397 1398 1399 1400 1401 1402
  /*
    Initialise global_ddl_log struct
  */
  bzero(global_ddl_log.file_entry_buf, sizeof(global_ddl_log.file_entry_buf));
  global_ddl_log.inited= FALSE;
  global_ddl_log.recovery_phase= TRUE;
  global_ddl_log.io_size= IO_SIZE;
monty@mysql.com's avatar
monty@mysql.com committed
1403
  global_ddl_log.file_id= (File) -1;
1404

1405 1406 1407 1408 1409 1410 1411 1412
  /*
    To be able to run this from boot, we allocate a temporary THD
  */
  if (!(thd=new THD))
    DBUG_VOID_RETURN;
  thd->thread_stack= (char*) &thd;
  thd->store_globals();

1413
  num_entries= read_ddl_log_header();
1414
  for (i= 1; i < num_entries + 1; i++)
1415
  {
1416
    if (read_ddl_log_entry(i, &ddl_log_entry))
1417
    {
1418 1419 1420
      sql_print_error("Failed to read entry no = %u from ddl log",
                       i);
      continue;
1421
    }
1422
    if (ddl_log_entry.entry_type == DDL_LOG_EXECUTE_CODE)
1423
    {
1424
      if (execute_ddl_log_entry(thd, ddl_log_entry.next_entry))
1425
      {
1426 1427
        /* Real unpleasant scenario but we continue anyways.  */
        continue;
1428 1429 1430
      }
    }
  }
1431
  close_ddl_log();
1432 1433 1434 1435 1436 1437
  create_ddl_log_file_name(file_name);
  VOID(my_delete(file_name, MYF(0)));
  global_ddl_log.recovery_phase= FALSE;
  delete thd;
  /* Remember that we don't have a THD */
  my_pthread_setspecific_ptr(THR_THD,  0);
1438
  DBUG_VOID_RETURN;
1439 1440 1441 1442
}


/*
1443
  Release all memory allocated to the ddl log
1444
  SYNOPSIS
1445
    release_ddl_log()
1446 1447 1448 1449
  RETURN VALUES
    NONE
*/

1450
void release_ddl_log()
1451
{
1452 1453 1454
  DDL_LOG_MEMORY_ENTRY *free_list= global_ddl_log.first_free;
  DDL_LOG_MEMORY_ENTRY *used_list= global_ddl_log.first_used;
  DBUG_ENTER("release_ddl_log");
1455

1456 1457 1458
  if (!global_ddl_log.do_release)
    DBUG_VOID_RETURN;

1459
  pthread_mutex_lock(&LOCK_gdl);
1460 1461
  while (used_list)
  {
1462
    DDL_LOG_MEMORY_ENTRY *tmp= used_list->next_log_entry;
1463
    my_free(used_list, MYF(0));
1464
    used_list= tmp;
1465 1466 1467
  }
  while (free_list)
  {
1468
    DDL_LOG_MEMORY_ENTRY *tmp= free_list->next_log_entry;
1469
    my_free(free_list, MYF(0));
1470
    free_list= tmp;
1471
  }
1472
  close_ddl_log();
monty@mysql.com's avatar
monty@mysql.com committed
1473
  global_ddl_log.inited= 0;
1474
  pthread_mutex_unlock(&LOCK_gdl);
1475
  VOID(pthread_mutex_destroy(&LOCK_gdl));
1476
  global_ddl_log.do_release= false;
1477
  DBUG_VOID_RETURN;
1478 1479 1480
}


1481 1482 1483
/*
---------------------------------------------------------------------------

1484
  END MODULE DDL log
1485 1486 1487 1488 1489
  --------------------

---------------------------------------------------------------------------
*/

1490

1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
/**
   @brief construct a temporary shadow file name.

   @details Make a shadow file name used by ALTER TABLE to construct the
   modified table (with keeping the original). The modified table is then
   moved back as original table. The name must start with the temp file
   prefix so it gets filtered out by table files listing routines. 
    
   @param[out] buff      buffer to receive the constructed name
   @param      bufflen   size of buff
   @param      lpt       alter table data structure

   @retval     path length
*/

uint build_table_shadow_filename(char *buff, size_t bufflen, 
                                 ALTER_PARTITION_PARAM_TYPE *lpt)
{
  char tmp_name[FN_REFLEN];
  my_snprintf (tmp_name, sizeof (tmp_name), "%s-%s", tmp_file_prefix,
               lpt->table_name);
  return build_table_filename(buff, bufflen, lpt->db, tmp_name, "", FN_IS_TMP);
}


1516 1517 1518 1519 1520 1521 1522 1523
/*
  SYNOPSIS
    mysql_write_frm()
    lpt                    Struct carrying many parameters needed for this
                           method
    flags                  Flags as defined below
      WFRM_INITIAL_WRITE        If set we need to prepare table before
                                creating the frm file
1524 1525 1526 1527 1528 1529
      WFRM_INSTALL_SHADOW       If set we should install the new frm
      WFRM_KEEP_SHARE           If set we know that the share is to be
                                retained and thus we should ensure share
                                object is correct, if not set we don't
                                set the new partition syntax string since
                                we know the share object is destroyed.
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551
      WFRM_PACK_FRM             If set we should pack the frm file and delete
                                the frm file

  RETURN VALUES
    TRUE                   Error
    FALSE                  Success

  DESCRIPTION
    A support method that creates a new frm file and in this process it
    regenerates the partition data. It works fine also for non-partitioned
    tables since it only handles partitioned data if it exists.
*/

bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags)
{
  /*
    Prepare table to prepare for writing a new frm file where the
    partitions in add/drop state have temporarily changed their state
    We set tmp_table to avoid get errors on naming of primary key index.
  */
  int error= 0;
  char path[FN_REFLEN+1];
1552 1553
  char shadow_path[FN_REFLEN+1];
  char shadow_frm_name[FN_REFLEN+1];
1554
  char frm_name[FN_REFLEN+1];
1555 1556 1557 1558
#ifdef WITH_PARTITION_STORAGE_ENGINE
  char *part_syntax_buf;
  uint syntax_len;
#endif
1559 1560
  DBUG_ENTER("mysql_write_frm");

1561 1562 1563
  /*
    Build shadow frm file name
  */
1564
  build_table_shadow_filename(shadow_path, sizeof(shadow_path) - 1, lpt);
1565
  strxmov(shadow_frm_name, shadow_path, reg_ext, NullS);
1566
  if (flags & WFRM_WRITE_SHADOW)
1567
  {
1568 1569 1570 1571 1572 1573 1574 1575
    if (mysql_prepare_create_table(lpt->thd, lpt->create_info,
                                   lpt->alter_info,
                                   /*tmp_table*/ 1,
                                   &lpt->db_options,
                                   lpt->table->file,
                                   &lpt->key_info_buffer,
                                   &lpt->key_count,
                                   /*select_field_count*/ 0))
1576 1577 1578 1579 1580
    {
      DBUG_RETURN(TRUE);
    }
#ifdef WITH_PARTITION_STORAGE_ENGINE
    {
1581 1582
      partition_info *part_info= lpt->table->part_info;
      if (part_info)
1583
      {
1584 1585
        if (!(part_syntax_buf= generate_partition_syntax(part_info,
                                                         &syntax_len,
1586
                                                         TRUE, TRUE)))
1587 1588 1589 1590
        {
          DBUG_RETURN(TRUE);
        }
        part_info->part_info_string= part_syntax_buf;
1591
        part_info->part_info_len= syntax_len;
1592 1593 1594
      }
    }
#endif
1595 1596 1597 1598
    /* Write shadow frm file */
    lpt->create_info->table_options= lpt->db_options;
    if ((mysql_create_frm(lpt->thd, shadow_frm_name, lpt->db,
                          lpt->table_name, lpt->create_info,
1599
                          lpt->alter_info->create_list, lpt->key_count,
1600
                          lpt->key_info_buffer, lpt->table->file)) ||
1601 1602 1603
        lpt->table->file->ha_create_handler_files(shadow_path, NULL,
                                                  CHF_CREATE_FLAG,
                                                  lpt->create_info))
1604 1605 1606 1607 1608
    {
      my_delete(shadow_frm_name, MYF(0));
      error= 1;
      goto end;
    }
1609 1610 1611 1612 1613 1614 1615 1616 1617
  }
  if (flags & WFRM_PACK_FRM)
  {
    /*
      We need to pack the frm file and after packing it we delete the
      frm file to ensure it doesn't get used. This is only used for
      handlers that have the main version of the frm file stored in the
      handler.
    */
1618 1619
    uchar *data;
    size_t length;
1620
    if (readfrm(shadow_path, &data, &length) ||
1621 1622
        packfrm(data, length, &lpt->pack_frm_data, &lpt->pack_frm_len))
    {
1623 1624
      my_free(data, MYF(MY_ALLOW_ZERO_PTR));
      my_free(lpt->pack_frm_data, MYF(MY_ALLOW_ZERO_PTR));
1625 1626 1627 1628
      mem_alloc_error(length);
      error= 1;
      goto end;
    }
1629
    error= my_delete(shadow_frm_name, MYF(MY_WME));
1630
  }
1631 1632
  if (flags & WFRM_INSTALL_SHADOW)
  {
1633 1634 1635
#ifdef WITH_PARTITION_STORAGE_ENGINE
    partition_info *part_info= lpt->part_info;
#endif
1636 1637 1638
    /*
      Build frm file name
    */
1639
    build_table_filename(path, sizeof(path) - 1, lpt->db,
1640
                         lpt->table_name, "", 0);
1641 1642 1643 1644
    strxmov(frm_name, path, reg_ext, NullS);
    /*
      When we are changing to use new frm file we need to ensure that we
      don't collide with another thread in process to open the frm file.
1645 1646 1647 1648 1649 1650
      We start by deleting the .frm file and possible .par file. Then we
      write to the DDL log that we have completed the delete phase by
      increasing the phase of the log entry. Next step is to rename the
      new .frm file and the new .par file to the real name. After
      completing this we write a new phase to the log entry that will
      deactivate it.
1651 1652 1653
    */
    VOID(pthread_mutex_lock(&LOCK_open));
    if (my_delete(frm_name, MYF(MY_WME)) ||
1654
#ifdef WITH_PARTITION_STORAGE_ENGINE
1655 1656
        lpt->table->file->ha_create_handler_files(path, shadow_path,
                                                  CHF_DELETE_FLAG, NULL) ||
1657 1658
        deactivate_ddl_log_entry(part_info->frm_log_entry->entry_pos) ||
        (sync_ddl_log(), FALSE) ||
1659
#endif
1660
#ifdef WITH_PARTITION_STORAGE_ENGINE
1661
        my_rename(shadow_frm_name, frm_name, MYF(MY_WME)) ||
1662 1663
        lpt->table->file->ha_create_handler_files(path, shadow_path,
                                                  CHF_RENAME_FLAG, NULL))
1664 1665 1666
#else
        my_rename(shadow_frm_name, frm_name, MYF(MY_WME)))
#endif
1667 1668
    {
      error= 1;
1669
      goto err;
1670
    }
1671
#ifdef WITH_PARTITION_STORAGE_ENGINE
1672
    if (part_info && (flags & WFRM_KEEP_SHARE))
1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698
    {
      TABLE_SHARE *share= lpt->table->s;
      char *tmp_part_syntax_str;
      if (!(part_syntax_buf= generate_partition_syntax(part_info,
                                                       &syntax_len,
                                                       TRUE, TRUE)))
      {
        error= 1;
        goto err;
      }
      if (share->partition_info_buffer_size < syntax_len + 1)
      {
        share->partition_info_buffer_size= syntax_len+1;
        if (!(tmp_part_syntax_str= (char*) strmake_root(&share->mem_root,
                                                        part_syntax_buf,
                                                        syntax_len)))
        {
          error= 1;
          goto err;
        }
        share->partition_info= tmp_part_syntax_str;
      }
      else
        memcpy((char*) share->partition_info, part_syntax_buf, syntax_len + 1);
      share->partition_info_len= part_info->part_info_len= syntax_len;
      part_info->part_info_string= part_syntax_buf;
1699
    }
1700 1701 1702
#endif

err:
1703
    VOID(pthread_mutex_unlock(&LOCK_open));
1704
#ifdef WITH_PARTITION_STORAGE_ENGINE
1705
    deactivate_ddl_log_entry(part_info->frm_log_entry->entry_pos);
1706
    part_info->frm_log_entry= NULL;
1707
    VOID(sync_ddl_log());
1708
#endif
1709
  }
1710

1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
end:
  DBUG_RETURN(error);
}


/*
  SYNOPSIS
    write_bin_log()
    thd                           Thread object
    clear_error                   is clear_error to be called
    query                         Query to log
    query_length                  Length of query

  RETURN VALUES
    NONE

  DESCRIPTION
    Write the binlog if open, routine used in multiple places in this
    file
*/

void write_bin_log(THD *thd, bool clear_error,
                   char const *query, ulong query_length)
{
  if (mysql_bin_log.is_open())
  {
1737
    int errcode= 0;
1738 1739
    if (clear_error)
      thd->clear_error();
1740 1741
    else
      errcode= query_error_code(thd, TRUE);
1742
    thd->binlog_query(THD::STMT_QUERY_TYPE,
1743
                      query, query_length, FALSE, FALSE, errcode);
1744 1745 1746
  }
}

1747

1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765
/*
 delete (drop) tables.

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

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

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

  RETURN
1766 1767
    FALSE OK.  In this case ok packet is sent to user
    TRUE  Error
1768 1769

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

1771 1772
bool mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists,
                    my_bool drop_temporary)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1773
{
1774
  bool error= FALSE, need_start_waiters= FALSE;
1775
  Drop_table_error_handler err_handler(thd->get_internal_handler());
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1776 1777 1778 1779
  DBUG_ENTER("mysql_rm_table");

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

1780
  if (!drop_temporary)
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1781
  {
1782
    if ((error= wait_if_global_read_lock(thd, 0, 1)))
1783
    {
1784
      my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), tables->table_name);
1785
      DBUG_RETURN(TRUE);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1786
    }
1787 1788
    else
      need_start_waiters= TRUE;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1789
  }
1790 1791 1792 1793 1794 1795

  /*
    Acquire LOCK_open after wait_if_global_read_lock(). If we would hold
    LOCK_open during wait_if_global_read_lock(), other threads could not
    close their tables. This would make a pretty deadlock.
  */
1796
  thd->push_internal_handler(&err_handler);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1797
  error= mysql_rm_table_part2(thd, tables, if_exists, drop_temporary, 0, 0);
1798 1799
  thd->pop_internal_handler();

1800

1801 1802 1803
  if (need_start_waiters)
    start_waiting_global_read_lock(thd);

1804
  if (error)
1805
    DBUG_RETURN(TRUE);
1806
  my_ok(thd);
1807
  DBUG_RETURN(FALSE);
1808 1809
}

1810
/*
1811 1812 1813 1814 1815 1816 1817 1818 1819
  Execute the drop of a normal or temporary table

  SYNOPSIS
    mysql_rm_table_part2()
    thd			Thread handler
    tables		Tables to drop
    if_exists		If set, don't give an error if table doesn't exists.
			In this case we give an warning of level 'NOTE'
    drop_temporary	Only drop temporary tables
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1820
    drop_view		Allow to delete VIEW .frm
1821 1822
    dont_log_query	Don't write query to log files. This will also not
			generate warnings if the handler files doesn't exists  
1823

1824 1825 1826 1827 1828 1829 1830 1831 1832
  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.
1833 1834 1835 1836 1837

 RETURN
   0	ok
   1	Error
   -1	Thread was killed
1838
*/
1839 1840

int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1841 1842
			 bool drop_temporary, bool drop_view,
			 bool dont_log_query)
1843 1844
{
  TABLE_LIST *table;
1845
  char path[FN_REFLEN + 1], *alias;
1846
  uint path_length;
1847
  String wrong_tables;
1848
  int error= 0;
1849
  int non_temp_tables_count= 0;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1850
  bool some_tables_deleted=0, tmp_table_deleted=0, foreign_key_error=0;
1851
  String built_query;
1852
  String built_tmp_query;
1853 1854
  DBUG_ENTER("mysql_rm_table_part2");

1855 1856 1857
  LINT_INIT(alias);
  LINT_INIT(path_length);

1858
  if (thd->current_stmt_binlog_row_based && !dont_log_query)
1859 1860 1861 1862 1863 1864 1865
  {
    built_query.set_charset(system_charset_info);
    if (if_exists)
      built_query.append("DROP TABLE IF EXISTS ");
    else
      built_query.append("DROP TABLE ");
  }
1866

1867
  mysql_ha_rm_tables(thd, tables, FALSE);
1868

1869 1870
  pthread_mutex_lock(&LOCK_open);

1871 1872 1873 1874 1875 1876 1877 1878 1879
  /*
    If we have the table in the definition cache, we don't have to check the
    .frm file to find if the table is a normal table (not view) and what
    engine to use.
  */

  for (table= tables; table; table= table->next_local)
  {
    TABLE_SHARE *share;
1880
    table->db_type= NULL;
1881
    if ((share= get_cached_table_share(table->db, table->table_name)))
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1882
      table->db_type= share->db_type();
1883 1884

    /* Disable drop of enabled log tables */
1885
    if (share && (share->table_category == TABLE_CATEGORY_PERFORMANCE) &&
1886 1887
        check_if_log_table(table->db_length, table->db,
                           table->table_name_length, table->table_name, 1))
1888
    {
1889
      my_error(ER_BAD_LOG_STATEMENT, MYF(0), "DROP");
1890
      pthread_mutex_unlock(&LOCK_open);
1891 1892
      DBUG_RETURN(1);
    }
1893 1894
  }

1895 1896
  if (!drop_temporary && lock_table_names_exclusively(thd, tables))
  {
1897
    pthread_mutex_unlock(&LOCK_open);
1898
    DBUG_RETURN(1);
1899
  }
1900

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1901
  for (table= tables; table; table= table->next_local)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1902
  {
1903
    char *db=table->db;
1904 1905
    handlerton *table_type;
    enum legacy_db_type frm_db_type;
1906

1907 1908 1909
    DBUG_PRINT("table", ("table_l: '%s'.'%s'  table: 0x%lx  s: 0x%lx",
                         table->db, table->table_name, (long) table->table,
                         table->table ? (long) table->table->s : (long) -1));
1910 1911 1912 1913 1914 1915 1916

    error= drop_temporary_table(thd, table);

    switch (error) {
    case  0:
      // removed temporary table
      tmp_table_deleted= 1;
1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935
      if (thd->variables.binlog_format == BINLOG_FORMAT_MIXED &&
          thd->current_stmt_binlog_row_based)
      {
        if (built_tmp_query.is_empty()) 
        {
          built_tmp_query.set_charset(system_charset_info);
          built_tmp_query.append("DROP TEMPORARY TABLE IF EXISTS ");
        }

        built_tmp_query.append("`");
        if (thd->db == NULL || strcmp(db,thd->db) != 0)
        {
          built_tmp_query.append(db);
          built_tmp_query.append("`.`");
        }
        built_tmp_query.append(table->table_name);
        built_tmp_query.append("`,");
      }

1936 1937
      continue;
    case -1:
1938
      DBUG_ASSERT(thd->in_sub_stmt);
1939 1940 1941 1942 1943
      error= 1;
      goto err_with_placeholders;
    default:
      // temporary table not found
      error= 0;
1944
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1945

1946 1947 1948 1949 1950 1951
    /*
      If row-based replication is used and the table is not a
      temporary table, we add the table name to the drop statement
      being built.  The string always end in a comma and the comma
      will be chopped off before being written to the binary log.
      */
1952
    if (thd->current_stmt_binlog_row_based && !dont_log_query)
1953
    {
1954
      non_temp_tables_count++;
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969
      /*
        Don't write the database name if it is the current one (or if
        thd->db is NULL).
      */
      built_query.append("`");
      if (thd->db == NULL || strcmp(db,thd->db) != 0)
      {
        built_query.append(db);
        built_query.append("`.`");
      }

      built_query.append(table->table_name);
      built_query.append("`,");
    }

1970
    table_type= table->db_type;
1971
    if (!drop_temporary)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1972
    {
1973
      TABLE *locked_table;
1974 1975 1976 1977
      abort_locked_tables(thd, db, table->table_name);
      remove_table_from_cache(thd, db, table->table_name,
	                      RTFC_WAIT_OTHER_THREAD_FLAG |
			      RTFC_CHECK_KILLED_FLAG);
1978 1979 1980 1981 1982 1983 1984
      /*
        If the table was used in lock tables, remember it so that
        unlock_table_names can free it
      */
      if ((locked_table= drop_locked_tables(thd, db, table->table_name)))
        table->table= locked_table;

1985
      if (thd->killed)
1986
      {
1987 1988
        error= -1;
        goto err_with_placeholders;
1989
      }
1990
      alias= (lower_case_table_names == 2) ? table->alias : table->table_name;
1991
      /* remove .frm file and engine files */
1992 1993
      path_length= build_table_filename(path, sizeof(path) - 1, db, alias,
                                        reg_ext,
1994 1995
                                        table->internal_tmp_table ?
                                        FN_IS_TMP : 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1996
    }
1997
    if (drop_temporary ||
Staale Smedseng's avatar
Staale Smedseng committed
1998 1999
        ((table_type == NULL &&        
         access(path, F_OK) &&
2000 2001
          ha_create_table_from_engine(thd, db, alias)) ||
         (!drop_view &&
2002
          mysql_frm_type(thd, path, &frm_db_type) != FRMTYPE_TABLE)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2003
    {
2004
      // Table was not found on disk and table can't be created from engine
2005
      if (if_exists)
2006 2007
	push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
			    ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
2008
			    table->table_name);
2009
      else
2010
        error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2011 2012 2013
    }
    else
    {
2014
      char *end;
2015 2016 2017 2018 2019
      if (table_type == NULL)
      {
	mysql_frm_type(thd, path, &frm_db_type);
        table_type= ha_resolve_by_legacy_type(thd, frm_db_type);
      }
2020 2021
      // Remove extension for delete
      *(end= path + path_length - reg_ext_length)= '\0';
2022
      error= ha_delete_table(thd, table_type, path, db, table->table_name,
2023
                             !dont_log_query);
2024
      if ((error == ENOENT || error == HA_ERR_NO_SUCH_TABLE) && 
2025
	  (if_exists || table_type == NULL))
2026
      {
2027
	error= 0;
2028 2029
        thd->clear_error();
      }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2030
      if (error == HA_ERR_ROW_IS_REFERENCED)
monty@mysql.com's avatar
monty@mysql.com committed
2031 2032
      {
	/* the table is referenced by a foreign key constraint */
2033
	foreign_key_error=1;
monty@mysql.com's avatar
monty@mysql.com committed
2034
      }
2035
      if (!error || error == ENOENT || error == HA_ERR_NO_SUCH_TABLE)
2036
      {
2037
        int new_error;
2038 2039
	/* Delete the table definition file */
	strmov(end,reg_ext);
2040
	if (!(new_error=my_delete(path,MYF(MY_WME))))
2041
        {
2042
	  some_tables_deleted=1;
2043 2044
          new_error= Table_triggers_list::drop_all_triggers(thd, db,
                                                            table->table_name);
2045
        }
2046
        error|= new_error;
2047
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2048 2049 2050 2051 2052
    }
    if (error)
    {
      if (wrong_tables.length())
	wrong_tables.append(',');
2053
      wrong_tables.append(String(table->table_name,system_charset_info));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2054
    }
2055 2056
    DBUG_PRINT("table", ("table: 0x%lx  s: 0x%lx", (long) table->table,
                         table->table ? (long) table->table->s : (long) -1));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2057
  }
2058 2059 2060 2061 2062
  /*
    It's safe to unlock LOCK_open: we have an exclusive lock
    on the table name.
  */
  pthread_mutex_unlock(&LOCK_open);
2063
  thd->thread_specific_used|= tmp_table_deleted;
2064 2065 2066 2067
  error= 0;
  if (wrong_tables.length())
  {
    if (!foreign_key_error)
2068
      my_printf_error(ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR), MYF(0),
2069
                      wrong_tables.c_ptr());
2070
    else
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2071
      my_message(ER_ROW_IS_REFERENCED, ER(ER_ROW_IS_REFERENCED), MYF(0));
2072 2073 2074 2075
    error= 1;
  }

  if (some_tables_deleted || tmp_table_deleted || !error)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2076
  {
2077
    query_cache_invalidate3(thd, tables, 0);
2078
    if (!dont_log_query)
2079
    {
2080
      if (!thd->current_stmt_binlog_row_based ||
Staale Smedseng's avatar
Staale Smedseng committed
2081
          (non_temp_tables_count > 0 && !tmp_table_deleted))
2082 2083 2084 2085 2086 2087 2088 2089 2090 2091
      {
        /*
          In this case, we are either using statement-based
          replication or using row-based replication but have only
          deleted one or more non-temporary tables (and no temporary
          tables).  In this case, we can write the original query into
          the binary log.
         */
        write_bin_log(thd, !error, thd->query, thd->query_length);
      }
2092
      else if (thd->current_stmt_binlog_row_based &&
2093 2094
               tmp_table_deleted)
      {
2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114
        if (non_temp_tables_count > 0)
        {
          /*
            In this case we have deleted both temporary and
            non-temporary tables, so:
            - since we have deleted a non-temporary table we have to
              binlog the statement, but
            - since we have deleted a temporary table we cannot binlog
              the statement (since the table may have not been created on the
              slave - check "if" branch below, this might cause the slave to 
              stop).

            Instead, we write a built statement, only containing the
            non-temporary tables, to the binary log
          */
          built_query.chop();                  // Chop of the last comma
          built_query.append(" /* generated by server */");
          write_bin_log(thd, !error, built_query.ptr(), built_query.length());
        }

2115
        /*
2116 2117 2118
          One needs to always log any temporary table drop, if:
            1. thread logging format is mixed mode; AND
            2. current statement logging format is set to row.
2119
        */
2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132
        if (thd->variables.binlog_format == BINLOG_FORMAT_MIXED)
        {
          /*
            In this case we have deleted some temporary tables but we are using
            row based logging for the statement. However, thread uses mixed mode
            format, thence we need to log the dropping as we cannot tell for
            sure whether the create was logged as statement previously or not, ie,
            before switching to row mode.
          */
          built_tmp_query.chop();                  // Chop of the last comma
          built_tmp_query.append(" /* generated by server */");
          write_bin_log(thd, !error, built_tmp_query.ptr(), built_tmp_query.length());
        }
2133
      }
2134

2135 2136
      /*
        The remaining cases are:
2137 2138
        - no tables were deleted and
        - only temporary tables were deleted and row-based
2139 2140 2141 2142
          replication is used.
        In both these cases, nothing should be written to the binary
        log.
      */
2143
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2144
  }
2145 2146
  pthread_mutex_lock(&LOCK_open);
err_with_placeholders:
2147
  unlock_table_names(thd, tables, (TABLE_LIST*) 0);
2148
  pthread_mutex_unlock(&LOCK_open);
2149
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2150 2151 2152
}


2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167
/*
  Quickly remove a table.

  SYNOPSIS
    quick_rm_table()
      base                      The handlerton handle.
      db                        The database name.
      table_name                The table name.
      flags                     flags for build_table_filename().

  RETURN
    0           OK
    != 0        Error
*/

2168
bool quick_rm_table(handlerton *base,const char *db,
2169
                    const char *table_name, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2170
{
2171
  char path[FN_REFLEN + 1];
2172 2173 2174
  bool error= 0;
  DBUG_ENTER("quick_rm_table");

2175
  uint path_length= build_table_filename(path, sizeof(path) - 1,
2176
                                         db, table_name, reg_ext, flags);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2177
  if (my_delete(path,MYF(0)))
2178
    error= 1; /* purecov: inspected */
2179
  path[path_length - reg_ext_length]= '\0'; // Remove reg_ext
2180 2181 2182
  if (!(flags & FRM_ONLY))
    error|= ha_delete_table(current_thd, base, path, db, table_name, 0);
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2183 2184
}

2185 2186 2187
/*
  Sort keys in the following order:
  - PRIMARY KEY
2188 2189
  - UNIQUE keys where all column are NOT NULL
  - UNIQUE keys that don't contain partial segments
2190 2191 2192 2193 2194 2195 2196 2197 2198 2199
  - 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)
{
2200 2201 2202
  ulong a_flags= a->flags, b_flags= b->flags;
  
  if (a_flags & HA_NOSAME)
2203
  {
2204
    if (!(b_flags & HA_NOSAME))
2205
      return -1;
2206
    if ((a_flags ^ b_flags) & (HA_NULL_PART_KEY | HA_END_SPACE_KEY))
2207 2208
    {
      /* Sort NOT NULL keys before other keys */
2209
      return (a_flags & (HA_NULL_PART_KEY | HA_END_SPACE_KEY)) ? 1 : -1;
2210 2211 2212 2213 2214
    }
    if (a->name == primary_key_name)
      return -1;
    if (b->name == primary_key_name)
      return 1;
2215 2216 2217
    /* Sort keys don't containing partial segments before others */
    if ((a_flags ^ b_flags) & HA_KEY_HAS_PART_KEY_SEG)
      return (a_flags & HA_KEY_HAS_PART_KEY_SEG) ? 1 : -1;
2218
  }
2219
  else if (b_flags & HA_NOSAME)
2220 2221
    return 1;					// Prefer b

2222
  if ((a_flags ^ b_flags) & HA_FULLTEXT)
2223
  {
2224
    return (a_flags & HA_FULLTEXT) ? 1 : -1;
2225
  }
2226
  /*
2227
    Prefer original key order.	usable_key_parts contains here
2228 2229 2230 2231 2232
    the original key position.
  */
  return ((a->usable_key_parts < b->usable_key_parts) ? -1 :
	  (a->usable_key_parts > b->usable_key_parts) ? 1 :
	  0);
2233 2234
}

2235 2236
/*
  Check TYPELIB (set or enum) for duplicates
2237

2238 2239 2240
  SYNOPSIS
    check_duplicates_in_interval()
    set_or_name   "SET" or "ENUM" string for warning message
2241 2242
    name	  name of the checked column
    typelib	  list of values for the column
2243
    dup_val_count  returns count of duplicate elements
2244 2245

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

  RETURN VALUES
2250 2251
    0             ok
    1             Error
2252 2253
*/

2254
bool check_duplicates_in_interval(const char *set_or_name,
2255
                                  const char *name, TYPELIB *typelib,
2256
                                  CHARSET_INFO *cs, unsigned int *dup_val_count)
2257
{
2258
  TYPELIB tmp= *typelib;
2259
  const char **cur_value= typelib->type_names;
2260
  unsigned int *cur_length= typelib->type_lengths;
2261
  *dup_val_count= 0;  
2262 2263
  
  for ( ; tmp.count > 1; cur_value++, cur_length++)
2264
  {
2265 2266 2267 2268
    tmp.type_names++;
    tmp.type_lengths++;
    tmp.count--;
    if (find_type2(&tmp, (const char*)*cur_value, *cur_length, cs))
2269
    {
2270 2271 2272 2273 2274 2275 2276
      if ((current_thd->variables.sql_mode &
         (MODE_STRICT_TRANS_TABLES | MODE_STRICT_ALL_TABLES)))
      {
        my_error(ER_DUPLICATED_VALUE_IN_TYPE, MYF(0),
                 name,*cur_value,set_or_name);
        return 1;
      }
monty@mysql.com's avatar
monty@mysql.com committed
2277
      push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_NOTE,
2278 2279 2280
			  ER_DUPLICATED_VALUE_IN_TYPE,
			  ER(ER_DUPLICATED_VALUE_IN_TYPE),
			  name,*cur_value,set_or_name);
2281
      (*dup_val_count)++;
2282 2283
    }
  }
2284
  return 0;
2285
}
2286

2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314

/*
  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++)
  {
2315
    size_t length= cs->cset->numchars(cs, *pos, *pos + *len);
2316 2317 2318 2319 2320 2321
    *tot_length+= length;
    set_if_bigger(*max_length, (uint32)length);
  }
}


2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332
/*
  Prepare a create_table instance for packing

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

  DESCRIPTION
2333
    This function prepares a Create_field instance.
2334 2335 2336 2337 2338 2339 2340
    Fields such as pack_flag are valid after this call.

  RETURN VALUES
   0	ok
   1	Error
*/

2341
int prepare_create_field(Create_field *sql_field, 
monty@mysql.com's avatar
monty@mysql.com committed
2342 2343
			 uint *blob_columns, 
			 int *timestamps, int *timestamps_with_niladic,
2344
			 longlong table_flags)
2345
{
2346
  unsigned int dup_val_count;
2347
  DBUG_ENTER("prepare_field");
monty@mysql.com's avatar
monty@mysql.com committed
2348 2349

  /*
2350
    This code came from mysql_prepare_create_table.
monty@mysql.com's avatar
monty@mysql.com committed
2351 2352 2353 2354 2355
    Indent preserved to make patching easier
  */
  DBUG_ASSERT(sql_field->charset);

  switch (sql_field->sql_type) {
2356 2357 2358 2359
  case MYSQL_TYPE_BLOB:
  case MYSQL_TYPE_MEDIUM_BLOB:
  case MYSQL_TYPE_TINY_BLOB:
  case MYSQL_TYPE_LONG_BLOB:
monty@mysql.com's avatar
monty@mysql.com committed
2360 2361 2362 2363 2364 2365 2366
    sql_field->pack_flag=FIELDFLAG_BLOB |
      pack_length_to_packflag(sql_field->pack_length -
                              portable_sizeof_char_ptr);
    if (sql_field->charset->state & MY_CS_BINSORT)
      sql_field->pack_flag|=FIELDFLAG_BINARY;
    sql_field->length=8;			// Unireg field length
    sql_field->unireg_check=Field::BLOB_FIELD;
2367
    (*blob_columns)++;
monty@mysql.com's avatar
monty@mysql.com committed
2368
    break;
2369
  case MYSQL_TYPE_GEOMETRY:
2370
#ifdef HAVE_SPATIAL
monty@mysql.com's avatar
monty@mysql.com committed
2371 2372 2373 2374
    if (!(table_flags & HA_CAN_GEOMETRY))
    {
      my_printf_error(ER_CHECK_NOT_IMPLEMENTED, ER(ER_CHECK_NOT_IMPLEMENTED),
                      MYF(0), "GEOMETRY");
2375
      DBUG_RETURN(1);
monty@mysql.com's avatar
monty@mysql.com committed
2376 2377 2378 2379 2380 2381 2382 2383
    }
    sql_field->pack_flag=FIELDFLAG_GEOM |
      pack_length_to_packflag(sql_field->pack_length -
                              portable_sizeof_char_ptr);
    if (sql_field->charset->state & MY_CS_BINSORT)
      sql_field->pack_flag|=FIELDFLAG_BINARY;
    sql_field->length=8;			// Unireg field length
    sql_field->unireg_check=Field::BLOB_FIELD;
2384
    (*blob_columns)++;
monty@mysql.com's avatar
monty@mysql.com committed
2385 2386 2387 2388 2389
    break;
#else
    my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED), MYF(0),
                    sym_group_geom.name, sym_group_geom.needed_define);
    DBUG_RETURN(1);
2390
#endif /*HAVE_SPATIAL*/
monty@mysql.com's avatar
monty@mysql.com committed
2391
  case MYSQL_TYPE_VARCHAR:
2392
#ifndef QQ_ALL_HANDLERS_SUPPORT_VARCHAR
monty@mysql.com's avatar
monty@mysql.com committed
2393 2394 2395 2396 2397 2398 2399 2400
    if (table_flags & HA_NO_VARCHAR)
    {
      /* convert VARCHAR to CHAR because handler is not yet up to date */
      sql_field->sql_type=    MYSQL_TYPE_VAR_STRING;
      sql_field->pack_length= calc_pack_length(sql_field->sql_type,
                                               (uint) sql_field->length);
      if ((sql_field->length / sql_field->charset->mbmaxlen) >
          MAX_FIELD_CHARLENGTH)
2401
      {
monty@mysql.com's avatar
monty@mysql.com committed
2402 2403
        my_printf_error(ER_TOO_BIG_FIELDLENGTH, ER(ER_TOO_BIG_FIELDLENGTH),
                        MYF(0), sql_field->field_name, MAX_FIELD_CHARLENGTH);
2404 2405
        DBUG_RETURN(1);
      }
monty@mysql.com's avatar
monty@mysql.com committed
2406 2407 2408
    }
#endif
    /* fall through */
2409
  case MYSQL_TYPE_STRING:
monty@mysql.com's avatar
monty@mysql.com committed
2410 2411 2412 2413
    sql_field->pack_flag=0;
    if (sql_field->charset->state & MY_CS_BINSORT)
      sql_field->pack_flag|=FIELDFLAG_BINARY;
    break;
2414
  case MYSQL_TYPE_ENUM:
monty@mysql.com's avatar
monty@mysql.com committed
2415 2416 2417 2418 2419
    sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
      FIELDFLAG_INTERVAL;
    if (sql_field->charset->state & MY_CS_BINSORT)
      sql_field->pack_flag|=FIELDFLAG_BINARY;
    sql_field->unireg_check=Field::INTERVAL_FIELD;
2420 2421 2422 2423
    if (check_duplicates_in_interval("ENUM",sql_field->field_name,
                                     sql_field->interval,
                                     sql_field->charset, &dup_val_count))
      DBUG_RETURN(1);
monty@mysql.com's avatar
monty@mysql.com committed
2424
    break;
2425
  case MYSQL_TYPE_SET:
monty@mysql.com's avatar
monty@mysql.com committed
2426 2427 2428 2429 2430
    sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
      FIELDFLAG_BITFIELD;
    if (sql_field->charset->state & MY_CS_BINSORT)
      sql_field->pack_flag|=FIELDFLAG_BINARY;
    sql_field->unireg_check=Field::BIT_FIELD;
2431 2432 2433 2434
    if (check_duplicates_in_interval("SET",sql_field->field_name,
                                     sql_field->interval,
                                     sql_field->charset, &dup_val_count))
      DBUG_RETURN(1);
2435 2436 2437 2438 2439 2440
    /* Check that count of unique members is not more then 64 */
    if (sql_field->interval->count -  dup_val_count > sizeof(longlong)*8)
    {
       my_error(ER_TOO_BIG_SET, MYF(0), sql_field->field_name);
       DBUG_RETURN(1);
    }
monty@mysql.com's avatar
monty@mysql.com committed
2441
    break;
2442 2443 2444 2445 2446
  case MYSQL_TYPE_DATE:			// Rest of string types
  case MYSQL_TYPE_NEWDATE:
  case MYSQL_TYPE_TIME:
  case MYSQL_TYPE_DATETIME:
  case MYSQL_TYPE_NULL:
monty@mysql.com's avatar
monty@mysql.com committed
2447 2448
    sql_field->pack_flag=f_settype((uint) sql_field->sql_type);
    break;
2449
  case MYSQL_TYPE_BIT:
ramil@mysql.com's avatar
ramil@mysql.com committed
2450
    /* 
2451 2452
      We have sql_field->pack_flag already set here, see
      mysql_prepare_create_table().
ramil@mysql.com's avatar
ramil@mysql.com committed
2453
    */
monty@mysql.com's avatar
monty@mysql.com committed
2454
    break;
2455
  case MYSQL_TYPE_NEWDECIMAL:
monty@mysql.com's avatar
monty@mysql.com committed
2456 2457 2458 2459 2460 2461 2462
    sql_field->pack_flag=(FIELDFLAG_NUMBER |
                          (sql_field->flags & UNSIGNED_FLAG ? 0 :
                           FIELDFLAG_DECIMAL) |
                          (sql_field->flags & ZEROFILL_FLAG ?
                           FIELDFLAG_ZEROFILL : 0) |
                          (sql_field->decimals << FIELDFLAG_DEC_SHIFT));
    break;
2463
  case MYSQL_TYPE_TIMESTAMP:
monty@mysql.com's avatar
monty@mysql.com committed
2464 2465 2466
    /* We should replace old TIMESTAMP fields with their newer analogs */
    if (sql_field->unireg_check == Field::TIMESTAMP_OLD_FIELD)
    {
2467
      if (!*timestamps)
2468
      {
monty@mysql.com's avatar
monty@mysql.com committed
2469
        sql_field->unireg_check= Field::TIMESTAMP_DNUN_FIELD;
2470
        (*timestamps_with_niladic)++;
2471
      }
monty@mysql.com's avatar
monty@mysql.com committed
2472 2473 2474 2475
      else
        sql_field->unireg_check= Field::NONE;
    }
    else if (sql_field->unireg_check != Field::NONE)
2476
      (*timestamps_with_niladic)++;
monty@mysql.com's avatar
monty@mysql.com committed
2477

2478
    (*timestamps)++;
monty@mysql.com's avatar
monty@mysql.com committed
2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493
    /* fall-through */
  default:
    sql_field->pack_flag=(FIELDFLAG_NUMBER |
                          (sql_field->flags & UNSIGNED_FLAG ? 0 :
                           FIELDFLAG_DECIMAL) |
                          (sql_field->flags & ZEROFILL_FLAG ?
                           FIELDFLAG_ZEROFILL : 0) |
                          f_settype((uint) sql_field->sql_type) |
                          (sql_field->decimals << FIELDFLAG_DEC_SHIFT));
    break;
  }
  if (!(sql_field->flags & NOT_NULL_FLAG))
    sql_field->pack_flag|= FIELDFLAG_MAYBE_NULL;
  if (sql_field->flags & NO_DEFAULT_VALUE_FLAG)
    sql_field->pack_flag|= FIELDFLAG_NO_DEFAULT;
2494 2495 2496
  DBUG_RETURN(0);
}

2497
/*
2498
  Preparation for table creation
2499 2500

  SYNOPSIS
2501
    mysql_prepare_create_table()
2502 2503
      thd                       Thread object.
      create_info               Create information (like MAX_ROWS).
2504
      alter_info                List of columns and indexes to create
2505 2506 2507 2508 2509 2510
      tmp_table                 If a temporary table is to be created.
      db_options          INOUT Table options (like HA_OPTION_PACK_RECORD).
      file                      The handler for the new table.
      key_info_buffer     OUT   An array of KEY structs for the indexes.
      key_count           OUT   The number of elements in the array.
      select_field_count        The number of fields coming from a select table.
2511

2512
  DESCRIPTION
2513
    Prepares the table and key structures for table creation.
2514

2515
  NOTES
2516
    sets create_info->varchar if the table has a varchar
2517

2518
  RETURN VALUES
2519 2520
    FALSE    OK
    TRUE     error
2521
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2522

2523
static int
2524 2525 2526 2527 2528 2529
mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
                           Alter_info *alter_info,
                           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
2530
{
2531
  const char	*key_name;
2532
  Create_field	*sql_field,*dup_field;
monty@mysql.com's avatar
monty@mysql.com committed
2533
  uint		field,null_fields,blob_columns,max_key_length;
monty@mysql.com's avatar
monty@mysql.com committed
2534
  ulong		record_offset= 0;
2535
  KEY		*key_info;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2536
  KEY_PART_INFO *key_part_info;
2537 2538 2539
  int		timestamps= 0, timestamps_with_niladic= 0;
  int		field_no,dup_no;
  int		select_field_pos,auto_increment=0;
2540 2541
  List_iterator<Create_field> it(alter_info->create_list);
  List_iterator<Create_field> it2(alter_info->create_list);
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
2542
  uint total_uneven_bit_length= 0;
2543
  DBUG_ENTER("mysql_prepare_create_table");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2544

2545
  select_field_pos= alter_info->create_list.elements - select_field_count;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2546
  null_fields=blob_columns=0;
2547
  create_info->varchar= 0;
monty@mysql.com's avatar
monty@mysql.com committed
2548
  max_key_length= file->max_key_length();
2549

2550
  for (field_no=0; (sql_field=it++) ; field_no++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2551
  {
2552 2553
    CHARSET_INFO *save_cs;

2554 2555 2556 2557 2558 2559
    /*
      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;
2560
    if (!sql_field->charset)
2561 2562 2563
      sql_field->charset= create_info->default_table_charset;
    /*
      table_charset is set in ALTER TABLE if we want change character set
2564 2565 2566
      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.
2567
    */
2568
    if (create_info->table_charset && sql_field->charset != &my_charset_bin)
2569
      sql_field->charset= create_info->table_charset;
2570

2571
    save_cs= sql_field->charset;
2572 2573 2574 2575 2576
    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];
2577 2578
      strmake(strmake(tmp, save_cs->csname, sizeof(tmp)-4),
              STRING_WITH_LEN("_bin"));
2579
      my_error(ER_UNKNOWN_COLLATION, MYF(0), tmp);
2580
      DBUG_RETURN(TRUE);
2581
    }
2582

2583
    /*
2584
      Convert the default value from client character
2585 2586 2587
      set into the column character set if necessary.
    */
    if (sql_field->def && 
2588
        save_cs != sql_field->def->collation.collation &&
2589 2590 2591 2592
        (sql_field->sql_type == MYSQL_TYPE_VAR_STRING ||
         sql_field->sql_type == MYSQL_TYPE_STRING ||
         sql_field->sql_type == MYSQL_TYPE_SET ||
         sql_field->sql_type == MYSQL_TYPE_ENUM))
2593
    {
2594
      /*
2595
        Starting from 5.1 we work here with a copy of Create_field
2596 2597 2598 2599 2600 2601 2602 2603
        created by the caller, not with the instance that was
        originally created during parsing. It's OK to create
        a temporary item and initialize with it a member of the
        copy -- this item will be thrown away along with the copy
        at the end of execution, and thus not introduce a dangling
        pointer in the parsed tree of a prepared statement or a
        stored procedure statement.
      */
2604
      sql_field->def= sql_field->def->safe_charset_converter(save_cs);
2605 2606 2607 2608 2609

      if (sql_field->def == NULL)
      {
        /* Could not convert */
        my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
2610
        DBUG_RETURN(TRUE);
2611 2612 2613
      }
    }

2614 2615
    if (sql_field->sql_type == MYSQL_TYPE_SET ||
        sql_field->sql_type == MYSQL_TYPE_ENUM)
2616 2617 2618
    {
      uint32 dummy;
      CHARSET_INFO *cs= sql_field->charset;
2619
      TYPELIB *interval= sql_field->interval;
2620 2621 2622 2623 2624 2625

      /*
        Create typelib from interval_list, and if necessary
        convert strings from client character set to the
        column character set.
      */
2626
      if (!interval)
2627
      {
2628
        /*
2629 2630 2631
          Create the typelib in runtime memory - we will free the
          occupied memory at the same time when we free this
          sql_field -- at the end of execution.
2632
        */
2633
        interval= sql_field->interval= typelib(thd->mem_root,
2634
                                               sql_field->interval_list);
2635
        List_iterator<String> int_it(sql_field->interval_list);
2636
        String conv, *tmp;
2637 2638 2639 2640 2641
        char comma_buf[2];
        int comma_length= cs->cset->wc_mb(cs, ',', (uchar*) comma_buf,
                                          (uchar*) comma_buf + 
                                          sizeof(comma_buf));
        DBUG_ASSERT(comma_length > 0);
2642
        for (uint i= 0; (tmp= int_it++); i++)
2643
        {
2644
          size_t lengthsp;
2645 2646 2647 2648 2649
          if (String::needs_conversion(tmp->length(), tmp->charset(),
                                       cs, &dummy))
          {
            uint cnv_errs;
            conv.copy(tmp->ptr(), tmp->length(), tmp->charset(), cs, &cnv_errs);
2650
            interval->type_names[i]= strmake_root(thd->mem_root, conv.ptr(),
2651
                                                  conv.length());
2652 2653
            interval->type_lengths[i]= conv.length();
          }
2654

2655
          // Strip trailing spaces.
2656 2657
          lengthsp= cs->cset->lengthsp(cs, interval->type_names[i],
                                       interval->type_lengths[i]);
2658 2659
          interval->type_lengths[i]= lengthsp;
          ((uchar *)interval->type_names[i])[lengthsp]= '\0';
2660
          if (sql_field->sql_type == MYSQL_TYPE_SET)
2661 2662 2663 2664 2665
          {
            if (cs->coll->instr(cs, interval->type_names[i], 
                                interval->type_lengths[i], 
                                comma_buf, comma_length, NULL, 0))
            {
2666
              my_error(ER_ILLEGAL_VALUE_FOR_TYPE, MYF(0), "set", tmp->ptr());
2667
              DBUG_RETURN(TRUE);
2668 2669
            }
          }
2670
        }
2671
        sql_field->interval_list.empty(); // Don't need interval_list anymore
2672 2673
      }

2674
      if (sql_field->sql_type == MYSQL_TYPE_SET)
2675
      {
2676
        uint32 field_length;
2677
        if (sql_field->def != NULL)
2678 2679 2680 2681 2682
        {
          char *not_used;
          uint not_used2;
          bool not_found= 0;
          String str, *def= sql_field->def->val_str(&str);
2683 2684 2685 2686 2687
          if (def == NULL) /* SQL "NULL" maps to NULL */
          {
            if ((sql_field->flags & NOT_NULL_FLAG) != 0)
            {
              my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
2688
              DBUG_RETURN(TRUE);
2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700
            }

            /* else, NULL is an allowed value */
            (void) find_set(interval, NULL, 0,
                            cs, &not_used, &not_used2, &not_found);
          }
          else /* not NULL */
          {
            (void) find_set(interval, def->ptr(), def->length(),
                            cs, &not_used, &not_used2, &not_found);
          }

2701 2702 2703
          if (not_found)
          {
            my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
2704
            DBUG_RETURN(TRUE);
2705 2706
          }
        }
2707 2708
        calculate_interval_lengths(cs, interval, &dummy, &field_length);
        sql_field->length= field_length + (interval->count - 1);
2709
      }
2710
      else  /* MYSQL_TYPE_ENUM */
2711
      {
2712
        uint32 field_length;
2713
        DBUG_ASSERT(sql_field->sql_type == MYSQL_TYPE_ENUM);
2714
        if (sql_field->def != NULL)
2715 2716
        {
          String str, *def= sql_field->def->val_str(&str);
2717
          if (def == NULL) /* SQL "NULL" maps to NULL */
2718
          {
2719 2720 2721
            if ((sql_field->flags & NOT_NULL_FLAG) != 0)
            {
              my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
2722
              DBUG_RETURN(TRUE);
2723 2724 2725 2726 2727 2728 2729 2730 2731 2732
            }

            /* else, the defaults yield the correct length for NULLs. */
          } 
          else /* not NULL */
          {
            def->length(cs->cset->lengthsp(cs, def->ptr(), def->length()));
            if (find_type2(interval, def->ptr(), def->length(), cs) == 0) /* not found */
            {
              my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
2733
              DBUG_RETURN(TRUE);
2734
            }
2735 2736
          }
        }
2737 2738
        calculate_interval_lengths(cs, interval, &field_length, &dummy);
        sql_field->length= field_length;
2739 2740 2741 2742
      }
      set_if_smaller(sql_field->length, MAX_FIELD_WIDTH-1);
    }

2743
    if (sql_field->sql_type == MYSQL_TYPE_BIT)
2744
    { 
ramil@mysql.com's avatar
ramil@mysql.com committed
2745
      sql_field->pack_flag= FIELDFLAG_NUMBER;
2746
      if (file->ha_table_flags() & HA_CAN_BIT_FIELD)
2747 2748 2749 2750 2751
        total_uneven_bit_length+= sql_field->length & 7;
      else
        sql_field->pack_flag|= FIELDFLAG_TREAT_BIT_AS_CHAR;
    }

2752
    sql_field->create_length_to_internal_length();
2753
    if (prepare_blob_field(thd, sql_field))
2754
      DBUG_RETURN(TRUE);
2755

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2756 2757
    if (!(sql_field->flags & NOT_NULL_FLAG))
      null_fields++;
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
2758

2759 2760
    if (check_column_name(sql_field->field_name))
    {
2761
      my_error(ER_WRONG_COLUMN_NAME, MYF(0), sql_field->field_name);
2762
      DBUG_RETURN(TRUE);
2763
    }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2764

2765 2766
    /* 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
2767
    {
2768
      if (my_strcasecmp(system_charset_info,
2769 2770
			sql_field->field_name,
			dup_field->field_name) == 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2771
      {
2772 2773 2774 2775
	/*
	  If this was a CREATE ... SELECT statement, accept a field
	  redefinition if we are changing a field in the SELECT part
	*/
2776 2777
	if (field_no < select_field_pos || dup_no >= select_field_pos)
	{
2778
	  my_error(ER_DUP_FIELDNAME, MYF(0), sql_field->field_name);
2779
	  DBUG_RETURN(TRUE);
2780 2781 2782
	}
	else
	{
2783
	  /* Field redefined */
2784
	  sql_field->def=		dup_field->def;
2785
	  sql_field->sql_type=		dup_field->sql_type;
2786 2787 2788
	  sql_field->charset=		(dup_field->charset ?
					 dup_field->charset :
					 create_info->default_table_charset);
2789
	  sql_field->length=		dup_field->char_length;
2790
          sql_field->pack_length=	dup_field->pack_length;
2791
          sql_field->key_length=	dup_field->key_length;
2792
	  sql_field->decimals=		dup_field->decimals;
2793
	  sql_field->create_length_to_internal_length();
2794
	  sql_field->unireg_check=	dup_field->unireg_check;
2795 2796 2797 2798 2799 2800 2801 2802
          /* 
            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
2803
          sql_field->interval=          dup_field->interval;
2804 2805 2806
	  it2.remove();			// Remove first (create) definition
	  select_field_pos--;
	  break;
2807
	}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2808 2809
      }
    }
2810 2811
    /* Don't pack rows in old tables if the user has requested this */
    if ((sql_field->flags & BLOB_FLAG) ||
Staale Smedseng's avatar
Staale Smedseng committed
2812 2813
	(sql_field->sql_type == MYSQL_TYPE_VARCHAR &&
	create_info->row_type != ROW_TYPE_FIXED))
2814
      (*db_options)|= HA_OPTION_PACK_RECORD;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2815 2816
    it2.rewind();
  }
2817 2818 2819

  /* record_offset will be increased with 'length-of-null-bits' later */
  record_offset= 0;
monty@mysql.com's avatar
monty@mysql.com committed
2820
  null_fields+= total_uneven_bit_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2821 2822 2823 2824

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

monty@mysql.com's avatar
monty@mysql.com committed
2827 2828
    if (prepare_create_field(sql_field, &blob_columns, 
			     &timestamps, &timestamps_with_niladic,
2829
			     file->ha_table_flags()))
2830
      DBUG_RETURN(TRUE);
2831
    if (sql_field->sql_type == MYSQL_TYPE_VARCHAR)
2832
      create_info->varchar= TRUE;
2833
    sql_field->offset= record_offset;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2834 2835
    if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
      auto_increment++;
2836
    record_offset+= sql_field->pack_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2837
  }
2838 2839
  if (timestamps_with_niladic > 1)
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2840 2841
    my_message(ER_TOO_MUCH_AUTO_TIMESTAMP_COLS,
               ER(ER_TOO_MUCH_AUTO_TIMESTAMP_COLS), MYF(0));
2842
    DBUG_RETURN(TRUE);
2843
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2844 2845
  if (auto_increment > 1)
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2846
    my_message(ER_WRONG_AUTO_KEY, ER(ER_WRONG_AUTO_KEY), MYF(0));
2847
    DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2848 2849
  }
  if (auto_increment &&
2850
      (file->ha_table_flags() & HA_NO_AUTO_INCREMENT))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2851
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2852 2853
    my_message(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT,
               ER(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT), MYF(0));
2854
    DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2855 2856
  }

2857
  if (blob_columns && (file->ha_table_flags() & HA_NO_BLOBS))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2858
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2859 2860
    my_message(ER_TABLE_CANT_HANDLE_BLOB, ER(ER_TABLE_CANT_HANDLE_BLOB),
               MYF(0));
2861
    DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2862 2863 2864
  }

  /* Create keys */
2865

2866 2867
  List_iterator<Key> key_iterator(alter_info->key_list);
  List_iterator<Key> key_iterator2(alter_info->key_list);
2868
  uint key_parts=0, fk_key_count=0;
2869
  bool primary_key=0,unique_key=0;
2870
  Key *key, *key2;
2871
  uint tmp, key_number;
2872 2873
  /* special marker for keys to be ignored */
  static char ignore_key[1];
2874

2875
  /* Calculate number of key segements */
2876
  *key_count= 0;
2877

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2878 2879
  while ((key=key_iterator++))
  {
2880 2881
    DBUG_PRINT("info", ("key name: '%s'  type: %d", key->name ? key->name :
                        "(none)" , key->type));
2882
    LEX_STRING key_name_str;
2883 2884 2885
    if (key->type == Key::FOREIGN_KEY)
    {
      fk_key_count++;
2886
      Foreign_key *fk_key= (Foreign_key*) key;
2887 2888 2889
      if (fk_key->ref_columns.elements &&
	  fk_key->ref_columns.elements != fk_key->columns.elements)
      {
2890 2891 2892
        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));
2893
	DBUG_RETURN(TRUE);
2894 2895 2896
      }
      continue;
    }
2897
    (*key_count)++;
2898
    tmp=file->max_key_parts();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2899 2900 2901
    if (key->columns.elements > tmp)
    {
      my_error(ER_TOO_MANY_KEY_PARTS,MYF(0),tmp);
2902
      DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2903
    }
2904 2905 2906 2907
    key_name_str.str= (char*) key->name;
    key_name_str.length= key->name ? strlen(key->name) : 0;
    if (check_string_char_length(&key_name_str, "", NAME_CHAR_LEN,
                                 system_charset_info, 1))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2908
    {
2909
      my_error(ER_TOO_LONG_IDENT, MYF(0), key->name);
2910
      DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2911
    }
2912
    key_iterator2.rewind ();
2913
    if (key->type != Key::FOREIGN_KEY)
2914
    {
2915
      while ((key2 = key_iterator2++) != key)
2916
      {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2917
	/*
2918 2919 2920
          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
2921
        */
2922 2923 2924
        if ((key2->type != Key::FOREIGN_KEY &&
             key2->name != ignore_key &&
             !foreign_key_prefix(key, key2)))
2925
        {
2926
          /* TODO: issue warning message */
2927 2928 2929 2930 2931 2932 2933
          /* mark that the generated key should be ignored */
          if (!key2->generated ||
              (key->generated && key->columns.elements <
               key2->columns.elements))
            key->name= ignore_key;
          else
          {
2934 2935 2936
            key2->name= ignore_key;
            key_parts-= key2->columns.elements;
            (*key_count)--;
2937 2938 2939
          }
          break;
        }
2940 2941 2942 2943 2944 2945
      }
    }
    if (key->name != ignore_key)
      key_parts+=key->columns.elements;
    else
      (*key_count)--;
2946
    if (key->name && !tmp_table && (key->type != Key::PRIMARY) &&
2947 2948 2949
	!my_strcasecmp(system_charset_info,key->name,primary_key_name))
    {
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name);
2950
      DBUG_RETURN(TRUE);
2951
    }
2952
  }
2953
  tmp=file->max_keys();
2954
  if (*key_count > tmp)
2955 2956
  {
    my_error(ER_TOO_MANY_KEYS,MYF(0),tmp);
2957
    DBUG_RETURN(TRUE);
2958
  }
2959

2960
  (*key_info_buffer)= key_info= (KEY*) sql_calloc(sizeof(KEY) * (*key_count));
2961
  key_part_info=(KEY_PART_INFO*) sql_calloc(sizeof(KEY_PART_INFO)*key_parts);
2962
  if (!*key_info_buffer || ! key_part_info)
2963
    DBUG_RETURN(TRUE);				// Out of memory
2964

2965
  key_iterator.rewind();
2966
  key_number=0;
2967
  for (; (key=key_iterator++) ; key_number++)
2968 2969
  {
    uint key_length=0;
2970
    Key_part_spec *column;
2971

2972 2973 2974 2975 2976 2977 2978 2979 2980 2981
    if (key->name == ignore_key)
    {
      /* ignore redundant keys */
      do
	key=key_iterator++;
      while (key && key->name == ignore_key);
      if (!key)
	break;
    }

2982
    switch (key->type) {
2983
    case Key::MULTIPLE:
2984
	key_info->flags= 0;
2985
	break;
2986
    case Key::FULLTEXT:
2987
	key_info->flags= HA_FULLTEXT;
2988
	if ((key_info->parser_name= &key->key_create_info.parser_name)->str)
2989
          key_info->flags|= HA_USES_PARSER;
2990 2991
        else
          key_info->parser_name= 0;
2992
	break;
2993
    case Key::SPATIAL:
hf@deer.(none)'s avatar
hf@deer.(none) committed
2994
#ifdef HAVE_SPATIAL
2995
	key_info->flags= HA_SPATIAL;
2996
	break;
hf@deer.(none)'s avatar
hf@deer.(none) committed
2997
#else
2998 2999
	my_error(ER_FEATURE_DISABLED, MYF(0),
                 sym_group_geom.name, sym_group_geom.needed_define);
3000
	DBUG_RETURN(TRUE);
hf@deer.(none)'s avatar
hf@deer.(none) committed
3001
#endif
3002 3003 3004 3005
    case Key::FOREIGN_KEY:
      key_number--;				// Skip this key
      continue;
    default:
3006 3007
      key_info->flags = HA_NOSAME;
      break;
3008
    }
3009 3010
    if (key->generated)
      key_info->flags|= HA_GENERATED_KEY;
3011

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3012 3013
    key_info->key_parts=(uint8) key->columns.elements;
    key_info->key_part=key_part_info;
3014
    key_info->usable_key_parts= key_number;
3015
    key_info->algorithm= key->key_create_info.algorithm;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3016

3017 3018
    if (key->type == Key::FULLTEXT)
    {
3019
      if (!(file->ha_table_flags() & HA_CAN_FULLTEXT))
3020
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3021 3022
	my_message(ER_TABLE_CANT_HANDLE_FT, ER(ER_TABLE_CANT_HANDLE_FT),
                   MYF(0));
3023
	DBUG_RETURN(TRUE);
3024 3025
      }
    }
3026 3027 3028
    /*
       Make SPATIAL to be RTREE by default
       SPATIAL only on BLOB or at least BINARY, this
3029
       actually should be replaced by special GEOM type
3030 3031 3032
       in near future when new frm file is ready
       checking for proper key parts number:
    */
3033

3034
    /* TODO: Add proper checks if handler supports key_type and algorithm */
3035
    if (key_info->flags & HA_SPATIAL)
3036
    {
3037
      if (!(file->ha_table_flags() & HA_CAN_RTREEKEYS))
3038 3039 3040
      {
        my_message(ER_TABLE_CANT_HANDLE_SPKEYS, ER(ER_TABLE_CANT_HANDLE_SPKEYS),
                   MYF(0));
3041
        DBUG_RETURN(TRUE);
3042
      }
3043 3044
      if (key_info->key_parts != 1)
      {
3045
	my_error(ER_WRONG_ARGUMENTS, MYF(0), "SPATIAL INDEX");
3046
	DBUG_RETURN(TRUE);
3047
      }
3048
    }
3049
    else if (key_info->algorithm == HA_KEY_ALG_RTREE)
3050
    {
hf@deer.(none)'s avatar
hf@deer.(none) committed
3051
#ifdef HAVE_RTREE_KEYS
3052 3053
      if ((key_info->key_parts & 1) == 1)
      {
3054
	my_error(ER_WRONG_ARGUMENTS, MYF(0), "RTREE INDEX");
3055
	DBUG_RETURN(TRUE);
3056
      }
3057
      /* TODO: To be deleted */
3058
      my_error(ER_NOT_SUPPORTED_YET, MYF(0), "RTREE INDEX");
3059
      DBUG_RETURN(TRUE);
hf@deer.(none)'s avatar
hf@deer.(none) committed
3060
#else
3061 3062
      my_error(ER_FEATURE_DISABLED, MYF(0),
               sym_group_rtree.name, sym_group_rtree.needed_define);
3063
      DBUG_RETURN(TRUE);
hf@deer.(none)'s avatar
hf@deer.(none) committed
3064
#endif
3065
    }
3066

3067 3068 3069 3070 3071
    /* Take block size from key part or table part */
    /*
      TODO: Add warning if block size changes. We can't do it here, as
      this may depend on the size of the key
    */
3072 3073
    key_info->block_size= (key->key_create_info.block_size ?
                           key->key_create_info.block_size :
3074 3075 3076 3077 3078
                           create_info->key_block_size);

    if (key_info->block_size)
      key_info->flags|= HA_USES_BLOCK_SIZE;

3079
    List_iterator<Key_part_spec> cols(key->columns), cols2(key->columns);
3080
    CHARSET_INFO *ft_key_charset=0;  // for FULLTEXT
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3081 3082
    for (uint column_nr=0 ; (column=cols++) ; column_nr++)
    {
3083
      uint length;
3084
      Key_part_spec *dup_column;
3085

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3086 3087 3088
      it.rewind();
      field=0;
      while ((sql_field=it++) &&
3089
	     my_strcasecmp(system_charset_info,
3090 3091
			   column->field_name,
			   sql_field->field_name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3092 3093 3094
	field++;
      if (!sql_field)
      {
3095
	my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name);
3096
	DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3097
      }
3098
      while ((dup_column= cols2++) != column)
3099 3100 3101 3102 3103 3104 3105
      {
        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);
3106
	  DBUG_RETURN(TRUE);
3107 3108 3109
	}
      }
      cols2.rewind();
3110
      if (key->type == Key::FULLTEXT)
3111
      {
3112 3113
	if ((sql_field->sql_type != MYSQL_TYPE_STRING &&
	     sql_field->sql_type != MYSQL_TYPE_VARCHAR &&
3114 3115
	     !f_is_blob(sql_field->pack_flag)) ||
	    sql_field->charset == &my_charset_bin ||
3116
	    sql_field->charset->mbminlen > 1 || // ucs2 doesn't work yet
3117 3118
	    (ft_key_charset && sql_field->charset != ft_key_charset))
	{
3119
	    my_error(ER_BAD_FT_COLUMN, MYF(0), column->field_name);
3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130
	    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));
3131
      }
3132
      else
3133
      {
3134 3135
	column->length*= sql_field->charset->mbmaxlen;

3136 3137 3138
        if (key->type == Key::SPATIAL && column->length)
        {
          my_error(ER_WRONG_SUB_KEY, MYF(0));
3139
	  DBUG_RETURN(TRUE);
3140 3141
	}

3142 3143
	if (f_is_blob(sql_field->pack_flag) ||
            (f_is_geom(sql_field->pack_flag) && key->type != Key::SPATIAL))
3144
	{
3145
	  if (!(file->ha_table_flags() & HA_CAN_INDEX_BLOBS))
3146
	  {
3147
	    my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name);
3148
	    DBUG_RETURN(TRUE);
3149
	  }
3150 3151
          if (f_is_geom(sql_field->pack_flag) && sql_field->geom_type ==
              Field::GEOM_POINT)
3152
            column->length= 25;
3153 3154
	  if (!column->length)
	  {
3155
	    my_error(ER_BLOB_KEY_WITHOUT_LENGTH, MYF(0), column->field_name);
3156
	    DBUG_RETURN(TRUE);
3157 3158
	  }
	}
hf@deer.(none)'s avatar
hf@deer.(none) committed
3159
#ifdef HAVE_SPATIAL
3160
	if (key->type == Key::SPATIAL)
3161
	{
3162
	  if (!column->length)
3163 3164
	  {
	    /*
3165 3166
              4 is: (Xmin,Xmax,Ymin,Ymax), this is for 2D case
              Lately we'll extend this code to support more dimensions
3167
	    */
3168
	    column->length= 4*sizeof(double);
3169 3170
	  }
	}
hf@deer.(none)'s avatar
hf@deer.(none) committed
3171
#endif
3172 3173 3174 3175 3176 3177 3178
	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
3179
            null_fields--;
3180 3181
	  }
	  else
3182 3183 3184 3185 3186
          {
            key_info->flags|= HA_NULL_PART_KEY;
            if (!(file->ha_table_flags() & HA_NULL_IN_KEY))
            {
              my_error(ER_NULL_COLUMN_IN_INDEX, MYF(0), column->field_name);
3187
              DBUG_RETURN(TRUE);
3188 3189 3190 3191 3192
            }
            if (key->type == Key::SPATIAL)
            {
              my_message(ER_SPATIAL_CANT_HAVE_NULL,
                         ER(ER_SPATIAL_CANT_HAVE_NULL), MYF(0));
3193
              DBUG_RETURN(TRUE);
3194 3195
            }
          }
3196 3197 3198
	}
	if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
	{
3199
	  if (column_nr == 0 || (file->ha_table_flags() & HA_AUTO_PART_KEY))
3200 3201
	    auto_increment--;			// Field is used
	}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3202
      }
3203

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3204 3205 3206
      key_part_info->fieldnr= field;
      key_part_info->offset=  (uint16) sql_field->offset;
      key_part_info->key_type=sql_field->pack_flag;
3207 3208
      length= sql_field->key_length;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3209 3210 3211 3212
      if (column->length)
      {
	if (f_is_blob(sql_field->pack_flag))
	{
monty@mysql.com's avatar
monty@mysql.com committed
3213
	  if ((length=column->length) > max_key_length ||
3214
	      length > file->max_key_part_length())
3215
	  {
monty@mysql.com's avatar
monty@mysql.com committed
3216
	    length=min(max_key_length, file->max_key_part_length());
3217 3218 3219 3220 3221 3222 3223 3224
	    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);
3225 3226
              /* Align key length to multibyte char boundary */
              length-= length % sql_field->charset->mbmaxlen;
3227 3228 3229 3230
	    }
	    else
	    {
	      my_error(ER_TOO_LONG_KEY,MYF(0),length);
3231
	      DBUG_RETURN(TRUE);
3232 3233
	    }
	  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3234
	}
3235
	else if (!f_is_geom(sql_field->pack_flag) &&
3236
		  (column->length > length ||
gkodinov/kgeorge@magare.gmz's avatar
gkodinov/kgeorge@magare.gmz committed
3237
                   !Field::type_can_have_key_part (sql_field->sql_type) ||
3238
		   ((f_is_packed(sql_field->pack_flag) ||
3239
		     ((file->ha_table_flags() & HA_NO_PREFIX_CHAR_KEYS) &&
3240 3241 3242
		      (key_info->flags & HA_NOSAME))) &&
		    column->length != length)))
	{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3243
	  my_message(ER_WRONG_SUB_KEY, ER(ER_WRONG_SUB_KEY), MYF(0));
3244
	  DBUG_RETURN(TRUE);
3245
	}
3246
	else if (!(file->ha_table_flags() & HA_NO_PREFIX_CHAR_KEYS))
3247
	  length=column->length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3248 3249 3250
      }
      else if (length == 0)
      {
3251
	my_error(ER_WRONG_KEY_COLUMN, MYF(0), column->field_name);
3252
	  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3253
      }
3254
      if (length > file->max_key_part_length() && key->type != Key::FULLTEXT)
3255
      {
3256
        length= file->max_key_part_length();
3257 3258 3259 3260 3261 3262 3263 3264
	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);
3265 3266
          /* Align key length to multibyte char boundary */
          length-= length % sql_field->charset->mbmaxlen;
3267 3268 3269 3270
	}
	else
	{
	  my_error(ER_TOO_LONG_KEY,MYF(0),length);
3271
	  DBUG_RETURN(TRUE);
3272
	}
3273 3274
      }
      key_part_info->length=(uint16) length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3275
      /* Use packed keys for long strings on the first column */
3276
      if (!((*db_options) & HA_OPTION_NO_PACK_KEYS) &&
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3277
	  (length >= KEY_DEFAULT_PACK_LENGTH &&
3278 3279
	   (sql_field->sql_type == MYSQL_TYPE_STRING ||
	    sql_field->sql_type == MYSQL_TYPE_VARCHAR ||
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3280 3281
	    sql_field->pack_flag & FIELDFLAG_BLOB)))
      {
Staale Smedseng's avatar
Staale Smedseng committed
3282
	if ((column_nr == 0 && (sql_field->pack_flag & FIELDFLAG_BLOB)) ||
3283 3284
            sql_field->sql_type == MYSQL_TYPE_VARCHAR)
	  key_info->flags|= HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3285 3286 3287
	else
	  key_info->flags|= HA_PACK_KEY;
      }
3288 3289 3290 3291
      /* Check if the key segment is partial, set the key flag accordingly */
      if (length != sql_field->key_length)
        key_info->flags|= HA_KEY_HAS_PART_KEY_SEG;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3292 3293 3294 3295 3296 3297 3298
      key_length+=length;
      key_part_info++;

      /* Create the key name based on the first column (if not given) */
      if (column_nr == 0)
      {
	if (key->type == Key::PRIMARY)
3299 3300 3301
	{
	  if (primary_key)
	  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3302 3303
	    my_message(ER_MULTIPLE_PRI_KEY, ER(ER_MULTIPLE_PRI_KEY),
                       MYF(0));
3304
	    DBUG_RETURN(TRUE);
3305 3306 3307 3308
	  }
	  key_name=primary_key_name;
	  primary_key=1;
	}
3309
	else if (!(key_name = key->name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3310
	  key_name=make_unique_key_name(sql_field->field_name,
3311 3312
					*key_info_buffer, key_info);
	if (check_if_keyname_exists(key_name, *key_info_buffer, key_info))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3313
	{
3314
	  my_error(ER_DUP_KEYNAME, MYF(0), key_name);
3315
	  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3316 3317 3318 3319
	}
	key_info->name=(char*) key_name;
      }
    }
3320 3321
    if (!key_info->name || check_column_name(key_info->name))
    {
3322
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key_info->name);
3323
      DBUG_RETURN(TRUE);
3324
    }
3325 3326
    if (!(key_info->flags & HA_NULL_PART_KEY))
      unique_key=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3327
    key_info->key_length=(uint16) key_length;
3328
    if (key_length > max_key_length && key->type != Key::FULLTEXT)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3329
    {
3330
      my_error(ER_TOO_LONG_KEY,MYF(0),max_key_length);
3331
      DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3332
    }
3333
    key_info++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3334
  }
3335
  if (!unique_key && !primary_key &&
3336
      (file->ha_table_flags() & HA_REQUIRE_PRIMARY_KEY))
3337
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3338
    my_message(ER_REQUIRES_PRIMARY_KEY, ER(ER_REQUIRES_PRIMARY_KEY), MYF(0));
3339
    DBUG_RETURN(TRUE);
3340
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3341 3342
  if (auto_increment > 0)
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3343
    my_message(ER_WRONG_AUTO_KEY, ER(ER_WRONG_AUTO_KEY), MYF(0));
3344
    DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3345
  }
3346
  /* Sort keys in optimized order */
3347 3348
  my_qsort((uchar*) *key_info_buffer, *key_count, sizeof(KEY),
	   (qsort_cmp) sort_keys);
monty@mysql.com's avatar
monty@mysql.com committed
3349
  create_info->null_bits= null_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3350

3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381
  /* Check fields. */
  it.rewind();
  while ((sql_field=it++))
  {
    Field::utype type= (Field::utype) MTYP_TYPENR(sql_field->unireg_check);

    if (thd->variables.sql_mode & MODE_NO_ZERO_DATE &&
        !sql_field->def &&
        sql_field->sql_type == MYSQL_TYPE_TIMESTAMP &&
        (sql_field->flags & NOT_NULL_FLAG) &&
        (type == Field::NONE || type == Field::TIMESTAMP_UN_FIELD))
    {
      /*
        An error should be reported if:
          - NO_ZERO_DATE SQL mode is active;
          - there is no explicit DEFAULT clause (default column value);
          - this is a TIMESTAMP column;
          - the column is not NULL;
          - this is not the DEFAULT CURRENT_TIMESTAMP column.

        In other words, an error should be reported if
          - NO_ZERO_DATE SQL mode is active;
          - the column definition is equivalent to
            'column_name TIMESTAMP DEFAULT 0'.
      */

      my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
      DBUG_RETURN(TRUE);
    }
  }

3382
  DBUG_RETURN(FALSE);
3383 3384
}

3385

3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401
/*
  Set table default charset, if not set

  SYNOPSIS
    set_table_default_charset()
    create_info        Table create information

  DESCRIPTION
    If the table character set was not given explicitely,
    let's fetch the database default character set and
    apply it to the table.
*/

static void set_table_default_charset(THD *thd,
				      HA_CREATE_INFO *create_info, char *db)
{
3402 3403 3404 3405 3406
  /*
    If the table character set was not given explicitly,
    let's fetch the database default character set and
    apply it to the table.
  */
3407 3408 3409
  if (!create_info->default_table_charset)
  {
    HA_CREATE_INFO db_info;
3410 3411 3412

    load_db_opt_by_name(thd, db, &db_info);

3413 3414 3415 3416 3417
    create_info->default_table_charset= db_info.default_table_charset;
  }
}


3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430
/*
  Extend long VARCHAR fields to blob & prepare field if it's a blob

  SYNOPSIS
    prepare_blob_field()
    sql_field		Field to check

  RETURN
    0	ok
    1	Error (sql_field can't be converted to blob)
        In this case the error is given
*/

3431
static bool prepare_blob_field(THD *thd, Create_field *sql_field)
3432 3433 3434 3435 3436 3437 3438 3439 3440
{
  DBUG_ENTER("prepare_blob_field");

  if (sql_field->length > MAX_FIELD_VARCHARLENGTH &&
      !(sql_field->flags & BLOB_FLAG))
  {
    /* Convert long VARCHAR columns to TEXT or BLOB */
    char warn_buff[MYSQL_ERRMSG_SIZE];

3441 3442
    if (sql_field->def || (thd->variables.sql_mode & (MODE_STRICT_TRANS_TABLES |
                                                      MODE_STRICT_ALL_TABLES)))
3443 3444 3445 3446 3447
    {
      my_error(ER_TOO_BIG_FIELDLENGTH, MYF(0), sql_field->field_name,
               MAX_FIELD_VARCHARLENGTH / sql_field->charset->mbmaxlen);
      DBUG_RETURN(1);
    }
3448
    sql_field->sql_type= MYSQL_TYPE_BLOB;
3449
    sql_field->flags|= BLOB_FLAG;
Sergei Golubchik's avatar
Sergei Golubchik committed
3450
    my_snprintf(warn_buff, sizeof(warn_buff), ER(ER_AUTO_CONVERT), sql_field->field_name,
3451
            (sql_field->charset == &my_charset_bin) ? "VARBINARY" : "VARCHAR",
3452 3453 3454 3455
            (sql_field->charset == &my_charset_bin) ? "BLOB" : "TEXT");
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE, ER_AUTO_CONVERT,
                 warn_buff);
  }
3456

3457 3458
  if ((sql_field->flags & BLOB_FLAG) && sql_field->length)
  {
3459 3460 3461
    if (sql_field->sql_type == FIELD_TYPE_BLOB ||
        sql_field->sql_type == FIELD_TYPE_TINY_BLOB ||
        sql_field->sql_type == FIELD_TYPE_MEDIUM_BLOB)
3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472
    {
      /* The user has given a length to the blob column */
      sql_field->sql_type= get_blob_type_from_length(sql_field->length);
      sql_field->pack_length= calc_pack_length(sql_field->sql_type, 0);
    }
    sql_field->length= 0;
  }
  DBUG_RETURN(0);
}


3473
/*
3474
  Preparation of Create_field for SP function return values.
3475 3476
  Based on code used in the inner loop of mysql_prepare_create_table()
  above.
3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487

  SYNOPSIS
    sp_prepare_create_field()
    thd			Thread object
    sql_field		Field to prepare

  DESCRIPTION
    Prepares the field structures for field creation.

*/

3488
void sp_prepare_create_field(THD *thd, Create_field *sql_field)
3489
{
3490 3491
  if (sql_field->sql_type == MYSQL_TYPE_SET ||
      sql_field->sql_type == MYSQL_TYPE_ENUM)
3492 3493
  {
    uint32 field_length, dummy;
3494
    if (sql_field->sql_type == MYSQL_TYPE_SET)
3495 3496 3497 3498 3499 3500 3501
    {
      calculate_interval_lengths(sql_field->charset,
                                 sql_field->interval, &dummy, 
                                 &field_length);
      sql_field->length= field_length + 
                         (sql_field->interval->count - 1);
    }
3502
    else /* MYSQL_TYPE_ENUM */
3503 3504 3505 3506 3507 3508 3509 3510 3511
    {
      calculate_interval_lengths(sql_field->charset,
                                 sql_field->interval,
                                 &field_length, &dummy);
      sql_field->length= field_length;
    }
    set_if_smaller(sql_field->length, MAX_FIELD_WIDTH-1);
  }

3512
  if (sql_field->sql_type == MYSQL_TYPE_BIT)
3513 3514 3515 3516 3517
  {
    sql_field->pack_flag= FIELDFLAG_NUMBER |
                          FIELDFLAG_TREAT_BIT_AS_CHAR;
  }
  sql_field->create_length_to_internal_length();
3518 3519 3520 3521
  DBUG_ASSERT(sql_field->def == 0);
  /* Can't go wrong as sql_field->def is not defined */
  (void) prepare_blob_field(thd, sql_field);
}
3522 3523


3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558
/*
  Write CREATE TABLE binlog

  SYNOPSIS
    write_create_table_bin_log()
    thd               Thread object
    create_info       Create information
    internal_tmp_table  Set to 1 if this is an internal temporary table

  DESCRIPTION
    This function only is called in mysql_create_table_no_lock and
    mysql_create_table

  RETURN VALUES
    NONE
 */
static inline void write_create_table_bin_log(THD *thd,
                                              const HA_CREATE_INFO *create_info,
                                              bool internal_tmp_table)
{
  /*
    Don't write statement if:
    - It is an internal temporary table,
    - Row-based logging is used and it we are creating a temporary table, or
    - The binary log is not open.
    Otherwise, the statement shall be binlogged.
   */
  if (!internal_tmp_table &&
      (!thd->current_stmt_binlog_row_based ||
       (thd->current_stmt_binlog_row_based &&
        !(create_info->options & HA_LEX_CREATE_TMP_TABLE))))
    write_bin_log(thd, TRUE, thd->query, thd->query_length);
}


3559 3560 3561 3562
/*
  Create a table

  SYNOPSIS
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3563
    mysql_create_table_no_lock()
3564 3565 3566
    thd			Thread object
    db			Database
    table_name		Table name
3567
    create_info	        Create information (like MAX_ROWS)
3568 3569
    fields		List of fields to create
    keys		List of keys to create
3570
    internal_tmp_table  Set to 1 if this is an internal temporary table
3571
			(From ALTER TABLE)
3572
    select_field_count
3573 3574

  DESCRIPTION
3575
    If one creates a temporary table, this is automatically opened
3576

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3577 3578 3579 3580 3581
    Note that this function assumes that caller already have taken
    name-lock on table being created or used some other way to ensure
    that concurrent operations won't intervene. mysql_create_table()
    is a wrapper that can be used for this.

3582 3583 3584 3585 3586 3587
    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
3588 3589
    FALSE OK
    TRUE  error
3590 3591
*/

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3592
bool mysql_create_table_no_lock(THD *thd,
3593
                                const char *db, const char *table_name,
3594 3595 3596 3597
                                HA_CREATE_INFO *create_info,
                                Alter_info *alter_info,
                                bool internal_tmp_table,
                                uint select_field_count)
3598
{
3599
  char		path[FN_REFLEN + 1];
3600
  uint          path_length;
3601 3602 3603 3604
  const char	*alias;
  uint		db_options, key_count;
  KEY		*key_info_buffer;
  handler	*file;
3605
  bool		error= TRUE;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3606
  DBUG_ENTER("mysql_create_table_no_lock");
3607 3608
  DBUG_PRINT("enter", ("db: '%s'  table: '%s'  tmp: %d",
                       db, table_name, internal_tmp_table));
3609

3610

3611
  /* Check for duplicate fields and check type of table to create */
3612
  if (!alter_info->create_list.elements)
3613
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3614 3615
    my_message(ER_TABLE_MUST_HAVE_COLUMNS, ER(ER_TABLE_MUST_HAVE_COLUMNS),
               MYF(0));
3616
    DBUG_RETURN(TRUE);
3617
  }
3618
  if (check_engine(thd, table_name, create_info))
3619
    DBUG_RETURN(TRUE);
3620
  db_options= create_info->table_options;
3621 3622 3623
  if (create_info->row_type == ROW_TYPE_DYNAMIC)
    db_options|=HA_OPTION_PACK_RECORD;
  alias= table_case_name(create_info, table_name);
3624 3625
  if (!(file= get_new_handler((TABLE_SHARE*) 0, thd->mem_root,
                              create_info->db_type)))
3626
  {
3627
    mem_alloc_error(sizeof(handler));
3628 3629
    DBUG_RETURN(TRUE);
  }
3630
#ifdef WITH_PARTITION_STORAGE_ENGINE
3631 3632
  partition_info *part_info= thd->work_part_info;

3633 3634 3635 3636 3637 3638 3639 3640
  if (!part_info && create_info->db_type->partition_flags &&
      (create_info->db_type->partition_flags() & HA_USE_AUTO_PARTITION))
  {
    /*
      Table is not defined as a partitioned table but the engine handles
      all tables as partitioned. The handler will set up the partition info
      object with the default settings.
    */
3641
    thd->work_part_info= part_info= new partition_info();
3642 3643 3644 3645 3646 3647
    if (!part_info)
    {
      mem_alloc_error(sizeof(partition_info));
      DBUG_RETURN(TRUE);
    }
    file->set_auto_partitions(part_info);
3648
    part_info->default_engine_type= create_info->db_type;
3649
    part_info->is_auto_partitioned= TRUE;
3650
  }
3651 3652 3653
  if (part_info)
  {
    /*
3654 3655 3656 3657 3658 3659 3660 3661 3662
      The table has been specified as a partitioned table.
      If this is part of an ALTER TABLE the handler will be the partition
      handler but we need to specify the default handler to use for
      partitions also in the call to check_partition_info. We transport
      this information in the default_db_type variable, it is either
      DB_TYPE_DEFAULT or the engine set in the ALTER TABLE command.

      Check that we don't use foreign keys in the table since it won't
      work even with InnoDB beneath it.
3663
    */
3664
    List_iterator<Key> key_iterator(alter_info->key_list);
3665
    Key *key;
3666
    handlerton *part_engine_type= create_info->db_type;
3667 3668
    char *part_syntax_buf;
    uint syntax_len;
3669
    handlerton *engine_type;
3670 3671 3672 3673 3674
    if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
    {
      my_error(ER_PARTITION_NO_TEMPORARY, MYF(0));
      goto err;
    }
3675 3676
    while ((key= key_iterator++))
    {
3677 3678
      if (key->type == Key::FOREIGN_KEY &&
          !part_info->is_auto_partitioned)
3679
      {
3680
        my_error(ER_FOREIGN_KEY_ON_PARTITIONED, MYF(0));
3681 3682 3683
        goto err;
      }
    }
3684
    if ((part_engine_type == partition_hton) &&
3685
        part_info->default_engine_type)
3686 3687 3688 3689 3690 3691
    {
      /*
        This only happens at ALTER TABLE.
        default_engine_type was assigned from the engine set in the ALTER
        TABLE command.
      */
3692
      ;
3693
    }
3694 3695
    else
    {
3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707
      if (create_info->used_fields & HA_CREATE_USED_ENGINE)
      {
        part_info->default_engine_type= create_info->db_type;
      }
      else
      {
        if (part_info->default_engine_type == NULL)
        {
          part_info->default_engine_type= ha_checktype(thd,
                                          DB_TYPE_DEFAULT, 0, 0);
        }
      }
3708
    }
mattiasj@witty's avatar
mattiasj@witty committed
3709 3710 3711
    DBUG_PRINT("info", ("db_type = %s create_info->db_type = %s",
             ha_resolve_storage_engine_name(part_info->default_engine_type),
             ha_resolve_storage_engine_name(create_info->db_type)));
3712
    if (part_info->check_partition_info(thd, &engine_type, file,
3713
                                        create_info, TRUE))
3714
      goto err;
3715
    part_info->default_engine_type= engine_type;
3716

3717 3718 3719 3720 3721 3722
    /*
      We reverse the partitioning parser and generate a standard format
      for syntax stored in frm file.
    */
    if (!(part_syntax_buf= generate_partition_syntax(part_info,
                                                     &syntax_len,
3723
                                                     TRUE, TRUE)))
3724
      goto err;
3725 3726
    part_info->part_info_string= part_syntax_buf;
    part_info->part_info_len= syntax_len;
3727 3728
    if ((!(engine_type->partition_flags &&
           engine_type->partition_flags() & HA_CAN_PARTITION)) ||
3729
        create_info->db_type == partition_hton)
3730 3731 3732 3733 3734
    {
      /*
        The handler assigned to the table cannot handle partitioning.
        Assign the partition handler as the handler of the table.
      */
mattiasj@witty's avatar
mattiasj@witty committed
3735
      DBUG_PRINT("info", ("db_type: %s",
mattiasj@witty's avatar
mattiasj@witty committed
3736
                        ha_resolve_storage_engine_name(create_info->db_type)));
3737
      delete file;
3738
      create_info->db_type= partition_hton;
3739 3740 3741 3742
      if (!(file= get_ha_partition(part_info)))
      {
        DBUG_RETURN(TRUE);
      }
3743 3744 3745 3746 3747 3748 3749 3750
      /*
        If we have default number of partitions or subpartitions we
        might require to set-up the part_info object such that it
        creates a proper .par file. The current part_info object is
        only used to create the frm-file and .par-file.
      */
      if (part_info->use_default_no_partitions &&
          part_info->no_parts &&
3751 3752
          (int)part_info->no_parts !=
          file->get_default_no_partitions(create_info))
3753
      {
3754
        uint i;
3755
        List_iterator<partition_element> part_it(part_info->partitions);
3756 3757 3758 3759
        part_it++;
        DBUG_ASSERT(thd->lex->sql_command != SQLCOM_CREATE_TABLE);
        for (i= 1; i < part_info->partitions.elements; i++)
          (part_it++)->part_state= PART_TO_BE_DROPPED;
3760 3761 3762 3763
      }
      else if (part_info->is_sub_partitioned() &&
               part_info->use_default_no_subpartitions &&
               part_info->no_subparts &&
3764
               (int)part_info->no_subparts !=
3765
                 file->get_default_no_partitions(create_info))
3766
      {
3767
        DBUG_ASSERT(thd->lex->sql_command != SQLCOM_CREATE_TABLE);
3768
        part_info->no_subparts= file->get_default_no_partitions(create_info);
3769 3770 3771 3772
      }
    }
    else if (create_info->db_type != engine_type)
    {
3773 3774 3775 3776 3777 3778
      /*
        We come here when we don't use a partitioned handler.
        Since we use a partitioned table it must be "native partitioned".
        We have switched engine from defaults, most likely only specified
        engines in partition clauses.
      */
3779
      delete file;
3780 3781
      if (!(file= get_new_handler((TABLE_SHARE*) 0, thd->mem_root,
                                  engine_type)))
3782 3783 3784 3785
      {
        mem_alloc_error(sizeof(handler));
        DBUG_RETURN(TRUE);
      }
3786 3787 3788
    }
  }
#endif
3789

3790
  set_table_default_charset(thd, create_info, (char*) db);
3791

3792 3793 3794 3795 3796
  if (mysql_prepare_create_table(thd, create_info, alter_info,
                                 internal_tmp_table,
                                 &db_options, file,
                                 &key_info_buffer, &key_count,
                                 select_field_count))
3797
    goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3798 3799 3800 3801

      /* Check if table exists */
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
3802
    path_length= build_tmptable_filename(thd, path, sizeof(path));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3803 3804
    create_info->table_options|=HA_CREATE_DELAY_KEY_WRITE;
  }
3805 3806
  else  
  {
3807
    path_length= build_table_filename(path, sizeof(path) - 1, db, alias, reg_ext,
3808
                                      internal_tmp_table ? FN_IS_TMP : 0);
3809
  }
3810

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3811
  /* Check if table already exists */
3812 3813
  if ((create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
      find_temporary_table(thd, db, table_name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3814
  {
3815
    if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
3816 3817
    {
      create_info->table_existed= 1;		// Mark that table existed
3818 3819 3820
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
                          ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
                          alias);
3821
      error= 0;
3822
      write_create_table_bin_log(thd, create_info, internal_tmp_table);
3823
      goto err;
3824
    }
monty@mysql.com's avatar
monty@mysql.com committed
3825
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), alias);
3826
    goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3827
  }
3828

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3829
  VOID(pthread_mutex_lock(&LOCK_open));
3830
  if (!internal_tmp_table && !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3831 3832 3833 3834
  {
    if (!access(path,F_OK))
    {
      if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
3835 3836
        goto warn;
      my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
3837
      goto unlock_and_end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3838
    }
3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851
    /*
      We don't assert here, but check the result, because the table could be
      in the table definition cache and in the same time the .frm could be
      missing from the disk, in case of manual intervention which deletes
      the .frm file. The user has to use FLUSH TABLES; to clear the cache.
      Then she could create the table. This case is pretty obscure and
      therefore we don't introduce a new error message only for it.
    */
    if (get_cached_table_share(db, alias))
    {
      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
      goto unlock_and_end;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3852 3853
  }

3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866
  /*
    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;
3867 3868 3869
    int retcode = ha_table_exists_in_engine(thd, db, table_name);
    DBUG_PRINT("info", ("exists_in_engine: %u",retcode));
    switch (retcode)
3870
    {
3871 3872 3873 3874 3875
      case HA_ERR_NO_SUCH_TABLE:
        /* Normal case, no table exists. we can go and create it */
        break;
      case HA_ERR_TABLE_EXIST:
        DBUG_PRINT("info", ("Table existed in handler"));
3876

3877 3878 3879 3880 3881 3882 3883 3884 3885
        if (create_if_not_exists)
          goto warn;
        my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
        goto unlock_and_end;
        break;
      default:
        DBUG_PRINT("info", ("error: %u from storage engine", retcode));
        my_error(retcode, MYF(0),table_name);
        goto unlock_and_end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3886 3887 3888
    }
  }

3889
  thd_proc_info(thd, "creating table");
3890
  create_info->table_existed= 0;		// Mark that table is created
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3891

3892
#ifdef HAVE_READLINK
3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910
  if (test_if_data_home_dir(create_info->data_file_name))
  {
    my_error(ER_WRONG_ARGUMENTS, MYF(0), "DATA DIRECTORY");
    goto unlock_and_end;
  }
  if (test_if_data_home_dir(create_info->index_file_name))
  {
    my_error(ER_WRONG_ARGUMENTS, MYF(0), "INDEX DIRECTORY");
    goto unlock_and_end;
  }

#ifdef WITH_PARTITION_STORAGE_ENGINE
  if (check_partition_dirs(thd->lex->part_info))
  {
    goto unlock_and_end;
  }
#endif /* WITH_PARTITION_STORAGE_ENGINE */

3911
  if (!my_use_symdir || (thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE))
3912
#endif /* HAVE_READLINK */
3913 3914
  {
    if (create_info->data_file_name)
3915 3916 3917
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                          WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED),
                          "DATA DIRECTORY");
3918
    if (create_info->index_file_name)
3919 3920 3921
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                          WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED),
                          "INDEX DIRECTORY");
3922
    create_info->data_file_name= create_info->index_file_name= 0;
3923
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3924
  create_info->table_options=db_options;
3925

3926
  path[path_length - reg_ext_length]= '\0'; // Remove .frm extension
3927 3928
  if (rea_create_table(thd, path, db, table_name,
                       create_info, alter_info->create_list,
3929
                       key_count, key_info_buffer, file))
3930
    goto unlock_and_end;
3931

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3932 3933 3934 3935 3936 3937
  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);
3938
      goto unlock_and_end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3939
    }
3940
    thd->thread_specific_used= TRUE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3941
  }
monty@mysql.com's avatar
monty@mysql.com committed
3942

3943
  write_create_table_bin_log(thd, create_info, internal_tmp_table);
3944
  error= FALSE;
3945
unlock_and_end:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3946
  VOID(pthread_mutex_unlock(&LOCK_open));
3947 3948

err:
3949
  thd_proc_info(thd, "After create");
3950
  delete file;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3951
  DBUG_RETURN(error);
3952 3953

warn:
3954
  error= FALSE;
3955 3956 3957 3958
  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
3959
  write_create_table_bin_log(thd, create_info, internal_tmp_table);
3960
  goto unlock_and_end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3961 3962
}

3963 3964

/*
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3965
  Database and name-locking aware wrapper for mysql_create_table_no_lock(),
3966 3967 3968 3969
*/

bool mysql_create_table(THD *thd, const char *db, const char *table_name,
                        HA_CREATE_INFO *create_info,
3970 3971 3972
                        Alter_info *alter_info,
                        bool internal_tmp_table,
                        uint select_field_count)
3973
{
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3974
  TABLE *name_lock= 0;
3975 3976 3977 3978 3979 3980
  bool result;
  DBUG_ENTER("mysql_create_table");

  /* Wait for any database locks */
  pthread_mutex_lock(&LOCK_lock_db);
  while (!thd->killed &&
3981
         hash_search(&lock_db_cache,(uchar*) db, strlen(db)))
3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994
  {
    wait_for_condition(thd, &LOCK_lock_db, &COND_refresh);
    pthread_mutex_lock(&LOCK_lock_db);
  }

  if (thd->killed)
  {
    pthread_mutex_unlock(&LOCK_lock_db);
    DBUG_RETURN(TRUE);
  }
  creating_table++;
  pthread_mutex_unlock(&LOCK_lock_db);

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010
  if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
  {
    if (lock_table_name_if_not_cached(thd, db, table_name, &name_lock))
    {
      result= TRUE;
      goto unlock;
    }
    if (!name_lock)
    {
      if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
      {
        push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
                            ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
                            table_name);
        create_info->table_existed= 1;
        result= FALSE;
4011
        write_create_table_bin_log(thd, create_info, internal_tmp_table);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
4012 4013 4014 4015 4016 4017 4018 4019 4020
      }
      else
      {
        my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
        result= TRUE;
      }
      goto unlock;
    }
  }
4021

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
4022
  result= mysql_create_table_no_lock(thd, db, table_name, create_info,
4023 4024 4025
                                     alter_info,
                                     internal_tmp_table,
                                     select_field_count);
4026

dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
4027 4028 4029 4030 4031 4032 4033
unlock:
  if (name_lock)
  {
    pthread_mutex_lock(&LOCK_open);
    unlink_open_table(thd, name_lock, FALSE);
    pthread_mutex_unlock(&LOCK_open);
  }
4034 4035 4036 4037 4038 4039 4040 4041
  pthread_mutex_lock(&LOCK_lock_db);
  if (!--creating_table && creating_database)
    pthread_cond_signal(&COND_refresh);
  pthread_mutex_unlock(&LOCK_lock_db);
  DBUG_RETURN(result);
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
4042 4043 4044 4045 4046 4047 4048 4049
/*
** 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++)
4050
    if (!my_strcasecmp(system_charset_info,name,key->name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4051 4052 4053 4054 4055 4056 4057 4058 4059 4060
      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;

4061 4062
  if (!check_if_keyname_exists(field_name,start,end) &&
      my_strcasecmp(system_charset_info,field_name,primary_key_name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4063
    return (char*) field_name;			// Use fieldname
4064 4065 4066 4067 4068 4069
  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
  */
4070
  for (uint i=2 ; i< 100; i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4071
  {
4072 4073
    *buff_end= '_';
    int10_to_str(i, buff_end+1, 10);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4074 4075 4076
    if (!check_if_keyname_exists(buff,start,end))
      return sql_strdup(buff);
  }
4077
  return (char*) "not_specified";		// Should never happen
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4078 4079
}

4080

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4081 4082 4083 4084
/****************************************************************************
** Alter a table definition
****************************************************************************/

4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098

/*
  Rename a table.

  SYNOPSIS
    mysql_rename_table()
      base                      The handlerton handle.
      old_db                    The old database name.
      old_name                  The old table name.
      new_db                    The new database name.
      new_name                  The new table name.
      flags                     flags for build_table_filename().
                                FN_FROM_IS_TMP old_name is temporary.
                                FN_TO_IS_TMP   new_name is temporary.
4099 4100
                                NO_FRM_RENAME  Don't rename the FRM file
                                but only the table in the storage engine.
4101 4102

  RETURN
4103 4104
    FALSE   OK
    TRUE    Error
4105 4106
*/

4107
bool
4108 4109 4110
mysql_rename_table(handlerton *base, const char *old_db,
                   const char *old_name, const char *new_db,
                   const char *new_name, uint flags)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4111
{
4112
  THD *thd= current_thd;
4113 4114
  char from[FN_REFLEN + 1], to[FN_REFLEN + 1],
    lc_from[FN_REFLEN + 1], lc_to[FN_REFLEN + 1];
4115 4116
  char *from_base= from, *to_base= to;
  char tmp_name[NAME_LEN+1];
4117
  handler *file;
4118
  int error=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4119
  DBUG_ENTER("mysql_rename_table");
4120 4121
  DBUG_PRINT("enter", ("old: '%s'.'%s'  new: '%s'.'%s'",
                       old_db, old_name, new_db, new_name));
4122

4123
  file= (base == NULL ? 0 :
4124 4125
         get_new_handler((TABLE_SHARE*) 0, thd->mem_root, base));

4126
  build_table_filename(from, sizeof(from) - 1, old_db, old_name, "",
4127
                       flags & FN_FROM_IS_TMP);
4128
  build_table_filename(to, sizeof(to) - 1, new_db, new_name, "",
4129
                       flags & FN_TO_IS_TMP);
4130 4131 4132 4133 4134 4135

  /*
    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.
   */
4136
  if (lower_case_table_names == 2 && file &&
4137
      !(file->ha_table_flags() & HA_FILE_BASED))
4138
  {
4139 4140
    strmov(tmp_name, old_name);
    my_casedn_str(files_charset_info, tmp_name);
4141
    build_table_filename(lc_from, sizeof(lc_from) - 1, old_db, tmp_name, "",
4142
                         flags & FN_FROM_IS_TMP);
4143
    from_base= lc_from;
4144

4145 4146
    strmov(tmp_name, new_name);
    my_casedn_str(files_charset_info, tmp_name);
4147
    build_table_filename(lc_to, sizeof(lc_to) - 1, new_db, tmp_name, "",
4148
                         flags & FN_TO_IS_TMP);
4149
    to_base= lc_to;
4150 4151
  }

4152
  if (!file || !(error=file->ha_rename_table(from_base, to_base)))
4153
  {
4154
    if (!(flags & NO_FRM_RENAME) && rename_file_ext(from,to,reg_ext))
4155
    {
4156
      error=my_errno;
4157
      /* Restore old file name */
4158
      if (file)
4159
        file->ha_rename_table(to_base, from_base);
4160 4161
    }
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4162
  delete file;
4163 4164 4165
  if (error == HA_ERR_WRONG_COMMAND)
    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "ALTER TABLE");
  else if (error)
4166 4167
    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
4168 4169
}

4170

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4171
/*
4172 4173 4174 4175 4176 4177
  Force all other threads to stop using the table

  SYNOPSIS
    wait_while_table_is_used()
    thd			Thread handler
    table		Table to remove from cache
4178 4179 4180
    function            HA_EXTRA_PREPARE_FOR_DROP if table is to be deleted
                        HA_EXTRA_FORCE_REOPEN if table is not be used
                        HA_EXTRA_PREPARE_FOR_RENAME if table is to be renamed
4181 4182 4183 4184 4185 4186 4187
  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
4188 4189
*/

4190 4191
void wait_while_table_is_used(THD *thd, TABLE *table,
                              enum ha_extra_function function)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4192
{
4193
  DBUG_ENTER("wait_while_table_is_used");
4194
  DBUG_PRINT("enter", ("table: '%s'  share: 0x%lx  db_stat: %u  version: %lu",
4195 4196
                       table->s->table_name.str, (ulong) table->s,
                       table->db_stat, table->s->version));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4197

4198 4199
  safe_mutex_assert_owner(&LOCK_open);

4200
  VOID(table->file->extra(function));
4201
  /* Mark all tables that are in use as 'old' */
4202
  mysql_lock_abort(thd, table, TRUE);	/* end threads waiting on lock */
4203 4204

  /* Wait until all there are no other threads that has this table open */
4205 4206 4207
  remove_table_from_cache(thd, table->s->db.str,
                          table->s->table_name.str,
                          RTFC_WAIT_OTHER_THREAD_FLAG);
4208 4209
  DBUG_VOID_RETURN;
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4210

4211 4212
/*
  Close a cached table
4213

4214
  SYNOPSIS
4215
    close_cached_table()
4216 4217 4218 4219 4220 4221
    thd			Thread handler
    table		Table to remove from cache

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

4223 4224 4225 4226
  PREREQUISITES
    Lock on LOCK_open
    Win32 clients must also have a WRITE LOCK on the table !
*/
4227

4228
void close_cached_table(THD *thd, TABLE *table)
4229 4230
{
  DBUG_ENTER("close_cached_table");
4231

4232
  wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
4233 4234
  /* Close lock if this is not got with LOCK TABLES */
  if (thd->lock)
4235
  {
4236 4237
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;			// Start locked threads
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4238
  }
4239
  /* Close all copies of 'table'.  This also frees all LOCK TABLES lock */
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
4240
  unlink_open_table(thd, table, TRUE);
4241 4242

  /* When lock on LOCK_open is freed other threads can continue */
4243
  broadcast_refresh();
monty@mysql.com's avatar
monty@mysql.com committed
4244
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4245 4246
}

4247
static int send_check_errmsg(THD *thd, TABLE_LIST* table,
4248
			     const char* operator_name, const char* errmsg)
4249

4250
{
4251 4252
  Protocol *protocol= thd->protocol;
  protocol->prepare_for_resend();
4253 4254
  protocol->store(table->alias, system_charset_info);
  protocol->store((char*) operator_name, system_charset_info);
4255
  protocol->store(STRING_WITH_LEN("error"), system_charset_info);
4256
  protocol->store(errmsg, system_charset_info);
4257
  thd->clear_error();
4258
  if (protocol->write())
4259 4260 4261 4262
    return -1;
  return 1;
}

4263

serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4264
static int prepare_for_restore(THD* thd, TABLE_LIST* table,
4265
			       HA_CHECK_OPT *check_opt)
4266
{
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4267
  DBUG_ENTER("prepare_for_restore");
4268

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4269 4270 4271 4272 4273 4274
  if (table->table) // do not overwrite existing tables on restore
  {
    DBUG_RETURN(send_check_errmsg(thd, table, "restore",
				  "table exists, will not overwrite on restore"
				  ));
  }
4275
  else
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4276
  {
4277
    char* backup_dir= thd->lex->backup_dir;
4278
    char src_path[FN_REFLEN], dst_path[FN_REFLEN + 1], uname[FN_REFLEN];
4279 4280
    char* table_name= table->table_name;
    char* db= table->db;
4281

4282
    VOID(tablename_to_filename(table->table_name, uname, sizeof(uname) - 1));
4283 4284

    if (fn_format_relative_to_data_home(src_path, uname, backup_dir, reg_ext))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4285
      DBUG_RETURN(-1); // protect buffer overflow
4286

4287
    build_table_filename(dst_path, sizeof(dst_path) - 1,
4288
                         db, table_name, reg_ext, 0);
4289

4290
    if (lock_and_wait_for_table_name(thd,table))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4291
      DBUG_RETURN(-1);
4292

4293
    if (my_copy(src_path, dst_path, MYF(MY_WME)))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4294
    {
4295
      pthread_mutex_lock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4296
      unlock_table_name(thd, table);
4297
      pthread_mutex_unlock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4298 4299 4300
      DBUG_RETURN(send_check_errmsg(thd, table, "restore",
				    "Failed copying .frm file"));
    }
4301
    if (mysql_truncate(thd, table, 1))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4302
    {
4303
      pthread_mutex_lock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4304
      unlock_table_name(thd, table);
4305
      pthread_mutex_unlock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4306 4307
      DBUG_RETURN(send_check_errmsg(thd, table, "restore",
				    "Failed generating table from .frm file"));
4308
    }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4309
  }
4310

4311 4312 4313 4314
  /*
    Now we should be able to open the partially restored table
    to finish the restore in the handler later on
  */
4315
  pthread_mutex_lock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
4316
  if (reopen_name_locked_table(thd, table, TRUE))
4317
  {
4318
    unlock_table_name(thd, table);
4319
    pthread_mutex_unlock(&LOCK_open);
4320 4321
    DBUG_RETURN(send_check_errmsg(thd, table, "restore",
                                  "Failed to open partially restored table"));
4322
  }
4323 4324
  /* A MERGE table must not come here. */
  DBUG_ASSERT(!table->table || !table->table->child_l);
4325
  pthread_mutex_unlock(&LOCK_open);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4326
  DBUG_RETURN(0);
4327
}
4328

4329

4330
static int prepare_for_repair(THD *thd, TABLE_LIST *table_list,
4331
			      HA_CHECK_OPT *check_opt)
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4332
{
4333 4334
  int error= 0;
  TABLE tmp_table, *table;
4335 4336 4337 4338
  TABLE_SHARE *share;
  char from[FN_REFLEN],tmp[FN_REFLEN+32];
  const char **ext;
  MY_STAT stat_info;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4339 4340 4341 4342
  DBUG_ENTER("prepare_for_repair");

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

  if (!(table= table_list->table))		/* if open_ltable failed */
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4345
  {
4346 4347 4348 4349 4350 4351 4352 4353 4354
    char key[MAX_DBKEY_LENGTH];
    uint key_length;

    key_length= create_table_def_key(thd, key, table_list, 0);
    pthread_mutex_lock(&LOCK_open);
    if (!(share= (get_table_share(thd, table_list, key, key_length, 0,
                                  &error))))
    {
      pthread_mutex_unlock(&LOCK_open);
4355
      DBUG_RETURN(0);				// Can't open frm file
4356 4357
    }

4358
    if (open_table_from_share(thd, share, "", 0, 0, 0, &tmp_table, FALSE))
4359 4360 4361 4362 4363
    {
      release_table_share(share, RELEASE_NORMAL);
      pthread_mutex_unlock(&LOCK_open);
      DBUG_RETURN(0);                           // Out of memory
    }
4364
    table= &tmp_table;
4365
    pthread_mutex_unlock(&LOCK_open);
4366
  }
4367 4368 4369 4370

  /* A MERGE table must not come here. */
  DBUG_ASSERT(!table->child_l);

4371 4372 4373 4374 4375 4376 4377 4378 4379
  /*
    REPAIR TABLE ... USE_FRM for temporary tables makes little sense.
  */
  if (table->s->tmp_table)
  {
    error= send_check_errmsg(thd, table_list, "repair",
			     "Cannot repair temporary table from .frm file");
    goto end;
  }
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4380

4381 4382 4383 4384 4385 4386 4387 4388 4389
  /*
    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
4390

4391 4392 4393
  if (table->s->frm_version != FRM_VER_TRUE_VARCHAR)
  {
    error= send_check_errmsg(thd, table_list, "repair",
Timothy Smith's avatar
Timothy Smith committed
4394
                             "Failed repairing incompatible .frm file");
4395 4396
    goto end;
  }
4397

4398 4399
  /*
    Check if this is a table type that stores index and data separately,
4400 4401 4402
    like ISAM or MyISAM. We assume fixed order of engine file name
    extentions array. First element of engine file name extentions array
    is meta/index file extention. Second element - data file extention. 
4403
  */
4404
  ext= table->file->bas_ext();
4405 4406
  if (!ext[0] || !ext[1])
    goto end;					// No data file
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4407

4408 4409
  // Name of data file
  strxmov(from, table->s->normalized_path.str, ext[1], NullS);
4410 4411
  if (!my_stat(from, &stat_info, MYF(0)))
    goto end;				// Can't use USE_FRM flag
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4412

4413 4414
  my_snprintf(tmp, sizeof(tmp), "%s-%lx_%lx",
	      from, current_pid, thd->thread_id);
4415

4416 4417 4418 4419 4420 4421 4422
  /* 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);
  }
4423
  if (lock_and_wait_for_table_name(thd,table_list))
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4424
  {
4425 4426
    error= -1;
    goto end;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4427
  }
4428
  if (my_rename(from, tmp, MYF(MY_WME)))
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4429
  {
4430
    pthread_mutex_lock(&LOCK_open);
4431
    unlock_table_name(thd, table_list);
4432
    pthread_mutex_unlock(&LOCK_open);
4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453
    error= send_check_errmsg(thd, table_list, "repair",
			     "Failed renaming data file");
    goto end;
  }
  if (mysql_truncate(thd, table_list, 1))
  {
    pthread_mutex_lock(&LOCK_open);
    unlock_table_name(thd, table_list);
    pthread_mutex_unlock(&LOCK_open);
    error= send_check_errmsg(thd, table_list, "repair",
			     "Failed generating table from .frm file");
    goto end;
  }
  if (my_rename(tmp, from, MYF(MY_WME)))
  {
    pthread_mutex_lock(&LOCK_open);
    unlock_table_name(thd, table_list);
    pthread_mutex_unlock(&LOCK_open);
    error= send_check_errmsg(thd, table_list, "repair",
			     "Failed restoring .MYD file");
    goto end;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4454 4455
  }

4456 4457 4458 4459
  /*
    Now we should be able to open the partially repaired table
    to finish the repair in the handler later on.
  */
4460
  pthread_mutex_lock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
4461
  if (reopen_name_locked_table(thd, table_list, TRUE))
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4462
  {
4463
    unlock_table_name(thd, table_list);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4464
    pthread_mutex_unlock(&LOCK_open);
4465 4466 4467
    error= send_check_errmsg(thd, table_list, "repair",
                             "Failed to open partially repaired table");
    goto end;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4468
  }
4469
  pthread_mutex_unlock(&LOCK_open);
4470 4471 4472

end:
  if (table == &tmp_table)
4473 4474 4475 4476 4477
  {
    pthread_mutex_lock(&LOCK_open);
    closefrm(table, 1);				// Free allocated memory
    pthread_mutex_unlock(&LOCK_open);
  }
4478
  DBUG_RETURN(error);
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4479
}
4480

4481

4482

4483 4484
/*
  RETURN VALUES
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
4485 4486 4487
    FALSE Message sent to net (admin operation went ok)
    TRUE  Message should be sent by caller 
          (admin operation or network communication failed)
4488
*/
4489 4490 4491 4492 4493
static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
                              HA_CHECK_OPT* check_opt,
                              const char *operator_name,
                              thr_lock_type lock_type,
                              bool open_for_modify,
4494
                              bool no_warnings_for_error,
4495 4496 4497
                              uint extra_open_options,
                              int (*prepare_func)(THD *, TABLE_LIST *,
                                                  HA_CHECK_OPT *),
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4498 4499 4500
                              int (handler::*operator_func)(THD *,
                                                            HA_CHECK_OPT *),
                              int (view_operator_func)(THD *, TABLE_LIST*))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4501
{
4502
  TABLE_LIST *table;
4503
  SELECT_LEX *select= &thd->lex->select_lex;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4504
  List<Item> field_list;
4505 4506
  Item *item;
  Protocol *protocol= thd->protocol;
4507
  LEX *lex= thd->lex;
4508
  int result_code;
4509
  DBUG_ENTER("mysql_admin_table");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4510

4511 4512
  if (end_active_trans(thd))
    DBUG_RETURN(1);
4513
  field_list.push_back(item = new Item_empty_string("Table", NAME_CHAR_LEN*2));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4514 4515 4516 4517 4518 4519 4520
  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;
4521 4522
  if (protocol->send_fields(&field_list,
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
4523
    DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4524

4525
  mysql_ha_rm_tables(thd, tables, FALSE);
4526

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4527
  for (table= tables; table; table= table->next_local)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4528 4529
  {
    char table_name[NAME_LEN*2+2];
4530
    char* db = table->db;
4531
    bool fatal_error=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4532

4533 4534
    DBUG_PRINT("admin", ("table: '%s'.'%s'", table->db, table->table_name));
    DBUG_PRINT("admin", ("extra_open_options: %u", extra_open_options));
serg@serg.mylan's avatar
serg@serg.mylan committed
4535
    strxmov(table_name, db, ".", table->table_name, NullS);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4536
    thd->open_options|= extra_open_options;
4537 4538
    table->lock_type= lock_type;
    /* open only one table from local list of command */
4539
    {
4540 4541 4542 4543 4544
      TABLE_LIST *save_next_global, *save_next_local;
      save_next_global= table->next_global;
      table->next_global= 0;
      save_next_local= table->next_local;
      table->next_local= 0;
4545
      select->table_list.first= (uchar*)table;
4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557
      /*
        Time zone tables and SP tables can be add to lex->query_tables list,
        so it have to be prepared.
        TODO: Investigate if we can put extra tables into argument instead of
        using lex->query_tables
      */
      lex->query_tables= table;
      lex->query_tables_last= &table->next_global;
      lex->query_tables_own_last= 0;
      thd->no_warnings_for_error= no_warnings_for_error;
      if (view_operator_func == NULL)
        table->required_type=FRMTYPE_TABLE;
4558

4559 4560 4561 4562 4563
      open_and_lock_tables(thd, table);
      thd->no_warnings_for_error= 0;
      table->next_global= save_next_global;
      table->next_local= save_next_local;
      thd->open_options&= ~extra_open_options;
4564
#ifdef WITH_PARTITION_STORAGE_ENGINE
4565
      if (table->table)
4566 4567 4568 4569 4570 4571 4572
      {
        /*
          Set up which partitions that should be processed
          if ALTER TABLE t ANALYZE/CHECK/OPTIMIZE/REPAIR PARTITION ..
        */
        Alter_info *alter_info= &lex->alter_info;

4573
        if (alter_info->flags & ALTER_ADMIN_PARTITION)
4574
        {
4575 4576 4577 4578 4579
          if (!table->table->part_info)
          {
            my_error(ER_PARTITION_MGMT_ON_NONPARTITIONED, MYF(0));
            DBUG_RETURN(TRUE);
          }
4580 4581 4582 4583 4584 4585 4586 4587
          uint no_parts_found;
          uint no_parts_opt= alter_info->partition_names.elements;
          no_parts_found= set_part_state(alter_info, table->table->part_info,
                                         PART_CHANGED);
          if (no_parts_found != no_parts_opt &&
              (!(alter_info->flags & ALTER_ALL_PARTITION)))
          {
            char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
4588
            size_t length;
4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605
            DBUG_PRINT("admin", ("sending non existent partition error"));
            protocol->prepare_for_resend();
            protocol->store(table_name, system_charset_info);
            protocol->store(operator_name, system_charset_info);
            protocol->store(STRING_WITH_LEN("error"), system_charset_info);
            length= my_snprintf(buff, sizeof(buff),
                                ER(ER_DROP_PARTITION_NON_EXISTENT),
                                table_name);
            protocol->store(buff, length, system_charset_info);
            if(protocol->write())
              goto err;
            my_eof(thd);
            goto err;
          }
        }
      }
#endif
4606
    }
4607 4608
    DBUG_PRINT("admin", ("table: 0x%lx", (long) table->table));

4609
    if (prepare_func)
4610
    {
4611
      DBUG_PRINT("admin", ("calling prepare_func"));
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
4612
      switch ((*prepare_func)(thd, table, check_opt)) {
4613
      case  1:           // error, message written to net
4614
        ha_autocommit_or_rollback(thd, 1);
4615
        end_trans(thd, ROLLBACK);
4616
        close_thread_tables(thd);
4617
        DBUG_PRINT("admin", ("simple error, admin next table"));
4618 4619
        continue;
      case -1:           // error, message could be written to net
4620 4621
        /* purecov: begin inspected */
        DBUG_PRINT("admin", ("severe error, stop"));
4622
        goto err;
4623
        /* purecov: end */
4624
      default:           // should be 0 otherwise
4625
        DBUG_PRINT("admin", ("prepare_func succeeded"));
4626
        ;
4627
      }
4628
    }
4629

4630
    /*
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4631 4632 4633 4634 4635 4636
      CHECK TABLE command is only command where VIEW allowed here and this
      command use only temporary teble method for VIEWs resolving => there
      can't be VIEW tree substitition of join view => if opening table
      succeed then table->table will have real TABLE pointer as value (in
      case of join view substitution table->table can be 0, but here it is
      impossible)
4637
    */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4638 4639
    if (!table->table)
    {
4640
      DBUG_PRINT("admin", ("open table failed"));
4641 4642 4643
      if (!thd->warn_list.elements)
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
                     ER_CHECK_NO_SUCH_TABLE, ER(ER_CHECK_NO_SUCH_TABLE));
4644 4645 4646
      /* if it was a view will check md5 sum */
      if (table->view &&
          view_checksum(thd, table) == HA_ADMIN_WRONG_CHECKSUM)
4647 4648
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
                     ER_VIEW_CHECKSUM, ER(ER_VIEW_CHECKSUM));
Staale Smedseng's avatar
Staale Smedseng committed
4649
      if (thd->main_da.is_error() && 
4650 4651
          (thd->main_da.sql_errno() == ER_NO_SUCH_TABLE ||
           thd->main_da.sql_errno() == ER_FILE_NOT_FOUND))
Staale Smedseng's avatar
Staale Smedseng committed
4652 4653 4654 4655 4656
        /* A missing table is just issued as a failed command */
        result_code= HA_ADMIN_FAILED;
      else
        /* Default failure code is corrupt table */
        result_code= HA_ADMIN_CORRUPT;
4657
      goto send_result;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4658
    }
4659 4660 4661

    if (table->view)
    {
4662
      DBUG_PRINT("admin", ("calling view_operator_func"));
4663 4664 4665 4666
      result_code= (*view_operator_func)(thd, table);
      goto send_result;
    }

4667
    if (table->schema_table)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4668
    {
4669 4670
      result_code= HA_ADMIN_NOT_IMPLEMENTED;
      goto send_result;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4671 4672
    }

4673
    if ((table->table->db_stat & HA_READ_ONLY) && open_for_modify)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4674
    {
4675
      /* purecov: begin inspected */
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4676
      char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
4677
      size_t length;
4678
      DBUG_PRINT("admin", ("sending error message"));
4679
      protocol->prepare_for_resend();
4680 4681
      protocol->store(table_name, system_charset_info);
      protocol->store(operator_name, system_charset_info);
4682
      protocol->store(STRING_WITH_LEN("error"), system_charset_info);
4683 4684 4685
      length= my_snprintf(buff, sizeof(buff), ER(ER_OPEN_AS_READONLY),
                          table_name);
      protocol->store(buff, length, system_charset_info);
4686
      ha_autocommit_or_rollback(thd, 0);
4687
      end_trans(thd, COMMIT);
4688
      close_thread_tables(thd);
4689
      lex->reset_query_tables_list(FALSE);
4690
      table->table=0;				// For query cache
4691
      if (protocol->write())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4692
	goto err;
4693
      thd->main_da.reset_diagnostics_area();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4694
      continue;
4695
      /* purecov: end */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4696 4697
    }

4698
    /* Close all instances of the table to allow repair to rename files */
4699
    if (lock_type == TL_WRITE && table->table->s->version)
4700
    {
4701
      DBUG_PRINT("admin", ("removing table from cache"));
4702
      pthread_mutex_lock(&LOCK_open);
4703 4704
      const char *old_message=thd->enter_cond(&COND_refresh, &LOCK_open,
					      "Waiting to get writelock");
4705
      mysql_lock_abort(thd,table->table, TRUE);
4706 4707
      remove_table_from_cache(thd, table->table->s->db.str,
                              table->table->s->table_name.str,
monty@mysql.com's avatar
monty@mysql.com committed
4708 4709
                              RTFC_WAIT_OTHER_THREAD_FLAG |
                              RTFC_CHECK_KILLED_FLAG);
4710
      thd->exit_cond(old_message);
4711
      DBUG_EXECUTE_IF("wait_in_mysql_admin_table", wait_for_kill_signal(thd););
4712 4713
      if (thd->killed)
	goto err;
4714 4715 4716
      /* Flush entries in the query cache involving this table. */
      query_cache_invalidate3(thd, table->table, 0);
      open_for_modify= 0;
4717 4718
    }

4719
    if (table->table->s->crashed && operator_func == &handler::ha_check)
4720
    {
4721 4722
      /* purecov: begin inspected */
      DBUG_PRINT("admin", ("sending crashed warning"));
4723 4724 4725
      protocol->prepare_for_resend();
      protocol->store(table_name, system_charset_info);
      protocol->store(operator_name, system_charset_info);
4726 4727 4728
      protocol->store(STRING_WITH_LEN("warning"), system_charset_info);
      protocol->store(STRING_WITH_LEN("Table is marked as crashed"),
                      system_charset_info);
4729 4730
      if (protocol->write())
        goto err;
4731
      /* purecov: end */
4732 4733
    }

4734 4735
    if (operator_func == &handler::ha_repair &&
        !(check_opt->sql_flags & TT_USEFRM))
4736 4737 4738 4739 4740
    {
      if ((table->table->file->check_old_types() == HA_ADMIN_NEEDS_ALTER) ||
          (table->table->file->ha_check_for_upgrade(check_opt) ==
           HA_ADMIN_NEEDS_ALTER))
      {
4741
        DBUG_PRINT("admin", ("recreating table"));
4742
        ha_autocommit_or_rollback(thd, 1);
4743 4744
        close_thread_tables(thd);
        tmp_disable_binlog(thd); // binlogging is done by caller if wanted
4745
        result_code= mysql_recreate_table(thd, table);
4746
        reenable_binlog(thd);
4747 4748 4749 4750 4751 4752 4753 4754
        /*
          mysql_recreate_table() can push OK or ERROR.
          Clear 'OK' status. If there is an error, keep it:
          we will store the error message in a result set row 
          and then clear.
        */
        if (thd->main_da.is_ok())
          thd->main_da.reset_diagnostics_area();
4755 4756 4757 4758
        goto send_result;
      }
    }

4759
    DBUG_PRINT("admin", ("calling operator_func '%s'", operator_name));
4760
    result_code = (table->table->file->*operator_func)(thd, check_opt);
4761
    DBUG_PRINT("admin", ("operator_func returned: %d", result_code));
4762 4763 4764

send_result:

4765
    lex->cleanup_after_one_table_open();
4766
    thd->clear_error();  // these errors shouldn't get client
4767
    {
4768 4769 4770 4771 4772 4773 4774
      List_iterator_fast<MYSQL_ERROR> it(thd->warn_list);
      MYSQL_ERROR *err;
      while ((err= it++))
      {
        protocol->prepare_for_resend();
        protocol->store(table_name, system_charset_info);
        protocol->store((char*) operator_name, system_charset_info);
4775 4776 4777
        protocol->store(warning_level_names[err->level].str,
                        warning_level_names[err->level].length,
                        system_charset_info);
4778 4779 4780 4781 4782
        protocol->store(err->msg, system_charset_info);
        if (protocol->write())
          goto err;
      }
      mysql_reset_errors(thd, true);
4783
    }
4784
    protocol->prepare_for_resend();
4785 4786
    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
4787

4788 4789 4790
send_result_message:

    DBUG_PRINT("info", ("result_code: %d", result_code));
4791 4792
    switch (result_code) {
    case HA_ADMIN_NOT_IMPLEMENTED:
4793
      {
4794
       char buf[MYSQL_ERRMSG_SIZE];
4795
       size_t length=my_snprintf(buf, sizeof(buf),
4796
				ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);
4797
	protocol->store(STRING_WITH_LEN("note"), system_charset_info);
4798
	protocol->store(buf, length, system_charset_info);
4799
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4800 4801
      break;

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4802 4803
    case HA_ADMIN_NOT_BASE_TABLE:
      {
4804
        char buf[MYSQL_ERRMSG_SIZE];
4805
        size_t length= my_snprintf(buf, sizeof(buf),
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4806
                                 ER(ER_BAD_TABLE_ERROR), table_name);
4807
        protocol->store(STRING_WITH_LEN("note"), system_charset_info);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4808
        protocol->store(buf, length, system_charset_info);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4809 4810 4811
      }
      break;

4812
    case HA_ADMIN_OK:
4813 4814
      protocol->store(STRING_WITH_LEN("status"), system_charset_info);
      protocol->store(STRING_WITH_LEN("OK"), system_charset_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4815 4816
      break;

4817
    case HA_ADMIN_FAILED:
4818 4819 4820
      protocol->store(STRING_WITH_LEN("status"), system_charset_info);
      protocol->store(STRING_WITH_LEN("Operation failed"),
                      system_charset_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4821 4822
      break;

vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
4823
    case HA_ADMIN_REJECT:
4824 4825 4826
      protocol->store(STRING_WITH_LEN("status"), system_charset_info);
      protocol->store(STRING_WITH_LEN("Operation need committed state"),
                      system_charset_info);
monty@mysql.com's avatar
monty@mysql.com committed
4827
      open_for_modify= FALSE;
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
4828 4829
      break;

4830
    case HA_ADMIN_ALREADY_DONE:
4831 4832 4833
      protocol->store(STRING_WITH_LEN("status"), system_charset_info);
      protocol->store(STRING_WITH_LEN("Table is already up to date"),
                      system_charset_info);
4834 4835
      break;

4836
    case HA_ADMIN_CORRUPT:
4837 4838
      protocol->store(STRING_WITH_LEN("error"), system_charset_info);
      protocol->store(STRING_WITH_LEN("Corrupt"), system_charset_info);
4839
      fatal_error=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4840 4841
      break;

4842
    case HA_ADMIN_INVALID:
4843 4844 4845
      protocol->store(STRING_WITH_LEN("error"), system_charset_info);
      protocol->store(STRING_WITH_LEN("Invalid argument"),
                      system_charset_info);
4846 4847
      break;

4848 4849 4850 4851 4852 4853
    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.
4854
        We have to end the row, so analyze could return more rows.
4855
      */
4856 4857 4858 4859 4860 4861
      protocol->store(STRING_WITH_LEN("note"), system_charset_info);
      protocol->store(STRING_WITH_LEN(
          "Table does not support optimize, doing recreate + analyze instead"),
                      system_charset_info);
      if (protocol->write())
        goto err;
4862
      ha_autocommit_or_rollback(thd, 0);
4863
      close_thread_tables(thd);
4864
      DBUG_PRINT("info", ("HA_ADMIN_TRY_ALTER, trying analyze..."));
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4865 4866 4867
      TABLE_LIST *save_next_local= table->next_local,
                 *save_next_global= table->next_global;
      table->next_local= table->next_global= 0;
4868
      tmp_disable_binlog(thd); // binlogging is done by caller if wanted
4869
      result_code= mysql_recreate_table(thd, table);
4870
      reenable_binlog(thd);
4871 4872 4873 4874 4875 4876 4877 4878
      /*
        mysql_recreate_table() can push OK or ERROR.
        Clear 'OK' status. If there is an error, keep it:
        we will store the error message in a result set row 
        and then clear.
      */
      if (thd->main_da.is_ok())
        thd->main_da.reset_diagnostics_area();
4879
      ha_autocommit_or_rollback(thd, 0);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4880
      close_thread_tables(thd);
4881 4882
      if (!result_code) // recreation went ok
      {
4883
        if ((table->table= open_ltable(thd, table, lock_type, 0)) &&
4884
            ((result_code= table->table->file->ha_analyze(thd, check_opt)) > 0))
4885 4886
          result_code= 0; // analyze went ok
      }
4887 4888 4889 4890
      /* Start a new row for the final status row */
      protocol->prepare_for_resend();
      protocol->store(table_name, system_charset_info);
      protocol->store(operator_name, system_charset_info);
4891 4892
      if (result_code) // either mysql_recreate_table or analyze failed
      {
4893 4894
        DBUG_ASSERT(thd->is_error());
        if (thd->is_error())
4895
        {
4896
          const char *err_msg= thd->main_da.message();
4897 4898
          if (!thd->vio_ok())
          {
Staale Smedseng's avatar
Staale Smedseng committed
4899
            sql_print_error("%s", err_msg);
4900 4901 4902 4903
          }
          else
          {
            /* Hijack the row already in-progress. */
4904
            protocol->store(STRING_WITH_LEN("error"), system_charset_info);
4905
            protocol->store(err_msg, system_charset_info);
4906 4907
            if (protocol->write())
              goto err;
4908 4909 4910 4911 4912
            /* 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);
          }
4913
          thd->clear_error();
4914 4915
        }
      }
4916
      result_code= result_code ? HA_ADMIN_FAILED : HA_ADMIN_OK;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4917 4918
      table->next_local= save_next_local;
      table->next_global= save_next_global;
4919 4920
      goto send_result_message;
    }
4921 4922
    case HA_ADMIN_WRONG_CHECKSUM:
    {
4923
      protocol->store(STRING_WITH_LEN("note"), system_charset_info);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4924 4925
      protocol->store(ER(ER_VIEW_CHECKSUM), strlen(ER(ER_VIEW_CHECKSUM)),
                      system_charset_info);
4926 4927
      break;
    }
4928

4929 4930 4931
    case HA_ADMIN_NEEDS_UPGRADE:
    case HA_ADMIN_NEEDS_ALTER:
    {
4932
      char buf[MYSQL_ERRMSG_SIZE];
4933
      size_t length;
4934 4935

      protocol->store(STRING_WITH_LEN("error"), system_charset_info);
4936 4937
      length=my_snprintf(buf, sizeof(buf), ER(ER_TABLE_NEEDS_UPGRADE),
                         table->table_name);
4938 4939 4940 4941 4942
      protocol->store(buf, length, system_charset_info);
      fatal_error=1;
      break;
    }

4943
    default:				// Probably HA_ADMIN_INTERNAL_ERROR
4944
      {
4945
        char buf[MYSQL_ERRMSG_SIZE];
4946
        size_t length=my_snprintf(buf, sizeof(buf),
4947 4948
                                "Unknown - internal error %d during operation",
                                result_code);
4949
        protocol->store(STRING_WITH_LEN("error"), system_charset_info);
4950 4951 4952 4953
        protocol->store(buf, length, system_charset_info);
        fatal_error=1;
        break;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4954
    }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4955
    if (table->table)
4956
    {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4957 4958
      if (fatal_error)
        table->table->s->version=0;               // Force close of table
4959
      else if (open_for_modify)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4960
      {
holyfoot@deer.(none)'s avatar
holyfoot@deer.(none) committed
4961
        if (table->table->s->tmp_table)
holyfoot@mysql.com's avatar
holyfoot@mysql.com committed
4962 4963 4964 4965
          table->table->file->info(HA_STATUS_CONST);
        else
        {
          pthread_mutex_lock(&LOCK_open);
4966 4967
          remove_table_from_cache(thd, table->table->s->db.str,
                                  table->table->s->table_name.str, RTFC_NO_FLAG);
holyfoot@mysql.com's avatar
holyfoot@mysql.com committed
4968 4969 4970
          pthread_mutex_unlock(&LOCK_open);
        }
        /* May be something modified consequently we have to invalidate cache */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4971 4972
        query_cache_invalidate3(thd, table->table, 0);
      }
4973
    }
4974
    ha_autocommit_or_rollback(thd, 0);
4975
    end_trans(thd, COMMIT);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4976
    close_thread_tables(thd);
4977
    table->table=0;				// For query cache
4978
    if (protocol->write())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4979 4980 4981
      goto err;
  }

4982
  my_eof(thd);
4983
  DBUG_RETURN(FALSE);
4984

4985
err:
4986
  ha_autocommit_or_rollback(thd, 1);
4987
  end_trans(thd, ROLLBACK);
4988
  close_thread_tables(thd);			// Shouldn't be needed
4989 4990
  if (table)
    table->table=0;
4991
  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4992 4993
}

4994

4995
bool mysql_backup_table(THD* thd, TABLE_LIST* table_list)
4996 4997
{
  DBUG_ENTER("mysql_backup_table");
4998
  WARN_DEPRECATED(thd, "6.0", "BACKUP TABLE",
4999
                  "MySQL Administrator (mysqldump, mysql)");
5000
  DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
5001
				"backup", TL_READ, 0, 0, 0, 0,
5002
				&handler::ha_backup, 0));
5003
}
5004

5005

5006
bool mysql_restore_table(THD* thd, TABLE_LIST* table_list)
5007 5008
{
  DBUG_ENTER("mysql_restore_table");
5009
  WARN_DEPRECATED(thd, "6.0", "RESTORE TABLE",
5010
                  "MySQL Administrator (mysqldump, mysql)");
5011
  DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
5012
				"restore", TL_WRITE, 1, 1, 0,
5013
				&prepare_for_restore,
5014
				&handler::ha_restore, 0));
5015
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5016

5017

5018
bool mysql_repair_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
5019 5020 5021
{
  DBUG_ENTER("mysql_repair_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
5022 5023 5024
				"repair", TL_WRITE, 1,
                                test(check_opt->sql_flags & TT_USEFRM),
                                HA_OPEN_FOR_REPAIR,
5025
				&prepare_for_repair,
5026
				&handler::ha_repair, 0));
5027 5028
}

5029

5030
bool mysql_optimize_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
5031 5032 5033
{
  DBUG_ENTER("mysql_optimize_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
5034
				"optimize", TL_WRITE, 1,0,0,0,
5035
				&handler::ha_optimize, 0));
5036 5037 5038
}


igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5039 5040 5041 5042 5043
/*
  Assigned specified indexes for a table into key cache

  SYNOPSIS
    mysql_assign_to_keycache()
5044 5045
    thd		Thread object
    tables	Table list (one table only)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5046 5047

  RETURN VALUES
5048 5049
   FALSE ok
   TRUE  error
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5050 5051
*/

5052
bool mysql_assign_to_keycache(THD* thd, TABLE_LIST* tables,
5053
			     LEX_STRING *key_cache_name)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5054
{
5055
  HA_CHECK_OPT check_opt;
5056
  KEY_CACHE *key_cache;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5057
  DBUG_ENTER("mysql_assign_to_keycache");
5058 5059 5060 5061 5062 5063 5064

  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);
5065
    DBUG_RETURN(TRUE);
5066 5067 5068 5069
  }
  pthread_mutex_unlock(&LOCK_global_system_variables);
  check_opt.key_cache= key_cache;
  DBUG_RETURN(mysql_admin_table(thd, tables, &check_opt,
5070
				"assign_to_keycache", TL_READ_NO_INSERT, 0, 0,
5071
				0, 0, &handler::assign_to_keycache, 0));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5072 5073
}

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5074 5075 5076 5077 5078 5079

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

  SYNOPSIS
    reassign_keycache_tables()
5080 5081 5082
    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
5083

5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096
  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
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5097 5098 5099
    0	  ok
*/

5100 5101
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
5102 5103 5104
{
  DBUG_ENTER("reassign_keycache_tables");

5105 5106
  DBUG_ASSERT(src_cache != dst_cache);
  DBUG_ASSERT(src_cache->in_init);
5107
  src_cache->param_buff_size= 0;		// Free key cache
5108 5109
  ha_resize_key_cache(src_cache);
  ha_change_key_cache(src_cache, dst_cache);
5110
  DBUG_RETURN(0);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5111 5112 5113
}


igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5114 5115 5116 5117 5118
/*
  Preload specified indexes for a table into key cache

  SYNOPSIS
    mysql_preload_keys()
5119 5120
    thd		Thread object
    tables	Table list (one table only)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5121 5122

  RETURN VALUES
5123 5124
    FALSE ok
    TRUE  error
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5125 5126
*/

5127
bool mysql_preload_keys(THD* thd, TABLE_LIST* tables)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5128 5129
{
  DBUG_ENTER("mysql_preload_keys");
5130 5131 5132 5133 5134
  /*
    We cannot allow concurrent inserts. The storage engine reads
    directly from the index file, bypassing the cache. It could read
    outdated information if parallel inserts into cache blocks happen.
  */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5135
  DBUG_RETURN(mysql_admin_table(thd, tables, 0,
5136
				"preload_keys", TL_READ_NO_INSERT, 0, 0, 0, 0,
5137
				&handler::preload_keys, 0));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5138 5139 5140
}


5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189

/**
  @brief          Create frm file based on I_S table

  @param[in]      thd                      thread handler
  @param[in]      schema_table             I_S table           
  @param[in]      dst_path                 path where frm should be created
  @param[in]      create_info              Create info

  @return         Operation status
    @retval       0                        success
    @retval       1                        error
*/


bool mysql_create_like_schema_frm(THD* thd, TABLE_LIST* schema_table,
                                  char *dst_path, HA_CREATE_INFO *create_info)
{
  HA_CREATE_INFO local_create_info;
  Alter_info alter_info;
  bool tmp_table= (create_info->options & HA_LEX_CREATE_TMP_TABLE);
  uint keys= schema_table->table->s->keys;
  uint db_options= 0;
  DBUG_ENTER("mysql_create_like_schema_frm");

  bzero((char*) &local_create_info, sizeof(local_create_info));
  local_create_info.db_type= schema_table->table->s->db_type();
  local_create_info.row_type= schema_table->table->s->row_type;
  local_create_info.default_table_charset=default_charset_info;
  alter_info.flags= (ALTER_CHANGE_COLUMN | ALTER_RECREATE);
  schema_table->table->use_all_columns();
  if (mysql_prepare_alter_table(thd, schema_table->table,
                                &local_create_info, &alter_info))
    DBUG_RETURN(1);
  if (mysql_prepare_create_table(thd, &local_create_info, &alter_info,
                                 tmp_table, &db_options,
                                 schema_table->table->file,
                                 &schema_table->table->s->key_info, &keys, 0))
    DBUG_RETURN(1);
  local_create_info.max_rows= 0;
  if (mysql_create_frm(thd, dst_path, NullS, NullS,
                       &local_create_info, alter_info.create_list,
                       keys, schema_table->table->s->key_info,
                       schema_table->table->file))
    DBUG_RETURN(1);
  DBUG_RETURN(0);
}


venu@myvenu.com's avatar
venu@myvenu.com committed
5190 5191 5192 5193 5194
/*
  Create a table identical to the specified table

  SYNOPSIS
    mysql_create_like_table()
5195
    thd		Thread object
5196 5197
    table       Table list element for target table
    src_table   Table list element for source table
venu@myvenu.com's avatar
venu@myvenu.com committed
5198 5199 5200
    create_info Create info

  RETURN VALUES
5201 5202
    FALSE OK
    TRUE  error
venu@myvenu.com's avatar
venu@myvenu.com committed
5203 5204
*/

5205
bool mysql_create_like_table(THD* thd, TABLE_LIST* table, TABLE_LIST* src_table,
5206
                             HA_CREATE_INFO *create_info)
venu@myvenu.com's avatar
venu@myvenu.com committed
5207
{
5208
  TABLE *name_lock= 0;
5209
  char src_path[FN_REFLEN], dst_path[FN_REFLEN + 1];
5210
  uint dst_path_length;
venu@myvenu.com's avatar
venu@myvenu.com committed
5211
  char *db= table->db;
5212
  char *table_name= table->table_name;
5213
  int  err;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
5214
  bool res= TRUE;
5215
  uint not_used;
5216 5217 5218
#ifdef WITH_PARTITION_STORAGE_ENGINE
  char tmp_path[FN_REFLEN];
#endif
5219
  char ts_name[FN_LEN + 1];
5220
  myf flags= MY_DONT_OVERWRITE_FILE;
venu@myvenu.com's avatar
venu@myvenu.com committed
5221
  DBUG_ENTER("mysql_create_like_table");
5222

5223

5224 5225 5226 5227 5228 5229 5230 5231
  /*
    By opening source table we guarantee that it exists and no concurrent
    DDL operation will mess with it. Later we also take an exclusive
    name-lock on target table name, which makes copying of .frm file,
    call to ha_create_table() and binlogging atomic against concurrent DML
    and DDL operations on target table. Thus by holding both these "locks"
    we ensure that our statement is properly isolated from all concurrent
    operations which matter.
5232
  */
5233
  if (open_tables(thd, &src_table, &not_used, 0))
5234 5235
    DBUG_RETURN(TRUE);

5236 5237 5238 5239 5240 5241
  /*
    For bug#25875, Newly created table through CREATE TABLE .. LIKE
                   has no ndb_dd attributes;
    Add something to get possible tablespace info from src table,
    it can get valid tablespace name only for disk-base ndb table
  */
5242
  if ((src_table->table->file->get_tablespace_name(thd, ts_name, FN_LEN)))
5243 5244 5245 5246 5247
  {
    create_info->tablespace= ts_name;
    create_info->storage_media= HA_SM_DISK;
  }

5248
  strxmov(src_path, src_table->table->s->path.str, reg_ext, NullS);
venu@myvenu.com's avatar
venu@myvenu.com committed
5249

5250
  DBUG_EXECUTE_IF("sleep_create_like_before_check_if_exists", my_sleep(6000000););
venu@myvenu.com's avatar
venu@myvenu.com committed
5251

5252 5253 5254
  /*
    Check that destination tables does not exist. Note that its name
    was already checked when it was added to the table list.
venu@myvenu.com's avatar
venu@myvenu.com committed
5255 5256 5257 5258 5259
  */
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
    if (find_temporary_table(thd, db, table_name))
      goto table_exists;
5260
    dst_path_length= build_tmptable_filename(thd, dst_path, sizeof(dst_path));
venu@myvenu.com's avatar
venu@myvenu.com committed
5261 5262 5263 5264
    create_info->table_options|= HA_CREATE_DELAY_KEY_WRITE;
  }
  else
  {
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
5265 5266 5267 5268
    if (lock_table_name_if_not_cached(thd, db, table_name, &name_lock))
      goto err;
    if (!name_lock)
      goto table_exists;
5269
    dst_path_length= build_table_filename(dst_path, sizeof(dst_path) - 1,
5270
                                          db, table_name, reg_ext, 0);
venu@myvenu.com's avatar
venu@myvenu.com committed
5271 5272 5273 5274
    if (!access(dst_path, F_OK))
      goto table_exists;
  }

5275 5276
  DBUG_EXECUTE_IF("sleep_create_like_before_copy", my_sleep(6000000););

5277 5278
  if (opt_sync_frm && !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
    flags|= MY_SYNC;
5279

5280
  /*
venu@myvenu.com's avatar
venu@myvenu.com committed
5281
    Create a new table by copying from source table
5282
    and sync the new table if the flag MY_SYNC is set
5283 5284 5285 5286 5287 5288 5289 5290 5291 5292

    Altough exclusive name-lock on target table protects us from concurrent
    DML and DDL operations on it we still want to wrap .FRM creation and call
    to ha_create_table() in critical section protected by LOCK_open in order
    to provide minimal atomicity against operations which disregard name-locks,
    like I_S implementation, for example. This is a temporary and should not
    be copied. Instead we should fix our code to always honor name-locks.

    Also some engines (e.g. NDB cluster) require that LOCK_open should be held
    during the call to ha_create_table(). See bug #28614 for more info.
5293
  */
5294
  VOID(pthread_mutex_lock(&LOCK_open));
5295 5296 5297 5298 5299 5300 5301 5302
  if (src_table->schema_table)
  {
    if (mysql_create_like_schema_frm(thd, src_table, dst_path, create_info))
    {
      VOID(pthread_mutex_unlock(&LOCK_open));
      goto err;
    }
  }
5303
  else if (my_copy(src_path, dst_path, flags))
5304 5305 5306 5307 5308
  {
    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);
5309
    VOID(pthread_mutex_unlock(&LOCK_open));
5310
    goto err;
5311
  }
venu@myvenu.com's avatar
venu@myvenu.com committed
5312 5313

  /*
5314 5315
    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
5316 5317
    and temporary tables).
  */
5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330
#ifdef WITH_PARTITION_STORAGE_ENGINE
  /*
    For partitioned tables we need to copy the .par file as well since
    it is used in open_table_def to even be able to create a new handler.
    There is no way to find out here if the original table is a
    partitioned table so we copy the file and ignore any errors.
  */
  fn_format(tmp_path, dst_path, reg_ext, ".par", MYF(MY_REPLACE_EXT));
  strmov(dst_path, tmp_path);
  fn_format(tmp_path, src_path, reg_ext, ".par", MYF(MY_REPLACE_EXT));
  strmov(src_path, tmp_path);
  my_copy(src_path, dst_path, MYF(MY_DONT_OVERWRITE_FILE));
#endif
5331 5332 5333

  DBUG_EXECUTE_IF("sleep_create_like_before_ha_create", my_sleep(6000000););

5334
  dst_path[dst_path_length - reg_ext_length]= '\0';  // Remove .frm
5335 5336
  if (thd->variables.keep_files_on_create)
    create_info->options|= HA_CREATE_KEEP_FILES;
5337
  err= ha_create_table(thd, dst_path, db, table_name, create_info, 1);
5338
  VOID(pthread_mutex_unlock(&LOCK_open));
5339

venu@myvenu.com's avatar
venu@myvenu.com committed
5340 5341 5342 5343
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  {
    if (err || !open_temporary_table(thd, dst_path, db, table_name, 1))
    {
5344 5345
      (void) rm_temporary_table(create_info->db_type,
				dst_path); /* purecov: inspected */
5346
      goto err;     /* purecov: inspected */
venu@myvenu.com's avatar
venu@myvenu.com committed
5347
    }
5348
    thd->thread_specific_used= TRUE;
venu@myvenu.com's avatar
venu@myvenu.com committed
5349 5350 5351
  }
  else if (err)
  {
5352
    (void) quick_rm_table(create_info->db_type, db,
5353
			  table_name, 0); /* purecov: inspected */
5354
    goto err;	    /* purecov: inspected */
venu@myvenu.com's avatar
venu@myvenu.com committed
5355
  }
5356

5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374
goto binlog;

table_exists:
  if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
  {
    char warn_buff[MYSQL_ERRMSG_SIZE];
    my_snprintf(warn_buff, sizeof(warn_buff),
		ER(ER_TABLE_EXISTS_ERROR), table_name);
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		 ER_TABLE_EXISTS_ERROR,warn_buff);
  }
  else
  {
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
    goto err;
  }

binlog:
5375 5376
  DBUG_EXECUTE_IF("sleep_create_like_before_binlogging", my_sleep(6000000););

5377 5378 5379
  /*
    We have to write the query before we unlock the tables.
  */
5380
  if (thd->current_stmt_binlog_row_based)
5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398
  {
    /*
       Since temporary tables are not replicated under row-based
       replication, CREATE TABLE ... LIKE ... needs special
       treatement.  We have four cases to consider, according to the
       following decision table:

           ==== ========= ========= ==============================
           Case    Target    Source Write to binary log
           ==== ========= ========= ==============================
           1       normal    normal Original statement
           2       normal temporary Generated statement
           3    temporary    normal Nothing
           4    temporary temporary Nothing
           ==== ========= ========= ==============================
    */
    if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
    {
5399
      if (src_table->table->s->tmp_table)               // Case 2
5400 5401 5402 5403
      {
        char buf[2048];
        String query(buf, sizeof(buf), system_charset_info);
        query.length(0);  // Have to zero it since constructor doesn't
5404 5405

        /*
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
5406 5407 5408 5409
          Here we open the destination table, on which we already have
          name-lock. This is needed for store_create_info() to work.
          The table will be closed by unlink_open_table() at the end
          of this function.
5410
        */
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
5411 5412 5413 5414 5415
        table->table= name_lock;
        VOID(pthread_mutex_lock(&LOCK_open));
        if (reopen_name_locked_table(thd, table, FALSE))
        {
          VOID(pthread_mutex_unlock(&LOCK_open));
5416
          goto err;
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
5417 5418
        }
        VOID(pthread_mutex_unlock(&LOCK_open));
5419

5420 5421 5422
        IF_DBUG(int result=)
          store_create_info(thd, table, &query,
                            create_info, FALSE /* show_database */);
5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433

        DBUG_ASSERT(result == 0); // store_create_info() always return 0
        write_bin_log(thd, TRUE, query.ptr(), query.length());
      }
      else                                      // Case 1
        write_bin_log(thd, TRUE, thd->query, thd->query_length);
    }
    /*
      Case 3 and 4 does nothing under RBR
    */
  }
5434
  else
5435 5436
    write_bin_log(thd, TRUE, thd->query, thd->query_length);

5437
  res= FALSE;
5438 5439

err:
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
5440
  if (name_lock)
5441 5442
  {
    pthread_mutex_lock(&LOCK_open);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
5443
    unlink_open_table(thd, name_lock, FALSE);
5444 5445
    pthread_mutex_unlock(&LOCK_open);
  }
5446
  DBUG_RETURN(res);
venu@myvenu.com's avatar
venu@myvenu.com committed
5447 5448 5449
}


5450
bool mysql_analyze_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
5451
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5452 5453
  thr_lock_type lock_type = TL_READ_NO_INSERT;

5454 5455
  DBUG_ENTER("mysql_analyze_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
5456
				"analyze", lock_type, 1, 0, 0, 0,
5457
				&handler::ha_analyze, 0));
5458 5459 5460
}


5461
bool mysql_check_table(THD* thd, TABLE_LIST* tables,HA_CHECK_OPT* check_opt)
5462
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5463 5464
  thr_lock_type lock_type = TL_READ_NO_INSERT;

5465 5466
  DBUG_ENTER("mysql_check_table");
  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5467
				"check", lock_type,
5468
				0, 0, HA_OPEN_FOR_REPAIR, 0,
5469
				&handler::ha_check, &view_checksum));
5470 5471
}

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

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
5473
/* table_list should contain just one table */
monty@mysql.com's avatar
monty@mysql.com committed
5474 5475 5476 5477
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
5478 5479 5480 5481 5482 5483
{
  TABLE *table;
  my_bool discard;
  int error;
  DBUG_ENTER("mysql_discard_or_import_tablespace");

monty@mysql.com's avatar
monty@mysql.com committed
5484 5485 5486 5487
  /*
    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
5488

5489
  thd_proc_info(thd, "discard_or_import_tablespace");
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
5490

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

monty@mysql.com's avatar
monty@mysql.com committed
5493 5494 5495 5496 5497
 /*
   We set this flag so that ha_innobase::open and ::external_lock() do
   not complain when we lock the table
 */
  thd->tablespace_op= TRUE;
5498
  if (!(table=open_ltable(thd, table_list, TL_WRITE, 0)))
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
5499 5500 5501 5502
  {
    thd->tablespace_op=FALSE;
    DBUG_RETURN(-1);
  }
5503

5504
  error= table->file->ha_discard_or_import_tablespace(discard);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
5505

5506
  thd_proc_info(thd, "end");
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
5507 5508 5509 5510

  if (error)
    goto err;

monty@mysql.com's avatar
monty@mysql.com committed
5511 5512 5513 5514
  /*
    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
5515 5516 5517
  query_cache_invalidate3(thd, table_list, 0);

  /* The ALTER TABLE is always in its own transaction */
5518 5519
  error = ha_autocommit_or_rollback(thd, 0);
  if (end_active_trans(thd))
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
5520 5521 5522
    error=1;
  if (error)
    goto err;
5523
  write_bin_log(thd, FALSE, thd->query, thd->query_length);
5524

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
5525
err:
5526
  ha_autocommit_or_rollback(thd, error);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
5527
  thd->tablespace_op=FALSE;
5528
  
monty@mysql.com's avatar
monty@mysql.com committed
5529 5530
  if (error == 0)
  {
5531
    my_ok(thd);
monty@mysql.com's avatar
monty@mysql.com committed
5532
    DBUG_RETURN(0);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
5533
  }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
5534

5535 5536
  table->file->print_error(error, MYF(0));
    
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
5537
  DBUG_RETURN(-1);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
5538
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5539

5540

5541 5542
/*
  SYNOPSIS
5543 5544
    compare_tables()
      table                     The original table.
5545 5546
      alter_info                Alter options, fields and keys for the new
                                table.
5547 5548
      create_info               Create options for the new table.
      order_num                 Number of order list elements.
5549 5550 5551 5552 5553 5554 5555 5556
      need_copy_table     OUT   Result of the comparison. Undefined if error.
                                Otherwise is one of:
                                ALTER_TABLE_METADATA_ONLY  No copy needed
                                ALTER_TABLE_DATA_CHANGED   Data changes,
                                                           copy needed
                                ALTER_TABLE_INDEX_CHANGED  Index changes,
                                                           copy might be needed
      key_info_buffer     OUT   An array of KEY structs for new indexes
5557 5558 5559 5560
      index_drop_buffer   OUT   An array of offsets into table->key_info.
      index_drop_count    OUT   The number of elements in the array.
      index_add_buffer    OUT   An array of offsets into key_info_buffer.
      index_add_count     OUT   The number of elements in the array.
5561
      candidate_key_count OUT   The number of candidate keys in original table.
5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572

  DESCRIPTION
    'table' (first argument) contains information of the original
    table, which includes all corresponding parts that the new
    table has in arguments create_list, key_list and create_info.

    By comparing the changes between the original and new table
    we can determine how much it has changed after ALTER TABLE
    and whether we need to make a copy of the table, or just change
    the .frm file.

5573 5574 5575 5576 5577
    If there are no data changes, but index changes, 'index_drop_buffer'
    and/or 'index_add_buffer' are populated with offsets into
    table->key_info or key_info_buffer respectively for the indexes
    that need to be dropped and/or (re-)created.

5578
  RETURN VALUES
5579 5580
    TRUE   error
    FALSE  success
5581 5582
*/

5583 5584 5585 5586 5587 5588
static
bool
compare_tables(TABLE *table,
               Alter_info *alter_info,
               HA_CREATE_INFO *create_info,
               uint order_num,
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
5589
               enum_alter_table_change_level *need_copy_table,
5590 5591
               KEY **key_info_buffer,
               uint **index_drop_buffer, uint *index_drop_count,
5592 5593
               uint **index_add_buffer, uint *index_add_count,
               uint *candidate_key_count)
5594 5595 5596
{
  Field **f_ptr, *field;
  uint changes= 0, tmp;
5597
  uint key_count;
5598 5599
  List_iterator_fast<Create_field> new_field_it, tmp_new_field_it;
  Create_field *new_field, *tmp_new_field;
5600 5601
  KEY_PART_INFO *key_part;
  KEY_PART_INFO *end;
5602
  THD *thd= table->in_use;
5603 5604 5605 5606 5607
  /*
    Remember if the new definition has new VARCHAR column;
    create_info->varchar will be reset in mysql_prepare_create_table.
  */
  bool varchar= create_info->varchar;
5608 5609 5610
  bool not_nullable= true;
  DBUG_ENTER("compare_tables");

5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629
  /*
    Create a copy of alter_info.
    To compare the new and old table definitions, we need to "prepare"
    the new definition - transform it from parser output to a format
    that describes the final table layout (all column defaults are
    initialized, duplicate columns are removed). This is done by
    mysql_prepare_create_table.  Unfortunately,
    mysql_prepare_create_table performs its transformations
    "in-place", that is, modifies the argument.  Since we would
    like to keep compare_tables() idempotent (not altering any
    of the arguments) we create a copy of alter_info here and
    pass it to mysql_prepare_create_table, then use the result
    to evaluate possibility of fast ALTER TABLE, and then
    destroy the copy.
  */
  Alter_info tmp_alter_info(*alter_info, thd->mem_root);
  uint db_options= 0; /* not used */
  /* Create the prepared information. */
  if (mysql_prepare_create_table(thd, create_info,
5630 5631 5632 5633 5634
                                 &tmp_alter_info,
                                 (table->s->tmp_table != NO_TMP_TABLE),
                                 &db_options,
                                 table->file, key_info_buffer,
                                 &key_count, 0))
5635 5636 5637
    DBUG_RETURN(1);
  /* Allocate result buffers. */
  if (! (*index_drop_buffer=
5638
         (uint*) thd->alloc(sizeof(uint) * table->s->keys)) ||
5639
      ! (*index_add_buffer=
5640
         (uint*) thd->alloc(sizeof(uint) * tmp_alter_info.key_list.elements)))
5641
    DBUG_RETURN(1);
5642
  
5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659
  /*
    Some very basic checks. If number of fields changes, or the
    handler, we need to run full ALTER TABLE. In the future
    new fields can be added and old dropped without copy, but
    not yet.

    Test also that engine was not given during ALTER TABLE, or
    we are force to run regular alter table (copy).
    E.g. ALTER TABLE tbl_name ENGINE=MyISAM.

    For the following ones we also want to run regular alter table:
    ALTER TABLE tbl_name ORDER BY ..
    ALTER TABLE tbl_name CONVERT TO CHARACTER SET ..

    At the moment we can't handle altering temporary tables without a copy.
    We also test if OPTIMIZE TABLE was given and was mapped to alter table.
    In that case we always do full copy.
svoj@may.pils.ru's avatar
svoj@may.pils.ru committed
5660 5661 5662 5663 5664 5665 5666 5667

    There was a bug prior to mysql-4.0.25. Number of null fields was
    calculated incorrectly. As a result frm and data files gets out of
    sync after fast alter table. There is no way to determine by which
    mysql version (in 4.0 and 4.1 branches) table was created, thus we
    disable fast alter table for all tables created by mysql versions
    prior to 5.0 branch.
    See BUG#6236.
5668
  */
5669
  if (table->s->fields != alter_info->create_list.elements ||
antony@ppcg5.local's avatar
antony@ppcg5.local committed
5670
      table->s->db_type() != create_info->db_type ||
5671 5672 5673 5674
      table->s->tmp_table ||
      create_info->used_fields & HA_CREATE_USED_ENGINE ||
      create_info->used_fields & HA_CREATE_USED_CHARSET ||
      create_info->used_fields & HA_CREATE_USED_DEFAULT_CHARSET ||
5675
      (table->s->row_type != create_info->row_type) ||
5676 5677
      create_info->used_fields & HA_CREATE_USED_PACK_KEYS ||
      create_info->used_fields & HA_CREATE_USED_MAX_ROWS ||
5678
      (alter_info->flags & (ALTER_RECREATE | ALTER_FOREIGN_KEY)) ||
5679
      order_num ||
svoj@may.pils.ru's avatar
svoj@may.pils.ru committed
5680
      !table->s->mysql_version ||
5681
      (table->s->frm_version < FRM_VER_TRUE_VARCHAR && varchar))
5682 5683 5684 5685
  {
    *need_copy_table= ALTER_TABLE_DATA_CHANGED;
    DBUG_RETURN(0);
  }
5686

5687 5688 5689 5690 5691 5692 5693
  /*
    Use transformed info to evaluate possibility of fast ALTER TABLE
    but use the preserved field to persist modifications.
  */
  new_field_it.init(alter_info->create_list);
  tmp_new_field_it.init(tmp_alter_info.create_list);

5694 5695 5696 5697
  /*
    Go through fields and check if the original ones are compatible
    with new table.
  */
5698 5699 5700 5701 5702
  for (f_ptr= table->field, new_field= new_field_it++,
       tmp_new_field= tmp_new_field_it++;
       (field= *f_ptr);
       f_ptr++, new_field= new_field_it++,
       tmp_new_field= tmp_new_field_it++)
5703 5704 5705 5706
  {
    /* Make sure we have at least the default charset in use. */
    if (!new_field->charset)
      new_field->charset= create_info->default_table_charset;
5707

5708
    /* Check that NULL behavior is same for old and new fields */
5709
    if ((tmp_new_field->flags & NOT_NULL_FLAG) !=
5710
	(uint) (field->flags & NOT_NULL_FLAG))
5711 5712 5713 5714
    {
      *need_copy_table= ALTER_TABLE_DATA_CHANGED;
      DBUG_RETURN(0);
    }
5715 5716 5717

    /* Don't pack rows in old tables if the user has requested this. */
    if (create_info->row_type == ROW_TYPE_DYNAMIC ||
5718
	(tmp_new_field->flags & BLOB_FLAG) ||
Staale Smedseng's avatar
Staale Smedseng committed
5719 5720
	(tmp_new_field->sql_type == MYSQL_TYPE_VARCHAR &&
	create_info->row_type != ROW_TYPE_FIXED))
5721 5722
      create_info->table_options|= HA_OPTION_PACK_RECORD;

5723
    /* Check if field was renamed */
5724
    field->flags&= ~FIELD_IS_RENAMED;
5725 5726
    if (my_strcasecmp(system_charset_info,
		      field->field_name,
5727
		      tmp_new_field->field_name))
5728
      field->flags|= FIELD_IS_RENAMED;      
5729

5730
    /* Evaluate changes bitmap and send to check_if_incompatible_data() */
5731
    if (!(tmp= field->is_equal(tmp_new_field)))
5732 5733 5734 5735
    {
      *need_copy_table= ALTER_TABLE_DATA_CHANGED;
      DBUG_RETURN(0);
    }
5736
    // Clear indexed marker
5737
    field->flags&= ~FIELD_IN_ADD_INDEX;
5738 5739 5740 5741 5742 5743 5744
    changes|= tmp;
  }

  /*
    Go through keys and check if the original ones are compatible
    with new table.
  */
5745 5746 5747
  KEY *table_key;
  KEY *table_key_end= table->key_info + table->s->keys;
  KEY *new_key;
5748
  KEY *new_key_end= *key_info_buffer + key_count;
5749

5750 5751 5752 5753 5754 5755 5756
  DBUG_PRINT("info", ("index count old: %d  new: %d",
                      table->s->keys, key_count));
  /*
    Step through all keys of the old table and search matching new keys.
  */
  *index_drop_count= 0;
  *index_add_count= 0;
5757
  *candidate_key_count= 0;
5758
  for (table_key= table->key_info; table_key < table_key_end; table_key++)
5759
  {
5760 5761 5762 5763
    KEY_PART_INFO *table_part;
    KEY_PART_INFO *table_part_end= table_key->key_part + table_key->key_parts;
    KEY_PART_INFO *new_part;

5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779
   /*
      Check if key is a candidate key, i.e. a unique index with no index
      fields nullable, then key is either already primary key or could
      be promoted to primary key if the original primary key is dropped.
      Count all candidate keys.
    */
    not_nullable= true;
    for (table_part= table_key->key_part;
         table_part < table_part_end;
         table_part++)
    {
      not_nullable= not_nullable && (! table_part->field->maybe_null());
    }
    if ((table_key->flags & HA_NOSAME) && not_nullable)
      (*candidate_key_count)++;

5780
    /* Search a new key with the same name. */
5781
    for (new_key= *key_info_buffer; new_key < new_key_end; new_key++)
5782 5783 5784 5785 5786 5787 5788
    {
      if (! strcmp(table_key->name, new_key->name))
        break;
    }
    if (new_key >= new_key_end)
    {
      /* Key not found. Add the offset of the key to the drop buffer. */
5789
      (*index_drop_buffer)[(*index_drop_count)++]= table_key - table->key_info;
5790 5791 5792 5793 5794 5795 5796 5797 5798 5799
      DBUG_PRINT("info", ("index dropped: '%s'", table_key->name));
      continue;
    }

    /* Check that the key types are compatible between old and new tables. */
    if ((table_key->algorithm != new_key->algorithm) ||
	((table_key->flags & HA_KEYFLAG_MASK) !=
         (new_key->flags & HA_KEYFLAG_MASK)) ||
        (table_key->key_parts != new_key->key_parts))
      goto index_changed;
5800 5801 5802 5803 5804

    /*
      Check that the key parts remain compatible between the old and
      new tables.
    */
5805 5806 5807
    for (table_part= table_key->key_part, new_part= new_key->key_part;
         table_part < table_part_end;
         table_part++, new_part++)
5808 5809 5810
    {
      /*
	Key definition has changed if we are using a different field or
5811 5812
	if the used key part length is different. We know that the fields
        did not change. Comparing field numbers is sufficient.
5813
      */
5814 5815 5816
      if ((table_part->length != new_part->length) ||
          (table_part->fieldnr - 1 != new_part->fieldnr))
	goto index_changed;
5817
    }
5818 5819 5820 5821
    continue;

  index_changed:
    /* Key modified. Add the offset of the key to both buffers. */
5822 5823
    (*index_drop_buffer)[(*index_drop_count)++]= table_key - table->key_info;
    (*index_add_buffer)[(*index_add_count)++]= new_key - *key_info_buffer;
5824 5825 5826 5827 5828 5829
    key_part= new_key->key_part;
    end= key_part + new_key->key_parts;
    for(; key_part != end; key_part++)
    {
      // Mark field to be part of new key 
      field= table->field[key_part->fieldnr];
5830
      field->flags|= FIELD_IN_ADD_INDEX;
5831
    }
5832
    DBUG_PRINT("info", ("index changed: '%s'", table_key->name));
5833
  }
5834
  /*end of for (; table_key < table_key_end;) */
5835

5836 5837 5838
  /*
    Step through all keys of the new table and find matching old keys.
  */
5839
  for (new_key= *key_info_buffer; new_key < new_key_end; new_key++)
5840 5841 5842 5843 5844 5845 5846 5847 5848 5849
  {
    /* Search an old key with the same name. */
    for (table_key= table->key_info; table_key < table_key_end; table_key++)
    {
      if (! strcmp(table_key->name, new_key->name))
        break;
    }
    if (table_key >= table_key_end)
    {
      /* Key not found. Add the offset of the key to the add buffer. */
5850
      (*index_add_buffer)[(*index_add_count)++]= new_key - *key_info_buffer;
5851 5852 5853 5854 5855 5856
      key_part= new_key->key_part;
      end= key_part + new_key->key_parts;
      for(; key_part != end; key_part++)
      {
        // Mark field to be part of new key 
        field= table->field[key_part->fieldnr];
5857
        field->flags|= FIELD_IN_ADD_INDEX;
5858
      }
marty@linux.site's avatar
marty@linux.site committed
5859
      DBUG_PRINT("info", ("index added: '%s'", new_key->name));
5860 5861
    }
  }
5862 5863 5864

  /* Check if changes are compatible with current handler without a copy */
  if (table->file->check_if_incompatible_data(create_info, changes))
5865 5866 5867 5868
  {
    *need_copy_table= ALTER_TABLE_DATA_CHANGED;
    DBUG_RETURN(0);
  }
5869

5870
  if (*index_drop_count || *index_add_count)
5871 5872 5873 5874
  {
    *need_copy_table= ALTER_TABLE_INDEX_CHANGED;
    DBUG_RETURN(0);
  }
5875

5876 5877
  *need_copy_table= ALTER_TABLE_METADATA_ONLY; // Tables are compatible
  DBUG_RETURN(0);
5878 5879 5880
}


andrey@example.com's avatar
andrey@example.com committed
5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906
/*
  Manages enabling/disabling of indexes for ALTER TABLE

  SYNOPSIS
    alter_table_manage_keys()
      table                  Target table
      indexes_were_disabled  Whether the indexes of the from table
                             were disabled
      keys_onoff             ENABLE | DISABLE | LEAVE_AS_IS

  RETURN VALUES
    FALSE  OK
    TRUE   Error
*/

static
bool alter_table_manage_keys(TABLE *table, int indexes_were_disabled,
                             enum enum_enable_or_disable keys_onoff)
{
  int error= 0;
  DBUG_ENTER("alter_table_manage_keys");
  DBUG_PRINT("enter", ("table=%p were_disabled=%d on_off=%d",
             table, indexes_were_disabled, keys_onoff));

  switch (keys_onoff) {
  case ENABLE:
5907
    error= table->file->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
andrey@example.com's avatar
andrey@example.com committed
5908 5909 5910 5911 5912 5913
    break;
  case LEAVE_AS_IS:
    if (!indexes_were_disabled)
      break;
    /* fall-through: disabled indexes */
  case DISABLE:
5914
    error= table->file->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
andrey@example.com's avatar
andrey@example.com committed
5915 5916 5917 5918 5919
  }

  if (error == HA_ERR_WRONG_COMMAND)
  {
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
5920 5921
                        ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
                        table->s->table_name.str);
andrey@example.com's avatar
andrey@example.com committed
5922 5923 5924 5925 5926 5927 5928 5929
    error= 0;
  } else if (error)
    table->file->print_error(error, MYF(0));

  DBUG_RETURN(error);
}


5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968
/**
  Prepare column and key definitions for CREATE TABLE in ALTER TABLE.

  This function transforms parse output of ALTER TABLE - lists of
  columns and keys to add, drop or modify into, essentially,
  CREATE TABLE definition - a list of columns and keys of the new
  table. While doing so, it also performs some (bug not all)
  semantic checks.

  This function is invoked when we know that we're going to
  perform ALTER TABLE via a temporary table -- i.e. fast ALTER TABLE
  is not possible, perhaps because the ALTER statement contains
  instructions that require change in table data, not only in
  table definition or indexes.

  @param[in,out]  thd         thread handle. Used as a memory pool
                              and source of environment information.
  @param[in]      table       the source table, open and locked
                              Used as an interface to the storage engine
                              to acquire additional information about
                              the original table.
  @param[in,out]  create_info A blob with CREATE/ALTER TABLE
                              parameters
  @param[in,out]  alter_info  Another blob with ALTER/CREATE parameters.
                              Originally create_info was used only in
                              CREATE TABLE and alter_info only in ALTER TABLE.
                              But since ALTER might end-up doing CREATE,
                              this distinction is gone and we just carry
                              around two structures.

  @return
    Fills various create_info members based on information retrieved
    from the storage engine.
    Sets create_info->varchar if the table has a VARCHAR column.
    Prepares alter_info->create_list and alter_info->key_list with
    columns and keys of the new table.
  @retval TRUE   error, out of memory or a semantical error in ALTER
                 TABLE instructions
  @retval FALSE  success
5969
*/
5970

5971 5972 5973 5974
static bool
mysql_prepare_alter_table(THD *thd, TABLE *table,
                          HA_CREATE_INFO *create_info,
                          Alter_info *alter_info)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5975
{
5976
  /* New column definitions are added here */
5977
  List<Create_field> new_create_list;
5978 5979 5980
  /* New key definitions are added here */
  List<Key> new_key_list;
  List_iterator<Alter_drop> drop_it(alter_info->drop_list);
5981
  List_iterator<Create_field> def_it(alter_info->create_list);
5982 5983
  List_iterator<Alter_column> alter_it(alter_info->alter_list);
  List_iterator<Key> key_it(alter_info->key_list);
5984 5985 5986
  List_iterator<Create_field> find_it(new_create_list);
  List_iterator<Create_field> field_it(new_create_list);
  List<Key_part_spec> key_parts;
5987 5988 5989 5990 5991
  uint db_create_options= (table->s->db_create_options
                           & ~(HA_OPTION_PACK_RECORD));
  uint used_fields= create_info->used_fields;
  KEY *key_info=table->key_info;
  bool rc= TRUE;
5992

5993
  DBUG_ENTER("mysql_prepare_alter_table");
5994

5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005
  create_info->varchar= FALSE;
  /* Let new create options override the old ones */
  if (!(used_fields & HA_CREATE_USED_MIN_ROWS))
    create_info->min_rows= table->s->min_rows;
  if (!(used_fields & HA_CREATE_USED_MAX_ROWS))
    create_info->max_rows= table->s->max_rows;
  if (!(used_fields & HA_CREATE_USED_AVG_ROW_LENGTH))
    create_info->avg_row_length= table->s->avg_row_length;
  if (!(used_fields & HA_CREATE_USED_DEFAULT_CHARSET))
    create_info->default_table_charset= table->s->table_charset;
  if (!(used_fields & HA_CREATE_USED_AUTO) && table->found_next_number_field)
6006
  {
6007 6008 6009
    /* Table has an autoincrement, copy value to new table */
    table->file->info(HA_STATUS_AUTO);
    create_info->auto_increment_value= table->file->stats.auto_increment_value;
6010
  }
6011 6012
  if (!(used_fields & HA_CREATE_USED_KEY_BLOCK_SIZE))
    create_info->key_block_size= table->s->key_block_size;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6013

6014
  if (!create_info->tablespace && create_info->storage_media != HA_SM_MEMORY)
6015
  {
6016
    char *tablespace= static_cast<char *>(thd->alloc(FN_LEN + 1));
6017
    /*
6018 6019
       Regular alter table of disk stored table (no tablespace/storage change)
       Copy tablespace name
6020
    */
6021 6022 6023 6024 6025
    if (tablespace &&
        (table->file->get_tablespace_name(thd, tablespace, FN_LEN)))
      create_info->tablespace= tablespace;
  }
  restore_record(table, s->default_values);     // Empty record for DEFAULT
6026
  Create_field *def;
6027

6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039
  /*
    First collect all fields from table which isn't in drop_list
  */
  Field **f_ptr,*field;
  for (f_ptr=table->field ; (field= *f_ptr) ; f_ptr++)
  {
    if (field->type() == MYSQL_TYPE_STRING)
      create_info->varchar= TRUE;
    /* Check if field should be dropped */
    Alter_drop *drop;
    drop_it.rewind();
    while ((drop=drop_it++))
6040
    {
6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052
      if (drop->type == Alter_drop::COLUMN &&
	  !my_strcasecmp(system_charset_info,field->field_name, drop->name))
      {
	/* 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;
      }
6053
    }
6054
    if (drop)
6055
    {
6056 6057
      drop_it.remove();
      continue;
6058
    }
6059 6060 6061
    /* Check if field is changed */
    def_it.rewind();
    while ((def=def_it++))
6062
    {
6063 6064 6065
      if (def->change &&
	  !my_strcasecmp(system_charset_info,field->field_name, def->change))
	break;
6066
    }
6067 6068 6069 6070
    if (def)
    {						// Field is changed
      def->field=field;
      if (!def->after)
6071
      {
6072 6073
	new_create_list.push_back(def);
	def_it.remove();
6074 6075
      }
    }
6076
    else
6077 6078
    {
      /*
6079 6080
        This field was not dropped and not changed, add it to the list
        for the new table.
6081
      */
6082
      def= new Create_field(field, field);
6083 6084 6085 6086
      new_create_list.push_back(def);
      alter_it.rewind();			// Change default if ALTER
      Alter_column *alter;
      while ((alter=alter_it++))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6087
      {
6088 6089
	if (!my_strcasecmp(system_charset_info,field->field_name, alter->name))
	  break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6090
      }
6091
      if (alter)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6092
      {
6093
	if (def->sql_type == MYSQL_TYPE_BLOB)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6094
	{
6095
	  my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0), def->change);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
6096
          goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6097
	}
6098 6099 6100 6101 6102
	if ((def->def=alter->def))              // Use new default
          def->flags&= ~NO_DEFAULT_VALUE_FLAG;
        else
          def->flags|= NO_DEFAULT_VALUE_FLAG;
	alter_it.remove();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6103 6104 6105
      }
    }
  }
6106 6107
  def_it.rewind();
  while ((def=def_it++))			// Add new columns
6108
  {
6109
    if (def->change && ! def->field)
6110
    {
6111
      my_error(ER_BAD_FIELD_ERROR, MYF(0), def->change, table->s->table_name.str);
6112
      goto err;
6113
    }
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130
    /*
      Check that the DATE/DATETIME not null field we are going to add is
      either has a default value or the '0000-00-00' is allowed by the
      set sql mode.
      If the '0000-00-00' value isn't allowed then raise the error_if_not_empty
      flag to allow ALTER TABLE only if the table to be altered is empty.
    */
    if ((def->sql_type == MYSQL_TYPE_DATE ||
         def->sql_type == MYSQL_TYPE_NEWDATE ||
         def->sql_type == MYSQL_TYPE_DATETIME) &&
         !alter_info->datetime_field &&
         !(~def->flags & (NO_DEFAULT_VALUE_FLAG | NOT_NULL_FLAG)) &&
         thd->variables.sql_mode & MODE_NO_ZERO_DATE)
    {
        alter_info->datetime_field= def;
        alter_info->error_if_not_empty= TRUE;
    }
6131 6132 6133 6134
    if (!def->after)
      new_create_list.push_back(def);
    else if (def->after == first_keyword)
      new_create_list.push_front(def);
6135
    else
6136
    {
6137
      Create_field *find;
6138 6139 6140 6141 6142 6143 6144 6145
      find_it.rewind();
      while ((find=find_it++))			// Add new columns
      {
	if (!my_strcasecmp(system_charset_info,def->after, find->field_name))
	  break;
      }
      if (!find)
      {
6146
	my_error(ER_BAD_FIELD_ERROR, MYF(0), def->after, table->s->table_name.str);
6147 6148 6149
        goto err;
      }
      find_it.after(def);			// Put element after this
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6150
      alter_info->change_level= ALTER_TABLE_DATA_CHANGED;
6151
    }
6152
  }
6153
  if (alter_info->alter_list.elements)
6154
  {
6155
    my_error(ER_BAD_FIELD_ERROR, MYF(0),
6156
             alter_info->alter_list.head()->name, table->s->table_name.str);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
6157
    goto err;
6158
  }
6159
  if (!new_create_list.elements)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6160
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6161 6162
    my_message(ER_CANT_REMOVE_ALL_FIELDS, ER(ER_CANT_REMOVE_ALL_FIELDS),
               MYF(0));
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
6163
    goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6164 6165 6166
  }

  /*
6167 6168
    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
6169 6170
  */

6171
  for (uint i=0 ; i < table->s->keys ; i++,key_info++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6172
  {
6173
    char *key_name= key_info->name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6174 6175 6176 6177 6178
    Alter_drop *drop;
    drop_it.rewind();
    while ((drop=drop_it++))
    {
      if (drop->type == Alter_drop::KEY &&
6179
	  !my_strcasecmp(system_charset_info,key_name, drop->name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194
	break;
    }
    if (drop)
    {
      drop_it.remove();
      continue;
    }

    KEY_PART_INFO *key_part= key_info->key_part;
    key_parts.empty();
    for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
    {
      if (!key_part->field)
	continue;				// Wrong field (from UNIREG)
      const char *key_part_name=key_part->field->field_name;
6195
      Create_field *cfield;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6196 6197 6198 6199 6200
      field_it.rewind();
      while ((cfield=field_it++))
      {
	if (cfield->change)
	{
6201 6202
	  if (!my_strcasecmp(system_charset_info, key_part_name,
			     cfield->change))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6203 6204
	    break;
	}
6205
	else if (!my_strcasecmp(system_charset_info,
6206
				key_part_name, cfield->field_name))
6207
	  break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6208 6209 6210 6211 6212
      }
      if (!cfield)
	continue;				// Field is removed
      uint key_part_length=key_part->length;
      if (cfield->field)			// Not new field
6213 6214 6215 6216 6217 6218 6219
      {
        /*
          If the field can't have only a part used in a key according to its
          new type, or should not be used partially according to its
          previous type, or the field length is less than the key part
          length, unset the key part length.

6220 6221 6222
          We also unset the key part length if it is the same as the
          old field's length, so the whole new field will be used.

6223 6224 6225 6226
          BLOBs may have cfield->length == 0, which is why we test it before
          checking whether cfield->length < key_part_length (in chars).
         */
        if (!Field::type_can_have_key_part(cfield->field->type()) ||
6227
            !Field::type_can_have_key_part(cfield->sql_type) ||
6228 6229
            /* spatial keys can't have sub-key length */
            (key_info->flags & HA_SPATIAL) ||
bar@mysql.com's avatar
bar@mysql.com committed
6230 6231
            (cfield->field->field_length == key_part_length &&
             !f_is_blob(key_part->key_type)) ||
6232 6233 6234
	    (cfield->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
6235
      }
6236
      key_part_length /= key_part->field->charset()->mbmaxlen;
6237
      key_parts.push_back(new Key_part_spec(cfield->field_name,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6238 6239 6240
					    key_part_length));
    }
    if (key_parts.elements)
6241 6242
    {
      KEY_CREATE_INFO key_create_info;
6243 6244
      Key *key;
      enum Key::Keytype key_type;
6245 6246 6247 6248 6249 6250
      bzero((char*) &key_create_info, sizeof(key_create_info));

      key_create_info.algorithm= key_info->algorithm;
      if (key_info->flags & HA_USES_BLOCK_SIZE)
        key_create_info.block_size= key_info->block_size;
      if (key_info->flags & HA_USES_PARSER)
6251
        key_create_info.parser_name= *plugin_name(key_info->parser);
6252

6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382
      if (key_info->flags & HA_SPATIAL)
        key_type= Key::SPATIAL;
      else if (key_info->flags & HA_NOSAME)
      {
        if (! my_strcasecmp(system_charset_info, key_name, primary_key_name))
          key_type= Key::PRIMARY;
        else
          key_type= Key::UNIQUE;
      }
      else if (key_info->flags & HA_FULLTEXT)
        key_type= Key::FULLTEXT;
      else
        key_type= Key::MULTIPLE;

      key= new Key(key_type, key_name,
                   &key_create_info,
                   test(key_info->flags & HA_GENERATED_KEY),
                   key_parts);
      new_key_list.push_back(key);
    }
  }
  {
    Key *key;
    while ((key=key_it++))			// Add new keys
    {
      if (key->type != Key::FOREIGN_KEY)
        new_key_list.push_back(key);
      if (key->name &&
	  !my_strcasecmp(system_charset_info,key->name,primary_key_name))
      {
	my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name);
        goto err;
      }
    }
  }

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

  if (!create_info->comment.str)
  {
    create_info->comment.str= table->s->comment.str;
    create_info->comment.length= table->s->comment.length;
  }

  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))
    db_create_options&= ~(HA_OPTION_PACK_KEYS | HA_OPTION_NO_PACK_KEYS);
  if (create_info->table_options &
      (HA_OPTION_CHECKSUM | HA_OPTION_NO_CHECKSUM))
    db_create_options&= ~(HA_OPTION_CHECKSUM | HA_OPTION_NO_CHECKSUM);
  if (create_info->table_options &
      (HA_OPTION_DELAY_KEY_WRITE | HA_OPTION_NO_DELAY_KEY_WRITE))
    db_create_options&= ~(HA_OPTION_DELAY_KEY_WRITE |
			  HA_OPTION_NO_DELAY_KEY_WRITE);
  create_info->table_options|= db_create_options;

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

  rc= FALSE;
  alter_info->create_list.swap(new_create_list);
  alter_info->key_list.swap(new_key_list);
err:
  DBUG_RETURN(rc);
}


/*
  Alter table

  SYNOPSIS
    mysql_alter_table()
      thd              Thread handle
      new_db           If there is a RENAME clause
      new_name         If there is a RENAME clause
      create_info      Information from the parsing phase about new
                       table properties.
      table_list       The table to change.
      alter_info       Lists of fields, keys to be changed, added
                       or dropped.
      order_num        How many ORDER BY fields has been specified.
      order            List of fields to ORDER BY.
      ignore           Whether we have ALTER IGNORE TABLE

  DESCRIPTION
    This is a veery long function and is everything but the kitchen sink :)
    It is used to alter a table and not only by ALTER TABLE but also
    CREATE|DROP INDEX are mapped on this function.

    When the ALTER TABLE statement just does a RENAME or ENABLE|DISABLE KEYS,
    or both, then this function short cuts its operation by renaming
    the table and/or enabling/disabling the keys. In this case, the FRM is
    not changed, directly by mysql_alter_table. However, if there is a
    RENAME + change of a field, or an index, the short cut is not used.
    See how `create_list` is used to generate the new FRM regarding the
    structure of the fields. The same is done for the indices of the table.

    Important is the fact, that this function tries to do as little work as
    possible, by finding out whether a intermediate table is needed to copy
    data into and when finishing the altering to use it as the original table.
    For this reason the function compare_tables() is called, which decides
    based on all kind of data how similar are the new and the original
    tables.

  RETURN VALUES
    FALSE  OK
    TRUE   Error
*/

bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
                       HA_CREATE_INFO *create_info,
                       TABLE_LIST *table_list,
                       Alter_info *alter_info,
                       uint order_num, ORDER *order, bool ignore)
{
  TABLE *table, *new_table= 0, *name_lock= 0;
  int error= 0;
6383
  char tmp_name[80],old_name[32],new_name_buff[FN_REFLEN + 1];
6384 6385
  char new_alias_buff[FN_REFLEN], *table_name, *db, *new_alias, *alias;
  char index_file[FN_REFLEN], data_file[FN_REFLEN];
6386
  char path[FN_REFLEN + 1];
6387
  char reg_path[FN_REFLEN+1];
6388
  ha_rows copied,deleted;
6389
  handlerton *old_db_type, *new_db_type, *save_old_db_type;
6390
  legacy_db_type table_type;
6391
  frm_type_enum frm_type;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6392
  enum_alter_table_change_level need_copy_table= ALTER_TABLE_METADATA_ONLY;
6393
#ifdef WITH_PARTITION_STORAGE_ENGINE
6394
  uint fast_alter_partition= 0;
6395 6396
  bool partition_changed= FALSE;
#endif
6397 6398
  bool need_lock_for_indexes= TRUE;
  KEY  *key_info_buffer;
Staale Smedseng's avatar
Staale Smedseng committed
6399 6400 6401 6402 6403
  uint index_drop_count= 0;
  uint *index_drop_buffer= NULL;
  uint index_add_count= 0;
  uint *index_add_buffer= NULL;
  uint candidate_key_count= 0;
6404
  bool committed= 0;
6405
  bool no_pk;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6406 6407
  DBUG_ENTER("mysql_alter_table");

6408 6409 6410 6411 6412 6413
  /*
    Check if we attempt to alter mysql.slow_log or
    mysql.general_log table and return an error if
    it is the case.
    TODO: this design is obsolete and will be removed.
  */
6414
  if (table_list && table_list->db && table_list->table_name)
6415
  {
6416
    int table_kind= 0;
6417

6418 6419 6420
    table_kind= check_if_log_table(table_list->db_length, table_list->db,
                                   table_list->table_name_length,
                                   table_list->table_name, 0);
6421

6422
    if (table_kind)
6423
    {
6424 6425 6426 6427 6428 6429
      /* Disable alter of enabled log tables */
      if (logger.is_log_table_enabled(table_kind))
      {
        my_error(ER_BAD_LOG_STATEMENT, MYF(0), "ALTER");
        DBUG_RETURN(TRUE);
      }
6430

6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442
      /* Disable alter of log tables to unsupported engine */
      if ((create_info->used_fields & HA_CREATE_USED_ENGINE) &&
          (!create_info->db_type || /* unknown engine */
           !(create_info->db_type->flags & HTON_SUPPORT_LOG_TABLES)))
      {
        my_error(ER_UNSUPORTED_LOG_ENGINE, MYF(0));
        DBUG_RETURN(TRUE);
      }

#ifdef WITH_PARTITION_STORAGE_ENGINE
      if (alter_info->flags & ALTER_PARTITION)
      {
6443
        my_error(ER_WRONG_USAGE, MYF(0), "PARTITION", "log table");
6444 6445 6446
        DBUG_RETURN(TRUE);
      }
#endif
6447 6448 6449
    }
  }

6450 6451 6452 6453 6454
  /*
    Assign variables table_name, new_name, db, new_db, path, reg_path
    to simplify further comparisions: we want to see if it's a RENAME
    later just by comparing the pointers, avoiding the need for strcmp.
  */
6455
  thd_proc_info(thd, "init");
6456
  table_name=table_list->table_name;
6457
  alias= (lower_case_table_names == 2) ? table_list->alias : table_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6458
  db=table_list->db;
monty@mysql.com's avatar
monty@mysql.com committed
6459
  if (!new_db || !my_strcasecmp(table_alias_charset, new_db, db))
6460
    new_db= db;
6461 6462
  build_table_filename(reg_path, sizeof(reg_path) - 1, db, table_name, reg_ext, 0);
  build_table_filename(path, sizeof(path) - 1, db, table_name, "", 0);
6463

6464
  mysql_ha_rm_tables(thd, table_list, FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6465

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
6466
  /* DISCARD/IMPORT TABLESPACE is always alone in an ALTER TABLE */
6467
  if (alter_info->tablespace_op != NO_TABLESPACE_OP)
6468
    /* Conditionally writes to binlog. */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
6469
    DBUG_RETURN(mysql_discard_or_import_tablespace(thd,table_list,
6470
						   alter_info->tablespace_op));
6471 6472 6473
  strxnmov(new_name_buff, sizeof (new_name_buff) - 1, mysql_data_home, "/", db, 
           "/", table_name, reg_ext, NullS);
  (void) unpack_filename(new_name_buff, new_name_buff);
6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486
  /*
    If this is just a rename of a view, short cut to the
    following scenario: 1) lock LOCK_open 2) do a RENAME
    2) unlock LOCK_open.
    This is a copy-paste added to make sure
    ALTER (sic:) TABLE .. RENAME works for views. ALTER VIEW is handled
    as an independent branch in mysql_execute_command. The need
    for a copy-paste arose because the main code flow of ALTER TABLE
    ... RENAME tries to use open_ltable, which does not work for views
    (open_ltable was never modified to merge table lists of child tables
    into the main table list, like open_tables does).
    This code is wrong and will be removed, please do not copy.
  */
6487 6488
  frm_type= mysql_frm_type(thd, new_name_buff, &table_type);
  /* Rename a view */
6489
  /* Sic: there is a race here */
6490 6491
  if (frm_type == FRMTYPE_VIEW && !(alter_info->flags & ~ALTER_RENAME))
  {
6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505
    /*
      The following branch handles "ALTER VIEW v1 /no arguments/;"
      This feature is not documented one. 
      However, before "OPTIMIZE TABLE t1;" was implemented, 
      ALTER TABLE with no alter_specifications was used to force-rebuild
      the table. That's why this grammar is allowed. That's why we ignore
      it for views. So just do nothing in such a case.
    */
    if (!new_name)
    {
      my_ok(thd);
      DBUG_RETURN(FALSE);
    }

6506 6507 6508 6509 6510 6511 6512 6513 6514
    /*
      Avoid problems with a rename on a table that we have locked or
      if the user is trying to to do this in a transcation context
    */

    if (thd->locked_tables || thd->active_transaction())
    {
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
6515
      DBUG_RETURN(TRUE);
6516 6517 6518
    }

    if (wait_if_global_read_lock(thd,0,1))
6519
      DBUG_RETURN(TRUE);
6520 6521
    VOID(pthread_mutex_lock(&LOCK_open));
    if (lock_table_names(thd, table_list))
6522
    {
6523
      error= 1;
6524
      goto view_err;
6525
    }
6526 6527 6528 6529 6530 6531
    
    if (!do_rename(thd, table_list, new_db, new_name, new_name, 1))
    {
      if (mysql_bin_log.is_open())
      {
        thd->clear_error();
6532
        Query_log_event qinfo(thd, thd->query, thd->query_length,
6533
                              0, FALSE, 0);
6534 6535
        mysql_bin_log.write(&qinfo);
      }
6536
      my_ok(thd);
6537 6538 6539 6540 6541 6542 6543 6544 6545
    }

    unlock_table_names(thd, table_list, (TABLE_LIST*) 0);

view_err:
    pthread_mutex_unlock(&LOCK_open);
    start_waiting_global_read_lock(thd);
    DBUG_RETURN(error);
  }
6546 6547

  if (!(table= open_n_lock_single_table(thd, table_list, TL_WRITE_ALLOW_READ)))
6548
    DBUG_RETURN(TRUE);
6549
  table->use_all_columns();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6550

6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564
  /*
    Prohibit changing of the UNION list of a non-temporary MERGE table
    under LOCK tables. It would be quite difficult to reuse a shrinked
    set of tables from the old table or to open a new TABLE object for
    an extended list and verify that they belong to locked tables.
  */
  if (thd->locked_tables &&
      (create_info->used_fields & HA_CREATE_USED_UNION) &&
      (table->s->tmp_table == NO_TMP_TABLE))
  {
    my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
    DBUG_RETURN(TRUE);
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6565 6566 6567
  /* Check that we are not trying to rename to an existing table */
  if (new_name)
  {
6568
    DBUG_PRINT("info", ("new_db.new_name: '%s'.'%s'", new_db, new_name));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6569
    strmov(new_name_buff,new_name);
6570
    strmov(new_alias= new_alias_buff, new_name);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6571
    if (lower_case_table_names)
6572 6573 6574
    {
      if (lower_case_table_names != 2)
      {
6575
	my_casedn_str(files_charset_info, new_name_buff);
6576 6577
	new_alias= new_name;			// Create lower case table name
      }
6578
      my_casedn_str(files_charset_info, new_name);
6579
    }
6580
    if (new_db == db &&
monty@mysql.com's avatar
monty@mysql.com committed
6581
	!my_strcasecmp(table_alias_charset, new_name_buff, table_name))
6582 6583
    {
      /*
6584 6585
	Source and destination table names are equal: make later check
	easier.
6586
      */
6587
      new_alias= new_name= table_name;
6588
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6589 6590
    else
    {
6591
      if (table->s->tmp_table != NO_TMP_TABLE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6592 6593 6594
      {
	if (find_temporary_table(thd,new_db,new_name_buff))
	{
6595
	  my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_name_buff);
6596
	  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6597 6598 6599 6600
	}
      }
      else
      {
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
6601 6602 6603 6604 6605 6606 6607 6608
        if (lock_table_name_if_not_cached(thd, new_db, new_name, &name_lock))
          DBUG_RETURN(TRUE);
        if (!name_lock)
        {
	  my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_alias);
	  DBUG_RETURN(TRUE);
        }

6609
        build_table_filename(new_name_buff, sizeof(new_name_buff) - 1,
6610 6611
                             new_db, new_name_buff, reg_ext, 0);
        if (!access(new_name_buff, F_OK))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6612 6613
	{
	  /* Table will be closed in do_command() */
6614
	  my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_alias);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
6615
          goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6616 6617 6618 6619 6620
	}
      }
    }
  }
  else
6621 6622 6623 6624
  {
    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
6625

antony@ppcg5.local's avatar
antony@ppcg5.local committed
6626
  old_db_type= table->s->db_type();
6627
  if (!create_info->db_type)
6628
  {
6629
#ifdef WITH_PARTITION_STORAGE_ENGINE
6630 6631
    if (table->part_info &&
        create_info->used_fields & HA_CREATE_USED_ENGINE)
6632 6633 6634 6635
    {
      /*
        This case happens when the user specified
        ENGINE = x where x is a non-existing storage engine
6636 6637 6638
        We set create_info->db_type to default_engine_type
        to ensure we don't change underlying engine type
        due to a erroneously given engine name.
6639
      */
6640
      create_info->db_type= table->part_info->default_engine_type;
6641
    }
6642
    else
6643
#endif
6644
      create_info->db_type= old_db_type;
6645
  }
6646

6647
  if (check_engine(thd, new_name, create_info))
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
6648
    goto err;
6649
  new_db_type= create_info->db_type;
6650

6651 6652
  if ((new_db_type != old_db_type ||
       alter_info->flags & ALTER_PARTITION) &&
6653
      !table->file->can_switch_engines())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6654
  {
6655
    my_error(ER_ROW_IS_REFERENCED, MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6656 6657 6658
    goto err;
  }

6659
  if (create_info->row_type == ROW_TYPE_NOT_USED)
6660
  {
6661
    create_info->row_type= table->s->row_type;
6662 6663
    create_info->used_fields |= HA_CREATE_USED_ROW_FORMAT;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6664

6665 6666 6667
  DBUG_PRINT("info", ("old type: %s  new type: %s",
             ha_resolve_storage_engine_name(old_db_type),
             ha_resolve_storage_engine_name(new_db_type)));
monty@mysql.com's avatar
monty@mysql.com committed
6668
  if (ha_check_storage_engine_flag(old_db_type, HTON_ALTER_NOT_SUPPORTED) ||
6669
      ha_check_storage_engine_flag(new_db_type, HTON_ALTER_NOT_SUPPORTED))
6670 6671 6672
  {
    DBUG_PRINT("info", ("doesn't support alter"));
    my_error(ER_ILLEGAL_HA, MYF(0), table_name);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
6673
    goto err;
6674 6675
  }
  
6676
  thd_proc_info(thd, "setup");
6677
  if (!(alter_info->flags & ~(ALTER_RENAME | ALTER_KEYS_ONOFF)) &&
6678
      !table->s->tmp_table) // no need to touch frm
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6679
  {
6680 6681 6682 6683
    switch (alter_info->keys_onoff) {
    case LEAVE_AS_IS:
      break;
    case ENABLE:
6684 6685 6686 6687 6688 6689 6690 6691 6692 6693
      /*
        wait_while_table_is_used() ensures that table being altered is
        opened only by this thread and that TABLE::TABLE_SHARE::version
        of TABLE object corresponding to this table is 0.
        The latter guarantees that no DML statement will open this table
        until ALTER TABLE finishes (i.e. until close_thread_tables())
        while the fact that the table is still open gives us protection
        from concurrent DDL statements.
      */
      VOID(pthread_mutex_lock(&LOCK_open));
6694
      wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
6695
      VOID(pthread_mutex_unlock(&LOCK_open));
6696
      DBUG_EXECUTE_IF("sleep_alter_enable_indexes", my_sleep(6000000););
6697
      error= table->file->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
6698 6699 6700
      /* COND_refresh will be signaled in close_thread_tables() */
      break;
    case DISABLE:
6701
      VOID(pthread_mutex_lock(&LOCK_open));
6702
      wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
6703
      VOID(pthread_mutex_unlock(&LOCK_open));
6704
      error=table->file->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
6705 6706
      /* COND_refresh will be signaled in close_thread_tables() */
      break;
6707 6708 6709 6710
    default:
      DBUG_ASSERT(FALSE);
      error= 0;
      break;
6711 6712 6713
    }
    if (error == HA_ERR_WRONG_COMMAND)
    {
6714
      error= 0;
6715 6716 6717 6718 6719
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
			  ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
			  table->alias);
    }

6720 6721 6722 6723 6724 6725 6726 6727 6728 6729
    VOID(pthread_mutex_lock(&LOCK_open));
    /*
      Unlike to the above case close_cached_table() below will remove ALL
      instances of TABLE from table cache (it will also remove table lock
      held by this thread). So to make actual table renaming and writing
      to binlog atomic we have to put them into the same critical section
      protected by LOCK_open mutex. This also removes gap for races between
      access() and mysql_rename_table() calls.
    */

6730
    if (!error && (new_name != table_name || new_db != db))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6731
    {
6732
      thd_proc_info(thd, "rename");
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745
      /*
        Then do a 'simple' rename of the table. First we need to close all
        instances of 'source' table.
      */
      close_cached_table(thd, table);
      /*
        Then, we want check once again that target table does not exist.
        Actually the order of these two steps does not matter since
        earlier we took name-lock on the target table, so we do them
        in this particular order only to be consistent with 5.0, in which
        we don't take this name-lock and where this order really matters.
        TODO: Investigate if we need this access() check at all.
      */
6746 6747
      if (!access(new_name_buff,F_OK))
      {
6748
	my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_name);
6749
	error= -1;
6750 6751 6752
      }
      else
      {
6753 6754 6755 6756 6757 6758 6759 6760 6761 6762
	*fn_ext(new_name)=0;
	if (mysql_rename_table(old_db_type,db,table_name,new_db,new_alias, 0))
	  error= -1;
        else if (Table_triggers_list::change_table_name(thd, db, table_name,
                                                        new_db, new_alias))
        {
          VOID(mysql_rename_table(old_db_type, new_db, new_alias, db,
                                  table_name, 0));
          error= -1;
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6763 6764
      }
    }
6765

6766 6767 6768 6769 6770 6771
    if (error == HA_ERR_WRONG_COMMAND)
    {
      error= 0;
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
			  ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
			  table->alias);
6772
    }
6773

6774 6775 6776
    if (!error)
    {
      write_bin_log(thd, TRUE, thd->query, thd->query_length);
6777
      my_ok(thd);
6778
    }
6779
    else if (error > 0)
6780
    {
6781 6782
      table->file->print_error(error, MYF(0));
      error= -1;
6783
    }
6784 6785 6786 6787 6788 6789
    if (name_lock)
      unlink_open_table(thd, name_lock, FALSE);
    VOID(pthread_mutex_unlock(&LOCK_open));
    table_list->table= NULL;                    // For query cache
    query_cache_invalidate3(thd, table_list, 0);
    DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6790 6791
  }

6792
  /* We have to do full alter table. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6793

6794 6795 6796
#ifdef WITH_PARTITION_STORAGE_ENGINE
  if (prep_alter_part_table(thd, table, alter_info, create_info, old_db_type,
                            &partition_changed, &fast_alter_partition))
6797
    goto err;
6798 6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810
#endif
  /*
    If the old table had partitions and we are doing ALTER TABLE ...
    engine= <new_engine>, the new table must preserve the original
    partitioning. That means that the new engine is still the
    partitioning engine, not the engine specified in the parser.
    This is discovered  in prep_alter_part_table, which in such case
    updates create_info->db_type.
    Now we need to update the stack copy of create_info->db_type,
    as otherwise we won't be able to correctly move the files of the
    temporary table to the result table files.
  */
  new_db_type= create_info->db_type;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6811

6812 6813
  if (mysql_prepare_alter_table(thd, table, create_info, alter_info))
    goto err;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6814 6815
  
  need_copy_table= alter_info->change_level;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6816

6817 6818
  set_table_default_charset(thd, create_info, db);

6819
  if (thd->variables.old_alter_table
antony@ppcg5.local's avatar
antony@ppcg5.local committed
6820
      || (table->s->db_type() != create_info->db_type)
6821
#ifdef WITH_PARTITION_STORAGE_ENGINE
6822
      || partition_changed
6823
#endif
6824
     )
6825
    need_copy_table= ALTER_TABLE_DATA_CHANGED;
6826
  else
6827
  {
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
6828
    enum_alter_table_change_level need_copy_table_res;
6829
    /* Check how much the tables differ. */
6830 6831
    if (compare_tables(table, alter_info,
                       create_info, order_num,
6832
                       &need_copy_table_res,
6833 6834
                       &key_info_buffer,
                       &index_drop_buffer, &index_drop_count,
6835 6836
                       &index_add_buffer, &index_add_count,
                       &candidate_key_count))
6837
      goto err;
6838 6839 6840
   
    if (need_copy_table == ALTER_TABLE_METADATA_ONLY)
      need_copy_table= need_copy_table_res;
6841 6842 6843 6844 6845 6846 6847 6848 6849 6850
  }

  /*
    If there are index changes only, try to do them online. "Index
    changes only" means also that the handler for the table does not
    change. The table is open and locked. The handler can be accessed.
  */
  if (need_copy_table == ALTER_TABLE_INDEX_CHANGED)
  {
    int   pk_changed= 0;
6851
    ulong alter_flags= 0;
6852 6853 6854 6855 6856 6857
    ulong needed_online_flags= 0;
    ulong needed_fast_flags= 0;
    KEY   *key;
    uint  *idx_p;
    uint  *idx_end_p;

6858
    alter_flags= table->file->alter_table_flags(alter_info->flags);
6859
    DBUG_PRINT("info", ("alter_flags: %lu", alter_flags));
6860 6861 6862 6863 6864 6865 6866 6867 6868
    /* Check dropped indexes. */
    for (idx_p= index_drop_buffer, idx_end_p= idx_p + index_drop_count;
         idx_p < idx_end_p;
         idx_p++)
    {
      key= table->key_info + *idx_p;
      DBUG_PRINT("info", ("index dropped: '%s'", key->name));
      if (key->flags & HA_NOSAME)
      {
6869 6870 6871 6872 6873
        /* 
           Unique key. Check for "PRIMARY". 
           or if dropping last unique key
        */
        if ((uint) (key - table->key_info) == table->s->primary_key)
6874
        {
6875
          DBUG_PRINT("info", ("Dropping primary key"));
6876 6877 6878 6879
          /* Primary key. */
          needed_online_flags|=  HA_ONLINE_DROP_PK_INDEX;
          needed_fast_flags|= HA_ONLINE_DROP_PK_INDEX_NO_WRITES;
          pk_changed++;
6880
          candidate_key_count--;
6881 6882 6883
        }
        else
        {
6884 6885 6886
          KEY_PART_INFO *part_end= key->key_part + key->key_parts;
          bool is_candidate_key= true;

6887 6888 6889
          /* Non-primary unique key. */
          needed_online_flags|=  HA_ONLINE_DROP_UNIQUE_INDEX;
          needed_fast_flags|= HA_ONLINE_DROP_UNIQUE_INDEX_NO_WRITES;
6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902

          /*
            Check if all fields in key are declared
            NOT NULL and adjust candidate_key_count
          */
          for (KEY_PART_INFO *key_part= key->key_part;
               key_part < part_end;
               key_part++)
            is_candidate_key=
              (is_candidate_key && 
               (! table->field[key_part->fieldnr-1]->maybe_null()));
          if (is_candidate_key)
            candidate_key_count--;
6903 6904 6905 6906 6907 6908 6909 6910 6911
        }
      }
      else
      {
        /* Non-unique key. */
        needed_online_flags|=  HA_ONLINE_DROP_INDEX;
        needed_fast_flags|= HA_ONLINE_DROP_INDEX_NO_WRITES;
      }
    }
6912 6913
    no_pk= ((table->s->primary_key == MAX_KEY) ||
            (needed_online_flags & HA_ONLINE_DROP_PK_INDEX));
6914 6915 6916 6917 6918 6919 6920 6921 6922
    /* Check added indexes. */
    for (idx_p= index_add_buffer, idx_end_p= idx_p + index_add_count;
         idx_p < idx_end_p;
         idx_p++)
    {
      key= key_info_buffer + *idx_p;
      DBUG_PRINT("info", ("index added: '%s'", key->name));
      if (key->flags & HA_NOSAME)
      {
6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947
        /* Unique key */

        KEY_PART_INFO *part_end= key->key_part + key->key_parts;    
        bool is_candidate_key= true;

        /*
          Check if all fields in key are declared
          NOT NULL
         */
        for (KEY_PART_INFO *key_part= key->key_part;
             key_part < part_end;
             key_part++)
          is_candidate_key=
            (is_candidate_key && 
             (! table->field[key_part->fieldnr]->maybe_null()));

        /*
           Check for "PRIMARY"
           or if adding first unique key
           defined on non-nullable fields
        */

        if ((!my_strcasecmp(system_charset_info,
                            key->name, primary_key_name)) ||
            (no_pk && candidate_key_count == 0 && is_candidate_key))
6948
        {
6949
          DBUG_PRINT("info", ("Adding primary key"));
6950 6951 6952 6953
          /* Primary key. */
          needed_online_flags|=  HA_ONLINE_ADD_PK_INDEX;
          needed_fast_flags|= HA_ONLINE_ADD_PK_INDEX_NO_WRITES;
          pk_changed++;
6954
          no_pk= false;
6955 6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967 6968 6969 6970
        }
        else
        {
          /* Non-primary unique key. */
          needed_online_flags|=  HA_ONLINE_ADD_UNIQUE_INDEX;
          needed_fast_flags|= HA_ONLINE_ADD_UNIQUE_INDEX_NO_WRITES;
        }
      }
      else
      {
        /* Non-unique key. */
        needed_online_flags|=  HA_ONLINE_ADD_INDEX;
        needed_fast_flags|= HA_ONLINE_ADD_INDEX_NO_WRITES;
      }
    }

6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983 6984
    if ((candidate_key_count > 0) && 
        (needed_online_flags & HA_ONLINE_DROP_PK_INDEX))
    {
      /*
        Dropped primary key when there is some other unique 
        not null key that should be converted to primary key
      */
      needed_online_flags|=  HA_ONLINE_ADD_PK_INDEX;
      needed_fast_flags|= HA_ONLINE_ADD_PK_INDEX_NO_WRITES;
      pk_changed= 2;
    }

    DBUG_PRINT("info", ("needed_online_flags: 0x%lx, needed_fast_flags: 0x%lx",
                        needed_online_flags, needed_fast_flags));
6985 6986 6987 6988 6989 6990 6991 6992 6993 6994 6995
    /*
      Online or fast add/drop index is possible only if
      the primary key is not added and dropped in the same statement.
      Otherwise we have to recreate the table.
      need_copy_table is no-zero at this place.
    */
    if ( pk_changed < 2 )
    {
      if ((alter_flags & needed_online_flags) == needed_online_flags)
      {
        /* All required online flags are present. */
6996
        need_copy_table= ALTER_TABLE_METADATA_ONLY;
6997 6998 6999 7000 7001
        need_lock_for_indexes= FALSE;
      }
      else if ((alter_flags & needed_fast_flags) == needed_fast_flags)
      {
        /* All required fast flags are present. */
7002
        need_copy_table= ALTER_TABLE_METADATA_ONLY;
7003 7004 7005 7006 7007
      }
    }
    DBUG_PRINT("info", ("need_copy_table: %u  need_lock: %d",
                        need_copy_table, need_lock_for_indexes));
  }
7008

7009 7010
  /*
    better have a negative test here, instead of positive, like
monty@mysql.com's avatar
monty@mysql.com committed
7011
    alter_info->flags & ALTER_ADD_COLUMN|ALTER_ADD_INDEX|...
7012 7013
    so that ALTER TABLE won't break when somebody will add new flag
  */
7014
  if (need_copy_table == ALTER_TABLE_METADATA_ONLY)
7015
    create_info->frm_only= 1;
7016

7017
#ifdef WITH_PARTITION_STORAGE_ENGINE
7018
  if (fast_alter_partition)
7019
  {
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
7020
    DBUG_ASSERT(!name_lock);
7021 7022 7023 7024
    DBUG_RETURN(fast_alter_partition_table(thd, table, alter_info,
                                           create_info, table_list,
                                           db, table_name,
                                           fast_alter_partition));
7025
  }
7026
#endif
7027

7028 7029 7030 7031 7032 7033
  my_snprintf(tmp_name, sizeof(tmp_name), "%s-%lx_%lx", tmp_file_prefix,
	      current_pid, thd->thread_id);
  /* Safety fix for innodb */
  if (lower_case_table_names)
    my_casedn_str(files_charset_info, tmp_name);

7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048
  /*
    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.
7049 7050
      At end, rename intermediate tables, and symlinks to intermediate
      table, to final table name.
7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076
      Remove old table and old symlinks

    If rename is made to another database:
      Create new tables in new database.
      Copy data.
      Remove old table and symlinks.
  */
  if (!strcmp(db, new_db))		// Ignore symlink if db changed
  {
    if (create_info->index_file_name)
    {
      /* Fix index_file_name to have 'tmp_name' as basename */
      strmov(index_file, tmp_name);
      create_info->index_file_name=fn_same(index_file,
					   create_info->index_file_name,
					   1);
    }
    if (create_info->data_file_name)
    {
      /* Fix data_file_name to have 'tmp_name' as basename */
      strmov(data_file, tmp_name);
      create_info->data_file_name=fn_same(data_file,
					  create_info->data_file_name,
					  1);
    }
  }
7077 7078
  else
    create_info->data_file_name=create_info->index_file_name=0;
monty@mysql.com's avatar
monty@mysql.com committed
7079

7080 7081 7082 7083 7084 7085
  /*
    Create a table with a temporary name.
    With create_info->frm_only == 1 this creates a .frm file only.
    We don't log the statement, it will be logged later.
  */
  tmp_disable_binlog(thd);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
7086
  error= mysql_create_table_no_lock(thd, new_db, tmp_name,
7087 7088 7089
                                    create_info,
                                    alter_info,
                                    1, 0);
7090 7091
  reenable_binlog(thd);
  if (error)
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
7092
    goto err;
7093 7094

  /* Open the table if we need to copy the data. */
7095
  DBUG_PRINT("info", ("need_copy_table: %u", need_copy_table));
7096
  if (need_copy_table != ALTER_TABLE_METADATA_ONLY)
7097
  {
7098
    if (table->s->tmp_table)
7099 7100 7101 7102
    {
      TABLE_LIST tbl;
      bzero((void*) &tbl, sizeof(tbl));
      tbl.db= new_db;
7103
      tbl.table_name= tbl.alias= tmp_name;
7104
      /* Table is in thd->temporary_tables */
7105 7106
      new_table= open_table(thd, &tbl, thd->mem_root, (bool*) 0,
                            MYSQL_LOCK_IGNORE_FLUSH);
7107 7108 7109
    }
    else
    {
7110
      char path[FN_REFLEN + 1];
7111
      /* table is a normal table: Create temporary table in same directory */
7112
      build_table_filename(path, sizeof(path) - 1, new_db, tmp_name, "",
7113
                           FN_IS_TMP);
7114
      /* Open our intermediate table */
7115 7116 7117
      new_table=open_temporary_table(thd, path, new_db, tmp_name,0);
    }
    if (!new_table)
7118
      goto err1;
7119 7120 7121 7122
    /*
      Note: In case of MERGE table, we do not attach children. We do not
      copy data for MERGE tables. Only the children have data.
    */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7123 7124
  }

7125
  /* Copy the data if necessary. */
7126
  thd->count_cuted_fields= CHECK_FIELD_WARN;	// calc cuted fields
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7127
  thd->cuted_fields=0L;
7128
  copied=deleted=0;
7129 7130 7131 7132
  /*
    We do not copy data for MERGE tables. Only the children have data.
    MERGE tables have HA_NO_COPY_ON_ALTER set.
  */
7133
  if (new_table && !(new_table->file->ha_table_flags() & HA_NO_COPY_ON_ALTER))
7134
  {
7135
    /* We don't want update TIMESTAMP fields during ALTER TABLE. */
monty@mysql.com's avatar
monty@mysql.com committed
7136
    new_table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
7137
    new_table->next_number_field=new_table->found_next_number_field;
7138
    thd_proc_info(thd, "copy to tmp table");
7139 7140 7141
    error= copy_data_between_tables(table, new_table,
                                    alter_info->create_list, ignore,
                                    order_num, order, &copied, &deleted,
7142
                                    alter_info->keys_onoff,
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
7143
                                    alter_info->error_if_not_empty);
7144
  }
7145
  else
7146 7147 7148
  {
    VOID(pthread_mutex_lock(&LOCK_open));
    wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
7149
    VOID(pthread_mutex_unlock(&LOCK_open));
7150
    thd_proc_info(thd, "manage keys");
7151 7152
    alter_table_manage_keys(table, table->file->indexes_are_disabled(),
                            alter_info->keys_onoff);
7153 7154
    error= ha_autocommit_or_rollback(thd, 0);
    if (end_active_trans(thd))
7155
      error= 1;
7156
  }
7157
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7158

7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171
  /* If we did not need to copy, we might still need to add/drop indexes. */
  if (! new_table)
  {
    uint          *key_numbers;
    uint          *keyno_p;
    KEY           *key_info;
    KEY           *key;
    uint          *idx_p;
    uint          *idx_end_p;
    KEY_PART_INFO *key_part;
    KEY_PART_INFO *part_end;
    DBUG_PRINT("info", ("No new_table, checking add/drop index"));

7172
    table->file->ha_prepare_for_alter();
7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199
    if (index_add_count)
    {
      /* The add_index() method takes an array of KEY structs. */
      key_info= (KEY*) thd->alloc(sizeof(KEY) * index_add_count);
      key= key_info;
      for (idx_p= index_add_buffer, idx_end_p= idx_p + index_add_count;
           idx_p < idx_end_p;
           idx_p++, key++)
      {
        /* Copy the KEY struct. */
        *key= key_info_buffer[*idx_p];
        /* Fix the key parts. */
        part_end= key->key_part + key->key_parts;
        for (key_part= key->key_part; key_part < part_end; key_part++)
          key_part->field= table->field[key_part->fieldnr];
      }
      /* Add the indexes. */
      if ((error= table->file->add_index(table, key_info, index_add_count)))
      {
        /*
          Exchange the key_info for the error message. If we exchange
          key number by key name in the message later, we need correct info.
        */
        KEY *save_key_info= table->key_info;
        table->key_info= key_info;
        table->file->print_error(error, MYF(0));
        table->key_info= save_key_info;
7200
        goto err1;
7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222
      }
    }
    /*end of if (index_add_count)*/

    if (index_drop_count)
    {
      /* The prepare_drop_index() method takes an array of key numbers. */
      key_numbers= (uint*) thd->alloc(sizeof(uint) * index_drop_count);
      keyno_p= key_numbers;
      /* Get the number of each key. */
      for (idx_p= index_drop_buffer, idx_end_p= idx_p + index_drop_count;
           idx_p < idx_end_p;
           idx_p++, keyno_p++)
        *keyno_p= *idx_p;
      /*
        Tell the handler to prepare for drop indexes.
        This re-numbers the indexes to get rid of gaps.
      */
      if ((error= table->file->prepare_drop_index(table, key_numbers,
                                                  index_drop_count)))
      {
        table->file->print_error(error, MYF(0));
7223
        goto err1;
7224 7225 7226 7227 7228 7229
      }

      /* Tell the handler to finally drop the indexes. */
      if ((error= table->file->final_drop_index(table)))
      {
        table->file->print_error(error, MYF(0));
7230
        goto err1;
7231 7232 7233 7234
      }
    }
    /*end of if (index_drop_count)*/

7235 7236 7237 7238
    /*
      The final .frm file is already created as a temporary file
      and will be renamed to the original table name later.
    */
7239

7240 7241
    /* Need to commit before a table is unlocked (NDB requirement). */
    DBUG_PRINT("info", ("Committing before unlocking table"));
7242
    if (ha_autocommit_or_rollback(thd, 0) || end_active_trans(thd))
7243
      goto err1;
7244
    committed= 1;
7245 7246 7247
  }
  /*end of if (! new_table) for add/drop index*/

7248
  if (table->s->tmp_table != NO_TMP_TABLE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7249 7250 7251
  {
    /* We changed a temporary table */
    if (error)
7252
      goto err1;
7253 7254 7255 7256 7257 7258
    /* 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
7259
    /* Remove link to old table and rename the new one */
7260
    close_temporary_table(thd, table, 1, 1);
7261 7262
    /* Should pass the 'new_name' as we store table name in the cache */
    if (rename_temporary_table(thd, new_table, new_db, new_name))
7263
      goto err1;
7264
    /* We don't replicate alter table statement on temporary tables */
7265
    if (!thd->current_stmt_binlog_row_based)
7266
      write_bin_log(thd, TRUE, thd->query, thd->query_length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7267 7268 7269
    goto end_temporary;
  }

7270 7271
  if (new_table)
  {
7272 7273 7274 7275
    /*
      Close the intermediate table that will be the new table.
      Note that MERGE tables do not have their children attached here.
    */
7276
    intern_close_table(new_table);
7277
    my_free(new_table,MYF(0));
7278
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7279 7280 7281
  VOID(pthread_mutex_lock(&LOCK_open));
  if (error)
  {
7282
    VOID(quick_rm_table(new_db_type, new_db, tmp_name, FN_IS_TMP));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7283 7284 7285
    VOID(pthread_mutex_unlock(&LOCK_open));
    goto err;
  }
7286

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7287
  /*
7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300
    Data is copied. Now we:
    1) Wait until all other threads close old version of table.
    2) Close instances of table open by this thread and replace them
       with exclusive name-locks.
    3) Rename the old table to a temp name, rename the new one to the
       old name.
    4) If we are under LOCK TABLES and don't do ALTER TABLE ... RENAME
       we reopen new version of table.
    5) Write statement to the binary log.
    6) If we are under LOCK TABLES and do ALTER TABLE ... RENAME we
       remove name-locks from list of open tables and table cache.
    7) If we are not not under LOCK TABLES we rely on close_thread_tables()
       call to remove name-locks from table cache and list of open table.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7301 7302
  */

7303
  thd_proc_info(thd, "rename result table");
7304 7305
  my_snprintf(old_name, sizeof(old_name), "%s2-%lx-%lx", tmp_file_prefix,
	      current_pid, thd->thread_id);
7306 7307
  if (lower_case_table_names)
    my_casedn_str(files_charset_info, old_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7308

7309
  wait_while_table_is_used(thd, table, HA_EXTRA_PREPARE_FOR_RENAME);
7310
  close_data_files_and_morph_locks(thd, db, table_name);
7311

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7312
  error=0;
7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324 7325 7326 7327
  save_old_db_type= old_db_type;

  /*
    This leads to the storage engine (SE) not being notified for renames in
    mysql_rename_table(), because we just juggle with the FRM and nothing
    more. If we have an intermediate table, then we notify the SE that
    it should become the actual table. Later, we will recycle the old table.
    However, in case of ALTER TABLE RENAME there might be no intermediate
    table. This is when the old and new tables are compatible, according to
    compare_table(). Then, we need one additional call to
    mysql_rename_table() with flag NO_FRM_RENAME, which does nothing else but
    actual rename in the SE and the FRM is not touched. Note that, if the
    table is renamed and the SE is also changed, then an intermediate table
    is created and the additional call will not take place.
  */
7328 7329 7330 7331 7332 7333
  if (need_copy_table == ALTER_TABLE_METADATA_ONLY)
  {
    DBUG_ASSERT(new_db_type == old_db_type);
    /* This type cannot happen in regular ALTER. */
    new_db_type= old_db_type= NULL;
  }
7334 7335
  if (mysql_rename_table(old_db_type, db, table_name, db, old_name,
                         FN_TO_IS_TMP))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7336 7337
  {
    error=1;
7338
    VOID(quick_rm_table(new_db_type, new_db, tmp_name, FN_IS_TMP));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7339
  }
7340
  else if (mysql_rename_table(new_db_type, new_db, tmp_name, new_db,
7341
                              new_alias, FN_FROM_IS_TMP) ||
7342
           ((new_name != table_name || new_db != db) && // we also do rename
7343
           (need_copy_table != ALTER_TABLE_METADATA_ONLY ||
7344 7345
            mysql_rename_table(save_old_db_type, db, table_name, new_db,
                               new_alias, NO_FRM_RENAME)) &&
7346
           Table_triggers_list::change_table_name(thd, db, table_name,
7347
                                                  new_db, new_alias)))
7348 7349
  {
    /* Try to get everything back. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7350
    error=1;
7351 7352 7353 7354
    VOID(quick_rm_table(new_db_type,new_db,new_alias, 0));
    VOID(quick_rm_table(new_db_type, new_db, tmp_name, FN_IS_TMP));
    VOID(mysql_rename_table(old_db_type, db, old_name, db, alias,
                            FN_FROM_IS_TMP));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7355
  }
7356

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7357 7358
  if (error)
  {
7359 7360
    /* This shouldn't happen. But let us play it safe. */
    goto err_with_placeholders;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7361
  }
7362

7363
  if (need_copy_table == ALTER_TABLE_METADATA_ONLY)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7364
  {
7365
    /*
7366 7367
      Now we have to inform handler that new .FRM file is in place.
      To do this we need to obtain a handler object for it.
7368
      NO need to tamper with MERGE tables. The real open is done later.
7369
    */
7370 7371 7372 7373 7374 7375 7376 7377
    TABLE *t_table;
    if (new_name != table_name || new_db != db)
    {
      table_list->alias= new_name;
      table_list->table_name= new_name;
      table_list->table_name_length= strlen(new_name);
      table_list->db= new_db;
      table_list->db_length= strlen(new_db);
7378 7379
      table_list->table= name_lock;
      if (reopen_name_locked_table(thd, table_list, FALSE))
7380 7381
        goto err_with_placeholders;
      t_table= table_list->table;
7382
    }
7383
    else
7384
    {
7385 7386 7387
      if (reopen_table(table))
        goto err_with_placeholders;
      t_table= table;
7388 7389
    }
    /* Tell the handler that a new frm file is in place. */
7390 7391
    if (t_table->file->ha_create_handler_files(path, NULL, CHF_INDEX_FLAG,
                                               create_info))
7392 7393
      goto err_with_placeholders;
    if (thd->locked_tables && new_name == table_name && new_db == db)
7394
    {
7395 7396 7397 7398 7399 7400 7401 7402
      /*
        We are going to reopen table down on the road, so we have to restore
        state of the TABLE object which we used for obtaining of handler
        object to make it suitable for reopening.
      */
      DBUG_ASSERT(t_table == table);
      table->open_placeholder= 1;
      close_handle_and_leave_table_as_lock(table);
7403 7404
    }
  }
7405

7406 7407 7408
  VOID(quick_rm_table(old_db_type, db, old_name, FN_IS_TMP));

  if (thd->locked_tables && new_name == table_name && new_db == db)
7409
  {
7410
    thd->in_lock_tables= 1;
7411
    error= reopen_tables(thd, 1, 1);
7412
    thd->in_lock_tables= 0;
7413
    if (error)
7414
      goto err_with_placeholders;
7415
  }
7416
  VOID(pthread_mutex_unlock(&LOCK_open));
7417

7418
  thd_proc_info(thd, "end");
7419

7420 7421
  DBUG_EXECUTE_IF("sleep_alter_before_main_binlog", my_sleep(6000000););

7422 7423 7424 7425
  ha_binlog_log_query(thd, create_info->db_type, LOGCOM_ALTER_TABLE,
                      thd->query, thd->query_length,
                      db, table_name);

7426 7427
  DBUG_ASSERT(!(mysql_bin_log.is_open() &&
                thd->current_stmt_binlog_row_based &&
7428 7429
                (create_info->options & HA_LEX_CREATE_TMP_TABLE)));
  write_bin_log(thd, TRUE, thd->query, thd->query_length);
7430

7431
  if (ha_check_storage_engine_flag(old_db_type, HTON_FLUSH_AFTER_RENAME))
7432
  {
7433 7434 7435
    /*
      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
7436
      shutdown. But we do not need to attach MERGE children.
7437
    */
7438
    char path[FN_REFLEN];
7439
    TABLE *t_table;
7440
    build_table_filename(path + 1, sizeof(path) - 1, new_db, table_name, "", 0);
7441 7442
    t_table= open_temporary_table(thd, path, new_db, tmp_name, 0);
    if (t_table)
7443
    {
7444
      intern_close_table(t_table);
7445
      my_free(t_table, MYF(0));
7446
    }
7447
    else
7448
      sql_print_warning("Could not open table %s.%s after rename\n",
serg@serg.mylan's avatar
serg@serg.mylan committed
7449
                        new_db,table_name);
7450
    ha_flush_logs(old_db_type);
7451
  }
7452
  table_list->table=0;				// For query cache
7453
  query_cache_invalidate3(thd, table_list, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7454

7455
  if (thd->locked_tables && (new_name != table_name || new_db != db))
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
7456
  {
7457 7458 7459 7460 7461 7462
    /*
      If are we under LOCK TABLES and did ALTER TABLE with RENAME we need
      to remove placeholders for the old table and for the target table
      from the list of open tables and table cache. If we are not under
      LOCK TABLES we can rely on close_thread_tables() doing this job.
    */
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
7463
    pthread_mutex_lock(&LOCK_open);
7464
    unlink_open_table(thd, table, FALSE);
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
7465 7466 7467 7468
    unlink_open_table(thd, name_lock, FALSE);
    pthread_mutex_unlock(&LOCK_open);
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7469
end_temporary:
7470 7471 7472
  my_snprintf(tmp_name, sizeof(tmp_name), ER(ER_INSERT_INFO),
	      (ulong) (copied + deleted), (ulong) deleted,
	      (ulong) thd->cuted_fields);
7473
  my_ok(thd, copied + deleted, 0L, tmp_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7474
  thd->some_tables_deleted=0;
7475
  DBUG_RETURN(FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7476

7477
err1:
7478 7479 7480 7481 7482 7483
  if (new_table)
  {
    /* close_temporary_table() frees the new_table pointer. */
    close_temporary_table(thd, new_table, 1, 1);
  }
  else
7484 7485 7486 7487
    VOID(quick_rm_table(new_db_type, new_db, tmp_name, 
                        create_info->frm_only
                        ? FN_IS_TMP | FRM_ONLY
                        : FN_IS_TMP));
7488

7489
err:
7490 7491 7492 7493 7494 7495
  /*
    No default value was provided for a DATE/DATETIME field, the
    current sql_mode doesn't allow the '0000-00-00' value and
    the table to be altered isn't empty.
    Report error here.
  */
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
7496
  if (alter_info->error_if_not_empty && thd->row_count)
7497
  {
7498 7499
    const char *f_val= 0;
    enum enum_mysql_timestamp_type t_type= MYSQL_TIMESTAMP_DATE;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
7500
    switch (alter_info->datetime_field->sql_type)
7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516
    {
      case MYSQL_TYPE_DATE:
      case MYSQL_TYPE_NEWDATE:
        f_val= "0000-00-00";
        t_type= MYSQL_TIMESTAMP_DATE;
        break;
      case MYSQL_TYPE_DATETIME:
        f_val= "0000-00-00 00:00:00";
        t_type= MYSQL_TIMESTAMP_DATETIME;
        break;
      default:
        /* Shouldn't get here. */
        DBUG_ASSERT(0);
    }
    bool save_abort_on_warning= thd->abort_on_warning;
    thd->abort_on_warning= TRUE;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
7517 7518
    make_truncated_value_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
                                 f_val, strlength(f_val), t_type,
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
7519
                                 alter_info->datetime_field->field_name);
7520 7521
    thd->abort_on_warning= save_abort_on_warning;
  }
dlenev@mockturtle.local's avatar
dlenev@mockturtle.local committed
7522 7523 7524 7525 7526 7527
  if (name_lock)
  {
    pthread_mutex_lock(&LOCK_open);
    unlink_open_table(thd, name_lock, FALSE);
    pthread_mutex_unlock(&LOCK_open);
  }
7528
  DBUG_RETURN(TRUE);
7529 7530 7531 7532 7533 7534 7535 7536 7537 7538 7539

err_with_placeholders:
  /*
    An error happened while we were holding exclusive name-lock on table
    being altered. To be safe under LOCK TABLES we should remove placeholders
    from list of open tables list and table cache.
  */
  unlink_open_table(thd, table, FALSE);
  if (name_lock)
    unlink_open_table(thd, name_lock, FALSE);
  VOID(pthread_mutex_unlock(&LOCK_open));
7540
  DBUG_RETURN(TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7541
}
7542
/* mysql_alter_table */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7543 7544

static int
7545
copy_data_between_tables(TABLE *from,TABLE *to,
7546
			 List<Create_field> &create,
7547
                         bool ignore,
7548
			 uint order_num, ORDER *order,
7549
			 ha_rows *copied,
andrey@example.com's avatar
andrey@example.com committed
7550
			 ha_rows *deleted,
7551 7552
                         enum enum_enable_or_disable keys_onoff,
                         bool error_if_not_empty)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7553 7554 7555 7556 7557
{
  int error;
  Copy_field *copy,*copy_end;
  ulong found_count,delete_count;
  THD *thd= current_thd;
7558
  uint length= 0;
7559 7560 7561 7562 7563
  SORT_FIELD *sortorder;
  READ_RECORD info;
  TABLE_LIST   tables;
  List<Item>   fields;
  List<Item>   all_fields;
7564
  ha_rows examined_rows;
7565
  bool auto_increment_field_copied= 0;
7566
  ulong save_sql_mode;
7567
  ulonglong prev_insert_id;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7568 7569
  DBUG_ENTER("copy_data_between_tables");

7570 7571 7572 7573 7574 7575
  /*
    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
  */
7576
  error= ha_enable_transaction(thd, FALSE);
7577 7578
  if (error)
    DBUG_RETURN(-1);
7579
  
7580
  if (!(copy= new Copy_field[to->s->fields]))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7581 7582
    DBUG_RETURN(-1);				/* purecov: inspected */

7583
  if (to->file->ha_external_lock(thd, F_WRLCK))
7584
    DBUG_RETURN(-1);
7585

andrey@example.com's avatar
andrey@example.com committed
7586 7587 7588
  /* We need external lock before we can disable/enable keys */
  alter_table_manage_keys(to, from->file->indexes_are_disabled(), keys_onoff);

7589 7590 7591 7592 7593
  /* We can abort alter table for any table type */
  thd->abort_on_warning= !ignore && test(thd->variables.sql_mode &
                                         (MODE_STRICT_TRANS_TABLES |
                                          MODE_STRICT_ALL_TABLES));

7594
  from->file->info(HA_STATUS_VARIABLE);
7595
  to->file->ha_start_bulk_insert(from->file->stats.records);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7596

7597 7598
  save_sql_mode= thd->variables.sql_mode;

7599 7600
  List_iterator<Create_field> it(create);
  Create_field *def;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7601 7602 7603 7604 7605
  copy_end=copy;
  for (Field **ptr=to->field ; *ptr ; ptr++)
  {
    def=it++;
    if (def->field)
7606 7607
    {
      if (*ptr == to->next_number_field)
7608
      {
7609
        auto_increment_field_copied= TRUE;
7610 7611 7612 7613 7614 7615 7616 7617 7618
        /*
          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
7619
      (copy_end++)->set(*ptr,def->field,0);
7620 7621
    }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7622 7623
  }

7624 7625
  found_count=delete_count=0;

monty@donna.mysql.fi's avatar
monty@donna.mysql.fi committed
7626 7627
  if (order)
  {
7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644 7645
    if (to->s->primary_key != MAX_KEY && to->file->primary_key_is_clustered())
    {
      char warn_buff[MYSQL_ERRMSG_SIZE];
      my_snprintf(warn_buff, sizeof(warn_buff), 
                  "ORDER BY ignored as there is a user-defined clustered index"
                  " in the table '%-.192s'", from->s->table_name.str);
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
                   warn_buff);
    }
    else
    {
      from->sort.io_cache=(IO_CACHE*) my_malloc(sizeof(IO_CACHE),
                                                MYF(MY_FAE | MY_ZEROFILL));
      bzero((char *) &tables, sizeof(tables));
      tables.table= from;
      tables.alias= tables.table_name= from->s->table_name.str;
      tables.db= from->s->db.str;
      error= 1;
7646

7647 7648 7649 7650 7651 7652 7653 7654 7655 7656
      if (thd->lex->select_lex.setup_ref_array(thd, order_num) ||
          setup_order(thd, thd->lex->select_lex.ref_pointer_array,
                      &tables, fields, all_fields, order) ||
          !(sortorder= make_unireg_sortorder(order, &length, NULL)) ||
          (from->sort.found_records= filesort(thd, from, sortorder, length,
                                              (SQL_SELECT *) 0, HA_POS_ERROR,
                                              1, &examined_rows)) ==
          HA_POS_ERROR)
        goto err;
    }
7657 7658
  };

7659 7660
  /* Tell handler that we have values for all columns in the to table */
  to->use_all_columns();
7661
  init_read_record(&info, thd, from, (SQL_SELECT *) 0, 1, 1, FALSE);
7662
  if (ignore)
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
7663
    to->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
7664
  thd->row_count= 0;
7665
  restore_record(to, s->default_values);        // Create empty record
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7666 7667 7668 7669
  while (!(error=info.read_record(&info)))
  {
    if (thd->killed)
    {
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
7670
      thd->send_kill_message();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7671 7672 7673
      error= 1;
      break;
    }
7674
    thd->row_count++;
7675 7676 7677 7678 7679 7680
    /* Return error if source table isn't empty. */
    if (error_if_not_empty)
    {
      error= 1;
      break;
    }
7681 7682
    if (to->next_number_field)
    {
7683
      if (auto_increment_field_copied)
7684
        to->auto_increment_field_not_null= TRUE;
7685 7686 7687
      else
        to->next_number_field->reset();
    }
7688
    
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7689
    for (Copy_field *copy_ptr=copy ; copy_ptr != copy_end ; copy_ptr++)
7690
    {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7691
      copy_ptr->do_copy(copy_ptr);
7692
    }
7693
    prev_insert_id= to->file->next_insert_id;
7694
    error=to->file->ha_write_row(to->record[0]);
7695 7696
    to->auto_increment_field_not_null= FALSE;
    if (error)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7697
    {
7698
      if (!ignore ||
7699
          to->file->is_fatal_error(error, HA_CHECK_DUP))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7700
      {
7701
         if (!to->file->is_fatal_error(error, HA_CHECK_DUP))
7702 7703 7704 7705
         {
           uint key_nr= to->file->get_dup_key(error);
           if ((int) key_nr >= 0)
           {
7706
             const char *err_msg= ER(ER_DUP_ENTRY_WITH_KEY_NAME);
7707
             if (key_nr == 0 &&
monty@mysql.com's avatar
monty@mysql.com committed
7708 7709
                 (to->key_info[0].key_part[0].field->flags &
                  AUTO_INCREMENT_FLAG))
7710
               err_msg= ER(ER_DUP_ENTRY_AUTOINCREMENT_CASE);
monty@mysql.com's avatar
monty@mysql.com committed
7711
             to->file->print_keydup_error(key_nr, err_msg);
7712 7713 7714 7715
             break;
           }
         }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7716 7717 7718
	to->file->print_error(error,MYF(0));
	break;
      }
7719
      to->file->restore_auto_increment(prev_insert_id);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7720 7721 7722
      delete_count++;
    }
    else
7723
      found_count++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7724 7725
  }
  end_read_record(&info);
7726
  free_io_cache(from);
7727
  delete [] copy;				// This is never 0
serg@serg.mylan's avatar
serg@serg.mylan committed
7728

7729
  if (to->file->ha_end_bulk_insert() && error <= 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7730
  {
serg@serg.mylan's avatar
serg@serg.mylan committed
7731
    to->file->print_error(my_errno,MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7732 7733
    error=1;
  }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
7734
  to->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
7735

7736 7737 7738 7739 7740 7741
  if (ha_enable_transaction(thd, TRUE))
  {
    error= 1;
    goto err;
  }
  
7742 7743 7744 7745
  /*
    Ensure that the new table is saved properly to disk so that we
    can do a rename
  */
7746
  if (ha_autocommit_or_rollback(thd, 0))
7747
    error=1;
7748
  if (end_active_trans(thd))
7749
    error=1;
7750

7751
 err:
7752
  thd->variables.sql_mode= save_sql_mode;
7753
  thd->abort_on_warning= 0;
7754
  free_io_cache(from);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7755 7756
  *copied= found_count;
  *deleted=delete_count;
7757
  to->file->ha_release_auto_increment();
7758
  if (to->file->ha_external_lock(thd,F_UNLCK))
7759
    error=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7760 7761
  DBUG_RETURN(error > 0 ? -1 : 0);
}
7762

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

7764 7765 7766 7767 7768 7769 7770 7771 7772 7773 7774
/*
  Recreates tables by calling mysql_alter_table().

  SYNOPSIS
    mysql_recreate_table()
    thd			Thread handler
    tables		Tables to recreate

 RETURN
    Like mysql_alter_table().
*/
7775
bool mysql_recreate_table(THD *thd, TABLE_LIST *table_list)
7776 7777
{
  HA_CREATE_INFO create_info;
7778 7779 7780
  Alter_info alter_info;

  DBUG_ENTER("mysql_recreate_table");
7781 7782 7783 7784 7785 7786
  DBUG_ASSERT(!table_list->next_global);
  /*
    table_list->table has been closed and freed. Do not reference
    uninitialized data. open_tables() could fail.
  */
  table_list->table= NULL;
7787 7788

  bzero((char*) &create_info, sizeof(create_info));
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
7789
  create_info.row_type=ROW_TYPE_NOT_USED;
7790
  create_info.default_table_charset=default_charset_info;
monty@mysql.com's avatar
monty@mysql.com committed
7791
  /* Force alter table to recreate table */
7792
  alter_info.flags= (ALTER_CHANGE_COLUMN | ALTER_RECREATE);
7793
  DBUG_RETURN(mysql_alter_table(thd, NullS, NullS, &create_info,
7794 7795
                                table_list, &alter_info, 0,
                                (ORDER *) 0, 0));
7796 7797 7798
}


7799 7800
bool mysql_checksum_table(THD *thd, TABLE_LIST *tables,
                          HA_CHECK_OPT *check_opt)
7801 7802 7803 7804 7805
{
  TABLE_LIST *table;
  List<Item> field_list;
  Item *item;
  Protocol *protocol= thd->protocol;
7806
  DBUG_ENTER("mysql_checksum_table");
7807 7808 7809

  field_list.push_back(item = new Item_empty_string("Table", NAME_LEN*2));
  item->maybe_null= 1;
7810 7811
  field_list.push_back(item= new Item_int("Checksum", (longlong) 1,
                                          MY_INT64_NUM_DECIMAL_DIGITS));
7812
  item->maybe_null= 1;
7813 7814
  if (protocol->send_fields(&field_list,
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
7815
    DBUG_RETURN(TRUE);
7816

7817
  /* Open one table after the other to keep lock time as short as possible. */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7818
  for (table= tables; table; table= table->next_local)
7819 7820
  {
    char table_name[NAME_LEN*2+2];
7821
    TABLE *t;
7822

7823
    strxmov(table_name, table->db ,".", table->table_name, NullS);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
7824

7825
    t= table->table= open_n_lock_single_table(thd, table, TL_READ);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
7826
    thd->clear_error();			// these errors shouldn't get client
7827 7828 7829 7830

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

7831
    if (!t)
7832
    {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
7833
      /* Table didn't exist */
7834
      protocol->store_null();
7835
      thd->clear_error();
7836 7837 7838
    }
    else
    {
7839
      if (t->file->ha_table_flags() & HA_HAS_CHECKSUM &&
7840 7841
	  !(check_opt->flags & T_EXTEND))
	protocol->store((ulonglong)t->file->checksum());
7842
      else if (!(t->file->ha_table_flags() & HA_HAS_CHECKSUM) &&
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
7843
	       (check_opt->flags & T_QUICK))
7844
	protocol->store_null();
7845 7846
      else
      {
7847 7848
	/* calculating table's checksum */
	ha_checksum crc= 0;
7849
        uchar null_mask=256 -  (1 << t->s->last_null_bit_pos);
7850

7851
        t->use_all_columns();
7852

7853
	if (t->file->ha_rnd_init(1))
7854 7855 7856
	  protocol->store_null();
	else
	{
7857
	  for (;;)
7858
	  {
7859 7860 7861 7862 7863 7864 7865 7866 7867 7868
            if (thd->killed)
            {
              /* 
                 we've been killed; let handler clean up, and remove the 
                 partial current row from the recordset (embedded lib) 
              */
              t->file->ha_rnd_end();
              thd->protocol->remove_last_row();
              goto err;
            }
7869
	    ha_checksum row_crc= 0;
7870 7871 7872 7873 7874 7875 7876
            int error= t->file->rnd_next(t->record[0]);
            if (unlikely(error))
            {
              if (error == HA_ERR_RECORD_DELETED)
                continue;
              break;
            }
7877 7878 7879 7880
	    if (t->s->null_bytes)
            {
              /* fix undefined null bits */
              t->record[0][t->s->null_bytes-1] |= null_mask;
serg@mysql.com's avatar
serg@mysql.com committed
7881 7882 7883
              if (!(t->s->db_create_options & HA_OPTION_PACK_RECORD))
                t->record[0][0] |= 1;

7884 7885
	      row_crc= my_checksum(row_crc, t->record[0], t->s->null_bytes);
            }
7886

7887
	    for (uint i= 0; i < t->s->fields; i++ )
7888 7889
	    {
	      Field *f= t->field[i];
7890
	      if ((f->type() == MYSQL_TYPE_BLOB) ||
7891
                  (f->type() == MYSQL_TYPE_VARCHAR))
7892 7893 7894
	      {
		String tmp;
		f->val_str(&tmp);
7895
		row_crc= my_checksum(row_crc, (uchar*) tmp.ptr(), tmp.length());
7896 7897
	      }
	      else
7898
		row_crc= my_checksum(row_crc, f->ptr,
7899
				     f->pack_length());
7900
	    }
7901

7902 7903 7904
	    crc+= row_crc;
	  }
	  protocol->store((ulonglong)crc);
7905
          t->file->ha_rnd_end();
7906
	}
7907
      }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
7908
      thd->clear_error();
7909 7910 7911 7912 7913 7914 7915
      close_thread_tables(thd);
      table->table=0;				// For query cache
    }
    if (protocol->write())
      goto err;
  }

7916
  my_eof(thd);
7917
  DBUG_RETURN(FALSE);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
7918

7919 7920 7921 7922
 err:
  close_thread_tables(thd);			// Shouldn't be needed
  if (table)
    table->table=0;
7923
  DBUG_RETURN(TRUE);
7924
}
7925 7926

static bool check_engine(THD *thd, const char *table_name,
7927
                         HA_CREATE_INFO *create_info)
7928
{
7929
  handlerton **new_engine= &create_info->db_type;
7930
  handlerton *req_engine= *new_engine;
7931
  bool no_substitution=
7932
        test(thd->variables.sql_mode & MODE_NO_ENGINE_SUBSTITUTION);
7933 7934
  if (!(*new_engine= ha_checktype(thd, ha_legacy_type(req_engine),
                                  no_substitution, 1)))
7935 7936
    return TRUE;

7937
  if (req_engine && req_engine != *new_engine)
7938
  {
serg@janus.mylan's avatar
serg@janus.mylan committed
7939
    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
7940 7941
                       ER_WARN_USING_OTHER_HANDLER,
                       ER(ER_WARN_USING_OTHER_HANDLER),
7942
                       ha_resolve_storage_engine_name(*new_engine),
7943 7944
                       table_name);
  }
7945 7946 7947 7948 7949
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE &&
      ha_check_storage_engine_flag(*new_engine, HTON_TEMPORARY_NOT_SUPPORTED))
  {
    if (create_info->used_fields & HA_CREATE_USED_ENGINE)
    {
7950
      my_error(ER_ILLEGAL_HA_CREATE_OPTION, MYF(0),
antony@ppcg5.local's avatar
antony@ppcg5.local committed
7951
               ha_resolve_storage_engine_name(*new_engine), "TEMPORARY");
7952 7953 7954
      *new_engine= 0;
      return TRUE;
    }
7955
    *new_engine= myisam_hton;
7956
  }
7957 7958
  return FALSE;
}