← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/row/row0ins.c

  • Committer: Monty Taylor
  • Date: 2008-11-16 20:15:33 UTC
  • mto: (584.1.9 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116201533-d0f19s1bk1h95iyw
Removed a big bank of includes from item.h.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/row/row0ins.c
 
1
/******************************************************
 
2
Insert into a table
 
3
 
 
4
(c) 1996 Innobase Oy
 
5
 
 
6
Created 4/20/1996 Heikki Tuuri
 
7
*******************************************************/
 
8
 
 
9
#include "row0ins.h"
 
10
 
 
11
#ifdef UNIV_NONINL
 
12
#include "row0ins.ic"
 
13
#endif
 
14
 
 
15
#include "dict0dict.h"
 
16
#include "dict0boot.h"
 
17
#include "trx0undo.h"
 
18
#include "btr0btr.h"
 
19
#include "btr0cur.h"
 
20
#include "mach0data.h"
 
21
#include "que0que.h"
 
22
#include "row0upd.h"
 
23
#include "row0sel.h"
 
24
#include "row0row.h"
 
25
#include "rem0cmp.h"
 
26
#include "lock0lock.h"
 
27
#include "log0log.h"
 
28
#include "eval0eval.h"
 
29
#include "data0data.h"
 
30
#include "usr0sess.h"
 
31
#include "buf0lru.h"
 
32
 
 
33
#define ROW_INS_PREV    1
 
34
#define ROW_INS_NEXT    2
 
35
 
 
36
 
 
37
/*********************************************************************
 
38
This prototype is copied from /mysql/sql/ha_innodb.cc.
 
39
Invalidates the MySQL query cache for the table.
 
40
NOTE that the exact prototype of this function has to be in
 
41
/innobase/row/row0ins.c! */
 
42
extern
 
43
void
 
44
innobase_invalidate_query_cache(
 
45
/*============================*/
 
46
        trx_t*  trx,            /* in: transaction which modifies the table */
 
47
        char*   full_name,      /* in: concatenation of database name, null
 
48
                                char '\0', table name, null char'\0';
 
49
                                NOTE that in Windows this is always
 
50
                                in LOWER CASE! */
 
51
        ulint   full_name_len); /* in: full name length where also the null
 
52
                                chars count */
 
53
 
 
54
/*************************************************************************
 
55
Creates an insert node struct. */
 
56
UNIV_INTERN
 
57
ins_node_t*
 
58
ins_node_create(
 
59
/*============*/
 
60
                                        /* out, own: insert node struct */
 
61
        ulint           ins_type,       /* in: INS_VALUES, ... */
 
62
        dict_table_t*   table,          /* in: table where to insert */
 
63
        mem_heap_t*     heap)           /* in: mem heap where created */
 
64
{
 
65
        ins_node_t*     node;
 
66
 
 
67
        node = mem_heap_alloc(heap, sizeof(ins_node_t));
 
68
 
 
69
        node->common.type = QUE_NODE_INSERT;
 
70
 
 
71
        node->ins_type = ins_type;
 
72
 
 
73
        node->state = INS_NODE_SET_IX_LOCK;
 
74
        node->table = table;
 
75
        node->index = NULL;
 
76
        node->entry = NULL;
 
77
 
 
78
        node->select = NULL;
 
79
 
 
80
        node->trx_id = ut_dulint_zero;
 
81
 
 
82
        node->entry_sys_heap = mem_heap_create(128);
 
83
 
 
84
        node->magic_n = INS_NODE_MAGIC_N;
 
85
 
 
86
        return(node);
 
87
}
 
88
 
 
89
/***************************************************************
 
90
Creates an entry template for each index of a table. */
 
91
UNIV_INTERN
 
92
void
 
93
ins_node_create_entry_list(
 
94
/*=======================*/
 
95
        ins_node_t*     node)   /* in: row insert node */
 
96
{
 
97
        dict_index_t*   index;
 
98
        dtuple_t*       entry;
 
99
 
 
100
        ut_ad(node->entry_sys_heap);
 
101
 
 
102
        UT_LIST_INIT(node->entry_list);
 
103
 
 
104
        index = dict_table_get_first_index(node->table);
 
105
 
 
106
        while (index != NULL) {
 
107
                entry = row_build_index_entry(node->row, NULL, index,
 
108
                                              node->entry_sys_heap);
 
109
                UT_LIST_ADD_LAST(tuple_list, node->entry_list, entry);
 
110
 
 
111
                index = dict_table_get_next_index(index);
 
112
        }
 
113
}
 
114
 
 
115
/*********************************************************************
 
116
Adds system field buffers to a row. */
 
117
static
 
118
void
 
119
row_ins_alloc_sys_fields(
 
120
/*=====================*/
 
121
        ins_node_t*     node)   /* in: insert node */
 
122
{
 
123
        dtuple_t*               row;
 
124
        dict_table_t*           table;
 
125
        mem_heap_t*             heap;
 
126
        const dict_col_t*       col;
 
127
        dfield_t*               dfield;
 
128
        byte*                   ptr;
 
129
 
 
130
        row = node->row;
 
131
        table = node->table;
 
132
        heap = node->entry_sys_heap;
 
133
 
 
134
        ut_ad(row && table && heap);
 
135
        ut_ad(dtuple_get_n_fields(row) == dict_table_get_n_cols(table));
 
136
 
 
137
        /* 1. Allocate buffer for row id */
 
138
 
 
139
        col = dict_table_get_sys_col(table, DATA_ROW_ID);
 
140
 
 
141
        dfield = dtuple_get_nth_field(row, dict_col_get_no(col));
 
142
 
 
143
        ptr = mem_heap_alloc(heap, DATA_ROW_ID_LEN);
 
144
 
 
145
        dfield_set_data(dfield, ptr, DATA_ROW_ID_LEN);
 
146
 
 
147
        node->row_id_buf = ptr;
 
148
 
 
149
        /* 3. Allocate buffer for trx id */
 
150
 
 
151
        col = dict_table_get_sys_col(table, DATA_TRX_ID);
 
152
 
 
153
        dfield = dtuple_get_nth_field(row, dict_col_get_no(col));
 
154
        ptr = mem_heap_alloc(heap, DATA_TRX_ID_LEN);
 
155
 
 
156
        dfield_set_data(dfield, ptr, DATA_TRX_ID_LEN);
 
157
 
 
158
        node->trx_id_buf = ptr;
 
159
 
 
160
        /* 4. Allocate buffer for roll ptr */
 
161
 
 
162
        col = dict_table_get_sys_col(table, DATA_ROLL_PTR);
 
163
 
 
164
        dfield = dtuple_get_nth_field(row, dict_col_get_no(col));
 
165
        ptr = mem_heap_alloc(heap, DATA_ROLL_PTR_LEN);
 
166
 
 
167
        dfield_set_data(dfield, ptr, DATA_ROLL_PTR_LEN);
 
168
}
 
169
 
 
170
/*************************************************************************
 
171
Sets a new row to insert for an INS_DIRECT node. This function is only used
 
172
if we have constructed the row separately, which is a rare case; this
 
173
function is quite slow. */
 
174
UNIV_INTERN
 
175
void
 
176
ins_node_set_new_row(
 
177
/*=================*/
 
178
        ins_node_t*     node,   /* in: insert node */
 
179
        dtuple_t*       row)    /* in: new row (or first row) for the node */
 
180
{
 
181
        node->state = INS_NODE_SET_IX_LOCK;
 
182
        node->index = NULL;
 
183
        node->entry = NULL;
 
184
 
 
185
        node->row = row;
 
186
 
 
187
        mem_heap_empty(node->entry_sys_heap);
 
188
 
 
189
        /* Create templates for index entries */
 
190
 
 
191
        ins_node_create_entry_list(node);
 
192
 
 
193
        /* Allocate from entry_sys_heap buffers for sys fields */
 
194
 
 
195
        row_ins_alloc_sys_fields(node);
 
196
 
 
197
        /* As we allocated a new trx id buf, the trx id should be written
 
198
        there again: */
 
199
 
 
200
        node->trx_id = ut_dulint_zero;
 
201
}
 
202
 
 
203
/***********************************************************************
 
204
Does an insert operation by updating a delete-marked existing record
 
205
in the index. This situation can occur if the delete-marked record is
 
206
kept in the index for consistent reads. */
 
207
static
 
208
ulint
 
209
row_ins_sec_index_entry_by_modify(
 
210
/*==============================*/
 
211
                                /* out: DB_SUCCESS or error code */
 
212
        ulint           mode,   /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
 
213
                                depending on whether mtr holds just a leaf
 
214
                                latch or also a tree latch */
 
215
        btr_cur_t*      cursor, /* in: B-tree cursor */
 
216
        const dtuple_t* entry,  /* in: index entry to insert */
 
217
        que_thr_t*      thr,    /* in: query thread */
 
218
        mtr_t*          mtr)    /* in: mtr; must be committed before
 
219
                                latching any further pages */
 
220
{
 
221
        big_rec_t*      dummy_big_rec;
 
222
        mem_heap_t*     heap;
 
223
        upd_t*          update;
 
224
        rec_t*          rec;
 
225
        ulint           err;
 
226
 
 
227
        rec = btr_cur_get_rec(cursor);
 
228
 
 
229
        ut_ad(!dict_index_is_clust(cursor->index));
 
230
        ut_ad(rec_get_deleted_flag(rec,
 
231
                                   dict_table_is_comp(cursor->index->table)));
 
232
 
 
233
        /* We know that in the alphabetical ordering, entry and rec are
 
234
        identified. But in their binary form there may be differences if
 
235
        there are char fields in them. Therefore we have to calculate the
 
236
        difference. */
 
237
 
 
238
        heap = mem_heap_create(1024);
 
239
 
 
240
        update = row_upd_build_sec_rec_difference_binary(
 
241
                cursor->index, entry, rec, thr_get_trx(thr), heap);
 
242
        if (mode == BTR_MODIFY_LEAF) {
 
243
                /* Try an optimistic updating of the record, keeping changes
 
244
                within the page */
 
245
 
 
246
                err = btr_cur_optimistic_update(BTR_KEEP_SYS_FLAG, cursor,
 
247
                                                update, 0, thr, mtr);
 
248
                switch (err) {
 
249
                case DB_OVERFLOW:
 
250
                case DB_UNDERFLOW:
 
251
                case DB_ZIP_OVERFLOW:
 
252
                        err = DB_FAIL;
 
253
                }
 
254
        } else {
 
255
                ut_a(mode == BTR_MODIFY_TREE);
 
256
                if (buf_LRU_buf_pool_running_out()) {
 
257
 
 
258
                        err = DB_LOCK_TABLE_FULL;
 
259
 
 
260
                        goto func_exit;
 
261
                }
 
262
 
 
263
                err = btr_cur_pessimistic_update(BTR_KEEP_SYS_FLAG, cursor,
 
264
                                                 &heap, &dummy_big_rec, update,
 
265
                                                 0, thr, mtr);
 
266
                ut_ad(!dummy_big_rec);
 
267
        }
 
268
func_exit:
 
269
        mem_heap_free(heap);
 
270
 
 
271
        return(err);
 
272
}
 
273
 
 
274
/***********************************************************************
 
275
Does an insert operation by delete unmarking and updating a delete marked
 
276
existing record in the index. This situation can occur if the delete marked
 
277
record is kept in the index for consistent reads. */
 
278
static
 
279
ulint
 
280
row_ins_clust_index_entry_by_modify(
 
281
/*================================*/
 
282
                                /* out: DB_SUCCESS, DB_FAIL, or error code */
 
283
        ulint           mode,   /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
 
284
                                depending on whether mtr holds just a leaf
 
285
                                latch or also a tree latch */
 
286
        btr_cur_t*      cursor, /* in: B-tree cursor */
 
287
        mem_heap_t**    heap,   /* in/out: pointer to memory heap, or NULL */
 
288
        big_rec_t**     big_rec,/* out: possible big rec vector of fields
 
289
                                which have to be stored externally by the
 
290
                                caller */
 
291
        const dtuple_t* entry,  /* in: index entry to insert */
 
292
        que_thr_t*      thr,    /* in: query thread */
 
293
        mtr_t*          mtr)    /* in: mtr; must be committed before
 
294
                                latching any further pages */
 
295
{
 
296
        rec_t*          rec;
 
297
        upd_t*          update;
 
298
        ulint           err;
 
299
 
 
300
        ut_ad(dict_index_is_clust(cursor->index));
 
301
 
 
302
        *big_rec = NULL;
 
303
 
 
304
        rec = btr_cur_get_rec(cursor);
 
305
 
 
306
        ut_ad(rec_get_deleted_flag(rec,
 
307
                                   dict_table_is_comp(cursor->index->table)));
 
308
 
 
309
        if (!*heap) {
 
310
                *heap = mem_heap_create(1024);
 
311
        }
 
312
 
 
313
        /* Build an update vector containing all the fields to be modified;
 
314
        NOTE that this vector may NOT contain system columns trx_id or
 
315
        roll_ptr */
 
316
 
 
317
        update = row_upd_build_difference_binary(cursor->index, entry, rec,
 
318
                                                 thr_get_trx(thr), *heap);
 
319
        if (mode == BTR_MODIFY_LEAF) {
 
320
                /* Try optimistic updating of the record, keeping changes
 
321
                within the page */
 
322
 
 
323
                err = btr_cur_optimistic_update(0, cursor, update, 0, thr,
 
324
                                                mtr);
 
325
                switch (err) {
 
326
                case DB_OVERFLOW:
 
327
                case DB_UNDERFLOW:
 
328
                case DB_ZIP_OVERFLOW:
 
329
                        err = DB_FAIL;
 
330
                }
 
331
        } else {
 
332
                ut_a(mode == BTR_MODIFY_TREE);
 
333
                if (buf_LRU_buf_pool_running_out()) {
 
334
 
 
335
                        return(DB_LOCK_TABLE_FULL);
 
336
 
 
337
                }
 
338
                err = btr_cur_pessimistic_update(0, cursor,
 
339
                                                 heap, big_rec, update,
 
340
                                                 0, thr, mtr);
 
341
        }
 
342
 
 
343
        return(err);
 
344
}
 
345
 
 
346
/*************************************************************************
 
347
Returns TRUE if in a cascaded update/delete an ancestor node of node
 
348
updates (not DELETE, but UPDATE) table. */
 
349
static
 
350
ibool
 
351
row_ins_cascade_ancestor_updates_table(
 
352
/*===================================*/
 
353
                                /* out: TRUE if an ancestor updates table */
 
354
        que_node_t*     node,   /* in: node in a query graph */
 
355
        dict_table_t*   table)  /* in: table */
 
356
{
 
357
        que_node_t*     parent;
 
358
        upd_node_t*     upd_node;
 
359
 
 
360
        parent = que_node_get_parent(node);
 
361
 
 
362
        while (que_node_get_type(parent) == QUE_NODE_UPDATE) {
 
363
 
 
364
                upd_node = parent;
 
365
 
 
366
                if (upd_node->table == table && upd_node->is_delete == FALSE) {
 
367
 
 
368
                        return(TRUE);
 
369
                }
 
370
 
 
371
                parent = que_node_get_parent(parent);
 
372
 
 
373
                ut_a(parent);
 
374
        }
 
375
 
 
376
        return(FALSE);
 
377
}
 
378
 
 
379
/*************************************************************************
 
380
Returns the number of ancestor UPDATE or DELETE nodes of a
 
381
cascaded update/delete node. */
 
382
static
 
383
ulint
 
384
row_ins_cascade_n_ancestors(
 
385
/*========================*/
 
386
                                /* out: number of ancestors */
 
387
        que_node_t*     node)   /* in: node in a query graph */
 
388
{
 
389
        que_node_t*     parent;
 
390
        ulint           n_ancestors = 0;
 
391
 
 
392
        parent = que_node_get_parent(node);
 
393
 
 
394
        while (que_node_get_type(parent) == QUE_NODE_UPDATE) {
 
395
                n_ancestors++;
 
396
 
 
397
                parent = que_node_get_parent(parent);
 
398
 
 
399
                ut_a(parent);
 
400
        }
 
401
 
 
402
        return(n_ancestors);
 
403
}
 
404
 
 
405
/**********************************************************************
 
406
Calculates the update vector node->cascade->update for a child table in
 
407
a cascaded update. */
 
408
static
 
409
ulint
 
410
row_ins_cascade_calc_update_vec(
 
411
/*============================*/
 
412
                                        /* out: number of fields in the
 
413
                                        calculated update vector; the value
 
414
                                        can also be 0 if no foreign key
 
415
                                        fields changed; the returned value
 
416
                                        is ULINT_UNDEFINED if the column
 
417
                                        type in the child table is too short
 
418
                                        to fit the new value in the parent
 
419
                                        table: that means the update fails */
 
420
        upd_node_t*     node,           /* in: update node of the parent
 
421
                                        table */
 
422
        dict_foreign_t* foreign,        /* in: foreign key constraint whose
 
423
                                        type is != 0 */
 
424
        mem_heap_t*     heap)           /* in: memory heap to use as
 
425
                                        temporary storage */
 
426
{
 
427
        upd_node_t*     cascade         = node->cascade_node;
 
428
        dict_table_t*   table           = foreign->foreign_table;
 
429
        dict_index_t*   index           = foreign->foreign_index;
 
430
        upd_t*          update;
 
431
        upd_field_t*    ufield;
 
432
        dict_table_t*   parent_table;
 
433
        dict_index_t*   parent_index;
 
434
        upd_t*          parent_update;
 
435
        upd_field_t*    parent_ufield;
 
436
        ulint           n_fields_updated;
 
437
        ulint           parent_field_no;
 
438
        ulint           i;
 
439
        ulint           j;
 
440
 
 
441
        ut_a(node);
 
442
        ut_a(foreign);
 
443
        ut_a(cascade);
 
444
        ut_a(table);
 
445
        ut_a(index);
 
446
 
 
447
        /* Calculate the appropriate update vector which will set the fields
 
448
        in the child index record to the same value (possibly padded with
 
449
        spaces if the column is a fixed length CHAR or FIXBINARY column) as
 
450
        the referenced index record will get in the update. */
 
451
 
 
452
        parent_table = node->table;
 
453
        ut_a(parent_table == foreign->referenced_table);
 
454
        parent_index = foreign->referenced_index;
 
455
        parent_update = node->update;
 
456
 
 
457
        update = cascade->update;
 
458
 
 
459
        update->info_bits = 0;
 
460
        update->n_fields = foreign->n_fields;
 
461
 
 
462
        n_fields_updated = 0;
 
463
 
 
464
        for (i = 0; i < foreign->n_fields; i++) {
 
465
 
 
466
                parent_field_no = dict_table_get_nth_col_pos(
 
467
                        parent_table,
 
468
                        dict_index_get_nth_col_no(parent_index, i));
 
469
 
 
470
                for (j = 0; j < parent_update->n_fields; j++) {
 
471
                        parent_ufield = parent_update->fields + j;
 
472
 
 
473
                        if (parent_ufield->field_no == parent_field_no) {
 
474
 
 
475
                                ulint                   min_size;
 
476
                                const dict_col_t*       col;
 
477
                                ulint                   ufield_len;
 
478
 
 
479
                                col = dict_index_get_nth_col(index, i);
 
480
 
 
481
                                /* A field in the parent index record is
 
482
                                updated. Let us make the update vector
 
483
                                field for the child table. */
 
484
 
 
485
                                ufield = update->fields + n_fields_updated;
 
486
 
 
487
                                ufield->field_no
 
488
                                        = dict_table_get_nth_col_pos(
 
489
                                        table, dict_col_get_no(col));
 
490
                                ufield->exp = NULL;
 
491
 
 
492
                                ufield->new_val = parent_ufield->new_val;
 
493
                                ufield_len = dfield_get_len(&ufield->new_val);
 
494
 
 
495
                                /* Clear the "external storage" flag */
 
496
                                dfield_set_len(&ufield->new_val, ufield_len);
 
497
 
 
498
                                /* Do not allow a NOT NULL column to be
 
499
                                updated as NULL */
 
500
 
 
501
                                if (dfield_is_null(&ufield->new_val)
 
502
                                    && (col->prtype & DATA_NOT_NULL)) {
 
503
 
 
504
                                        return(ULINT_UNDEFINED);
 
505
                                }
 
506
 
 
507
                                /* If the new value would not fit in the
 
508
                                column, do not allow the update */
 
509
 
 
510
                                if (!dfield_is_null(&ufield->new_val)
 
511
                                    && dtype_get_at_most_n_mbchars(
 
512
                                        col->prtype,
 
513
                                        col->mbminlen, col->mbmaxlen,
 
514
                                        col->len,
 
515
                                        ufield_len,
 
516
                                        dfield_get_data(&ufield->new_val))
 
517
                                    < ufield_len) {
 
518
 
 
519
                                        return(ULINT_UNDEFINED);
 
520
                                }
 
521
 
 
522
                                /* If the parent column type has a different
 
523
                                length than the child column type, we may
 
524
                                need to pad with spaces the new value of the
 
525
                                child column */
 
526
 
 
527
                                min_size = dict_col_get_min_size(col);
 
528
 
 
529
                                /* Because UNIV_SQL_NULL (the marker
 
530
                                of SQL NULL values) exceeds all possible
 
531
                                values of min_size, the test below will
 
532
                                not hold for SQL NULL columns. */
 
533
 
 
534
                                if (min_size > ufield_len) {
 
535
 
 
536
                                        char*           pad_start;
 
537
                                        const char*     pad_end;
 
538
                                        char*           padded_data
 
539
                                                = mem_heap_alloc(
 
540
                                                        heap, min_size);
 
541
                                        pad_start = padded_data + ufield_len;
 
542
                                        pad_end = padded_data + min_size;
 
543
 
 
544
                                        memcpy(padded_data,
 
545
                                               dfield_get_data(&ufield
 
546
                                                               ->new_val),
 
547
                                               dfield_get_len(&ufield
 
548
                                                              ->new_val));
 
549
 
 
550
                                        switch (UNIV_EXPECT(col->mbminlen,1)) {
 
551
                                        default:
 
552
                                                ut_error;
 
553
                                                return(ULINT_UNDEFINED);
 
554
                                        case 1:
 
555
                                                if (UNIV_UNLIKELY
 
556
                                                    (dtype_get_charset_coll(
 
557
                                                            col->prtype)
 
558
                                                     == DATA_MYSQL_BINARY_CHARSET_COLL)) {
 
559
                                                        /* Do not pad BINARY
 
560
                                                        columns. */
 
561
                                                        return(ULINT_UNDEFINED);
 
562
                                                }
 
563
 
 
564
                                                /* space=0x20 */
 
565
                                                memset(pad_start, 0x20,
 
566
                                                       pad_end - pad_start);
 
567
                                                break;
 
568
                                        case 2:
 
569
                                                /* space=0x0020 */
 
570
                                                ut_a(!(ufield_len % 2));
 
571
                                                ut_a(!(min_size % 2));
 
572
                                                do {
 
573
                                                        *pad_start++ = 0x00;
 
574
                                                        *pad_start++ = 0x20;
 
575
                                                } while (pad_start < pad_end);
 
576
                                                break;
 
577
                                        }
 
578
 
 
579
                                        dfield_set_data(&ufield->new_val,
 
580
                                                        padded_data, min_size);
 
581
                                }
 
582
 
 
583
                                n_fields_updated++;
 
584
                        }
 
585
                }
 
586
        }
 
587
 
 
588
        update->n_fields = n_fields_updated;
 
589
 
 
590
        return(n_fields_updated);
 
591
}
 
592
 
 
593
/*************************************************************************
 
594
Set detailed error message associated with foreign key errors for
 
595
the given transaction. */
 
596
static
 
597
void
 
598
row_ins_set_detailed(
 
599
/*=================*/
 
600
        trx_t*          trx,            /* in: transaction */
 
601
        dict_foreign_t* foreign)        /* in: foreign key constraint */
 
602
{
 
603
        mutex_enter(&srv_misc_tmpfile_mutex);
 
604
        rewind(srv_misc_tmpfile);
 
605
 
 
606
        if (os_file_set_eof(srv_misc_tmpfile)) {
 
607
                ut_print_name(srv_misc_tmpfile, trx, TRUE,
 
608
                              foreign->foreign_table_name);
 
609
                dict_print_info_on_foreign_key_in_create_format(
 
610
                        srv_misc_tmpfile, trx, foreign, FALSE);
 
611
                trx_set_detailed_error_from_file(trx, srv_misc_tmpfile);
 
612
        } else {
 
613
                trx_set_detailed_error(trx, "temp file operation failed");
 
614
        }
 
615
 
 
616
        mutex_exit(&srv_misc_tmpfile_mutex);
 
617
}
 
618
 
 
619
/*************************************************************************
 
620
Reports a foreign key error associated with an update or a delete of a
 
621
parent table index entry. */
 
622
static
 
623
void
 
624
row_ins_foreign_report_err(
 
625
/*=======================*/
 
626
        const char*     errstr,         /* in: error string from the viewpoint
 
627
                                        of the parent table */
 
628
        que_thr_t*      thr,            /* in: query thread whose run_node
 
629
                                        is an update node */
 
630
        dict_foreign_t* foreign,        /* in: foreign key constraint */
 
631
        const rec_t*    rec,            /* in: a matching index record in the
 
632
                                        child table */
 
633
        const dtuple_t* entry)          /* in: index entry in the parent
 
634
                                        table */
 
635
{
 
636
        FILE*   ef      = dict_foreign_err_file;
 
637
        trx_t*  trx     = thr_get_trx(thr);
 
638
 
 
639
        row_ins_set_detailed(trx, foreign);
 
640
 
 
641
        mutex_enter(&dict_foreign_err_mutex);
 
642
        rewind(ef);
 
643
        ut_print_timestamp(ef);
 
644
        fputs(" Transaction:\n", ef);
 
645
        trx_print(ef, trx, 600);
 
646
 
 
647
        fputs("Foreign key constraint fails for table ", ef);
 
648
        ut_print_name(ef, trx, TRUE, foreign->foreign_table_name);
 
649
        fputs(":\n", ef);
 
650
        dict_print_info_on_foreign_key_in_create_format(ef, trx, foreign,
 
651
                                                        TRUE);
 
652
        putc('\n', ef);
 
653
        fputs(errstr, ef);
 
654
        fputs(" in parent table, in index ", ef);
 
655
        ut_print_name(ef, trx, FALSE, foreign->referenced_index->name);
 
656
        if (entry) {
 
657
                fputs(" tuple:\n", ef);
 
658
                dtuple_print(ef, entry);
 
659
        }
 
660
        fputs("\nBut in child table ", ef);
 
661
        ut_print_name(ef, trx, TRUE, foreign->foreign_table_name);
 
662
        fputs(", in index ", ef);
 
663
        ut_print_name(ef, trx, FALSE, foreign->foreign_index->name);
 
664
        if (rec) {
 
665
                fputs(", there is a record:\n", ef);
 
666
                rec_print(ef, rec, foreign->foreign_index);
 
667
        } else {
 
668
                fputs(", the record is not available\n", ef);
 
669
        }
 
670
        putc('\n', ef);
 
671
 
 
672
        mutex_exit(&dict_foreign_err_mutex);
 
673
}
 
674
 
 
675
/*************************************************************************
 
676
Reports a foreign key error to dict_foreign_err_file when we are trying
 
677
to add an index entry to a child table. Note that the adding may be the result
 
678
of an update, too. */
 
679
static
 
680
void
 
681
row_ins_foreign_report_add_err(
 
682
/*===========================*/
 
683
        trx_t*          trx,            /* in: transaction */
 
684
        dict_foreign_t* foreign,        /* in: foreign key constraint */
 
685
        const rec_t*    rec,            /* in: a record in the parent table:
 
686
                                        it does not match entry because we
 
687
                                        have an error! */
 
688
        const dtuple_t* entry)          /* in: index entry to insert in the
 
689
                                        child table */
 
690
{
 
691
        FILE*   ef      = dict_foreign_err_file;
 
692
 
 
693
        row_ins_set_detailed(trx, foreign);
 
694
 
 
695
        mutex_enter(&dict_foreign_err_mutex);
 
696
        rewind(ef);
 
697
        ut_print_timestamp(ef);
 
698
        fputs(" Transaction:\n", ef);
 
699
        trx_print(ef, trx, 600);
 
700
        fputs("Foreign key constraint fails for table ", ef);
 
701
        ut_print_name(ef, trx, TRUE, foreign->foreign_table_name);
 
702
        fputs(":\n", ef);
 
703
        dict_print_info_on_foreign_key_in_create_format(ef, trx, foreign,
 
704
                                                        TRUE);
 
705
        fputs("\nTrying to add in child table, in index ", ef);
 
706
        ut_print_name(ef, trx, FALSE, foreign->foreign_index->name);
 
707
        if (entry) {
 
708
                fputs(" tuple:\n", ef);
 
709
                /* TODO: DB_TRX_ID and DB_ROLL_PTR may be uninitialized.
 
710
                It would be better to only display the user columns. */
 
711
                dtuple_print(ef, entry);
 
712
        }
 
713
        fputs("\nBut in parent table ", ef);
 
714
        ut_print_name(ef, trx, TRUE, foreign->referenced_table_name);
 
715
        fputs(", in index ", ef);
 
716
        ut_print_name(ef, trx, FALSE, foreign->referenced_index->name);
 
717
        fputs(",\nthe closest match we can find is record:\n", ef);
 
718
        if (rec && page_rec_is_supremum(rec)) {
 
719
                /* If the cursor ended on a supremum record, it is better
 
720
                to report the previous record in the error message, so that
 
721
                the user gets a more descriptive error message. */
 
722
                rec = page_rec_get_prev_const(rec);
 
723
        }
 
724
 
 
725
        if (rec) {
 
726
                rec_print(ef, rec, foreign->referenced_index);
 
727
        }
 
728
        putc('\n', ef);
 
729
 
 
730
        mutex_exit(&dict_foreign_err_mutex);
 
731
}
 
732
 
 
733
/*************************************************************************
 
734
Invalidate the query cache for the given table. */
 
735
static
 
736
void
 
737
row_ins_invalidate_query_cache(
 
738
/*===========================*/
 
739
        que_thr_t*      thr,            /* in: query thread whose run_node
 
740
                                        is an update node */
 
741
        const char*     name)           /* in: table name prefixed with
 
742
                                        database name and a '/' character */
 
743
{
 
744
        char*   buf;
 
745
        char*   ptr;
 
746
        ulint   len = strlen(name) + 1;
 
747
 
 
748
        buf = mem_strdupl(name, len);
 
749
 
 
750
        ptr = strchr(buf, '/');
 
751
        ut_a(ptr);
 
752
        *ptr = '\0';
 
753
 
 
754
        /* We call a function in ha_innodb.cc */
 
755
#ifndef UNIV_HOTBACKUP
 
756
        innobase_invalidate_query_cache(thr_get_trx(thr), buf, len);
 
757
#endif
 
758
        mem_free(buf);
 
759
}
 
760
 
 
761
/*************************************************************************
 
762
Perform referential actions or checks when a parent row is deleted or updated
 
763
and the constraint had an ON DELETE or ON UPDATE condition which was not
 
764
RESTRICT. */
 
765
static
 
766
ulint
 
767
row_ins_foreign_check_on_constraint(
 
768
/*================================*/
 
769
                                        /* out: DB_SUCCESS, DB_LOCK_WAIT,
 
770
                                        or error code */
 
771
        que_thr_t*      thr,            /* in: query thread whose run_node
 
772
                                        is an update node */
 
773
        dict_foreign_t* foreign,        /* in: foreign key constraint whose
 
774
                                        type is != 0 */
 
775
        btr_pcur_t*     pcur,           /* in: cursor placed on a matching
 
776
                                        index record in the child table */
 
777
        dtuple_t*       entry,          /* in: index entry in the parent
 
778
                                        table */
 
779
        mtr_t*          mtr)            /* in: mtr holding the latch of pcur
 
780
                                        page */
 
781
{
 
782
        upd_node_t*     node;
 
783
        upd_node_t*     cascade;
 
784
        dict_table_t*   table           = foreign->foreign_table;
 
785
        dict_index_t*   index;
 
786
        dict_index_t*   clust_index;
 
787
        dtuple_t*       ref;
 
788
        mem_heap_t*     upd_vec_heap    = NULL;
 
789
        const rec_t*    rec;
 
790
        const rec_t*    clust_rec;
 
791
        const buf_block_t* clust_block;
 
792
        upd_t*          update;
 
793
        ulint           n_to_update;
 
794
        ulint           err;
 
795
        ulint           i;
 
796
        trx_t*          trx;
 
797
        mem_heap_t*     tmp_heap        = NULL;
 
798
 
 
799
        ut_a(thr);
 
800
        ut_a(foreign);
 
801
        ut_a(pcur);
 
802
        ut_a(mtr);
 
803
 
 
804
        trx = thr_get_trx(thr);
 
805
 
 
806
        /* Since we are going to delete or update a row, we have to invalidate
 
807
        the MySQL query cache for table. A deadlock of threads is not possible
 
808
        here because the caller of this function does not hold any latches with
 
809
        the sync0sync.h rank above the kernel mutex. The query cache mutex has
 
810
        a rank just above the kernel mutex. */
 
811
 
 
812
        row_ins_invalidate_query_cache(thr, table->name);
 
813
 
 
814
        node = thr->run_node;
 
815
 
 
816
        if (node->is_delete && 0 == (foreign->type
 
817
                                     & (DICT_FOREIGN_ON_DELETE_CASCADE
 
818
                                        | DICT_FOREIGN_ON_DELETE_SET_NULL))) {
 
819
 
 
820
                row_ins_foreign_report_err("Trying to delete",
 
821
                                           thr, foreign,
 
822
                                           btr_pcur_get_rec(pcur), entry);
 
823
 
 
824
                return(DB_ROW_IS_REFERENCED);
 
825
        }
 
826
 
 
827
        if (!node->is_delete && 0 == (foreign->type
 
828
                                      & (DICT_FOREIGN_ON_UPDATE_CASCADE
 
829
                                         | DICT_FOREIGN_ON_UPDATE_SET_NULL))) {
 
830
 
 
831
                /* This is an UPDATE */
 
832
 
 
833
                row_ins_foreign_report_err("Trying to update",
 
834
                                           thr, foreign,
 
835
                                           btr_pcur_get_rec(pcur), entry);
 
836
 
 
837
                return(DB_ROW_IS_REFERENCED);
 
838
        }
 
839
 
 
840
        if (node->cascade_node == NULL) {
 
841
                /* Extend our query graph by creating a child to current
 
842
                update node. The child is used in the cascade or set null
 
843
                operation. */
 
844
 
 
845
                node->cascade_heap = mem_heap_create(128);
 
846
                node->cascade_node = row_create_update_node_for_mysql(
 
847
                        table, node->cascade_heap);
 
848
                que_node_set_parent(node->cascade_node, node);
 
849
        }
 
850
 
 
851
        /* Initialize cascade_node to do the operation we want. Note that we
 
852
        use the SAME cascade node to do all foreign key operations of the
 
853
        SQL DELETE: the table of the cascade node may change if there are
 
854
        several child tables to the table where the delete is done! */
 
855
 
 
856
        cascade = node->cascade_node;
 
857
 
 
858
        cascade->table = table;
 
859
 
 
860
        cascade->foreign = foreign;
 
861
 
 
862
        if (node->is_delete
 
863
            && (foreign->type & DICT_FOREIGN_ON_DELETE_CASCADE)) {
 
864
                cascade->is_delete = TRUE;
 
865
        } else {
 
866
                cascade->is_delete = FALSE;
 
867
 
 
868
                if (foreign->n_fields > cascade->update_n_fields) {
 
869
                        /* We have to make the update vector longer */
 
870
 
 
871
                        cascade->update = upd_create(foreign->n_fields,
 
872
                                                     node->cascade_heap);
 
873
                        cascade->update_n_fields = foreign->n_fields;
 
874
                }
 
875
        }
 
876
 
 
877
        /* We do not allow cyclic cascaded updating (DELETE is allowed,
 
878
        but not UPDATE) of the same table, as this can lead to an infinite
 
879
        cycle. Check that we are not updating the same table which is
 
880
        already being modified in this cascade chain. We have to check
 
881
        this also because the modification of the indexes of a 'parent'
 
882
        table may still be incomplete, and we must avoid seeing the indexes
 
883
        of the parent table in an inconsistent state! */
 
884
 
 
885
        if (!cascade->is_delete
 
886
            && row_ins_cascade_ancestor_updates_table(cascade, table)) {
 
887
 
 
888
                /* We do not know if this would break foreign key
 
889
                constraints, but play safe and return an error */
 
890
 
 
891
                err = DB_ROW_IS_REFERENCED;
 
892
 
 
893
                row_ins_foreign_report_err(
 
894
                        "Trying an update, possibly causing a cyclic"
 
895
                        " cascaded update\n"
 
896
                        "in the child table,", thr, foreign,
 
897
                        btr_pcur_get_rec(pcur), entry);
 
898
 
 
899
                goto nonstandard_exit_func;
 
900
        }
 
901
 
 
902
        if (row_ins_cascade_n_ancestors(cascade) >= 15) {
 
903
                err = DB_ROW_IS_REFERENCED;
 
904
 
 
905
                row_ins_foreign_report_err(
 
906
                        "Trying a too deep cascaded delete or update\n",
 
907
                        thr, foreign, btr_pcur_get_rec(pcur), entry);
 
908
 
 
909
                goto nonstandard_exit_func;
 
910
        }
 
911
 
 
912
        index = btr_pcur_get_btr_cur(pcur)->index;
 
913
 
 
914
        ut_a(index == foreign->foreign_index);
 
915
 
 
916
        rec = btr_pcur_get_rec(pcur);
 
917
 
 
918
        if (dict_index_is_clust(index)) {
 
919
                /* pcur is already positioned in the clustered index of
 
920
                the child table */
 
921
 
 
922
                clust_index = index;
 
923
                clust_rec = rec;
 
924
                clust_block = btr_pcur_get_block(pcur);
 
925
        } else {
 
926
                /* We have to look for the record in the clustered index
 
927
                in the child table */
 
928
 
 
929
                clust_index = dict_table_get_first_index(table);
 
930
 
 
931
                tmp_heap = mem_heap_create(256);
 
932
 
 
933
                ref = row_build_row_ref(ROW_COPY_POINTERS, index, rec,
 
934
                                        tmp_heap);
 
935
                btr_pcur_open_with_no_init(clust_index, ref,
 
936
                                           PAGE_CUR_LE, BTR_SEARCH_LEAF,
 
937
                                           cascade->pcur, 0, mtr);
 
938
 
 
939
                clust_rec = btr_pcur_get_rec(cascade->pcur);
 
940
                clust_block = btr_pcur_get_block(cascade->pcur);
 
941
 
 
942
                if (!page_rec_is_user_rec(clust_rec)
 
943
                    || btr_pcur_get_low_match(cascade->pcur)
 
944
                    < dict_index_get_n_unique(clust_index)) {
 
945
 
 
946
                        fputs("InnoDB: error in cascade of a foreign key op\n"
 
947
                              "InnoDB: ", stderr);
 
948
                        dict_index_name_print(stderr, trx, index);
 
949
 
 
950
                        fputs("\n"
 
951
                              "InnoDB: record ", stderr);
 
952
                        rec_print(stderr, rec, index);
 
953
                        fputs("\n"
 
954
                              "InnoDB: clustered record ", stderr);
 
955
                        rec_print(stderr, clust_rec, clust_index);
 
956
                        fputs("\n"
 
957
                              "InnoDB: Submit a detailed bug report to"
 
958
                              " http://bugs.mysql.com\n", stderr);
 
959
 
 
960
                        err = DB_SUCCESS;
 
961
 
 
962
                        goto nonstandard_exit_func;
 
963
                }
 
964
        }
 
965
 
 
966
        /* Set an X-lock on the row to delete or update in the child table */
 
967
 
 
968
        err = lock_table(0, table, LOCK_IX, thr);
 
969
 
 
970
        if (err == DB_SUCCESS) {
 
971
                /* Here it suffices to use a LOCK_REC_NOT_GAP type lock;
 
972
                we already have a normal shared lock on the appropriate
 
973
                gap if the search criterion was not unique */
 
974
 
 
975
                err = lock_clust_rec_read_check_and_lock_alt(
 
976
                        0, clust_block, clust_rec, clust_index,
 
977
                        LOCK_X, LOCK_REC_NOT_GAP, thr);
 
978
        }
 
979
 
 
980
        if (err != DB_SUCCESS) {
 
981
 
 
982
                goto nonstandard_exit_func;
 
983
        }
 
984
 
 
985
        if (rec_get_deleted_flag(clust_rec, dict_table_is_comp(table))) {
 
986
                /* This can happen if there is a circular reference of
 
987
                rows such that cascading delete comes to delete a row
 
988
                already in the process of being delete marked */
 
989
                err = DB_SUCCESS;
 
990
 
 
991
                goto nonstandard_exit_func;
 
992
        }
 
993
 
 
994
        if ((node->is_delete
 
995
             && (foreign->type & DICT_FOREIGN_ON_DELETE_SET_NULL))
 
996
            || (!node->is_delete
 
997
                && (foreign->type & DICT_FOREIGN_ON_UPDATE_SET_NULL))) {
 
998
 
 
999
                /* Build the appropriate update vector which sets
 
1000
                foreign->n_fields first fields in rec to SQL NULL */
 
1001
 
 
1002
                update = cascade->update;
 
1003
 
 
1004
                update->info_bits = 0;
 
1005
                update->n_fields = foreign->n_fields;
 
1006
 
 
1007
                for (i = 0; i < foreign->n_fields; i++) {
 
1008
                        upd_field_t*    ufield = &update->fields[i];
 
1009
 
 
1010
                        ufield->field_no = dict_table_get_nth_col_pos(
 
1011
                                table,
 
1012
                                dict_index_get_nth_col_no(index, i));
 
1013
                        ufield->orig_len = 0;
 
1014
                        ufield->exp = NULL;
 
1015
                        dfield_set_null(&ufield->new_val);
 
1016
                }
 
1017
        }
 
1018
 
 
1019
        if (!node->is_delete
 
1020
            && (foreign->type & DICT_FOREIGN_ON_UPDATE_CASCADE)) {
 
1021
 
 
1022
                /* Build the appropriate update vector which sets changing
 
1023
                foreign->n_fields first fields in rec to new values */
 
1024
 
 
1025
                upd_vec_heap = mem_heap_create(256);
 
1026
 
 
1027
                n_to_update = row_ins_cascade_calc_update_vec(node, foreign,
 
1028
                                                              upd_vec_heap);
 
1029
                if (n_to_update == ULINT_UNDEFINED) {
 
1030
                        err = DB_ROW_IS_REFERENCED;
 
1031
 
 
1032
                        row_ins_foreign_report_err(
 
1033
                                "Trying a cascaded update where the"
 
1034
                                " updated value in the child\n"
 
1035
                                "table would not fit in the length"
 
1036
                                " of the column, or the value would\n"
 
1037
                                "be NULL and the column is"
 
1038
                                " declared as not NULL in the child table,",
 
1039
                                thr, foreign, btr_pcur_get_rec(pcur), entry);
 
1040
 
 
1041
                        goto nonstandard_exit_func;
 
1042
                }
 
1043
 
 
1044
                if (cascade->update->n_fields == 0) {
 
1045
 
 
1046
                        /* The update does not change any columns referred
 
1047
                        to in this foreign key constraint: no need to do
 
1048
                        anything */
 
1049
 
 
1050
                        err = DB_SUCCESS;
 
1051
 
 
1052
                        goto nonstandard_exit_func;
 
1053
                }
 
1054
        }
 
1055
 
 
1056
        /* Store pcur position and initialize or store the cascade node
 
1057
        pcur stored position */
 
1058
 
 
1059
        btr_pcur_store_position(pcur, mtr);
 
1060
 
 
1061
        if (index == clust_index) {
 
1062
                btr_pcur_copy_stored_position(cascade->pcur, pcur);
 
1063
        } else {
 
1064
                btr_pcur_store_position(cascade->pcur, mtr);
 
1065
        }
 
1066
 
 
1067
        mtr_commit(mtr);
 
1068
 
 
1069
        ut_a(cascade->pcur->rel_pos == BTR_PCUR_ON);
 
1070
 
 
1071
        cascade->state = UPD_NODE_UPDATE_CLUSTERED;
 
1072
 
 
1073
        err = row_update_cascade_for_mysql(thr, cascade,
 
1074
                                           foreign->foreign_table);
 
1075
 
 
1076
        if (foreign->foreign_table->n_foreign_key_checks_running == 0) {
 
1077
                fprintf(stderr,
 
1078
                        "InnoDB: error: table %s has the counter 0"
 
1079
                        " though there is\n"
 
1080
                        "InnoDB: a FOREIGN KEY check running on it.\n",
 
1081
                        foreign->foreign_table->name);
 
1082
        }
 
1083
 
 
1084
        /* Release the data dictionary latch for a while, so that we do not
 
1085
        starve other threads from doing CREATE TABLE etc. if we have a huge
 
1086
        cascaded operation running. The counter n_foreign_key_checks_running
 
1087
        will prevent other users from dropping or ALTERing the table when we
 
1088
        release the latch. */
 
1089
 
 
1090
        row_mysql_unfreeze_data_dictionary(thr_get_trx(thr));
 
1091
        row_mysql_freeze_data_dictionary(thr_get_trx(thr));
 
1092
 
 
1093
        mtr_start(mtr);
 
1094
 
 
1095
        /* Restore pcur position */
 
1096
 
 
1097
        btr_pcur_restore_position(BTR_SEARCH_LEAF, pcur, mtr);
 
1098
 
 
1099
        if (tmp_heap) {
 
1100
                mem_heap_free(tmp_heap);
 
1101
        }
 
1102
 
 
1103
        if (upd_vec_heap) {
 
1104
                mem_heap_free(upd_vec_heap);
 
1105
        }
 
1106
 
 
1107
        return(err);
 
1108
 
 
1109
nonstandard_exit_func:
 
1110
        if (tmp_heap) {
 
1111
                mem_heap_free(tmp_heap);
 
1112
        }
 
1113
 
 
1114
        if (upd_vec_heap) {
 
1115
                mem_heap_free(upd_vec_heap);
 
1116
        }
 
1117
 
 
1118
        btr_pcur_store_position(pcur, mtr);
 
1119
 
 
1120
        mtr_commit(mtr);
 
1121
        mtr_start(mtr);
 
1122
 
 
1123
        btr_pcur_restore_position(BTR_SEARCH_LEAF, pcur, mtr);
 
1124
 
 
1125
        return(err);
 
1126
}
 
1127
 
 
1128
/*************************************************************************
 
1129
Sets a shared lock on a record. Used in locking possible duplicate key
 
1130
records and also in checking foreign key constraints. */
 
1131
static
 
1132
ulint
 
1133
row_ins_set_shared_rec_lock(
 
1134
/*========================*/
 
1135
                                        /* out: DB_SUCCESS or error code */
 
1136
        ulint                   type,   /* in: LOCK_ORDINARY, LOCK_GAP, or
 
1137
                                        LOCK_REC_NOT_GAP type lock */
 
1138
        const buf_block_t*      block,  /* in: buffer block of rec */
 
1139
        const rec_t*            rec,    /* in: record */
 
1140
        dict_index_t*           index,  /* in: index */
 
1141
        const ulint*            offsets,/* in: rec_get_offsets(rec, index) */
 
1142
        que_thr_t*              thr)    /* in: query thread */
 
1143
{
 
1144
        ulint   err;
 
1145
 
 
1146
        ut_ad(rec_offs_validate(rec, index, offsets));
 
1147
 
 
1148
        if (dict_index_is_clust(index)) {
 
1149
                err = lock_clust_rec_read_check_and_lock(
 
1150
                        0, block, rec, index, offsets, LOCK_S, type, thr);
 
1151
        } else {
 
1152
                err = lock_sec_rec_read_check_and_lock(
 
1153
                        0, block, rec, index, offsets, LOCK_S, type, thr);
 
1154
        }
 
1155
 
 
1156
        return(err);
 
1157
}
 
1158
 
 
1159
#ifndef UNIV_HOTBACKUP
 
1160
/*************************************************************************
 
1161
Sets a exclusive lock on a record. Used in locking possible duplicate key
 
1162
records */
 
1163
static
 
1164
ulint
 
1165
row_ins_set_exclusive_rec_lock(
 
1166
/*===========================*/
 
1167
                                        /* out: DB_SUCCESS or error code */
 
1168
        ulint                   type,   /* in: LOCK_ORDINARY, LOCK_GAP, or
 
1169
                                        LOCK_REC_NOT_GAP type lock */
 
1170
        const buf_block_t*      block,  /* in: buffer block of rec */
 
1171
        const rec_t*            rec,    /* in: record */
 
1172
        dict_index_t*           index,  /* in: index */
 
1173
        const ulint*            offsets,/* in: rec_get_offsets(rec, index) */
 
1174
        que_thr_t*              thr)    /* in: query thread */
 
1175
{
 
1176
        ulint   err;
 
1177
 
 
1178
        ut_ad(rec_offs_validate(rec, index, offsets));
 
1179
 
 
1180
        if (dict_index_is_clust(index)) {
 
1181
                err = lock_clust_rec_read_check_and_lock(
 
1182
                        0, block, rec, index, offsets, LOCK_X, type, thr);
 
1183
        } else {
 
1184
                err = lock_sec_rec_read_check_and_lock(
 
1185
                        0, block, rec, index, offsets, LOCK_X, type, thr);
 
1186
        }
 
1187
 
 
1188
        return(err);
 
1189
}
 
1190
#endif /* !UNIV_HOTBACKUP */
 
1191
 
 
1192
/*******************************************************************
 
1193
Checks if foreign key constraint fails for an index entry. Sets shared locks
 
1194
which lock either the success or the failure of the constraint. NOTE that
 
1195
the caller must have a shared latch on dict_operation_lock. */
 
1196
UNIV_INTERN
 
1197
ulint
 
1198
row_ins_check_foreign_constraint(
 
1199
/*=============================*/
 
1200
                                /* out: DB_SUCCESS,
 
1201
                                DB_NO_REFERENCED_ROW,
 
1202
                                or DB_ROW_IS_REFERENCED */
 
1203
        ibool           check_ref,/* in: TRUE if we want to check that
 
1204
                                the referenced table is ok, FALSE if we
 
1205
                                want to to check the foreign key table */
 
1206
        dict_foreign_t* foreign,/* in: foreign constraint; NOTE that the
 
1207
                                tables mentioned in it must be in the
 
1208
                                dictionary cache if they exist at all */
 
1209
        dict_table_t*   table,  /* in: if check_ref is TRUE, then the foreign
 
1210
                                table, else the referenced table */
 
1211
        dtuple_t*       entry,  /* in: index entry for index */
 
1212
        que_thr_t*      thr)    /* in: query thread */
 
1213
{
 
1214
        upd_node_t*     upd_node;
 
1215
        dict_table_t*   check_table;
 
1216
        dict_index_t*   check_index;
 
1217
        ulint           n_fields_cmp;
 
1218
        btr_pcur_t      pcur;
 
1219
        ibool           moved;
 
1220
        int             cmp;
 
1221
        ulint           err;
 
1222
        ulint           i;
 
1223
        mtr_t           mtr;
 
1224
        trx_t*          trx             = thr_get_trx(thr);
 
1225
        mem_heap_t*     heap            = NULL;
 
1226
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
 
1227
        ulint*          offsets         = offsets_;
 
1228
        rec_offs_init(offsets_);
 
1229
 
 
1230
run_again:
 
1231
#ifdef UNIV_SYNC_DEBUG
 
1232
        ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_SHARED));
 
