1
/*****************************************************************************
3
Copyright (c) 1996, 2010, Innobase Oy. All Rights Reserved.
5
This program is free software; you can redistribute it and/or modify it under
6
the terms of the GNU General Public License as published by the Free Software
7
Foundation; version 2 of the License.
9
This program is distributed in the hope that it will be useful, but WITHOUT
10
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
13
You should have received a copy of the GNU General Public License along with
14
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15
Place, Suite 330, Boston, MA 02111-1307 USA
17
*****************************************************************************/
19
/**************************************************//**
23
Created 4/20/1996 Heikki Tuuri
24
*******************************************************/
32
#include "ha_prototypes.h"
33
#include "dict0dict.h"
34
#include "dict0boot.h"
38
#include "mach0data.h"
44
#include "lock0lock.h"
46
#include "eval0eval.h"
47
#include "data0data.h"
51
#define ROW_INS_PREV 1
52
#define ROW_INS_NEXT 2
54
/*************************************************************************
55
IMPORTANT NOTE: Any operation that generates redo MUST check that there
56
is enough space in the redo log before for that operation. This is
57
done by calling log_free_check(). The reason for checking the
58
availability of the redo log space before the start of the operation is
59
that we MUST not hold any synchonization objects when performing the
61
If you make a change in this module make sure that no codepath is
62
introduced where a call to log_free_check() is bypassed. */
64
/*********************************************************************//**
65
Creates an insert node struct.
66
@return own: insert node struct */
71
ulint ins_type, /*!< in: INS_VALUES, ... */
72
dict_table_t* table, /*!< in: table where to insert */
73
mem_heap_t* heap) /*!< in: mem heap where created */
77
node = mem_heap_alloc(heap, sizeof(ins_node_t));
79
node->common.type = QUE_NODE_INSERT;
81
node->ins_type = ins_type;
83
node->state = INS_NODE_SET_IX_LOCK;
92
node->entry_sys_heap = mem_heap_create(128);
94
node->magic_n = INS_NODE_MAGIC_N;
99
/***********************************************************//**
100
Creates an entry template for each index of a table. */
103
ins_node_create_entry_list(
104
/*=======================*/
105
ins_node_t* node) /*!< in: row insert node */
110
ut_ad(node->entry_sys_heap);
112
UT_LIST_INIT(node->entry_list);
114
index = dict_table_get_first_index(node->table);
116
while (index != NULL) {
117
entry = row_build_index_entry(node->row, NULL, index,
118
node->entry_sys_heap);
119
UT_LIST_ADD_LAST(tuple_list, node->entry_list, entry);
121
/* We will include all indexes (include those corrupted
122
secondary indexes) in the entry list. Filteration of
123
these corrupted index will be done in row_ins() */
124
index = dict_table_get_next_index(index);
128
/*****************************************************************//**
129
Adds system field buffers to a row. */
132
row_ins_alloc_sys_fields(
133
/*=====================*/
134
ins_node_t* node) /*!< in: insert node */
139
const dict_col_t* col;
145
heap = node->entry_sys_heap;
147
ut_ad(row && table && heap);
148
ut_ad(dtuple_get_n_fields(row) == dict_table_get_n_cols(table));
150
/* 1. Allocate buffer for row id */
152
col = dict_table_get_sys_col(table, DATA_ROW_ID);
154
dfield = dtuple_get_nth_field(row, dict_col_get_no(col));
156
ptr = mem_heap_zalloc(heap, DATA_ROW_ID_LEN);
158
dfield_set_data(dfield, ptr, DATA_ROW_ID_LEN);
160
node->row_id_buf = ptr;
162
/* 3. Allocate buffer for trx id */
164
col = dict_table_get_sys_col(table, DATA_TRX_ID);
166
dfield = dtuple_get_nth_field(row, dict_col_get_no(col));
167
ptr = mem_heap_zalloc(heap, DATA_TRX_ID_LEN);
169
dfield_set_data(dfield, ptr, DATA_TRX_ID_LEN);
171
node->trx_id_buf = ptr;
173
/* 4. Allocate buffer for roll ptr */
175
col = dict_table_get_sys_col(table, DATA_ROLL_PTR);
177
dfield = dtuple_get_nth_field(row, dict_col_get_no(col));
178
ptr = mem_heap_zalloc(heap, DATA_ROLL_PTR_LEN);
180
dfield_set_data(dfield, ptr, DATA_ROLL_PTR_LEN);
183
/*********************************************************************//**
184
Sets a new row to insert for an INS_DIRECT node. This function is only used
185
if we have constructed the row separately, which is a rare case; this
186
function is quite slow. */
189
ins_node_set_new_row(
190
/*=================*/
191
ins_node_t* node, /*!< in: insert node */
192
dtuple_t* row) /*!< in: new row (or first row) for the node */
194
node->state = INS_NODE_SET_IX_LOCK;
200
mem_heap_empty(node->entry_sys_heap);
202
/* Create templates for index entries */
204
ins_node_create_entry_list(node);
206
/* Allocate from entry_sys_heap buffers for sys fields */
208
row_ins_alloc_sys_fields(node);
210
/* As we allocated a new trx id buf, the trx id should be written
216
/*******************************************************************//**
217
Does an insert operation by updating a delete-marked existing record
218
in the index. This situation can occur if the delete-marked record is
219
kept in the index for consistent reads.
220
@return DB_SUCCESS or error code */
223
row_ins_sec_index_entry_by_modify(
224
/*==============================*/
225
ulint mode, /*!< in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
226
depending on whether mtr holds just a leaf
227
latch or also a tree latch */
228
btr_cur_t* cursor, /*!< in: B-tree cursor */
229
const dtuple_t* entry, /*!< in: index entry to insert */
230
que_thr_t* thr, /*!< in: query thread */
231
mtr_t* mtr) /*!< in: mtr; must be committed before
232
latching any further pages */
234
big_rec_t* dummy_big_rec;
240
rec = btr_cur_get_rec(cursor);
242
ut_ad(!dict_index_is_clust(cursor->index));
243
ut_ad(rec_get_deleted_flag(rec,
244
dict_table_is_comp(cursor->index->table)));
246
/* We know that in the alphabetical ordering, entry and rec are
247
identified. But in their binary form there may be differences if
248
there are char fields in them. Therefore we have to calculate the
251
heap = mem_heap_create(1024);
253
update = row_upd_build_sec_rec_difference_binary(
254
cursor->index, entry, rec, thr_get_trx(thr), heap);
255
if (mode == BTR_MODIFY_LEAF) {
256
/* Try an optimistic updating of the record, keeping changes
259
err = btr_cur_optimistic_update(BTR_KEEP_SYS_FLAG, cursor,
260
update, 0, thr, mtr);
264
case DB_ZIP_OVERFLOW:
268
ut_a(mode == BTR_MODIFY_TREE);
269
if (buf_LRU_buf_pool_running_out()) {
271
err = DB_LOCK_TABLE_FULL;
276
err = btr_cur_pessimistic_update(BTR_KEEP_SYS_FLAG, cursor,
277
&heap, &dummy_big_rec, update,
279
ut_ad(!dummy_big_rec);
287
/*******************************************************************//**
288
Does an insert operation by delete unmarking and updating a delete marked
289
existing record in the index. This situation can occur if the delete marked
290
record is kept in the index for consistent reads.
291
@return DB_SUCCESS, DB_FAIL, or error code */
294
row_ins_clust_index_entry_by_modify(
295
/*================================*/
296
ulint mode, /*!< in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
297
depending on whether mtr holds just a leaf
298
latch or also a tree latch */
299
btr_cur_t* cursor, /*!< in: B-tree cursor */
300
mem_heap_t** heap, /*!< in/out: pointer to memory heap, or NULL */
301
big_rec_t** big_rec,/*!< out: possible big rec vector of fields
302
which have to be stored externally by the
304
const dtuple_t* entry, /*!< in: index entry to insert */
305
que_thr_t* thr, /*!< in: query thread */
306
mtr_t* mtr) /*!< in: mtr; must be committed before
307
latching any further pages */
313
ut_ad(dict_index_is_clust(cursor->index));
317
rec = btr_cur_get_rec(cursor);
319
ut_ad(rec_get_deleted_flag(rec,
320
dict_table_is_comp(cursor->index->table)));
323
*heap = mem_heap_create(1024);
326
/* Build an update vector containing all the fields to be modified;
327
NOTE that this vector may NOT contain system columns trx_id or
330
update = row_upd_build_difference_binary(cursor->index, entry, rec,
331
thr_get_trx(thr), *heap);
332
if (mode == BTR_MODIFY_LEAF) {
333
/* Try optimistic updating of the record, keeping changes
336
err = btr_cur_optimistic_update(0, cursor, update, 0, thr,
341
case DB_ZIP_OVERFLOW:
345
ut_a(mode == BTR_MODIFY_TREE);
346
if (buf_LRU_buf_pool_running_out()) {
348
return(DB_LOCK_TABLE_FULL);
351
err = btr_cur_pessimistic_update(0, cursor,
352
heap, big_rec, update,
359
/*********************************************************************//**
360
Returns TRUE if in a cascaded update/delete an ancestor node of node
361
updates (not DELETE, but UPDATE) table.
362
@return TRUE if an ancestor updates table */
365
row_ins_cascade_ancestor_updates_table(
366
/*===================================*/
367
que_node_t* node, /*!< in: node in a query graph */
368
dict_table_t* table) /*!< in: table */
371
upd_node_t* upd_node;
373
parent = que_node_get_parent(node);
375
while (que_node_get_type(parent) == QUE_NODE_UPDATE) {
379
if (upd_node->table == table && upd_node->is_delete == FALSE) {
384
parent = que_node_get_parent(parent);
392
/*********************************************************************//**
393
Returns the number of ancestor UPDATE or DELETE nodes of a
394
cascaded update/delete node.
395
@return number of ancestors */
398
row_ins_cascade_n_ancestors(
399
/*========================*/
400
que_node_t* node) /*!< in: node in a query graph */
403
ulint n_ancestors = 0;
405
parent = que_node_get_parent(node);
407
while (que_node_get_type(parent) == QUE_NODE_UPDATE) {
410
parent = que_node_get_parent(parent);
418
/******************************************************************//**
419
Calculates the update vector node->cascade->update for a child table in
421
@return number of fields in the calculated update vector; the value
422
can also be 0 if no foreign key fields changed; the returned value is
423
ULINT_UNDEFINED if the column type in the child table is too short to
424
fit the new value in the parent table: that means the update fails */
427
row_ins_cascade_calc_update_vec(
428
/*============================*/
429
upd_node_t* node, /*!< in: update node of the parent
431
dict_foreign_t* foreign, /*!< in: foreign key constraint whose
433
mem_heap_t* heap) /*!< in: memory heap to use as
436
upd_node_t* cascade = node->cascade_node;
437
dict_table_t* table = foreign->foreign_table;
438
dict_index_t* index = foreign->foreign_index;
441
dict_table_t* parent_table;
442
dict_index_t* parent_index;
443
upd_t* parent_update;
444
upd_field_t* parent_ufield;
445
ulint n_fields_updated;
446
ulint parent_field_no;
456
/* Calculate the appropriate update vector which will set the fields
457
in the child index record to the same value (possibly padded with
458
spaces if the column is a fixed length CHAR or FIXBINARY column) as
459
the referenced index record will get in the update. */
461
parent_table = node->table;
462
ut_a(parent_table == foreign->referenced_table);
463
parent_index = foreign->referenced_index;
464
parent_update = node->update;
466
update = cascade->update;
468
update->info_bits = 0;
469
update->n_fields = foreign->n_fields;
471
n_fields_updated = 0;
473
for (i = 0; i < foreign->n_fields; i++) {
475
parent_field_no = dict_table_get_nth_col_pos(
477
dict_index_get_nth_col_no(parent_index, i));
479
for (j = 0; j < parent_update->n_fields; j++) {
480
parent_ufield = parent_update->fields + j;
482
if (parent_ufield->field_no == parent_field_no) {
485
const dict_col_t* col;
488
col = dict_index_get_nth_col(index, i);
490
/* A field in the parent index record is
491
updated. Let us make the update vector
492
field for the child table. */
494
ufield = update->fields + n_fields_updated;
497
= dict_table_get_nth_col_pos(
498
table, dict_col_get_no(col));
501
ufield->new_val = parent_ufield->new_val;
502
ufield_len = dfield_get_len(&ufield->new_val);
504
/* Clear the "external storage" flag */
505
dfield_set_len(&ufield->new_val, ufield_len);
507
/* Do not allow a NOT NULL column to be
510
if (dfield_is_null(&ufield->new_val)
511
&& (col->prtype & DATA_NOT_NULL)) {
513
return(ULINT_UNDEFINED);
516
/* If the new value would not fit in the
517
column, do not allow the update */
519
if (!dfield_is_null(&ufield->new_val)
520
&& dtype_get_at_most_n_mbchars(
521
col->prtype, col->mbminmaxlen,
524
dfield_get_data(&ufield->new_val))
527
return(ULINT_UNDEFINED);
530
/* If the parent column type has a different
531
length than the child column type, we may
532
need to pad with spaces the new value of the
535
min_size = dict_col_get_min_size(col);
537
/* Because UNIV_SQL_NULL (the marker
538
of SQL NULL values) exceeds all possible
539
values of min_size, the test below will
540
not hold for SQL NULL columns. */
542
if (min_size > ufield_len) {
549
padded_data = mem_heap_alloc(
552
pad = padded_data + ufield_len;
553
pad_len = min_size - ufield_len;
556
dfield_get_data(&ufield
560
mbminlen = dict_col_get_mbminlen(col);
562
ut_ad(!(ufield_len % mbminlen));
563
ut_ad(!(min_size % mbminlen));
566
&& dtype_get_charset_coll(
568
== DATA_MYSQL_BINARY_CHARSET_COLL) {
569
/* Do not pad BINARY columns */
570
return(ULINT_UNDEFINED);
573
row_mysql_pad_col(mbminlen,
575
dfield_set_data(&ufield->new_val,
576
padded_data, min_size);
584
update->n_fields = n_fields_updated;
586
return(n_fields_updated);
589
/*********************************************************************//**
590
Set detailed error message associated with foreign key errors for
591
the given transaction. */
594
row_ins_set_detailed(
595
/*=================*/
596
trx_t* trx, /*!< in: transaction */
597
dict_foreign_t* foreign) /*!< in: foreign key constraint */
599
mutex_enter(&srv_misc_tmpfile_mutex);
600
rewind(srv_misc_tmpfile);
602
if (os_file_set_eof(srv_misc_tmpfile)) {
603
ut_print_name(srv_misc_tmpfile, trx, TRUE,
604
foreign->foreign_table_name);
605
dict_print_info_on_foreign_key_in_create_format(
606
srv_misc_tmpfile, trx, foreign, FALSE);
607
trx_set_detailed_error_from_file(trx, srv_misc_tmpfile);
609
trx_set_detailed_error(trx, "temp file operation failed");
612
mutex_exit(&srv_misc_tmpfile_mutex);
615
/*********************************************************************//**
616
Reports a foreign key error associated with an update or a delete of a
617
parent table index entry. */
620
row_ins_foreign_report_err(
621
/*=======================*/
622
const char* errstr, /*!< in: error string from the viewpoint
623
of the parent table */
624
que_thr_t* thr, /*!< in: query thread whose run_node
626
dict_foreign_t* foreign, /*!< in: foreign key constraint */
627
const rec_t* rec, /*!< in: a matching index record in the
629
const dtuple_t* entry) /*!< in: index entry in the parent
632
FILE* ef = dict_foreign_err_file;
633
trx_t* trx = thr_get_trx(thr);
635
row_ins_set_detailed(trx, foreign);
637
mutex_enter(&dict_foreign_err_mutex);
639
ut_print_timestamp(ef);
640
fputs(" Transaction:\n", ef);
641
trx_print(ef, trx, 600);
643
fputs("Foreign key constraint fails for table ", ef);
644
ut_print_name(ef, trx, TRUE, foreign->foreign_table_name);
646
dict_print_info_on_foreign_key_in_create_format(ef, trx, foreign,
650
fputs(" in parent table, in index ", ef);
651
ut_print_name(ef, trx, FALSE, foreign->referenced_index->name);
653
fputs(" tuple:\n", ef);
654
dtuple_print(ef, entry);
656
fputs("\nBut in child table ", ef);
657
ut_print_name(ef, trx, TRUE, foreign->foreign_table_name);
658
fputs(", in index ", ef);
659
ut_print_name(ef, trx, FALSE, foreign->foreign_index->name);
661
fputs(", there is a record:\n", ef);
662
rec_print(ef, rec, foreign->foreign_index);
664
fputs(", the record is not available\n", ef);
668
mutex_exit(&dict_foreign_err_mutex);
671
/*********************************************************************//**
672
Reports a foreign key error to dict_foreign_err_file when we are trying
673
to add an index entry to a child table. Note that the adding may be the result
674
of an update, too. */
677
row_ins_foreign_report_add_err(
678
/*===========================*/
679
trx_t* trx, /*!< in: transaction */
680
dict_foreign_t* foreign, /*!< in: foreign key constraint */
681
const rec_t* rec, /*!< in: a record in the parent table:
682
it does not match entry because we
684
const dtuple_t* entry) /*!< in: index entry to insert in the
687
FILE* ef = dict_foreign_err_file;
689
row_ins_set_detailed(trx, foreign);
691
mutex_enter(&dict_foreign_err_mutex);
693
ut_print_timestamp(ef);
694
fputs(" Transaction:\n", ef);
695
trx_print(ef, trx, 600);
696
fputs("Foreign key constraint fails for table ", ef);
697
ut_print_name(ef, trx, TRUE, foreign->foreign_table_name);
699
dict_print_info_on_foreign_key_in_create_format(ef, trx, foreign,
701
fputs("\nTrying to add in child table, in index ", ef);
702
ut_print_name(ef, trx, FALSE, foreign->foreign_index->name);
704
fputs(" tuple:\n", ef);
705
/* TODO: DB_TRX_ID and DB_ROLL_PTR may be uninitialized.
706
It would be better to only display the user columns. */
707
dtuple_print(ef, entry);
709
fputs("\nBut in parent table ", ef);
710
ut_print_name(ef, trx, TRUE, foreign->referenced_table_name);
711
fputs(", in index ", ef);
712
ut_print_name(ef, trx, FALSE, foreign->referenced_index->name);
713
fputs(",\nthe closest match we can find is record:\n", ef);
714
if (rec && page_rec_is_supremum(rec)) {
715
/* If the cursor ended on a supremum record, it is better
716
to report the previous record in the error message, so that
717
the user gets a more descriptive error message. */
718
rec = page_rec_get_prev_const(rec);
722
rec_print(ef, rec, foreign->referenced_index);
726
mutex_exit(&dict_foreign_err_mutex);
729
/*********************************************************************//**
730
Invalidate the query cache for the given table. */
733
row_ins_invalidate_query_cache(
734
/*===========================*/
735
que_thr_t* thr, /*!< in: query thread whose run_node
737
const char* name) /*!< in: table name prefixed with
738
database name and a '/' character */
742
ulint len = strlen(name) + 1;
744
buf = mem_strdupl(name, len);
746
ptr = strchr(buf, '/');
750
innobase_invalidate_query_cache(thr_get_trx(thr), buf, len);
754
/*********************************************************************//**
755
Perform referential actions or checks when a parent row is deleted or updated
756
and the constraint had an ON DELETE or ON UPDATE condition which was not
758
@return DB_SUCCESS, DB_LOCK_WAIT, or error code */
761
row_ins_foreign_check_on_constraint(
762
/*================================*/
763
que_thr_t* thr, /*!< in: query thread whose run_node
765
dict_foreign_t* foreign, /*!< in: foreign key constraint whose
767
btr_pcur_t* pcur, /*!< in: cursor placed on a matching
768
index record in the child table */
769
dtuple_t* entry, /*!< in: index entry in the parent
771
mtr_t* mtr) /*!< in: mtr holding the latch of pcur
776
dict_table_t* table = foreign->foreign_table;
778
dict_index_t* clust_index;
780
mem_heap_t* upd_vec_heap = NULL;
782
const rec_t* clust_rec;
783
const buf_block_t* clust_block;
789
mem_heap_t* tmp_heap = NULL;
796
trx = thr_get_trx(thr);
798
/* Since we are going to delete or update a row, we have to invalidate
799
the MySQL query cache for table. A deadlock of threads is not possible
800
here because the caller of this function does not hold any latches with
801
the sync0sync.h rank above the kernel mutex. The query cache mutex has
802
a rank just above the kernel mutex. */
804
row_ins_invalidate_query_cache(thr, table->name);
806
node = thr->run_node;
808
if (node->is_delete && 0 == (foreign->type
809
& (DICT_FOREIGN_ON_DELETE_CASCADE
810
| DICT_FOREIGN_ON_DELETE_SET_NULL))) {
812
row_ins_foreign_report_err("Trying to delete",
814
btr_pcur_get_rec(pcur), entry);
816
return(DB_ROW_IS_REFERENCED);
819
if (!node->is_delete && 0 == (foreign->type
820
& (DICT_FOREIGN_ON_UPDATE_CASCADE
821
| DICT_FOREIGN_ON_UPDATE_SET_NULL))) {
823
/* This is an UPDATE */
825
row_ins_foreign_report_err("Trying to update",
827
btr_pcur_get_rec(pcur), entry);
829
return(DB_ROW_IS_REFERENCED);
832
if (node->cascade_node == NULL) {
833
/* Extend our query graph by creating a child to current
834
update node. The child is used in the cascade or set null
837
node->cascade_heap = mem_heap_create(128);
838
node->cascade_node = row_create_update_node_for_mysql(
839
table, node->cascade_heap);
840
que_node_set_parent(node->cascade_node, node);
843
/* Initialize cascade_node to do the operation we want. Note that we
844
use the SAME cascade node to do all foreign key operations of the
845
SQL DELETE: the table of the cascade node may change if there are
846
several child tables to the table where the delete is done! */
848
cascade = node->cascade_node;
850
cascade->table = table;
852
cascade->foreign = foreign;
855
&& (foreign->type & DICT_FOREIGN_ON_DELETE_CASCADE)) {
856
cascade->is_delete = TRUE;
858
cascade->is_delete = FALSE;
860
if (foreign->n_fields > cascade->update_n_fields) {
861
/* We have to make the update vector longer */
863
cascade->update = upd_create(foreign->n_fields,
865
cascade->update_n_fields = foreign->n_fields;
869
/* We do not allow cyclic cascaded updating (DELETE is allowed,
870
but not UPDATE) of the same table, as this can lead to an infinite
871
cycle. Check that we are not updating the same table which is
872
already being modified in this cascade chain. We have to check
873
this also because the modification of the indexes of a 'parent'
874
table may still be incomplete, and we must avoid seeing the indexes
875
of the parent table in an inconsistent state! */
877
if (!cascade->is_delete
878
&& row_ins_cascade_ancestor_updates_table(cascade, table)) {
880
/* We do not know if this would break foreign key
881
constraints, but play safe and return an error */
883
err = DB_ROW_IS_REFERENCED;
885
row_ins_foreign_report_err(
886
"Trying an update, possibly causing a cyclic"
888
"in the child table,", thr, foreign,
889
btr_pcur_get_rec(pcur), entry);
891
goto nonstandard_exit_func;
894
if (row_ins_cascade_n_ancestors(cascade) >= 15) {
895
err = DB_ROW_IS_REFERENCED;
897
row_ins_foreign_report_err(
898
"Trying a too deep cascaded delete or update\n",
899
thr, foreign, btr_pcur_get_rec(pcur), entry);
901
goto nonstandard_exit_func;
904
index = btr_pcur_get_btr_cur(pcur)->index;
906
ut_a(index == foreign->foreign_index);
908
rec = btr_pcur_get_rec(pcur);
910
if (dict_index_is_clust(index)) {
911
/* pcur is already positioned in the clustered index of
916
clust_block = btr_pcur_get_block(pcur);
918
/* We have to look for the record in the clustered index
919
in the child table */
921
clust_index = dict_table_get_first_index(table);
923
tmp_heap = mem_heap_create(256);
925
ref = row_build_row_ref(ROW_COPY_POINTERS, index, rec,
927
btr_pcur_open_with_no_init(clust_index, ref,
928
PAGE_CUR_LE, BTR_SEARCH_LEAF,
929
cascade->pcur, 0, mtr);
931
clust_rec = btr_pcur_get_rec(cascade->pcur);
932
clust_block = btr_pcur_get_block(cascade->pcur);
934
if (!page_rec_is_user_rec(clust_rec)
935
|| btr_pcur_get_low_match(cascade->pcur)
936
< dict_index_get_n_unique(clust_index)) {
938
fputs("InnoDB: error in cascade of a foreign key op\n"
940
dict_index_name_print(stderr, trx, index);
943
"InnoDB: record ", stderr);
944
rec_print(stderr, rec, index);
946
"InnoDB: clustered record ", stderr);
947
rec_print(stderr, clust_rec, clust_index);
949
"InnoDB: Submit a detailed bug report to"
950
" http://bugs.mysql.com\n", stderr);
954
goto nonstandard_exit_func;
958
/* Set an X-lock on the row to delete or update in the child table */
960
err = lock_table(0, table, LOCK_IX, thr);
962
if (err == DB_SUCCESS) {
963
/* Here it suffices to use a LOCK_REC_NOT_GAP type lock;
964
we already have a normal shared lock on the appropriate
965
gap if the search criterion was not unique */
967
err = lock_clust_rec_read_check_and_lock_alt(
968
0, clust_block, clust_rec, clust_index,
969
LOCK_X, LOCK_REC_NOT_GAP, thr);
972
if (err != DB_SUCCESS) {
974
goto nonstandard_exit_func;
977
if (rec_get_deleted_flag(clust_rec, dict_table_is_comp(table))) {
978
/* This can happen if there is a circular reference of
979
rows such that cascading delete comes to delete a row
980
already in the process of being delete marked */
983
goto nonstandard_exit_func;
987
&& (foreign->type & DICT_FOREIGN_ON_DELETE_SET_NULL))
989
&& (foreign->type & DICT_FOREIGN_ON_UPDATE_SET_NULL))) {
991
/* Build the appropriate update vector which sets
992
foreign->n_fields first fields in rec to SQL NULL */
994
update = cascade->update;
996
update->info_bits = 0;
997
update->n_fields = foreign->n_fields;
999
for (i = 0; i < foreign->n_fields; i++) {
1000
upd_field_t* ufield = &update->fields[i];
1002
ufield->field_no = dict_table_get_nth_col_pos(
1004
dict_index_get_nth_col_no(index, i));
1005
ufield->orig_len = 0;
1007
dfield_set_null(&ufield->new_val);
1011
if (!node->is_delete
1012
&& (foreign->type & DICT_FOREIGN_ON_UPDATE_CASCADE)) {
1014
/* Build the appropriate update vector which sets changing
1015
foreign->n_fields first fields in rec to new values */
1017
upd_vec_heap = mem_heap_create(256);
1019
n_to_update = row_ins_cascade_calc_update_vec(node, foreign,
1021
if (n_to_update == ULINT_UNDEFINED) {
1022
err = DB_ROW_IS_REFERENCED;
1024
row_ins_foreign_report_err(
1025
"Trying a cascaded update where the"
1026
" updated value in the child\n"
1027
"table would not fit in the length"
1028
" of the column, or the value would\n"
1029
"be NULL and the column is"
1030
" declared as not NULL in the child table,",
1031
thr, foreign, btr_pcur_get_rec(pcur), entry);
1033
goto nonstandard_exit_func;
1036
if (cascade->update->n_fields == 0) {
1038
/* The update does not change any columns referred
1039
to in this foreign key constraint: no need to do
1044
goto nonstandard_exit_func;
1048
/* Store pcur position and initialize or store the cascade node
1049
pcur stored position */
1051
btr_pcur_store_position(pcur, mtr);
1053
if (index == clust_index) {
1054
btr_pcur_copy_stored_position(cascade->pcur, pcur);
1056
btr_pcur_store_position(cascade->pcur, mtr);
1061
ut_a(cascade->pcur->rel_pos == BTR_PCUR_ON);
1063
cascade->state = UPD_NODE_UPDATE_CLUSTERED;
1065
err = row_update_cascade_for_mysql(thr, cascade,
1066
foreign->foreign_table);
1068
if (foreign->foreign_table->n_foreign_key_checks_running == 0) {
1070
"InnoDB: error: table %s has the counter 0"
1071
" though there is\n"
1072
"InnoDB: a FOREIGN KEY check running on it.\n",
1073
foreign->foreign_table->name);
1076
/* Release the data dictionary latch for a while, so that we do not
1077
starve other threads from doing CREATE TABLE etc. if we have a huge
1078
cascaded operation running. The counter n_foreign_key_checks_running
1079
will prevent other users from dropping or ALTERing the table when we
1080
release the latch. */
1082
row_mysql_unfreeze_data_dictionary(thr_get_trx(thr));
1083
row_mysql_freeze_data_dictionary(thr_get_trx(thr));
1087
/* Restore pcur position */
1089
btr_pcur_restore_position(BTR_SEARCH_LEAF, pcur, mtr);
1092
mem_heap_free(tmp_heap);
1096
mem_heap_free(upd_vec_heap);
1101
nonstandard_exit_func:
1103
mem_heap_free(tmp_heap);
1107
mem_heap_free(upd_vec_heap);
1110
btr_pcur_store_position(pcur, mtr);
1115
btr_pcur_restore_position(BTR_SEARCH_LEAF, pcur, mtr);
1120
/*********************************************************************//**
1121
Sets a shared lock on a record. Used in locking possible duplicate key
1122
records and also in checking foreign key constraints.
1123
@return DB_SUCCESS, DB_SUCCESS_LOCKED_REC, or error code */
1126
row_ins_set_shared_rec_lock(
1127
/*========================*/
1128
ulint type, /*!< in: LOCK_ORDINARY, LOCK_GAP, or
1129
LOCK_REC_NOT_GAP type lock */
1130
const buf_block_t* block, /*!< in: buffer block of rec */
1131
const rec_t* rec, /*!< in: record */
1132
dict_index_t* index, /*!< in: index */
1133
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
1134
que_thr_t* thr) /*!< in: query thread */
1138
ut_ad(rec_offs_validate(rec, index, offsets));
1140
if (dict_index_is_clust(index)) {
1141
err = lock_clust_rec_read_check_and_lock(
1142
0, block, rec, index, offsets, LOCK_S, type, thr);
1144
err = lock_sec_rec_read_check_and_lock(
1145
0, block, rec, index, offsets, LOCK_S, type, thr);
1151
/*********************************************************************//**
1152
Sets a exclusive lock on a record. Used in locking possible duplicate key
1154
@return DB_SUCCESS, DB_SUCCESS_LOCKED_REC, or error code */
1157
row_ins_set_exclusive_rec_lock(
1158
/*===========================*/
1159
ulint type, /*!< in: LOCK_ORDINARY, LOCK_GAP, or
1160
LOCK_REC_NOT_GAP type lock */
1161
const buf_block_t* block, /*!< in: buffer block of rec */
1162
const rec_t* rec, /*!< in: record */
1163
dict_index_t* index, /*!< in: index */
1164
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
1165
que_thr_t* thr) /*!< in: query thread */
1169
ut_ad(rec_offs_validate(rec, index, offsets));
1171
if (dict_index_is_clust(index)) {
1172
err = lock_clust_rec_read_check_and_lock(
1173
0, block, rec, index, offsets, LOCK_X, type, thr);
1175
err = lock_sec_rec_read_check_and_lock(
1176
0, block, rec, index, offsets, LOCK_X, type, thr);
1182
/***************************************************************//**
1183
Checks if foreign key constraint fails for an index entry. Sets shared locks
1184
which lock either the success or the failure of the constraint. NOTE that
1185
the caller must have a shared latch on dict_operation_lock.
1186
@return DB_SUCCESS, DB_NO_REFERENCED_ROW, or DB_ROW_IS_REFERENCED */
1189
row_ins_check_foreign_constraint(
1190
/*=============================*/
1191
ibool check_ref,/*!< in: TRUE if we want to check that
1192
the referenced table is ok, FALSE if we
1193
want to check the foreign key table */
1194
dict_foreign_t* foreign,/*!< in: foreign constraint; NOTE that the
1195
tables mentioned in it must be in the
1196
dictionary cache if they exist at all */
1197
dict_table_t* table, /*!< in: if check_ref is TRUE, then the foreign
1198
table, else the referenced table */
1199
dtuple_t* entry, /*!< in: index entry for index */
1200
que_thr_t* thr) /*!< in: query thread */
1202
upd_node_t* upd_node;
1203
dict_table_t* check_table;
1204
dict_index_t* check_index;
1211
trx_t* trx = thr_get_trx(thr);
1212
mem_heap_t* heap = NULL;
1213
ulint offsets_[REC_OFFS_NORMAL_SIZE];
1214
ulint* offsets = offsets_;
1215
rec_offs_init(offsets_);
1218
#ifdef UNIV_SYNC_DEBUG
1219
ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_SHARED));
1220
#endif /* UNIV_SYNC_DEBUG */
1224
if (trx->check_foreigns == FALSE) {
1225
/* The user has suppressed foreign key checks currently for
1230
/* If any of the foreign key fields in entry is SQL NULL, we
1231
suppress the foreign key check: this is compatible with Oracle,
1234
for (i = 0; i < foreign->n_fields; i++) {
1235
if (UNIV_SQL_NULL == dfield_get_len(
1236
dtuple_get_nth_field(entry, i))) {
1242
if (que_node_get_type(thr->run_node) == QUE_NODE_UPDATE) {
1243
upd_node = thr->run_node;
1245
if (!(upd_node->is_delete) && upd_node->foreign == foreign) {
1246
/* If a cascaded update is done as defined by a
1247
foreign key constraint, do not check that
1248
constraint for the child row. In ON UPDATE CASCADE
1249
the update of the parent row is only half done when
1250
we come here: if we would check the constraint here
1251
for the child row it would fail.
1253
A QUESTION remains: if in the child table there are
1254
several constraints which refer to the same parent
1255
table, we should merge all updates to the child as
1256
one update? And the updates can be contradictory!
1257
Currently we just perform the update associated
1258
with each foreign key constraint, one after
1259
another, and the user has problems predicting in
1260
which order they are performed. */
1267
check_table = foreign->referenced_table;
1268
check_index = foreign->referenced_index;
1270
check_table = foreign->foreign_table;
1271
check_index = foreign->foreign_index;
1274
if (check_table == NULL || check_table->ibd_file_missing) {
1276
FILE* ef = dict_foreign_err_file;
1278
row_ins_set_detailed(trx, foreign);
1280
mutex_enter(&dict_foreign_err_mutex);
1282
ut_print_timestamp(ef);
1283
fputs(" Transaction:\n", ef);
1284
trx_print(ef, trx, 600);
1285
fputs("Foreign key constraint fails for table ", ef);
1286
ut_print_name(ef, trx, TRUE,
1287
foreign->foreign_table_name);
1289
dict_print_info_on_foreign_key_in_create_format(
1290
ef, trx, foreign, TRUE);
1291
fputs("\nTrying to add to index ", ef);
1292
ut_print_name(ef, trx, FALSE,
1293
foreign->foreign_index->name);
1294
fputs(" tuple:\n", ef);
1295
dtuple_print(ef, entry);
1296
fputs("\nBut the parent table ", ef);
1297
ut_print_name(ef, trx, TRUE,
1298
foreign->referenced_table_name);
1299
fputs("\nor its .ibd file does"
1300
" not currently exist!\n", ef);
1301
mutex_exit(&dict_foreign_err_mutex);
1303
err = DB_NO_REFERENCED_ROW;
1312
if (check_table != table) {
1313
/* We already have a LOCK_IX on table, but not necessarily
1316
err = lock_table(0, check_table, LOCK_IS, thr);
1318
if (err != DB_SUCCESS) {
1320
goto do_possible_lock_wait;
1326
/* Store old value on n_fields_cmp */
1328
n_fields_cmp = dtuple_get_n_fields_cmp(entry);
1330
dtuple_set_n_fields_cmp(entry, foreign->n_fields);
1332
btr_pcur_open(check_index, entry, PAGE_CUR_GE,
1333
BTR_SEARCH_LEAF, &pcur, &mtr);
1335
/* Scan index records and check if there is a matching record */
1338
const rec_t* rec = btr_pcur_get_rec(&pcur);
1339
const buf_block_t* block = btr_pcur_get_block(&pcur);
1341
if (page_rec_is_infimum(rec)) {
1346
offsets = rec_get_offsets(rec, check_index,
1347
offsets, ULINT_UNDEFINED, &heap);
1349
if (page_rec_is_supremum(rec)) {
1351
err = row_ins_set_shared_rec_lock(LOCK_ORDINARY, block,
1355
case DB_SUCCESS_LOCKED_REC:
1363
cmp = cmp_dtuple_rec(entry, rec, offsets);
1366
if (rec_get_deleted_flag(rec,
1367
rec_offs_comp(offsets))) {
1368
err = row_ins_set_shared_rec_lock(
1369
LOCK_ORDINARY, block,
1370
rec, check_index, offsets, thr);
1372
case DB_SUCCESS_LOCKED_REC:
1379
/* Found a matching record. Lock only
1380
a record because we can allow inserts
1383
err = row_ins_set_shared_rec_lock(
1384
LOCK_REC_NOT_GAP, block,
1385
rec, check_index, offsets, thr);
1388
case DB_SUCCESS_LOCKED_REC:
1399
} else if (foreign->type != 0) {
1400
/* There is an ON UPDATE or ON DELETE
1401
condition: check them in a separate
1404
err = row_ins_foreign_check_on_constraint(
1405
thr, foreign, &pcur, entry,
1407
if (err != DB_SUCCESS) {
1408
/* Since reporting a plain
1409
"duplicate key" error
1410
message to the user in
1411
cases where a long CASCADE
1412
operation would lead to a
1413
duplicate key in some
1415
confusing, map duplicate
1416
key errors resulting from
1418
separate error code. */
1420
if (err == DB_DUPLICATE_KEY) {
1421
err = DB_FOREIGN_DUPLICATE_KEY;
1427
/* row_ins_foreign_check_on_constraint
1428
may have repositioned pcur on a
1430
block = btr_pcur_get_block(&pcur);
1432
row_ins_foreign_report_err(
1433
"Trying to delete or update",
1434
thr, foreign, rec, entry);
1436
err = DB_ROW_IS_REFERENCED;
1443
err = row_ins_set_shared_rec_lock(
1445
rec, check_index, offsets, thr);
1448
case DB_SUCCESS_LOCKED_REC:
1451
err = DB_NO_REFERENCED_ROW;
1452
row_ins_foreign_report_add_err(
1453
trx, foreign, rec, entry);
1461
} while (btr_pcur_move_to_next(&pcur, &mtr));
1464
row_ins_foreign_report_add_err(
1465
trx, foreign, btr_pcur_get_rec(&pcur), entry);
1466
err = DB_NO_REFERENCED_ROW;
1472
btr_pcur_close(&pcur);
1476
/* Restore old value */
1477
dtuple_set_n_fields_cmp(entry, n_fields_cmp);
1479
do_possible_lock_wait:
1480
if (err == DB_LOCK_WAIT) {
1481
trx->error_state = err;
1483
que_thr_stop_for_mysql(thr);
1485
srv_suspend_mysql_thread(thr);
1487
if (trx->error_state == DB_SUCCESS) {
1492
err = trx->error_state;
1496
if (UNIV_LIKELY_NULL(heap)) {
1497
mem_heap_free(heap);
1502
/***************************************************************//**
1503
Checks if foreign key constraints fail for an index entry. If index
1504
is not mentioned in any constraint, this function does nothing,
1505
Otherwise does searches to the indexes of referenced tables and
1506
sets shared locks which lock either the success or the failure of
1508
@return DB_SUCCESS or error code */
1511
row_ins_check_foreign_constraints(
1512
/*==============================*/
1513
dict_table_t* table, /*!< in: table */
1514
dict_index_t* index, /*!< in: index */
1515
dtuple_t* entry, /*!< in: index entry for index */
1516
que_thr_t* thr) /*!< in: query thread */
1518
dict_foreign_t* foreign;
1521
ibool got_s_lock = FALSE;
1523
trx = thr_get_trx(thr);
1525
foreign = UT_LIST_GET_FIRST(table->foreign_list);
1528
if (foreign->foreign_index == index) {
1530
if (foreign->referenced_table == NULL) {
1531
dict_table_get(foreign->referenced_table_name_lookup,
1535
if (0 == trx->dict_operation_lock_mode) {
1538
row_mysql_freeze_data_dictionary(trx);
1541
if (foreign->referenced_table) {
1542
mutex_enter(&(dict_sys->mutex));
1544
(foreign->referenced_table
1545
->n_foreign_key_checks_running)++;
1547
mutex_exit(&(dict_sys->mutex));
1550
/* NOTE that if the thread ends up waiting for a lock
1551
we will release dict_operation_lock temporarily!
1552
But the counter on the table protects the referenced
1553
table from being dropped while the check is running. */
1555
err = row_ins_check_foreign_constraint(
1556
TRUE, foreign, table, entry, thr);
1558
if (foreign->referenced_table) {
1559
mutex_enter(&(dict_sys->mutex));
1561
ut_a(foreign->referenced_table
1562
->n_foreign_key_checks_running > 0);
1563
(foreign->referenced_table
1564
->n_foreign_key_checks_running)--;
1566
mutex_exit(&(dict_sys->mutex));
1570
row_mysql_unfreeze_data_dictionary(trx);
1573
if (err != DB_SUCCESS) {
1578
foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
1584
/***************************************************************//**
1585
Checks if a unique key violation to rec would occur at the index entry
1587
@return TRUE if error */
1590
row_ins_dupl_error_with_rec(
1591
/*========================*/
1592
const rec_t* rec, /*!< in: user record; NOTE that we assume
1593
that the caller already has a record lock on
1595
const dtuple_t* entry, /*!< in: entry to insert */
1596
dict_index_t* index, /*!< in: index */
1597
const ulint* offsets)/*!< in: rec_get_offsets(rec, index) */
1599
ulint matched_fields;
1600
ulint matched_bytes;
1604
ut_ad(rec_offs_validate(rec, index, offsets));
1606
n_unique = dict_index_get_n_unique(index);
1611
cmp_dtuple_rec_with_match(entry, rec, offsets,
1612
&matched_fields, &matched_bytes);
1614
if (matched_fields < n_unique) {
1619
/* In a unique secondary index we allow equal key values if they
1620
contain SQL NULLs */
1622
if (!dict_index_is_clust(index)) {
1624
for (i = 0; i < n_unique; i++) {
1625
if (UNIV_SQL_NULL == dfield_get_len(
1626
dtuple_get_nth_field(entry, i))) {
1633
return(!rec_get_deleted_flag(rec, rec_offs_comp(offsets)));
1636
/***************************************************************//**
1637
Scans a unique non-clustered index at a given index entry to determine
1638
whether a uniqueness violation has occurred for the key value of the entry.
1639
Set shared locks on possible duplicate records.
1640
@return DB_SUCCESS, DB_DUPLICATE_KEY, or DB_LOCK_WAIT */
1643
row_ins_scan_sec_index_for_duplicate(
1644
/*=================================*/
1645
dict_index_t* index, /*!< in: non-clustered unique index */
1646
dtuple_t* entry, /*!< in: index entry */
1647
que_thr_t* thr) /*!< in: query thread */
1654
ulint err = DB_SUCCESS;
1655
unsigned allow_duplicates;
1657
mem_heap_t* heap = NULL;
1658
ulint offsets_[REC_OFFS_NORMAL_SIZE];
1659
ulint* offsets = offsets_;
1660
rec_offs_init(offsets_);
1662
n_unique = dict_index_get_n_unique(index);
1664
/* If the secondary index is unique, but one of the fields in the
1665
n_unique first fields is NULL, a unique key violation cannot occur,
1666
since we define NULL != NULL in this case */
1668
for (i = 0; i < n_unique; i++) {
1669
if (UNIV_SQL_NULL == dfield_get_len(
1670
dtuple_get_nth_field(entry, i))) {
1678
/* Store old value on n_fields_cmp */
1680
n_fields_cmp = dtuple_get_n_fields_cmp(entry);
1682
dtuple_set_n_fields_cmp(entry, dict_index_get_n_unique(index));
1684
btr_pcur_open(index, entry, PAGE_CUR_GE, BTR_SEARCH_LEAF, &pcur, &mtr);
1686
allow_duplicates = thr_get_trx(thr)->duplicates & TRX_DUP_IGNORE;
1688
/* Scan index records and check if there is a duplicate */
1691
const rec_t* rec = btr_pcur_get_rec(&pcur);
1692
const buf_block_t* block = btr_pcur_get_block(&pcur);
1694
if (page_rec_is_infimum(rec)) {
1699
offsets = rec_get_offsets(rec, index, offsets,
1700
ULINT_UNDEFINED, &heap);
1702
if (allow_duplicates) {
1704
/* If the SQL-query will update or replace
1705
duplicate key we will take X-lock for
1706
duplicates ( REPLACE, LOAD DATAFILE REPLACE,
1707
INSERT ON DUPLICATE KEY UPDATE). */
1709
err = row_ins_set_exclusive_rec_lock(
1710
LOCK_ORDINARY, block,
1711
rec, index, offsets, thr);
1714
err = row_ins_set_shared_rec_lock(
1715
LOCK_ORDINARY, block,
1716
rec, index, offsets, thr);
1720
case DB_SUCCESS_LOCKED_REC:
1728
if (page_rec_is_supremum(rec)) {
1733
cmp = cmp_dtuple_rec(entry, rec, offsets);
1736
if (row_ins_dupl_error_with_rec(rec, entry,
1738
err = DB_DUPLICATE_KEY;
1740
thr_get_trx(thr)->error_info = index;
1748
} while (btr_pcur_move_to_next(&pcur, &mtr));
1751
if (UNIV_LIKELY_NULL(heap)) {
1752
mem_heap_free(heap);
1756
/* Restore old value */
1757
dtuple_set_n_fields_cmp(entry, n_fields_cmp);
1762
/***************************************************************//**
1763
Checks if a unique key violation error would occur at an index entry
1764
insert. Sets shared locks on possible duplicate records. Works only
1765
for a clustered index!
1766
@return DB_SUCCESS if no error, DB_DUPLICATE_KEY if error,
1767
DB_LOCK_WAIT if we have to wait for a lock on a possible duplicate
1771
row_ins_duplicate_error_in_clust(
1772
/*=============================*/
1773
btr_cur_t* cursor, /*!< in: B-tree cursor */
1774
const dtuple_t* entry, /*!< in: entry to insert */
1775
que_thr_t* thr, /*!< in: query thread */
1776
mtr_t* mtr) /*!< in: mtr */
1781
trx_t* trx = thr_get_trx(thr);
1782
mem_heap_t*heap = NULL;
1783
ulint offsets_[REC_OFFS_NORMAL_SIZE];
1784
ulint* offsets = offsets_;
1785
rec_offs_init(offsets_);
1789
ut_a(dict_index_is_clust(cursor->index));
1790
ut_ad(dict_index_is_unique(cursor->index));
1792
/* NOTE: For unique non-clustered indexes there may be any number
1793
of delete marked records with the same value for the non-clustered
1794
index key (remember multiversioning), and which differ only in
1795
the row refererence part of the index record, containing the
1796
clustered index key fields. For such a secondary index record,
1797
to avoid race condition, we must FIRST do the insertion and after
1798
that check that the uniqueness condition is not breached! */
1800
/* NOTE: A problem is that in the B-tree node pointers on an
1801
upper level may match more to the entry than the actual existing
1802
user records on the leaf level. So, even if low_match would suggest
1803
that a duplicate key violation may occur, this may not be the case. */
1805
n_unique = dict_index_get_n_unique(cursor->index);
1807
if (cursor->low_match >= n_unique) {
1809
rec = btr_cur_get_rec(cursor);
1811
if (!page_rec_is_infimum(rec)) {
1812
offsets = rec_get_offsets(rec, cursor->index, offsets,
1813
ULINT_UNDEFINED, &heap);
1815
/* We set a lock on the possible duplicate: this
1816
is needed in logical logging of MySQL to make
1817
sure that in roll-forward we get the same duplicate
1818
errors as in original execution */
1820
if (trx->duplicates & TRX_DUP_IGNORE) {
1822
/* If the SQL-query will update or replace
1823
duplicate key we will take X-lock for
1824
duplicates ( REPLACE, LOAD DATAFILE REPLACE,
1825
INSERT ON DUPLICATE KEY UPDATE). */
1827
err = row_ins_set_exclusive_rec_lock(
1829
btr_cur_get_block(cursor),
1830
rec, cursor->index, offsets, thr);
1833
err = row_ins_set_shared_rec_lock(
1835
btr_cur_get_block(cursor), rec,
1836
cursor->index, offsets, thr);
1840
case DB_SUCCESS_LOCKED_REC:
1847
if (row_ins_dupl_error_with_rec(
1848
rec, entry, cursor->index, offsets)) {
1849
trx->error_info = cursor->index;
1850
err = DB_DUPLICATE_KEY;
1856
if (cursor->up_match >= n_unique) {
1858
rec = page_rec_get_next(btr_cur_get_rec(cursor));
1860
if (!page_rec_is_supremum(rec)) {
1861
offsets = rec_get_offsets(rec, cursor->index, offsets,
1862
ULINT_UNDEFINED, &heap);
1864
if (trx->duplicates & TRX_DUP_IGNORE) {
1866
/* If the SQL-query will update or replace
1867
duplicate key we will take X-lock for
1868
duplicates ( REPLACE, LOAD DATAFILE REPLACE,
1869
INSERT ON DUPLICATE KEY UPDATE). */
1871
err = row_ins_set_exclusive_rec_lock(
1873
btr_cur_get_block(cursor),
1874
rec, cursor->index, offsets, thr);
1877
err = row_ins_set_shared_rec_lock(
1879
btr_cur_get_block(cursor),
1880
rec, cursor->index, offsets, thr);
1884
case DB_SUCCESS_LOCKED_REC:
1891
if (row_ins_dupl_error_with_rec(
1892
rec, entry, cursor->index, offsets)) {
1893
trx->error_info = cursor->index;
1894
err = DB_DUPLICATE_KEY;
1899
ut_a(!dict_index_is_clust(cursor->index));
1900
/* This should never happen */
1905
if (UNIV_LIKELY_NULL(heap)) {
1906
mem_heap_free(heap);
1911
/***************************************************************//**
1912
Checks if an index entry has long enough common prefix with an existing
1913
record so that the intended insert of the entry must be changed to a modify of
1914
the existing record. In the case of a clustered index, the prefix must be
1915
n_unique fields long, and in the case of a secondary index, all fields must be
1917
@return 0 if no update, ROW_INS_PREV if previous should be updated;
1918
currently we do the search so that only the low_match record can match
1919
enough to the search tuple, not the next record */
1922
row_ins_must_modify(
1923
/*================*/
1924
btr_cur_t* cursor) /*!< in: B-tree cursor */
1929
/* NOTE: (compare to the note in row_ins_duplicate_error) Because node
1930
pointers on upper levels of the B-tree may match more to entry than
1931
to actual user records on the leaf level, we have to check if the
1932
candidate record is actually a user record. In a clustered index
1933
node pointers contain index->n_unique first fields, and in the case
1934
of a secondary index, all fields of the index. */
1936
enough_match = dict_index_get_n_unique_in_tree(cursor->index);
1938
if (cursor->low_match >= enough_match) {
1940
rec = btr_cur_get_rec(cursor);
1942
if (!page_rec_is_infimum(rec)) {
1944
return(ROW_INS_PREV);
1951
/***************************************************************//**
1952
Tries to insert an index entry to an index. If the index is clustered
1953
and a record with the same unique key is found, the other record is
1954
necessarily marked deleted by a committed transaction, or a unique key
1955
violation error occurs. The delete marked record is then updated to an
1956
existing record, and we must write an undo log record on the delete
1957
marked record. If the index is secondary, and a record with exactly the
1958
same fields is found, the other record is necessarily marked deleted.
1959
It is then unmarked. Otherwise, the entry is just inserted to the index.
1960
@return DB_SUCCESS, DB_LOCK_WAIT, DB_FAIL if pessimistic retry needed,
1964
row_ins_index_entry_low(
1965
/*====================*/
1966
ulint mode, /*!< in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
1967
depending on whether we wish optimistic or
1968
pessimistic descent down the index tree */
1969
dict_index_t* index, /*!< in: index */
1970
dtuple_t* entry, /*!< in/out: index entry to insert */
1971
ulint n_ext, /*!< in: number of externally stored columns */
1972
que_thr_t* thr) /*!< in: query thread */
1976
ulint modify = 0; /* remove warning */
1981
big_rec_t* big_rec = NULL;
1983
mem_heap_t* heap = NULL;
1991
/* Note that we use PAGE_CUR_LE as the search mode, because then
1992
the function will return in both low_match and up_match of the
1993
cursor sensible values */
1995
if (dict_index_is_clust(index)) {
1997
} else if (!(thr_get_trx(thr)->check_unique_secondary)) {
1998
search_mode = mode | BTR_INSERT | BTR_IGNORE_SEC_UNIQUE;
2000
search_mode = mode | BTR_INSERT;
2003
btr_cur_search_to_nth_level(index, 0, entry, PAGE_CUR_LE,
2005
&cursor, 0, __FILE__, __LINE__, &mtr);
2007
if (cursor.flag == BTR_CUR_INSERT_TO_IBUF) {
2008
/* The insertion was made to the insert buffer already during
2009
the search: we are done */
2011
ut_ad(search_mode & BTR_INSERT);
2019
page_t* page = btr_cur_get_page(&cursor);
2020
rec_t* first_rec = page_rec_get_next(
2021
page_get_infimum_rec(page));
2023
ut_ad(page_rec_is_supremum(first_rec)
2024
|| rec_get_n_fields(first_rec, index)
2025
== dtuple_get_n_fields(entry));
2029
n_unique = dict_index_get_n_unique(index);
2031
if (dict_index_is_unique(index) && (cursor.up_match >= n_unique
2032
|| cursor.low_match >= n_unique)) {
2034
if (dict_index_is_clust(index)) {
2035
/* Note that the following may return also
2038
err = row_ins_duplicate_error_in_clust(
2039
&cursor, entry, thr, &mtr);
2040
if (err != DB_SUCCESS) {
2046
err = row_ins_scan_sec_index_for_duplicate(
2050
if (err != DB_SUCCESS) {
2054
/* We did not find a duplicate and we have now
2055
locked with s-locks the necessary records to
2056
prevent any insertion of a duplicate by another
2057
transaction. Let us now reposition the cursor and
2058
continue the insertion. */
2060
btr_cur_search_to_nth_level(index, 0, entry,
2064
__FILE__, __LINE__, &mtr);
2068
modify = row_ins_must_modify(&cursor);
2071
/* There is already an index entry with a long enough common
2072
prefix, we must convert the insert into a modify of an
2075
if (modify == ROW_INS_NEXT) {
2076
rec = page_rec_get_next(btr_cur_get_rec(&cursor));
2078
btr_cur_position(index, rec,
2079
btr_cur_get_block(&cursor),&cursor);
2082
if (dict_index_is_clust(index)) {
2083
err = row_ins_clust_index_entry_by_modify(
2084
mode, &cursor, &heap, &big_rec, entry,
2088
err = row_ins_sec_index_entry_by_modify(
2089
mode, &cursor, entry, thr, &mtr);
2092
if (mode == BTR_MODIFY_LEAF) {
2093
err = btr_cur_optimistic_insert(
2094
0, &cursor, entry, &insert_rec, &big_rec,
2097
ut_a(mode == BTR_MODIFY_TREE);
2098
if (buf_LRU_buf_pool_running_out()) {
2100
err = DB_LOCK_TABLE_FULL;
2104
err = btr_cur_pessimistic_insert(
2105
0, &cursor, entry, &insert_rec, &big_rec,
2113
if (UNIV_LIKELY_NULL(big_rec)) {
2118
btr_cur_search_to_nth_level(index, 0, entry, PAGE_CUR_LE,
2119
BTR_MODIFY_TREE, &cursor, 0,
2120
__FILE__, __LINE__, &mtr);
2121
rec = btr_cur_get_rec(&cursor);
2122
offsets = rec_get_offsets(rec, index, NULL,
2123
ULINT_UNDEFINED, &heap);
2125
err = btr_store_big_rec_extern_fields(
2126
index, btr_cur_get_block(&cursor),
2127
rec, offsets, &mtr, FALSE, big_rec);
2130
dtuple_big_rec_free(big_rec);
2132
dtuple_convert_back_big_rec(index, entry, big_rec);
2138
if (UNIV_LIKELY_NULL(heap)) {
2139
mem_heap_free(heap);
2144
/***************************************************************//**
2145
Inserts an index entry to index. Tries first optimistic, then pessimistic
2146
descent down the tree. If the entry matches enough to a delete marked record,
2147
performs the insert by updating or delete unmarking the delete marked
2149
@return DB_SUCCESS, DB_LOCK_WAIT, DB_DUPLICATE_KEY, or some other error code */
2152
row_ins_index_entry(
2153
/*================*/
2154
dict_index_t* index, /*!< in: index */
2155
dtuple_t* entry, /*!< in/out: index entry to insert */
2156
ulint n_ext, /*!< in: number of externally stored columns */
2157
ibool foreign,/*!< in: TRUE=check foreign key constraints
2158
(foreign=FALSE only during CREATE INDEX) */
2159
que_thr_t* thr) /*!< in: query thread */
2163
if (foreign && UT_LIST_GET_FIRST(index->table->foreign_list)) {
2164
err = row_ins_check_foreign_constraints(index->table, index,
2166
if (err != DB_SUCCESS) {
2172
/* Try first optimistic descent to the B-tree */
2174
err = row_ins_index_entry_low(BTR_MODIFY_LEAF, index, entry,
2176
if (err != DB_FAIL) {
2181
/* Try then pessimistic descent to the B-tree */
2183
err = row_ins_index_entry_low(BTR_MODIFY_TREE, index, entry,
2188
/***********************************************************//**
2189
Sets the values of the dtuple fields in entry from the values of appropriate
2193
row_ins_index_entry_set_vals(
2194
/*=========================*/
2195
dict_index_t* index, /*!< in: index */
2196
dtuple_t* entry, /*!< in: index entry to make */
2197
const dtuple_t* row) /*!< in: row */
2202
ut_ad(entry && row);
2204
n_fields = dtuple_get_n_fields(entry);
2206
for (i = 0; i < n_fields; i++) {
2207
dict_field_t* ind_field;
2209
const dfield_t* row_field;
2212
field = dtuple_get_nth_field(entry, i);
2213
ind_field = dict_index_get_nth_field(index, i);
2214
row_field = dtuple_get_nth_field(row, ind_field->col->ind);
2215
len = dfield_get_len(row_field);
2217
/* Check column prefix indexes */
2218
if (ind_field->prefix_len > 0
2219
&& dfield_get_len(row_field) != UNIV_SQL_NULL) {
2221
const dict_col_t* col
2222
= dict_field_get_col(ind_field);
2224
len = dtype_get_at_most_n_mbchars(
2225
col->prtype, col->mbminmaxlen,
2226
ind_field->prefix_len,
2227
len, dfield_get_data(row_field));
2229
ut_ad(!dfield_is_ext(row_field));
2232
dfield_set_data(field, dfield_get_data(row_field), len);
2233
if (dfield_is_ext(row_field)) {
2234
ut_ad(dict_index_is_clust(index));
2235
dfield_set_ext(field);
2240
/***********************************************************//**
2241
Inserts a single index entry to the table.
2242
@return DB_SUCCESS if operation successfully completed, else error
2243
code or DB_LOCK_WAIT */
2246
row_ins_index_entry_step(
2247
/*=====================*/
2248
ins_node_t* node, /*!< in: row insert node */
2249
que_thr_t* thr) /*!< in: query thread */
2253
ut_ad(dtuple_check_typed(node->row));
2255
row_ins_index_entry_set_vals(node->index, node->entry, node->row);
2257
ut_ad(dtuple_check_typed(node->entry));
2259
err = row_ins_index_entry(node->index, node->entry, 0, TRUE, thr);
2264
/***********************************************************//**
2265
Allocates a row id for row and inits the node->index field. */
2268
row_ins_alloc_row_id_step(
2269
/*======================*/
2270
ins_node_t* node) /*!< in: row insert node */
2274
ut_ad(node->state == INS_NODE_ALLOC_ROW_ID);
2276
if (dict_index_is_unique(dict_table_get_first_index(node->table))) {
2278
/* No row id is stored if the clustered index is unique */
2283
/* Fill in row id value to row */
2285
row_id = dict_sys_get_new_row_id();
2287
dict_sys_write_row_id(node->row_id_buf, row_id);
2290
/***********************************************************//**
2291
Gets a row to insert from the values list. */
2294
row_ins_get_row_from_values(
2295
/*========================*/
2296
ins_node_t* node) /*!< in: row insert node */
2298
que_node_t* list_node;
2303
/* The field values are copied in the buffers of the select node and
2304
it is safe to use them until we fetch from select again: therefore
2305
we can just copy the pointers */
2310
list_node = node->values_list;
2313
eval_exp(list_node);
2315
dfield = dtuple_get_nth_field(row, i);
2316
dfield_copy_data(dfield, que_node_get_val(list_node));
2319
list_node = que_node_get_next(list_node);
2323
/***********************************************************//**
2324
Gets a row to insert from the select list. */
2327
row_ins_get_row_from_select(
2328
/*========================*/
2329
ins_node_t* node) /*!< in: row insert node */
2331
que_node_t* list_node;
2336
/* The field values are copied in the buffers of the select node and
2337
it is safe to use them until we fetch from select again: therefore
2338
we can just copy the pointers */
2343
list_node = node->select->select_list;
2346
dfield = dtuple_get_nth_field(row, i);
2347
dfield_copy_data(dfield, que_node_get_val(list_node));
2350
list_node = que_node_get_next(list_node);
2354
/***********************************************************//**
2355
Inserts a row to a table.
2356
@return DB_SUCCESS if operation successfully completed, else error
2357
code or DB_LOCK_WAIT */
2362
ins_node_t* node, /*!< in: row insert node */
2363
que_thr_t* thr) /*!< in: query thread */
2369
if (node->state == INS_NODE_ALLOC_ROW_ID) {
2371
row_ins_alloc_row_id_step(node);
2373
node->index = dict_table_get_first_index(node->table);
2374
node->entry = UT_LIST_GET_FIRST(node->entry_list);
2376
if (node->ins_type == INS_SEARCHED) {
2378
row_ins_get_row_from_select(node);
2380
} else if (node->ins_type == INS_VALUES) {
2382
row_ins_get_row_from_values(node);
2385
node->state = INS_NODE_INSERT_ENTRIES;
2388
ut_ad(node->state == INS_NODE_INSERT_ENTRIES);
2390
while (node->index != NULL) {
2391
err = row_ins_index_entry_step(node, thr);
2393
if (err != DB_SUCCESS) {
2398
node->index = dict_table_get_next_index(node->index);
2399
node->entry = UT_LIST_GET_NEXT(tuple_list, node->entry);
2401
/* Skip corrupted secondar index and its entry */
2402
while (node->index && dict_index_is_corrupted(node->index)) {
2404
node->index = dict_table_get_next_index(node->index);
2405
node->entry = UT_LIST_GET_NEXT(tuple_list, node->entry);
2409
ut_ad(node->entry == NULL);
2411
node->state = INS_NODE_ALLOC_ROW_ID;
2416
/***********************************************************//**
2417
Inserts a row to a table. This is a high-level function used in SQL execution
2419
@return query thread to run next or NULL */
2424
que_thr_t* thr) /*!< in: query thread */
2428
sel_node_t* sel_node;
2434
trx = thr_get_trx(thr);
2436
trx_start_if_not_started(trx);
2438
node = thr->run_node;
2440
ut_ad(que_node_get_type(node) == QUE_NODE_INSERT);
2442
parent = que_node_get_parent(node);
2443
sel_node = node->select;
2445
if (thr->prev_node == parent) {
2446
node->state = INS_NODE_SET_IX_LOCK;
2449
/* If this is the first time this node is executed (or when
2450
execution resumes after wait for the table IX lock), set an
2451
IX lock on the table and reset the possible select node. MySQL's
2452
partitioned table code may also call an insert within the same
2453
SQL statement AFTER it has used this table handle to do a search.
2454
This happens, for example, when a row update moves it to another
2455
partition. In that case, we have already set the IX lock on the
2456
table during the search operation, and there is no need to set
2457
it again here. But we must write trx->id to node->trx_id_buf. */
2459
trx_write_trx_id(node->trx_id_buf, trx->id);
2461
if (node->state == INS_NODE_SET_IX_LOCK) {
2463
/* It may be that the current session has not yet started
2464
its transaction, or it has been committed: */
2466
if (trx->id == node->trx_id) {
2467
/* No need to do IX-locking */
2472
err = lock_table(0, node->table, LOCK_IX, thr);
2474
if (err != DB_SUCCESS) {
2476
goto error_handling;
2479
node->trx_id = trx->id;
2481
node->state = INS_NODE_ALLOC_ROW_ID;
2483
if (node->ins_type == INS_SEARCHED) {
2484
/* Reset the cursor */
2485
sel_node->state = SEL_NODE_OPEN;
2487
/* Fetch a row to insert */
2489
thr->run_node = sel_node;
2495
if ((node->ins_type == INS_SEARCHED)
2496
&& (sel_node->state != SEL_NODE_FETCH)) {
2498
ut_ad(sel_node->state == SEL_NODE_NO_MORE_ROWS);
2500
/* No more rows to insert */
2501
thr->run_node = parent;
2506
/* DO THE CHECKS OF THE CONSISTENCY CONSTRAINTS HERE */
2508
err = row_ins(node, thr);
2511
trx->error_state = err;
2513
if (err != DB_SUCCESS) {
2514
/* err == DB_LOCK_WAIT or SQL error detected */
2518
/* DO THE TRIGGER ACTIONS HERE */
2520
if (node->ins_type == INS_SEARCHED) {
2521
/* Fetch a row to insert */
2523
thr->run_node = sel_node;
2525
thr->run_node = que_node_get_parent(node);
added
removed
storage/innobase/row/row0ins.c
