← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/statement/alter_table.cc

  • Committer: Stewart Smith
  • Date: 2008-11-21 16:06:07 UTC
  • mto: This revision was merged to the branch mainline in revision 593.
  • Revision ID: stewart@flamingspork.com-20081121160607-n6gdlt013spuo54r
remove mysql_frm_type
and fix engines to return correct value from delete_table when table doesn't exist.
(it should be ENOENT).

Also fix up some tests that manipulated frm files by hand. These tests are no longer valid and will need to be rewritten in the not too distant future.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/statement/alter_table.cc
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2009 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
20
 
 
21
 
#include "config.h"
22
 
 
23
 
#include <fcntl.h>
24
 
 
25
 
#include <sstream>
26
 
 
27
 
#include "drizzled/show.h"
28
 
#include "drizzled/lock.h"
29
 
#include "drizzled/session.h"
30
 
#include "drizzled/statement/alter_table.h"
31
 
#include "drizzled/global_charset_info.h"
32
 
 
33
 
 
34
 
#include "drizzled/gettext.h"
35
 
#include "drizzled/data_home.h"
36
 
#include "drizzled/sql_table.h"
37
 
#include "drizzled/table_proto.h"
38
 
#include "drizzled/optimizer/range.h"
39
 
#include "drizzled/time_functions.h"
40
 
#include "drizzled/records.h"
41
 
#include "drizzled/pthread_globals.h"
42
 
#include "drizzled/internal/my_sys.h"
43
 
#include "drizzled/internal/iocache.h"
44
 
 
45
 
#include "drizzled/transaction_services.h"
46
 
 
47
 
using namespace std;
48
 
 
49
 
namespace drizzled
50
 
{
51
 
 
52
 
extern pid_t current_pid;
53
 
 
54
 
static int copy_data_between_tables(Session *session,
55
 
                                    Table *from,Table *to,
56
 
                                    List<CreateField> &create,
57
 
                                    bool ignore,
58
 
                                    uint32_t order_num,
59
 
                                    order_st *order,
60
 
                                    ha_rows *copied,
61
 
                                    ha_rows *deleted,
62
 
                                    enum enum_enable_or_disable keys_onoff,
63
 
                                    bool error_if_not_empty);
64
 
 
65
 
static bool mysql_prepare_alter_table(Session *session,
66
 
                                      Table *table,
67
 
                                      HA_CREATE_INFO *create_info,
68
 
                                      const message::Table &original_proto,
69
 
                                      message::Table &table_message,
70
 
                                      AlterInfo *alter_info);
71
 
 
72
 
static int create_temporary_table(Session *session,
73
 
                                  TableIdentifier &identifier,
74
 
                                  HA_CREATE_INFO *create_info,
75
 
                                  message::Table &create_message,
76
 
                                  AlterInfo *alter_info);
77
 
 
78
 
static Table *open_alter_table(Session *session, Table *table, TableIdentifier &identifier);
79
 
 
80
 
bool statement::AlterTable::execute()
81
 
{
82
 
  TableList *first_table= (TableList *) session->lex->select_lex.table_list.first;
83
 
  TableList *all_tables= session->lex->query_tables;
84
 
  assert(first_table == all_tables && first_table != 0);
85
 
  Select_Lex *select_lex= &session->lex->select_lex;
86
 
  bool need_start_waiting= false;
87
 
 
88
 
  if (is_engine_set)
89
 
  {
90
 
    create_info.db_type= 
91
 
      plugin::StorageEngine::findByName(*session, create_table_message.engine().name());
92
 
 
93
 
    if (create_info.db_type == NULL)
94
 
    {
95
 
      my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), 
96
 
               create_table_message.engine().name().c_str());
97
 
 
98
 
      return true;
99
 
    }
100
 
  }
101
 
 
102
 
  /* Must be set in the parser */
103
 
  assert(select_lex->db);
104
 
 
105
 
  /* Chicken/Egg... we need to search for the table, to know if the table exists, so we can build a full identifier from it */
106
 
  message::Table original_table_message;
107
 
  {
108
 
    TableIdentifier identifier(first_table->db, first_table->table_name);
109
 
    if (plugin::StorageEngine::getTableDefinition(*session, identifier, original_table_message) != EEXIST)
110
 
    {
111
 
      my_error(ER_BAD_TABLE_ERROR, MYF(0), identifier.getSQLPath().c_str());
112
 
      return true;
113
 
    }
114
 
 
115
 
    if (not  create_info.db_type)
116
 
    {
117
 
      create_info.db_type= 
118
 
        plugin::StorageEngine::findByName(*session, original_table_message.engine().name());
119
 
 
120
 
      if (not create_info.db_type)
121
 
      {
122
 
        my_error(ER_BAD_TABLE_ERROR, MYF(0), identifier.getSQLPath().c_str());
123
 
        return true;
124
 
      }
125
 
    }
126
 
  }
127
 
 
128
 
  if (not validateCreateTableOption())
129
 
  {
130
 
    return true;
131
 
  }
132
 
 
133
 
  /* ALTER TABLE ends previous transaction */
134
 
  if (not session->endActiveTransaction())
135
 
  {
136
 
    return true;
137
 
  }
138
 
 
139
 
  if (not (need_start_waiting= ! wait_if_global_read_lock(session, 0, 1)))
140
 
  {
141
 
    return true;
142
 
  }
143
 
 
144
 
  bool res;
145
 
  if (original_table_message.type() == message::Table::STANDARD )
146
 
  {
147
 
    TableIdentifier identifier(first_table->db, first_table->table_name);
148
 
    TableIdentifier new_identifier(select_lex->db ? select_lex->db : first_table->db,
149
 
                                   session->lex->name.str ? session->lex->name.str : first_table->table_name);
150
 
 
151
 
    res= alter_table(session, 
152
 
                     identifier,
153
 
                     new_identifier,
154
 
                     &create_info,
155
 
                     original_table_message,
156
 
                     create_table_message,
157
 
                     first_table,
158
 
                     &alter_info,
159
 
                     select_lex->order_list.elements,
160
 
                     (order_st *) select_lex->order_list.first,
161
 
                     session->lex->ignore);
162
 
  }
163
 
  else
164
 
  {
165
 
    Table *table= session->find_temporary_table(first_table);
166
 
    assert(table);
167
 
    {
168
 
      TableIdentifier identifier(first_table->db, first_table->table_name, table->getMutableShare()->getPath());
169
 
      TableIdentifier new_identifier(select_lex->db ? select_lex->db : first_table->db,
170
 
                                     session->lex->name.str ? session->lex->name.str : first_table->table_name,
171
 
                                     table->getMutableShare()->getPath());
172
 
 
173
 
      res= alter_table(session, 
174
 
                       identifier,
175
 
                       new_identifier,
176
 
                       &create_info,
177
 
                       original_table_message,
178
 
                       create_table_message,
179
 
                       first_table,
180
 
                       &alter_info,
181
 
                       select_lex->order_list.elements,
182
 
                       (order_st *) select_lex->order_list.first,
183
 
                       session->lex->ignore);
184
 
    }
185
 
  }
186
 
 
187
 
  /*
188
 
     Release the protection against the global read lock and wake
189
 
     everyone, who might want to set a global read lock.
190
 
   */
191
 
  start_waiting_global_read_lock(session);
192
 
  return res;
193
 
}
194
 
 
195
 
 
196
 
/**
197
 
  Prepare column and key definitions for CREATE TABLE in ALTER Table.
198
 
 
199
 
  This function transforms parse output of ALTER Table - lists of
200
 
  columns and keys to add, drop or modify into, essentially,
201
 
  CREATE TABLE definition - a list of columns and keys of the new
202
 
  table. While doing so, it also performs some (bug not all)
203
 
  semantic checks.
204
 
 
205
 
  This function is invoked when we know that we're going to
206
 
  perform ALTER Table via a temporary table -- i.e. fast ALTER Table
207
 
  is not possible, perhaps because the ALTER statement contains
208
 
  instructions that require change in table data, not only in
209
 
  table definition or indexes.
210
 
 
211
 
  @param[in,out]  session         thread handle. Used as a memory pool
212
 
                              and source of environment information.
213
 
  @param[in]      table       the source table, open and locked
214
 
                              Used as an interface to the storage engine
215
 
                              to acquire additional information about
216
 
                              the original table.
217
 
  @param[in,out]  create_info A blob with CREATE/ALTER Table
218
 
                              parameters
219
 
  @param[in,out]  alter_info  Another blob with ALTER/CREATE parameters.
220
 
                              Originally create_info was used only in
221
 
                              CREATE TABLE and alter_info only in ALTER Table.
222
 
                              But since ALTER might end-up doing CREATE,
223
 
                              this distinction is gone and we just carry
224
 
                              around two structures.
225
 
 
226
 
  @return
227
 
    Fills various create_info members based on information retrieved
228
 
    from the storage engine.
229
 
    Sets create_info->varchar if the table has a VARCHAR column.
230
 
    Prepares alter_info->create_list and alter_info->key_list with
231
 
    columns and keys of the new table.
232
 
  @retval true   error, out of memory or a semantical error in ALTER
233
 
                 Table instructions
234
 
  @retval false  success
235
 
*/
236
 
