28#include <drizzled/lock.h>
29#include <drizzled/session.h>
30#include <drizzled/statement/alter_table.h>
31#include <drizzled/charset.h>
32#include <drizzled/gettext.h>
33#include <drizzled/data_home.h>
35#include <drizzled/table_proto.h>
36#include <drizzled/optimizer/range.h>
37#include <drizzled/time_functions.h>
38#include <drizzled/records.h>
39#include <drizzled/pthread_globals.h>
40#include <drizzled/internal/my_sys.h>
41#include <drizzled/internal/iocache.h>
42#include <drizzled/plugin/storage_engine.h>
43#include <drizzled/copy_field.h>
44#include <drizzled/transaction_services.h>
45#include <drizzled/filesort.h>
46#include <drizzled/message.h>
47#include <drizzled/message/alter_table.pb.h>
48#include <drizzled/alter_column.h>
49#include <drizzled/alter_info.h>
50#include <drizzled/util/test.h>
51#include <drizzled/open_tables_state.h>
52#include <drizzled/table/cache.h>
53#include <drizzled/create_field.h>
54#include <drizzled/catalog/instance.h>
55#include <drizzled/key_part_info.h>
61extern pid_t current_pid;
63static int copy_data_between_tables(
Session *session,
71 message::AlterTable &alter_table_message,
72 bool error_if_not_empty);
76 HA_CREATE_INFO *create_info,
77 const message::Table &original_proto,
78 message::Table &table_message,
79 message::AlterTable &alter_table_message,
84static int apply_online_alter_keys_onoff(
Session *session,
86 const message::AlterTable::AlterKeysOnOff &op);
88static int apply_online_rename_table(
Session *session,
93 const message::AlterTable::RenameTable &alter_operation);
97AlterTable::AlterTable(Session *in_session, Table_ident *) :
100 set_command(SQLCOM_ALTER_TABLE);
108 TableList *all_tables= lex().query_tables;
109 assert(first_table == all_tables && first_table != 0);
110 Select_Lex *select_lex= &lex().select_lex;
112 is_engine_set= not createTableMessage().engine().name().empty();
116 create_info().db_type=
117 plugin::StorageEngine::findByName(session(), createTableMessage().engine().name());
119 if (create_info().db_type == NULL)
121 my_error(createTableMessage().engine().name(), ER_UNKNOWN_STORAGE_ENGINE, MYF(0));
128 assert(select_lex->db);
131 message::table::shared_ptr original_table_message;
134 first_table->getSchemaName(),
135 first_table->getTableName());
136 if (not (original_table_message= plugin::StorageEngine::getTableMessage(session(), identifier)))
138 my_error(ER_BAD_TABLE_ERROR, identifier);
142 if (not create_info().db_type)
144 create_info().db_type=
145 plugin::StorageEngine::findByName(session(), original_table_message->engine().name());
147 if (not create_info().db_type)
149 my_error(ER_BAD_TABLE_ERROR, identifier);
155 if (not validateCreateTableOption())
158 if (session().inTransaction())
160 my_error(ER_TRANSACTIONAL_DDL_NOT_SUPPORTED, MYF(0));
164 if (session().wait_if_global_read_lock(0, 1))
168 if (original_table_message->type() == message::Table::STANDARD )
171 first_table->getSchemaName(),
172 first_table->getTableName());
174 select_lex->db ? select_lex->db : first_table->getSchemaName(),
175 lex().name.data() ? lex().name.data() : first_table->getTableName());
177 res= alter_table(&session(),
181 *original_table_message,
182 createTableMessage(),
185 select_lex->order_list.size(),
186 (
Order *) select_lex->order_list.first,
192 first_table->getSchemaName(),
193 first_table->getTableName());
194 Table *table= session().open_tables.find_temporary_table(catch22);
198 first_table->getSchemaName(),
199 first_table->getTableName(),
200 table->getMutableShare()->getPath());
203 select_lex->db ? select_lex->db : first_table->getSchemaName(),
204 lex().name.data() ? lex().name.data() : first_table->getTableName(),
205 table->getMutableShare()->getPath());
207 res= alter_table(&session(),
211 *original_table_message,
212 createTableMessage(),
215 select_lex->order_list.size(),
216 (
Order *) select_lex->order_list.first,
225 session().startWaitingGlobalReadLock();
273 HA_CREATE_INFO *create_info,
274 const message::Table &original_proto,
275 message::Table &table_message,
276 message::AlterTable &alter_table_message,
279 uint32_t used_fields= create_info->used_fields;
280 vector<string> drop_keys;
281 vector<string> drop_columns;
282 vector<string> drop_fkeys;
283 vector<const message::AlterTable::RenameKey *> rename_keys;
285 for (
const message::AlterTable::RenameKey &rename_key : alter_table_message.rename_keys())
287 if (not system_charset_info->strcasecmp(rename_key.old_name().c_str(),
"PRIMARY"))
289 my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), rename_key.old_name().c_str());
292 if (not system_charset_info->strcasecmp(rename_key.new_name().c_str(),
"PRIMARY"))
294 my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), rename_key.new_name().c_str());
297 rename_keys.push_back(&rename_key);
302 for (
int operationnr= 0; operationnr < alter_table_message.operations_size();
305 const message::AlterTable::AlterTableOperation &operation=
306 alter_table_message.operations(operationnr);
308 switch (operation.operation())
310 case message::AlterTable::AlterTableOperation::DROP_KEY:
311 drop_keys.push_back(operation.drop_name());
313 case message::AlterTable::AlterTableOperation::DROP_COLUMN:
314 drop_columns.push_back(operation.drop_name());
316 case message::AlterTable::AlterTableOperation::DROP_FOREIGN_KEY:
317 drop_fkeys.push_back(operation.drop_name());
325 message::Table::TableOptions *table_options= table_message.mutable_options();
327 if (not (used_fields & HA_CREATE_USED_DEFAULT_CHARSET))
328 create_info->default_table_charset= table->getShare()->table_charset;
330 if (not (used_fields & HA_CREATE_USED_AUTO) && table->found_next_number_field)
333 table->cursor->info(HA_STATUS_AUTO);
334 create_info->auto_increment_value= table->cursor->stats.auto_increment_value;
335 if (create_info->auto_increment_value != original_proto.options().auto_increment_value())
336 table_options->set_has_user_set_auto_increment_value(
false);
339 table->restoreRecordAsDefault();
345 for (
Field **f_ptr= table->getFields(); (field= *f_ptr); f_ptr++)
348 vector<string>::iterator it= drop_columns.begin();
349 while (it != drop_columns.end())
351 if (not system_charset_info->strcasecmp(field->field_name, it->c_str()))
354 if (MTYP_TYPENR(field->unireg_check) == Field::NEXT_NUMBER &&
355 not (used_fields & HA_CREATE_USED_AUTO))
357 create_info->auto_increment_value= 0;
358 create_info->used_fields|= HA_CREATE_USED_AUTO;
365 if (it != drop_columns.end())
367 drop_columns.erase(it);
376 List<CreateField>::iterator def_it= alter_info->create_list.begin();
377 while ((def= def_it++))
380 ! system_charset_info->strcasecmp(field->field_name, def->
change))
390 new_create_list.push_back(def);
401 new_create_list.push_back(def);
402 AlterInfo::alter_list_t::iterator alter(alter_info->alter_list.begin());
404 for (; alter != alter_info->alter_list.end(); alter++)
406 if (not system_charset_info->strcasecmp(field->field_name, alter->name))
410 if (alter != alter_info->alter_list.end())
412 def->setDefaultValue(alter->def, NULL);
414 alter_info->alter_list.erase(alter);
420 List<CreateField>::iterator def_it= alter_info->create_list.begin();
421 while ((def= def_it++))
423 if (def->
change && ! def->field)
425 my_error(ER_BAD_FIELD_ERROR, MYF(0), def->
change, table->getMutableShare()->getTableName());
431 if (not (~def->flags & (NO_DEFAULT_VALUE_FLAG | NOT_NULL_FLAG)) and not def->
change)
433 alter_info->error_if_not_empty=
true;
437 new_create_list.push_back(def);
439 else if (def->
after == first_keyword)
441 new_create_list.push_front(def);
446 List<CreateField>::iterator find_it= new_create_list.begin();
448 while ((find= find_it++))
456 my_error(ER_BAD_FIELD_ERROR, MYF(0), def->
after, table->getMutableShare()->getTableName());
472 if (alter_table_message.build_method() == message::AlterTable::BUILD_ONLINE)
474 my_error(*session->getQueryString(), ER_NOT_SUPPORTED_YET);
480 if (not alter_info->alter_list.empty())
482 my_error(ER_BAD_FIELD_ERROR, MYF(0), alter_info->alter_list.front().name, table->getMutableShare()->getTableName());
486 if (new_create_list.is_empty())
488 my_message(ER_CANT_REMOVE_ALL_FIELDS, ER(ER_CANT_REMOVE_ALL_FIELDS), MYF(0));
496 KeyInfo *key_info= table->key_info;
497 for (uint32_t i= 0; i < table->getShare()->sizeKeys(); i++, key_info++)
499 const char *key_name= key_info->name;
501 vector<string>::iterator it= drop_keys.begin();
502 while (it != drop_keys.end())
504 if (not system_charset_info->strcasecmp(key_name, it->c_str()))
509 if (it != drop_keys.end())
515 const char *new_key_name= key_name;
516 bool generated= key_info->flags & HA_GENERATED_KEY;
517 for (
auto rename_it= rename_keys.begin(); rename_it != rename_keys.end(); ++rename_it)
519 if (not system_charset_info->strcasecmp(key_name, (*rename_it)->old_name().c_str()))
521 new_key_name= (*rename_it)->new_name().c_str();
527 rename_keys.erase(rename_it);
534 for (uint32_t j= 0; j < key_info->key_parts; j++, key_part++)
536 if (not key_part->field)
539 const char *key_part_name= key_part->field->
field_name;
541 List<CreateField>::iterator field_it= new_create_list.begin();
542 while ((cfield= field_it++))
546 if (not system_charset_info->strcasecmp(key_part_name, cfield->
change))
549 else if (not system_charset_info->strcasecmp(key_part_name, cfield->
field_name))
556 uint32_t key_part_length= key_part->length;
575 (cfield->
length < key_part_length / key_part->field->charset()->mbmaxlen)))
578 key_part_length/= key_part->field->charset()->mbmaxlen;
581 if (key_parts.size())
584 key_create_info.algorithm= key_info->algorithm;
586 if (key_info->flags & HA_USES_BLOCK_SIZE)
587 key_create_info.block_size= key_info->block_size;
589 if (key_info->flags & HA_USES_COMMENT)
590 key_create_info.comment= key_info->comment;
592 Key::Keytype key_type= key_info->flags & HA_NOSAME
593 ? (is_primary_key(key_name) ? Key::PRIMARY : Key::UNIQUE)
595 new_key_list.push_back(
new Key(key_type, str_ref(new_key_name), &key_create_info, generated, key_parts));
599 for (
const message::AlterTable::RenameKey *rename_key : rename_keys)
601 if (not rename_key->if_exists())
603 my_error(ER_KEY_DOES_NOT_EXITS, MYF(0),
604 rename_key->old_name().c_str(),
605 table->getShare()->getTableName());
608 push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
609 ER_KEY_DOES_NOT_EXITS, ER(ER_KEY_DOES_NOT_EXITS),
610 rename_key->old_name().c_str(),
611 table->getShare()->getTableName());
615 for (int32_t j= 0; j < original_proto.fk_constraint_size(); j++)
617 vector<string>::iterator it= drop_fkeys.begin();
618 while (it != drop_fkeys.end())
620 if (! system_charset_info->strcasecmp(original_proto.fk_constraint(j).name().c_str(), it->c_str()))
627 if (it != drop_fkeys.end())
629 drop_fkeys.erase(it);
633 message::Table::ForeignKeyConstraint *pfkey= table_message.add_fk_constraint();
634 *pfkey= original_proto.fk_constraint(j);
639 List<Key>::iterator key_it(alter_info->key_list.begin());
640 while ((key= key_it++))
642 if (key->type == Key::FOREIGN_KEY)
644 if (((
Foreign_key *)key)->validate(new_create_list))
650 add_foreign_key_to_table_message(&table_message,
660 if (key->type != Key::FOREIGN_KEY)
661 new_key_list.push_back(key);
663 if (key->name.data() && is_primary_key(key->name.data()))
665 my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name.data());
672 for (
int j= 0; j < table_message.fk_constraint_size(); j++)
674 if (! table_message.fk_constraint(j).has_name())
676 std::string name(table->getMutableShare()->getTableName());
679 name.append(
"_ibfk_");
680 snprintf(number,
sizeof(number),
"%d", j+1);
683 message::Table::ForeignKeyConstraint *pfkey= table_message.mutable_fk_constraint(j);
684 pfkey->set_name(name);
688 if (drop_keys.size())
690 my_error(ER_CANT_DROP_FIELD_OR_KEY,
692 drop_keys.front().c_str());
696 if (drop_columns.size())
698 my_error(ER_CANT_DROP_FIELD_OR_KEY,
700 drop_columns.front().c_str());
704 if (drop_fkeys.size())
706 my_error(ER_CANT_DROP_FIELD_OR_KEY,
708 drop_fkeys.front().c_str());
712 if (not alter_info->alter_list.empty())
714 my_error(ER_CANT_DROP_FIELD_OR_KEY,
716 alter_info->alter_list.front().name);
720 if (not table_message.options().has_comment()
721 && table->getMutableShare()->hasComment())
723 table_options->set_comment(table->getMutableShare()->getComment());
726 if (table->getShare()->getType())
728 table_message.set_type(message::Table::TEMPORARY);
731 table_message.set_creation_timestamp(table->getShare()->getTableMessage()->creation_timestamp());
732 table_message.set_version(table->getShare()->getTableMessage()->version());
733 table_message.set_uuid(table->getShare()->getTableMessage()->uuid());
735 alter_info->create_list.swap(new_create_list);
736 alter_info->key_list.swap(new_key_list);
738 size_t num_engine_options= table_message.engine().options_size();
739 size_t original_num_engine_options= original_proto.engine().options_size();
740 for (
size_t x= 0; x < original_num_engine_options; ++x)
744 for (
size_t y= 0; y < num_engine_options; ++y)
746 found= not table_message.engine().options(y).name().compare(original_proto.engine().options(x).name());
754 message::Engine::Option *opt= table_message.mutable_engine()->add_options();
756 opt->set_name(original_proto.engine().options(x).name());
757 opt->set_state(original_proto.engine().options(x).state());
761 drizzled::message::update(table_message);
767static int discard_or_import_tablespace(Session *session,
768 TableList *table_list,
775 session->set_proc_info(
"discard_or_import_tablespace");
781 session->setDoingTablespaceOperation(
true);
782 Table* table= session->openTableLock(table_list, TL_WRITE);
785 session->setDoingTablespaceOperation(
false);
791 error= table->cursor->ha_discard_or_import_tablespace(discard);
793 session->set_proc_info(
"end");
799 error= TransactionServices::autocommitOrRollback(*session,
false);
800 if (not session->endActiveTransaction())
806 TransactionServices::rawStatement(*session,
807 *session->getQueryString(),
812 (void) TransactionServices::autocommitOrRollback(*session, error);
813 session->setDoingTablespaceOperation(
false);
821 table->print_error(error, MYF(0));
841 Table *table,
int indexes_were_disabled,
842 const message::AlterTable &alter_table_message)
845 if (alter_table_message.has_alter_keys_onoff()
846 && alter_table_message.alter_keys_onoff().enable())
848 error= table->cursor->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
851 if ((! alter_table_message.has_alter_keys_onoff() && indexes_were_disabled)
852 || (alter_table_message.has_alter_keys_onoff()
853 && ! alter_table_message.alter_keys_onoff().enable()))
855 error= table->cursor->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
858 if (error == HA_ERR_WRONG_COMMAND)
860 push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
861 ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
862 table->getMutableShare()->getTableName());
867 table->print_error(error, MYF(0));
873static bool lockTableIfDifferent(Session &session,
874 identifier::Table &original_table_identifier,
875 identifier::Table &new_table_identifier,
879 if (not (original_table_identifier == new_table_identifier))
881 if (original_table_identifier.isTmp())
883 if (session.open_tables.find_temporary_table(new_table_identifier))
885 my_error(ER_TABLE_EXISTS_ERROR, new_table_identifier);
891 name_lock= session.lock_table_name_if_not_cached(new_table_identifier);
894 my_error(ER_TABLE_EXISTS_ERROR, new_table_identifier);
898 if (plugin::StorageEngine::doesTableExist(session, new_table_identifier))
901 my_error(ER_TABLE_EXISTS_ERROR, new_table_identifier);
904 boost::mutex::scoped_lock scopedLock(table::Cache::mutex());
905 session.unlink_open_table(name_lock);
962 HA_CREATE_INFO *create_info,
963 const message::Table &original_proto,
964 message::Table &create_proto,
965 message::AlterTable &alter_table_message,
978 if (not original_table_identifier.isValid())
981 if (not new_table_identifier.isValid())
984 session->set_proc_info(
"init");
986 table->use_all_columns();
991 original_engine= table->getMutableShare()->getEngine();
993 if (not create_info->db_type)
995 create_info->db_type= original_engine;
997 new_engine= create_info->db_type;
1000 create_proto.set_schema(new_table_identifier.getSchemaName());
1001 create_proto.set_type(new_table_identifier.getType());
1007 if (new_engine != original_engine &&
1008 not table->cursor->can_switch_engines())
1011 my_error(ER_ROW_IS_REFERENCED, MYF(0));
1016 if (original_engine->check_flag(HTON_BIT_ALTER_NOT_SUPPORTED) ||
1017 new_engine->check_flag(HTON_BIT_ALTER_NOT_SUPPORTED))
1019 my_error(ER_ILLEGAL_HA, new_table_identifier);
1024 session->set_proc_info(
"setup");
1032 if ((alter_table_message.has_rename()
1033 || alter_table_message.has_alter_keys_onoff())
1034 && alter_table_message.operations_size() == 0)
1042 tmp.reset(ALTER_RENAME);
1043 tmp.reset(ALTER_KEYS_ONOFF);
1044 tmp&= alter_info->flags;
1046 if((not (tmp.any()) && not table->getShare()->getType()))
1048 if (alter_table_message.has_alter_keys_onoff())
1050 error= apply_online_alter_keys_onoff(session, table,
1051 alter_table_message.alter_keys_onoff());
1053 if (error == HA_ERR_WRONG_COMMAND)
1056 push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1057 ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
1062 if (alter_table_message.has_rename())
1064 error= apply_online_rename_table(session,
1067 original_table_identifier,
1068 new_table_identifier,
1069 alter_table_message.rename());
1071 if (error == HA_ERR_WRONG_COMMAND)
1074 push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1075 ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
1082 TransactionServices::allocateNewTransactionId();
1084 *session->getQueryString(),
1085 *session->schema());
1088 else if (error > EE_OK)
1090 table->print_error(error, MYF(0));
1093 table_list->
table= NULL;
1099 if (alter_table_message.build_method() == message::AlterTable::BUILD_ONLINE)
1101 my_error(*session->getQueryString(), ER_NOT_SUPPORTED_YET);
1106 new_engine= create_info->db_type;
1108 if (
prepare_alter_table(session, table, create_info, original_proto, create_proto, alter_table_message, alter_info))
1113 set_table_default_charset(session->catalog().identifier(), create_info, new_table_identifier.getSchemaName().c_str());
1115 snprintf(tmp_name,
sizeof(tmp_name),
"%s-%lx_%" PRIx64,
TMP_FILE_PREFIX, (
unsigned long) current_pid, session->thread_id);
1124 original_table_identifier.getSchemaName(),
1126 create_proto.type() != message::Table::TEMPORARY ? message::Table::INTERNAL :
1127 message::Table::TEMPORARY);
1133 create_proto.set_name(new_table_as_temporary.getTableName());
1134 create_proto.mutable_engine()->set_name(create_info->db_type->getName());
1136 error= create_table(session,
1137 new_table_as_temporary,
1138 create_info, create_proto, alter_info,
true, 0,
false);
1146 Table *new_table= open_alter_table(session, table, new_table_as_temporary);
1151 plugin::StorageEngine::dropTable(*session, new_table_as_temporary);
1158 session->count_cuted_fields= CHECK_FIELD_ERROR_FOR_NULL;
1159 session->cuted_fields= 0L;
1160 session->set_proc_info(
"copy to tmp table");
1164 new_table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
1165 new_table->next_number_field= new_table->found_next_number_field;
1166 error= copy_data_between_tables(session,
1169 alter_info->create_list,
1175 alter_table_message,
1176 alter_info->error_if_not_empty);
1179 assert(session->count_cuted_fields == CHECK_FIELD_ERROR_FOR_NULL);
1190 if (alter_info->error_if_not_empty && session->row_count)
1192 my_error(ER_INVALID_ALTER_TABLE_FOR_NOT_NULL, MYF(0));
1195 if (original_table_identifier.isTmp())
1200 session->open_tables.close_temporary_table(new_table);
1204 plugin::StorageEngine::dropTable(*session, new_table_as_temporary);
1217 new_table->intern_close_table();
1218 if (new_table->hasShare())
1220 delete new_table->getMutableShare();
1226 boost::mutex::scoped_lock scopedLock(table::Cache::mutex());
1228 plugin::StorageEngine::dropTable(*session, new_table_as_temporary);
1234 else if (original_table_identifier.isTmp())
1237 if (session->open_tables.lock)
1239 session->unlockTables(session->open_tables.lock);
1240 session->open_tables.lock= 0;
1244 session->open_tables.close_temporary_table(table);
1247 new_table->getMutableShare()->setIdentifier(new_table_identifier);
1249 new_table_identifier.setPath(new_table_as_temporary.getPath());
1251 if (rename_table(*session, new_engine, new_table_as_temporary, new_table_identifier) != 0)
1265 new_table->intern_close_table();
1267 if (new_table->hasShare())
1269 delete new_table->getMutableShare();
1276 boost::mutex::scoped_lock scopedLock(table::Cache::mutex());
1293 session->set_proc_info(
"rename result table");
1295 snprintf(old_name,
sizeof(old_name),
"%s2-%lx-%" PRIx64,
TMP_FILE_PREFIX, (
unsigned long) current_pid, session->thread_id);
1297 files_charset_info->casedn_str(old_name);
1299 wait_while_table_is_used(session, table, HA_EXTRA_PREPARE_FOR_RENAME);
1300 session->close_data_files_and_morph_locks(original_table_identifier);
1314 original_table_identifier.getSchemaName(),
1315 old_name, create_proto.type() != message::Table::TEMPORARY ? message::Table::INTERNAL :
1316 message::Table::TEMPORARY);
1318 drizzled::error_t rename_error= EE_OK;
1319 if (rename_table(*session, original_engine, original_table_identifier, original_table_to_drop))
1321 error= ER_ERROR_ON_RENAME;
1322 plugin::StorageEngine::dropTable(*session, new_table_as_temporary);
1326 if (rename_table(*session, new_engine, new_table_as_temporary, new_table_identifier) != 0)
1329 rename_error= ER_ERROR_ON_RENAME;
1331 plugin::StorageEngine::dropTable(*session, new_table_identifier);
1333 plugin::StorageEngine::dropTable(*session, new_table_as_temporary);
1335 rename_table(*session, original_engine, original_table_to_drop, original_table_identifier);
1339 plugin::StorageEngine::dropTable(*session, original_table_to_drop);
1350 session->unlink_open_table(table);
1356 session->set_proc_info(
"end");
1359 *session->getQueryString(),
1360 *session->schema());
1361 table_list->
table= NULL;
1369 if (session->is_error())
1375 snprintf(tmp_name,
sizeof(tmp_name), ER(ER_INSERT_INFO),
1376 (ulong) (copied + deleted), (ulong) deleted,
1377 (ulong) session->cuted_fields);
1378 session->my_ok(copied + deleted, 0, 0L, tmp_name);
1382static int apply_online_alter_keys_onoff(Session *session,
1384 const message::AlterTable::AlterKeysOnOff &op)
1400 boost::mutex::scoped_lock scopedLock(table::Cache::mutex());
1401 wait_while_table_is_used(session, table, HA_EXTRA_FORCE_REOPEN);
1403 error= table->cursor->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
1410 boost::mutex::scoped_lock scopedLock(table::Cache::mutex());
1411 wait_while_table_is_used(session, table, HA_EXTRA_FORCE_REOPEN);
1413 error= table->cursor->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
1421static int apply_online_rename_table(Session *session,
1423 plugin::StorageEngine *original_engine,
1424 identifier::Table &original_table_identifier,
1425 identifier::Table &new_table_identifier,
1426 const message::AlterTable::RenameTable &alter_operation)
1430 boost::mutex::scoped_lock scopedLock(table::Cache::mutex());
1437 if (not (original_table_identifier == new_table_identifier))
1439 assert(alter_operation.to_name() == new_table_identifier.getTableName());
1440 assert(alter_operation.to_schema() == new_table_identifier.getSchemaName());
1442 session->set_proc_info(
"rename");
1447 session->close_cached_table(table);
1456 if (plugin::StorageEngine::doesTableExist(*session, new_table_identifier))
1458 my_error(ER_TABLE_EXISTS_ERROR, new_table_identifier);
1463 if (rename_table(*session, original_engine, original_table_identifier, new_table_identifier))
1472bool alter_table(Session *session,
1473 identifier::Table &original_table_identifier,
1474 identifier::Table &new_table_identifier,
1475 HA_CREATE_INFO *create_info,
1476 const message::Table &original_proto,
1477 message::Table &create_proto,
1478 TableList *table_list,
1479 AlterInfo *alter_info,
1486 message::AlterTable *alter_table_message= session->lex().alter_table();
1488 alter_table_message->set_catalog(original_table_identifier.getCatalogName());
1489 alter_table_message->set_schema(original_table_identifier.getSchemaName());
1490 alter_table_message->set_name(original_table_identifier.getTableName());
1492 if (alter_table_message->operations_size()
1493 && (alter_table_message->operations(0).operation()
1494 == message::AlterTable::AlterTableOperation::DISCARD_TABLESPACE
1495 || alter_table_message->operations(0).operation()
1496 == message::AlterTable::AlterTableOperation::IMPORT_TABLESPACE))
1498 bool discard= (alter_table_message->operations(0).operation() ==
1499 message::AlterTable::AlterTableOperation::DISCARD_TABLESPACE);
1501 return discard_or_import_tablespace(session, table_list, discard);
1504 session->set_proc_info(
"init");
1506 if (not (table= session->openTableLock(table_list, TL_WRITE_ALLOW_READ)))
1509 session->set_proc_info(
"gained write lock on table");
1516 Table *name_lock= NULL;
1518 if (not lockTableIfDifferent(*session, original_table_identifier, new_table_identifier, name_lock))
1525 original_table_identifier,
1526 new_table_identifier,
1530 *alter_table_message,
1539 boost::mutex::scoped_lock scopedLock(table::Cache::mutex());
1540 session->unlink_open_table(name_lock);
1549copy_data_between_tables(Session *session,
1550 Table *from, Table *to,
1551 List<CreateField> &create,
1553 uint32_t order_num, Order *order,
1556 message::AlterTable &alter_table_message,
1557 bool error_if_not_empty)
1560 CopyField *copy,*copy_end;
1561 ulong found_count,delete_count;
1563 SortField *sortorder;
1567 List<Item> all_fields;
1568 ha_rows examined_rows;
1569 bool auto_increment_field_copied= 0;
1586 to->getMutableShare()->getEngine()->startStatement(session);
1588 copy=
new CopyField[to->getShare()->sizeFields()];
1590 if (to->cursor->ha_external_lock(session, F_WRLCK))
1595 alter_table_message);
1598 session->setAbortOnWarning(not ignore);
1600 from->cursor->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
1601 to->cursor->ha_start_bulk_insert(from->cursor->stats.records);
1603 List<CreateField>::iterator it(create.begin());
1605 for (Field **ptr= to->getFields(); *ptr ; ptr++)
1607 CreateField* def=it++;
1610 if (*ptr == to->next_number_field)
1611 auto_increment_field_copied=
true;
1613 (copy_end++)->set(*ptr,def->field,0);
1618 found_count=delete_count=0;
1624 if (to->getShare()->hasPrimaryKey() && to->cursor->primary_key_is_clustered())
1626 char warn_buff[DRIZZLE_ERRMSG_SIZE];
1627 snprintf(warn_buff,
sizeof(warn_buff),
1628 _(
"order_st BY ignored because there is a user-defined clustered "
1629 "index in the table '%-.192s'"),
1630 from->getMutableShare()->getTableName());
1631 push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
1636 FileSort filesort(*session);
1637 from->sort.io_cache=
new internal::io_cache_st;
1640 tables.setTableName(from->getMutableShare()->getTableName());
1641 tables.alias= tables.getTableName();
1642 tables.setSchemaName(from->getMutableShare()->getSchemaName());
1645 session->lex().select_lex.setup_ref_array(session, order_num);
1646 if (
setup_order(session, session->lex().select_lex.ref_pointer_array, &tables, fields, all_fields, order))
1648 sortorder= make_unireg_sortorder(order, &length, NULL);
1649 if ((from->sort.found_records= filesort.run(from, sortorder, length, (optimizer::SqlSelect *) 0, HA_POS_ERROR, 1, examined_rows)) == HA_POS_ERROR)
1655 to->use_all_columns();
1657 error= info.init_read_record(session, from, NULL, 1,
true);
1660 to->print_error(errno, MYF(0));
1667 to->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
1670 session->row_count= 0;
1671 to->restoreRecordAsDefault();
1672 while (not (error=info.read_record(&info)))
1674 if (session->getKilled())
1676 session->send_kill_message();
1680 session->row_count++;
1682 if (error_if_not_empty)
1687 if (to->next_number_field)
1689 if (auto_increment_field_copied)
1690 to->auto_increment_field_not_null=
true;
1692 to->next_number_field->reset();
1695 for (CopyField *copy_ptr= copy; copy_ptr != copy_end ; copy_ptr++)
1697 if (not copy->to_field->hasDefault() and copy->from_null_ptr and *copy->from_null_ptr & copy->from_bit)
1699 copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
1700 ER_WARN_DATA_TRUNCATED, 1);
1701 copy->to_field->reset();
1706 copy_ptr->do_copy(copy_ptr);
1715 error= to->cursor->insertRecord(to->record[0]);
1716 to->auto_increment_field_not_null=
false;
1720 if (!ignore || to->cursor->is_fatal_error(error, HA_CHECK_DUP))
1722 to->print_error(error, MYF(0));
1725 to->cursor->restore_auto_increment(prev_insert_id);
1734 info.end_read_record();
1735 from->free_io_cache();
1738 if (to->cursor->ha_end_bulk_insert() && error <= 0)
1740 to->print_error(errno, MYF(0));
1743 to->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1749 if (TransactionServices::autocommitOrRollback(*session,
false))
1752 if (not session->endActiveTransaction())
1757 session->setAbortOnWarning(
false);
1758 from->free_io_cache();
1759 *copied= found_count;
1760 *deleted=delete_count;
1761 to->cursor->ha_release_auto_increment();
1763 if (to->cursor->ha_external_lock(session, F_UNLCK))
1768 return error > 0 ? -1 : 0;
1771static Table *open_alter_table(Session *session, Table *table, identifier::Table &identifier)
1774 if (table->getShare()->getType())
1777 tbl.setSchemaName(identifier.getSchemaName().c_str());
1778 tbl.alias= identifier.getTableName().c_str();
1779 tbl.setTableName(identifier.getTableName().c_str());
1782 return session->openTable(&tbl, NULL, DRIZZLE_LOCK_IGNORE_FLUSH);
1787 return session->open_temporary_table(identifier,
false);
enum_field_types sql_type
static bool type_can_have_key_part(enum_field_types)
Table * table
opened table
static void rawStatement(Session &, const std::string &query, const std::string &schema)
int setup_order(Session *session, Item **ref_pointer_array, TableList *tables, List< Item > &fields, List< Item > &all_fields, Order *order)
TODO: Rename this file - func.h is stupid.
uint64_t prev_insert_id(uint64_t nr, drizzle_system_variables *variables)
static bool internal_alter_table(Session *session, Table *table, identifier::Table &original_table_identifier, identifier::Table &new_table_identifier, HA_CREATE_INFO *create_info, const message::Table &original_proto, message::Table &create_proto, message::AlterTable &alter_table_message, TableList *table_list, AlterInfo *alter_info, uint32_t order_num, Order *order, bool ignore)
static bool alter_table_manage_keys(Session *session, Table *table, int indexes_were_disabled, const message::AlterTable &alter_table_message)
static bool prepare_alter_table(Session *session, Table *table, HA_CREATE_INFO *create_info, const message::Table &original_proto, message::Table &table_message, message::AlterTable &alter_table_message, AlterInfo *alter_info)