1233
#endif /* UNIV_SYNC_DEBUG */
 
1234
 
 
1235
        err = DB_SUCCESS;
 
1236
 
 
1237
        if (trx->check_foreigns == FALSE) {
 
1238
                /* The user has suppressed foreign key checks currently for
 
1239
                this session */
 
1240
                goto exit_func;
 
1241
        }
 
1242
 
 
1243
        /* If any of the foreign key fields in entry is SQL NULL, we
 
1244
        suppress the foreign key check: this is compatible with Oracle,
 
1245
        for example */
 
1246
 
 
1247
        for (i = 0; i < foreign->n_fields; i++) {
 
1248
                if (UNIV_SQL_NULL == dfield_get_len(
 
1249
                            dtuple_get_nth_field(entry, i))) {
 
1250
 
 
1251
                        goto exit_func;
 
1252
                }
 
1253
        }
 
1254
 
 
1255
        if (que_node_get_type(thr->run_node) == QUE_NODE_UPDATE) {
 
1256
                upd_node = thr->run_node;
 
1257
 
 
1258
                if (!(upd_node->is_delete) && upd_node->foreign == foreign) {
 
1259
                        /* If a cascaded update is done as defined by a
 
1260
                        foreign key constraint, do not check that
 
1261
                        constraint for the child row. In ON UPDATE CASCADE
 
1262
                        the update of the parent row is only half done when
 
1263
                        we come here: if we would check the constraint here
 
1264
                        for the child row it would fail.
 
1265
 
 
1266
                        A QUESTION remains: if in the child table there are
 
1267
                        several constraints which refer to the same parent
 
1268
                        table, we should merge all updates to the child as
 
1269
                        one update? And the updates can be contradictory!
 
1270
                        Currently we just perform the update associated
 
1271
                        with each foreign key constraint, one after
 
1272
                        another, and the user has problems predicting in
 
1273
                        which order they are performed. */
 
1274
 
 
1275
                        goto exit_func;
 
1276
                }
 
1277
        }
 