static bool mysql_prepare_alter_table(Session *session,
237
 
                                      Table *table,
238
 
                                      HA_CREATE_INFO *create_info,
239
 
                                      const message::Table &original_proto,
240
 
                                      message::Table &table_message,
241
 
                                      AlterInfo *alter_info)
242
 
{
243
 
  /* New column definitions are added here */
244
 
  List<CreateField> new_create_list;
245
 
  /* New key definitions are added here */
246
 
  List<Key> new_key_list;
247
 
  List_iterator<AlterDrop> drop_it(alter_info->drop_list);
248
 
  List_iterator<CreateField> def_it(alter_info->create_list);
249
 
  List_iterator<AlterColumn> alter_it(alter_info->alter_list);
250
 
  List_iterator<Key> key_it(alter_info->key_list);
251
 
  List_iterator<CreateField> find_it(new_create_list);
252
 
  List_iterator<CreateField> field_it(new_create_list);
253
 
  List<Key_part_spec> key_parts;
254
 
  uint32_t used_fields= create_info->used_fields;
255
 
  KeyInfo *key_info= table->key_info;
256
 
  bool rc= true;
257
 
 
258
 
  /* Let new create options override the old ones */
259
 
  message::Table::TableOptions *table_options;
260
 
  table_options= table_message.mutable_options();
261
 
 
262
 
  if (! (used_fields & HA_CREATE_USED_DEFAULT_CHARSET))
263
 
    create_info->default_table_charset= table->getShare()->table_charset;
264
 
  if (! (used_fields & HA_CREATE_USED_AUTO) &&
265
 
      table->found_next_number_field)
266
 
  {
267
 
    /* Table has an autoincrement, copy value to new table */
268
 
    table->cursor->info(HA_STATUS_AUTO);
269
 
    create_info->auto_increment_value= table->cursor->stats.auto_increment_value;
270
 
    if (create_info->auto_increment_value != original_proto.options().auto_increment_value())
271
 
      table_options->set_has_user_set_auto_increment_value(false);
272
 
  }
273
 
  table->restoreRecordAsDefault(); /* Empty record for DEFAULT */
274
 
  CreateField *def;
275
 
 
276
 
  /* First collect all fields from table which isn't in drop_list */
277
 
  Field **f_ptr;
278
 
  Field *field;
279
 
  for (f_ptr= table->getFields(); (field= *f_ptr); f_ptr++)
280
 
  {
281
 
    /* Check if field should be dropped */
282
 
    AlterDrop *drop;
283
 
    drop_it.rewind();
284
 
    while ((drop= drop_it++))
285
 
    {
286
 
      if (drop->type == AlterDrop::COLUMN &&
287
 
          ! my_strcasecmp(system_charset_info, field->field_name, drop->name))
288
 
      {
289
 
        /* Reset auto_increment value if it was dropped */
290
 
        if (MTYP_TYPENR(field->unireg_check) == Field::NEXT_NUMBER &&
291
 
            ! (used_fields & HA_CREATE_USED_AUTO))
292
 
        {
293
 
          create_info->auto_increment_value= 0;
294
 
          create_info->used_fields|= HA_CREATE_USED_AUTO;
295
 
        }
296
 
        break;
297
 
      }
298
 
    }
299
 
    if (drop)
300
 
    {
301
 
      drop_it.remove();
302
 
      continue;
303
 
    }
304
 
    
305
 
    /* Mark that we will read the field */
306
 
    field->setReadSet();
307
 
 
308
 
    /* Check if field is changed */
309
 
    def_it.rewind();
310
 
    while ((def= def_it++))
311
 
    {
312
 
      if (def->change &&
313
 
          ! my_strcasecmp(system_charset_info, field->field_name, def->change))
314
 
              break;
315
 
    }
316
 
    if (def)
317
 
    {
318
 
      /* Field is changed */
319
 
      def->field= field;
320
 
      if (! def->after)
321
 
      {
322
 
        new_create_list.push_back(def);
323
 
        def_it.remove();
324
 
      }
325
 
    }
326
 
    else
327
 
    {
328
 
      /*
329
 
        This field was not dropped and not changed, add it to the list
330
 
        for the new table.
331
 
      */
332
 
      def= new CreateField(field, field);
333
 
      new_create_list.push_back(def);
334
 
      alter_it.rewind(); /* Change default if ALTER */
335
 
      AlterColumn *alter;
336
 
      while ((alter= alter_it++))
337
 
      {
338
 
        if (! my_strcasecmp(system_charset_info,field->field_name, alter->name))
339
 
          break;
340
 
      }
341
 
      if (alter)
342
 
      {
343
 
        if (def->sql_type == DRIZZLE_TYPE_BLOB)
344
 
        {
345
 
          my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0), def->change);
346
 
                goto err;
347
 
        }
348
 
        if ((def->def= alter->def))
349
 
        {
350
 
          /* Use new default */
351
 
          def->flags&= ~NO_DEFAULT_VALUE_FLAG;
352
 
        }
353
 
        else
354
 
          def->flags|= NO_DEFAULT_VALUE_FLAG;
355
 
        alter_it.remove();
356
 
      }
357
 
    }
358
 
  }
359
 
  def_it.rewind();
360
 
  while ((def= def_it++)) /* Add new columns */
361
 
  {
362
 
    if (def->change && ! def->field)
363
 
    {
364
 
      my_error(ER_BAD_FIELD_ERROR, MYF(0), def->change, table->getMutableShare()->getTableName());
365
 
      goto err;
366
 
    }
367
 
    /*
368
 
      Check that the DATE/DATETIME not null field we are going to add is
369
 
      either has a default value or the '0000-00-00' is allowed by the
370
 
      set sql mode.
371
 
      If the '0000-00-00' value isn't allowed then raise the error_if_not_empty
372
 
      flag to allow ALTER Table only if the table to be altered is empty.
373
 
    */
374
 
    if ((def->sql_type == DRIZZLE_TYPE_DATE ||
375
 
         def->sql_type == DRIZZLE_TYPE_DATETIME) &&
376
 
        ! alter_info->datetime_field &&
377
 
        ! (~def->flags & (NO_DEFAULT_VALUE_FLAG | NOT_NULL_FLAG)))
378
 
    {
379
 
      alter_info->datetime_field= def;
380
 
      alter_info->error_if_not_empty= true;
381
 
    }
382
 
    if (! def->after)
383
 
      new_create_list.push_back(def);
384
 
    else if (def->after == first_keyword)
385
 
      new_create_list.push_front(def);
386
 
    else
387
 
    {
388
 
      CreateField *find;
389
 
      find_it.rewind();
390
 
      while ((find= find_it++)) /* Add new columns */
391
 
      {
392
 
        if (! my_strcasecmp(system_charset_info,def->after, find->field_name))
393
 
          break;
394
 
      }
395
 
      if (! find)
396
 
      {
397
 
        my_error(ER_BAD_FIELD_ERROR, MYF(0), def->after, table->getMutableShare()->getTableName());
398
 
        goto err;
399
 
      }
400
 
      find_it.after(def); /* Put element after this */
401
 
      /*
402
 
        XXX: hack for Bug#28427.
403
 
        If column order has changed, force OFFLINE ALTER Table
404
 
        without querying engine capabilities.  If we ever have an
405
 
        engine that supports online ALTER Table CHANGE COLUMN
406
 
        <name> AFTER <name1> (Falcon?), this fix will effectively
407
 
        disable the capability.
408
 
        TODO: detect the situation in compare_tables, behave based
409
 
        on engine capabilities.
410
 
      */
411
 
      if (alter_info->build_method == HA_BUILD_ONLINE)
412
 
      {
413
 
        my_error(ER_NOT_SUPPORTED_YET, MYF(0), session->query.c_str());
414
 
        goto err;
415
 
      }
416
 
      alter_info->build_method= HA_BUILD_OFFLINE;
417
 
    }
418
 
  }
