← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/statement/alter_table.cc

  • Committer: Lee Bieber
  • Date: 2011-02-11 20:30:05 UTC
  • mfrom: (2157.1.3 build)
  • Revision ID: kalebral@gmail.com-20110211203005-757o1y2yf78dxzqr
Merge Stewart - 716848: drizzleimport displays wrong program_name
Merge Stewart - update README file
Merge Andrew and Joe - Exposes the InnoDB SYS_REPLICATION_LOG to data_dictionary so that it is fast and fixes many issues we have been having

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/statement/alter_table.cc
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#include <config.h>
 
21
#include "config.h"
22
22
 
23
23
#include <fcntl.h>
24
24
 
25
25
#include <sstream>
26
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
 
#include <drizzled/plugin/storage_engine.h>
45
 
#include <drizzled/copy_field.h>
46
 
 
47
 
#include <drizzled/transaction_services.h>
48
 
 
49
 
#include <drizzled/filesort.h>
50
 
 
51
 
#include <drizzled/message.h>
 
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"
52
50
 
53
51
using namespace std;
54
52
 
82
80
AlterTable::AlterTable(Session *in_session, Table_ident *ident, drizzled::ha_build_method build_arg) :
83
81
  CreateTable(in_session)
84
82
{ 
85
 
  in_session->getLex()->sql_command= SQLCOM_ALTER_TABLE;
 
83
  in_session->lex->sql_command= SQLCOM_ALTER_TABLE;
86
84
  (void)ident;
87
85
  alter_info.build_method= build_arg;
88
86
}
91
89
 
92
90
bool statement::AlterTable::execute()
93
91
{
94
 
  TableList *first_table= (TableList *) getSession()->getLex()->select_lex.table_list.first;
95
 
  TableList *all_tables= getSession()->getLex()->query_tables;
 
92
  TableList *first_table= (TableList *) getSession()->lex->select_lex.table_list.first;
 
93
  TableList *all_tables= getSession()->lex->query_tables;
96
94
  assert(first_table == all_tables && first_table != 0);
97
 
  Select_Lex *select_lex= &getSession()->getLex()->select_lex;
 
95
  Select_Lex *select_lex= &getSession()->lex->select_lex;
98
96
  bool need_start_waiting= false;
99
97
 
100
98
  is_engine_set= not createTableMessage().engine().name().empty();
119
117
  message::table::shared_ptr original_table_message;
120
118
  {
121
119
    identifier::Table identifier(first_table->getSchemaName(), first_table->getTableName());
122
 
    if (not (original_table_message= plugin::StorageEngine::getTableMessage(*getSession(), identifier)))
 
120
    if (plugin::StorageEngine::getTableDefinition(*getSession(), identifier, original_table_message) != EEXIST)
123
121
    {
124
122
      my_error(ER_BAD_TABLE_ERROR, identifier);
125
123
      return true;
155
153
  {
156
154
    identifier::Table identifier(first_table->getSchemaName(), first_table->getTableName());
157
155
    identifier::Table new_identifier(select_lex->db ? select_lex->db : first_table->getSchemaName(),
158
 
                                   getSession()->getLex()->name.str ? getSession()->getLex()->name.str : first_table->getTableName());
 
156
                                   getSession()->lex->name.str ? getSession()->lex->name.str : first_table->getTableName());
159
157
 
160
158
    res= alter_table(getSession(), 
161
159
                     identifier,
167
165
                     &alter_info,
168
166
                     select_lex->order_list.elements,
169
167
                     (Order *) select_lex->order_list.first,
170
 
                     getSession()->getLex()->ignore);
 
168
                     getSession()->lex->ignore);
171
169
  }
172
170
  else
173
171
  {
177
175
    {
178
176
      identifier::Table identifier(first_table->getSchemaName(), first_table->getTableName(), table->getMutableShare()->getPath());
179
177
      identifier::Table new_identifier(select_lex->db ? select_lex->db : first_table->getSchemaName(),
180
 
                                       getSession()->getLex()->name.str ? getSession()->getLex()->name.str : first_table->getTableName(),
 
178
                                       getSession()->lex->name.str ? getSession()->lex->name.str : first_table->getTableName(),
181
179
                                       table->getMutableShare()->getPath());
182
180
 
183
181
      res= alter_table(getSession(), 
190
188
                       &alter_info,
191
189
                       select_lex->order_list.elements,
192
190
                       (Order *) select_lex->order_list.first,
193
 
                       getSession()->getLex()->ignore);
 
191
                       getSession()->lex->ignore);
194
192
    }
195
193
  }
196
194
 
255
253
  List<CreateField> new_create_list;
256
254
  /* New key definitions are added here */
257
255
  List<Key> new_key_list;
258
 
  List<AlterDrop>::iterator drop_it(alter_info->drop_list.begin());
259
 
  List<CreateField>::iterator def_it(alter_info->create_list.begin());
260
 
  List<AlterColumn>::iterator alter_it(alter_info->alter_list.begin());
261
 
  List<Key>::iterator key_it(alter_info->key_list.begin());
262
 
  List<CreateField>::iterator find_it(new_create_list.begin());
