sql_table.cc 335 KB
Newer Older
1
/*
2
   Copyright (c) 2000, 2016, Oracle and/or its affiliates.
3
   Copyright (c) 2010, 2016, MariaDB
unknown's avatar
unknown committed
4 5 6

   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
unknown's avatar
unknown committed
7
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
8 9 10 11 12 13 14 15

   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
16 17
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
*/
unknown's avatar
unknown committed
18 19 20

/* drop and alter of tables */

21
#include <my_global.h>
22 23
#include "sql_priv.h"
#include "unireg.h"
Konstantin Osipov's avatar
Konstantin Osipov committed
24
#include "debug_sync.h"
25 26 27
#include "sql_table.h"
#include "sql_parse.h"                        // test_if_data_home_dir
#include "sql_cache.h"                          // query_cache_*
28
#include "sql_base.h"   // lock_table_names
29
#include "lock.h"       // mysql_unlock_tables
30
#include "strfunc.h"    // find_type2, find_set
31
#include "sql_truncate.h"                       // regenerate_locked_table 
32 33 34
#include "sql_partition.h"                      // mem_alloc_error,
                                                // generate_partition_syntax,
                                                // partition_info
35
                                                // NOT_A_PARTITION_ID
36
#include "sql_db.h"                             // load_db_opt_by_name
37 38 39
#include "sql_time.h"                  // make_truncated_value_warning
#include "records.h"             // init_read_record, end_read_record
#include "filesort.h"            // filesort_free_buffers
40
#include "sql_select.h"                // setup_order
41 42 43 44
#include "sql_handler.h"               // mysql_ha_rm_tables
#include "discover.h"                  // readfrm
#include "my_pthread.h"                // pthread_mutex_t
#include "log_event.h"                 // Query_log_event
45
#include "sql_statistics.h"
46
#include <hash.h>
unknown's avatar
unknown committed
47
#include <myisam.h>
48
#include <my_dir.h>
49
#include "create_options.h"
50
#include "sp_head.h"
Konstantin Osipov's avatar
Konstantin Osipov committed
51
#include "sp.h"
52
#include "sql_trigger.h"
53
#include "sql_parse.h"
54
#include "sql_show.h"
Konstantin Osipov's avatar
Konstantin Osipov committed
55
#include "transaction.h"
56
#include "sql_audit.h"
unknown's avatar
unknown committed
57

58

unknown's avatar
unknown committed
59 60 61 62
#ifdef __WIN__
#include <io.h>
#endif

unknown's avatar
unknown committed
63
const char *primary_key_name="PRIMARY";
unknown's avatar
unknown committed
64 65

static bool check_if_keyname_exists(const char *name,KEY *start, KEY *end);
66 67
static char *make_unique_key_name(THD *thd, const char *field_name, KEY *start,
                                  KEY *end);
68 69 70
static void make_unique_constraint_name(THD *thd, LEX_STRING *name,
                                        List<Virtual_column_info> *vcol,
                                        uint *nr);
71 72 73 74 75 76
static int copy_data_between_tables(THD *thd, TABLE *from,TABLE *to,
                                    List<Create_field> &create, bool ignore,
				    uint order_num, ORDER *order,
				    ha_rows *copied,ha_rows *deleted,
                                    Alter_info::enum_enable_or_disable keys_onoff,
                                    Alter_table_ctx *alter_ctx);
77

Alexander Barkov's avatar
Alexander Barkov committed
78
static bool prepare_blob_field(THD *thd, Column_definition *sql_field);
79
static int mysql_prepare_create_table(THD *, HA_CREATE_INFO *, Alter_info *,
80
                                      uint *, handler *, KEY **, uint *, int);
Sergei Golubchik's avatar
Sergei Golubchik committed
81
static uint blob_length_by_type(enum_field_types type);
82

83 84
/**
  @brief Helper function for explain_filename
85 86 87 88 89
  @param thd          Thread handle
  @param to_p         Explained name in system_charset_info
  @param end_p        End of the to_p buffer
  @param name         Name to be converted
  @param name_len     Length of the name, in bytes
90
*/
91 92
static char* add_identifier(THD* thd, char *to_p, const char * end_p,
                            const char* name, uint name_len)
93 94 95
{
  uint res;
  uint errors;
96
  const char *conv_name, *conv_name_end;
97 98
  char tmp_name[FN_REFLEN];
  char conv_string[FN_REFLEN];
99
  int quote;
100 101 102 103 104 105 106 107 108 109

  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;
  }
110 111
  res= strconvert(&my_charset_filename, conv_name, name_len,
                  system_charset_info,
112 113
                  conv_string, FN_REFLEN, &errors);
  if (!res || errors)
114 115
  {
    DBUG_PRINT("error", ("strconvert of '%s' failed with %u (errors: %u)", conv_name, res, errors));
116
    conv_name= name;
117
    conv_name_end= name + name_len;
118
  }
119 120 121 122
  else
  {
    DBUG_PRINT("info", ("conv '%s' -> '%s'", conv_name, conv_string));
    conv_name= conv_string;
123
    conv_name_end= conv_string + res;
124 125
  }

126
  quote = thd ? get_quote_char_for_identifier(thd, conv_name, res - 1) : '`';
127 128

  if (quote != EOF && (end_p - to_p > 2))
129
  {
130
    *(to_p++)= (char) quote;
131 132
    while (*conv_name && (end_p - to_p - 1) > 0)
    {
133 134
      int length= my_charlen(system_charset_info, conv_name, conv_name_end);
      if (length <= 0)
135
        length= 1;
136
      if (length == 1 && *conv_name == (char) quote)
137 138 139
      { 
        if ((end_p - to_p) < 3)
          break;
140
        *(to_p++)= (char) quote;
141 142
        *(to_p++)= *(conv_name++);
      }
143
      else if (((long) length) < (end_p - to_p))
144 145 146 147 148 149 150
      {
        to_p= strnmov(to_p, conv_name, length);
        conv_name+= length;
      }
      else
        break;                               /* string already filled */
    }
151 152 153 154 155
    if (end_p > to_p) {
      *(to_p++)= (char) quote;
      if (end_p > to_p)
	*to_p= 0; /* terminate by NUL, but do not include it in the count */
    }
156
  }
157
  else
158 159
    to_p= strnmov(to_p, conv_name, end_p - to_p);
  DBUG_RETURN(to_p);
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
}


/**
  @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.

175 176 177 178 179 180 181
  Examples:

    t1#P#p1                 table t1 partition p1
    t1#P#p1#SP#sp1          table t1 partition p1 subpartition sp1
    t1#P#p1#SP#sp1#TMP#     table t1 partition p1 subpartition sp1 temporary
    t1#P#p1#SP#sp1#REN#     table t1 partition p1 subpartition sp1 renamed

182
   @param      thd          Thread handle
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
   @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)

   @retval     Length of returned string
*/

203 204
uint explain_filename(THD* thd,
		      const char *from,
205 206 207 208 209 210 211 212 213 214 215 216 217 218
                      char *to,
                      uint to_length,
                      enum_explain_filename_mode explain_mode)
{
  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;
Sergei Golubchik's avatar
Sergei Golubchik committed
219
  uint part_type= NORMAL_PART_NAME;
220

221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
  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;
239 240
  /* Look if there are partition tokens in the table name. */
  while ((tmp_p= strchr(tmp_p, '#')))
241 242 243 244 245 246
  {
    tmp_p++;
    switch (tmp_p[0]) {
    case 'P':
    case 'p':
      if (tmp_p[1] == '#')
247
      {
248
        part_name= tmp_p + 2;
249 250
        tmp_p+= 2;
      }
251 252 253 254 255 256 257
      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;
258 259
	tmp_p+= 3;
      }
260 261 262 263 264 265
      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])
266
      {
Sergei Golubchik's avatar
Sergei Golubchik committed
267
        part_type= TEMP_PART_NAME;
268 269
        tmp_p+= 4;
      }
270 271 272 273 274 275
      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])
276
      {
Sergei Golubchik's avatar
Sergei Golubchik committed
277
        part_type= RENAMED_PART_NAME;
278 279
        tmp_p+= 4;
      }
280 281
      break;
    default:
282 283
      /* Not partition name part. */
      ;
284 285 286 287 288 289 290 291 292
    }
  }
  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);
Sergei Golubchik's avatar
Sergei Golubchik committed
293
    if (part_type != NORMAL_PART_NAME)
294 295 296 297 298 299 300
    {
      if (subpart_name)
        subpart_name_len-= 5;
      else
        part_name_len-= 5;
    }
  }
301 302
  else
    table_name_len= strlen(table_name);
303 304 305 306
  if (db_name)
  {
    if (explain_mode == EXPLAIN_ALL_VERBOSE)
    {
307 308
      to_p= strnmov(to_p, ER_THD_OR_DEFAULT(thd, ER_DATABASE_NAME),
                                            end_p - to_p);
309
      *(to_p++)= ' ';
310
      to_p= add_identifier(thd, to_p, end_p, db_name, db_name_len);
311 312 313 314
      to_p= strnmov(to_p, ", ", end_p - to_p);
    }
    else
    {
315
      to_p= add_identifier(thd, to_p, end_p, db_name, db_name_len);
316 317 318 319
      to_p= strnmov(to_p, ".", end_p - to_p);
    }
  }
  if (explain_mode == EXPLAIN_ALL_VERBOSE)
320
  {
321
    to_p= strnmov(to_p, ER_THD_OR_DEFAULT(thd, ER_TABLE_NAME), end_p - to_p);
322
    *(to_p++)= ' ';
323
    to_p= add_identifier(thd, to_p, end_p, table_name, table_name_len);
324
  }
325
  else
326
    to_p= add_identifier(thd, to_p, end_p, table_name, table_name_len);
327 328
  if (part_name)
  {
329
    if (explain_mode == EXPLAIN_PARTITIONS_AS_COMMENT)
330 331 332 333 334
      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);
Sergei Golubchik's avatar
Sergei Golubchik committed
335
    if (part_type != NORMAL_PART_NAME)
336
    {
Sergei Golubchik's avatar
Sergei Golubchik committed
337
      if (part_type == TEMP_PART_NAME)
338 339
        to_p= strnmov(to_p, ER_THD_OR_DEFAULT(thd, ER_TEMPORARY_NAME),
                      end_p - to_p);
340
      else
341 342
        to_p= strnmov(to_p, ER_THD_OR_DEFAULT(thd, ER_RENAMED_NAME),
                      end_p - to_p);
343 344
      to_p= strnmov(to_p, " ", end_p - to_p);
    }
345 346
    to_p= strnmov(to_p, ER_THD_OR_DEFAULT(thd, ER_PARTITION_NAME),
                  end_p - to_p);
347
    *(to_p++)= ' ';
348
    to_p= add_identifier(thd, to_p, end_p, part_name, part_name_len);
349 350 351
    if (subpart_name)
    {
      to_p= strnmov(to_p, ", ", end_p - to_p);
352 353
      to_p= strnmov(to_p, ER_THD_OR_DEFAULT(thd, ER_SUBPARTITION_NAME),
                    end_p - to_p);
354
      *(to_p++)= ' ';
355
      to_p= add_identifier(thd, to_p, end_p, subpart_name, subpart_name_len);
356
    }
357
    if (explain_mode == EXPLAIN_PARTITIONS_AS_COMMENT)
358 359 360 361 362 363 364
      to_p= strnmov(to_p, " */", end_p - to_p);
  }
  DBUG_PRINT("exit", ("to '%s'", to));
  DBUG_RETURN(to_p - to);
}


365 366 367 368 369 370 371 372 373 374 375 376 377
/*
  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.
*/

378 379
uint filename_to_tablename(const char *from, char *to, uint to_length, 
                           bool stay_quiet)
380
{
381
  uint errors;
382
  size_t res;
383 384 385
  DBUG_ENTER("filename_to_tablename");
  DBUG_PRINT("enter", ("from '%s'", from));

Sergei Golubchik's avatar
Sergei Golubchik committed
386
  res= strconvert(&my_charset_filename, from, FN_REFLEN,
387 388
                  system_charset_info,  to, to_length, &errors);
  if (errors) // Old 5.0 name
389
  {
390 391
    res= (strxnmov(to, to_length, MYSQL50_TABLE_NAME_PREFIX,  from, NullS) -
          to);
392
    if (!stay_quiet)
393
      sql_print_error("Invalid (old?) table or database name '%s'", from);
394
  }
395 396 397

  DBUG_PRINT("exit", ("to '%s'", to));
  DBUG_RETURN(res);
398 399 400
}


401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
/**
  Check if given string begins with "#mysql50#" prefix
  
  @param   name          string to check cut 
  
  @retval
    FALSE  no prefix found
  @retval
    TRUE   prefix found
*/

bool check_mysql50_prefix(const char *name)
{
  return (name[0] == '#' && 
         !strncmp(name, MYSQL50_TABLE_NAME_PREFIX,
                  MYSQL50_TABLE_NAME_PREFIX_LENGTH));
}


Ramil Kalimullin's avatar
Ramil Kalimullin committed
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
/**
  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)
{
435
  if (check_mysql50_prefix(from))
Ramil Kalimullin's avatar
Ramil Kalimullin committed
436 437 438 439 440 441
    return (uint) (strmake(to, from + MYSQL50_TABLE_NAME_PREFIX_LENGTH,
                           to_length - 1) - to);
  return 0;
}


442 443 444 445 446 447 448 449 450 451 452 453 454
/*
  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.
*/

455 456
uint tablename_to_filename(const char *from, char *to, uint to_length)
{
457
  uint errors, length;
458 459 460
  DBUG_ENTER("tablename_to_filename");
  DBUG_PRINT("enter", ("from '%s'", from));

Ramil Kalimullin's avatar
Ramil Kalimullin committed
461
  if ((length= check_n_cut_mysql50_prefix(from, to, to_length)))
unknown's avatar
unknown committed
462
  {
463 464 465 466 467 468 469 470
    /*
      Check if the name supplied is a valid mysql 5.0 name and 
      make the name a zero length string if it's not.
      Note that just returning zero length is not enough : 
      a lot of places don't check the return value and expect 
      a zero terminated string.
    */  
    if (check_table_name(to, length, TRUE))
471
    {
472 473
      to[0]= 0;
      length= 0;
unknown's avatar
unknown committed
474
    }
Ramil Kalimullin's avatar
Ramil Kalimullin committed
475
    DBUG_RETURN(length);
unknown's avatar
unknown committed
476
  }
477
  length= strconvert(system_charset_info, from, FN_REFLEN,
478 479 480 481 482 483 484
                     &my_charset_filename, to, to_length, &errors);
  if (check_if_legal_tablename(to) &&
      length + 4 < to_length)
  {
    memcpy(to + length, "@@@", 4);
    length+= 3;
  }
485 486
  DBUG_PRINT("exit", ("to '%s'", to));
  DBUG_RETURN(length);
487 488 489
}


490
/*
491
  Creates path to a file: mysql_data_dir/db/table.ext
492 493

  SYNOPSIS
494
   build_table_filename()
495
     buff                       Where to write result in my_charset_filename.
496
                                This may be the same as table_name.
497 498 499 500 501 502
     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.
503 504 505 506 507 508

  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".
509 510
    Unless flags indicate a temporary table name.
    'db' is always converted.
511
    'ext' is not converted.
512

513 514 515 516 517
    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.
518

519 520
  RETURN
    path length
521 522 523
*/

uint build_table_filename(char *buff, size_t bufflen, const char *db,
524
                          const char *table_name, const char *ext, uint flags)
525 526 527
{
  char dbbuff[FN_REFLEN];
  char tbbuff[FN_REFLEN];
528
  DBUG_ENTER("build_table_filename");
529 530
  DBUG_PRINT("enter", ("db: '%s'  table_name: '%s'  ext: '%s'  flags: %x",
                       db, table_name, ext, flags));
531 532

  if (flags & FN_IS_TMP) // FN_FROM_IS_TMP | FN_TO_IS_TMP
533
    strmake(tbbuff, table_name, sizeof(tbbuff)-1);
534
  else
Konstantin Osipov's avatar
Konstantin Osipov committed
535
    (void) tablename_to_filename(table_name, tbbuff, sizeof(tbbuff));
536

Konstantin Osipov's avatar
Konstantin Osipov committed
537
  (void) tablename_to_filename(db, dbbuff, sizeof(dbbuff));
538 539 540 541

  char *end = buff + bufflen;
  /* Don't add FN_ROOTDIR if mysql_data_home already includes it */
  char *pos = strnmov(buff, mysql_data_home, bufflen);
542
  size_t rootdir_len= strlen(FN_ROOTDIR);
543 544 545
  if (pos - rootdir_len >= buff &&
      memcmp(pos - rootdir_len, FN_ROOTDIR, rootdir_len) != 0)
    pos= strnmov(pos, FN_ROOTDIR, end - pos);
546 547
  pos= strxnmov(pos, end - pos, dbbuff, FN_ROOTDIR, NullS);
#ifdef USE_SYMDIR
548 549 550 551 552
  if (!(flags & SKIP_SYMDIR_ACCESS))
  {
    unpack_dirname(buff, buff);
    pos= strend(buff);
  }
553 554
#endif
  pos= strxnmov(pos, end - pos, tbbuff, ext, NullS);
555

556
  DBUG_PRINT("exit", ("buff: '%s'", buff));
557
  DBUG_RETURN(pos - buff);
558 559 560
}


561 562 563
/**
  Create path to a temporary table mysql_tmpdir/#sql1234_12_1
  (i.e. to its .FRM file but without an extension).
564

565 566 567
  @param thd      The thread handle.
  @param buff     Where to write result in my_charset_filename.
  @param bufflen  buff size
568

569
  @note
570 571 572
    Uses current_pid, thread_id, and tmp_table counter to create
    a file name in mysql_tmpdir.

573
  @return Path length.
574 575
*/

576
uint build_tmptable_filename(THD* thd, char *buff, size_t bufflen)
577
{
578 579
  DBUG_ENTER("build_tmptable_filename");

580
  char *p= strnmov(buff, mysql_tmpdir, bufflen);
581
  my_snprintf(p, bufflen - (p - buff), "/%s%lx_%llx_%x",
582
              tmp_file_prefix, current_pid,
Michael Widenius's avatar
Michael Widenius committed
583
              thd->thread_id, thd->tmp_table++);
584

585 586 587 588 589
  if (lower_case_table_names)
  {
    /* Convert all except tmpdir to lower case */
    my_casedn_str(files_charset_info, p);
  }
590

591
  size_t length= unpack_filename(buff, buff);
592 593
  DBUG_PRINT("exit", ("buff: '%s'", buff));
  DBUG_RETURN(length);
594 595
}

unknown's avatar
unknown committed
596 597 598
/*
--------------------------------------------------------------------------

599
   MODULE: DDL log
unknown's avatar
unknown committed
600 601 602 603 604 605 606 607
   -----------------

   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
608
   ddl log while we are executing. These entries are dropped when the
unknown's avatar
unknown committed
609 610 611 612
   operation is completed.

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

613
   There is only one ddl log in the system and it is protected by a mutex
unknown's avatar
unknown committed
614 615 616
   and there is a global struct that contains information about its current
   state.

617 618
   History:
   First version written in 2006 by Mikael Ronstrom
unknown's avatar
unknown committed
619 620 621
--------------------------------------------------------------------------
*/

622
struct st_global_ddl_log
unknown's avatar
unknown committed
623
{
624 625 626 627 628 629
  /*
    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.
  */
630
  char file_entry_buf[4*IO_SIZE];
unknown's avatar
unknown committed
631 632
  char file_name_str[FN_REFLEN];
  char *file_name;
633 634 635
  DDL_LOG_MEMORY_ENTRY *first_free;
  DDL_LOG_MEMORY_ENTRY *first_used;
  uint num_entries;
unknown's avatar
unknown committed
636 637
  File file_id;
  uint name_len;
638
  uint io_size;
639
  bool inited;
640
  bool do_release;
641
  bool recovery_phase;
642 643
  st_global_ddl_log() : inited(false), do_release(false) {}
};
unknown's avatar
unknown committed
644

645
st_global_ddl_log global_ddl_log;
unknown's avatar
unknown committed
646

Marc Alff's avatar
Marc Alff committed
647
mysql_mutex_t LOCK_gdl;
unknown's avatar
unknown committed
648

649 650 651 652 653
#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
654

655 656
#define DDL_LOG_NUM_ENTRY_POS 0
#define DDL_LOG_NAME_LEN_POS 4
657
#define DDL_LOG_IO_SIZE_POS 8
unknown's avatar
unknown committed
658

659 660
/**
  Read one entry from ddl log file.
661 662

  @param entry_no                     Entry number to read
663 664 665 666

  @return Operation status
    @retval true   Error
    @retval false  Success
unknown's avatar
unknown committed
667 668
*/

669
static bool read_ddl_log_file_entry(uint entry_no)
unknown's avatar
unknown committed
670 671
{
  bool error= FALSE;
672
  File file_id= global_ddl_log.file_id;
673
  uchar *file_entry_buf= (uchar*)global_ddl_log.file_entry_buf;
674 675
  uint io_size= global_ddl_log.io_size;
  DBUG_ENTER("read_ddl_log_file_entry");
unknown's avatar
unknown committed
676

677
  mysql_mutex_assert_owner(&LOCK_gdl);
Marc Alff's avatar
Marc Alff committed
678 679
  if (mysql_file_pread(file_id, file_entry_buf, io_size, io_size * entry_no,
                       MYF(MY_WME)) != io_size)
unknown's avatar
unknown committed
680 681 682 683 684
    error= TRUE;
  DBUG_RETURN(error);
}


685 686 687
/**
  Write one entry to ddl log file.

688
  @param entry_no                     Entry number to write
689 690 691 692

  @return Operation status
    @retval true   Error
    @retval false  Success
unknown's avatar
unknown committed
693 694
*/

695
static bool write_ddl_log_file_entry(uint entry_no)
unknown's avatar
unknown committed
696 697
{
  bool error= FALSE;
698
  File file_id= global_ddl_log.file_id;
699
  uchar *file_entry_buf= (uchar*)global_ddl_log.file_entry_buf;
700
  DBUG_ENTER("write_ddl_log_file_entry");
unknown's avatar
unknown committed
701

702
  mysql_mutex_assert_owner(&LOCK_gdl);
703
  if (mysql_file_pwrite(file_id, file_entry_buf,
Marc Alff's avatar
Marc Alff committed
704
                        IO_SIZE, IO_SIZE * entry_no, MYF(MY_WME)) != IO_SIZE)
unknown's avatar
unknown committed
705 706 707 708 709
    error= TRUE;
  DBUG_RETURN(error);
}


710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731
/**
  Sync the ddl log file.

  @return Operation status
    @retval FALSE  Success
    @retval TRUE   Error
*/


static bool sync_ddl_log_file()
{
  DBUG_ENTER("sync_ddl_log_file");
  DBUG_RETURN(mysql_file_sync(global_ddl_log.file_id, MYF(MY_WME)));
}


/**
  Write ddl log header.

  @return Operation status
    @retval TRUE                      Error
    @retval FALSE                     Success
unknown's avatar
unknown committed
732 733
*/

734
static bool write_ddl_log_header()
unknown's avatar
unknown committed
735 736
{
  uint16 const_var;
737
  DBUG_ENTER("write_ddl_log_header");
unknown's avatar
unknown committed
738

739 740
  int4store(&global_ddl_log.file_entry_buf[DDL_LOG_NUM_ENTRY_POS],
            global_ddl_log.num_entries);
741
  const_var= FN_REFLEN;
742
  int4store(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_LEN_POS],
unknown's avatar
unknown committed
743
            (ulong) const_var);
744
  const_var= IO_SIZE;
745
  int4store(&global_ddl_log.file_entry_buf[DDL_LOG_IO_SIZE_POS],
unknown's avatar
unknown committed
746
            (ulong) const_var);
747
  if (write_ddl_log_file_entry(0UL))
748 749 750 751
  {
    sql_print_error("Error writing ddl log header");
    DBUG_RETURN(TRUE);
  }
752
  DBUG_RETURN(sync_ddl_log_file());
unknown's avatar
unknown committed
753 754 755
}


756 757 758
/**
  Create ddl log file name.
  @param file_name                   Filename setup
759 760
*/

761
static inline void create_ddl_log_file_name(char *file_name)
762
{
763
  strxmov(file_name, mysql_data_home, "/", "ddl_log.log", NullS);
764 765 766
}


767 768 769 770 771 772 773 774
/**
  Read header of ddl log file.

  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.

  @return Last entry in ddl log (0 if no entries)
unknown's avatar
unknown committed
775 776
*/

777
static uint read_ddl_log_header()
unknown's avatar
unknown committed
778
{
779
  uchar *file_entry_buf= (uchar*)global_ddl_log.file_entry_buf;
780
  char file_name[FN_REFLEN];
781
  uint entry_no;
782
  bool successful_open= FALSE;
783
  DBUG_ENTER("read_ddl_log_header");
unknown's avatar
unknown committed
784

785 786
  mysql_mutex_init(key_LOCK_gdl, &LOCK_gdl, MY_MUTEX_INIT_SLOW);
  mysql_mutex_lock(&LOCK_gdl);
787
  create_ddl_log_file_name(file_name);
Marc Alff's avatar
Marc Alff committed
788 789 790
  if ((global_ddl_log.file_id= mysql_file_open(key_file_global_ddl_log,
                                               file_name,
                                               O_RDWR | O_BINARY, MYF(0))) >= 0)
unknown's avatar
unknown committed
791
  {
792
    if (read_ddl_log_file_entry(0UL))
793
    {
794 795
      /* Write message into error log */
      sql_print_error("Failed to read ddl log file in recovery");
796
    }
797 798
    else
      successful_open= TRUE;
unknown's avatar
unknown committed
799
  }
800 801
  if (successful_open)
  {
802 803
    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]);
804
    global_ddl_log.io_size= uint4korr(&file_entry_buf[DDL_LOG_IO_SIZE_POS]);
805 806 807
    DBUG_ASSERT(global_ddl_log.io_size <=
                sizeof(global_ddl_log.file_entry_buf));
  }
808
  else
809 810 811
  {
    entry_no= 0;
  }
812 813 814
  global_ddl_log.first_free= NULL;
  global_ddl_log.first_used= NULL;
  global_ddl_log.num_entries= 0;
815
  global_ddl_log.do_release= true;
816
  mysql_mutex_unlock(&LOCK_gdl);
unknown's avatar
unknown committed
817
  DBUG_RETURN(entry_no);
unknown's avatar
unknown committed
818 819 820
}


821
/**
822 823 824
  Convert from ddl_log_entry struct to file_entry_buf binary blob.

  @param ddl_log_entry   filled in ddl_log_entry struct.
unknown's avatar
unknown committed
825 826
*/

827
static void set_global_from_ddl_log_entry(const DDL_LOG_ENTRY *ddl_log_entry)
unknown's avatar
unknown committed
828
{
829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
  mysql_mutex_assert_owner(&LOCK_gdl);
  global_ddl_log.file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]=
                                    (char)DDL_LOG_ENTRY_CODE;
  global_ddl_log.file_entry_buf[DDL_LOG_ACTION_TYPE_POS]=
                                    (char)ddl_log_entry->action_type;
  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_REFLEN);
  strmake(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS],
          ddl_log_entry->name, FN_REFLEN - 1);
  if (ddl_log_entry->action_type == DDL_LOG_RENAME_ACTION ||
      ddl_log_entry->action_type == DDL_LOG_REPLACE_ACTION ||
      ddl_log_entry->action_type == DDL_LOG_EXCHANGE_ACTION)
  {
    DBUG_ASSERT(strlen(ddl_log_entry->from_name) < FN_REFLEN);
    strmake(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS + FN_REFLEN],
          ddl_log_entry->from_name, FN_REFLEN - 1);
  }
  else
    global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS + FN_REFLEN]= 0;
  DBUG_ASSERT(strlen(ddl_log_entry->handler_name) < FN_REFLEN);
  strmake(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS + (2*FN_REFLEN)],
          ddl_log_entry->handler_name, FN_REFLEN - 1);
  if (ddl_log_entry->action_type == DDL_LOG_EXCHANGE_ACTION)
  {
    DBUG_ASSERT(strlen(ddl_log_entry->tmp_name) < FN_REFLEN);
    strmake(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS + (3*FN_REFLEN)],
          ddl_log_entry->tmp_name, FN_REFLEN - 1);
  }
  else
    global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS + (3*FN_REFLEN)]= 0;
}


/**
  Convert from file_entry_buf binary blob to ddl_log_entry struct.

  @param[out] ddl_log_entry   struct to fill in.
868

869 870
  @note Strings (names) are pointing to the global_ddl_log structure,
  so LOCK_gdl needs to be hold until they are read or copied.
unknown's avatar
unknown committed
871 872
*/

873 874
static void set_ddl_log_entry_from_global(DDL_LOG_ENTRY *ddl_log_entry,
                                          const uint read_entry)
unknown's avatar
unknown committed
875
{
876
  char *file_entry_buf= (char*) global_ddl_log.file_entry_buf;
877
  uint inx;
878
  uchar single_char;
879

880
  mysql_mutex_assert_owner(&LOCK_gdl);
881
  ddl_log_entry->entry_pos= read_entry;
882 883 884 885
  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;
886 887 888 889 890 891 892
  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];
893 894 895 896 897 898 899
  if (ddl_log_entry->action_type == DDL_LOG_EXCHANGE_ACTION)
  {
    inx+= global_ddl_log.name_len;
    ddl_log_entry->tmp_name= &file_entry_buf[inx];
  }
  else
    ddl_log_entry->tmp_name= NULL;
unknown's avatar
unknown committed
900 901
}

unknown's avatar
unknown committed
902

903 904
/**
  Read a ddl log entry.
unknown's avatar
unknown committed
905

906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
  Read a specified entry in the ddl log.

  @param read_entry               Number of entry to read
  @param[out] entry_info          Information from entry

  @return Operation status
    @retval TRUE                     Error
    @retval FALSE                    Success
*/

static bool read_ddl_log_entry(uint read_entry, DDL_LOG_ENTRY *ddl_log_entry)
{
  DBUG_ENTER("read_ddl_log_entry");

  if (read_ddl_log_file_entry(read_entry))
  {
    DBUG_RETURN(TRUE);
  }
  set_ddl_log_entry_from_global(ddl_log_entry, read_entry);
unknown's avatar
unknown committed
925 926 927 928
  DBUG_RETURN(FALSE);
}


929 930
/**
  Initialise ddl log.
unknown's avatar
unknown committed
931

932 933
  Write the header of the ddl log file and length of names. Also set
  number of entries to zero.
unknown's avatar
unknown committed
934

935 936 937
  @return Operation status
    @retval TRUE                     Error
    @retval FALSE                    Success
unknown's avatar
unknown committed
938 939
*/

940
static bool init_ddl_log()
unknown's avatar
unknown committed
941
{
942
  char file_name[FN_REFLEN];
943
  DBUG_ENTER("init_ddl_log");
unknown's avatar
unknown committed
944

945
  if (global_ddl_log.inited)
unknown's avatar
unknown committed
946 947
    goto end;

948
  global_ddl_log.io_size= IO_SIZE;
949
  global_ddl_log.name_len= FN_REFLEN;
950
  create_ddl_log_file_name(file_name);
Marc Alff's avatar
Marc Alff committed
951 952 953 954
  if ((global_ddl_log.file_id= mysql_file_create(key_file_global_ddl_log,
                                                 file_name, CREATE_MODE,
                                                 O_RDWR | O_TRUNC | O_BINARY,
                                                 MYF(MY_WME))) < 0)
955
  {
956
    /* Couldn't create ddl log file, this is serious error */
957 958
    sql_print_error("Failed to open ddl log file");
    DBUG_RETURN(TRUE);
959
  }
unknown's avatar
Fixes  
unknown committed
960
  global_ddl_log.inited= TRUE;
961
  if (write_ddl_log_header())
962
  {
Marc Alff's avatar
Marc Alff committed
963
    (void) mysql_file_close(global_ddl_log.file_id, MYF(MY_WME));
unknown's avatar
Fixes  
unknown committed
964
    global_ddl_log.inited= FALSE;
965
    DBUG_RETURN(TRUE);
966
  }
unknown's avatar
unknown committed
967 968

end:
969
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
970 971 972
}


973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
/**
  Sync ddl log file.

  @return Operation status
    @retval TRUE        Error
    @retval FALSE       Success
*/

static bool sync_ddl_log_no_lock()
{
  DBUG_ENTER("sync_ddl_log_no_lock");

  mysql_mutex_assert_owner(&LOCK_gdl);
  if ((!global_ddl_log.recovery_phase) &&
      init_ddl_log())
  {
    DBUG_RETURN(TRUE);
  }
  DBUG_RETURN(sync_ddl_log_file());
}


/**
  @brief Deactivate an individual entry.

  @details For complex rename operations we need to deactivate individual
  entries.

  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
  do in a safe manner unless the ddl log is informed of the phases in
  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.

  @param entry_no     Entry position of record to change

  @return Operation status
    @retval TRUE      Error
    @retval FALSE     Success
*/

static bool deactivate_ddl_log_entry_no_lock(uint entry_no)
{
  uchar *file_entry_buf= (uchar*)global_ddl_log.file_entry_buf;
  DBUG_ENTER("deactivate_ddl_log_entry_no_lock");

  mysql_mutex_assert_owner(&LOCK_gdl);
  if (!read_ddl_log_file_entry(entry_no))
  {
    if (file_entry_buf[DDL_LOG_ENTRY_TYPE_POS] == DDL_LOG_ENTRY_CODE)
    {
      /*
        Log entry, if complete mark it done (IGNORE).
        Otherwise increase the phase by one.
      */
      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_ACTION_TYPE_POS] == DDL_LOG_EXCHANGE_ACTION &&
           file_entry_buf[DDL_LOG_PHASE_POS] >= EXCH_PHASE_TEMP_TO_FROM))
        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)
      {
        DBUG_ASSERT(file_entry_buf[DDL_LOG_PHASE_POS] == 0);
        file_entry_buf[DDL_LOG_PHASE_POS]= 1;
      }
      else if (file_entry_buf[DDL_LOG_ACTION_TYPE_POS] == DDL_LOG_EXCHANGE_ACTION)
      {
        DBUG_ASSERT(file_entry_buf[DDL_LOG_PHASE_POS] <=
                                                 EXCH_PHASE_FROM_TO_NAME);
        file_entry_buf[DDL_LOG_PHASE_POS]++;
      }
      else
      {
        DBUG_ASSERT(0);
      }
      if (write_ddl_log_file_entry(entry_no))
      {
        sql_print_error("Error in deactivating log entry. Position = %u",
                        entry_no);
        DBUG_RETURN(TRUE);
      }
    }
  }
  else
  {
    sql_print_error("Failed in reading entry before deactivating it");
    DBUG_RETURN(TRUE);
  }
  DBUG_RETURN(FALSE);
}


1075
/**
1076
  Execute one action in a ddl log entry
1077 1078 1079 1080 1081 1082

  @param ddl_log_entry              Information in action entry to execute

  @return Operation status
    @retval TRUE                       Error
    @retval FALSE                      Success
unknown's avatar
unknown committed
1083 1084
*/

1085
static int execute_ddl_log_action(THD *thd, DDL_LOG_ENTRY *ddl_log_entry)
unknown's avatar
unknown committed
1086
{
1087 1088
  bool frm_action= FALSE;
  LEX_STRING handler_name;
1089
  handler *file= NULL;
1090
  MEM_ROOT mem_root;
1091
  int error= TRUE;
1092
  char to_path[FN_REFLEN];
1093
  char from_path[FN_REFLEN];
1094
#ifdef WITH_PARTITION_STORAGE_ENGINE
1095
  char *par_ext= (char*)".par";
1096
#endif
1097
  handlerton *hton;
1098
  DBUG_ENTER("execute_ddl_log_action");
1099

1100
  mysql_mutex_assert_owner(&LOCK_gdl);
1101
  if (ddl_log_entry->entry_type == DDL_IGNORE_LOG_ENTRY_CODE)
1102 1103 1104
  {
    DBUG_RETURN(FALSE);
  }
1105
  DBUG_PRINT("ddl_log",
1106 1107
             ("execute type %c next %u name '%s' from_name '%s' handler '%s'"
              " tmp_name '%s'",
1108 1109 1110 1111
             ddl_log_entry->action_type,
             ddl_log_entry->next_entry,
             ddl_log_entry->name,
             ddl_log_entry->from_name,
1112 1113
             ddl_log_entry->handler_name,
             ddl_log_entry->tmp_name));
1114 1115
  handler_name.str= (char*)ddl_log_entry->handler_name;
  handler_name.length= strlen(ddl_log_entry->handler_name);
1116
  init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0, MYF(MY_THREAD_SPECIFIC));
1117
  if (!strcmp(ddl_log_entry->handler_name, reg_ext))
1118 1119 1120
    frm_action= TRUE;
  else
  {
1121
    plugin_ref plugin= ha_resolve_by_name(thd, &handler_name, false);
unknown's avatar
unknown committed
1122
    if (!plugin)
1123
    {
1124
      my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), ddl_log_entry->handler_name);
1125 1126
      goto error;
    }
unknown's avatar
unknown committed
1127 1128
    hton= plugin_data(plugin, handlerton*);
    file= get_new_handler((TABLE_SHARE*)0, &mem_root, hton);
1129
    if (!file)
1130 1131
    {
      mem_alloc_error(sizeof(handler));
1132
      goto error;
1133
    }
1134
  }
1135
  switch (ddl_log_entry->action_type)
1136
  {
1137
    case DDL_LOG_REPLACE_ACTION:
1138
    case DDL_LOG_DELETE_ACTION:
1139
    {
1140
      if (ddl_log_entry->phase == 0)
1141 1142 1143
      {
        if (frm_action)
        {
1144
          strxmov(to_path, ddl_log_entry->name, reg_ext, NullS);
Marc Alff's avatar
Marc Alff committed
1145
          if ((error= mysql_file_delete(key_file_frm, to_path, MYF(MY_WME))))
1146
          {
1147
            if (my_errno != ENOENT)
1148 1149
              break;
          }
1150
#ifdef WITH_PARTITION_STORAGE_ENGINE
1151
          strxmov(to_path, ddl_log_entry->name, par_ext, NullS);
Marc Alff's avatar
Marc Alff committed
1152
          (void) mysql_file_delete(key_file_partition, to_path, MYF(MY_WME));
1153
#endif
1154 1155 1156
        }
        else
        {
1157
          if ((error= file->ha_delete_table(ddl_log_entry->name)))
1158 1159 1160 1161
          {
            if (error != ENOENT && error != HA_ERR_NO_SUCH_TABLE)
              break;
          }
1162
        }
1163
        if ((deactivate_ddl_log_entry_no_lock(ddl_log_entry->entry_pos)))
1164
          break;
1165
        (void) sync_ddl_log_no_lock();
1166
        error= FALSE;
1167 1168
        if (ddl_log_entry->action_type == DDL_LOG_DELETE_ACTION)
          break;
1169
      }
1170 1171 1172 1173 1174 1175
      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.
      */
1176
    }
1177
    case DDL_LOG_RENAME_ACTION:
1178
    {
1179 1180 1181
      error= TRUE;
      if (frm_action)
      {
1182
        strxmov(to_path, ddl_log_entry->name, reg_ext, NullS);
1183
        strxmov(from_path, ddl_log_entry->from_name, reg_ext, NullS);
Marc Alff's avatar
Marc Alff committed
1184
        if (mysql_file_rename(key_file_frm, from_path, to_path, MYF(MY_WME)))
1185
          break;
1186
#ifdef WITH_PARTITION_STORAGE_ENGINE
1187
        strxmov(to_path, ddl_log_entry->name, par_ext, NullS);
1188
        strxmov(from_path, ddl_log_entry->from_name, par_ext, NullS);
Marc Alff's avatar
Marc Alff committed
1189
        (void) mysql_file_rename(key_file_partition, from_path, to_path, MYF(MY_WME));
1190
#endif
1191 1192 1193
      }
      else
      {
1194 1195
        if (file->ha_rename_table(ddl_log_entry->from_name,
                                  ddl_log_entry->name))
1196
          break;
1197
      }
1198
      if ((deactivate_ddl_log_entry_no_lock(ddl_log_entry->entry_pos)))
1199
        break;
1200
      (void) sync_ddl_log_no_lock();
1201
      error= FALSE;
1202
      break;
1203
    }
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
    case DDL_LOG_EXCHANGE_ACTION:
    {
      /* We hold LOCK_gdl, so we can alter global_ddl_log.file_entry_buf */
      char *file_entry_buf= (char*)&global_ddl_log.file_entry_buf;
      /* not yet implemented for frm */
      DBUG_ASSERT(!frm_action);
      /*
        Using a case-switch here to revert all currently done phases,
        since it will fall through until the first phase is undone.
      */
      switch (ddl_log_entry->phase) {
        case EXCH_PHASE_TEMP_TO_FROM:
          /* tmp_name -> from_name possibly done */
          (void) file->ha_rename_table(ddl_log_entry->from_name,
                                       ddl_log_entry->tmp_name);
          /* decrease the phase and sync */
          file_entry_buf[DDL_LOG_PHASE_POS]--;
          if (write_ddl_log_file_entry(ddl_log_entry->entry_pos))
            break;
          if (sync_ddl_log_no_lock())
            break;
          /* fall through */
        case EXCH_PHASE_FROM_TO_NAME:
          /* from_name -> name possibly done */
          (void) file->ha_rename_table(ddl_log_entry->name,
                                       ddl_log_entry->from_name);
          /* decrease the phase and sync */
          file_entry_buf[DDL_LOG_PHASE_POS]--;
          if (write_ddl_log_file_entry(ddl_log_entry->entry_pos))
            break;
          if (sync_ddl_log_no_lock())
            break;
          /* fall through */
        case EXCH_PHASE_NAME_TO_TEMP:
          /* name -> tmp_name possibly done */
          (void) file->ha_rename_table(ddl_log_entry->tmp_name,
                                       ddl_log_entry->name);
          /* disable the entry and sync */
          file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]= DDL_IGNORE_LOG_ENTRY_CODE;
          if (write_ddl_log_file_entry(ddl_log_entry->entry_pos))
            break;
          if (sync_ddl_log_no_lock())
            break;
          error= FALSE;
          break;
        default:
          DBUG_ASSERT(0);
          break;
      }

      break;
    }
1256 1257 1258 1259 1260 1261 1262 1263
    default:
      DBUG_ASSERT(0);
      break;
  }
  delete file;
error:
  free_root(&mem_root, MYF(0)); 
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1264 1265 1266
}


1267
/**
1268
  Get a free entry in the ddl log
1269 1270 1271 1272 1273 1274

  @param[out] active_entry     A ddl log memory entry returned

  @return Operation status
    @retval TRUE               Error
    @retval FALSE              Success
unknown's avatar
unknown committed
1275 1276
*/

1277 1278
static bool get_free_ddl_log_entry(DDL_LOG_MEMORY_ENTRY **active_entry,
                                   bool *write_header)
unknown's avatar
unknown committed
1279
{
1280 1281 1282
  DDL_LOG_MEMORY_ENTRY *used_entry;
  DDL_LOG_MEMORY_ENTRY *first_used= global_ddl_log.first_used;
  DBUG_ENTER("get_free_ddl_log_entry");
1283

1284
  if (global_ddl_log.first_free == NULL)
1285
  {
1286 1287
    if (!(used_entry= (DDL_LOG_MEMORY_ENTRY*)my_malloc(
                              sizeof(DDL_LOG_MEMORY_ENTRY), MYF(MY_WME))))
1288
    {
1289
      sql_print_error("Failed to allocate memory for ddl log free list");
1290 1291
      DBUG_RETURN(TRUE);
    }
1292
    global_ddl_log.num_entries++;
1293
    used_entry->entry_pos= global_ddl_log.num_entries;
1294
    *write_header= TRUE;
1295 1296 1297
  }
  else
  {
1298 1299
    used_entry= global_ddl_log.first_free;
    global_ddl_log.first_free= used_entry->next_log_entry;
1300
    *write_header= FALSE;
1301 1302 1303 1304 1305 1306
  }
  /*
    Move from free list to used list
  */
  used_entry->next_log_entry= first_used;
  used_entry->prev_log_entry= NULL;
1307
  used_entry->next_active_log_entry= NULL;
1308
  global_ddl_log.first_used= used_entry;
1309 1310 1311 1312
  if (first_used)
    first_used->prev_log_entry= used_entry;

  *active_entry= used_entry;
1313
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
1314 1315 1316
}


1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360
/**
  Execute one entry in the ddl log.
  
  Executing an entry means executing a linked list of actions.

  @param first_entry           Reference to first action in entry

  @return Operation status
    @retval TRUE               Error
    @retval FALSE              Success
*/

static bool execute_ddl_log_entry_no_lock(THD *thd, uint first_entry)
{
  DDL_LOG_ENTRY ddl_log_entry;
  uint read_entry= first_entry;
  DBUG_ENTER("execute_ddl_log_entry_no_lock");

  mysql_mutex_assert_owner(&LOCK_gdl);
  do
  {
    if (read_ddl_log_entry(read_entry, &ddl_log_entry))
    {
      /* Write to error log and continue with next log entry */
      sql_print_error("Failed to read entry = %u from ddl log",
                      read_entry);
      break;
    }
    DBUG_ASSERT(ddl_log_entry.entry_type == DDL_LOG_ENTRY_CODE ||
                ddl_log_entry.entry_type == DDL_IGNORE_LOG_ENTRY_CODE);

    if (execute_ddl_log_action(thd, &ddl_log_entry))
    {
      /* Write to error log and continue with next log entry */
      sql_print_error("Failed to execute action for entry = %u from ddl log",
                      read_entry);
      break;
    }
    read_entry= ddl_log_entry.next_entry;
  } while (read_entry);
  DBUG_RETURN(FALSE);
}


unknown's avatar
unknown committed
1361
/*
1362
  External interface methods for the DDL log Module
1363 1364 1365
  ---------------------------------------------------
*/

1366 1367
/**
  Write a ddl log entry.
1368

1369 1370
  A careful write of the ddl log is performed to ensure that we can
  handle crashes occurring during CREATE and ALTER TABLE processing.
1371

1372 1373
  @param ddl_log_entry         Information about log entry
  @param[out] entry_written    Entry information written into   
1374

1375 1376 1377
  @return Operation status
    @retval TRUE               Error
    @retval FALSE              Success
unknown's avatar
unknown committed
1378 1379
*/

1380 1381
bool write_ddl_log_entry(DDL_LOG_ENTRY *ddl_log_entry,
                         DDL_LOG_MEMORY_ENTRY **active_entry)
unknown's avatar
unknown committed
1382
{
1383
  bool error, write_header;
1384 1385
  DBUG_ENTER("write_ddl_log_entry");

1386
  mysql_mutex_assert_owner(&LOCK_gdl);
1387 1388 1389 1390
  if (init_ddl_log())
  {
    DBUG_RETURN(TRUE);
  }
1391
  set_global_from_ddl_log_entry(ddl_log_entry);
1392
  if (get_free_ddl_log_entry(active_entry, &write_header))
1393 1394 1395 1396
  {
    DBUG_RETURN(TRUE);
  }
  error= FALSE;
1397
  DBUG_PRINT("ddl_log",
1398 1399
             ("write type %c next %u name '%s' from_name '%s' handler '%s'"
              " tmp_name '%s'",
1400 1401 1402 1403
             (char) global_ddl_log.file_entry_buf[DDL_LOG_ACTION_TYPE_POS],
             ddl_log_entry->next_entry,
             (char*) &global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS],
             (char*) &global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS
1404
                                                    + FN_REFLEN],
1405
             (char*) &global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS
1406 1407 1408
                                                    + (2*FN_REFLEN)],
             (char*) &global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS
                                                    + (3*FN_REFLEN)]));
1409
  if (write_ddl_log_file_entry((*active_entry)->entry_pos))
1410
  {
1411
    error= TRUE;
1412 1413 1414
    sql_print_error("Failed to write entry_no = %u",
                    (*active_entry)->entry_pos);
  }
1415 1416
  if (write_header && !error)
  {
1417
    (void) sync_ddl_log_no_lock();
1418
    if (write_ddl_log_header())
1419 1420
      error= TRUE;
  }
1421
  if (error)
1422
    release_ddl_log_memory_entry(*active_entry);
1423
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1424 1425 1426
}


1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
/**
  @brief Write final entry in the ddl log.

  @details This is the last write in the ddl log. The previous log entries
  have already been written but not yet synched to disk.
  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.

  @param first_entry               First entry in linked list of entries
1438 1439 1440
                                   to execute, if 0 = NULL it means that
                                   the entry is removed and the entries
                                   are put into the free list.
1441
  @param complete                  Flag indicating we are simply writing
1442
                                   info about that entry has been completed
1443
  @param[in,out] active_entry      Entry to execute, 0 = NULL if the entry
1444 1445 1446 1447
                                   is written first time and needs to be
                                   returned. In this case the entry written
                                   is returned in this parameter

1448 1449 1450
  @return Operation status
    @retval TRUE                   Error
    @retval FALSE                  Success
1451
*/ 
unknown's avatar
unknown committed
1452

1453 1454 1455
bool write_execute_ddl_log_entry(uint first_entry,
                                 bool complete,
                                 DDL_LOG_MEMORY_ENTRY **active_entry)
unknown's avatar
unknown committed
1456
{
1457
  bool write_header= FALSE;
1458 1459
  char *file_entry_buf= (char*)global_ddl_log.file_entry_buf;
  DBUG_ENTER("write_execute_ddl_log_entry");
1460

1461
  mysql_mutex_assert_owner(&LOCK_gdl);
1462 1463 1464 1465
  if (init_ddl_log())
  {
    DBUG_RETURN(TRUE);
  }
1466 1467
  if (!complete)
  {
1468 1469 1470 1471 1472 1473
    /*
      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.
    */
1474
    (void) sync_ddl_log_no_lock();
1475
    file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]= (char)DDL_LOG_EXECUTE_CODE;
1476 1477
  }
  else
1478
    file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]= (char)DDL_IGNORE_LOG_ENTRY_CODE;
1479 1480 1481 1482
  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;
1483 1484
  file_entry_buf[DDL_LOG_NAME_POS + FN_REFLEN]= 0;
  file_entry_buf[DDL_LOG_NAME_POS + 2*FN_REFLEN]= 0;
1485
  if (!(*active_entry))
1486
  {
1487
    if (get_free_ddl_log_entry(active_entry, &write_header))
1488 1489 1490
    {
      DBUG_RETURN(TRUE);
    }
1491
    write_header= TRUE;
1492
  }
1493
  if (write_ddl_log_file_entry((*active_entry)->entry_pos))
1494
  {
1495
    sql_print_error("Error writing execute entry in ddl log");
1496
    release_ddl_log_memory_entry(*active_entry);
1497 1498
    DBUG_RETURN(TRUE);
  }
1499
  (void) sync_ddl_log_no_lock();
1500 1501
  if (write_header)
  {
1502
    if (write_ddl_log_header())
1503
    {
1504
      release_ddl_log_memory_entry(*active_entry);
1505 1506 1507
      DBUG_RETURN(TRUE);
    }
  }
unknown's avatar
unknown committed
1508 1509 1510 1511
  DBUG_RETURN(FALSE);
}


1512 1513 1514 1515 1516 1517 1518 1519 1520 1521
/**
  Deactivate an individual entry.

  @details see deactivate_ddl_log_entry_no_lock.

  @param entry_no     Entry position of record to change

  @return Operation status
    @retval TRUE      Error
    @retval FALSE     Success
1522 1523
*/

1524
bool deactivate_ddl_log_entry(uint entry_no)
1525
{
1526
  bool error;
1527
  DBUG_ENTER("deactivate_ddl_log_entry");
1528

1529 1530 1531 1532
  mysql_mutex_lock(&LOCK_gdl);
  error= deactivate_ddl_log_entry_no_lock(entry_no);
  mysql_mutex_unlock(&LOCK_gdl);
  DBUG_RETURN(error);
1533 1534 1535
}


1536 1537 1538 1539 1540 1541
/**
  Sync ddl log file.

  @return Operation status
    @retval TRUE        Error
    @retval FALSE       Success
1542 1543
*/

1544
bool sync_ddl_log()
1545
{
1546
  bool error;
1547
  DBUG_ENTER("sync_ddl_log");
1548

1549 1550 1551 1552
  mysql_mutex_lock(&LOCK_gdl);
  error= sync_ddl_log_no_lock();
  mysql_mutex_unlock(&LOCK_gdl);

1553 1554 1555 1556
  DBUG_RETURN(error);
}


1557 1558 1559
/**
  Release a log memory entry.
  @param log_memory_entry                Log memory entry to release
1560 1561
*/

1562
void release_ddl_log_memory_entry(DDL_LOG_MEMORY_ENTRY *log_entry)
1563
{
1564 1565 1566 1567
  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");
1568

1569
  mysql_mutex_assert_owner(&LOCK_gdl);
1570
  global_ddl_log.first_free= log_entry;
1571 1572 1573 1574 1575
  log_entry->next_log_entry= first_free;

  if (prev_log_entry)
    prev_log_entry->next_log_entry= next_log_entry;
  else
1576
    global_ddl_log.first_used= next_log_entry;
1577 1578
  if (next_log_entry)
    next_log_entry->prev_log_entry= prev_log_entry;
1579
  DBUG_VOID_RETURN;
1580 1581 1582
}


1583 1584 1585 1586 1587 1588 1589 1590 1591 1592
/**
  Execute one entry in the ddl log.
  
  Executing an entry means executing a linked list of actions.

  @param first_entry           Reference to first action in entry

  @return Operation status
    @retval TRUE               Error
    @retval FALSE              Success
unknown's avatar
unknown committed
1593 1594
*/

1595
bool execute_ddl_log_entry(THD *thd, uint first_entry)
unknown's avatar
unknown committed
1596
{
1597
  bool error;
1598
  DBUG_ENTER("execute_ddl_log_entry");
unknown's avatar
unknown committed
1599

Marc Alff's avatar
Marc Alff committed
1600
  mysql_mutex_lock(&LOCK_gdl);
1601
  error= execute_ddl_log_entry_no_lock(thd, first_entry);
Marc Alff's avatar
Marc Alff committed
1602
  mysql_mutex_unlock(&LOCK_gdl);
1603
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1604 1605
}

1606

1607 1608
/**
  Close the ddl log.
1609 1610 1611 1612 1613 1614 1615
*/

static void close_ddl_log()
{
  DBUG_ENTER("close_ddl_log");
  if (global_ddl_log.file_id >= 0)
  {
Marc Alff's avatar
Marc Alff committed
1616
    (void) mysql_file_close(global_ddl_log.file_id, MYF(MY_WME));
1617 1618 1619 1620 1621 1622
    global_ddl_log.file_id= (File) -1;
  }
  DBUG_VOID_RETURN;
}


1623 1624
/**
  Execute the ddl log at recovery of MySQL Server.
unknown's avatar
unknown committed
1625 1626
*/

1627
void execute_ddl_log_recovery()
unknown's avatar
unknown committed
1628
{
1629
  uint num_entries, i;
unknown's avatar
Fixes  
unknown committed
1630
  THD *thd;
1631
  DDL_LOG_ENTRY ddl_log_entry;
unknown's avatar
Fixes  
unknown committed
1632
  char file_name[FN_REFLEN];
Sergei Golubchik's avatar
Sergei Golubchik committed
1633
  static char recover_query_string[]= "INTERNAL DDL LOG RECOVER IN PROGRESS";
1634
  DBUG_ENTER("execute_ddl_log_recovery");
unknown's avatar
unknown committed
1635

1636 1637 1638 1639 1640 1641 1642
  /*
    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;
unknown's avatar
unknown committed
1643
  global_ddl_log.file_id= (File) -1;
1644

1645 1646 1647
  /*
    To be able to run this from boot, we allocate a temporary THD
  */
Monty's avatar
Monty committed
1648
  if (!(thd=new THD(0)))
1649 1650 1651 1652
    DBUG_VOID_RETURN;
  thd->thread_stack= (char*) &thd;
  thd->store_globals();

Sergei Golubchik's avatar
Sergei Golubchik committed
1653 1654 1655
  thd->set_query(recover_query_string, strlen(recover_query_string));

  /* this also initialize LOCK_gdl */
1656
  num_entries= read_ddl_log_header();
1657
  mysql_mutex_lock(&LOCK_gdl);
1658
  for (i= 1; i < num_entries + 1; i++)
unknown's avatar
unknown committed
1659
  {
1660
    if (read_ddl_log_entry(i, &ddl_log_entry))
1661
    {
1662 1663 1664
      sql_print_error("Failed to read entry no = %u from ddl log",
                       i);
      continue;
1665
    }
1666
    if (ddl_log_entry.entry_type == DDL_LOG_EXECUTE_CODE)
unknown's avatar
unknown committed
1667
    {
1668
      if (execute_ddl_log_entry_no_lock(thd, ddl_log_entry.next_entry))
unknown's avatar
unknown committed
1669
      {
1670 1671
        /* Real unpleasant scenario but we continue anyways.  */
        continue;
unknown's avatar
unknown committed
1672 1673 1674
      }
    }
  }
1675
  close_ddl_log();
1676
  create_ddl_log_file_name(file_name);
Marc Alff's avatar
Marc Alff committed
1677
  (void) mysql_file_delete(key_file_global_ddl_log, file_name, MYF(0));
1678
  global_ddl_log.recovery_phase= FALSE;
1679
  mysql_mutex_unlock(&LOCK_gdl);
Sergei Golubchik's avatar
Sergei Golubchik committed
1680
  thd->reset_query();
1681
  delete thd;
1682
  DBUG_VOID_RETURN;
1683 1684 1685
}


1686 1687
/**
  Release all memory allocated to the ddl log.
1688 1689
*/

1690
void release_ddl_log()
1691
{
1692 1693
  DDL_LOG_MEMORY_ENTRY *free_list;
  DDL_LOG_MEMORY_ENTRY *used_list;
1694
  DBUG_ENTER("release_ddl_log");
1695

1696 1697 1698
  if (!global_ddl_log.do_release)
    DBUG_VOID_RETURN;

Marc Alff's avatar
Marc Alff committed
1699
  mysql_mutex_lock(&LOCK_gdl);
1700 1701
  free_list= global_ddl_log.first_free;
  used_list= global_ddl_log.first_used;
1702 1703
  while (used_list)
  {
1704
    DDL_LOG_MEMORY_ENTRY *tmp= used_list->next_log_entry;
1705
    my_free(used_list);
unknown's avatar
unknown committed
1706
    used_list= tmp;
1707 1708 1709
  }
  while (free_list)
  {
1710
    DDL_LOG_MEMORY_ENTRY *tmp= free_list->next_log_entry;
1711
    my_free(free_list);
unknown's avatar
unknown committed
1712
    free_list= tmp;
1713
  }
1714
  close_ddl_log();
unknown's avatar
unknown committed
1715
  global_ddl_log.inited= 0;
Marc Alff's avatar
Marc Alff committed
1716 1717
  mysql_mutex_unlock(&LOCK_gdl);
  mysql_mutex_destroy(&LOCK_gdl);
1718
  global_ddl_log.do_release= false;
1719
  DBUG_VOID_RETURN;
1720 1721 1722
}


unknown's avatar
unknown committed
1723 1724 1725
/*
---------------------------------------------------------------------------

1726
  END MODULE DDL log
unknown's avatar
unknown committed
1727 1728 1729 1730 1731
  --------------------

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

unknown's avatar
unknown committed
1732

1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757
/**
   @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);
}


unknown's avatar
unknown committed
1758 1759 1760 1761 1762 1763 1764 1765
/*
  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
1766 1767 1768 1769 1770 1771
      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.
unknown's avatar
unknown committed
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
      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];
1794 1795
  char shadow_path[FN_REFLEN+1];
  char shadow_frm_name[FN_REFLEN+1];
unknown's avatar
unknown committed
1796
  char frm_name[FN_REFLEN+1];
1797 1798 1799 1800
#ifdef WITH_PARTITION_STORAGE_ENGINE
  char *part_syntax_buf;
  uint syntax_len;
#endif
unknown's avatar
unknown committed
1801 1802
  DBUG_ENTER("mysql_write_frm");

1803 1804 1805
  /*
    Build shadow frm file name
  */
1806
  build_table_shadow_filename(shadow_path, sizeof(shadow_path) - 1, lpt);
1807
  strxmov(shadow_frm_name, shadow_path, reg_ext, NullS);
1808
  if (flags & WFRM_WRITE_SHADOW)
unknown's avatar
unknown committed
1809
  {
1810 1811 1812 1813
    if (mysql_prepare_create_table(lpt->thd, lpt->create_info, lpt->alter_info,
                                   &lpt->db_options, lpt->table->file,
                                   &lpt->key_info_buffer, &lpt->key_count,
                                   C_ALTER_TABLE))
unknown's avatar
unknown committed
1814 1815 1816 1817 1818
    {
      DBUG_RETURN(TRUE);
    }
#ifdef WITH_PARTITION_STORAGE_ENGINE
    {
1819 1820
      partition_info *part_info= lpt->table->part_info;
      if (part_info)
unknown's avatar
unknown committed
1821
      {
1822
        if (!(part_syntax_buf= generate_partition_syntax(lpt->thd, part_info,
1823
                                                         &syntax_len,
1824 1825
                                                         TRUE, TRUE,
                                                         lpt->create_info,
1826 1827
                                                         lpt->alter_info,
                                                         NULL)))
1828 1829 1830 1831
        {
          DBUG_RETURN(TRUE);
        }
        part_info->part_info_string= part_syntax_buf;
1832
        part_info->part_info_len= syntax_len;
unknown's avatar
unknown committed
1833 1834 1835
      }
    }
#endif
1836 1837
    /* Write shadow frm file */
    lpt->create_info->table_options= lpt->db_options;
1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849
    LEX_CUSTRING frm= build_frm_image(lpt->thd, lpt->table_name,
                                      lpt->create_info,
                                      lpt->alter_info->create_list,
                                      lpt->key_count, lpt->key_info_buffer,
                                      lpt->table->file);
    if (!frm.str)
    {
      error= 1;
      goto end;
    }

    int error= writefrm(shadow_path, lpt->db, lpt->table_name,
1850
                        lpt->create_info->tmp_table(), frm.str, frm.length);
1851 1852 1853
    my_free(const_cast<uchar*>(frm.str));

    if (error || lpt->table->file->ha_create_partitioning_metadata(shadow_path,
1854
                                       NULL, CHF_CREATE_FLAG))
1855
    {
Marc Alff's avatar
Marc Alff committed
1856
      mysql_file_delete(key_file_frm, shadow_frm_name, MYF(0));
1857 1858 1859
      error= 1;
      goto end;
    }
unknown's avatar
unknown committed
1860
  }
1861 1862
  if (flags & WFRM_INSTALL_SHADOW)
  {
1863 1864 1865
#ifdef WITH_PARTITION_STORAGE_ENGINE
    partition_info *part_info= lpt->part_info;
#endif
1866 1867 1868
    /*
      Build frm file name
    */
1869
    build_table_filename(path, sizeof(path) - 1, lpt->db,
1870
                         lpt->table_name, "", 0);
1871
    strxnmov(frm_name, sizeof(frm_name), path, reg_ext, NullS);
1872 1873 1874
    /*
      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.
1875 1876 1877 1878 1879 1880
      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.
1881
    */
Marc Alff's avatar
Marc Alff committed
1882
    if (mysql_file_delete(key_file_frm, frm_name, MYF(MY_WME)) ||
1883
#ifdef WITH_PARTITION_STORAGE_ENGINE
1884
        lpt->table->file->ha_create_partitioning_metadata(path, shadow_path,
1885
                                                  CHF_DELETE_FLAG) ||
1886 1887
        deactivate_ddl_log_entry(part_info->frm_log_entry->entry_pos) ||
        (sync_ddl_log(), FALSE) ||
Marc Alff's avatar
Marc Alff committed
1888 1889
        mysql_file_rename(key_file_frm,
                          shadow_frm_name, frm_name, MYF(MY_WME)) ||
1890
        lpt->table->file->ha_create_partitioning_metadata(path, shadow_path,
1891
                                                  CHF_RENAME_FLAG))
1892
#else
Marc Alff's avatar
Marc Alff committed
1893 1894
        mysql_file_rename(key_file_frm,
                          shadow_frm_name, frm_name, MYF(MY_WME)))
1895
#endif
1896 1897
    {
      error= 1;
1898
      goto err;
1899
    }
1900
#ifdef WITH_PARTITION_STORAGE_ENGINE
1901
    if (part_info && (flags & WFRM_KEEP_SHARE))
1902 1903 1904
    {
      TABLE_SHARE *share= lpt->table->s;
      char *tmp_part_syntax_str;
1905
      if (!(part_syntax_buf= generate_partition_syntax(lpt->thd, part_info,
1906
                                                       &syntax_len,
1907 1908
                                                       TRUE, TRUE,
                                                       lpt->create_info,
1909 1910
                                                       lpt->alter_info,
                                                       NULL)))
1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924
      {
        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;
        }
1925
        share->partition_info_str= tmp_part_syntax_str;
1926 1927
      }
      else
1928 1929 1930
        memcpy((char*) share->partition_info_str, part_syntax_buf,
               syntax_len + 1);
      share->partition_info_str_len= part_info->part_info_len= syntax_len;
1931
      part_info->part_info_string= part_syntax_buf;
1932
    }
1933 1934 1935
#endif

err:
1936
#ifdef WITH_PARTITION_STORAGE_ENGINE
1937
    deactivate_ddl_log_entry(part_info->frm_log_entry->entry_pos);
1938
    part_info->frm_log_entry= NULL;
Konstantin Osipov's avatar
Konstantin Osipov committed
1939
    (void) sync_ddl_log();
1940
#endif
Magne Mahre's avatar
Magne Mahre committed
1941
    ;
unknown's avatar
unknown committed
1942
  }
1943

unknown's avatar
unknown committed
1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955
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
1956 1957
    is_trans                      if the event changes either
                                  a trans or non-trans engine.
unknown's avatar
unknown committed
1958 1959 1960 1961 1962 1963 1964 1965 1966

  RETURN VALUES
    NONE

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

1967
int write_bin_log(THD *thd, bool clear_error,
1968
                  char const *query, ulong query_length, bool is_trans)
unknown's avatar
unknown committed
1969
{
1970
  int error= 0;
unknown's avatar
unknown committed
1971 1972
  if (mysql_bin_log.is_open())
  {
1973
    int errcode= 0;
1974
    thd_proc_info(thd, "Writing to binlog");
unknown's avatar
unknown committed
1975 1976
    if (clear_error)
      thd->clear_error();
1977 1978
    else
      errcode= query_error_code(thd, TRUE);
1979
    error= thd->binlog_query(THD::STMT_QUERY_TYPE,
1980 1981
                             query, query_length, is_trans, FALSE, FALSE,
                             errcode);
1982
    thd_proc_info(thd, 0);
unknown's avatar
unknown committed
1983
  }
1984
  return error;
unknown's avatar
unknown committed
1985 1986
}

1987

unknown's avatar
unknown committed
1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002
/*
 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

Konstantin Osipov's avatar
Konstantin Osipov committed
2003 2004
    Wait if global_read_lock (FLUSH TABLES WITH READ LOCK) is set, but
    not if under LOCK TABLES.
unknown's avatar
unknown committed
2005 2006

  RETURN
unknown's avatar
unknown committed
2007 2008
    FALSE OK.  In this case ok packet is sent to user
    TRUE  Error
unknown's avatar
unknown committed
2009 2010

*/
unknown's avatar
unknown committed
2011

unknown's avatar
unknown committed
2012 2013
bool mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists,
                    my_bool drop_temporary)
unknown's avatar
unknown committed
2014
{
2015
  bool error;
2016
  Drop_table_error_handler err_handler;
2017
  TABLE_LIST *table;
unknown's avatar
unknown committed
2018 2019
  DBUG_ENTER("mysql_rm_table");

2020 2021 2022
  /* Disable drop of enabled log tables, must be done before name locking */
  for (table= tables; table; table= table->next_local)
  {
2023
    if (check_if_log_table(table, TRUE, "DROP"))
2024 2025 2026
      DBUG_RETURN(true);
  }

2027
  if (!drop_temporary)
2028
  {
2029
    if (!in_bootstrap)
2030
    {
2031 2032 2033 2034 2035
      for (table= tables; table; table= table->next_local)
      {
        LEX_STRING db_name= { table->db, table->db_length };
        LEX_STRING table_name= { table->table_name, table->table_name_length };
        if (table->open_type == OT_BASE_ONLY ||
2036
            !thd->find_temporary_table(table))
2037 2038
          (void) delete_statistics_for_table(thd, &db_name, &table_name);
      }
2039
    }
unknown's avatar
unknown committed
2040

2041 2042
    if (!thd->locked_tables_mode)
    {
unknown's avatar
unknown committed
2043 2044
      if (lock_table_names(thd, tables, NULL,
                           thd->variables.lock_wait_timeout, 0))
2045 2046 2047 2048 2049
        DBUG_RETURN(true);
    }
    else
    {
      for (table= tables; table; table= table->next_local)
Michael Widenius's avatar
Michael Widenius committed
2050 2051
      {
        if (is_temporary_table(table))
2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076
        {
          /*
            A temporary table.

            Don't try to find a corresponding MDL lock or assign it
            to table->mdl_request.ticket. There can't be metadata
            locks for temporary tables: they are local to the session.

            Later in this function we release the MDL lock only if
            table->mdl_requeset.ticket is not NULL. Thus here we
            ensure that we won't release the metadata lock on the base
            table locked with LOCK TABLES as a side effect of temporary
            table drop.
          */
          DBUG_ASSERT(table->mdl_request.ticket == NULL);
        }
        else
        {
          /*
            Not a temporary table.

            Since 'tables' list can't contain duplicates (this is ensured
            by parser) it is safe to cache pointer to the TABLE instances
            in its elements.
          */
2077
          table->table= find_table_for_mdl_upgrade(thd, table->db,
2078 2079 2080 2081 2082
                                                   table->table_name, false);
          if (!table->table)
            DBUG_RETURN(true);
          table->mdl_request.ticket= table->table->mdl_ticket;
        }
Michael Widenius's avatar
Michael Widenius committed
2083
      }
2084
    }
unknown's avatar
unknown committed
2085
  }
2086

unknown's avatar
unknown committed
2087
  /* mark for close and remove all cached entries */
2088
  thd->push_internal_handler(&err_handler);
2089
  error= mysql_rm_table_no_locks(thd, tables, if_exists, drop_temporary,
2090
                                 false, false, false);
2091 2092
  thd->pop_internal_handler();

2093
  if (error)
unknown's avatar
unknown committed
2094
    DBUG_RETURN(TRUE);
2095
  my_ok(thd);
unknown's avatar
unknown committed
2096
  DBUG_RETURN(FALSE);
2097 2098
}

2099

2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116
/**
  Find the comment in the query.
  That's auxiliary function to be used handling DROP TABLE [comment].

  @param  thd             Thread handler
  @param  comment_pos     How many characters to skip before the comment.
                          Can be either 9 for DROP TABLE or
                          17 for DROP TABLE IF EXISTS
  @param  comment_start   returns the beginning of the comment if found.

  @retval  0  no comment found
  @retval  >0 the lenght of the comment found

*/
static uint32 comment_length(THD *thd, uint32 comment_pos,
                             const char **comment_start)
{
2117 2118 2119
  /* We use uchar * here to make array indexing portable */
  const uchar *query= (uchar*) thd->query();
  const uchar *query_end= (uchar*) query + thd->query_length();
2120 2121 2122 2123
  const uchar *const state_map= thd->charset()->state_map;

  for (; query < query_end; query++)
  {
Sergei Golubchik's avatar
Sergei Golubchik committed
2124
    if (state_map[static_cast<uchar>(*query)] == MY_LEX_SKIP)
2125 2126 2127 2128 2129
      continue;
    if (comment_pos-- == 0)
      break;
  }
  if (query > query_end - 3 /* comment can't be shorter than 4 */ ||
Sergei Golubchik's avatar
Sergei Golubchik committed
2130
      state_map[static_cast<uchar>(*query)] != MY_LEX_LONG_COMMENT || query[1] != '*')
2131 2132
    return 0;
  
2133
  *comment_start= (char*) query;
2134 2135 2136 2137
  
  for (query+= 3; query < query_end; query++)
  {
    if (query[-1] == '*' && query[0] == '/')
2138
      return (char*) query - *comment_start + 1;
2139 2140 2141 2142 2143
  }
  return 0;
}


2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154
/**
  Execute the drop of a normal or temporary table.

  @param  thd             Thread handler
  @param  tables          Tables to drop
  @param  if_exists       If set, don't give an error if table doesn't exists.
                          In this case we give an warning of level 'NOTE'
  @param  drop_temporary  Only drop temporary tables
  @param  drop_view       Allow to delete VIEW .frm
  @param  dont_log_query  Don't write query to log files. This will also not
                          generate warnings if the handler files doesn't exists
2155 2156
  @param  dont_free_locks Don't do automatic UNLOCK TABLE if no more locked
                          tables
2157 2158 2159 2160 2161 2162 2163 2164

  @retval  0  ok
  @retval  1  Error
  @retval -1  Thread was killed

  @note This function assumes that metadata locks have already been taken.
        It is also assumed that the tables have been removed from TDC.

unknown's avatar
unknown committed
2165 2166 2167
  @note This function assumes that temporary tables to be dropped have
        been pre-opened using corresponding table list elements.

2168 2169 2170 2171 2172 2173 2174
  @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.
2175
*/
2176

2177 2178
int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists,
                            bool drop_temporary, bool drop_view,
2179 2180
                            bool dont_log_query,
                            bool dont_free_locks)
2181 2182
{
  TABLE_LIST *table;
Michael Widenius's avatar
Michael Widenius committed
2183 2184 2185
  char path[FN_REFLEN + 1], wrong_tables_buff[160], *alias= NULL;
  String wrong_tables(wrong_tables_buff, sizeof(wrong_tables_buff)-1,
                      system_charset_info);
2186
  uint path_length= 0, errors= 0;
2187
  int error= 0;
2188
  int non_temp_tables_count= 0;
2189 2190 2191
  bool non_tmp_error= 0;
  bool trans_tmp_table_deleted= 0, non_trans_tmp_table_deleted= 0;
  bool non_tmp_table_deleted= 0;
2192
  bool is_drop_tmp_if_exists_added= 0;
2193
  bool was_view= 0;
2194
  String built_query;
2195
  String built_trans_tmp_query, built_non_trans_tmp_query;
2196
  DBUG_ENTER("mysql_rm_table_no_locks");
2197

Michael Widenius's avatar
Michael Widenius committed
2198
  wrong_tables.length(0);
2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222
  /*
    Prepares the drop statements that will be written into the binary
    log as follows:

    1 - If we are not processing a "DROP TEMPORARY" it prepares a
    "DROP".

    2 - A "DROP" may result in a "DROP TEMPORARY" but the opposite is
    not true.

    3 - If the current format is row, the IF EXISTS token needs to be
    appended because one does not know if CREATE TEMPORARY was previously
    written to the binary log.

    4 - Add the IF_EXISTS token if necessary, i.e. if_exists is TRUE.

    5 - For temporary tables, there is a need to differentiate tables
    in transactional and non-transactional storage engines. For that,
    reason, two types of drop statements are prepared.

    The need to different the type of tables when dropping a temporary
    table stems from the fact that such drop does not commit an ongoing
    transaction and changes to non-transactional tables must be written
    ahead of the transaction in some circumstances.
2223 2224 2225 2226 2227 2228 2229 2230 2231

    6- Slave SQL thread ignores all replicate-* filter rules
    for temporary tables with 'IF EXISTS' clause. (See sql/sql_parse.cc:
    mysql_execute_command() for details). These commands will be binlogged
    as they are, even if the default database (from USE `db`) is not present
    on the Slave. This can cause point in time recovery failures later
    when user uses the slave's binlog to re-apply. Hence at the time of binary
    logging, these commands will be written with fully qualified table names
    and use `db` will be suppressed.
2232 2233
  */
  if (!dont_log_query)
2234
  {
2235 2236
    if (!drop_temporary)
    {
2237 2238 2239
      const char *comment_start;
      uint32 comment_len;

2240
      built_query.set_charset(thd->charset());
2241 2242 2243 2244
      if (if_exists)
        built_query.append("DROP TABLE IF EXISTS ");
      else
        built_query.append("DROP TABLE ");
2245 2246 2247 2248 2249 2250

      if ((comment_len= comment_length(thd, if_exists ? 17:9, &comment_start)))
      {
        built_query.append(comment_start, comment_len);
        built_query.append(" ");
      }
2251 2252 2253 2254
    }

    if (thd->is_current_stmt_binlog_format_row() || if_exists)
    {
2255
      is_drop_tmp_if_exists_added= true;
2256 2257 2258 2259 2260
      built_trans_tmp_query.set_charset(system_charset_info);
      built_trans_tmp_query.append("DROP TEMPORARY TABLE IF EXISTS ");
      built_non_trans_tmp_query.set_charset(system_charset_info);
      built_non_trans_tmp_query.append("DROP TEMPORARY TABLE IF EXISTS ");
    }
2261
    else
2262 2263 2264 2265 2266 2267
    {
      built_trans_tmp_query.set_charset(system_charset_info);
      built_trans_tmp_query.append("DROP TEMPORARY TABLE ");
      built_non_trans_tmp_query.set_charset(system_charset_info);
      built_non_trans_tmp_query.append("DROP TEMPORARY TABLE ");
    }
2268
  }
2269

unknown's avatar
VIEW  
unknown committed
2270
  for (table= tables; table; table= table->next_local)
unknown's avatar
unknown committed
2271
  {
2272
    bool is_trans= 0;
2273
    bool table_creation_was_logged= 1;
2274
    char *db=table->db;
unknown's avatar
unknown committed
2275
    size_t db_length= table->db_length;
2276
    handlerton *table_type= 0;
2277

2278 2279 2280
    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));
2281

2282 2283 2284 2285 2286 2287 2288
    /*
      If we are in locked tables mode and are dropping a temporary table,
      the ticket should be NULL to ensure that we don't release a lock
      on a base table later.
    */
    DBUG_ASSERT(!(thd->locked_tables_mode &&
                  table->open_type != OT_BASE_ONLY &&
2289
                  thd->find_temporary_table(table) &&
2290 2291
                  table->mdl_request.ticket != NULL));

2292
    if (table->open_type == OT_BASE_ONLY || !is_temporary_table(table))
2293
      error= 1;
2294
    else
2295
    {
2296
      table_creation_was_logged= table->table->s->table_creation_was_logged;
2297
      if (thd->drop_temporary_table(table->table, &is_trans, true))
2298
      {
2299
        error= 1;
2300 2301
        goto err;
      }
2302
      error= 0;
2303
      table->table= 0;
2304 2305 2306 2307
    }

    if ((drop_temporary && if_exists) || !error)
    {
2308
      /*
2309 2310 2311 2312 2313 2314 2315 2316
        This handles the case of temporary tables. We have the following cases:

          . "DROP TEMPORARY" was executed and a temporary table was affected
          (i.e. drop_temporary && !error) or the if_exists was specified (i.e.
          drop_temporary && if_exists).

          . "DROP" was executed but a temporary table was affected (.i.e
          !error).
2317
      */
2318
      if (!dont_log_query && table_creation_was_logged)
2319
      {
2320 2321 2322 2323 2324 2325 2326 2327 2328
        /*
          If there is an error, we don't know the type of the engine
          at this point. So, we keep it in the trx-cache.
        */
        is_trans= error ? TRUE : is_trans;
        if (is_trans)
          trans_tmp_table_deleted= TRUE;
        else
          non_trans_tmp_table_deleted= TRUE;
2329

2330 2331 2332
        String *built_ptr_query=
          (is_trans ? &built_trans_tmp_query : &built_non_trans_tmp_query);
        /*
2333 2334 2335
          Write the database name if it is not the current one or if
          thd->db is NULL or 'IF EXISTS' clause is present in 'DROP TEMPORARY'
          query.
2336
        */
2337 2338
        if (thd->db == NULL || strcmp(db,thd->db) != 0
            || is_drop_tmp_if_exists_added )
2339
        {
unknown's avatar
unknown committed
2340 2341
          append_identifier(thd, built_ptr_query, db, db_length);
          built_ptr_query->append(".");
2342
        }
unknown's avatar
unknown committed
2343
        append_identifier(thd, built_ptr_query, table->table_name,
unknown's avatar
unknown committed
2344
                          table->table_name_length);
unknown's avatar
unknown committed
2345
        built_ptr_query->append(",");
2346
      }
2347
      /*
2348 2349 2350
        This means that a temporary table was droped and as such there
        is no need to proceed with the code that tries to drop a regular
        table.
2351
      */
2352
      if (!error) continue;
2353
    }
2354
    else if (!drop_temporary)
unknown's avatar
unknown committed
2355
    {
2356 2357
      non_temp_tables_count++;

2358 2359
      DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, table->db,
                                                 table->table_name,
2360
                                                 MDL_SHARED));
2361

2362
      alias= (lower_case_table_names == 2) ? table->alias : table->table_name;
unknown's avatar
unknown committed
2363
      /* remove .frm file and engine files */
2364
      path_length= build_table_filename(path, sizeof(path) - 1, db, alias,
2365
                                        reg_ext, 0);
2366 2367 2368 2369 2370

      /*
        This handles the case where a "DROP" was executed and a regular
        table "may be" dropped as drop_temporary is FALSE and error is
        TRUE. If the error was FALSE a temporary table was dropped and
2371
        regardless of the status of drop_temporary a "DROP TEMPORARY"
2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387
        must be used.
      */
      if (!dont_log_query)
      {
        /*
          Note that unless if_exists is TRUE or a temporary table was deleted, 
          there is no means to know if the statement should be written to the
          binary log. See further information on this variable in what follows.
        */
        non_tmp_table_deleted= (if_exists ? TRUE : non_tmp_table_deleted);
        /*
          Don't write the database name if it is the current one (or if
          thd->db is NULL).
        */
        if (thd->db == NULL || strcmp(db,thd->db) != 0)
        {
unknown's avatar
unknown committed
2388 2389
          append_identifier(thd, &built_query, db, db_length);
          built_query.append(".");
2390 2391
        }

unknown's avatar
unknown committed
2392 2393 2394
        append_identifier(thd, &built_query, table->table_name,
                          table->table_name_length);
        built_query.append(",");
2395
      }
unknown's avatar
unknown committed
2396
    }
2397
    DEBUG_SYNC(thd, "rm_table_no_locks_before_delete_table");
2398
    error= 0;
2399 2400 2401
    if (drop_temporary ||
        (ha_table_exists(thd, db, alias, &table_type) == 0 && table_type == 0) ||
        (!drop_view && (was_view= (table_type == view_pseudo_hton))))
unknown's avatar
unknown committed
2402
    {
2403 2404 2405
      /*
        One of the following cases happened:
          . "DROP TEMPORARY" but a temporary table was not found.
2406 2407
          . "DROP" but table was not found
          . "DROP TABLE" statement, but it's a view. 
2408
      */
2409
      if (if_exists)
Michael Widenius's avatar
Michael Widenius committed
2410 2411 2412 2413 2414 2415 2416 2417
      {
        char buff[FN_REFLEN];
        String tbl_name(buff, sizeof(buff), system_charset_info);
        tbl_name.length(0);
        tbl_name.append(db);
        tbl_name.append('.');
        tbl_name.append(table->table_name);
        push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
2418 2419
                            ER_BAD_TABLE_ERROR,
                            ER_THD(thd, ER_BAD_TABLE_ERROR),
Michael Widenius's avatar
Michael Widenius committed
2420 2421
                            tbl_name.c_ptr_safe());
      }
2422
      else
2423 2424
      {
        non_tmp_error = (drop_temporary ? non_tmp_error : TRUE);
2425
        error= 1;
2426
      }
unknown's avatar
unknown committed
2427 2428 2429
    }
    else
    {
unknown's avatar
unknown committed
2430
      char *end;
2431
      /*
2432
        It could happen that table's share in the table definition cache
2433 2434 2435 2436 2437 2438 2439
        is the only thing that keeps the engine plugin loaded
        (if it is uninstalled and waits for the ref counter to drop to 0).

        In this case, the tdc_remove_table() below will release and unload
        the plugin. And ha_delete_table() will get a dangling pointer.

        Let's lock the plugin till the end of the statement.
2440
      */
2441
      if (table_type && table_type != view_pseudo_hton)
2442
        ha_lock_engine(thd, table_type);
2443

2444
      if (thd->locked_tables_mode)
unknown's avatar
unknown committed
2445
      {
2446
        if (wait_while_table_is_used(thd, table->table, HA_EXTRA_NOT_USED))
2447 2448 2449 2450
        {
          error= -1;
          goto err;
        }
2451
        /* the following internally does TDC_RT_REMOVE_ALL */
2452
        close_all_tables_for_name(thd, table->table->s,
Sergei Golubchik's avatar
Sergei Golubchik committed
2453
                                  HA_EXTRA_PREPARE_FOR_DROP, NULL);
2454
        table->table= 0;
unknown's avatar
unknown committed
2455
      }
2456 2457 2458 2459 2460 2461 2462 2463 2464
      else
        tdc_remove_table(thd, TDC_RT_REMOVE_ALL, table->db, table->table_name,
                         false);

      /* Check that we have an exclusive lock on the table to be dropped. */
      DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, table->db,
                                                 table->table_name,
                                                 MDL_EXCLUSIVE));

2465 2466
      // Remove extension for delete
      *(end= path + path_length - reg_ext_length)= '\0';
2467

unknown's avatar
unknown committed
2468
      error= ha_delete_table(thd, table_type, path, db, table->table_name,
2469
                             !dont_log_query);
2470

2471
      if (!error)
unknown's avatar
unknown committed
2472
      {
2473
        int frm_delete_error, trigger_drop_error= 0;
unknown's avatar
unknown committed
2474 2475
	/* Delete the table definition file */
	strmov(end,reg_ext);
2476 2477 2478 2479
        frm_delete_error= mysql_file_delete(key_file_frm, path, MYF(MY_WME));
        if (frm_delete_error)
          frm_delete_error= my_errno;
        else
2480
        {
2481
          non_tmp_table_deleted= TRUE;
2482 2483 2484 2485 2486 2487 2488
          trigger_drop_error=
            Table_triggers_list::drop_all_triggers(thd, db, table->table_name);
        }

        if (trigger_drop_error ||
            (frm_delete_error && frm_delete_error != ENOENT))
          error= 1;
2489
        else if (frm_delete_error && if_exists)
2490
          thd->clear_error();
2491
      }
2492
      non_tmp_error= error ? TRUE : non_tmp_error;
unknown's avatar
unknown committed
2493 2494 2495 2496 2497
    }
    if (error)
    {
      if (wrong_tables.length())
	wrong_tables.append(',');
Michael Widenius's avatar
Michael Widenius committed
2498 2499 2500
      wrong_tables.append(db);
      wrong_tables.append('.');
      wrong_tables.append(table->table_name);
2501
      errors++;
unknown's avatar
unknown committed
2502
    }
2503 2504
    else
    {
Sergei Golubchik's avatar
Sergei Golubchik committed
2505
      PSI_CALL_drop_table_share(false, table->db, table->db_length,
2506
                                table->table_name, table->table_name_length);
2507
      mysql_audit_drop_table(thd, table);
2508 2509
    }

2510 2511
    DBUG_PRINT("table", ("table: 0x%lx  s: 0x%lx", (long) table->table,
                         table->table ? (long) table->table->s : (long) -1));
2512 2513

    DBUG_EXECUTE_IF("bug43138",
2514
                    my_error(ER_BAD_TABLE_ERROR, MYF(0),
2515
                                    table->table_name););
unknown's avatar
unknown committed
2516
  }
2517
  DEBUG_SYNC(thd, "rm_table_no_locks_before_binlog");
2518 2519
  thd->thread_specific_used|= (trans_tmp_table_deleted ||
                               non_trans_tmp_table_deleted);
2520
  error= 0;
2521
err:
2522 2523
  if (wrong_tables.length())
  {
2524 2525
    DBUG_ASSERT(errors);
    if (errors == 1 && was_view)
2526
      my_error(ER_IT_IS_A_VIEW, MYF(0), wrong_tables.c_ptr_safe());
2527
    else if (errors > 1 || !thd->is_error())
2528
      my_error(ER_BAD_TABLE_ERROR, MYF(0), wrong_tables.c_ptr_safe());
2529 2530 2531
    error= 1;
  }

2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543
  /*
    We are always logging drop of temporary tables.
    The reason is to handle the following case:
    - Use statement based replication
    - CREATE TEMPORARY TABLE foo (logged)
    - set row based replication
    - DROP TEMPORAY TABLE foo    (needs to be logged)
    This should be fixed so that we remember if creation of the
    temporary table was logged and only log it if the creation was
    logged.
  */

2544 2545
  if (non_trans_tmp_table_deleted ||
      trans_tmp_table_deleted || non_tmp_table_deleted)
unknown's avatar
unknown committed
2546
  {
unknown's avatar
unknown committed
2547
    query_cache_invalidate3(thd, tables, 0);
2548
    if (!dont_log_query && mysql_bin_log.is_open())
2549
    {
2550
      if (non_trans_tmp_table_deleted)
2551
      {
2552 2553 2554 2555 2556 2557
          /* Chop of the last comma */
          built_non_trans_tmp_query.chop();
          built_non_trans_tmp_query.append(" /* generated by server */");
          error |= thd->binlog_query(THD::STMT_QUERY_TYPE,
                                     built_non_trans_tmp_query.ptr(),
                                     built_non_trans_tmp_query.length(),
2558 2559 2560
                                     FALSE, FALSE,
                                     is_drop_tmp_if_exists_added,
                                     0);
2561
      }
2562
      if (trans_tmp_table_deleted)
2563
      {
2564 2565 2566 2567 2568 2569
          /* Chop of the last comma */
          built_trans_tmp_query.chop();
          built_trans_tmp_query.append(" /* generated by server */");
          error |= thd->binlog_query(THD::STMT_QUERY_TYPE,
                                     built_trans_tmp_query.ptr(),
                                     built_trans_tmp_query.length(),
2570 2571 2572
                                     TRUE, FALSE,
                                     is_drop_tmp_if_exists_added,
                                     0);
2573 2574 2575 2576 2577
      }
      if (non_tmp_table_deleted)
      {
          /* Chop of the last comma */
          built_query.chop();
2578
          built_query.append(" /* generated by server */");
2579 2580
          int error_code = non_tmp_error ?  thd->get_stmt_da()->sql_errno()
                                         : 0;
2581 2582 2583 2584 2585
          error |= thd->binlog_query(THD::STMT_QUERY_TYPE,
                                     built_query.ptr(),
                                     built_query.length(),
                                     TRUE, FALSE, FALSE,
                                     error_code);
2586
      }
2587
    }
unknown's avatar
unknown committed
2588
  }
2589

2590 2591 2592 2593
  if (!drop_temporary)
  {
    /*
      Under LOCK TABLES we should release meta-data locks on the tables
2594
      which were dropped.
Konstantin Osipov's avatar
Konstantin Osipov committed
2595 2596 2597 2598

      Leave LOCK TABLES mode if we managed to drop all tables which were
      locked. Additional check for 'non_temp_tables_count' is to avoid
      leaving LOCK TABLES mode if we have dropped only temporary tables.
2599
    */
2600
    if (thd->locked_tables_mode)
Konstantin Osipov's avatar
Konstantin Osipov committed
2601
    {
2602 2603
      if (thd->lock && thd->lock->table_count == 0 &&
          non_temp_tables_count > 0 && !dont_free_locks)
Konstantin Osipov's avatar
Konstantin Osipov committed
2604
      {
2605 2606 2607 2608 2609
        thd->locked_tables_list.unlock_locked_tables(thd);
        goto end;
      }
      for (table= tables; table; table= table->next_local)
      {
2610 2611
        /* Drop locks for all successfully dropped tables. */
        if (table->table == NULL && table->mdl_request.ticket)
2612 2613 2614 2615 2616 2617 2618 2619
        {
          /*
            Under LOCK TABLES we may have several instances of table open
            and locked and therefore have to remove several metadata lock
            requests associated with them.
          */
          thd->mdl_context.release_all_locks_for_name(table->mdl_request.ticket);
        }
Konstantin Osipov's avatar
Konstantin Osipov committed
2620 2621
      }
    }
2622 2623 2624 2625
    /*
      Rely on the caller to implicitly commit the transaction
      and release metadata locks.
    */
2626 2627
  }

Konstantin Osipov's avatar
Konstantin Osipov committed
2628
end:
2629
  DBUG_RETURN(error);
unknown's avatar
unknown committed
2630 2631
}

2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652
/**
  Log the drop of a table.

  @param thd	           Thread handler
  @param db_name           Database name
  @param table_name        Table name
  @param temporary_table   1 if table was a temporary table

  This code is only used in the case of failed CREATE OR REPLACE TABLE
  when the original table was dropped but we could not create the new one.
*/

bool log_drop_table(THD *thd, const char *db_name, size_t db_name_length,
                    const char *table_name, size_t table_name_length,
                    bool temporary_table)
{
  char buff[NAME_LEN*2 + 80];
  String query(buff, sizeof(buff), system_charset_info);
  bool error;
  DBUG_ENTER("log_drop_table");

2653 2654 2655
  if (!mysql_bin_log.is_open())
    DBUG_RETURN(0);
  
2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671
  query.length(0);
  query.append(STRING_WITH_LEN("DROP "));
  if (temporary_table)
    query.append(STRING_WITH_LEN("TEMPORARY "));
  query.append(STRING_WITH_LEN("TABLE IF EXISTS "));
  append_identifier(thd, &query, db_name, db_name_length);
  query.append(".");
  append_identifier(thd, &query, table_name, table_name_length);
  query.append(STRING_WITH_LEN("/* Generated to handle "
                               "failed CREATE OR REPLACE */"));
  error= thd->binlog_query(THD::STMT_QUERY_TYPE,
                           query.ptr(), query.length(),
                           FALSE, FALSE, temporary_table, 0);
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
2672

2673
/**
2674 2675
  Quickly remove a table.

2676 2677 2678 2679 2680 2681
  @param thd         Thread context.
  @param base        The handlerton handle.
  @param db          The database name.
  @param table_name  The table name.
  @param flags       Flags for build_table_filename() as well as describing
                     if handler files / .FRM should be deleted as well.
2682

2683
  @return False in case of success, True otherwise.
2684 2685
*/

2686
bool quick_rm_table(THD *thd, handlerton *base, const char *db,
2687
                    const char *table_name, uint flags, const char *table_path)
unknown's avatar
unknown committed
2688
{
2689
  char path[FN_REFLEN + 1];
unknown's avatar
unknown committed
2690 2691 2692
  bool error= 0;
  DBUG_ENTER("quick_rm_table");

2693 2694 2695
  uint path_length= table_path ?
    (strxnmov(path, sizeof(path) - 1, table_path, reg_ext, NullS) - path) :
    build_table_filename(path, sizeof(path)-1, db, table_name, reg_ext, flags);
Marc Alff's avatar
Marc Alff committed
2696
  if (mysql_file_delete(key_file_frm, path, MYF(0)))
unknown's avatar
unknown committed
2697
    error= 1; /* purecov: inspected */
2698
  path[path_length - reg_ext_length]= '\0'; // Remove reg_ext
2699 2700 2701 2702 2703
  if (flags & NO_HA_TABLE)
  {
    handler *file= get_new_handler((TABLE_SHARE*) 0, thd->mem_root, base);
    if (!file)
      DBUG_RETURN(true);
Sergei Golubchik's avatar
Sergei Golubchik committed
2704
    (void) file->ha_create_partitioning_metadata(path, NULL, CHF_DELETE_FLAG);
2705 2706 2707
    delete file;
  }
  if (!(flags & (FRM_ONLY|NO_HA_TABLE)))
2708
    error|= ha_delete_table(current_thd, base, path, db, table_name, 0);
2709 2710

  if (likely(error == 0))
Sergei Golubchik's avatar
Sergei Golubchik committed
2711
  {
2712 2713
    PSI_CALL_drop_table_share(flags & FN_IS_TMP, db, strlen(db),
                              table_name, strlen(table_name));
Sergei Golubchik's avatar
Sergei Golubchik committed
2714
  }
2715

2716
  DBUG_RETURN(error);
unknown's avatar
unknown committed
2717 2718
}

2719

2720 2721 2722
/*
  Sort keys in the following order:
  - PRIMARY KEY
2723 2724
  - UNIQUE keys where all column are NOT NULL
  - UNIQUE keys that don't contain partial segments
2725 2726 2727 2728 2729 2730 2731 2732 2733 2734
  - 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)
{
2735 2736 2737
  ulong a_flags= a->flags, b_flags= b->flags;
  
  if (a_flags & HA_NOSAME)
2738
  {
2739
    if (!(b_flags & HA_NOSAME))
2740
      return -1;
2741
    if ((a_flags ^ b_flags) & HA_NULL_PART_KEY)
2742 2743
    {
      /* Sort NOT NULL keys before other keys */
2744
      return (a_flags & HA_NULL_PART_KEY) ? 1 : -1;
2745 2746 2747 2748 2749
    }
    if (a->name == primary_key_name)
      return -1;
    if (b->name == primary_key_name)
      return 1;
2750 2751 2752
    /* 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;
2753
  }
2754
  else if (b_flags & HA_NOSAME)
2755 2756
    return 1;					// Prefer b

2757
  if ((a_flags ^ b_flags) & HA_FULLTEXT)
2758
  {
2759
    return (a_flags & HA_FULLTEXT) ? 1 : -1;
2760
  }
unknown's avatar
unknown committed
2761
  /*
2762
    Prefer original key order.	usable_key_parts contains here
unknown's avatar
unknown committed
2763 2764 2765 2766 2767
    the original key position.
  */
  return ((a->usable_key_parts < b->usable_key_parts) ? -1 :
	  (a->usable_key_parts > b->usable_key_parts) ? 1 :
	  0);
2768 2769
}

2770 2771
/*
  Check TYPELIB (set or enum) for duplicates
2772

2773 2774 2775
  SYNOPSIS
    check_duplicates_in_interval()
    set_or_name   "SET" or "ENUM" string for warning message
2776 2777
    name	  name of the checked column
    typelib	  list of values for the column
2778
    dup_val_count  returns count of duplicate elements
2779 2780

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

  RETURN VALUES
2785 2786
    0             ok
    1             Error
2787 2788
*/

2789
bool check_duplicates_in_interval(const char *set_or_name,
2790
                                  const char *name, TYPELIB *typelib,
2791
                                  CHARSET_INFO *cs, unsigned int *dup_val_count)
2792
{
2793
  TYPELIB tmp= *typelib;
2794
  const char **cur_value= typelib->type_names;
2795
  unsigned int *cur_length= typelib->type_lengths;
2796
  *dup_val_count= 0;  
2797 2798
  
  for ( ; tmp.count > 1; cur_value++, cur_length++)
2799
  {
2800 2801 2802 2803
    tmp.type_names++;
    tmp.type_lengths++;
    tmp.count--;
    if (find_type2(&tmp, (const char*)*cur_value, *cur_length, cs))
2804
    {
2805 2806
      THD *thd= current_thd;
      ErrConvString err(*cur_value, *cur_length, cs);
2807
      if (current_thd->is_strict_mode())
2808 2809
      {
        my_error(ER_DUPLICATED_VALUE_IN_TYPE, MYF(0),
2810
                 name, err.ptr(), set_or_name);
2811 2812
        return 1;
      }
2813
      push_warning_printf(thd,Sql_condition::WARN_LEVEL_NOTE,
2814
                          ER_DUPLICATED_VALUE_IN_TYPE,
2815
                          ER_THD(thd, ER_DUPLICATED_VALUE_IN_TYPE),
2816
                          name, err.ptr(), set_or_name);
2817
      (*dup_val_count)++;
2818 2819
    }
  }
2820
  return 0;
2821
}
2822

2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850

/*
  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++)
  {
2851
    size_t length= cs->cset->numchars(cs, *pos, *pos + *len);
2852 2853 2854 2855 2856 2857
    *tot_length+= length;
    set_if_bigger(*max_length, (uint32)length);
  }
}


unknown's avatar
unknown committed
2858 2859 2860 2861 2862 2863 2864 2865 2866 2867
/*
  Prepare a create_table instance for packing

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

  DESCRIPTION
unknown's avatar
unknown committed
2868
    This function prepares a Create_field instance.
unknown's avatar
unknown committed
2869 2870 2871 2872 2873 2874 2875
    Fields such as pack_flag are valid after this call.

  RETURN VALUES
   0	ok
   1	Error
*/

Alexander Barkov's avatar
Alexander Barkov committed
2876
int prepare_create_field(Column_definition *sql_field,
unknown's avatar
unknown committed
2877
			 uint *blob_columns, 
2878
			 longlong table_flags)
unknown's avatar
unknown committed
2879
{
2880 2881
  uint dup_val_count;
  uint decimals= sql_field->decimals;
2882
  DBUG_ENTER("prepare_create_field");
unknown's avatar
unknown committed
2883 2884

  /*
2885
    This code came from mysql_prepare_create_table.
unknown's avatar
unknown committed
2886 2887 2888 2889 2890
    Indent preserved to make patching easier
  */
  DBUG_ASSERT(sql_field->charset);

  switch (sql_field->sql_type) {
2891 2892 2893 2894
  case MYSQL_TYPE_BLOB:
  case MYSQL_TYPE_MEDIUM_BLOB:
  case MYSQL_TYPE_TINY_BLOB:
  case MYSQL_TYPE_LONG_BLOB:
unknown's avatar
unknown committed
2895 2896 2897 2898 2899 2900
    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
2901
    (*blob_columns)++;
unknown's avatar
unknown committed
2902
    break;
2903
  case MYSQL_TYPE_GEOMETRY:
unknown's avatar
unknown committed
2904
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
2905 2906
    if (!(table_flags & HA_CAN_GEOMETRY))
    {
2907
      my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), "GEOMETRY");
unknown's avatar
unknown committed
2908
      DBUG_RETURN(1);
unknown's avatar
unknown committed
2909 2910 2911 2912 2913 2914 2915
    }
    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
2916
    (*blob_columns)++;
unknown's avatar
unknown committed
2917 2918
    break;
#else
2919
    my_error(ER_FEATURE_DISABLED, MYF(0),
unknown's avatar
unknown committed
2920 2921
                    sym_group_geom.name, sym_group_geom.needed_define);
    DBUG_RETURN(1);
unknown's avatar
unknown committed
2922
#endif /*HAVE_SPATIAL*/
unknown's avatar
unknown committed
2923
  case MYSQL_TYPE_VARCHAR:
unknown's avatar
unknown committed
2924
#ifndef QQ_ALL_HANDLERS_SUPPORT_VARCHAR
unknown's avatar
unknown committed
2925 2926 2927 2928 2929 2930 2931 2932
    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)
unknown's avatar
unknown committed
2933
      {
2934
        my_error(ER_TOO_BIG_FIELDLENGTH, MYF(0), sql_field->field_name,
2935
                        static_cast<ulong>(MAX_FIELD_CHARLENGTH));
unknown's avatar
unknown committed
2936 2937
        DBUG_RETURN(1);
      }
unknown's avatar
unknown committed
2938 2939 2940
    }
#endif
    /* fall through */
2941
  case MYSQL_TYPE_STRING:
unknown's avatar
unknown committed
2942 2943 2944 2945
    sql_field->pack_flag=0;
    if (sql_field->charset->state & MY_CS_BINSORT)
      sql_field->pack_flag|=FIELDFLAG_BINARY;
    break;
2946
  case MYSQL_TYPE_ENUM:
unknown's avatar
unknown committed
2947 2948 2949 2950
    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;
2951 2952 2953 2954
    if (check_duplicates_in_interval("ENUM",sql_field->field_name,
                                     sql_field->interval,
                                     sql_field->charset, &dup_val_count))
      DBUG_RETURN(1);
unknown's avatar
unknown committed
2955
    break;
2956
  case MYSQL_TYPE_SET:
unknown's avatar
unknown committed
2957 2958 2959 2960
    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;
2961 2962 2963 2964
    if (check_duplicates_in_interval("SET",sql_field->field_name,
                                     sql_field->interval,
                                     sql_field->charset, &dup_val_count))
      DBUG_RETURN(1);
2965 2966 2967 2968 2969 2970
    /* 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);
    }
unknown's avatar
unknown committed
2971
    break;
2972 2973 2974 2975
  case MYSQL_TYPE_DATE:			// Rest of string types
  case MYSQL_TYPE_NEWDATE:
  case MYSQL_TYPE_TIME:
  case MYSQL_TYPE_DATETIME:
2976 2977
  case MYSQL_TYPE_TIME2:
  case MYSQL_TYPE_DATETIME2:
2978
  case MYSQL_TYPE_NULL:
unknown's avatar
unknown committed
2979 2980
    sql_field->pack_flag=f_settype((uint) sql_field->sql_type);
    break;
2981
  case MYSQL_TYPE_BIT:
unknown's avatar
unknown committed
2982
    /* 
2983 2984
      We have sql_field->pack_flag already set here, see
      mysql_prepare_create_table().
unknown's avatar
unknown committed
2985
    */
unknown's avatar
unknown committed
2986
    break;
2987
  case MYSQL_TYPE_NEWDECIMAL:
unknown's avatar
unknown committed
2988 2989 2990 2991 2992
    sql_field->pack_flag=(FIELDFLAG_NUMBER |
                          (sql_field->flags & UNSIGNED_FLAG ? 0 :
                           FIELDFLAG_DECIMAL) |
                          (sql_field->flags & ZEROFILL_FLAG ?
                           FIELDFLAG_ZEROFILL : 0) |
2993
                          (decimals << FIELDFLAG_DEC_SHIFT));
unknown's avatar
unknown committed
2994
    break;
2995 2996 2997 2998 2999 3000 3001 3002 3003 3004
  case MYSQL_TYPE_FLOAT:
  case MYSQL_TYPE_DOUBLE:
    /*
      User specified FLOAT() or DOUBLE() without precision. Change to
      FLOATING_POINT_DECIMALS to keep things compatible with earlier MariaDB
      versions.
    */
    if (decimals >= FLOATING_POINT_DECIMALS)
      decimals= FLOATING_POINT_DECIMALS;
    /* fall-trough */
3005
  case MYSQL_TYPE_TIMESTAMP:
3006
  case MYSQL_TYPE_TIMESTAMP2:
unknown's avatar
unknown committed
3007 3008 3009 3010 3011 3012 3013 3014
    /* 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) |
3015
                          (decimals << FIELDFLAG_DEC_SHIFT));
unknown's avatar
unknown committed
3016 3017
    break;
  }
3018 3019
  if (!(sql_field->flags & NOT_NULL_FLAG) ||
      (sql_field->vcol_info))  /* Make virtual columns allow NULL values */
unknown's avatar
unknown committed
3020 3021 3022
    sql_field->pack_flag|= FIELDFLAG_MAYBE_NULL;
  if (sql_field->flags & NO_DEFAULT_VALUE_FLAG)
    sql_field->pack_flag|= FIELDFLAG_NO_DEFAULT;
unknown's avatar
unknown committed
3023 3024 3025
  DBUG_RETURN(0);
}

3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058

/*
  Get character set from field object generated by parser using
  default values when not set.

  SYNOPSIS
    get_sql_field_charset()
    sql_field                 The sql_field object
    create_info               Info generated by parser

  RETURN VALUES
    cs                        Character set
*/

CHARSET_INFO* get_sql_field_charset(Create_field *sql_field,
                                    HA_CREATE_INFO *create_info)
{
  CHARSET_INFO *cs= sql_field->charset;

  if (!cs)
    cs= create_info->default_table_charset;
  /*
    table_charset is set only in ALTER TABLE t1 CONVERT TO CHARACTER SET csname
    if we want change character set 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.
  */
  if (create_info->table_charset && cs != &my_charset_bin)
    cs= create_info->table_charset;
  return cs;
}


3059 3060 3061 3062
/**
   Modifies the first column definition whose SQL type is TIMESTAMP
   by adding the features DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP.

3063 3064 3065
   If the first TIMESTAMP column appears to be nullable, or to have an
   explicit default, or to be a virtual column, then no promition is done.

3066 3067
   @param column_definitions The list of column definitions, in the physical
                             order in which they appear in the table.
Michael Widenius's avatar
Michael Widenius committed
3068 3069
*/

3070 3071
void promote_first_timestamp_column(List<Create_field> *column_definitions)
{
Michael Widenius's avatar
Michael Widenius committed
3072
  List_iterator_fast<Create_field> it(*column_definitions);
3073 3074 3075 3076
  Create_field *column_definition;

  while ((column_definition= it++) != NULL)
  {
Michael Widenius's avatar
Michael Widenius committed
3077
    if (is_timestamp_type(column_definition->sql_type) ||    // TIMESTAMP
3078 3079 3080
        column_definition->unireg_check == Field::TIMESTAMP_OLD_FIELD) // Legacy
    {
      if ((column_definition->flags & NOT_NULL_FLAG) != 0 && // NOT NULL,
3081
          column_definition->default_value == NULL &&   // no constant default,
3082 3083
          column_definition->unireg_check == Field::NONE && // no function default
          column_definition->vcol_info == NULL)
3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097
      {
        DBUG_PRINT("info", ("First TIMESTAMP column '%s' was promoted to "
                            "DEFAULT CURRENT_TIMESTAMP ON UPDATE "
                            "CURRENT_TIMESTAMP",
                            column_definition->field_name
                            ));
        column_definition->unireg_check= Field::TIMESTAMP_DNUN_FIELD;
      }
      return;
    }
  }
}


3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119
/**
  Check if there is a duplicate key. Report a warning for every duplicate key.

  @param thd              Thread context.
  @param key              Key to be checked.
  @param key_info         Key meta-data info.
  @param key_list         List of existing keys.
*/
static void check_duplicate_key(THD *thd,
                                Key *key, KEY *key_info,
                                List<Key> *key_list)
{
  /*
    We only check for duplicate indexes if it is requested and the
    key is not auto-generated.

    Check is requested if the key was explicitly created or altered
    by the user (unless it's a foreign key).
  */
  if (!key->key_create_info.check_for_duplicate_indexes || key->generated)
    return;

Michael Widenius's avatar
Michael Widenius committed
3120 3121
  List_iterator_fast<Key> key_list_iterator(*key_list);
  List_iterator_fast<Key_part_spec> key_column_iterator(key->columns);
3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144
  Key *k;

  while ((k= key_list_iterator++))
  {
    // Looking for a similar key...

    if (k == key)
      break;

    if (k->generated ||
        (key->type != k->type) ||
        (key->key_create_info.algorithm != k->key_create_info.algorithm) ||
        (key->columns.elements != k->columns.elements))
    {
      // Keys are different.
      continue;
    }

    /*
      Keys 'key' and 'k' might be identical.
      Check that the keys have identical columns in the same order.
    */

Michael Widenius's avatar
Michael Widenius committed
3145
    List_iterator_fast<Key_part_spec> k_column_iterator(k->columns);
3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168

    bool all_columns_are_identical= true;

    key_column_iterator.rewind();

    for (uint i= 0; i < key->columns.elements; ++i)
    {
      Key_part_spec *c1= key_column_iterator++;
      Key_part_spec *c2= k_column_iterator++;

      DBUG_ASSERT(c1 && c2);

      if (my_strcasecmp(system_charset_info,
                        c1->field_name.str, c2->field_name.str) ||
          (c1->length != c2->length))
      {
        all_columns_are_identical= false;
        break;
      }
    }

    // Report a warning if we have two identical keys.

3169
    DBUG_ASSERT(thd->lex->query_tables->alias);
3170 3171 3172
    if (all_columns_are_identical)
    {
      push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
3173
                          ER_DUP_INDEX, ER_THD(thd, ER_DUP_INDEX),
3174 3175
                          key_info->name,
                          thd->lex->query_tables->db,
3176
                          thd->lex->query_tables->alias);
3177 3178 3179 3180 3181 3182
      break;
    }
  }
}


unknown's avatar
unknown committed
3183
/*
3184
  Preparation for table creation
unknown's avatar
unknown committed
3185 3186

  SYNOPSIS
3187
    mysql_prepare_create_table()
3188 3189
      thd                       Thread object.
      create_info               Create information (like MAX_ROWS).
3190
      alter_info                List of columns and indexes to create
3191 3192 3193 3194
      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.
3195
      create_table_mode         C_ORDINARY_CREATE, C_ALTER_TABLE,
Sergei Golubchik's avatar
Sergei Golubchik committed
3196
                                C_CREATE_SELECT, C_ASSISTED_DISCOVERY
unknown's avatar
unknown committed
3197

3198
  DESCRIPTION
3199
    Prepares the table and key structures for table creation.
unknown's avatar
unknown committed
3200

3201
  NOTES
3202
    sets create_info->varchar if the table has a varchar
3203

unknown's avatar
unknown committed
3204
  RETURN VALUES
3205 3206
    FALSE    OK
    TRUE     error
unknown's avatar
unknown committed
3207
*/
unknown's avatar
unknown committed
3208

unknown's avatar
unknown committed
3209
static int
3210
mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
3211
                           Alter_info *alter_info, uint *db_options,
3212
                           handler *file, KEY **key_info_buffer,
3213
                           uint *key_count, int create_table_mode)
unknown's avatar
unknown committed
3214
{
3215
  const char	*key_name;
unknown's avatar
unknown committed
3216
  Create_field	*sql_field,*dup_field;
unknown's avatar
unknown committed
3217
  uint		field,null_fields,blob_columns,max_key_length;
unknown's avatar
unknown committed
3218
  ulong		record_offset= 0;
3219
  KEY		*key_info;
unknown's avatar
unknown committed
3220
  KEY_PART_INFO *key_part_info;
3221 3222
  int		field_no,dup_no;
  int		select_field_pos,auto_increment=0;
Michael Widenius's avatar
Michael Widenius committed
3223
  List_iterator_fast<Create_field> it(alter_info->create_list);
unknown's avatar
unknown committed
3224
  List_iterator<Create_field> it2(alter_info->create_list);
unknown's avatar
unknown committed
3225
  uint total_uneven_bit_length= 0;
3226 3227
  int select_field_count= C_CREATE_SELECT(create_table_mode);
  bool tmp_table= create_table_mode == C_ALTER_TABLE;
3228
  DBUG_ENTER("mysql_prepare_create_table");
unknown's avatar
unknown committed
3229

3230
  select_field_pos= alter_info->create_list.elements - select_field_count;
unknown's avatar
unknown committed
3231
  null_fields=blob_columns=0;
3232
  create_info->varchar= 0;
unknown's avatar
unknown committed
3233
  max_key_length= file->max_key_length();
3234

3235
  for (field_no=0; (sql_field=it++) ; field_no++)
unknown's avatar
unknown committed
3236
  {
3237 3238
    CHARSET_INFO *save_cs;

3239 3240 3241 3242 3243 3244
    /*
      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;
3245
    /* Set field charset. */
3246
    save_cs= sql_field->charset= get_sql_field_charset(sql_field, create_info);
3247
    if ((sql_field->flags & BINCMP_FLAG) &&
3248
	!(sql_field->charset= find_bin_collation(sql_field->charset)))
3249
      DBUG_RETURN(TRUE);
3250

3251 3252
    if (sql_field->sql_type == MYSQL_TYPE_SET ||
        sql_field->sql_type == MYSQL_TYPE_ENUM)
3253 3254 3255
    {
      uint32 dummy;
      CHARSET_INFO *cs= sql_field->charset;
3256
      TYPELIB *interval= sql_field->interval;
3257 3258 3259 3260 3261 3262

      /*
        Create typelib from interval_list, and if necessary
        convert strings from client character set to the
        column character set.
      */
3263
      if (!interval)
3264
      {
3265
        /*
3266 3267 3268
          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.
3269
        */
3270
        interval= sql_field->interval= typelib(thd->mem_root,
3271
                                               sql_field->interval_list);
3272
        List_iterator<String> int_it(sql_field->interval_list);
3273
        String conv, *tmp;
3274 3275
        char comma_buf[5]; /* 5 bytes for 'filename' charset */
        DBUG_ASSERT(sizeof(comma_buf) >= cs->mbmaxlen);
3276
        int comma_length= cs->cset->wc_mb(cs, ',', (uchar*) comma_buf,
3277
                                          (uchar*) comma_buf +
3278 3279
                                          sizeof(comma_buf));
        DBUG_ASSERT(comma_length > 0);
3280
        for (uint i= 0; (tmp= int_it++); i++)
3281
        {
3282
          size_t lengthsp;
3283 3284 3285 3286 3287
          if (String::needs_conversion(tmp->length(), tmp->charset(),
                                       cs, &dummy))
          {
            uint cnv_errs;
            conv.copy(tmp->ptr(), tmp->length(), tmp->charset(), cs, &cnv_errs);
3288
            interval->type_names[i]= strmake_root(thd->mem_root, conv.ptr(),
unknown's avatar
unknown committed
3289
                                                  conv.length());
3290 3291
            interval->type_lengths[i]= conv.length();
          }
3292

3293
          // Strip trailing spaces.
unknown's avatar
unknown committed
3294 3295
          lengthsp= cs->cset->lengthsp(cs, interval->type_names[i],
                                       interval->type_lengths[i]);
3296 3297
          interval->type_lengths[i]= lengthsp;
          ((uchar *)interval->type_names[i])[lengthsp]= '\0';
3298
          if (sql_field->sql_type == MYSQL_TYPE_SET)
3299 3300 3301 3302 3303
          {
            if (cs->coll->instr(cs, interval->type_names[i], 
                                interval->type_lengths[i], 
                                comma_buf, comma_length, NULL, 0))
            {
3304 3305
              ErrConvString err(tmp->ptr(), tmp->length(), cs);
              my_error(ER_ILLEGAL_VALUE_FOR_TYPE, MYF(0), "set", err.ptr());
3306
              DBUG_RETURN(TRUE);
3307 3308
            }
          }
3309
        }
3310
        sql_field->interval_list.empty(); // Don't need interval_list anymore
3311 3312
      }

3313
      if (sql_field->sql_type == MYSQL_TYPE_SET)
3314
      {
3315 3316 3317
        uint32 field_length;
        calculate_interval_lengths(cs, interval, &dummy, &field_length);
        sql_field->length= field_length + (interval->count - 1);
3318
      }
3319
      else  /* MYSQL_TYPE_ENUM */
3320
      {
3321
        uint32 field_length;
3322
        DBUG_ASSERT(sql_field->sql_type == MYSQL_TYPE_ENUM);
3323 3324
        calculate_interval_lengths(cs, interval, &field_length, &dummy);
        sql_field->length= field_length;
3325 3326 3327 3328
      }
      set_if_smaller(sql_field->length, MAX_FIELD_WIDTH-1);
    }

3329
    if (sql_field->sql_type == MYSQL_TYPE_BIT)
3330
    { 
unknown's avatar
unknown committed
3331
      sql_field->pack_flag= FIELDFLAG_NUMBER;
3332
      if (file->ha_table_flags() & HA_CAN_BIT_FIELD)
3333 3334 3335 3336 3337
        total_uneven_bit_length+= sql_field->length & 7;
      else
        sql_field->pack_flag|= FIELDFLAG_TREAT_BIT_AS_CHAR;
    }

3338
    sql_field->create_length_to_internal_length();
unknown's avatar
unknown committed
3339
    if (prepare_blob_field(thd, sql_field))
3340
      DBUG_RETURN(TRUE);
3341

3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408
    /*
      Convert the default value from client character
      set into the column character set if necessary.
      We can only do this for constants as we have not yet run fix_fields.
    */
    if (sql_field->default_value &&
        sql_field->default_value->expr_item->basic_const_item() &&
        save_cs != sql_field->default_value->expr_item->collation.collation &&
        (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_TINY_BLOB ||
         sql_field->sql_type == MYSQL_TYPE_MEDIUM_BLOB ||
         sql_field->sql_type == MYSQL_TYPE_LONG_BLOB ||
         sql_field->sql_type == MYSQL_TYPE_BLOB ||
         sql_field->sql_type == MYSQL_TYPE_ENUM))
    {
      Item *item;
      if (!(item= sql_field->default_value->expr_item->
            safe_charset_converter(thd, save_cs)))
      {
        /* Could not convert */
        my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
        DBUG_RETURN(TRUE);
      }
      /* Fix for prepare statement */
      thd->change_item_tree(&sql_field->default_value->expr_item, item);
    }

    if (sql_field->default_value &&
        sql_field->default_value->expr_item->basic_const_item() &&
        (sql_field->sql_type == MYSQL_TYPE_SET ||
         sql_field->sql_type == MYSQL_TYPE_ENUM))
    {
      StringBuffer<MAX_FIELD_WIDTH> str;
      String *def= sql_field->default_value->expr_item->val_str(&str);
      bool not_found;
      if (def == NULL) /* SQL "NULL" maps to NULL */
      {
        not_found= sql_field->flags & NOT_NULL_FLAG;
      }
      else
      {
        not_found= false;
        if (sql_field->sql_type == MYSQL_TYPE_SET)
        {
          char *not_used;
          uint not_used2;
          find_set(sql_field->interval, def->ptr(), def->length(),
                   sql_field->charset, &not_used, &not_used2, &not_found);
        }
        else /* MYSQL_TYPE_ENUM */
        {
          def->length(sql_field->charset->cset->lengthsp(sql_field->charset,
                                                  def->ptr(), def->length()));
          not_found= !find_type2(sql_field->interval, def->ptr(),
                                 def->length(), sql_field->charset);
        }
      }

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

unknown's avatar
unknown committed
3409 3410
    if (!(sql_field->flags & NOT_NULL_FLAG))
      null_fields++;
unknown's avatar
unknown committed
3411

unknown's avatar
unknown committed
3412 3413
    if (check_column_name(sql_field->field_name))
    {
3414
      my_error(ER_WRONG_COLUMN_NAME, MYF(0), sql_field->field_name);
3415
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3416
    }
unknown's avatar
unknown committed
3417

3418 3419
    /* Check if we have used the same field name before */
    for (dup_no=0; (dup_field=it2++) != sql_field; dup_no++)
unknown's avatar
unknown committed
3420
    {
3421
      if (my_strcasecmp(system_charset_info,
3422 3423
			sql_field->field_name,
			dup_field->field_name) == 0)
unknown's avatar
unknown committed
3424
      {
3425 3426 3427 3428
	/*
	  If this was a CREATE ... SELECT statement, accept a field
	  redefinition if we are changing a field in the SELECT part
	*/
3429 3430
	if (field_no < select_field_pos || dup_no >= select_field_pos)
	{
3431
	  my_error(ER_DUP_FIELDNAME, MYF(0), sql_field->field_name);
3432
	  DBUG_RETURN(TRUE);
3433 3434 3435
	}
	else
	{
3436
	  /* Field redefined */
3437 3438 3439 3440 3441 3442 3443 3444 3445

          /*
            If we are replacing a BIT field, revert the increment
            of total_uneven_bit_length that was done above.
          */
          if (sql_field->sql_type == MYSQL_TYPE_BIT &&
              file->ha_table_flags() & HA_CAN_BIT_FIELD)
            total_uneven_bit_length-= sql_field->length & 7;

3446
	  sql_field->default_value=	dup_field->default_value;
3447
	  sql_field->sql_type=		dup_field->sql_type;
3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461

          /*
            If we are replacing a field with a BIT field, we need
            to initialize pack_flag. Note that we do not need to
            increment total_uneven_bit_length here as this dup_field
            has already been processed.
          */
          if (sql_field->sql_type == MYSQL_TYPE_BIT)
          {
            sql_field->pack_flag= FIELDFLAG_NUMBER;
            if (!(file->ha_table_flags() & HA_CAN_BIT_FIELD))
              sql_field->pack_flag|= FIELDFLAG_TREAT_BIT_AS_CHAR;
          }

3462 3463 3464
	  sql_field->charset=		(dup_field->charset ?
					 dup_field->charset :
					 create_info->default_table_charset);
3465
	  sql_field->length=		dup_field->char_length;
3466
          sql_field->pack_length=	dup_field->pack_length;
3467
          sql_field->key_length=	dup_field->key_length;
3468
	  sql_field->decimals=		dup_field->decimals;
3469
	  sql_field->create_length_to_internal_length();
3470
	  sql_field->unireg_check=	dup_field->unireg_check;
3471 3472 3473 3474 3475 3476 3477 3478
          /* 
            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;
unknown's avatar
unknown committed
3479
          sql_field->interval=          dup_field->interval;
3480
          sql_field->vcol_info=         dup_field->vcol_info;
3481 3482 3483
	  it2.remove();			// Remove first (create) definition
	  select_field_pos--;
	  break;
3484
	}
unknown's avatar
unknown committed
3485 3486
      }
    }
3487 3488
    /* 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
3489
	(sql_field->sql_type == MYSQL_TYPE_VARCHAR &&
3490
         create_info->row_type != ROW_TYPE_FIXED))
3491
      (*db_options)|= HA_OPTION_PACK_RECORD;
unknown's avatar
unknown committed
3492 3493
    it2.rewind();
  }
3494 3495 3496

  /* record_offset will be increased with 'length-of-null-bits' later */
  record_offset= 0;
unknown's avatar
unknown committed
3497
  null_fields+= total_uneven_bit_length;
unknown's avatar
unknown committed
3498 3499 3500 3501

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

unknown's avatar
unknown committed
3504
    if (prepare_create_field(sql_field, &blob_columns, 
3505
			     file->ha_table_flags()))
3506
      DBUG_RETURN(TRUE);
3507
    if (sql_field->sql_type == MYSQL_TYPE_VARCHAR)
3508
      create_info->varchar= TRUE;
3509
    sql_field->offset= record_offset;
unknown's avatar
unknown committed
3510 3511
    if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
      auto_increment++;
3512 3513
    if (parse_option_list(thd, create_info->db_type, &sql_field->option_struct,
                          &sql_field->option_list,
3514 3515 3516
                          create_info->db_type->field_options, FALSE,
                          thd->mem_root))
      DBUG_RETURN(TRUE);
3517 3518 3519 3520 3521
    /*
      For now skip fields that are not physically stored in the database
      (virtual fields) and update their offset later 
      (see the next loop).
    */
3522
    if (sql_field->stored_in_db())
3523 3524 3525 3526 3527 3528
      record_offset+= sql_field->pack_length;
  }
  /* Update virtual fields' offset*/
  it.rewind();
  while ((sql_field=it++))
  {
3529
    if (!sql_field->stored_in_db())
3530 3531 3532 3533
    {
      sql_field->offset= record_offset;
      record_offset+= sql_field->pack_length;
    }
unknown's avatar
unknown committed
3534 3535 3536
  }
  if (auto_increment > 1)
  {
3537
    my_message(ER_WRONG_AUTO_KEY, ER_THD(thd, ER_WRONG_AUTO_KEY), MYF(0));
3538
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3539 3540
  }
  if (auto_increment &&
3541
      (file->ha_table_flags() & HA_NO_AUTO_INCREMENT))
unknown's avatar
unknown committed
3542
  {
3543
    my_error(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT, MYF(0), file->table_type());
3544
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3545 3546
  }

3547
  if (blob_columns && (file->ha_table_flags() & HA_NO_BLOBS))
unknown's avatar
unknown committed
3548
  {
3549
    my_error(ER_TABLE_CANT_HANDLE_BLOB, MYF(0), file->table_type());
3550
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3551 3552
  }

3553 3554 3555 3556 3557 3558 3559
  /*
   CREATE TABLE[with auto_increment column] SELECT is unsafe as the rows
   inserted in the created table depends on the order of the rows fetched
   from the select tables. This order may differ on master and slave. We
   therefore mark it as unsafe.
  */
  if (select_field_count > 0 && auto_increment)
Michael Widenius's avatar
Michael Widenius committed
3560
    thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_CREATE_SELECT_AUTOINC);
3561

unknown's avatar
unknown committed
3562
  /* Create keys */
3563

3564 3565
  List_iterator<Key> key_iterator(alter_info->key_list);
  List_iterator<Key> key_iterator2(alter_info->key_list);
3566
  uint key_parts=0, fk_key_count=0;
3567
  bool primary_key=0,unique_key=0;
3568
  Key *key, *key2;
unknown's avatar
unknown committed
3569
  uint tmp, key_number;
3570 3571
  /* special marker for keys to be ignored */
  static char ignore_key[1];
3572

3573
  /* Calculate number of key segements */
3574
  *key_count= 0;
3575

unknown's avatar
unknown committed
3576 3577
  while ((key=key_iterator++))
  {
3578
    DBUG_PRINT("info", ("key name: '%s'  type: %d", key->name.str ? key->name.str :
3579
                        "(none)" , key->type));
3580 3581 3582
    if (key->type == Key::FOREIGN_KEY)
    {
      fk_key_count++;
3583 3584
      if (((Foreign_key *)key)->validate(alter_info->create_list))
        DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3585
      Foreign_key *fk_key= (Foreign_key*) key;
3586 3587 3588
      if (fk_key->ref_columns.elements &&
	  fk_key->ref_columns.elements != fk_key->columns.elements)
      {
3589
        my_error(ER_WRONG_FK_DEF, MYF(0),
3590 3591
                 (fk_key->name.str ? fk_key->name.str :
                                     "foreign key without name"),
3592
                 ER_THD(thd, ER_KEY_REF_DO_NOT_MATCH_TABLE_REF));
3593
	DBUG_RETURN(TRUE);
3594 3595 3596
      }
      continue;
    }
3597
    (*key_count)++;
unknown's avatar
unknown committed
3598
    tmp=file->max_key_parts();
unknown's avatar
unknown committed
3599 3600 3601
    if (key->columns.elements > tmp)
    {
      my_error(ER_TOO_MANY_KEY_PARTS,MYF(0),tmp);
3602
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3603
    }
3604
    if (check_string_char_length(&key->name, 0, NAME_CHAR_LEN,
3605
                                 system_charset_info, 1))
unknown's avatar
unknown committed
3606
    {
3607
      my_error(ER_TOO_LONG_IDENT, MYF(0), key->name.str);
3608
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3609
    }
3610
    key_iterator2.rewind ();
3611
    if (key->type != Key::FOREIGN_KEY)
3612
    {
3613
      while ((key2 = key_iterator2++) != key)
3614
      {
unknown's avatar
unknown committed
3615
	/*
3616 3617 3618
          foreign_key_prefix(key, key2) returns 0 if key or key2, or both, is
          'generated', and a generated key is a prefix of the other key.
          Then we do not need the generated shorter key.
unknown's avatar
unknown committed
3619
        */
3620
        if ((key2->type != Key::FOREIGN_KEY &&
3621
             key2->name.str != ignore_key &&
3622
             !foreign_key_prefix(key, key2)))
3623
        {
3624
          /* TODO: issue warning message */
3625 3626 3627 3628
          /* mark that the generated key should be ignored */
          if (!key2->generated ||
              (key->generated && key->columns.elements <
               key2->columns.elements))
3629
            key->name.str= ignore_key;
3630 3631
          else
          {
3632
            key2->name.str= ignore_key;
3633 3634
            key_parts-= key2->columns.elements;
            (*key_count)--;
3635 3636 3637
          }
          break;
        }
3638 3639
      }
    }
3640
    if (key->name.str != ignore_key)
3641 3642 3643
      key_parts+=key->columns.elements;
    else
      (*key_count)--;
3644 3645
    if (key->name.str && !tmp_table && (key->type != Key::PRIMARY) &&
	!my_strcasecmp(system_charset_info, key->name.str, primary_key_name))
3646
    {
3647
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name.str);
3648
      DBUG_RETURN(TRUE);
3649
    }
3650
  }
unknown's avatar
unknown committed
3651
  tmp=file->max_keys();
3652
  if (*key_count > tmp)
3653 3654
  {
    my_error(ER_TOO_MANY_KEYS,MYF(0),tmp);
3655
    DBUG_RETURN(TRUE);
3656
  }
3657

3658 3659
  (*key_info_buffer)= key_info= (KEY*) thd->calloc(sizeof(KEY) * (*key_count));
  key_part_info=(KEY_PART_INFO*) thd->calloc(sizeof(KEY_PART_INFO)*key_parts);
3660
  if (!*key_info_buffer || ! key_part_info)
3661
    DBUG_RETURN(TRUE);				// Out of memory
3662

3663
  key_iterator.rewind();
unknown's avatar
unknown committed
3664
  key_number=0;
unknown's avatar
unknown committed
3665
  for (; (key=key_iterator++) ; key_number++)
3666 3667
  {
    uint key_length=0;
unknown's avatar
unknown committed
3668
    Key_part_spec *column;
3669

3670
    if (key->name.str == ignore_key)
3671 3672 3673 3674
    {
      /* ignore redundant keys */
      do
	key=key_iterator++;
3675
      while (key && key->name.str == ignore_key);
3676 3677 3678 3679
      if (!key)
	break;
    }

3680
    switch (key->type) {
unknown's avatar
unknown committed
3681
    case Key::MULTIPLE:
3682
	key_info->flags= 0;
3683
	break;
unknown's avatar
unknown committed
3684
    case Key::FULLTEXT:
3685
	key_info->flags= HA_FULLTEXT;
unknown's avatar
unknown committed
3686
	if ((key_info->parser_name= &key->key_create_info.parser_name)->str)
3687
          key_info->flags|= HA_USES_PARSER;
3688 3689
        else
          key_info->parser_name= 0;
3690
	break;
unknown's avatar
unknown committed
3691
    case Key::SPATIAL:
unknown's avatar
unknown committed
3692
#ifdef HAVE_SPATIAL
3693
	key_info->flags= HA_SPATIAL;
3694
	break;
unknown's avatar
unknown committed
3695
#else
3696 3697
	my_error(ER_FEATURE_DISABLED, MYF(0),
                 sym_group_geom.name, sym_group_geom.needed_define);
3698
	DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3699
#endif
3700 3701 3702 3703
    case Key::FOREIGN_KEY:
      key_number--;				// Skip this key
      continue;
    default:
3704 3705
      key_info->flags = HA_NOSAME;
      break;
unknown's avatar
unknown committed
3706
    }
3707 3708
    if (key->generated)
      key_info->flags|= HA_GENERATED_KEY;
unknown's avatar
unknown committed
3709

3710
    key_info->user_defined_key_parts=(uint8) key->columns.elements;
unknown's avatar
unknown committed
3711
    key_info->key_part=key_part_info;
unknown's avatar
unknown committed
3712
    key_info->usable_key_parts= key_number;
unknown's avatar
unknown committed
3713
    key_info->algorithm= key->key_create_info.algorithm;
3714
    key_info->option_list= key->option_list;
3715 3716
    if (parse_option_list(thd, create_info->db_type, &key_info->option_struct,
                          &key_info->option_list,
3717 3718 3719
                          create_info->db_type->index_options, FALSE,
                          thd->mem_root))
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3720

3721 3722
    if (key->type == Key::FULLTEXT)
    {
3723
      if (!(file->ha_table_flags() & HA_CAN_FULLTEXT))
3724
      {
3725
	my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0), file->table_type());
3726
	DBUG_RETURN(TRUE);
3727 3728
      }
    }
unknown's avatar
unknown committed
3729 3730 3731
    /*
       Make SPATIAL to be RTREE by default
       SPATIAL only on BLOB or at least BINARY, this
3732
       actually should be replaced by special GEOM type
unknown's avatar
unknown committed
3733 3734 3735
       in near future when new frm file is ready
       checking for proper key parts number:
    */
3736

3737
    /* TODO: Add proper checks if handler supports key_type and algorithm */
3738
    if (key_info->flags & HA_SPATIAL)
3739
    {
3740
      if (!(file->ha_table_flags() & HA_CAN_RTREEKEYS))
3741
      {
3742
	my_error(ER_TABLE_CANT_HANDLE_SPKEYS, MYF(0), file->table_type());
3743
        DBUG_RETURN(TRUE);
3744
      }
3745
      if (key_info->user_defined_key_parts != 1)
3746
      {
3747
	my_error(ER_WRONG_ARGUMENTS, MYF(0), "SPATIAL INDEX");
3748
	DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3749
      }
3750
    }
unknown's avatar
unknown committed
3751
    else if (key_info->algorithm == HA_KEY_ALG_RTREE)
unknown's avatar
unknown committed
3752
    {
unknown's avatar
unknown committed
3753
#ifdef HAVE_RTREE_KEYS
3754
      if ((key_info->user_defined_key_parts & 1) == 1)
3755
      {
3756
	my_error(ER_WRONG_ARGUMENTS, MYF(0), "RTREE INDEX");
3757
	DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3758
      }
3759
      /* TODO: To be deleted */
3760
      my_error(ER_NOT_SUPPORTED_YET, MYF(0), "RTREE INDEX");
3761
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3762
#else
3763 3764
      my_error(ER_FEATURE_DISABLED, MYF(0),
               sym_group_rtree.name, sym_group_rtree.needed_define);
3765
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3766
#endif
unknown's avatar
unknown committed
3767
    }
3768

3769 3770 3771 3772 3773
    /* 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
    */
unknown's avatar
unknown committed
3774 3775
    key_info->block_size= (key->key_create_info.block_size ?
                           key->key_create_info.block_size :
3776 3777 3778 3779 3780
                           create_info->key_block_size);

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

unknown's avatar
unknown committed
3781
    List_iterator<Key_part_spec> cols(key->columns), cols2(key->columns);
3782
    CHARSET_INFO *ft_key_charset=0;  // for FULLTEXT
unknown's avatar
unknown committed
3783 3784
    for (uint column_nr=0 ; (column=cols++) ; column_nr++)
    {
unknown's avatar
unknown committed
3785
      Key_part_spec *dup_column;
unknown's avatar
unknown committed
3786

unknown's avatar
unknown committed
3787 3788 3789
      it.rewind();
      field=0;
      while ((sql_field=it++) &&
3790
	     my_strcasecmp(system_charset_info,
3791
			   column->field_name.str,
3792
			   sql_field->field_name))
unknown's avatar
unknown committed
3793 3794 3795
	field++;
      if (!sql_field)
      {
3796
	my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.str);
3797
	DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3798
      }
unknown's avatar
unknown committed
3799
      while ((dup_column= cols2++) != column)
3800 3801
      {
        if (!my_strcasecmp(system_charset_info,
3802
	     	           column->field_name.str, dup_column->field_name.str))
3803
	{
3804
	  my_error(ER_DUP_FIELDNAME, MYF(0), column->field_name.str);
3805
	  DBUG_RETURN(TRUE);
3806 3807 3808
	}
      }
      cols2.rewind();
3809
      if (key->type == Key::FULLTEXT)
3810
      {
3811 3812
	if ((sql_field->sql_type != MYSQL_TYPE_STRING &&
	     sql_field->sql_type != MYSQL_TYPE_VARCHAR &&
3813 3814
	     !f_is_blob(sql_field->pack_flag)) ||
	    sql_field->charset == &my_charset_bin ||
3815
	    sql_field->charset->mbminlen > 1 || // ucs2 doesn't work yet
3816 3817
	    (ft_key_charset && sql_field->charset != ft_key_charset))
	{
3818
	    my_error(ER_BAD_FT_COLUMN, MYF(0), column->field_name.str);
3819 3820 3821 3822 3823 3824 3825 3826 3827 3828
	    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).
	*/
3829
        column->length= MY_TEST(f_is_blob(sql_field->pack_flag));
3830
      }
3831
      else
3832
      {
3833 3834
	column->length*= sql_field->charset->mbmaxlen;

3835
        if (key->type == Key::SPATIAL)
unknown's avatar
unknown committed
3836
        {
3837 3838 3839 3840 3841 3842 3843
          if (column->length)
          {
            my_error(ER_WRONG_SUB_KEY, MYF(0));
            DBUG_RETURN(TRUE);
          }
          if (!f_is_geom(sql_field->pack_flag))
          {
3844
            my_error(ER_WRONG_ARGUMENTS, MYF(0), "SPATIAL INDEX");
3845 3846 3847
            DBUG_RETURN(TRUE);
          }
        }
unknown's avatar
unknown committed
3848

3849 3850
	if (f_is_blob(sql_field->pack_flag) ||
            (f_is_geom(sql_field->pack_flag) && key->type != Key::SPATIAL))
3851
	{
3852
	  if (!(file->ha_table_flags() & HA_CAN_INDEX_BLOBS))
3853
	  {
3854 3855
	    my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name.str,
                     file->table_type());
3856
	    DBUG_RETURN(TRUE);
3857
	  }
3858 3859
          if (f_is_geom(sql_field->pack_flag) && sql_field->geom_type ==
              Field::GEOM_POINT)
3860
            column->length= MAX_LEN_GEOM_POINT_FIELD;
3861 3862
	  if (!column->length)
	  {
3863
	    my_error(ER_BLOB_KEY_WITHOUT_LENGTH, MYF(0), column->field_name.str);
3864
	    DBUG_RETURN(TRUE);
3865 3866
	  }
	}
unknown's avatar
unknown committed
3867
#ifdef HAVE_SPATIAL
3868
	if (key->type == Key::SPATIAL)
3869
	{
3870
	  if (!column->length)
3871 3872
	  {
	    /*
3873 3874
              4 is: (Xmin,Xmax,Ymin,Ymax), this is for 2D case
              Lately we'll extend this code to support more dimensions
3875
	    */
3876
	    column->length= 4*sizeof(double);
3877 3878
	  }
	}
unknown's avatar
unknown committed
3879
#endif
3880 3881 3882 3883 3884
        if (key->type == Key::PRIMARY && sql_field->vcol_info)
        {
          my_error(ER_PRIMARY_KEY_BASED_ON_VIRTUAL_COLUMN, MYF(0));
          DBUG_RETURN(TRUE);
        }
3885 3886 3887 3888 3889 3890 3891
	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;
unknown's avatar
unknown committed
3892
            null_fields--;
3893 3894
	  }
	  else
3895 3896 3897 3898
          {
            key_info->flags|= HA_NULL_PART_KEY;
            if (!(file->ha_table_flags() & HA_NULL_IN_KEY))
            {
3899
              my_error(ER_NULL_COLUMN_IN_INDEX, MYF(0), column->field_name.str);
3900
              DBUG_RETURN(TRUE);
3901 3902 3903 3904
            }
            if (key->type == Key::SPATIAL)
            {
              my_message(ER_SPATIAL_CANT_HAVE_NULL,
3905
                         ER_THD(thd, ER_SPATIAL_CANT_HAVE_NULL), MYF(0));
3906
              DBUG_RETURN(TRUE);
3907 3908
            }
          }
3909 3910 3911
	}
	if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
	{
3912
	  if (column_nr == 0 || (file->ha_table_flags() & HA_AUTO_PART_KEY))
3913 3914
	    auto_increment--;			// Field is used
	}
unknown's avatar
unknown committed
3915
      }
3916

unknown's avatar
unknown committed
3917 3918 3919
      key_part_info->fieldnr= field;
      key_part_info->offset=  (uint16) sql_field->offset;
      key_part_info->key_type=sql_field->pack_flag;
3920
      uint key_part_length= sql_field->key_length;
3921

unknown's avatar
unknown committed
3922 3923 3924 3925
      if (column->length)
      {
	if (f_is_blob(sql_field->pack_flag))
	{
Sergei Golubchik's avatar
Sergei Golubchik committed
3926
	  key_part_length= MY_MIN(column->length,
Sergei Golubchik's avatar
Sergei Golubchik committed
3927 3928 3929
                               blob_length_by_type(sql_field->sql_type)
                               * sql_field->charset->mbmaxlen);
	  if (key_part_length > max_key_length ||
3930
	      key_part_length > file->max_key_part_length())
3931
	  {
Sergei Golubchik's avatar
Sergei Golubchik committed
3932
	    key_part_length= MY_MIN(max_key_length, file->max_key_part_length());
3933 3934 3935
	    if (key->type == Key::MULTIPLE)
	    {
	      /* not a critical problem */
Sergei Golubchik's avatar
Sergei Golubchik committed
3936
	      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
3937 3938 3939
                                  ER_TOO_LONG_KEY,
                                  ER_THD(thd, ER_TOO_LONG_KEY),
                                  key_part_length);
3940
              /* Align key length to multibyte char boundary */
3941
              key_part_length-= key_part_length % sql_field->charset->mbmaxlen;
3942 3943 3944
	    }
	    else
	    {
3945
	      my_error(ER_TOO_LONG_KEY, MYF(0), key_part_length);
3946
	      DBUG_RETURN(TRUE);
3947 3948
	    }
	  }
unknown's avatar
unknown committed
3949
	}
3950
        // Catch invalid use of partial keys 
3951
	else if (!f_is_geom(sql_field->pack_flag) &&
3952
                 // is the key partial? 
3953
                 column->length != key_part_length &&
3954
                 // is prefix length bigger than field length? 
3955
                 (column->length > key_part_length ||
3956 3957 3958 3959 3960 3961 3962 3963
                  // can the field have a partial key? 
                  !Field::type_can_have_key_part (sql_field->sql_type) ||
                  // a packed field can't be used in a partial key
                  f_is_packed(sql_field->pack_flag) ||
                  // does the storage engine allow prefixed search?
                  ((file->ha_table_flags() & HA_NO_PREFIX_CHAR_KEYS) &&
                   // and is this a 'unique' key?
                   (key_info->flags & HA_NOSAME))))
3964
        {
3965
	  my_message(ER_WRONG_SUB_KEY, ER_THD(thd, ER_WRONG_SUB_KEY), MYF(0));
3966
	  DBUG_RETURN(TRUE);
3967
	}
3968
	else if (!(file->ha_table_flags() & HA_NO_PREFIX_CHAR_KEYS))
3969
	  key_part_length= column->length;
unknown's avatar
unknown committed
3970
      }
Sergei Golubchik's avatar
Sergei Golubchik committed
3971
      else if (key_part_length == 0 && (sql_field->flags & NOT_NULL_FLAG))
unknown's avatar
unknown committed
3972
      {
3973 3974
	my_error(ER_WRONG_KEY_COLUMN, MYF(0), file->table_type(),
                 column->field_name.str);
3975
	  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3976
      }
3977 3978
      if (key_part_length > file->max_key_part_length() &&
          key->type != Key::FULLTEXT)
3979
      {
3980
        key_part_length= file->max_key_part_length();
3981 3982 3983
	if (key->type == Key::MULTIPLE)
	{
	  /* not a critical problem */
Sergei Golubchik's avatar
Sergei Golubchik committed
3984
	  push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
3985 3986
                              ER_TOO_LONG_KEY, ER_THD(thd, ER_TOO_LONG_KEY),
                              key_part_length);
3987
          /* Align key length to multibyte char boundary */
3988
          key_part_length-= key_part_length % sql_field->charset->mbmaxlen;
3989 3990 3991
	}
	else
	{
3992
	  my_error(ER_TOO_LONG_KEY, MYF(0), key_part_length);
3993
	  DBUG_RETURN(TRUE);
3994
	}
3995
      }
3996
      key_part_info->length= (uint16) key_part_length;
unknown's avatar
unknown committed
3997
      /* Use packed keys for long strings on the first column */
3998
      if (!((*db_options) & HA_OPTION_NO_PACK_KEYS) &&
3999
          !((create_info->table_options & HA_OPTION_NO_PACK_KEYS)) &&
4000
	  (key_part_length >= KEY_DEFAULT_PACK_LENGTH &&
4001 4002
	   (sql_field->sql_type == MYSQL_TYPE_STRING ||
	    sql_field->sql_type == MYSQL_TYPE_VARCHAR ||
unknown's avatar
unknown committed
4003 4004
	    sql_field->pack_flag & FIELDFLAG_BLOB)))
      {
Staale Smedseng's avatar
Staale Smedseng committed
4005
	if ((column_nr == 0 && (sql_field->pack_flag & FIELDFLAG_BLOB)) ||
4006 4007
            sql_field->sql_type == MYSQL_TYPE_VARCHAR)
	  key_info->flags|= HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY;
unknown's avatar
unknown committed
4008 4009 4010
	else
	  key_info->flags|= HA_PACK_KEY;
      }
4011
      /* Check if the key segment is partial, set the key flag accordingly */
4012
      if (key_part_length != sql_field->key_length)
4013 4014
        key_info->flags|= HA_KEY_HAS_PART_KEY_SEG;

4015
      key_length+= key_part_length;
unknown's avatar
unknown committed
4016 4017 4018 4019 4020 4021
      key_part_info++;

      /* Create the key name based on the first column (if not given) */
      if (column_nr == 0)
      {
	if (key->type == Key::PRIMARY)
4022 4023 4024
	{
	  if (primary_key)
	  {
4025
	    my_message(ER_MULTIPLE_PRI_KEY, ER_THD(thd, ER_MULTIPLE_PRI_KEY),
unknown's avatar
unknown committed
4026
                       MYF(0));
4027
	    DBUG_RETURN(TRUE);
4028 4029 4030 4031
	  }
	  key_name=primary_key_name;
	  primary_key=1;
	}
4032
	else if (!(key_name= key->name.str))
4033
	  key_name=make_unique_key_name(thd, sql_field->field_name,
4034 4035
					*key_info_buffer, key_info);
	if (check_if_keyname_exists(key_name, *key_info_buffer, key_info))
unknown's avatar
unknown committed
4036
	{
4037
	  my_error(ER_DUP_KEYNAME, MYF(0), key_name);
4038
	  DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
4039 4040 4041 4042
	}
	key_info->name=(char*) key_name;
      }
    }
4043 4044
    if (!key_info->name || check_column_name(key_info->name))
    {
4045
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key_info->name);
4046
      DBUG_RETURN(TRUE);
4047
    }
4048
    if (key->type == Key::UNIQUE && !(key_info->flags & HA_NULL_PART_KEY))
4049
      unique_key=1;
unknown's avatar
unknown committed
4050
    key_info->key_length=(uint16) key_length;
4051
    if (key_length > max_key_length && key->type != Key::FULLTEXT)
unknown's avatar
unknown committed
4052
    {
4053
      my_error(ER_TOO_LONG_KEY,MYF(0),max_key_length);
4054
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
4055
    }
4056

4057 4058 4059 4060
    if (validate_comment_length(thd, &key->key_create_info.comment,
                                INDEX_COMMENT_MAXLEN, ER_TOO_LONG_INDEX_COMMENT,
                                key_info->name))
       DBUG_RETURN(TRUE);
4061 4062 4063 4064 4065 4066 4067 4068

    key_info->comment.length= key->key_create_info.comment.length;
    if (key_info->comment.length > 0)
    {
      key_info->flags|= HA_USES_COMMENT;
      key_info->comment.str= key->key_create_info.comment.str;
    }

4069 4070 4071
    // Check if a duplicate index is defined.
    check_duplicate_key(thd, key, key_info, &alter_info->key_list);

unknown's avatar
unknown committed
4072
    key_info++;
unknown's avatar
unknown committed
4073
  }
4074

4075
  if (!unique_key && !primary_key &&
4076
      (file->ha_table_flags() & HA_REQUIRE_PRIMARY_KEY))
4077
  {
4078 4079
    my_message(ER_REQUIRES_PRIMARY_KEY, ER_THD(thd, ER_REQUIRES_PRIMARY_KEY),
               MYF(0));
4080
    DBUG_RETURN(TRUE);
4081
  }
unknown's avatar
unknown committed
4082 4083
  if (auto_increment > 0)
  {
4084
    my_message(ER_WRONG_AUTO_KEY, ER_THD(thd, ER_WRONG_AUTO_KEY), MYF(0));
4085
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
4086
  }
4087
  /* Sort keys in optimized order */
4088 4089
  my_qsort((uchar*) *key_info_buffer, *key_count, sizeof(KEY),
	   (qsort_cmp) sort_keys);
unknown's avatar
unknown committed
4090
  create_info->null_bits= null_fields;
unknown's avatar
unknown committed
4091

4092 4093 4094 4095 4096 4097
  /* Check fields. */
  it.rewind();
  while ((sql_field=it++))
  {
    Field::utype type= (Field::utype) MTYP_TYPENR(sql_field->unireg_check);

4098 4099 4100 4101 4102
    /*
      Set NO_DEFAULT_VALUE_FLAG if this field doesn't have a default value and
      it is NOT NULL, not an AUTO_INCREMENT field, not a TIMESTAMP and not
      updated trough a NOW() function.
    */
4103
    if (!sql_field->default_value &&
4104 4105 4106 4107 4108 4109 4110 4111
        !sql_field->has_default_function() &&
        (sql_field->flags & NOT_NULL_FLAG) &&
        !is_timestamp_type(sql_field->sql_type))
    {
      sql_field->flags|= NO_DEFAULT_VALUE_FLAG;
      sql_field->pack_flag|= FIELDFLAG_NO_DEFAULT;
    }

4112
    if (thd->variables.sql_mode & MODE_NO_ZERO_DATE &&
4113
        !sql_field->default_value &&
4114
        is_timestamp_type(sql_field->sql_type) &&
4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136
        (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);
    }
  }

4137
  /* Check table level constraints */
Sergei Golubchik's avatar
Sergei Golubchik committed
4138
  create_info->check_constraint_list= &alter_info->check_constraint_list;
4139 4140
  {
    uint nr= 1;
Sergei Golubchik's avatar
Sergei Golubchik committed
4141
    List_iterator_fast<Virtual_column_info> c_it(alter_info->check_constraint_list);
4142 4143 4144 4145 4146
    Virtual_column_info *check;
    while ((check= c_it++))
    {
      if (!check->name.length)
        make_unique_constraint_name(thd, &check->name,
Sergei Golubchik's avatar
Sergei Golubchik committed
4147
                                    &alter_info->check_constraint_list,
4148
                                    &nr);
4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159
      {
        /* Check that there's no repeating constraint names. */
        List_iterator_fast<Virtual_column_info>
          dup_it(alter_info->check_constraint_list);
        Virtual_column_info *dup_check;
        while ((dup_check= dup_it++) && dup_check != check)
        {
          if (check->name.length == dup_check->name.length &&
              my_strcasecmp(system_charset_info,
                            check->name.str, dup_check->name.str) == 0)
          {
4160
            my_error(ER_DUP_CONSTRAINT_NAME, MYF(0), "CHECK", check->name.str);
4161 4162 4163 4164
            DBUG_RETURN(TRUE);
          }
        }
      }
4165 4166 4167 4168

      if (check_string_char_length(&check->name, 0, NAME_CHAR_LEN,
                                   system_charset_info, 1))
      {
4169
        my_error(ER_TOO_LONG_IDENT, MYF(0), check->name.str);
4170 4171
        DBUG_RETURN(TRUE);
      }
4172
      if (check_expression(check, check->name.str, VCOL_CHECK_TABLE))
4173 4174 4175 4176
        DBUG_RETURN(TRUE);
    }
  }

4177 4178 4179 4180 4181 4182
  /* Give warnings for not supported table options */
#if defined(WITH_ARIA_STORAGE_ENGINE)
  extern handlerton *maria_hton;
  if (file->ht != maria_hton)
#endif
    if (create_info->transactional)
Sergei Golubchik's avatar
Sergei Golubchik committed
4183
      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
4184
                          ER_ILLEGAL_HA_CREATE_OPTION,
4185
                          ER_THD(thd, ER_ILLEGAL_HA_CREATE_OPTION),
4186 4187 4188
                          file->engine_name()->str,
                          "TRANSACTIONAL=1");

4189 4190
  if (parse_option_list(thd, file->partition_ht(), &create_info->option_struct,
                          &create_info->option_list,
4191
                          file->partition_ht()->table_options, FALSE,
4192 4193 4194
                          thd->mem_root))
      DBUG_RETURN(TRUE);

4195
  DBUG_RETURN(FALSE);
4196 4197
}

4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228
/**
  check comment length of table, column, index and partition

  If comment lenght is more than the standard length
  truncate it and store the comment lenght upto the standard
  comment length size

  @param          thd             Thread handle
  @param[in,out]  comment         Comment
  @param          max_len         Maximum allowed comment length
  @param          err_code        Error message
  @param          name            Name of commented object

  @return Operation status
    @retval       true            Error found
    @retval       false           On Success
*/
bool validate_comment_length(THD *thd, LEX_STRING *comment, size_t max_len,
                             uint err_code, const char *name)
{
  DBUG_ENTER("validate_comment_length");
  uint tmp_len= my_charpos(system_charset_info, comment->str,
                           comment->str + comment->length, max_len);
  if (tmp_len < comment->length)
  {
    if (thd->is_strict_mode())
    {
       my_error(err_code, MYF(0), name, static_cast<ulong>(max_len));
       DBUG_RETURN(true);
    }
    push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN, err_code,
4229 4230
                        ER_THD(thd, err_code), name,
                        static_cast<ulong>(max_len));
4231 4232 4233 4234 4235
    comment->length= tmp_len;
  }
  DBUG_RETURN(false);
}

4236

unknown's avatar
unknown committed
4237 4238 4239 4240 4241 4242 4243 4244
/*
  Set table default charset, if not set

  SYNOPSIS
    set_table_default_charset()
    create_info        Table create information

  DESCRIPTION
4245
    If the table character set was not given explicitly,
unknown's avatar
unknown committed
4246 4247 4248 4249 4250 4251 4252
    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)
{
4253 4254 4255 4256 4257
  /*
    If the table character set was not given explicitly,
    let's fetch the database default character set and
    apply it to the table.
  */
unknown's avatar
unknown committed
4258 4259
  if (!create_info->default_table_charset)
  {
4260
    Schema_specification_st db_info;
4261 4262 4263

    load_db_opt_by_name(thd, db, &db_info);

unknown's avatar
unknown committed
4264 4265 4266 4267 4268
    create_info->default_table_charset= db_info.default_table_charset;
  }
}


unknown's avatar
unknown committed
4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281
/*
  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
*/

Alexander Barkov's avatar
Alexander Barkov committed
4282
static bool prepare_blob_field(THD *thd, Column_definition *sql_field)
unknown's avatar
unknown committed
4283 4284 4285 4286 4287 4288 4289 4290 4291
{
  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];

4292
    if (thd->is_strict_mode())
unknown's avatar
unknown committed
4293 4294
    {
      my_error(ER_TOO_BIG_FIELDLENGTH, MYF(0), sql_field->field_name,
4295 4296
               static_cast<ulong>(MAX_FIELD_VARCHARLENGTH /
                                  sql_field->charset->mbmaxlen));
unknown's avatar
unknown committed
4297 4298
      DBUG_RETURN(1);
    }
4299
    sql_field->sql_type= MYSQL_TYPE_BLOB;
unknown's avatar
unknown committed
4300
    sql_field->flags|= BLOB_FLAG;
4301 4302 4303 4304 4305
    my_snprintf(warn_buff, sizeof(warn_buff), ER_THD(thd, ER_AUTO_CONVERT),
                sql_field->field_name,
                (sql_field->charset == &my_charset_bin) ? "VARBINARY" :
                "VARCHAR",
                (sql_field->charset == &my_charset_bin) ? "BLOB" : "TEXT");
4306
    push_warning(thd, Sql_condition::WARN_LEVEL_NOTE, ER_AUTO_CONVERT,
unknown's avatar
unknown committed
4307 4308
                 warn_buff);
  }
4309

unknown's avatar
unknown committed
4310 4311
  if ((sql_field->flags & BLOB_FLAG) && sql_field->length)
  {
4312 4313 4314
    if (sql_field->sql_type == FIELD_TYPE_BLOB ||
        sql_field->sql_type == FIELD_TYPE_TINY_BLOB ||
        sql_field->sql_type == FIELD_TYPE_MEDIUM_BLOB)
unknown's avatar
unknown committed
4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325
    {
      /* 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);
}


4326
/*
unknown's avatar
unknown committed
4327
  Preparation of Create_field for SP function return values.
4328 4329
  Based on code used in the inner loop of mysql_prepare_create_table()
  above.
4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340

  SYNOPSIS
    sp_prepare_create_field()
    thd			Thread object
    sql_field		Field to prepare

  DESCRIPTION
    Prepares the field structures for field creation.

*/

Alexander Barkov's avatar
Alexander Barkov committed
4341
void sp_prepare_create_field(THD *thd, Column_definition *sql_field)
4342
{
4343 4344
  if (sql_field->sql_type == MYSQL_TYPE_SET ||
      sql_field->sql_type == MYSQL_TYPE_ENUM)
4345 4346
  {
    uint32 field_length, dummy;
4347
    if (sql_field->sql_type == MYSQL_TYPE_SET)
4348 4349 4350 4351 4352 4353 4354
    {
      calculate_interval_lengths(sql_field->charset,
                                 sql_field->interval, &dummy, 
                                 &field_length);
      sql_field->length= field_length + 
                         (sql_field->interval->count - 1);
    }
4355
    else /* MYSQL_TYPE_ENUM */
4356 4357 4358 4359 4360 4361 4362 4363 4364
    {
      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);
  }

4365
  if (sql_field->sql_type == MYSQL_TYPE_BIT)
4366 4367 4368 4369 4370
  {
    sql_field->pack_flag= FIELDFLAG_NUMBER |
                          FIELDFLAG_TREAT_BIT_AS_CHAR;
  }
  sql_field->create_length_to_internal_length();
4371
  DBUG_ASSERT(sql_field->default_value == 0);
unknown's avatar
unknown committed
4372 4373 4374
  /* Can't go wrong as sql_field->def is not defined */
  (void) prepare_blob_field(thd, sql_field);
}
4375

4376

4377
handler *mysql_create_frm_image(THD *thd,
unknown's avatar
unknown committed
4378
                                const char *db, const char *table_name,
4379
                                HA_CREATE_INFO *create_info,
4380
                                Alter_info *alter_info, int create_table_mode,
Sergei Golubchik's avatar
Sergei Golubchik committed
4381 4382
                                KEY **key_info,
                                uint *key_count,
4383
                                LEX_CUSTRING *frm)
4384
{
4385
  uint		db_options;
4386 4387
  handler       *file;
  DBUG_ENTER("mysql_create_frm_image");
4388

4389
  if (!alter_info->create_list.elements)
4390
  {
Sergei Golubchik's avatar
Sergei Golubchik committed
4391
    my_error(ER_TABLE_MUST_HAVE_COLUMNS, MYF(0));
4392
    DBUG_RETURN(NULL);
4393
  }
4394

4395 4396
  set_table_default_charset(thd, create_info, (char*) db);

4397
  db_options= create_info->table_options;
4398 4399
  if (create_info->row_type == ROW_TYPE_DYNAMIC ||
      create_info->row_type == ROW_TYPE_PAGE)
4400
    db_options|= HA_OPTION_PACK_RECORD;
Sergei Golubchik's avatar
Sergei Golubchik committed
4401

4402 4403
  if (!(file= get_new_handler((TABLE_SHARE*) 0, thd->mem_root,
                              create_info->db_type)))
4404
  {
unknown's avatar
unknown committed
4405
    mem_alloc_error(sizeof(handler));
4406
    DBUG_RETURN(NULL);
4407
  }
4408
#ifdef WITH_PARTITION_STORAGE_ENGINE
4409 4410
  partition_info *part_info= thd->work_part_info;

unknown's avatar
unknown committed
4411 4412 4413 4414 4415 4416 4417 4418
  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.
    */
unknown's avatar
unknown committed
4419
    thd->work_part_info= part_info= new partition_info();
unknown's avatar
unknown committed
4420 4421 4422
    if (!part_info)
    {
      mem_alloc_error(sizeof(partition_info));
4423
      goto err;
unknown's avatar
unknown committed
4424 4425
    }
    file->set_auto_partitions(part_info);
unknown's avatar
unknown committed
4426
    part_info->default_engine_type= create_info->db_type;
4427
    part_info->is_auto_partitioned= TRUE;
unknown's avatar
unknown committed
4428
  }
4429 4430 4431
  if (part_info)
  {
    /*
unknown's avatar
unknown committed
4432 4433 4434 4435 4436 4437
      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.
4438
    */
unknown's avatar
unknown committed
4439
    handlerton *part_engine_type= create_info->db_type;
4440 4441
    char *part_syntax_buf;
    uint syntax_len;
unknown's avatar
unknown committed
4442
    handlerton *engine_type;
4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481
    List_iterator<partition_element> part_it(part_info->partitions);
    partition_element *part_elem;

    while ((part_elem= part_it++))
    {
      if (part_elem->part_comment)
      {
        LEX_STRING comment= {
          part_elem->part_comment, strlen(part_elem->part_comment)
        };
        if (validate_comment_length(thd, &comment,
                                     TABLE_PARTITION_COMMENT_MAXLEN,
                                     ER_TOO_LONG_TABLE_PARTITION_COMMENT,
                                     part_elem->partition_name))
          DBUG_RETURN(NULL);
        part_elem->part_comment[comment.length]= '\0';
      }
      if (part_elem->subpartitions.elements)
      {
        List_iterator<partition_element> sub_it(part_elem->subpartitions);
        partition_element *subpart_elem;
        while ((subpart_elem= sub_it++))
        {
          if (subpart_elem->part_comment)
          {
            LEX_STRING comment= {
              subpart_elem->part_comment, strlen(subpart_elem->part_comment)
            };
            if (validate_comment_length(thd, &comment,
                                         TABLE_PARTITION_COMMENT_MAXLEN,
                                         ER_TOO_LONG_TABLE_PARTITION_COMMENT,
                                         subpart_elem->partition_name))
              DBUG_RETURN(NULL);
            subpart_elem->part_comment[comment.length]= '\0';
          }
        }
      }
    } 

4482
    if (create_info->tmp_table())
4483 4484 4485 4486
    {
      my_error(ER_PARTITION_NO_TEMPORARY, MYF(0));
      goto err;
    }
4487
    if ((part_engine_type == partition_hton) &&
4488
        part_info->default_engine_type)
4489 4490 4491 4492 4493 4494
    {
      /*
        This only happens at ALTER TABLE.
        default_engine_type was assigned from the engine set in the ALTER
        TABLE command.
      */
unknown's avatar
unknown committed
4495
      ;
4496
    }
4497 4498
    else
    {
unknown's avatar
unknown committed
4499 4500 4501 4502 4503 4504 4505 4506
      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)
        {
Sergei Golubchik's avatar
Sergei Golubchik committed
4507
          part_info->default_engine_type= ha_default_handlerton(thd);
unknown's avatar
unknown committed
4508 4509
        }
      }
4510
    }
unknown's avatar
unknown committed
4511 4512 4513
    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)));
4514
    if (part_info->check_partition_info(thd, &engine_type, file,
4515
                                        create_info, FALSE))
unknown's avatar
unknown committed
4516
      goto err;
unknown's avatar
unknown committed
4517
    part_info->default_engine_type= engine_type;
unknown's avatar
unknown committed
4518

4519 4520 4521 4522
    /*
      We reverse the partitioning parser and generate a standard format
      for syntax stored in frm file.
    */
4523
    if (!(part_syntax_buf= generate_partition_syntax(thd, part_info,
4524
                                                     &syntax_len,
4525 4526
                                                     TRUE, TRUE,
                                                     create_info,
4527 4528
                                                     alter_info,
                                                     NULL)))
unknown's avatar
unknown committed
4529
      goto err;
4530 4531
    part_info->part_info_string= part_syntax_buf;
    part_info->part_info_len= syntax_len;
unknown's avatar
unknown committed
4532 4533
    if ((!(engine_type->partition_flags &&
           engine_type->partition_flags() & HA_CAN_PARTITION)) ||
4534
        create_info->db_type == partition_hton)
4535 4536 4537 4538 4539
    {
      /*
        The handler assigned to the table cannot handle partitioning.
        Assign the partition handler as the handler of the table.
      */
unknown's avatar
unknown committed
4540
      DBUG_PRINT("info", ("db_type: %s",
unknown's avatar
unknown committed
4541
                        ha_resolve_storage_engine_name(create_info->db_type)));
4542
      delete file;
4543
      create_info->db_type= partition_hton;
4544
      if (!(file= get_ha_partition(part_info)))
4545 4546
        DBUG_RETURN(NULL);

4547 4548 4549 4550 4551 4552
      /*
        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.
      */
4553 4554 4555
      if (part_info->use_default_num_partitions &&
          part_info->num_parts &&
          (int)part_info->num_parts !=
4556
          file->get_default_no_partitions(create_info))
4557
      {
4558
        uint i;
4559
        List_iterator<partition_element> part_it(part_info->partitions);
4560 4561 4562 4563
        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;
4564 4565
      }
      else if (part_info->is_sub_partitioned() &&
4566 4567 4568
               part_info->use_default_num_subpartitions &&
               part_info->num_subparts &&
               (int)part_info->num_subparts !=
4569
                 file->get_default_no_partitions(create_info))
4570
      {
4571
        DBUG_ASSERT(thd->lex->sql_command != SQLCOM_CREATE_TABLE);
4572
        part_info->num_subparts= file->get_default_no_partitions(create_info);
4573 4574 4575 4576
      }
    }
    else if (create_info->db_type != engine_type)
    {
4577 4578 4579 4580 4581 4582
      /*
        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.
      */
4583
      delete file;
4584 4585
      if (!(file= get_new_handler((TABLE_SHARE*) 0, thd->mem_root,
                                  engine_type)))
4586 4587
      {
        mem_alloc_error(sizeof(handler));
4588
        DBUG_RETURN(NULL);
4589
      }
4590 4591
    }
  }
Sergei Golubchik's avatar
Sergei Golubchik committed
4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603
  /*
    Unless table's storage engine supports partitioning natively
    don't allow foreign keys on partitioned tables (they won't
    work work even with InnoDB beneath of partitioning engine).
    If storage engine handles partitioning natively (like NDB)
    foreign keys support is possible, so we let the engine decide.
  */
  if (create_info->db_type == partition_hton)
  {
    List_iterator_fast<Key> key_iterator(alter_info->key_list);
    Key *key;
    while ((key= key_iterator++))
4604
    {
Sergei Golubchik's avatar
Sergei Golubchik committed
4605
      if (key->type == Key::FOREIGN_KEY)
4606
      {
Sergei Golubchik's avatar
Sergei Golubchik committed
4607 4608
        my_error(ER_FOREIGN_KEY_ON_PARTITIONED, MYF(0));
        goto err;
4609 4610
      }
    }
4611 4612
  }
#endif
4613

4614
  if (mysql_prepare_create_table(thd, create_info, alter_info, &db_options,
Sergei Golubchik's avatar
Sergei Golubchik committed
4615
                                 file, key_info, key_count,
4616
                                 create_table_mode))
4617
    goto err;
4618
  create_info->table_options=db_options;
unknown's avatar
unknown committed
4619

4620
  *frm= build_frm_image(thd, table_name, create_info,
Sergei Golubchik's avatar
Sergei Golubchik committed
4621 4622
                        alter_info->create_list, *key_count,
                        *key_info, file);
4623

4624 4625
  if (frm->str)
    DBUG_RETURN(file);
4626

4627 4628 4629 4630
err:
  delete file;
  DBUG_RETURN(NULL);
}
Sergei Golubchik's avatar
Sergei Golubchik committed
4631

unknown's avatar
unknown committed
4632

Sergei Golubchik's avatar
Sergei Golubchik committed
4633
/**
4634 4635
  Create a table

Sergei Golubchik's avatar
Sergei Golubchik committed
4636
  @param thd                 Thread object
4637 4638 4639
  @param orig_db             Database for error messages
  @param orig_table_name     Table name for error messages
                             (it's different from table_name for ALTER TABLE)
Sergei Golubchik's avatar
Sergei Golubchik committed
4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653
  @param db                  Database
  @param table_name          Table name
  @param path                Path to table (i.e. to its .FRM file without
                             the extension).
  @param create_info         Create information (like MAX_ROWS)
  @param alter_info          Description of fields and keys for new table
  @param create_table_mode   C_ORDINARY_CREATE, C_ALTER_TABLE, C_ASSISTED_DISCOVERY
                             or any positive number (for C_CREATE_SELECT).
  @param[out] is_trans       Identifies the type of engine where the table
                             was created: either trans or non-trans.
  @param[out] key_info       Array of KEY objects describing keys in table
                             which was created.
  @param[out] key_count      Number of keys in table which was created.

4654 4655
  If one creates a temporary table, its is automatically opened and its
  TABLE_SHARE is added to THD::all_temp_tables list.
unknown's avatar
unknown committed
4656

Sergei Golubchik's avatar
Sergei Golubchik committed
4657 4658 4659 4660
  Note that this function assumes that caller already have taken
  exclusive metadata 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.
4661

4662 4663 4664
  @retval 0 OK
  @retval 1 error
  @retval -1 table existed but IF EXISTS was used
4665 4666
*/

Sergei Golubchik's avatar
Sergei Golubchik committed
4667
static
4668
int create_table_impl(THD *thd,
4669
                       const char *orig_db, const char *orig_table_name,
Sergei Golubchik's avatar
Sergei Golubchik committed
4670 4671
                       const char *db, const char *table_name,
                       const char *path,
4672
                       const DDL_options_st options,
Sergei Golubchik's avatar
Sergei Golubchik committed
4673 4674 4675 4676 4677 4678 4679
                       HA_CREATE_INFO *create_info,
                       Alter_info *alter_info,
                       int create_table_mode,
                       bool *is_trans,
                       KEY **key_info,
                       uint *key_count,
                       LEX_CUSTRING *frm)
4680 4681
{
  const char	*alias;
Sergei Golubchik's avatar
Sergei Golubchik committed
4682
  handler	*file= 0;
4683
  int		error= 1;
Sergei Golubchik's avatar
Sergei Golubchik committed
4684 4685
  bool          frm_only= create_table_mode == C_ALTER_TABLE_FRM_ONLY;
  bool          internal_tmp_table= create_table_mode == C_ALTER_TABLE || frm_only;
4686
  DBUG_ENTER("mysql_create_table_no_lock");
4687 4688
  DBUG_PRINT("enter", ("db: '%s'  table: '%s'  tmp: %d  path: %s",
                       db, table_name, internal_tmp_table, path));
4689

4690
  if (thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE)
unknown's avatar
unknown committed
4691
  {
4692
    if (create_info->data_file_name)
Sergei Golubchik's avatar
Sergei Golubchik committed
4693
      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
4694 4695
                          WARN_OPTION_IGNORED,
                          ER_THD(thd, WARN_OPTION_IGNORED),
4696
                          "DATA DIRECTORY");
4697
    if (create_info->index_file_name)
Sergei Golubchik's avatar
Sergei Golubchik committed
4698
      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
4699 4700
                          WARN_OPTION_IGNORED,
                          ER_THD(thd, WARN_OPTION_IGNORED),
4701
                          "INDEX DIRECTORY");
4702
    create_info->data_file_name= create_info->index_file_name= 0;
unknown's avatar
unknown committed
4703
  }
Sergei Golubchik's avatar
Sergei Golubchik committed
4704 4705 4706 4707 4708
  else
  if (error_if_data_home_dir(create_info->data_file_name,  "DATA DIRECTORY") ||
      error_if_data_home_dir(create_info->index_file_name, "INDEX DIRECTORY")||
      check_partition_dirs(thd->lex->part_info))
    goto err;
4709

Sergei Golubchik's avatar
Sergei Golubchik committed
4710
  alias= table_case_name(create_info, table_name);
Sergei Golubchik's avatar
Sergei Golubchik committed
4711

4712 4713
  /* Check if table exists */
  if (create_info->tmp_table())
unknown's avatar
unknown committed
4714
  {
4715 4716 4717 4718 4719 4720
    /*
      If a table exists, it must have been pre-opened. Try looking for one
      in-use in THD::all_temp_tables list of TABLE_SHAREs.
    */
    TABLE *tmp_table= thd->find_temporary_table(db, table_name);

4721
    if (tmp_table)
unknown's avatar
unknown committed
4722
    {
4723
      bool table_creation_was_logged= tmp_table->s->table_creation_was_logged;
4724
      if (options.or_replace())
4725 4726 4727 4728 4729
      {
        /*
          We are using CREATE OR REPLACE on an existing temporary table
          Remove the old table so that we can re-create it.
        */
4730
        if (thd->drop_temporary_table(tmp_table, NULL, true))
4731 4732
          goto err;
      }
4733
      else if (options.if_not_exists())
4734
        goto warn;
4735 4736 4737 4738 4739
      else
      {
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), alias);
        goto err;
      }
4740 4741 4742 4743 4744 4745 4746 4747 4748 4749
      /*
        We have to log this query, even if it failed later to ensure the
        drop is done.
      */
      if (table_creation_was_logged)
      {
        thd->variables.option_bits|= OPTION_KEEP_LOG;
        thd->log_current_statement= 1;
        create_info->table_was_deleted= 1;
      }
unknown's avatar
unknown committed
4750 4751
    }
  }
4752
  else
unknown's avatar
unknown committed
4753
  {
4754 4755
    if (!internal_tmp_table && ha_table_exists(thd, db, table_name))
    {
4756
      if (options.or_replace())
4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771
      {
        TABLE_LIST table_list;
        table_list.init_one_table(db, strlen(db), table_name,
                                  strlen(table_name), table_name,
                                  TL_WRITE_ALLOW_WRITE);
        table_list.table= create_info->table;

        if (check_if_log_table(&table_list, TRUE, "CREATE OR REPLACE"))
          goto err;
        
        /*
          Rollback the empty transaction started in mysql_create_table()
          call to open_and_lock_tables() when we are using LOCK TABLES.
        */
        (void) trans_rollback_stmt(thd);
4772 4773
        /* Remove normal table without logging. Keep tables locked */
        if (mysql_rm_table_no_locks(thd, &table_list, 0, 0, 0, 1, 1))
4774
          goto err;
4775 4776 4777 4778 4779 4780 4781

        /*
          We have to log this query, even if it failed later to ensure the
          drop is done.
        */
        thd->variables.option_bits|= OPTION_KEEP_LOG;
        thd->log_current_statement= 1;
4782
        create_info->table_was_deleted= 1;
4783
        DBUG_EXECUTE_IF("send_kill_after_delete", thd->killed= KILL_QUERY; );
4784

4785
        /*
4786
          Restart statement transactions for the case of CREATE ... SELECT.
4787
        */
4788 4789
        if (thd->lex->select_lex.item_list.elements &&
            restart_trans_for_tables(thd, thd->lex->query_tables))
4790 4791
          goto err;
      }
4792
      else if (options.if_not_exists())
4793
        goto warn;
4794 4795 4796 4797 4798
      else
      {
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
        goto err;
      }
unknown's avatar
unknown committed
4799 4800 4801
    }
  }

Sergei Golubchik's avatar
Sergei Golubchik committed
4802
  THD_STAGE_INFO(thd, stage_creating_table);
unknown's avatar
unknown committed
4803

4804 4805 4806
  if (check_engine(thd, orig_db, orig_table_name, create_info))
    goto err;

Sergei Golubchik's avatar
Sergei Golubchik committed
4807
  if (create_table_mode == C_ASSISTED_DISCOVERY)
4808
  {
Sergei Golubchik's avatar
Sergei Golubchik committed
4809 4810 4811
    /* check that it's used correctly */
    DBUG_ASSERT(alter_info->create_list.elements == 0);
    DBUG_ASSERT(alter_info->key_list.elements == 0);
4812

Sergei Golubchik's avatar
Sergei Golubchik committed
4813 4814 4815 4816 4817 4818
    TABLE_SHARE share;
    handlerton *hton= create_info->db_type;
    int ha_err;
    Field *no_fields= 0;

    if (!hton->discover_table_structure)
4819
    {
4820
      my_error(ER_TABLE_MUST_HAVE_COLUMNS, MYF(0));
Sergei Golubchik's avatar
Sergei Golubchik committed
4821
      goto err;
4822
    }
Sergei Golubchik's avatar
Sergei Golubchik committed
4823 4824 4825 4826 4827

    init_tmp_table_share(thd, &share, db, 0, table_name, path);

    /* prepare everything for discovery */
    share.field= &no_fields;
4828
    share.db_plugin= ha_lock_engine(thd, hton);
Sergei Golubchik's avatar
Sergei Golubchik committed
4829 4830 4831 4832 4833 4834 4835
    share.option_list= create_info->option_list;
    share.connect_string= create_info->connect_string;

    if (parse_engine_table_options(thd, hton, &share))
      goto err;

    ha_err= hton->discover_table_structure(hton, thd, &share, create_info);
4836 4837 4838 4839 4840 4841 4842 4843 4844 4845

    /*
      if discovery failed, the plugin will be auto-unlocked, as it
      was locked on the THD, see above.
      if discovery succeeded, the plugin was replaced by a globally
      locked plugin, that will be unlocked by free_table_share()
    */
    if (ha_err)
      share.db_plugin= 0; // will be auto-freed, locked above on the THD

Sergei Golubchik's avatar
Sergei Golubchik committed
4846 4847 4848
    free_table_share(&share);

    if (ha_err)
4849
    {
4850
      my_error(ER_GET_ERRNO, MYF(0), ha_err, hton_name(hton)->str);
Sergei Golubchik's avatar
Sergei Golubchik committed
4851
      goto err;
4852
    }
4853
  }
Sergei Golubchik's avatar
Sergei Golubchik committed
4854
  else
4855
  {
4856 4857 4858
    file= mysql_create_frm_image(thd, orig_db, orig_table_name, create_info,
                                 alter_info, create_table_mode, key_info,
                                 key_count, frm);
Sergei Golubchik's avatar
Sergei Golubchik committed
4859 4860
    if (!file)
      goto err;
Sergei Golubchik's avatar
Sergei Golubchik committed
4861 4862
    if (rea_create_table(thd, frm, path, db, table_name, create_info,
                         file, frm_only))
Sergei Golubchik's avatar
Sergei Golubchik committed
4863
      goto err;
4864
  }
4865

4866
  create_info->table= 0;
Sergei Golubchik's avatar
Sergei Golubchik committed
4867
  if (!frm_only && create_info->tmp_table())
unknown's avatar
unknown committed
4868
  {
4869 4870
    TABLE *table= thd->create_and_open_tmp_table(create_info->db_type, frm,
                                                 path, db, table_name, true);
4871 4872

    if (!table)
unknown's avatar
unknown committed
4873
    {
4874
      (void) thd->rm_temporary_table(create_info->db_type, path);
4875
      goto err;
unknown's avatar
unknown committed
4876
    }
4877 4878 4879 4880

    if (is_trans != NULL)
      *is_trans= table->file->has_transactions();

unknown's avatar
unknown committed
4881
    thd->thread_specific_used= TRUE;
4882
    create_info->table= table;                  // Store pointer to table
unknown's avatar
unknown committed
4883
  }
4884
#ifdef WITH_PARTITION_STORAGE_ENGINE
Sergei Golubchik's avatar
Sergei Golubchik committed
4885
  else if (thd->work_part_info && frm_only)
4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896
  {
    /*
      For partitioned tables we can't find some problems with table
      until table is opened. Therefore in order to disallow creation
      of corrupted tables we have to try to open table as the part
      of its creation process.
      In cases when both .FRM and SE part of table are created table
      is implicitly open in ha_create_table() call.
      In cases when we create .FRM without SE part we have to open
      table explicitly.
    */
4897 4898 4899 4900 4901
    TABLE table;
    TABLE_SHARE share;

    init_tmp_table_share(thd, &share, db, 0, table_name, path);

Sergei Golubchik's avatar
Sergei Golubchik committed
4902
    bool result= (open_table_def(thd, &share, GTS_TABLE) ||
4903 4904 4905
                  open_table_from_share(thd, &share, "", 0, (uint) READ_ALL,
                                        0, &table, true));
    if (!result)
Sergey Vojtovich's avatar
Sergey Vojtovich committed
4906
      (void) closefrm(&table);
4907 4908 4909 4910

    free_table_share(&share);

    if (result)
4911 4912
    {
      char frm_name[FN_REFLEN];
4913
      strxnmov(frm_name, sizeof(frm_name), path, reg_ext, NullS);
4914
      (void) mysql_file_delete(key_file_frm, frm_name, MYF(0));
Sergei Golubchik's avatar
Sergei Golubchik committed
4915
      (void) file->ha_create_partitioning_metadata(path, NULL, CHF_DELETE_FLAG);
4916 4917 4918 4919
      goto err;
    }
  }
#endif
unknown's avatar
unknown committed
4920

4921
  error= 0;
unknown's avatar
unknown committed
4922
err:
Sergei Golubchik's avatar
Sergei Golubchik committed
4923
  THD_STAGE_INFO(thd, stage_after_create);
unknown's avatar
unknown committed
4924
  delete file;
4925
  DBUG_PRINT("exit", ("return: %d", error));
unknown's avatar
unknown committed
4926
  DBUG_RETURN(error);
4927 4928

warn:
4929
  error= -1;
4930
  push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
4931 4932
                      ER_TABLE_EXISTS_ERROR,
                      ER_THD(thd, ER_TABLE_EXISTS_ERROR),
4933
                      alias);
4934
  goto err;
unknown's avatar
unknown committed
4935 4936
}

4937 4938 4939 4940
/**
  Simple wrapper around create_table_impl() to be used
  in various version of CREATE TABLE statement.
*/
4941 4942

int mysql_create_table_no_lock(THD *thd,
4943
                                const char *db, const char *table_name,
4944
                                Table_specification_st *create_info,
4945 4946 4947 4948 4949
                                Alter_info *alter_info, bool *is_trans,
                                int create_table_mode)
{
  KEY *not_used_1;
  uint not_used_2;
4950
  int res;
4951
  char path[FN_REFLEN + 1];
Sergei Golubchik's avatar
Sergei Golubchik committed
4952
  LEX_CUSTRING frm= {0,0};
4953

Sergei Golubchik's avatar
Sergei Golubchik committed
4954
  if (create_info->tmp_table())
4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969
    build_tmptable_filename(thd, path, sizeof(path));
  else
  {
    int length;
    const char *alias= table_case_name(create_info, table_name);
    length= build_table_filename(path, sizeof(path) - 1, db, alias,
                                 "", 0);
    // Check if we hit FN_REFLEN bytes along with file extension.
    if (length+reg_ext_length > FN_REFLEN)
    {
      my_error(ER_IDENT_CAUSES_TOO_LONG_PATH, MYF(0), sizeof(path)-1, path);
      return true;
    }
  }

4970
  res= create_table_impl(thd, db, table_name, db, table_name, path,
4971 4972
                         *create_info, create_info,
                         alter_info, create_table_mode,
4973
                         is_trans, &not_used_1, &not_used_2, &frm);
Sergei Golubchik's avatar
Sergei Golubchik committed
4974 4975
  my_free(const_cast<uchar*>(frm.str));
  return res;
4976 4977
}

4978 4979 4980 4981 4982 4983 4984 4985
/**
  Implementation of SQLCOM_CREATE_TABLE.

  Take the metadata locks (including a shared lock on the affected
  schema) and create the table. Is written to be called from
  mysql_execute_command(), to which it delegates the common parts
  with other commands (i.e. implicit commit before and after,
  close of thread tables.
unknown's avatar
unknown committed
4986 4987
*/

4988
bool mysql_create_table(THD *thd, TABLE_LIST *create_table,
4989
                        Table_specification_st *create_info,
4990
                        Alter_info *alter_info)
unknown's avatar
unknown committed
4991
{
Sergei Golubchik's avatar
Sergei Golubchik committed
4992 4993
  const char *db= create_table->db;
  const char *table_name= create_table->table_name;
4994
  bool is_trans= FALSE;
4995
  bool result;
Sergei Golubchik's avatar
Sergei Golubchik committed
4996
  int create_table_mode;
4997
  TABLE_LIST *pos_in_locked_tables= 0;
4998
  MDL_ticket *mdl_ticket= 0;
unknown's avatar
unknown committed
4999 5000
  DBUG_ENTER("mysql_create_table");

5001 5002
  DBUG_ASSERT(create_table == thd->lex->query_tables);

5003 5004 5005 5006
  /* Copy temporarily the statement flags to thd for lock_table_names() */
  uint save_thd_create_info_options= thd->lex->create_info.options;
  thd->lex->create_info.options|= create_info->options;

Sergei Golubchik's avatar
Sergei Golubchik committed
5007
  /* Open or obtain an exclusive metadata lock on table being created  */
5008
  result= open_and_lock_tables(thd, *create_info, create_table, FALSE, 0);
5009 5010 5011 5012

  thd->lex->create_info.options= save_thd_create_info_options;

  if (result)
unknown's avatar
unknown committed
5013
  {
5014
    /* is_error() may be 0 if table existed and we generated a warning */
Sergei Golubchik's avatar
Sergei Golubchik committed
5015
    DBUG_RETURN(thd->is_error());
unknown's avatar
unknown committed
5016
  }
5017
  /* The following is needed only in case of lock tables */
5018 5019
  if ((create_info->table= create_table->table))
  {
5020
    pos_in_locked_tables= create_info->table->pos_in_locked_tables;
5021 5022
    mdl_ticket= create_table->table->mdl_ticket;
  }
5023
  
5024 5025
  /* Got lock. */
  DEBUG_SYNC(thd, "locked_table_name");
unknown's avatar
unknown committed
5026

Sergei Golubchik's avatar
Sergei Golubchik committed
5027 5028 5029 5030 5031
  if (alter_info->create_list.elements || alter_info->key_list.elements)
    create_table_mode= C_ORDINARY_CREATE;
  else
    create_table_mode= C_ASSISTED_DISCOVERY;

5032 5033 5034
  if (!opt_explicit_defaults_for_timestamp)
    promote_first_timestamp_column(&alter_info->create_list);

Sergei Golubchik's avatar
Sergei Golubchik committed
5035
  if (mysql_create_table_no_lock(thd, db, table_name, create_info, alter_info,
5036
                                 &is_trans, create_table_mode) > 0)
5037 5038 5039 5040
  {
    result= 1;
    goto err;
  }
5041

5042 5043 5044 5045 5046
  /*
    Check if we are doing CREATE OR REPLACE TABLE under LOCK TABLES
    on a non temporary table
  */
  if (thd->locked_tables_mode && pos_in_locked_tables &&
5047
      create_info->or_replace())
5048 5049 5050 5051 5052 5053 5054
  {
    /*
      Add back the deleted table and re-created table as a locked table
      This should always work as we have a meta lock on the table.
     */
    thd->locked_tables_list.add_back_last_deleted_lock(pos_in_locked_tables);
    if (thd->locked_tables_list.reopen_tables(thd))
5055
    {
5056
      thd->locked_tables_list.unlink_all_closed_tables(thd, NULL, 0);
5057 5058
      result= 1;
    }
5059 5060 5061 5062 5063
    else
    {
      TABLE *table= pos_in_locked_tables->table;
      table->mdl_ticket->downgrade_lock(MDL_SHARED_NO_READ_WRITE);
    }
5064
  }
5065

5066
err:
Sergei Golubchik's avatar
Sergei Golubchik committed
5067 5068
  /* In RBR we don't need to log CREATE TEMPORARY TABLE */
  if (thd->is_current_stmt_binlog_format_row() && create_info->tmp_table())
5069
    DBUG_RETURN(result);
5070

5071 5072
  /* Write log if no error or if we already deleted a table */
  if (!result || thd->log_current_statement)
5073 5074 5075 5076 5077 5078 5079 5080
  {
    if (result && create_info->table_was_deleted)
    {
      /*
        Possible locked table was dropped. We should remove meta data locks
        associated with it and do UNLOCK_TABLES if no more locked tables.
      */
      thd->locked_tables_list.unlock_locked_table(thd, mdl_ticket);
5081 5082 5083 5084 5085 5086 5087 5088 5089
    }
    else if (!result && create_info->tmp_table() && create_info->table)
    {
      /*
        Remember that tmp table creation was logged so that we know if
        we should log a delete of it.
      */
      create_info->table->s->table_creation_was_logged= 1;
    }
5090 5091 5092
    if (write_bin_log(thd, result ? FALSE : TRUE, thd->query(),
                      thd->query_length(), is_trans))
      result= 1;
5093
  }
unknown's avatar
unknown committed
5094 5095 5096 5097
  DBUG_RETURN(result);
}


unknown's avatar
unknown committed
5098 5099 5100 5101 5102 5103 5104 5105
/*
** 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++)
5106
    if (!my_strcasecmp(system_charset_info,name,key->name))
unknown's avatar
unknown committed
5107 5108 5109 5110 5111 5112
      return 1;
  return 0;
}


static char *
5113
make_unique_key_name(THD *thd, const char *field_name,KEY *start,KEY *end)
unknown's avatar
unknown committed
5114 5115 5116
{
  char buff[MAX_FIELD_NAME],*buff_end;

5117 5118
  if (!check_if_keyname_exists(field_name,start,end) &&
      my_strcasecmp(system_charset_info,field_name,primary_key_name))
unknown's avatar
unknown committed
5119
    return (char*) field_name;			// Use fieldname
5120 5121 5122 5123 5124 5125
  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
  */
5126
  for (uint i=2 ; i< 100; i++)
unknown's avatar
unknown committed
5127
  {
5128 5129
    *buff_end= '_';
    int10_to_str(i, buff_end+1, 10);
unknown's avatar
unknown committed
5130
    if (!check_if_keyname_exists(buff,start,end))
5131
      return thd->strdup(buff);
unknown's avatar
unknown committed
5132
  }
5133
  return (char*) "not_specified";		// Should never happen
unknown's avatar
unknown committed
5134 5135
}

5136 5137 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
/**
   Make an unique name for constraints without a name
*/

static void make_unique_constraint_name(THD *thd, LEX_STRING *name,
                                        List<Virtual_column_info> *vcol,
                                        uint *nr)
{
  char buff[MAX_FIELD_NAME], *end;
  List_iterator_fast<Virtual_column_info> it(*vcol);

  end=strmov(buff, "CONSTRAINT_");
  for (;;)
  {
    Virtual_column_info *check;
    char *real_end= int10_to_str((*nr)++, end, 10);
    it.rewind();
    while ((check= it++))
    {
      if (check->name.str &&
          !my_strcasecmp(system_charset_info, buff, check->name.str))
        break;
    }
    if (!check)                                 // Found unique name
    {
      name->length= (size_t) (real_end - buff);
      name->str= thd->strmake(buff, name->length);
      return;
    }
  }
}

5168

unknown's avatar
unknown committed
5169 5170 5171 5172
/****************************************************************************
** Alter a table definition
****************************************************************************/

5173

5174
/**
5175 5176
  Rename a table.

5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187
  @param base      The handlerton handle.
  @param old_db    The old database name.
  @param old_name  The old table name.
  @param new_db    The new database name.
  @param new_name  The new table name.
  @param flags     flags
                   FN_FROM_IS_TMP old_name is temporary.
                   FN_TO_IS_TMP   new_name is temporary.
                   NO_FRM_RENAME  Don't rename the FRM file
                                  but only the table in the storage engine.
                   NO_HA_TABLE    Don't rename table in engine.
Sergei Golubchik's avatar
Sergei Golubchik committed
5188
                   NO_FK_CHECKS   Don't check FK constraints during rename.
5189 5190 5191

  @return false    OK
  @return true     Error
5192 5193
*/

5194
bool
5195 5196 5197
mysql_rename_table(handlerton *base, const char *old_db,
                   const char *old_name, const char *new_db,
                   const char *new_name, uint flags)
unknown's avatar
unknown committed
5198
{
5199
  THD *thd= current_thd;
5200 5201
  char from[FN_REFLEN + 1], to[FN_REFLEN + 1],
    lc_from[FN_REFLEN + 1], lc_to[FN_REFLEN + 1];
5202
  char *from_base= from, *to_base= to;
5203
  char tmp_name[SAFE_NAME_LEN+1], tmp_db_name[SAFE_NAME_LEN+1];
unknown's avatar
unknown committed
5204
  handler *file;
unknown's avatar
unknown committed
5205
  int error=0;
5206
  ulonglong save_bits= thd->variables.option_bits;
5207
  int length;
unknown's avatar
unknown committed
5208
  DBUG_ENTER("mysql_rename_table");
5209
  DBUG_ASSERT(base);
5210 5211
  DBUG_PRINT("enter", ("old: '%s'.'%s'  new: '%s'.'%s'",
                       old_db, old_name, new_db, new_name));
unknown's avatar
unknown committed
5212

5213 5214 5215
  // Temporarily disable foreign key checks
  if (flags & NO_FK_CHECKS) 
    thd->variables.option_bits|= OPTION_NO_FOREIGN_KEY_CHECKS;
unknown's avatar
unknown committed
5216

5217
  file= get_new_handler((TABLE_SHARE*) 0, thd->mem_root, base);
unknown's avatar
unknown committed
5218

5219
  build_table_filename(from, sizeof(from) - 1, old_db, old_name, "",
5220
                       flags & FN_FROM_IS_TMP);
5221 5222 5223 5224 5225 5226 5227 5228
  length= build_table_filename(to, sizeof(to) - 1, new_db, new_name, "",
                               flags & FN_TO_IS_TMP);
  // Check if we hit FN_REFLEN bytes along with file extension.
  if (length+reg_ext_length > FN_REFLEN)
  {
    my_error(ER_IDENT_CAUSES_TOO_LONG_PATH, MYF(0), sizeof(to)-1, to);
    DBUG_RETURN(TRUE);
  }
5229 5230 5231 5232 5233 5234

  /*
    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.
   */
5235
  if (lower_case_table_names == 2 && file &&
5236
      !(file->ha_table_flags() & HA_FILE_BASED))
unknown's avatar
unknown committed
5237
  {
5238 5239
    strmov(tmp_name, old_name);
    my_casedn_str(files_charset_info, tmp_name);
5240 5241 5242 5243 5244
    strmov(tmp_db_name, old_db);
    my_casedn_str(files_charset_info, tmp_db_name);

    build_table_filename(lc_from, sizeof(lc_from) - 1, tmp_db_name, tmp_name,
                         "", flags & FN_FROM_IS_TMP);
5245
    from_base= lc_from;
unknown's avatar
unknown committed
5246

5247 5248
    strmov(tmp_name, new_name);
    my_casedn_str(files_charset_info, tmp_name);
5249 5250 5251 5252
    strmov(tmp_db_name, new_db);
    my_casedn_str(files_charset_info, tmp_db_name);

    build_table_filename(lc_to, sizeof(lc_to) - 1, tmp_db_name, tmp_name, "",
5253
                         flags & FN_TO_IS_TMP);
5254
    to_base= lc_to;
unknown's avatar
unknown committed
5255 5256
  }

5257 5258 5259 5260
  if (flags & NO_HA_TABLE)
  {
    if (rename_file_ext(from,to,reg_ext))
      error= my_errno;
Sergei Golubchik's avatar
Sergei Golubchik committed
5261
    (void) file->ha_create_partitioning_metadata(to, from, CHF_RENAME_FLAG);
5262 5263
  }
  else if (!file || !(error=file->ha_rename_table(from_base, to_base)))
5264
  {
5265
    if (!(flags & NO_FRM_RENAME) && rename_file_ext(from,to,reg_ext))
5266
    {
unknown's avatar
unknown committed
5267
      error=my_errno;
5268
      if (file)
5269 5270 5271 5272 5273 5274
      {
        if (error == ENOENT)
          error= 0; // this is ok if file->ha_rename_table() succeeded
        else
          file->ha_rename_table(to_base, from_base); // Restore old file name
      }
5275 5276
    }
  }
unknown's avatar
unknown committed
5277
  delete file;
5278 5279 5280
  if (error == HA_ERR_WRONG_COMMAND)
    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "ALTER TABLE");
  else if (error)
unknown's avatar
unknown committed
5281
    my_error(ER_ERROR_ON_RENAME, MYF(0), from, to, error);
5282 5283
  else if (!(flags & FN_IS_TMP))
    mysql_audit_rename_table(thd, old_db, old_name, new_db, new_name);
Sergei Golubchik's avatar
Sergei Golubchik committed
5284 5285 5286 5287 5288 5289 5290

  /*
    Remove the old table share from the pfs table share array. The new table
    share will be created when the renamed table is first accessed.
   */
  if (likely(error == 0))
  {
5291
    PSI_CALL_drop_table_share(flags & FN_FROM_IS_TMP,
5292 5293
                              old_db, strlen(old_db),
                              old_name, strlen(old_name));
Sergei Golubchik's avatar
Sergei Golubchik committed
5294 5295
  }

5296 5297 5298
  // Restore options bits to the original value
  thd->variables.option_bits= save_bits;

unknown's avatar
unknown committed
5299
  DBUG_RETURN(error != 0);
unknown's avatar
unknown committed
5300 5301
}

unknown's avatar
unknown committed
5302

unknown's avatar
unknown committed
5303 5304 5305 5306 5307
/*
  Create a table identical to the specified table

  SYNOPSIS
    mysql_create_like_table()
5308
    thd		Thread object
unknown's avatar
unknown committed
5309 5310
    table       Table list element for target table
    src_table   Table list element for source table
unknown's avatar
unknown committed
5311 5312 5313
    create_info Create info

  RETURN VALUES
unknown's avatar
unknown committed
5314 5315
    FALSE OK
    TRUE  error
unknown's avatar
unknown committed
5316 5317
*/

5318 5319
bool mysql_create_like_table(THD* thd, TABLE_LIST* table,
                             TABLE_LIST* src_table,
5320
                             Table_specification_st *create_info)
unknown's avatar
unknown committed
5321
{
5322
  Table_specification_st local_create_info;
5323
  TABLE_LIST *pos_in_locked_tables= 0;
5324
  Alter_info local_alter_info;
5325
  Alter_table_ctx local_alter_ctx; // Not used
unknown's avatar
unknown committed
5326
  bool res= TRUE;
5327
  bool is_trans= FALSE;
5328
  bool do_logging= FALSE;
unknown's avatar
unknown committed
5329
  uint not_used;
5330
  int create_res;
unknown's avatar
unknown committed
5331
  DBUG_ENTER("mysql_create_like_table");
5332

5333 5334 5335
#ifdef WITH_WSREP
  if (WSREP_ON && !thd->wsrep_applier &&
      wsrep_create_like_table(thd, table, src_table, create_info))
5336
    DBUG_RETURN(res);
5337 5338
#endif

unknown's avatar
unknown committed
5339
  /*
5340 5341 5342 5343 5344 5345 5346 5347 5348
    We the open source table to get its description in HA_CREATE_INFO
    and Alter_info objects. This also acquires a shared metadata lock
    on this table which ensures that no concurrent DDL operation will
    mess with it.
    Also in case when we create non-temporary table open_tables()
    call obtains an exclusive metadata lock on target table ensuring
    that we can safely perform table creation.
    Thus by holding both these locks we ensure that our statement is
    properly isolated from all concurrent operations which matter.
5349
  */
5350 5351

  /* Copy temporarily the statement flags to thd for lock_table_names() */
5352
  // QQ: is this really needed???
5353 5354 5355 5356 5357 5358
  uint save_thd_create_info_options= thd->lex->create_info.options;
  thd->lex->create_info.options|= create_info->options;
  res= open_tables(thd, &thd->lex->query_tables, &not_used, 0);
  thd->lex->create_info.options= save_thd_create_info_options;

  if (res)
5359
  {
5360
    /* is_error() may be 0 if table existed and we generated a warning */
5361
    res= thd->is_error();
5362
    goto err;
5363
  }
5364
  /* Ensure we don't try to create something from which we select from */
5365
  if (create_info->or_replace() && !create_info->tmp_table())
5366 5367 5368 5369 5370 5371 5372 5373 5374
  {
    TABLE_LIST *duplicate;
    if ((duplicate= unique_table(thd, table, src_table, 0)))
    {
      update_non_unique_table_error(src_table, "CREATE", duplicate);
      goto err;
    }
  }

5375
  src_table->table->use_all_columns();
unknown's avatar
unknown committed
5376

5377 5378
  DEBUG_SYNC(thd, "create_table_like_after_open");

5379 5380 5381 5382 5383 5384
  /*
    Fill Table_specification_st and Alter_info with the source table description.
    Set OR REPLACE and IF NOT EXISTS option as in the CREATE TABLE LIKE
    statement.
  */
  local_create_info.init(create_info->create_like_options());
5385 5386 5387
  local_create_info.db_type= src_table->table->s->db_type();
  local_create_info.row_type= src_table->table->s->row_type;
  if (mysql_prepare_alter_table(thd, src_table->table, &local_create_info,
5388
                                &local_alter_info, &local_alter_ctx))
5389 5390 5391 5392
    goto err;
#ifdef WITH_PARTITION_STORAGE_ENGINE
  /* Partition info is not handled by mysql_prepare_alter_table() call. */
  if (src_table->table->part_info)
5393
    thd->work_part_info= src_table->table->part_info->get_clone(thd);
5394
#endif
unknown's avatar
unknown committed
5395

unknown's avatar
unknown committed
5396
  /*
5397 5398
    Adjust description of source table before using it for creation of
    target table.
Konstantin Osipov's avatar
Konstantin Osipov committed
5399

5400 5401
    Similarly to SHOW CREATE TABLE we ignore MAX_ROWS attribute of
    temporary table which represents I_S table.
5402
  */
5403
  if (src_table->schema_table)
5404 5405 5406
    local_create_info.max_rows= 0;
  /* Replace type of source table with one specified in the statement. */
  local_create_info.options&= ~HA_LEX_CREATE_TMP_TABLE;
5407
  local_create_info.options|= create_info->tmp_table();
5408 5409
  /* Reset auto-increment counter for the new table. */
  local_create_info.auto_increment_value= 0;
5410 5411 5412 5413 5414
  /*
    Do not inherit values of DATA and INDEX DIRECTORY options from
    the original table. This is documented behavior.
  */
  local_create_info.data_file_name= local_create_info.index_file_name= NULL;
5415

5416 5417 5418 5419
  /* The following is needed only in case of lock tables */
  if ((local_create_info.table= thd->lex->query_tables->table))
    pos_in_locked_tables= local_create_info.table->pos_in_locked_tables;    

5420 5421 5422 5423
  res= ((create_res=
         mysql_create_table_no_lock(thd, table->db, table->table_name,
                                    &local_create_info, &local_alter_info,
                                    &is_trans, C_ORDINARY_CREATE)) > 0);
5424 5425 5426
  /* Remember to log if we deleted something */
  do_logging= thd->log_current_statement;
  if (res)
5427
    goto err;
unknown's avatar
unknown committed
5428 5429

  /*
5430 5431
    Check if we are doing CREATE OR REPLACE TABLE under LOCK TABLES
    on a non temporary table
unknown's avatar
unknown committed
5432
  */
5433
  if (thd->locked_tables_mode && pos_in_locked_tables &&
5434
      create_info->or_replace())
5435 5436 5437 5438 5439 5440 5441
  {
    /*
      Add back the deleted table and re-created table as a locked table
      This should always work as we have a meta lock on the table.
     */
    thd->locked_tables_list.add_back_last_deleted_lock(pos_in_locked_tables);
    if (thd->locked_tables_list.reopen_tables(thd))
5442
    {
5443
      thd->locked_tables_list.unlink_all_closed_tables(thd, NULL, 0);
5444 5445
      res= 1;                                   // We got an error
    }
5446 5447 5448 5449 5450 5451 5452
    else
    {
      /*
        Get pointer to the newly opened table. We need this to ensure we
        don't reopen the table when doing statment logging below.
      */
      table->table= pos_in_locked_tables->table;
5453
      table->table->mdl_ticket->downgrade_lock(MDL_SHARED_NO_READ_WRITE);
5454 5455
    }
  }
5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466
  else
  {
    /*
      Ensure that we have an exclusive lock on target table if we are creating
      non-temporary table.
    */
    DBUG_ASSERT((create_info->tmp_table()) ||
                thd->mdl_context.is_lock_owner(MDL_key::TABLE, table->db,
                                               table->table_name,
                                               MDL_EXCLUSIVE));
  }
5467 5468 5469

  DEBUG_SYNC(thd, "create_table_like_before_binlog");

5470 5471 5472
  /*
    We have to write the query before we unlock the tables.
  */
Sergei Golubchik's avatar
Sergei Golubchik committed
5473 5474 5475
  if (thd->is_current_stmt_binlog_disabled())
    goto err;

5476
  if (thd->is_current_stmt_binlog_format_row())
5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487
  {
    /*
       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
5488 5489
           2       normal temporary Generated statement if the table
                                    was created.
5490 5491 5492 5493
           3    temporary    normal Nothing
           4    temporary temporary Nothing
           ==== ========= ========= ==============================
    */
5494
    if (!(create_info->tmp_table()))
5495
    {
unknown's avatar
unknown committed
5496
      if (src_table->table->s->tmp_table)               // Case 2
5497 5498 5499 5500
      {
        char buf[2048];
        String query(buf, sizeof(buf), system_charset_info);
        query.length(0);  // Have to zero it since constructor doesn't
5501 5502
        Open_table_context ot_ctx(thd, MYSQL_OPEN_REOPEN |
                                  MYSQL_OPEN_IGNORE_KILLED);
unknown's avatar
unknown committed
5503
        bool new_table= FALSE; // Whether newly created table is open.
5504

5505
        if (create_res != 0)
5506
        {
5507 5508 5509 5510
          /*
            Table or view with same name already existed and we where using
            IF EXISTS. Continue without logging anything.
          */
5511
          do_logging= 0;
5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522
          goto err;
        }
        if (!table->table)
        {
          TABLE_LIST::enum_open_strategy save_open_strategy;
          int open_res;
          /* Force the newly created table to be opened */
          save_open_strategy= table->open_strategy;
          table->open_strategy= TABLE_LIST::OPEN_NORMAL;

          /*
5523
            In order for show_create_table() to work we need to open
5524 5525 5526 5527 5528 5529
            destination table if it is not already open (i.e. if it
            has not existed before). We don't need acquire metadata
            lock in order to do this as we already hold exclusive
            lock on this table. The table will be closed by
            close_thread_table() at the end of this branch.
          */
5530
          open_res= open_table(thd, table, &ot_ctx);
5531 5532 5533
          /* Restore */
          table->open_strategy= save_open_strategy;
          if (open_res)
unknown's avatar
unknown committed
5534
          {
5535 5536
            res= 1;
            goto err;
unknown's avatar
unknown committed
5537
          }
5538
          new_table= TRUE;
5539 5540 5541 5542 5543 5544 5545
        }
        /*
          We have to re-test if the table was a view as the view may not
          have been opened until just above.
        */
        if (!table->view)
        {
5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560
          /*
            After opening a MERGE table add the children to the query list of
            tables, so that children tables info can be used on "CREATE TABLE"
            statement generation by the binary log.
            Note that placeholders don't have the handler open.
          */
          if (table->table->file->extra(HA_EXTRA_ADD_CHILDREN_LIST))
            goto err;

          /*
            As the reference table is temporary and may not exist on slave, we must
            force the ENGINE to be present into CREATE TABLE.
          */
          create_info->used_fields|= HA_CREATE_USED_ENGINE;

5561
          int result __attribute__((unused))=
5562
            show_create_table(thd, table, &query, create_info, WITH_DB_NAME);
5563

5564
          DBUG_ASSERT(result == 0); // show_create_table() always return 0
5565
          do_logging= FALSE;
5566
          if (write_bin_log(thd, TRUE, query.ptr(), query.length()))
5567 5568
          {
            res= 1;
5569
            do_logging= 0;
5570
            goto err;
5571
          }
5572

unknown's avatar
unknown committed
5573 5574 5575 5576 5577 5578 5579 5580 5581 5582
          if (new_table)
          {
            DBUG_ASSERT(thd->open_tables == table->table);
            /*
              When opening the table, we ignored the locked tables
              (MYSQL_OPEN_GET_NEW_TABLE). Now we can close the table
              without risking to close some locked table.
            */
            close_thread_table(thd, &thd->open_tables);
          }
5583
        }
5584 5585
      }
      else                                      // Case 1
5586
        do_logging= TRUE;
5587 5588 5589 5590 5591
    }
    /*
      Case 3 and 4 does nothing under RBR
    */
  }
5592
  else
5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604
  {
    DBUG_PRINT("info",
               ("res: %d  tmp_table: %d  create_info->table: %p",
                res, create_info->tmp_table(), local_create_info.table));
    if (!res && create_info->tmp_table() && local_create_info.table)
    {
      /*
        Remember that tmp table creation was logged so that we know if
        we should log a delete of it.
      */
      local_create_info.table->s->table_creation_was_logged= 1;
    }
5605
    do_logging= TRUE;
5606
  }
5607

5608
err:
5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624
  if (do_logging)
  {
    if (res && create_info->table_was_deleted)
    {
      /*
        Table was not deleted. Original table was deleted.
        We have to log it.
      */
      log_drop_table(thd, table->db, table->db_length,
                     table->table_name, table->table_name_length,
                     create_info->tmp_table());
    }
    else if (write_bin_log(thd, res ? FALSE : TRUE, thd->query(),
                           thd->query_length(), is_trans))
      res= 1;
  }
5625

5626
  DBUG_RETURN(res);
unknown's avatar
unknown committed
5627 5628 5629
}


unknown's avatar
unknown committed
5630
/* table_list should contain just one table */
5631 5632 5633
int mysql_discard_or_import_tablespace(THD *thd,
                                       TABLE_LIST *table_list,
                                       bool discard)
unknown's avatar
unknown committed
5634
{
5635
  Alter_table_prelocking_strategy alter_prelocking_strategy;
unknown's avatar
unknown committed
5636 5637 5638
  int error;
  DBUG_ENTER("mysql_discard_or_import_tablespace");

Sergei Golubchik's avatar
Sergei Golubchik committed
5639 5640
  mysql_audit_alter_table(thd, table_list);

unknown's avatar
unknown committed
5641 5642 5643 5644
  /*
    Note that DISCARD/IMPORT TABLESPACE always is the only operation in an
    ALTER TABLE
  */
unknown's avatar
unknown committed
5645

Sergei Golubchik's avatar
Sergei Golubchik committed
5646
  THD_STAGE_INFO(thd, stage_discard_or_import_tablespace);
unknown's avatar
unknown committed
5647

unknown's avatar
unknown committed
5648 5649 5650 5651 5652
 /*
   We set this flag so that ha_innobase::open and ::external_lock() do
   not complain when we lock the table
 */
  thd->tablespace_op= TRUE;
5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663
  /*
    Adjust values of table-level and metadata which was set in parser
    for the case general ALTER TABLE.
  */
  table_list->mdl_request.set_type(MDL_EXCLUSIVE);
  table_list->lock_type= TL_WRITE;
  /* Do not open views. */
  table_list->required_type= FRMTYPE_TABLE;

  if (open_and_lock_tables(thd, table_list, FALSE, 0,
                           &alter_prelocking_strategy))
unknown's avatar
unknown committed
5664 5665 5666 5667
  {
    thd->tablespace_op=FALSE;
    DBUG_RETURN(-1);
  }
5668

5669
  error= table_list->table->file->ha_discard_or_import_tablespace(discard);
unknown's avatar
unknown committed
5670

Sergei Golubchik's avatar
Sergei Golubchik committed
5671
  THD_STAGE_INFO(thd, stage_end);
unknown's avatar
unknown committed
5672 5673 5674 5675

  if (error)
    goto err;

unknown's avatar
unknown committed
5676 5677 5678 5679
  /*
    The 0 in the call below means 'not in a transaction', which means
    immediate invalidation; that is probably what we wish here
  */
unknown's avatar
unknown committed
5680 5681 5682
  query_cache_invalidate3(thd, table_list, 0);

  /* The ALTER TABLE is always in its own transaction */
Konstantin Osipov's avatar
Konstantin Osipov committed
5683 5684
  error= trans_commit_stmt(thd);
  if (trans_commit_implicit(thd))
unknown's avatar
unknown committed
5685 5686 5687
    error=1;
  if (error)
    goto err;
5688
  error= write_bin_log(thd, FALSE, thd->query(), thd->query_length());
5689

unknown's avatar
unknown committed
5690
err:
unknown's avatar
unknown committed
5691
  thd->tablespace_op=FALSE;
5692

unknown's avatar
unknown committed
5693 5694
  if (error == 0)
  {
5695
    my_ok(thd);
unknown's avatar
unknown committed
5696
    DBUG_RETURN(0);
unknown's avatar
unknown committed
5697
  }
unknown's avatar
unknown committed
5698

5699
  table_list->table->file->print_error(error, MYF(0));
5700

unknown's avatar
unknown committed
5701
  DBUG_RETURN(-1);
unknown's avatar
unknown committed
5702
}
unknown's avatar
unknown committed
5703

5704

5705
/**
5706 5707
  Check if key is a candidate key, i.e. a unique index with no index
  fields partial or nullable.
5708 5709
*/

5710
static bool is_candidate_key(KEY *key)
5711
{
5712 5713
  KEY_PART_INFO *key_part;
  KEY_PART_INFO *key_part_end= key->key_part + key->user_defined_key_parts;
5714

5715 5716
  if (!(key->flags & HA_NOSAME) || (key->flags & HA_NULL_PART_KEY))
    return false;
5717

5718
  for (key_part= key->key_part; key_part < key_part_end; key_part++)
5719
  {
5720 5721
    if (key_part->key_part_flag & HA_PART_KEY_SEG)
      return false;
5722
  }
5723
  return true;
5724 5725
}

5726

5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766
/*
   Preparation for table creation

   SYNOPSIS
     handle_if_exists_option()
       thd                       Thread object.
       table                     The altered table.
       alter_info                List of columns and indexes to create

   DESCRIPTION
     Looks for the IF [NOT] EXISTS options, checks the states and remove items
     from the list if existing found.

   RETURN VALUES
     NONE
*/

static void
handle_if_exists_options(THD *thd, TABLE *table, Alter_info *alter_info)
{
  Field **f_ptr;
  DBUG_ENTER("handle_if_exists_option");

  /* Handle ADD COLUMN IF NOT EXISTS. */
  {
    List_iterator<Create_field> it(alter_info->create_list);
    Create_field *sql_field;

    while ((sql_field=it++))
    {
      if (!sql_field->create_if_not_exists || sql_field->change)
        continue;
      /*
         If there is a field with the same name in the table already,
         remove the sql_field from the list.
      */
      for (f_ptr=table->field; *f_ptr; f_ptr++)
      {
        if (my_strcasecmp(system_charset_info,
              sql_field->field_name, (*f_ptr)->field_name) == 0)
5767 5768 5769 5770 5771 5772 5773 5774 5775 5776
          goto drop_create_field;
      }
      {
        /*
          If in the ADD list there is a field with the same name,
          remove the sql_field from the list.
        */
        List_iterator<Create_field> chk_it(alter_info->create_list);
        Create_field *chk_field;
        while ((chk_field= chk_it++) && chk_field != sql_field)
5777
        {
5778 5779 5780
          if (my_strcasecmp(system_charset_info,
                sql_field->field_name, chk_field->field_name) == 0)
            goto drop_create_field;
5781 5782
        }
      }
5783 5784 5785
      continue;
drop_create_field:
      push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
5786 5787
                          ER_DUP_FIELDNAME, ER_THD(thd, ER_DUP_FIELDNAME),
                          sql_field->field_name);
5788 5789 5790 5791 5792 5793 5794 5795
      it.remove();
      if (alter_info->create_list.is_empty())
      {
        alter_info->flags&= ~Alter_info::ALTER_ADD_COLUMN;
        if (alter_info->key_list.is_empty())
          alter_info->flags&= ~(Alter_info::ALTER_ADD_INDEX |
              Alter_info::ADD_FOREIGN_KEY);
      }
5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814
    }
  }

  /* Handle MODIFY COLUMN IF EXISTS. */
  {
    List_iterator<Create_field> it(alter_info->create_list);
    Create_field *sql_field;

    while ((sql_field=it++))
    {
      if (!sql_field->create_if_not_exists || !sql_field->change)
        continue;
      /*
         If there is NO field with the same name in the table already,
         remove the sql_field from the list.
      */
      for (f_ptr=table->field; *f_ptr; f_ptr++)
      {
        if (my_strcasecmp(system_charset_info,
5815
              sql_field->change, (*f_ptr)->field_name) == 0)
5816 5817 5818 5819 5820 5821
        {
          break;
        }
      }
      if (*f_ptr == NULL)
      {
Sergei Golubchik's avatar
Sergei Golubchik committed
5822
        push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
5823 5824 5825
                            ER_BAD_FIELD_ERROR,
                            ER_THD(thd, ER_BAD_FIELD_ERROR),
                            sql_field->change, table->s->table_name.str);
5826 5827 5828
        it.remove();
        if (alter_info->create_list.is_empty())
        {
Sergei Golubchik's avatar
Sergei Golubchik committed
5829 5830
          alter_info->flags&= ~(Alter_info::ALTER_ADD_COLUMN |
                                Alter_info::ALTER_CHANGE_COLUMN);
5831
          if (alter_info->key_list.is_empty())
Sergei Golubchik's avatar
Sergei Golubchik committed
5832
            alter_info->flags&= ~Alter_info::ALTER_ADD_INDEX;
5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863
        }
      }
    }
  }

  /* Handle DROP COLUMN/KEY IF EXISTS. */
  {
    List_iterator<Alter_drop> drop_it(alter_info->drop_list);
    Alter_drop *drop;
    bool remove_drop;
    while ((drop= drop_it++))
    {
      if (!drop->drop_if_exists)
        continue;
      remove_drop= TRUE;
      if (drop->type == Alter_drop::COLUMN)
      {
        /*
           If there is NO field with that name in the table,
           remove the 'drop' from the list.
        */
        for (f_ptr=table->field; *f_ptr; f_ptr++)
        {
          if (my_strcasecmp(system_charset_info,
                            drop->name, (*f_ptr)->field_name) == 0)
          {
            remove_drop= FALSE;
            break;
          }
        }
      }
Sergei Golubchik's avatar
Sergei Golubchik committed
5864 5865
      else if (drop->type == Alter_drop::CHECK_CONSTRAINT)
      {
5866
        for (uint i=table->s->field_check_constraints; i < table->s->table_check_constraints; i++)
Sergei Golubchik's avatar
Sergei Golubchik committed
5867 5868 5869 5870 5871 5872 5873 5874 5875 5876
        {
          if (my_strcasecmp(system_charset_info, drop->name,
                            table->check_constraints[i]->name.str) == 0)
          {
            remove_drop= FALSE;
            break;
          }
        }
      }
      else /* Alter_drop::KEY and Alter_drop::FOREIGN_KEY */
5877 5878
      {
        uint n_key;
5879
        if (drop->type != Alter_drop::FOREIGN_KEY)
5880
        {
5881
          for (n_key=0; n_key < table->s->keys; n_key++)
5882
          {
5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904
            if (my_strcasecmp(system_charset_info,
                  drop->name, table->key_info[n_key].name) == 0)
            {
              remove_drop= FALSE;
              break;
            }
          }
        }
        else
        {
          List <FOREIGN_KEY_INFO> fk_child_key_list;
          FOREIGN_KEY_INFO *f_key;
          table->file->get_foreign_key_list(thd, &fk_child_key_list);
          List_iterator<FOREIGN_KEY_INFO> fk_key_it(fk_child_key_list);
          while ((f_key= fk_key_it++))
          {
            if (my_strcasecmp(system_charset_info, f_key->foreign_id->str,
                  drop->name) == 0)
            {
              remove_drop= FALSE;
              break;
            }
5905 5906 5907
          }
        }
      }
5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927

      if (!remove_drop)
      {
        /*
          Check if the name appears twice in the DROP list.
        */
        List_iterator<Alter_drop> chk_it(alter_info->drop_list);
        Alter_drop *chk_drop;
        while ((chk_drop= chk_it++) && chk_drop != drop)
        {
          if (drop->type == chk_drop->type &&
              my_strcasecmp(system_charset_info,
                            drop->name, chk_drop->name) == 0)
          {
            remove_drop= TRUE;
            break;
          }
        }
      }

5928 5929
      if (remove_drop)
      {
Sergei Golubchik's avatar
Sergei Golubchik committed
5930
        push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
5931 5932
                            ER_CANT_DROP_FIELD_OR_KEY,
                            ER_THD(thd, ER_CANT_DROP_FIELD_OR_KEY),
5933
                            drop->type_name(), drop->name);
5934 5935
        drop_it.remove();
        if (alter_info->drop_list.is_empty())
Sergei Golubchik's avatar
Sergei Golubchik committed
5936
          alter_info->flags&= ~(Alter_info::ALTER_DROP_COLUMN |
5937 5938
                                Alter_info::ALTER_DROP_INDEX  |
                                Alter_info::DROP_FOREIGN_KEY);
5939 5940 5941 5942 5943 5944 5945 5946 5947 5948
      }
    }
  }

  /* ALTER TABLE ADD KEY IF NOT EXISTS */
  /* ALTER TABLE ADD FOREIGN KEY IF NOT EXISTS */
  {
    Key *key;
    List_iterator<Key> key_it(alter_info->key_list);
    uint n_key;
5949
    const char *keyname= NULL;
5950 5951
    while ((key=key_it++))
    {
5952
      if (!key->if_not_exists() && !key->or_replace())
5953
        continue;
5954 5955

      /* Check if the table already has a PRIMARY KEY */
5956 5957 5958 5959
      bool dup_primary_key= key->type == Key::PRIMARY &&
                            table->s->primary_key != MAX_KEY;
      if (dup_primary_key)
        goto remove_key;
5960

5961 5962 5963 5964
      /* If the name of the key is not specified,     */
      /* let us check the name of the first key part. */
      if ((keyname= key->name.str) == NULL)
      {
5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975
        if (key->type == Key::PRIMARY)
          keyname= primary_key_name;
        else
        {
          List_iterator<Key_part_spec> part_it(key->columns);
          Key_part_spec *kp;
          if ((kp= part_it++))
            keyname= kp->field_name.str;
          if (keyname == NULL)
            continue;
        }
5976
      }
5977
      if (key->type != Key::FOREIGN_KEY)
5978
      {
5979
        for (n_key=0; n_key < table->s->keys; n_key++)
5980
        {
5981 5982
          if (my_strcasecmp(system_charset_info,
                keyname, table->key_info[n_key].name) == 0)
5983
          {
5984
            goto remove_key;
5985 5986 5987
          }
        }
      }
5988 5989 5990 5991 5992 5993 5994 5995 5996 5997
      else
      {
        List <FOREIGN_KEY_INFO> fk_child_key_list;
        FOREIGN_KEY_INFO *f_key;
        table->file->get_foreign_key_list(thd, &fk_child_key_list);
        List_iterator<FOREIGN_KEY_INFO> fk_key_it(fk_child_key_list);
        while ((f_key= fk_key_it++))
        {
          if (my_strcasecmp(system_charset_info, f_key->foreign_id->str,
                key->name.str) == 0)
5998
            goto remove_key;
5999 6000
        }
      }
6001

6002
      {
6003 6004 6005 6006
        Key *chk_key;
        List_iterator<Key> chk_it(alter_info->key_list);
        const char *chkname;
        while ((chk_key=chk_it++) && chk_key != key)
6007
        {
6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019
          if ((chkname= chk_key->name.str) == NULL)
          {
            List_iterator<Key_part_spec> part_it(chk_key->columns);
            Key_part_spec *kp;
            if ((kp= part_it++))
              chkname= kp->field_name.str;
            if (keyname == NULL)
              continue;
          }
          if (key->type == chk_key->type &&
              my_strcasecmp(system_charset_info, keyname, chkname) == 0)
            goto remove_key;
6020 6021
        }
      }
6022 6023 6024
      continue;

remove_key:
6025
      if (key->if_not_exists())
6026
      {
6027
        push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
6028 6029
                            ER_DUP_KEYNAME, ER_THD(thd, dup_primary_key
                            ? ER_MULTIPLE_PRI_KEY : ER_DUP_KEYNAME), keyname);
6030
        key_it.remove();
6031 6032 6033 6034 6035 6036 6037 6038 6039
        if (key->type == Key::FOREIGN_KEY)
        {
          /* ADD FOREIGN KEY appends two items. */
          key_it.remove();
        }
        if (alter_info->key_list.is_empty())
          alter_info->flags&= ~(Alter_info::ALTER_ADD_INDEX |
              Alter_info::ADD_FOREIGN_KEY);
      }
Sergei Golubchik's avatar
Sergei Golubchik committed
6040
      else
6041
      {
Sergei Golubchik's avatar
Sergei Golubchik committed
6042
        DBUG_ASSERT(key->or_replace());
6043 6044 6045 6046 6047 6048 6049
        Alter_drop::drop_type type= (key->type == Key::FOREIGN_KEY) ?
          Alter_drop::FOREIGN_KEY : Alter_drop::KEY;
        Alter_drop *ad= new Alter_drop(type, key->name.str, FALSE);
        if (ad != NULL)
        {
          // Adding the index into the drop list for replacing
          alter_info->flags |= Alter_info::ALTER_DROP_INDEX;
6050
          alter_info->drop_list.push_back(ad, thd->mem_root);
6051
        }
6052
      }
6053 6054 6055 6056 6057
    }
  }
  
#ifdef WITH_PARTITION_STORAGE_ENGINE
  partition_info *tab_part_info= table->part_info;
6058
  if (tab_part_info)
6059 6060
  {
    /* ALTER TABLE ADD PARTITION IF NOT EXISTS */
6061 6062
    if ((alter_info->flags & Alter_info::ALTER_ADD_PARTITION) &&
        thd->lex->create_info.if_not_exists())
6063 6064 6065 6066 6067 6068 6069 6070 6071 6072
    {
      partition_info *alt_part_info= thd->lex->part_info;
      if (alt_part_info)
      {
        List_iterator<partition_element> new_part_it(alt_part_info->partitions);
        partition_element *pe;
        while ((pe= new_part_it++))
        {
          if (!tab_part_info->has_unique_name(pe))
          {
Sergei Golubchik's avatar
Sergei Golubchik committed
6073
            push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
6074 6075 6076
                                ER_SAME_NAME_PARTITION,
                                ER_THD(thd, ER_SAME_NAME_PARTITION),
                                pe->partition_name);
Sergei Golubchik's avatar
Sergei Golubchik committed
6077
            alter_info->flags&= ~Alter_info::ALTER_ADD_PARTITION;
6078 6079 6080 6081 6082 6083 6084
            thd->lex->part_info= NULL;
            break;
          }
        }
      }
    }
    /* ALTER TABLE DROP PARTITION IF EXISTS */
6085 6086
    if ((alter_info->flags & Alter_info::ALTER_DROP_PARTITION) &&
        thd->lex->if_exists())
6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102
    {
      List_iterator<char> names_it(alter_info->partition_names);
      char *name;

      while ((name= names_it++))
      {
        List_iterator<partition_element> part_it(tab_part_info->partitions);
        partition_element *part_elem;
        while ((part_elem= part_it++))
        {
          if (my_strcasecmp(system_charset_info,
                              part_elem->partition_name, name) == 0)
            break;
        }
        if (!part_elem)
        {
Sergei Golubchik's avatar
Sergei Golubchik committed
6103
          push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
6104 6105 6106
                              ER_DROP_PARTITION_NON_EXISTENT,
                              ER_THD(thd, ER_DROP_PARTITION_NON_EXISTENT),
                              "DROP");
6107 6108 6109 6110
          names_it.remove();
        }
      }
      if (alter_info->partition_names.elements == 0)
Sergei Golubchik's avatar
Sergei Golubchik committed
6111
        alter_info->flags&= ~Alter_info::ALTER_DROP_PARTITION;
6112 6113 6114 6115
    }
  }
#endif /*WITH_PARTITION_STORAGE_ENGINE*/

6116 6117 6118 6119 6120 6121 6122 6123
  /* ADD CONSTRAINT IF NOT EXISTS. */
  {
    List_iterator<Virtual_column_info> it(alter_info->check_constraint_list);
    Virtual_column_info *check;
    TABLE_SHARE *share= table->s;
    uint c;
    while ((check=it++))
    {
Oleksandr Byelkin's avatar
Oleksandr Byelkin committed
6124
      if (!(check->flags & Alter_info::CHECK_CONSTRAINT_IF_NOT_EXISTS) &&
6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148
          check->name.length)
        continue;
      check->flags= 0;
      for (c= share->field_check_constraints;
           c < share->table_check_constraints ; c++)
      {
        Virtual_column_info *dup= table->check_constraints[c];
        if (dup->name.length == check->name.length &&
            my_strcasecmp(system_charset_info,
                          check->name.str, dup->name.str) == 0)
        {
          push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
            ER_DUP_CONSTRAINT_NAME, ER_THD(thd, ER_DUP_CONSTRAINT_NAME),
            "CHECK", check->name.str);
          it.remove();
          if (alter_info->check_constraint_list.elements == 0)
            alter_info->flags&= ~Alter_info::ALTER_ADD_CHECK_CONSTRAINT;

          break;
        }
      }
    }
  }

6149 6150 6151 6152
  DBUG_VOID_RETURN;
}


6153 6154
/**
  Get Create_field object for newly created table by field index.
unknown's avatar
unknown committed
6155

6156 6157
  @param alter_info  Alter_info describing newly created table.
  @param idx         Field index.
unknown's avatar
unknown committed
6158 6159
*/

6160
static Create_field *get_field_by_index(Alter_info *alter_info, uint idx)
unknown's avatar
unknown committed
6161
{
6162 6163 6164
  List_iterator_fast<Create_field> field_it(alter_info->create_list);
  uint field_idx= 0;
  Create_field *field;
unknown's avatar
unknown committed
6165

6166 6167
  while ((field= field_it++) && field_idx < idx)
  { field_idx++; }
6168

6169 6170
  return field;
}
Michael Widenius's avatar
Michael Widenius committed
6171

unknown's avatar
unknown committed
6172

6173 6174 6175 6176
static int compare_uint(const uint *s, const uint *t)
{
  return (*s < *t) ? -1 : ((*s > *t) ? 1 : 0);
}
unknown's avatar
unknown committed
6177 6178


6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218
/**
   Compare original and new versions of a table and fill Alter_inplace_info
   describing differences between those versions.

   @param          thd                Thread
   @param          table              The original table.
   @param          varchar            Indicates that new definition has new
                                      VARCHAR column.
   @param[in/out]  ha_alter_info      Data structure which already contains
                                      basic information about create options,
                                      field and keys for the new version of
                                      table and which should be completed with
                                      more detailed information needed for
                                      in-place ALTER.

   First argument 'table' 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.

   Compare the changes between the original and new table definitions.
   The result of this comparison is then passed to SE which determines
   whether it can carry out these changes in-place.

   Mark any changes detected in the ha_alter_flags.
   We generally try to specify handler flags only if there are real
   changes. But in cases when it is cumbersome to determine if some
   attribute has really changed we might choose to set flag
   pessimistically, for example, relying on parser output only.

   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.

   Note that this function assumes that it is OK to change Alter_info
   and HA_CREATE_INFO which it gets. It is caller who is responsible
   for creating copies for this structures if he needs them unchanged.

   @retval true  error
   @retval false success
unknown's avatar
unknown committed
6219 6220
*/

6221 6222 6223 6224
static bool fill_alter_inplace_info(THD *thd,
                                    TABLE *table,
                                    bool varchar,
                                    Alter_inplace_info *ha_alter_info)
unknown's avatar
unknown committed
6225 6226
{
  Field **f_ptr, *field;
6227 6228 6229
  List_iterator_fast<Create_field> new_field_it;
  Create_field *new_field;
  KEY_PART_INFO *key_part, *new_part;
6230
  KEY_PART_INFO *end;
6231 6232 6233
  uint candidate_key_count= 0;
  Alter_info *alter_info= ha_alter_info->alter_info;
  DBUG_ENTER("fill_alter_inplace_info");
unknown's avatar
unknown committed
6234

6235 6236 6237 6238 6239 6240 6241
  /* Allocate result buffers. */
  if (! (ha_alter_info->index_drop_buffer=
          (KEY**) thd->alloc(sizeof(KEY*) * table->s->keys)) ||
      ! (ha_alter_info->index_add_buffer=
          (uint*) thd->alloc(sizeof(uint) *
                            alter_info->key_list.elements)))
    DBUG_RETURN(true);
6242

6243
  /*
6244 6245 6246 6247
    Comparing new and old default values of column is cumbersome.
    So instead of using such a comparison for detecting if default
    has really changed we rely on flags set by parser to get an
    approximate value for storage engine flag.
6248
  */
6249 6250 6251 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
  if (alter_info->flags & (Alter_info::ALTER_CHANGE_COLUMN |
                           Alter_info::ALTER_CHANGE_COLUMN_DEFAULT))
    ha_alter_info->handler_flags|= Alter_inplace_info::ALTER_COLUMN_DEFAULT;
  if (alter_info->flags & Alter_info::ADD_FOREIGN_KEY)
    ha_alter_info->handler_flags|= Alter_inplace_info::ADD_FOREIGN_KEY;
  if (alter_info->flags & Alter_info::DROP_FOREIGN_KEY)
    ha_alter_info->handler_flags|= Alter_inplace_info::DROP_FOREIGN_KEY;
  if (alter_info->flags & Alter_info::ALTER_OPTIONS)
    ha_alter_info->handler_flags|= Alter_inplace_info::CHANGE_CREATE_OPTION;
  if (alter_info->flags & Alter_info::ALTER_RENAME)
    ha_alter_info->handler_flags|= Alter_inplace_info::ALTER_RENAME;
  /* Check partition changes */
  if (alter_info->flags & Alter_info::ALTER_ADD_PARTITION)
    ha_alter_info->handler_flags|= Alter_inplace_info::ADD_PARTITION;
  if (alter_info->flags & Alter_info::ALTER_DROP_PARTITION)
    ha_alter_info->handler_flags|= Alter_inplace_info::DROP_PARTITION;
  if (alter_info->flags & Alter_info::ALTER_PARTITION)
    ha_alter_info->handler_flags|= Alter_inplace_info::ALTER_PARTITION;
  if (alter_info->flags & Alter_info::ALTER_COALESCE_PARTITION)
    ha_alter_info->handler_flags|= Alter_inplace_info::COALESCE_PARTITION;
  if (alter_info->flags & Alter_info::ALTER_REORGANIZE_PARTITION)
    ha_alter_info->handler_flags|= Alter_inplace_info::REORGANIZE_PARTITION;
  if (alter_info->flags & Alter_info::ALTER_TABLE_REORG)
    ha_alter_info->handler_flags|= Alter_inplace_info::ALTER_TABLE_REORG;
  if (alter_info->flags & Alter_info::ALTER_REMOVE_PARTITIONING)
    ha_alter_info->handler_flags|= Alter_inplace_info::ALTER_REMOVE_PARTITIONING;
  if (alter_info->flags & Alter_info::ALTER_ALL_PARTITION)
    ha_alter_info->handler_flags|= Alter_inplace_info::ALTER_ALL_PARTITION;
6277 6278 6279
  /* Check for: ALTER TABLE FORCE, ALTER TABLE ENGINE and OPTIMIZE TABLE. */
  if (alter_info->flags & Alter_info::ALTER_RECREATE)
    ha_alter_info->handler_flags|= Alter_inplace_info::RECREATE_TABLE;
Sergei Golubchik's avatar
Sergei Golubchik committed
6280 6281 6282 6283
  if (alter_info->flags & Alter_info::ALTER_ADD_CHECK_CONSTRAINT)
    ha_alter_info->handler_flags|= Alter_inplace_info::ALTER_ADD_CHECK_CONSTRAINT;
  if (alter_info->flags & Alter_info::ALTER_DROP_CHECK_CONSTRAINT)
    ha_alter_info->handler_flags|= Alter_inplace_info::ALTER_DROP_CHECK_CONSTRAINT;
6284

6285
  /*
6286 6287
    If we altering table with old VARCHAR fields we will be automatically
    upgrading VARCHAR column types.
6288
  */
6289
  if (table->s->frm_version < FRM_VER_TRUE_VARCHAR && varchar)
6290
    ha_alter_info->handler_flags|=  Alter_inplace_info::ALTER_STORED_COLUMN_TYPE;
6291

unknown's avatar
unknown committed
6292
  /*
6293 6294 6295 6296 6297 6298 6299 6300 6301
    Go through fields in old version of table and detect changes to them.
    We don't want to rely solely on Alter_info flags for this since:
    a) new definition of column can be fully identical to the old one
       despite the fact that this column is mentioned in MODIFY clause.
    b) even if new column type differs from its old column from metadata
       point of view, it might be identical from storage engine point
       of view (e.g. when ENUM('a','b') is changed to ENUM('a','b',c')).
    c) flags passed to storage engine contain more detailed information
       about nature of changes than those provided from parser.
unknown's avatar
unknown committed
6302
  */
6303
  bool maybe_alter_vcol= false;
6304 6305 6306
  uint field_stored_index= 0;
  for (f_ptr= table->field; (field= *f_ptr); f_ptr++,
                               field_stored_index+= field->stored_in_db())
unknown's avatar
unknown committed
6307
  {
6308 6309 6310
    /* Clear marker for renamed or dropped field
    which we are going to set later. */
    field->flags&= ~(FIELD_IS_RENAMED | FIELD_IS_DROPPED);
unknown's avatar
unknown committed
6311

6312
    /* Use transformed info to evaluate flags for storage engine. */
6313
    uint new_field_index= 0, new_field_stored_index= 0;
6314 6315
    new_field_it.init(alter_info->create_list);
    while ((new_field= new_field_it++))
6316
    {
6317 6318 6319
      if (new_field->field == field)
        break;
      new_field_index++;
6320
      new_field_stored_index+= new_field->stored_in_db();
6321
    }
unknown's avatar
unknown committed
6322

6323
    if (new_field)
6324
    {
6325
      /* Field is not dropped. Evaluate changes bitmap for it. */
unknown's avatar
unknown committed
6326

6327 6328 6329
      /*
        Check if type of column has changed to some incompatible type.
      */
6330 6331
      uint is_equal= field->is_equal(new_field);
      switch (is_equal)
6332 6333 6334
      {
      case IS_EQUAL_NO:
        /* New column type is incompatible with old one. */
6335 6336 6337 6338 6339 6340
        if (field->stored_in_db())
          ha_alter_info->handler_flags|=
            Alter_inplace_info::ALTER_STORED_COLUMN_TYPE;
        else
          ha_alter_info->handler_flags|=
            Alter_inplace_info::ALTER_VIRTUAL_COLUMN_TYPE;
6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361
        if (table->s->tmp_table == NO_TMP_TABLE)
        {
          delete_statistics_for_column(thd, table, field);
          KEY *key_info= table->key_info; 
          for (uint i=0; i < table->s->keys; i++, key_info++)
          {
            if (field->part_of_key.is_set(i))
            {
              uint key_parts= table->actual_n_key_parts(key_info);
              for (uint j= 0; j < key_parts; j++)
              {
                if (key_info->key_part[j].fieldnr-1 == field->field_index)
                {
                  delete_statistics_for_index(thd, table, key_info,
                                       j >= key_info->user_defined_key_parts);
                  break;
                }
              }           
            }
          }      
        }
6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384
        break;
      case IS_EQUAL_YES:
        /*
          New column is the same as the old one or the fully compatible with
          it (for example, ENUM('a','b') was changed to ENUM('a','b','c')).
          Such a change if any can ALWAYS be carried out by simply updating
          data-dictionary without even informing storage engine.
          No flag is set in this case.
        */
        break;
      case IS_EQUAL_PACK_LENGTH:
        /*
          New column type differs from the old one, but has compatible packed
          data representation. Depending on storage engine, such a change can
          be carried out by simply updating data dictionary without changing
          actual data (for example, VARCHAR(300) is changed to VARCHAR(400)).
        */
        ha_alter_info->handler_flags|= Alter_inplace_info::
                                         ALTER_COLUMN_EQUAL_PACK_LENGTH;
        break;
      default:
        DBUG_ASSERT(0);
        /* Safety. */
6385 6386
        ha_alter_info->handler_flags|=
          Alter_inplace_info::ALTER_STORED_COLUMN_TYPE;
6387
      }
unknown's avatar
unknown committed
6388

6389
      if (field->vcol_info || new_field->vcol_info)
6390
      {
6391 6392 6393 6394 6395 6396
        /* base <-> virtual or stored <-> virtual */
        if (field->stored_in_db() != new_field->stored_in_db())
          ha_alter_info->handler_flags|=
                    Alter_inplace_info::ALTER_STORED_COLUMN_TYPE |
                    Alter_inplace_info::ALTER_VIRTUAL_COLUMN_TYPE;
        if (field->vcol_info && new_field->vcol_info)
6397
        {
6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409
          bool value_changes= is_equal == IS_EQUAL_NO;
          Alter_inplace_info::HA_ALTER_FLAGS alter_expr= field->stored_in_db()
                                           ? Alter_inplace_info::ALTER_STORED_GCOL_EXPR
                                           : Alter_inplace_info::ALTER_VIRTUAL_GCOL_EXPR;
          if (!field->vcol_info->is_equal(new_field->vcol_info))
          {
            ha_alter_info->handler_flags|= alter_expr;
            value_changes= true;
          }

          if ((ha_alter_info->handler_flags & Alter_inplace_info::ALTER_COLUMN_DEFAULT)
              && !(ha_alter_info->handler_flags & alter_expr))
6410
          { /*
6411 6412 6413
              a DEFAULT value of a some column was changed.  see if this vcol
              uses DEFAULT() function. The check is kind of expensive, so don't
              do it if ALTER_COLUMN_VCOL is already set.
6414 6415 6416
            */
            if (field->vcol_info->expr_item->walk(
                                 &Item::check_func_default_processor, 0, 0))
6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430
            {
              ha_alter_info->handler_flags|= alter_expr;
              value_changes= true;
            }
          }

          if (field->vcol_info->is_in_partitioning_expr() ||
              field->flags & PART_KEY_FLAG)
          {
            if (value_changes)
              ha_alter_info->handler_flags|=
                Alter_inplace_info::ALTER_COLUMN_VCOL;
            else
              maybe_alter_vcol= true;
6431 6432
          }
        }
6433 6434 6435
        else /* base <-> stored */
          ha_alter_info->handler_flags|=
            Alter_inplace_info::ALTER_STORED_COLUMN_TYPE;
6436
      }
6437

6438 6439 6440 6441
      /* Check if field was renamed */
      if (my_strcasecmp(system_charset_info, field->field_name,
                        new_field->field_name))
      {
6442
        field->flags|= FIELD_IS_RENAMED;
6443
        ha_alter_info->handler_flags|= Alter_inplace_info::ALTER_COLUMN_NAME;
6444 6445
        rename_column_in_stat_tables(thd, table, field,
                                     new_field->field_name);
6446
      }
6447

6448 6449 6450
      /* Check that NULL behavior is same for old and new fields */
      if ((new_field->flags & NOT_NULL_FLAG) !=
          (uint) (field->flags & NOT_NULL_FLAG))
6451
      {
6452 6453 6454 6455 6456 6457
        if (new_field->flags & NOT_NULL_FLAG)
          ha_alter_info->handler_flags|=
            Alter_inplace_info::ALTER_COLUMN_NOT_NULLABLE;
        else
          ha_alter_info->handler_flags|=
            Alter_inplace_info::ALTER_COLUMN_NULLABLE;
6458
      }
6459

6460 6461 6462 6463
      /*
        We do not detect changes to default values in this loop.
        See comment above for more details.
      */
6464

6465 6466 6467
      /*
        Detect changes in column order.
      */
6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479
      if (field->stored_in_db())
      {
        if (field_stored_index != new_field_stored_index)
          ha_alter_info->handler_flags|=
            Alter_inplace_info::ALTER_STORED_COLUMN_ORDER;
      }
      else
      {
        if (field->field_index != new_field_index)
          ha_alter_info->handler_flags|=
            Alter_inplace_info::ALTER_VIRTUAL_COLUMN_ORDER;
      }
6480

6481 6482 6483 6484
      /* Detect changes in storage type of column */
      if (new_field->field_storage_type() != field->field_storage_type())
        ha_alter_info->handler_flags|=
          Alter_inplace_info::ALTER_COLUMN_STORAGE_TYPE;
6485

6486 6487 6488 6489
      /* Detect changes in column format of column */
      if (new_field->column_format() != field->column_format())
        ha_alter_info->handler_flags|=
          Alter_inplace_info::ALTER_COLUMN_COLUMN_FORMAT;
6490 6491 6492 6493 6494 6495 6496 6497 6498

      if (engine_options_differ(field->option_struct, new_field->option_struct,
                                table->file->ht->field_options))
      {
        ha_alter_info->handler_flags|= Alter_inplace_info::ALTER_COLUMN_OPTION;
        ha_alter_info->create_info->fields_option_struct[f_ptr - table->field]=
          new_field->option_struct;
      }

6499
    }
6500
    else
6501
    {
6502
      // Field is not present in new version of table and therefore was dropped.
6503
      field->flags|= FIELD_IS_DROPPED;
6504 6505 6506 6507
      if (field->stored_in_db())
        ha_alter_info->handler_flags|= Alter_inplace_info::DROP_STORED_COLUMN;
      else
        ha_alter_info->handler_flags|= Alter_inplace_info::DROP_VIRTUAL_COLUMN;
6508
    }
unknown's avatar
unknown committed
6509 6510
  }

6511 6512 6513
  if (maybe_alter_vcol)
  {
    /*
6514 6515 6516 6517
      What if one of the normal columns was altered and it was part of the some
      virtual column expression?  Currently we don't detect this correctly
      (FIXME), so let's just say that a vcol *might* be affected if any other
      column was altered.
6518 6519
    */
    if (ha_alter_info->handler_flags &
6520 6521 6522 6523
                   ( Alter_inplace_info::ALTER_STORED_COLUMN_TYPE
                   | Alter_inplace_info::ALTER_VIRTUAL_COLUMN_TYPE
                   | Alter_inplace_info::ALTER_COLUMN_NOT_NULLABLE
                   | Alter_inplace_info::ALTER_COLUMN_OPTION ))
6524 6525 6526
      ha_alter_info->handler_flags|= Alter_inplace_info::ALTER_COLUMN_VCOL;
  }

6527 6528 6529 6530
  new_field_it.init(alter_info->create_list);
  while ((new_field= new_field_it++))
  {
    if (! new_field->field)
6531
    {
6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542
      // Field is not present in old version of table and therefore was added.
      if (new_field->vcol_info)
        if (new_field->stored_in_db())
          ha_alter_info->handler_flags|=
            Alter_inplace_info::ADD_STORED_GENERATED_COLUMN;
        else
          ha_alter_info->handler_flags|=
            Alter_inplace_info::ADD_VIRTUAL_COLUMN;
      else
        ha_alter_info->handler_flags|=
          Alter_inplace_info::ADD_STORED_BASE_COLUMN;
6543
    }
unknown's avatar
unknown committed
6544 6545 6546 6547 6548 6549
  }

  /*
    Go through keys and check if the original ones are compatible
    with new table.
  */
6550 6551 6552
  KEY *table_key;
  KEY *table_key_end= table->key_info + table->s->keys;
  KEY *new_key;
6553 6554
  KEY *new_key_end=
    ha_alter_info->key_info_buffer + ha_alter_info->key_count;
unknown's avatar
unknown committed
6555

6556
  DBUG_PRINT("info", ("index count old: %d  new: %d",
6557 6558
                      table->s->keys, ha_alter_info->key_count));

6559 6560 6561
  /*
    Step through all keys of the old table and search matching new keys.
  */
6562 6563
  ha_alter_info->index_drop_count= 0;
  ha_alter_info->index_add_count= 0;
6564
  for (table_key= table->key_info; table_key < table_key_end; table_key++)
unknown's avatar
unknown committed
6565
  {
6566
    /* Search a new key with the same name. */
6567 6568 6569
    for (new_key= ha_alter_info->key_info_buffer;
         new_key < new_key_end;
         new_key++)
6570 6571 6572 6573 6574 6575
    {
      if (! strcmp(table_key->name, new_key->name))
        break;
    }
    if (new_key >= new_key_end)
    {
6576 6577 6578 6579
      /* Key not found. Add the key to the drop buffer. */
      ha_alter_info->index_drop_buffer
        [ha_alter_info->index_drop_count++]=
        table_key;
6580 6581 6582 6583 6584 6585
      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) ||
6586
        ((table_key->flags & HA_KEYFLAG_MASK) !=
6587
         (new_key->flags & HA_KEYFLAG_MASK)) ||
6588 6589
        (table_key->user_defined_key_parts !=
         new_key->user_defined_key_parts))
6590
      goto index_changed;
unknown's avatar
unknown committed
6591

6592 6593 6594 6595
    if (engine_options_differ(table_key->option_struct, new_key->option_struct,
                              table->file->ht->index_options))
      goto index_changed;

unknown's avatar
unknown committed
6596 6597 6598 6599
    /*
      Check that the key parts remain compatible between the old and
      new tables.
    */
6600 6601 6602 6603
    end= table_key->key_part + table_key->user_defined_key_parts;
    for (key_part= table_key->key_part, new_part= new_key->key_part;
         key_part < end;
         key_part++, new_part++)
unknown's avatar
unknown committed
6604 6605
    {
      /*
6606 6607 6608 6609 6610
        Key definition has changed if we are using a different field or
        if the used key part length is different. It makes sense to
        check lengths first as in case when fields differ it is likely
        that lengths differ too and checking fields is more expensive
        in general case.
unknown's avatar
unknown committed
6611
      */
6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624
      if (key_part->length != new_part->length)
        goto index_changed;

      new_field= get_field_by_index(alter_info, new_part->fieldnr);

      /*
        For prefix keys KEY_PART_INFO::field points to cloned Field
        object with adjusted length. So below we have to check field
        indexes instead of simply comparing pointers to Field objects.
      */
      if (! new_field->field ||
          new_field->field->field_index != key_part->fieldnr - 1)
        goto index_changed;
unknown's avatar
unknown committed
6625
    }
6626 6627 6628 6629

    /* Check that key comment is not changed. */
    if (table_key->comment.length != new_key->comment.length ||
        (table_key->comment.length &&
6630 6631 6632
         memcmp(table_key->comment.str, new_key->comment.str,
                table_key->comment.length) != 0))
      goto index_changed;
6633

6634 6635 6636
    continue;

  index_changed:
6637 6638 6639 6640 6641 6642 6643 6644
    /* Key modified. Add the key / key offset to both buffers. */
    ha_alter_info->index_drop_buffer
      [ha_alter_info->index_drop_count++]=
      table_key;
    ha_alter_info->index_add_buffer
      [ha_alter_info->index_add_count++]=
      new_key - ha_alter_info->key_info_buffer;
    /* Mark all old fields which are used in newly created index. */
6645
    DBUG_PRINT("info", ("index changed: '%s'", table_key->name));
unknown's avatar
unknown committed
6646
  }
6647
  /*end of for (; table_key < table_key_end;) */
unknown's avatar
unknown committed
6648

6649 6650 6651
  /*
    Step through all keys of the new table and find matching old keys.
  */
6652 6653 6654
  for (new_key= ha_alter_info->key_info_buffer;
       new_key < new_key_end;
       new_key++)
6655 6656
  {
    /* Search an old key with the same name. */
6657
    for (table_key= table->key_info; table_key < table_key_end; table_key++)
6658 6659 6660 6661 6662 6663 6664
    {
      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. */
6665 6666 6667
      ha_alter_info->index_add_buffer
        [ha_alter_info->index_add_count++]=
        new_key - ha_alter_info->key_info_buffer;
unknown's avatar
unknown committed
6668
      DBUG_PRINT("info", ("index added: '%s'", new_key->name));
6669
    }
6670
    else
6671 6672
      ha_alter_info->create_info->indexes_option_struct[table_key - table->key_info]=
        new_key->option_struct;
6673
  }
6674

6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686
  /*
    Sort index_add_buffer according to how key_info_buffer is sorted.
    I.e. with primary keys first - see sort_keys().
  */
  my_qsort(ha_alter_info->index_add_buffer,
           ha_alter_info->index_add_count,
           sizeof(uint), (qsort_cmp) compare_uint);

  /* Now let us calculate flags for storage engine API. */

  /* Count all existing candidate keys. */
  for (table_key= table->key_info; table_key < table_key_end; table_key++)
6687
  {
6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698
    /*
      Check if key is a candidate key, This key is either already primary key
      or could be promoted to primary key if the original primary key is
      dropped.
      In MySQL one is allowed to create primary key with partial fields (i.e.
      primary key which is not considered candidate). For simplicity we count
      such key as a candidate key here.
    */
    if (((uint) (table_key - table->key_info) == table->s->primary_key) ||
        is_candidate_key(table_key))
      candidate_key_count++;
6699
  }
6700

6701 6702 6703 6704 6705 6706 6707
  /* Figure out what kind of indexes we are dropping. */
  KEY **dropped_key;
  KEY **dropped_key_end= ha_alter_info->index_drop_buffer +
                         ha_alter_info->index_drop_count;

  for (dropped_key= ha_alter_info->index_drop_buffer;
       dropped_key < dropped_key_end; dropped_key++)
6708
  {
6709 6710 6711 6712 6713 6714 6715 6716 6717
    table_key= *dropped_key;

    if (table_key->flags & HA_NOSAME)
    {
      /*
        Unique key. Check for PRIMARY KEY. Also see comment about primary
        and candidate keys above.
      */
      if ((uint) (table_key - table->key_info) == table->s->primary_key)
6718
      {
6719 6720 6721 6722 6723 6724 6725 6726
        ha_alter_info->handler_flags|= Alter_inplace_info::DROP_PK_INDEX;
        candidate_key_count--;
      }
      else
      {
        ha_alter_info->handler_flags|= Alter_inplace_info::DROP_UNIQUE_INDEX;
        if (is_candidate_key(table_key))
          candidate_key_count--;
6727
      }
6728
    }
6729
    else
6730
      ha_alter_info->handler_flags|= Alter_inplace_info::DROP_INDEX;
6731
  }
6732

6733 6734 6735 6736
  /* Now figure out what kind of indexes we are adding. */
  for (uint add_key_idx= 0; add_key_idx < ha_alter_info->index_add_count; add_key_idx++)
  {
    new_key= ha_alter_info->key_info_buffer + ha_alter_info->index_add_buffer[add_key_idx];
unknown's avatar
unknown committed
6737

6738
    if (new_key->flags & HA_NOSAME)
6739
    {
6740
      bool is_pk= !my_strcasecmp(system_charset_info, new_key->name, primary_key_name);
unknown's avatar
unknown committed
6741

6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756
      if ((!(new_key->flags & HA_KEY_HAS_PART_KEY_SEG) &&
           !(new_key->flags & HA_NULL_PART_KEY)) ||
          is_pk)
      {
        /* Candidate key or primary key! */
        if (candidate_key_count == 0 || is_pk)
          ha_alter_info->handler_flags|= Alter_inplace_info::ADD_PK_INDEX;
        else
          ha_alter_info->handler_flags|= Alter_inplace_info::ADD_UNIQUE_INDEX;
        candidate_key_count++;
      }
      else
      {
        ha_alter_info->handler_flags|= Alter_inplace_info::ADD_UNIQUE_INDEX;
      }
6757
    }
6758 6759
    else
      ha_alter_info->handler_flags|= Alter_inplace_info::ADD_INDEX;
6760
  }
unknown's avatar
unknown committed
6761

6762 6763
  DBUG_RETURN(false);
}
unknown's avatar
unknown committed
6764

6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855

/**
  Mark fields participating in newly added indexes in TABLE object which
  corresponds to new version of altered table.

  @param ha_alter_info  Alter_inplace_info describing in-place ALTER.
  @param altered_table  TABLE object for new version of TABLE in which
                        fields should be marked.
*/

static void update_altered_table(const Alter_inplace_info &ha_alter_info,
                                 TABLE *altered_table)
{
  uint field_idx, add_key_idx;
  KEY *key;
  KEY_PART_INFO *end, *key_part;

  /*
    Clear marker for all fields, as we are going to set it only
    for fields which participate in new indexes.
  */
  for (field_idx= 0; field_idx < altered_table->s->fields; ++field_idx)
    altered_table->field[field_idx]->flags&= ~FIELD_IN_ADD_INDEX;

  /*
    Go through array of newly added indexes and mark fields
    participating in them.
  */
  for (add_key_idx= 0; add_key_idx < ha_alter_info.index_add_count;
       add_key_idx++)
  {
    key= ha_alter_info.key_info_buffer +
         ha_alter_info.index_add_buffer[add_key_idx];

    end= key->key_part + key->user_defined_key_parts;
    for (key_part= key->key_part; key_part < end; key_part++)
      altered_table->field[key_part->fieldnr]->flags|= FIELD_IN_ADD_INDEX;
  }
}


/**
  Compare two tables to see if their metadata are compatible.
  One table specified by a TABLE instance, the other using Alter_info
  and HA_CREATE_INFO.

  @param[in]  table          The first table.
  @param[in]  alter_info     Alter options, fields and keys for the
                             second table.
  @param[in]  create_info    Create options for the second table.
  @param[out] metadata_equal Result of comparison.

  @retval true   error
  @retval false  success
*/

bool mysql_compare_tables(TABLE *table,
                          Alter_info *alter_info,
                          HA_CREATE_INFO *create_info,
                          bool *metadata_equal)
{
  DBUG_ENTER("mysql_compare_tables");

  uint changes= IS_EQUAL_NO;
  uint key_count;
  List_iterator_fast<Create_field> tmp_new_field_it;
  THD *thd= table->in_use;
  *metadata_equal= false;

  /*
    Create a copy of alter_info.
    To compare definitions, we need to "prepare" the definition - transform it
    from parser output to a format that describes the 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 mysql_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 compare the tables, and
    then destroy the copy.
  */
  Alter_info tmp_alter_info(*alter_info, thd->mem_root);
  uint db_options= 0; /* not used */
  KEY *key_info_buffer= NULL;

  /* Create the prepared information. */
  int create_table_mode= table->s->tmp_table == NO_TMP_TABLE ?
                           C_ORDINARY_CREATE : C_ALTER_TABLE;
  if (mysql_prepare_create_table(thd, create_info, &tmp_alter_info,
                                 &db_options, table->file, &key_info_buffer,
                                 &key_count, create_table_mode))
Sergei Golubchik's avatar
Sergei Golubchik committed
6856
    DBUG_RETURN(1);
6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884

  /* Some very basic checks. */
  if (table->s->fields != alter_info->create_list.elements ||
      table->s->db_type() != create_info->db_type ||
      table->s->tmp_table ||
      (table->s->row_type != create_info->row_type))
    DBUG_RETURN(false);

  /* Go through fields and check if they are compatible. */
  tmp_new_field_it.init(tmp_alter_info.create_list);
  for (Field **f_ptr= table->field; *f_ptr; f_ptr++)
  {
    Field *field= *f_ptr;
    Create_field *tmp_new_field= tmp_new_field_it++;

    /* Check that NULL behavior is the same. */
    if ((tmp_new_field->flags & NOT_NULL_FLAG) !=
	(uint) (field->flags & NOT_NULL_FLAG))
      DBUG_RETURN(false);

    /*
      mysql_prepare_alter_table() clears HA_OPTION_PACK_RECORD bit when
      preparing description of existing table. In ALTER TABLE it is later
      updated to correct value by create_table_impl() call.
      So to get correct value of this bit in this function we have to
      mimic behavior of create_table_impl().
    */
    if (create_info->row_type == ROW_TYPE_DYNAMIC ||
6885
        create_info->row_type == ROW_TYPE_PAGE ||
6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905
	(tmp_new_field->flags & BLOB_FLAG) ||
	(tmp_new_field->sql_type == MYSQL_TYPE_VARCHAR &&
	create_info->row_type != ROW_TYPE_FIXED))
      create_info->table_options|= HA_OPTION_PACK_RECORD;

    /* Check if field was renamed */
    if (my_strcasecmp(system_charset_info,
		      field->field_name,
		      tmp_new_field->field_name))
      DBUG_RETURN(false);

    /* Evaluate changes bitmap and send to check_if_incompatible_data() */
    uint field_changes= field->is_equal(tmp_new_field);
    if (field_changes != IS_EQUAL_YES)
      DBUG_RETURN(false);

    changes|= field_changes;
  }

  /* Check if changes are compatible with current handler. */
6906
  if (table->file->check_if_incompatible_data(create_info, changes))
6907 6908 6909 6910 6911 6912 6913 6914 6915 6916
    DBUG_RETURN(false);

  /* Go through keys and check if they are compatible. */
  KEY *table_key;
  KEY *table_key_end= table->key_info + table->s->keys;
  KEY *new_key;
  KEY *new_key_end= key_info_buffer + key_count;

  /* Step through all keys of the first table and search matching keys. */
  for (table_key= table->key_info; table_key < table_key_end; table_key++)
6917
  {
6918 6919 6920 6921 6922 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 6948 6949 6950 6951
    /* Search a key with the same name. */
    for (new_key= key_info_buffer; new_key < new_key_end; new_key++)
    {
      if (! strcmp(table_key->name, new_key->name))
        break;
    }
    if (new_key >= new_key_end)
      DBUG_RETURN(false);

    /* Check that the key types are compatible. */
    if ((table_key->algorithm != new_key->algorithm) ||
	((table_key->flags & HA_KEYFLAG_MASK) !=
         (new_key->flags & HA_KEYFLAG_MASK)) ||
        (table_key->user_defined_key_parts !=
         new_key->user_defined_key_parts))
      DBUG_RETURN(false);

    /* Check that the key parts remain compatible. */
    KEY_PART_INFO *table_part;
    KEY_PART_INFO *table_part_end= table_key->key_part + table_key->user_defined_key_parts;
    KEY_PART_INFO *new_part;
    for (table_part= table_key->key_part, new_part= new_key->key_part;
         table_part < table_part_end;
         table_part++, new_part++)
    {
      /*
	Key definition is different if we are using a different field or
	if the used key part length is different. We know that the fields
        are equal. Comparing field numbers is sufficient.
      */
      if ((table_part->length != new_part->length) ||
          (table_part->fieldnr - 1 != new_part->fieldnr))
        DBUG_RETURN(false);
    }
6952
  }
6953

6954 6955
  /* Step through all keys of the second table and find matching keys. */
  for (new_key= key_info_buffer; new_key < new_key_end; new_key++)
6956
  {
6957 6958 6959 6960 6961 6962 6963 6964
    /* Search a 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)
      DBUG_RETURN(false);
6965
  }
6966

6967 6968
  *metadata_equal= true; // Tables are compatible
  DBUG_RETURN(false);
unknown's avatar
unknown committed
6969 6970 6971
}


unknown's avatar
unknown committed
6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983 6984 6985 6986 6987 6988
/*
  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,
6989
                             Alter_info::enum_enable_or_disable keys_onoff)
unknown's avatar
unknown committed
6990 6991 6992 6993 6994 6995 6996
{
  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) {
6997
  case Alter_info::ENABLE:
6998
    DEBUG_SYNC(table->in_use, "alter_table_enable_indexes");
6999
    error= table->file->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
unknown's avatar
unknown committed
7000
    break;
7001
  case Alter_info::LEAVE_AS_IS:
unknown's avatar
unknown committed
7002 7003 7004
    if (!indexes_were_disabled)
      break;
    /* fall-through: disabled indexes */
7005
  case Alter_info::DISABLE:
7006
    error= table->file->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
unknown's avatar
unknown committed
7007 7008 7009 7010
  }

  if (error == HA_ERR_WRONG_COMMAND)
  {
7011 7012 7013
    THD *thd= table->in_use;
    push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
                        ER_ILLEGAL_HA, ER_THD(thd, ER_ILLEGAL_HA),
7014 7015
                        table->file->table_type(),
                        table->s->db.str, table->s->table_name.str);
unknown's avatar
unknown committed
7016
    error= 0;
7017 7018
  }
  else if (error)
unknown's avatar
unknown committed
7019 7020 7021 7022 7023
    table->file->print_error(error, MYF(0));

  DBUG_RETURN(error);
}

7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050

/**
  Check if the pending ALTER TABLE operations support the in-place
  algorithm based on restrictions in the SQL layer or given the
  nature of the operations themselves. If in-place isn't supported,
  it won't be necessary to check with the storage engine.

  @param table        The original TABLE.
  @param create_info  Information from the parsing phase about new
                      table properties.
  @param alter_info   Data related to detected changes.

  @return false       In-place is possible, check with storage engine.
  @return true        Incompatible operations, must use table copy.
*/

static bool is_inplace_alter_impossible(TABLE *table,
                                        HA_CREATE_INFO *create_info,
                                        const Alter_info *alter_info)
{
  DBUG_ENTER("is_inplace_alter_impossible");

  /* At the moment we can't handle altering temporary tables without a copy. */
  if (table->s->tmp_table)
    DBUG_RETURN(true);

  /*
7051
    For the ALTER TABLE tbl_name ORDER BY ... we always use copy
7052 7053 7054 7055 7056 7057 7058 7059 7060
    algorithm. In theory, this operation can be done in-place by some
    engine, but since a) no current engine does this and b) our current
    API lacks infrastructure for passing information about table ordering
    to storage engine we simply always do copy now.

    ENABLE/DISABLE KEYS is a MyISAM/Heap specific operation that is
    not supported for in-place in combination with other operations.
    Alone, it will be done by simple_rename_or_index_change().
  */
7061
  if (alter_info->flags & (Alter_info::ALTER_ORDER |
7062 7063 7064 7065
                           Alter_info::ALTER_KEYS_ONOFF))
    DBUG_RETURN(true);

  /*
7066 7067 7068 7069
    If the table engine is changed explicitly (using ENGINE clause)
    or implicitly (e.g. when non-partitioned table becomes
    partitioned) a regular alter table (copy) needs to be
    performed.
7070
  */
7071
  if (create_info->db_type != table->s->db_type())
7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085
    DBUG_RETURN(true);

  /*
    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.
  */
  if (!table->s->mysql_version)
    DBUG_RETURN(true);

7086 7087 7088 7089 7090 7091 7092 7093
  /*
    If we are using a MySQL 5.7 table with virtual fields, ALTER TABLE must
    recreate the table as we need to rewrite generated fields
  */
  if (table->s->mysql_version > 50700 && table->s->mysql_version < 100000 &&
      table->s->virtual_fields)
    DBUG_RETURN(TRUE);

7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136
  DBUG_RETURN(false);
}


/**
  Perform in-place alter table.

  @param thd                Thread handle.
  @param table_list         TABLE_LIST for the table to change.
  @param table              The original TABLE.
  @param altered_table      TABLE object for new version of the table.
  @param ha_alter_info      Structure describing ALTER TABLE to be carried
                            out and serving as a storage place for data
                            used during different phases.
  @param inplace_supported  Enum describing the locking requirements.
  @param target_mdl_request Metadata request/lock on the target table name.
  @param alter_ctx          ALTER TABLE runtime context.

  @retval   true              Error
  @retval   false             Success

  @note
    If mysql_alter_table does not need to copy the table, it is
    either an alter table where the storage engine does not
    need to know about the change, only the frm will change,
    or the storage engine supports performing the alter table
    operation directly, in-place without mysql having to copy
    the table.

  @note This function frees the TABLE object associated with the new version of
        the table and removes the .FRM file for it in case of both success and
        failure.
*/

static bool mysql_inplace_alter_table(THD *thd,
                                      TABLE_LIST *table_list,
                                      TABLE *table,
                                      TABLE *altered_table,
                                      Alter_inplace_info *ha_alter_info,
                                      enum_alter_inplace_result inplace_supported,
                                      MDL_request *target_mdl_request,
                                      Alter_table_ctx *alter_ctx)
{
7137
  Open_table_context ot_ctx(thd, MYSQL_OPEN_REOPEN | MYSQL_OPEN_IGNORE_KILLED);
7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 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 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254 7255 7256 7257 7258 7259 7260 7261 7262 7263 7264 7265 7266 7267 7268 7269 7270 7271 7272 7273 7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308 7309 7310 7311 7312 7313 7314 7315 7316
  handlerton *db_type= table->s->db_type();
  MDL_ticket *mdl_ticket= table->mdl_ticket;
  HA_CREATE_INFO *create_info= ha_alter_info->create_info;
  Alter_info *alter_info= ha_alter_info->alter_info;
  bool reopen_tables= false;

  DBUG_ENTER("mysql_inplace_alter_table");

  /*
    Upgrade to EXCLUSIVE lock if:
    - This is requested by the storage engine
    - Or the storage engine needs exclusive lock for just the prepare
      phase
    - Or requested by the user

    Note that we handle situation when storage engine needs exclusive
    lock for prepare phase under LOCK TABLES in the same way as when
    exclusive lock is required for duration of the whole statement.
  */
  if (inplace_supported == HA_ALTER_INPLACE_EXCLUSIVE_LOCK ||
      ((inplace_supported == HA_ALTER_INPLACE_SHARED_LOCK_AFTER_PREPARE ||
        inplace_supported == HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE) &&
       (thd->locked_tables_mode == LTM_LOCK_TABLES ||
        thd->locked_tables_mode == LTM_PRELOCKED_UNDER_LOCK_TABLES)) ||
       alter_info->requested_lock == Alter_info::ALTER_TABLE_LOCK_EXCLUSIVE)
  {
    if (wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN))
      goto cleanup;
    /*
      Get rid of all TABLE instances belonging to this thread
      except one to be used for in-place ALTER TABLE.

      This is mostly needed to satisfy InnoDB assumptions/asserts.
    */
    close_all_tables_for_name(thd, table->s,
                              alter_ctx->is_table_renamed() ?
                              HA_EXTRA_PREPARE_FOR_RENAME :
			      HA_EXTRA_NOT_USED,
                              table);
    /*
      If we are under LOCK TABLES we will need to reopen tables which we
      just have closed in case of error.
    */
    reopen_tables= true;
  }
  else if (inplace_supported == HA_ALTER_INPLACE_SHARED_LOCK_AFTER_PREPARE ||
           inplace_supported == HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE)
  {
    /*
      Storage engine has requested exclusive lock only for prepare phase
      and we are not under LOCK TABLES.
      Don't mark TABLE_SHARE as old in this case, as this won't allow opening
      of table by other threads during main phase of in-place ALTER TABLE.
    */
    if (thd->mdl_context.upgrade_shared_lock(table->mdl_ticket, MDL_EXCLUSIVE,
                                             thd->variables.lock_wait_timeout))
      goto cleanup;

    tdc_remove_table(thd, TDC_RT_REMOVE_NOT_OWN_KEEP_SHARE,
                     table->s->db.str, table->s->table_name.str,
                     false);
  }

  /*
    Upgrade to SHARED_NO_WRITE lock if:
    - The storage engine needs writes blocked for the whole duration
    - Or this is requested by the user
    Note that under LOCK TABLES, we will already have SHARED_NO_READ_WRITE.
  */
  if ((inplace_supported == HA_ALTER_INPLACE_SHARED_LOCK ||
       alter_info->requested_lock == Alter_info::ALTER_TABLE_LOCK_SHARED) &&
      thd->mdl_context.upgrade_shared_lock(table->mdl_ticket,
                                           MDL_SHARED_NO_WRITE,
                                           thd->variables.lock_wait_timeout))
  {
    goto cleanup;
  }

  // It's now safe to take the table level lock.
  if (lock_tables(thd, table_list, alter_ctx->tables_opened, 0))
    goto cleanup;

  DEBUG_SYNC(thd, "alter_table_inplace_after_lock_upgrade");
  THD_STAGE_INFO(thd, stage_alter_inplace_prepare);

  switch (inplace_supported) {
  case HA_ALTER_ERROR:
  case HA_ALTER_INPLACE_NOT_SUPPORTED:
    DBUG_ASSERT(0);
    // fall through
  case HA_ALTER_INPLACE_NO_LOCK:
  case HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE:
    switch (alter_info->requested_lock) {
    case Alter_info::ALTER_TABLE_LOCK_DEFAULT:
    case Alter_info::ALTER_TABLE_LOCK_NONE:
      ha_alter_info->online= true;
      break;
    case Alter_info::ALTER_TABLE_LOCK_SHARED:
    case Alter_info::ALTER_TABLE_LOCK_EXCLUSIVE:
      break;
    }
    break;
  case HA_ALTER_INPLACE_EXCLUSIVE_LOCK:
  case HA_ALTER_INPLACE_SHARED_LOCK_AFTER_PREPARE:
  case HA_ALTER_INPLACE_SHARED_LOCK:
    break;
  }

  if (table->file->ha_prepare_inplace_alter_table(altered_table,
                                                  ha_alter_info))
  {
    goto rollback;
  }

  /*
    Downgrade the lock if storage engine has told us that exclusive lock was
    necessary only for prepare phase (unless we are not under LOCK TABLES) and
    user has not explicitly requested exclusive lock.
  */
  if ((inplace_supported == HA_ALTER_INPLACE_SHARED_LOCK_AFTER_PREPARE ||
       inplace_supported == HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE) &&
      !(thd->locked_tables_mode == LTM_LOCK_TABLES ||
        thd->locked_tables_mode == LTM_PRELOCKED_UNDER_LOCK_TABLES) &&
      (alter_info->requested_lock != Alter_info::ALTER_TABLE_LOCK_EXCLUSIVE))
  {
    /* If storage engine or user requested shared lock downgrade to SNW. */
    if (inplace_supported == HA_ALTER_INPLACE_SHARED_LOCK_AFTER_PREPARE ||
        alter_info->requested_lock == Alter_info::ALTER_TABLE_LOCK_SHARED)
      table->mdl_ticket->downgrade_lock(MDL_SHARED_NO_WRITE);
    else
    {
      DBUG_ASSERT(inplace_supported == HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE);
      table->mdl_ticket->downgrade_lock(MDL_SHARED_UPGRADABLE);
    }
  }

  DEBUG_SYNC(thd, "alter_table_inplace_after_lock_downgrade");
  THD_STAGE_INFO(thd, stage_alter_inplace);

  if (table->file->ha_inplace_alter_table(altered_table,
                                          ha_alter_info))
  {
    goto rollback;
  }

  // Upgrade to EXCLUSIVE before commit.
  if (wait_while_table_is_used(thd, table, HA_EXTRA_PREPARE_FOR_RENAME))
    goto rollback;

  /*
    If we are killed after this point, we should ignore and continue.
    We have mostly completed the operation at this point, there should
    be no long waits left.
  */

  DBUG_EXECUTE_IF("alter_table_rollback_new_index", {
      table->file->ha_commit_inplace_alter_table(altered_table,
                                                 ha_alter_info,
                                                 false);
      my_error(ER_UNKNOWN_ERROR, MYF(0));
      goto cleanup;
    });

  DEBUG_SYNC(thd, "alter_table_inplace_before_commit");
  THD_STAGE_INFO(thd, stage_alter_inplace_commit);

  if (table->file->ha_commit_inplace_alter_table(altered_table,
                                                 ha_alter_info,
                                                 true))
  {
    goto rollback;
  }

  close_all_tables_for_name(thd, table->s,
                            alter_ctx->is_table_renamed() ?
                            HA_EXTRA_PREPARE_FOR_RENAME :
                            HA_EXTRA_NOT_USED,
                            NULL);
  table_list->table= table= NULL;
7317 7318

  thd->drop_temporary_table(altered_table, NULL, false);
7319 7320 7321 7322 7323 7324 7325 7326 7327 7328 7329 7330 7331 7332 7333 7334 7335

  /*
    Replace the old .FRM with the new .FRM, but keep the old name for now.
    Rename to the new name (if needed) will be handled separately below.
  */
  if (mysql_rename_table(db_type, alter_ctx->new_db, alter_ctx->tmp_name,
                         alter_ctx->db, alter_ctx->alias,
                         FN_FROM_IS_TMP | NO_HA_TABLE))
  {
    // Since changes were done in-place, we can't revert them.
    (void) quick_rm_table(thd, db_type,
                          alter_ctx->new_db, alter_ctx->tmp_name,
                          FN_IS_TMP | NO_HA_TABLE);
    DBUG_RETURN(true);
  }

  table_list->mdl_request.ticket= mdl_ticket;
7336
  if (open_table(thd, table_list, &ot_ctx))
7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348 7349 7350 7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380 7381
    DBUG_RETURN(true);

  /*
    Tell the handler that the changed frm is on disk and table
    has been re-opened
  */
  table_list->table->file->ha_notify_table_changed();

  /*
    We might be 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 usable for later reopening.
  */
  close_thread_table(thd, &thd->open_tables);
  table_list->table= NULL;

  // Rename altered table if requested.
  if (alter_ctx->is_table_renamed())
  {
    // Remove TABLE and TABLE_SHARE for old name from TDC.
    tdc_remove_table(thd, TDC_RT_REMOVE_ALL,
                     alter_ctx->db, alter_ctx->table_name, false);

    if (mysql_rename_table(db_type, alter_ctx->db, alter_ctx->table_name,
                           alter_ctx->new_db, alter_ctx->new_alias, 0))
    {
      /*
        If the rename fails we will still have a working table
        with the old name, but with other changes applied.
      */
      DBUG_RETURN(true);
    }
    if (Table_triggers_list::change_table_name(thd,
                                               alter_ctx->db,
                                               alter_ctx->alias,
                                               alter_ctx->table_name,
                                               alter_ctx->new_db,
                                               alter_ctx->new_alias))
    {
      /*
        If the rename of trigger files fails, try to rename the table
        back so we at least have matching table and trigger files.
      */
      (void) mysql_rename_table(db_type,
                                alter_ctx->new_db, alter_ctx->new_alias,
Sergei Golubchik's avatar
Sergei Golubchik committed
7382
                                alter_ctx->db, alter_ctx->alias, NO_FK_CHECKS);
7383 7384
      DBUG_RETURN(true);
    }
7385 7386
    rename_table_in_stat_tables(thd, alter_ctx->db,alter_ctx->alias,
                                alter_ctx->new_db, alter_ctx->new_alias);
unknown's avatar
unknown committed
7387 7388
  }

7389
  DBUG_RETURN(false);
unknown's avatar
unknown committed
7390

7391 7392 7393 7394 7395 7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406 7407
 rollback:
  table->file->ha_commit_inplace_alter_table(altered_table,
                                             ha_alter_info,
                                             false);
 cleanup:
  if (reopen_tables)
  {
    /* Close the only table instance which is still around. */
    close_all_tables_for_name(thd, table->s,
                              alter_ctx->is_table_renamed() ?
                              HA_EXTRA_PREPARE_FOR_RENAME :
                              HA_EXTRA_NOT_USED,
                              NULL);
    if (thd->locked_tables_list.reopen_tables(thd))
      thd->locked_tables_list.unlink_all_closed_tables(thd, NULL, 0);
    /* QQ; do something about metadata locks ? */
  }
7408
  thd->drop_temporary_table(altered_table, NULL, false);
7409 7410 7411 7412
  // Delete temporary .frm/.par
  (void) quick_rm_table(thd, create_info->db_type, alter_ctx->new_db,
                        alter_ctx->tmp_name, FN_IS_TMP | NO_HA_TABLE);
  DBUG_RETURN(true);
unknown's avatar
unknown committed
7413 7414
}

7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443
/**
  maximum possible length for certain blob types.

  @param[in]      type        Blob type (e.g. MYSQL_TYPE_TINY_BLOB)

  @return
    length
*/

static uint
blob_length_by_type(enum_field_types type)
{
  switch (type)
  {
  case MYSQL_TYPE_TINY_BLOB:
    return 255;
  case MYSQL_TYPE_BLOB:
    return 65535;
  case MYSQL_TYPE_MEDIUM_BLOB:
    return 16777215;
  case MYSQL_TYPE_LONG_BLOB:
    return 4294967295U;
  default:
    DBUG_ASSERT(0); // we should never go here
    return 0;
  }
}


7444 7445 7446 7447 7448 7449 7450 7451 7452 7453
/**
  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
7454
  perform ALTER TABLE via a temporary table -- i.e. in-place ALTER TABLE
7455 7456 7457 7458 7459 7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472
  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.
7473
  @param[in,out]  alter_ctx   Runtime context for ALTER TABLE.
7474 7475 7476 7477 7478 7479 7480

  @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.
7481

7482 7483 7484
  @retval TRUE   error, out of memory or a semantical error in ALTER
                 TABLE instructions
  @retval FALSE  success
7485
*/
7486

7487
bool
7488 7489
mysql_prepare_alter_table(THD *thd, TABLE *table,
                          HA_CREATE_INFO *create_info,
7490 7491
                          Alter_info *alter_info,
                          Alter_table_ctx *alter_ctx)
unknown's avatar
unknown committed
7492
{
7493
  /* New column definitions are added here */
unknown's avatar
unknown committed
7494
  List<Create_field> new_create_list;
7495 7496 7497
  /* New key definitions are added here */
  List<Key> new_key_list;
  List_iterator<Alter_drop> drop_it(alter_info->drop_list);
unknown's avatar
unknown committed
7498
  List_iterator<Create_field> def_it(alter_info->create_list);
7499 7500
  List_iterator<Alter_column> alter_it(alter_info->alter_list);
  List_iterator<Key> key_it(alter_info->key_list);
unknown's avatar
unknown committed
7501 7502 7503
  List_iterator<Create_field> find_it(new_create_list);
  List_iterator<Create_field> field_it(new_create_list);
  List<Key_part_spec> key_parts;
7504
  List<Virtual_column_info> new_constraint_list;
7505 7506
  uint db_create_options= (table->s->db_create_options
                           & ~(HA_OPTION_PACK_RECORD));
7507
  uint used_fields;
7508 7509
  KEY *key_info=table->key_info;
  bool rc= TRUE;
7510
  bool modified_primary_key= FALSE;
7511 7512
  Create_field *def;
  Field **f_ptr,*field;
7513
  DBUG_ENTER("mysql_prepare_alter_table");
7514

7515 7516 7517 7518 7519 7520 7521 7522
  /*
    Merge incompatible changes flag in case of upgrade of a table from an
    old MariaDB or MySQL version.  This ensures that we don't try to do an
    online alter table if field packing or character set changes are required.
  */
  create_info->used_fields|= table->s->incompatible_version;
  used_fields= create_info->used_fields;

7523 7524 7525 7526 7527 7528 7529 7530 7531 7532 7533
  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)
7534
  {
7535 7536 7537
    /* 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;
7538
  }
Michael Widenius's avatar
Michael Widenius committed
7539

7540 7541
  if (!(used_fields & HA_CREATE_USED_KEY_BLOCK_SIZE))
    create_info->key_block_size= table->s->key_block_size;
Michael Widenius's avatar
Michael Widenius committed
7542 7543 7544 7545 7546 7547 7548

  if (!(used_fields & HA_CREATE_USED_STATS_SAMPLE_PAGES))
    create_info->stats_sample_pages= table->s->stats_sample_pages;

  if (!(used_fields & HA_CREATE_USED_STATS_AUTO_RECALC))
    create_info->stats_auto_recalc= table->s->stats_auto_recalc;

7549 7550
  if (!(used_fields & HA_CREATE_USED_TRANSACTIONAL))
    create_info->transactional= table->s->transactional;
unknown's avatar
unknown committed
7551

7552 7553 7554
  if (!(used_fields & HA_CREATE_USED_CONNECTION))
    create_info->connect_string= table->s->connect_string;

7555
  restore_record(table, s->default_values);     // Empty record for DEFAULT
7556

7557 7558 7559 7560 7561 7562
  if ((create_info->fields_option_struct= (ha_field_option_struct**)
         thd->calloc(sizeof(void*) * table->s->fields)) == NULL ||
      (create_info->indexes_option_struct= (ha_index_option_struct**)
         thd->calloc(sizeof(void*) * table->s->keys)) == NULL)
    DBUG_RETURN(1);

7563 7564
  create_info->option_list= merge_engine_table_options(table->s->option_list,
                                        create_info->option_list, thd->mem_root);
7565

7566 7567 7568 7569 7570
  /*
    First collect all fields from table which isn't in drop_list
  */
  for (f_ptr=table->field ; (field= *f_ptr) ; f_ptr++)
  {
7571
    Alter_drop *drop;
7572
    if (field->type() == MYSQL_TYPE_VARCHAR)
7573 7574 7575 7576
      create_info->varchar= TRUE;
    /* Check if field should be dropped */
    drop_it.rewind();
    while ((drop=drop_it++))
7577
    {
7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589
      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;
      }
7590
    }
7591
    if (drop)
7592
    {
7593 7594
      if (table->s->tmp_table == NO_TMP_TABLE)
        (void) delete_statistics_for_column(thd, table, field);
7595 7596
      drop_it.remove();
      continue;
7597
    }
7598 7599 7600
    /* Check if field is changed */
    def_it.rewind();
    while ((def=def_it++))
7601
    {
7602 7603 7604
      if (def->change &&
	  !my_strcasecmp(system_charset_info,field->field_name, def->change))
	break;
7605
    }
7606 7607 7608
    if (def)
    {						// Field is changed
      def->field=field;
7609 7610 7611 7612 7613
      /*
        Add column being updated to the list of new columns.
        Note that columns with AFTER clauses are added to the end
        of the list for now. Their positions will be corrected later.
      */
7614
      new_create_list.push_back(def, thd->mem_root);
7615
      if (field->stored_in_db() != def->stored_in_db())
7616
      {
Sergei Golubchik's avatar
Sergei Golubchik committed
7617
        my_error(ER_UNSUPPORTED_ACTION_ON_VIRTUAL_COLUMN, MYF(0));
7618 7619
        goto err;
      }
7620
      if (!def->after)
unknown's avatar
unknown committed
7621
      {
7622 7623 7624 7625 7626 7627 7628
        /*
          If this ALTER TABLE doesn't have an AFTER clause for the modified
          column then remove this column from the list of columns to be
          processed. So later we can iterate over the columns remaining
          in this list and process modified columns with AFTER clause or
          add new columns.
        */
7629
	def_it.remove();
unknown's avatar
unknown committed
7630 7631
      }
    }
7632
    else
7633 7634
    {
      /*
7635 7636
        This field was not dropped and not changed, add it to the list
        for the new table.
7637
      */
7638 7639
      def= new (thd->mem_root) Create_field(thd, field, field);
      new_create_list.push_back(def, thd->mem_root);
7640 7641 7642
      alter_it.rewind();			// Change default if ALTER
      Alter_column *alter;
      while ((alter=alter_it++))
unknown's avatar
unknown committed
7643
      {
7644 7645
	if (!my_strcasecmp(system_charset_info,field->field_name, alter->name))
	  break;
unknown's avatar
unknown committed
7646
      }
7647
      if (alter)
unknown's avatar
unknown committed
7648
      {
7649
	if ((def->default_value= alter->default_value))
7650 7651 7652 7653
          def->flags&= ~NO_DEFAULT_VALUE_FLAG;
        else
          def->flags|= NO_DEFAULT_VALUE_FLAG;
	alter_it.remove();
unknown's avatar
unknown committed
7654 7655 7656
      }
    }
  }
7657 7658
  def_it.rewind();
  while ((def=def_it++))			// Add new columns
7659
  {
7660
    if (def->change && ! def->field)
7661
    {
7662 7663
      my_error(ER_BAD_FIELD_ERROR, MYF(0), def->change,
               table->s->table_name.str);
7664
      goto err;
7665
    }
unknown's avatar
unknown committed
7666 7667 7668 7669 7670 7671 7672 7673 7674
    /*
      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 ||
7675 7676
         def->sql_type == MYSQL_TYPE_DATETIME ||
         def->sql_type == MYSQL_TYPE_DATETIME2) &&
7677
         !alter_ctx->datetime_field &&
unknown's avatar
unknown committed
7678 7679 7680
         !(~def->flags & (NO_DEFAULT_VALUE_FLAG | NOT_NULL_FLAG)) &&
         thd->variables.sql_mode & MODE_NO_ZERO_DATE)
    {
7681 7682
        alter_ctx->datetime_field= def;
        alter_ctx->error_if_not_empty= TRUE;
unknown's avatar
unknown committed
7683
    }
7684
    if (!def->after)
7685
      new_create_list.push_back(def, thd->mem_root);
7686
    else
7687
    {
unknown's avatar
unknown committed
7688
      Create_field *find;
7689
      if (def->change)
7690
      {
7691 7692 7693 7694 7695 7696 7697 7698 7699 7700 7701 7702 7703 7704 7705 7706 7707 7708 7709 7710
        find_it.rewind();
        /*
          For columns being modified with AFTER clause we should first remove
          these columns from the list and then add them back at their correct
          positions.
        */
        while ((find=find_it++))
        {
          /*
            Create_fields representing changed columns are added directly
            from Alter_info::create_list to new_create_list. We can therefore
            safely use pointer equality rather than name matching here.
            This prevents removing the wrong column in case of column rename.
          */
          if (find == def)
          {
            find_it.remove();
            break;
          }
        }
7711
      }
7712
      if (def->after == first_keyword)
7713
        new_create_list.push_front(def, thd->mem_root);
7714
      else
7715
      {
7716 7717 7718 7719 7720 7721 7722 7723 7724 7725 7726 7727
        find_it.rewind();
        while ((find=find_it++))
        {
          if (!my_strcasecmp(system_charset_info, def->after, find->field_name))
            break;
        }
        if (!find)
        {
          my_error(ER_BAD_FIELD_ERROR, MYF(0), def->after, table->s->table_name.str);
          goto err;
        }
        find_it.after(def);			// Put column after this
7728 7729
      }
    }
7730
  }
7731
  if (alter_info->alter_list.elements)
7732
  {
7733
    my_error(ER_BAD_FIELD_ERROR, MYF(0),
7734
             alter_info->alter_list.head()->name, table->s->table_name.str);
unknown's avatar
unknown committed
7735
    goto err;
7736
  }
7737
  if (!new_create_list.elements)
unknown's avatar
unknown committed
7738
  {
7739 7740
    my_message(ER_CANT_REMOVE_ALL_FIELDS,
               ER_THD(thd, ER_CANT_REMOVE_ALL_FIELDS),
unknown's avatar
unknown committed
7741
               MYF(0));
unknown's avatar
unknown committed
7742
    goto err;
unknown's avatar
unknown committed
7743 7744 7745
  }

  /*
7746 7747
    Collect all keys which isn't in drop list. Add only those
    for which some fields exists.
unknown's avatar
unknown committed
7748
  */
7749
 
7750
  for (uint i=0 ; i < table->s->keys ; i++,key_info++)
unknown's avatar
unknown committed
7751
  {
7752
    char *key_name= key_info->name;
unknown's avatar
unknown committed
7753 7754 7755 7756 7757
    Alter_drop *drop;
    drop_it.rewind();
    while ((drop=drop_it++))
    {
      if (drop->type == Alter_drop::KEY &&
7758
	  !my_strcasecmp(system_charset_info,key_name, drop->name))
unknown's avatar
unknown committed
7759 7760 7761 7762
	break;
    }
    if (drop)
    {
7763
      if (table->s->tmp_table == NO_TMP_TABLE)
7764 7765 7766 7767 7768 7769 7770
      {
        (void) delete_statistics_for_index(thd, table, key_info, FALSE);
        if (i == table->s->primary_key)
	{
          KEY *tab_key_info= table->key_info;
	  for (uint j=0; j < table->s->keys; j++, tab_key_info++)
	  {
7771 7772
            if (tab_key_info->user_defined_key_parts !=
                tab_key_info->ext_key_parts)
7773 7774 7775 7776 7777
	      (void) delete_statistics_for_index(thd, table, tab_key_info,
                                                 TRUE);
	  }
	}
      }  
unknown's avatar
unknown committed
7778 7779 7780 7781 7782 7783
      drop_it.remove();
      continue;
    }

    KEY_PART_INFO *key_part= key_info->key_part;
    key_parts.empty();
7784
    bool delete_index_stat= FALSE;
7785
    for (uint j=0 ; j < key_info->user_defined_key_parts ; j++,key_part++)
unknown's avatar
unknown committed
7786 7787 7788 7789
    {
      if (!key_part->field)
	continue;				// Wrong field (from UNIREG)
      const char *key_part_name=key_part->field->field_name;
unknown's avatar
unknown committed
7790
      Create_field *cfield;
7791 7792
      uint key_part_length;

unknown's avatar
unknown committed
7793 7794 7795 7796 7797
      field_it.rewind();
      while ((cfield=field_it++))
      {
	if (cfield->change)
	{
unknown's avatar
unknown committed
7798 7799
	  if (!my_strcasecmp(system_charset_info, key_part_name,
			     cfield->change))
unknown's avatar
unknown committed
7800 7801
	    break;
	}
7802
	else if (!my_strcasecmp(system_charset_info,
7803
				key_part_name, cfield->field_name))
unknown's avatar
unknown committed
7804
	  break;
unknown's avatar
unknown committed
7805 7806
      }
      if (!cfield)
7807
      {
7808 7809
        if (table->s->primary_key == i)
          modified_primary_key= TRUE;
7810
        delete_index_stat= TRUE;
unknown's avatar
unknown committed
7811
	continue;				// Field is removed
7812
      }
7813
      key_part_length= key_part->length;
unknown's avatar
unknown committed
7814
      if (cfield->field)			// Not new field
7815 7816 7817 7818 7819 7820 7821
      {
        /*
          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.

7822 7823 7824
          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.

7825 7826
          BLOBs may have cfield->length == 0, which is why we test it before
          checking whether cfield->length < key_part_length (in chars).
7827 7828 7829 7830 7831 7832 7833 7834
          
          In case of TEXTs we check the data type maximum length *in bytes*
          to key part length measured *in characters* (i.e. key_part_length
          devided to mbmaxlen). This is because it's OK to have:
          CREATE TABLE t1 (a tinytext, key(a(254)) character set utf8);
          In case of this example:
          - data type maximum length is 255.
          - key_part_length is 1016 (=254*4, where 4 is mbmaxlen)
7835 7836
         */
        if (!Field::type_can_have_key_part(cfield->field->type()) ||
unknown's avatar
unknown committed
7837
            !Field::type_can_have_key_part(cfield->sql_type) ||
unknown's avatar
unknown committed
7838 7839
            /* spatial keys can't have sub-key length */
            (key_info->flags & HA_SPATIAL) ||
unknown's avatar
unknown committed
7840 7841
            (cfield->field->field_length == key_part_length &&
             !f_is_blob(key_part->key_type)) ||
7842 7843 7844 7845 7846
            (cfield->length && (((cfield->sql_type >= MYSQL_TYPE_TINY_BLOB &&
                                  cfield->sql_type <= MYSQL_TYPE_BLOB) ? 
                                blob_length_by_type(cfield->sql_type) :
                                cfield->length) <
	     key_part_length / key_part->field->charset()->mbmaxlen)))
7847
	  key_part_length= 0;			// Use whole field
unknown's avatar
unknown committed
7848
      }
7849
      key_part_length /= key_part->field->charset()->mbmaxlen;
unknown's avatar
unknown committed
7850
      key_parts.push_back(new Key_part_spec(cfield->field_name,
7851
                                            strlen(cfield->field_name),
7852 7853
					    key_part_length),
                          thd->mem_root);
unknown's avatar
unknown committed
7854
    }
7855 7856 7857 7858 7859
    if (table->s->tmp_table == NO_TMP_TABLE)
    {
      if (delete_index_stat) 
        (void) delete_statistics_for_index(thd, table, key_info, FALSE);
      else if (modified_primary_key &&
7860
               key_info->user_defined_key_parts != key_info->ext_key_parts)
7861 7862 7863
        (void) delete_statistics_for_index(thd, table, key_info, TRUE);
    }

unknown's avatar
unknown committed
7864
    if (key_parts.elements)
7865 7866
    {
      KEY_CREATE_INFO key_create_info;
7867 7868
      Key *key;
      enum Key::Keytype key_type;
7869 7870 7871 7872 7873 7874
      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)
7875
        key_create_info.parser_name= *plugin_name(key_info->parser);
7876 7877
      if (key_info->flags & HA_USES_COMMENT)
        key_create_info.comment= key_info->comment;
7878

7879 7880 7881 7882 7883 7884
      /*
        We're refreshing an already existing index. Since the index is not
        modified, there is no need to check for duplicate indexes again.
      */
      key_create_info.check_for_duplicate_indexes= false;

7885 7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896 7897 7898
      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;

7899
      key= new Key(key_type, key_name, strlen(key_name),
7900
                   &key_create_info,
7901
                   MY_TEST(key_info->flags & HA_GENERATED_KEY),
7902
                   key_parts, key_info->option_list, DDL_options());
7903
      new_key_list.push_back(key, thd->mem_root);
7904 7905 7906 7907 7908 7909
    }
  }
  {
    Key *key;
    while ((key=key_it++))			// Add new keys
    {
7910 7911 7912
      if (key->type == Key::FOREIGN_KEY &&
          ((Foreign_key *)key)->validate(new_create_list))
        goto err;
7913
      new_key_list.push_back(key, thd->mem_root);
7914 7915
      if (key->name.str &&
	  !my_strcasecmp(system_charset_info, key->name.str, primary_key_name))
7916
      {
7917
	my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name.str);
7918 7919 7920 7921 7922
        goto err;
      }
    }
  }

7923 7924 7925 7926 7927 7928 7929 7930 7931 7932 7933 7934 7935
  /* Add all table level constraints which are not in the drop list */
  if (table->s->table_check_constraints)
  {
    TABLE_SHARE *share= table->s;

    for (uint i= share->field_check_constraints;
         i < share->table_check_constraints ; i++)
    {
      Virtual_column_info *check= table->check_constraints[i];
      Alter_drop *drop;
      drop_it.rewind();
      while ((drop=drop_it++))
      {
Sergei Golubchik's avatar
Sergei Golubchik committed
7936
        if (drop->type == Alter_drop::CHECK_CONSTRAINT &&
7937 7938 7939 7940 7941 7942 7943 7944 7945 7946 7947
            !my_strcasecmp(system_charset_info, check->name.str, drop->name))
        {
          drop_it.remove();
          break;
        }
      }
      if (!drop)
        new_constraint_list.push_back(check, thd->mem_root);
    }
  }
  /* Add new constraints */
Sergei Golubchik's avatar
Sergei Golubchik committed
7948
  new_constraint_list.append(&alter_info->check_constraint_list);
7949

7950 7951
  if (alter_info->drop_list.elements)
  {
7952 7953 7954 7955 7956 7957
    Alter_drop *drop;
    drop_it.rewind();
    while ((drop=drop_it++)) {
      switch (drop->type) {
      case Alter_drop::KEY:
      case Alter_drop::COLUMN:
Sergei Golubchik's avatar
Sergei Golubchik committed
7958
      case Alter_drop::CHECK_CONSTRAINT:
7959
          my_error(ER_CANT_DROP_FIELD_OR_KEY, MYF(0), drop->type_name(),
7960
                   alter_info->drop_list.head()->name);
7961 7962 7963 7964 7965 7966
        goto err;
      case Alter_drop::FOREIGN_KEY:
        // Leave the DROP FOREIGN KEY names in the alter_info->drop_list.
        break;
      }
    }
7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979
  }

  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);
Michael Widenius's avatar
Michael Widenius committed
7980 7981 7982 7983 7984
  if ((create_info->table_options &
       (HA_OPTION_STATS_PERSISTENT | HA_OPTION_NO_STATS_PERSISTENT)) ||
      (used_fields & HA_CREATE_USED_STATS_PERSISTENT))
    db_create_options&= ~(HA_OPTION_STATS_PERSISTENT | HA_OPTION_NO_STATS_PERSISTENT);

7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997 7998 7999
  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);
Sergei Golubchik's avatar
Sergei Golubchik committed
8000
  alter_info->check_constraint_list.swap(new_constraint_list);
8001 8002 8003 8004 8005
err:
  DBUG_RETURN(rc);
}


8006 8007 8008
/**
  Get Create_field object for newly created table by its name
  in the old version of table.
8009

8010 8011
  @param alter_info  Alter_info describing newly created table.
  @param old_name    Name of field in old table.
8012

8013 8014
  @returns Pointer to Create_field object, NULL - if field is
           not present in new version of table.
8015 8016
*/

8017 8018
static Create_field *get_field_by_old_name(Alter_info *alter_info,
                                           const char *old_name)
8019
{
8020 8021
  List_iterator_fast<Create_field> new_field_it(alter_info->create_list);
  Create_field *new_field;
unknown's avatar
unknown committed
8022

8023
  while ((new_field= new_field_it++))
8024
  {
8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047 8048 8049 8050 8051 8052 8053 8054 8055 8056 8057 8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071
    if (new_field->field &&
        (my_strcasecmp(system_charset_info,
                       new_field->field->field_name,
                       old_name) == 0))
      break;
  }
  return new_field;
}


/** Type of change to foreign key column, */

enum fk_column_change_type
{
  FK_COLUMN_NO_CHANGE, FK_COLUMN_DATA_CHANGE,
  FK_COLUMN_RENAMED, FK_COLUMN_DROPPED
};

/**
  Check that ALTER TABLE's changes on columns of a foreign key are allowed.

  @param[in]   thd              Thread context.
  @param[in]   alter_info       Alter_info describing changes to be done
                                by ALTER TABLE.
  @param[in]   fk_columns       List of columns of the foreign key to check.
  @param[out]  bad_column_name  Name of field on which ALTER TABLE tries to
                                do prohibited operation.

  @note This function takes into account value of @@foreign_key_checks
        setting.

  @retval FK_COLUMN_NO_CHANGE    No significant changes are to be done on
                                 foreign key columns.
  @retval FK_COLUMN_DATA_CHANGE  ALTER TABLE might result in value
                                 change in foreign key column (and
                                 foreign_key_checks is on).
  @retval FK_COLUMN_RENAMED      Foreign key column is renamed.
  @retval FK_COLUMN_DROPPED      Foreign key column is dropped.
*/

static enum fk_column_change_type
fk_check_column_changes(THD *thd, Alter_info *alter_info,
                        List<LEX_STRING> &fk_columns,
                        const char **bad_column_name)
{
  List_iterator_fast<LEX_STRING> column_it(fk_columns);
  LEX_STRING *column;
8072

8073
  *bad_column_name= NULL;
8074

8075 8076 8077 8078 8079
  while ((column= column_it++))
  {
    Create_field *new_field= get_field_by_old_name(alter_info, column->str);

    if (new_field)
8080
    {
8081
      Field *old_field= new_field->field;
8082

8083 8084
      if (my_strcasecmp(system_charset_info, old_field->field_name,
                        new_field->field_name))
8085
      {
8086 8087 8088 8089 8090 8091 8092 8093
        /*
          Copy algorithm doesn't support proper renaming of columns in
          the foreign key yet. At the moment we lack API which will tell
          SE that foreign keys should be updated to use new name of column
          like it happens in case of in-place algorithm.
        */
        *bad_column_name= column->str;
        return FK_COLUMN_RENAMED;
8094 8095
      }

8096 8097 8098
      if ((old_field->is_equal(new_field) == IS_EQUAL_NO) ||
          ((new_field->flags & NOT_NULL_FLAG) &&
           !(old_field->flags & NOT_NULL_FLAG)))
8099
      {
8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110
        if (!(thd->variables.option_bits & OPTION_NO_FOREIGN_KEY_CHECKS))
        {
          /*
            Column in a FK has changed significantly. Unless
            foreign_key_checks are off we prohibit this since this
            means values in this column might be changed by ALTER
            and thus referential integrity might be broken,
          */
          *bad_column_name= column->str;
          return FK_COLUMN_DATA_CHANGE;
        }
8111
      }
8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125
    }
    else
    {
      /*
        Column in FK was dropped. Most likely this will break
        integrity constraints of InnoDB data-dictionary (and thus
        InnoDB will emit an error), so we prohibit this right away
        even if foreign_key_checks are off.
        This also includes a rare case when another field replaces
        field being dropped since it is easy to break referential
        integrity in this case.
      */
      *bad_column_name= column->str;
      return FK_COLUMN_DROPPED;
8126 8127 8128
    }
  }

8129 8130
  return FK_COLUMN_NO_CHANGE;
}
8131

Konstantin Osipov's avatar
Konstantin Osipov committed
8132

8133 8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146 8147 8148 8149 8150 8151 8152 8153 8154 8155
/**
  Check if ALTER TABLE we are about to execute using COPY algorithm
  is not supported as it might break referential integrity.

  @note If foreign_key_checks is disabled (=0), we allow to break
        referential integrity. But we still disallow some operations
        like dropping or renaming columns in foreign key since they
        are likely to break consistency of InnoDB data-dictionary
        and thus will end-up in error anyway.

  @param[in]  thd          Thread context.
  @param[in]  table        Table to be altered.
  @param[in]  alter_info   Lists of fields, keys to be changed, added
                           or dropped.
  @param[out] alter_ctx    ALTER TABLE runtime context.
                           Alter_table_ctx::fk_error_if_delete flag
                           is set if deletion during alter can break
                           foreign key integrity.

  @retval false  Success.
  @retval true   Error, ALTER - tries to do change which is not compatible
                 with foreign key definitions on the table.
*/
Konstantin Osipov's avatar
Konstantin Osipov committed
8156

8157 8158 8159 8160 8161 8162 8163
static bool fk_prepare_copy_alter_table(THD *thd, TABLE *table,
                                        Alter_info *alter_info,
                                        Alter_table_ctx *alter_ctx)
{
  List <FOREIGN_KEY_INFO> fk_parent_key_list;
  List <FOREIGN_KEY_INFO> fk_child_key_list;
  FOREIGN_KEY_INFO *f_key;
Konstantin Osipov's avatar
Konstantin Osipov committed
8164

8165
  DBUG_ENTER("fk_prepare_copy_alter_table");
Konstantin Osipov's avatar
Konstantin Osipov committed
8166

8167
  table->file->get_parent_foreign_key_list(thd, &fk_parent_key_list);
Konstantin Osipov's avatar
Konstantin Osipov committed
8168

8169 8170 8171
  /* OOM when building list. */
  if (thd->is_error())
    DBUG_RETURN(true);
unknown's avatar
unknown committed
8172

8173
  /*
8174 8175 8176
    Remove from the list all foreign keys in which table participates as
    parent which are to be dropped by this ALTER TABLE. This is possible
    when a foreign key has the same table as child and parent.
8177
  */
8178
  List_iterator<FOREIGN_KEY_INFO> fk_parent_key_it(fk_parent_key_list);
8179

8180
  while ((f_key= fk_parent_key_it++))
unknown's avatar
unknown committed
8181
  {
8182 8183 8184 8185
    Alter_drop *drop;
    List_iterator_fast<Alter_drop> drop_it(alter_info->drop_list);

    while ((drop= drop_it++))
8186 8187
    {
      /*
8188 8189 8190 8191 8192
        InnoDB treats foreign key names in case-insensitive fashion.
        So we do it here too. For database and table name type of
        comparison used depends on lower-case-table-names setting.
        For l_c_t_n = 0 we use case-sensitive comparison, for
        l_c_t_n > 0 modes case-insensitive comparison is used.
8193
      */
8194 8195 8196 8197 8198 8199 8200 8201
      if ((drop->type == Alter_drop::FOREIGN_KEY) &&
          (my_strcasecmp(system_charset_info, f_key->foreign_id->str,
                         drop->name) == 0) &&
          (my_strcasecmp(table_alias_charset, f_key->foreign_db->str,
                         table->s->db.str) == 0) &&
          (my_strcasecmp(table_alias_charset, f_key->foreign_table->str,
                         table->s->table_name.str) == 0))
        fk_parent_key_it.remove();
8202
    }
8203
  }
8204

8205 8206 8207 8208 8209 8210 8211 8212 8213
  /*
    If there are FKs in which this table is parent which were not
    dropped we need to prevent ALTER deleting rows from the table,
    as it might break referential integrity. OTOH it is OK to do
    so if foreign_key_checks are disabled.
  */
  if (!fk_parent_key_list.is_empty() &&
      !(thd->variables.option_bits & OPTION_NO_FOREIGN_KEY_CHECKS))
    alter_ctx->set_fk_error_if_delete_row(fk_parent_key_list.head());
8214

8215 8216 8217 8218 8219
  fk_parent_key_it.rewind();
  while ((f_key= fk_parent_key_it++))
  {
    enum fk_column_change_type changes;
    const char *bad_column_name;
8220

8221 8222 8223
    changes= fk_check_column_changes(thd, alter_info,
                                     f_key->referenced_fields,
                                     &bad_column_name);
8224

8225 8226 8227 8228 8229 8230 8231 8232 8233 8234 8235 8236 8237
    switch(changes)
    {
    case FK_COLUMN_NO_CHANGE:
      /* No significant changes. We can proceed with ALTER! */
      break;
    case FK_COLUMN_DATA_CHANGE:
    {
      char buff[NAME_LEN*2+2];
      strxnmov(buff, sizeof(buff)-1, f_key->foreign_db->str, ".",
               f_key->foreign_table->str, NullS);
      my_error(ER_FK_COLUMN_CANNOT_CHANGE_CHILD, MYF(0), bad_column_name,
               f_key->foreign_id->str, buff);
      DBUG_RETURN(true);
unknown's avatar
unknown committed
8238
    }
8239 8240 8241
    case FK_COLUMN_RENAMED:
      my_error(ER_ALTER_OPERATION_NOT_SUPPORTED_REASON, MYF(0),
               "ALGORITHM=COPY",
8242
               ER_THD(thd, ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME),
8243 8244 8245
               "ALGORITHM=INPLACE");
      DBUG_RETURN(true);
    case FK_COLUMN_DROPPED:
8246
    {
8247 8248 8249 8250 8251 8252
      StringBuffer<NAME_LEN*2+2> buff(system_charset_info);
      LEX_STRING *db= f_key->foreign_db, *tbl= f_key->foreign_table;

      append_identifier(thd, &buff, db->str, db->length);
      buff.append('.');
      append_identifier(thd, &buff, tbl->str,tbl->length);
8253
      my_error(ER_FK_COLUMN_CANNOT_DROP_CHILD, MYF(0), bad_column_name,
8254
               f_key->foreign_id->str, buff.c_ptr());
8255 8256 8257 8258
      DBUG_RETURN(true);
    }
    default:
      DBUG_ASSERT(0);
8259 8260
    }
  }
unknown's avatar
unknown committed
8261

8262
  table->file->get_foreign_key_list(thd, &fk_child_key_list);
8263

8264 8265 8266
  /* OOM when building list. */
  if (thd->is_error())
    DBUG_RETURN(true);
unknown's avatar
unknown committed
8267

8268
  /*
8269 8270
    Remove from the list all foreign keys which are to be dropped
    by this ALTER TABLE.
8271
  */
8272
  List_iterator<FOREIGN_KEY_INFO> fk_key_it(fk_child_key_list);
unknown's avatar
unknown committed
8273

8274
  while ((f_key= fk_key_it++))
8275
  {
8276 8277
    Alter_drop *drop;
    List_iterator_fast<Alter_drop> drop_it(alter_info->drop_list);
8278

8279 8280 8281 8282 8283 8284 8285 8286
    while ((drop= drop_it++))
    {
      /* Names of foreign keys in InnoDB are case-insensitive. */
      if ((drop->type == Alter_drop::FOREIGN_KEY) &&
          (my_strcasecmp(system_charset_info, f_key->foreign_id->str,
                         drop->name) == 0))
        fk_key_it.remove();
    }
8287
  }
8288

8289 8290
  fk_key_it.rewind();
  while ((f_key= fk_key_it++))
unknown's avatar
unknown committed
8291
  {
8292 8293 8294 8295 8296 8297 8298 8299
    enum fk_column_change_type changes;
    const char *bad_column_name;

    changes= fk_check_column_changes(thd, alter_info,
                                     f_key->foreign_fields,
                                     &bad_column_name);

    switch(changes)
8300
    {
8301 8302 8303 8304 8305 8306 8307 8308 8309 8310
    case FK_COLUMN_NO_CHANGE:
      /* No significant changes. We can proceed with ALTER! */
      break;
    case FK_COLUMN_DATA_CHANGE:
      my_error(ER_FK_COLUMN_CANNOT_CHANGE, MYF(0), bad_column_name,
               f_key->foreign_id->str);
      DBUG_RETURN(true);
    case FK_COLUMN_RENAMED:
      my_error(ER_ALTER_OPERATION_NOT_SUPPORTED_REASON, MYF(0),
               "ALGORITHM=COPY",
8311
               ER_THD(thd, ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME),
8312 8313 8314 8315 8316 8317 8318 8319
               "ALGORITHM=INPLACE");
      DBUG_RETURN(true);
    case FK_COLUMN_DROPPED:
      my_error(ER_FK_COLUMN_CANNOT_DROP, MYF(0), bad_column_name,
               f_key->foreign_id->str);
      DBUG_RETURN(true);
    default:
      DBUG_ASSERT(0);
8320
    }
8321
  }
8322

8323 8324
  DBUG_RETURN(false);
}
8325

8326 8327 8328 8329 8330 8331 8332 8333 8334 8335 8336 8337 8338 8339 8340 8341 8342 8343 8344 8345 8346 8347 8348 8349 8350 8351 8352 8353 8354 8355 8356 8357 8358 8359 8360 8361 8362 8363 8364 8365 8366 8367 8368 8369 8370 8371 8372 8373 8374 8375 8376 8377 8378 8379 8380 8381 8382 8383 8384 8385 8386 8387 8388 8389 8390 8391
/**
  Rename temporary table and/or turn indexes on/off without touching .FRM.
  Its a variant of simple_rename_or_index_change() to be used exclusively
  for temporary tables.

  @param thd            Thread handler
  @param table_list     TABLE_LIST for the table to change
  @param keys_onoff     ENABLE or DISABLE KEYS?
  @param alter_ctx      ALTER TABLE runtime context.

  @return Operation status
    @retval false           Success
    @retval true            Failure
*/
static bool
simple_tmp_rename_or_index_change(THD *thd, TABLE_LIST *table_list,
                                  Alter_info::enum_enable_or_disable keys_onoff,
                                  Alter_table_ctx *alter_ctx)
{
  DBUG_ENTER("simple_tmp_rename_or_index_change");

  TABLE *table= table_list->table;
  bool error= false;

  DBUG_ASSERT(table->s->tmp_table);

  if (keys_onoff != Alter_info::LEAVE_AS_IS)
  {
    THD_STAGE_INFO(thd, stage_manage_keys);
    error= alter_table_manage_keys(table, table->file->indexes_are_disabled(),
                                   keys_onoff);
  }

  if (!error && alter_ctx->is_table_renamed())
  {
    THD_STAGE_INFO(thd, stage_rename);

    /*
      If THD::rename_temporary_table() fails, there is no need to rename it
      back to the original name (unlike the case for non-temporary tables),
      as it was an allocation error and the table was not renamed.
    */
    error= thd->rename_temporary_table(table, alter_ctx->new_db,
                                       alter_ctx->new_alias);
  }

  if (!error)
  {
    int res= 0;
    /*
      We do not replicate alter table statement on temporary tables under
      ROW-based replication.
    */
    if (!thd->is_current_stmt_binlog_format_row())
    {
      res= write_bin_log(thd, true, thd->query(), thd->query_length());
    }
    if (res != 0)
      error= true;
    else
      my_ok(thd);
  }

  DBUG_RETURN(error);
}

8392

8393 8394 8395 8396 8397 8398 8399 8400 8401 8402 8403 8404 8405 8406 8407 8408 8409 8410 8411 8412 8413
/**
  Rename table and/or turn indexes on/off without touching .FRM

  @param thd            Thread handler
  @param table_list     TABLE_LIST for the table to change
  @param keys_onoff     ENABLE or DISABLE KEYS?
  @param alter_ctx      ALTER TABLE runtime context.

  @return Operation status
    @retval false           Success
    @retval true            Failure
*/

static bool
simple_rename_or_index_change(THD *thd, TABLE_LIST *table_list,
                              Alter_info::enum_enable_or_disable keys_onoff,
                              Alter_table_ctx *alter_ctx)
{
  TABLE *table= table_list->table;
  MDL_ticket *mdl_ticket= table->mdl_ticket;
  int error= 0;
8414 8415 8416
  enum ha_extra_function extra_func= thd->locked_tables_mode
                                       ? HA_EXTRA_NOT_USED
                                       : HA_EXTRA_FORCE_REOPEN;
8417 8418 8419 8420
  DBUG_ENTER("simple_rename_or_index_change");

  if (keys_onoff != Alter_info::LEAVE_AS_IS)
  {
8421
    if (wait_while_table_is_used(thd, table, extra_func))
8422 8423 8424 8425 8426 8427
      DBUG_RETURN(true);

    // It's now safe to take the table level lock.
    if (lock_tables(thd, table_list, alter_ctx->tables_opened, 0))
      DBUG_RETURN(true);

8428
    THD_STAGE_INFO(thd, stage_manage_keys);
8429 8430 8431
    error= alter_table_manage_keys(table,
                                   table->file->indexes_are_disabled(),
                                   keys_onoff);
8432
  }
8433

8434 8435 8436 8437 8438 8439 8440 8441 8442 8443 8444 8445
  if (!error && alter_ctx->is_table_renamed())
  {
    THD_STAGE_INFO(thd, stage_rename);
    handlerton *old_db_type= table->s->db_type();
    /*
      Then do a 'simple' rename of the table. First we need to close all
      instances of 'source' table.
      Note that if wait_while_table_is_used() returns error here (i.e. if
      this thread was killed) then it must be that previous step of
      simple rename did nothing and therefore we can safely return
      without additional clean-up.
    */
8446
    if (wait_while_table_is_used(thd, table, extra_func))
8447 8448 8449 8450 8451 8452 8453 8454 8455 8456 8457 8458 8459 8460 8461 8462 8463 8464 8465 8466 8467 8468 8469 8470
      DBUG_RETURN(true);
    close_all_tables_for_name(thd, table->s, HA_EXTRA_PREPARE_FOR_RENAME, NULL);

    LEX_STRING old_db_name= { alter_ctx->db, strlen(alter_ctx->db) };
    LEX_STRING old_table_name=
               { alter_ctx->table_name, strlen(alter_ctx->table_name) };
    LEX_STRING new_db_name= { alter_ctx->new_db, strlen(alter_ctx->new_db) };
    LEX_STRING new_table_name=
               { alter_ctx->new_alias, strlen(alter_ctx->new_alias) };
    (void) rename_table_in_stat_tables(thd, &old_db_name, &old_table_name,
                                       &new_db_name, &new_table_name);

    if (mysql_rename_table(old_db_type, alter_ctx->db, alter_ctx->table_name,
                           alter_ctx->new_db, alter_ctx->new_alias, 0))
      error= -1;
    else if (Table_triggers_list::change_table_name(thd,
                                                    alter_ctx->db,
                                                    alter_ctx->alias,
                                                    alter_ctx->table_name,
                                                    alter_ctx->new_db,
                                                    alter_ctx->new_alias))
    {
      (void) mysql_rename_table(old_db_type,
                                alter_ctx->new_db, alter_ctx->new_alias,
Sergei Golubchik's avatar
Sergei Golubchik committed
8471 8472
                                alter_ctx->db, alter_ctx->table_name,
                                NO_FK_CHECKS);
8473
      error= -1;
8474
    }
unknown's avatar
unknown committed
8475 8476
  }

8477 8478 8479
  if (!error)
  {
    error= write_bin_log(thd, TRUE, thd->query(), thd->query_length());
8480

8481 8482 8483 8484 8485
    if (!error)
      my_ok(thd);
  }
  table_list->table= NULL;                    // For query cache
  query_cache_invalidate3(thd, table_list, 0);
8486

8487 8488
  if ((thd->locked_tables_mode == LTM_LOCK_TABLES ||
       thd->locked_tables_mode == LTM_PRELOCKED_UNDER_LOCK_TABLES))
8489
  {
8490 8491 8492 8493 8494 8495 8496 8497 8498
    /*
      Under LOCK TABLES we should adjust meta-data locks before finishing
      statement. Otherwise we can rely on them being released
      along with the implicit commit.
    */
    if (alter_ctx->is_table_renamed())
      thd->mdl_context.release_all_locks_for_name(mdl_ticket);
    else
      mdl_ticket->downgrade_lock(MDL_SHARED_NO_READ_WRITE);
8499
  }
8500 8501
  DBUG_RETURN(error != 0);
}
8502

8503 8504 8505 8506 8507 8508 8509 8510 8511 8512 8513 8514 8515 8516 8517 8518 8519 8520 8521 8522 8523 8524 8525 8526 8527 8528 8529 8530 8531 8532 8533 8534 8535 8536 8537 8538 8539

/**
  Alter table

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

  @retval   true          Error
  @retval   false         Success

  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.

  Altering a table can be done in two ways. The table can be modified
  directly using an in-place algorithm, or the changes can be done using
  an intermediate temporary table (copy). In-place is the preferred
  algorithm as it avoids copying table data. The storage engine
  selects which algorithm to use in check_if_supported_inplace_alter()
  based on information about the table changes from fill_alter_inplace_info().
8540 8541 8542 8543 8544 8545
*/

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,
8546
                       uint order_num, ORDER *order, bool ignore)
8547
{
unknown's avatar
unknown committed
8548 8549
  DBUG_ENTER("mysql_alter_table");

8550 8551 8552 8553 8554 8555
  /*
    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.
  */
8556
  int table_kind= check_if_log_table(table_list, FALSE, NullS);
8557

8558 8559 8560 8561
  if (table_kind)
  {
    /* Disable alter of enabled log tables */
    if (logger.is_log_table_enabled(table_kind))
8562
    {
8563 8564 8565
      my_error(ER_BAD_LOG_STATEMENT, MYF(0), "ALTER");
      DBUG_RETURN(true);
    }
8566

8567 8568 8569 8570 8571 8572 8573 8574 8575
    /* 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),
               hton_name(create_info->db_type)->str);
      DBUG_RETURN(true);
    }
unknown's avatar
unknown committed
8576

8577
#ifdef WITH_PARTITION_STORAGE_ENGINE
8578 8579 8580 8581
    if (alter_info->flags & Alter_info::ALTER_PARTITION)
    {
      my_error(ER_WRONG_USAGE, MYF(0), "PARTITION", "log table");
      DBUG_RETURN(true);
8582
    }
8583
#endif
8584 8585
  }

Sergei Golubchik's avatar
Sergei Golubchik committed
8586
  THD_STAGE_INFO(thd, stage_init);
Konstantin Osipov's avatar
Konstantin Osipov committed
8587

8588
  /*
Konstantin Osipov's avatar
Konstantin Osipov committed
8589 8590 8591
    Code below can handle only base tables so ensure that we won't open a view.
    Note that RENAME TABLE the only ALTER clause which is supported for views
    has been already processed.
8592
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
8593
  table_list->required_type= FRMTYPE_TABLE;
unknown's avatar
unknown committed
8594

8595
  Alter_table_prelocking_strategy alter_prelocking_strategy;
8596

8597
  DEBUG_SYNC(thd, "alter_table_before_open_tables");
8598
  uint tables_opened;
8599 8600

  thd->open_options|= HA_OPEN_FOR_ALTER;
8601 8602
  bool error= open_tables(thd, &table_list, &tables_opened, 0,
                          &alter_prelocking_strategy);
8603
  thd->open_options&= ~HA_OPEN_FOR_ALTER;
8604

8605
  DEBUG_SYNC(thd, "alter_opened_table");
unknown's avatar
unknown committed
8606

8607 8608 8609 8610 8611 8612 8613 8614 8615 8616 8617
#ifdef WITH_WSREP
  DBUG_EXECUTE_IF("sync.alter_opened_table",
                  {
                    const char act[]=
                      "now "
                      "wait_for signal.alter_opened_table";
                    DBUG_ASSERT(!debug_sync_set_action(thd,
                                                       STRING_WITH_LEN(act)));
                  };);
#endif // WITH_WSREP

Konstantin Osipov's avatar
Konstantin Osipov committed
8618
  if (error)
8619
    DBUG_RETURN(true);
unknown's avatar
unknown committed
8620

8621
  TABLE *table= table_list->table;
8622
  table->use_all_columns();
8623
  MDL_ticket *mdl_ticket= table->mdl_ticket;
8624 8625

  /*
8626 8627 8628 8629
    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.
8630
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
8631 8632
  if ((thd->locked_tables_mode == LTM_LOCK_TABLES ||
       thd->locked_tables_mode == LTM_PRELOCKED_UNDER_LOCK_TABLES) &&
8633 8634 8635 8636
      (create_info->used_fields & HA_CREATE_USED_UNION) &&
      (table->s->tmp_table == NO_TMP_TABLE))
  {
    my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
8637
    DBUG_RETURN(true);
8638
  }
8639

8640
  Alter_table_ctx alter_ctx(thd, table_list, tables_opened, new_db, new_name);
8641

8642 8643
  MDL_request target_mdl_request;

unknown's avatar
unknown committed
8644
  /* Check that we are not trying to rename to an existing table */
8645
  if (alter_ctx.is_table_renamed())
unknown's avatar
unknown committed
8646
  {
8647
    if (table->s->tmp_table != NO_TMP_TABLE)
unknown's avatar
unknown committed
8648
    {
8649 8650 8651 8652 8653 8654
      /*
        Check whether a temporary table exists with same requested new name.
        If such table exists, there must be a corresponding TABLE_SHARE in
        THD::all_temp_tables list.
      */
      if (thd->find_tmp_table_share(alter_ctx.new_db, alter_ctx.new_name))
8655
      {
8656 8657
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), alter_ctx.new_alias);
        DBUG_RETURN(true);
8658 8659
      }
    }
8660
    else
8661
    {
8662 8663
      MDL_request_list mdl_requests;
      MDL_request target_db_mdl_request;
8664

8665 8666 8667 8668
      target_mdl_request.init(MDL_key::TABLE,
                              alter_ctx.new_db, alter_ctx.new_name,
                              MDL_EXCLUSIVE, MDL_TRANSACTION);
      mdl_requests.push_front(&target_mdl_request);
8669

8670
      /*
8671 8672 8673
        If we are moving the table to a different database, we also
        need IX lock on the database name so that the target database
        is protected by MDL while the table is moved.
8674
      */
8675
      if (alter_ctx.is_database_changed())
unknown's avatar
unknown committed
8676
      {
8677 8678 8679 8680
        target_db_mdl_request.init(MDL_key::SCHEMA, alter_ctx.new_db, "",
                                   MDL_INTENTION_EXCLUSIVE,
                                   MDL_TRANSACTION);
        mdl_requests.push_front(&target_db_mdl_request);
unknown's avatar
unknown committed
8681
      }
8682

8683 8684 8685 8686 8687 8688 8689
      /*
        Global intention exclusive lock must have been already acquired when
        table to be altered was open, so there is no need to do it here.
      */
      DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::GLOBAL,
                                                 "", "",
                                                 MDL_INTENTION_EXCLUSIVE));
8690

8691 8692 8693
      if (thd->mdl_context.acquire_locks(&mdl_requests,
                                         thd->variables.lock_wait_timeout))
        DBUG_RETURN(true);
8694

8695 8696 8697 8698 8699
      DEBUG_SYNC(thd, "locked_table_name");
      /*
        Table maybe does not exist, but we got an exclusive lock
        on the name, now we can safely try to find out for sure.
      */
8700
      if (ha_table_exists(thd, alter_ctx.new_db, alter_ctx.new_name, 0))
8701
      {
8702 8703 8704
        /* Table will be closed in do_command() */
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), alter_ctx.new_alias);
        DBUG_RETURN(true);
8705 8706
      }
    }
unknown's avatar
unknown committed
8707
  }
8708

unknown's avatar
unknown committed
8709
  if (!create_info->db_type)
8710
  {
8711
#ifdef WITH_PARTITION_STORAGE_ENGINE
8712 8713
    if (table->part_info &&
        create_info->used_fields & HA_CREATE_USED_ENGINE)
8714 8715
    {
      /*
8716 8717
        This case happens when the user specified
        ENGINE = x where x is a non-existing storage engine
8718 8719 8720
        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.
8721
      */
8722
      create_info->db_type= table->part_info->default_engine_type;
8723
    }
8724
    else
8725
#endif
8726
      create_info->db_type= table->s->db_type();
8727
  }
8728

8729 8730
  if (check_engine(thd, alter_ctx.new_db, alter_ctx.new_name, create_info))
    DBUG_RETURN(true);
8731

8732 8733
  if ((create_info->db_type != table->s->db_type() ||
       alter_info->flags & Alter_info::ALTER_PARTITION) &&
8734
      !table->file->can_switch_engines())
unknown's avatar
unknown committed
8735
  {
8736
    my_error(ER_ROW_IS_REFERENCED, MYF(0));
8737
    DBUG_RETURN(true);
unknown's avatar
unknown committed
8738 8739
  }

8740
  /*
8741 8742 8743 8744 8745 8746 8747
   If foreign key is added then check permission to access parent table.

   In function "check_fk_parent_table_access", create_info->db_type is used
   to identify whether engine supports FK constraint or not. Since
   create_info->db_type is set here, check to parent table access is delayed
   till this point for the alter operation.
  */
Sergei Golubchik's avatar
Sergei Golubchik committed
8748
  if ((alter_info->flags & Alter_info::ADD_FOREIGN_KEY) &&
8749
      check_fk_parent_table_access(thd, create_info, alter_info, new_db))
Sergei Golubchik's avatar
Sergei Golubchik committed
8750
    DBUG_RETURN(true);
8751

8752
  /*
8753 8754
    If this is an ALTER TABLE and no explicit row type specified reuse
    the table's row type.
Sergei Golubchik's avatar
Sergei Golubchik committed
8755
    Note: this is the same as if the row type was specified explicitly.
8756
  */
8757
  if (create_info->row_type == ROW_TYPE_NOT_USED)
8758
  {
8759
    /* ALTER TABLE without explicit row type */
8760
    create_info->row_type= table->s->row_type;
8761 8762 8763 8764 8765
  }
  else
  {
    /* ALTER TABLE with specific row type */
    create_info->used_fields |= HA_CREATE_USED_ROW_FORMAT;
8766
  }
unknown's avatar
unknown committed
8767

8768
  DBUG_PRINT("info", ("old type: %s  new type: %s",
8769 8770 8771
             ha_resolve_storage_engine_name(table->s->db_type()),
             ha_resolve_storage_engine_name(create_info->db_type)));
  if (ha_check_storage_engine_flag(table->s->db_type(), HTON_ALTER_NOT_SUPPORTED))
8772 8773
  {
    DBUG_PRINT("info", ("doesn't support alter"));
8774 8775 8776
    my_error(ER_ILLEGAL_HA, MYF(0), hton_name(table->s->db_type())->str,
             alter_ctx.db, alter_ctx.table_name);
    DBUG_RETURN(true);
8777
  }
8778 8779 8780 8781 8782 8783 8784 8785 8786 8787

  if (ha_check_storage_engine_flag(create_info->db_type,
                                   HTON_ALTER_NOT_SUPPORTED))
  {
    DBUG_PRINT("info", ("doesn't support alter"));
    my_error(ER_ILLEGAL_HA, MYF(0), hton_name(create_info->db_type)->str,
             alter_ctx.new_db, alter_ctx.new_name);
    DBUG_RETURN(true);
  }

Sergei Golubchik's avatar
Sergei Golubchik committed
8788 8789 8790
  if (table->s->tmp_table == NO_TMP_TABLE)
    mysql_audit_alter_table(thd, table_list);

Sergei Golubchik's avatar
Sergei Golubchik committed
8791
  THD_STAGE_INFO(thd, stage_setup);
8792 8793 8794 8795 8796 8797 8798 8799 8800 8801 8802

  handle_if_exists_options(thd, table, alter_info);

  /*
    Look if we have to do anything at all.
    ALTER can become NOOP after handling
    the IF (NOT) EXISTS options.
  */
  if (alter_info->flags == 0)
  {
    my_snprintf(alter_ctx.tmp_name, sizeof(alter_ctx.tmp_name),
8803
                ER_THD(thd, ER_INSERT_INFO), 0L, 0L,
8804 8805
                thd->get_stmt_da()->current_statement_warn_count());
    my_ok(thd, 0L, 0L, alter_ctx.tmp_name);
8806

8807 8808 8809 8810 8811 8812 8813
    /* We don't replicate alter table statement on temporary tables */
    if (table->s->tmp_table == NO_TMP_TABLE ||
        !thd->is_current_stmt_binlog_format_row())
    {
      if (write_bin_log(thd, true, thd->query(), thd->query_length()))
        DBUG_RETURN(true);
    }
8814

8815 8816 8817
    DBUG_RETURN(false);
  }

8818 8819 8820 8821
  /*
     Test if we are only doing RENAME or KEYS ON/OFF. This works
     as we are testing if flags == 0 above.
  */
8822 8823 8824
  if (!(alter_info->flags & ~(Alter_info::ALTER_RENAME |
                              Alter_info::ALTER_KEYS_ONOFF)) &&
      alter_info->requested_algorithm !=
8825
      Alter_info::ALTER_TABLE_ALGORITHM_COPY)   // No need to touch frm.
unknown's avatar
unknown committed
8826
  {
8827 8828 8829
    bool res;

    if (!table->s->tmp_table)
8830
    {
8831 8832 8833 8834 8835 8836 8837 8838 8839 8840 8841 8842 8843 8844 8845 8846 8847
      // This requires X-lock, no other lock levels supported.
      if (alter_info->requested_lock != Alter_info::ALTER_TABLE_LOCK_DEFAULT &&
          alter_info->requested_lock != Alter_info::ALTER_TABLE_LOCK_EXCLUSIVE)
      {
        my_error(ER_ALTER_OPERATION_NOT_SUPPORTED, MYF(0),
                 "LOCK=NONE/SHARED", "LOCK=EXCLUSIVE");
        DBUG_RETURN(true);
      }
      res= simple_rename_or_index_change(thd, table_list,
                                         alter_info->keys_onoff,
                                         &alter_ctx);
    }
    else
    {
      res= simple_tmp_rename_or_index_change(thd, table_list,
                                             alter_info->keys_onoff,
                                             &alter_ctx);
8848
    }
Sergei Golubchik's avatar
Sergei Golubchik committed
8849
    DBUG_RETURN(res);
8850
  }
unknown's avatar
unknown committed
8851

8852
  /* We have to do full alter table. */
unknown's avatar
unknown committed
8853

8854
#ifdef WITH_PARTITION_STORAGE_ENGINE
8855 8856
  bool partition_changed= false;
  bool fast_alter_partition= false;
unknown's avatar
unknown committed
8857
  {
8858 8859 8860 8861 8862 8863 8864
    if (prep_alter_part_table(thd, table, alter_info, create_info,
                              &alter_ctx, &partition_changed,
                              &fast_alter_partition))
    {
      DBUG_RETURN(true);
    }
  }
8865
#endif
8866

8867 8868 8869 8870 8871
  if (mysql_prepare_alter_table(thd, table, create_info, alter_info,
                                &alter_ctx))
  {
    DBUG_RETURN(true);
  }
unknown's avatar
unknown committed
8872

8873
  set_table_default_charset(thd, create_info, alter_ctx.db);
8874 8875 8876

  if (!opt_explicit_defaults_for_timestamp)
    promote_first_timestamp_column(&alter_info->create_list);
unknown's avatar
unknown committed
8877

8878
#ifdef WITH_PARTITION_STORAGE_ENGINE
8879
  if (fast_alter_partition)
8880
  {
8881 8882 8883 8884 8885 8886 8887 8888 8889 8890 8891
    /*
      ALGORITHM and LOCK clauses are generally not allowed by the
      parser for operations related to partitioning.
      The exceptions are ALTER_PARTITION and ALTER_REMOVE_PARTITIONING.
      For consistency, we report ER_ALTER_OPERATION_NOT_SUPPORTED here.
    */
    if (alter_info->requested_lock !=
        Alter_info::ALTER_TABLE_LOCK_DEFAULT)
    {
      my_error(ER_ALTER_OPERATION_NOT_SUPPORTED_REASON, MYF(0),
               "LOCK=NONE/SHARED/EXCLUSIVE",
8892
               ER_THD(thd, ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION),
8893 8894
               "LOCK=DEFAULT");
      DBUG_RETURN(true);
8895
    }
8896 8897
    else if (alter_info->requested_algorithm !=
             Alter_info::ALTER_TABLE_ALGORITHM_DEFAULT)
8898
    {
8899 8900
      my_error(ER_ALTER_OPERATION_NOT_SUPPORTED_REASON, MYF(0),
               "ALGORITHM=COPY/INPLACE",
8901
               ER_THD(thd, ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION),
8902 8903
               "ALGORITHM=DEFAULT");
      DBUG_RETURN(true);
8904 8905
    }

8906
    /*
8907 8908
      Upgrade from MDL_SHARED_UPGRADABLE to MDL_SHARED_NO_WRITE.
      Afterwards it's safe to take the table level lock.
8909
    */
8910 8911 8912
    if (thd->mdl_context.upgrade_shared_lock(mdl_ticket, MDL_SHARED_NO_WRITE,
                                             thd->variables.lock_wait_timeout)
        || lock_tables(thd, table_list, alter_ctx.tables_opened, 0))
8913
    {
8914
      DBUG_RETURN(true);
8915
    }
8916 8917

    // In-place execution of ALTER TABLE for partitioning.
unknown's avatar
unknown committed
8918 8919
    DBUG_RETURN(fast_alter_partition_table(thd, table, alter_info,
                                           create_info, table_list,
8920 8921
                                           alter_ctx.db,
                                           alter_ctx.table_name));
unknown's avatar
unknown committed
8922
  }
8923
#endif
unknown's avatar
unknown committed
8924

8925
  /*
8926 8927 8928 8929 8930 8931 8932 8933
    Use copy algorithm if:
    - old_alter_table system variable is set without in-place requested using
      the ALGORITHM clause.
    - Or if in-place is impossible for given operation.
    - Changes to partitioning which were not handled by fast_alter_part_table()
      needs to be handled using table copying algorithm unless the engine
      supports auto-partitioning as such engines can do some changes
      using in-place API.
8934
  */
8935 8936 8937 8938
  if ((thd->variables.old_alter_table &&
       alter_info->requested_algorithm !=
       Alter_info::ALTER_TABLE_ALGORITHM_INPLACE)
      || is_inplace_alter_impossible(table, create_info, alter_info)
8939
#ifdef WITH_PARTITION_STORAGE_ENGINE
8940 8941 8942 8943
      || (partition_changed &&
          !(table->s->db_type()->partition_flags() & HA_USE_AUTO_PARTITION))
#endif
     )
unknown's avatar
unknown committed
8944
  {
8945 8946 8947 8948 8949 8950 8951 8952
    if (alter_info->requested_algorithm ==
        Alter_info::ALTER_TABLE_ALGORITHM_INPLACE)
    {
      my_error(ER_ALTER_OPERATION_NOT_SUPPORTED, MYF(0),
               "ALGORITHM=INPLACE", "ALGORITHM=COPY");
      DBUG_RETURN(true);
    }
    alter_info->requested_algorithm= Alter_info::ALTER_TABLE_ALGORITHM_COPY;
unknown's avatar
unknown committed
8953 8954
  }

8955 8956 8957 8958 8959 8960 8961 8962 8963
  /*
    ALTER TABLE ... ENGINE to the same engine is a common way to
    request table rebuild. Set ALTER_RECREATE flag to force table
    rebuild.
  */
  if (create_info->db_type == table->s->db_type() &&
      create_info->used_fields & HA_CREATE_USED_ENGINE)
    alter_info->flags|= Alter_info::ALTER_RECREATE;

8964 8965 8966 8967 8968 8969 8970 8971 8972 8973 8974 8975 8976 8977
  /*
    If the old table had partitions and we are doing ALTER TABLE ...
    engine= <new_engine>, the new table must preserve the original
    partitioning. This 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.
    It's therefore important that the assignment below is done
    after prep_alter_part_table.
  */
  handlerton *new_db_type= create_info->db_type;
  handlerton *old_db_type= table->s->db_type();
  TABLE *new_table= NULL;
  ha_rows copied=0,deleted=0;
8978

8979 8980 8981 8982 8983 8984 8985 8986 8987 8988 8989 8990 8991 8992 8993
  /*
    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.
8994 8995
      At end, rename intermediate tables, and symlinks to intermediate
      table, to final table name.
8996 8997 8998 8999 9000 9001 9002
      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.
  */
9003 9004 9005
  char index_file[FN_REFLEN], data_file[FN_REFLEN];

  if (!alter_ctx.is_database_changed())
9006 9007 9008 9009
  {
    if (create_info->index_file_name)
    {
      /* Fix index_file_name to have 'tmp_name' as basename */
9010
      strmov(index_file, alter_ctx.tmp_name);
9011
      create_info->index_file_name=fn_same(index_file,
9012 9013
                                           create_info->index_file_name,
                                           1);
9014 9015 9016 9017
    }
    if (create_info->data_file_name)
    {
      /* Fix data_file_name to have 'tmp_name' as basename */
9018
      strmov(data_file, alter_ctx.tmp_name);
9019
      create_info->data_file_name=fn_same(data_file,
9020 9021
                                          create_info->data_file_name,
                                          1);
9022 9023
    }
  }
9024
  else
9025 9026
  {
    /* Ignore symlink if db is changed. */
9027
    create_info->data_file_name=create_info->index_file_name=0;
9028
  }
unknown's avatar
unknown committed
9029

9030
  DEBUG_SYNC(thd, "alter_table_before_create_table_no_lock");
9031 9032 9033
  /* We can abort alter table for any table type */
  thd->abort_on_warning= !ignore && thd->is_strict_mode();

9034
  /*
9035
    Create .FRM for new version of table with a temporary name.
9036
    We don't log the statement, it will be logged later.
9037 9038 9039 9040 9041 9042 9043 9044 9045 9046 9047

    Keep information about keys in newly created table as it
    will be used later to construct Alter_inplace_info object
    and by fill_alter_inplace_info() call.
  */
  KEY *key_info;
  uint key_count;
  /*
    Remember if the new definition has new VARCHAR column;
    create_info->varchar will be reset in create_table_impl()/
    mysql_prepare_create_table().
9048
  */
9049
  bool varchar= create_info->varchar;
Sergei Golubchik's avatar
Sergei Golubchik committed
9050
  LEX_CUSTRING frm= {0,0};
9051

9052
  tmp_disable_binlog(thd);
Sergei Golubchik's avatar
Sergei Golubchik committed
9053
  create_info->options|=HA_CREATE_TMP_ALTER;
9054 9055 9056
  error= create_table_impl(thd,
                           alter_ctx.db, alter_ctx.table_name,
                           alter_ctx.new_db, alter_ctx.tmp_name,
9057
                           alter_ctx.get_tmp_path(),
9058
                           thd->lex->create_info, create_info, alter_info,
Sergei Golubchik's avatar
Sergei Golubchik committed
9059 9060
                           C_ALTER_TABLE_FRM_ONLY, NULL,
                           &key_info, &key_count, &frm);
9061
  reenable_binlog(thd);
9062
  thd->abort_on_warning= false;
9063
  if (error)
Sergei Golubchik's avatar
Sergei Golubchik committed
9064 9065
  {
    my_free(const_cast<uchar*>(frm.str));
9066
    DBUG_RETURN(true);
Sergei Golubchik's avatar
Sergei Golubchik committed
9067
  }
9068

9069 9070 9071 9072
  /* Remember that we have not created table in storage engine yet. */
  bool no_ha_table= true;

  if (alter_info->requested_algorithm != Alter_info::ALTER_TABLE_ALGORITHM_COPY)
unknown's avatar
unknown committed
9073
  {
9074 9075
    Alter_inplace_info ha_alter_info(create_info, alter_info,
                                     key_info, key_count,
9076
                                     IF_PARTITIONING(thd->work_part_info, NULL),
9077 9078 9079 9080 9081 9082 9083 9084
                                     ignore);
    TABLE *altered_table= NULL;
    bool use_inplace= true;

    /* Fill the Alter_inplace_info structure. */
    if (fill_alter_inplace_info(thd, table, varchar, &ha_alter_info))
      goto err_new_table_cleanup;

Sergei Golubchik's avatar
Sergei Golubchik committed
9085 9086 9087 9088 9089 9090 9091 9092 9093 9094 9095 9096 9097 9098 9099 9100 9101 9102 9103 9104 9105
    if (ha_alter_info.handler_flags == 0)
    {
      /*
        No-op ALTER, no need to call handler API functions.

        If this code path is entered for an ALTER statement that
        should not be a real no-op, new handler flags should be added
        and fill_alter_inplace_info() adjusted.

        Note that we can end up here if an ALTER statement has clauses
        that cancel each other out (e.g. ADD/DROP identically index).

        Also note that we ignore the LOCK clause here.

         TODO don't create the frm in the first place
      */
      deletefrm(alter_ctx.get_tmp_path());
      my_free(const_cast<uchar*>(frm.str));
      goto end_inplace;
    }

9106 9107 9108
    // We assume that the table is non-temporary.
    DBUG_ASSERT(!table->s->tmp_table);

9109 9110 9111 9112 9113
    if (!(altered_table=
          thd->create_and_open_tmp_table(new_db_type, &frm,
                                         alter_ctx.get_tmp_path(),
                                         alter_ctx.new_db, alter_ctx.tmp_name,
                                         false)))
9114 9115 9116 9117 9118 9119 9120 9121 9122 9123 9124 9125
      goto err_new_table_cleanup;

    /* Set markers for fields in TABLE object for altered table. */
    update_altered_table(ha_alter_info, altered_table);

    /*
      Mark all columns in 'altered_table' as used to allow usage
      of its record[0] buffer and Field objects during in-place
      ALTER TABLE.
    */
    altered_table->column_bitmaps_set_no_signal(&altered_table->s->all_set,
                                                &altered_table->s->all_set);
9126
    restore_record(altered_table, s->default_values); // Create empty record
9127 9128 9129 9130
    /* Check that we can call default functions with default field values */
    altered_table->reset_default_fields();
    if (altered_table->default_field &&
        altered_table->update_default_fields(0, 1))
9131
      goto err_new_table_cleanup;
9132 9133 9134

    // Ask storage engine whether to use copy or in-place
    enum_alter_inplace_result inplace_supported=
Sergei Golubchik's avatar
Sergei Golubchik committed
9135 9136
      table->file->check_if_supported_inplace_alter(altered_table,
                                                    &ha_alter_info);
9137 9138 9139 9140 9141 9142 9143 9144 9145 9146 9147 9148 9149 9150 9151 9152 9153 9154 9155

    switch (inplace_supported) {
    case HA_ALTER_INPLACE_EXCLUSIVE_LOCK:
      // If SHARED lock and no particular algorithm was requested, use COPY.
      if (alter_info->requested_lock ==
          Alter_info::ALTER_TABLE_LOCK_SHARED &&
          alter_info->requested_algorithm ==
          Alter_info::ALTER_TABLE_ALGORITHM_DEFAULT)
      {
        use_inplace= false;
      }
      // Otherwise, if weaker lock was requested, report errror.
      else if (alter_info->requested_lock ==
               Alter_info::ALTER_TABLE_LOCK_NONE ||
               alter_info->requested_lock ==
               Alter_info::ALTER_TABLE_LOCK_SHARED)
      {
        ha_alter_info.report_unsupported_error("LOCK=NONE/SHARED",
                                               "LOCK=EXCLUSIVE");
9156
        thd->drop_temporary_table(altered_table, NULL, false);
9157 9158 9159 9160 9161 9162 9163 9164 9165 9166
        goto err_new_table_cleanup;
      }
      break;
    case HA_ALTER_INPLACE_SHARED_LOCK_AFTER_PREPARE:
    case HA_ALTER_INPLACE_SHARED_LOCK:
      // If weaker lock was requested, report errror.
      if (alter_info->requested_lock ==
          Alter_info::ALTER_TABLE_LOCK_NONE)
      {
        ha_alter_info.report_unsupported_error("LOCK=NONE", "LOCK=SHARED");
9167
        thd->drop_temporary_table(altered_table, NULL, false);
9168 9169 9170 9171 9172 9173 9174 9175 9176 9177 9178 9179 9180
        goto err_new_table_cleanup;
      }
      break;
    case HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE:
    case HA_ALTER_INPLACE_NO_LOCK:
      break;
    case HA_ALTER_INPLACE_NOT_SUPPORTED:
      // If INPLACE was requested, report error.
      if (alter_info->requested_algorithm ==
          Alter_info::ALTER_TABLE_ALGORITHM_INPLACE)
      {
        ha_alter_info.report_unsupported_error("ALGORITHM=INPLACE",
                                               "ALGORITHM=COPY");
9181
        thd->drop_temporary_table(altered_table, NULL, false);
9182 9183 9184 9185 9186 9187 9188
        goto err_new_table_cleanup;
      }
      // COPY with LOCK=NONE is not supported, no point in trying.
      if (alter_info->requested_lock ==
          Alter_info::ALTER_TABLE_LOCK_NONE)
      {
        ha_alter_info.report_unsupported_error("LOCK=NONE", "LOCK=SHARED");
9189
        thd->drop_temporary_table(altered_table, NULL, false);
9190 9191 9192 9193 9194 9195 9196
        goto err_new_table_cleanup;
      }
      // Otherwise use COPY
      use_inplace= false;
      break;
    case HA_ALTER_ERROR:
    default:
9197
      thd->drop_temporary_table(altered_table, NULL, false);
9198 9199 9200 9201
      goto err_new_table_cleanup;
    }

    if (use_inplace)
9202
    {
9203 9204 9205 9206
      table->s->frm_image= &frm;
      int res= mysql_inplace_alter_table(thd, table_list, table, altered_table,
                                         &ha_alter_info, inplace_supported,
                                         &target_mdl_request, &alter_ctx);
Sergei Golubchik's avatar
Sergei Golubchik committed
9207
      my_free(const_cast<uchar*>(frm.str));
9208 9209

      if (res)
9210 9211 9212
        DBUG_RETURN(true);

      goto end_inplace;
9213
    }
9214
    else
9215
    {
9216
      thd->drop_temporary_table(altered_table, NULL, false);
9217 9218
    }
  }
unknown's avatar
unknown committed
9219

9220 9221 9222 9223 9224
  /* ALTER TABLE using copy algorithm. */

  /* Check if ALTER TABLE is compatible with foreign key definitions. */
  if (fk_prepare_copy_alter_table(thd, table, alter_info, &alter_ctx))
    goto err_new_table_cleanup;
9225

9226
  if (!table->s->tmp_table)
unknown's avatar
unknown committed
9227
  {
9228 9229
    // COPY algorithm doesn't work with concurrent writes.
    if (alter_info->requested_lock == Alter_info::ALTER_TABLE_LOCK_NONE)
9230
    {
9231 9232
      my_error(ER_ALTER_OPERATION_NOT_SUPPORTED_REASON, MYF(0),
               "LOCK=NONE",
9233
               ER_THD(thd, ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COPY),
9234 9235
               "LOCK=SHARED");
      goto err_new_table_cleanup;
9236
    }
9237 9238 9239 9240

    // If EXCLUSIVE lock is requested, upgrade already.
    if (alter_info->requested_lock == Alter_info::ALTER_TABLE_LOCK_EXCLUSIVE &&
        wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN))
9241
      goto err_new_table_cleanup;
9242

9243
    /*
9244 9245
      Otherwise upgrade to SHARED_NO_WRITE.
      Note that under LOCK TABLES, we will already have SHARED_NO_READ_WRITE.
9246
    */
9247 9248 9249 9250 9251 9252
    if (alter_info->requested_lock != Alter_info::ALTER_TABLE_LOCK_EXCLUSIVE &&
        thd->mdl_context.upgrade_shared_lock(mdl_ticket, MDL_SHARED_NO_WRITE,
                                             thd->variables.lock_wait_timeout))
      goto err_new_table_cleanup;

    DEBUG_SYNC(thd, "alter_table_copy_after_lock_upgrade");
unknown's avatar
unknown committed
9253 9254
  }

9255 9256 9257 9258
  // It's now safe to take the table level lock.
  if (lock_tables(thd, table_list, alter_ctx.tables_opened, 0))
    goto err_new_table_cleanup;

Sergei Golubchik's avatar
Sergei Golubchik committed
9259 9260 9261 9262
  if (ha_create_table(thd, alter_ctx.get_tmp_path(),
                      alter_ctx.new_db, alter_ctx.tmp_name,
                      create_info, &frm))
    goto err_new_table_cleanup;
9263

Sergei Golubchik's avatar
Sergei Golubchik committed
9264 9265
  /* Mark that we have created table in storage engine. */
  no_ha_table= false;
9266

Sergei Golubchik's avatar
Sergei Golubchik committed
9267 9268
  if (create_info->tmp_table())
  {
9269 9270 9271 9272 9273 9274 9275
    TABLE *tmp_table=
      thd->create_and_open_tmp_table(new_db_type, &frm,
                                     alter_ctx.get_tmp_path(),
                                     alter_ctx.new_db, alter_ctx.tmp_name,
                                     true);
    if (!tmp_table)
    {
Sergei Golubchik's avatar
Sergei Golubchik committed
9276
      goto err_new_table_cleanup;
9277
    }
9278
    /* in case of alter temp table send the tracker in OK packet */
9279
    SESSION_TRACKER_CHANGED(thd, SESSION_STATE_CHANGE_TRACKER, NULL);
9280 9281
  }

9282

9283 9284 9285 9286 9287 9288 9289
  /* Open the table since we need to copy the data. */
  if (table->s->tmp_table != NO_TMP_TABLE)
  {
    TABLE_LIST tbl;
    tbl.init_one_table(alter_ctx.new_db, strlen(alter_ctx.new_db),
                       alter_ctx.tmp_name, strlen(alter_ctx.tmp_name),
                       alter_ctx.tmp_name, TL_READ_NO_INSERT);
9290 9291 9292 9293 9294
    /*
      Table can be found in the list of open tables in THD::all_temp_tables
      list.
    */
    tbl.table= thd->find_temporary_table(&tbl);
9295 9296 9297 9298
    new_table= tbl.table;
  }
  else
  {
9299 9300 9301 9302 9303 9304 9305 9306 9307
    /*
      table is a normal table: Create temporary table in same directory.
      Open our intermediate table.
    */
    new_table=
      thd->create_and_open_tmp_table(new_db_type, &frm,
                                     alter_ctx.get_tmp_path(),
                                     alter_ctx.new_db, alter_ctx.tmp_name,
                                     true);
9308 9309 9310 9311 9312 9313 9314 9315
  }
  if (!new_table)
    goto err_new_table_cleanup;
  /*
    Note: In case of MERGE table, we do not attach children. We do not
    copy data for MERGE tables. Only the children have data.
  */

9316
  /* Copy the data if necessary. */
9317
  thd->count_cuted_fields= CHECK_FIELD_WARN;	// calc cuted fields
unknown's avatar
unknown committed
9318
  thd->cuted_fields=0L;
9319

9320 9321 9322 9323
  /*
    We do not copy data for MERGE tables. Only the children have data.
    MERGE tables have HA_NO_COPY_ON_ALTER set.
  */
9324
  if (!(new_table->file->ha_table_flags() & HA_NO_COPY_ON_ALTER))
9325 9326
  {
    new_table->next_number_field=new_table->found_next_number_field;
9327
    THD_STAGE_INFO(thd, stage_copy_to_tmp_table);
9328 9329 9330 9331
    DBUG_EXECUTE_IF("abort_copy_table", {
        my_error(ER_LOCK_WAIT_TIMEOUT, MYF(0));
        goto err_new_table_cleanup;
      });
9332 9333 9334 9335 9336 9337
    if (copy_data_between_tables(thd, table, new_table,
                                 alter_info->create_list, ignore,
                                 order_num, order, &copied, &deleted,
                                 alter_info->keys_onoff,
                                 &alter_ctx))
      goto err_new_table_cleanup;
9338
  }
9339
  else
9340
  {
9341 9342
    if (!table->s->tmp_table &&
        wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN))
9343
      goto err_new_table_cleanup;
Sergei Golubchik's avatar
Sergei Golubchik committed
9344
    THD_STAGE_INFO(thd, stage_manage_keys);
9345 9346
    alter_table_manage_keys(table, table->file->indexes_are_disabled(),
                            alter_info->keys_onoff);
Konstantin Osipov's avatar
Konstantin Osipov committed
9347
    if (trans_commit_stmt(thd) || trans_commit_implicit(thd))
9348
      goto err_new_table_cleanup;
9349
  }
9350
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
9351

unknown's avatar
unknown committed
9352
  if (table->s->tmp_table != NO_TMP_TABLE)
unknown's avatar
unknown committed
9353
  {
9354 9355 9356
    /* Close lock if this is a transactional table */
    if (thd->lock)
    {
9357 9358 9359 9360
      if (thd->locked_tables_mode != LTM_LOCK_TABLES &&
          thd->locked_tables_mode != LTM_PRELOCKED_UNDER_LOCK_TABLES)
      {
        mysql_unlock_tables(thd, thd->lock);
9361
        thd->lock= NULL;
9362 9363 9364 9365 9366 9367 9368 9369 9370
      }
      else
      {
        /*
          If LOCK TABLES list is not empty and contains this table,
          unlock the table and remove the table from this list.
        */
        mysql_lock_remove(thd, thd->lock, table);
      }
9371
    }
9372 9373
    new_table->s->table_creation_was_logged=
      table->s->table_creation_was_logged;
unknown's avatar
unknown committed
9374
    /* Remove link to old table and rename the new one */
9375
    thd->drop_temporary_table(table, NULL, true);
9376
    /* Should pass the 'new_name' as we store table name in the cache */
9377 9378
    if (thd->rename_temporary_table(new_table, alter_ctx.new_db,
                                    alter_ctx.new_name))
9379
      goto err_new_table_cleanup;
9380
    /* We don't replicate alter table statement on temporary tables */
9381
    if (!thd->is_current_stmt_binlog_format_row() &&
9382 9383
        write_bin_log(thd, true, thd->query(), thd->query_length()))
      DBUG_RETURN(true);
Sergei Golubchik's avatar
Sergei Golubchik committed
9384
    my_free(const_cast<uchar*>(frm.str));
unknown's avatar
unknown committed
9385 9386 9387
    goto end_temporary;
  }

9388 9389
  /*
    Close the intermediate table that will be the new table, but do
9390 9391
    not delete it! Even though MERGE tables do not have their children
    attached here it is safe to call THD::drop_temporary_table().
9392
  */
9393
  thd->drop_temporary_table(new_table, NULL, false);
9394 9395
  new_table= NULL;

9396
  DEBUG_SYNC(thd, "alter_table_before_rename_result_table");
9397

unknown's avatar
unknown committed
9398
  /*
9399
    Data is copied. Now we:
Konstantin Osipov's avatar
Konstantin Osipov committed
9400 9401
    1) Wait until all other threads will stop using old version of table
       by upgrading shared metadata lock to exclusive one.
9402
    2) Close instances of table open by this thread and replace them
Konstantin Osipov's avatar
Konstantin Osipov committed
9403
       with placeholders to simplify reopen process.
9404 9405 9406 9407 9408 9409
    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
Konstantin Osipov's avatar
Konstantin Osipov committed
9410
       remove placeholders and release metadata locks.
9411 9412
    7) If we are not not under LOCK TABLES we rely on the caller
      (mysql_execute_command()) to release metadata locks.
unknown's avatar
unknown committed
9413 9414
  */

Sergei Golubchik's avatar
Sergei Golubchik committed
9415
  THD_STAGE_INFO(thd, stage_rename_result_table);
unknown's avatar
unknown committed
9416

9417 9418 9419
  if (wait_while_table_is_used(thd, table, HA_EXTRA_PREPARE_FOR_RENAME))
    goto err_new_table_cleanup;

Konstantin Osipov's avatar
Konstantin Osipov committed
9420
  close_all_tables_for_name(thd, table->s,
9421 9422 9423 9424 9425
                            alter_ctx.is_table_renamed() ?
                            HA_EXTRA_PREPARE_FOR_RENAME: 
                            HA_EXTRA_NOT_USED,
                            NULL);
  table_list->table= table= NULL;                  /* Safety */
Sergei Golubchik's avatar
Sergei Golubchik committed
9426
  my_free(const_cast<uchar*>(frm.str));
9427 9428

  /*
9429 9430
    Rename the old table to temporary name to have a backup in case
    anything goes wrong while renaming the new table.
9431
  */
9432 9433 9434 9435 9436 9437 9438
  char backup_name[32];
  my_snprintf(backup_name, sizeof(backup_name), "%s2-%lx-%lx", tmp_file_prefix,
              current_pid, thd->thread_id);
  if (lower_case_table_names)
    my_casedn_str(files_charset_info, backup_name);
  if (mysql_rename_table(old_db_type, alter_ctx.db, alter_ctx.table_name,
                         alter_ctx.db, backup_name, FN_TO_IS_TMP))
9439
  {
9440 9441 9442 9443
    // Rename to temporary name failed, delete the new table, abort ALTER.
    (void) quick_rm_table(thd, new_db_type, alter_ctx.new_db,
                          alter_ctx.tmp_name, FN_IS_TMP);
    goto err_with_mdl;
9444 9445
  }

9446 9447 9448 9449
  // Rename the new table to the correct name.
  if (mysql_rename_table(new_db_type, alter_ctx.new_db, alter_ctx.tmp_name,
                         alter_ctx.new_db, alter_ctx.new_alias,
                         FN_FROM_IS_TMP))
9450
  {
9451 9452 9453
    // Rename failed, delete the temporary table.
    (void) quick_rm_table(thd, new_db_type, alter_ctx.new_db,
                          alter_ctx.tmp_name, FN_IS_TMP);
Sergei Golubchik's avatar
Sergei Golubchik committed
9454

9455 9456
    // Restore the backup of the original table to the old name.
    (void) mysql_rename_table(old_db_type, alter_ctx.db, backup_name,
Sergei Golubchik's avatar
Sergei Golubchik committed
9457 9458
                              alter_ctx.db, alter_ctx.alias,
                              FN_FROM_IS_TMP | NO_FK_CHECKS);
9459
    goto err_with_mdl;
unknown's avatar
unknown committed
9460
  }
9461

9462
  // Check if we renamed the table and if so update trigger files.
9463
  if (alter_ctx.is_table_renamed())
9464
  {
9465 9466 9467 9468 9469 9470
    if (Table_triggers_list::change_table_name(thd,
                                               alter_ctx.db,
                                               alter_ctx.alias,
                                               alter_ctx.table_name,
                                               alter_ctx.new_db,
                                               alter_ctx.new_alias))
9471
    {
9472 9473 9474 9475 9476
      // Rename succeeded, delete the new table.
      (void) quick_rm_table(thd, new_db_type,
                            alter_ctx.new_db, alter_ctx.new_alias, 0);
      // Restore the backup of the original table to the old name.
      (void) mysql_rename_table(old_db_type, alter_ctx.db, backup_name,
Sergei Golubchik's avatar
Sergei Golubchik committed
9477
                                alter_ctx.db, alter_ctx.alias,
9478
                                FN_FROM_IS_TMP | NO_FK_CHECKS);
9479
      goto err_with_mdl;
9480
    }
9481 9482
    rename_table_in_stat_tables(thd, alter_ctx.db,alter_ctx.alias,
                                alter_ctx.new_db, alter_ctx.new_alias);
9483
  }
9484

9485 9486
  // ALTER TABLE succeeded, delete the backup of the old table.
  if (quick_rm_table(thd, old_db_type, alter_ctx.db, backup_name, FN_IS_TMP))
unknown's avatar
unknown committed
9487
  {
unknown's avatar
unknown committed
9488
    /*
9489 9490 9491
      The fact that deletion of the backup failed is not critical
      error, but still worth reporting as it might indicate serious
      problem with server.
unknown's avatar
unknown committed
9492
    */
9493
    goto err_with_mdl_after_alter;
9494
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
9495

9496
end_inplace:
9497

Konstantin Osipov's avatar
Konstantin Osipov committed
9498
  if (thd->locked_tables_list.reopen_tables(thd))
9499
    goto err_with_mdl_after_alter;
9500

Sergei Golubchik's avatar
Sergei Golubchik committed
9501
  THD_STAGE_INFO(thd, stage_end);
9502

9503
  DEBUG_SYNC(thd, "alter_table_before_main_binlog");
9504

unknown's avatar
unknown committed
9505
  DBUG_ASSERT(!(mysql_bin_log.is_open() &&
9506
                thd->is_current_stmt_binlog_format_row() &&
9507
                (create_info->tmp_table())));
9508 9509
  if (write_bin_log(thd, true, thd->query(), thd->query_length()))
    DBUG_RETURN(true);
9510

9511 9512
  table_list->table= NULL;			// For query cache
  query_cache_invalidate3(thd, table_list, false);
unknown's avatar
unknown committed
9513

Konstantin Osipov's avatar
Konstantin Osipov committed
9514 9515
  if (thd->locked_tables_mode == LTM_LOCK_TABLES ||
      thd->locked_tables_mode == LTM_PRELOCKED_UNDER_LOCK_TABLES)
unknown's avatar
unknown committed
9516
  {
9517
    if (alter_ctx.is_table_renamed())
Konstantin Osipov's avatar
Konstantin Osipov committed
9518
      thd->mdl_context.release_all_locks_for_name(mdl_ticket);
9519
    else
9520
      mdl_ticket->downgrade_lock(MDL_SHARED_NO_READ_WRITE);
unknown's avatar
unknown committed
9521 9522
  }

unknown's avatar
unknown committed
9523
end_temporary:
9524
  my_snprintf(alter_ctx.tmp_name, sizeof(alter_ctx.tmp_name),
9525
              ER_THD(thd, ER_INSERT_INFO),
9526
	      (ulong) (copied + deleted), (ulong) deleted,
9527 9528 9529
	      (ulong) thd->get_stmt_da()->current_statement_warn_count());
  my_ok(thd, copied + deleted, 0L, alter_ctx.tmp_name);
  DBUG_RETURN(false);
unknown's avatar
unknown committed
9530

9531
err_new_table_cleanup:
Sergei Golubchik's avatar
Sergei Golubchik committed
9532
  my_free(const_cast<uchar*>(frm.str));
9533 9534
  if (new_table)
  {
9535
    thd->drop_temporary_table(new_table, NULL, true);
9536 9537
  }
  else
9538 9539
    (void) quick_rm_table(thd, new_db_type,
                          alter_ctx.new_db, alter_ctx.tmp_name,
9540 9541
                          (FN_IS_TMP | (no_ha_table ? NO_HA_TABLE : 0)),
                          alter_ctx.get_tmp_path());
9542

9543 9544 9545 9546 9547 9548
  /*
    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.
  */
9549 9550
  if (alter_ctx.error_if_not_empty &&
      thd->get_stmt_da()->current_row_for_warning())
9551
  {
9552 9553
    const char *f_val= 0;
    enum enum_mysql_timestamp_type t_type= MYSQL_TIMESTAMP_DATE;
9554
    switch (alter_ctx.datetime_field->sql_type)
9555 9556 9557 9558 9559 9560 9561
    {
      case MYSQL_TYPE_DATE:
      case MYSQL_TYPE_NEWDATE:
        f_val= "0000-00-00";
        t_type= MYSQL_TIMESTAMP_DATE;
        break;
      case MYSQL_TYPE_DATETIME:
9562
      case MYSQL_TYPE_DATETIME2:
9563 9564 9565 9566 9567 9568 9569 9570
        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;
9571 9572
    thd->abort_on_warning= true;
    make_truncated_value_warning(thd, Sql_condition::WARN_LEVEL_WARN,
unknown's avatar
unknown committed
9573
                                 f_val, strlength(f_val), t_type,
9574
                                 alter_ctx.datetime_field->field_name);
9575 9576
    thd->abort_on_warning= save_abort_on_warning;
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
9577

9578
  DBUG_RETURN(true);
9579

9580 9581
err_with_mdl_after_alter:
  /* the table was altered. binlog the operation */
9582 9583 9584
  DBUG_ASSERT(!(mysql_bin_log.is_open() &&
                thd->is_current_stmt_binlog_format_row() &&
                (create_info->tmp_table())));
9585 9586
  write_bin_log(thd, true, thd->query(), thd->query_length());

Konstantin Osipov's avatar
Konstantin Osipov committed
9587
err_with_mdl:
9588
  /*
Konstantin Osipov's avatar
Konstantin Osipov committed
9589
    An error happened while we were holding exclusive name metadata lock
Konstantin Osipov's avatar
Konstantin Osipov committed
9590 9591 9592
    on table being altered. To be safe under LOCK TABLES we should
    remove all references to the altered table from the list of locked
    tables and release the exclusive metadata lock.
9593
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
9594
  thd->locked_tables_list.unlink_all_closed_tables(thd, NULL, 0);
Konstantin Osipov's avatar
Konstantin Osipov committed
9595
  thd->mdl_context.release_all_locks_for_name(mdl_ticket);
9596
  DBUG_RETURN(true);
unknown's avatar
unknown committed
9597
}
9598 9599


9600 9601 9602 9603 9604 9605 9606

/**
  Prepare the transaction for the alter table's copy phase.
*/

bool mysql_trans_prepare_alter_copy_data(THD *thd)
{
9607
  DBUG_ENTER("mysql_trans_prepare_alter_copy_data");
9608 9609 9610 9611 9612 9613 9614 9615 9616 9617 9618 9619 9620 9621 9622 9623 9624 9625 9626
  /*
    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.
  */
  if (ha_enable_transaction(thd, FALSE))
    DBUG_RETURN(TRUE);
  DBUG_RETURN(FALSE);
}


/**
  Commit the copy phase of the alter table.
*/

bool mysql_trans_commit_alter_copy_data(THD *thd)
{
  bool error= FALSE;
9627
  DBUG_ENTER("mysql_trans_commit_alter_copy_data");
9628 9629 9630 9631 9632 9633 9634 9635 9636 9637 9638 9639 9640 9641 9642 9643 9644 9645 9646

  if (ha_enable_transaction(thd, TRUE))
    DBUG_RETURN(TRUE);
  
  /*
    Ensure that the new table is saved properly to disk before installing
    the new .frm.
    And that InnoDB's internal latches are released, to avoid deadlock
    when waiting on other instances of the table before rename (Bug#54747).
  */
  if (trans_commit_stmt(thd))
    error= TRUE;
  if (trans_commit_implicit(thd))
    error= TRUE;

  DBUG_RETURN(error);
}


unknown's avatar
unknown committed
9647
static int
9648 9649
copy_data_between_tables(THD *thd, TABLE *from, TABLE *to,
			 List<Create_field> &create, bool ignore,
9650
			 uint order_num, ORDER *order,
9651 9652 9653
			 ha_rows *copied, ha_rows *deleted,
                         Alter_info::enum_enable_or_disable keys_onoff,
                         Alter_table_ctx *alter_ctx)
unknown's avatar
unknown committed
9654
{
9655
  int error= 1;
9656
  Copy_field *copy= NULL, *copy_end;
9657
  ha_rows found_count= 0, delete_count= 0;
9658
  SORT_INFO  *file_sort= 0;
unknown's avatar
unknown committed
9659 9660 9661 9662
  READ_RECORD info;
  TABLE_LIST   tables;
  List<Item>   fields;
  List<Item>   all_fields;
9663
  bool auto_increment_field_copied= 0;
9664
  bool init_read_record_done= 0;
Monty's avatar
Monty committed
9665
  sql_mode_t save_sql_mode= thd->variables.sql_mode;
9666
  ulonglong prev_insert_id, time_to_report_progress;
9667
  Field **dfield_ptr= to->default_field;
unknown's avatar
unknown committed
9668 9669
  DBUG_ENTER("copy_data_between_tables");

9670
  /* Two or 3 stages; Sorting, copying data and update indexes */
9671
  thd_progress_init(thd, 2 + MY_TEST(order));
9672

9673
  if (mysql_trans_prepare_alter_copy_data(thd))
9674
    DBUG_RETURN(-1);
9675

9676
  if (!(copy= new Copy_field[to->s->fields]))
9677
    DBUG_RETURN(-1);				/* purecov: inspected */
unknown's avatar
unknown committed
9678

9679
  /* We need external lock before we can disable/enable keys */
9680
  if (to->file->ha_external_lock(thd, F_WRLCK))
9681
    DBUG_RETURN(-1);
9682

unknown's avatar
unknown committed
9683 9684
  alter_table_manage_keys(to, from->file->indexes_are_disabled(), keys_onoff);

9685
  /* We can abort alter table for any table type */
9686
  thd->abort_on_warning= !ignore && thd->is_strict_mode();
9687

9688
  from->file->info(HA_STATUS_VARIABLE);
9689 9690
  to->file->ha_start_bulk_insert(from->file->stats.records,
                                 ignore ? 0 : HA_CREATE_UNIQUE_INDEX_BY_SORT);
unknown's avatar
unknown committed
9691

9692 9693
  List_iterator<Create_field> it(create);
  Create_field *def;
unknown's avatar
unknown committed
9694
  copy_end=copy;
9695
  to->s->default_fields= 0;
unknown's avatar
unknown committed
9696 9697 9698 9699
  for (Field **ptr=to->field ; *ptr ; ptr++)
  {
    def=it++;
    if (def->field)
9700 9701
    {
      if (*ptr == to->next_number_field)
9702
      {
9703
        auto_increment_field_copied= TRUE;
9704 9705 9706 9707 9708 9709 9710 9711 9712
        /*
          If we are going to copy contents of one auto_increment column to
          another auto_increment column it is sensible to preserve zeroes.
          This condition also covers case when we are don't actually alter
          auto_increment column.
        */
        if (def->field == from->found_next_number_field)
          thd->variables.sql_mode|= MODE_NO_AUTO_VALUE_ON_ZERO;
      }
unknown's avatar
unknown committed
9713
      (copy_end++)->set(*ptr,def->field,0);
9714
    }
9715 9716 9717
    else
    {
      /*
9718 9719 9720 9721
        Update the set of auto-update fields to contain only the new fields
        added to the table. Only these fields should be updated automatically.
        Old fields keep their current values, and therefore should not be
        present in the set of autoupdate fields.
9722
      */
9723
      if ((*ptr)->default_value)
9724 9725 9726 9727 9728
      {
        *(dfield_ptr++)= *ptr;
        ++to->s->default_fields;
      }
    }
unknown's avatar
unknown committed
9729
  }
9730 9731
  if (dfield_ptr)
    *dfield_ptr= NULL;
unknown's avatar
unknown committed
9732

unknown's avatar
unknown committed
9733 9734
  if (order)
  {
9735 9736
    if (to->s->primary_key != MAX_KEY &&
        to->file->ha_table_flags() & HA_TABLE_SCAN_ON_INDEX)
9737 9738 9739 9740 9741
    {
      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);
9742
      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
9743 9744 9745 9746 9747 9748 9749 9750
                   warn_buff);
    }
    else
    {
      bzero((char *) &tables, sizeof(tables));
      tables.table= from;
      tables.alias= tables.table_name= from->s->table_name.str;
      tables.db= from->s->db.str;
unknown's avatar
unknown committed
9751

Sergei Golubchik's avatar
Sergei Golubchik committed
9752
      THD_STAGE_INFO(thd, stage_sorting);
9753
      Filesort_tracker dummy_tracker(false);
9754 9755
      Filesort fsort(order, HA_POS_ERROR, true, NULL);

9756 9757
      if (thd->lex->select_lex.setup_ref_array(thd, order_num) ||
          setup_order(thd, thd->lex->select_lex.ref_pointer_array,
9758 9759
                      &tables, fields, all_fields, order))
        goto err;
9760

9761
      if (!(file_sort= filesort(thd, from, &fsort, &dummy_tracker)))
9762 9763
        goto err;
    }
9764 9765
    thd_progress_next_stage(thd);
  }
unknown's avatar
unknown committed
9766

Sergei Golubchik's avatar
Sergei Golubchik committed
9767
  THD_STAGE_INFO(thd, stage_copy_to_tmp_table);
9768 9769
  /* Tell handler that we have values for all columns in the to table */
  to->use_all_columns();
9770 9771 9772
  /* Add virtual columns to vcol_set to ensure they are updated */
  if (to->vfield)
    to->mark_virtual_columns_for_write(TRUE);
9773 9774
  if (init_read_record(&info, thd, from, (SQL_SELECT *) 0, file_sort, 1, 1,
                       FALSE))
9775
    goto err;
9776
  init_read_record_done= 1;
9777

9778
  if (ignore && !alter_ctx->fk_error_if_delete_row)
unknown's avatar
unknown committed
9779
    to->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
9780
  thd->get_stmt_da()->reset_current_row_for_warning();
9781
  restore_record(to, s->default_values);        // Create empty record
9782
  to->reset_default_fields();
9783 9784 9785 9786

  thd->progress.max_counter= from->file->records();
  time_to_report_progress= MY_HOW_OFTEN_TO_WRITE/10;

unknown's avatar
unknown committed
9787 9788 9789 9790
  while (!(error=info.read_record(&info)))
  {
    if (thd->killed)
    {
unknown's avatar
SCRUM  
unknown committed
9791
      thd->send_kill_message();
unknown's avatar
unknown committed
9792 9793 9794
      error= 1;
      break;
    }
9795 9796 9797 9798 9799 9800 9801
    if (++thd->progress.counter >= time_to_report_progress)
    {
      time_to_report_progress+= MY_HOW_OFTEN_TO_WRITE/10;
      thd_progress_report(thd, thd->progress.counter,
                          thd->progress.max_counter);
    }

9802
    /* Return error if source table isn't empty. */
9803
    if (alter_ctx->error_if_not_empty)
9804 9805 9806 9807
    {
      error= 1;
      break;
    }
9808 9809
    if (to->next_number_field)
    {
9810
      if (auto_increment_field_copied)
9811
        to->auto_increment_field_not_null= TRUE;
9812 9813 9814
      else
        to->next_number_field->reset();
    }
9815
    
unknown's avatar
unknown committed
9816
    for (Copy_field *copy_ptr=copy ; copy_ptr != copy_end ; copy_ptr++)
9817
    {
unknown's avatar
unknown committed
9818
      copy_ptr->do_copy(copy_ptr);
9819
    }
9820
    prev_insert_id= to->file->next_insert_id;
9821 9822
    if (to->default_field)
      to->update_default_fields(0, ignore);
Michael Widenius's avatar
Michael Widenius committed
9823
    if (to->vfield)
9824
      to->update_virtual_fields(VCOL_UPDATE_FOR_WRITE);
9825 9826 9827 9828

    /* This will set thd->is_error() if fatal failure */
    if (to->verify_constraints(ignore) == VIEW_CHECK_SKIP)
      continue;
9829 9830 9831 9832 9833
    if (thd->is_error())
    {
      error= 1;
      break;
    }
9834
    error=to->file->ha_write_row(to->record[0]);
9835 9836
    to->auto_increment_field_not_null= FALSE;
    if (error)
unknown's avatar
unknown committed
9837
    {
9838
      if (to->file->is_fatal_error(error, HA_CHECK_DUP))
unknown's avatar
unknown committed
9839
      {
9840 9841
        /* Not a duplicate key error. */
	to->file->print_error(error, MYF(0));
9842
        error= 1;
unknown's avatar
unknown committed
9843 9844
	break;
      }
9845 9846 9847 9848 9849 9850 9851 9852 9853 9854 9855 9856 9857 9858 9859 9860 9861 9862 9863 9864 9865 9866 9867 9868 9869 9870 9871 9872 9873 9874
      else
      {
        /* Duplicate key error. */
        if (alter_ctx->fk_error_if_delete_row)
        {
          /*
            We are trying to omit a row from the table which serves as parent
            in a foreign key. This might have broken referential integrity so
            emit an error. Note that we can't ignore this error even if we are
            executing ALTER IGNORE TABLE. IGNORE allows to skip rows, but
            doesn't allow to break unique or foreign key constraints,
          */
          my_error(ER_FK_CANNOT_DELETE_PARENT, MYF(0),
                   alter_ctx->fk_error_id,
                   alter_ctx->fk_error_table);
          break;
        }

        if (ignore)
        {
          /* This ALTER IGNORE TABLE. Simply skip row and continue. */
          to->file->restore_auto_increment(prev_insert_id);
          delete_count++;
        }
        else
        {
          /* Ordinary ALTER TABLE. Report duplicate key error. */
          uint key_nr= to->file->get_dup_key(error);
          if ((int) key_nr >= 0)
          {
9875
            const char *err_msg= ER_THD(thd, ER_DUP_ENTRY_WITH_KEY_NAME);
9876 9877 9878
            if (key_nr == 0 &&
                (to->key_info[0].key_part[0].field->flags &
                 AUTO_INCREMENT_FLAG))
9879
              err_msg= ER_THD(thd, ER_DUP_ENTRY_AUTOINCREMENT_CASE);
9880 9881 9882 9883 9884 9885 9886 9887 9888
            print_keydup_error(to, key_nr == MAX_KEY ? NULL :
                                   &to->key_info[key_nr],
                               err_msg, MYF(0));
          }
          else
            to->file->print_error(error, MYF(0));
          break;
        }
      }
unknown's avatar
unknown committed
9889 9890
    }
    else
9891
      found_count++;
9892
    thd->get_stmt_da()->inc_current_row_for_warning();
unknown's avatar
unknown committed
9893
  }
unknown's avatar
unknown committed
9894

Sergei Golubchik's avatar
Sergei Golubchik committed
9895
  THD_STAGE_INFO(thd, stage_enabling_keys);
9896 9897
  thd_progress_next_stage(thd);

9898
  if (error > 0 && !from->s->tmp_table)
9899 9900
  {
    /* We are going to drop the temporary table */
9901
    to->file->extra(HA_EXTRA_PREPARE_FOR_DROP);
9902
  }
9903
  if (to->file->ha_end_bulk_insert() && error <= 0)
unknown's avatar
unknown committed
9904
  {
unknown's avatar
unknown committed
9905
    to->file->print_error(my_errno,MYF(0));
Konstantin Osipov's avatar
Konstantin Osipov committed
9906
    error= 1;
unknown's avatar
unknown committed
9907
  }
unknown's avatar
unknown committed
9908
  to->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
9909

9910
  if (mysql_trans_commit_alter_copy_data(thd))
9911
    error= 1;
9912

9913
 err:
9914 9915 9916 9917 9918 9919
  /* Free resources */
  if (init_read_record_done)
    end_read_record(&info);
  delete [] copy;
  delete file_sort;

9920
  thd->variables.sql_mode= save_sql_mode;
9921
  thd->abort_on_warning= 0;
unknown's avatar
unknown committed
9922 9923
  *copied= found_count;
  *deleted=delete_count;
9924
  to->file->ha_release_auto_increment();
9925
  if (to->file->ha_external_lock(thd,F_UNLCK))
9926
    error=1;
9927 9928
  if (error < 0 && !from->s->tmp_table &&
      to->file->extra(HA_EXTRA_PREPARE_FOR_RENAME))
Konstantin Osipov's avatar
Konstantin Osipov committed
9929
    error= 1;
9930
  thd_progress_end(thd);
unknown's avatar
unknown committed
9931 9932
  DBUG_RETURN(error > 0 ? -1 : 0);
}
9933

unknown's avatar
unknown committed
9934

9935
/*
9936
  Recreates one table by calling mysql_alter_table().
9937 9938 9939 9940

  SYNOPSIS
    mysql_recreate_table()
    thd			Thread handler
9941
    table_list          Table to recreate
9942 9943
    table_copy          Recreate the table by using
                        ALTER TABLE COPY algorithm
9944 9945 9946 9947

 RETURN
    Like mysql_alter_table().
*/
9948

9949
bool mysql_recreate_table(THD *thd, TABLE_LIST *table_list, bool table_copy)
9950 9951
{
  HA_CREATE_INFO create_info;
9952
  Alter_info alter_info;
9953
  TABLE_LIST *next_table= table_list->next_global;
9954

9955
  DBUG_ENTER("mysql_recreate_table");
9956
  /* Set lock type which is appropriate for ALTER TABLE. */
9957
  table_list->lock_type= TL_READ_NO_INSERT;
9958 9959
  /* Same applies to MDL request. */
  table_list->mdl_request.set_type(MDL_SHARED_NO_WRITE);
9960 9961
  /* hide following tables from open_tables() */
  table_list->next_global= NULL;
9962 9963

  bzero((char*) &create_info, sizeof(create_info));
unknown's avatar
unknown committed
9964
  create_info.row_type=ROW_TYPE_NOT_USED;
9965
  create_info.default_table_charset=default_charset_info;
unknown's avatar
unknown committed
9966
  /* Force alter table to recreate table */
9967 9968
  alter_info.flags= (Alter_info::ALTER_CHANGE_COLUMN |
                     Alter_info::ALTER_RECREATE);
9969 9970 9971 9972

  if (table_copy)
    alter_info.requested_algorithm= Alter_info::ALTER_TABLE_ALGORITHM_COPY;

9973
  bool res= mysql_alter_table(thd, NullS, NullS, &create_info,
9974
                                table_list, &alter_info, 0,
Sergei Golubchik's avatar
Sergei Golubchik committed
9975
                                (ORDER *) 0, 0);
9976 9977
  table_list->next_global= next_table;
  DBUG_RETURN(res);
9978 9979 9980
}


9981 9982 9983 9984 9985 9986 9987 9988 9989 9990 9991 9992
static void flush_checksum(ha_checksum *row_crc, uchar **checksum_start,
                           size_t *checksum_length)
{
  if (*checksum_start)
  {
    *row_crc= my_checksum(*row_crc, *checksum_start, *checksum_length);
    *checksum_start= NULL;
    *checksum_length= 0;
  }
}


9993 9994
bool mysql_checksum_table(THD *thd, TABLE_LIST *tables,
                          HA_CHECK_OPT *check_opt)
9995 9996 9997 9998 9999
{
  TABLE_LIST *table;
  List<Item> field_list;
  Item *item;
  Protocol *protocol= thd->protocol;
unknown's avatar
unknown committed
10000
  DBUG_ENTER("mysql_checksum_table");
10001

10002 10003 10004 10005 10006 10007
  /*
    CHECKSUM TABLE returns results and rollbacks statement transaction,
    so it should not be used in stored function or trigger.
  */
  DBUG_ASSERT(! thd->in_sub_stmt);

10008 10009 10010
  field_list.push_back(item= new (thd->mem_root)
                       Item_empty_string(thd, "Table", NAME_LEN*2),
                       thd->mem_root);
10011
  item->maybe_null= 1;
10012 10013 10014 10015
  field_list.push_back(item= new (thd->mem_root)
                       Item_int(thd, "Checksum", (longlong) 1,
                                MY_INT64_NUM_DECIMAL_DIGITS),
                       thd->mem_root);
10016
  item->maybe_null= 1;
10017
  if (protocol->send_result_set_metadata(&field_list,
10018
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
unknown's avatar
unknown committed
10019
    DBUG_RETURN(TRUE);
10020

10021 10022 10023 10024 10025 10026 10027 10028
  /*
    Close all temporary tables which were pre-open to simplify
    privilege checking. Clear all references to closed tables.
  */
  close_thread_tables(thd);
  for (table= tables; table; table= table->next_local)
    table->table= NULL;

10029
  /* Open one table after the other to keep lock time as short as possible. */
unknown's avatar
VIEW  
unknown committed
10030
  for (table= tables; table; table= table->next_local)
10031
  {
10032
    char table_name[SAFE_NAME_LEN*2+2];
10033
    TABLE *t;
10034
    TABLE_LIST *save_next_global;
10035

10036
    strxmov(table_name, table->db ,".", table->table_name, NullS);
unknown's avatar
unknown committed
10037

10038 10039 10040 10041 10042 10043 10044
    /* Remember old 'next' pointer and break the list.  */
    save_next_global= table->next_global;
    table->next_global= NULL;
    table->lock_type= TL_READ;
    /* Allow to open real tables only. */
    table->required_type= FRMTYPE_TABLE;

10045
    if (thd->open_temporary_tables(table) ||
10046 10047 10048 10049 10050 10051 10052 10053
        open_and_lock_tables(thd, table, FALSE, 0))
    {
      t= NULL;
    }
    else
      t= table->table;

    table->next_global= save_next_global;
10054 10055 10056 10057

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

10058
    if (!t)
10059
    {
unknown's avatar
unknown committed
10060
      /* Table didn't exist */
10061 10062 10063 10064
      protocol->store_null();
    }
    else
    {
10065 10066
      /* Call ->checksum() if the table checksum matches 'old_mode' settings */
      if (!(check_opt->flags & T_EXTEND) &&
Sergei Golubchik's avatar
Sergei Golubchik committed
10067 10068
          (((t->file->ha_table_flags() & HA_HAS_OLD_CHECKSUM) && thd->variables.old_mode) ||
           ((t->file->ha_table_flags() & HA_HAS_NEW_CHECKSUM) && !thd->variables.old_mode)))
10069
        protocol->store((ulonglong)t->file->checksum());
10070
      else if (check_opt->flags & T_QUICK)
10071
        protocol->store_null();
10072 10073
      else
      {
10074 10075
        /* calculating table's checksum */
        ha_checksum crc= 0;
unknown's avatar
unknown committed
10076
        uchar null_mask=256 -  (1 << t->s->last_null_bit_pos);
10077

10078
        t->use_all_columns();
10079

10080 10081 10082 10083 10084 10085
        if (t->file->ha_rnd_init(1))
          protocol->store_null();
        else
        {
          for (;;)
          {
10086 10087 10088 10089 10090 10091 10092 10093 10094 10095
            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;
            }
10096
            ha_checksum row_crc= 0;
10097
            int error= t->file->ha_rnd_next(t->record[0]);
10098 10099 10100 10101 10102 10103
            if (unlikely(error))
            {
              if (error == HA_ERR_RECORD_DELETED)
                continue;
              break;
            }
10104
            if (t->s->null_bytes)
unknown's avatar
unknown committed
10105 10106 10107
            {
              /* fix undefined null bits */
              t->record[0][t->s->null_bytes-1] |= null_mask;
unknown's avatar
unknown committed
10108 10109 10110
              if (!(t->s->db_create_options & HA_OPTION_PACK_RECORD))
                t->record[0][0] |= 1;

10111
              row_crc= my_checksum(row_crc, t->record[0], t->s->null_bytes);
unknown's avatar
unknown committed
10112
            }
10113

10114 10115 10116 10117 10118
            uchar *checksum_start= NULL;
            size_t checksum_length= 0;
            for (uint i= 0; i < t->s->fields; i++ )
            {
              Field *f= t->field[i];
10119

Sergei Golubchik's avatar
Sergei Golubchik committed
10120
              if (! thd->variables.old_mode && f->is_real_null(0))
10121 10122
              {
                flush_checksum(&row_crc, &checksum_start, &checksum_length);
10123
                continue;
10124
              }
10125 10126 10127 10128 10129 10130 10131 10132 10133 10134 10135
             /*
               BLOB and VARCHAR have pointers in their field, we must convert
               to string; GEOMETRY is implemented on top of BLOB.
               BIT may store its data among NULL bits, convert as well.
             */
              switch (f->type()) {
                case MYSQL_TYPE_BLOB:
                case MYSQL_TYPE_VARCHAR:
                case MYSQL_TYPE_GEOMETRY:
                case MYSQL_TYPE_BIT:
                {
10136
                  flush_checksum(&row_crc, &checksum_start, &checksum_length);
10137 10138 10139 10140 10141 10142 10143
                  String tmp;
                  f->val_str(&tmp);
                  row_crc= my_checksum(row_crc, (uchar*) tmp.ptr(),
                           tmp.length());
                  break;
                }
                default:
10144
                  if (!checksum_start)
10145
                    checksum_start= f->ptr;
10146 10147
                  DBUG_ASSERT(checksum_start + checksum_length == f->ptr);
                  checksum_length+= f->pack_length();
10148
                  break;
10149 10150
              }
            }
10151
            flush_checksum(&row_crc, &checksum_start, &checksum_length);
10152

10153 10154 10155
            crc+= row_crc;
          }
          protocol->store((ulonglong)crc);
unknown's avatar
unknown committed
10156
          t->file->ha_rnd_end();
10157
        }
10158
      }
10159
      trans_rollback_stmt(thd);
10160 10161
      close_thread_tables(thd);
    }
10162 10163 10164 10165 10166 10167 10168 10169 10170 10171 10172 10173 10174 10175 10176

    if (thd->transaction_rollback_request)
    {
      /*
        If transaction rollback was requested we honor it. To do this we
        abort statement and return error as not only CHECKSUM TABLE is
        rolled back but the whole transaction in which it was used.
      */
      thd->protocol->remove_last_row();
      goto err;
    }

    /* Hide errors from client. Return NULL for problematic tables instead. */
    thd->clear_error();

10177 10178 10179 10180
    if (protocol->write())
      goto err;
  }

10181
  my_eof(thd);
unknown's avatar
unknown committed
10182
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
10183

10184
err:
unknown's avatar
unknown committed
10185
  DBUG_RETURN(TRUE);
10186
}
10187

10188 10189 10190 10191 10192 10193 10194 10195 10196 10197 10198 10199 10200 10201 10202
/**
  @brief Check if the table can be created in the specified storage engine.

  Checks if the storage engine is enabled and supports the given table
  type (e.g. normal, temporary, system). May do engine substitution
  if the requested engine is disabled.

  @param thd          Thread descriptor.
  @param db_name      Database name.
  @param table_name   Name of table to be created.
  @param create_info  Create info from parser, including engine.

  @retval true  Engine not available/supported, error has been reported.
  @retval false Engine available/supported.
*/
10203 10204
bool check_engine(THD *thd, const char *db_name,
                  const char *table_name, HA_CREATE_INFO *create_info)
10205
{
10206
  DBUG_ENTER("check_engine");
10207
  handlerton **new_engine= &create_info->db_type;
unknown's avatar
unknown committed
10208
  handlerton *req_engine= *new_engine;
10209
  handlerton *enf_engine= NULL;
Sergei Golubchik's avatar
Sergei Golubchik committed
10210 10211 10212 10213
  bool no_substitution= thd->variables.sql_mode & MODE_NO_ENGINE_SUBSTITUTION;
  *new_engine= ha_checktype(thd, req_engine, no_substitution);
  DBUG_ASSERT(*new_engine);
  if (!*new_engine)
10214
    DBUG_RETURN(true);
10215

10216 10217 10218 10219 10220 10221 10222 10223
  /* Enforced storage engine should not be used in
  ALTER TABLE that does not use explicit ENGINE = x to
  avoid unwanted unrelated changes.*/
  if (!(thd->lex->sql_command == SQLCOM_ALTER_TABLE &&
        !(create_info->used_fields & HA_CREATE_USED_ENGINE)))
    enf_engine= thd->variables.enforced_table_plugin ?
       plugin_hton(thd->variables.enforced_table_plugin) : NULL;

10224 10225 10226 10227 10228 10229 10230 10231 10232 10233 10234
  if (enf_engine && enf_engine != *new_engine)
  {
    if (no_substitution)
    {
      const char *engine_name= ha_resolve_storage_engine_name(req_engine);
      my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), engine_name, engine_name);
      DBUG_RETURN(TRUE);
    }
    *new_engine= enf_engine;
  }

unknown's avatar
unknown committed
10235
  if (req_engine && req_engine != *new_engine)
10236
  {
10237
    push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
10238
                       ER_WARN_USING_OTHER_HANDLER,
10239
                        ER_THD(thd, ER_WARN_USING_OTHER_HANDLER),
unknown's avatar
unknown committed
10240
                       ha_resolve_storage_engine_name(*new_engine),
10241 10242
                       table_name);
  }
10243
  if (create_info->tmp_table() &&
10244 10245 10246 10247
      ha_check_storage_engine_flag(*new_engine, HTON_TEMPORARY_NOT_SUPPORTED))
  {
    if (create_info->used_fields & HA_CREATE_USED_ENGINE)
    {
unknown's avatar
unknown committed
10248
      my_error(ER_ILLEGAL_HA_CREATE_OPTION, MYF(0),
10249
               hton_name(*new_engine)->str, "TEMPORARY");
10250
      *new_engine= 0;
10251
      DBUG_RETURN(true);
10252
    }
10253
    *new_engine= myisam_hton;
10254
  }
10255 10256

  DBUG_RETURN(false);
10257
}