419
 
  if (alter_info->alter_list.elements)
420
 
  {
421
 
    my_error(ER_BAD_FIELD_ERROR,
422
 
             MYF(0),
423
 
             alter_info->alter_list.head()->name,
424
 
             table->getMutableShare()->getTableName());
425
 
    goto err;
426
 
  }
427
 
  if (! new_create_list.elements)
428
 
  {
429
 
    my_message(ER_CANT_REMOVE_ALL_FIELDS,
430
 
               ER(ER_CANT_REMOVE_ALL_FIELDS),
431
 
               MYF(0));
432
 
    goto err;
433
 
  }
434
 
 
435
 
  /*
436
 
    Collect all keys which isn't in drop list. Add only those
437
 
    for which some fields exists.
438
 
  */
439
 
  for (uint32_t i= 0; i < table->getShare()->sizeKeys(); i++, key_info++)
440
 
  {
441
 
    char *key_name= key_info->name;
442
 
    AlterDrop *drop;
443
 
    drop_it.rewind();
444
 
    while ((drop= drop_it++))
445
 
    {
446
 
      if (drop->type == AlterDrop::KEY &&
447
 
          ! my_strcasecmp(system_charset_info, key_name, drop->name))
448
 
        break;
449
 
    }
450
 
    if (drop)
451
 
    {
452
 
      drop_it.remove();
453
 
      continue;
454
 
    }
455
 
 
456
 
    KeyPartInfo *key_part= key_info->key_part;
457
 
    key_parts.empty();
458
 
    for (uint32_t j= 0; j < key_info->key_parts; j++, key_part++)
459
 
    {
460
 
      if (! key_part->field)
461
 
              continue; /* Wrong field (from UNIREG) */
462
 
 
463
 
      const char *key_part_name= key_part->field->field_name;
464
 
      CreateField *cfield;
465
 
      field_it.rewind();
466
 
      while ((cfield= field_it++))
467
 
      {
468
 
        if (cfield->change)
469
 
        {
470
 
          if (! my_strcasecmp(system_charset_info, key_part_name, cfield->change))
471
 
            break;
472
 
        }
473
 
        else if (! my_strcasecmp(system_charset_info, key_part_name, cfield->field_name))
474
 
          break;
475
 
      }
476
 
      if (! cfield)
477
 
              continue; /* Field is removed */
478
 
      
479
 
      uint32_t key_part_length= key_part->length;
480
 
      if (cfield->field) /* Not new field */
481
 
      {
482
 
        /*
483
 
          If the field can't have only a part used in a key according to its
484
 
          new type, or should not be used partially according to its
485
 
          previous type, or the field length is less than the key part
486
 
          length, unset the key part length.
487
 
 
488
 
          We also unset the key part length if it is the same as the
489
 
          old field's length, so the whole new field will be used.
490
 
 
491
 
          BLOBs may have cfield->length == 0, which is why we test it before
492
 
          checking whether cfield->length < key_part_length (in chars).
493
 
         */
494
 
        if (! Field::type_can_have_key_part(cfield->field->type()) ||
495
 
            ! Field::type_can_have_key_part(cfield->sql_type) ||
496
 
            (cfield->field->field_length == key_part_length) ||
497
 
            (cfield->length &&
498
 
             (cfield->length < key_part_length / key_part->field->charset()->mbmaxlen)))
499
 
          key_part_length= 0; /* Use whole field */
500
 
      }
501
 
      key_part_length/= key_part->field->charset()->mbmaxlen;
502
 
      key_parts.push_back(new Key_part_spec(cfield->field_name,
503
 
                                            strlen(cfield->field_name),
504
 
                                            key_part_length));
505
 
    }
506
 
    if (key_parts.elements)
507
 
    {
508
 
      KEY_CREATE_INFO key_create_info;
509
 
      Key *key;
510
 
      enum Key::Keytype key_type;
511
 
      memset(&key_create_info, 0, sizeof(key_create_info));
512
 
 
513
 
      key_create_info.algorithm= key_info->algorithm;
514
 
      if (key_info->flags & HA_USES_BLOCK_SIZE)
515
 
        key_create_info.block_size= key_info->block_size;
516
 
      if (key_info->flags & HA_USES_COMMENT)
517
 
        key_create_info.comment= key_info->comment;
518
 
 
519
 
      if (key_info->flags & HA_NOSAME)
520
 
      {
521
 
        if (is_primary_key_name(key_name))
522
 
          key_type= Key::PRIMARY;
523
 
        else
524
 
          key_type= Key::UNIQUE;
525
 
      }
526
 
      else
527
 
        key_type= Key::MULTIPLE;
528
 
 
529
 
      key= new Key(key_type,
530
 
                   key_name,
531
 
                   strlen(key_name),
532
 
                   &key_create_info,
533
 
                   test(key_info->flags & HA_GENERATED_KEY),
534
 
                   key_parts);
535
 
      new_key_list.push_back(key);
536
 
    }
537
 
  }
538
 
 
539
 
  /* Copy over existing foreign keys */
540
 
  for (int j= 0; j < original_proto.fk_constraint_size(); j++)
541
 
  {
542
 
    AlterDrop *drop;
543
 
    drop_it.rewind();
544
 
    while ((drop= drop_it++))
545
 
    {
546
 
      if (drop->type == AlterDrop::FOREIGN_KEY &&
547
 
          ! my_strcasecmp(system_charset_info, original_proto.fk_constraint(j).name().c_str(), drop->name))
548
 
      {
549
 
        break;
550
 
      }
551
 
    }
552
 
    if (drop)
553
 
    {
554
 
      drop_it.remove();
555
 
      continue;
556
 
    }
557
 
 
558
 
    message::Table::ForeignKeyConstraint *pfkey= table_message.add_fk_constraint();
559
 
    *pfkey= original_proto.fk_constraint(j);
560
 
  }
561
 
 
562
 
  {
563
 
    Key *key;
564
 
    while ((key= key_it++)) /* Add new keys */
565
 
    {
566
 
      if (key->type == Key::FOREIGN_KEY)
567
 
      {
568
 
        if (((Foreign_key *)key)->validate(new_create_list))
569
 
          goto err;
570
 
 
571
 
        Foreign_key *fkey= (Foreign_key*)key;
572
 
        add_foreign_key_to_table_message(&table_message,
573
 
                                         fkey->name.str,
574
 
                                         fkey->columns,
575
 
                                         fkey->ref_table,
576
 
                                         fkey->ref_columns,
577
 
                                         fkey->delete_opt,
578
 
                                         fkey->update_opt,
579
 
                                         fkey->match_opt);
580
 
      }
581
 
 
582
 
      if (key->type != Key::FOREIGN_KEY)
583
 
        new_key_list.push_back(key);
584
 
 
585
 
      if (key->name.str && is_primary_key_name(key->name.str))
586
 
      {
587
 
        my_error(ER_WRONG_NAME_FOR_INDEX,
588
 
                 MYF(0),
589
 
                 key->name.str);
590
 
        goto err;
591
 
      }
592
 
    }
593
 
  }
594
 
 
595
 
  /* Fix names of foreign keys being added */
596
 
  for (int j= 0; j < table_message.fk_constraint_size(); j++)
597
 
  {
598
 
    if (! table_message.fk_constraint(j).has_name())
599
 
    {
600
 
      std::string name(table->getMutableShare()->getTableName());
601
 
      char number[20];
602
 
 
603
 
      name.append("_ibfk_");
604
 
      snprintf(number, sizeof(number), "%d", j+1);
605
 
      name.append(number);
606
 
 
607
 
      message::Table::ForeignKeyConstraint *pfkey= table_message.mutable_fk_constraint(j);
608
 
      pfkey->set_name(name);
609
 
    }
610
 
  }
611
 
 
612
 
  if (alter_info->drop_list.elements)
