17
17
/* Insert of records */
22
Drizzle has a different form of DELAYED then MySQL. DELAYED is just
23
a hint to the the sorage engine (which can then do whatever it likes.
25
#include <drizzled/server_includes.h>
20
26
#include <drizzled/sql_select.h>
21
27
#include <drizzled/show.h>
28
#include <drizzled/replication/mi.h>
22
29
#include <drizzled/error.h>
23
30
#include <drizzled/name_resolution_context_state.h>
31
#include <drizzled/slave.h>
32
#include <drizzled/sql_parse.h>
24
33
#include <drizzled/probes.h>
34
#include <drizzled/tableop_hooks.h>
25
35
#include <drizzled/sql_base.h>
26
36
#include <drizzled/sql_load.h>
27
37
#include <drizzled/field/timestamp.h>
28
38
#include <drizzled/lock.h>
29
#include "drizzled/sql_table.h"
30
#include "drizzled/pthread_globals.h"
31
#include "drizzled/transaction_services.h"
32
#include "drizzled/plugin/transactional_storage_engine.h"
37
extern plugin::StorageEngine *heap_engine;
38
extern plugin::StorageEngine *myisam_engine;
41
42
Check if insert fields are correct.
120
121
if (table->timestamp_field) // Don't automaticly set timestamp if used
122
if (table->timestamp_field->isWriteSet())
123
if (bitmap_is_set(table->write_set,
124
table->timestamp_field->field_index))
123
125
clear_timestamp_auto_bits(table->timestamp_field_type,
124
126
TIMESTAMP_AUTO_SET_ON_INSERT);
127
table->setWriteSet(table->timestamp_field->field_index);
129
bitmap_set_bit(table->write_set,
130
table->timestamp_field->field_index);
133
/* Mark all virtual columns for write*/
135
table->mark_virtual_columns();
175
182
if (table->timestamp_field)
177
184
/* Don't set timestamp column if this is modified. */
178
if (table->timestamp_field->isWriteSet())
185
if (bitmap_is_set(table->write_set,
186
table->timestamp_field->field_index))
179
187
clear_timestamp_auto_bits(table->timestamp_field_type,
180
188
TIMESTAMP_AUTO_SET_ON_UPDATE);
181
189
if (timestamp_mark)
182
table->setWriteSet(table->timestamp_field->field_index);
190
bitmap_set_bit(table->write_set,
191
table->timestamp_field->field_index);
247
257
upgrade_lock_type(session, &table_list->lock_type, duplic,
248
258
values_list.elements > 1);
250
if (session->openTablesLock(table_list))
261
We can't write-delayed into a table locked with LOCK TABLES:
262
this will lead to a deadlock, since the delayed thread will
263
never be able to get a lock on the table. QQQ: why not
264
upgrade the lock here instead?
266
if (table_list->lock_type == TL_WRITE_DELAYED && session->locked_tables &&
267
find_locked_table(session, table_list->db, table_list->table_name))
252
DRIZZLE_INSERT_DONE(1, 0);
269
my_error(ER_DELAYED_INSERT_TABLE_LOCKED, MYF(0),
270
table_list->table_name);
275
if (open_and_lock_tables(session, table_list))
256
278
lock_type= table_list->lock_type;
258
280
session->set_proc_info("init");
323
345
session->count_cuted_fields= ((values_list.elements == 1 &&
325
CHECK_FIELD_ERROR_FOR_NULL :
347
CHECK_FIELD_ERROR_FOR_NULL :
327
349
session->cuted_fields = 0L;
328
350
table->next_number_field=table->found_next_number_field;
352
if (session->slave_thread &&
353
(info.handle_duplicates == DUP_UPDATE) &&
354
(table->next_number_field != NULL) &&
355
rpl_master_has_bug(&active_mi->rli, 24432))
331
359
session->set_proc_info("update");
332
360
if (duplic == DUP_REPLACE)
333
table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
361
table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
334
362
if (duplic == DUP_UPDATE)
335
table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
363
table->file->extra(HA_EXTRA_INSERT_WITH_UPDATE);
337
365
if (duplic != DUP_ERROR || ignore)
338
table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
339
table->cursor->ha_start_bulk_insert(values_list.elements);
366
table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
367
table->file->ha_start_bulk_insert(values_list.elements);
370
table->restoreRecordAsDefault(); // Get empty record
372
if (fill_record(session, table->field, *values))
398
if (session->used_tables) // Column used in values()
399
restore_record(table,s->default_values); // Get empty record
403
Fix delete marker. No need to restore rest of record since it will
404
be overwritten by fill_record() anyway (and fill_record() does not
405
use default values in this case).
407
table->record[0][0]= table->s->default_values[0];
409
if (fill_record(session, table->field, *values, 0))
374
411
if (values_list.elements != 1 && ! session->is_error())
402
436
Do not do this release if this is a delayed insert, it would steal
403
437
auto_inc values from the delayed_insert thread as they share Table.
405
table->cursor->ha_release_auto_increment();
406
if (table->cursor->ha_end_bulk_insert() && !error)
439
table->file->ha_release_auto_increment();
440
if (table->file->ha_end_bulk_insert() && !error)
408
table->print_error(errno,MYF(0));
442
table->file->print_error(my_errno,MYF(0));
411
445
if (duplic != DUP_ERROR || ignore)
412
table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
414
transactional_table= table->cursor->has_transactions();
416
changed= (info.copied || info.deleted || info.updated);
417
if ((changed && error <= 0) || session->transaction.stmt.hasModifiedNonTransData())
419
if (session->transaction.stmt.hasModifiedNonTransData())
420
session->transaction.all.markModifiedNonTransData();
422
assert(transactional_table || !changed || session->transaction.stmt.hasModifiedNonTransData());
446
table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
448
transactional_table= table->file->has_transactions();
450
if ((changed= (info.copied || info.deleted || info.updated)))
453
Invalidate the table in the query cache if something changed.
454
For the transactional algorithm to work the invalidation must be
455
before binlog writing and ha_autocommit_or_rollback
458
if ((changed && error <= 0) || session->transaction.stmt.modified_non_trans_table || was_insert_delayed)
460
if (session->transaction.stmt.modified_non_trans_table)
461
session->transaction.all.modified_non_trans_table= true;
463
assert(transactional_table || !changed ||
464
session->transaction.stmt.modified_non_trans_table);
425
467
session->set_proc_info("end");
443
485
session->count_cuted_fields= CHECK_FIELD_IGNORE;
444
486
table->auto_increment_field_not_null= false;
445
487
if (duplic == DUP_REPLACE)
446
table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
488
table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
450
492
if (values_list.elements == 1 && (!(session->options & OPTION_WARNINGS) ||
451
493
!session->cuted_fields))
453
session->row_count_func= info.copied + info.deleted + info.updated;
454
session->my_ok((ulong) session->row_count_func,
455
info.copied + info.deleted + info.touched, id);
495
session->row_count_func= info.copied + info.deleted +
496
((session->client_capabilities & CLIENT_FOUND_ROWS) ?
497
info.touched : info.updated);
498
my_ok(session, (ulong) session->row_count_func, id);
503
ha_rows updated=((session->client_capabilities & CLIENT_FOUND_ROWS) ?
504
info.touched : info.updated);
461
snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
506
sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
462
507
(ulong) (info.records - info.copied), (ulong) session->cuted_fields);
464
snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
465
(ulong) (info.deleted + info.updated), (ulong) session->cuted_fields);
466
session->row_count_func= info.copied + info.deleted + info.updated;
467
session->my_ok((ulong) session->row_count_func,
468
info.copied + info.deleted + info.touched, id, buff);
509
sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
510
(ulong) (info.deleted + updated), (ulong) session->cuted_fields);
511
session->row_count_func= info.copied + info.deleted + updated;
512
::my_ok(session, (ulong) session->row_count_func, id, buff);
470
514
session->abort_on_warning= 0;
471
DRIZZLE_INSERT_DONE(0, session->row_count_func);
515
DRIZZLE_INSERT_END();
475
519
if (table != NULL)
476
table->cursor->ha_release_auto_increment();
520
table->file->ha_release_auto_increment();
477
521
if (!joins_freed)
478
522
free_underlaid_joins(session, &session->lex->select_lex);
479
523
session->abort_on_warning= 0;
480
DRIZZLE_INSERT_DONE(1, 0);
524
DRIZZLE_INSERT_END();
557
601
Table *table, List<Item> &fields, List_item *values,
558
602
List<Item> &update_fields, List<Item> &update_values,
559
603
enum_duplicates duplic,
604
COND **where __attribute__((unused)),
561
605
bool select_insert,
562
606
bool check_fields, bool abort_on_warning)
564
Select_Lex *select_lex= &session->lex->select_lex;
608
SELECT_LEX *select_lex= &session->lex->select_lex;
565
609
Name_resolution_context *context= &select_lex->context;
566
610
Name_resolution_context_state ctx_state;
567
611
bool insert_into_view= (0 != 0);
654
698
if (!select_insert)
656
700
TableList *duplicate;
657
if ((duplicate= unique_table(table_list, table_list->next_global, true)))
701
if ((duplicate= unique_table(session, table_list, table_list->next_global, 1)))
659
my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->alias);
703
update_non_unique_table_error(table_list, "INSERT", duplicate);
664
707
if (duplic == DUP_UPDATE || duplic == DUP_REPLACE)
665
708
table->prepare_for_position();
731
774
the autogenerated value to avoid session->insert_id_for_cur_row to become
734
if (table->cursor->insert_id_for_cur_row > 0)
735
insert_id_for_cur_row= table->cursor->insert_id_for_cur_row;
777
if (table->file->insert_id_for_cur_row > 0)
778
insert_id_for_cur_row= table->file->insert_id_for_cur_row;
737
table->cursor->insert_id_for_cur_row= insert_id_for_cur_row;
780
table->file->insert_id_for_cur_row= insert_id_for_cur_row;
738
781
bool is_duplicate_key_error;
739
if (table->cursor->is_fatal_error(error, HA_CHECK_DUP))
782
if (table->file->is_fatal_error(error, HA_CHECK_DUP))
741
is_duplicate_key_error= table->cursor->is_fatal_error(error, 0);
784
is_duplicate_key_error= table->file->is_fatal_error(error, 0);
742
785
if (!is_duplicate_key_error)
814
table->cursor->restore_auto_increment(prev_insert_id);
857
table->file->restore_auto_increment(prev_insert_id);
815
858
if (table->next_number_field)
816
table->cursor->adjust_next_insert_id_after_explicit_value(
859
table->file->adjust_next_insert_id_after_explicit_value(
817
860
table->next_number_field->val_int());
819
if ((table->cursor->getEngine()->check_flag(HTON_BIT_PARTIAL_COLUMN_READ) &&
862
if ((table->file->ha_table_flags() & HA_PARTIAL_COLUMN_READ &&
820
863
!bitmap_is_subset(table->write_set, table->read_set)) ||
821
864
table->compare_record())
823
if ((error=table->cursor->ha_update_row(table->record[1],
866
if ((error=table->file->ha_update_row(table->record[1],
824
867
table->record[0])) &&
825
868
error != HA_ERR_RECORD_IS_THE_SAME)
827
870
if (info->ignore &&
828
!table->cursor->is_fatal_error(error, HA_CHECK_DUP_KEY))
871
!table->file->is_fatal_error(error, HA_CHECK_DUP_KEY))
830
873
goto gok_or_after_err;
895
if ((error=table->cursor->ha_delete_row(table->record[1])))
938
if ((error=table->file->ha_delete_row(table->record[1])))
898
if (!table->cursor->has_transactions())
899
session->transaction.stmt.markModifiedNonTransData();
941
if (!table->file->has_transactions())
942
session->transaction.stmt.modified_non_trans_table= true;
900
943
/* Let us attempt do write_row() once more */
904
session->record_first_successful_insert_id_in_cur_stmt(table->cursor->insert_id_for_cur_row);
947
session->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
906
949
Restore column maps if they where replaced during an duplicate key
910
953
table->write_set != save_write_set)
911
954
table->column_bitmaps_set(save_read_set, save_write_set);
913
else if ((error=table->cursor->ha_write_row(table->record[0])))
956
else if ((error=table->file->ha_write_row(table->record[0])))
915
958
if (!info->ignore ||
916
table->cursor->is_fatal_error(error, HA_CHECK_DUP))
959
table->file->is_fatal_error(error, HA_CHECK_DUP))
918
table->cursor->restore_auto_increment(prev_insert_id);
961
table->file->restore_auto_increment(prev_insert_id);
919
962
goto gok_or_after_err;
922
965
after_n_copied_inc:
924
session->record_first_successful_insert_id_in_cur_stmt(table->cursor->insert_id_for_cur_row);
967
session->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
926
969
gok_or_after_err:
929
if (!table->cursor->has_transactions())
930
session->transaction.stmt.markModifiedNonTransData();
972
if (!table->file->has_transactions())
973
session->transaction.stmt.modified_non_trans_table= true;
1170
1214
We won't start bulk inserts at all if this statement uses functions or
1171
1215
should invoke triggers since they may access to the same table too.
1173
table->cursor->ha_start_bulk_insert((ha_rows) 0);
1217
table->file->ha_start_bulk_insert((ha_rows) 0);
1175
table->restoreRecordAsDefault(); // Get empty record
1219
restore_record(table,s->default_values); // Get empty record
1176
1220
table->next_number_field=table->found_next_number_field;
1222
if (session->slave_thread &&
1223
(info.handle_duplicates == DUP_UPDATE) &&
1224
(table->next_number_field != NULL) &&
1225
rpl_master_has_bug(&active_mi->rli, 24432))
1178
1228
session->cuted_fields=0;
1179
1229
if (info.ignore || info.handle_duplicates != DUP_ERROR)
1180
table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
1230
table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
1181
1231
if (info.handle_duplicates == DUP_REPLACE)
1182
table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1232
table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1183
1233
if (info.handle_duplicates == DUP_UPDATE)
1184
table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1234
table->file->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1185
1235
session->abort_on_warning= !info.ignore;
1186
1236
table->mark_columns_needed_for_insert();
1295
1342
void select_insert::store_values(List<Item> &values)
1297
1344
if (fields->elements)
1298
fill_record(session, *fields, values, true);
1345
fill_record(session, *fields, values, 1);
1300
fill_record(session, table->field, values, true);
1347
fill_record(session, table->field, values, 1);
1303
1350
void select_insert::send_error(uint32_t errcode,const char *err)
1313
1360
bool select_insert::send_eof()
1316
bool const trans_table= table->cursor->has_transactions();
1363
bool const trans_table= table->file->has_transactions();
1320
error= table->cursor->ha_end_bulk_insert();
1321
table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1322
table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1367
error= table->file->ha_end_bulk_insert();
1368
table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1369
table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1324
1371
if ((changed= (info.copied || info.deleted || info.updated)))
1327
1374
We must invalidate the table in the query cache before binlog writing
1328
1375
and ha_autocommit_or_rollback.
1330
if (session->transaction.stmt.hasModifiedNonTransData())
1331
session->transaction.all.markModifiedNonTransData();
1377
if (session->transaction.stmt.modified_non_trans_table)
1378
session->transaction.all.modified_non_trans_table= true;
1333
1380
assert(trans_table || !changed ||
1334
session->transaction.stmt.hasModifiedNonTransData());
1381
session->transaction.stmt.modified_non_trans_table);
1336
table->cursor->ha_release_auto_increment();
1383
table->file->ha_release_auto_increment();
1340
table->print_error(error,MYF(0));
1341
DRIZZLE_INSERT_SELECT_DONE(error, 0);
1387
table->file->print_error(error,MYF(0));
1344
1390
char buff[160];
1345
1391
if (info.ignore)
1346
snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
1392
sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
1347
1393
(ulong) (info.records - info.copied), (ulong) session->cuted_fields);
1349
snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
1395
sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
1350
1396
(ulong) (info.deleted+info.updated), (ulong) session->cuted_fields);
1351
session->row_count_func= info.copied + info.deleted + info.updated;
1397
session->row_count_func= info.copied + info.deleted +
1398
((session->client_capabilities & CLIENT_FOUND_ROWS) ?
1399
info.touched : info.updated);
1353
1401
id= (session->first_successful_insert_id_in_cur_stmt > 0) ?
1354
1402
session->first_successful_insert_id_in_cur_stmt :
1355
1403
(session->arg_of_last_insert_id_function ?
1356
1404
session->first_successful_insert_id_in_prev_stmt :
1357
1405
(info.copied ? autoinc_value_of_last_inserted_row : 0));
1358
session->my_ok((ulong) session->row_count_func,
1359
info.copied + info.deleted + info.touched, id, buff);
1360
DRIZZLE_INSERT_SELECT_DONE(0, session->row_count_func);
1406
::my_ok(session, (ulong) session->row_count_func, id, buff);
1364
1410
void select_insert::abort() {
1391
1437
zero, so no check for that is made.
1393
1439
changed= (info.copied || info.deleted || info.updated);
1394
transactional_table= table->cursor->has_transactions();
1440
transactional_table= table->file->has_transactions();
1395
1441
assert(transactional_table || !changed ||
1396
session->transaction.stmt.hasModifiedNonTransData());
1397
table->cursor->ha_release_auto_increment();
1400
if (DRIZZLE_INSERT_SELECT_DONE_ENABLED())
1402
DRIZZLE_INSERT_SELECT_DONE(0, info.copied + info.deleted + info.updated);
1442
session->transaction.stmt.modified_non_trans_table);
1443
table->file->ha_release_auto_increment();
1471
1510
Field *tmp_field;
1474
if (not (identifier.isTmp()) && create_table->table->db_stat)
1513
if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
1514
create_table->table->db_stat)
1476
/* Table already exists and was open at openTablesLock() stage. */
1477
if (is_if_not_exists)
1516
/* Table already exists and was open at open_and_lock_tables() stage. */
1517
if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
1479
1519
create_info->table_existed= 1; // Mark that table existed
1480
1520
push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1481
1521
ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
1482
1522
create_table->table_name);
1483
return create_table->table;
1523
return(create_table->table);
1486
1526
my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->table_name);
1490
1530
tmp_table.alias= 0;
1491
1531
tmp_table.timestamp_field= 0;
1492
1532
tmp_table.s= &share;
1533
init_tmp_table_share(session, &share, "", 0, "", "");
1494
1535
tmp_table.s->db_create_options=0;
1495
1536
tmp_table.s->blob_ptr_size= portable_sizeof_char_ptr;
1497
if (not table_proto.engine().name().compare("MyISAM"))
1498
tmp_table.s->db_low_byte_first= true;
1499
else if (not table_proto.engine().name().compare("MEMORY"))
1500
tmp_table.s->db_low_byte_first= true;
1537
tmp_table.s->db_low_byte_first=
1538
test(create_info->db_type == myisam_hton ||
1539
create_info->db_type == heap_hton);
1502
1540
tmp_table.null_row= false;
1503
1541
tmp_table.maybe_null= false;
1505
1543
while ((item=it++))
1507
CreateField *cr_field;
1545
Create_field *cr_field;
1508
1546
Field *field, *def_field;
1509
1547
if (item->type() == Item::FUNC_ITEM)
1510
1548
if (item->result_type() != STRING_RESULT)
1513
1551
field= item->tmp_table_field_from_field_type(&tmp_table, 0);
1515
1553
field= create_tmp_field(session, &tmp_table, item, item->type(),
1516
(Item ***) 0, &tmp_field, &def_field, false,
1554
(Item ***) 0, &tmp_field, &def_field, 0, 0, 0, 0,
1519
!(cr_field=new CreateField(field,(item->type() == Item::FIELD_ITEM ?
1557
!(cr_field=new Create_field(field,(item->type() == Item::FIELD_ITEM ?
1520
1558
((Item_field *)item)->field :
1523
1561
if (item->maybe_null)
1524
1562
cr_field->flags &= ~NOT_NULL_FLAG;
1525
1563
alter_info->create_list.push_back(cr_field);
1531
1569
Note that we either creating (or opening existing) temporary table or
1532
1570
creating base table on which name we have exclusive lock. So code below
1533
1571
should not cause deadlocks or races.
1573
We don't log the statement, it will be logged later.
1575
If this is a HEAP table, the automatic DELETE FROM which is written to the
1576
binlog when a HEAP table is opened for the first time since startup, must
1577
not be written: 1) it would be wrong (imagine we're in CREATE SELECT: we
1578
don't want to delete from it) 2) it would be written before the CREATE
1579
Table, which is a wrong order. So we keep binary logging disabled when we
1536
if (not mysql_create_table_no_lock(session,
1583
tmp_disable_binlog(session);
1584
if (!mysql_create_table_no_lock(session, create_table->db,
1585
create_table->table_name,
1586
create_info, alter_info, 0,
1587
select_field_count, true))
1545
if (create_info->table_existed && not identifier.isTmp())
1589
if (create_info->table_existed &&
1590
!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
1548
1593
This means that someone created table underneath server
1550
1595
cluster. We don't have much options but throw an error.
1552
1597
my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->table_name);
1556
if (not identifier.isTmp())
1601
if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
1558
pthread_mutex_lock(&LOCK_open); /* CREATE TABLE... has found that the table already exists for insert and is adapting to use it */
1559
if (session->reopen_name_locked_table(create_table, false))
1603
pthread_mutex_lock(&LOCK_open);
1604
if (reopen_name_locked_table(session, create_table, false))
1561
quick_rm_table(*session, identifier);
1606
quick_rm_table(create_info->db_type, create_table->db,
1607
table_case_name(create_info, create_table->table_name),
1564
1611
table= create_table->table;
1569
if (not (table= session->openTable(create_table, (bool*) 0,
1570
DRIZZLE_OPEN_TEMPORARY_ONLY)) &&
1571
not create_info->table_existed)
1616
if (!(table= open_table(session, create_table, (bool*) 0,
1617
DRIZZLE_OPEN_TEMPORARY_ONLY)) &&
1618
!create_info->table_existed)
1574
1621
This shouldn't happen as creation of temporary table should make
1575
1622
it preparable for open. But let us do close_temporary_table() here
1578
session->drop_temporary_table(create_table);
1625
drop_temporary_table(session, create_table);
1629
reenable_binlog(session);
1582
1630
if (!table) // open failed
1586
1634
table->reginfo.lock_type=TL_WRITE;
1635
hooks->prelock(&table, 1); // Call prelock hooks
1587
1636
if (! ((*lock)= mysql_lock_tables(session, &table, 1,
1588
DRIZZLE_LOCK_IGNORE_FLUSH, ¬_used)))
1637
DRIZZLE_LOCK_IGNORE_FLUSH, ¬_used)) ||
1638
hooks->postlock(&table, 1))
1596
if (not create_info->table_existed)
1597
session->drop_open_table(table, identifier);
1646
if (!create_info->table_existed)
1647
drop_open_table(session, table, create_table->db, create_table->table_name);
1606
select_create::prepare(List<Item> &values, Select_Lex_Unit *u)
1655
select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
1608
1657
DRIZZLE_LOCK *extra_lock= NULL;
1660
Tableop_hooks *hook_ptr= NULL;
1610
For replication, the CREATE-SELECT statement is written
1611
in two pieces: the first transaction messsage contains
1612
the CREATE TABLE statement as a CreateTableStatement message
1613
necessary to create the table.
1615
The second transaction message contains all the InsertStatement
1616
and associated InsertRecords that should go into the table.
1662
For row-based replication, the CREATE-SELECT statement is written
1663
in two pieces: the first one contain the CREATE TABLE statement
1664
necessary to create the table and the second part contain the rows
1665
that should go into the table.
1667
For non-temporary tables, the start of the CREATE-SELECT
1668
implicitly commits the previous transaction, and all events
1669
forming the statement will be stored the transaction cache. At end
1670
of the statement, the entire statement is committed as a
1671
transaction, and all events are written to the binary log.
1673
On the master, the table is locked for the duration of the
1674
statement, but since the CREATE part is replicated as a simple
1675
statement, there is no way to lock the table for accesses on the
1676
slave. Hence, we have to hold on to the CREATE part of the
1677
statement until the statement has finished.
1679
class MY_HOOKS : public Tableop_hooks {
1681
MY_HOOKS(select_create *x, TableList *create_table,
1682
TableList *select_tables)
1683
: ptr(x), all_tables(*create_table)
1685
all_tables.next_global= select_tables;
1689
virtual int do_postlock(Table **tables, uint32_t count)
1691
Table const *const table = *tables;
1692
if (drizzle_bin_log.is_open()
1693
&& !table->s->tmp_table
1694
&& !ptr->get_create_info()->table_existed)
1696
ptr->binlog_show_create_table(tables, count);
1702
TableList all_tables;
1705
MY_HOOKS hooks(this, create_table, select_tables);
1621
if (not (table= create_table_from_items(session, create_info, create_table,
1623
alter_info, &values,
1625
&extra_lock, identifier)))
1711
Start a statement transaction before the create if we are using
1712
row-based replication for the statement. If we are creating a
1713
temporary table, we need to start a statement transaction.
1715
if ((session->lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) == 0
1716
&& drizzle_bin_log.is_open())
1720
if (!(table= create_table_from_items(session, create_info, create_table,
1721
alter_info, &values,
1722
&extra_lock, hook_ptr)))
1626
1723
return(-1); // abort() deletes table
1628
1725
if (extra_lock)
1630
1727
assert(m_plock == NULL);
1632
if (identifier.isTmp())
1729
if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
1633
1730
m_plock= &m_lock;
1635
1732
m_plock= &session->extra_lock;
1649
1746
/* Mark all fields that are given values */
1650
1747
for (Field **f= field ; *f ; f++)
1651
table->setWriteSet((*f)->field_index);
1748
bitmap_set_bit(table->write_set, (*f)->field_index);
1653
1750
/* Don't set timestamp if used */
1654
1751
table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
1655
1752
table->next_number_field=table->found_next_number_field;
1657
table->restoreRecordAsDefault(); // Get empty record
1754
restore_record(table,s->default_values); // Get empty record
1658
1755
session->cuted_fields=0;
1659
1756
if (info.ignore || info.handle_duplicates != DUP_ERROR)
1660
table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
1757
table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
1661
1758
if (info.handle_duplicates == DUP_REPLACE)
1662
table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1759
table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1663
1760
if (info.handle_duplicates == DUP_UPDATE)
1664
table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1665
table->cursor->ha_start_bulk_insert((ha_rows) 0);
1761
table->file->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1762
table->file->ha_start_bulk_insert((ha_rows) 0);
1666
1763
session->abort_on_warning= !info.ignore;
1667
1764
if (check_that_all_fields_are_given_values(session, table, table_list))
1669
1766
table->mark_columns_needed_for_insert();
1670
table->cursor->extra(HA_EXTRA_WRITE_CACHE);
1767
table->file->extra(HA_EXTRA_WRITE_CACHE);
1772
select_create::binlog_show_create_table(Table **tables, uint32_t count)
1775
Note 1: In RBR mode, we generate a CREATE TABLE statement for the
1776
created table by calling store_create_info() (behaves as SHOW
1777
CREATE TABLE). In the event of an error, nothing should be
1778
written to the binary log, even if the table is non-transactional;
1779
therefore we pretend that the generated CREATE TABLE statement is
1780
for a transactional table. The event will then be put in the
1781
transaction cache, and any subsequent events (e.g., table-map
1782
events and binrow events) will also be put there. We can then use
1783
ha_autocommit_or_rollback() to either throw away the entire
1784
kaboodle of events, or write them to the binary log.
1786
We write the CREATE TABLE statement here and not in prepare()
1787
since there potentially are sub-selects or accesses to information
1788
schema that will do a close_thread_tables(), destroying the
1789
statement transaction cache.
1791
assert(tables && *tables && count > 0);
1794
String query(buf, sizeof(buf), system_charset_info);
1796
TableList tmp_table_list;
1798
memset(&tmp_table_list, 0, sizeof(tmp_table_list));
1799
tmp_table_list.table = *tables;
1800
query.length(0); // Have to zero it since constructor doesn't
1802
result= store_create_info(session, &tmp_table_list, &query, create_info);
1803
assert(result == 0); /* store_create_info() always return 0 */
1674
1806
void select_create::store_values(List<Item> &values)
1676
fill_record(session, field, values, true);
1808
fill_record(session, field, values, 1);
1680
1812
void select_create::send_error(uint32_t errcode,const char *err)
1683
1817
This will execute any rollbacks that are necessary before writing
1684
1818
the transcation cache.
1711
1847
if (!table->s->tmp_table)
1713
TransactionServices &transaction_services= TransactionServices::singleton();
1714
transaction_services.ha_autocommit_or_rollback(session, 0);
1715
(void) session->endActiveTransaction();
1849
ha_autocommit_or_rollback(session, 0);
1850
end_active_trans(session);
1718
table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1719
table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1853
table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1854
table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1722
1857
mysql_unlock_tables(session, *m_plock);
1759
table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1760
table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1761
if (not create_info->table_existed)
1762
session->drop_open_table(table, identifier);
1763
table= NULL; // Safety
1900
table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1901
table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1902
if (!create_info->table_existed)
1903
drop_open_table(session, table, create_table->db, create_table->table_name);
1767
} /* namespace drizzled */
1910
/*****************************************************************************
1911
Instansiate templates
1912
*****************************************************************************/
1914
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
1915
template class List_iterator_fast<List_item>;
1916
#endif /* HAVE_EXPLICIT_TEMPLATE_INSTANTIATION */