1278
 
 
1279
        if (check_ref) {
 
1280
                check_table = foreign->referenced_table;
 
1281
                check_index = foreign->referenced_index;
 
1282
        } else {
 
1283
                check_table = foreign->foreign_table;
 
1284
                check_index = foreign->foreign_index;
 
1285
        }
 
1286
 
 
1287
        if (check_table == NULL || check_table->ibd_file_missing) {
 
1288
                if (check_ref) {
 
1289
                        FILE*   ef = dict_foreign_err_file;
 
1290
 
 
1291
                        row_ins_set_detailed(trx, foreign);
 
1292
 
 
1293
                        mutex_enter(&dict_foreign_err_mutex);
 
1294
                        rewind(ef);
 
1295
                        ut_print_timestamp(ef);
 
1296
                        fputs(" Transaction:\n", ef);
 
1297
                        trx_print(ef, trx, 600);
 
1298
                        fputs("Foreign key constraint fails for table ", ef);
 
1299
                        ut_print_name(ef, trx, TRUE,
 
1300
                                      foreign->foreign_table_name);
 
1301
                        fputs(":\n", ef);
 
1302
                        dict_print_info_on_foreign_key_in_create_format(
 
1303
                                ef, trx, foreign, TRUE);
 
1304
                        fputs("\nTrying to add to index ", ef);
 
1305
                        ut_print_name(ef, trx, FALSE,
 
1306
                                      foreign->foreign_index->name);
 
1307
                        fputs(" tuple:\n", ef);
 
1308
                        dtuple_print(ef, entry);
 
1309
                        fputs("\nBut the parent table ", ef);
 
1310
                        ut_print_name(ef, trx, TRUE,
 
1311
                                      foreign->referenced_table_name);
 
1312
                        fputs("\nor its .ibd file does"
 
1313
                              " not currently exist!\n", ef);
 
1314
                        mutex_exit(&dict_foreign_err_mutex);
 
1315
 
 
1316
                        err = DB_NO_REFERENCED_ROW;
 
1317
                }
 
1318
 
 
1319
                goto exit_func;
 
1320
        }
 