613
 
  {
614
 
    my_error(ER_CANT_DROP_FIELD_OR_KEY,
615
 
             MYF(0),
616
 
             alter_info->drop_list.head()->name);
617
 
    goto err;
618
 
  }
619
 
  if (alter_info->alter_list.elements)
620
 
  {
621
 
    my_error(ER_CANT_DROP_FIELD_OR_KEY,
622
 
             MYF(0),
623
 
             alter_info->alter_list.head()->name);
624
 
    goto err;
625
 
  }
626
 
 
627
 
  if (not table_message.options().has_comment()
628
 
      && table->getMutableShare()->hasComment())
629
 
    table_options->set_comment(table->getMutableShare()->getComment());
630
 
 
631
 
  if (table->getShare()->getType())
632
 
  {
633
 
    table_message.set_type(message::Table::TEMPORARY);
634
 
  }
635
 
 
636
 
  table_message.set_creation_timestamp(table->getShare()->getTableProto()->creation_timestamp());
637
 
 
638
 
  table_message.set_update_timestamp(time(NULL));
639
 
 
640
 
  rc= false;
641
 
  alter_info->create_list.swap(new_create_list);
642
 
  alter_info->key_list.swap(new_key_list);
643
 
err:
644
 
 
645
 
  size_t num_engine_options= table_message.engine().options_size();
646
 
  size_t original_num_engine_options= original_proto.engine().options_size();
647
 
  for (size_t x= 0; x < original_num_engine_options; ++x)
648
 
  {
649
 
    bool found= false;
650
 
 
651
 
    for (size_t y= 0; y < num_engine_options; ++y)
652
 
    {
653
 
      found= not table_message.engine().options(y).name().compare(original_proto.engine().options(x).name());
654
 
      
655
 
      if (found)
656
 
        break;
657
 
    }
658
 
 
659
 
    if (not found)
660
 
    {
661
 
      message::Engine::Option *opt= table_message.mutable_engine()->add_options();
662
 
 
663
 
      opt->set_name(original_proto.engine().options(x).name());
664
 
      opt->set_state(original_proto.engine().options(x).state());
665
 
    }
666
 
  }
667
 
 
668
 
  return rc;
669
 
}
670
 
 
671
 
/* table_list should contain just one table */
672
 
static int mysql_discard_or_import_tablespace(Session *session,
673
 
                                              TableList *table_list,
674
 
                                              enum tablespace_op_type tablespace_op)
675
 
{
676
 
  Table *table;
677
 
  bool discard;
678
 
  int error;
679
 
 
680
 
  /*
681
 
    Note that DISCARD/IMPORT TABLESPACE always is the only operation in an
682
 
    ALTER Table
683
 
  */
684
 
 
685
 
  TransactionServices &transaction_services= TransactionServices::singleton();
686
 
  session->set_proc_info("discard_or_import_tablespace");
687
 
 
688
 
  discard= test(tablespace_op == DISCARD_TABLESPACE);
689
 
 
690
 
 /*
691
 
   We set this flag so that ha_innobase::open and ::external_lock() do
692
 
   not complain when we lock the table
693
 
 */
694
 
  session->tablespace_op= true;
695
 
  if (!(table= session->openTableLock(table_list, TL_WRITE)))
696
 
  {
697
 
    session->tablespace_op= false;
698
 
    return -1;
699
 
  }
700
 
 
701
 
  error= table->cursor->ha_discard_or_import_tablespace(discard);
702
 
 
703
 
  session->set_proc_info("end");
704
 
 
705
 
  if (error)
706
 
    goto err;
707
 
 
708
 
  /* The ALTER Table is always in its own transaction */
709
 
  error= transaction_services.autocommitOrRollback(session, false);
710
 
  if (! session->endActiveTransaction())
711
 
    error=1;
712
 
  if (error)
713
 
    goto err;
714
 
  write_bin_log(session, session->query.c_str());
715
 
 
716
 
err:
717
 
  (void) transaction_services.autocommitOrRollback(session, error);
718
 
  session->tablespace_op=false;
719
 
 
720
 
  if (error == 0)
721
 
  {
722
 
    session->my_ok();
723
 
    return 0;
724
 
  }
725
 
 
726
 
  table->print_error(error, MYF(0));
727
 
 
728
 
  return -1;
729
 
}
730
 
 
731
 
/**
732
 
  Manages enabling/disabling of indexes for ALTER Table
733
 
 
734
 
  SYNOPSIS
735
 
    alter_table_manage_keys()
736
 
      table                  Target table
737
 
      indexes_were_disabled  Whether the indexes of the from table
738
 
                             were disabled
739
 
      keys_onoff             ENABLE | DISABLE | LEAVE_AS_IS
740
 
 
741
 
  RETURN VALUES
742
 
    false  OK
743
 
    true   Error
744
 
*/
745
 
static bool alter_table_manage_keys(Session *session,
746
 
                                    Table *table, int indexes_were_disabled,
747
 
                                    enum enum_enable_or_disable keys_onoff)
748
 
{
749
 
  int error= 0;
750
 
  switch (keys_onoff) {
751
 
  case ENABLE:
752
 
    error= table->cursor->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
753
 
    break;
754
 
  case LEAVE_AS_IS:
755
 
    if (not indexes_were_disabled)
756
 
      break;
757
 
    /* fall-through: disabled indexes */
758
 
  case DISABLE:
759
 
    error= table->cursor->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
760
 
  }
761
 
 
762
 
  if (error == HA_ERR_WRONG_COMMAND)
763
 
  {
764
 
    push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
765
 
                        ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
766
 
                        table->getMutableShare()->getTableName());
767
 
    error= 0;
768
 
  } else if (error)
769
 
    table->print_error(error, MYF(0));
770
 
 
771
 
  return(error);
772
 
}
773
 
 
774
 
static bool lockTableIfDifferent(Session &session,
775
 
                                 TableIdentifier &original_table_identifier,
776
 
                                 TableIdentifier &new_table_identifier,
777
 
                                 Table *name_lock)
778
 
{
779
 
  /* Check that we are not trying to rename to an existing table */
780
 
  if (not (original_table_identifier == new_table_identifier))
781
 
  {
782
 
    if (original_table_identifier.isTmp())
783
 
    {
784
 
 
785
 
      if (session.find_temporary_table(new_table_identifier))
786
 
      {
787
 
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_table_identifier.getSQLPath().c_str());
788
 
        return false;
789
 
      }
790
 
    }
791
 
    else
792
 
    {
793
 
      if (session.lock_table_name_if_not_cached(new_table_identifier, &name_lock))
794
 
      {
795
 
        return false;
796
 
      }
797
 
 
798
 
      if (not name_lock)
799
 
      {
800
 
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_table_identifier.getSQLPath().c_str());
801
 
        return false;
802
 
      }
803
 
 
804
 
      if (plugin::StorageEngine::doesTableExist(session, new_table_identifier))
805
 
      {
806
 
        /* Table will be closed by Session::executeCommand() */
807
 
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_table_identifier.getSQLPath().c_str());
808
 
 
809
 
        LOCK_open.lock(); /* ALTER TABLe */
810
 
        session.unlink_open_table(name_lock);
811
 
        LOCK_open.unlock();
812
 
 
813
 
        return false;
814
 
      }
815
 
    }
816
 
  }
817
 
 
818
 
  return true;
819
 
}
820
 
 
821
 
/**
822
 
  Alter table
823
 
 
824
 
  SYNOPSIS
825
 
    alter_table()
826
 
      session              Thread handle
827
 
      new_db           If there is a RENAME clause
828
 
      new_name         If there is a RENAME clause
829
 
      create_info      Information from the parsing phase about new
830
 
                       table properties.
831
 
      table_list       The table to change.
832
 
      alter_info       Lists of fields, keys to be changed, added
833
 
                       or dropped.
834
 
      order_num        How many ORDER BY fields has been specified.
835
 
      order            List of fields to order_st BY.
836
 
      ignore           Whether we have ALTER IGNORE Table
837
 
 
838
 
  DESCRIPTION
839
 
    This is a veery long function and is everything but the kitchen sink :)
840
 
    It is used to alter a table and not only by ALTER Table but also
841
 
    CREATE|DROP INDEX are mapped on this function.
842
 
 
843
 
    When the ALTER Table statement just does a RENAME or ENABLE|DISABLE KEYS,
844
 
    or both, then this function short cuts its operation by renaming
845
 
    the table and/or enabling/disabling the keys. In this case, the FRM is
846
 
    not changed, directly by alter_table. However, if there is a
847
 
    RENAME + change of a field, or an index, the short cut is not used.
848
 
    See how `create_list` is used to generate the new FRM regarding the
849
 
    structure of the fields. The same is done for the indices of the table.
850
 
 
851
 
    Important is the fact, that this function tries to do as little work as
852
 
    possible, by finding out whether a intermediate table is needed to copy
853
 
    data into and when finishing the altering to use it as the original table.
854
 
    For this reason the function compare_tables() is called, which decides
855
 
    based on all kind of data how similar are the new and the original
856
 
    tables.
857
 
 
858
 
  RETURN VALUES
859
 
    false  OK
860
 
    true   Error
861
 
*/
862
 
 
863
 
