21 #include <drizzled/sql_select.h>
23 #include <drizzled/error.h>
24 #include <drizzled/name_resolution_context_state.h>
25 #include <drizzled/probes.h>
26 #include <drizzled/sql_base.h>
27 #include <drizzled/sql_load.h>
28 #include <drizzled/field/epoch.h>
29 #include <drizzled/lock.h>
31 #include <drizzled/pthread_globals.h>
32 #include <drizzled/transaction_services.h>
33 #include <drizzled/plugin/transactional_storage_engine.h>
34 #include <drizzled/select_insert.h>
35 #include <drizzled/select_create.h>
36 #include <drizzled/table/shell.h>
37 #include <drizzled/alter_info.h>
38 #include <drizzled/sql_parse.h>
39 #include <drizzled/sql_lex.h>
40 #include <drizzled/statistics_variables.h>
41 #include <drizzled/session/transactions.h>
42 #include <drizzled/open_tables_state.h>
43 #include <drizzled/table/cache.h>
44 #include <drizzled/create_field.h>
48 extern plugin::StorageEngine *heap_engine;
49 extern plugin::StorageEngine *myisam_engine;
72 static int check_insert_fields(Session *session, TableList *table_list,
73 List<Item> &fields, List<Item> &values,
77 Table *table= table_list->table;
79 if (fields.size() == 0 && values.size() != 0)
81 if (values.size() != table->getShare()->sizeFields())
83 my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1L);
86 clear_timestamp_auto_bits(table->timestamp_field_type,
87 TIMESTAMP_AUTO_SET_ON_INSERT);
96 Select_Lex *select_lex= &session->lex().select_lex;
97 Name_resolution_context *context= &select_lex->context;
98 Name_resolution_context_state ctx_state;
101 if (fields.size() != values.size())
103 my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1L);
107 session->dup_field= 0;
110 ctx_state.save_state(context, table_list);
116 table_list->next_local= 0;
117 context->resolve_in_table_list_only(table_list);
118 res= setup_fields(session, 0, fields, MARK_COLUMNS_WRITE, 0, 0);
121 ctx_state.restore_state(context, table_list);
126 if (check_unique && session->dup_field)
128 my_error(ER_FIELD_SPECIFIED_TWICE, MYF(0), session->dup_field->field_name);
131 if (table->timestamp_field)
133 if (table->timestamp_field->isWriteSet())
135 clear_timestamp_auto_bits(table->timestamp_field_type,
136 TIMESTAMP_AUTO_SET_ON_INSERT);
140 table->setWriteSet(table->timestamp_field->position());
168 static int check_update_fields(Session *session, TableList *insert_table_list,
169 List<Item> &update_fields,
172 Table *table= insert_table_list->table;
173 bool timestamp_mark=
false;
175 if (table->timestamp_field)
181 timestamp_mark= table->write_set->test(table->timestamp_field->position());
182 table->write_set->reset(table->timestamp_field->position());
186 if (setup_fields(session, 0, update_fields, MARK_COLUMNS_WRITE, 0, 0))
189 if (table->timestamp_field)
192 if (table->timestamp_field->isWriteSet())
194 clear_timestamp_auto_bits(table->timestamp_field_type,
195 TIMESTAMP_AUTO_SET_ON_UPDATE);
200 table->setWriteSet(table->timestamp_field->position());
217 thr_lock_type *lock_type,
218 enum_duplicates duplic,
221 if (duplic == DUP_UPDATE ||
222 (duplic == DUP_REPLACE && *lock_type == TL_WRITE_CONCURRENT_INSERT))
224 *lock_type= TL_WRITE_DEFAULT;
243 enum_duplicates duplic,
247 bool transactional_table, joins_freed=
false;
249 uint32_t value_count;
258 Item *unused_conds= 0;
266 values_list.size() > 1);
270 DRIZZLE_INSERT_DONE(1, 0);
277 value_count= values->size();
279 if (prepare_insert(session, table_list, table, fields, values,
280 update_fields, update_values, duplic, &unused_conds,
282 (fields.size() || !value_count ||
289 session->setAbortOnWarning(
false);
290 DRIZZLE_INSERT_DONE(1, 0);
295 table= table_list->
table;
297 context= &session->lex().select_lex.context;
308 ctx_state.save_state(context, table_list);
315 context->resolve_in_table_list_only(table_list);
317 while ((values= its++))
320 if (values->size() != value_count)
322 my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), counter);
328 session->setAbortOnWarning(
false);
329 DRIZZLE_INSERT_DONE(1, 0);
333 if (setup_fields(session, 0, *values, MARK_COLUMNS_READ, 0, 0))
339 session->setAbortOnWarning(
false);
340 DRIZZLE_INSERT_DONE(1, 0);
344 its= values_list.begin();
347 ctx_state.restore_state(context, table_list);
353 info.handle_duplicates=duplic;
354 info.update_fields= &update_fields;
355 info.update_values= &update_values;
362 session->count_cuted_fields= ignore ? CHECK_FIELD_WARN : CHECK_FIELD_ERROR_FOR_NULL;
369 if (duplic == DUP_REPLACE)
370 table->
cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
371 if (duplic == DUP_UPDATE)
372 table->
cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
374 if (duplic != DUP_ERROR || ignore)
375 table->
cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
376 table->
cursor->ha_start_bulk_insert(values_list.size());
380 session->setAbortOnWarning(not ignore);
382 table->mark_columns_needed_for_insert();
384 while ((values= its++))
386 if (fields.size() || !value_count)
388 table->restoreRecordAsDefault();
389 if (fill_record(session, fields, *values))
391 if (values_list.size() != 1 && ! session->
is_error())
407 table->restoreRecordAsDefault();
409 if (fill_record(session, table->getFields(), *values))
411 if (values_list.size() != 1 && ! session->
is_error())
424 error=write_record(session, table ,&info);
443 if (table->
cursor->ha_end_bulk_insert() && !error)
445 table->print_error(errno,MYF(0));
448 if (duplic != DUP_ERROR || ignore)
449 table->
cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
451 transactional_table= table->
cursor->has_transactions();
475 (session->arg_of_last_insert_id_function ?
480 session->count_cuted_fields= CHECK_FIELD_IGNORE;
481 table->auto_increment_field_not_null=
false;
482 if (duplic == DUP_REPLACE)
483 table->
cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
491 session->setAbortOnWarning(
false);
492 DRIZZLE_INSERT_DONE(1, 0);
496 if (values_list.size() == 1 && (!(session->
options & OPTION_WARNINGS) ||
500 session->
my_ok((ulong) session->rowCount(),
507 snprintf(buff,
sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.
records,
510 snprintf(buff,
sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.
records,
513 session->
my_ok((ulong) session->rowCount(),
516 session->status_var.inserted_row_count+= session->rowCount();
517 session->setAbortOnWarning(
false);
518 DRIZZLE_INSERT_DONE(0, session->rowCount());
540 static bool prepare_insert_check_table(Session *session, TableList *table_list,
553 return setup_tables_and_check_access(session, &session->lex().select_lex.context,
554 &session->lex().select_lex.top_join_list, table_list, &session->lex().select_lex.leaf_tables, select_insert);
589 bool prepare_insert(Session *session, TableList *table_list,
590 Table *table, List<Item> &fields, List_item *values,
591 List<Item> &update_fields, List<Item> &update_values,
592 enum_duplicates duplic,
595 bool check_fields,
bool abort_on_warning)
597 Select_Lex *select_lex= &session->lex().select_lex;
598 Name_resolution_context *context= &select_lex->context;
599 Name_resolution_context_state ctx_state;
600 bool insert_into_view= (0 != 0);
605 assert (!select_insert || !values);
612 if (not select_insert)
614 for (Select_Lex_Unit *un= select_lex->first_inner_unit();
618 for (Select_Lex *sl= un->first_select();
620 sl= sl->next_select())
622 sl->context.outer_context= 0;
627 if (duplic == DUP_UPDATE)
630 table_list->set_insert_values();
633 if (prepare_insert_check_table(session, table_list, fields, select_insert))
641 assert (!select_lex->group_list.elements);
644 ctx_state.save_state(context, table_list);
650 table_list->next_local= 0;
651 context->resolve_in_table_list_only(table_list);
653 res= check_insert_fields(session, context->table_list, fields, *values,
654 !insert_into_view, &map) ||
655 setup_fields(session, 0, *values, MARK_COLUMNS_READ, 0, 0);
657 if (!res && check_fields)
659 bool saved_abort_on_warning= session->abortOnWarning();
661 session->setAbortOnWarning(abort_on_warning);
662 res= check_that_all_fields_are_given_values(session,
664 context->table_list->table,
665 context->table_list);
666 session->setAbortOnWarning(saved_abort_on_warning);
669 if (!res && duplic == DUP_UPDATE)
671 res= check_update_fields(session, context->table_list, update_fields, &map);
675 ctx_state.restore_state(context, table_list);
678 res= setup_fields(session, 0, update_values, MARK_COLUMNS_READ, 0, 0);
685 table= table_list->table;
687 if (not select_insert && unique_table(table_list, table_list->next_global,
true))
689 my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->alias);
693 if (duplic == DUP_UPDATE || duplic == DUP_REPLACE)
694 table->prepare_for_position();
702 static int last_uniq_key(Table *table,uint32_t keynr)
704 while (++keynr < table->getShare()->sizeKeys())
705 if (table->key_info[keynr].flags & HA_NOSAME)
738 int write_record(Session *session, Table *table,CopyInfo *info)
741 std::vector<unsigned char> key;
742 boost::dynamic_bitset<> *save_read_set, *save_write_set;
744 uint64_t insert_id_for_cur_row= 0;
748 save_read_set= table->read_set;
749 save_write_set= table->write_set;
751 if (info->handle_duplicates == DUP_REPLACE || info->handle_duplicates == DUP_UPDATE)
753 while ((error=table->cursor->insertRecord(table->getInsertRecord())))
763 if (table->cursor->insert_id_for_cur_row > 0)
764 insert_id_for_cur_row= table->cursor->insert_id_for_cur_row;
766 table->cursor->insert_id_for_cur_row= insert_id_for_cur_row;
767 bool is_duplicate_key_error;
768 if (table->cursor->is_fatal_error(error, HA_CHECK_DUP))
770 is_duplicate_key_error= table->cursor->is_fatal_error(error, 0);
771 if (!is_duplicate_key_error)
779 goto gok_or_after_err;
782 if ((
int) (key_nr = table->get_dup_key(error)) < 0)
784 error= HA_ERR_FOUND_DUPP_KEY;
788 table->use_all_columns();
794 if (info->handle_duplicates == DUP_REPLACE &&
795 table->next_number_field &&
796 key_nr == table->getShare()->next_number_index &&
797 (insert_id_for_cur_row > 0))
799 if (table->cursor->getEngine()->check_flag(HTON_BIT_DUPLICATE_POS))
801 if (table->cursor->rnd_pos(table->getUpdateRecord(),table->cursor->dup_ref))
806 if (table->cursor->extra(HA_EXTRA_FLUSH_CACHE))
814 key.resize(table->getShare()->max_unique_length);
816 key_copy(&key[0], table->getInsertRecord(), table->key_info+key_nr, 0);
817 if ((error=(table->cursor->index_read_idx_map(table->getUpdateRecord(),key_nr,
818 &key[0], HA_WHOLE_KEY,
819 HA_READ_KEY_EXACT))))
822 if (info->handle_duplicates == DUP_UPDATE)
829 assert(table->insert_values.size());
830 table->storeRecordAsInsert();
831 table->restoreRecord();
832 assert(info->update_fields->size() ==
833 info->update_values->size());
834 if (fill_record(session, *info->update_fields,
835 *info->update_values,
839 table->cursor->restore_auto_increment(prev_insert_id);
840 if (table->next_number_field)
841 table->cursor->adjust_next_insert_id_after_explicit_value(
842 table->next_number_field->val_int());
845 if (! table->records_are_comparable() || table->compare_records())
847 if ((error=table->cursor->updateRecord(table->getUpdateRecord(),
848 table->getInsertRecord())) &&
849 error != HA_ERR_RECORD_IS_THE_SAME)
852 !table->cursor->is_fatal_error(error, HA_CHECK_DUP_KEY))
854 goto gok_or_after_err;
859 if (error != HA_ERR_RECORD_IS_THE_SAME)
870 insert_id_for_cur_row= table->cursor->insert_id_for_cur_row= 0;
874 if (table->next_number_field)
875 table->cursor->adjust_next_insert_id_after_explicit_value(
876 table->next_number_field->val_int());
879 goto gok_or_after_err;
897 if (last_uniq_key(table,key_nr) &&
898 !table->cursor->referenced_by_foreign_key() &&
899 (table->timestamp_field_type == TIMESTAMP_NO_AUTO_SET ||
900 table->timestamp_field_type == TIMESTAMP_AUTO_SET_ON_BOTH))
902 if ((error=table->cursor->updateRecord(table->getUpdateRecord(),
903 table->getInsertRecord())) &&
904 error != HA_ERR_RECORD_IS_THE_SAME)
906 if (error != HA_ERR_RECORD_IS_THE_SAME)
910 session->record_first_successful_insert_id_in_cur_stmt(table->cursor->insert_id_for_cur_row);
915 goto after_n_copied_inc;
919 if ((error=table->cursor->deleteRecord(table->getUpdateRecord())))
922 if (!table->cursor->has_transactions())
923 session->transaction.stmt.markModifiedNonTransData();
928 session->record_first_successful_insert_id_in_cur_stmt(table->cursor->insert_id_for_cur_row);
933 if (table->read_set != save_read_set ||
934 table->write_set != save_write_set)
935 table->column_bitmaps_set(*save_read_set, *save_write_set);
937 else if ((error=table->cursor->insertRecord(table->getInsertRecord())))
940 table->cursor->is_fatal_error(error, HA_CHECK_DUP))
942 table->cursor->restore_auto_increment(prev_insert_id);
943 goto gok_or_after_err;
948 session->record_first_successful_insert_id_in_cur_stmt(table->cursor->insert_id_for_cur_row);
951 if (!table->cursor->has_transactions())
952 session->transaction.stmt.markModifiedNonTransData();
956 info->last_errno= error;
958 if (session->lex().current_select)
959 session->lex().current_select->no_error= 0;
960 table->print_error(error,MYF(0));
963 table->cursor->restore_auto_increment(prev_insert_id);
964 table->column_bitmaps_set(*save_read_set, *save_write_set);
973 int check_that_all_fields_are_given_values(Session *session, Table *entry,
978 for (Field **field=entry->getFields() ; *field ; field++)
980 if (not (*field)->isWriteSet())
987 if (((*field)->flags & NO_DEFAULT_VALUE_FLAG) &&
988 ((*field)->real_type() != DRIZZLE_TYPE_ENUM))
990 my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), (*field)->field_name);
1004 if (((*field)->flags & NOT_NULL_FLAG) &&
1005 (*field)->is_null())
1007 my_error(ER_BAD_NULL_ERROR, MYF(0), (*field)->field_name);
1012 return session->abortOnWarning() ? err : 0;
1032 bool insert_select_prepare(Session *session)
1034 LEX *lex= &session->lex();
1035 Select_Lex *select_lex= &lex->select_lex;
1042 if (prepare_insert(session, lex->query_tables,
1043 lex->query_tables->table, lex->field_list, 0,
1044 lex->update_list, lex->value_list,
1046 &select_lex->where,
true,
false,
false))
1053 assert(select_lex->leaf_tables != 0);
1054 lex->leaf_tables_insert= select_lex->leaf_tables;
1056 select_lex->leaf_tables= select_lex->leaf_tables->next_leaf;
1061 select_insert::select_insert(TableList *table_list_par, Table *table_par,
1062 List<Item> *fields_par,
1063 List<Item> *update_fields,
1064 List<Item> *update_values,
1065 enum_duplicates duplic,
1066 bool ignore_check_option_errors) :
1067 table_list(table_list_par), table(table_par), fields(fields_par),
1068 autoinc_value_of_last_inserted_row(0),
1069 insert_into_view(table_list_par && 0 != 0)
1071 info.handle_duplicates= duplic;
1072 info.ignore= ignore_check_option_errors;
1073 info.update_fields= update_fields;
1074 info.update_values= update_values;
1079 select_insert::prepare(List<Item> &values, Select_Lex_Unit *u)
1083 Select_Lex *lex_current_select_save= session->lex().current_select;
1093 session->lex().current_select= &session->lex().select_lex;
1094 res= check_insert_fields(session, table_list, *fields, values,
1095 !insert_into_view, &map) ||
1096 setup_fields(session, 0, values, MARK_COLUMNS_READ, 0, 0);
1098 if (!res && fields->size())
1100 bool saved_abort_on_warning= session->abortOnWarning();
1101 session->setAbortOnWarning(not info.ignore);
1102 res= check_that_all_fields_are_given_values(session, table_list->table,
1104 session->setAbortOnWarning(saved_abort_on_warning);
1107 if (info.handle_duplicates == DUP_UPDATE && !res)
1109 Name_resolution_context *context= &session->lex().select_lex.context;
1110 Name_resolution_context_state ctx_state;
1113 ctx_state.save_state(context, table_list);
1116 table_list->next_local= 0;
1117 context->resolve_in_table_list_only(table_list);
1119 res= res || check_update_fields(session, context->table_list,
1120 *info.update_fields, &map);
1126 assert (!table_list->next_name_resolution_table);
1127 if (session->lex().select_lex.group_list.elements == 0 and
1128 not session->lex().select_lex.with_sum_func)
1134 table_list->next_name_resolution_table=
1135 ctx_state.get_first_name_resolution_table();
1137 res= res || setup_fields(session, 0, *info.update_values,
1138 MARK_COLUMNS_READ, 0, 0);
1147 List<Item>::iterator li(info.update_values->begin());
1150 while ((item= li++))
1152 item->transform(&Item::update_value_transformer,
1153 (
unsigned char*)session->lex().current_select);
1158 ctx_state.restore_state(context, table_list);
1161 session->lex().current_select= lex_current_select_save;
1168 table= table_list->table;
1174 if (unique_table(table_list, table_list->next_global))
1177 session->lex().current_select->options|= OPTION_BUFFER_RESULT;
1178 session->lex().current_select->join->select_options|= OPTION_BUFFER_RESULT;
1180 else if (not (session->lex().current_select->options & OPTION_BUFFER_RESULT))
1191 table->cursor->ha_start_bulk_insert((ha_rows) 0);
1193 table->restoreRecordAsDefault();
1194 table->next_number_field=table->found_next_number_field;
1196 session->cuted_fields=0;
1198 if (info.ignore || info.handle_duplicates != DUP_ERROR)
1199 table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
1201 if (info.handle_duplicates == DUP_REPLACE)
1202 table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1204 if (info.handle_duplicates == DUP_UPDATE)
1205 table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1207 session->setAbortOnWarning(not info.ignore);
1208 table->mark_columns_needed_for_insert();
1231 int select_insert::prepare2(
void)
1233 if (session->lex().current_select->options & OPTION_BUFFER_RESULT)
1234 table->cursor->ha_start_bulk_insert((ha_rows) 0);
1240 void select_insert::cleanup()
1246 select_insert::~select_insert()
1251 table->next_number_field=0;
1252 table->auto_increment_field_not_null=
false;
1253 table->cursor->ha_reset();
1255 session->count_cuted_fields= CHECK_FIELD_IGNORE;
1256 session->setAbortOnWarning(
false);
1261 bool select_insert::send_data(List<Item> &values)
1266 if (unit->offset_limit_cnt)
1268 unit->offset_limit_cnt--;
1272 session->count_cuted_fields= CHECK_FIELD_WARN;
1273 store_values(values);
1274 session->count_cuted_fields= CHECK_FIELD_IGNORE;
1275 if (session->is_error())
1279 plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
1281 error= write_record(session, table, &info);
1282 table->auto_increment_field_not_null=
false;
1286 if (info.handle_duplicates == DUP_UPDATE)
1296 table->restoreRecordAsDefault();
1298 if (table->next_number_field)
1304 if (session->first_successful_insert_id_in_cur_stmt == 0)
1305 autoinc_value_of_last_inserted_row=
1306 table->next_number_field->val_int();
1311 table->next_number_field->reset();
1318 void select_insert::store_values(List<Item> &values)
1321 fill_record(session, *fields, values,
true);
1323 fill_record(session, table->getFields(), values,
true);
1326 void select_insert::send_error(drizzled::error_t errcode,
const char *err)
1328 my_message(errcode, err, MYF(0));
1332 bool select_insert::send_eof()
1335 bool const trans_table= table->cursor->has_transactions();
1339 error= table->cursor->ha_end_bulk_insert();
1340 table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1341 table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1343 if ((changed= (info.copied || info.deleted || info.updated)))
1345 if (session->transaction.stmt.hasModifiedNonTransData())
1346 session->transaction.all.markModifiedNonTransData();
1348 assert(trans_table || !changed ||
1349 session->transaction.stmt.hasModifiedNonTransData());
1351 table->cursor->ha_release_auto_increment();
1355 table->print_error(error,MYF(0));
1356 DRIZZLE_INSERT_SELECT_DONE(error, 0);
1361 snprintf(buff,
sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
1362 (ulong) (info.records - info.copied), (ulong) session->cuted_fields);
1364 snprintf(buff,
sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
1365 (ulong) (info.deleted+info.updated), (ulong) session->cuted_fields);
1366 session->row_count_func= info.copied + info.deleted + info.updated;
1368 id= (session->first_successful_insert_id_in_cur_stmt > 0) ?
1369 session->first_successful_insert_id_in_cur_stmt :
1370 (session->arg_of_last_insert_id_function ?
1371 session->first_successful_insert_id_in_prev_stmt :
1372 (info.copied ? autoinc_value_of_last_inserted_row : 0));
1373 session->my_ok((ulong) session->rowCount(),
1374 info.copied + info.deleted + info.touched, id, buff);
1375 session->status_var.inserted_row_count+= session->rowCount();
1376 DRIZZLE_INSERT_SELECT_DONE(0, session->rowCount());
1380 void select_insert::abort() {
1391 bool changed, transactional_table;
1393 table->cursor->ha_end_bulk_insert();
1395 changed= (info.copied || info.deleted || info.updated);
1396 transactional_table= table->cursor->has_transactions();
1397 assert(transactional_table || !changed ||
1398 session->transaction.stmt.hasModifiedNonTransData());
1399 table->cursor->ha_release_auto_increment();
1402 if (DRIZZLE_INSERT_SELECT_DONE_ENABLED())
1404 DRIZZLE_INSERT_SELECT_DONE(0, info.copied + info.deleted + info.updated);
1457 static Table *create_table_from_items(Session *session, HA_CREATE_INFO *create_info,
1458 TableList *create_table,
1459 message::Table &table_proto,
1460 AlterInfo *alter_info,
1462 bool is_if_not_exists,
1464 const identifier::Table& identifier)
1466 TableShare share(message::Table::INTERNAL);
1467 uint32_t select_field_count= items->size();
1469 List<Item>::iterator it(items->begin());
1473 if (not (identifier.isTmp()) && create_table->table->db_stat)
1476 if (is_if_not_exists)
1478 create_info->table_existed= 1;
1479 push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1480 ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
1481 create_table->getTableName());
1482 return create_table->table;
1485 my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->getTableName());
1490 table::Shell tmp_table(share);
1492 if (not table_proto.engine().name().compare(
"MyISAM"))
1493 tmp_table.getMutableShare()->db_low_byte_first=
true;
1494 else if (not table_proto.engine().name().compare(
"MEMORY"))
1495 tmp_table.getMutableShare()->db_low_byte_first=
true;
1497 tmp_table.in_use= session;
1501 CreateField *cr_field;
1502 Field *field, *def_field;
1503 if (item->type() == Item::FUNC_ITEM)
1505 if (item->result_type() != STRING_RESULT)
1507 field= item->tmp_table_field(&tmp_table);
1511 field= item->tmp_table_field_from_field_type(&tmp_table, 0);
1517 (Item ***) 0, &tmp_field, &def_field,
false,
1522 !(cr_field=
new CreateField(field,(item->type() == Item::FIELD_ITEM ?
1523 ((Item_field *)item)->field :
1529 if (item->maybe_null)
1531 cr_field->flags &= ~NOT_NULL_FLAG;
1534 alter_info->create_list.push_back(cr_field);
1547 if (not create_table_no_lock(session,
1556 if (create_info->table_existed && not identifier.isTmp())
1563 my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->getTableName());
1567 if (not identifier.isTmp())
1570 boost::mutex::scoped_lock scopedLock(table::Cache::mutex());
1572 if (create_table->table)
1574 table::Concurrent *concurrent_table=
static_cast<table::Concurrent *
>(create_table->table);
1576 if (concurrent_table->reopen_name_locked_table(create_table, session))
1578 (void)plugin::StorageEngine::dropTable(*session, identifier);
1582 table= create_table->table;
1587 (void)plugin::StorageEngine::dropTable(*session, identifier);
1592 if (not (table= session->openTable(create_table, (
bool*) 0,
1593 DRIZZLE_OPEN_TEMPORARY_ONLY)) &&
1594 not create_info->table_existed)
1601 session->open_tables.drop_temporary_table(identifier);
1609 table->reginfo.lock_type=TL_WRITE;
1610 if (not ((*lock)= session->lockTables(&table, 1, DRIZZLE_LOCK_IGNORE_FLUSH)))
1614 session->unlockTables(*lock);
1618 if (not create_info->table_existed)
1619 session->drop_open_table(table, identifier);
1629 select_create::prepare(List<Item> &values, Select_Lex_Unit *u)
1631 DrizzleLock *extra_lock= NULL;
1644 if (not (table= create_table_from_items(session, create_info, create_table,
1646 alter_info, &values,
1648 &extra_lock, identifier)))
1655 assert(m_plock == NULL);
1657 if (identifier.isTmp())
1660 m_plock= &session->open_tables.extra_lock;
1662 *m_plock= extra_lock;
1665 if (table->getShare()->sizeFields() < values.size())
1667 my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1);
1672 field= table->getFields() + table->getShare()->sizeFields() - values.size();
1675 for (Field **f= field ; *f ; f++)
1677 table->setWriteSet((*f)->position());
1681 table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
1682 table->next_number_field=table->found_next_number_field;
1684 table->restoreRecordAsDefault();
1685 session->cuted_fields=0;
1686 if (info.ignore || info.handle_duplicates != DUP_ERROR)
1687 table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
1689 if (info.handle_duplicates == DUP_REPLACE)
1690 table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1692 if (info.handle_duplicates == DUP_UPDATE)
1693 table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1695 table->cursor->ha_start_bulk_insert((ha_rows) 0);
1696 session->setAbortOnWarning(not info.ignore);
1697 if (check_that_all_fields_are_given_values(session, table, table_list))
1700 table->mark_columns_needed_for_insert();
1701 table->cursor->extra(HA_EXTRA_WRITE_CACHE);
1705 void select_create::store_values(List<Item> &values)
1707 fill_record(session, field, values,
true);
1711 void select_create::send_error(drizzled::error_t errcode,
const char *err)
1724 select_insert::send_error(errcode, err);
1728 bool select_create::send_eof()
1730 bool tmp=select_insert::send_eof();
1740 if (!table->getShare()->getType())
1742 TransactionServices::autocommitOrRollback(*session, 0);
1743 (void) session->endActiveTransaction();
1746 table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1747 table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1750 session->unlockTables(*m_plock);
1759 void select_create::abort()
1776 select_insert::abort();
1780 session->unlockTables(*m_plock);
1787 table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1788 table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1789 if (not create_info->table_existed)
1790 session->drop_open_table(table, identifier);