263
 
  List<CreateField>::iterator field_it(new_create_list.begin());
 
256
  List_iterator<AlterDrop> drop_it(alter_info->drop_list);
 
257
  List_iterator<CreateField> def_it(alter_info->create_list);
 
258
  List_iterator<AlterColumn> alter_it(alter_info->alter_list);
 
259
  List_iterator<Key> key_it(alter_info->key_list);
 
260
  List_iterator<CreateField> find_it(new_create_list);
 
261
  List_iterator<CreateField> field_it(new_create_list);
264
262
  List<Key_part_spec> key_parts;
265
263
  uint32_t used_fields= create_info->used_fields;
266
264
  KeyInfo *key_info= table->key_info;
291
289
  {
292
290
    /* Check if field should be dropped */
293
291
    AlterDrop *drop;
294
 
    drop_it= alter_info->drop_list.begin();
 
292
    drop_it.rewind();
295
293
    while ((drop= drop_it++))
296
294
    {
297
295
      if (drop->type == AlterDrop::COLUMN &&
318
316
    field->setReadSet();
319
317
 
320
318
    /* Check if field is changed */
321
 
    def_it= alter_info->create_list.begin();
 
319
    def_it.rewind();
322
320
    while ((def= def_it++))
323
321
    {
324
322
      if (def->change &&
344
342
      */
345
343
      def= new CreateField(field, field);
346
344
      new_create_list.push_back(def);
347
 
      alter_it= alter_info->alter_list.begin(); /* Change default if ALTER */
 
345
      alter_it.rewind(); /* Change default if ALTER */
348
346
      AlterColumn *alter;
349
347
 
350
348
      while ((alter= alter_it++))
375
373
    }
376
374
  }
377
375
 
378
 
  def_it= alter_info->create_list.begin();
 
376
  def_it.rewind();
379
377
  while ((def= def_it++)) /* Add new columns */
380
378
  {
381
379
    if (def->change && ! def->field)
401
399
    else
402
400
    {
403
401
      CreateField *find;
404
 
      find_it= new_create_list.begin();
 
402
      find_it.rewind();
405
403
 
406
404
      while ((find= find_it++)) /* Add new columns */
407
405
      {
463
461
    char *key_name= key_info->name;
464
462
    AlterDrop *drop;
465
463
 
466
 
    drop_it= alter_info->drop_list.begin();
 
464
    drop_it.rewind();
467
465
    while ((drop= drop_it++))
468
466
    {
469
467
      if (drop->type == AlterDrop::KEY &&
478
476
    }
479
477
 
480
478
    KeyPartInfo *key_part= key_info->key_part;
481
 
    key_parts.clear();
 
479
    key_parts.empty();
482
480
    for (uint32_t j= 0; j < key_info->key_parts; j++, key_part++)
483
481
    {
484
482
      if (! key_part->field)
486
484
 
487
485
      const char *key_part_name= key_part->field->field_name;
488
486
      CreateField *cfield;
489
 
      field_it= new_create_list.begin();
 
487
      field_it.rewind();
490
488
      while ((cfield= field_it++))
491
489
      {
492
490
        if (cfield->change)
568
566
  for (int32_t j= 0; j < original_proto.fk_constraint_size(); j++)
569
567
  {
570
568
    AlterDrop *drop;
571
 
    drop_it= alter_info->drop_list.begin();
 
569
    drop_it.rewind();
572
570
    while ((drop= drop_it++))
573
571
    {
574
572
      if (drop->type == AlterDrop::FOREIGN_KEY &&
1487
1485
  from->cursor->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
1488
1486
  to->cursor->ha_start_bulk_insert(from->cursor->stats.records);
1489
1487
 
1490
 
  List<CreateField>::iterator it(create.begin());
 
1488
  List_iterator<CreateField> it(create);
1491
1489
  CreateField *def;
1492
1490
  copy_end= copy;
1493
1491
  for (Field **ptr= to->getFields(); *ptr ; ptr++)
1525
1523
        from->sort.io_cache= new internal::IO_CACHE;
1526
1524
 
1527
1525
        tables.table= from;
1528
 
        tables.setTableName(from->getMutableShare()->getTableName());
1529
 
        tables.alias= tables.getTableName();
 
1526
        tables.setTableName(const_cast<char *>(from->getMutableShare()->getTableName()));
 
1527
        tables.alias= const_cast<char *>(tables.getTableName());
1530
1528
        tables.setSchemaName(const_cast<char *>(from->getMutableShare()->getSchemaName()));
1531
1529
        error= 1;
1532
1530
 
1533
 
        if (session->getLex()->select_lex.setup_ref_array(session, order_num) ||
1534
 
            setup_order(session, session->getLex()->select_lex.ref_pointer_array,
 
1531
        if (session->lex->select_lex.setup_ref_array(session, order_num) ||
 
1532
            setup_order(session, session->lex->select_lex.ref_pointer_array,
1535
1533
                        &tables, fields, all_fields, order) ||
1536
1534
            !(sortorder= make_unireg_sortorder(order, &length, NULL)) ||
1537
1535
            (from->sort.found_records= filesort.run(from, sortorder, length,