static bool internal_alter_table(Session *session,
864
 
                                 Table *table,
865
 
                                 TableIdentifier &original_table_identifier,
866
 
                                 TableIdentifier &new_table_identifier,
867
 
                                 HA_CREATE_INFO *create_info,
868
 
                                 const message::Table &original_proto,
869
 
                                 message::Table &create_proto,
870
 
                                 TableList *table_list,
871
 
                                 AlterInfo *alter_info,
872
 
                                 uint32_t order_num,
873
 
                                 order_st *order,
874
 
                                 bool ignore)
875
 
{
876
 
  int error= 0;
877
 
  char tmp_name[80];
878
 
  char old_name[32];
879
 
  ha_rows copied= 0;
880
 
  ha_rows deleted= 0;
881
 
 
882
 
  session->set_proc_info("init");
883
 
 
884
 
  table->use_all_columns();
885
 
 
886
 
  plugin::StorageEngine *new_engine;
887
 
  plugin::StorageEngine *original_engine;
888
 
 
889
 
  original_engine= table->getMutableShare()->getEngine();
890
 
 
891
 
  if (not create_info->db_type)
892
 
  {
893
 
    create_info->db_type= original_engine;
894
 
  }
895
 
  new_engine= create_info->db_type;
896
 
 
897
 
 
898
 
  create_proto.set_schema(new_table_identifier.getSchemaName());
899
 
  create_proto.set_type(new_table_identifier.getType());
900
 
 
901
 
  /**
902
 
    @todo Have a check on the table definition for FK in the future 
903
 
    to remove the need for the cursor. (aka can_switch_engines())
904
 
  */
905
 
  if (new_engine != original_engine &&
906
 
      not table->cursor->can_switch_engines())
907
 
  {
908
 
    assert(0);
909
 
    my_error(ER_ROW_IS_REFERENCED, MYF(0));
910
 
 
911
 
    return true;
912
 
  }
913
 
 
914
 
  if (original_engine->check_flag(HTON_BIT_ALTER_NOT_SUPPORTED) ||
915
 
      new_engine->check_flag(HTON_BIT_ALTER_NOT_SUPPORTED))
916
 
  {
917
 
    my_error(ER_ILLEGAL_HA, MYF(0), new_table_identifier.getSQLPath().c_str());
918
 
 
919
 
    return true;
920
 
  }
921
 
 
922
 
  session->set_proc_info("setup");
923
 
 
924
 
  /*
925
 
   * test if no other bits except ALTER_RENAME and ALTER_KEYS_ONOFF are set
926
 
 */
927
 
  {
928
 
    bitset<32> tmp;
929
 
 
930
 
    tmp.set();
931
 
    tmp.reset(ALTER_RENAME);
932
 
    tmp.reset(ALTER_KEYS_ONOFF);
933
 
    tmp&= alter_info->flags;
934
 
 
935
 
    if (! (tmp.any()) && ! table->getShare()->getType()) // no need to touch frm
936
 
    {
937
 
      switch (alter_info->keys_onoff)
938
 
      {
939
 
      case LEAVE_AS_IS:
940
 
        break;
941
 
      case ENABLE:
942
 
        /*
943
 
          wait_while_table_is_used() ensures that table being altered is
944
 
          opened only by this thread and that Table::TableShare::version
945
 
          of Table object corresponding to this table is 0.
946
 
          The latter guarantees that no DML statement will open this table
947
 
          until ALTER Table finishes (i.e. until close_thread_tables())
948
 
          while the fact that the table is still open gives us protection
949
 
          from concurrent DDL statements.
950
 
        */
951
 
        LOCK_open.lock(); /* DDL wait for/blocker */
952
 
        wait_while_table_is_used(session, table, HA_EXTRA_FORCE_REOPEN);
953
 
        LOCK_open.unlock();
954
 
        error= table->cursor->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
955
 
        /* COND_refresh will be signaled in close_thread_tables() */
956
 
        break;
957
 
      case DISABLE:
958
 
        LOCK_open.lock(); /* DDL wait for/blocker */
959
 
        wait_while_table_is_used(session, table, HA_EXTRA_FORCE_REOPEN);
960
 
        LOCK_open.unlock();
961
 
        error=table->cursor->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
962
 
        /* COND_refresh will be signaled in close_thread_tables() */
963
 
        break;
964
 
      default:
965
 
        assert(false);
966
 
        error= 0;
967
 
        break;
968
 
      }
969
 
 
970
 
      if (error == HA_ERR_WRONG_COMMAND)
971
 
      {
972
 
        error= 0;
973
 
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
974
 
                            ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
975
 
                            table->getAlias());
976
 
      }
977
 
 
978
 
      LOCK_open.lock(); /* Lock to remove all instances of table from table cache before ALTER */
979
 
      /*
980
 
        Unlike to the above case close_cached_table() below will remove ALL
981
 
        instances of Table from table cache (it will also remove table lock
982
 
        held by this thread). So to make actual table renaming and writing
983
 
        to binlog atomic we have to put them into the same critical section
984
 
        protected by LOCK_open mutex. This also removes gap for races between
985
 
        access() and mysql_rename_table() calls.
986
 
      */
987
 
 
988
 
      if (error == 0 &&  not (original_table_identifier == new_table_identifier))
989
 
      {
990
 
        session->set_proc_info("rename");
991
 
        /*
992
 
          Then do a 'simple' rename of the table. First we need to close all
993
 
          instances of 'source' table.
994
 
        */
995
 
        session->close_cached_table(table);
996
 
        /*
997
 
          Then, we want check once again that target table does not exist.
998
 
          Actually the order of these two steps does not matter since
999
 
          earlier we took name-lock on the target table, so we do them
1000
 
          in this particular order only to be consistent with 5.0, in which
1001
 
          we don't take this name-lock and where this order really matters.
1002
 
          @todo Investigate if we need this access() check at all.
1003
 
        */
1004
 
        if (plugin::StorageEngine::doesTableExist(*session, new_table_identifier))
1005
 
        {
1006
 
          my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_table_identifier.getSQLPath().c_str());
1007
 
          error= -1;
1008
 
        }
1009
 
        else
1010
 
        {
1011
 
          if (mysql_rename_table(*session, original_engine, original_table_identifier, new_table_identifier))
1012
 
          {
1013
 
            error= -1;
1014
 
          }
1015
 
        }
1016
 
      }
1017
 
 
1018
 
      if (error == HA_ERR_WRONG_COMMAND)
1019
 
      {
1020
 
        error= 0;
1021
 
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1022
 
                            ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
1023
 
                            table->getAlias());
1024
 
      }
1025
 
 
1026
 
      if (error == 0)
1027
 
      {
1028
 
        write_bin_log(session, session->query.c_str());
1029
 
        session->my_ok();
1030
 
      }
1031
 
      else if (error > 0)
1032
 
      {
1033
 
        table->print_error(error, MYF(0));
1034
 
        error= -1;
1035
 
      }
1036
 
 
1037
 
      LOCK_open.unlock();
1038
 
      table_list->table= NULL;
1039
 
 
1040
 
      return error;
1041
 
    }
1042
 
  }
1043
 
 
1044
 
  /* We have to do full alter table. */
1045
 
  new_engine= create_info->db_type;
1046
 
 
1047
 
  if (mysql_prepare_alter_table(session, table, create_info, original_proto, create_proto, alter_info))
1048
 
  {
1049
 
    return true;
1050
 
  }