1321
 
 
1322
        ut_a(check_table);
 
1323
        ut_a(check_index);
 
1324
 
 
1325
        if (check_table != table) {
 
1326
                /* We already have a LOCK_IX on table, but not necessarily
 
1327
                on check_table */
 
1328
 
 
1329
                err = lock_table(0, check_table, LOCK_IS, thr);
 
1330
 
 
1331
                if (err != DB_SUCCESS) {
 
1332
 
 
1333
                        goto do_possible_lock_wait;
 
1334
                }
 
1335
        }
 
1336
 
 
1337
        mtr_start(&mtr);
 
1338
 
 
1339
        /* Store old value on n_fields_cmp */
 
1340
 
 
1341
        n_fields_cmp = dtuple_get_n_fields_cmp(entry);
 
1342
 
 
1343
        dtuple_set_n_fields_cmp(entry, foreign->n_fields);
 
1344
 
 
1345
        btr_pcur_open(check_index, entry, PAGE_CUR_GE,
 
1346
                      BTR_SEARCH_LEAF, &pcur, &mtr);
 
1347
 
 
1348
        /* Scan index records and check if there is a matching record */
 
1349
 
 
1350
        for (;;) {
 
1351
                const rec_t*            rec = btr_pcur_get_rec(&pcur);
 
1352
                const buf_block_t*      block = btr_pcur_get_block(&pcur);
 
1353
 
 
1354
                if (page_rec_is_infimum(rec)) {
 
1355
 
 
1356
                        goto next_rec;
 
1357
                }
 
1358
 
 
1359
                offsets = rec_get_offsets(rec, check_index,
 
1360
                                          offsets, ULINT_UNDEFINED, &heap);
 
1361
 
 
1362
                if (page_rec_is_supremum(rec)) {
 
1363
 
 
1364
                        err = row_ins_set_shared_rec_lock(LOCK_ORDINARY, block,
 
1365
                                                          rec, check_index,
 
1366
                                                          offsets, thr);
 
1367
                        if (err != DB_SUCCESS) {
 
1368
 
 
1369
                                break;
 
1370
                        }
 
1371
 
 
1372
                        goto next_rec;
 
1373
                }
 
1374
 
 
1375
                cmp = cmp_dtuple_rec(entry, rec, offsets);
 
1376
 
 
1377
                if (cmp == 0) {
 
1378
                        if (rec_get_deleted_flag(rec,
 
1379
                                                 rec_offs_comp(offsets))) {
 
1380
                                err = row_ins_set_shared_rec_lock(
 
1381
                                        LOCK_ORDINARY, block,
 
1382
                                        rec, check_index, offsets, thr);
 
1383
                                if (err != DB_SUCCESS) {
 
1384
 
 
1385
                                        break;
 
1386
                                }
 
1387
                        } else {
 
1388
                                /* Found a matching record. Lock only
 
1389
                                a record because we can allow inserts
 
1390
                                into gaps */
 
1391
 
 
1392
                                err = row_ins_set_shared_rec_lock(
 
1393
                                        LOCK_REC_NOT_GAP, block,
 
1394
                                        rec, check_index, offsets, thr);
 
1395
 
 
1396
                                if (err != DB_SUCCESS) {
 
1397
 
 
1398
                                        break;
 
1399
                                }
 
1400
 
 
1401
                                if (check_ref) {
 
1402
                                        err = DB_SUCCESS;
 
1403
 
 
1404
                                        break;
 
1405
                                } else if (foreign->type != 0) {
 
1406
                                        /* There is an ON UPDATE or ON DELETE
 
1407
                                        condition: check them in a separate
 
1408
                                        function */
 
1409
 
 
1410
                                        err = row_ins_foreign_check_on_constraint(
 
1411
                                                thr, foreign, &pcur, entry,
 
1412
                                                &mtr);
 
1413
                                        if (err != DB_SUCCESS) {
 
1414
                                                /* Since reporting a plain
 
1415
                                                "duplicate key" error
 
1416
                                                message to the user in
 
1417
                                                cases where a long CASCADE
 
1418
                                                operation would lead to a
 
1419
                                                duplicate key in some
 
1420
                                                other table is very
 
1421
                                                confusing, map duplicate
 
1422
                                                key errors resulting from
 
1423
                                                FK constraints to a
 
1424
                                                separate error code. */
 
1425
 
 
1426
                                                if (err == DB_DUPLICATE_KEY) {
 
1427
                                                        err = DB_FOREIGN_DUPLICATE_KEY;
 
1428
                                                }
 
1429
 
 
1430
                                                break;
 
1431
                                        }
 
1432
 
 
1433
                                        /* row_ins_foreign_check_on_constraint
 
1434
                                        may have repositioned pcur on a
 
1435
                                        different block */
 
1436
                                        block = btr_pcur_get_block(&pcur);
 
1437
                                } else {
 
1438
                                        row_ins_foreign_report_err(
 
1439
                                                "Trying to delete or update",
 
1440
                                                thr, foreign, rec, entry);
 
1441
 
 
1442
                                        err = DB_ROW_IS_REFERENCED;
 
1443
                                        break;
 
1444
                                }
 
1445
                        }
 
1446
                }
 
1447
 
 
1448
                if (cmp < 0) {
 
1449
                        err = row_ins_set_shared_rec_lock(
 
1450
                                LOCK_GAP, block,
 
1451
                                rec, check_index, offsets, thr);
 
1452
                        if (err != DB_SUCCESS) {
 
1453
 
 
1454
                                break;
 
1455
                        }
 
1456
 
 
1457
                        if (check_ref) {
 
1458
                                err = DB_NO_REFERENCED_ROW;
 
1459
                                row_ins_foreign_report_add_err(
 
1460
                                        trx, foreign, rec, entry);
 
1461
                        } else {
 
1462
                                err = DB_SUCCESS;
 
1463
                        }
 
1464
 
 
1465
                        break;
 
1466
                }
 
1467
 
 
1468
                ut_a(cmp == 0);
 
1469
next_rec:
 
1470
                moved = btr_pcur_move_to_next(&pcur, &mtr);
 
1471
 
 
1472
                if (!moved) {
 
1473
                        if (check_ref) {
 
1474
                                rec = btr_pcur_get_rec(&pcur);
 
1475
                                row_ins_foreign_report_add_err(
 
1476
                                        trx, foreign, rec, entry);
 
1477
                                err = DB_NO_REFERENCED_ROW;
 
1478
                        } else {
 
1479
                                err = DB_SUCCESS;
 
1480
                        }
 
1481
 
 
1482
                        break;
 
1483
                }
 
1484
        }
 
