← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/statement/alter_table.cc

  • Committer: Brian Aker
  • Date: 2009-01-24 09:43:35 UTC
  • Revision ID: brian@gir-3.local-20090124094335-6qdtvc35gl5fvivz
Adding in an example singe thread scheduler

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