1051
 
 
1052
 
  set_table_default_charset(create_info, new_table_identifier.getSchemaName().c_str());
1053
 
 
1054
 
  alter_info->build_method= HA_BUILD_OFFLINE;
1055
 
 
1056
 
  snprintf(tmp_name, sizeof(tmp_name), "%s-%lx_%"PRIx64, TMP_FILE_PREFIX, (unsigned long) current_pid, session->thread_id);
1057
 
 
1058
 
  /* Create a temporary table with the new format */
1059
 
  /**
1060
 
    @note we make an internal temporary table unless the table is a temporary table. In last
1061
 
    case we just use it as is. Neither of these tables require locks in order to  be
1062
 
    filled.
1063
 
  */
1064
 
  TableIdentifier new_table_as_temporary(original_table_identifier.getSchemaName(),
1065
 
                                         tmp_name,
1066
 
                                         create_proto.type() != message::Table::TEMPORARY ? message::Table::INTERNAL :
1067
 
                                         message::Table::TEMPORARY);
1068
 
 
1069
 
  error= create_temporary_table(session, new_table_as_temporary, create_info, create_proto, alter_info);
1070
 
 
1071
 
  if (error != 0)
1072
 
  {
1073
 
    return true;
1074
 
  }
1075
 
 
1076
 
  /* Open the table so we need to copy the data to it. */
1077
 
  Table *new_table= open_alter_table(session, table, new_table_as_temporary);
1078
 
 
1079
 
 
1080
 
  if (not new_table)
1081
 
  {
1082
 
    quick_rm_table(*session, new_table_as_temporary);
1083
 
    return true;
1084
 
  }
1085
 
 
1086
 
  /* Copy the data if necessary. */
1087
 
  {
1088
 
    /* We must not ignore bad input! */
1089
 
    session->count_cuted_fields= CHECK_FIELD_ERROR_FOR_NULL;    // calc cuted fields
1090
 
    session->cuted_fields= 0L;
1091
 
    session->set_proc_info("copy to tmp table");
1092
 
    copied= deleted= 0;
1093
 
 
1094
 
    /* We don't want update TIMESTAMP fields during ALTER Table. */
1095
 
    new_table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
1096
 
    new_table->next_number_field= new_table->found_next_number_field;
1097
 
    error= copy_data_between_tables(session,
1098
 
                                    table,
1099
 
                                    new_table,
1100
 
                                    alter_info->create_list,
1101
 
                                    ignore,
1102
 
                                    order_num,
1103
 
                                    order,
1104
 
                                    &copied,
1105
 
                                    &deleted,
1106
 
                                    alter_info->keys_onoff,
1107
 
                                    alter_info->error_if_not_empty);
1108
 
 
1109
 
    /* We must not ignore bad input! */
1110
 
    assert(session->count_cuted_fields == CHECK_FIELD_ERROR_FOR_NULL);
1111
 
  }
1112
 
 
1113
 
  /* Now we need to resolve what just happened with the data copy. */
1114
 
 
1115
 
  if (error)
1116
 
  {
1117
 
 
1118
 
    /*
1119
 
      No default value was provided for a DATE/DATETIME field, the
1120
 
      current sql_mode doesn't allow the '0000-00-00' value and
1121
 
      the table to be altered isn't empty.
1122
 
      Report error here.
1123
 
    */
1124
 
    if (alter_info->error_if_not_empty && session->row_count)
1125
 
    {
1126
 
      const char *f_val= 0;
1127
 
      enum enum_drizzle_timestamp_type t_type= DRIZZLE_TIMESTAMP_DATE;
1128
 
 
1129
 
      switch (alter_info->datetime_field->sql_type)
1130
 
      {
1131
 
      case DRIZZLE_TYPE_DATE:
1132
 
        f_val= "0000-00-00";
1133
 
        t_type= DRIZZLE_TIMESTAMP_DATE;
1134
 
        break;
1135
 
      case DRIZZLE_TYPE_DATETIME:
1136
 
        f_val= "0000-00-00 00:00:00";
1137
 
        t_type= DRIZZLE_TIMESTAMP_DATETIME;
1138
 
        break;
1139
 
      default:
1140
 
        /* Shouldn't get here. */
1141
 
        assert(0);
1142
 
      }
1143
 
      bool save_abort_on_warning= session->abort_on_warning;
1144
 
      session->abort_on_warning= true;
1145
 
      make_truncated_value_warning(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
1146
 
                                   f_val, internal::strlength(f_val), t_type,
1147
 
                                   alter_info->datetime_field->field_name);
1148
 
      session->abort_on_warning= save_abort_on_warning;
1149
 
    }
1150
 
 
1151
 
    if (original_table_identifier.isTmp())
1152
 
    {
1153
 
      if (new_table)
1154
 
      {
1155
 
        /* close_temporary_table() frees the new_table pointer. */
1156
 
        session->close_temporary_table(new_table);
1157
 
      }
1158
 
      else
1159
 
      {
1160
 
        quick_rm_table(*session, new_table_as_temporary);
1161
 
      }
1162
 
 
1163
 
      return true;
1164
 
    }
1165
 
    else
1166
 
    {
1167
 
      if (new_table)
1168
 
      {
1169
 
        /*
1170
 
          Close the intermediate table that will be the new table.
1171
 
          Note that MERGE tables do not have their children attached here.
1172
 
        */
1173
 
        new_table->intern_close_table();
1174
 
        if (new_table->hasShare())
1175
 
        {
1176
 
          delete new_table->s;
1177
 
          new_table->s= NULL;
1178
 
        }
1179
 
 
1180
 
        delete new_table;
1181
 
      }
1182
 
 
1183
 
      LOCK_open.lock(); /* ALTER TABLE */
1184
 
 
1185
 
      quick_rm_table(*session, new_table_as_temporary);
1186
 
      LOCK_open.unlock();
1187
 
 
1188
 
      return true;
1189
 
    }
1190
 
  }
1191
 
  // Temporary table and success
1192
 
  else if (original_table_identifier.isTmp())
1193
 
  {
1194
 
    /* Close lock if this is a transactional table */
1195
 
    if (session->lock)
1196
 
    {
1197
 
      mysql_unlock_tables(session, session->lock);
1198
 
      session->lock= 0;
1199
 
    }
1200
 
 
1201
 
    /* Remove link to old table and rename the new one */
1202
 
    session->close_temporary_table(table);
1203
 
 
1204
 
    /* Should pass the 'new_name' as we store table name in the cache */
1205
 
    new_table->getMutableShare()->setIdentifier(new_table_identifier);
1206
 
 
1207
 
    new_table_identifier.setPath(new_table_as_temporary.getPath());
1208
 
 
1209
 
    if (mysql_rename_table(*session, new_engine, new_table_as_temporary, new_table_identifier) != 0)
1210
 
    {
1211
 
      return true;
1212
 
    }
1213
 
  }
1214
 
  // Normal table success
1215
 
  else