1485
 
 
1486
        btr_pcur_close(&pcur);
 
1487
 
 
1488
        mtr_commit(&mtr);
 
1489
 
 
1490
        /* Restore old value */
 
1491
        dtuple_set_n_fields_cmp(entry, n_fields_cmp);
 
1492
 
 
1493
do_possible_lock_wait:
 
1494
        if (err == DB_LOCK_WAIT) {
 
1495
                trx->error_state = err;
 
1496
 
 
1497
                que_thr_stop_for_mysql(thr);
 
1498
 
 
1499
                srv_suspend_mysql_thread(thr);
 
1500
 
 
1501
                if (trx->error_state == DB_SUCCESS) {
 
1502
 
 
1503
                        goto run_again;
 
1504
                }
 
1505
 
 
1506
                err = trx->error_state;
 
1507
        }
 
1508
 
 
1509
exit_func:
 
1510
        if (UNIV_LIKELY_NULL(heap)) {
 
1511
                mem_heap_free(heap);
 
1512
        }
 
1513
        return(err);
 
1514
}
 
1515
 
 
1516
/*******************************************************************
 
1517
Checks if foreign key constraints fail for an index entry. If index
 
1518
is not mentioned in any constraint, this function does nothing,
 
1519
Otherwise does searches to the indexes of referenced tables and
 
1520
sets shared locks which lock either the success or the failure of
 
1521
a constraint. */
 
1522
static
 
1523
ulint
 
1524
row_ins_check_foreign_constraints(
 
1525
/*==============================*/
 
1526
                                /* out: DB_SUCCESS or error code */
 
1527
        dict_table_t*   table,  /* in: table */
 
1528
        dict_index_t*   index,  /* in: index */
 
1529
        dtuple_t*       entry,  /* in: index entry for index */
 
1530
        que_thr_t*      thr)    /* in: query thread */
 
1531
{
 
1532
        dict_foreign_t* foreign;
 
1533
        ulint           err;
 
1534
        trx_t*          trx;
 
1535
        ibool           got_s_lock      = FALSE;
 
1536
 
 
1537
        trx = thr_get_trx(thr);
 
1538
 
 
1539
        foreign = UT_LIST_GET_FIRST(table->foreign_list);
 
1540
 
 
1541
        while (foreign) {
 
1542
                if (foreign->foreign_index == index) {
 
1543
 
 
1544
                        if (foreign->referenced_table == NULL) {
 
1545
                                dict_table_get(foreign->referenced_table_name,
 
1546
                                               FALSE);
 
1547
                        }
 
1548
 
 
1549
                        if (0 == trx->dict_operation_lock_mode) {
 
1550
                                got_s_lock = TRUE;
 
1551
 
 
1552
                                row_mysql_freeze_data_dictionary(trx);
 
1553
                        }
 
1554
 
 
1555
                        if (foreign->referenced_table) {
 
1556
                                mutex_enter(&(dict_sys->mutex));
 
1557
 
 
1558
                                (foreign->referenced_table
 
1559
                                 ->n_foreign_key_checks_running)++;
 
1560
 
 
1561
                                mutex_exit(&(dict_sys->mutex));
 
1562
                        }
 
1563
 
 
1564
                        /* NOTE that if the thread ends up waiting for a lock
 
1565
                        we will release dict_operation_lock temporarily!
 
1566
                        But the counter on the table protects the referenced
 
1567
                        table from being dropped while the check is running. */
 
1568
 
 
1569
                        err = row_ins_check_foreign_constraint(
 
1570
                                TRUE, foreign, table, entry, thr);
 
1571
 
 
1572
                        if (foreign->referenced_table) {
 
1573
                                mutex_enter(&(dict_sys->mutex));
 
1574
 
 
1575
                                ut_a(foreign->referenced_table
 
1576
                                     ->n_foreign_key_checks_running > 0);
 
1577
                                (foreign->referenced_table
 
1578
                                 ->n_foreign_key_checks_running)--;
 
1579
 
 
1580
                                mutex_exit(&(dict_sys->mutex));
 
1581
                        }
 
1582
 
 
1583
                        if (got_s_lock) {
 
1584
                                row_mysql_unfreeze_data_dictionary(trx);
 
1585
                        }
 
1586
 
 
1587
                        if (err != DB_SUCCESS) {
 
1588
                                return(err);
 
1589
                        }
 
1590
                }
 
1591
 
 
1592
                foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
 
1593
        }
 
1594
 
 
1595
        return(DB_SUCCESS);
 
1596
}
 
1597
 
 
1598
#ifndef UNIV_HOTBACKUP
 
