← 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: 2011-01-22 07:12:16 UTC
  • mfrom: (2096.1.16 alter-table)
  • Revision ID: brian@tangent.org-20110122071216-j0e8bwecb1cqefm9
Merge in work for parser cleanup.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/statement/alter_table.cc
75
75
 
76
76
static Table *open_alter_table(Session *session, Table *table, identifier::Table &identifier);
77
77
 
 
78
namespace statement {
 
79
 
 
80
AlterTable::AlterTable(Session *in_session, Table_ident *ident, drizzled::ha_build_method build_arg) :
 
81
  CreateTable(in_session)
 
82
{ 
 
83
  in_session->lex->sql_command= SQLCOM_ALTER_TABLE;
 
84
  (void)ident;
 
85
  alter_info.build_method= build_arg;
 
86
}
 
87
 
 
88
} // namespace statement
 
89
 
78
90
bool statement::AlterTable::execute()
79
91
{
80
92
  TableList *first_table= (TableList *) session->lex->select_lex.table_list.first;
92
104
 
93
105
    if (create_info().db_type == NULL)
94
106
    {
95
 
      my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), 
96
 
               createTableMessage().engine().name().c_str());
 
107
      my_error(createTableMessage().engine().name(), ER_UNKNOWN_STORAGE_ENGINE, MYF(0));
97
108
 
98
109
      return true;
99
110
    }
108
119
    identifier::Table identifier(first_table->getSchemaName(), first_table->getTableName());
109
120
    if (plugin::StorageEngine::getTableDefinition(*session, identifier, original_table_message) != EEXIST)
110
121
    {
111
 
      std::string path;
112
 
      identifier.getSQLPath(path);
113
 
      my_error(ER_BAD_TABLE_ERROR, MYF(0), path.c_str());
 
122
      my_error(ER_BAD_TABLE_ERROR, identifier);
114
123
      return true;
115
124
    }
116
125
 
121
130
 
122
131
      if (not create_info().db_type)
123
132
      {
124
 
        std::string path;
125
 
        identifier.getSQLPath(path);
126
 
        my_error(ER_BAD_TABLE_ERROR, MYF(0), path.c_str());
 
133
        my_error(ER_BAD_TABLE_ERROR, identifier);
127
134
        return true;
128
135
      }
129
136
    }
420
427
      */
421
428
      if (alter_info->build_method == HA_BUILD_ONLINE)
422
429
      {
423
 
        my_error(ER_NOT_SUPPORTED_YET, MYF(0), session->getQueryString()->c_str());
 
430
        my_error(*session->getQueryString(), ER_NOT_SUPPORTED_YET);
424
431
        return true;
425
432
      }
426
433
 
521
528
    }
522
529
    if (key_parts.elements)
523
530
    {
524
 
      key_create_information_st key_create_info;
 
531
      key_create_information_st key_create_info= default_key_create_info;
525
532
      Key *key;
526
 
      enum Key::Keytype key_type;
527
 
      memset(&key_create_info, 0, sizeof(key_create_info));
 
533
      Key::Keytype key_type;
528
534
 
529
535
      key_create_info.algorithm= key_info->algorithm;
 
536
 
530
537
      if (key_info->flags & HA_USES_BLOCK_SIZE)
531
538
        key_create_info.block_size= key_info->block_size;
 
539
 
532
540
      if (key_info->flags & HA_USES_COMMENT)
533
541
        key_create_info.comment= key_info->comment;
534
542
 
540
548
          key_type= Key::UNIQUE;
541
549
      }
542
550
      else
 
551
      {
543
552
        key_type= Key::MULTIPLE;
 
553
      }
544
554
 
545
555
      key= new Key(key_type,
546
556
                   key_name,
812
822
 
813
823
      if (session.find_temporary_table(new_table_identifier))
814
824
      {
815
 
        std::string path;
816
 
        new_table_identifier.getSQLPath(path);
817
 
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), path.c_str());
 
825
        my_error(ER_TABLE_EXISTS_ERROR, new_table_identifier);
818
826
        return false;
819
827
      }
820
828
    }
951
959
  if (original_engine->check_flag(HTON_BIT_ALTER_NOT_SUPPORTED) ||
952
960
      new_engine->check_flag(HTON_BIT_ALTER_NOT_SUPPORTED))
953
961
  {
954
 
    std::string path;
955
 
    new_table_identifier.getSQLPath(path);
956
 
    my_error(ER_ILLEGAL_HA, MYF(0), path.c_str());
 
962
    my_error(ER_ILLEGAL_HA, new_table_identifier);
957
963
 
958
964
    return true;
959
965
  }