1216
 
  {
1217
 
    if (new_table)
1218
 
    {
1219
 
      /*
1220
 
        Close the intermediate table that will be the new table.
1221
 
        Note that MERGE tables do not have their children attached here.
1222
 
      */
1223
 
      new_table->intern_close_table();
1224
 
 
1225
 
      if (new_table->hasShare())
1226
 
      {
1227
 
        delete new_table->s;
1228
 
        new_table->s= NULL;
1229
 
      }
1230
 
 
1231
 
      delete new_table;
1232
 
    }
1233
 
 
1234
 
    LOCK_open.lock(); /* ALTER TABLE */
1235
 
 
1236
 
    /*
1237
 
      Data is copied. Now we:
1238
 
      1) Wait until all other threads close old version of table.
1239
 
      2) Close instances of table open by this thread and replace them
1240
 
      with exclusive name-locks.
1241
 
      3) Rename the old table to a temp name, rename the new one to the
1242
 
      old name.
1243
 
      4) If we are under LOCK TABLES and don't do ALTER Table ... RENAME
1244
 
      we reopen new version of table.
1245
 
      5) Write statement to the binary log.
1246
 
      6) If we are under LOCK TABLES and do ALTER Table ... RENAME we
1247
 
      remove name-locks from list of open tables and table cache.
1248
 
      7) If we are not not under LOCK TABLES we rely on close_thread_tables()
1249
 
      call to remove name-locks from table cache and list of open table.
1250
 
    */
1251
 
 
1252
 
    session->set_proc_info("rename result table");
1253
 
 
1254
 
    snprintf(old_name, sizeof(old_name), "%s2-%lx-%"PRIx64, TMP_FILE_PREFIX, (unsigned long) current_pid, session->thread_id);
1255
 
 
1256
 
    my_casedn_str(files_charset_info, old_name);
1257
 
 
1258
 
    wait_while_table_is_used(session, table, HA_EXTRA_PREPARE_FOR_RENAME);
1259
 
    session->close_data_files_and_morph_locks(original_table_identifier);
1260
 
 
1261
 
    error= 0;
1262
 
 
1263
 
    /*
1264
 
      This leads to the storage engine (SE) not being notified for renames in
1265
 
      mysql_rename_table(), because we just juggle with the FRM and nothing
1266
 
      more. If we have an intermediate table, then we notify the SE that
1267
 
      it should become the actual table. Later, we will recycle the old table.
1268
 
      However, in case of ALTER Table RENAME there might be no intermediate
1269
 
      table. This is when the old and new tables are compatible, according to
1270
 
      compare_table(). Then, we need one additional call to
1271
 
    */
1272
 
    TableIdentifier original_table_to_drop(original_table_identifier.getSchemaName(),
1273
 
                                           old_name, create_proto.type() != message::Table::TEMPORARY ? message::Table::INTERNAL :
1274
 
                                         message::Table::TEMPORARY);
1275
 
 
1276
 
    if (mysql_rename_table(*session, original_engine, original_table_identifier, original_table_to_drop))
1277
 
    {
1278
 
      error= 1;
1279
 
      quick_rm_table(*session, new_table_as_temporary);
1280
 
    }
1281
 
    else
1282
 
    {
1283
 
      if (mysql_rename_table(*session, new_engine, new_table_as_temporary, new_table_identifier) != 0)
1284
 
      {
1285
 
        /* Try to get everything back. */
1286
 
        error= 1;
1287
 
 
1288
 
        quick_rm_table(*session, new_table_identifier);
1289
 
 
1290
 
        quick_rm_table(*session, new_table_as_temporary);
1291
 
 
1292
 
        mysql_rename_table(*session, original_engine, original_table_to_drop, original_table_identifier);
1293
 
      }
1294
 
      else
1295
 
      {
1296
 
        quick_rm_table(*session, original_table_to_drop);
1297
 
      }
1298
 
    }
1299
 
 
1300
 
    if (error)
1301
 
    {
1302
 
      /*
1303
 
        An error happened while we were holding exclusive name-lock on table
1304
 
        being altered. To be safe under LOCK TABLES we should remove placeholders
1305
 
        from list of open tables list and table cache.
1306
 
      */
1307
 
      session->unlink_open_table(table);
1308
 
      LOCK_open.unlock();
1309
 
 
1310
 
      return true;
1311
 
    }
1312
 
 
1313
 
    LOCK_open.unlock();
1314
 
 
1315
 
    session->set_proc_info("end");
1316
 
 
1317
 
    write_bin_log(session, session->query.c_str());
1318
 
    table_list->table= NULL;
1319
 
  }
1320
 
 
1321
 
  /*
1322
 
   * Field::store() may have called my_error().  If this is 
1323
 
   * the case, we must not send an ok packet, since 
1324
 
   * Diagnostics_area::is_set() will fail an assert.
1325
 
 */
1326
 
  if (session->is_error())
1327
 
  {
1328
 
    /* my_error() was called.  Return true (which means error...) */
1329
 
    return true;
1330
 
  }
1331
 
 
1332
 
  snprintf(tmp_name, sizeof(tmp_name), ER(ER_INSERT_INFO),
1333
 
           (ulong) (copied + deleted), (ulong) deleted,
1334
 
           (ulong) session->cuted_fields);
1335
 
  session->my_ok(copied + deleted, 0, 0L, tmp_name);
1336
 
  session->some_tables_deleted= 0;
1337
 
 
1338
 
  return false;
1339
 
}
1340
 
 
1341
 
bool alter_table(Session *session,
1342
 
                 TableIdentifier &original_table_identifier,
1343
 
                 TableIdentifier &new_table_identifier,
1344
 
                 HA_CREATE_INFO *create_info,
1345
 
                 const message::Table &original_proto,
1346
 
                 message::Table &create_proto,
1347
 
                 TableList *table_list,
1348
 
                 AlterInfo *alter_info,
1349
 
                 uint32_t order_num,
1350
 
                 order_st *order,
1351
 
                 bool ignore)
1352
 
{
1353
 
  bool error;
1354
 
  Table *table;
1355
 
 
1356
 
  if (alter_info->tablespace_op != NO_TABLESPACE_OP)
1357
 
  {
1358
 
    /* DISCARD/IMPORT TABLESPACE is always alone in an ALTER Table */
1359
 
    return mysql_discard_or_import_tablespace(session, table_list, alter_info->tablespace_op);
1360
 
  }
1361
 
 
1362
 
  session->set_proc_info("init");
1363
 
 
1364
 
  if (not (table= session->openTableLock(table_list, TL_WRITE_ALLOW_READ)))
1365
 
    return true;
1366
 
 
1367
 
  session->set_proc_info("gained write lock on table");
1368
 
 
1369
 
  /* 
1370
 
    Check that we are not trying to rename to an existing table,
1371
 
    if one existed we get a lock, if we can't we error.
1372
 
  */
1373
 
  {
1374
 
    Table *name_lock= NULL;
1375
 
 
1376
 
    if (not lockTableIfDifferent(*session, original_table_identifier, new_table_identifier, name_lock))
1377
 
    {
1378
 
      return true;
1379
 
    }
1380
 
 
1381
 
    error= internal_alter_table(session,
1382
 
                                table,
1383
 
                                original_table_identifier,
1384
 
                                new_table_identifier,
1385
 
                                create_info,
1386
 
                                original_proto,
1387
 
                                create_proto,
1388
 
                                table_list,
1389
 
                                alter_info,
1390
 
                                order_num,
1391
 
                                order,
1392
 
                                ignore);
1393
 
 
1394
 
    if (name_lock)
1395
 
    {
1396
 
      LOCK_open.lock(); /* ALTER TABLe */
1397
 
      session->unlink_open_table(name_lock);
1398
 
      LOCK_open.unlock();
1399
 
    }
1400
 
  }
1401
 
 
1402
 
  return error;
1403
 
}
1404
 
/* alter_table */
1405
 
 
1406
 
static int
1407
 
copy_data_between_tables(Session *session,
1408
 
                         Table *from, Table *to,
1409
 
                         List<CreateField> &create,
1410
 
                         bool ignore,
1411
 
                         uint32_t order_num, order_st *order,
1412
 
                         ha_rows *copied,
1413
 
                         ha_rows *deleted,
1414
 
                         enum enum_enable_or_disable keys_onoff,
1415
 
                         bool error_if_not_empty)
1416
 