1599
/*******************************************************************
 
1600
Checks if a unique key violation to rec would occur at the index entry
 
1601
insert. */
 
1602
static
 
1603
ibool
 
1604
row_ins_dupl_error_with_rec(
 
1605
/*========================*/
 
1606
                                /* out: TRUE if error */
 
1607
        const rec_t*    rec,    /* in: user record; NOTE that we assume
 
1608
                                that the caller already has a record lock on
 
1609
                                the record! */
 
1610
        const dtuple_t* entry,  /* in: entry to insert */
 
1611
        dict_index_t*   index,  /* in: index */
 
1612
        const ulint*    offsets)/* in: rec_get_offsets(rec, index) */
 
1613
{
 
1614
        ulint   matched_fields;
 
1615
        ulint   matched_bytes;
 
1616
        ulint   n_unique;
 
1617
        ulint   i;
 
1618
 
 
1619
        ut_ad(rec_offs_validate(rec, index, offsets));
 
1620
 
 
1621
        n_unique = dict_index_get_n_unique(index);
 
1622
 
 
1623
        matched_fields = 0;
 
1624
        matched_bytes = 0;
 
1625
 
 
1626
        cmp_dtuple_rec_with_match(entry, rec, offsets,
 
1627
                                  &matched_fields, &matched_bytes);
 
1628
 
 
1629
        if (matched_fields < n_unique) {
 
1630
 
 
1631
                return(FALSE);
 
1632
        }
 
1633
 
 
1634
        /* In a unique secondary index we allow equal key values if they
 
1635
        contain SQL NULLs */
 
1636
 
 
1637
        if (!dict_index_is_clust(index)) {
 
1638
 
 
1639
                for (i = 0; i < n_unique; i++) {
 
1640
                        if (UNIV_SQL_NULL == dfield_get_len(
 
1641
                                    dtuple_get_nth_field(entry, i))) {
 
1642
 
 
1643
                                return(FALSE);
 
1644
                        }
 
1645
                }
 
1646
        }
 
1647
 
 
1648
        return(!rec_get_deleted_flag(rec, rec_offs_comp(offsets)));
 
1649
}
 
1650
#endif /* !UNIV_HOTBACKUP */
 
1651
 
 
1652
/*******************************************************************
 
1653
Scans a unique non-clustered index at a given index entry to determine
 
1654
whether a uniqueness violation has occurred for the key value of the entry.
 
1655
Set shared locks on possible duplicate records. */
 
1656
static
 
1657
ulint
 
1658
row_ins_scan_sec_index_for_duplicate(
 
1659
/*=================================*/
 
1660
                                /* out: DB_SUCCESS, DB_DUPLICATE_KEY, or
 
1661
                                DB_LOCK_WAIT */
 
1662
        dict_index_t*   index,  /* in: non-clustered unique index */
 
1663
        dtuple_t*       entry,  /* in: index entry */
 
1664
        que_thr_t*      thr)    /* in: query thread */
 
1665
{
 
1666
#ifndef UNIV_HOTBACKUP
 
1667
        ulint           n_unique;
 
1668
        ulint           i;
 
1669
        int             cmp;
 
1670
        ulint           n_fields_cmp;
 
1671
        btr_pcur_t      pcur;
 
1672
        ulint           err             = DB_SUCCESS;
 
1673
        unsigned        allow_duplicates;
 
1674
        mtr_t           mtr;
 
1675
        mem_heap_t*     heap            = NULL;
 
1676
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
 
1677
        ulint*          offsets         = offsets_;
 
1678
        rec_offs_init(offsets_);
 
1679
 
 
1680
        n_unique = dict_index_get_n_unique(index);
 
1681
 
 
1682
        /* If the secondary index is unique, but one of the fields in the
 
1683
        n_unique first fields is NULL, a unique key violation cannot occur,
 
1684
        since we define NULL != NULL in this case */
 
1685
 
 
1686
        for (i = 0; i < n_unique; i++) {
 
1687
                if (UNIV_SQL_NULL == dfield_get_len(
 
1688
                            dtuple_get_nth_field(entry, i))) {
 
1689
 
 
1690
                        return(DB_SUCCESS);
 
1691
                }
 
1692
        }
 
1693
 
 
1694
        mtr_start(&mtr);
 
1695
 
 
1696
        /* Store old value on n_fields_cmp */
 
1697
 
 
1698
        n_fields_cmp = dtuple_get_n_fields_cmp(entry);
 
1699
 
 
1700
        dtuple_set_n_fields_cmp(entry, dict_index_get_n_unique(index));
 
1701
 
 
1702
        btr_pcur_open(index, entry, PAGE_CUR_GE, BTR_SEARCH_LEAF, &pcur, &mtr);
 
1703
 
 
1704
        allow_duplicates = thr_get_trx(thr)->duplicates & TRX_DUP_IGNORE;
 
1705
 
 
1706
        /* Scan index records and check if there is a duplicate */
 
1707
 
 
1708
        do {
 
1709
                const rec_t*            rec     = btr_pcur_get_rec(&pcur);
 
1710
                const buf_block_t*      block   = btr_pcur_get_block(&pcur);
 
1711
 
 
1712
                if (page_rec_is_infimum(rec)) {
 
1713
 
 
1714
                        continue;
 
1715
                }
 
1716
 
 
1717
                offsets = rec_get_offsets(rec, index, offsets,
 
1718
                                          ULINT_UNDEFINED, &heap);
 
1719
 
 
1720
                if (allow_duplicates) {
 
1721
 
 
1722
                        /* If the SQL-query will update or replace
 
1723
                        duplicate key we will take X-lock for
 
1724
                        duplicates ( REPLACE, LOAD DATAFILE REPLACE,
 
1725
                        INSERT ON DUPLICATE KEY UPDATE). */
 
1726
 
 
1727
                        err = row_ins_set_exclusive_rec_lock(
 
1728
                                LOCK_ORDINARY, block,
 
1729
                                rec, index, offsets, thr);
 
1730
                } else {
 
1731
 
 
1732
                        err = row_ins_set_shared_rec_lock(
 
1733
                                LOCK_ORDINARY, block,
 
1734
                                rec, index, offsets, thr);
 
1735
                }
 
1736
 
 
1737
                if (err != DB_SUCCESS) {
 
1738
 
 
1739
                        break;
 
1740
                }
 
1741
 
 
1742
                if (page_rec_is_supremum(rec)) {
 
1743
 
 
1744
                        continue;
 
1745
                }
 
1746
 
 
1747
                cmp = cmp_dtuple_rec(entry, rec, offsets);
 
1748
 
 
1749
                if (cmp == 0) {
 
1750
                        if (row_ins_dupl_error_with_rec(rec, entry,
 
1751
                                                        index, offsets)) {
 
1752
                                err = DB_DUPLICATE_KEY;
 
1753
 
 
1754
                                thr_get_trx(thr)->error_info = index;
 
1755
 
 
1756
                                break;
 
1757
                        }
 
1758
                }
 
1759
 
 
1760
                if (cmp < 0) {
 
1761
                        break;
 
1762
                }
 
1763
 
 
1764
                ut_a(cmp == 0);
 
1765
        } while (btr_pcur_move_to_next(&pcur, &mtr));
 
1766
 
 
1767
        if (UNIV_LIKELY_NULL(heap)) {
 
1768
                mem_heap_free(heap);
 
1769
        }
 
1770
        mtr_commit(&mtr);
 
1771
 
 
1772
        /* Restore old value */
 
1773
        dtuple_set_n_fields_cmp(entry, n_fields_cmp);
 
1774
 
 
1775
        return(err);
 
1776
#else /* UNIV_HOTBACKUP */
 
1777
        /* This function depends on MySQL code that is not included in
 
1778
        InnoDB Hot Backup builds.  Besides, this function should never
 
1779
        be called in InnoDB Hot Backup. */
 
1780
        ut_error;
 
1781
        return(DB_FAIL);
 
1782
#endif /* UNIV_HOTBACKUP */
 
1783
}
 
1784
 
 
1785
/*******************************************************************
 
1786
Checks if a unique key violation error would occur at an index entry
 
1787
insert. Sets shared locks on possible duplicate records. Works only
 
1788
for a clustered index! */
 
1789
static
 
1790
ulint
 
1791
row_ins_duplicate_error_in_clust(
 
1792
/*=============================*/
 
1793
                                /* out: DB_SUCCESS if no error,
 
1794
                                DB_DUPLICATE_KEY if error, DB_LOCK_WAIT if we
 
1795
                                have to wait for a lock on a possible
 
1796
                                duplicate record */
 
1797
        btr_cur_t*      cursor, /* in: B-tree cursor */
 
1798
        dtuple_t*       entry,  /* in: entry to insert */
 
1799
        que_thr_t*      thr,    /* in: query thread */
 
1800
        mtr_t*          mtr)    /* in: mtr */
 
1801
{
 
1802
#ifndef UNIV_HOTBACKUP
 
1803
        ulint   err;
 
1804
        rec_t*  rec;
 
1805
        ulint   n_unique;
 
1806
        trx_t*  trx             = thr_get_trx(thr);
 
1807
        mem_heap_t*heap         = NULL;
 
1808
        ulint   offsets_[REC_OFFS_NORMAL_SIZE];
 
1809
        ulint*  offsets         = offsets_;
 
1810
        rec_offs_init(offsets_);
 
1811
 
 
1812
        UT_NOT_USED(mtr);
 
1813
 
 
1814
        ut_a(dict_index_is_clust(cursor->index));
 
1815
        ut_ad(dict_index_is_unique(cursor->index));
 
1816
 
 
1817
        /* NOTE: For unique non-clustered indexes there may be any number
 
1818
        of delete marked records with the same value for the non-clustered
 
1819
        index key (remember multiversioning), and which differ only in
 
1820
        the row refererence part of the index record, containing the
 
1821
        clustered index key fields. For such a secondary index record,
 
1822
        to avoid race condition, we must FIRST do the insertion and after
 
1823
        that check that the uniqueness condition is not breached! */
 
1824
 
 
1825
        /* NOTE: A problem is that in the B-tree node pointers on an
 
1826
        upper level may match more to the entry than the actual existing
 
1827
        user records on the leaf level. So, even if low_match would suggest
 
1828
        that a duplicate key violation may occur, this may not be the case. */
 
1829
 
 
1830
        n_unique = dict_index_get_n_unique(cursor->index);
 
1831
 
 
1832
        if (cursor->low_match >= n_unique) {
 
1833
 
 
1834
                rec = btr_cur_get_rec(cursor);
 
1835
 
 
1836
                if (!page_rec_is_infimum(rec)) {
 
1837
                        offsets = rec_get_offsets(rec, cursor->index, offsets,
 
1838
                                                  ULINT_UNDEFINED, &heap);
 
1839
 
 
1840
                        /* We set a lock on the possible duplicate: this
 
1841
                        is needed in logical logging of MySQL to make
 
1842
                        sure that in roll-forward we get the same duplicate
 
1843
                        errors as in original execution */
 
1844
 
 
1845
                        if (trx->duplicates & TRX_DUP_IGNORE) {
 
1846
 
 
1847
                                /* If the SQL-query will update or replace
 
1848
                                duplicate key we will take X-lock for
 
1849
                                duplicates ( REPLACE, LOAD DATAFILE REPLACE,
 
1850
                                INSERT ON DUPLICATE KEY UPDATE). */
 
1851
 
 
1852
                                err = row_ins_set_exclusive_rec_lock(
 
1853
                                        LOCK_REC_NOT_GAP,
 
1854
                                        btr_cur_get_block(cursor),
 
1855
                                        rec, cursor->index, offsets, thr);
 
1856
                        } else {
 
1857
 
 
1858
                                err = row_ins_set_shared_rec_lock(
 
1859
                                        LOCK_REC_NOT_GAP,
 
1860
                                        btr_cur_get_block(cursor), rec,
 
1861
                                        cursor->index, offsets, thr);
 
1862
                        }
 
1863
 
 
1864
                        if (err != DB_SUCCESS) {
 
1865
                                goto func_exit;
 
1866
                        }
 
1867
 
 
1868
                        if (row_ins_dupl_error_with_rec(
 
1869
                                    rec, entry, cursor->index, offsets)) {
 
1870
                                trx->error_info = cursor->index;
 
1871
                                err = DB_DUPLICATE_KEY;
 
1872
                                goto func_exit;
 
1873
                        }
 
1874
                }
 
1875
        }
 
1876
 
 
1877
        if (cursor->up_match >= n_unique) {
 
1878
 
 
1879
                rec = page_rec_get_next(btr_cur_get_rec(cursor));
 
1880
 
 
1881
                if (!page_rec_is_supremum(rec)) {
 
1882
                        offsets = rec_get_offsets(rec, cursor->index, offsets,
 
1883
                                                  ULINT_UNDEFINED, &heap);
 
1884
 
 
1885
                        if (trx->duplicates & TRX_DUP_IGNORE) {
 
1886
 
 
1887
                                /* If the SQL-query will update or replace
 
1888
                                duplicate key we will take X-lock for
 
1889
                                duplicates ( REPLACE, LOAD DATAFILE REPLACE,
 
1890
                                INSERT ON DUPLICATE KEY UPDATE). */
 
1891
 
 
1892
                                err = row_ins_set_exclusive_rec_lock(
 
1893
                                        LOCK_REC_NOT_GAP,
 
1894
                                        btr_cur_get_block(cursor),
 
1895
                                        rec, cursor->index, offsets, thr);
 
1896
                        } else {
 
1897
 
 
1898
                                err = row_ins_set_shared_rec_lock(
 
1899
                                        LOCK_REC_NOT_GAP,
 
1900
                                        btr_cur_get_block(cursor),
 
1901
                                        rec, cursor->index, offsets, thr);
 
1902
                        }
 
1903
 
 
1904
                        if (err != DB_SUCCESS) {
 
1905
                                goto func_exit;
 
1906
                        }
 
1907
 
 
1908
                        if (row_ins_dupl_error_with_rec(
 
1909
                                    rec, entry, cursor->index, offsets)) {
 
1910
                                trx->error_info = cursor->index;
 
1911
                                err = DB_DUPLICATE_KEY;
 
1912
                                goto func_exit;
 
1913
                        }
 
1914
                }
 
1915
 
 
1916
                ut_a(!dict_index_is_clust(cursor->index));
 
1917
                /* This should never happen */
 
1918
        }
 
1919
 
 
1920
        err = DB_SUCCESS;
 
1921
func_exit:
 
1922
        if (UNIV_LIKELY_NULL(heap)) {
 
1923
                mem_heap_free(heap);
 
1924
        }
 
1925
        return(err);
 
1926
#else /* UNIV_HOTBACKUP */
 
1927
        /* This function depends on MySQL code that is not included in
 
1928
        InnoDB Hot Backup builds.  Besides, this function should never
 
1929
        be called in InnoDB Hot Backup. */
 
1930
        ut_error;
 
1931
        return(DB_FAIL);
 
1932
#endif /* UNIV_HOTBACKUP */
 
1933
}
 
1934
 
 
1935
/*******************************************************************
 
1936
Checks if an index entry has long enough common prefix with an existing
 
1937
record so that the intended insert of the entry must be changed to a modify of
 
1938
the existing record. In the case of a clustered index, the prefix must be
 
1939
n_unique fields long, and in the case of a secondary index, all fields must be
 
1940
equal. */
 
1941
UNIV_INLINE
 
1942
ulint
 
1943
row_ins_must_modify(
 
1944
/*================*/
 
1945
                                /* out: 0 if no update, ROW_INS_PREV if
 
1946
                                previous should be updated; currently we
 
1947
                                do the search so that only the low_match
 
1948
                                record can match enough to the search tuple,
 
1949
                                not the next record */
 
1950
        btr_cur_t*      cursor) /* in: B-tree cursor */
 
1951
{
 
1952
        ulint   enough_match;
 
1953
        rec_t*  rec;
 
1954
 
 
1955
        /* NOTE: (compare to the note in row_ins_duplicate_error) Because node
 
1956
        pointers on upper levels of the B-tree may match more to entry than
 
1957
        to actual user records on the leaf level, we have to check if the
 
1958
        candidate record is actually a user record. In a clustered index
 
1959
        node pointers contain index->n_unique first fields, and in the case
 
1960
        of a secondary index, all fields of the index. */
 
1961
 
 
1962
        enough_match = dict_index_get_n_unique_in_tree(cursor->index);
 
1963
 
 
1964
        if (cursor->low_match >= enough_match) {
 
1965
 
 
1966
                rec = btr_cur_get_rec(cursor);
 
1967
 
 
1968
                if (!page_rec_is_infimum(rec)) {
 
1969
 
 
1970
                        return(ROW_INS_PREV);
 
1971
                }
 
1972
        }
 
1973
 
 
1974
        return(0);
 
1975
}
 
1976
 
 
1977
/*******************************************************************
 
1978
Tries to insert an index entry to an index. If the index is clustered
 
1979
and a record with the same unique key is found, the other record is
 
1980
necessarily marked deleted by a committed transaction, or a unique key
 
1981
violation error occurs. The delete marked record is then updated to an
 
1982
existing record, and we must write an undo log record on the delete
 
1983
marked record. If the index is secondary, and a record with exactly the
 
1984
same fields is found, the other record is necessarily marked deleted.
 
1985
It is then unmarked. Otherwise, the entry is just inserted to the index. */
 
1986
static
 
1987
ulint
 
1988
row_ins_index_entry_low(
 
1989
/*====================*/
 
1990
                                /* out: DB_SUCCESS, DB_LOCK_WAIT, DB_FAIL
 
1991
                                if pessimistic retry needed, or error code */
 
1992
        ulint           mode,   /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
 
1993
                                depending on whether we wish optimistic or
 
1994
                                pessimistic descent down the index tree */
 
1995
        dict_index_t*   index,  /* in: index */
 
1996
        dtuple_t*       entry,  /* in: index entry to insert */
 
1997
        ulint           n_ext,  /* in: number of externally stored columns */
 
1998
        que_thr_t*      thr)    /* in: query thread */
 
1999
{
 
2000
        btr_cur_t       cursor;
 
2001
        ulint           ignore_sec_unique       = 0;
 
2002
        ulint           modify = 0; /* remove warning */
 
2003
        rec_t*          insert_rec;
 
2004
        rec_t*          rec;
 
2005
        ulint           err;
 
2006
        ulint           n_unique;
 
2007
        big_rec_t*      big_rec                 = NULL;
 
2008
        mtr_t           mtr;
 
2009
        mem_heap_t*     heap                    = NULL;
 
2010
 
 
2011
        log_free_check();
 
2012
 
 
2013
        mtr_start(&mtr);
 
2014
 
 
2015
        cursor.thr = thr;
 
2016
 
 
2017
        /* Note that we use PAGE_CUR_LE as the search mode, because then
 
2018
        the function will return in both low_match and up_match of the
 
2019
        cursor sensible values */
 
2020
 
 
2021
        if (!(thr_get_trx(thr)->check_unique_secondary)) {
 
2022
                ignore_sec_unique = BTR_IGNORE_SEC_UNIQUE;
 
2023
        }
 
2024
 
 
2025
        btr_cur_search_to_nth_level(index, 0, entry, PAGE_CUR_LE,
 
2026
                                    mode | BTR_INSERT | ignore_sec_unique,
 
2027
                                    &cursor, 0, &mtr);
 
2028
 
 
2029
        if (cursor.flag == BTR_CUR_INSERT_TO_IBUF) {
 
2030
                /* The insertion was made to the insert buffer already during
 
2031
                the search: we are done */
 
2032
 
 
2033
                err = DB_SUCCESS;
 
2034
 
 
2035
                goto function_exit;
 
2036
        }
 
2037
 
 
2038
#ifdef UNIV_DEBUG
 
2039
        {
 
2040
                page_t* page = btr_cur_get_page(&cursor);
 
2041
                rec_t*  first_rec = page_rec_get_next(
 
2042
                        page_get_infimum_rec(page));
 
2043
 
 
2044
                ut_ad(page_rec_is_supremum(first_rec)
 
2045
                      || rec_get_n_fields(first_rec, index)
 
2046
                      == dtuple_get_n_fields(entry));
 
2047
        }
 
2048
#endif
 
2049
 
 
2050
        n_unique = dict_index_get_n_unique(index);
 
2051
 
 
2052
        if (dict_index_is_unique(index) && (cursor.up_match >= n_unique
 
2053
                                            || cursor.low_match >= n_unique)) {
 
2054
 
 
2055
                if (dict_index_is_clust(index)) {
 
2056
                        /* Note that the following may return also
 
2057
                        DB_LOCK_WAIT */
 
2058
 
 
2059
                        err = row_ins_duplicate_error_in_clust(
 
2060
                                &cursor, entry, thr, &mtr);
 
2061
                        if (err != DB_SUCCESS) {
 
2062
 
 
2063
                                goto function_exit;
 
2064
                        }
 
2065
                } else {
 
2066
                        mtr_commit(&mtr);
 
2067
                        err = row_ins_scan_sec_index_for_duplicate(
 
2068
                                index, entry, thr);
 
2069
                        mtr_start(&mtr);
 
2070
 
 
2071
                        if (err != DB_SUCCESS) {
 
2072
 
 
2073
                                goto function_exit;
 
2074
                        }
 
2075
 
 
2076
                        /* We did not find a duplicate and we have now
 
2077
                        locked with s-locks the necessary records to
 
2078
                        prevent any insertion of a duplicate by another
 
2079
                        transaction. Let us now reposition the cursor and
 
2080
                        continue the insertion. */
 
2081
 
 
2082
                        btr_cur_search_to_nth_level(index, 0, entry,
 
2083
                                                    PAGE_CUR_LE,
 
2084
                                                    mode | BTR_INSERT,
 
2085
                                                    &cursor, 0, &mtr);
 
2086
                }
 
2087
        }
 
2088
 
 
2089
        modify = row_ins_must_modify(&cursor);
 
2090
 
 
2091
        if (modify != 0) {
 
2092
                /* There is already an index entry with a long enough common
 
2093
                prefix, we must convert the insert into a modify of an
 
2094
                existing record */
 
2095
 
 
2096
                if (modify == ROW_INS_NEXT) {
 
2097
                        rec = page_rec_get_next(btr_cur_get_rec(&cursor));
 
2098
 
 
2099
                        btr_cur_position(index, rec,
 
2100
                                         btr_cur_get_block(&cursor),&cursor);
 
2101
                }
 
2102
 
 
2103
                if (dict_index_is_clust(index)) {
 
2104
                        err = row_ins_clust_index_entry_by_modify(
 
2105
                                mode, &cursor, &heap, &big_rec, entry,
 
2106
                                thr, &mtr);
 
2107
                } else {
 
2108
                        ut_ad(!n_ext);
 
2109
                        err = row_ins_sec_index_entry_by_modify(
 
2110
                                mode, &cursor, entry, thr, &mtr);
 
2111
                }
 
2112
        } else {
 
2113
                if (mode == BTR_MODIFY_LEAF) {
 
2114
                        err = btr_cur_optimistic_insert(
 
2115
                                0, &cursor, entry, &insert_rec, &big_rec,
 
2116
                                n_ext, thr, &mtr);
 
2117
                } else {
 
2118
                        ut_a(mode == BTR_MODIFY_TREE);
 
2119
                        if (buf_LRU_buf_pool_running_out()) {
 
2120
 
 
2121
                                err = DB_LOCK_TABLE_FULL;
 
2122
 
 
2123
                                goto function_exit;
 
2124
                        }
 
2125
                        err = btr_cur_pessimistic_insert(
 
2126
                                0, &cursor, entry, &insert_rec, &big_rec,
 
2127
                                n_ext, thr, &mtr);
 
2128
                }
 
2129
        }
 
2130
 
 
2131
function_exit:
 
2132
        mtr_commit(&mtr);
 
2133
 
 
2134
        if (UNIV_LIKELY_NULL(big_rec)) {
 
2135
                rec_t*  rec;
 
2136
                ulint*  offsets;
 
2137
                mtr_start(&mtr);
 
2138
 
 
2139
                btr_cur_search_to_nth_level(index, 0, entry, PAGE_CUR_LE,
 
2140
                                            BTR_MODIFY_TREE, &cursor, 0, &mtr);
 
2141
                rec = btr_cur_get_rec(&cursor);
 
2142
                offsets = rec_get_offsets(rec, index, NULL,
 
2143
                                          ULINT_UNDEFINED, &heap);
 
2144
 
 
2145
                err = btr_store_big_rec_extern_fields(
 
2146
                        index, btr_cur_get_block(&cursor),
 
2147
                        rec, offsets, big_rec, &mtr);
 
2148
 
 
2149
                if (modify) {
 
2150
                        dtuple_big_rec_free(big_rec);
 
2151
                } else {
 
2152
                        dtuple_convert_back_big_rec(index, entry, big_rec);
 
2153
                }
 
2154
 
 
2155
                mtr_commit(&mtr);
 
2156
        }
 
2157
 
 
2158
        if (UNIV_LIKELY_NULL(heap)) {
 
2159
                mem_heap_free(heap);
 
2160
        }
 
2161
        return(err);
 
2162
}
 
2163
 
 
2164
/*******************************************************************
 
2165
Inserts an index entry to index. Tries first optimistic, then pessimistic
 
2166
descent down the tree. If the entry matches enough to a delete marked record,
 
2167
performs the insert by updating or delete unmarking the delete marked
 
2168
record. */
 
2169
UNIV_INTERN
 
2170
ulint
 
2171
row_ins_index_entry(
 
2172
/*================*/
 
2173
                                /* out: DB_SUCCESS, DB_LOCK_WAIT,
 
2174
                                DB_DUPLICATE_KEY, or some other error code */
 
2175
        dict_index_t*   index,  /* in: index */
 
2176
        dtuple_t*       entry,  /* in: index entry to insert */
 
2177
        ulint           n_ext,  /* in: number of externally stored columns */
 
2178
        ibool           foreign,/* in: TRUE=check foreign key constraints */
 
2179
        que_thr_t*      thr)    /* in: query thread */
 
2180
{
 
2181
        ulint   err;
 
2182
 
 
2183
        if (foreign && UT_LIST_GET_FIRST(index->table->foreign_list)) {
 
2184
                err = row_ins_check_foreign_constraints(index->table, index,
 
2185
                                                        entry, thr);
 
2186
                if (err != DB_SUCCESS) {
 
2187
 
 
2188
                        return(err);
 
2189
                }
 
2190
        }
 
2191
 
 
2192
        /* Try first optimistic descent to the B-tree */
 
2193
 
 
2194
        err = row_ins_index_entry_low(BTR_MODIFY_LEAF, index, entry,
 
2195
                                      n_ext, thr);
 
2196
        if (err != DB_FAIL) {
 
2197
 
 
2198
                return(err);
 
2199
        }
 
2200
 
 
2201
        /* Try then pessimistic descent to the B-tree */
 
2202
 
 
2203
        err = row_ins_index_entry_low(BTR_MODIFY_TREE, index, entry,
 
2204
                                      n_ext, thr);
 
2205
        return(err);
 
2206
}
 