{
1417
 
  int error= 0;
1418
 
  CopyField *copy,*copy_end;
1419
 
  ulong found_count,delete_count;
1420
 
  uint32_t length= 0;
1421
 
  SortField *sortorder;
1422
 
  ReadRecord info;
1423
 
  TableList   tables;
1424
 
  List<Item>   fields;
1425
 
  List<Item>   all_fields;
1426
 
  ha_rows examined_rows;
1427
 
  bool auto_increment_field_copied= 0;
1428
 
  uint64_t prev_insert_id;
1429
 
 
1430
 
  /*
1431
 
    Turn off recovery logging since rollback of an alter table is to
1432
 
    delete the new table so there is no need to log the changes to it.
1433
 
 
1434
 
    This needs to be done before external_lock
1435
 
  */
1436
 
  TransactionServices &transaction_services= TransactionServices::singleton();
1437
 
 
1438
 
  /* 
1439
 
   * LP Bug #552420 
1440
 
   *
1441
 
   * Since open_temporary_table() doesn't invoke mysql_lock_tables(), we
1442
 
   * don't get the usual automatic call to StorageEngine::startStatement(), so
1443
 
   * we manually call it here...
1444
 
   */
1445
 
  to->s->getEngine()->startStatement(session);
1446
 
 
1447
 
  if (!(copy= new CopyField[to->getShare()->sizeFields()]))
1448
 
    return -1;
1449
 
 
1450
 
  if (to->cursor->ha_external_lock(session, F_WRLCK))
1451
 
    return -1;
1452
 
 
1453
 
  /* We need external lock before we can disable/enable keys */
1454
 
  alter_table_manage_keys(session, to, from->cursor->indexes_are_disabled(), keys_onoff);
1455
 
 
1456
 
  /* We can abort alter table for any table type */
1457
 
  session->abort_on_warning= !ignore;
1458
 
 
1459
 
  from->cursor->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
1460
 
  to->cursor->ha_start_bulk_insert(from->cursor->stats.records);
1461
 
 
1462
 
  List_iterator<CreateField> it(create);
1463
 
  CreateField *def;
1464
 
  copy_end=copy;
1465
 
  for (Field **ptr= to->getFields(); *ptr ; ptr++)
1466
 
  {
1467
 
    def=it++;
1468
 
    if (def->field)
1469
 
    {
1470
 
      if (*ptr == to->next_number_field)
1471
 
        auto_increment_field_copied= true;
1472
 
 
1473
 
      (copy_end++)->set(*ptr,def->field,0);
1474
 
    }
1475
 
 
1476
 
  }
1477
 
 
1478
 
  found_count=delete_count=0;
1479
 
 
1480
 
  if (order)
1481
 
  {
1482
 
    if (to->getShare()->hasPrimaryKey() && to->cursor->primary_key_is_clustered())
1483
 
    {
1484
 
      char warn_buff[DRIZZLE_ERRMSG_SIZE];
1485
 
      snprintf(warn_buff, sizeof(warn_buff),
1486
 
               _("order_st BY ignored because there is a user-defined clustered "
1487
 
                 "index in the table '%-.192s'"),
1488
 
               from->getMutableShare()->getTableName());
1489
 
      push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
1490
 
                   warn_buff);
1491
 
    }
1492
 
    else
1493
 
    {
1494
 
      from->sort.io_cache= new internal::IO_CACHE;
1495
 
 
1496
 
      memset(&tables, 0, sizeof(tables));
1497
 
      tables.table= from;
1498
 
      tables.alias= tables.table_name= const_cast<char *>(from->getMutableShare()->getTableName());
1499
 
      tables.db= const_cast<char *>(from->getMutableShare()->getSchemaName());
1500
 
      error= 1;
1501
 
 
1502
 
      if (session->lex->select_lex.setup_ref_array(session, order_num) ||
1503
 
          setup_order(session, session->lex->select_lex.ref_pointer_array,
1504
 
                      &tables, fields, all_fields, order) ||
1505
 
          !(sortorder= make_unireg_sortorder(order, &length, NULL)) ||
1506
 
          (from->sort.found_records= filesort(session, from, sortorder, length,
1507
 
                                              (optimizer::SqlSelect *) 0, HA_POS_ERROR,
1508
 
                                              1, &examined_rows)) ==
1509
 
          HA_POS_ERROR)
1510
 
      {
1511
 
        goto err;
1512
 
      }
1513
 
    }
1514
 
  }
1515
 
 
1516
 
  /* Tell handler that we have values for all columns in the to table */
1517
 
  to->use_all_columns();
1518
 
  info.init_read_record(session, from, (optimizer::SqlSelect *) 0, 1, true);
1519
 
  if (ignore)
1520
 
    to->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
1521
 
  session->row_count= 0;
1522
 
  to->restoreRecordAsDefault();        // Create empty record
1523
 
  while (!(error=info.read_record(&info)))
1524
 
  {
1525
 
    if (session->killed)
1526
 
    {
1527
 
      session->send_kill_message();
1528
 
      error= 1;
1529
 
      break;
1530
 
    }
1531
 
    session->row_count++;
1532
 
    /* Return error if source table isn't empty. */
1533
 
    if (error_if_not_empty)
1534
 
    {
1535
 
      error= 1;
1536
 
      break;
1537
 
    }
1538
 
    if (to->next_number_field)
1539
 
    {
1540
 
      if (auto_increment_field_copied)
1541
 
        to->auto_increment_field_not_null= true;
1542
 
      else
1543
 
        to->next_number_field->reset();
1544
 
    }
1545
 
 
1546
 
    for (CopyField *copy_ptr=copy ; copy_ptr != copy_end ; copy_ptr++)
1547
 
    {
1548
 
      copy_ptr->do_copy(copy_ptr);
1549
 
    }
1550
 
    prev_insert_id= to->cursor->next_insert_id;
1551
 
    error= to->cursor->insertRecord(to->record[0]);
1552
 
    to->auto_increment_field_not_null= false;
1553
 
 
1554
 
    if (error)
1555
 
    { 
1556
 
      if (!ignore ||
1557
 
          to->cursor->is_fatal_error(error, HA_CHECK_DUP))
1558
 
      { 
1559
 
        to->print_error(error, MYF(0));
1560
 
        break;
1561
 
      }
1562
 
      to->cursor->restore_auto_increment(prev_insert_id);
1563
 
      delete_count++;
1564
 
    }
1565
 
    else
1566
 
    {
1567
 
      found_count++;
1568
 
    }
1569
 
  }
1570
 
 
1571
 
  info.end_read_record();
1572
 
  from->free_io_cache();
1573
 
  delete [] copy;                               // This is never 0
1574
 
 
1575
 
  if (to->cursor->ha_end_bulk_insert() && error <= 0)
1576
 
  {
1577
 
    to->print_error(errno, MYF(0));
1578
 
    error=1;
1579
 
  }
1580
 
  to->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1581
 
 
1582
 
  /*
1583
 
    Ensure that the new table is saved properly to disk so that we
1584
 
    can do a rename
1585
 
  */
1586
 
  if (transaction_services.autocommitOrRollback(session, false))
1587
 
    error=1;
1588
 
  if (! session->endActiveTransaction())
1589
 
    error=1;
1590
 
 
1591
 
 err:
1592
 
  session->abort_on_warning= 0;
1593
 
  from->free_io_cache();
1594
 
  *copied= found_count;
1595
 
  *deleted=delete_count;
1596
 
  to->cursor->ha_release_auto_increment();
1597
 
  if (to->cursor->ha_external_lock(session,F_UNLCK))
1598
 
    error=1;
1599
 
 
1600
 
  return(error > 0 ? -1 : 0);
1601
 
}
1602
 
 
1603
 
static int
1604
 
create_temporary_table(Session *session,
1605
 
                       TableIdentifier &identifier,
1606
 
                       HA_CREATE_INFO *create_info,
1607
 
                       message::Table &create_proto,
1608
 
                       AlterInfo *alter_info)
1609
 
{
1610
 
  int error;
1611
 
 
1612
 
  /*
1613
 
    Create a table with a temporary name.
1614
 
    We don't log the statement, it will be logged later.
1615
 
  */
1616
 
  create_proto.set_name(identifier.getTableName());
1617
 
 
1618
 
  create_proto.mutable_engine()->set_name(create_info->db_type->getName());
1619
 
 
1620
 
  error= mysql_create_table(session,
1621
 
                            identifier,
1622
 
                            create_info, create_proto, alter_info, true, 0, false);
1623
 
 
1624
 
  return error;
1625
 
}
1626
 
 
1627
 
static Table *open_alter_table(Session *session, Table *table, TableIdentifier &identifier)
1628
 
{
1629
 
  Table *new_table;
1630
 
 
1631
 
  /* Open the table so we need to copy the data to it. */
1632
 
  if (table->getShare()->getType())
1633
 
  {
1634
 
    TableList tbl;
1635
 
    tbl.db= const_cast<char *>(identifier.getSchemaName().c_str());
1636
 
    tbl.alias= const_cast<char *>(identifier.getTableName().c_str());
1637
 
    tbl.table_name= const_cast<char *>(identifier.getTableName().c_str());
1638
 
 
1639
 
    /* Table is in session->temporary_tables */
1640
 
    new_table= session->openTable(&tbl, (bool*) 0, DRIZZLE_LOCK_IGNORE_FLUSH);
1641
 
  }
1642
 
  else
1643
 
  {
1644
 
    /* Open our intermediate table */
1645
 
    new_table= session->open_temporary_table(identifier, false);
1646
 
  }
1647
 
 
1648
 
  return new_table;
1649
 
}
1650
 
 
1651
 
} /* namespace drizzled */