2207
 
 
2208
/***************************************************************
 
2209
Sets the values of the dtuple fields in entry from the values of appropriate
 
2210
columns in row. */
 
2211
static
 
2212
void
 
2213
row_ins_index_entry_set_vals(
 
2214
/*=========================*/
 
2215
        dict_index_t*   index,  /* in: index */
 
2216
        dtuple_t*       entry,  /* in: index entry to make */
 
2217
        const dtuple_t* row)    /* in: row */
 
2218
{
 
2219
        ulint   n_fields;
 
2220
        ulint   i;
 
2221
 
 
2222
        ut_ad(entry && row);
 
2223
 
 
2224
        n_fields = dtuple_get_n_fields(entry);
 
2225
 
 
2226
        for (i = 0; i < n_fields; i++) {
 
2227
                dict_field_t*   ind_field;
 
2228
                dfield_t*       field;
 
2229
                const dfield_t* row_field;
 
2230
                ulint           len;
 
2231
 
 
2232
                field = dtuple_get_nth_field(entry, i);
 
2233
                ind_field = dict_index_get_nth_field(index, i);
 
2234
                row_field = dtuple_get_nth_field(row, ind_field->col->ind);
 
2235
                len = dfield_get_len(row_field);
 
2236
 
 
2237
                /* Check column prefix indexes */
 
2238
                if (ind_field->prefix_len > 0
 
2239
                    && dfield_get_len(row_field) != UNIV_SQL_NULL) {
 
2240
 
 
2241
                        const   dict_col_t*     col
 
2242
                                = dict_field_get_col(ind_field);
 
2243
 
 
2244
                        len = dtype_get_at_most_n_mbchars(
 
2245
                                col->prtype, col->mbminlen, col->mbmaxlen,
 
2246
                                ind_field->prefix_len,
 
2247
                                len, dfield_get_data(row_field));
 
2248
 
 
2249
                        ut_ad(!dfield_is_ext(row_field));
 
2250
                }
 
2251
 
 
2252
                dfield_set_data(field, dfield_get_data(row_field), len);
 
2253
                if (dfield_is_ext(row_field)) {
 
2254
                        ut_ad(dict_index_is_clust(index));
 
2255
                        dfield_set_ext(field);
 
2256
                }
 
2257
        }
 
2258
}
 
2259
 
 
2260
/***************************************************************
 
2261
Inserts a single index entry to the table. */
 
2262
static
 
2263
ulint
 
2264
row_ins_index_entry_step(
 
2265
/*=====================*/
 
2266
                                /* out: DB_SUCCESS if operation successfully
 
2267
                                completed, else error code or DB_LOCK_WAIT */
 
2268
        ins_node_t*     node,   /* in: row insert node */
 
2269
        que_thr_t*      thr)    /* in: query thread */
 
2270
{
 
2271
        ulint   err;
 
2272
 
 
2273
        ut_ad(dtuple_check_typed(node->row));
 
2274
 
 
2275
        row_ins_index_entry_set_vals(node->index, node->entry, node->row);
 
2276
 
 
2277
        ut_ad(dtuple_check_typed(node->entry));
 
2278
 
 
2279
        err = row_ins_index_entry(node->index, node->entry, 0, TRUE, thr);
 
2280
 
 
2281
        return(err);
 
2282
}
 
2283
 
 
2284
/***************************************************************
 
2285
Allocates a row id for row and inits the node->index field. */
 
2286
UNIV_INLINE
 
2287
void
 
2288
row_ins_alloc_row_id_step(
 
2289
/*======================*/
 
2290
        ins_node_t*     node)   /* in: row insert node */
 
2291
{
 
2292
        dulint  row_id;
 
2293
 
 
2294
        ut_ad(node->state == INS_NODE_ALLOC_ROW_ID);
 
2295
 
 
2296
        if (dict_index_is_unique(dict_table_get_first_index(node->table))) {
 
2297
 
 
2298
                /* No row id is stored if the clustered index is unique */
 
2299
 
 
2300
                return;
 
2301
        }
 
2302
 
 
2303
        /* Fill in row id value to row */
 
2304
 
 
2305
        row_id = dict_sys_get_new_row_id();
 
2306
 
 
2307
        dict_sys_write_row_id(node->row_id_buf, row_id);
 
2308
}
 
2309
 
 
2310
/***************************************************************
 
2311
Gets a row to insert from the values list. */
 
2312
UNIV_INLINE
 
2313
void
 
2314
row_ins_get_row_from_values(
 
2315
/*========================*/
 
2316
        ins_node_t*     node)   /* in: row insert node */
 
2317
{
 
2318
        que_node_t*     list_node;
 
2319
        dfield_t*       dfield;
 
2320
        dtuple_t*       row;
 
2321
        ulint           i;
 
2322
 
 
2323
        /* The field values are copied in the buffers of the select node and
 
2324
        it is safe to use them until we fetch from select again: therefore
 
2325
        we can just copy the pointers */
 
2326
 
 
2327
        row = node->row;
 
2328
 
 
2329
        i = 0;
 
2330
        list_node = node->values_list;
 
2331
 
 
2332
        while (list_node) {
 
2333
                eval_exp(list_node);
 
2334
 
 
2335
                dfield = dtuple_get_nth_field(row, i);
 
2336
                dfield_copy_data(dfield, que_node_get_val(list_node));
 
2337
 
 
2338
                i++;
 
2339
                list_node = que_node_get_next(list_node);
 
2340
        }
 
2341
}
 
2342
 
 
2343
/***************************************************************
 
2344
Gets a row to insert from the select list. */
 
2345
UNIV_INLINE
 
2346
void
 
2347
row_ins_get_row_from_select(
 
2348
/*========================*/
 
2349
        ins_node_t*     node)   /* in: row insert node */
 
2350
{
 
2351
        que_node_t*     list_node;
 
2352
        dfield_t*       dfield;
 
2353
        dtuple_t*       row;
 
2354
        ulint           i;
 
2355
 
 
2356
        /* The field values are copied in the buffers of the select node and
 
2357
        it is safe to use them until we fetch from select again: therefore
 
2358
        we can just copy the pointers */
 
2359
 
 
2360
        row = node->row;
 
2361
 
 
2362
        i = 0;
 
2363
        list_node = node->select->select_list;
 
2364
 
 
2365
        while (list_node) {
 
2366
                dfield = dtuple_get_nth_field(row, i);
 
2367
                dfield_copy_data(dfield, que_node_get_val(list_node));
 
2368
 
 
2369
                i++;
 
2370
                list_node = que_node_get_next(list_node);
 
2371
        }
 
2372
}
 
2373
 
 
2374
/***************************************************************
 
2375
Inserts a row to a table. */
 
2376
static
 
2377
ulint
 
2378
row_ins(
 
2379
/*====*/
 
2380
                                /* out: DB_SUCCESS if operation successfully
 
2381
                                completed, else error code or DB_LOCK_WAIT */
 
2382
        ins_node_t*     node,   /* in: row insert node */
 
2383
        que_thr_t*      thr)    /* in: query thread */
 
2384
{
 
2385
        ulint   err;
 
2386
 
 
2387
        ut_ad(node && thr);
 
2388
 
 
2389
        if (node->state == INS_NODE_ALLOC_ROW_ID) {
 
2390
 
 
2391
                row_ins_alloc_row_id_step(node);
 
2392
 
 
2393
                node->index = dict_table_get_first_index(node->table);
 
2394
                node->entry = UT_LIST_GET_FIRST(node->entry_list);
 
2395
 
 
2396
                if (node->ins_type == INS_SEARCHED) {
 
2397
 
 
2398
                        row_ins_get_row_from_select(node);
 
2399
 
 
2400
                } else if (node->ins_type == INS_VALUES) {
 
2401
 
 
2402
                        row_ins_get_row_from_values(node);
 
2403
                }
 
2404
 
 
2405
                node->state = INS_NODE_INSERT_ENTRIES;
 
2406
        }
 
2407
 
 
2408
        ut_ad(node->state == INS_NODE_INSERT_ENTRIES);
 
2409
 
 
2410
        while (node->index != NULL) {
 
2411
                err = row_ins_index_entry_step(node, thr);
 
2412
 
 
2413
                if (err != DB_SUCCESS) {
 
2414
 
 
2415
                        return(err);
 
2416
                }
 
2417
 
 
2418
                node->index = dict_table_get_next_index(node->index);
 
2419
                node->entry = UT_LIST_GET_NEXT(tuple_list, node->entry);
 
2420
        }
 
2421
 
 
2422
        ut_ad(node->entry == NULL);
 
2423
 
 
2424
        node->state = INS_NODE_ALLOC_ROW_ID;
 
2425
 
 
2426
        return(DB_SUCCESS);
 
2427
}
 
2428
 
 
2429
/***************************************************************
 
2430
Inserts a row to a table. This is a high-level function used in SQL execution
 
2431
graphs. */
 
2432
UNIV_INTERN
 
2433
que_thr_t*
 
2434
row_ins_step(
 
2435
/*=========*/
 
2436
                                /* out: query thread to run next or NULL */
 
2437
        que_thr_t*      thr)    /* in: query thread */
 
2438
{
 
2439
        ins_node_t*     node;
 
2440
        que_node_t*     parent;
 
2441
        sel_node_t*     sel_node;
 
2442
        trx_t*          trx;
 
2443
        ulint           err;
 
2444
 
 
2445
        ut_ad(thr);
 
2446
 
 
2447
        trx = thr_get_trx(thr);
 
2448
 
 
2449
        trx_start_if_not_started(trx);
 
2450
 
 
2451
        node = thr->run_node;
 
2452
 
 
2453
        ut_ad(que_node_get_type(node) == QUE_NODE_INSERT);
 
2454
 
 
2455
        parent = que_node_get_parent(node);
 
2456
        sel_node = node->select;
 
2457
 
 
2458
        if (thr->prev_node == parent) {
 
2459
                node->state = INS_NODE_SET_IX_LOCK;
 
2460
        }
 
2461
 
 
2462
        /* If this is the first time this node is executed (or when
 
2463
        execution resumes after wait for the table IX lock), set an
 
2464
        IX lock on the table and reset the possible select node. MySQL's
 
2465
        partitioned table code may also call an insert within the same
 
2466
        SQL statement AFTER it has used this table handle to do a search.
 
2467
        This happens, for example, when a row update moves it to another
 
2468
        partition. In that case, we have already set the IX lock on the
 
2469
        table during the search operation, and there is no need to set
 
2470
        it again here. But we must write trx->id to node->trx_id_buf. */
 
2471
 
 
2472
        trx_write_trx_id(node->trx_id_buf, trx->id);
 
2473
 
 
2474
        if (node->state == INS_NODE_SET_IX_LOCK) {
 
2475
 
 
2476
                /* It may be that the current session has not yet started
 
2477
                its transaction, or it has been committed: */
 
2478
 
 
2479
                if (UT_DULINT_EQ(trx->id, node->trx_id)) {
 
2480
                        /* No need to do IX-locking */
 
2481
 
 
2482
                        goto same_trx;
 
2483
                }
 
2484
 
 
2485
                err = lock_table(0, node->table, LOCK_IX, thr);
 
2486
 
 
2487
                if (err != DB_SUCCESS) {
 
2488
 
 
2489
                        goto error_handling;
 
2490
                }
 
2491
 
 
2492
                node->trx_id = trx->id;
 
2493
same_trx:
 
2494
                node->state = INS_NODE_ALLOC_ROW_ID;
 
2495
 
 
2496
                if (node->ins_type == INS_SEARCHED) {
 
2497
                        /* Reset the cursor */
 
2498
                        sel_node->state = SEL_NODE_OPEN;
 
2499
 
 
2500
                        /* Fetch a row to insert */
 
2501
 
 
2502
                        thr->run_node = sel_node;
 
2503
 
 
2504
                        return(thr);
 
2505
                }
 
2506
        }
 
2507
 
 
2508
        if ((node->ins_type == INS_SEARCHED)
 
2509
            && (sel_node->state != SEL_NODE_FETCH)) {
 
2510
 
 
2511
                ut_ad(sel_node->state == SEL_NODE_NO_MORE_ROWS);
 
2512
 
 
2513
                /* No more rows to insert */
 
2514
                thr->run_node = parent;
 
2515
 
 
2516
                return(thr);
 
2517
        }
 
2518
 
 
2519
        /* DO THE CHECKS OF THE CONSISTENCY CONSTRAINTS HERE */
 
2520
 
 
2521
        err = row_ins(node, thr);
 
2522
 
 
2523
error_handling:
 
2524
        trx->error_state = err;
 
2525
 
 
2526
        if (err != DB_SUCCESS) {
 
2527
                /* err == DB_LOCK_WAIT or SQL error detected */
 
2528
                return(NULL);
 
2529
        }
 
2530
 
 
2531
        /* DO THE TRIGGER ACTIONS HERE */
 
2532
 
 
2533
        if (node->ins_type == INS_SEARCHED) {
 
2534
                /* Fetch a row to insert */
 
2535
 
 
2536
                thr->run_node = sel_node;
 
2537
        } else {
 
2538
                thr->run_node = que_node_get_parent(node);
 
2539
        }
 
2540
 
 
2541
        return(thr);
 
2542
}